[Kinetics] Use same nomenclature for Reaction and ReactionRate types

Removing checks for consistency between (current) Reaction3 objects
and ReactionRate objects makes the framework more flexible.

include/cantera/kinetics/ReactionRate.h

@@ -258,7 +258,7 @@ 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;
 
@@ -322,7 +322,10 @@ 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;
 
@@ -405,7 +408,7 @@ 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;
 
@@ -447,7 +450,7 @@ 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;
 

include/cantera/kinetics/ReactionRateFactory.h

@@ -84,11 +84,5 @@ shared_ptr<ReactionRateBase> newReactionRate(
  */
 shared_ptr<ReactionRateBase> newReactionRate(const AnyMap& rate_node);
 
-//! Retrieve the canoncial rate object name
-/*!
- * @param type string identifying alternate reaction rate name.
- */
-std::string canonicalRateName(const std::string& type);
-
 }
 #endif

interfaces/cython/cantera/reaction.pyx

@@ -142,7 +142,7 @@ cdef class ArrheniusRate(ReactionRate):
     where ``A`` is the `pre_exponential_factor`, ``b`` is the `temperature_exponent`,
     and ``Ea`` is the `activation_energy`.
     """
-    _reaction_rate_type = "ArrheniusRate"
+    _reaction_rate_type = "Arrhenius"
 
     def __cinit__(self, A=None, b=None, Ea=None, input_data=None, init=True):
 
@@ -200,7 +200,7 @@ cdef class PlogRate(ReactionRate):
     A pressure-dependent reaction rate parameterized by logarithmically
     interpolating between Arrhenius rate expressions at various pressures.
     """
-    _reaction_rate_type = "PlogRate"
+    _reaction_rate_type = "pressure-dependent-Arrhenius"
 
     def __cinit__(self, rates=None, input_data=None, init=True):
 
@@ -253,7 +253,7 @@ cdef class ChebyshevRate(ReactionRate):
     A pressure-dependent reaction rate parameterized by a bivariate Chebyshev
     polynomial in temperature and pressure.
     """
-    _reaction_rate_type = "ChebyshevRate"
+    _reaction_rate_type = "Chebyshev"
 
     def __cinit__(self, Tmin=None, Tmax=None, Pmin=None, Pmax=None, data=None,
                   input_data=None, init=True):
@@ -345,7 +345,7 @@ cdef class CustomRate(ReactionRate):
     Warning: this class is an experimental part of the Cantera API and
         may be changed or removed without notice.
     """
-    _reaction_rate_type = "custom-function"
+    _reaction_rate_type = "custom-rate-function"
 
     def __cinit__(self, k=None, init=True):
 

interfaces/cython/cantera/test/test_reaction.py

@@ -200,7 +200,7 @@ class TestArrheniusRate(ReactionRateTests, utilities.CanteraTest):
     # test Arrhenius rate expressions
 
     _cls = ct.ArrheniusRate
-    _type = "ArrheniusRate"
+    _type = "Arrhenius"
     _uses_pressure = False
     _index = 0
     _input = {"rate-constant": {"A": 38.7, "b": 2.7, "Ea": 26191840.0}}
@@ -234,7 +234,7 @@ class TestPlogRate(ReactionRateTests, utilities.CanteraTest):
     # test Plog rate expressions
 
     _cls = ct.PlogRate
-    _type = "PlogRate"
+    _type = "pressure-dependent-Arrhenius"
     _uses_pressure = True
     _index = 3
     _input = {"rate-constants": [
@@ -311,7 +311,7 @@ class TestChebyshevRate(ReactionRateTests, utilities.CanteraTest):
     # test Chebyshev rate expressions
 
     _cls = ct.ChebyshevRate
-    _type = "ChebyshevRate"
+    _type = "Chebyshev"
     _uses_pressure = True
     _index = 4
     _input = {"data": [[8.2883, -1.1397, -0.12059, 0.016034],

src/kinetics/Reaction.cpp

@@ -196,13 +196,8 @@ void Reaction::setRate(shared_ptr<ReactionRateBase> rate)
     if (!rate) {
         // null pointer
         m_rate.reset();
-    } else if (canonicalRateName(type()) == rate->type()) {
-        m_rate = rate;
     } else {
-        throw CanteraError("Reaction::setRate",
-            "Mismatched reaction rate types: reaction type '{}' requires\n"
-            "rate with type '{}' but received rate object with\n"
-            "type '{}'.", type(), canonicalRateName(type()), rate->type());
+        m_rate = rate;
     }
 }
 

src/kinetics/ReactionRateFactory.cpp

@@ -20,30 +20,27 @@ std::mutex ReactionRateFactory::rate_mutex;
 ReactionRateFactory::ReactionRateFactory()
 {
     // ArrheniusRate evaluator
-    reg("ArrheniusRate", [](const AnyMap& node, const Units& rate_units) {
+    reg("Arrhenius", [](const AnyMap& node, const Units& rate_units) {
         return new ArrheniusRate(node, rate_units);
     });
-    addAlias("ArrheniusRate", "");
-    addAlias("ArrheniusRate", "elementary");
-    addAlias("ArrheniusRate", "three-body");
+    addAlias("Arrhenius", "");
+    addAlias("Arrhenius", "elementary");
+    addAlias("Arrhenius", "three-body");
 
     // PlogRate evaluator
-    reg("PlogRate", [](const AnyMap& node, const Units& rate_units) {
+    reg("pressure-dependent-Arrhenius", [](const AnyMap& node, const Units& rate_units) {
         return new PlogRate(node, rate_units);
     });
-    addAlias("PlogRate", "pressure-dependent-Arrhenius");
 
     // ChebyshevRate evaluator
-    reg("ChebyshevRate", [](const AnyMap& node, const Units& rate_units) {
+    reg("Chebyshev", [](const AnyMap& node, const Units& rate_units) {
         return new ChebyshevRate3(node, rate_units);
     });
-    addAlias("ChebyshevRate", "Chebyshev");
 
     // CustomFunc1Rate evaluator
-    reg("custom-function", [](const AnyMap& node, const Units& rate_units) {
+    reg("custom-rate-function", [](const AnyMap& node, const Units& rate_units) {
         return new CustomFunc1Rate(node, rate_units);
     });
-    addAlias("custom-function", "custom-rate-function");
 }
 
 shared_ptr<ReactionRateBase> newReactionRate(const std::string& type)
@@ -85,14 +82,4 @@ shared_ptr<ReactionRateBase> newReactionRate(const AnyMap& rate_node)
     return newReactionRate(node, Units(0.));
 }
 
-std::string canonicalRateName(const std::string& type)
-{
-    if (ReactionRateFactory::factory()->exists(type)) {
-        return ReactionRateFactory::factory()->canonicalize(type);
-    }
-
-    throw CanteraError("ReactionRateFactory::canonicalRateName",
-        "Unknown reaction rate type alias '{}'.", type);
-}
-
 }