musica 0.12.2__cp39-cp39-win_arm64.whl → 0.13.0__cp39-cp39-win_arm64.whl

musica/test/unit/test_serializer.py

@@ -1,55 +1,52 @@
 import pytest
 import os
-from musica.mechanism_configuration import MechanismSerializer, Mechanism, Parser
+from musica.mechanism_configuration import 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()
+    mechanism = 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.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"]
+    mechanism = get_fully_defined_mechanism()
+    extensions = [".json", ".yml", ".yaml"]
     for extension in extensions:
         path = f"{tmp_path}/test_mechanism{extension}"
-        MechanismSerializer.serialize(MECHANISM_FULLY_DEFINED, path)
+        mechanism.export(path)
         mechanism = parser.parse(path)
         validate_full_v1_mechanism(mechanism)
 
 
 def test_serialize_to_file(tmp_path):
-    MECHANISM_FULLY_DEFINED = get_fully_defined_mechanism()
+    mechanism = 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)
+        mechanism.export(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')
+    mechanism = Mechanism(name="Full Configuration")
     with pytest.raises(Exception):
-        MechanismSerializer.serialize(get_fully_defined_mechanism(), 'unsupported.txt')
+        mechanism.export("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")
+    mechanism.export(f"{path}test_mechanism.json")
     assert os.path.exists(path)
 
 
@@ -59,11 +56,15 @@ def test_overwrite_file(tmp_path):
     assert not os.path.exists(file_path)
 
     # write first file
-    MechanismSerializer.serialize(mechanism, file_path)
+    mechanism.export(file_path)
     files = list(tmp_path.iterdir())
     assert len(files) == 1
 
     # overwrite file
-    MechanismSerializer.serialize(mechanism, file_path)
+    mechanism.export(file_path)
     files = list(tmp_path.iterdir())
     assert len(files) == 1
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

musica/test/unit/test_state.py

@@ -12,8 +12,7 @@ def create_test_mechanism() -> Mechanism:
     # Chemical species
     A = mc.Species(
         name="A",
-        diffusion_coefficient_m2_s=20.3,
-        molecular_weight_kg_mol=13.2,
+        molecular_weight_kg_mol=32.1,
         other_properties={
             "__absolute tolerance": "1.0e-30"})
     B = mc.Species(name="B")
@@ -21,7 +20,7 @@ def create_test_mechanism() -> Mechanism:
     M = mc.Species(name="M", is_third_body=True)
 
     # Chemical phases
-    gas = mc.Phase(name="gas", species=[A, B, C, M])
+    gas = mc.Phase(name="gas", species=[mc.PhaseSpecies(name=A.name, diffusion_coefficient_m2_s=1.0), B, C, M])
 
     # Reactions
     my_arrhenius = mc.Arrhenius(
@@ -146,7 +145,8 @@ def create_test_mechanism() -> Mechanism:
         species=[A, B, C, M],
         phases=[gas],
         reactions=[my_arrhenius, my_other_arrhenius, my_troe, my_ternary,
-                   my_branched, my_tunneling, my_surface, photo_b,
+                   my_branched, my_tunneling,
+                   my_surface, photo_b,
                    my_emission, my_first_order_loss, user_defined],
         version=mc.Version(1, 0, 0),
     )
@@ -259,6 +259,15 @@ def test_set_get_user_defined_rate_parameters():
     result = state.get_user_defined_rate_parameters()
     assert result["EMIS.my emission"][0] == 1.0
 
+    params = {
+        "SURF.my surface.effective radius [m]": 0.5,
+        "SURF.my surface.particle number concentration [# m-3]": 1000.0,
+    }
+    state.set_user_defined_rate_parameters(params)
+    result = state.get_user_defined_rate_parameters()
+    assert result["SURF.my surface.effective radius [m]"][0] == 0.5
+    assert result["SURF.my surface.particle number concentration [# m-3]"][0] == 1000.0
+
     # Test multiple grid cells
     state_multi = solver.create_state(number_of_grid_cells=2)
     params_multi = {"PHOTO.photo B": [1.0, 2.0]}
@@ -323,3 +332,7 @@ def test_set_get_user_defined_rate_parameters():
         "USER.my user defined"
     ]
     assert sorted(expected_params) == sorted(param_names)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

musica/test/unit/test_util_full_mechanism.py

@@ -1,71 +1,35 @@
 import musica.mechanism_configuration as mc
 
 
