Fix tests by passing interp_method

Author: fluidnumericsJoe

tests/test_advection.py

@@ -362,8 +362,8 @@ def test_stommelgyre_fieldset(kernel, rtol, grid_type):
     ds = stommel_gyre_dataset(grid_type=grid_type)
     grid = XGrid.from_dataset(ds)
     vector_interp_method = None if grid_type == "A" else CGrid_Velocity
-    U = Field("U", ds["U"], grid)
-    V = Field("V", ds["V"], grid)
+    U = Field("U", ds["U"], grid, interp_method=XLinear)
+    V = Field("V", ds["V"], grid, interp_method=XLinear)
     P = Field("P", ds["P"], grid, interp_method=XLinear)
     UV = VectorField("UV", U, V, vector_interp_method=vector_interp_method)
     fieldset = FieldSet([U, V, P, UV])
@@ -451,8 +451,8 @@ def test_nemo_curvilinear_fieldset():
     )
     grid = XGrid(xgcm_grid, mesh="spherical")
 
-    U = parcels.Field("U", ds["U"], grid)
-    V = parcels.Field("V", ds["V"], grid)
+    U = parcels.Field("U", ds["U"], grid, interp_method=XLinear)
+    V = parcels.Field("V", ds["V"], grid, interp_method=XLinear)
     U.units = parcels.GeographicPolar()
     V.units = parcels.GeographicPolar()  # U and V need GoegraphicPolar for  C-Grid interpolation to work correctly
     UV = parcels.VectorField("UV", U, V, vector_interp_method=CGrid_Velocity)
@@ -536,9 +536,9 @@ def test_nemo_3D_curvilinear_fieldset(kernel):
     )
     grid = XGrid(xgcm_grid, mesh="spherical")
 
-    U = parcels.Field("U", ds["U"], grid)
-    V = parcels.Field("V", ds["V"], grid)
-    W = parcels.Field("W", ds["W"], grid)
+    U = parcels.Field("U", ds["U"], grid, interp_method=XLinear)
+    V = parcels.Field("V", ds["V"], grid, interp_method=XLinear)
+    W = parcels.Field("W", ds["W"], grid, interp_method=XLinear)
     U.units = parcels.GeographicPolar()
     V.units = parcels.GeographicPolar()  # U and V need GoegraphicPolar for C-Grid interpolation to work correctly
     UV = parcels.VectorField("UV", U, V, vector_interp_method=CGrid_Velocity)

tests/test_field.py

@@ -9,37 +9,37 @@
 from parcels._datasets.structured.generic import T as T_structured
 from parcels._datasets.structured.generic import datasets as datasets_structured
 from parcels._datasets.unstructured.generic import datasets as datasets_unstructured
-from parcels.interpolators import UXPiecewiseConstantFace, UXPiecewiseLinearNode
+from parcels.interpolators import UXPiecewiseConstantFace, UXPiecewiseLinearNode, XLinear
 
 
 def test_field_init_param_types():
     data = datasets_structured["ds_2d_left"]
     grid = XGrid.from_dataset(data)
 
     with pytest.raises(TypeError, match="Expected a string for variable name, got int instead."):
-        Field(name=123, data=data["data_g"], grid=grid)
+        Field(name=123, data=data["data_g"], grid=grid, interp_method=XLinear)
 
     for name in ["a b", "123"]:
         with pytest.raises(
             ValueError,
             match=r"Received invalid Python variable name.*: not a valid identifier. HINT: avoid using spaces, special characters, and starting with a number.",
         ):
-            Field(name=name, data=data["data_g"], grid=grid)
+            Field(name=name, data=data["data_g"], grid=grid, interp_method=XLinear)
 
     with pytest.raises(
         ValueError,
         match=r"Received invalid Python variable name.*: it is a reserved keyword. HINT: avoid using the following names:.*",
     ):
-        Field(name="while", data=data["data_g"], grid=grid)
+        Field(name="while", data=data["data_g"], grid=grid, interp_method=XLinear)
 
     with pytest.raises(
         ValueError,
         match="Expected `data` to be a uxarray.UxDataArray or xarray.DataArray",
     ):
-        Field(name="test", data=123, grid=grid)
+        Field(name="test", data=123, grid=grid, interp_method=XLinear)
 
     with pytest.raises(ValueError, match="Expected `grid` to be a parcels UxGrid, or parcels XGrid"):
-        Field(name="test", data=data["data_g"], grid=123)
+        Field(name="test", data=data["data_g"], grid=123, interp_method=XLinear)
 
 
 @pytest.mark.parametrize(
@@ -66,6 +66,7 @@ def test_field_incompatible_combination(data, grid):
             name="test_field",
             data=data,
             grid=grid,
+            interp_method=XLinear,
         )
 
 
