roms-tools 3.1.2__py3-none-any.whl → 3.3.0__py3-none-any.whl

roms_tools/tests/test_analysis/test_cdr_analysis.py

@@ -0,0 +1,144 @@
+import logging
+
+import numpy as np
+import pytest
+import xarray as xr
+
+from roms_tools.analysis.cdr_analysis import (
+    _validate_source,
+    _validate_uptake_efficiency,
+    compute_cdr_metrics,
+)
+
+
+@pytest.fixture
+def minimal_grid_ds():
+    """Minimal grid dataset with uniform spacing."""
+    return xr.Dataset(
+        {
+            "pm": (("eta_rho", "xi_rho"), np.ones((2, 2))),
+            "pn": (("eta_rho", "xi_rho"), np.ones((2, 2))),
+        }
+    )
+
+
+@pytest.fixture
+def minimal_ds():
+    """Minimal ROMS dataset with required variables and dimensions."""
+    time = np.arange(3)
+    s_rho = np.arange(1)
+    eta_rho = np.arange(2)
+    xi_rho = np.arange(2)
+
+    return xr.Dataset(
+        {
+            "avg_begin_time": ("time", time),
+            "avg_end_time": ("time", time + 1),
+            "ALK_source": (
+                ("time", "s_rho", "eta_rho", "xi_rho"),
+                np.ones((3, 1, 2, 2)),
+            ),
+            "DIC_source": (
+                ("time", "s_rho", "eta_rho", "xi_rho"),
+                -np.ones((3, 1, 2, 2)),
+            ),
+            "FG_CO2": (("time", "eta_rho", "xi_rho"), np.full((3, 2, 2), 2.0)),
+            "FG_ALT_CO2": (("time", "eta_rho", "xi_rho"), np.full((3, 2, 2), 1.0)),
+            "hDIC": (
+                ("time", "s_rho", "eta_rho", "xi_rho"),
+                np.full((3, 1, 2, 2), 10.0),
+            ),
+            "hDIC_ALT_CO2": (
+                ("time", "s_rho", "eta_rho", "xi_rho"),
+                np.full((3, 1, 2, 2), 9.0),
+            ),
+        },
+        coords={"time": time, "s_rho": s_rho, "eta_rho": eta_rho, "xi_rho": xi_rho},
+    )
+
+
+def test_compute_cdr_metrics_outputs(
+    minimal_ds: xr.Dataset, minimal_grid_ds: xr.Dataset
+) -> None:
+    ds_cdr = compute_cdr_metrics(minimal_ds, minimal_grid_ds)
+
+    # Required outputs exist
+    for var in [
+        "area",
+        "window_length",
+        "FG_CO2",
+        "FG_ALT_CO2",
+        "hDIC",
+        "hDIC_ALT_CO2",
+        "cdr_efficiency",
+        "cdr_efficiency_from_delta_diff",
+    ]:
+        assert var in ds_cdr
+
+    # Area should be 1 (since pm=pn=1)
+    assert np.allclose(ds_cdr["area"], 1.0)
+
+    # Window length should be 1 everywhere
+    assert np.all(ds_cdr["window_length"].values == 1)
+
+
+def test_missing_variable_in_ds(
+    minimal_ds: xr.Dataset, minimal_grid_ds: xr.Dataset
+) -> None:
+    bad_ds = minimal_ds.drop_vars("FG_CO2")
+    with pytest.raises(KeyError, match="Missing required variables"):
+        compute_cdr_metrics(bad_ds, minimal_grid_ds)
+
+
+def test_missing_variable_in_grid(
+    minimal_ds: xr.Dataset, minimal_grid_ds: xr.Dataset
+) -> None:
+    bad_grid_ds = minimal_grid_ds.drop_vars("pm")
+    with pytest.raises(KeyError, match="Missing required variables"):
+        compute_cdr_metrics(minimal_ds, bad_grid_ds)
+
+
+def test_validate_source_passes(minimal_ds):
+    # Should not raise
+    _validate_source(minimal_ds)
+
+
+def test_validate_source_alk_negative(minimal_ds):
+    bad_ds = minimal_ds.copy()
+    bad_ds["ALK_source"].loc[dict(time=0)] = -1
+    with pytest.raises(ValueError, match="ALK_source"):
+        _validate_source(bad_ds)
+
+
+def test_validate_source_dic_positive(minimal_ds):
+    bad_ds = minimal_ds.copy()
+    bad_ds["DIC_source"].loc[dict(time=0)] = 1
+    with pytest.raises(ValueError, match="DIC_source"):
+        _validate_source(bad_ds)
+
+
+def test_validate_uptake_efficiency_logs(caplog):
+    arr1 = xr.DataArray([1.0, 2.0, 3.0], dims="time")
+    arr2 = xr.DataArray([1.0, 2.5, 3.0], dims="time")
+
+    with caplog.at_level(logging.INFO):
+        diff = _validate_uptake_efficiency(arr1, arr2)
+
+    assert np.isclose(diff, 0.5)
+    assert "flux-based and DIC-based uptake efficiency" in caplog.text
+
+
+def test_efficiency_nan_when_zero_source(minimal_ds, minimal_grid_ds):
+    # Make ALK_source and DIC_source both zero at t=0
+    ds = minimal_ds.copy()
+    ds["ALK_source"].loc[dict(time=0)] = 0
+    ds["DIC_source"].loc[dict(time=0)] = 0
+
+    ds_cdr = compute_cdr_metrics(ds, minimal_grid_ds)
+
+    eff_flux = ds_cdr["cdr_efficiency"].isel(time=0).item()
+    eff_diff = ds_cdr["cdr_efficiency_from_delta_diff"].isel(time=0).item()
+
+    # Should be NaN, not inf
+    assert np.isnan(eff_flux)
+    assert np.isnan(eff_diff)