-def get_fully_defined_mechanism():
+def get_fully_defined_mechanism() -> mc.Mechanism:
     # Chemical species
-    A = mc.Species(name="A", other_properties={"__absolute tolerance": "1.0e-30"})
-    B = mc.Species(name="B", tracer_type="AEROSOL")
-    C = mc.Species(name="C", tracer_type="THIRD_BODY")
-    M = mc.Species(name="M")
+    A = mc.Species(name="A", molecular_weight_kg_mol=0.02897, other_properties={"__absolute tolerance": "1.0e-30"})
+    B = mc.Species(name="B", constant_concentration_mol_m3=1e19)
+    C = mc.Species(name="C", constant_mixing_ratio_mol_mol=1e-20)
+    M = mc.Species(name="M", is_third_body=True)
     H2O2 = mc.Species(
         name="H2O2",
-        HLC_298K_mol_m3_Pa=1.011596348,
-        HLC_exponential_factor_K=6340,
-        diffusion_coefficient_m2_s=1.46e-05,
-        N_star=1.74,
         molecular_weight_kg_mol=0.0340147,
-        density_kg_m3=1000.0,
         other_properties={"__absolute tolerance": "1.0e-10"},
     )
     ethanol = mc.Species(
         name="ethanol",
-        diffusion_coefficient_m2_s=0.95e-05,
-        N_star=2.55,
         molecular_weight_kg_mol=0.04607,
         other_properties={"__absolute tolerance": "1.0e-20"},
     )
-    ethanol_aq = mc.Species(
-        name="ethanol_aq",
-        molecular_weight_kg_mol=0.04607,
-        density_kg_m3=1000.0,
-        other_properties={"__absolute tolerance": "1.0e-20"},
-    )
-    H2O2_aq = mc.Species(
-        name="H2O2_aq",
-        molecular_weight_kg_mol=0.0340147,
-        density_kg_m3=1000.0,
-        other_properties={"__absolute tolerance": "1.0e-10"},
-    )
-    H2O_aq = mc.Species(
-        name="H2O_aq",
-        density_kg_m3=1000.0,
-        molecular_weight_kg_mol=0.01801,
-    )
-    aerosol_stuff = mc.Species(
-        name="aerosol stuff",
-        molecular_weight_kg_mol=0.5,
-        density_kg_m3=1000.0,
-        other_properties={"__absolute tolerance": "1.0e-20"},
-    )
-    more_aerosol_stuff = mc.Species(
-        name="more aerosol stuff",
-        molecular_weight_kg_mol=0.2,
-        density_kg_m3=1000.0,
-        other_properties={"__absolute tolerance": "1.0e-20"},
-    )
 
     # Chemical phases
-    gas = mc.Phase(name="gas", species=[A, B, C, ethanol])
-    aqueous_aerosol = mc.Phase(
-        name="aqueous aerosol",
-        species=[H2O2_aq, H2O_aq, ethanol_aq, A, B, C],
-        other_properties={"__irrelevant": "2"},
-    )
-    surface_reacting_phase = mc.Phase(
-        name="surface reacting phase",
-        species=[aerosol_stuff, more_aerosol_stuff]
-    )
-    cloud = mc.Phase(name="cloud", species=[B, C])
+    gas = mc.Phase(
+        name="gas",
+        species=[
+            mc.PhaseSpecies(
+                name=A.name,
+                diffusion_coefficient_m2_s=1.0),
+            B,
+            C,
+            ethanol,
+            H2O2,
+            M])
 
     # Reactions
     my_arrhenius = mc.Arrhenius(
@@ -85,31 +49,6 @@ def get_fully_defined_mechanism():
         products=[(1.2, B)]
     )
 
-    my_condensed_arrhenius = mc.CondensedPhaseArrhenius(
-        name="my condensed arrhenius",
-        condensed_phase=aqueous_aerosol,
-        A=123.45,
-        B=1.3,
-        Ea=123.45,
-        D=300.0,
-        E=0.6e-5,
-        reactants=[H2O2_aq, H2O_aq],
-        products=[ethanol_aq],
-        other_properties={"__irrelevant": "2"},
-    )
-
-    my_other_condensed_arrhenius = mc.CondensedPhaseArrhenius(
-        name="my other condensed arrhenius",
-        condensed_phase=aqueous_aerosol,
-        A=123.45,
-        B=1.3,
-        C=123.45,
-        D=300.0,
-        E=0.6e-5,
-        reactants=[H2O2_aq, H2O_aq],
-        products=[ethanol_aq]
-    )
-
     my_troe = mc.Troe(
         name="my troe",
         gas_phase=gas,
@@ -172,7 +111,6 @@ def get_fully_defined_mechanism():
         gas_phase_species=A,
         reaction_probability=2.0e-2,
         gas_phase_products=[B, C],
-        condensed_phase=surface_reacting_phase,
         other_properties={"__irrelevant": "2"},
     )
 
