musica 0.10.1__cp312-cp312-win_amd64.whl → 0.11.1.0__cp312-cp312-win_amd64.whl

musica/musica.cpp

@@ -0,0 +1,214 @@
+// Copyright (C) 2023-2025 University Corporation for Atmospheric Research
+// SPDX-License-Identifier: Apache-2.0
+#include <musica/micm/micm.hpp>
+#include <musica/micm/micm_c_interface.hpp>
+#include <musica/micm/state_c_interface.hpp>
+#include <musica/micm/state.hpp>
+#include <mechanism_configuration/v1/types.hpp>
+#include <musica/micm/cuda_availability.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")
+      .def(py::init<>())
+      .def_readwrite("temperature", &micm::Conditions::temperature_)
+      .def_readwrite("pressure", &micm::Conditions::pressure_)
+      .def_readwrite("air_density", &micm::Conditions::air_density_);
+
+  py::class_<musica::State>(core, "_State")
+      .def(py::init<>())
+      .def("__del__", [](musica::State &state) { })
+      .def("number_of_grid_cells",
+           [](musica::State &state) {
+             return state.NumberOfGridCells();
+           })
+      .def_property(
+          "conditions",
+          [](musica::State &state) -> std::vector<micm::Conditions>& {
+            return state.GetConditions();
+          },
+          nullptr,
+          "list of conditions structs for each grid cell")
+      .def_property(
+          "concentrations",
+          [](musica::State &state) -> std::vector<double>& {
+            return state.GetOrderedConcentrations();
+          },
+          nullptr,
+          "native 1D list of concentrations, ordered by species and grid cell according to matrix type")
+      .def_property(
+          "user_defined_rate_parameters",
+          [](musica::State &state) -> std::vector<double>& {
+            return state.GetOrderedRateParameters();
+          },
+          nullptr,
+          "native 1D list of user-defined rate parameters, ordered by parameter and grid cell according to matrix type")
+      .def("concentration_strides",
+          [](musica::State &state) {
+            return state.GetConcentrationsStrides();
+          })
+      .def("user_defined_rate_parameter_strides",
+          [](musica::State &state) {
+            return state.GetUserDefinedRateParametersStrides();
+          });
+
+  py::enum_<musica::MICMSolver>(core, "_SolverType")
+      .value("rosenbrock", musica::MICMSolver::Rosenbrock)
+      .value("rosenbrock_standard_order", musica::MICMSolver::RosenbrockStandardOrder)
+      .value("backward_euler", musica::MICMSolver::BackwardEuler)
+      .value("backward_euler_standard_order", musica::MICMSolver::BackwardEulerStandardOrder)
+      .value("cuda_rosenbrock", musica::MICMSolver::CudaRosenbrock);
+
+  py::class_<musica::MICM>(core, "_Solver");
+
+  core.def("_vector_size",
+      [](const musica::MICMSolver solver_type)
+      {
+        switch (solver_type)
+        {
+          case musica::MICMSolver::Rosenbrock:
+          case musica::MICMSolver::BackwardEuler:
+          case musica::MICMSolver::CudaRosenbrock:
+            return musica::MUSICA_VECTOR_SIZE;
+          case musica::MICMSolver::RosenbrockStandardOrder:
+          case musica::MICMSolver::BackwardEulerStandardOrder:
+            return static_cast<std::size_t>(0);
+          default:
+            throw py::value_error("Invalid MICM solver type.");
+        }
+      },
+      "Returns the vector dimension for vector-ordered solvers, 0 otherwise.");
+
+  core.def(
+      "_create_solver",
+      [](const char *config_path, musica::MICMSolver solver_type)
+      {
+        musica::Error error;
+        musica::MICM *micm = musica::CreateMicm(config_path, solver_type, &error);
+        if (!musica::IsSuccess(error))
+        {
+          std::cout << "Error creating solver: " << error.message_.value_ << " solver_type: " << solver_type
+                    << " config_path: " << config_path << std::endl;
+          std::string message = "Error creating solver: " + std::string(error.message_.value_);
+          DeleteError(&error);
+          throw py::value_error(message);
+        }
+        return micm;
+      });
+
+  core.def(
+      "_create_solver_from_mechanism",
+      [](const v1::Mechanism &mechanism, musica::MICMSolver solver_type)
+      {
+        musica::Error error;
+        musica::Chemistry chemistry = musica::ConvertV1Mechanism(mechanism);
+        musica::MICM *micm = musica::CreateMicmFromChemistryMechanism(&chemistry, solver_type, &error);
+        if (!musica::IsSuccess(error))
+        {
+          std::string message = "Error creating solver: " + std::string(error.message_.value_);
+          DeleteError(&error);
+          throw py::value_error(message);
+        }
+        return micm;
+      });
+  
+  core.def(
+      "_create_state",
+      [](musica::MICM *micm, std::size_t number_of_grid_cells)
+      {
+        musica::Error error;
+        musica::State *state = musica::CreateMicmState(micm, number_of_grid_cells, &error);
+        if (!musica::IsSuccess(error))
+        {
+          std::string message = "Error creating state: " + std::string(error.message_.value_);
+          DeleteError(&error);
+          throw py::value_error(message);
+        }
+        return state;
+      });
+
+  core.def(
+      "_micm_solve",
+      [](musica::MICM *micm, musica::State *state, double time_step)
+      {
+        musica::String solver_state;
+        musica::SolverResultStats solver_stats;
+        musica::Error error;
+        musica::MicmSolve(micm, state, time_step, &solver_state, &solver_stats, &error);
+        if (!musica::IsSuccess(error))
+        {
+          std::string message = "Error solving system: " + std::string(error.message_.value_);
+          DeleteError(&error);
+          throw py::value_error(message);
+        }
+      },
+      "Solve the chemistry system");
+
+  core.def(
+      "_species_ordering",
+      [](musica::State *state)
+      {
+        std::map<std::string, std::size_t> map;
+        std::visit([&map](auto &state) { map = state.variable_map_; }, state->state_variant_);
+        return map;
+      },
+      "Return map of species names to their indices in the state concentrations vector");
+
+  core.def(
+      "_user_defined_rate_parameters_ordering",
+      [](musica::State *state)
+      {
+        std::map<std::string, std::size_t> map;
+
+        std::visit([&map](auto &state) { map = state.custom_rate_parameter_map_; }, state->state_variant_);
+        return map;
+      },
+      "Return map of reaction rate parameters to their indices in the state user-defined rate parameters vector");
+
+  core.def("_is_cuda_available", &musica::IsCudaAvailable, "Check if CUDA is available");
+
+  core.def(
+      "_print_state",
+      [](musica::State *state, const double current_time)
+      {
+        std::visit([&current_time](auto &state) {
+          std::cout << "Current time: " << current_time << std::endl;
+          std::cout << "State variables: " << std::endl;
+          std::vector<std::string> species_names(state.variable_map_.size());
+          for (const auto &species : state.variable_map_)
+            species_names[species.second] = species.first;
+          for (const auto &name : species_names)
+            std::cout << name << ",";
+          std::cout << std::endl << state.variables_ << std::endl;
+          std::cout << "User-defined rate parameters: " << std::endl;
+          std::vector<std::string> rate_param_names(state.custom_rate_parameter_map_.size());
+          for (const auto &rate : state.custom_rate_parameter_map_)
+            rate_param_names[rate.second] = rate.first;
+          for (const auto &name : rate_param_names)
+            std::cout << name << ",";
+          std::cout << std::endl << state.custom_rate_parameters_ << std::endl;
+          std::cout << "Conditions: " << std::endl;
+          std::cout << "Temperature,Pressure,Air density" << std::endl;
+          for (const auto &condition : state.conditions_)
+          {
+            std::cout << condition.temperature_ << ","
+                      << condition.pressure_ << ","
+                      << condition.air_density_ << std::endl;
+          }
+        }, state->state_variant_);
+      },
+      "Print the state to stdout with the current time");
+}