roms_tools/tests/test_analysis/test_cdr_ensemble.py

@@ -0,0 +1,202 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+import xarray as xr
+
+from roms_tools import Ensemble
+
+# ----------------------------
+# Fixtures
+# ----------------------------
+
+
+@pytest.fixture
+def create_member_ds() -> xr.Dataset:
+    """Simple Dataset for testing."""
+    times = np.array(["2000-01-01", "2000-01-02", "2000-01-03"], dtype="datetime64[ns]")
+    ds = xr.Dataset(
+        {"cdr_efficiency": ("time", [0.1, 0.2, 0.3]), "abs_time": ("time", times)},
+        coords={"time": times},
+    )
+    return ds
+
+
+@pytest.fixture
+def identical_members(create_member_ds: xr.Dataset) -> dict[str, xr.Dataset]:
+    """Two truly identical members for basic tests."""
+    return {
+        "member1": create_member_ds.copy(),
+        "member2": create_member_ds.copy(),
+    }
+
+
+@pytest.fixture
+def varied_members() -> dict[str, xr.Dataset]:
+    """Ensemble members with different lengths, frequencies, start dates, and leading NaNs."""
+    # Member 1: daily, 5 days, starts 2000-01-01, first value is NaN
+    times1 = np.array(
+        ["2000-01-01", "2000-01-02", "2000-01-03", "2000-01-04", "2000-01-05"],
+        dtype="datetime64[ns]",
+    )
+    ds1 = xr.Dataset(
+        {
+            "cdr_efficiency": ("time", [np.nan, 0.2, 0.3, 0.4, 0.5]),
+            "abs_time": ("time", times1),
+        },
+        coords={"time": times1},
+    )
+
+    # Member 2: every 2 days, 4 entries, starts 2000-01-02, first two values NaN
+    times2 = np.array(
+        ["2000-01-02", "2000-01-04", "2000-01-06", "2000-01-08"], dtype="datetime64[ns]"
+    )
+    ds2 = xr.Dataset(
+        {
+            "cdr_efficiency": ("time", [np.nan, np.nan, 0.6, 0.8]),
+            "abs_time": ("time", times2),
+        },
+        coords={"time": times2},
+    )
+
+    # Member 3: daily, 3 days, starts 1999-12-31, no NaNs
+    times3 = np.array(
+        ["1999-12-31", "2000-01-01", "2000-01-02"], dtype="datetime64[ns]"
+    )
+    ds3 = xr.Dataset(
+        {"cdr_efficiency": ("time", [0.05, 0.15, 0.25]), "abs_time": ("time", times3)},
+        coords={"time": times3},
+    )
+
+    return {"member1": ds1, "member2": ds2, "member3": ds3}
+
+
+# ----------------------------
+# Tests
+# ----------------------------
+
+
+def test_extract_efficiency(create_member_ds: xr.Dataset) -> None:
+    ens = Ensemble.__new__(Ensemble)
+    eff_rel = ens._extract_efficiency(create_member_ds)
+
+    assert isinstance(eff_rel, xr.DataArray)
+    assert np.issubdtype(eff_rel.time.dtype, np.timedelta64)
+    assert "abs_time" not in eff_rel.coords
+    assert eff_rel.time.attrs.get("long_name") == "time since release start"
+
+
+def test_extract_efficiency_missing_abs_time() -> None:
+    """Test that _extract_efficiency raises an error if 'abs_time' is missing."""
+    times = np.array(["2000-01-01", "2000-01-02"], dtype="datetime64[ns]")
+    ds = xr.Dataset(
+        {"cdr_efficiency": ("time", [0.1, 0.2])},
+        coords={"time": times},  # Note: no 'abs_time' coordinate
+    )
+
+    ens = Ensemble.__new__(Ensemble)
+    with pytest.raises(
+        ValueError, match="Dataset must contain an 'abs_time' coordinate."
+    ):
+        ens._extract_efficiency(ds)
+
+
+def test_align_times_identical(identical_members: dict[str, xr.Dataset]) -> None:
+    ens = Ensemble.__new__(Ensemble)
+    effs = {
+        name: Ensemble._extract_efficiency(ens, ds)
+        for name, ds in identical_members.items()
+    }
+    aligned = ens._align_times(effs)
+
+    assert isinstance(aligned, xr.Dataset)
+    for name in identical_members.keys():
+        assert name in aligned.data_vars
+
+    # Time dimension matches union of member times
+    all_times = np.unique(np.concatenate([eff.time.values for eff in effs.values()]))
+    assert len(aligned.time) == len(all_times)
+
+
+def test_align_times_varied(varied_members: dict[str, xr.Dataset]) -> None:
+    ens = Ensemble.__new__(Ensemble)
+    effs = {
+        name: Ensemble._extract_efficiency(ens, ds)
+        for name, ds in varied_members.items()
+    }
+    aligned = ens._align_times(effs)
+
+    # Check all members exist
+    for name in varied_members.keys():
+        assert name in aligned.data_vars
+
+    # Time dimension is union of all times
+    all_times = np.unique(np.concatenate([eff.time.values for eff in effs.values()]))
+    assert len(aligned.time) == len(all_times)
+
+    # Check that for each member, times before first valid value and after last valid value are NaN
+    for name, eff in effs.items():
+        # Find first and last valid relative times
+        valid_mask = ~np.isnan(eff.values)
+        first_valid_time = eff.time.values[valid_mask][0]
+        last_valid_time = eff.time.values[valid_mask][-1]
+
+        # Times before first valid → should be NaN
+        missing_before = aligned.time.values < first_valid_time
+        if missing_before.any():
+            assert np.all(np.isnan(aligned[name].values[missing_before]))
+
+        # Times after last valid → should be NaN
+        missing_after = aligned.time.values > last_valid_time
+        if missing_after.any():
+            assert np.all(np.isnan(aligned[name].values[missing_after]))
+
+
+def test_compute_statistics(identical_members: dict[str, xr.Dataset]) -> None:
+    ens = Ensemble.__new__(Ensemble)
+    effs = {
+        name: Ensemble._extract_efficiency(ens, ds)
+        for name, ds in identical_members.items()
+    }
+    aligned = ens._align_times(effs)
+    ds_stats = ens._compute_statistics(aligned)
+
+    assert "ensemble_mean" in ds_stats.data_vars
+    assert "ensemble_std" in ds_stats.data_vars
+    n_time = len(ds_stats.time)
+    assert ds_stats.ensemble_mean.shape[0] == n_time
+    assert ds_stats.ensemble_std.shape[0] == n_time
+
+    # Ensemble mean should equal the member values
+    first_member_name = next(iter(identical_members))
+    xr.testing.assert_allclose(ds_stats.ensemble_mean, ds_stats[first_member_name])
+
+    # For identical members, std should be 0
+    np.testing.assert_allclose(ds_stats.ensemble_std.values, 0.0)
+
+
+def test_ensemble_post_init(identical_members: dict[str, xr.Dataset]) -> None:
+    ens = Ensemble(identical_members)
+    assert isinstance(ens.ds, xr.Dataset)
+    assert "ensemble_mean" in ens.ds.data_vars
+    assert "ensemble_std" in ens.ds.data_vars
+    np.testing.assert_allclose(ens.ds.ensemble_std.values, 0.0)
+
+
+def test_plot(identical_members: dict[str, xr.Dataset], tmp_path: Path) -> None:
+    ens = Ensemble(identical_members)
+    save_path = tmp_path / "plot.png"
+    ens.plot(save_path=str(save_path))
+    assert save_path.exists()
+
+
+def test_extract_efficiency_empty() -> None:
+    # Dataset with all NaN
+    times = np.array(["2000-01-01", "2000-01-02"], dtype="datetime64[ns]")
+    ds = xr.Dataset(
+        {"cdr_efficiency": ("time", [np.nan, np.nan]), "abs_time": ("time", times)},
+        coords={"time": times},
+    )
+    ens = Ensemble.__new__(Ensemble)
+    with pytest.raises(ValueError):
+        ens._extract_efficiency(ds)