@@ -185,15 +123,6 @@ def get_fully_defined_mechanism():
         other_properties={"__irrelevant": "2"},
     )
 
-    condensed_photo_B = mc.CondensedPhasePhotolysis(
-        name="condensed photo B",
-        condensed_phase=aqueous_aerosol,
-        reactants=[H2O2_aq],
-        products=[ethanol_aq],
-        scaling_factor=12.3,
-        other_properties={"__irrelevant": "2"},
-    )
-
     my_emission = mc.Emission(
         name="my emission",
         gas_phase=gas,
@@ -210,35 +139,6 @@ def get_fully_defined_mechanism():
         other_properties={"__irrelevant": "2"},
     )
 
-    my_aqueous_equilibrium = mc.AqueousEquilibrium(
-        name="my aqueous eq",
-        condensed_phase=aqueous_aerosol,
-        condensed_phase_water=H2O_aq,
-        A=1.14e-2,
-        C=2300.0,
-        k_reverse=0.32,
-        reactants=[(2, A)],
-        products=[B, C],
-        other_properties={"__irrelevant": "2"},
-    )
-
-    my_wet_deposition = mc.WetDeposition(
-        name="rxn cloud",
-        condensed_phase=cloud,
-        scaling_factor=12.3,
-        other_properties={"__irrelevant": "2"},
-    )
-
-    my_simpol_phase_transfer = mc.SimpolPhaseTransfer(
-        name="my simpol",
-        gas_phase=gas,
-        gas_phase_species=ethanol,
-        condensed_phase=aqueous_aerosol,
-        condensed_phase_species=ethanol_aq,
-        B=[-1.97e03, 2.91e00, 1.96e-03, -4.96e-01],
-        other_properties={"__irrelevant": "2"},
-    )
-
     user_defined = mc.UserDefined(
         name="my user defined",
         gas_phase=gas,
@@ -248,18 +148,29 @@ def get_fully_defined_mechanism():
         other_properties={"__irrelevant": "2"}
     )
 
+    taylor_series_reaction = mc.TaylorSeries(
+        name="my taylor series",
+        gas_phase=gas,
+        A=12.3,
+        B=-1.5,
+        C=1.0e-6,
+        D=340,
+        E=0.00032,
+        reactants=[B],
+        products=[C],
+        other_properties={"__irrelevant": "2"}
+    )
+
     # Mechanism
     return mc.Mechanism(
         name="Full Configuration",
-        species=[A, B, C, M, H2O2, ethanol, ethanol_aq, H2O2_aq, H2O_aq,
-                 aerosol_stuff, more_aerosol_stuff],
-        phases=[gas, aqueous_aerosol, surface_reacting_phase, cloud],
-        reactions=[my_arrhenius, my_other_arrhenius, my_condensed_arrhenius,
-                   my_other_condensed_arrhenius, my_troe, my_ternary, my_branched,
-                   my_tunneling, my_surface, photo_B, condensed_photo_B,
-                   my_emission, my_first_order_loss, my_aqueous_equilibrium,
-                   my_wet_deposition, my_simpol_phase_transfer,
-                   user_defined],
+        species=[A, B, C, M, H2O2, ethanol],
+        phases=[gas],
+        reactions=[my_arrhenius, my_other_arrhenius, my_troe, my_ternary, my_branched,
+                   my_tunneling, my_surface, photo_B,
+                   my_emission, my_first_order_loss, user_defined,
+                   taylor_series_reaction
+                   ],
         version=mc.Version(1, 0, 0),
     )
 
