Rename Arrhenius reference temperature to Equilibrium

examples/v1/cam_cloud_chemistry.json

@@ -48,6 +48,7 @@
   "aerosol processes": [
     {
       "__comment": "Henry's Law Equilibrium: SO2(g) <-> SO2(aq)",
+      "__note": "HLC = HLC_ref * exp(C*(1/T - 1/T0))",
       "type": "HENRY_LAW_EQUILIBRIUM",
       "gas phase": "gas",
       "gas-phase species": "SO2",
@@ -62,6 +63,7 @@
     },
     {
       "__comment": "Henry's Law Equilibrium: H2O2(g) <-> H2O2(aq)",
+      "__note": "HLC = HLC_ref * exp(C*(1/T - 1/T0))",
       "type": "HENRY_LAW_EQUILIBRIUM",
       "gas phase": "gas",
       "gas-phase species": "H2O2",
@@ -76,6 +78,7 @@
     },
     {
       "__comment": "Henry's Law Equilibrium: O3(g) <-> O3(aq)",
+      "__note": "HLC = HLC_ref * exp(C*(1/T - 1/T0))",
       "type": "HENRY_LAW_EQUILIBRIUM",
       "gas phase": "gas",
       "gas-phase species": "O3",
@@ -103,10 +106,10 @@
         { "name": "H2O",     "coefficient": 1 }
       ],
       "forward rate constants": {
-        "CLOUD": { "type": "ARRHENIUS", "A": 3.184e8,  "C": 4430.0 }
+        "type": "ARRHENIUS", "A": 3.184e8,  "C": 4430.0
       },
       "equilibrium constant": {
-        "type": "ARRHENIUS_REFERENCE_TEMPERATURE", "A": 1725.0, "C [K]": 0.0, "T0 [K]": 298.15
+        "type": "EQUILIBRIUM", "A": 1725.0, "C [K]": 0.0, "T0 [K]": 298.15
       }
     },
     {
@@ -123,7 +126,7 @@
         { "name": "SO4mm", "coefficient": 1 }
       ],
       "rate constants": {
-        "CLOUD": { "type": "ARRHENIUS", "A": 1.333e8, "C": 4430.0}
+        "type": "ARRHENIUS", "A": 1.333e8, "C": 4430.0
       }
     },
     {
@@ -140,7 +143,7 @@
       ],
       "algebraic species": "OHm",
       "equilibrium constant": {
-        "type": "ARRHENIUS_REFERENCE_TEMPERATURE", "A": 3.24e-18, "C [K]": 0.0, "T0 [K]": 298.15
+        "type": "EQUILIBRIUM", "A": 3.24e-18, "C [K]": 0.0, "T0 [K]": 298.15
       }
     },
     {
@@ -157,7 +160,7 @@
       ],
       "algebraic species": "HSO3m",
       "equilibrium constant": {
-        "type": "ARRHENIUS_REFERENCE_TEMPERATURE", "A": 3.06e-4, "C [K]": 2090.0, "T0 [K]": 298.15
+        "type": "EQUILIBRIUM", "A": 3.06e-4, "C [K]": 2090.0, "T0 [K]": 298.15
       }
     },
     {
@@ -174,7 +177,7 @@
         { "name": "SO3mm", "coefficient": 1 }
       ],
       "equilibrium constant": {
-        "type": "ARRHENIUS_REFERENCE_TEMPERATURE", "A": 1.08e-9, "C [K]": 1120.0, "T0 [K]": 298.15
+        "type": "EQUILIBRIUM", "A": 1.08e-9, "C [K]": 1120.0, "T0 [K]": 298.15
       }
     },
     {

include/mechanism_configuration/errors.hpp

@@ -41,7 +41,6 @@ namespace mechanism_configuration
     ReactionRequiresUnknownSpecies,
     UnknownSpecies,
     UnknownPhase,
-    UnknownAerosolRepresentation,
     RequestedSpeciesNotRegisteredInPhase,
     TooManyReactionComponents,
     InvalidVersion,

include/mechanism_configuration/types/aerosol.hpp

@@ -7,7 +7,6 @@
 #include <mechanism_configuration/types/reactions.hpp>
 
 #include <functional>
-#include <map>
 #include <optional>
 #include <string>
 #include <variant>
@@ -19,18 +18,17 @@ namespace mechanism_configuration::types
   // Rate constants
   // ----------------------------------------
 
-  /// @brief Reference-temperature Arrhenius
+  /// @brief Equilibrium constant with reference-temperature Arrhenius form
   ///        f(T) = A * exp( C * (1/T0 - 1/T) )      (C = +Ea/R, positive)
-  struct ArrheniusReferenceTemperature
+  struct Equilibrium
   {
     double A;            ///< Value at the reference temperature T0 [units vary by use]
     double C = 0.0;      ///< Temperature-dependence parameter [K] (C = +Ea/R)
     double T0 = 298.15;  ///< Reference temperature [K]
   };
 
   /// @brief Henry's law constant: HLC(T) = HLC_ref * exp( C * (1/T - 1/T0) )
-  ///        Same as ArrheniusReferenceTemperature but with the
-  ///        opposite temperature trend (solubility rises as T falls)
+  ///        Same as Equilibrium but with the opposite temperature trend
   struct HenryLawConstant
   {
     double HLC_ref;      ///< Reference HLC at T0 [mol m-3 Pa-1]
@@ -39,7 +37,7 @@ namespace mechanism_configuration::types
   };
 
   /// @brief A reaction rate constant parsed from config.
-  using RateConstant = std::variant<Arrhenius, ArrheniusReferenceTemperature, std::function<double(double)>>;
+  using RateConstant = std::variant<Arrhenius, Equilibrium, std::function<double(double)>>;
 
   // ----------------------------------------
   // Representations
@@ -80,8 +78,7 @@ namespace mechanism_configuration::types
     std::string solvent;
     std::vector<ReactionComponent> reactants;
     std::vector<ReactionComponent> products;
-    /// @brief Rate constant per aerosol representation; keys are representation names.
-    std::map<std::string, RateConstant> rate_constants;
+    RateConstant rate_constants;
     std::optional<double> solvent_floor_;
     std::optional<double> min_halflife_;
   };
