roms-tools 2.7.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

roms_tools/tests/test_setup/test_initial_conditions.py

@@ -1,14 +1,17 @@
-import pytest
+import logging
+import textwrap
 from datetime import datetime
-from roms_tools import InitialConditions, Grid
-import xarray as xr
+from pathlib import Path
+
+import matplotlib.pyplot as plt
 import numpy as np
-import textwrap
-import logging
+import pytest
+import xarray as xr
+
+from conftest import calculate_data_hash
+from roms_tools import Grid, InitialConditions
 from roms_tools.download import download_test_data
 from roms_tools.setup.datasets import CESMBGCDataset, UnifiedBGCDataset
-from pathlib import Path
-from conftest import calculate_data_hash
 
 
 @pytest.mark.parametrize(
@@ -43,6 +46,43 @@ def test_initial_conditions_creation(ic_fixture, request):
     assert ic.ds.coords["ocean_time"].attrs["units"] == "seconds"
 
 
+def test_initial_conditions_creation_with_duplicates(use_dask: bool) -> None:
+    """Test the creation of the InitialConditions object with duplicates in source data
+    works as expected."""
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+
+    grid = Grid(
+        nx=3,
+        ny=3,
+        size_x=400,
+        size_y=400,
+        center_lon=-8,
+        center_lat=58,
+        rot=0,
+        N=3,
+    )
+
+    initial_conditions = InitialConditions(
+        grid=grid,
+        ini_time=datetime(2012, 1, 1),
+        source={"path": [fname1, fname2], "name": "GLORYS"},
+        use_dask=use_dask,
+    )
+
+    initial_conditions_with_duplicates_in_source_data = InitialConditions(
+        grid=grid,
+        ini_time=datetime(2012, 1, 1),
+        source={"path": [fname1, fname1, fname2], "name": "GLORYS"},
+        use_dask=use_dask,
+    )
+
+    assert initial_conditions.ds.identical(
+        initial_conditions_with_duplicates_in_source_data.ds
+    )
+
+
 @pytest.mark.parametrize(
     "ic_fixture",
     [
@@ -401,6 +441,21 @@ def test_interpolation_from_climatology(use_dask):
     )
 
 
+def test_computed_missing_optional_fields(
+    initial_conditions_with_unified_bgc_from_climatology,
+):
+    ds = initial_conditions_with_unified_bgc_from_climatology.ds
+
+    # Use tight tolerances because 'DOC' and 'DOCr' can have values order 1e-6
+
+    # 'DOCr' was missing in the source data and should have been filled with a constant default value
+    assert np.allclose(
+        ds.DOCr.std(), 0.0, rtol=1e-10, atol=1e-10
+    ), "DOCr should be constant across space and time"
+    # 'DOC' was present in the source data and should show spatial or temporal variability
+    assert ds.DOC.std() > 1e-10, "DOC should vary across space and time"
+
+
 @pytest.mark.parametrize(
     "initial_conditions_fixture",
     [
@@ -441,6 +496,13 @@ def test_initial_conditions_plot(initial_conditions_fixture, request):
     initial_conditions.plot(var_name="ubar")
     initial_conditions.plot(var_name="vbar")
 
+    # Test that passing a matplotlib.axes.Axes works
+    fig, ax = plt.subplots(1, 1)
+    initial_conditions.plot(var_name="temp", s=0, ax=ax)
+    initial_conditions.plot(var_name="temp", eta=0, ax=ax)
+    initial_conditions.plot(var_name="temp", s=0, xi=0, ax=ax)
+    initial_conditions.plot(var_name="zeta", ax=ax)
+
 
 @pytest.mark.parametrize(
     "initial_conditions_fixture",

roms_tools/tests/test_setup/test_nesting.py

@@ -1,17 +1,19 @@
-import pytest
-import xarray as xr
-import numpy as np
 import logging
 from pathlib import Path
-from roms_tools import Grid, ChildGrid
-from roms_tools.setup.utils import get_boundary_coords
+
+import numpy as np
+import pytest
+import xarray as xr
+
 from conftest import calculate_file_hash
+from roms_tools import ChildGrid, Grid
 from roms_tools.setup.nesting import (
+    compute_boundary_distance,
     interpolate_indices,
     map_child_boundaries_onto_parent_grid_indices,
-    compute_boundary_distance,
     modify_child_topography_and_mask,
 )
+from roms_tools.setup.utils import get_boundary_coords
 
 
 @pytest.fixture()

roms_tools/tests/test_setup/test_river_forcing.py

@@ -1,12 +1,14 @@
-from roms_tools import RiverForcing, Grid
-import xarray as xr
-import numpy as np
-from datetime import datetime
+import logging
 import textwrap
+from datetime import datetime
 from pathlib import Path
+
+import numpy as np
 import pytest
-import logging
+import xarray as xr
+
 from conftest import calculate_file_hash
+from roms_tools import Grid, RiverForcing
 
 
 @pytest.fixture
@@ -186,18 +188,16 @@ class TestRiverForcingGeneral:
             "river_forcing_with_prescribed_multi_cell_indices",
         ],
     )
-    def test_constant_tracers(self, river_forcing_fixture, request):
+    def test_tracers_are_filled(self, river_forcing_fixture, request):
         river_forcing = request.getfixturevalue(river_forcing_fixture)
-        np.testing.assert_allclose(
-            river_forcing.ds.river_tracer.isel(ntracers=0).values, 17.0, atol=0
-        )
-        np.testing.assert_allclose(
-            river_forcing.ds.river_tracer.isel(ntracers=1).values, 1.0, atol=0
-        )
-        np.testing.assert_allclose(
-            river_forcing.ds.river_tracer.isel(ntracers=slice(2, None)).values,
+        # Test that all tracers have been filled and have positive values
+        assert river_forcing.ds.river_tracer.all() > 0.0
+        # Test that tracers are constant across rivers and time
+        assert np.allclose(
+            river_forcing.ds.river_tracer.std(dim=["river_time", "nriver"]),
             0.0,
-            atol=0,
+            rtol=1e-5,
+            atol=1e-5,
         )
 
     def test_reproducibility_same_grid(self, river_forcing):

roms_tools/tests/test_setup/test_surface_forcing.py

@@ -1,12 +1,15 @@
-import pytest
+import logging
+import textwrap
 from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import pytest
 import xarray as xr
+
+from conftest import calculate_data_hash
 from roms_tools import Grid, SurfaceForcing
 from roms_tools.download import download_test_data
-import textwrap
-from pathlib import Path
-import logging
-from conftest import calculate_data_hash
 
 
 @pytest.fixture
@@ -154,6 +157,60 @@ def grid_that_lies_west_of_dateline_more_than_five_degrees_away():
     return grid
 
 
+def _test_successful_initialization(
+    grid: Grid,
+    start_time: datetime,
+    end_time: datetime,
+    source: dict[str, str],
+    coarse_grid_mode: str,
+    use_dask: bool,
+    caplog,
+):
+    with caplog.at_level(logging.INFO):
+        sfc_forcing = SurfaceForcing(
+            grid=grid,
+            start_time=start_time,
+            end_time=end_time,
+            source=source,
+            correct_radiation=True,
+            wind_dropoff=True,
+            coarse_grid_mode=coarse_grid_mode,
+            use_dask=use_dask,
+        )
+
+        assert sfc_forcing.grid == grid
+        assert sfc_forcing.start_time == start_time
+        assert sfc_forcing.end_time == end_time
+        assert sfc_forcing.type == "physics"
+        assert sfc_forcing.source == source
+        assert sfc_forcing.correct_radiation
+        assert sfc_forcing.wind_dropoff
+
+        if coarse_grid_mode == "always":
+            assert sfc_forcing.use_coarse_grid
+            assert (
+                "Data will be interpolated onto grid coarsened by factor 2."
+                in caplog.text
+            )
+        elif coarse_grid_mode == "never":
+            assert not sfc_forcing.use_coarse_grid
+            assert "Data will be interpolated onto fine grid." in caplog.text
+
+        assert isinstance(sfc_forcing.ds, xr.Dataset)
+        assert "uwnd" in sfc_forcing.ds
+        assert "vwnd" in sfc_forcing.ds
+        assert "swrad" in sfc_forcing.ds
+        assert "lwrad" in sfc_forcing.ds
+        assert "Tair" in sfc_forcing.ds
+        assert "qair" in sfc_forcing.ds
+        assert "rain" in sfc_forcing.ds
+        assert sfc_forcing.ds.coords["time"].attrs["units"] == "days"
+
+        assert sfc_forcing.ds.attrs["source"] == source["name"]
+        assert sfc_forcing.ds.attrs["correct_radiation"] == "True"
+        assert sfc_forcing.ds.attrs["wind_dropoff"] == "True"
+
+
 @pytest.mark.parametrize(
     "grid_fixture",
     [
@@ -165,7 +222,7 @@ def grid_that_lies_west_of_dateline_more_than_five_degrees_away():
     ],
 )
 def test_successful_initialization_with_regional_data(
-    grid_fixture, request, caplog, use_dask
+    grid_fixture, request, use_dask, caplog
 ):
     """Test the initialization of SurfaceForcing with regional ERA5 data.
 
@@ -174,57 +231,57 @@ def test_successful_initialization_with_regional_data(
     - Then with the coarse grid enabled.
     """
 
-    start_time = datetime(2020, 1, 31)
-    end_time = datetime(2020, 2, 2)
-
     fname = Path(download_test_data("ERA5_regional_test_data.nc"))
-
     grid = request.getfixturevalue(grid_fixture)
 
     for coarse_grid_mode in ["always", "never"]:
-        with caplog.at_level(logging.INFO):
-            sfc_forcing = SurfaceForcing(
-                grid=grid,
-                start_time=start_time,
-                end_time=end_time,
-                source={"name": "ERA5", "path": fname},
-                correct_radiation=True,
-                coarse_grid_mode=coarse_grid_mode,
-                use_dask=use_dask,
-            )
+        _test_successful_initialization(
+            grid=grid,
+            start_time=datetime(2020, 1, 31),
+            end_time=datetime(2020, 2, 2),
+            source={"name": "ERA5", "path": fname, "climatology": False},
+            coarse_grid_mode=coarse_grid_mode,
+            use_dask=use_dask,
+            caplog=caplog,
+        )
 
-        assert sfc_forcing.ds is not None
-        assert "uwnd" in sfc_forcing.ds
-        assert "vwnd" in sfc_forcing.ds
-        assert "swrad" in sfc_forcing.ds
-        assert "lwrad" in sfc_forcing.ds
-        assert "Tair" in sfc_forcing.ds
-        assert "qair" in sfc_forcing.ds
-        assert "rain" in sfc_forcing.ds
 
-        assert sfc_forcing.start_time == start_time
-        assert sfc_forcing.end_time == end_time
-        assert sfc_forcing.type == "physics"
-        assert sfc_forcing.source == {
-            "name": "ERA5",
-            "path": fname,
-            "climatology": False,
-        }
-        assert sfc_forcing.ds.coords["time"].attrs["units"] == "days"
+@pytest.mark.parametrize(
+    "grid_fixture",
+    [
+        "grid_that_straddles_dateline",
+        "grid_that_lies_east_of_dateline_less_than_five_degrees_away",
+        "grid_that_lies_east_of_dateline_more_than_five_degrees_away",
+        "grid_that_lies_west_of_dateline_less_than_five_degrees_away",
+        "grid_that_lies_west_of_dateline_more_than_five_degrees_away",
+        "grid_that_straddles_dateline_but_is_too_big_for_regional_test_data",
+        "another_grid_that_straddles_dateline_but_is_too_big_for_regional_test_data",
+        "grid_that_straddles_180_degree_meridian",
+    ],
+)
+def test_successful_initialization_with_global_data(
+    grid_fixture, request, use_dask, caplog
+):
+    """Test initialization of SurfaceForcing with global data.
 
-        if coarse_grid_mode == "always":
-            assert sfc_forcing.use_coarse_grid
-            assert (
-                "Data will be interpolated onto grid coarsened by factor 2."
-                in caplog.text
-            )
-        elif coarse_grid_mode == "never":
-            assert not sfc_forcing.use_coarse_grid
-            assert "Data will be interpolated onto fine grid." in caplog.text
+    Verifies that the SurfaceForcing object is correctly initialized with global data,
+    including the correct handling of the grid and physics data. Checks both coarse and
+    fine grid initialization.
+    """
 
-        sfc_forcing.plot("uwnd", time=0)
-        sfc_forcing.plot("vwnd", time=0)
-        sfc_forcing.plot("rain", time=0)
+    fname = Path(download_test_data("ERA5_global_test_data.nc"))
+    grid = request.getfixturevalue(grid_fixture)
+
+    for coarse_grid_mode in ["always", "never"]:
+        _test_successful_initialization(
+            grid=grid,
+            start_time=datetime(2020, 1, 31),
+            end_time=datetime(2020, 2, 2),
+            source={"name": "ERA5", "path": fname, "climatology": False},
+            coarse_grid_mode=coarse_grid_mode,
+            use_dask=use_dask,
+            caplog=caplog,
+        )
 
 
 @pytest.mark.parametrize(
@@ -290,67 +347,6 @@ def test_no_longitude_intersection_initialization_with_regional_data(
             )
 
 
-@pytest.mark.parametrize(
-    "grid_fixture",
-    [
-        "grid_that_straddles_dateline",
-        "grid_that_lies_east_of_dateline_less_than_five_degrees_away",
-        "grid_that_lies_east_of_dateline_more_than_five_degrees_away",
-        "grid_that_lies_west_of_dateline_less_than_five_degrees_away",
-        "grid_that_lies_west_of_dateline_more_than_five_degrees_away",
-        "grid_that_straddles_dateline_but_is_too_big_for_regional_test_data",
-        "another_grid_that_straddles_dateline_but_is_too_big_for_regional_test_data",
-        "grid_that_straddles_180_degree_meridian",
-    ],
-)
-def test_successful_initialization_with_global_data(grid_fixture, request, use_dask):
-    """Test initialization of SurfaceForcing with global data.
-
-    Verifies that the SurfaceForcing object is correctly initialized with global data,
-    including the correct handling of the grid and physics data. Checks both coarse and
-    fine grid initialization.
-    """
-    start_time = datetime(2020, 1, 31)
-    end_time = datetime(2020, 2, 2)
-
-    fname = Path(download_test_data("ERA5_global_test_data.nc"))
-
-    grid = request.getfixturevalue(grid_fixture)
-
-    for coarse_grid_mode in ["always", "never"]:
-        sfc_forcing = SurfaceForcing(
-            grid=grid,
-            coarse_grid_mode=coarse_grid_mode,
-            start_time=start_time,
-            end_time=end_time,
-            source={"name": "ERA5", "path": fname},
-            use_dask=use_dask,
-        )
-        assert sfc_forcing.start_time == start_time
-        assert sfc_forcing.end_time == end_time
-        assert sfc_forcing.type == "physics"
-        assert sfc_forcing.source == {
-            "name": "ERA5",
-            "path": fname,
-            "climatology": False,
-        }
-
-        assert "uwnd" in sfc_forcing.ds
-        assert "vwnd" in sfc_forcing.ds
-        assert "swrad" in sfc_forcing.ds
-        assert "lwrad" in sfc_forcing.ds
-        assert "Tair" in sfc_forcing.ds
-        assert "qair" in sfc_forcing.ds
-        assert "rain" in sfc_forcing.ds
-        assert sfc_forcing.ds.attrs["source"] == "ERA5"
-        assert sfc_forcing.ds.coords["time"].attrs["units"] == "days"
-
-        if coarse_grid_mode == "always":
-            assert sfc_forcing.use_coarse_grid
-        elif coarse_grid_mode == "never":
-            assert not sfc_forcing.use_coarse_grid
-
-
 def test_start_time_end_time_error(use_dask):
     """Test error when start_time and end_time are not both provided or both None."""
     # Case 1: Only start_time provided
@@ -525,8 +521,6 @@ def test_surface_forcing_creation(
     for time_coord in ["pco2_time", "iron_time", "dust_time", "nox_time", "nhy_time"]:
         assert sfc_forcing.ds.coords[time_coord].attrs["units"] == "days"
 
-    sfc_forcing.plot("pco2_air", time=0)
-
 
 @pytest.mark.parametrize(
     "sfc_forcing_fixture",
@@ -546,6 +540,19 @@ def test_surface_forcing_pco2_replication(sfc_forcing_fixture, request):
     )
 
 
+def test_computed_missing_optional_fields(bgc_surface_forcing_from_unified_climatology):
+    ds = bgc_surface_forcing_from_unified_climatology.ds
+
+    # Use tight tolerances because 'nox' and 'nhy' can have values order 1e-12
+
+    # 'nhy' was missing in the source data and should have been filled with a constant default value
+    assert np.allclose(
+        ds.nhy.std(), 0.0, rtol=1e-13, atol=1e-13
+    ), "NHy should be constant across space and time"
+    # 'nox' was present in the source data and should show spatial or temporal variability
+    assert ds.nox.std() > 1e-13, "NOx should vary across space and time"
+
+
 def test_determine_usage_coarse_grid():
     # ERA5 data with 1/4 degree resolution spanning [-50E, 30E] and [40N, 80N]
     fname = download_test_data("ERA5_regional_test_data.nc")
@@ -597,19 +604,64 @@ def test_determine_usage_coarse_grid():
     assert surface_forcing.use_coarse_grid
 
 
+def test_apply_wind_correction(surface_forcing):
+
+    uwnd = surface_forcing.ds["uwnd"]
+    vwnd = surface_forcing.ds["vwnd"]
+
+    prev_coords = surface_forcing.target_coords.copy()
+    uwnd_corr, vwnd_corr = surface_forcing._apply_wind_correction(uwnd, vwnd)
+
+    assert isinstance(uwnd_corr, xr.DataArray)
+    assert isinstance(vwnd_corr, xr.DataArray)
+
+    # sanity check that the degrees conversion doesn't change the coords on our xarray
+    assert prev_coords == surface_forcing.target_coords
+
+    # Wind correction should not increase magnitude
+    assert (abs(uwnd_corr) <= abs(uwnd)).all()
+    assert (abs(vwnd_corr) <= abs(vwnd)).all()
+
+    # Direction (sign) should be preserved
+    assert (np.sign(uwnd_corr) == np.sign(uwnd)).all()
+    assert (np.sign(vwnd_corr) == np.sign(vwnd)).all()
+
+    # the ratio should be 1 far away, and 0.6 over/near land
+    assert np.isclose((uwnd_corr / uwnd).max(), 1.0)
+    assert np.isclose((vwnd_corr / vwnd).max(), 1.0)
+
+    assert np.isclose((uwnd_corr / uwnd).min(), 0.6)
+    assert np.isclose((vwnd_corr / vwnd).min(), 0.6)
+
+
 @pytest.mark.parametrize(
     "sfc_forcing_fixture",
     [
         "surface_forcing",
         "corrected_surface_forcing",
+        "surface_forcing_with_wind_dropoff",
         "coarse_surface_forcing",
     ],
 )
-def test_surface_forcing_save(sfc_forcing_fixture, request, tmp_path):
+def test_surface_forcing_plot(sfc_forcing_fixture, request, tmp_path):
     """Test save method."""
     sfc_forcing = request.getfixturevalue(sfc_forcing_fixture)
     sfc_forcing.plot(var_name="uwnd", time=0)
 
+
+@pytest.mark.parametrize(
+    "sfc_forcing_fixture",
+    [
+        "surface_forcing",
+        "corrected_surface_forcing",
+        "surface_forcing_with_wind_dropoff",
+        "coarse_surface_forcing",
+    ],
+)
+def test_surface_forcing_save(sfc_forcing_fixture, request, tmp_path):
+    """Test save method."""
+    sfc_forcing = request.getfixturevalue(sfc_forcing_fixture)
+
     for file_str in ["test_sf", "test_sf.nc"]:
         # Create a temporary filepath using the tmp_path fixture
         for filepath in [
@@ -634,10 +686,18 @@ def test_surface_forcing_save(sfc_forcing_fixture, request, tmp_path):
             expected_filepath.unlink()
 
 
-def test_surface_forcing_bgc_plot(bgc_surface_forcing):
+@pytest.mark.parametrize(
+    "sfc_forcing_fixture",
+    [
+        "bgc_surface_forcing",
+        "bgc_surface_forcing_from_climatology",
+        "bgc_surface_forcing_from_unified_climatology",
+    ],
+)
+def test_surface_forcing_bgc_plot(sfc_forcing_fixture, request):
     """Test plot method."""
-
-    bgc_surface_forcing.plot(var_name="pco2_air", time=0)
+    sfc_forcing = request.getfixturevalue(sfc_forcing_fixture)
+    sfc_forcing.plot(var_name="pco2_air", time=0)
 
 
 def test_surface_forcing_bgc_save(bgc_surface_forcing, tmp_path):
@@ -713,6 +773,7 @@ def test_surface_forcing_bgc_from_clim_save(sfc_forcing_fixture, tmp_path, reque
         "surface_forcing",
         "coarse_surface_forcing",
         "corrected_surface_forcing",
+        "surface_forcing_with_wind_dropoff",
         "bgc_surface_forcing",
         "bgc_surface_forcing_from_climatology",
         "bgc_surface_forcing_from_unified_climatology",
@@ -746,6 +807,7 @@ def test_roundtrip_yaml(sfc_forcing_fixture, request, tmp_path, use_dask):
     [
         "surface_forcing",
         "corrected_surface_forcing",
+        "surface_forcing_with_wind_dropoff",
         "coarse_surface_forcing",
         "bgc_surface_forcing",
     ],
@@ -856,3 +918,35 @@ def test_from_yaml_missing_surface_forcing(tmp_path, use_dask):
             SurfaceForcing.from_yaml(yaml_filepath, use_dask=use_dask)
         yaml_filepath = Path(yaml_filepath)
         yaml_filepath.unlink()
+
+
+@pytest.mark.stream
+def test_surface_forcing_arco(surface_forcing_arco, tmp_path):
+    """One big integration test for cloud-based ERA5 data because the streaming takes a
+    long time."""
+
+    # Test plotting
+    surface_forcing_arco.plot(var_name="uwnd", time=0)
+
+    # Roundtrip yaml
+    yaml_filepath = tmp_path / "test_yaml.yaml"
+    surface_forcing_arco.to_yaml(yaml_filepath)
+    sfc_forcing_from_yaml = SurfaceForcing.from_yaml(yaml_filepath, use_dask=True)
+    assert surface_forcing_arco == sfc_forcing_from_yaml
+
+    # Compare hashes
+    filepath1 = tmp_path / "test1.nc"
+    filepath2 = tmp_path / "test2.nc"
+    surface_forcing_arco.save(filepath1, group=True)
+    sfc_forcing_from_yaml.save(filepath2, group=True)
+    filepath_str1 = str(Path(filepath1).with_suffix(""))
+    filepath_str2 = str(Path(filepath2).with_suffix(""))
+    expected_filepath1 = f"{filepath_str1}_202002.nc"
+    expected_filepath2 = f"{filepath_str2}_202002.nc"
+    hash1 = calculate_data_hash(expected_filepath1)
+    hash2 = calculate_data_hash(expected_filepath2)
+    assert hash1 == hash2, f"Hashes do not match: {hash1} != {hash2}"
+
+    yaml_filepath.unlink()
+    Path(expected_filepath1).unlink()
+    Path(expected_filepath2).unlink()

roms_tools/tests/test_setup/test_tides.py

@@ -1,10 +1,12 @@
-import pytest
-from roms_tools import Grid, TidalForcing
-import xarray as xr
-from roms_tools.download import download_test_data
 import textwrap
 from pathlib import Path
+
+import pytest
+import xarray as xr
+
 from conftest import calculate_data_hash
+from roms_tools import Grid, TidalForcing
+from roms_tools.download import download_test_data
 
 
 @pytest.fixture(scope="session")

roms_tools/tests/test_setup/test_utils.py

@@ -1,12 +1,16 @@
-from roms_tools import Grid, BoundaryForcing
-from roms_tools.setup.utils import interpolate_from_climatology
-from roms_tools.setup.datasets import ERA5Correction
-from roms_tools.download import download_test_data
-import xarray as xr
-import pytest
 from datetime import datetime
 from pathlib import Path
 
+import pytest
+import xarray as xr
+
+from roms_tools import BoundaryForcing, Grid
+from roms_tools.download import download_test_data
+from roms_tools.setup.datasets import ERA5Correction
+from roms_tools.setup.utils import (
+    interpolate_from_climatology,
+)
+
 
 def test_interpolate_from_climatology(use_dask):
 

roms_tools/tests/test_setup/test_validation.py

@@ -1,6 +1,7 @@
-import pytest
 import os
 import shutil
+
+import pytest
 import xarray as xr
 
 
@@ -78,7 +79,10 @@ def test_check_results(forcing_fixture, request):
     expected_forcing_ds = xr.open_zarr(fname, decode_timedelta=False)
     forcing = request.getfixturevalue(forcing_fixture)
 
-    xr.testing.assert_allclose(forcing.ds, expected_forcing_ds, rtol=1.0e-5, atol=1e-08)
+    # Set small tolerance because some fields like NOx, NHy have values order 1e-12
+    xr.testing.assert_allclose(
+        forcing.ds, expected_forcing_ds, rtol=1.0e-12, atol=1e-13
+    )
 
 
 @pytest.mark.parametrize(