Non-empty Reactor and Connector Objects

include/cantera/base/FactoryBase.h

@@ -60,7 +60,7 @@
     static vector<FactoryBase*> s_vFactoryRegistry;
 };
 
-//! Factory class that supports registering functions to create objects
+//! Factory class that supports registering functions to create objects.
 //!
 //! Template arguments for the class are the base type created by the factory,
 //! followed by the types of any arguments which need to be passed to the
@@ -97,7 +97,7 @@
         } else if (m_synonyms.count(name)) {
             return m_synonyms.at(name);
         } else if (m_deprecated_names.count(name)) {
-            warn_deprecated("FactoryBase::canonicalize",
+            warn_deprecated("Factory::canonicalize",
                 fmt::format("Model name '{}' is deprecated. Use '{}' instead.",
                             name, m_deprecated_names.at(name)));
             return m_deprecated_names.at(name);
@@ -133,6 +133,79 @@
     std::unordered_map<string, string> m_deprecated_names;
 };
 
+
+//! Factory class that supports registering functions to create shared objects.
+//!
+//! Template arguments for the class are the base type created by the factory,
+//! followed by the types of any arguments which need to be passed to the
+//! functions used to create objects, that is, arguments to the constructor.
+template <class T, typename ... Args>
+class SharedFactory : public FactoryBase {
+public:
+    virtual ~SharedFactory() {}
+
+    //! Create an object using the object construction function corresponding to
+    //! "name" and the provided constructor arguments
+    shared_ptr<T> create(const string& name, Args... args) {
+        return m_creators.at(canonicalize(name))(args...);
+    }
+
+    //! Register a new object construction function
+    void reg(const string& name, function<shared_ptr<T>(Args...)> f) {
+        m_creators[name] = f;
+    }
+
+    //! Add an alias for an existing registered type
+    void addAlias(const string& original, const string& alias) {
+        if (!m_creators.count(original)) {
+            throw CanteraError("SharedFactory::addAlias",
+                "Name '{}' not registered", original);
+        }
+        m_synonyms[alias] = original;
+    }
+
+    //! Get the canonical name registered for a type
+    string canonicalize(const string& name) {
+        if (m_creators.count(name)) {
+            return name;
+        } else if (m_synonyms.count(name)) {
+            return m_synonyms.at(name);
+        } else if (m_deprecated_names.count(name)) {
+            warn_deprecated("SharedFactory::canonicalize",
+                fmt::format("Model name '{}' is deprecated. Use '{}' instead.",
+                            name, m_deprecated_names.at(name)));
+            return m_deprecated_names.at(name);
+        } else {
+            throw CanteraError("SharedFactory::canonicalize", "No such type: '{}'", name);
+        }
+    }
+
+    //! Returns true if `name` is registered with this factory
+    bool exists(const string& name) const {
+        return m_creators.count(name) || m_synonyms.count(name);
+    }
+
+protected:
+    //! Add a deprecated alias for an existing registered type
+    void addDeprecatedAlias(const string& original, const string& alias) {
+        if (!m_creators.count(original)) {
+            throw CanteraError("SharedFactory::addDeprecatedAlias",
+                "Name '{}' not registered", original);
+        }
+        m_deprecated_names[alias] = original;
+    }
+
+private:
+    std::unordered_map<string, function<shared_ptr<T>(Args...)>> m_creators;
+
+    //! Map of synonyms to canonical names
+    std::unordered_map<string, string> m_synonyms;
+
+    //! Map of deprecated synonyms to canonical names. Use of these names will
+    //! show a deprecation warning.
+    std::unordered_map<string, string> m_deprecated_names;
+};
+
 }
 
 #endif

include/cantera/clib/ctreactor.h