musica/test/examples/v0/config.json

@@ -0,0 +1,7 @@
+{
+    "camp-files": [
+      "species.json",
+      "reactions.json"
+    ]
+  }
+  

musica/test/examples/v0/config.yaml

@@ -0,0 +1,3 @@
+camp-files:
+- species.yaml
+- reactions.yaml

musica/test/examples/v0/reactions.json

@@ -0,0 +1,193 @@
+{
+  "camp-data": [
+    {
+      "type": "MECHANISM",
+      "name": "music box interactive configuration",
+      "reactions": [
+        {
+          "type": "PHOTOLYSIS",
+          "scaling factor": 1,
+          "MUSICA name": "foo",
+          "reactants": {
+            "foo": {}
+          },
+          "products": {
+            "buz": {
+              "yield": 1
+            },
+            "bar": {
+              "yield": 1
+            }
+          }
+        },
+        {
+          "type": "ARRHENIUS",
+          "A": 6e-34,
+          "Ea": 0,
+          "B": -2.4,
+          "D": 300,
+          "E": 0,
+          "reactants": {
+            "bar": {
+              "qty": 1
+            },
+            "quuz": {
+              "qty": 1
+            },
+            "M": {
+              "qty": 1
+            }
+          },
+          "products": {
+            "baz": {
+              "yield": 1
+            },
+            "M": {
+              "yield": 1
+            }
+          }
+        },
+        {
+          "type": "TROE",
+          "k0_A": 2.5e-31,
+          "k0_B": -1.8,
+          "k0_C": 0,
+          "kinf_A": 2.2e-11,
+          "kinf_B": -0.7,
+          "kinf_C": 0,
+          "Fc": 0.6,
+          "N": 1,
+          "reactants": {
+            "bar": {
+              "qty": 1
+            },
+            "foo": {
+              "qty": 1
+            }
+          },
+          "products": {
+            "baz": {
+              "yield": 1
+            }
+          }
+        },
+        {
+          "type": "EMISSION",
+          "scaling factor": 1,
+          "MUSICA name": "buz",
+          "species": "buz"
+        },
+        {
+          "type": "FIRST_ORDER_LOSS",
+          "species": "bar",
+          "MUSICA name": "bar",
+          "scaling factor": 2.5
+        },
+        {
+          "type": "TERNARY_CHEMICAL_ACTIVATION",
+          "reactants": {
+            "bar" : { },
+            "baz" : { }
+          },
+          "products": {
+            "bar": { "yield": 0.5 },
+            "foo": { }
+          },
+          "k0_A": 32.1,
+          "k0_B": -2.3,
+          "k0_C": 102.3,
+          "kinf_A": 63.4,
+          "kinf_B": -1.3,
+          "kinf_C": 908.5,
+          "Fc": 1.3,
+          "N": 32.1
+        },
+        {
+          "type": "BRANCHED",
+          "reactants": {
+            "foo" : { },
+            "quz" : { "qty" :2 }
+          },
+          "alkoxy products": {
+            "bar": { "yield": 1.0 },
+            "baz": { "yield": 3.2 }
+          },
+          "nitrate products": {
+            "quz": { "yield": 1.0 }
+          },
+          "Y" : 42.3,
+          "X" : 12.3,
+          "a0" : 1.0e-5,
+          "n" : 3
+        },
+        {
+          "type": "WENNBERG_NO_RO2",
+          "reactants": {
+            "bar" : { },
+            "baz" : { }
+          },
+          "alkoxy products": {
+            "baz": { }
+          },
+          "nitrate products": {
+            "bar": { "yield": 0.5 },
+            "foo": { }
+          },
+          "Y" : 2.3e8,
+          "X" : 0.32,
+          "a0" : 0.423,
+          "n" : 6
+        },
+        {
+          "type": "TUNNELING",
+          "reactants": {
+            "bar" : { },
+            "baz" : { }
+          },
+          "products": {
+            "bar": { "yield": 0.5 },
+            "foo": { }
+          },
+          "A": 32.1,
+          "B": -2.3,
+          "C": 102.3
+        },
+        {
+          "type": "WENNBERG_TUNNELING",
+          "reactants": {
+            "bar2" : { },
+            "baz2" : { }
+          },
+          "products": {
+            "bar2": { "yield": 0.5 },
+            "foo2": { }
+          },
+          "A": 2.1,
+          "B": -1.3,
+          "C": 12.3
+        },
+        {
+          "type": "SURFACE",
+          "gas-phase reactant": "bar",
+          "gas-phase products": {
+            "bar": { "yield": 0.5 },
+            "foo": { }
+          },
+          "reaction probability": 0.5,
+          "MUSICA name": "kbar"
+        },
+        {
+          "type": "USER_DEFINED",
+          "MUSICA name": "bar",
+          "reactants": { 
+            "foo" : { "qty": 2 }
+          },
+          "products": {
+            "bar" : { }
+          }, 
+          "scaling factor": 2.5
+        }
+      ]
+    }
+  ]
+}

