musica 0.12.2__cp311-cp311-manylinux_2_26_i686.manylinux_2_28_i686.whl

musica/test/integration/test_carma.py

@@ -0,0 +1,227 @@
+import pytest
+import musica
+
+available = musica.backend.carma_available()
+pytestmark = pytest.mark.skipif(
+    not available, reason="CARMA backend is not available")
+
+
+def test_carma_version():
+    version = musica.carma.version
+    assert version is not None
+    assert isinstance(version, str)
+    print(f"CARMA version: {version}")
+
+
+def test_carma_with_all_components():
+    """Test CARMA with multiple groups, elements, solutes, and gases"""
+    params = musica.CARMAParameters()
+    params.nz = 1
+    params.ny = 1
+    params.nx = 1
+    params.nbin = 3
+    params.dtime = 900.0
+    params.deltaz = 500.0
+    params.zmin = 1000.0
+
+    # Set up wavelength bins
+    params.wavelength_bins = [
+        musica.carma.CARMAWavelengthBin(
+            center=550e-9, width=50e-9, do_emission=True),   # 550 nm ± 25 nm
+        musica.carma.CARMAWavelengthBin(
+            center=850e-9, width=100e-9, do_emission=True)  # 850 nm ± 50 nm
+    ]
+
+    # Group 1: Aluminum particles (sphere)
+    aluminum_group = musica.carma.CARMAGroupConfig(
+        name="aluminum",
+        shortname="ALUM",
+        rmin=1e-8,
+        rmrat=2.0,
+        ishape=musica.carma.ParticleShape.SPHERE,
+        eshape=1.0,
+        is_fractal=False,
+        do_vtran=True,
+        do_drydep=True,
+        df=[1.8, 1.8, 1.8]  # fractal dimension per bin
+    )
+    params.groups.append(aluminum_group)
+
+    # Group 2: Sulfate particles (sphere, with swelling)
+    sulfate_group = musica.carma.CARMAGroupConfig(
+        name="sulfate",
+        shortname="SULF",
+        rmin=5e-9,
+        rmrat=2.5,
+        ishape=musica.carma.ParticleShape.SPHERE,
+        eshape=1.0,
+        swelling_approach={
+            "algorithm": musica.carma.ParticleSwellingAlgorithm.FITZGERALD,
+            "composition": musica.carma.ParticleSwellingComposition.AMMONIUM_SULFATE
+        },
+        is_sulfate=True,
+        do_wetdep=True,
+        do_vtran=True,
+        solfac=0.8,
+        df=[2.0, 2.0, 2.0]
+    )
+    params.groups.append(sulfate_group)
+
+    # Group 3: Ice particles (hexagon)
+    ice_group = musica.carma.CARMAGroupConfig(
+        name="ice",
+        shortname="ICE",
+        rmin=2e-8,
+        rmrat=3.0,
+        ishape=musica.carma.ParticleShape.HEXAGON,
+        eshape=2.0,  # aspect ratio
+        is_ice=True,
+        is_cloud=True,
+        do_vtran=True,
+        df=[1.5, 1.5, 1.5]
+    )
+    params.groups.append(ice_group)
+
+    # Element 1: Aluminum core (Group 1)
+    aluminum_element = musica.carma.CARMAElementConfig(
+        igroup=1,
+        name="Aluminum",
+        shortname="AL",
+        rho=2.70,  # g/cm³
+        itype=musica.carma.ParticleType.INVOLATILE,
+        icomposition=musica.carma.ParticleComposition.ALUMINUM,
+        kappa=0.0,
+        is_shell=False  # core
+    )
+    params.elements.append(aluminum_element)
+
+    # Element 2: Sulfate (Group 2)
+    sulfate_element = musica.carma.CARMAElementConfig(
+        igroup=2,
+        isolute=1,  # linked to first solute
+        name="Sulfate",
+        shortname="SO4",
+        rho=1.84,  # g/cm³
+        itype=musica.carma.ParticleType.VOLATILE,
+        icomposition=musica.carma.ParticleComposition.SULFURIC_ACID,
+        kappa=0.61,  # hygroscopicity
+        is_shell=True
+    )
+    params.elements.append(sulfate_element)
+
+    # Element 3: Water on sulfate (Group 2)
+    water_element = musica.carma.CARMAElementConfig(
+        igroup=2,
+        name="Water",
+        shortname="H2O",
+        rho=1.0,  # g/cm³
+        itype=musica.carma.ParticleType.CORE_MASS,
+        icomposition=musica.carma.ParticleComposition.WATER,
+        kappa=0.0,
+        is_shell=True
+    )
+    params.elements.append(water_element)
+
+    # Element 4: Ice (Group 3)
+    ice_element = musica.carma.CARMAElementConfig(
+        igroup=3,
+        name="Ice",
+        shortname="ICE",
+        rho=0.92,  # g/cm³
+        itype=musica.carma.ParticleType.INVOLATILE,
+        icomposition=musica.carma.ParticleComposition.ICE,
+        kappa=0.0,
+        is_shell=False
+    )
+    params.elements.append(ice_element)
+
+    # Solute: Sulfate
+    sulfate_solute = musica.carma.CARMASoluteConfig(
+        name="Sulfate",
+        shortname="SO4",
+        ions=2,
+        wtmol=0.1324,  # kg mol-1
+        rho=1840.0  # kg m-3
+    )
+    params.solutes.append(sulfate_solute)
+
+    # Gas: Water vapor
+    water_gas = musica.carma.CARMAGasConfig(
+        name="Water Vapor",
+        shortname="H2O",
+        wtmol=0.01801528,  # kg mol-1
+        ivaprtn=musica.carma.VaporizationAlgorithm.H2O_MURPHY_2005,
+        icomposition=musica.carma.GasComposition.H2O,
+        dgc_threshold=1.0e-6,
+        ds_threshold=1.0e-4
+    )
+    params.gases.append(water_gas)
+
+    # Gas: Sulfuric acid
+    h2so4_gas = musica.carma.CARMAGasConfig(
+        name="Sulfuric Acid",
+        shortname="H2SO4",
+        wtmol=0.098079,  # kg mol-1
+        ivaprtn=musica.carma.VaporizationAlgorithm.H2O_BUCK_1981,
+        icomposition=musica.carma.GasComposition.H2SO4,
+        dgc_threshold=0.05,
+        ds_threshold=0.1
+    )
+    params.gases.append(h2so4_gas)
+
+    # Gas: Sulfur dioxide
+    so2_gas = musica.carma.CARMAGasConfig(
+        name="Sulfur Dioxide",
+        shortname="SO2",
+        wtmol=0.064066,  # kg mol-1
+        ivaprtn=musica.carma.VaporizationAlgorithm.H2O_BUCK_1981,
+        icomposition=musica.carma.GasComposition.SO2,
+        dgc_threshold=0.05,
+        ds_threshold=0.1
+    )
+    params.gases.append(so2_gas)
+
+    # Create CARMA instance and run
+    carma = musica.CARMA(params)
+
+    assert carma is not None
+    assert isinstance(carma, musica.CARMA)
+
+    state = carma.create_state(
+        vertical_center=[16500.0],
+        vertical_levels=[16500.0, 17000.0],
+        pressure=[90000.0],
+        pressure_levels=[101325.0, 90050.0],
+        temperature=[280.0],
+        time=0.0,
+        time_step=900.0,  # 15 minutes
+        longitude=0.0,
+        latitude=0.0,
+        coordinates=musica.carma.CarmaCoordinates.CARTESIAN
+    )
+
+    assert state is not None
+    assert isinstance(state, musica.CARMAState)
+
+    state.set_bin(1, 1, 1.0)
+    state.set_detrain(1, 1, 1.0)
+    state.set_gas(1, 1.4e-3)
+    state.set_temperature(300.0)
+    state.set_air_density(1.2)
+    state.step(land=musica.carma.CARMASurfaceProperties(surface_friction_velocity=0.42, area_fraction=0.3),
+               ocean=musica.carma.CARMASurfaceProperties(
+                   aerodynamic_resistance=0.1),
+               ice=musica.carma.CARMASurfaceProperties(area_fraction=0.2))
+    print(state.get_step_statistics())
+    print(state.get_bins())
+    print(state.get_detrained_masses())
+    print(state.get_environmental_values())
+    print(state.get_gases())
+    print(carma.get_group_properties())
+    print(carma.get_element_properties())
+    print(carma.get_gas_properties())
+    print(carma.get_solute_properties())
+
+
+if __name__ == '__main__':
+    pytest.main([__file__])