@@ -19,12 +19,12 @@ extern "C" {
 
     CANTERA_CAPI int reactor_new(const char* type, int n, const char* name);
     CANTERA_CAPI int reactor_del(int i);
+    CANTERA_CAPI int reactor_type(int i, int len, char* nbuf);
     CANTERA_CAPI int reactor_name(int i, int len, char* nbuf);
     CANTERA_CAPI int reactor_setName(int i, const char* name);
     CANTERA_CAPI int reactor_setInitialVolume(int i, double v);
     CANTERA_CAPI int reactor_setChemistry(int i, int cflag);
     CANTERA_CAPI int reactor_setEnergy(int i, int eflag);
-    CANTERA_CAPI int reactor_insert(int i, int n);
     CANTERA_CAPI double reactor_mass(int i);
     CANTERA_CAPI double reactor_volume(int i);
     CANTERA_CAPI double reactor_density(int i);
@@ -51,11 +51,12 @@ extern "C" {
     CANTERA_CAPI double reactornet_atol(int i);
     CANTERA_CAPI double reactornet_sensitivity(int i, const char* v, int p, int r);
 
-    CANTERA_CAPI int flowdev_new(const char* type, const char* name);
-    CANTERA_CAPI int flowdev_del(int i);
-    CANTERA_CAPI int flowdev_name(int i, int len, char* nbuf);
-    CANTERA_CAPI int flowdev_setName(int i, const char* name);
-    CANTERA_CAPI int flowdev_install(int i, int n, int m);
+    CANTERA_CAPI int connector_new(const char* type, int r0, int r1, const char* name);
+    CANTERA_CAPI int connector_del(int i);
+    CANTERA_CAPI int connector_type(int i, int len, char* nbuf);
+    CANTERA_CAPI int connector_name(int i, int len, char* nbuf);
+    CANTERA_CAPI int connector_setName(int i, const char* name);
+
     CANTERA_CAPI int flowdev_setPrimary(int i, int n);
     CANTERA_CAPI double flowdev_massFlowRate(int i);
     CANTERA_CAPI int flowdev_setMassFlowCoeff(int i, double v);
@@ -64,11 +65,6 @@ extern "C" {
     CANTERA_CAPI int flowdev_setPressureFunction(int i, int n);
     CANTERA_CAPI int flowdev_setTimeFunction(int i, int n);
 
-    CANTERA_CAPI int wall_new(const char* type, const char* name);
-    CANTERA_CAPI int wall_del(int i);
-    CANTERA_CAPI int wall_name(int i, int len, char* nbuf);
-    CANTERA_CAPI int wall_setName(int i, const char* name);
-    CANTERA_CAPI int wall_install(int i, int n, int m);
     CANTERA_CAPI double wall_expansionRate(int i);
     CANTERA_CAPI double wall_heatRate(int i);
     CANTERA_CAPI double wall_area(int i);
@@ -79,14 +75,8 @@ extern "C" {
     CANTERA_CAPI int wall_setExpansionRateCoeff(int i, double k);
     CANTERA_CAPI int wall_setVelocity(int i, int n);
     CANTERA_CAPI int wall_setEmissivity(int i, double epsilon);
-    CANTERA_CAPI int wall_ready(int i);
 
-    CANTERA_CAPI int reactorsurface_new(const char* name);
-    CANTERA_CAPI int reactorsurface_del(int i);
-    CANTERA_CAPI int reactorsurface_name(int i, int len, char* nbuf);
-    CANTERA_CAPI int reactorsurface_setName(int i, const char* name);
     CANTERA_CAPI int reactorsurface_install(int i, int n);
-    CANTERA_CAPI int reactorsurface_setkinetics(int i, int n);
     CANTERA_CAPI double reactorsurface_area(int i);
     CANTERA_CAPI int reactorsurface_setArea(int i, double v);
     CANTERA_CAPI int reactorsurface_addSensitivityReaction(int i, int rxn);

include/cantera/zeroD/Connector.h

@@ -0,0 +1,70 @@
+//! @file Connector.h
+
+// This file is part of Cantera. See License.txt in the top-level directory or
+// at https://cantera.org/license.txt for license and copyright information.
+
+#ifndef CT_CONNECTOR_H
+#define CT_CONNECTOR_H
+
+#include "cantera/base/ct_defs.h"
+#include "cantera/base/global.h"
+
+namespace Cantera
+{
+class ReactorNode;
+
+/**
+ * Base class for walls and flow devices connecting reactors.
+ * In a reactor network, walls and flow devices (valves, pressure regulators, etc.)
+ * form edges of a directed graph that connect reactors that form nodes.
+ *
+ * @since New in %Cantera 3.1.
+ *
+ * @ingroup connectorGroup
+ */
+class Connector : public std::enable_shared_from_this<Connector>
+{
+protected:
+    //! Instantiate a Connector object with associated ReactorNode objects.
+    //! @param r0  First reactor.
+    //! @param r1  Second reactor.
+    //! @param name  Name of the connector.
+    Connector(shared_ptr<ReactorNode> r0, shared_ptr<ReactorNode> r1,
+              const string& name="(none)") : m_nodes({r0, r1}), m_name(name) {}
+
+public:
+    Connector() = default;
+    virtual ~Connector() = default;
+    Connector(const Connector&) = delete;
+    Connector& operator=(const Connector&) = delete;
+
+    //! String indicating the connector implemented. Usually
+    //! corresponds to the name of the derived class.
+    virtual string type() const {
+        return "Connector";
+    }
+
+    //! Retrieve connector name.
+    string name() const {
+        return m_name;
+    }
+
+    //! Set connector name.
+    void setName(const string& name) {
+        m_name = name;
+    }
+
+    //! Set the default name of a connector. Returns `false` if it was previously set.
+    void setDefaultName(map<string, int>& counts);
+
+protected:
+    //! Pair of reactors forming end points of the connector.
+    pair<shared_ptr<ReactorNode>, shared_ptr<ReactorNode>> m_nodes;
+
+    string m_name;  //!< Connector name.
+    bool m_defaultNameSet = false;  //!< `true` if default name has been previously set.
+};
+
+}
+
+#endif

include/cantera/zeroD/ConnectorFactory.h

@@ -0,0 +1,81 @@
+//! @file ConnectorFactory.h
+
+// This file is part of Cantera. See License.txt in the top-level directory or
+// at https://cantera.org/license.txt for license and copyright information.
+
+#ifndef CONNECTOR_FACTORY_H
+#define CONNECTOR_FACTORY_H
+
+#include "cantera/base/FactoryBase.h"
+#include "cantera/zeroD/Connector.h"
+
+namespace Cantera
+{
+
+class FlowDevice;
+class WallBase;
+
+//! Factory class to create Connector objects.
+//!
+//! This class is mainly used via the newConnector() function, for example:
+//!
+//! ```cpp
+//!     shared_ptr<Connector> valve = newConnector("Valve", r0, r1, "my_valve");
+//! ```
+//!
+//! where `r0` and `r1` are reactor objects.
+class ConnectorFactory :
+    public SharedFactory<Connector, shared_ptr<ReactorNode>, shared_ptr<ReactorNode>, const string&>
+{
+public:
+    static ConnectorFactory* factory();
+
+    void deleteFactory() override;
+
+private:
+    static ConnectorFactory* s_factory;
+    static std::mutex connector_mutex;
+    ConnectorFactory();
+};
+
+//! @defgroup connectorGroup Connectors
+//! %Connector objects connect zero-dimensional reactors.
+//! Connector objects should be instantiated via the newConnector() function, for
+//! example:
+//!
+//! ```cpp
+//!     shared_ptr<Connector> valve = newConnector("Valve", r0, r1, "my_valve");
+//! ```
+//!
+//! where `r0` and `r1` are reactor objects.
+//!
+//! @since New in %Cantera 3.1.
+//!
+//! @ingroup zerodGroup
+//! @{
+
+//! Create a Connector object of the specified type
+//! @param model  String specifying reactor type.
+//! @param r0  First reactor.
+//! @param r1  Second reactor.
+//! @param name  Name of the connector.
+//! @since New in %Cantera 3.1.
+shared_ptr<Connector> newConnector(const string& model,
+                                   shared_ptr<ReactorNode> r0,
+                                   shared_ptr<ReactorNode> r1,
+                                   const string& name="(none)");
+
+//! Create a FlowDevice object of the specified type
+//! @since New in %Cantera 3.0.
+//! @deprecated Replaced by newConnector. To be removed after %Cantera 3.1.
+shared_ptr<FlowDevice> newFlowDevice3(const string& model);
+
+//! Create a WallBase object of the specified type
+//! @since New in %Cantera 3.0.
+//! @deprecated Replaced by Wall::create. To be removed after %Cantera 3.1.
+shared_ptr<WallBase> newWall3(const string& model);
+
+//! @}
+}
+
+#endif

include/cantera/zeroD/ConstPressureMoleReactor.h

@@ -22,6 +22,17 @@ class ConstPressureMoleReactor : public MoleReactor
 public:
     using MoleReactor::MoleReactor; // inherit constructors
 
+    //! Create a new ConstPressureMoleReactor.
+    //! @param contents  Solution object describing contents.
+    //! @param name  Name of the reactor. Optional; if left empty, a default name will
+    //!     be assigned when the reactor is integrated into a ReactorNet.
+    static shared_ptr<ConstPressureMoleReactor> create(
+        shared_ptr<Solution> contents, const string& name="")
+    {
+        return shared_ptr<ConstPressureMoleReactor>(
+            new ConstPressureMoleReactor(contents, name) );
+    }
+
     string type() const override {
         return "ConstPressureMoleReactor";
     };

include/cantera/zeroD/ConstPressureReactor.h

@@ -25,6 +25,17 @@ class ConstPressureReactor : public Reactor
 public:
     using Reactor::Reactor; // inherit constructors
 
+    //! Create a new ConstPressureReactor.
+    //! @param contents  Solution object describing contents.
+    //! @param name  Name of the reactor. Optional; if left empty, a default name will
+    //!     be assigned when the reactor is integrated into a ReactorNet.
+    static shared_ptr<ConstPressureReactor> create(
+        shared_ptr<Solution> contents, const string& name="")
+    {
+        return shared_ptr<ConstPressureReactor>(
+            new ConstPressureReactor(contents, name) );
+    }
+
     string type() const override {
         return "ConstPressureReactor";
     }