@@ -85,6 +86,7 @@ def test_field_init_structured_grid(data, grid):
         name="test_field",
         data=data,
         grid=grid,
+        interp_method=XLinear,
     )
     assert field.name == "test_field"
     assert field.data.equals(data)
@@ -113,6 +115,7 @@ def test_field_init_fail_on_float_time_dim():
             name="test_field",
             data=data,
             grid=grid,
+            interp_method=XLinear,
         )
 
 
@@ -128,7 +131,7 @@ def test_field_init_fail_on_float_time_dim():
 )
 def test_field_time_interval(data, grid):
     """Test creating a field."""
-    field = Field(name="test_field", data=data, grid=grid)
+    field = Field(name="test_field", data=data, grid=grid, interp_method=XLinear)
     assert field.time_interval.left == np.datetime64("2000-01-01")
     assert field.time_interval.right == np.datetime64("2001-01-01")
 
@@ -163,8 +166,8 @@ def invalid_interpolator_wrong_signature(particle_positions, grid_positions, inv
         return 0.0
 
     # Create component fields
-    U = Field(name="U", data=ds["data_g"], grid=grid)
-    V = Field(name="V", data=ds["data_g"], grid=grid)
+    U = Field(name="U", data=ds["data_g"], grid=grid, interp_method=XLinear)
+    V = Field(name="V", data=ds["data_g"], grid=grid, interp_method=XLinear)
 
     # Test invalid interpolator with wrong signature
     with pytest.raises(ValueError, match=".*incorrect name.*"):

tests/test_fieldset.py

@@ -12,6 +12,7 @@
 from parcels._datasets.structured.generic import T as T_structured
 from parcels._datasets.structured.generic import datasets as datasets_structured
 from parcels._datasets.unstructured.generic import datasets as datasets_unstructured
+from parcels.interpolators import XLinear
 from tests import utils
 
 ds = datasets_structured["ds_2d_left"]
@@ -21,8 +22,8 @@
 def fieldset() -> FieldSet:
     """Fixture to create a FieldSet object for testing."""
     grid = XGrid.from_dataset(ds, mesh="flat")
-    U = Field("U", ds["U_A_grid"], grid)
-    V = Field("V", ds["V_A_grid"], grid)
+    U = Field("U", ds["U_A_grid"], grid, interp_method=XLinear)
+    V = Field("V", ds["V_A_grid"], grid, interp_method=XLinear)
     UV = VectorField("UV", U, V)
 
     return FieldSet(
@@ -65,7 +66,7 @@ def test_fieldset_add_constant_field(fieldset):
 
 def test_fieldset_add_field(fieldset):
     grid = XGrid.from_dataset(ds, mesh="flat")
-    field = Field("test_field", ds["U_A_grid"], grid)
+    field = Field("test_field", ds["U_A_grid"], grid, interp_method=XLinear)
     fieldset.add_field(field)
     assert fieldset.test_field == field
 
@@ -78,7 +79,7 @@ def test_fieldset_add_field_wrong_type(fieldset):
 
 def test_fieldset_add_field_already_exists(fieldset):
     grid = XGrid.from_dataset(ds, mesh="flat")
-    field = Field("test_field", ds["U_A_grid"], grid)
+    field = Field("test_field", ds["U_A_grid"], grid, interp_method=XLinear)
     fieldset.add_field(field, "test_field")
     with pytest.raises(ValueError, match="FieldSet already has a Field with name 'test_field'"):
         fieldset.add_field(field, "test_field")
@@ -96,7 +97,7 @@ def test_fieldset_gridset(fieldset):
 
 def test_fieldset_no_UV(tmp_zarrfile):
     grid = XGrid.from_dataset(ds, mesh="flat")
-    fieldset = FieldSet([Field("P", ds["U_A_grid"], grid)])
+    fieldset = FieldSet([Field("P", ds["U_A_grid"], grid, interp_method=XLinear)])
 
     def SampleP(particles, fieldset):
         particles.dlon += fieldset.P[particles]
@@ -114,7 +115,7 @@ def test_fieldset_from_structured_generic_datasets(ds):
     grid = XGrid.from_dataset(ds, mesh="flat")
     fields = []
     for var in ds.data_vars:
-        fields.append(Field(var, ds[var], grid))
+        fields.append(Field(var, ds[var], grid, interp_method=XLinear))
 
     fieldset = FieldSet(fields)
 
@@ -130,12 +131,12 @@ def test_fieldset_gridset_multiple_grids(): ...
 
 def test_fieldset_time_interval():
     grid1 = XGrid.from_dataset(ds, mesh="flat")
-    field1 = Field("field1", ds["U_A_grid"], grid1)
+    field1 = Field("field1", ds["U_A_grid"], grid1, interp_method=XLinear)
 
     ds2 = ds.copy()
     ds2["time"] = (ds2["time"].dims, ds2["time"].data + np.timedelta64(timedelta(days=1)), ds2["time"].attrs)
     grid2 = XGrid.from_dataset(ds2, mesh="flat")
-    field2 = Field("field2", ds2["U_A_grid"], grid2)
+    field2 = Field("field2", ds2["U_A_grid"], grid2, interp_method=XLinear)
 
     fieldset = FieldSet([field1, field2])
     fieldset.add_constant_field("constant_field", 1.0)
@@ -161,8 +162,8 @@ def test_fieldset_init_incompatible_calendars():
     )
 
     grid = XGrid.from_dataset(ds1, mesh="flat")
-    U = Field("U", ds1["U_A_grid"], grid)
-    V = Field("V", ds1["V_A_grid"], grid)
+    U = Field("U", ds1["U_A_grid"], grid, interp_method=XLinear)
+    V = Field("V", ds1["V_A_grid"], grid, interp_method=XLinear)
     UV = VectorField("UV", U, V)
 
     ds2 = ds.copy()
@@ -172,7 +173,7 @@ def test_fieldset_init_incompatible_calendars():
         ds2["time"].attrs,
     )
     grid2 = XGrid.from_dataset(ds2, mesh="flat")
