Reaction rate factories

include/cantera/kinetics/MultiRate.h

@@ -61,7 +61,7 @@ class MultiRateBase
 
 //! A class template handling all reaction rates specific to `BulkKinetics`.
 template <class RateType, class DataType>
-class MultiBulkRates final : public MultiRateBase
+class MultiBulkRate final : public MultiRateBase
 {
 public:
     virtual void add(const size_t rxn_index,

include/cantera/kinetics/Reaction.h

@@ -142,9 +142,7 @@ class Reaction
     }
 
     //! Set reaction rate pointer
-    void setRate(shared_ptr<ReactionRateBase> rate) {
-        m_rate = rate;
-    }
+    void setRate(shared_ptr<ReactionRateBase> rate);
 
     //! Get pointer to third-body
     shared_ptr<ThirdBody> thirdBody() {
@@ -497,7 +495,6 @@ class ElementaryReaction3 : public Reaction
     virtual std::string type() const {
         return "elementary";
     }
-    virtual void getParameters(AnyMap& reactionNode) const;
 };
 
 
@@ -542,7 +539,6 @@ class PlogReaction3 : public Reaction
     virtual std::string type() const {
         return "pressure-dependent-Arrhenius";
     }
-    virtual void getParameters(AnyMap& reactionNode) const;
 };
 
 
@@ -560,8 +556,6 @@ class ChebyshevReaction3 : public Reaction
     virtual std::string type() const {
         return "Chebyshev";
     }
-
-    virtual void getParameters(AnyMap& reactionNode) const;
 };
 
 

include/cantera/kinetics/ReactionRate.h

