Parse arrhenius

include/open_atmos/constants.hpp

@@ -0,0 +1,14 @@
+// Copyright (C) 2023-2024 National Center for Atmospheric Research, University of Illinois at Urbana-Champaign
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+namespace open_atmos
+{
+  namespace constants
+  {
+    static constexpr double boltzmann = 1.380649e-23;  // J K^{-1}
+    static constexpr double avogadro = 6.02214076e23;  // # mol^{-1}
+    static constexpr double R = boltzmann * avogadro;  // J K^{-1} mol^{-1}
+  }                                                    // namespace constants
+}  // namespace open_atmos

include/open_atmos/mechanism_configuration/parser.hpp

@@ -29,7 +29,10 @@ namespace open_atmos
       RequiredKeyNotFound,
       MutuallyExclusiveOption,
       InvalidVersion,
-      DuplicateSpeciesDetected
+      DuplicateSpeciesDetected,
+      DuplicatePhasesDetected,
+      PhaseRequiresUnknownSpecies,
+      ReactionRequiresUnknownSpecies,
     };
     std::string configParseStatusToString(const ConfigParseStatus &status);
 

include/open_atmos/mechanism_configuration/validation.hpp

@@ -31,6 +31,26 @@ namespace open_atmos
       const std::string phase = "phase";
       const std::string n_star = "N star";
       const std::string density = "density [kg m-3]";
+
+      // Reactions
+      const std::string reactants = "reactants";
+      const std::string products = "products";
+      const std::string type = "type";
+      const std::string gas_phase = "gas phase";
+
+      // Reactant and product
+      const std::string species_name = "species name";
+      const std::string coefficient = "coefficient";
+
+      // Arrhenius
+      const std::string Arrhenius_key = "ARRHENIUS";
+      const std::string A = "A";
+      const std::string B = "B";
+      const std::string C = "C";
+      const std::string D = "D";
+      const std::string E = "E";
+      const std::string Ea = "Ea";
+
     } keys;
 
     struct Configuration
@@ -53,14 +73,26 @@ namespace open_atmos
 
     struct Phase
     {
-      const std::vector<std::string> required_keys {};
-      const std::vector<std::string> optional_keys {};
+      const std::vector<std::string> required_keys{ keys.name, keys.species };
+      const std::vector<std::string> optional_keys{};
     } phase;
 
+    struct ReactionComponent
+    {
+      const std::vector<std::string> required_keys{ keys.species_name };
+      const std::vector<std::string> optional_keys{ keys.coefficient };
+    } reaction_component;
+
+    struct Arrhenius
+    {
+      const std::vector<std::string> required_keys{ keys.products, keys.reactants, keys.type, keys.gas_phase };
+      const std::vector<std::string> optional_keys{ keys.A, keys.B, keys.C, keys.D, keys.E, keys.Ea, keys.name };
+    } arrhenius;
+
     struct Mechanism
     {
-      const std::vector<std::string> required_keys {};
-      const std::vector<std::string> optional_keys {};
+      const std::vector<std::string> required_keys{};
+      const std::vector<std::string> optional_keys{};
     } mechanism;
 
   }  // namespace validation

include/open_atmos/types.hpp

@@ -22,13 +22,56 @@ namespace open_atmos
 
     struct Phase
     {
+      std::string name;
+      std::vector<std::string> species;
+      std::unordered_map<std::string, std::string> unknown_properties;
+    };
+
+    struct ReactionComponent
+    {
+      std::string species_name;
+      double coefficient;
+      std::unordered_map<std::string, std::string> unknown_properties;
+    };
+
+    struct Arrhenius
+    {
+      /// @brief Pre-exponential factor [(mol m−3)^(−(𝑛−1)) s−1]
+      double A{ 1 };
+      /// @brief Unitless exponential factor
+      double B{ 0 };
+      /// @brief Activation threshold, expected to be the negative activation energy divided by the boltzman constant
+      ///        [-E_a / k_b), K]
+      double C{ 0 };
+      /// @brief A factor that determines temperature dependence [K]
+      double D{ 300 };
+      /// @brief A factor that determines pressure dependence [Pa-1]
+      double E{ 0 };
+
+      /// @brief A list of reactants
+      std::vector<ReactionComponent> reactants;
+      /// @brief A list of products
+      std::vector<ReactionComponent> products;
+      /// @brief An identifier, optional, uniqueness not enforced
+      std::string name;
+      /// @brief An identifier indicating which gas phase this reaction takes place in
+      std::string gas_phase;
+
+      std::unordered_map<std::string, std::string> unknown_properties;
+    };
+
+    struct Reactions
+    {
+      std::vector<types::Arrhenius> arrhenius;
     };
 
     struct Mechanism
     {
-      std::string name; // optional
+      /// @brief An identifier, optional
+      std::string name;
       std::vector<types::Species> species;
-      std::unordered_map<std::string, types::Phase> phases;
+      std::vector<types::Phase> phases;
+      Reactions reactions;
     };
 
   }  // namespace types