roms_tools/tests/test_analysis/test_roms_output.py

@@ -72,15 +72,19 @@ def test_load_model_output_file(roms_output_fixture, request):
     assert isinstance(roms_output.ds, xr.Dataset)
 
 
-def test_load_model_output_file_list(use_dask):
+@pytest.fixture
+def roms_output_from_two_restart_files(use_dask):
     fname_grid = Path(download_test_data("epac25km_grd.nc"))
     grid = Grid.from_file(fname_grid)
 
     # List of files
     file1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
     file2 = Path(download_test_data("eastpac25km_rst.19980126000000.nc"))
-    output = ROMSOutput(grid=grid, path=[file1, file2], use_dask=use_dask)
-    assert isinstance(output.ds, xr.Dataset)
+    return ROMSOutput(grid=grid, path=[file1, file2], use_dask=use_dask)
+
+
+def test_load_model_output_file_list(roms_output_from_two_restart_files):
+    assert isinstance(roms_output_from_two_restart_files.ds, xr.Dataset)
 
 
 def test_load_model_output_with_wildcard(use_dask):
@@ -618,3 +622,57 @@ def test_regrid_with_custom_depth_levels(roms_output_fixture, request):
     assert isinstance(ds_regridded, xr.Dataset)
     assert "depth" in ds_regridded.coords
     np.allclose(ds_regridded.depth, depth_levels, atol=0.0)
