Refactor code organization after adding Aerosols and Emissions

CITATION.cff

@@ -12,5 +12,8 @@ authors:
     given-names: Jiwon
   - family-names: Thind
     given-names: Montek
+  - family-names: Meech
+    given-names: Scott
+
 license: Apache-2.0
 url: "https://github.com/NCAR/MechanismConfiguration"

cmake/test_util.cmake

@@ -13,9 +13,10 @@ function(create_standard_test)
   add_executable(test_${TEST_NAME} ${TEST_SOURCES})
 
   target_link_libraries(test_${TEST_NAME} PUBLIC musica::mechanism_configuration GTest::gtest_main)
-  target_include_directories(test_${TEST_NAME} 
-    PUBLIC 
+  target_include_directories(test_${TEST_NAME}
+    PUBLIC
       ${PROJECT_SOURCE_DIR}/src
+      ${PROJECT_SOURCE_DIR}/test
   )
 
 

include/mechanism_configuration/errors.hpp

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -67,11 +66,5 @@ namespace mechanism_configuration
 
   std::string ErrorCodeToString(const ErrorCode& status);
 
-  // For Google Test printing
-  inline void PrintTo(const ErrorCode& status, std::ostream* os)
-  {
-    *os << ErrorCodeToString(status);
-  }
-
   using Errors = std::vector<std::pair<ErrorCode, std::string>>;
 }  // namespace mechanism_configuration

include/mechanism_configuration/mechanism.hpp

@@ -4,95 +4,40 @@
 
 #pragma once
 
-#include <mechanism_configuration/aerosol_types.hpp>
-#include <mechanism_configuration/types.hpp>
+#include <mechanism_configuration/mechanism_version.hpp>
+#include <mechanism_configuration/types/aerosol.hpp>
+#include <mechanism_configuration/types/emissions.hpp>
+#include <mechanism_configuration/types/reactions.hpp>
+#include <mechanism_configuration/types/species.hpp>
 
-#include <filesystem>
-#include <iostream>
 #include <optional>
 #include <string>