musica/test/integration/test_carma_aluminum.py

@@ -0,0 +1,12 @@
+import pytest
+import musica
+
+available = musica.backend.carma_available()
+pytestmark = pytest.mark.skipif(
+    not available, reason="CARMA backend is not available")
+
+
+def test_carma_aluminum():
+    from musica.examples import carma_aluminum
+    state = carma_aluminum.run_carma_aluminum_example()
+    assert state is not None, "State should not be None"

musica/test/integration/test_carma_sulfate.py

@@ -0,0 +1,17 @@
+import pytest
+import musica
+
+available = musica.backend.carma_available()
+pytestmark = pytest.mark.skipif(
+    not available, reason="CARMA backend is not available")
+
+
+def test_carma_sulfate():
+    from musica.examples import carma_sulfate
+    env_state, gas_state, bin_state = carma_sulfate.run_carma_sulfate_example()
+    # Basic assertions to verify the simulation ran successfully
+    assert env_state is not None, "Environmental state should not be None"
+    assert gas_state is not None, "Gas state should not be None"
+    assert bin_state is not None, "Bin state should not be None"
+    # Optionally, check expected dimensions or variables
+    assert hasattr(bin_state, "mass_mixing_ratio"), "Bin state should have mass_mixing_ratio"

musica/test/integration/test_chapman.py