-    incompatible_calendar = Field("test", ds2["data_g"], grid2)
+    incompatible_calendar = Field("test", ds2["data_g"], grid2, interp_method=XLinear)
 
     with pytest.raises(CalendarError, match="Expected field '.*' to have calendar compatible with datetime object"):
         FieldSet([U, V, UV, incompatible_calendar])
@@ -186,7 +187,7 @@ def test_fieldset_add_field_incompatible_calendars(fieldset):
         ds_test["time"].attrs,
     )
     grid = XGrid.from_dataset(ds_test, mesh="flat")
-    field = Field("test_field", ds_test["data_g"], grid)
+    field = Field("test_field", ds_test["data_g"], grid, interp_method=XLinear)
 
     with pytest.raises(CalendarError, match="Expected field '.*' to have calendar compatible with datetime object"):
         fieldset.add_field(field, "test_field")
@@ -198,7 +199,7 @@ def test_fieldset_add_field_incompatible_calendars(fieldset):
         ds_test["time"].attrs,
     )
     grid = XGrid.from_dataset(ds_test, mesh="flat")
-    field = Field("test_field", ds_test["data_g"], grid)
+    field = Field("test_field", ds_test["data_g"], grid, interp_method=XLinear)
 
     with pytest.raises(CalendarError, match="Expected field '.*' to have calendar compatible with datetime object"):
         fieldset.add_field(field, "test_field")
@@ -328,8 +329,8 @@ def test_fieldset_from_fesom2_missingUV():
         _ = FieldSet.from_fesom2(localds)
     assert "Dataset has only one of the two variables 'U' and 'V'" in str(info)
 
-    # Intentionally create a dataset that is missing both U and V
-    localds = ds.rename({"U": "notU", "V": "notV"})
+    # Intentionally create a dataset that is missing the V field
+    localds = ds.rename({"V": "notV"})
     with pytest.raises(ValueError) as info:
         _ = FieldSet.from_fesom2(localds)
-    assert "Dataset has neither 'U' nor 'V' in potential options " in str(info)
+    assert "Dataset has only one of the two variables 'U' and 'V'" in str(info)

tests/test_index_search.py

@@ -7,6 +7,7 @@
 from parcels._core.index_search import _search_indices_curvilinear_2d
 from parcels._datasets.structured.generic import datasets
 from parcels._tutorial import download_example_dataset
+from parcels.interpolators import XLinear
 
 
 @pytest.fixture
@@ -17,6 +18,7 @@ def field_cone():
         name="test_field",
         data=ds["data_g"],
         grid=grid,
+        interp_method=XLinear,
     )
     return field
 

tests/test_interpolation.py

@@ -9,17 +9,13 @@
     ParticleFile,
     ParticleSet,
     StatusCode,
-    UxGrid,
     Variable,
     VectorField,
     XGrid,
 )
 from parcels._core.index_search import _search_time_index
 from parcels._datasets.structured.generated import simple_UV_dataset
-from parcels._datasets.unstructured.generic import datasets as datasets_unstructured
 from parcels.interpolators import (
-    UXPiecewiseConstantFace,
-    UXPiecewiseLinearNode,
     XFreeslip,
     XLinear,
     XLinearInvdistLandTracer,
@@ -56,7 +52,7 @@ def field():
             "y": (["y"], [0.5, 1.5, 2.5, 3.5], {"axis": "Y"}),
         },
     )
