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

musica/test/test_analytical.py

@@ -1,323 +0,0 @@
-import pytest
-import numpy as np
-import musica
-import random
-import musica.mechanism_configuration as mc
-from _musica._core import _is_cuda_available
-
-
-def TestSingleGridCell(solver, state, time_step, places=5):
-    temperature = 272.5
-    pressure = 101253.3
-    GAS_CONSTANT = 8.31446261815324
-    air_density = pressure / (GAS_CONSTANT * temperature)
-
-    rate_constants = {
-        "USER.reaction 1": 0.001,
-        "USER.reaction 2": 0.002
-    }
-
-    concentrations = {
-        "A": 0.75,
-        "B": 0,
-        "C": 0.4,
-        "D": 0.8,
-        "E": 0,
-        "F": 0.1
-    }
-    state.set_conditions(temperature, pressure, air_density)
-    state.set_concentrations(concentrations)
-    state.set_user_defined_rate_parameters(rate_constants)
-
-    # test to make sure a second call to set_conditions with an empty dictionary does not change the values
-    state.set_concentrations({})
-    state.set_user_defined_rate_parameters({})
-
-    initial_concentrations = state.get_concentrations()
-    initial_rate_parameters = state.get_user_defined_rate_parameters()
-    initial_temperatures = state.get_conditions()["temperature"]
-    initial_pressures = state.get_conditions()["pressure"]
-    initial_air_density = state.get_conditions()["air_density"]
-    assert np.isclose(initial_concentrations["A"][0], concentrations["A"], atol=1e-13)
-    assert np.isclose(initial_concentrations["B"][0], concentrations["B"], atol=1e-13)
-    assert np.isclose(initial_concentrations["C"][0], concentrations["C"], atol=1e-13)
-    assert np.isclose(initial_concentrations["D"][0], concentrations["D"], atol=1e-13)
-    assert np.isclose(initial_concentrations["E"][0], concentrations["E"], atol=1e-13)
-    assert np.isclose(initial_concentrations["F"][0], concentrations["F"], atol=1e-13)
-    assert np.isclose(initial_rate_parameters["USER.reaction 1"][0], rate_constants["USER.reaction 1"], atol=1e-13)
-    assert np.isclose(initial_rate_parameters["USER.reaction 2"][0], rate_constants["USER.reaction 2"], atol=1e-13)
-    assert np.isclose(initial_temperatures[0], temperature, atol=1e-13)
-    assert np.isclose(initial_pressures[0], pressure, atol=1e-13)
-    assert np.isclose(initial_air_density[0], air_density, atol=1e-13)
-
-    time_step = 1
-    sim_length = 100
-
-    curr_time = time_step
-    initial_A = initial_concentrations["A"][0]
-    initial_C = initial_concentrations["C"][0]
-    initial_D = initial_concentrations["D"][0]
-    initial_F = initial_concentrations["F"][0]
-    # Gets analytical concentrations
-    while curr_time <= sim_length:
-        solver.solve(state, time_step)
-        concentrations = state.get_concentrations()
-        k1 = rate_constants["USER.reaction 1"]
-        k2 = rate_constants["USER.reaction 2"]
-        k3 = 0.004 * np.exp(50.0 / temperature)
-        k4 = 0.012 * np.exp(75.0 / temperature) * \
-            (temperature / 50.0)**(-2) * (1.0 + 1.0e-6 * pressure)
-        A_conc = initial_A * np.exp(-(k3) * curr_time)
-        B_conc = initial_A * (k3 / (k4 - k3)) * \
-            (np.exp(-k3 * curr_time) - np.exp(-k4 * curr_time))
-        C_conc = initial_C + initial_A * \
-            (1.0 + (k3 * np.exp(-k4 * curr_time) - k4 * np.exp(-k3 * curr_time)) / (k4 - k3))
-        D_conc = initial_D * np.exp(-(k1) * curr_time)
-        E_conc = initial_D * (k1 / (k2 - k1)) * \
-            (np.exp(-k1 * curr_time) - np.exp(-k2 * curr_time))
-        F_conc = initial_F + initial_D * \
-            (1.0 + (k1 * np.exp(-k2 * curr_time) - k2 * np.exp(-k1 * curr_time)) / (k2 - k1))
-
-        assert np.isclose(concentrations["A"][0], A_conc, atol=10**-places)
-        assert np.isclose(concentrations["B"][0], B_conc, atol=10**-places)
-        assert np.isclose(concentrations["C"][0], C_conc, atol=10**-places)
-        assert np.isclose(concentrations["D"][0], D_conc, atol=10**-places)
-        assert np.isclose(concentrations["E"][0], E_conc, atol=10**-places)
-        assert np.isclose(concentrations["F"][0], F_conc, atol=10**-places)
-
-        curr_time += time_step
-
-
-def TestMultipleGridCell(solver, state, num_grid_cells, time_step, places=5):
-    concentrations = {
-        "A": [],
-        "B": [],
-        "C": [],
-        "D": [],
-        "E": [],
-        "F": []
-    }
-    rate_constants = {
-        "USER.reaction 1": [],
-        "USER.reaction 2": []
-    }
-    temperatures = []
-    pressures = []
-
-    for i in range(num_grid_cells):
-        temperatures.append(275.0 + random.uniform(-50.0, 50.0))
-        pressures.append(101253.3 + random.uniform(-500.0, 500.0))
-        concentrations["A"].append(0.75 + random.uniform(-0.05, 0.05))
-        concentrations["B"].append(0)
-        concentrations["C"].append(0.4 + random.uniform(-0.05, 0.05))
-        concentrations["D"].append(0.8 + random.uniform(-0.05, 0.05))
-        concentrations["E"].append(0)
-        concentrations["F"].append(0.1 + random.uniform(-0.05, 0.05))
-        rate_constants["USER.reaction 1"].append(
-            0.001 + random.uniform(-0.0001, 0.0001))
-        rate_constants["USER.reaction 2"].append(
-            0.002 + random.uniform(-0.0001, 0.0001))
-
-    state.set_conditions(temperatures, pressures)  # Air density should be calculated in the state
-    state.set_concentrations(concentrations)
-    state.set_user_defined_rate_parameters(rate_constants)
-
-    initial_concentrations = state.get_concentrations()
-    initial_rate_parameters = state.get_user_defined_rate_parameters()
-    initial_temperatures = state.get_conditions()["temperature"]
-    initial_pressures = state.get_conditions()["pressure"]
-    initial_air_density = state.get_conditions()["air_density"]
-    for i in range(num_grid_cells):
-        assert np.isclose(initial_concentrations["A"][i], concentrations["A"][i], atol=1e-13)
-        assert np.isclose(initial_concentrations["B"][i], concentrations["B"][i], atol=1e-13)
-        assert np.isclose(initial_concentrations["C"][i], concentrations["C"][i], atol=1e-13)
-        assert np.isclose(initial_concentrations["D"][i], concentrations["D"][i], atol=1e-13)
-        assert np.isclose(initial_concentrations["E"][i], concentrations["E"][i], atol=1e-13)
-        assert np.isclose(initial_concentrations["F"][i], concentrations["F"][i], atol=1e-13)
-        assert np.isclose(
-            initial_rate_parameters["USER.reaction 1"][i],
-            rate_constants["USER.reaction 1"][i],
-            atol=1e-13)
-        assert np.isclose(
-            initial_rate_parameters["USER.reaction 2"][i],
-            rate_constants["USER.reaction 2"][i],
-            atol=1e-13)
-        assert np.isclose(initial_temperatures[i], temperatures[i], atol=1e-13)
-        assert np.isclose(initial_pressures[i], pressures[i], atol=1e-13)
-        assert np.isclose(initial_air_density[i], pressures[i] / (8.31446261815324 * temperatures[i]), atol=1e-13)
-
-    time_step = 1
-    sim_length = 100
-
-    curr_time = time_step
-    initial_A = num_grid_cells * [0.0]
-    initial_C = num_grid_cells * [0.0]
-    initial_D = num_grid_cells * [0.0]
-    initial_F = num_grid_cells * [0.0]
-    for i in range(num_grid_cells):
-        initial_A[i] = initial_concentrations["A"][i]
-        initial_C[i] = initial_concentrations["C"][i]
-        initial_D[i] = initial_concentrations["D"][i]
-        initial_F[i] = initial_concentrations["F"][i]
-
-    k1 = num_grid_cells * [0.0]
-    k2 = num_grid_cells * [0.0]
-    k3 = num_grid_cells * [0.0]
-    k4 = num_grid_cells * [0.0]
-    for i in range(num_grid_cells):
-        k1[i] = rate_constants["USER.reaction 1"][i]
-        k2[i] = rate_constants["USER.reaction 2"][i]
-        k3[i] = 0.004 * np.exp(50.0 / temperatures[i])
-        k4[i] = 0.012 * np.exp(75.0 / temperatures[i]) * \
-            (temperatures[i] / 50.0)**(-2) * (1.0 + 1.0e-6 * pressures[i])
-
-    while curr_time <= sim_length:
-        solver.solve(state, time_step)
-        concentrations = state.get_concentrations()
-
-        for i in range(num_grid_cells):
-            A_conc = initial_A[i] * np.exp(-(k3[i]) * curr_time)
-            B_conc = initial_A[i] * (k3[i] / (k4[i] - k3[i])) * \
-                (np.exp(-k3[i] * curr_time) - np.exp(-k4[i] * curr_time))
-            C_conc = initial_C[i] + initial_A[i] * (1.0 + (
-                k3[i] * np.exp(-k4[i] * curr_time) - k4[i] * np.exp(-k3[i] * curr_time)) / (k4[i] - k3[i]))
-            D_conc = initial_D[i] * np.exp(-(k1[i]) * curr_time)
-            E_conc = initial_D[i] * (k1[i] / (k2[i] - k1[i])) * \
-                (np.exp(-k1[i] * curr_time) - np.exp(-k2[i] * curr_time))
-            F_conc = initial_F[i] + initial_D[i] * (1.0 + (
-                k1[i] * np.exp(-k2[i] * curr_time) - k2[i] * np.exp(-k1[i] * curr_time)) / (k2[i] - k1[i]))
-
-            assert np.isclose(
-                concentrations["A"][i],
-                A_conc,
-                atol=10**-places), f"Grid cell {i} of {num_grid_cells}: A concentration mismatch. Initial A: {initial_concentrations['A'][i]}"
-            assert np.isclose(
-                concentrations["B"][i],
-                B_conc,
-                atol=10**-places), f"Grid cell {i} of {num_grid_cells}: B concentration mismatch. Initial B: {initial_concentrations['B'][i]}"
-            assert np.isclose(
-                concentrations["C"][i],
-                C_conc,
-                atol=10**-places), f"Grid cell {i} of {num_grid_cells}: C concentration mismatch. Initial C: {initial_concentrations['C'][i]}"
-            assert np.isclose(
-                concentrations["D"][i],
-                D_conc,
-                atol=10**-places), f"Grid cell {i} of {num_grid_cells}: D concentration mismatch. Initial D: {initial_concentrations['D'][i]}"
-            assert np.isclose(
-                concentrations["E"][i],
-                E_conc,
-                atol=10**-places), f"Grid cell {i} of {num_grid_cells}: E concentration mismatch. Initial E: {initial_concentrations['E'][i]}"
-            assert np.isclose(
-                concentrations["F"][i],
-                F_conc,
-                atol=10**-places), f"Grid cell {i} of {num_grid_cells}: F concentration mismatch. Initial F: {initial_concentrations['F'][i]}"
-
-        curr_time += time_step
-
-
-def GetMechanism():
-    A = mc.Species(name="A")
-    B = mc.Species(name="B")
-    C = mc.Species(name="C")
-    D = mc.Species(name="D")
-    E = mc.Species(name="E")
-    F = mc.Species(name="F")
-    gas = mc.Phase(name="gas", species=[A, B, C, D, E, F])
-    arr1 = mc.Arrhenius(name="A->B", A=0.004, C=50,
-                        gas_phase=gas, reactants=[A], products=[B])
-    arr2 = mc.Arrhenius(name="B->C", A=0.012, B=-2, C=75, D=50, E=1.0e-6,
-                        gas_phase=gas, reactants=[B], products=[C])
-    user1 = mc.UserDefined(name="reaction 1", gas_phase=gas,
-                           reactants=[D], products=[E])
-    user2 = mc.UserDefined(name="reaction 2", gas_phase=gas,
-                           reactants=[E], products=[F])
-    mechanism = mc.Mechanism(
-        name="analytical test",
-        species=[A, B, C, D, E, F],
-        phases=[gas],
-        reactions=[arr1, arr2, user1, user2],
-    )
-    return mechanism
-
-
-def test_single_grid_cell_standard_rosenbrock():
-    solver = musica.MICM(
-        config_path="configs/analytical",
-        solver_type=musica.SolverType.rosenbrock_standard_order)
-    state = solver.create_state()
-    TestSingleGridCell(solver, state, 200.0, 5)
-
-
-def test_multiple_grid_cells_standard_rosenbrock():
-    for i in range(1, 11):
-        solver = musica.MICM(
-            config_path="configs/analytical",
-            solver_type=musica.SolverType.rosenbrock_standard_order)
-        state = solver.create_state(i)
-        TestMultipleGridCell(solver, state, i, 200.0, 5)
-
-
-def test_cuda_rosenbrock():
-    if _is_cuda_available():
-        solver = musica.MICM(
-            config_path="configs/analytical",
-            solver_type=musica.SolverType.cuda_rosenbrock)
-        state = solver.create_state()
-        TestSingleGridCell(solver, state, 200.0, 5)
-    else:
-        pytest.skip("CUDA is not available.")
-
-
-def test_single_grid_cell_backward_euler():
-    solver = musica.MICM(
-        config_path="configs/analytical",
-        solver_type=musica.SolverType.backward_euler_standard_order)
-    state = solver.create_state()
-    TestSingleGridCell(solver, state, 10.0, places=2)
-
-
-def test_multiple_grid_cells_backward_euler():
-    for i in range(1, 11):
-        solver = musica.MICM(
-            config_path="configs/analytical",
-            solver_type=musica.SolverType.backward_euler_standard_order)
-        state = solver.create_state(i)
-        TestMultipleGridCell(solver, state, i, 10.0, places=2)
-
-
-def test_single_grid_cell_rosenbrock():
-    solver = musica.MICM(
-        config_path="configs/analytical",
-        solver_type=musica.SolverType.rosenbrock)
-    state = solver.create_state()
-    TestSingleGridCell(solver, state, 200.0, 5)
-
-
-def test_multiple_grid_cells_rosenbrock():
-    for i in range(1, 11):
-        solver = musica.MICM(
-            config_path="configs/analytical",
-            solver_type=musica.SolverType.rosenbrock)
-        state = solver.create_state(i)
-        TestMultipleGridCell(solver, state, i, 200.0, 5)
-
-
-def test_single_grid_cell_backward_euler_standard_order():
-    solver = musica.MICM(
-        config_path="configs/analytical",
-        solver_type=musica.SolverType.backward_euler_standard_order)
-    state = solver.create_state()
-    TestSingleGridCell(solver, state, 10.0, places=2)
-
-
-def test_multiple_grid_cells_backward_euler_standard_order():
-    for i in range(1, 11):
-        solver = musica.MICM(
-            config_path="configs/analytical",
-            solver_type=musica.SolverType.backward_euler_standard_order)
-        state = solver.create_state(i)
-        TestMultipleGridCell(solver, state, i, 10.0, places=2)
-
-
-if __name__ == '__main__':
-    pytest.main()

musica/test/test_chapman.py

@@ -1,123 +0,0 @@
-import pytest
-import musica
-import musica.mechanism_configuration as mc
-
-
-def test_solve_with_config_path():
-    solver = musica.MICM(
-        config_path="configs/chapman",
-        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],
-    )