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

musica/test/unit/test_grid.py

@@ -0,0 +1,137 @@
+"""Tests for the Grid class."""
+from __future__ import annotations
+import pytest  # type: ignore
+import numpy as np  # type: ignore
+from musica.grid import Grid, backend
+
+# Skip all tests if TUV-x is not available
+pytestmark = pytest.mark.skipif(not backend.tuvx_available(),
+                                reason="TUV-x backend is not available")
+
+
+def test_grid_initialization():
+    """Test Grid initialization with various input combinations."""
+    # Test with num_sections
+    grid = Grid(name="test", units="m", num_sections=5)
+    assert grid.name == "test"
+    assert grid.units == "m"
+    assert grid.num_sections == 5
+
+    # Test with edges
+    edges = np.array([0, 1, 2, 3, 4, 5])
+    grid = Grid(name="test", units="m", edges=edges)
+    assert grid.name == "test"
+    assert grid.units == "m"
+    assert grid.num_sections == 5
+    np.testing.assert_array_equal(grid.edges, edges)
+
+    # Test with midpoints
+    midpoints = np.array([0.5, 1.5, 2.5, 3.5, 4.5])
+    grid = Grid(name="test", units="m", midpoints=midpoints)
+    assert grid.name == "test"
+    assert grid.units == "m"
+    assert grid.num_sections == 5
+    np.testing.assert_array_equal(grid.midpoints, midpoints)
+
+    # Test with both edges and midpoints
+    grid = Grid(name="test", units="m", edges=edges, midpoints=midpoints)
+    assert grid.name == "test"
+    assert grid.units == "m"
+    assert grid.num_sections == 5
+    np.testing.assert_array_equal(grid.edges, edges)
+    np.testing.assert_array_equal(grid.midpoints, midpoints)
+
+    # Test invalid initialization
+    with pytest.raises(ValueError, match="At least one of num_sections, edges, or midpoints must be provided"):
+        Grid(name="test", units="m")
+
+
+def test_grid_properties():
+    """Test Grid property getters and setters."""
+    grid = Grid(name="test", units="m", num_sections=5)
+
+    # Test edges
+    edges = np.array([0, 1, 2, 3, 4, 5])
+    grid.edges = edges
+    np.testing.assert_array_equal(grid.edges, edges)
+
+    # Test midpoints
+    midpoints = np.array([0.5, 1.5, 2.5, 3.5, 4.5])
+    grid.midpoints = midpoints
+    np.testing.assert_array_equal(grid.midpoints, midpoints)
+
+    # Test invalid edges size
+    with pytest.raises(ValueError, match="Array size must be num_sections \\+ 1"):
+        grid.edges = np.array([0, 1, 2])
+
+    # Test invalid midpoints size
+    with pytest.raises(ValueError, match="Array size must be num_sections"):
+        grid.midpoints = np.array([0.5, 1.5, 2.5])
+
+
+def test_grid_string_methods():
+    """Test string representations of Grid."""
+    grid = Grid(name="test", units="m", num_sections=5)
+    edges = np.array([0, 1, 2, 3, 4, 5])
+    grid.edges = edges
+
+    # Test str()
+    expected_str = "Grid(name=test, units=m, num_sections=5)"
+    assert str(grid) == expected_str
+
+    # Test repr()
+    assert repr(grid).startswith("Grid(name=test, units=m, num_sections=5")
+    assert "edges=" in repr(grid)
+    assert "midpoints=" in repr(grid)
+
+
+def test_grid_comparison():
+    """Test Grid comparison methods."""
+    grid1 = Grid(name="test", units="m", num_sections=5)
+    grid1.edges = np.array([0, 1, 2, 3, 4, 5])
+
+    # Test equal grids
+    grid2 = Grid(name="test", units="m", num_sections=5)
+    grid2.edges = np.array([0, 1, 2, 3, 4, 5])
+    assert grid1 == grid2
+
+    # Test unequal grids
+    grid3 = Grid(name="test", units="m", num_sections=6)
+    grid3.edges = np.array([0, 1, 2, 3, 4, 5, 6])
+    assert grid1 != grid3
+
+    grid4 = Grid(name="test", units="m", num_sections=5)
+    grid4.edges = np.array([0, 2, 4, 6, 8, 10])
+    assert grid1 != grid4
+
+    grid5 = Grid(name="different", units="m", num_sections=5)
+    grid5.edges = np.array([0, 1, 2, 3, 4, 5])
+    assert grid1 != grid5
+
+    grid6 = Grid(name="test", units="cm", num_sections=5)
+    grid6.edges = np.array([0, 1, 2, 3, 4, 5])
+    assert grid1 != grid6
+
+
+def test_grid_container_methods():
+    """Test Grid container methods (len, contains)."""
+    grid = Grid(name="test", units="m", num_sections=5)
+    edges = np.array([0, 1, 2, 3, 4, 5])
+    grid.edges = edges
+
+    # Test len()
+    assert len(grid) == 5
+
+    # Test contains
+    assert 2.5 in grid
+    assert -1 not in grid
+    assert 6 not in grid
+
+
+def test_grid_bool():
+    """Test Grid boolean evaluation."""
+    grid = Grid(name="test", units="m", num_sections=5)
+    assert bool(grid) is True
+
+    # Note: Cannot test num_sections=0 case as it's prevented by constructor
+    # but the __bool__ method would return False in that case