@@ -0,0 +1,139 @@
+import pytest
+import musica
+import musica.mechanism_configuration as mc
+
+
+def test_solve_with_config_path_v0():
+    solver = musica.MICM(
+        config_path="configs/v0/chapman",
+        solver_type=musica.SolverType.rosenbrock_standard_order,
+    )
+    TestSolve(solver)
+
+
+def test_solve_with_config_path_v1_json():
+    solver = musica.MICM(
+        config_path="configs/v1/chapman/config.json",
+        solver_type=musica.SolverType.rosenbrock_standard_order,
+    )
+    TestSolve(solver)
+
+
+def test_solve_with_config_path_v1_yaml():
+    solver = musica.MICM(
+        config_path="configs/v1/chapman/config.yaml",
+        solver_type=musica.SolverType.rosenbrock_standard_order,
+    )
+    TestSolve(solver)
+
+
+def test_solve_with_mechanism():
+    solver = musica.MICM(
+        mechanism=GetMechanism(),
+        solver_type=musica.SolverType.rosenbrock_standard_order,
+    )
+    TestSolve(solver)
+
+
+def TestSolve(solver):
+    state = solver.create_state()
+
+    time_step = 200.0
+    temperature = 272.5
+    pressure = 101253.3
+
+    rate_constants = {
+        "PHOTO.jO2": 2.42e-17,
+        "PHOTO.jO3->O": 1.15e-5,
+        "PHOTO.jO3->O1D": 6.61e-9
+    }
+
+    initial_concentrations = {
+        "O2": 0.75,
+        "O": 0.0,
+        "O1D": 0.0,
+        "O3": 0.0000081
+    }
+
+    # Test setting int values
+    state.set_conditions(temperatures=272, pressures=101325)
+
+    # Set actual test conditions
+    state.set_conditions(temperatures=temperature, pressures=pressure)
+    state.set_concentrations(initial_concentrations)
+    state.set_user_defined_rate_parameters(rate_constants)
+
+    solver.solve(state, time_step)
+    concentrations = state.get_concentrations()
+
+    assert pytest.approx(concentrations["O2"][0], rel=1e-5) == 0.75
+    assert concentrations["O"][0] > 0.0
+    assert concentrations["O1D"][0] > 0.0
+    assert concentrations["O3"][0] != 0.0000081
+
+
+def GetMechanism():
+    M = mc.Species(tracer_type="THIRD_BODY")
+    O2 = mc.Species(name="O2", tracer_type="CONSTANT")
+    O = mc.Species(name="O", other_properties={
+                   "__absolute_tolerance": "1e-12"})
+    O1D = mc.Species(name="O1D", other_properties={
+                     "__absolute_tolerance": "1e-12"})
+    O3 = mc.Species(
+        name="O3",
+        molecular_weight_kg_mol=0.048,
+        other_properties={
+            "__absolute_tolerance": "1e-12",
+            "__long_name": "ozone",
+            "__atmos": "3",
+            "__do_advect": "True",
+        })
+    gas = mc.Phase(
+        name="gas",
+        species=[O2, O, O1D, O3, M],
+    )
+    jO2 = mc.Photolysis(
+        name="jO2",
+        reactants=[O2],
+        products=[(2, O)],
+    )
+    R2 = mc.Arrhenius(
+        name="R2",
+        A=8.018e-17,
+        reactants=[O, O2],
+        products=[O3],
+    )
+    jO31 = mc.Photolysis(
+        name="jO3->O",
+        reactants=[O3],
+        products=[O, O2],
+    )
+    R4 = mc.Arrhenius(
+        name="R4",
+        A=1.576e-15,
+        reactants=[O, O3],
+        products=[(2, O2)],
+    )
+    jO32 = mc.Photolysis(
+        name="jO3->O1D",
+        reactants=[O3],
+        products=[O1D, O2],
+    )
+    R6 = mc.Arrhenius(
+        name="R6",
+        A=7.11e-11,
+        reactants=[O1D, M],
+        products=[O, M],
+    )
+    R7 = mc.Arrhenius(
+        name="R7",
+        A=1.2e-10,
+        reactants=[O1D, O3],
+        products=[(2, O2)],
+    )
+    return mc.Mechanism(
+        name="Chapman",
+        species=[O2, O, O1D, O3, M],
+        phases=[gas],
+        reactions=[jO2, R2, jO31, R4, jO32, R6, R7],
+    )