@@ -92,12 +89,11 @@ namespace mechanism_configuration::types
     std::string solvent;
     std::vector<ReactionComponent> reactants;
     std::vector<ReactionComponent> products;
-    /// @brief Per-representation forward / reverse rate constants; keys are representation names.
-    ///        Supply exactly two of {forward, reverse, equilibrium} per representation; the third is derived.
-    std::map<std::string, RateConstant> forward_rate_constants;
-    std::map<std::string, RateConstant> reverse_rate_constants;
+    /// @brief Supply exactly two of {forward, reverse, equilibrium}; the third is derived.
+    std::optional<RateConstant> forward_rate_constants;
+    std::optional<RateConstant> reverse_rate_constants;
     /// @brief Shared, intrinsic equilibrium constant (NOT per representation).
-    std::optional<ArrheniusReferenceTemperature> equilibrium_constant;
+    std::optional<Equilibrium> equilibrium_constant;
     std::optional<double> solvent_floor_;
   };
 
@@ -138,7 +134,7 @@ namespace mechanism_configuration::types
     std::string solvent;
     std::vector<ReactionComponent> reactants;
     std::vector<ReactionComponent> products;
-    ArrheniusReferenceTemperature equilibrium_constant;
+    Equilibrium equilibrium_constant;
     std::optional<double> solvent_floor_;
   };
 

src/detail/v1/aerosol/keys.hpp

@@ -39,7 +39,7 @@ namespace mechanism_configuration::v1::keys
   inline constexpr std::string_view equilibrium_constant = "equilibrium constant";
   inline constexpr std::string_view reference_temperature = "T0 [K]";
 
-  inline constexpr std::string_view ArrheniusReferenceTemperature_key = "ARRHENIUS_REFERENCE_TEMPERATURE";
+  inline constexpr std::string_view Equilibrium_key = "EQUILIBRIUM";
 
   inline constexpr std::string_view henry_law_constant = "Henry's law constant";
   inline constexpr std::string_view HLC_ref = "HLC_ref [mol m-3 Pa-1]";

src/detail/v1/aerosol/parsers.hpp

@@ -10,7 +10,6 @@
 
 #include <yaml-cpp/yaml.h>
 
-#include <map>
 #include <string>
 #include <vector>
 
@@ -21,19 +20,15 @@ namespace mechanism_configuration::v1
   // ----------------------------------------
 
   types::HenryLawConstant ParseHenryLawConstant(const YAML::Node& object);
-  types::ArrheniusReferenceTemperature ParseArrheniusReferenceTemperature(const YAML::Node& object);
+  types::Equilibrium ParseEquilibrium(const YAML::Node& object);
 
   /// @brief Parses a bare Arrhenius rate-constant block (A, B, C, D, E).
   types::Arrhenius ParseArrhenius(const YAML::Node& object);
 
   /// @brief Parses one rate-constant block into the RateConstant variant, dispatching on its