-    return Field("U", ds["U"], XGrid.from_dataset(ds))
+    return Field("U", ds["U"], XGrid.from_dataset(ds), interp_method=XLinear)
 
 
 @pytest.mark.parametrize(
@@ -189,20 +185,6 @@ def test_interpolation_mesh_type(mesh, npart=10):
     assert U.eval(time, 0, lat, 0, applyConversion=False) == 1
 
 
-def test_default_interpolator_set_correctly():
-    ds = simple_UV_dataset()
-    grid = XGrid.from_dataset(ds)
-    U = Field("U", ds["U"], grid)
-    assert U.interp_method == XLinear
-
-    ds = datasets_unstructured["stommel_gyre_delaunay"]
-    grid = UxGrid(grid=ds.uxgrid, z=ds.coords["nz"])
-    U = Field("U", ds["U"], grid)
-    assert U.interp_method == UXPiecewiseConstantFace
-    W = Field("W", ds["W"], grid)
-    assert W.interp_method == UXPiecewiseLinearNode
-
-
 interp_methods = {
     "linear": XLinear,
 }

tests/test_kernel.py

@@ -10,6 +10,7 @@
     XGrid,
 )
 from parcels._datasets.structured.generic import datasets as datasets_structured
+from parcels.interpolators import XLinear
 from parcels.kernels import AdvectionRK4
 from tests.common_kernels import MoveEast, MoveNorth
 
@@ -18,8 +19,8 @@
 def fieldset() -> FieldSet:
     ds = datasets_structured["ds_2d_left"]
     grid = XGrid.from_dataset(ds, mesh="flat")
-    U = Field("U", ds["U_A_grid"], grid)
-    V = Field("V", ds["V_A_grid"], grid)
+    U = Field("U", ds["U_A_grid"], grid, interp_method=XLinear)
+    V = Field("V", ds["V_A_grid"], grid, interp_method=XLinear)
     return FieldSet([U, V])
 
 

tests/test_particlefile.py

@@ -22,6 +22,7 @@
 from parcels._core.particle import Particle, create_particle_data, get_default_particle
 from parcels._core.utils.time import TimeInterval
 from parcels._datasets.structured.generic import datasets
+from parcels.interpolators import XLinear
 from parcels.kernels import AdvectionRK4
 from tests.common_kernels import DoNothing
 
@@ -31,8 +32,8 @@ def fieldset() -> FieldSet:  # TODO v4: Move into a `conftest.py` file and remov
     """Fixture to create a FieldSet object for testing."""
     ds = datasets["ds_2d_left"]
     grid = XGrid.from_dataset(ds)
-    U = Field("U", ds["U_A_grid"], grid)
-    V = Field("V", ds["V_A_grid"], grid)
+    U = Field("U", ds["U_A_grid"], grid, XLinear)
+    V = Field("V", ds["V_A_grid"], grid, XLinear)
     UV = VectorField("UV", U, V)
 
     return FieldSet(
@@ -228,7 +229,9 @@ def test_write_timebackward(fieldset, tmp_zarrfile):
 @pytest.mark.v4alpha
 def test_write_xiyi(fieldset, tmp_zarrfile):
     fieldset.U.data[:] = 1  # set a non-zero zonal velocity
-    fieldset.add_field(Field(name="P", data=np.zeros((3, 20)), lon=np.linspace(0, 1, 20), lat=[-2, 0, 2]))
+    fieldset.add_field(
+        Field(name="P", data=np.zeros((3, 20)), lon=np.linspace(0, 1, 20), lat=[-2, 0, 2], interp_method=XLinear)
+    )
     dt = np.timedelta64(3600, "s")
 
     particle = get_default_particle(np.float64)

tests/test_particleset.py

@@ -16,6 +16,7 @@
     XGrid,
 )
 from parcels._datasets.structured.generic import datasets as datasets_structured
+from parcels.interpolators import XLinear
 from tests.common_kernels import DoNothing
 from tests.utils import round_and_hash_float_array
 
@@ -24,8 +25,8 @@
 def fieldset() -> FieldSet:
     ds = datasets_structured["ds_2d_left"]
     grid = XGrid.from_dataset(ds, mesh="flat")
-    U = Field("U", ds["U_A_grid"], grid)
-    V = Field("V", ds["V_A_grid"], grid)
+    U = Field("U", ds["U_A_grid"], grid, interp_method=XLinear)
+    V = Field("V", ds["V_A_grid"], grid, interp_method=XLinear)
     return FieldSet([U, V])