musica/test/examples/v0/reactions.yaml

@@ -0,0 +1,142 @@
+camp-data:
+- name: music box interactive configuration
+  reactions:
+  - MUSICA name: foo
+    products:
+      bar:
+        yield: 1
+      buz:
+        yield: 1
+    reactants:
+      foo: {}
+    scaling factor: 1
+    type: PHOTOLYSIS
+  - A: 6.0e-34
+    B: -2.4
+    D: 300
+    E: 0
+    Ea: 0
+    products:
+      M:
+        yield: 1
+      baz:
+        yield: 1
+    reactants:
+      M:
+        qty: 1
+      bar:
+        qty: 1
+      quuz:
+        qty: 1
+    type: ARRHENIUS
+  - Fc: 0.6
+    N: 1
+    k0_A: 2.5e-31
+    k0_B: -1.8
+    k0_C: 0
+    kinf_A: 2.2e-11
+    kinf_B: -0.7
+    kinf_C: 0
+    products:
+      baz:
+        yield: 1
+    reactants:
+      bar:
+        qty: 1
+      foo:
+        qty: 1
+    type: TROE
+  - MUSICA name: buz
+    scaling factor: 1
+    species: buz
+    type: EMISSION
+  - MUSICA name: bar
+    scaling factor: 2.5
+    species: bar
+    type: FIRST_ORDER_LOSS
+  - Fc: 1.3
+    N: 32.1
+    k0_A: 32.1
+    k0_B: -2.3
+    k0_C: 102.3
+    kinf_A: 63.4
+    kinf_B: -1.3
+    kinf_C: 908.5
+    products:
+      bar:
+        yield: 0.5
+      foo: {}
+    reactants:
+      bar: {}
+      baz: {}
+    type: TERNARY_CHEMICAL_ACTIVATION
+  - X: 12.3
+    Y: 42.3
+    a0: 1.0e-05
+    alkoxy products:
+      bar:
+        yield: 1.0
+      baz:
+        yield: 3.2
+    n: 3
+    nitrate products:
+      quz:
+        yield: 1.0
+    reactants:
+      foo: {}
+      quz:
+        qty: 2
+    type: BRANCHED
+  - X: 0.32
+    Y: 230000000.0
+    a0: 0.423
+    alkoxy products:
+      baz: {}
+    n: 6
+    nitrate products:
+      bar:
+        yield: 0.5
+      foo: {}
+    reactants:
+      bar: {}
+      baz: {}
+    type: WENNBERG_NO_RO2
+  - A: 32.1
+    B: -2.3
+    C: 102.3
+    products:
+      bar:
+        yield: 0.5
+      foo: {}
+    reactants:
+      bar: {}
+      baz: {}
+    type: TUNNELING
+  - A: 2.1
+    B: -1.3
+    C: 12.3
+    products:
+      bar2:
+        yield: 0.5
+      foo2: {}
+    reactants:
+      bar2: {}
+      baz2: {}
+    type: WENNBERG_TUNNELING
+  - MUSICA name: kbar
+    gas-phase products:
+      bar:
+        yield: 0.5
+      foo: {}
+    gas-phase reactant: bar
+    reaction probability: 0.5
+    type: SURFACE
+  - MUSICA name: bar
+    products:
+      bar: {}
+    reactants:
+      foo:
+        qty: 2
+    scaling factor: 2.5
+    type: USER_DEFINED
+  type: MECHANISM

musica/test/examples/v0/species.json

@@ -0,0 +1,40 @@
+{
+  "camp-data": [
+    {
+      "name": "foo",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "bar",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "buz",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "quuz",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "foo2",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "bar2",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "baz",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "baz2",
+      "type": "CHEM_SPEC"
+    },
+    {
+      "name": "M",
+      "type": "CHEM_SPEC"
+    }
+  ]
+}

musica/test/examples/v0/species.yaml

@@ -0,0 +1,19 @@
+camp-data:
+- name: foo
+  type: CHEM_SPEC
+- name: bar
+  type: CHEM_SPEC
+- name: buz
+  type: CHEM_SPEC
+- name: quuz
+  type: CHEM_SPEC
+- name: foo2
+  type: CHEM_SPEC
+- name: bar2
+  type: CHEM_SPEC
+- name: baz
+  type: CHEM_SPEC
+- name: baz2
+  type: CHEM_SPEC
+- name: M
+  type: CHEM_SPEC