-  ///        inner `type` (ARRHENIUS -> Arrhenius, ARRHENIUS_REFERENCE_TEMPERATURE -> Arrhenius reference temperature).
+  ///        inner `type` (ARRHENIUS -> Arrhenius, EQUILIBRIUM -> Equilibrium constant).
   types::RateConstant ParseRateConstant(const YAML::Node& object);
 
-  /// @brief Parses a per-representation rate-constant map, e.g. { "CLOUD": { ... } }.
-  /// @return Map keyed by representation name to its rate constant.
-  std::map<std::string, types::RateConstant> ParseRateConstantMap(const YAML::Node& object);
-
   // ----------------------------------------
   // Representation parsers
   // ----------------------------------------

src/errors.cpp

@@ -25,7 +25,6 @@ namespace mechanism_configuration
       case ErrorCode::ReactionRequiresUnknownSpecies: return "ReactionRequiresUnknownSpecies";
       case ErrorCode::UnknownSpecies: return "UnknownSpecies";
       case ErrorCode::UnknownPhase: return "UnknownPhase";
-      case ErrorCode::UnknownAerosolRepresentation: return "UnknownAerosolRepresentation";
       case ErrorCode::RequestedSpeciesNotRegisteredInPhase: return "RequestedSpeciesNotRegisteredInPhase";
       case ErrorCode::TooManyReactionComponents: return "TooManyReactionComponents";
       case ErrorCode::InvalidVersion: return "InvalidVersion";

src/v1/aerosol/parsers.cpp

@@ -15,9 +15,9 @@ namespace mechanism_configuration::v1
   // Rate constants parser
   // ----------------------------------------
 
-  types::ArrheniusReferenceTemperature ParseArrheniusReferenceTemperature(const YAML::Node& object)
+  types::Equilibrium ParseEquilibrium(const YAML::Node& object)
   {
-    types::ArrheniusReferenceTemperature rate_constant;
+    types::Equilibrium rate_constant;
 
     rate_constant.A = object[keys::A].as<double>();
     if (object[keys::henry_law_C])
@@ -47,8 +47,8 @@ namespace mechanism_configuration::v1
 
   types::RateConstant ParseRateConstant(const YAML::Node& object)
   {
-    if (object[keys::type] && object[keys::type].as<std::string>() == keys::ArrheniusReferenceTemperature_key)
-      return ParseArrheniusReferenceTemperature(object);
+    if (object[keys::type] && object[keys::type].as<std::string>() == keys::Equilibrium_key)
+      return ParseEquilibrium(object);
 
     // ARRHENIUS is the default when no (recognized) type is given.
     return ParseArrhenius(object);
@@ -67,20 +67,6 @@ namespace mechanism_configuration::v1
     return henry_law_constant;
   }
 
-  std::map<std::string, types::RateConstant> ParseRateConstantMap(const YAML::Node& object)
-  {
-    std::map<std::string, types::RateConstant> rate_constants;
-
-    // Each key is an aerosol representation name (e.g. "CLOUD"); each value is a rate-constant
-    // block whose own `type` selects the RateConstant variant alternative.
-    for (const auto& entry : object)
-    {
-      rate_constants.emplace(entry.first.as<std::string>(), ParseRateConstant(entry.second));
-    }
-
-    return rate_constants;
-  }
-
   // ----------------------------------------
   // Representation parsers
   // ----------------------------------------
@@ -162,7 +148,7 @@ namespace mechanism_configuration::v1
     reaction.solvent = object[keys::solvent].as<std::string>();
     reaction.reactants = ParseReactionComponents(object, keys::reactants);
     reaction.products = ParseReactionComponents(object, keys::products);
-    reaction.rate_constants = ParseRateConstantMap(object[keys::rate_constants]);
+    reaction.rate_constants = ParseRateConstant(object[keys::rate_constants]);
 
     return reaction;
   }
@@ -179,11 +165,11 @@ namespace mechanism_configuration::v1
     // Any two of {forward, reverse, equilibrium} may be supplied; the third is derived
     // downstream, so each is parsed only when present.
     if (object[keys::forward_rate_constants])
-      reaction.forward_rate_constants = ParseRateConstantMap(object[keys::forward_rate_constants]);
+      reaction.forward_rate_constants = ParseRateConstant(object[keys::forward_rate_constants]);
     if (object[keys::reverse_rate_constants])
-      reaction.reverse_rate_constants = ParseRateConstantMap(object[keys::reverse_rate_constants]);
+      reaction.reverse_rate_constants = ParseRateConstant(object[keys::reverse_rate_constants]);
     if (object[keys::equilibrium_constant])