+
+
+@pytest.fixture
+def roms_output_with_cdr_vars(roms_output_from_two_restart_files):
+    """Adds minimal CDR variables to the ROMSOutput dataset."""
+    ds = roms_output_from_two_restart_files.ds.copy()
+
+    # Dimensions
+    time = ds.sizes["time"]
+    eta_rho = ds.sizes["eta_rho"]
+    xi_rho = ds.sizes["xi_rho"]
+    s_rho = ds.sizes["s_rho"]
+
+    # Add required variables for CDR metrics
+    ds["ALK_source"] = xr.DataArray(
+        np.abs(np.random.randn(time, s_rho, eta_rho, xi_rho)),
+        dims=("time", "s_rho", "eta_rho", "xi_rho"),
+    )
+    ds["DIC_source"] = xr.DataArray(
+        -np.abs(np.random.randn(time, s_rho, eta_rho, xi_rho)),
+        dims=("time", "s_rho", "eta_rho", "xi_rho"),
+    )
+    ds["FG_CO2"] = xr.DataArray(
+        np.random.randn(time, eta_rho, xi_rho), dims=("time", "eta_rho", "xi_rho")
+    )
+    ds["FG_ALT_CO2"] = xr.DataArray(
+        np.random.randn(time, eta_rho, xi_rho), dims=("time", "eta_rho", "xi_rho")
+    )
+    ds["hDIC"] = xr.DataArray(
+        np.random.randn(time, s_rho, eta_rho, xi_rho),
+        dims=("time", "s_rho", "eta_rho", "xi_rho"),
+    )
+    ds["hDIC_ALT_CO2"] = xr.DataArray(
+        np.random.randn(time, s_rho, eta_rho, xi_rho),
+        dims=("time", "s_rho", "eta_rho", "xi_rho"),
+    )
+
+    # Add average begin/end times (simulate seconds)
+    ds["avg_begin_time"] = xr.DataArray(np.arange(time) * 3600, dims=("time",))
+    ds["avg_end_time"] = xr.DataArray((np.arange(time) + 1) * 3600, dims=("time",))
+
+    roms_output_from_two_restart_files.ds = ds
+    return roms_output_from_two_restart_files
+
+
+def test_cdr_metrics_computes_and_plots(roms_output_with_cdr_vars):
+    roms_output_with_cdr_vars.cdr_metrics()
+    assert hasattr(roms_output_with_cdr_vars, "ds_cdr")
+
+    ds_cdr = roms_output_with_cdr_vars.ds_cdr
+
+    # Check presence of both efficiency variables
+    assert "cdr_efficiency" in ds_cdr
+    assert "cdr_efficiency_from_delta_diff" in ds_cdr