musica/test/integration/test_sulfate_box_model.py

@@ -0,0 +1,34 @@
+import pytest
+import musica
+
+available = musica.backend.carma_available()
+pytestmark = pytest.mark.skipif(
+    not available, reason="CARMA backend is not available")
+
+
+def test_sulfate_box_model():
+    """Test the sulfate box model implementation."""
+    from musica.examples import sulfate_box_model
+    concentrations, times, sulfate_data = sulfate_box_model.run_box_model()
+
+    # Basic assertions to verify the simulation ran successfully
+    assert concentrations is not None, "Concentrations should not be None"
+    assert len(concentrations) > 0, "Should have concentration data"
+    assert times is not None, "Times should not be None"
+    assert len(times) > 0, "Should have time data"
+    assert sulfate_data is not None, "CARMA sulfate data should not be None"
+
+    # Check that we have the expected species
+    expected_species = ["HO2", "H2O2", "SO2", "SO3", "H2SO4", "H2O"]
+    for species in expected_species:
+        assert species in concentrations.columns, f"Missing species: {species}"
+
+    # Check that CARMA data has expected structure
+    assert hasattr(sulfate_data, "mass_mixing_ratio"), "CARMA data should have mass_mixing_ratio"
+    assert "time" in sulfate_data.dims, "CARMA data should have time dimension"
+    assert "bin" in sulfate_data.dims, "CARMA data should have bin dimension"
+
+    print(f"✅ Test passed! Simulated {len(times)} time steps over {times[-1]:.2f} hours")
+    print(f"   Chemical species tracked: {list(concentrations.columns)}")
+    print(f"   CARMA bins: {len(sulfate_data.bin)}")
+    print(f"   Vertical levels: {len(sulfate_data.vertical_center)}")

musica/test/integration/test_tuvx.py