-      reaction.equilibrium_constant = ParseArrheniusReferenceTemperature(object[keys::equilibrium_constant]);
+      reaction.equilibrium_constant = ParseEquilibrium(object[keys::equilibrium_constant]);
 
     return reaction;
   }
@@ -225,7 +211,7 @@ namespace mechanism_configuration::v1
     equilibrium.solvent = object[keys::solvent].as<std::string>();
     equilibrium.reactants = ParseReactionComponents(object, keys::reactants);
     equilibrium.products = ParseReactionComponents(object, keys::products);
-    equilibrium.equilibrium_constant = ParseArrheniusReferenceTemperature(object[keys::equilibrium_constant]);
+    equilibrium.equilibrium_constant = ParseEquilibrium(object[keys::equilibrium_constant]);
 
     return equilibrium;
   }

src/v1/aerosol/schema.cpp

@@ -21,7 +21,7 @@ namespace mechanism_configuration::v1
 {
   namespace
   {
-    Errors CheckArrheniusReferenceTemperatureSchema(const YAML::Node& object)
+    Errors CheckEquilibriumSchema(const YAML::Node& object)
     {
       const std::vector<std::string_view> required_keys = { keys::A, keys::henry_law_C };
       const std::vector<std::string_view> optional_keys = { keys::type, keys::reference_temperature };
@@ -37,8 +37,8 @@ namespace mechanism_configuration::v1
 
     Errors CheckRateConstantSchema(const YAML::Node& object)
     {
-      if (object[keys::type] && object[keys::type].as<std::string>() == keys::ArrheniusReferenceTemperature_key)
-        return CheckArrheniusReferenceTemperatureSchema(object);
+      if (object[keys::type] && object[keys::type].as<std::string>() == keys::Equilibrium_key)
+        return CheckEquilibriumSchema(object);
       return CheckArrheniusSchema(object);
     }
 
@@ -49,18 +49,6 @@ namespace mechanism_configuration::v1
       return CheckSchema(object, required_keys, optional_keys);
     }
 
-    // A per-representation rate-constant map. Each value is a typed rate-constant block.
-    Errors CheckRateConstantMapSchema(const YAML::Node& object)
-    {
-      Errors errors;
-      for (const auto& entry : object)
-      {
-        auto entry_errors = CheckRateConstantSchema(entry.second);
-        errors.insert(errors.end(), entry_errors.begin(), entry_errors.end());
-      }
-      return errors;
-    }
-
     // Each linear-constraint term references a species in a phase with a coefficient.
     Errors CheckLinearConstraintTermsSchema(const YAML::Node& object)
     {
@@ -178,7 +166,7 @@ namespace mechanism_configuration::v1
         }
         if (object[keys::rate_constants])
         {
-          auto e = CheckRateConstantMapSchema(object[keys::rate_constants]);
+          auto e = CheckRateConstantSchema(object[keys::rate_constants]);
           nested_errors.insert(nested_errors.end(), e.begin(), e.end());
         }
       }
@@ -198,17 +186,17 @@ namespace mechanism_configuration::v1
         }
         if (object[keys::forward_rate_constants])
         {
-          auto e = CheckRateConstantMapSchema(object[keys::forward_rate_constants]);
+          auto e = CheckRateConstantSchema(object[keys::forward_rate_constants]);
           nested_errors.insert(nested_errors.end(), e.begin(), e.end());
         }
         if (object[keys::reverse_rate_constants])
         {
-          auto e = CheckRateConstantMapSchema(object[keys::reverse_rate_constants]);
+          auto e = CheckRateConstantSchema(object[keys::reverse_rate_constants]);
           nested_errors.insert(nested_errors.end(), e.begin(), e.end());
         }
         if (object[keys::equilibrium_constant])
         {
-          auto e = CheckArrheniusReferenceTemperatureSchema(object[keys::equilibrium_constant]);
+          auto e = CheckEquilibriumSchema(object[keys::equilibrium_constant]);
           nested_errors.insert(nested_errors.end(), e.begin(), e.end());
         }
       }
@@ -247,7 +235,7 @@ namespace mechanism_configuration::v1
         }
         if (object[keys::equilibrium_constant])
         {
-          auto e = CheckArrheniusReferenceTemperatureSchema(object[keys::equilibrium_constant]);
+          auto e = CheckEquilibriumSchema(object[keys::equilibrium_constant]);
           nested_errors.insert(nested_errors.end(), e.begin(), e.end());
         }
       }