-#include <variant>
+#include <vector>
 
 namespace mechanism_configuration
 {
-// glibc defines `major` and `minor` as macros, which conflict with the `Version` struct fields.
-// Temporarily undefine the macros before the struct definition and restore them afterward.
-// https://stackoverflow.com/a/22253389/5217293
-#pragma push_macro("major")
-#undef major
-#pragma push_macro("minor")
-#undef minor
-
-  struct Version
-  {
-    unsigned int major;
-    unsigned int minor;
-    unsigned int patch;
-
-    Version()
-        : major(0),
-          minor(0),
-          patch(0)
-    {
-    }
-
-    Version(unsigned int major, unsigned int minor, unsigned int patch)
-        : major(major),
-          minor(minor),
-          patch(patch)
-    {
-    }
-
-    Version(std::string version)
-    {
-      std::string delimiter = ".";
-      size_t pos = 0;
-      int i = 0;
-      while ((pos = version.find(delimiter)) != std::string::npos)
-      {
-        std::string token = version.substr(0, pos);
-        switch (i)
-        {
-          case 0: major = std::stoi(token); break;
-          case 1: minor = std::stoi(token); break;
-        }
-        version.erase(0, pos + delimiter.length());
-        i++;
-      }
-      // The remaining part is the patch version
-      if (!version.empty())
-      {
-        patch = std::stoi(version);
-      }
-    }
-
-    std::string to_string() const
-    {
-      return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
-    }
-  };
-
-#pragma pop_macro("minor")
-#pragma pop_macro("major")
-
   /// @brief Represents a full mechanism definition
   struct Mechanism
   {
     /// @brief Mechanism name (optional)
     std::string name;
+    /// @brief Version of the mechanism configuration format used, in major.minor.patch format
+    Version version;
+    /// @brief Relative tolerance for solver (optional, default: 1e-6)
+    double relative_tolerance{ 1e-6 };
+
     /// @brief Species list
     std::vector<types::Species> species;
     /// @brief Phases list
     std::vector<types::Phase> phases;
     /// @brief Represents a collection of different reaction types, each stored in a vector
     ///        corresponding to a specific mechanism
+    /// @note Not wrapped in optional: gas-phase chemistry is the default and requires reactions
+    ///       to be present. Reactions may be empty when other chemistry (aerosol, etc.) is used
+    ///       instead, but the field itself is always present.
     types::Reactions reactions;
-    /// @brief Aerosol representations, processes, and constraints
-    types::Aerosol aerosol;
-    /// @brief Version of the mechanism configuration format used, in major.minor.patch format
-    Version version;
-    /// @brief Relative tolerance for solver (optional, default: 1e-6)
-    double relative_tolerance{ 1e-6 };
+    /// @brief Aerosol representations, processes, and constraints (optional)
+    std::optional<types::Aerosol> aerosol;
     /// @brief Emissions configuration (optional)
     std::optional<types::EmissionsConfig> emissions;
   };

include/mechanism_configuration/mechanism_configuration.hpp

@@ -4,10 +4,12 @@
 
 #pragma once
 
-#include <mechanism_configuration/aerosol_types.hpp>
 #include <mechanism_configuration/errors.hpp>
 #include <mechanism_configuration/mechanism.hpp>
 #include <mechanism_configuration/parse.hpp>
-#include <mechanism_configuration/types.hpp>
+#include <mechanism_configuration/types/aerosol.hpp>
+#include <mechanism_configuration/types/emissions.hpp>
+#include <mechanism_configuration/types/reactions.hpp>
+#include <mechanism_configuration/types/species.hpp>
 #include <mechanism_configuration/validate.hpp>
 #include <mechanism_configuration/version.hpp>

include/mechanism_configuration/mechanism_version.hpp

@@ -0,0 +1,71 @@
+// Copyright (C) 2023–2026 University Corporation for Atmospheric Research
+//                         University of Illinois at Urbana-Champaign
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+namespace mechanism_configuration
+{
+// glibc defines `major` and `minor` as macros, which conflict with the `Version` struct fields.
+// Temporarily undefine the macros before the struct definition and restore them afterward.
+// https://stackoverflow.com/a/22253389/5217293
+#pragma push_macro("major")
+#undef major
+#pragma push_macro("minor")
+#undef minor
+
+  struct Version
+  {
+    unsigned int major;
+    unsigned int minor;
+    unsigned int patch;
+
+    Version()
+        : major(0),
+          minor(0),
+          patch(0)
+    {
+    }
+
+    Version(unsigned int major, unsigned int minor, unsigned int patch)
+        : major(major),
+          minor(minor),
+          patch(patch)
+    {
+    }
+
+    Version(std::string version)
+    {
+      std::string delimiter = ".";
+      size_t pos = 0;
+      int i = 0;
+      while ((pos = version.find(delimiter)) != std::string::npos)
+      {
+        std::string token = version.substr(0, pos);
+        switch (i)
+        {
+          case 0: major = std::stoi(token); break;
+          case 1: minor = std::stoi(token); break;
+        }
+        version.erase(0, pos + delimiter.length());
+        i++;
+      }
+      // The remaining part is the patch version
+      if (!version.empty())
+      {
+        patch = std::stoi(version);
+      }
+    }
+
+    std::string to_string() const
+    {
+      return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
+    }
+  };
+
+#pragma pop_macro("minor")
+#pragma pop_macro("major")
+
+}  // namespace mechanism_configuration

include/mechanism_configuration/aerosol_types.hpp → include/mechanism_configuration/types/aerosol.hpp

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include <mechanism_configuration/types.hpp>
+#include <mechanism_configuration/types/reactions.hpp>
 
 #include <functional>
 #include <map>

include/mechanism_configuration/types/emissions.hpp

@@ -0,0 +1,96 @@
+// Copyright (C) 2023–2026 University Corporation for Atmospheric Research
+//                         University of Illinois at Urbana-Champaign
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace mechanism_configuration::types
+{
+
+  struct SpeciesMapping
+  {
+    std::string inventory_species;
+    std::string mechanism_species;
+    double scaling_factor{ 1.0 };
+  };
+
+  struct SpeciesMap
+  {
+    std::string name;
+    std::vector<SpeciesMapping> mappings;
+  };
+
+  struct Inventory
+  {
+    std::string name;
+    std::string directory;
+    std::string file_pattern;
+    std::string convention;
+  };
+
+  enum class SourceMode
+  {
+    Offline,
+  };
+
+  enum class SourceType
+  {
+    Anthropogenic,
+    Fire,
+    Biogenic,
+    Dust,
+    SeaSalt,
+    Lightning,
+  };
+
+  enum class TemporalInterpolation
+  {
+    Linear,
+    Nearest,
+    None,
+  };
+
+  enum class VerticalInjection
+  {
+    Surface,
+  };
+
+  struct SourceDescriptor
+  {
+    std::string name;
+    SourceMode mode{ SourceMode::Offline };
+    SourceType type{ SourceType::Anthropogenic };
+    std::string inventory;
+    std::string species_map;
+    TemporalInterpolation temporal_interpolation{ TemporalInterpolation::Linear };
+    VerticalInjection vertical_injection{ VerticalInjection::Surface };
+    int category{ 0 };
+    int hierarchy{ 1 };
+    double scaling_factor{ 1.0 };
+    std::string sector;
+    std::unordered_map<std::string, std::string> unknown_properties;
+  };
+
+  enum class RegriddingType
+  {
+    None,
+  };
+
+  struct Regridding
+  {
+    RegriddingType type{ RegriddingType::None };
+  };
+
+  struct EmissionsConfig
+  {
+    std::vector<Inventory> inventories;
+    std::vector<SpeciesMap> species_maps;
+    Regridding regridding;
+    std::vector<SourceDescriptor> sources;
+  };
+
+}  // namespace mechanism_configuration::types