musica 0.12.2__cp39-cp39-macosx_15_0_arm64.whl → 0.13.0__cp39-cp39-macosx_15_0_arm64.whl

musica/mechanism_configuration.cpp

@@ -1,5 +1,7 @@
 // Copyright (C) 2025 University Corporation for Atmospheric Research
 // SPDX-License-Identifier: Apache-2.0
+#include "binding_common.hpp"
+
 #include <musica/micm/parse.hpp>
 
 #include <mechanism_configuration/constants.hpp>
@@ -7,8 +9,6 @@
 #include <mechanism_configuration/v1/reaction_types.hpp>
 #include <mechanism_configuration/v1/types.hpp>
 #include <mechanism_configuration/v1/validation.hpp>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
 
 #include <variant>
 
@@ -21,18 +21,13 @@ enum class ReactionType
 {
   Arrhenius,
   Branched,
-  CondensedPhaseArrhenius,
-  CondensedPhasePhotolysis,
   Emission,
   FirstOrderLoss,
-  SimpolPhaseTransfer,
-  AqueousEquilibrium,
-  WetDeposition,
-  HenrysLaw,
   Photolysis,
   Surface,
-  Troe,
+  TaylorSeries,
   TernaryChemicalActivation,
+  Troe,
   Tunneling,
   UserDefined
 };
@@ -42,18 +37,13 @@ struct ReactionsIterator
   using VariantType = std::variant<
       Arrhenius,
       Branched,
-      CondensedPhaseArrhenius,
-      CondensedPhasePhotolysis,
       Emission,
       FirstOrderLoss,
-      SimpolPhaseTransfer,
-      AqueousEquilibrium,
-      WetDeposition,
-      HenrysLaw,
       Photolysis,
       Surface,
-      Troe,
+      TaylorSeries,
       TernaryChemicalActivation,
+      Troe,
       Tunneling,
       UserDefined>;
 
@@ -62,26 +52,19 @@ struct ReactionsIterator
   size_t inner_index = 0;
 
   ReactionsIterator(Reactions &reactions)
-      : reaction_lists{
-          std::vector<VariantType>(reactions.arrhenius.begin(), reactions.arrhenius.end()),
-          std::vector<VariantType>(reactions.branched.begin(), reactions.branched.end()),
-          std::vector<VariantType>(reactions.condensed_phase_arrhenius.begin(), reactions.condensed_phase_arrhenius.end()),
-          std::vector<VariantType>(reactions.condensed_phase_photolysis.begin(), reactions.condensed_phase_photolysis.end()),
-          std::vector<VariantType>(reactions.emission.begin(), reactions.emission.end()),
-          std::vector<VariantType>(reactions.first_order_loss.begin(), reactions.first_order_loss.end()),
-          std::vector<VariantType>(reactions.simpol_phase_transfer.begin(), reactions.simpol_phase_transfer.end()),
-          std::vector<VariantType>(reactions.aqueous_equilibrium.begin(), reactions.aqueous_equilibrium.end()),
-          std::vector<VariantType>(reactions.wet_deposition.begin(), reactions.wet_deposition.end()),
-          std::vector<VariantType>(reactions.henrys_law.begin(), reactions.henrys_law.end()),
-          std::vector<VariantType>(reactions.photolysis.begin(), reactions.photolysis.end()),
-          std::vector<VariantType>(reactions.surface.begin(), reactions.surface.end()),
-          std::vector<VariantType>(reactions.troe.begin(), reactions.troe.end()),
-          std::vector<VariantType>(
-              reactions.ternary_chemical_activation.begin(),
-              reactions.ternary_chemical_activation.end()),
-          std::vector<VariantType>(reactions.tunneling.begin(), reactions.tunneling.end()),
-          std::vector<VariantType>(reactions.user_defined.begin(), reactions.user_defined.end())
-        }
+      : reaction_lists{ std::vector<VariantType>(reactions.arrhenius.begin(), reactions.arrhenius.end()),
+                        std::vector<VariantType>(reactions.branched.begin(), reactions.branched.end()),
+                        std::vector<VariantType>(reactions.emission.begin(), reactions.emission.end()),
+                        std::vector<VariantType>(reactions.first_order_loss.begin(), reactions.first_order_loss.end()),
+                        std::vector<VariantType>(reactions.photolysis.begin(), reactions.photolysis.end()),
+                        std::vector<VariantType>(reactions.surface.begin(), reactions.surface.end()),
+                        std::vector<VariantType>(reactions.taylor_series.begin(), reactions.taylor_series.end()),
+                        std::vector<VariantType>(
+                            reactions.ternary_chemical_activation.begin(),
+                            reactions.ternary_chemical_activation.end()),
+                        std::vector<VariantType>(reactions.troe.begin(), reactions.troe.end()),
+                        std::vector<VariantType>(reactions.tunneling.begin(), reactions.tunneling.end()),
+                        std::vector<VariantType>(reactions.user_defined.begin(), reactions.user_defined.end()) }
   {
   }
 