roms_tools/tests/test_setup/test_boundary_forcing.py

@@ -13,6 +13,12 @@ import xarray as xr
 from conftest import calculate_data_hash
 from roms_tools import BoundaryForcing, Grid
 from roms_tools.download import download_test_data
+from roms_tools.tests.test_setup.utils import download_regional_and_bigger
+
+try:
+    import copernicusmarine  # type: ignore
+except ImportError:
+    copernicusmarine = None
 
 
 @pytest.mark.parametrize(
@@ -271,7 +277,7 @@ def test_boundary_divided_by_land_warning(caplog, use_dask):
             use_dask=use_dask,
         )
     # Verify the warning message in the log
-    assert "the western boundary is divided by land" in caplog.text
+    assert "divided by land" in caplog.text
 
 
 def test_info_depth(caplog, use_dask):
@@ -324,57 +330,6 @@ def test_info_depth(caplog, use_dask):
     )
 
 
-def test_info_fill(caplog, use_dask):
-    grid = Grid(
-        nx=3,
-        ny=3,
-        size_x=400,
-        size_y=400,
-        center_lon=-8,
-        center_lat=58,
-        rot=0,
-        N=3,  # number of vertical levels
-        theta_s=5.0,  # surface control parameter
-        theta_b=2.0,  # bottom control parameter
-        hc=250.0,  # critical depth
-    )
-
-    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
-    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
-
-    with caplog.at_level(logging.INFO):
-        BoundaryForcing(
-            grid=grid,
-            start_time=datetime(2012, 1, 1),
-            end_time=datetime(2012, 12, 31),
-            source={"name": "GLORYS", "path": [fname1, fname2]},
-            apply_2d_horizontal_fill=True,
-            use_dask=use_dask,
-        )
-
-    # Verify the warning message in the log
-    assert (
-        "Applying 2D horizontal fill to the source data before regridding."
-        in caplog.text
-    )
-
-    # Clear the log before the next test
-    caplog.clear()
-
-    with caplog.at_level(logging.INFO):
-        BoundaryForcing(
-            grid=grid,
-            start_time=datetime(2012, 1, 1),
-            end_time=datetime(2012, 12, 31),
-            source={"name": "GLORYS", "path": [fname1, fname2]},
-            apply_2d_horizontal_fill=False,
-            use_dask=use_dask,
-        )
-    # Verify the warning message in the log
-    for direction in ["south", "east", "north", "west"]:
-        assert f"Applying 1D horizontal fill to {direction}ern boundary." in caplog.text
-
-
 def test_1d_and_2d_fill_coincide_if_no_fill(use_dask):
     grid = Grid(
         nx=2,
@@ -787,6 +742,53 @@ def test_default_glorys_dataset_loading(tiny_grid: Grid) -> None:
         assert set(bf.ds.data_vars).issuperset(expected_vars)
 
 
+@pytest.mark.use_copernicus
+@pytest.mark.skipif(copernicusmarine is None, reason="copernicusmarine required")
+@pytest.mark.parametrize(
+    "grid_fixture",
+    [
+        "tiny_grid_that_straddles_dateline",
+        "tiny_grid_that_straddles_180_degree_meridian",
+        "tiny_rotated_grid",
+    ],
+)
+def test_invariance_to_get_glorys_bounds(tmp_path, grid_fixture, use_dask, request):
+    start_time = datetime(2012, 1, 1)
+    grid = request.getfixturevalue(grid_fixture)
+
+    regional_file, bigger_regional_file = download_regional_and_bigger(
+        tmp_path, grid, start_time
+    )
+
+    bf_from_regional = BoundaryForcing(
+        grid=grid,
+        source={"name": "GLORYS", "path": str(regional_file)},
+        type="physics",
+        start_time=start_time,
+        end_time=start_time,
+        apply_2d_horizontal_fill=True,
+        use_dask=use_dask,
+    )
+    bf_from_bigger_regional = BoundaryForcing(
+        grid=grid,
+        source={"name": "GLORYS", "path": str(bigger_regional_file)},
+        type="physics",
+        start_time=start_time,
+        end_time=start_time,
+        apply_2d_horizontal_fill=True,
+        use_dask=use_dask,
+    )
+
+    # Use assert_allclose instead of equals: necessary for grids that straddle the 180° meridian.
+    # Copernicus returns data on [-180, 180] by default, but if you request a range
+    # like [170, 190], it remaps longitudes. That remapping introduces tiny floating
+    # point differences in the longitude coordinate, which will then propagate into further differences once you do regridding.
+    # Need to adjust the tolerances for these grids that straddle the 180° meridian.
+    xr.testing.assert_allclose(
+        bf_from_bigger_regional.ds, bf_from_regional.ds, rtol=1e-4, atol=1e-5
+    )
+
+
 @pytest.mark.parametrize(
     "use_dask",
     [pytest.param(True, marks=pytest.mark.use_dask), False],

roms_tools/tests/test_setup/test_cdr_forcing.py

@@ -3,6 +3,7 @@ from datetime import datetime, timedelta
 from pathlib import Path
 
 import numpy as np
+import pandas as pd
 import pytest
 import xarray as xr
 from pydantic import ValidationError
@@ -16,6 +17,7 @@ from roms_tools.setup.cdr_forcing import (
     ReleaseSimulationManager,
 )
 from roms_tools.setup.cdr_release import ReleaseType
+from roms_tools.setup.utils import get_tracer_metadata_dict
 
 try:
     import xesmf  # type: ignore
@@ -977,3 +979,55 @@ class TestCDRForcing:
             yaml_filepath.unlink()
             filepath1.unlink()
             filepath2.unlink()
+
+    @pytest.mark.parametrize(
+        "cdr_forcing, tracer_attr",
+        [
+            ("volume_release_cdr_forcing_without_grid", "tracer_concentrations"),
+            ("tracer_perturbation_cdr_forcing_without_grid", "tracer_fluxes"),
+        ],
+    )
+    def test_compute_total_cdr_source(self, cdr_forcing, tracer_attr, request):
+        dt = 30.0
+        cdr_instance = getattr(self, cdr_forcing)
+
+        df = cdr_instance.compute_total_cdr_source(dt)
+
+        # Check type
+        assert isinstance(df, pd.DataFrame)
+
+        # Check rows = number of releases + 1 for the units row
+        assert df.shape[0] == len(cdr_instance.releases) + 1
+
+        # Columns = tracer names
+        all_tracers = set()
+        for r in cdr_instance.releases:
+            all_tracers.update(getattr(r, tracer_attr).keys())
+
+        # Remove temp and salt since they are excluded from integrated totals
+        all_tracers.discard("temp")
+        all_tracers.discard("salt")
+
+        # Columns are now just tracer names (units row removed)
+        col_tracers = set(df.columns)
+        assert col_tracers == all_tracers
+
+        # Check that units are included in the units row
+        tracer_meta = get_tracer_metadata_dict(include_bgc=True, unit_type="integrated")
+        for tracer in df.columns:
+            unit = tracer_meta.get(tracer, {}).get("units", None)
+            if unit:
+                assert df.loc["units", tracer] == unit, (
+                    f"Units row for '{tracer}' is incorrect"
+                )
+
+        # Exclude units row
+        data_only = df.drop("units")
+
+        # Convert all columns to numeric, coerce errors to NaN
+        data_numeric = data_only.apply(pd.to_numeric, errors="coerce")
+
+        # Now check all finite (ignoring any NaNs that were non-numeric)
+        assert np.all(np.isfinite(data_numeric.values)), (
+            "Some values are not finite numbers"
+        )