@@ -0,0 +1,62 @@
+import pytest
+import musica
+import json
+
+available = musica.backend.tuvx_available()
+pytestmark = pytest.mark.skipif(not available, reason="TUV-x backend is not available")
+
+
+def test_tuvx_version():
+    version = musica.tuvx.version
+    assert version is not None
+    assert isinstance(version, str)
+
+
+def test_full_tuvx(monkeypatch):
+    monkeypatch.chdir("configs/tuvx")
+    file = "tuv_5_4.json"
+    tuvx = musica.TUVX(file)
+    assert tuvx is not None
+
+    heating_rates = tuvx.heating_rate_names
+    photolysis_rates = tuvx.photolysis_rate_names
+    rates = tuvx.run()
+
+    assert len(rates) > 0, "No photolysis rates found"
+    assert len(heating_rates) == 0, "Heating rates should be empty for this config"
+    assert len(photolysis_rates) > 0, "No photolysis rates found"
+
+
+def test_fixed_tuvx(monkeypatch):
+    monkeypatch.chdir("src")
+    file = "test/data/tuvx/fixed/config.json"
+    tuvx = musica.TUVX(file)
+    assert tuvx is not None
+
+    # Access properties multiple times
+    photolysis_names_1 = tuvx.photolysis_rate_names
+    photolysis_names_2 = tuvx.photolysis_rate_names
+    heating_names_1 = tuvx.heating_rate_names
+    heating_names_2 = tuvx.heating_rate_names
+
+    # Verify they return the same object (cached)
+    assert photolysis_names_1 is photolysis_names_2
+    assert heating_names_1 is heating_names_2
+
+    assert len(heating_names_1) > 0, "No heating rates found"
+    assert len(photolysis_names_1) > 0, "No photolysis rates found"
+
+    # these fail to run due to missing solar zenith angle, but that's not required and these should be able to run
+    # rates = tuvx.run()
+    # print(f"Rates: {rates}")
+
+
+def test_tuvx_initialization_errors():
+    """Test error handling during TUVX initialization."""
+    # Test with non-existent file
+    with pytest.raises(FileNotFoundError):
+        musica.TUVX("non_existent_config.json")
+
+
+if __name__ == '__main__':
+    pytest.main([__file__])

musica/test/unit/test_parser.py

@@ -0,0 +1,64 @@
+import pytest
+import musica.mechanism_configuration as mc
+from musica.mechanism_configuration import Parser
+from test_util_full_mechanism import get_fully_defined_mechanism, validate_full_v1_mechanism
+
+
+def test_parsed_full_v1_configuration():
+    parser = Parser()
+    extensions = [".yaml", ".json"]
+    for extension in extensions:
+        path = f"musica/test/examples/v1/full_configuration/full_configuration{extension}"
+        mechanism = parser.parse(path)
+        validate_full_v1_mechanism(mechanism)
+
+
+def test_parser_reports_bad_files():
+    parser = Parser()
+    extensions = [".yaml", ".json"]
+    for extension in extensions:
+        path = f"musica/test/examples/_missing_configuration{extension}"
+        with pytest.raises(Exception):
+            parser.parse(path)
+
+
+def test_hard_coded_full_v1_configuration():
+    MECHANISM_FULLY_DEFINED = get_fully_defined_mechanism()
+    validate_full_v1_mechanism(MECHANISM_FULLY_DEFINED)
+
+
+def test_hard_coded_default_constructed_types():
+    arrhenius = mc.Arrhenius()
+    assert arrhenius.type == mc.ReactionType.Arrhenius
+    condensed_phase_arrhenius = mc.CondensedPhaseArrhenius()
+    assert condensed_phase_arrhenius.type == mc.ReactionType.CondensedPhaseArrhenius
+    condensed_phase_photolysis = mc.CondensedPhasePhotolysis()
+    assert condensed_phase_photolysis.type == mc.ReactionType.CondensedPhasePhotolysis
+    emission = mc.Emission()
+    assert emission.type == mc.ReactionType.Emission
+    first_order_loss = mc.FirstOrderLoss()
+    assert first_order_loss.type == mc.ReactionType.FirstOrderLoss
+    henrys_law = mc.HenrysLaw()
+    assert henrys_law.type == mc.ReactionType.HenrysLaw
+    photolysis = mc.Photolysis()
+    assert photolysis.type == mc.ReactionType.Photolysis
+    simpol_phase_transfer = mc.SimpolPhaseTransfer()
+    assert simpol_phase_transfer.type == mc.ReactionType.SimpolPhaseTransfer
+    surface = mc.Surface()
+    assert surface.type == mc.ReactionType.Surface
+    troe = mc.Troe()
+    assert troe.type == mc.ReactionType.Troe
+    ternary_chemical_activation = mc.TernaryChemicalActivation()
+    assert ternary_chemical_activation.type == mc.ReactionType.TernaryChemicalActivation
+    tunneling = mc.Tunneling()
+    assert tunneling.type == mc.ReactionType.Tunneling
+    wet_deposition = mc.WetDeposition()
+    assert wet_deposition.type == mc.ReactionType.WetDeposition
+    branched = mc.Branched()
+    assert branched.type == mc.ReactionType.Branched
+    user_defined = mc.UserDefined()
+    assert user_defined.type == mc.ReactionType.UserDefined
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