musica/test/unit/test_grid_map.py

@@ -0,0 +1,126 @@
+# Copyright (C) 2023-2025 National Center for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+"""
+Tests for the TUV-x GridMap class.
+"""
+
+import pytest
+import numpy as np
+from musica.grid import Grid, backend
+from musica.grid_map import GridMap
+
+# Skip all tests if TUV-x is not available
+pytestmark = pytest.mark.skipif(not backend.tuvx_available(),
+                                reason="TUV-x backend is not available")
+
+
+def test_grid_map_creation():
+    """Test creating a GridMap instance"""
+    grid_map = GridMap()
+    assert len(grid_map) == 0
+    assert bool(grid_map) is False
+    assert str(grid_map) == "GridMap(num_grids=0)"
+
+
+def test_grid_map_add_get_grid():
+    """Test adding and retrieving grids from the map"""
+    grid_map = GridMap()
+
+    # Create a grid to add
+    grid = Grid(name="height", units="km", num_sections=5)
+    edges = np.array([0, 2, 4, 6, 8, 10], dtype=np.float64)
+    grid.edges = edges
+
+    # Test dictionary-style assignment
+    grid_map["height", "km"] = grid
+    assert len(grid_map) == 1
+    assert bool(grid_map) is True
+
+    # Test dictionary-style access
+    retrieved_grid = grid_map["height", "km"]
+    assert retrieved_grid.name == "height"
+    assert retrieved_grid.units == "km"
+    assert retrieved_grid.num_sections == 5
+    assert np.array_equal(retrieved_grid.edges, edges)
+
+
+def test_grid_map_contains():
+    """Test checking for grid existence"""
+    grid_map = GridMap()
+    grid = Grid(name="wavelength", units="nm", num_sections=3)
+
+    grid_map["wavelength", "nm"] = grid
+
+    assert ("wavelength", "nm") in grid_map
+    assert ("height", "km") not in grid_map
+    assert "invalid_key" not in grid_map
+
+
+def test_grid_map_iteration():
+    """Test iterating over grids in the map"""
+    grid_map = GridMap()
+
+    grids = [
+        ("height", "km", 5),
+        ("wavelength", "nm", 3),
+        ("time", "s", 2)
+    ]
+
+    # Add grids to map
+    for name, units, sections in grids:
+        grid = Grid(name=name, units=units, num_sections=sections)
+        grid_map[name, units] = grid
+
+    # Test keys()
+    keys = set(grid_map.keys())
+    expected_keys = {(name, units) for name, units, _ in grids}
+    assert keys == expected_keys
+
+    # Test values()
+    for grid in grid_map.values():
+        assert isinstance(grid, Grid)
+        assert (grid.name, grid.units) in expected_keys
+
+    # Test items()
+    for key, grid in grid_map.items():
+        assert isinstance(grid, Grid)
+        assert key in expected_keys
+        assert key == (grid.name, grid.units)
+
+
+def test_grid_map_clear():
+    """Test clearing all grids from the map"""
+    grid_map = GridMap()
+
+    grid = Grid(name="height", units="km", num_sections=5)
+    grid_map["height", "km"] = grid
+
+    assert len(grid_map) == 1
+    grid_map.clear()
+    assert len(grid_map) == 0
+    assert ("height", "km") not in grid_map
+
+
+def test_grid_map_errors():
+    """Test error handling"""
+    grid_map = GridMap()
+    grid = Grid(name="height", units="km", num_sections=5)
+
+    # Test invalid key type
+    with pytest.raises(TypeError):
+        grid_map["invalid"] = grid
+
+    with pytest.raises(TypeError):
+        grid_map[123, "km"] = grid
+
+    # Test invalid value type
+    with pytest.raises(TypeError):
+        grid_map["height", "km"] = "not_a_grid"
+
+    # Test mismatched grid properties
+    with pytest.raises(ValueError):
+        grid_map["wrong", "units"] = grid
+
+    # Test accessing non-existent grid
+    with pytest.raises(KeyError):
+        _ = grid_map["nonexistent", "grid"]

musica/test/unit/test_parser.py

@@ -30,20 +30,12 @@ def test_hard_coded_full_v1_configuration():
 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()
@@ -52,13 +44,21 @@ def test_hard_coded_default_constructed_types():
     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
 
 
+def test_convert_v0_to_v1():
+    parser = Parser()
+    base = 'configs/v0'
+    configs = ['analytical', 'carbon_bond_5', 'chapman', 'robertson', 'TS1', 'surface']
+    for config in configs:
+        path = f"{base}/{config}/config.json"
+        mechanism = parser.parse_and_convert_v0(path)
+        assert mechanism is not None
+
+
 if __name__ == "__main__":
     pytest.main([__file__])

musica/test/unit/test_profile.py

@@ -0,0 +1,169 @@
+"""Tests for the Profile class."""
+from __future__ import annotations
+import pytest  # type: ignore
+import numpy as np  # type: ignore
+from musica.grid import Grid
+from musica.profile import Profile, backend
+
+# Skip all tests if TUV-x is not available
+pytestmark = pytest.mark.skipif(not backend.tuvx_available(),
+                                reason="TUV-x backend is not available")
+
+
+@pytest.fixture
+def sample_grid():
+    """Create a sample grid for testing."""
+    grid = Grid(name="test_grid", units="m", num_sections=5)
+    grid.edges = np.array([0, 1, 2, 3, 4, 5])
+    grid.midpoints = np.array([0.5, 1.5, 2.5, 3.5, 4.5])
+    return grid
+
+
+def test_profile_initialization(sample_grid):
+    """Test Profile initialization with various input combinations."""
+    # Test basic initialization
+    profile = Profile(name="test", units="K", grid=sample_grid)
+    assert profile.name == "test"
+    assert profile.units == "K"
+
+    # Test number_of_sections
+    assert profile.number_of_sections == 5
+
+    # Test with edge_values
+    edge_values = np.array([290, 280, 270, 260, 250, 240])
+    profile = Profile(name="test", units="K", grid=sample_grid, edge_values=edge_values)
+    np.testing.assert_array_equal(profile.edge_values, edge_values)
+
+    # Test with midpoint_values
+    midpoint_values = np.array([285, 275, 265, 255, 245])
+    profile = Profile(name="test", units="K", grid=sample_grid, midpoint_values=midpoint_values)
+    np.testing.assert_array_equal(profile.midpoint_values, midpoint_values)
+
+    # Test with layer_densities
+    layer_densities = np.array([1e25, 1e24, 1e23, 1e22, 1e21])
+    profile = Profile(name="test", units="K", grid=sample_grid, layer_densities=layer_densities)
+    np.testing.assert_array_equal(profile.layer_densities, layer_densities)
+
+    # Test with all values
+    profile = Profile(name="test", units="K", grid=sample_grid,
+                      edge_values=edge_values,
+                      midpoint_values=midpoint_values,
+                      layer_densities=layer_densities)
+    np.testing.assert_array_equal(profile.edge_values, edge_values)
+    np.testing.assert_array_equal(profile.midpoint_values, midpoint_values)
+    np.testing.assert_array_equal(profile.layer_densities, layer_densities)
+
+
+def test_profile_properties(sample_grid):
+    """Test Profile property getters and setters."""
+    profile = Profile(name="test", units="K", grid=sample_grid)
+
+    # Test number_of_sections
+    assert profile.number_of_sections == 5
+
+    # Test edge_values
+    edge_values = np.array([290, 280, 270, 260, 250, 240])
+    profile.edge_values = edge_values
+    np.testing.assert_array_equal(profile.edge_values, edge_values)
+
+    # Test midpoint_values
+    midpoint_values = np.array([285, 275, 265, 255, 245])
+    profile.midpoint_values = midpoint_values
+    np.testing.assert_array_equal(profile.midpoint_values, midpoint_values)
+
+    # Test layer_densities
+    layer_densities = np.array([1e25, 1e24, 1e23, 1e22, 1e21])
+    profile.layer_densities = layer_densities
+    np.testing.assert_array_equal(profile.layer_densities, layer_densities)
+
+    # Test exo_layer_density
+    profile.exo_layer_density = 1e20
+    assert profile.exo_layer_density == 1e20
+
+    # Test invalid edge_values size
+    with pytest.raises(ValueError, match="Array size must be num_sections \\+ 1"):
+        profile.edge_values = np.array([290, 280, 270])
+
+    # Test invalid midpoint_values size
+    with pytest.raises(ValueError, match="Array size must be num_sections"):
+        profile.midpoint_values = np.array([285, 275, 265])
+
+    # Test invalid layer_densities size
+    with pytest.raises(ValueError, match="Array size must be num_sections"):
+        profile.layer_densities = np.array([1e25, 1e24, 1e23])
+
+
+def test_profile_string_methods(sample_grid):
+    """Test string representations of Profile."""
+    profile = Profile(name="test", units="K", grid=sample_grid)
+    edge_values = np.array([290, 280, 270, 260, 250, 240])
+    profile.edge_values = edge_values
+
+    # Test str()
+    assert str(profile).startswith("Profile(name=test, units=K, number_of_sections=5)")
+
+    # Test repr()
+    repr_str = repr(profile)
+    assert repr_str.startswith("Profile(name=test, units=K, number_of_sections=5")
+    assert "edge_values=" in repr_str
+    assert "midpoint_values=" in repr_str
+    assert "layer_densities=" in repr_str
+    assert "exo_layer_density=" in repr_str
+
+
+def test_profile_comparison(sample_grid):
+    """Test Profile comparison methods."""
+    edge_values1 = np.array([290, 280, 270, 260, 250, 240])
+    profile1 = Profile(name="test", units="K", grid=sample_grid)
+    profile1.edge_values = edge_values1
+
+    # Test equal profiles
+    profile2 = Profile(name="test", units="K", grid=sample_grid)
+    profile2.edge_values = edge_values1
+    assert profile1 == profile2
+
+    # Test unequal profiles
+    profile3 = Profile(name="different", units="K", grid=sample_grid)
+    profile3.edge_values = edge_values1
+    assert profile1 != profile3
+
+    profile4 = Profile(name="test", units="°C", grid=sample_grid)
+    profile4.edge_values = edge_values1
+    assert profile1 != profile4
+
+    edge_values2 = np.array([295, 285, 275, 265, 255, 245])
+    profile5 = Profile(name="test", units="K", grid=sample_grid)
+    profile5.edge_values = edge_values2
+    assert profile1 != profile5
+
+
+def test_profile_container_methods(sample_grid):
+    """Test Profile container methods (len)."""
+    profile = Profile(name="test", units="K", grid=sample_grid)
+    edge_values = np.array([290, 280, 270, 260, 250, 240])
+    profile.edge_values = edge_values
+
+    # Test len()
+    assert len(profile) == 5
+
+
+def test_profile_bool(sample_grid):
+    """Test Profile boolean evaluation."""
+    profile = Profile(name="test", units="K", grid=sample_grid)
+    assert bool(profile) is True  # True if grid has sections
+
+
+def test_exo_layer_density_calculation(sample_grid):
+    """Test exospheric layer density calculation."""
+    profile = Profile(name="test", units="K", grid=sample_grid)
+    edge_values = np.array([290, 280, 270, 260, 250, 240])
+    profile.edge_values = edge_values
+
+    layer_densities = np.array([1e25, 1e24, 1e23, 1e22, 1e21])
+    profile.layer_densities = layer_densities
+
+    # Test calculation with scale height
+    scale_height = 7000  # meters
+    profile.calculate_exo_layer_density(scale_height)
+    assert profile.exo_layer_density == pytest.approx(240.0 * scale_height, rel=1e-2)
+    assert profile.layer_densities[4] == pytest.approx(1.0e21 + 240.0 * scale_height, rel=1e-2)

musica/test/unit/test_profile_map.py

@@ -0,0 +1,137 @@
+# Copyright (C) 2023-2025 National Center for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+"""
+Tests for the TUV-x ProfileMap class.
+"""
+
+import pytest
+import numpy as np
+from musica.grid import Grid
+from musica.profile import Profile
+from musica.profile_map import ProfileMap, backend
+
+# Skip all tests if TUV-x is not available
+pytestmark = pytest.mark.skipif(not backend.tuvx_available(),
+                                reason="TUV-x backend is not available")
+
+
+@pytest.fixture
+def sample_grid():
+    """Create a sample grid for testing."""
+    grid = Grid(name="height", units="km", num_sections=5)
+    grid.edges = np.array([0, 2, 4, 6, 8, 10], dtype=np.float64)
+    grid.midpoints = np.array([1, 3, 5, 7, 9], dtype=np.float64)
+    return grid
+
+
+@pytest.fixture
+def sample_profile(sample_grid):
+    """Create a sample profile for testing."""
+    profile = Profile(name="temperature", units="K", grid=sample_grid)
+    profile.edge_values = np.array([300, 290, 280, 270, 260, 250], dtype=np.float64)
+    profile.midpoint_values = np.array([295, 285, 275, 265, 255], dtype=np.float64)
+    return profile
+
+
+def test_profile_map_creation():
+    """Test creating a ProfileMap instance"""
+    profile_map = ProfileMap()
+    assert len(profile_map) == 0
+    assert bool(profile_map) is False
+    assert str(profile_map) == "ProfileMap(num_profiles=0)"
+
+
+def test_profile_map_add_get_profile(sample_grid, sample_profile):
+    """Test adding and retrieving profiles from the map"""
+    profile_map = ProfileMap()
+
+    # Test dictionary-style assignment
+    profile_map["temperature", "K"] = sample_profile
+    assert len(profile_map) == 1
+    assert bool(profile_map) is True
+
+    # Test dictionary-style access
+    retrieved_profile = profile_map["temperature", "K"]
+    assert retrieved_profile.name == "temperature"
+    assert retrieved_profile.units == "K"
+    assert np.array_equal(retrieved_profile.edge_values, sample_profile.edge_values)
+    assert np.array_equal(retrieved_profile.midpoint_values, sample_profile.midpoint_values)
+
+
+def test_profile_map_contains(sample_grid, sample_profile):
+    """Test checking for profile existence"""
+    profile_map = ProfileMap()
+    profile_map["temperature", "K"] = sample_profile
+
+    assert ("temperature", "K") in profile_map
+    assert ("pressure", "hPa") not in profile_map
+    assert "invalid_key" not in profile_map
+
+
+def test_profile_map_iteration(sample_grid):
+    """Test iterating over profiles in the map"""
+    profile_map = ProfileMap()
+
+    # Create test profiles
+    profiles = [
+        ("temperature", "K", [300, 290, 280, 270, 260, 250]),
+        ("pressure", "hPa", [1000, 800, 600, 400, 200, 100]),
+        ("density", "kg/m3", [1.2, 1.0, 0.8, 0.6, 0.4, 0.2])
+    ]
+
+    # Add profiles to map
+    for name, units, edge_values in profiles:
+        profile = Profile(name=name, units=units, grid=sample_grid)
+        profile.edge_values = np.array(edge_values, dtype=np.float64)
+        profile_map[name, units] = profile
+
+    # Test keys()
+    keys = set(profile_map.keys())
+    expected_keys = {(name, units) for name, units, _ in profiles}
+    assert keys == expected_keys
+
+    # Test values()
+    for profile in profile_map.values():
+        assert isinstance(profile, Profile)
+        assert (profile.name, profile.units) in expected_keys
+
+    # Test items()
+    for key, profile in profile_map.items():
+        assert isinstance(profile, Profile)
+        assert key in expected_keys
+        assert key == (profile.name, profile.units)
+
+
+def test_profile_map_clear(sample_grid, sample_profile):
+    """Test clearing all profiles from the map"""
+    profile_map = ProfileMap()
+    profile_map["temperature", "K"] = sample_profile
+
+    assert len(profile_map) == 1
+    profile_map.clear()
+    assert len(profile_map) == 0
+    assert ("temperature", "K") not in profile_map
+
+
+def test_profile_map_errors(sample_grid, sample_profile):
+    """Test error handling"""
+    profile_map = ProfileMap()
+
+    # Test invalid key type
+    with pytest.raises(TypeError):
+        profile_map["invalid"] = sample_profile
+
+    with pytest.raises(TypeError):
+        profile_map[123, "K"] = sample_profile
+
+    # Test invalid value type
+    with pytest.raises(TypeError):
+        profile_map["temperature", "K"] = "not_a_profile"
+
+    # Test mismatched profile properties
+    with pytest.raises(ValueError):
+        profile_map["wrong", "units"] = sample_profile
+
+    # Test accessing non-existent profile
+    with pytest.raises(KeyError):
+        _ = profile_map["nonexistent", "profile"]