@@ -163,14 +146,6 @@ Reactions create_reactions(const py::list &reactions)
     {
       reaction_obj.branched.push_back(item.cast<Branched>());
     }
-    else if (py::isinstance<CondensedPhaseArrhenius>(item))
-    {
-      reaction_obj.condensed_phase_arrhenius.push_back(item.cast<CondensedPhaseArrhenius>());
-    }
-    else if (py::isinstance<CondensedPhasePhotolysis>(item))
-    {
-      reaction_obj.condensed_phase_photolysis.push_back(item.cast<CondensedPhasePhotolysis>());
-    }
     else if (py::isinstance<Emission>(item))
     {
       reaction_obj.emission.push_back(item.cast<Emission>());
@@ -179,22 +154,6 @@ Reactions create_reactions(const py::list &reactions)
     {
       reaction_obj.first_order_loss.push_back(item.cast<FirstOrderLoss>());
     }
-    else if (py::isinstance<SimpolPhaseTransfer>(item))
-    {
-      reaction_obj.simpol_phase_transfer.push_back(item.cast<SimpolPhaseTransfer>());
-    }
-    else if (py::isinstance<AqueousEquilibrium>(item))
-    {
-      reaction_obj.aqueous_equilibrium.push_back(item.cast<AqueousEquilibrium>());
-    }
-    else if (py::isinstance<WetDeposition>(item))
-    {
-      reaction_obj.wet_deposition.push_back(item.cast<WetDeposition>());
-    }
-    else if (py::isinstance<HenrysLaw>(item))
-    {
-      reaction_obj.henrys_law.push_back(item.cast<HenrysLaw>());
-    }
     else if (py::isinstance<Photolysis>(item))
     {
       reaction_obj.photolysis.push_back(item.cast<Photolysis>());
@@ -203,14 +162,18 @@ Reactions create_reactions(const py::list &reactions)
     {
       reaction_obj.surface.push_back(item.cast<Surface>());
     }
-    else if (py::isinstance<Troe>(item))
+    else if (py::isinstance<TaylorSeries>(item))
     {
-      reaction_obj.troe.push_back(item.cast<Troe>());
+      reaction_obj.taylor_series.push_back(item.cast<TaylorSeries>());
     }
     else if (py::isinstance<TernaryChemicalActivation>(item))
     {
       reaction_obj.ternary_chemical_activation.push_back(item.cast<TernaryChemicalActivation>());
     }
+    else if (py::isinstance<Troe>(item))
+    {
+      reaction_obj.troe.push_back(item.cast<Troe>());
+    }
     else if (py::isinstance<Tunneling>(item))
     {
       reaction_obj.tunneling.push_back(item.cast<Tunneling>());
@@ -232,32 +195,20 @@ void bind_mechanism_configuration(py::module_ &mechanism_configuration)
   py::enum_<ReactionType>(mechanism_configuration, "_ReactionType")
       .value("Arrhenius", ReactionType::Arrhenius)
       .value("Branched", ReactionType::Branched)
-      .value("CondensedPhaseArrhenius", ReactionType::CondensedPhaseArrhenius)
-      .value("CondensedPhasePhotolysis", ReactionType::CondensedPhasePhotolysis)
       .value("Emission", ReactionType::Emission)
       .value("FirstOrderLoss", ReactionType::FirstOrderLoss)
-      .value("SimpolPhaseTransfer", ReactionType::SimpolPhaseTransfer)
-      .value("AqueousEquilibrium", ReactionType::AqueousEquilibrium)
-      .value("WetDeposition", ReactionType::WetDeposition)
-      .value("HenrysLaw", ReactionType::HenrysLaw)
       .value("Photolysis", ReactionType::Photolysis)
       .value("Surface", ReactionType::Surface)
-      .value("Troe", ReactionType::Troe)
+      .value("TaylorSeries", ReactionType::TaylorSeries)
       .value("TernaryChemicalActivation", ReactionType::TernaryChemicalActivation)
+      .value("Troe", ReactionType::Troe)
       .value("Tunneling", ReactionType::Tunneling)
       .value("UserDefined", ReactionType::UserDefined);
 
   py::class_<Species>(mechanism_configuration, "_Species")
       .def(py::init<>())
       .def_readwrite("name", &Species::name)
-      .def_readwrite("absolute_tolerance", &Species::absolute_tolerance)
-      .def_readwrite("diffusion_coefficient_m2_s", &Species::diffusion_coefficient)
       .def_readwrite("molecular_weight_kg_mol", &Species::molecular_weight)
-      .def_readwrite("HLC_298K_mol_m3_Pa", &Species::henrys_law_constant_298)
-      .def_readwrite("HLC_exponential_factor_K", &Species::henrys_law_constant_exponential_factor)
-      .def_readwrite("N_star", &Species::n_star)
-      .def_readwrite("density_kg_m3", &Species::density)
-      .def_readwrite("tracer_type", &Species::tracer_type)
       .def_readwrite("constant_concentration_mol_m3", &Species::constant_concentration)
       .def_readwrite("constant_mixing_ratio_mol_mol", &Species::constant_mixing_ratio)
       .def_readwrite("is_third_body", &Species::is_third_body)
@@ -265,6 +216,14 @@ void bind_mechanism_configuration(py::module_ &mechanism_configuration)
       .def("__str__", [](const Species &s) { return s.name; })
       .def("__repr__", [](const Species &s) { return "<Species: " + s.name + ">"; });
 
+  py::class_<PhaseSpecies>(mechanism_configuration, "_PhaseSpecies")
+      .def(py::init<>())
+      .def_readwrite("name", &PhaseSpecies::name)
+      .def_readwrite("diffusion_coefficient_m2_s", &PhaseSpecies::diffusion_coefficient)
+      .def_readwrite("other_properties", &PhaseSpecies::unknown_properties)
+      .def("__str__", [](const PhaseSpecies &s) { return s.name; })
+      .def("__repr__", [](const PhaseSpecies &s) { return "<PhaseSpecies: " + s.name + ">"; });
+
   py::class_<Phase>(mechanism_configuration, "_Phase")
       .def(py::init<>())
       .def_readwrite("name", &Phase::name)
@@ -312,21 +271,21 @@ void bind_mechanism_configuration(py::module_ &mechanism_configuration)
       .def("__repr__", [](const Arrhenius &a) { return "<Arrhenius: " + a.name + ">"; })
       .def_property_readonly("type", [](const Arrhenius &) { return ReactionType::Arrhenius; });
 
-  py::class_<CondensedPhaseArrhenius>(mechanism_configuration, "_CondensedPhaseArrhenius")
+  py::class_<TaylorSeries>(mechanism_configuration, "_TaylorSeries")
       .def(py::init<>())
-      .def_readwrite("A", &CondensedPhaseArrhenius::A)
-      .def_readwrite("B", &CondensedPhaseArrhenius::B)
-      .def_readwrite("C", &CondensedPhaseArrhenius::C)
-      .def_readwrite("D", &CondensedPhaseArrhenius::D)
-      .def_readwrite("E", &CondensedPhaseArrhenius::E)
-      .def_readwrite("reactants", &CondensedPhaseArrhenius::reactants)
-      .def_readwrite("products", &CondensedPhaseArrhenius::products)
-      .def_readwrite("name", &CondensedPhaseArrhenius::name)
-      .def_readwrite("condensed_phase", &CondensedPhaseArrhenius::condensed_phase)
-      .def_readwrite("other_properties", &CondensedPhaseArrhenius::unknown_properties)
-      .def("__str__", [](const CondensedPhaseArrhenius &cpa) { return cpa.name; })
-      .def("__repr__", [](const CondensedPhaseArrhenius &cpa) { return "<CondensedPhaseArrhenius: " + cpa.name + ">"; })
-      .def_property_readonly("type", [](const CondensedPhaseArrhenius &) { return ReactionType::CondensedPhaseArrhenius; });
+      .def_readwrite("A", &TaylorSeries::A)
+      .def_readwrite("B", &TaylorSeries::B)
+      .def_readwrite("C", &TaylorSeries::C)
+      .def_readwrite("D", &TaylorSeries::D)
+      .def_readwrite("E", &TaylorSeries::E)
+      .def_readwrite("taylor_coefficients", &TaylorSeries::taylor_coefficients)
+      .def_readwrite("name", &TaylorSeries::name)
+      .def_readwrite("gas_phase", &TaylorSeries::gas_phase)
+      .def_readwrite("reactants", &TaylorSeries::reactants)
+      .def_readwrite("products", &TaylorSeries::products)
+      .def_readwrite("other_properties", &TaylorSeries::unknown_properties)
+      .def("__str__", [](const TaylorSeries &ts) { return "TaylorSeries"; })
+      .def("__repr__", [](const TaylorSeries &ts) { return "<TaylorSeries>"; });
 
   py::class_<Troe>(mechanism_configuration, "_Troe")
       .def(py::init<>())
@@ -404,7 +363,6 @@ void bind_mechanism_configuration(py::module_ &mechanism_configuration)
       .def_readwrite("gas_phase_products", &Surface::gas_phase_products)
       .def_readwrite("name", &Surface::name)
       .def_readwrite("gas_phase", &Surface::gas_phase)
-      .def_readwrite("condensed_phase", &Surface::condensed_phase)
       .def_readwrite("other_properties", &Surface::unknown_properties)
       .def("__str__", [](const Surface &s) { return s.name; })
       .def("__repr__", [](const Surface &s) { return "<Surface: " + s.name + ">"; })
@@ -422,19 +380,6 @@ void bind_mechanism_configuration(py::module_ &mechanism_configuration)
       .def("__repr__", [](const Photolysis &p) { return "<Photolysis: " + p.name + ">"; })
       .def_property_readonly("type", [](const Photolysis &) { return ReactionType::Photolysis; });
 
-  py::class_<CondensedPhasePhotolysis>(mechanism_configuration, "_CondensedPhasePhotolysis")
-      .def(py::init<>())
-      .def_readwrite("scaling_factor", &CondensedPhasePhotolysis::scaling_factor)
-      .def_readwrite("reactants", &CondensedPhasePhotolysis::reactants)
-      .def_readwrite("products", &CondensedPhasePhotolysis::products)
-      .def_readwrite("name", &CondensedPhasePhotolysis::name)
-      .def_readwrite("condensed_phase", &CondensedPhasePhotolysis::condensed_phase)
-      .def_readwrite("other_properties", &CondensedPhasePhotolysis::unknown_properties)
-      .def("__str__", [](const CondensedPhasePhotolysis &cpp) { return cpp.name; })
-      .def("__repr__", [](const CondensedPhasePhotolysis &cpp) { return "<CondensedPhasePhotolysis: " + cpp.name + ">"; })
-      .def_property_readonly(
-          "type", [](const CondensedPhasePhotolysis &) { return ReactionType::CondensedPhasePhotolysis; });
-
   py::class_<Emission>(mechanism_configuration, "_Emission")
       .def(py::init<>())
       .def_readwrite("scaling_factor", &Emission::scaling_factor)
@@ -457,52 +402,6 @@ void bind_mechanism_configuration(py::module_ &mechanism_configuration)
       .def("__repr__", [](const FirstOrderLoss &fol) { return "<FirstOrderLoss: " + fol.name + ">"; })
       .def_property_readonly("type", [](const FirstOrderLoss &) { return ReactionType::FirstOrderLoss; });
 
-  py::class_<AqueousEquilibrium>(mechanism_configuration, "_AqueousEquilibrium")
-      .def(py::init<>())
-      .def_readwrite("name", &AqueousEquilibrium::name)
-      .def_readwrite("condensed_phase", &AqueousEquilibrium::condensed_phase)
-      .def_readwrite("condensed_phase_water", &AqueousEquilibrium::condensed_phase_water)
-      .def_readwrite("reactants", &AqueousEquilibrium::reactants)
-      .def_readwrite("products", &AqueousEquilibrium::products)
-      .def_readwrite("A", &AqueousEquilibrium::A)
-      .def_readwrite("C", &AqueousEquilibrium::C)
-      .def_readwrite("k_reverse", &AqueousEquilibrium::k_reverse)
-      .def_readwrite("other_properties", &AqueousEquilibrium::unknown_properties)
-      .def("__str__", [](const AqueousEquilibrium &ae) { return ae.name; })
-      .def("__repr__", [](const AqueousEquilibrium &ae) { return "<AqueousEquilibrium: " + ae.name + ">"; })
-      .def_property_readonly("type", [](const AqueousEquilibrium &) { return ReactionType::AqueousEquilibrium; });
-
-  py::class_<WetDeposition>(mechanism_configuration, "_WetDeposition")
-      .def(py::init<>())
-      .def_readwrite("scaling_factor", &WetDeposition::scaling_factor)
-      .def_readwrite("name", &WetDeposition::name)
-      .def_readwrite("condensed_phase", &WetDeposition::condensed_phase)
-      .def_readwrite("other_properties", &WetDeposition::unknown_properties)
-      .def("__str__", [](const WetDeposition &wd) { return wd.name; })
-      .def("__repr__", [](const WetDeposition &wd) { return "<WetDeposition: " + wd.name + ">"; })
-      .def_property_readonly("type", [](const WetDeposition &) { return ReactionType::WetDeposition; });
-
-  py::class_<HenrysLaw>(mechanism_configuration, "_HenrysLaw")
-      .def(py::init<>())
-      .def_readwrite("name", &HenrysLaw::name)
-      .def_readwrite("other_properties", &HenrysLaw::unknown_properties)
-      .def("__str__", [](const HenrysLaw &hl) { return hl.name; })
-      .def("__repr__", [](const HenrysLaw &hl) { return "<HenrysLaw: " + hl.name + ">"; })
-      .def_property_readonly("type", [](const HenrysLaw &) { return ReactionType::HenrysLaw; });
-
-  py::class_<SimpolPhaseTransfer>(mechanism_configuration, "_SimpolPhaseTransfer")
-      .def(py::init<>())
-      .def_readwrite("gas_phase", &SimpolPhaseTransfer::gas_phase)
-      .def_readwrite("gas_phase_species", &SimpolPhaseTransfer::gas_phase_species)
-      .def_readwrite("condensed_phase", &SimpolPhaseTransfer::condensed_phase)
-      .def_readwrite("condensed_phase_species", &SimpolPhaseTransfer::condensed_phase_species)
-      .def_readwrite("name", &SimpolPhaseTransfer::name)
-      .def_readwrite("B", &SimpolPhaseTransfer::B)
-      .def_readwrite("other_properties", &SimpolPhaseTransfer::unknown_properties)
-      .def("__str__", [](const SimpolPhaseTransfer &spt) { return spt.name; })
-      .def("__repr__", [](const SimpolPhaseTransfer &spt) { return "<SimpolPhaseTransfer: " + spt.name + ">"; })
-      .def_property_readonly("type", [](const SimpolPhaseTransfer &) { return ReactionType::SimpolPhaseTransfer; });
-
   py::class_<UserDefined>(mechanism_configuration, "_UserDefined")
       .def(py::init<>())
       .def_readwrite("scaling_factor", &UserDefined::scaling_factor)
@@ -520,29 +419,22 @@ void bind_mechanism_configuration(py::module_ &mechanism_configuration)
       .def(py::init([](const py::list &reactions) { return create_reactions(reactions); }))
       .def_readwrite("arrhenius", &Reactions::arrhenius)
       .def_readwrite("branched", &Reactions::branched)
-      .def_readwrite("condensed_phase_arrhenius", &Reactions::condensed_phase_arrhenius)
-      .def_readwrite("condensed_phase_photolysis", &Reactions::condensed_phase_photolysis)
       .def_readwrite("emission", &Reactions::emission)
       .def_readwrite("first_order_loss", &Reactions::first_order_loss)
-      .def_readwrite("simpol_phase_transfer", &Reactions::simpol_phase_transfer)
-      .def_readwrite("aqueous_equilibrium", &Reactions::aqueous_equilibrium)
-      .def_readwrite("wet_deposition", &Reactions::wet_deposition)
-      .def_readwrite("henrys_law", &Reactions::henrys_law)
       .def_readwrite("photolysis", &Reactions::photolysis)
       .def_readwrite("surface", &Reactions::surface)
-      .def_readwrite("troe", &Reactions::troe)
+      .def_readwrite("taylor_series", &Reactions::taylor_series)
       .def_readwrite("ternary_chemical_activation", &Reactions::ternary_chemical_activation)
+      .def_readwrite("troe", &Reactions::troe)
       .def_readwrite("tunneling", &Reactions::tunneling)
       .def_readwrite("user_defined", &Reactions::user_defined)
       .def(
           "__len__",
           [](const Reactions &r)
           {
-            return r.arrhenius.size() + r.branched.size() + r.condensed_phase_arrhenius.size() +
-                   r.condensed_phase_photolysis.size() + r.emission.size() + r.first_order_loss.size() +
-                   r.simpol_phase_transfer.size() + r.aqueous_equilibrium.size() + r.wet_deposition.size() +
-                   r.henrys_law.size() + r.photolysis.size() + r.surface.size() + r.troe.size() + r.tunneling.size() +
-                   r.user_defined.size();
+            return r.arrhenius.size() + r.branched.size() + r.emission.size() + r.first_order_loss.size() +
+                   r.photolysis.size() + r.surface.size() + r.taylor_series.size() + r.troe.size() +
+                   r.ternary_chemical_activation.size() + r.tunneling.size() + r.user_defined.size();
           })
       .def("__str__", [](const Reactions &r) { return "Reactions"; })
       .def("__repr__", [](const Reactions &r) { return "<Reactions>"; })

musica/musica.cpp

@@ -1,5 +1,7 @@
 // Copyright (C) 2023-2025 University Corporation for Atmospheric Research
 // SPDX-License-Identifier: Apache-2.0
+#include "binding_common.hpp"
+
 #include <musica/micm/cuda_availability.hpp>
 #include <musica/micm/micm.hpp>
 #include <musica/micm/micm_c_interface.hpp>
@@ -7,19 +9,14 @@
 #include <musica/micm/state_c_interface.hpp>
 
 #include <mechanism_configuration/v1/types.hpp>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
 
 namespace py = pybind11;
 namespace v1 = mechanism_configuration::v1::types;
 
-PYBIND11_MAKE_OPAQUE(std::vector<double>)
 PYBIND11_MAKE_OPAQUE(std::vector<micm::Conditions>)
 
 void bind_musica(py::module_ &core)
 {
-  py::bind_vector<std::vector<double>>(core, "VectorDouble");
   py::bind_vector<std::vector<micm::Conditions>>(core, "VectorConditions");
 
   py::class_<micm::Conditions>(core, "_Conditions")