@@ -267,49 +178,25 @@ def get_fully_defined_mechanism():
 def _validate_species(species):
     # Define the expected species and their required attributes
     expected_species = {
-        "A": {"other_properties": {"__absolute tolerance": "1e-30"}},
-        "B": {"tracer_type": "AEROSOL"},
-        "C": {"tracer_type": "THIRD_BODY"},
-        "M": {},
-        "H2O2": {
-            "HLC_298K_mol_m3_Pa": 1.011596348,
-            "HLC_exponential_factor_K": 6340,
-            "diffusion_coefficient_m2_s": 1.46e-05,
-            "N_star": 1.74,
-            "molecular_weight_kg_mol": 0.0340147,
-            "density_kg_m3": 1000.0,
-            "other_properties": {"__absolute tolerance": "1e-10"},
+        "A": {
+            "molecular_weight_kg_mol": 0.02897,
+            "other_properties": {"__absolute tolerance": "1e-30"}
         },
-        "ethanol": {
-            "diffusion_coefficient_m2_s": 0.95e-05,
-            "N_star": 2.55,
-            "molecular_weight_kg_mol": 0.04607,
-            "other_properties": {"__absolute tolerance": "1e-20"},
+        "B": {
+            "constant_concentration_mol_m3": 1e19,
         },
-        "ethanol_aq": {
-            "molecular_weight_kg_mol": 0.04607,
-            "density_kg_m3": 1000.0,
-            "other_properties": {"__absolute tolerance": "1e-20"},
+        "C": {
+            "constant_mixing_ratio_mol_mol": 1e-20,
         },
-        "H2O2_aq": {
+        "M": {"is_third_body": True},
+        "H2O2": {
             "molecular_weight_kg_mol": 0.0340147,
-            "density_kg_m3": 1000.0,
             "other_properties": {"__absolute tolerance": "1e-10"},
         },
-        "H2O_aq": {
-            "density_kg_m3": 1000.0,
-            "molecular_weight_kg_mol": 0.01801,
-        },
-        "aerosol stuff": {
-            "molecular_weight_kg_mol": 0.5,
-            "density_kg_m3": 1000.0,
-            "other_properties": {"__absolute tolerance": "1e-20"},
-        },
-        "more aerosol stuff": {
-            "molecular_weight_kg_mol": 0.2,
-            "density_kg_m3": 1000.0,
+        "ethanol": {
+            "molecular_weight_kg_mol": 0.04607,
             "other_properties": {"__absolute tolerance": "1e-20"},
-        },
+        }
     }
 
     # Create a dictionary for quick lookup of species by name
@@ -341,28 +228,14 @@ def _validate_species(species):
 
 
 def _validate_phases(phases):
-    # Define the expected phases and their associated species
-    expected_phases = {
-        "gas": ["A", "B", "C", "ethanol"],
-        "aqueous aerosol": ["H2O2_aq", "H2O_aq", "ethanol_aq", "A", "B", "C"],
-        "surface reacting phase": ["aerosol stuff", "more aerosol stuff"],
-        "cloud": ["B", "C"],
-    }
-
-    # Create a dictionary for quick lookup of phases by name
-    phases_dict = {phase.name: phase for phase in phases}
-
-    # Validate each expected phase
-    for name, expected_species in expected_phases.items():
-        assert name in phases_dict, f"Phase '{name}' is missing."
-        assert hasattr(
-            phases_dict[name], "species"
-        ), f"Phase '{name}' does not have a 'species' attribute."
-        phase_species = getattr(phases_dict[name], "species")
-        assert set(phase_species) == set(expected_species), (
-            f"Phase '{name}' has species {phase_species}, "
-            f"expected {expected_species}."
-        )
+    assert len(phases) == 1
+    assert phases[0].name == "gas"
+    assert phases[0].species[0].name == "A"
+    assert phases[0].species[0].diffusion_coefficient_m2_s == 1.0
+    assert phases[0].species[1].name == "B"
+    assert phases[0].species[2].name == "C"
+    assert phases[0].species[3].name == "ethanol"
+    assert phases[0].species[4].name == "H2O2"
 
 
 def _extract_components(components):
@@ -403,75 +276,6 @@ def _validate_arrhenius(reactions):
     assert reactions[1].other_properties == {}
 
 
-def _validate_simpol_phase_transfer(reactions):
-    assert reactions[0].type == mc.ReactionType.SimpolPhaseTransfer
-    assert reactions[0].gas_phase == "gas"
-    assert _extract_components([reactions[0].gas_phase_species]) == [
-        {"species name": "ethanol", "coefficient": 1}
-    ]
-    assert reactions[0].condensed_phase == "aqueous aerosol"
-    assert _extract_components([reactions[0].condensed_phase_species]) == [
-        {"species name": "ethanol_aq", "coefficient": 1}
-    ]
-    assert reactions[0].B == [-1.97e03, 2.91e00, 1.96e-03, -4.96e-01]
-    assert reactions[0].name == "my simpol"
-    assert reactions[0].other_properties == {"__irrelevant": "2"}
-
-
-def _validate_aqueous_equilibrium(reactions):
-    assert reactions[0].type == mc.ReactionType.AqueousEquilibrium
-    assert reactions[0].condensed_phase == "aqueous aerosol"
-    assert reactions[0].condensed_phase_water == "H2O_aq"
-    assert reactions[0].A == 1.14e-2
-    assert reactions[0].C == 2300.0
-    assert reactions[0].k_reverse == 0.32
-    assert _extract_components(reactions[0].reactants) == [
-        {"species name": "A", "coefficient": 2}
-    ]
-    assert _extract_components(reactions[0].products) == [
-        {"species name": "B", "coefficient": 1},
-        {"species name": "C", "coefficient": 1},
-    ]
-    assert reactions[0].name == "my aqueous eq"
-    assert reactions[0].other_properties == {"__irrelevant": "2"}
-
-
-def _validate_condensed_phase_arrhenius(reactions):
-    for reaction in reactions:
-        assert reaction.type == mc.ReactionType.CondensedPhaseArrhenius
-        assert reaction.condensed_phase == "aqueous aerosol"
-        assert reaction.A == 123.45
-        assert reaction.B == 1.3
-        assert reaction.D == 300.0
-        assert reaction.E == 0.6e-5
-        assert _extract_components(reaction.reactants) == [
-            {"species name": "H2O2_aq", "coefficient": 1},
-            {"species name": "H2O_aq", "coefficient": 1},
-        ]
-        assert _extract_components(reaction.products) == [
-            {"species name": "ethanol_aq", "coefficient": 1}
-        ]
-    assert reactions[0].name == "my condensed arrhenius"
-    assert reactions[0].C == -123.45 / 1.380649e-23
-    assert reactions[0].other_properties == {"__irrelevant": "2"}
-    assert reactions[1].name == "my other condensed arrhenius"
-    assert reactions[1].C == 123.45
-
-
-def _validate_condensed_phase_photolysis(reactions):
-    assert reactions[0].type == mc.ReactionType.CondensedPhasePhotolysis
-    assert reactions[0].condensed_phase == "aqueous aerosol"
-    assert _extract_components(reactions[0].reactants) == [
-        {"species name": "H2O2_aq", "coefficient": 1}
-    ]
-    assert _extract_components(reactions[0].products) == [
-        {"species name": "ethanol_aq", "coefficient": 1}
-    ]
-    assert reactions[0].scaling_factor == 12.3
-    assert reactions[0].name == "condensed photo B"
-    assert reactions[0].other_properties == {"__irrelevant": "2"}
-
-
 def _validate_emission(reactions):
     assert reactions[0].type == mc.ReactionType.Emission
     assert reactions[0].gas_phase == "gas"
@@ -519,7 +323,6 @@ def _validate_surface(reactions):
         {"species name": "B", "coefficient": 1},
         {"species name": "C", "coefficient": 1},
     ]
-    assert reactions[0].condensed_phase == "surface reacting phase"
     assert reactions[0].name == "my surface"
     assert reactions[0].other_properties == {"__irrelevant": "2"}
 
@@ -568,28 +371,6 @@ def _validate_ternary_chemical_activation(reactions):
     assert reactions[0].other_properties == {"__irrelevant": "2"}
 
 
-def _validate_ternary_chemical_activation(reactions):
-    assert reactions[0].type == mc.ReactionType.TernaryChemicalActivation
-    assert reactions[0].gas_phase == "gas"
-    assert _extract_components(reactions[0].reactants) == [
-        {"species name": "B", "coefficient": 1},
-        {"species name": "M", "coefficient": 1},
-    ]
-    assert _extract_components(reactions[0].products) == [
-        {"species name": "C", "coefficient": 1}
-    ]
-    assert reactions[0].k0_A == 32.1
-    assert reactions[0].k0_B == -2.3
-    assert reactions[0].k0_C == 102.3
-    assert reactions[0].kinf_A == 63.4
-    assert reactions[0].kinf_B == -1.3
-    assert reactions[0].kinf_C == 908.5
-    assert reactions[0].Fc == 1.3
-    assert reactions[0].N == 32.1
-    assert reactions[0].name == "my ternary chemical activation"
-    assert reactions[0].other_properties == {"__irrelevant": "2"}
-
-
 def _validate_branched_no_ro2(reactions):
     assert reactions[0].type == mc.ReactionType.Branched
     assert reactions[0].gas_phase == "gas"
@@ -626,14 +407,6 @@ def _validate_tunneling(reactions):
     assert reactions[0].other_properties == {"__irrelevant": "2"}
 
 
-def _validate_wet_deposition(reactions):
-    assert reactions[0].type == mc.ReactionType.WetDeposition
-    assert reactions[0].name == "rxn cloud"
-    assert reactions[0].condensed_phase == "cloud"
-    assert reactions[0].scaling_factor == 12.3
-    assert reactions[0].other_properties == {"__irrelevant": "2"}
-
-
 def _validate_user_defined(reactions):
     assert reactions[0].type == mc.ReactionType.UserDefined
     assert reactions[0].gas_phase == "gas"
@@ -650,33 +423,40 @@ def _validate_user_defined(reactions):
     assert reactions[0].other_properties == {"__irrelevant": "2"}
 
 
+def _validate_taylor_series(reactions):
+    assert reactions[0].type == mc.ReactionType.TaylorSeries
+    assert reactions[0].gas_phase == "gas"
+    assert _extract_components(reactions[0].reactants) == [
+        {"species name": "B", "coefficient": 1}
+    ]
+    assert _extract_components(reactions[0].products) == [
+        {"species name": "C", "coefficient": 1}
+    ]
+    assert reactions[0].A == 12.3
+    assert reactions[0].B == -1.5
+    assert reactions[0].C == 1.0e-6
+    assert reactions[0].D == 340
+    assert reactions[0].E == 0.00032
+    assert reactions[0].name == "my taylor series"
+
+
 def validate_full_v1_mechanism(mechanism):
     assert mechanism is not None
     assert mechanism.name == "Full Configuration"
-    assert len(mechanism.species) == 11
+    assert len(mechanism.species) == 6
     _validate_species(mechanism.species)
-    assert len(mechanism.phases) == 4
+    assert len(mechanism.phases) == 1
     _validate_phases(mechanism.phases)
-    assert len(mechanism.reactions.aqueous_equilibrium) == 1
-    _validate_aqueous_equilibrium(mechanism.reactions.aqueous_equilibrium)
     assert len(mechanism.reactions.arrhenius) == 2
     _validate_arrhenius(mechanism.reactions.arrhenius)
     assert len(mechanism.reactions.branched) == 1
     _validate_branched_no_ro2(mechanism.reactions.branched)
-    assert len(mechanism.reactions.condensed_phase_arrhenius) == 2
-    _validate_condensed_phase_arrhenius(mechanism.reactions.condensed_phase_arrhenius)
-    assert len(mechanism.reactions.condensed_phase_photolysis) == 1
-    _validate_condensed_phase_photolysis(
-        mechanism.reactions.condensed_phase_photolysis
-    )
     assert len(mechanism.reactions.emission) == 1
     _validate_emission(mechanism.reactions.emission)
     assert len(mechanism.reactions.first_order_loss) == 1
     _validate_first_order_loss(mechanism.reactions.first_order_loss)
     assert len(mechanism.reactions.photolysis) == 1
     _validate_photolysis(mechanism.reactions.photolysis)
-    assert len(mechanism.reactions.simpol_phase_transfer) == 1
-    _validate_simpol_phase_transfer(mechanism.reactions.simpol_phase_transfer)
     assert len(mechanism.reactions.surface) == 1
     _validate_surface(mechanism.reactions.surface)
     assert len(mechanism.reactions.troe) == 1
@@ -685,14 +465,14 @@ def validate_full_v1_mechanism(mechanism):
     _validate_ternary_chemical_activation(mechanism.reactions.ternary_chemical_activation)
     assert len(mechanism.reactions.tunneling) == 1
     _validate_tunneling(mechanism.reactions.tunneling)
-    assert len(mechanism.reactions.wet_deposition) == 1
-    _validate_wet_deposition(mechanism.reactions.wet_deposition)
     assert len(mechanism.reactions.user_defined) == 1
     _validate_user_defined(mechanism.reactions.user_defined)
+    assert len(mechanism.reactions.taylor_series) == 1
+    _validate_taylor_series(mechanism.reactions.taylor_series)
     assert mechanism.version.major == 1
     assert mechanism.version.minor == 0
     assert mechanism.version.patch == 0
-    assert len(mechanism.reactions) == 16
+    assert len(mechanism.reactions) == 12
     for reaction in mechanism.reactions:
         assert reaction is not None
         assert isinstance(reaction.type, mc.ReactionType)