musica/test/unit/test_serializer.py

@@ -0,0 +1,69 @@
+import pytest
+import os
+from musica.mechanism_configuration import MechanismSerializer, Mechanism, Parser
+from test_util_full_mechanism import get_fully_defined_mechanism, validate_full_v1_mechanism
+
+
+def test_mechanism_export_loop(tmp_path):
+    parser = Parser()
+    MECHANISM_FULLY_DEFINED = get_fully_defined_mechanism()
+    extensions = [".yml", ".yaml", ".json"]
+    for extension in extensions:
+        path = f"{tmp_path}/test_mechanism{extension}"
+        MECHANISM_FULLY_DEFINED.export(path)
+        mechanism = parser.parse(path)
+        validate_full_v1_mechanism(mechanism)
+
+
+def test_serialize_parser_loop(tmp_path):
+    parser = Parser()
+    MECHANISM_FULLY_DEFINED = get_fully_defined_mechanism()
+    extensions = [".yml", ".yaml", ".json"]
+    for extension in extensions:
+        path = f"{tmp_path}/test_mechanism{extension}"
+        MechanismSerializer.serialize(MECHANISM_FULLY_DEFINED, path)
+        mechanism = parser.parse(path)
+        validate_full_v1_mechanism(mechanism)
+
+
+def test_serialize_to_file(tmp_path):
+    MECHANISM_FULLY_DEFINED = get_fully_defined_mechanism()
+    extensions = [".yml", ".yaml", ".json"]
+    for extension in extensions:
+        file_path = f'{tmp_path}/test_mechanism{extension}'
+        assert not os.path.exists(file_path)
+        MechanismSerializer.serialize(MECHANISM_FULLY_DEFINED, file_path)
+        assert os.path.exists(file_path)
+
+
+def test_bad_inputs():
+    with pytest.raises(TypeError):
+        MechanismSerializer.serialize(None)
+    with pytest.raises(TypeError):
+        MechanismSerializer.serialize('not a mechanism')
+    with pytest.raises(Exception):
+        MechanismSerializer.serialize(get_fully_defined_mechanism(), 'unsupported.txt')
+
+
+def test_path_creation(tmp_path):
+    mechanism = Mechanism(name="Full Configuration")
+    path = f"{tmp_path}/non_existant_path/"
+    assert not os.path.exists(path)
+    MechanismSerializer.serialize(mechanism, f"{path}test_mechanism.json")
+    assert os.path.exists(path)
+
+
+def test_overwrite_file(tmp_path):
+    mechanism = Mechanism(name="Full Configuration")
+    file_path = f'{tmp_path}/test_mechanism.json'
+    assert not os.path.exists(file_path)
+
+    # write first file
+    MechanismSerializer.serialize(mechanism, file_path)
+    files = list(tmp_path.iterdir())
+    assert len(files) == 1
+
+    # overwrite file
+    MechanismSerializer.serialize(mechanism, file_path)
+    files = list(tmp_path.iterdir())
+    assert len(files) == 1