musica 0.14.4__cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

musica/main.py

@@ -0,0 +1,128 @@
+import argparse
+import datetime
+import logging
+import shutil
+import os
+from musica import Examples
+from musica import __version__
+import musica.examples
+import importlib.resources as ir
+import musica
+
+
+def versions():
+    return f"musica {musica.__version__} (MICM {musica.micm.__version__}, TUV-x {musica.tuvx.__version__}, CARMA {musica.carma.__version__})"
+
+
+def format_examples_help(examples):
+    return '\n'.join(f"{e.short_name}: {e.description}" for e in examples)
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description='musica CLI',
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument(
+        '-e', '--example',
+        type=str,
+        choices=[e.short_name for e in Examples],
+        help=f'Name of the example to copy out.\nAvailable examples:\n{format_examples_help(Examples)}'
+    )
+    parser.add_argument(
+        '-o', '--output',
+        type=str,
+        help=("Path to save the output to.")
+    )
+    parser.add_argument(
+        '-v', '--verbose',
+        action='count',
+        default=0,
+        help='Increase logging verbosity. Use -v for info, -vv for debug.'
+    )
+    parser.add_argument(
+        '--version',
+        action='version',
+        version=versions(),
+    )
+    parser.add_argument(
+        '--convert',
+        type=str,
+        help='Path to a musica v0 configuration to convert to v1 format.'
+    )
+    return parser.parse_args()
+
+
+def setup_logging(verbosity):
+    log_level = logging.DEBUG if verbosity >= 2 else logging.INFO if verbosity == 1 else logging.CRITICAL
+    datefmt = '%Y-%m-%d %H:%M:%S'
+    format_string = '%(asctime)s - %(levelname)s - %(module)s.%(funcName)s - %(message)s'
+    formatter = logging.Formatter(format_string, datefmt=datefmt)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(log_level)
+    logging.basicConfig(level=log_level, handlers=[console_handler])
+
+
+def copy_example(logger, example_arg, output_path):
+    example = next((e for e in Examples if e.short_name == example_arg), None)
+    if not example:
+        raise ValueError(f"Example '{example_arg}' not found.")
+
+    logger.info(f"Copying example: {example} to {output_path}")
+
+    with ir.path(musica.examples, example.path) as example_path:
+        logger.info(f"Copying example from {example_path} to {output_path}")
+        shutil.copy(example_path, output_path)
+
+
+def convert_configuration(logger, configuration, output_path):
+    logger.info(f"Converting configuration: {configuration} to {output_path}")
+    if not os.path.exists(configuration):
+        raise ValueError(f"Configuration file '{configuration}' does not exist.")
+
+    parser = musica.mechanism_configuration.Parser()
+    mechanism = parser.parse_and_convert_v0(configuration)
+    mechanism.export(output_path)
+
+
+def main():
+    start = datetime.datetime.now()
+
+    args = parse_arguments()
+    setup_logging(args.verbose)
+
+    logger = logging.getLogger(__name__)
+
+    logger.debug(f"{__file__}")
+    logger.info(f"Start time: {start}")
+
+    logger.debug(f"Working directory = {os.getcwd()}")
+
+    # Figure out what action we are doing. We are either converting or copying an example.
+    convert = args.convert
+    example_arg = args.example
+    output = args.output
+
+    if not convert and not example_arg:
+        raise ValueError("Either --convert or --example must be specified.")
+
+    if convert and example_arg:
+        raise ValueError("Cannot specify both --convert and --example. Choose one.")
+
+    if not output:
+        logger.debug("No output path specified, using current directory.")
+        output = '.'
+
+    if convert:
+        convert_configuration(logger, convert, output)
+    else:
+        copy_example(logger, example_arg, output)
+
+    end = datetime.datetime.now()
+    logger.info(f"End time: {end}")
+    logger.info(f"Elapsed time: {end - start} seconds")
+
+
+if __name__ == "__main__":
+    main()

musica/mechanism_configuration/__init__.py

@@ -0,0 +1,18 @@
+from .arrhenius import Arrhenius
+from .branched import Branched
+from .emission import Emission
+from .first_order_loss import FirstOrderLoss
+from .mechanism import Mechanism
+from .ancillary import Version, Parser, ReactionType
+from .phase import Phase
+from .phase_species import PhaseSpecies
+from .photolysis import Photolysis
+from .reaction_component import ReactionComponent
+from .reactions import Reactions
+from .species import Species
+from .surface import Surface
+from .taylor_series import TaylorSeries
+from .ternary_chemical_activation import TernaryChemicalActivation
+from .troe import Troe
+from .tunneling import Tunneling
+from .user_defined import UserDefined