@@ -21,6 +21,7 @@ namespace Cantera
 {
 
 class Func1;
+class MultiRateBase;
 
 //! Abstract base class for reaction rate definitions
 /**
@@ -43,6 +44,9 @@ class ReactionRateBase
     //! Identifier of reaction type
     virtual std::string type() const = 0;
 
+    //! Create multi-rate evaluator
+    virtual unique_ptr<MultiRateBase> newMultiRate() const = 0;
+
     //! Update reaction rate data based on temperature
     //! @param T  temperature [K]
     virtual void update(double T) = 0;
@@ -104,6 +108,10 @@ class ReactionRateBase
     //! @param rate_units  Description of units used for rate parameters
     virtual void setParameters(const AnyMap& node, const Units& rate_units);
 
+    //! Set rate units
+    //! @param rate_units  Description of units used for rate parameters
+    virtual void setUnits(const Units& rate_units);
+
 protected:
     //! Get parameters
     //! Store the parameters of a ReactionRate needed to reconstruct an identical
@@ -250,7 +258,9 @@ class ArrheniusRate final : public ReactionRate<ArrheniusData>, public Arrhenius
     virtual void getParameters(AnyMap& rateNode,
                                const Units& rate_units) const override;
 
-    virtual std::string type() const override { return "ArrheniusRate"; }
+    virtual std::string type() const override { return "Arrhenius"; }
+
+    virtual unique_ptr<MultiRateBase> newMultiRate() const override;
 
     //! Update information specific to reaction
     static bool usesUpdate() { return false; }
@@ -312,7 +322,12 @@ class PlogRate final : public ReactionRate<PlogData>, public Plog
     //! @param node  AnyMap containing rate information
     PlogRate(const AnyMap& node);
 
-    virtual std::string type() const override { return "PlogRate"; }
+    virtual std::string type() const override
+    {
+        return "pressure-dependent-Arrhenius";
+    }
+
+    virtual unique_ptr<MultiRateBase> newMultiRate() const override;
 
     virtual void setParameters(const AnyMap& node, const Units& rate_units) override;
     virtual void getParameters(AnyMap& rateNode,
@@ -393,7 +408,9 @@ class ChebyshevRate3 final : public ReactionRate<ChebyshevData>, public Chebyshe
     //! @param node  AnyMap containing rate information
     ChebyshevRate3(const AnyMap& node);
 
-    virtual std::string type() const override { return "ChebyshevRate"; }
+    virtual std::string type() const override { return "Chebyshev"; }
+
+    virtual unique_ptr<MultiRateBase> newMultiRate() const override;
 
     virtual void setParameters(const AnyMap& node, const Units& rate_units) override;
     virtual void getParameters(AnyMap& rateNode,
@@ -433,7 +450,9 @@ class CustomFunc1Rate final : public ReactionRate<CustomFunc1Data>
     //! @param rate_units  Description of units used for rate parameters
     CustomFunc1Rate(const AnyMap& rate, const Units& rate_units) {}
 
-    virtual std::string type() const override { return "custom-function"; }
+    virtual std::string type() const override { return "custom-rate-function"; }
+
+    virtual unique_ptr<MultiRateBase> newMultiRate() const override;
 
     virtual void setParameters(const AnyMap& node, const Units& rate_units) override {
         units = rate_units;

include/cantera/kinetics/ReactionRateFactory.h

@@ -0,0 +1,88 @@
+/**
+ *  @file ReactionRateFactory.h
+ *  Factory class for reaction rate objects. Used by classes that implement kinetics
+ *  (see \ref reactionGroup and class \link Cantera::Rate Rate\endlink).
+ */
+
+// 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_NEWRATE_H
+#define CT_NEWRATE_H
+
+#include "cantera/base/FactoryBase.h"
+#include "cantera/kinetics/ReactionRate.h"
+
+namespace Cantera
+{
+
+class Kinetics;
+class Units;
+
+/**
+ * Factory class to construct reaction rate calculators.
+ * The reaction factory is accessed through the static method factory:
+ *
+ * @code
+ * Rate* f = ReactionRateFactory::factory()->newReactionRate(type, c)
+ * @endcode
+ *
+ * @ingroup reactionGroup
+ */
+class ReactionRateFactory
+    : public Factory<ReactionRateBase, const AnyMap&, const Units&>
+{
+public:
+    /**
+     * Return a pointer to the factory. On the first call, a new instance is
+     * created. Since there is no need to instantiate more than one factory,
+     * on all subsequent calls, a pointer to the existing factory is returned.
+     */
+    static ReactionRateFactory* factory() {
+        std::unique_lock<std::mutex> lock(rate_mutex);
+        if (!s_factory) {
+            s_factory = new ReactionRateFactory;
+        }
+        return s_factory;
+    }
+
+    virtual void deleteFactory() {
+        std::unique_lock<std::mutex> lock(rate_mutex);
+        delete s_factory;
+        s_factory = 0;
+    }
+
+private:
+    //! Pointer to the single instance of the factory
+    static ReactionRateFactory* s_factory;
+
+    //! default constructor, which is defined as private
+    ReactionRateFactory();
+
+    //!  Mutex for use when calling the factory
+    static std::mutex rate_mutex;
+};
+
+
+//! Create a new empty ReactionRateBase object
+/*!
+ * @param type string identifying type of reaction rate.
+ */
+shared_ptr<ReactionRateBase> newReactionRate(const std::string& type);
+
+//! Create a new Rate object using the specified parameters
+/*!
+ * @param rate_node AnyMap node describing reaction rate.
+ * @param rate_units Unit system of the reaction rate
+ */
+shared_ptr<ReactionRateBase> newReactionRate(
+    const AnyMap& rate_node, const Units& rate_units);
+
+//! Create a new Rate object using the specified parameters
+/*!
+ * @param rate_node AnyMap node describing reaction rate.
+ */
+shared_ptr<ReactionRateBase> newReactionRate(const AnyMap& rate_node);
+
+}
+#endif

interfaces/cython/cantera/_cantera.pxd

@@ -341,6 +341,10 @@ cdef extern from "cantera/kinetics/ReactionFactory.h" namespace "Cantera":
     cdef shared_ptr[CxxReaction] CxxNewReaction "newReaction" (XML_Node&) except +translate_exception
     cdef shared_ptr[CxxReaction] CxxNewReaction "newReaction" (CxxAnyMap&, CxxKinetics&) except +translate_exception
 
+cdef extern from "cantera/kinetics/ReactionRateFactory.h" namespace "Cantera":
+    cdef shared_ptr[CxxReactionRateBase] CxxNewReactionRate "newReactionRate" (string) except +translate_exception
+    cdef shared_ptr[CxxReactionRateBase] CxxNewReactionRate "newReactionRate" (CxxAnyMap&) except +translate_exception
+
 cdef extern from "cantera/kinetics/Reaction.h" namespace "Cantera":
     cdef vector[shared_ptr[CxxReaction]] CxxGetReactions "getReactions" (XML_Node&) except +translate_exception
     cdef vector[shared_ptr[CxxReaction]] CxxGetReactions "getReactions" (CxxAnyValue&, CxxKinetics&) except +translate_exception
@@ -1146,27 +1150,14 @@ cdef class ThermoPhase(_SolutionBase):
 cdef class InterfacePhase(ThermoPhase):
     cdef CxxSurfPhase* surf
 
-cdef class _ReactionRate:
-    cdef shared_ptr[CxxReactionRateBase] _base
-    cdef CxxReactionRateBase* base
-
-cdef class ArrheniusRate(_ReactionRate):
-    cdef CxxArrheniusRate* rate
-    @staticmethod
-    cdef wrap(shared_ptr[CxxReactionRateBase])
-
-cdef class PlogRate(_ReactionRate):
-    cdef CxxPlogRate* rate
-    @staticmethod
-    cdef wrap(shared_ptr[CxxReactionRateBase])
-
-cdef class ChebyshevRate(_ReactionRate):
-    cdef CxxChebyshevRate3* rate
+cdef class ReactionRate:
+    cdef shared_ptr[CxxReactionRateBase] _rate
+    cdef CxxReactionRateBase* rate
     @staticmethod
     cdef wrap(shared_ptr[CxxReactionRateBase])
 
-cdef class CustomRate(_ReactionRate):
-    cdef CxxCustomFunc1Rate* rate
+cdef class CustomRate(ReactionRate):
+    cdef CxxCustomFunc1Rate* cxx_object(self)
     cdef Func1 _rate_func
 
 cdef class Reaction: