musica 0.10.1__cp37-cp37m-win32.whl → 0.11.1__cp37-cp37m-win32.whl

musica/tools/prepare_build_environment_linux.sh

@@ -0,0 +1,21 @@
+#! /bin/bash
+
+set -e
+set -x
+
+# Cuda can only be installed on x86_64 architecture.
+if [ "$(uname -m)" == "x86_64" ]; then
+  # Install CUDA 12.2:
+  yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
+  # error mirrorlist.centos.org doesn't exists anymore.
+  sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo
+  sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/*.repo
+  sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/*.repo
+  yum install --setopt=obsoletes=0 -y \
+      cuda-nvcc-12-2-12.2.140-1 \
+      cuda-cudart-devel-12-2-12.2.140-1 \
+      libcurand-devel-12-2-10.3.3.141-1 \
+      libcublas-devel-12-2-12.2.5.6-1 \
+      libnccl-devel-2.19.3-1+cuda12.2
+  ln -s cuda-12.2 /usr/local/cuda
+fi

musica/tools/prepare_build_environment_windows.sh

@@ -0,0 +1,22 @@
+#! /bin/bash
+
+set -e
+set -x
+
+CUDA_ROOT="C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.8"
+# curl --netrc-optional -L -nv -o cuda.exe https://developer.download.nvidia.com/compute/cuda/12.2.2/local_installers/cuda_12.2.2_537.13_windows.exe
+curl --netrc-optional -L -nv -o cuda.exe https://developer.download.nvidia.com/compute/cuda/12.8.1/local_installers/cuda_12.8.1_572.61_windows.exe
+./cuda.exe -s nvcc_12.8 cudart_12.8 cublas_dev_12.8 curand_dev_12.8 
+rm cuda.exe
+
+export CUDA_PATH="/c/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.8"
+export PATH="$CUDA_PATH/bin:$PATH"
+
+ls "c/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.8/extras/visual_studio_integration/MSBuildExtensions"
+ls "c/Program Files (x86)/Microsoft Visual Studio/"
+
+# choco install cuda 
+
+ls "$CUDA_PATH"
+ls "$CUDA_PATH/bin"
+which nvcc.exe

musica/types.py

@@ -0,0 +1,362 @@
+# Copyright (C) 2023-2025 University Corporation for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of the musica Python package.
+# For more information, see the LICENSE file in the top-level directory of this distribution.
+from typing import Optional, Any, Dict, List, Union, Tuple
+from os import PathLike
+import math
+from _musica._core import (
+    _Conditions,
+    _SolverType,
+    _Solver,
+    _State,
+    _create_solver,
+    _create_solver_from_mechanism,
+    _create_state,
+    _micm_solve,
+    _vector_size,
+    _species_ordering,
+    _user_defined_rate_parameters_ordering,
+)
+import musica.mechanism_configuration as mc
+
+AVOGADRO = 6.02214076e23  # mol^-1
+BOLTZMANN = 1.380649e-23  # J K^-1
+GAS_CONSTANT = AVOGADRO * BOLTZMANN  # J K^-1 mol^-1
+
+FilePath = Union[str, "PathLike[str]"]
+
+
+def _get_vector_matrix_indices(row_index: int, column_index: int, vector_size: int) -> Tuple[int, int]:
+    """
+    Get the row and column indices for a matrix given the row and column indices for a vector.
+
+    Parameters
+    ----------
+    row_index : int
+        Row index of the vector.
+    column_index : int
+        Column index of the vector.
+    vector_size : int
+        Size of the vector.
+
+    Returns
+    -------
+    tuple[int, int]
+        Index for which state matrix to use and the index in that matrix'x underlying data vector.
+    """
+    return (row_index // vector_size, column_index * (vector_size - 1) + row_index % vector_size)
+
+
+class Conditions(_Conditions):
+    """
+    Conditions class for the MICM solver. If air density is not provided,
+    it will be calculated from the Ideal Gas Law using the provided temperature and pressure.
+
+    Parameters
+    ----------
+    temperature : float
+        Temperature in Kelvin.
+    pressure : float
+        Pressure in Pascals.
+    air_density : float
+        Air density in mol m-3
+    """
+
+    def __init__(
+        self,
+        temperature: Optional[Union[float, int]] = None,
+        pressure: Optional[Union[float, int]] = None,
+        air_density: Optional[Union[float, int]] = None,
+    ):
+        super().__init__()
+        if temperature is not None:
+            self.temperature = temperature
+        if pressure is not None:
+            self.pressure = pressure
+        if air_density is not None:
+            self.air_density = air_density
+        elif temperature is not None and pressure is not None:
+            self.air_density = 1.0 / (GAS_CONSTANT * temperature / pressure)
+
+
+class SolverType(_SolverType):
+    """
+    Enum class for the type of solver to use.
+    """
+
+
+class State():
+    """
+    State class for the MICM solver. It contains the initial conditions and species concentrations.
+    """
+
+    def __init__(self, solver: _Solver, number_of_grid_cells: int, vector_size: int = 0):
+        if number_of_grid_cells < 1:
+            raise ValueError("number_of_grid_cells must be greater than 0.")
+        super().__init__()
+        self.__states = [
+            _create_state(solver, min(vector_size, number_of_grid_cells - i * vector_size))
+            for i in range(math.ceil(number_of_grid_cells / vector_size))
+        ] if vector_size > 0 else [_create_state(solver, number_of_grid_cells)]
+        self.__species_ordering = _species_ordering(self.__states[0])
+        self.__user_defined_rate_parameters_ordering = _user_defined_rate_parameters_ordering(self.__states[0])
+        self.__number_of_grid_cells = number_of_grid_cells
+        self.__vector_size = vector_size
+
+    def get_internal_states(self) -> List[_State]:
+        """
+        Get the internal states of the MICM solver.
+
+        Returns
+        -------
+        List[_State]
+            List of internal states.
+        """
+        return self.__states
+
+    def set_concentrations(self, concentrations: Dict[str, Union[Union[float, int], List[Union[float, int]]]]):
+        """
+        Set the concentrations of the species in the state. Any species not in the
+        dictionary will be set to zero. The concentrations can be a single value when solving
+        for a single grid cell, or a list of values when solving for multiple grid cells.
+
+        Parameters
+        ----------
+        concentrations : Dict[str, Union[Union[float, int], List[Union[float, int]]]]
+            Dictionary of species names and their concentrations.
+        """
+        for name, value in concentrations.items():
+            if name not in self.__species_ordering:
+                raise ValueError(f"Species {name} not found in the mechanism.")
+            i_species = self.__species_ordering[name]
+            if isinstance(value, float) or isinstance(value, int):
+                value = [value]
+            if len(value) != self.__number_of_grid_cells:
+                raise ValueError(f"Concentration list for {name} must have length {self.__number_of_grid_cells}.")
+            # Counter 'k' is used to map grid cell indices across multiple state segments.
+            k = 0
+            for state in self.__states:
+                cell_stride, species_stride = state.concentration_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    state.concentrations[i_species * species_stride + i_cell * cell_stride] = value[k]
+                    k += 1
+
+    def set_user_defined_rate_parameters(
+            self, user_defined_rate_parameters: Dict[str, Union[Union[float, int], List[Union[float, int]]]]):
+        """
+        Set the user-defined rate parameters in the state. Any parameter not in the
+        dictionary will be set to zero. The parameters can be a single value when solving
+        for a single grid cell, or a list of values when solving for multiple grid cells.
+
+        Parameters
+        ----------
+        user_defined_rate_parameters : Dict[str, Union[Union[float, int], List[Union[float, int]]]]
+            Dictionary of user-defined rate parameter names and their values.
+        """
+        for name, value in user_defined_rate_parameters.items():
+            if name not in self.__user_defined_rate_parameters_ordering:
+                raise ValueError(f"User-defined rate parameter {name} not found in the mechanism.")
+            i_param = self.__user_defined_rate_parameters_ordering[name]
+            if isinstance(value, float) or isinstance(value, int):
+                value = [value]
+            if len(value) != self.__number_of_grid_cells:
+                raise ValueError(
+                    f"User-defined rate parameter list for {name} must have length {self.__number_of_grid_cells}.")
+            # Initialize `k` to index the grid cells when assigning user-defined rate parameters.
+            k = 0
+            for state in self.__states:
+                cell_stride, param_stride = state.user_defined_rate_parameter_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    state.user_defined_rate_parameters[i_param * param_stride + i_cell * cell_stride] = value[k]
+                    k += 1
+
+    def set_conditions(self,
+                       temperatures: Union[Union[float, int], List[Union[float, int]]],
+                       pressures: Union[Union[float, int], List[Union[float, int]]],
+                       air_densities: Optional[Union[Union[float, int], List[Union[float, int]]]] = None):
+        """
+        Set the conditions for the state. The individual conditions can be a single value
+        when solving for a single grid cell, or a list of values when solving for multiple grid cells.
+        If air density is not provided, it will be calculated from the Ideal Gas Law using the provided
+        temperature and pressure.
+
+        Parameters
+        ----------
+        temperatures : Union[float, List[float]]
+            Temperature in Kelvin.
+        pressures : Union[float, List[float]]
+            Pressure in Pascals.
+        air_densities : Optional[Union[float, List[float]]]
+            Air density in mol m-3. If not provided, it will be calculated from the Ideal Gas Law.
+        """
+        if isinstance(temperatures, float) or isinstance(temperatures, int):
+            if self.__number_of_grid_cells > 1:
+                raise ValueError(f"temperatures must be a list of length {self.__number_of_grid_cells}.")
+            temperatures = [temperatures]
+        if isinstance(pressures, float) or isinstance(pressures, int):
+            if self.__number_of_grid_cells > 1:
+                raise ValueError(f"pressures must be a list of length {self.__number_of_grid_cells}.")
+            pressures = [pressures]
+        if air_densities is not None and (isinstance(air_densities, float) or isinstance(air_densities, int)):
+            if self.__number_of_grid_cells > 1:
+                raise ValueError(f"air_densities must be a list of length {self.__number_of_grid_cells}.")
+            air_densities = [air_densities]
+        if len(temperatures) != self.__number_of_grid_cells:
+            raise ValueError(f"temperatures must be a list of length {self.__number_of_grid_cells}.")
+        if len(pressures) != self.__number_of_grid_cells:
+            raise ValueError(f"pressures must be a list of length {self.__number_of_grid_cells}.")
+        if air_densities is not None and len(air_densities) != self.__number_of_grid_cells:
+            raise ValueError(f"air_densities must be a list of length {self.__number_of_grid_cells}.")
+        k = 0
+        for state in self.__states:
+            for condition in state.conditions:
+                condition.temperature = temperatures[k]
+                condition.pressure = pressures[k]
+                condition.air_density = air_densities[k] if air_densities is not None else pressures[k] / (
+                    GAS_CONSTANT * temperatures[k])
+                k += 1
+
+    def get_concentrations(self) -> Dict[str, List[float]]:
+        """
+        Get the concentrations of the species in the state.
+
+        Returns
+        -------
+        Dict[str, List[float]]
+            Dictionary of species names and their concentrations.
+        """
+        concentrations = {}
+        for species, i_species in self.__species_ordering.items():
+            concentrations[species] = []
+            for state in self.__states:
+                cell_stride, species_stride = state.concentration_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    concentrations[species].append(
+                        state.concentrations[i_species * species_stride + i_cell * cell_stride])
+        return concentrations
+
+    def get_user_defined_rate_parameters(self) -> Dict[str, List[float]]:
+        """
+        Get the user-defined rate parameters in the state.
+
+        Returns
+        -------
+        Dict[str, List[float]]
+            Dictionary of user-defined rate parameter names and their values.
+        """
+        user_defined_rate_parameters = {}
+        for param, i_param in self.__user_defined_rate_parameters_ordering.items():
+            user_defined_rate_parameters[param] = []
+            for state in self.__states:
+                cell_stride, param_stride = state.user_defined_rate_parameter_strides()
+                for i_cell in range(state.number_of_grid_cells()):
+                    user_defined_rate_parameters[param].append(
+                        state.user_defined_rate_parameters[i_param * param_stride + i_cell * cell_stride])
+        return user_defined_rate_parameters
+
+    def get_conditions(self) -> Dict[str, List[float]]:
+        """
+        Get the conditions for the state.
+
+        Returns
+        -------
+        Dict[str, List[float]]
+            Dictionary of conditions names and their values.
+        """
+        conditions = {}
+        conditions["temperature"] = []
+        conditions["pressure"] = []
+        conditions["air_density"] = []
+        for state in self.__states:
+            for i_cell in range(state.number_of_grid_cells()):
+                conditions["temperature"].append(state.conditions[i_cell].temperature)
+                conditions["pressure"].append(state.conditions[i_cell].pressure)
+                conditions["air_density"].append(state.conditions[i_cell].air_density)
+        return conditions
+
+
+class MICM():
+    """
+    The MICM class is a wrapper around the C++ MICM solver. It provides methods to create a solver,
+    create a state, and solve the system of equations.
+
+    Parameters
+    ----------
+    config_path : FilePath
+        Path to the configuration file.
+    mechanism : mechanism_configuration.Mechanism
+        Mechanism object which specifies the chemical mechanism to use.
+    solver_type : SolverType
+        Type of solver to use.
+    number_of_grid_cells : int
+        Number of grid cells to use. The default is 1.
+    """
+
+    def __init__(
+        self,
+        config_path: FilePath = None,
+        mechanism: mc.Mechanism = None,
+        solver_type: _SolverType = None,
+    ):
+        self.__solver_type = solver_type
+        self.__vector_size = _vector_size(solver_type)
+        if config_path is None and mechanism is None:
+            raise ValueError("Either config_path or mechanism must be provided.")
+        if config_path is not None and mechanism is not None:
+            raise ValueError("Only one of config_path or mechanism must be provided.")
+        if config_path is not None:
+            self.__solver = _create_solver(config_path, solver_type)
+        elif mechanism is not None:
+            self.__solver = _create_solver_from_mechanism(mechanism, solver_type)
+
+    def solver_type(self) -> SolverType:
+        """
+        Get the type of solver used.
+
+        Returns
+        -------
+        SolverType
+            The type of solver used.
+        """
+        return self.__solver_type
+
+    def create_state(self, number_of_grid_cells: int = 1) -> State:
+        """
+        Create a new state object.
+
+        Returns
+        -------
+        State
+            A new state object.
+        """
+        return State(self.__solver, number_of_grid_cells, self.__vector_size)
+
+    def solve(
+            self,
+            state: State,
+            time_step: float,
+    ):
+        """
+        Solve the system of equations for the given state and time step.
+
+        Parameters
+        ----------
+        state : State
+            State object containing the initial conditions.
+        time_step : float
+            Time step in seconds.
+
+        Returns
+        -------
+        State
+            Updated state object after solving the system of equations.
+        """
+        if not isinstance(state, State):
+            raise TypeError("state must be an instance of State.")
+        if not isinstance(time_step, (int, float)):
+            raise TypeError("time_step must be an int or float.")
+        states = state.get_internal_states()
+        for _, _state in enumerate(states):
+            _micm_solve(self.__solver, _state, time_step)

{musica-0.10.1.dist-info → musica-0.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: musica
-Version: 0.10.1
+Version: 0.11.1
 Summary: MUSICA is a Python library for performing computational simulations in atmospheric chemistry.
 Home-page: https://wiki.ucar.edu/display/MUSICA/MUSICA+Home
 Author-Email: Matthew Dawsom <mattdawson@ucar.edu>, Jiwon Gim <jiwongim@ucar.edu>, David Fillmore <fillmore@ucar.edu>, Kyle Shores <kshores@ucar.edu>, Montek Thind <mthind@ucar.edu>
@@ -209,6 +209,7 @@ License:                                  Apache License
 Project-URL: Homepage, https://wiki.ucar.edu/display/MUSICA/MUSICA+Home
 Provides-Extra: test
 Requires-Dist: numpy; extra == "test"
+Requires-Dist: pytest; extra == "test"
 Description-Content-Type: text/markdown
 
 # MUSICA
@@ -222,6 +223,7 @@ Description-Content-Type: text/markdown
 [![DOI](https://zenodo.org/badge/550370528.svg)](https://zenodo.org/doi/10.5281/zenodo.7458559)
 [![PyPI version](https://badge.fury.io/py/musica.svg)](https://pypi.org/p/musica)
 [![FAIR checklist badge](https://fairsoftwarechecklist.net/badge.svg)](https://fairsoftwarechecklist.net/v0.2?f=31&a=32113&i=22322&r=123)
+[![codecov](https://codecov.io/gh/NCAR/musica/branch/main/graph/badge.svg)](https://codecov.io/gh/NCAR/musica)
 
 Multi-Scale Infrastructure for Chemistry and Aerosols
 
@@ -274,6 +276,22 @@ Specifying a specific version of `tuv-x` by has, but using the official reposito
         -DTUVX_GIT_TAG=a6b2c4d8745
 
 
+### Python build
+Musica has python bindings. If you want to install the python package, you may `pip install musica`.
+
+To build the package locally,
+
+```
+pip install -e .
+```
+
+If you have an NVIDIA GPU and cuda installed, you can enable a build of musica with GPU support by setting the environment 
+variable `BUILD_GPU`.
+
+```
+BUILD_GPU=1 pip install -e .
+```
+
 ## Citing MUSICA
 
 MUSICA can be cited in at least two ways. The first is to cite [the paper](https://doi.org/10.1175/BAMS-D-19-0331.1) that defines the vision

musica-0.11.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+_musica.cp37-win32.pyd,sha256=QrOgwWywNu-c_WSEntx9Zppq6N9EeA-ZndgFDRSFb3E,1281024
+lib/musica.lib,sha256=6GkqfVVMzpLdyN62CqFHbY1VzWxkCAgmHFz12x--nxg,3434448
+lib/yaml-cpp.lib,sha256=1kXgiW-REqu2dloLReZbPd4FG7hMYkSArZTtOyxp2w8,1799180
+musica/__init__.py,sha256=ZtW55jXUkE_2GFco1Q1GyGrpyNoVej6gfbpEWHzfpM0,85
+musica/_version.py,sha256=TYiYsKySORMKTb6v-yyuXf6S-1keJ7xf0QxD5hFzCmg,20
+musica/binding.cpp,sha256=rpc7Fn_GmR2Femli_gEvtgtiprRnForekUlMDoBo7PQ,674
+musica/CMakeLists.txt,sha256=yDo8hzh5m44GUMoeTH3z1IC5zWJUYQeK8CrGFGfdJ8U,1010
+musica/mechanism_configuration.cpp,sha256=JXGAO3j1EEKYdswjrtX8J3KcI_YlfS9WGRmlMxctaDw,27619
+musica/mechanism_configuration.py,sha256=_0kS0fvGS-CbQ_YfJOeSM416u7WLPwq7GzDcPgGGBWA,59302
+musica/musica.cpp,sha256=DH18hBFpJF9m68F1FaGgVBwxVxaeYr304dLF2DY4FOo,8579
+musica/test/examples/v0/config.json,sha256=JDQdrDNRmRXGYlytX1uiSDV1lkYIAneLwlodHKFw-os,85
+musica/test/examples/v0/config.yaml,sha256=r31QbiFE2YDudGxLGpTKnpyveTnlfXeLgJ2qSrQddDY,47
+musica/test/examples/v0/reactions.json,sha256=SmRUE5XOAv0h3HOWg4Fb1swBiZvZ-1hsIrmMCJqEVIk,4380
+musica/test/examples/v0/reactions.yaml,sha256=5QeEkhjeAL_rXxNYCLOuqDUudTmgwLW3NERDupKpj6s,2408
+musica/test/examples/v0/species.json,sha256=klFuYb2vAtWdHfHJVYuIuPe_6LHRTuB0Aw29YhwfCFc,604
+musica/test/examples/v0/species.yaml,sha256=ECT9DDa2GMwhSRaRLxjOiCATTKkTRTPwugRsUjHSytY,302
+musica/test/examples/v1/full_configuration.json,sha256=1-kr2bZJvfuENfy6FMfc5ZEOtgs_NhzHYeGrEGLqLMw,9240
+musica/test/examples/v1/full_configuration.yaml,sha256=9NSd8BUJnJ6CPjX9ZngqbFDEqUf1qG5ixbnQDO2m79k,5505
+musica/test/test_analytical.py,sha256=UAM3YEx6OnxkQem0oidptY5mM1smDkcWIyIA0iG-f6w,14098
+musica/test/test_chapman.py,sha256=_OHLNBWT5qcU8s3mQAisV16qOdyRq7gdaU4nFZtxTnY,3193
+musica/test/test_parser.py,sha256=s8b55MntiDmUeW3GP_-JHucEhxi5RMSzPWQULM73rpg,24985
+musica/test/tuvx.py,sha256=L8X7rJ09HiRlrhLK6fjircI8tGHnFCZJzVow8He5YOE,126
+musica/tools/prepare_build_environment_linux.sh,sha256=qJeVEjYuWFYZuk9Q26gu0Ly4oKx06Sp5f-WVr3PmnYQ,822
+musica/tools/prepare_build_environment_windows.sh,sha256=sBBWhJQaS2zWDVFLIDMNBMOMPw8auXwnwz7nhuB5Q_k,847
+musica/types.py,sha256=GA04nbo-m7Jg_TQMvFMdMC35kzSDynUHvt7alBnM8FI,15257
+musica-0.11.1.dist-info/METADATA,sha256=IlAF1TS5yurBr3aax-x1xM6svzQ2m3W8nP23j3Orsm4,20536
+musica-0.11.1.dist-info/WHEEL,sha256=0jqwLq1QEQxAxQ8s6kub4lrGP70AxxK4kIUHpH0xAdM,101
+musica-0.11.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+musica-0.11.1.dist-info/RECORD,,

musica-0.10.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-lib/mechanism_configuration.lib,sha256=qkRxVS3983_ikvdP_WIybP7SQitZd7W2SOqWpeyVAdA,9070174
-lib/musica.lib,sha256=3m8WCpfqEVLuRm8bgm15XMb16_ndnwNhbSqh8xcabcg,3051132
-lib/yaml-cpp.lib,sha256=w0ndIiR-R1SZfEhaypcqzf0wS51D875R6MyTtFaFrIE,1765642
-musica/_version.py,sha256=nv9a5tGlYCBP2HcJGV3ULwnsKWdjpZ47i8Es22y_BL4,20
-musica.cp37-win32.pyd,sha256=1HZD4id6vdJ93FtNyVkLMlwCVc7kF8VuQe3dZkIWYMc,1023488
-musica-0.10.1.dist-info/METADATA,sha256=DBMwh30xlAVKYFO-AY6l7iC03ebDbz7sOEX3S3bynkI,20025
-musica-0.10.1.dist-info/WHEEL,sha256=0jqwLq1QEQxAxQ8s6kub4lrGP70AxxK4kIUHpH0xAdM,101
-musica-0.10.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-musica-0.10.1.dist-info/RECORD,,