musica/mechanism_configuration/ancillary.py

@@ -0,0 +1,6 @@
+from .. import backend
+
+_backend = backend.get_backend()
+Version = _backend._mechanism_configuration._Version
+Parser = _backend._mechanism_configuration._Parser
+ReactionType = _backend._mechanism_configuration._ReactionType

musica/mechanism_configuration/arrhenius.py

@@ -0,0 +1,149 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .phase import Phase
+from .species import Species
+from .utils import _add_other_properties, _remove_empty_keys
+from ..constants import BOLTZMANN
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+Arrhenius = _backend._mechanism_configuration._Arrhenius
+
+original_init = Arrhenius.__init__
+
+
+@property
+def type(self):
+    """Get the reaction type."""
+    return ReactionType.Arrhenius
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    A: Optional[float] = None,
+    B: Optional[float] = None,
+    C: Optional[float] = None,
+    Ea: Optional[float] = None,
+    D: Optional[float] = None,
+    E: Optional[float] = None,
+    reactants: Optional[List[Union[Species,
+                                   Tuple[float, Species]]]] = None,
+    products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the Arrhenius object with the given parameters.
+
+    Args:
+        name (str): The name of the Arrhenius rate constant.
+        A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1] where n is the number of reactants.
+        B (float): Temperature exponent [unitless].
+        C (float): Exponential term [K-1].
+        Ea (float): Activation energy [J molecule-1].
+        D (float): Reference Temperature [K].
+        E (float): Pressure scaling term [Pa-1].
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+        products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the reaction.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the Arrhenius rate constant.
+    """
+    original_init(self)
+
+    # Validate mutually exclusive parameters
+    if C is not None and Ea is not None:
+        raise ValueError("Cannot specify both C and Ea.")
+    if Ea is not None:
+        C = -Ea / BOLTZMANN
+
+    self.name = name if name is not None else self.name
+    self.A = A if A is not None else self.A
+    self.B = B if B is not None else self.B
+    self.C = C if C is not None else self.C
+    self.D = D if D is not None else self.D
+    self.E = E if E is not None else self.E
+    self.gas_phase = gas_phase.name if gas_phase is not None else self.gas_phase
+    self.other_properties = other_properties if other_properties is not None else self.other_properties
+    self.reactants = (
+        [
+            (
+                ReactionComponent(r.name)
+                if isinstance(r, Species)
+                else ReactionComponent(r[1].name, r[0])
+            )
+            for r in reactants
+        ]
+        if reactants is not None
+        else self.reactants
+    )
+    self.products = (
+        [
+            (
+                ReactionComponent(p.name)
+                if isinstance(p, Species)
+                else ReactionComponent(p[1].name, p[0])
+            )
+            for p in products
+        ]
+        if products is not None
+        else self.products
+    )
+
+
+def serialize(self) -> Dict:
+    """
+    Serialize the Arrhenius object to a dictionary using only Python-visible data.
+
+    Returns:
+        Dict: A dictionary representation of the Arrhenius object.
+    """
+    serialize_dict = {
+        "type": "ARRHENIUS",
+        "name": self.name,
+        "A": self.A,
+        "B": self.B,
+        "C": self.C,
+        "D": self.D,
+        "E": self.E,
+        "reactants": [r.serialize() for r in self.reactants],
+        "products": [r.serialize() for r in self.products],
+        "gas phase": self.gas_phase,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+Arrhenius.__doc__ = """
+    A class representing an Arrhenius rate constant.
+
+    k = A * exp( C / T ) * ( T / D )^B * exp( 1 - E * P )
+
+    where:
+        k = rate constant
+        A = pre-exponential factor [(mol m-3)^(n-1)s-1]
+        B = temperature exponent [unitless]
+        C = exponential term [K-1]
+        D = reference temperature [K]
+        E = pressure scaling term [Pa-1]
+        T = temperature [K]
+        P = pressure [Pa]
+        n = number of reactants
+
+    Attributes:
+        name (str): The name of the Arrhenius rate constant.
+        A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1] where n is the number of reactants.
+        B (float): Temperature exponent [unitless].
+        C (float): Exponential term [K-1].
+        D (float): Reference Temperature [K].
+        E (float): Pressure scaling term [Pa-1].
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+        products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the reaction.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the Arrhenius rate constant.
+    """
+
+Arrhenius.__init__ = __init__
+Arrhenius.serialize = serialize
+Arrhenius.type = type

musica/mechanism_configuration/branched.py

@@ -0,0 +1,140 @@
+from .utils import _add_other_properties, _remove_empty_keys
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+Branched = _backend._mechanism_configuration._Branched
+
+original_init = Branched.__init__
+
+
+@property
+def type(self):
+    """Get the reaction type."""
+    return ReactionType.Branched
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    X: Optional[float] = None,
+    Y: Optional[float] = None,
+    a0: Optional[float] = None,
+    n: Optional[float] = None,
+    reactants: Optional[List[Union[Species,
+                                   Tuple[float, Species]]]] = None,
+    nitrate_products: Optional[List[Union[Species,
+                                          Tuple[float, Species]]]] = None,
+    alkoxy_products: Optional[List[Union[Species,
+                                         Tuple[float, Species]]]] = None,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the Branched object with the given parameters.
+
+    Args:
+        name (str): The name of the branched reaction rate constant.
+        X (float): Pre-exponential branching factor [(mol m-3)^-(n-1)s-1].
+        Y (float): Exponential branching factor [K-1].
+        a0 (float): Z parameter [unitless].
+        n (float): A parameter [unitless].
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+        nitrate_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the nitrate branch.
+        alkoxy_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the alkoxy branch.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the branched reaction rate constant.
+    """
+    original_init(self)
+
+    self.name = name if name is not None else self.name
+    self.X = X if X is not None else self.X
+    self.Y = Y if Y is not None else self.Y
+    self.a0 = a0 if a0 is not None else self.a0
+    self.n = n if n is not None else self.n
+    self.gas_phase = gas_phase.name if gas_phase is not None else self.gas_phase
+    self.other_properties = other_properties if other_properties is not None else self.other_properties
+    self.reactants = (
+        [
+            (
+                ReactionComponent(r.name)
+                if isinstance(r, Species)
+                else ReactionComponent(r[1].name, r[0])
+            )
+            for r in reactants
+        ]
+        if reactants is not None
+        else self.reactants
+    )
+    self.nitrate_products = (
+        [
+            (
+                ReactionComponent(p.name)
+                if isinstance(p, Species)
+                else ReactionComponent(p[1].name, p[0])
+            )
+            for p in nitrate_products
+        ]
+        if nitrate_products is not None
+        else self.nitrate_products
+    )
+    self.alkoxy_products = (
+        [
+            (
+                ReactionComponent(p.name)
+                if isinstance(p, Species)
+                else ReactionComponent(p[1].name, p[0])
+            )
+            for p in alkoxy_products
+        ]
+        if alkoxy_products is not None
+        else self.alkoxy_products
+    )
+
+
+def serialize(self) -> Dict:
+    """
+    Serialize the Branched object to a dictionary using only Python-visible data.
+
+    Returns:
+        Dict: A dictionary representation of the Branched object.
+    """
+    serialize_dict = {
+        "type": "BRANCHED_NO_RO2",
+        "name": self.name,
+        "X": self.X,
+        "Y": self.Y,
+        "a0": self.a0,
+        "n": self.n,
+        "reactants": [r.serialize() for r in self.reactants],
+        "nitrate products": [r.serialize() for r in self.nitrate_products],
+        "alkoxy products": [r.serialize() for r in self.alkoxy_products],
+        "gas phase": self.gas_phase,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+Branched.__doc__ = """
+    A class representing a branched reaction rate constant.
+
+    Attributes:
+        name (str): The name of the branched reaction rate constant.
+        X (float): Pre-exponential branching factor [(mol m-3)^-(n-1)s-1].
+        Y (float): Exponential branching factor [K-1].
+        a0 (float): Z parameter [unitless].
+        n (float): A parameter [unitless].
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+        nitrate_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the nitrate branch.
+        alkoxy_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the alkoxy branch.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the branched reaction rate constant.
+    """
+
+Branched.__init__ = __init__
+Branched.serialize = serialize
+Branched.type = type

musica/mechanism_configuration/emission.py

@@ -0,0 +1,82 @@
+from .utils import _add_other_properties, _remove_empty_keys
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+Emission = _backend._mechanism_configuration._Emission
+
+original_init = Emission.__init__
+
+
+@property
+def type(self):
+    return ReactionType.Emission
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    scaling_factor: Optional[float] = None,
+    products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the Emission object with the given parameters.
+
+    Args:
+        name (str): The name of the emission reaction rate constant.
+        scaling_factor (float): The scaling factor for the emission rate constant.
+        products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the reaction.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the emission reaction rate constant.
+    """
+    original_init(self)
+    self.name = name if name is not None else self.name
+    self.scaling_factor = scaling_factor if scaling_factor is not None else self.scaling_factor
+    self.products = (
+        [
+            (
+                ReactionComponent(p.name)
+                if isinstance(p, Species)
+                else ReactionComponent(p[1].name, p[0])
+            )
+            for p in products
+        ]
+        if products is not None
+        else self.products
+    )
+    self.gas_phase = gas_phase.name if gas_phase is not None else self.gas_phase
+    self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+
+def serialize(self) -> Dict:
+    serialize_dict = {
+        "type": "EMISSION",
+        "name": self.name,
+        "scaling factor": self.scaling_factor,
+        "products": [r.serialize() for r in self.products],
+        "gas phase": self.gas_phase,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return serialize_dict
+
+
+Emission.__doc__ = """
+A class representing an emission reaction rate constant.
+
+Attributes:
+    name (str): The name of the emission reaction rate constant.
+    scaling_factor (float): The scaling factor for the emission rate constant.
+    products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the reaction.
+    gas_phase (Phase): The gas phase in which the reaction occurs.
+    other_properties (Dict[str, Any]): A dictionary of other properties of the emission reaction rate constant.
+"""
+
+Emission.__init__ = __init__
+Emission.serialize = serialize
+Emission.type = type

musica/mechanism_configuration/first_order_loss.py

@@ -0,0 +1,90 @@
+from .utils import _add_other_properties, _remove_empty_keys
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+FirstOrderLoss = _backend._mechanism_configuration._FirstOrderLoss
+
+original_init = FirstOrderLoss.__init__
+
+
+@property
+def type(self):
+    return ReactionType.FirstOrderLoss
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    scaling_factor: Optional[float] = None,
+    reactants: Optional[List[Union[Species,
+                                   Tuple[float, Species]]]] = None,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the FirstOrderLoss object with the given parameters.
+
+    Args:
+        name (str): The name of the first-order loss reaction rate constant.
+        scaling_factor (float): The scaling factor for the first-order loss rate constant.
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the first-order loss reaction rate constant.
+    """
+    original_init(self)
+
+    self.name = name if name is not None else self.name
+    self.scaling_factor = scaling_factor if scaling_factor is not None else self.scaling_factor
+    self.gas_phase = gas_phase.name if gas_phase is not None else self.gas_phase
+    self.other_properties = other_properties if other_properties is not None else self.other_properties
+    self.reactants = (
+        [
+            (
+                ReactionComponent(r.name)
+                if isinstance(r, Species)
+                else ReactionComponent(r[1].name, r[0])
+            )
+            for r in reactants
+        ]
+        if reactants is not None
+        else self.reactants
+    )
+
+
+def serialize(self) -> Dict:
+    """
+    Serialize the FirstOrderLoss object to a dictionary using only Python-visible data.
+
+    Returns:
+        Dict: A dictionary representation of the FirstOrderLoss object.
+    """
+    serialize_dict = {
+        "type": "FIRST_ORDER_LOSS",
+        "name": self.name,
+        "scaling factor": self.scaling_factor,
+        "reactants": [r.serialize() for r in self.reactants],
+        "gas phase": self.gas_phase,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+FirstOrderLoss.__doc__ = """
+A class representing a first-order loss reaction rate constant.
+
+Attributes:
+    name (str): The name of the first-order loss reaction rate constant.
+    scaling_factor (float): The scaling factor for the first-order loss rate constant.
+    reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+    gas_phase (Phase): The gas phase in which the reaction occurs.
+    other_properties (Dict[str, Any]): A dictionary of other properties of the first-order loss reaction rate constant.
+"""
+
+FirstOrderLoss.__init__ = __init__
+FirstOrderLoss.serialize = serialize
+FirstOrderLoss.type = type