musica 0.11.1.1__cp312-cp312-win_amd64.whl → 0.14.2__cp312-cp312-win_amd64.whl

musica/tools/prepare_build_environment_linux.sh

@@ -1,41 +0,0 @@
-#! /bin/bash
-
-set -e
-set -x
-
-# Update the mirror list to use vault.centos.org
-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
-
-sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
-sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
-
-yum install -y zip tree
-
-# Use CIBW_ARCHS or CIBW_ARCH if set, else fallback to uname -m
-if [ -n "$CIBW_ARCHS" ]; then
-  target_arch="$CIBW_ARCHS"
-elif [ -n "$CIBW_ARCH" ]; then
-  target_arch="$CIBW_ARCH"
-else
-  target_arch="$(uname -m)"
-fi
-
-echo "Detected target_arch: $target_arch"
-
-if [ "$target_arch" = "x86_64" ]; then
-  # Install CUDA 12.2 for x86_64:
-  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

@@ -1,22 +0,0 @@
-#! /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/tools/repair_wheel_gpu.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-auditwheel repair --exclude libcublas --exclude libcublasLt --exclude libcudart -w "$2" "$1"
-
-for whl in "$2"/*.whl; do
-  tmpdir=$(mktemp -d)
-  unzip -q "$whl" -d "$tmpdir"
-  tree "$tmpdir"
-  echo "Before patchelf:"
-  readelf -d "$tmpdir"/_musica*.so
-  patchelf --remove-rpath "$tmpdir"/_musica*.so
-  patchelf --set-rpath "\$ORIGIN:\$ORIGIN/../../nvidia/cublas/lib:\$ORIGIN/../../nvidia/cuda_runtime/lib" --force-rpath "$tmpdir"/_musica*.so
-  # Remove bundled CUDA libraries
-  rm -f "$tmpdir"/musica.libs/libcudart-*.so*
-  rm -f "$tmpdir"/musica.libs/libcublas-*.so*
-  rm -f "$tmpdir"/musica.libs/libcublasLt-*.so*
-  echo "After patchelf:"
-  readelf -d "$tmpdir"/_musica*.so
-  # Repack the wheel with correct structure
-  (cd "$tmpdir" && zip -qr "${whl%.whl}.patched.whl" .)
-  rm -rf "$tmpdir"
-  # Replace the original wheel with the patched one
-  mv "${whl%.whl}.patched.whl" "$whl"
-done

musica/types.py

@@ -1,362 +0,0 @@
-# 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.11.1.1.dist-info/RECORD

@@ -1,30 +0,0 @@
-_musica.cp312-win_amd64.pyd,sha256=OPpnY6Nm9doCljoEzLkIky5BoTmP36QWidFxKQvqIa4,1531904
-lib/musica.lib,sha256=btfX7dN39dlkLEQ9cXbtx-pH7Hh8pBm1cudEMrdXUNI,5507286
-lib/yaml-cpp.lib,sha256=lT-GEY3q3MQqRyd9IDHtZwKefm2GuwtmHkzQmBqdiD8,2764186
-musica/__init__.py,sha256=ZtW55jXUkE_2GFco1Q1GyGrpyNoVej6gfbpEWHzfpM0,85
-musica/_version.py,sha256=UKJdIRQbpP27qmDKiN3zXQk32a8c-cH4Lf8v0oFMPi4,22
-musica/binding.cpp,sha256=rpc7Fn_GmR2Femli_gEvtgtiprRnForekUlMDoBo7PQ,674
-musica/CMakeLists.txt,sha256=j5m-7lf8E1YwpiEeUml5GL27hS4sfpgn2h2LzoQDiO8,1174
-musica/mechanism_configuration.cpp,sha256=JXGAO3j1EEKYdswjrtX8J3KcI_YlfS9WGRmlMxctaDw,27619
-musica/mechanism_configuration.py,sha256=_0kS0fvGS-CbQ_YfJOeSM416u7WLPwq7GzDcPgGGBWA,59302
-musica/musica.cpp,sha256=z4nucF98Nd-V6U_OLp_5RsW4WGE8qMn3GWLvCuY_nJE,8612
-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=lY5XuEMEg7IEfTvEIeSRhShMNdX39q00H8RjqGnZB30,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=Xrd95nPnznqTAc24TVeehXP-7uMkJE1FysKKZsPYgPs,1507
-musica/tools/prepare_build_environment_windows.sh,sha256=sBBWhJQaS2zWDVFLIDMNBMOMPw8auXwnwz7nhuB5Q_k,847
-musica/tools/repair_wheel_gpu.sh,sha256=bXFSgNjCE4D8NvLGfNkIDyt2Qsx6AlT1VfHEBlrRTz4,942
-musica/types.py,sha256=GA04nbo-m7Jg_TQMvFMdMC35kzSDynUHvt7alBnM8FI,15257
-musica-0.11.1.1.dist-info/METADATA,sha256=URpXjU5lo-wyROln6GI9YbAqGFDPH0gq8O30EzTW5uc,20814
-musica-0.11.1.1.dist-info/WHEEL,sha256=FmzxB5JvGlblMZ3nyeR4sHqjN8xvrDOf24fzxfEP0HA,106
-musica-0.11.1.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-musica-0.11.1.1.dist-info/RECORD,,