diff --git a/docs/user_guide/examples_v3/example_brownian.py b/docs/user_guide/examples_v3/example_brownian.py index 7d53b6fd8..49248f513 100644 --- a/docs/user_guide/examples_v3/example_brownian.py +++ b/docs/user_guide/examples_v3/example_brownian.py @@ -36,8 +36,8 @@ def test_brownian_example(mesh, npart=3000): pset = parcels.ParticleSet( fieldset=fieldset, pclass=parcels.Particle, - lon=np.zeros(npart), - lat=np.zeros(npart), + x=np.zeros(npart), + y=np.zeros(npart), ) pset.execute( pset.Kernel(parcels.kernels.DiffusionUniformKh), diff --git a/docs/user_guide/examples_v3/example_decaying_moving_eddy.py b/docs/user_guide/examples_v3/example_decaying_moving_eddy.py index 01e6c401d..42ce5afdd 100644 --- a/docs/user_guide/examples_v3/example_decaying_moving_eddy.py +++ b/docs/user_guide/examples_v3/example_decaying_moving_eddy.py @@ -69,7 +69,7 @@ def true_values( def decaying_moving_example(fieldset, outfile, method=parcels.kernels.AdvectionRK4): pset = parcels.ParticleSet( - fieldset, pclass=parcels.Particle, lon=start_lon, lat=start_lat + fieldset, pclass=parcels.Particle, x=start_lon, y=start_lat ) dt = timedelta(minutes=5) diff --git a/docs/user_guide/examples_v3/example_globcurrent.py b/docs/user_guide/examples_v3/example_globcurrent.py index 622adea81..ba7d3f55b 100755 --- a/docs/user_guide/examples_v3/example_globcurrent.py +++ b/docs/user_guide/examples_v3/example_globcurrent.py @@ -70,7 +70,7 @@ def test_globcurrent_particles(): latstart = [-35] pset = parcels.ParticleSet( - fieldset, pclass=parcels.Particle, lon=lonstart, lat=latstart + fieldset, pclass=parcels.Particle, x=lonstart, y=latstart ) pset.execute( @@ -91,29 +91,29 @@ def test__particles_init_time(): pset = parcels.ParticleSet( fieldset, pclass=parcels.Particle, - lon=lonstart, - lat=latstart, + x=lonstart, + y=latstart, time=np.datetime64("2002-01-15"), ) pset2 = parcels.ParticleSet( fieldset, pclass=parcels.Particle, - lon=lonstart, - lat=latstart, + x=lonstart, + y=latstart, time=14 * 86400, ) pset3 = parcels.ParticleSet( fieldset, pclass=parcels.Particle, - lon=lonstart, - lat=latstart, + x=lonstart, + y=latstart, time=np.array([np.datetime64("2002-01-15")]), ) pset4 = parcels.ParticleSet( fieldset, pclass=parcels.Particle, - lon=lonstart, - lat=latstart, + x=lonstart, + y=latstart, time=[np.datetime64("2002-01-15")], ) assert pset[0].time - pset2[0].time == 0 @@ -126,8 +126,8 @@ def test_globcurrent_outside_time_interval_error(): pset = parcels.ParticleSet( fieldset, pclass=parcels.Particle, - lon=[25], - lat=[-35], + x=[25], + y=[-35], time=fieldset.U.grid.time[0] - timedelta(days=1).total_seconds(), ) with pytest.raises(parcels.OutsideTimeInterval): @@ -173,10 +173,10 @@ def SampleP(particle, fieldset, time): # pragma: no cover if with_starttime: time = fieldset.U.grid.time[0] if dt > 0 else fieldset.U.grid.time[-1] pset = parcels.ParticleSet( - fieldset, pclass=MyParticle, lon=[25], lat=[-35], time=time + fieldset, pclass=MyParticle, x=[25], y=[-35], time=time ) else: - pset = parcels.ParticleSet(fieldset, pclass=MyParticle, lon=[25], lat=[-35]) + pset = parcels.ParticleSet(fieldset, pclass=MyParticle, x=[25], y=[-35]) if with_starttime: with pytest.raises(parcels.OutsideTimeInterval): @@ -202,7 +202,7 @@ def DeleteP0(particle, fieldset, time): # pragma: no cover particle.delete() pset0 = parcels.ParticleSet( - fieldset, pclass=parcels.Particle, lon=[25, 25], lat=[-35, -35], time=time0 + fieldset, pclass=parcels.Particle, x=[25, 25], y=[-35, -35], time=time0 ) pset0.execute( @@ -212,7 +212,7 @@ def DeleteP0(particle, fieldset, time): # pragma: no cover ) pset1 = parcels.ParticleSet( - fieldset, pclass=parcels.Particle, lon=[25, 25], lat=[-35, -35], time=time0 + fieldset, pclass=parcels.Particle, x=[25, 25], y=[-35, -35], time=time0 ) pset1.execute( @@ -231,7 +231,7 @@ def test_globcurrent_pset_fromfile(dt, pid_offset, tmpdir): fieldset = set_globcurrent_fieldset() parcels.Particle.setLastID(pid_offset) - pset = parcels.ParticleSet(fieldset, pclass=parcels.Particle, lon=25, lat=-35) + pset = parcels.ParticleSet(fieldset, pclass=parcels.Particle, x=25, y=-35) pfile = pset.ParticleFile(filename, outputdt=timedelta(hours=6)) pset.execute( parcels.kernels.AdvectionRK4, @@ -265,7 +265,7 @@ def test_error_outputdt_not_multiple_dt(tmpdir): dt = 81.2584344538292 # number for which output writing fails - pset = parcels.ParticleSet(fieldset, pclass=parcels.Particle, lon=[0], lat=[0]) + pset = parcels.ParticleSet(fieldset, pclass=parcels.Particle, x=[0], y=[0]) ofile = pset.ParticleFile(name=filepath, outputdt=timedelta(days=1)) def DoNothing(particle, fieldset, time): # pragma: no cover diff --git a/docs/user_guide/examples_v3/example_moving_eddies.py b/docs/user_guide/examples_v3/example_moving_eddies.py index 348e21b32..169250a67 100644 --- a/docs/user_guide/examples_v3/example_moving_eddies.py +++ b/docs/user_guide/examples_v3/example_moving_eddies.py @@ -166,7 +166,7 @@ def test_moving_eddies_fwdbwd(mesh, tmpdir, npart=2): lons = [3.3, 3.3] if fieldset.U.grid.mesh == "spherical" else [3.3e5, 3.3e5] lats = [46.0, 47.8] if fieldset.U.grid.mesh == "spherical" else [1e5, 2.8e5] pset = parcels.ParticleSet( - fieldset=fieldset, pclass=parcels.Particle, lon=lons, lat=lats + fieldset=fieldset, pclass=parcels.Particle, x=lons, y=lats ) # Execte for 14 days, with 30sec timesteps and hourly output diff --git a/docs/user_guide/examples_v3/example_ofam.py b/docs/user_guide/examples_v3/example_ofam.py index 4b68011d3..036540d33 100644 --- a/docs/user_guide/examples_v3/example_ofam.py +++ b/docs/user_guide/examples_v3/example_ofam.py @@ -49,12 +49,12 @@ def test_ofam_xarray_vs_netcdf(dt): lonstart, latstart, runtime = (180, 10, timedelta(days=7)) psetN = parcels.ParticleSet( - fieldsetNetcdf, pclass=parcels.Particle, lon=lonstart, lat=latstart + fieldsetNetcdf, pclass=parcels.Particle, x=lonstart, y=latstart ) psetN.execute(parcels.kernels.AdvectionRK4, runtime=runtime, dt=dt) psetX = parcels.ParticleSet( - fieldsetxarray, pclass=parcels.Particle, lon=lonstart, lat=latstart + fieldsetxarray, pclass=parcels.Particle, x=lonstart, y=latstart ) psetX.execute(parcels.kernels.AdvectionRK4, runtime=runtime, dt=dt) @@ -74,8 +74,8 @@ def test_ofam_particles(use_xarray): pset = parcels.ParticleSet( fieldset, pclass=parcels.Particle, - lon=lonstart, - lat=latstart, + x=lonstart, + y=latstart, depth=depstart, ) diff --git a/docs/user_guide/v4-migration.md b/docs/user_guide/v4-migration.md index b0452d745..421bebcf1 100644 --- a/docs/user_guide/v4-migration.md +++ b/docs/user_guide/v4-migration.md @@ -18,6 +18,7 @@ Version 4 of Parcels is unreleased at the moment. The information in this migrat - Users need to explicitly use `convert_z_to_sigma_croco` in sampling kernels (such as the `AdvectionRK4_3D_CROCO` or `SampleOMegaCroco` kernels) when working with CROCO data, as the automatic conversion from depth to sigma grids under the hood has been removed. - We added a new AdvectionRK2 Kernel. The AdvectionRK4 kernel is still available, but RK2 is now the recommended default advection scheme as it is faster while the accuracy is comparable for most applications. See also the Choosing an integration method tutorial. - Functions shouldn't be converted to Kernels before adding to a pset.execute() call. Instead, simply pass the function(s) as a list to pset.execute(). +- Kernel variables `lon` and `lat` have been renamed to `x` and `y`, and `dlon` and `dlat` have been renamed to `dx` and `dy`. These changes are also reflected on the ParticleSet as well as the particlefile output. ## FieldSet diff --git a/src/parcels/_compat.py b/src/parcels/_compat.py index 96c29433d..f3273dbc6 100644 --- a/src/parcels/_compat.py +++ b/src/parcels/_compat.py @@ -1,7 +1,7 @@ """Import helpers for compatability between installations.""" -# for compat with v3 of parcels when users provide `initial=attrgetter("lon")` to a Variable +# for compat with v3 of parcels when users provide `initial=attrgetter("...")` to a Variable # so that particle initial state matches another variable class _AttrgetterHelper: """ diff --git a/src/parcels/_core/field.py b/src/parcels/_core/field.py index 5248de828..7bd8565eb 100644 --- a/src/parcels/_core/field.py +++ b/src/parcels/_core/field.py @@ -184,7 +184,7 @@ def __getitem__(self, key): self._check_velocitysampling() try: if isinstance(key, ParticleSetView): - return self.eval(key.time, key.z, key.lat, key.lon, key) + return self.eval(key.time, key.z, key.y, key.x, key) else: return self.eval(*key) except tuple(AllParcelsErrorCodes.keys()) as error: @@ -293,7 +293,7 @@ def eval(self, time: datetime, z, y, x, particles=None): def __getitem__(self, key): try: if isinstance(key, ParticleSetView): - return self.eval(key.time, key.z, key.lat, key.lon, key) + return self.eval(key.time, key.z, key.y, key.x, key) else: return self.eval(*key) except tuple(AllParcelsErrorCodes.keys()) as error: @@ -389,7 +389,7 @@ def _assert_same_time_interval(fields: Sequence[Field]) -> None: def _get_positions(field: Field, time, z, y, x, particles, _ei) -> tuple[dict, dict]: """Initialize and populate particle_positions and grid_positions dictionaries""" - particle_positions = {"time": time, "z": z, "lat": y, "lon": x} + particle_positions = {"time": time, "z": z, "y": y, "x": x} grid_positions = {} grid_positions.update(_search_time_index(field, time)) grid_positions.update(field.grid.search(z, y, x, ei=_ei)) diff --git a/src/parcels/_core/kernel.py b/src/parcels/_core/kernel.py index ab1986353..fbd26f4e1 100644 --- a/src/parcels/_core/kernel.py +++ b/src/parcels/_core/kernel.py @@ -106,13 +106,13 @@ def remove_deleted(self, pset): pset.remove_indices(indices) def _position_update(self, particles, fieldset): - particles.lon += particles.dlon - particles.lat += particles.dlat + particles.x += particles.dx + particles.y += particles.dy particles.z += particles.dz particles.time += particles.dt - particles.dlon = 0 - particles.dlat = 0 + particles.dx = 0 + particles.dy = 0 particles.dz = 0 if hasattr(self.fieldset, "RK45_tol"): @@ -244,6 +244,6 @@ def execute(self, pset, endtime, dt): if error_code == StatusCode.ErrorOutsideTimeInterval: error_func(pset[inds].time) else: - error_func(pset[inds].z, pset[inds].lat, pset[inds].lon) + error_func(pset[inds].z, pset[inds].y, pset[inds].x) return pset diff --git a/src/parcels/_core/particle.py b/src/parcels/_core/particle.py index 322d313bb..cc047f142 100644 --- a/src/parcels/_core/particle.py +++ b/src/parcels/_core/particle.py @@ -141,18 +141,26 @@ def get_default_particle(spatial_dtype: type[np.float32] | type[np.float64]) -> attrs={"standard_name": "vertical coordinate", "units": "m", "positive": "down"}, ), Variable( - "lat", + "y", dtype=spatial_dtype, - attrs={"standard_name": "latitude", "units": "degrees_north", "axis": "Y"}, + attrs={ + "standard_name": "latitude", + "units": "degrees_north", + "axis": "Y", + }, # TODO v4: Update to ensure that units come from the model ), Variable( - "lon", + "x", dtype=spatial_dtype, - attrs={"standard_name": "longitude", "units": "degrees_east", "axis": "X"}, + attrs={ + "standard_name": "longitude", + "units": "degrees_east", + "axis": "X", + }, # TODO v4: Update to ensure that units come from the model ), Variable("dz", dtype=spatial_dtype, to_write=False), - Variable("dlat", dtype=spatial_dtype, to_write=False), - Variable("dlon", dtype=spatial_dtype, to_write=False), + Variable("dy", dtype=spatial_dtype, to_write=False), + Variable("dx", dtype=spatial_dtype, to_write=False), Variable( "particle_id", dtype=np.int64, diff --git a/src/parcels/_core/particleset.py b/src/parcels/_core/particleset.py index f9aa83206..5280d6767 100644 --- a/src/parcels/_core/particleset.py +++ b/src/parcels/_core/particleset.py @@ -60,8 +60,8 @@ def __init__( pclass=Particle, time=None, z=None, - lat=None, - lon=None, + y=None, + x=None, particle_ids=None, **kwargs, ): @@ -70,21 +70,21 @@ def __init__( self.fieldset = fieldset time = np.empty(shape=0) if time is None else np.array(time).flatten() - lat = np.empty(shape=0) if lat is None else np.array(lat).flatten() - lon = np.empty(shape=0) if lon is None else np.array(lon).flatten() + y = np.empty(shape=0) if y is None else np.array(y).flatten() + x = np.empty(shape=0) if x is None else np.array(x).flatten() if particle_ids is None: - particle_ids = np.arange(lon.size) + particle_ids = np.arange(x.size) if z is None: minz = 0 for field in self.fieldset.fields.values(): if field.grid.depth is not None: minz = min(minz, field.grid.depth[0]) - z = np.ones(lon.size) * minz + z = np.ones(x.size) * minz else: z = np.array(z).flatten() - assert lon.size == lat.size and lon.size == z.size, "lon, lat, z don't all have the same lenghts" + assert x.size == y.size and x.size == z.size, "lon, lat, z don't all have the same lenghts" if time is None or len(time) == 0: # do not set a time yet (because sign_dt not known) @@ -95,26 +95,26 @@ def __init__( time = timedelta_to_float(time) else: raise TypeError("particle time must be a datetime, timedelta, or date object") - time = np.repeat(time, lon.size) if time.size == 1 else time + time = np.repeat(time, x.size) if time.size == 1 else time - assert lon.size == time.size, "time and positions (lon, lat, z) do not have the same lengths." + assert x.size == time.size, "time and positions (lon, lat, z) do not have the same lengths." if fieldset.time_interval: _warn_particle_times_outside_fieldset_time_bounds(time, fieldset.time_interval) for kwvar in kwargs: kwargs[kwvar] = np.array(kwargs[kwvar]).flatten() - assert lon.size == kwargs[kwvar].size, f"{kwvar} and positions (lon, lat, z) don't have the same lengths." + assert x.size == kwargs[kwvar].size, f"{kwvar} and positions (lon, lat, z) don't have the same lengths." self._data = create_particle_data( pclass=pclass, - nparticles=lon.size, + nparticles=x.size, ngrids=len(fieldset.gridset), initial=dict( time=time, z=z, - lat=lat, - lon=lon, + y=y, + x=x, particle_id=particle_ids, ), ) @@ -245,7 +245,7 @@ def remove_indices(self, indices): def populate_indices(self): """Pre-populate guesses of particle ei (element id) indices""" for i, grid in enumerate(self.fieldset.gridset): - grid_positions = grid.search(self.z, self.lat, self.lon) + grid_positions = grid.search(self.z, self.y, self.x) self._data["ei"][:, i] = grid.ravel_index( { "X": grid_positions["X"]["index"], diff --git a/src/parcels/_core/statuscodes.py b/src/parcels/_core/statuscodes.py index 22d0d1788..408819ae8 100644 --- a/src/parcels/_core/statuscodes.py +++ b/src/parcels/_core/statuscodes.py @@ -41,7 +41,7 @@ class FieldInterpolationError(RuntimeError): def _raise_field_interpolation_error(z, y, x): - raise FieldInterpolationError(f"Field interpolation returned NaN at (z={z}, lat={y}, lon={x})") + raise FieldInterpolationError(f"Field interpolation returned NaN at (z={z}, y={y}, x={x})") class FieldOutOfBoundError(RuntimeError): @@ -51,7 +51,7 @@ class FieldOutOfBoundError(RuntimeError): def _raise_field_out_of_bound_error(z, y, x): - raise FieldOutOfBoundError(f"Field sampled out-of-bound, at (z={z}, lat={y}, lon={x})") + raise FieldOutOfBoundError(f"Field sampled out-of-bound, at (z={z}, y={y}, x={x})") class FieldOutOfBoundSurfaceError(RuntimeError): @@ -65,7 +65,7 @@ def format_out(val): return "unknown" if val is None else val raise FieldOutOfBoundSurfaceError( - f"Field sampled out-of-bound at the surface, at (z={format_out(z)}, lat={format_out(y)}, lon={format_out(x)})" + f"Field sampled out-of-bound at the surface, at (z={format_out(z)}, y={format_out(y)}, x={format_out(x)})" ) @@ -82,7 +82,7 @@ class GridSearchingError(RuntimeError): def _raise_grid_searching_error(z, y, x): - raise GridSearchingError(f"Grid searching failed at (z={z}, lat={y}, lon={x})") + raise GridSearchingError(f"Grid searching failed at (z={z}, y={y}, x={x})") class GeneralError(RuntimeError): @@ -92,7 +92,7 @@ class GeneralError(RuntimeError): def _raise_general_error(z, y, x): - raise GeneralError(f"General error occurred at (z={z}, lat={y}, lon={x})") + raise GeneralError(f"General error occurred at (z={z}, y={y}, x={x})") class OutsideTimeInterval(RuntimeError): diff --git a/src/parcels/_reprs.py b/src/parcels/_reprs.py index c1b21cfd2..bc23ad0cd 100644 --- a/src/parcels/_reprs.py +++ b/src/parcels/_reprs.py @@ -97,8 +97,8 @@ def particleset_repr(pset: ParticleSet) -> str: def particlesetview_repr(pview: Any) -> str: """Return a pretty repr for ParticleSetView""" time_string = "not_yet_set" if pview.time is None or np.isnan(pview.time) else f"{pview.time:f}" - out = f"P[{pview.particle_id}]: time={time_string}, z={pview.z:f}, lat={pview.lat:f}, lon={pview.lon:f}" - vars = [v.name for v in pview._pclass.variables if v.to_write is True and v.name not in ["lon", "lat", "z", "time"]] + out = f"P[{pview.particle_id}]: time={time_string}, z={pview.z:f}, y={pview.y:f}, x={pview.x:f}" + vars = [v.name for v in pview._pclass.variables if v.to_write is True and v.name not in ["z", "y", "x", "time"]] for var in vars: out += f", {var}={getattr(pview, var):f}" diff --git a/src/parcels/interpolators/_uxinterpolators.py b/src/parcels/interpolators/_uxinterpolators.py index 0f724400d..80e804475 100644 --- a/src/parcels/interpolators/_uxinterpolators.py +++ b/src/parcels/interpolators/_uxinterpolators.py @@ -171,7 +171,7 @@ def interp( u = vectorfield.U.interp_method.interp(particle_positions, grid_positions, vectorfield.U) v = vectorfield.V.interp_method.interp(particle_positions, grid_positions, vectorfield.V) if vectorfield.grid._mesh == "spherical": - u /= 1852 * 60 * np.cos(np.deg2rad(particle_positions["lat"])) + u /= 1852 * 60 * np.cos(np.deg2rad(particle_positions["y"])) v /= 1852 * 60 if "3D" in vectorfield.vector_type: diff --git a/src/parcels/interpolators/_xinterpolators.py b/src/parcels/interpolators/_xinterpolators.py index f1966e871..d20313ffb 100644 --- a/src/parcels/interpolators/_xinterpolators.py +++ b/src/parcels/interpolators/_xinterpolators.py @@ -132,7 +132,7 @@ def interp( field: Field, ): """Returning the single value of a Constant Field (with a size=(1,1,1,1) array)""" - return field.data[0, 0, 0, 0].values * np.ones_like(particle_positions["lon"]) + return field.data[0, 0, 0, 0].values * np.ones_like(particle_positions["x"]) class XLinear_Velocity(VectorInterpolator): # noqa: N801 @@ -149,7 +149,7 @@ def interp( u = _xlinear.interp(particle_positions, grid_positions, vectorfield.U) v = _xlinear.interp(particle_positions, grid_positions, vectorfield.V) if vectorfield.grid._mesh == "spherical": - u /= 1852 * 60 * np.cos(np.deg2rad(particle_positions["lat"])) + u /= 1852 * 60 * np.cos(np.deg2rad(particle_positions["y"])) v /= 1852 * 60 if vectorfield.W: @@ -304,7 +304,7 @@ def _compute_corner_data(data, selection_dict) -> np.ndarray: v = v.compute() if grid._mesh == "spherical": - conversion = 1852 * 60.0 * np.cos(np.deg2rad(particle_positions["lat"])) + conversion = 1852 * 60.0 * np.cos(np.deg2rad(particle_positions["y"])) u /= conversion v /= conversion diff --git a/src/parcels/kernels/_advection.py b/src/parcels/kernels/_advection.py index 792c8ee17..a883aa2c4 100644 --- a/src/parcels/kernels/_advection.py +++ b/src/parcels/kernels/_advection.py @@ -35,22 +35,22 @@ def AdvectionRK2(particles, fieldset): # pragma: no cover """Advection of particles using second-order Runge-Kutta integration.""" dt = _constrain_dt_to_within_time_interval(fieldset.time_interval, particles.time, particles.dt) (u1, v1) = fieldset.UV[particles] - lon1, lat1 = (particles.lon + u1 * 0.5 * dt, particles.lat + v1 * 0.5 * dt) - (u2, v2) = fieldset.UV[particles.time + 0.5 * dt, particles.z, lat1, lon1, particles] - particles.dlon += u2 * dt - particles.dlat += v2 * dt + x1, y1 = (particles.x + u1 * 0.5 * dt, particles.y + v1 * 0.5 * dt) + (u2, v2) = fieldset.UV[particles.time + 0.5 * dt, particles.z, y1, x1, particles] + particles.dx += u2 * dt + particles.dy += v2 * dt def AdvectionRK2_3D(particles, fieldset): # pragma: no cover """Advection of particles using second-order Runge-Kutta integration including vertical velocity.""" dt = _constrain_dt_to_within_time_interval(fieldset.time_interval, particles.time, particles.dt) (u1, v1, w1) = fieldset.UVW[particles] - lon1 = particles.lon + u1 * 0.5 * dt - lat1 = particles.lat + v1 * 0.5 * dt + x1 = particles.x + u1 * 0.5 * dt + y1 = particles.y + v1 * 0.5 * dt z1 = particles.z + w1 * 0.5 * dt - (u2, v2, w2) = fieldset.UVW[particles.time + 0.5 * dt, z1, lat1, lon1, particles] - particles.dlon += u2 * dt - particles.dlat += v2 * dt + (u2, v2, w2) = fieldset.UVW[particles.time + 0.5 * dt, z1, y1, x1, particles] + particles.dx += u2 * dt + particles.dy += v2 * dt particles.dz += w2 * dt @@ -58,42 +58,42 @@ def AdvectionRK4(particles, fieldset): # pragma: no cover """Advection of particles using fourth-order Runge-Kutta integration.""" dt = _constrain_dt_to_within_time_interval(fieldset.time_interval, particles.time, particles.dt) (u1, v1) = fieldset.UV[particles] - lon1, lat1 = (particles.lon + u1 * 0.5 * dt, particles.lat + v1 * 0.5 * dt) - (u2, v2) = fieldset.UV[particles.time + 0.5 * dt, particles.z, lat1, lon1, particles] - lon2, lat2 = (particles.lon + u2 * 0.5 * dt, particles.lat + v2 * 0.5 * dt) - (u3, v3) = fieldset.UV[particles.time + 0.5 * dt, particles.z, lat2, lon2, particles] - lon3, lat3 = (particles.lon + u3 * dt, particles.lat + v3 * dt) - (u4, v4) = fieldset.UV[particles.time + dt, particles.z, lat3, lon3, particles] - particles.dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6.0 * dt - particles.dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6.0 * dt + x1, y1 = (particles.x + u1 * 0.5 * dt, particles.y + v1 * 0.5 * dt) + (u2, v2) = fieldset.UV[particles.time + 0.5 * dt, particles.z, y1, x1, particles] + x2, y2 = (particles.x + u2 * 0.5 * dt, particles.y + v2 * 0.5 * dt) + (u3, v3) = fieldset.UV[particles.time + 0.5 * dt, particles.z, y2, x2, particles] + x3, y3 = (particles.x + u3 * dt, particles.y + v3 * dt) + (u4, v4) = fieldset.UV[particles.time + dt, particles.z, y3, x3, particles] + particles.dx += (u1 + 2 * u2 + 2 * u3 + u4) / 6.0 * dt + particles.dy += (v1 + 2 * v2 + 2 * v3 + v4) / 6.0 * dt def AdvectionRK4_3D(particles, fieldset): # pragma: no cover """Advection of particles using fourth-order Runge-Kutta integration including vertical velocity.""" dt = _constrain_dt_to_within_time_interval(fieldset.time_interval, particles.time, particles.dt) (u1, v1, w1) = fieldset.UVW[particles] - lon1 = particles.lon + u1 * 0.5 * dt - lat1 = particles.lat + v1 * 0.5 * dt + x1 = particles.x + u1 * 0.5 * dt + y1 = particles.y + v1 * 0.5 * dt z1 = particles.z + w1 * 0.5 * dt - (u2, v2, w2) = fieldset.UVW[particles.time + 0.5 * dt, z1, lat1, lon1, particles] - lon2 = particles.lon + u2 * 0.5 * dt - lat2 = particles.lat + v2 * 0.5 * dt + (u2, v2, w2) = fieldset.UVW[particles.time + 0.5 * dt, z1, y1, x1, particles] + x2 = particles.x + u2 * 0.5 * dt + y2 = particles.y + v2 * 0.5 * dt z2 = particles.z + w2 * 0.5 * dt - (u3, v3, w3) = fieldset.UVW[particles.time + 0.5 * dt, z2, lat2, lon2, particles] - lon3 = particles.lon + u3 * dt - lat3 = particles.lat + v3 * dt + (u3, v3, w3) = fieldset.UVW[particles.time + 0.5 * dt, z2, y2, x2, particles] + x3 = particles.x + u3 * dt + y3 = particles.y + v3 * dt z3 = particles.z + w3 * dt - (u4, v4, w4) = fieldset.UVW[particles.time + dt, z3, lat3, lon3, particles] - particles.dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * dt - particles.dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * dt + (u4, v4, w4) = fieldset.UVW[particles.time + dt, z3, y3, x3, particles] + particles.dx += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * dt + particles.dy += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * dt particles.dz += (w1 + 2 * w2 + 2 * w3 + w4) / 6 * dt def AdvectionEE(particles, fieldset): # pragma: no cover """Advection of particles using Explicit Euler (aka Euler Forward) integration.""" (u1, v1) = fieldset.UV[particles] - particles.dlon += u1 * particles.dt - particles.dlat += v1 * particles.dt + particles.dx += u1 * particles.dt + particles.dy += v1 * particles.dt def AdvectionRK45(particles, fieldset): # pragma: no cover @@ -120,39 +120,39 @@ def AdvectionRK45(particles, fieldset): # pragma: no cover b5 = [16.0 / 135.0, 0.0, 6656.0 / 12825.0, 28561.0 / 56430.0, -9.0 / 50.0, 2.0 / 55.0] (u1, v1) = fieldset.UV[particles] - lon1, lat1 = (particles.lon + u1 * A[0][0] * dt, particles.lat + v1 * A[0][0] * dt) - (u2, v2) = fieldset.UV[particles.time + c[0] * dt, particles.z, lat1, lon1, particles] - lon2, lat2 = ( - particles.lon + (u1 * A[1][0] + u2 * A[1][1]) * dt, - particles.lat + (v1 * A[1][0] + v2 * A[1][1]) * dt, + x1, y1 = (particles.x + u1 * A[0][0] * dt, particles.y + v1 * A[0][0] * dt) + (u2, v2) = fieldset.UV[particles.time + c[0] * dt, particles.z, y1, x1, particles] + x2, y2 = ( + particles.x + (u1 * A[1][0] + u2 * A[1][1]) * dt, + particles.y + (v1 * A[1][0] + v2 * A[1][1]) * dt, ) - (u3, v3) = fieldset.UV[particles.time + c[1] * dt, particles.z, lat2, lon2, particles] - lon3, lat3 = ( - particles.lon + (u1 * A[2][0] + u2 * A[2][1] + u3 * A[2][2]) * dt, - particles.lat + (v1 * A[2][0] + v2 * A[2][1] + v3 * A[2][2]) * dt, + (u3, v3) = fieldset.UV[particles.time + c[1] * dt, particles.z, y2, x2, particles] + x3, y3 = ( + particles.x + (u1 * A[2][0] + u2 * A[2][1] + u3 * A[2][2]) * dt, + particles.y + (v1 * A[2][0] + v2 * A[2][1] + v3 * A[2][2]) * dt, ) - (u4, v4) = fieldset.UV[particles.time + c[2] * dt, particles.z, lat3, lon3, particles] - lon4, lat4 = ( - particles.lon + (u1 * A[3][0] + u2 * A[3][1] + u3 * A[3][2] + u4 * A[3][3]) * dt, - particles.lat + (v1 * A[3][0] + v2 * A[3][1] + v3 * A[3][2] + v4 * A[3][3]) * dt, + (u4, v4) = fieldset.UV[particles.time + c[2] * dt, particles.z, y3, x3, particles] + x4, y4 = ( + particles.x + (u1 * A[3][0] + u2 * A[3][1] + u3 * A[3][2] + u4 * A[3][3]) * dt, + particles.y + (v1 * A[3][0] + v2 * A[3][1] + v3 * A[3][2] + v4 * A[3][3]) * dt, ) - (u5, v5) = fieldset.UV[particles.time + c[3] * dt, particles.z, lat4, lon4, particles] - lon5, lat5 = ( - particles.lon + (u1 * A[4][0] + u2 * A[4][1] + u3 * A[4][2] + u4 * A[4][3] + u5 * A[4][4]) * dt, - particles.lat + (v1 * A[4][0] + v2 * A[4][1] + v3 * A[4][2] + v4 * A[4][3] + v5 * A[4][4]) * dt, + (u5, v5) = fieldset.UV[particles.time + c[3] * dt, particles.z, y4, x4, particles] + x5, y5 = ( + particles.x + (u1 * A[4][0] + u2 * A[4][1] + u3 * A[4][2] + u4 * A[4][3] + u5 * A[4][4]) * dt, + particles.y + (v1 * A[4][0] + v2 * A[4][1] + v3 * A[4][2] + v4 * A[4][3] + v5 * A[4][4]) * dt, ) - (u6, v6) = fieldset.UV[particles.time + c[4] * dt, particles.z, lat5, lon5, particles] + (u6, v6) = fieldset.UV[particles.time + c[4] * dt, particles.z, y5, x5, particles] - lon_4th = (u1 * b4[0] + u2 * b4[1] + u3 * b4[2] + u4 * b4[3] + u5 * b4[4]) * dt - lat_4th = (v1 * b4[0] + v2 * b4[1] + v3 * b4[2] + v4 * b4[3] + v5 * b4[4]) * dt - lon_5th = (u1 * b5[0] + u2 * b5[1] + u3 * b5[2] + u4 * b5[3] + u5 * b5[4] + u6 * b5[5]) * dt - lat_5th = (v1 * b5[0] + v2 * b5[1] + v3 * b5[2] + v4 * b5[3] + v5 * b5[4] + v6 * b5[5]) * dt + x_4th = (u1 * b4[0] + u2 * b4[1] + u3 * b4[2] + u4 * b4[3] + u5 * b4[4]) * dt + y_4th = (v1 * b4[0] + v2 * b4[1] + v3 * b4[2] + v4 * b4[3] + v5 * b4[4]) * dt + x_5th = (u1 * b5[0] + u2 * b5[1] + u3 * b5[2] + u4 * b5[3] + u5 * b5[4] + u6 * b5[5]) * dt + y_5th = (v1 * b5[0] + v2 * b5[1] + v3 * b5[2] + v4 * b5[3] + v5 * b5[4] + v6 * b5[5]) * dt - kappa = np.sqrt(np.pow(lon_5th - lon_4th, 2) + np.pow(lat_5th - lat_4th, 2)) + kappa = np.sqrt(np.pow(x_5th - x_4th, 2) + np.pow(y_5th - y_4th, 2)) good_particles = (kappa <= fieldset.RK45_tol) | (np.fabs(dt) <= np.fabs(fieldset.RK45_min_dt)) - particles.dlon += np.where(good_particles, lon_5th, 0) - particles.dlat += np.where(good_particles, lat_5th, 0) + particles.dx += np.where(good_particles, x_5th, 0) + particles.dy += np.where(good_particles, y_5th, 0) increase_dt_particles = ( good_particles & (kappa <= fieldset.RK45_tol / 10) & (np.fabs(dt * 2) <= np.fabs(fieldset.RK45_max_dt)) @@ -193,7 +193,7 @@ def AdvectionAnalytical(particles, fieldset): # pragma: no cover withW = True if "W" in [f.name for f in fieldset.fields.values()] else False withTime = True if len(fieldset.U.grid.time) > 1 else False tau, zeta, eta, xsi, ti, zi, yi, xi = fieldset.U._search_indices( - particles.z, particles.lat, particles.lon, particles=particles + particles.z, particles.y, particles.x, particles=particles ) ds_t = dt if withTime: @@ -227,14 +227,14 @@ def AdvectionAnalytical(particles, fieldset): # pragma: no cover grid = fieldset.U.grid if grid._gtype < 2: - px = np.array([grid.lon[xi], grid.lon[xi + 1], grid.lon[xi + 1], grid.lon[xi]]) - py = np.array([grid.lat[yi], grid.lat[yi], grid.lat[yi + 1], grid.lat[yi + 1]]) + px = np.array([grid.x[xi], grid.x[xi + 1], grid.x[xi + 1], grid.x[xi]]) + py = np.array([grid.y[yi], grid.y[yi], grid.y[yi + 1], grid.y[yi + 1]]) else: - px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) - py = np.array([grid.lat[yi, xi], grid.lat[yi, xi + 1], grid.lat[yi + 1, xi + 1], grid.lat[yi + 1, xi]]) + px = np.array([grid.x[yi, xi], grid.x[yi, xi + 1], grid.x[yi + 1, xi + 1], grid.x[yi + 1, xi]]) + py = np.array([grid.y[yi, xi], grid.y[yi, xi + 1], grid.y[yi + 1, xi + 1], grid.y[yi + 1, xi]]) if grid.mesh == "spherical": - px[0] = px[0] + 360 if px[0] < particles.lon - 225 else px[0] - px[0] = px[0] - 360 if px[0] > particles.lat + 225 else px[0] + px[0] = px[0] + 360 if px[0] < particles.x - 225 else px[0] + px[0] = px[0] - 360 if px[0] > particles.y + 225 else px[0] px[1:] = np.where(px[1:] - px[0] > 180, px[1:] - 360, px[1:]) px[1:] = np.where(-px[1:] + px[0] > 180, px[1:] + 360, px[1:]) if withW: @@ -249,7 +249,7 @@ def AdvectionAnalytical(particles, fieldset): # pragma: no cover c4 = i_u._geodetic_distance(py[3], py[0], px[3], px[0], grid.mesh, np.dot(i_u.phi2D_lin(eta, 0.0), py)) rad = np.pi / 180.0 deg2m = 1852 * 60.0 - meshJac = (deg2m * deg2m * math.cos(rad * particles.lat)) if grid.mesh == "spherical" else 1 + meshJac = (deg2m * deg2m * math.cos(rad * particles.y)) if grid.mesh == "spherical" else 1 dxdy = i_u._compute_jacobian_determinant(py, px, eta, xsi) * meshJac if withW: @@ -324,19 +324,19 @@ def compute_rs(r, B, delta, s_min): # noqa: N803 rs_x = compute_rs(xsi, B_x, delta_x, s_min) rs_y = compute_rs(eta, B_y, delta_y, s_min) - particles.dlon += ( + particles.dx += ( (1.0 - rs_x) * (1.0 - rs_y) * px[0] + rs_x * (1.0 - rs_y) * px[1] + rs_x * rs_y * px[2] + (1.0 - rs_x) * rs_y * px[3] - - particles.lon + - particles.x ) - particles.dlat += ( + particles.dy += ( (1.0 - rs_x) * (1.0 - rs_y) * py[0] + rs_x * (1.0 - rs_y) * py[1] + rs_x * rs_y * py[2] + (1.0 - rs_x) * rs_y * py[3] - - particles.lat + - particles.y ) if withW: diff --git a/src/parcels/kernels/_advectiondiffusion.py b/src/parcels/kernels/_advectiondiffusion.py index 51f6d2666..4a3eee981 100644 --- a/src/parcels/kernels/_advectiondiffusion.py +++ b/src/parcels/kernels/_advectiondiffusion.py @@ -37,34 +37,34 @@ def AdvectionDiffusionM1(particles, fieldset): # pragma: no cover dWx = np.random.normal(0, np.sqrt(np.fabs(particles.dt))) dWy = np.random.normal(0, np.sqrt(np.fabs(particles.dt))) - Kxp1 = fieldset.Kh_zonal[particles.time, particles.z, particles.lat, particles.lon + fieldset.dres, particles] - Kxm1 = fieldset.Kh_zonal[particles.time, particles.z, particles.lat, particles.lon - fieldset.dres, particles] + Kxp1 = fieldset.Kh_zonal[particles.time, particles.z, particles.y, particles.x + fieldset.dres, particles] + Kxm1 = fieldset.Kh_zonal[particles.time, particles.z, particles.y, particles.x - fieldset.dres, particles] if fieldset.Kh_zonal.grid._mesh == "spherical": - Kxp1 = meters_to_degrees_zonal(Kxp1, particles.lat) - Kxm1 = meters_to_degrees_zonal(Kxm1, particles.lat) + Kxp1 = meters_to_degrees_zonal(Kxp1, particles.y) + Kxm1 = meters_to_degrees_zonal(Kxm1, particles.y) dKdx = (Kxp1 - Kxm1) / (2 * fieldset.dres) - u, v = fieldset.UV[particles.time, particles.z, particles.lat, particles.lon, particles] - kh_zonal = fieldset.Kh_zonal[particles.time, particles.z, particles.lat, particles.lon, particles] + u, v = fieldset.UV[particles.time, particles.z, particles.y, particles.x, particles] + kh_zonal = fieldset.Kh_zonal[particles.time, particles.z, particles.y, particles.x, particles] if fieldset.Kh_zonal.grid._mesh == "spherical": - kh_zonal = meters_to_degrees_zonal(kh_zonal, particles.lat) + kh_zonal = meters_to_degrees_zonal(kh_zonal, particles.y) bx = np.sqrt(2 * kh_zonal) - Kyp1 = fieldset.Kh_meridional[particles.time, particles.z, particles.lat + fieldset.dres, particles.lon, particles] - Kym1 = fieldset.Kh_meridional[particles.time, particles.z, particles.lat - fieldset.dres, particles.lon, particles] + Kyp1 = fieldset.Kh_meridional[particles.time, particles.z, particles.y + fieldset.dres, particles.x, particles] + Kym1 = fieldset.Kh_meridional[particles.time, particles.z, particles.y - fieldset.dres, particles.x, particles] if fieldset.Kh_meridional.grid._mesh == "spherical": Kyp1 = meters_to_degrees_meridional(Kyp1) Kym1 = meters_to_degrees_meridional(Kym1) dKdy = (Kyp1 - Kym1) / (2 * fieldset.dres) - kh_meridional = fieldset.Kh_meridional[particles.time, particles.z, particles.lat, particles.lon, particles] + kh_meridional = fieldset.Kh_meridional[particles.time, particles.z, particles.y, particles.x, particles] if fieldset.Kh_meridional.grid._mesh == "spherical": kh_meridional = meters_to_degrees_meridional(kh_meridional) by = np.sqrt(2 * kh_meridional) # Particle positions are updated only after evaluating all terms. - particles.dlon += u * particles.dt + 0.5 * dKdx * (dWx**2 + particles.dt) + bx * dWx - particles.dlat += v * particles.dt + 0.5 * dKdy * (dWy**2 + particles.dt) + by * dWy + particles.dx += u * particles.dt + 0.5 * dKdx * (dWx**2 + particles.dt) + bx * dWx + particles.dy += v * particles.dt + 0.5 * dKdy * (dWy**2 + particles.dt) + by * dWy def AdvectionDiffusionEM(particles, fieldset): # pragma: no cover @@ -84,37 +84,37 @@ def AdvectionDiffusionEM(particles, fieldset): # pragma: no cover dWx = np.random.normal(0, np.sqrt(np.fabs(particles.dt))) dWy = np.random.normal(0, np.sqrt(np.fabs(particles.dt))) - u, v = fieldset.UV[particles.time, particles.z, particles.lat, particles.lon, particles] + u, v = fieldset.UV[particles.time, particles.z, particles.y, particles.x, particles] - Kxp1 = fieldset.Kh_zonal[particles.time, particles.z, particles.lat, particles.lon + fieldset.dres, particles] - Kxm1 = fieldset.Kh_zonal[particles.time, particles.z, particles.lat, particles.lon - fieldset.dres, particles] + Kxp1 = fieldset.Kh_zonal[particles.time, particles.z, particles.y, particles.x + fieldset.dres, particles] + Kxm1 = fieldset.Kh_zonal[particles.time, particles.z, particles.y, particles.x - fieldset.dres, particles] if fieldset.Kh_zonal.grid._mesh == "spherical": - Kxp1 = meters_to_degrees_zonal(Kxp1, particles.lat) - Kxm1 = meters_to_degrees_zonal(Kxm1, particles.lat) + Kxp1 = meters_to_degrees_zonal(Kxp1, particles.y) + Kxm1 = meters_to_degrees_zonal(Kxm1, particles.y) dKdx = (Kxp1 - Kxm1) / (2 * fieldset.dres) ax = u + dKdx - kh_zonal = fieldset.Kh_zonal[particles.time, particles.z, particles.lat, particles.lon, particles] + kh_zonal = fieldset.Kh_zonal[particles.time, particles.z, particles.y, particles.x, particles] if fieldset.Kh_zonal.grid._mesh == "spherical": - kh_zonal = meters_to_degrees_zonal(kh_zonal, particles.lat) + kh_zonal = meters_to_degrees_zonal(kh_zonal, particles.y) bx = np.sqrt(2 * kh_zonal) - Kyp1 = fieldset.Kh_meridional[particles.time, particles.z, particles.lat + fieldset.dres, particles.lon, particles] - Kym1 = fieldset.Kh_meridional[particles.time, particles.z, particles.lat - fieldset.dres, particles.lon, particles] + Kyp1 = fieldset.Kh_meridional[particles.time, particles.z, particles.y + fieldset.dres, particles.x, particles] + Kym1 = fieldset.Kh_meridional[particles.time, particles.z, particles.y - fieldset.dres, particles.x, particles] if fieldset.Kh_meridional.grid._mesh == "spherical": Kyp1 = meters_to_degrees_meridional(Kyp1) Kym1 = meters_to_degrees_meridional(Kym1) dKdy = (Kyp1 - Kym1) / (2 * fieldset.dres) ay = v + dKdy - kh_meridional = fieldset.Kh_meridional[particles.time, particles.z, particles.lat, particles.lon, particles] + kh_meridional = fieldset.Kh_meridional[particles.time, particles.z, particles.y, particles.x, particles] if fieldset.Kh_meridional.grid._mesh == "spherical": kh_meridional = meters_to_degrees_meridional(kh_meridional) by = np.sqrt(2 * kh_meridional) # Particle positions are updated only after evaluating all terms. - particles.dlon += ax * particles.dt + bx * dWx - particles.dlat += ay * particles.dt + by * dWy + particles.dx += ax * particles.dt + bx * dWx + particles.dy += ay * particles.dt + by * dWy def DiffusionUniformKh(particles, fieldset): # pragma: no cover @@ -143,11 +143,11 @@ def DiffusionUniformKh(particles, fieldset): # pragma: no cover kh_meridional = fieldset.Kh_meridional[particles] if fieldset.Kh_zonal.grid._mesh == "spherical": - kh_zonal = meters_to_degrees_zonal(kh_zonal, particles.lat) + kh_zonal = meters_to_degrees_zonal(kh_zonal, particles.y) kh_meridional = meters_to_degrees_meridional(kh_meridional) bx = np.sqrt(2 * kh_zonal) by = np.sqrt(2 * kh_meridional) - particles.dlon += bx * dWx - particles.dlat += by * dWy + particles.dx += bx * dWx + particles.dy += by * dWy diff --git a/src/parcels/kernels/_sigmagrids.py b/src/parcels/kernels/_sigmagrids.py index bfa408eed..875443fa6 100644 --- a/src/parcels/kernels/_sigmagrids.py +++ b/src/parcels/kernels/_sigmagrids.py @@ -31,8 +31,8 @@ def SampleOmegaCroco(particles, fieldset): This Kernel can be adapted to sample any other field on a CROCO sigma grid by replacing 'omega' with the desired field name. """ - sigma = convert_z_to_sigma_croco(fieldset, particles.time, particles.z, particles.lat, particles.lon, particles) - particles.omega = fieldset.omega[particles.time, sigma, particles.lat, particles.lon, particles] + sigma = convert_z_to_sigma_croco(fieldset, particles.time, particles.z, particles.y, particles.x, particles) + particles.omega = fieldset.omega[particles.time, sigma, particles.y, particles.x, particles] # TODO change to RK2 (once RK4 yields same results as v3) @@ -42,46 +42,46 @@ def AdvectionRK4_3D_CROCO(particles, fieldset): # pragma: no cover It also uses linear interpolation of the W field, which gives much better results than the default C-grid interpolation. """ dt = _constrain_dt_to_within_time_interval(fieldset.time_interval, particles.time, particles.dt) - sigma = particles.z / fieldset.h[particles.time, np.zeros_like(particles.z), particles.lat, particles.lon] + sigma = particles.z / fieldset.h[particles.time, np.zeros_like(particles.z), particles.y, particles.x] - sig = convert_z_to_sigma_croco(fieldset, particles.time, particles.z, particles.lat, particles.lon, particles) - (u1, v1) = fieldset.UV[particles.time, sig, particles.lat, particles.lon, particles] - w1 = fieldset.W[particles.time, sig, particles.lat, particles.lon, particles] - w1 *= sigma / fieldset.h[particles.time, np.zeros_like(particles.z), particles.lat, particles.lon] - lon1 = particles.lon + u1 * 0.5 * dt - lat1 = particles.lat + v1 * 0.5 * dt + sig = convert_z_to_sigma_croco(fieldset, particles.time, particles.z, particles.y, particles.x, particles) + (u1, v1) = fieldset.UV[particles.time, sig, particles.y, particles.x, particles] + w1 = fieldset.W[particles.time, sig, particles.y, particles.x, particles] + w1 *= sigma / fieldset.h[particles.time, np.zeros_like(particles.z), particles.y, particles.x] + x1 = particles.x + u1 * 0.5 * dt + y1 = particles.y + v1 * 0.5 * dt sig_dep1 = sigma + w1 * 0.5 * dt - dep1 = sig_dep1 * fieldset.h[particles.time, np.zeros_like(particles.z), lat1, lon1] + dep1 = sig_dep1 * fieldset.h[particles.time, np.zeros_like(particles.z), y1, x1] - sig1 = convert_z_to_sigma_croco(fieldset, particles.time + 0.5 * dt, dep1, lat1, lon1, particles) - (u2, v2) = fieldset.UV[particles.time + 0.5 * dt, sig1, lat1, lon1, particles] - w2 = fieldset.W[particles.time + 0.5 * dt, sig1, lat1, lon1, particles] - w2 *= sig_dep1 / fieldset.h[particles.time, np.zeros_like(particles.z), lat1, lon1] - lon2 = particles.lon + u2 * 0.5 * dt - lat2 = particles.lat + v2 * 0.5 * dt + sig1 = convert_z_to_sigma_croco(fieldset, particles.time + 0.5 * dt, dep1, y1, x1, particles) + (u2, v2) = fieldset.UV[particles.time + 0.5 * dt, sig1, y1, x1, particles] + w2 = fieldset.W[particles.time + 0.5 * dt, sig1, y1, x1, particles] + w2 *= sig_dep1 / fieldset.h[particles.time, np.zeros_like(particles.z), y1, x1] + x2 = particles.x + u2 * 0.5 * dt + y2 = particles.y + v2 * 0.5 * dt sig_dep2 = sigma + w2 * 0.5 * dt - dep2 = sig_dep2 * fieldset.h[particles.time, np.zeros_like(particles.z), lat2, lon2] + dep2 = sig_dep2 * fieldset.h[particles.time, np.zeros_like(particles.z), y2, x2] - sig2 = convert_z_to_sigma_croco(fieldset, particles.time + 0.5 * dt, dep2, lat2, lon2, particles) - (u3, v3) = fieldset.UV[particles.time + 0.5 * dt, sig2, lat2, lon2, particles] - w3 = fieldset.W[particles.time + 0.5 * dt, sig2, lat2, lon2, particles] - w3 *= sig_dep2 / fieldset.h[particles.time, np.zeros_like(particles.z), lat2, lon2] - lon3 = particles.lon + u3 * dt - lat3 = particles.lat + v3 * dt + sig2 = convert_z_to_sigma_croco(fieldset, particles.time + 0.5 * dt, dep2, y2, x2, particles) + (u3, v3) = fieldset.UV[particles.time + 0.5 * dt, sig2, y2, x2, particles] + w3 = fieldset.W[particles.time + 0.5 * dt, sig2, y2, x2, particles] + w3 *= sig_dep2 / fieldset.h[particles.time, np.zeros_like(particles.z), y2, x2] + x3 = particles.x + u3 * dt + y3 = particles.y + v3 * dt sig_dep3 = sigma + w3 * dt - dep3 = sig_dep3 * fieldset.h[particles.time, np.zeros_like(particles.z), lat3, lon3] + dep3 = sig_dep3 * fieldset.h[particles.time, np.zeros_like(particles.z), y3, x3] - sig3 = convert_z_to_sigma_croco(fieldset, particles.time + dt, dep3, lat3, lon3, particles) - (u4, v4) = fieldset.UV[particles.time + dt, sig3, lat3, lon3, particles] - w4 = fieldset.W[particles.time + dt, sig3, lat3, lon3, particles] - w4 *= sig_dep3 / fieldset.h[particles.time, np.zeros_like(particles.z), lat3, lon3] - lon4 = particles.lon + u4 * dt - lat4 = particles.lat + v4 * dt + sig3 = convert_z_to_sigma_croco(fieldset, particles.time + dt, dep3, y3, x3, particles) + (u4, v4) = fieldset.UV[particles.time + dt, sig3, y3, x3, particles] + w4 = fieldset.W[particles.time + dt, sig3, y3, x3, particles] + w4 *= sig_dep3 / fieldset.h[particles.time, np.zeros_like(particles.z), y3, x3] + x4 = particles.x + u4 * dt + y4 = particles.y + v4 * dt sig_dep4 = sigma + w4 * dt - dep4 = sig_dep4 * fieldset.h[particles.time, np.zeros_like(particles.z), lat4, lon4] - particles.dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * dt - particles.dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * dt + dep4 = sig_dep4 * fieldset.h[particles.time, np.zeros_like(particles.z), y4, x4] + particles.dx += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * dt + particles.dy += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * dt particles.dz += ( (dep1 - particles.z) * 2 + 2 * (dep2 - particles.z) * 2 + 2 * (dep3 - particles.z) + dep4 - particles.z ) / 6 diff --git a/tests-v3/test_advection.py b/tests-v3/test_advection.py index 3d8f06bac..9071a9d4c 100644 --- a/tests-v3/test_advection.py +++ b/tests-v3/test_advection.py @@ -52,7 +52,7 @@ def test_advection_2DCROCO(): X = np.array([40e3, 80e3, 120e3]) Y = np.ones(X.size) * 100e3 Z = np.zeros(X.size) - pset = ParticleSet(fieldset=fieldset, pclass=Particle, lon=X, lat=Y, depth=Z) + pset = ParticleSet(fieldset=fieldset, pclass=Particle, x=X, y=Y, depth=Z) pset.execute([AdvectionRK4], runtime=runtime, dt=100) assert np.allclose(pset.depth, Z.flatten(), atol=1e-3) @@ -67,7 +67,7 @@ def test_analyticalAgrid(): U = np.ones((lat.size, lon.size), dtype=np.float32) V = np.ones((lat.size, lon.size), dtype=np.float32) fieldset = FieldSet.from_data({"U": U, "V": V}, {"lon": lon, "lat": lat}, mesh="flat") - pset = ParticleSet(fieldset, pclass=Particle, lon=1, lat=1) + pset = ParticleSet(fieldset, pclass=Particle, x=1, y=1) with pytest.raises(NotImplementedError): pset.execute(AdvectionAnalytical, runtime=1) @@ -97,7 +97,7 @@ def test_uniform_analytical(u, v, w, direction, tmp_zarrfile): fieldset.V.interp_method = "cgrid_velocity" x0, y0, z0 = 6.1, 6.2, 20 - pset = ParticleSet(fieldset, pclass=Particle, lon=x0, lat=y0, depth=z0) + pset = ParticleSet(fieldset, pclass=Particle, x=x0, y=y0, depth=z0) outfile = pset.ParticleFile(name=tmp_zarrfile, outputdt=1, chunks=(1, 1)) pset.execute(AdvectionAnalytical, runtime=4, dt=direction, output_file=outfile) diff --git a/tests-v3/test_fieldset.py b/tests-v3/test_fieldset.py index 69295cf87..aed966f4d 100644 --- a/tests-v3/test_fieldset.py +++ b/tests-v3/test_fieldset.py @@ -263,7 +263,7 @@ def SampleUV2(particle, fieldset, time): # pragma: no cover particle.dlon += u * particle.dt particle.dlat += v * particle.dt - pset = ParticleSet(fieldset, pclass=Particle, lon=0.5, lat=0.5) + pset = ParticleSet(fieldset, pclass=Particle, x=0.5, y=0.5) pset.execute(AdvectionRK4 + pset.Kernel(SampleUV2), dt=1, runtime=2) assert abs(pset.lon[0] - 2.5) < 1e-9 @@ -343,7 +343,7 @@ def sampleTemp(particle, fieldset, time): # pragma: no cover ] ) - pset = ParticleSet(fieldset, pclass=MyParticle, lon=[0.5], lat=[0.5], depth=[0.5]) + pset = ParticleSet(fieldset, pclass=MyParticle, x=[0.5], y=[0.5], depth=[0.5]) pset.execute( AdvectionRK4_3D + pset.Kernel(sampleTemp), runtime=timedelta(hours=51), dt=timedelta(hours=dt_sign * 1) ) diff --git a/tests-v3/test_fieldset_sampling.py b/tests-v3/test_fieldset_sampling.py index 291c27b88..64607a7dc 100644 --- a/tests-v3/test_fieldset_sampling.py +++ b/tests-v3/test_fieldset_sampling.py @@ -114,7 +114,7 @@ def test_fieldset_sample_eval(fieldset): @pytest.mark.xfail(reason="Test is directly testing adding the halo. This test should either be adapted or removed.") def test_fieldset_polar_with_halo(fieldset_geometric_polar): fieldset_geometric_polar.add_periodic_halo(zonal=5) - pset = ParticleSet(fieldset_geometric_polar, pclass=pclass(), lon=0, lat=0) + pset = ParticleSet(fieldset_geometric_polar, pclass=pclass(), x=0, y=0) pset.execute(runtime=1) assert pset.lon[0] == 0.0 @@ -131,7 +131,7 @@ def test_verticalsampling(zdir): } data = {"U": np.zeros(dims, dtype=np.float32), "V": np.zeros(dims, dtype=np.float32)} fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - pset = ParticleSet(fieldset, pclass=Particle, lon=0, lat=0, depth=0.7 * zdir) + pset = ParticleSet(fieldset, pclass=Particle, x=0, y=0, depth=0.7 * zdir) pset.execute(AdvectionRK4, dt=1.0, runtime=1.0) zi, yi, xi = fieldset.U.unravel_index(pset[0].ei) assert zi == [2] @@ -189,7 +189,7 @@ def test_nearest_neighbor_interpolation2D(): fieldset = FieldSet.from_data(data, dimensions, mesh="flat") fieldset.P.interp_method = "nearest" xv, yv = np.meshgrid(np.linspace(0.0, 1.0, int(np.sqrt(npart))), np.linspace(0.0, 1.0, int(np.sqrt(npart)))) - pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten()) + pset = ParticleSet(fieldset, pclass=pclass(), x=xv.flatten(), y=yv.flatten()) pset.execute(SampleP, endtime=1, dt=1) assert np.allclose(pset.p[(pset.lon < 0.5) & (pset.lat > 0.5)], 1.0, rtol=1e-5) assert np.allclose(pset.p[(pset.lon > 0.5) | (pset.lat < 0.5)], 0.0, rtol=1e-5) @@ -215,8 +215,8 @@ def test_nearest_neighbor_interpolation3D(): fieldset.P.interp_method = "nearest" xv, yv = np.meshgrid(np.linspace(0, 1.0, int(np.sqrt(npart))), np.linspace(0, 1.0, int(np.sqrt(npart)))) # combine a pset at 0m with pset at 1m, as meshgrid does not do 3D - pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.zeros(npart)) - pset2 = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.ones(npart)) + pset = ParticleSet(fieldset, pclass=pclass(), x=xv.flatten(), y=yv.flatten(), depth=np.zeros(npart)) + pset2 = ParticleSet(fieldset, pclass=pclass(), x=xv.flatten(), y=yv.flatten(), depth=np.ones(npart)) pset.add(pset2) pset.execute(SampleP, endtime=1, dt=1) assert np.allclose(pset.p[(pset.lon < 0.5) & (pset.lat > 0.5) & (pset.depth > 0.5)], 1.0, rtol=1e-5) @@ -247,9 +247,9 @@ def test_inversedistance_nearland(withDepth, arrtype): fieldset.P.interp_method = "linear_invdist_land_tracer" xv, yv = np.meshgrid(np.linspace(0.1, 0.9, int(np.sqrt(npart))), np.linspace(0.1, 0.9, int(np.sqrt(npart)))) - pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.zeros(npart)) + pset = ParticleSet(fieldset, pclass=pclass(), x=xv.flatten(), y=yv.flatten(), depth=np.zeros(npart)) if withDepth: - pset2 = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.ones(npart)) + pset2 = ParticleSet(fieldset, pclass=pclass(), x=xv.flatten(), y=yv.flatten(), depth=np.ones(npart)) pset.add(pset2) pset.execute(SampleP, endtime=1, dt=1) if arrtype == "rand": @@ -301,7 +301,7 @@ def test_partialslip_nearland_zonal(boundaryslip, withW, withT): fieldset = FieldSet.from_data(data, dimensions, mesh="flat", interp_method=boundaryslip) pset = ParticleSet( - fieldset, pclass=Particle, lon=np.zeros(npart), lat=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) + fieldset, pclass=Particle, x=np.zeros(npart), y=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) ) kernel = AdvectionRK4_3D if withW else AdvectionRK4 pset.execute(kernel, endtime=2, dt=1) @@ -345,7 +345,7 @@ def test_partialslip_nearland_meridional(boundaryslip, withW): fieldset = FieldSet.from_data(data, dimensions, mesh="flat", interp_method=interp_method) pset = ParticleSet( - fieldset, pclass=Particle, lat=np.zeros(npart), lon=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) + fieldset, pclass=Particle, y=np.zeros(npart), x=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) ) kernel = AdvectionRK4_3D if withW else AdvectionRK4 pset.execute(kernel, endtime=2, dt=1) @@ -380,7 +380,7 @@ def test_partialslip_nearland_vertical(boundaryslip): fieldset = FieldSet.from_data(data, dimensions, mesh="flat", interp_method={"U": boundaryslip, "V": boundaryslip}) pset = ParticleSet( - fieldset, pclass=Particle, lon=np.zeros(npart), lat=np.zeros(npart), depth=np.linspace(0.1, 3.9, npart) + fieldset, pclass=Particle, x=np.zeros(npart), y=np.zeros(npart), depth=np.linspace(0.1, 3.9, npart) ) pset.execute(AdvectionRK4, endtime=2, dt=1) if boundaryslip == "partialslip": @@ -408,11 +408,11 @@ def test_fieldset_sample_particle(): lon = np.linspace(-170, 170, npart) lat = np.linspace(-80, 80, npart) - pset = ParticleSet(fieldset, pclass=pclass(), lon=lon, lat=np.zeros(npart) + 70.0) + pset = ParticleSet(fieldset, pclass=pclass(), x=lon, y=np.zeros(npart) + 70.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.v, lon, rtol=1e-6) - pset = ParticleSet(fieldset, pclass=pclass(), lat=lat, lon=np.zeros(npart) - 45.0) + pset = ParticleSet(fieldset, pclass=pclass(), y=lat, x=np.zeros(npart) - 45.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.u, lat, rtol=1e-6) @@ -426,11 +426,11 @@ def test_fieldset_sample_geographic(fieldset_geometric): lon = np.linspace(-170, 170, npart) lat = np.linspace(-80, 80, npart) - pset = ParticleSet(fieldset, pclass=pclass(), lon=lon, lat=np.zeros(npart) + 70.0) + pset = ParticleSet(fieldset, pclass=pclass(), x=lon, y=np.zeros(npart) + 70.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.v, lon, rtol=1e-6) - pset = ParticleSet(fieldset, pclass=pclass(), lat=lat, lon=np.zeros(npart) - 45.0) + pset = ParticleSet(fieldset, pclass=pclass(), y=lat, x=np.zeros(npart) - 45.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.u, lat, rtol=1e-6) @@ -444,11 +444,11 @@ def test_fieldset_sample_geographic_polar(fieldset_geometric_polar): lon = np.linspace(-170, 170, npart) lat = np.linspace(-80, 80, npart) - pset = ParticleSet(fieldset, pclass=pclass(), lon=lon, lat=np.zeros(npart) + 70.0) + pset = ParticleSet(fieldset, pclass=pclass(), x=lon, y=np.zeros(npart) + 70.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.v, lon, rtol=1e-6) - pset = ParticleSet(fieldset, pclass=pclass(), lat=lat, lon=np.zeros(npart) - 45.0) + pset = ParticleSet(fieldset, pclass=pclass(), y=lat, x=np.zeros(npart) - 45.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.u, lat, rtol=1e-2) @@ -475,7 +475,7 @@ def test_meridionalflow_spherical(): lonstart = [0, 45] latstart = [0, 45] runtime = timedelta(hours=24) - pset = ParticleSet(fieldset, pclass=Particle, lon=lonstart, lat=latstart) + pset = ParticleSet(fieldset, pclass=Particle, x=lonstart, y=latstart) pset.execute(pset.Kernel(AdvectionRK4), runtime=runtime, dt=timedelta(hours=1)) assert pset.lat[0] - (latstart[0] + runtime.total_seconds() * maxvel / 1852 / 60) < 1e-4 @@ -507,7 +507,7 @@ def test_zonalflow_spherical(): lonstart = [0, 45] latstart = [0, 45] runtime = timedelta(hours=24) - pset = ParticleSet(fieldset, pclass=pclass(), lon=lonstart, lat=latstart) + pset = ParticleSet(fieldset, pclass=pclass(), x=lonstart, y=latstart) pset.execute(pset.Kernel(AdvectionRK4) + SampleP, runtime=runtime, dt=timedelta(hours=1)) assert pset.lat[0] - latstart[0] < 1e-4 @@ -566,7 +566,7 @@ def test_sampling_out_of_bounds_time(allow_time_extrapolation): } fieldset = FieldSet.from_data(data, dimensions, mesh="flat", allow_time_extrapolation=allow_time_extrapolation) - pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=-1.0) + pset = ParticleSet(fieldset, pclass=pclass(), x=[0.5], y=[0.5], time=-1.0) if allow_time_extrapolation: pset.execute(SampleP, endtime=-0.9, dt=0.1) assert np.allclose(pset.p, 0.0, rtol=1e-5) @@ -574,19 +574,19 @@ def test_sampling_out_of_bounds_time(allow_time_extrapolation): with pytest.raises(RuntimeError): pset.execute(SampleP, endtime=-0.9, dt=0.1) - pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=0) + pset = ParticleSet(fieldset, pclass=pclass(), x=[0.5], y=[0.5], time=0) pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 0.0, rtol=1e-5) - pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=0.5) + pset = ParticleSet(fieldset, pclass=pclass(), x=[0.5], y=[0.5], time=0.5) pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 0.5, rtol=1e-5) - pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=1.0) + pset = ParticleSet(fieldset, pclass=pclass(), x=[0.5], y=[0.5], time=1.0) pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 1.0, rtol=1e-5) - pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=2.0) + pset = ParticleSet(fieldset, pclass=pclass(), x=[0.5], y=[0.5], time=2.0) if allow_time_extrapolation: pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 1.0, rtol=1e-5) @@ -606,7 +606,7 @@ def test_sampling_3DCROCO(): def SampleU(particle, fieldset, time): # pragma: no cover particle.p = fieldset.U[time, particle.depth, particle.lat, particle.lon, particle] - pset = ParticleSet(fieldset, pclass=SampleP, lon=120e3, lat=50e3, depth=-0.4) + pset = ParticleSet(fieldset, pclass=SampleP, x=120e3, y=50e3, depth=-0.4) pset.execute(SampleU, endtime=1, dt=1) assert np.isclose(pset.p, 1.0) @@ -727,7 +727,7 @@ def test_sampling_multiple_grid_sizes(ugridfactor): lat=np.linspace(0.0, 1.0, ydim, dtype=np.float32), ) fieldset = FieldSet(U, V) - pset = ParticleSet(fieldset, pclass=Particle, lon=[0.8], lat=[0.9]) + pset = ParticleSet(fieldset, pclass=Particle, x=[0.8], y=[0.9]) if ugridfactor > 1: assert fieldset.U.grid is not fieldset.V.grid @@ -756,7 +756,7 @@ def test_multiple_grid_addlater_error(): ) fieldset = FieldSet(U, V) - pset = ParticleSet(fieldset, pclass=Particle, lon=[0.8], lat=[0.9]) # noqa ; to trigger fieldset._check_complete + pset = ParticleSet(fieldset, pclass=Particle, x=[0.8], y=[0.9]) # noqa ; to trigger fieldset._check_complete P = Field( "P", @@ -798,7 +798,7 @@ def calc_p(t, y, x): fieldset = FieldSet.from_data(data, dimensions, mesh="flat") xv, yv = np.meshgrid(np.arange(0, 1, 0.5), np.arange(0, 1, 0.5)) - pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten()) + pset = ParticleSet(fieldset, pclass=pclass(), x=xv.flatten(), y=yv.flatten()) def SampleP(particle, fieldset, time): # pragma: no cover particle.p = fieldset.P[time, particle.depth, particle.lat, particle.lon] diff --git a/tests-v3/test_kernel_execution.py b/tests-v3/test_kernel_execution.py index 6a61f2986..dd74a9358 100644 --- a/tests-v3/test_kernel_execution.py +++ b/tests-v3/test_kernel_execution.py @@ -37,7 +37,7 @@ def SampleP(particle, fieldset, time): # pragma: no cover lons = [] ps = [] for dir in [1, -1]: - pset = ParticleSet(fieldset, pclass=SampleParticle, lon=0, lat=0) + pset = ParticleSet(fieldset, pclass=SampleParticle, x=0, y=0) pset.execute(kernels[::dir], endtime=1, dt=1) lons.append(pset.lon) ps.append(pset.p) @@ -62,7 +62,7 @@ def Kernel2(particle, fieldset, time): # pragma: no cover add_lon = -0.3 particle.dlon += add_lon - pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, x=[0.5], y=[0.5]) pset.execute([Kernel1, Kernel2], endtime=2.0, dt=1.0) assert np.allclose(pset.lon, 0.3, rtol=1e-5) @@ -78,7 +78,7 @@ def MoveWest(particle, fieldset, time): # pragma: no cover add_lon = -0.3 particle.dlon += add_lon - pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, x=[0.5], y=[0.5]) pset.execute(pset.Kernel(MoveEast), endtime=1.0, dt=1.0) pset.execute(pset.Kernel(MoveWest), endtime=3.0, dt=1.0) assert np.allclose(pset.lon, 0.3, rtol=1e-5) # should be 0.5 + 0.1 - 0.3 = 0.3 diff --git a/tests-v3/test_kernel_language.py b/tests-v3/test_kernel_language.py index eaae53f21..c4bb80b05 100644 --- a/tests-v3/test_kernel_language.py +++ b/tests-v3/test_kernel_language.py @@ -42,8 +42,8 @@ def test_expression_int(name, expr, result): pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, - lon=np.linspace(0.0, 1.0, npart), - lat=np.zeros(npart) + 0.5, + x=np.linspace(0.0, 1.0, npart), + y=np.zeros(npart) + 0.5, ) pset.execute(expr_kernel(f"Test{name}", pset, expr), endtime=1.0, dt=1.0) assert np.all([p.p == result for p in pset]) @@ -66,8 +66,8 @@ def test_expression_float(name, expr, result): pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, - lon=np.linspace(0.0, 1.0, npart), - lat=np.zeros(npart) + 0.5, + x=np.linspace(0.0, 1.0, npart), + y=np.zeros(npart) + 0.5, ) pset.execute(expr_kernel(f"Test{name}", pset, expr), endtime=1.0, dt=1.0) assert np.all([p.p == result for p in pset]) @@ -96,8 +96,8 @@ def test_expression_bool(name, expr, result): pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, - lon=np.linspace(0.0, 1.0, npart), - lat=np.zeros(npart) + 0.5, + x=np.linspace(0.0, 1.0, npart), + y=np.zeros(npart) + 0.5, ) pset.execute(expr_kernel(f"Test{name}", pset, expr), endtime=1.0, dt=1.0) assert np.all(result == pset.p) @@ -106,7 +106,7 @@ def test_expression_bool(name, expr, result): def test_while_if_break(): """Test while, if and break commands.""" TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=[0], lat=[0]) + pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, x=[0], y=[0]) def kernel(particle, fieldset, time): # pragma: no cover while particle.p < 30: @@ -125,7 +125,7 @@ def test_nested_if(): TestParticle = Particle.add_variables( [Variable("p0", dtype=np.int32, initial=0), Variable("p1", dtype=np.int32, initial=1)] ) - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=0, lat=0) + pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, x=0, y=0) def kernel(particle, fieldset, time): # pragma: no cover if particle.p1 >= particle.p0: @@ -140,7 +140,7 @@ def kernel(particle, fieldset, time): # pragma: no cover def test_pass(): """Test pass commands.""" TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=0, lat=0) + pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, x=0, y=0) def kernel(particle, fieldset, time): # pragma: no cover particle.p = -1 @@ -151,7 +151,7 @@ def kernel(particle, fieldset, time): # pragma: no cover def test_dt_as_variable_in_kernel(): - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=Particle, lon=0, lat=0) + pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=Particle, x=0, y=0) def kernel(particle, fieldset, time): # pragma: no cover dt = 1.0 # noqa @@ -165,7 +165,7 @@ def test_varname_as_fieldname(): fset.add_field(Field("speed", 10, lon=0, lat=0)) fset.add_constant("vertical_speed", 0.1) particle = Particle.add_variable("speed") - pset = ParticleSet(fset, pclass=particle, lon=0, lat=0) + pset = ParticleSet(fset, pclass=particle, x=0, y=0) def kernel_particlename(particle, fieldset, time): # pragma: no cover particle.speed = fieldset.speed[particle] @@ -182,7 +182,7 @@ def kernel_varname(particle, fieldset, time): # pragma: no cover def test_if_withfield(fieldset_unit_mesh): """Test combination of if and Field sampling commands.""" TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) - pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, lon=[0], lat=[0]) + pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, x=[0], y=[0]) def kernel(particle, fieldset, time): # pragma: no cover u, v = fieldset.UV[time, 0, 0, 1.0] @@ -217,7 +217,7 @@ def kernel(particle, fieldset, time): # pragma: no cover def test_print(fieldset_unit_mesh, capfd): """Test print statements.""" TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) - pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, x=[0.5], y=[0.5]) def kernel(particle, fieldset, time): # pragma: no cover particle.p = 1e-3 @@ -245,7 +245,7 @@ def kernel2(particle, fieldset, time): # pragma: no cover def test_fieldset_access(fieldset_unit_mesh): - pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, lon=0, lat=0) + pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, x=0, y=0) def kernel(particle, fieldset, time): # pragma: no cover particle.lon = fieldset.U.grid.lon[2] @@ -257,7 +257,7 @@ def kernel(particle, fieldset, time): # pragma: no cover @pytest.mark.parametrize("concat", [False, True]) def test_random_kernel_concat(fieldset_unit_mesh, concat): TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) - pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, lon=0, lat=0) + pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, x=0, y=0) def RandomKernel(particle, fieldset, time): # pragma: no cover particle.p += random.uniform(0, 1) @@ -272,7 +272,7 @@ def AddOne(particle, fieldset, time): # pragma: no cover def test_dt_modif_by_kernel(): TestParticle = Particle.add_variable("age", dtype=np.float32, initial=0) - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=[0.5], lat=[0]) + pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, x=[0.5], y=[0]) def modif_dt(particle, fieldset, time): # pragma: no cover particle.age += particle.dt @@ -291,8 +291,8 @@ def test_small_dt(dt, expectation): pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), pclass=Particle, - lon=np.zeros(npart), - lat=np.zeros(npart), + x=np.zeros(npart), + y=np.zeros(npart), time=np.arange(0, npart) * dt * 10, ) diff --git a/tests-v3/test_particles.py b/tests-v3/test_particles.py index 172d2a429..23680a2a0 100644 --- a/tests-v3/test_particles.py +++ b/tests-v3/test_particles.py @@ -19,7 +19,7 @@ def fieldset(): def test_print(fieldset): TestParticle = Particle.add_variable("p", to_write=True) - pset = ParticleSet(fieldset, pclass=TestParticle, lon=[0, 1], lat=[0, 1]) + pset = ParticleSet(fieldset, pclass=TestParticle, x=[0, 1], y=[0, 1]) print(pset) @@ -32,7 +32,7 @@ def test_variable_init(fieldset): ] TestParticle = Particle.add_variables(extra_vars) TestParticle = TestParticle.add_variable("p_int", np.int32, initial=12.0) - pset = ParticleSet(fieldset, pclass=TestParticle, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + pset = ParticleSet(fieldset, pclass=TestParticle, x=np.linspace(0, 1, npart), y=np.linspace(1, 0, npart)) def addOne(particle, fieldset, time): # pragma: no cover particle.p_float += 1.0 @@ -50,7 +50,7 @@ def test_variable_unsupported_dtypes(fieldset, type): """Test that checks errors thrown for unsupported dtypes.""" TestParticle = Particle.add_variable("p", dtype=type, initial=10.0) with pytest.raises((RuntimeError, TypeError)): - ParticleSet(fieldset, pclass=TestParticle, lon=[0], lat=[0]) + ParticleSet(fieldset, pclass=TestParticle, x=[0], y=[0]) def test_variable_special_names(fieldset): @@ -58,7 +58,7 @@ def test_variable_special_names(fieldset): for vars in ["z", "lon"]: TestParticle = Particle.add_variable(vars, dtype=np.float32, initial=10.0) with pytest.raises(AttributeError): - ParticleSet(fieldset, pclass=TestParticle, lon=[0], lat=[0]) + ParticleSet(fieldset, pclass=TestParticle, x=[0], y=[0]) @pytest.mark.parametrize("coord_type", [np.float32, np.float64]) @@ -78,7 +78,7 @@ def test_variable_init_relative(fieldset, coord_type): lon = np.linspace(0, 1, npart, dtype=lonlat_type) lat = np.linspace(1, 0, npart, dtype=lonlat_type) - pset = ParticleSet(fieldset, pclass=TestParticle, lon=lon, lat=lat, lonlatdepth_dtype=coord_type) + pset = ParticleSet(fieldset, pclass=TestParticle, x=lon, y=lat, lonlatdepth_dtype=coord_type) # Adjust base variable to test for aliasing effects for p in pset: p.p_base += 3.0 diff --git a/tests-v3/test_particlesets.py b/tests-v3/test_particlesets.py index 73bbdb204..f44fd9750 100644 --- a/tests-v3/test_particlesets.py +++ b/tests-v3/test_particlesets.py @@ -20,7 +20,7 @@ def fieldset(): @pytest.fixture def pset(fieldset): npart = 10 - pset = ParticleSet(fieldset, pclass=Particle, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) + pset = ParticleSet(fieldset, pclass=Particle, x=np.linspace(0, 1, npart), y=np.zeros(npart)) return pset @@ -32,7 +32,7 @@ def test_pset_create_list_with_customvariable(fieldset): MyParticle = Particle.add_variable("v") v_vals = np.arange(npart) - pset = ParticleSet(fieldset, lon=lon, lat=lat, v=v_vals, pclass=MyParticle) + pset = ParticleSet(fieldset, x=lon, y=lat, v=v_vals, pclass=MyParticle) assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) assert np.allclose([p.v for p in pset], v_vals, rtol=1e-12) @@ -47,7 +47,7 @@ def test_pset_create_fromparticlefile(fieldset, restart, tmp_zarrfile): TestParticle = TestParticle.add_variable("p2", np.float32, initial=1, to_write=False) TestParticle = TestParticle.add_variable("p3", np.float64, to_write="once") - pset = ParticleSet(fieldset, lon=lon, lat=lat, depth=[4] * len(lon), pclass=TestParticle, p3=np.arange(len(lon))) + pset = ParticleSet(fieldset, x=lon, y=lat, depth=[4] * len(lon), pclass=TestParticle, p3=np.arange(len(lon))) pfile = pset.ParticleFile(tmp_zarrfile, outputdt=1) def Kernel(particle, fieldset, time): # pragma: no cover @@ -125,9 +125,9 @@ def test_pset_create_with_time(fieldset): lon = np.linspace(0, 1, npart) lat = np.linspace(1, 0, npart) time = 5.0 - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle, time=time) + pset = ParticleSet(fieldset, x=lon, y=lat, pclass=Particle, time=time) assert np.allclose([p.time for p in pset], time, rtol=1e-12) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle, time=[time] * npart) + pset = ParticleSet(fieldset, x=lon, y=lat, pclass=Particle, time=[time] * npart) assert np.allclose([p.time for p in pset], time, rtol=1e-12) pset = ParticleSet.from_line(fieldset, size=npart, start=(0, 1), finish=(1, 0), pclass=Particle, time=time) assert np.allclose([p.time for p in pset], time, rtol=1e-12) @@ -136,7 +136,7 @@ def test_pset_create_with_time(fieldset): def test_pset_repeated_release(fieldset): npart = 10 time = np.arange(0, npart, 1) # release 1 particle every second - pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.zeros(npart), pclass=Particle, time=time) + pset = ParticleSet(fieldset, x=np.zeros(npart), y=np.zeros(npart), pclass=Particle, time=time) assert np.allclose([p.time for p in pset], time) def IncrLon(particle, fieldset, time): # pragma: no cover @@ -147,7 +147,7 @@ def IncrLon(particle, fieldset, time): # pragma: no cover def test_pset_repeatdt_check_dt(fieldset): - pset = ParticleSet(fieldset, lon=[0], lat=[0], pclass=Particle, repeatdt=5) + pset = ParticleSet(fieldset, x=[0], y=[0], pclass=Particle, repeatdt=5) def IncrLon(particle, fieldset, time): # pragma: no cover particle.lon = 1.0 @@ -160,7 +160,7 @@ def test_pset_access(fieldset): npart = 100 lon = np.linspace(0, 1, npart, dtype=np.float32) lat = np.linspace(1, 0, npart, dtype=np.float32) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle) + pset = ParticleSet(fieldset, x=lon, y=lat, pclass=Particle) assert pset.size == 100 assert np.allclose([pset[i].lon for i in range(pset.size)], lon, rtol=1e-12) assert np.allclose([pset[i].lat for i in range(pset.size)], lat, rtol=1e-12) @@ -170,7 +170,7 @@ def test_pset_custom_pclass(fieldset): npart = 100 TestParticle = Particle.add_variable([Variable("p", np.float32, initial=0.33), Variable("n", np.int32, initial=2)]) - pset = ParticleSet(fieldset, pclass=TestParticle, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + pset = ParticleSet(fieldset, pclass=TestParticle, x=np.linspace(0, 1, npart), y=np.linspace(1, 0, npart)) assert pset.size == npart assert np.allclose([p.p - 0.33 for p in pset], np.zeros(npart), atol=1e-5) assert np.allclose([p.n - 2 for p in pset], np.zeros(npart), rtol=1e-12) @@ -182,9 +182,9 @@ def test_pset_add_execute(fieldset): def AddLat(particle, fieldset, time): # pragma: no cover particle.dlat += 0.1 - pset = ParticleSet(fieldset, lon=[], lat=[], pclass=Particle) + pset = ParticleSet(fieldset, x=[], y=[], pclass=Particle) for _ in range(npart): - pset += ParticleSet(pclass=Particle, lon=0.1, lat=0.1, fieldset=fieldset) + pset += ParticleSet(pclass=Particle, x=0.1, y=0.1, fieldset=fieldset) for _ in range(4): pset.execute(pset.Kernel(AddLat), runtime=1.0, dt=1.0) assert np.allclose(np.array([p.lat for p in pset]), 0.4, rtol=1e-12) @@ -195,7 +195,7 @@ def test_pset_remove_particle(fieldset): npart = 100 lon = np.linspace(0, 1, npart) lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle) + pset = ParticleSet(fieldset, x=lon, y=lat, pclass=Particle) for ilon, ilat in zip(lon[::-1], lat[::-1], strict=True): assert pset.lon[-1] == ilon assert pset.lat[-1] == ilat diff --git a/tests-v3/tools/test_warnings.py b/tests-v3/tools/test_warnings.py index 7dc03c66a..9d646c373 100644 --- a/tests-v3/tools/test_warnings.py +++ b/tests-v3/tools/test_warnings.py @@ -33,8 +33,8 @@ def test_kernel_warnings(): pset = ParticleSet( fieldset=fieldset, pclass=Particle.add_variable("next_dt", dtype=np.float32, initial=1), - lon=[0], - lat=[0], + x=[0], + y=[0], depth=[0], time=[0], next_dt=1, diff --git a/tests/common_kernels.py b/tests/common_kernels.py index 53e3c7310..adbf6f5ff 100644 --- a/tests/common_kernels.py +++ b/tests/common_kernels.py @@ -14,8 +14,8 @@ def DeleteParticle(particles, fieldset): # pragma: no cover def MoveEast(particles, fieldset): # pragma: no cover - particles.dlon += 0.1 + particles.dx += 0.1 def MoveNorth(particles, fieldset): # pragma: no cover - particles.dlat += 0.1 + particles.dy += 0.1 diff --git a/tests/test_advection.py b/tests/test_advection.py index 3141c62ac..2793ccb88 100644 --- a/tests/test_advection.py +++ b/tests/test_advection.py @@ -50,15 +50,15 @@ def test_advection_zonal(mesh, npart=10): runtime = 7200 startlat = np.linspace(0, 80, npart) startlon = 20.0 + np.zeros(npart) - pset = ParticleSet(fieldset, lon=startlon, lat=startlat) + pset = ParticleSet(fieldset, x=startlon, y=startlat) pset.execute(AdvectionRK4, runtime=runtime, dt=np.timedelta64(15, "m")) expected_dlon = runtime if mesh == "spherical": - expected_dlon /= 1852 * 60 * np.cos(np.deg2rad(pset.lat)) + expected_dlon /= 1852 * 60 * np.cos(np.deg2rad(pset.y)) - np.testing.assert_allclose(pset.lon - startlon, expected_dlon, atol=1e-5) - np.testing.assert_allclose(pset.lat, startlat, atol=1e-5) + np.testing.assert_allclose(pset.x - startlon, expected_dlon, atol=1e-5) + np.testing.assert_allclose(pset.y, startlat, atol=1e-5) def test_advection_zonal_with_particlefile(tmp_parquet): @@ -68,20 +68,20 @@ def test_advection_zonal_with_particlefile(tmp_parquet): ds["U"].data[:] = 1.0 fieldset = FieldSet.from_sgrid_conventions(ds, mesh="flat") - pset = ParticleSet(fieldset, lon=np.zeros(npart) + 20.0, lat=np.linspace(0, 80, npart)) + pset = ParticleSet(fieldset, x=np.zeros(npart) + 20.0, y=np.linspace(0, 80, npart)) pfile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(30, "m")) pset.execute(AdvectionRK4, runtime=np.timedelta64(2, "h"), dt=np.timedelta64(15, "m"), output_file=pfile) - assert (np.diff(pset.lon) < 1.0e-4).all() + assert (np.diff(pset.x) < 1.0e-4).all() df = pd.read_parquet(tmp_parquet) final_time = df["time"].max() - np.testing.assert_allclose(df[df["time"] == final_time]["lon"].values, pset.lon, atol=1e-5) + np.testing.assert_allclose(df[df["time"] == final_time]["x"].values, pset.x, atol=1e-5) assert_cftime_like_particlefile(tmp_parquet) def periodicBC(particles, fieldset): - particles.total_dlon += particles.dlon - particles.lon = np.fmod(particles.lon, 2) + particles.total_dlon += particles.dx + particles.x = np.fmod(particles.x, 2) def test_advection_zonal_periodic(): @@ -100,11 +100,11 @@ def test_advection_zonal_periodic(): PeriodicParticle = Particle.add_variable(Variable("total_dlon", initial=0)) startlon = np.array([0.5, 0.4]) - pset = ParticleSet(fieldset, pclass=PeriodicParticle, lon=startlon, lat=[0.5, 0.5]) + pset = ParticleSet(fieldset, pclass=PeriodicParticle, x=startlon, y=[0.5, 0.5]) pset.execute([AdvectionEE, periodicBC], runtime=np.timedelta64(40, "s"), dt=np.timedelta64(1, "s")) np.testing.assert_allclose(pset.total_dlon, 4.0, atol=1e-5) - np.testing.assert_allclose(pset.lon, startlon, atol=1e-5) - np.testing.assert_allclose(pset.lat, 0.5, atol=1e-5) + np.testing.assert_allclose(pset.x, startlon, atol=1e-5) + np.testing.assert_allclose(pset.y, 0.5, atol=1e-5) @pytest.mark.parametrize("mesh", ["spherical", "flat"]) @@ -117,15 +117,15 @@ def test_advection_meridional(mesh, npart=10): runtime = 7200 startlat = np.linspace(0, 80, npart) startlon = 20.0 + np.zeros(npart) - pset = ParticleSet(fieldset, lon=startlon, lat=startlat) + pset = ParticleSet(fieldset, x=startlon, y=startlat) pset.execute(AdvectionRK4, runtime=runtime, dt=np.timedelta64(15, "m")) expected_dlat = runtime if mesh == "spherical": expected_dlat /= 1852 * 60 - np.testing.assert_allclose(pset.lon, startlon, atol=1e-5) - np.testing.assert_allclose(pset.lat - startlat, expected_dlat, atol=1e-4) + np.testing.assert_allclose(pset.x, startlon, atol=1e-5) + np.testing.assert_allclose(pset.y - startlat, expected_dlat, atol=1e-4) @pytest.mark.parametrize("mesh", ["spherical", "flat"]) @@ -136,13 +136,13 @@ def test_horizontal_advection_in_3D_flow(mesh, npart=10): ds["U"].data[:, 0, :, :] = 0.0 # Set U to 0 at the surface fieldset = FieldSet.from_sgrid_conventions(ds, mesh=mesh) - pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.zeros(npart), z=np.linspace(0.1, 0.9, npart)) + pset = ParticleSet(fieldset, x=np.zeros(npart), y=np.zeros(npart), z=np.linspace(0.1, 0.9, npart)) pset.execute(AdvectionRK4, runtime=np.timedelta64(2, "h"), dt=np.timedelta64(15, "m")) expected_lon = pset.z * pset.time if mesh == "spherical": - expected_lon /= 1852 * 60 * np.cos(np.deg2rad(pset.lat)) - np.testing.assert_allclose(pset.lon, expected_lon, atol=1.0e-1) + expected_lon /= 1852 * 60 * np.cos(np.deg2rad(pset.y)) + np.testing.assert_allclose(pset.x, expected_lon, atol=1.0e-1) @pytest.mark.parametrize("direction", ["up", "down"]) @@ -167,8 +167,8 @@ def SubmergeParticle(particles, fieldset): # pragma: no cover if len(inds) == 0: return (u, v) = fieldset.UV[particles[inds]] - particles[inds].dlon = u * particles.dt - particles[inds].dlat = v * particles.dt + particles[inds].dx = u * particles.dt + particles[inds].dy = v * particles.dt particles[inds].dz = 0.0 particles[inds].z = 0 particles[inds].state = StatusCode.Evaluate @@ -178,13 +178,13 @@ def SubmergeParticle(particles, fieldset): # pragma: no cover kernels.append(SubmergeParticle) kernels.append(DeleteParticle) - pset = ParticleSet(fieldset=fieldset, lon=0.5, lat=0.5, z=0.9) + pset = ParticleSet(fieldset=fieldset, x=0.5, y=0.5, z=0.9) with warnings.catch_warnings(): warnings.simplefilter("error", FieldEvalWarning) pset.execute(kernels, runtime=np.timedelta64(10, "s"), dt=np.timedelta64(1, "s")) if direction == "up" and resubmerge_particle: - np.testing.assert_allclose(pset.lon[0], 0.6, atol=1e-5) + np.testing.assert_allclose(pset.x[0], 0.6, atol=1e-5) np.testing.assert_allclose(pset.z[0], 0, atol=1e-5) else: assert len(pset) == 0 @@ -219,13 +219,13 @@ def test_length1dimensions(u_value, x_slice, v_value, y_slice, w_value, z_slice) fieldset = FieldSet.from_sgrid_conventions(ds, mesh="flat") x0, y0, z0 = 3, 3, 20 - pset = ParticleSet(fieldset, lon=x0, lat=y0, z=z0) + pset = ParticleSet(fieldset, x=x0, y=y0, z=z0) kernel = AdvectionRK4 if w_value is None else AdvectionRK4_3D pset.execute(kernel, runtime=np.timedelta64(4, "s"), dt=np.timedelta64(1, "s")) - assert len(pset.lon) == len([p.lon for p in pset]) - np.testing.assert_allclose(np.array([p.lon - x0 for p in pset]), 4 * u_value, atol=1e-5) - np.testing.assert_allclose(np.array([p.lat - y0 for p in pset]), 4 * v_value, atol=1e-5) + assert len(pset.x) == len([p.x for p in pset]) + np.testing.assert_allclose(np.array([p.x - x0 for p in pset]), 4 * u_value, atol=1e-5) + np.testing.assert_allclose(np.array([p.y - y0 for p in pset]), 4 * v_value, atol=1e-5) if w_value: np.testing.assert_allclose(np.array([p.z - z0 for p in pset]), 4 * w_value, atol=1e-5) @@ -240,15 +240,15 @@ def test_radialrotation(npart=10): starttime = np.arange(np.timedelta64(0, "s"), npart * dt, dt) endtime = np.timedelta64(10, "m") - pset = parcels.ParticleSet(fieldset, lon=lon, lat=lat, time=starttime) + pset = parcels.ParticleSet(fieldset, x=lon, y=lat, time=starttime) pset.execute(parcels.kernels.AdvectionRK4, endtime=endtime, dt=dt) theta = 2 * np.pi * (pset.time - timedelta_to_float(starttime)) / (24 * 3600) true_lon = (lon - 30.0) * np.cos(theta) + 30.0 true_lat = -(lon - 30.0) * np.sin(theta) + 30.0 - np.testing.assert_allclose(pset.lon, true_lon, atol=5e-2) - np.testing.assert_allclose(pset.lat, true_lat, atol=5e-2) + np.testing.assert_allclose(pset.x, true_lon, atol=5e-2) + np.testing.assert_allclose(pset.y, true_lat, atol=5e-2) @pytest.mark.parametrize( @@ -288,7 +288,7 @@ def test_moving_eddy(kernel, rtol): fieldset.add_context("RK45_tol", rtol) pset = ParticleSet( - fieldset, pclass=DEFAULT_PARTICLES[kernel], lon=start_lon, lat=start_lat, z=start_z, time=np.timedelta64(0, "s") + fieldset, pclass=DEFAULT_PARTICLES[kernel], x=start_lon, y=start_lat, z=start_z, time=np.timedelta64(0, "s") ) pset.execute(kernel, dt=dt, endtime=endtime) @@ -299,8 +299,8 @@ def truth_moving(x_0, y_0, t): return lon, lat exp_lon, exp_lat = truth_moving(start_lon, start_lat, endtime) - np.testing.assert_allclose(pset.lon, exp_lon, rtol=rtol) - np.testing.assert_allclose(pset.lat, exp_lat, rtol=rtol) + np.testing.assert_allclose(pset.x, exp_lon, rtol=rtol) + np.testing.assert_allclose(pset.y, exp_lat, rtol=rtol) if kernel == AdvectionRK4_3D: np.testing.assert_allclose(pset.z, exp_lat, rtol=rtol) @@ -327,7 +327,7 @@ def test_decaying_moving_eddy(kernel, rtol): fieldset.add_context("RK45_min_dt", 10 * 60) pset = ParticleSet( - fieldset, pclass=DEFAULT_PARTICLES[kernel], lon=start_lon, lat=start_lat, time=np.timedelta64(0, "s") + fieldset, pclass=DEFAULT_PARTICLES[kernel], x=start_lon, y=start_lat, time=np.timedelta64(0, "s") ) pset.execute(kernel, dt=dt, endtime=endtime) @@ -346,8 +346,8 @@ def truth_moving(x_0, y_0, t): return lon, lat exp_lon, exp_lat = truth_moving(start_lon, start_lat, endtime) - np.testing.assert_allclose(pset.lon, exp_lon, rtol=rtol) - np.testing.assert_allclose(pset.lat, exp_lat, rtol=rtol) + np.testing.assert_allclose(pset.x, exp_lon, rtol=rtol) + np.testing.assert_allclose(pset.y, exp_lat, rtol=rtol) @pytest.mark.parametrize( @@ -376,10 +376,10 @@ def test_stommelgyre_fieldset(kernel, rtol, grid_type): fieldset.add_context("RK45_tol", rtol) def UpdateP(particles, fieldset): # pragma: no cover - particles.p = fieldset.P[particles.time, particles.z, particles.lat, particles.lon] + particles.p = fieldset.P[particles.time, particles.z, particles.y, particles.x] particles.p_start = np.where(particles.time == 0, particles.p, particles.p_start) - pset = ParticleSet(fieldset, pclass=SampleParticle, lon=start_lon, lat=start_lat, time=np.timedelta64(0, "s")) + pset = ParticleSet(fieldset, pclass=SampleParticle, x=start_lon, y=start_lat, time=np.timedelta64(0, "s")) pset.execute([kernel, UpdateP], dt=dt, runtime=runtime) np.testing.assert_allclose(pset.p, pset.p_start, rtol=rtol) @@ -411,10 +411,10 @@ def test_peninsula_fieldset(kernel, rtol, grid_type): fieldset.add_context("RK45_tol", rtol) def UpdateP(particles, fieldset): # pragma: no cover - particles.p = fieldset.P[particles.time, particles.z, particles.lat, particles.lon] + particles.p = fieldset.P[particles.time, particles.z, particles.y, particles.x] particles.p_start = np.where(particles.time == 0, particles.p, particles.p_start) - pset = ParticleSet(fieldset, pclass=SampleParticle, lon=start_lon, lat=start_lat, time=np.timedelta64(0, "s")) + pset = ParticleSet(fieldset, pclass=SampleParticle, x=start_lon, y=start_lat, time=np.timedelta64(0, "s")) pset.execute([kernel, UpdateP], dt=dt, runtime=runtime) np.testing.assert_allclose(pset.p, pset.p_start, rtol=rtol) @@ -433,9 +433,9 @@ def test_nemo_curvilinear_fieldset(): latp = np.linspace(-70, 88, npart) runtime = np.timedelta64(160, "D") - pset = parcels.ParticleSet(fieldset, lon=lonp, lat=latp) + pset = parcels.ParticleSet(fieldset, x=lonp, y=latp) pset.execute(AdvectionEE, runtime=runtime, dt=np.timedelta64(10, "D")) - np.testing.assert_allclose(pset.lat, latp, atol=1e-1) + np.testing.assert_allclose(pset.y, latp, atol=1e-1) @pytest.mark.parametrize("kernel", [AdvectionRK4, AdvectionRK4_3D]) @@ -453,7 +453,7 @@ def test_nemo_3D_curvilinear_fieldset(kernel): lons_initial = np.linspace(1.9, 3.4, npart) lats_initial = np.linspace(52.5, 51.6, npart) z_initial = np.ones_like(lons_initial) - pset = parcels.ParticleSet(fieldset, lon=lons_initial, lat=lats_initial, z=z_initial) + pset = parcels.ParticleSet(fieldset, x=lons_initial, y=lats_initial, z=z_initial) pset.execute(kernel, runtime=np.timedelta64(3, "D") + np.timedelta64(18, "h"), dt=np.timedelta64(6, "h")) @@ -477,7 +477,7 @@ def test_mitgcm(): lon = [24e3] * npart lat = np.linspace(22e3, 1950e3, npart) - pset = parcels.ParticleSet(fieldset, lon=lon, lat=lat) + pset = parcels.ParticleSet(fieldset, x=lon, y=lat) pset.execute(AdvectionRK4, runtime=np.timedelta64(1, "D"), dt=np.timedelta64(1, "h")) lat_v3 = [ 22363.3109351, @@ -491,4 +491,4 @@ def test_mitgcm(): 1741733.45906654, 1952691.93845841, ] - np.testing.assert_allclose(pset.lat, lat_v3, atol=1) + np.testing.assert_allclose(pset.y, lat_v3, atol=1) diff --git a/tests/test_diffusion.py b/tests/test_diffusion.py index 9acb5e878..ab9f6cce5 100644 --- a/tests/test_diffusion.py +++ b/tests/test_diffusion.py @@ -33,17 +33,17 @@ def test_fieldKh_Brownian(mesh): runtime = np.timedelta64(2, "h") np.random.seed(1234) - pset = ParticleSet(fieldset=fieldset, lon=np.zeros(npart), lat=np.zeros(npart)) + pset = ParticleSet(fieldset=fieldset, x=np.zeros(npart), y=np.zeros(npart)) pset.execute(DiffusionUniformKh, runtime=runtime, dt=np.timedelta64(1, "h")) expected_std_lon = np.sqrt(2 * kh_zonal * mesh_conversion**2 * timedelta_to_float(runtime)) expected_std_lat = np.sqrt(2 * kh_meridional * mesh_conversion**2 * timedelta_to_float(runtime)) tol = 500 * mesh_conversion # effectively 500 m errors - np.testing.assert_allclose(np.std(pset.lat), expected_std_lat, atol=tol) - np.testing.assert_allclose(np.std(pset.lon), expected_std_lon, atol=tol) - np.testing.assert_allclose(np.mean(pset.lon), 0, atol=tol) - np.testing.assert_allclose(np.mean(pset.lat), 0, atol=tol) + np.testing.assert_allclose(np.std(pset.y), expected_std_lat, atol=tol) + np.testing.assert_allclose(np.std(pset.x), expected_std_lon, atol=tol) + np.testing.assert_allclose(np.mean(pset.x), 0, atol=tol) + np.testing.assert_allclose(np.mean(pset.y), 0, atol=tol) @pytest.mark.parametrize("mesh", ["spherical", "flat"]) @@ -69,13 +69,13 @@ def test_fieldKh_SpatiallyVaryingDiffusion(mesh, kernel): npart = 10000 np.random.seed(1636) - pset = ParticleSet(fieldset=fieldset, lon=np.zeros(npart), lat=np.zeros(npart)) + pset = ParticleSet(fieldset=fieldset, x=np.zeros(npart), y=np.zeros(npart)) pset.execute(kernel, runtime=np.timedelta64(3, "h"), dt=np.timedelta64(1, "h")) tol = 2000 * mesh_conversion # effectively 2000 m errors (because of low numbers of particles) - assert np.allclose(np.mean(pset.lon), 0, atol=tol) - assert np.allclose(np.mean(pset.lat), 0, atol=tol) - assert abs(stats.skew(pset.lon)) > abs(stats.skew(pset.lat)) + assert np.allclose(np.mean(pset.x), 0, atol=tol) + assert np.allclose(np.mean(pset.y), 0, atol=tol) + assert abs(stats.skew(pset.x)) > abs(stats.skew(pset.y)) @pytest.mark.parametrize("lambd", [1, 5]) @@ -89,7 +89,7 @@ def test_randomexponential(lambd): # Set random seed np.random.seed(1234) - pset = ParticleSet(fieldset=fieldset, lon=np.zeros(npart), lat=np.zeros(npart), z=np.zeros(npart)) + pset = ParticleSet(fieldset=fieldset, x=np.zeros(npart), y=np.zeros(npart), z=np.zeros(npart)) def vertical_randomexponential(particles, fieldset): # pragma: no cover # Kernel for random exponential variable in z direction @@ -115,9 +115,7 @@ def test_randomvonmises(mu, kappa): np.random.seed(1234) AngleParticle = Particle.add_variable(Variable("angle")) - pset = ParticleSet( - fieldset=fieldset, pclass=AngleParticle, lon=np.zeros(npart), lat=np.zeros(npart), z=np.zeros(npart) - ) + pset = ParticleSet(fieldset=fieldset, pclass=AngleParticle, x=np.zeros(npart), y=np.zeros(npart), z=np.zeros(npart)) def vonmises(particles, fieldset): # pragma: no cover particles.angle = np.array([random.vonmisesvariate(fieldset.mu, fieldset.kappa) for _ in range(len(particles))]) diff --git a/tests/test_fieldset.py b/tests/test_fieldset.py index 8e2f65b6f..799517a06 100644 --- a/tests/test_fieldset.py +++ b/tests/test_fieldset.py @@ -76,14 +76,14 @@ def test_fieldset_no_UV(tmp_parquet): fieldset = FieldSet.from_sgrid_conventions(ds[["U_A_grid", "grid"]].rename({"U_A_grid": "P"}), mesh="flat") def SampleP(particles, fieldset): - particles.dlon += fieldset.P[particles] + particles.dx += fieldset.P[particles] - pset = ParticleSet(fieldset, lon=0, lat=0) + pset = ParticleSet(fieldset, x=0, y=0) ofile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) pset.execute(SampleP, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s"), output_file=ofile) df = pd.read_parquet(tmp_parquet) - assert len(df["lon"]) == 2 + assert len(df["x"]) == 2 @pytest.mark.parametrize("ds", [pytest.param(ds, id=k) for k, ds in datasets_structured.items()]) diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py index b77190153..a97e2cd87 100644 --- a/tests/test_interpolation.py +++ b/tests/test_interpolation.py @@ -254,7 +254,7 @@ def test_interp_regression_v3(interp_name): x, y, z = np.meshgrid(np.linspace(0, 1, 7), np.linspace(0, 1, 13), np.linspace(0, 1, 5)) TestP = Particle.add_variable(Variable("pid", dtype=np.int32, initial=0)) - pset = ParticleSet(fieldset, pclass=TestP, lon=x, lat=y, z=z, pid=np.arange(x.size)) + pset = ParticleSet(fieldset, pclass=TestP, x=x, y=y, z=z, pid=np.arange(x.size)) def DeleteParticle(particle, fieldset, time): if particle.state >= 50: diff --git a/tests/test_kernel.py b/tests/test_kernel.py index e9fc3a80a..7f9b13933 100644 --- a/tests/test_kernel.py +++ b/tests/test_kernel.py @@ -10,7 +10,7 @@ def test_unknown_var_in_kernel(fieldset): - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) def ErrorKernel(particles, fieldset): # pragma: no cover particles.unknown_varname += 0.2 @@ -20,19 +20,19 @@ def ErrorKernel(particles, fieldset): # pragma: no cover def test_context_in_kernel(fieldset): - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) fieldset.add_context("fix_lon", -0.5) def ContextKernel(particles, fieldset): - particles.lon = fieldset.fix_lon + particles.x = fieldset.fix_lon pset.execute(ContextKernel, runtime=np.timedelta64(2, "s"), dt=np.timedelta64(1, "s")) - assert pset.lon == -0.5 + assert pset.x == -0.5 def test_func_context_in_kernel(fieldset): - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) def ContextFunc(x): return 2 * x @@ -40,19 +40,19 @@ def ContextFunc(x): fieldset.add_context("func", ContextFunc) def FuncContextKernel(particles, fieldset): - particles.lon = fieldset.func(particles.lon) + particles.x = fieldset.func(particles.x) pset.execute(FuncContextKernel, runtime=np.timedelta64(2, "s"), dt=np.timedelta64(1, "s")) - assert pset.lon == 2.0 + assert pset.x == 2.0 def test_kernel_init(fieldset): - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) Kernel(kernels=[AdvectionRK4], pset=pset) def test_kernel_merging(fieldset): - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) merged_kernel = Kernel(kernels=[AdvectionRK4, MoveEast, MoveNorth], pset=pset) assert merged_kernel.funcname == "AdvectionRK4MoveEastMoveNorth" assert len(merged_kernel._kernels) == 3 @@ -71,7 +71,7 @@ def test_kernel_from_list(fieldset): Tests that a Kernel can be created from a list functions, or a list of mixed functions and kernel objects. """ - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) kernels_single = Kernel(kernels=[AdvectionRK4], pset=pset) kernels_functions = Kernel(kernels=[AdvectionRK4, MoveEast, MoveNorth], pset=pset) @@ -86,7 +86,7 @@ def test_kernel_from_list_error_checking(fieldset): Tests that various error cases raise appropriate messages. """ - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) with pytest.raises(ValueError, match="List of `kernels` should have at least one function."): Kernel(kernels=[], pset=pset) @@ -101,14 +101,14 @@ def test_kernel_from_list_error_checking(fieldset): def test_RK45Kernel_error_no_next_dt(fieldset): """Tests that kernel throws error if Particle class does not have next_dt for RK45""" - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) with pytest.raises(ValueError, match='ParticleClass requires a "next_dt" for AdvectionRK45 Kernel.'): Kernel(kernels=[AdvectionRK45], pset=pset) def test_kernel_signature(fieldset): - pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + pset = ParticleSet(fieldset, x=[0.5], y=[0.5]) def good_kernel(particles, fieldset): pass diff --git a/tests/test_particlefile.py b/tests/test_particlefile.py index d9feb6217..3100f27a9 100755 --- a/tests/test_particlefile.py +++ b/tests/test_particlefile.py @@ -31,7 +31,7 @@ def test_metadata(fieldset, tmp_parquet): - pset = ParticleSet(fieldset, pclass=Particle, lon=0, lat=0) + pset = ParticleSet(fieldset, pclass=Particle, x=0, y=0) ofile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) pset.execute(DoNothing, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s"), output_file=ofile) @@ -42,7 +42,7 @@ def test_metadata(fieldset, tmp_parquet): @pytest.mark.parametrize("compression", ["zstd", "gzip", "snappy", "brotli", None]) def test_compression(fieldset, tmp_parquet, compression): - pset = ParticleSet(fieldset, pclass=Particle, lon=0, lat=0) + pset = ParticleSet(fieldset, pclass=Particle, x=0, y=0) ofile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s"), compression=compression) pset.execute(DoNothing, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s"), output_file=ofile) @@ -62,7 +62,7 @@ def test_write_fieldset_without_time(tmp_parquet): assert "time" not in ds.dims fieldset = FieldSet.from_sgrid_conventions(ds, mesh="flat") - pset = ParticleSet(fieldset, pclass=Particle, lon=0, lat=0) + pset = ParticleSet(fieldset, pclass=Particle, x=0, y=0) ofile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) pset.execute(DoNothing, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s"), output_file=ofile) @@ -79,8 +79,8 @@ def test_pfile_array_remove_particles(fieldset, tmp_parquet): pset = ParticleSet( fieldset, pclass=Particle, - lon=np.linspace(0, 1, npart), - lat=0.5 * np.ones(npart), + x=np.linspace(0, 1, npart), + y=0.5 * np.ones(npart), time=fieldset.time_interval.left, ) pfile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) @@ -98,8 +98,8 @@ def test_pfile_array_remove_all_particles(fieldset, tmp_parquet): pset = ParticleSet( fieldset, pclass=Particle, - lon=np.linspace(0, 1, npart), - lat=0.5 * np.ones(npart), + x=np.linspace(0, 1, npart), + y=0.5 * np.ones(npart), time=fieldset.time_interval.left, ) pfile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) @@ -132,7 +132,7 @@ def test_write_dtypes_pfile(fieldset, tmp_parquet): extra_vars = [Variable(f"v_{d.__name__}", dtype=d, initial=0.0) for d in dtypes] MyParticle = Particle.add_variable(extra_vars) - pset = ParticleSet(fieldset, pclass=MyParticle, lon=0, lat=0, time=fieldset.time_interval.left) + pset = ParticleSet(fieldset, pclass=MyParticle, x=0, y=0, time=fieldset.time_interval.left) pfile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) pfile.write(pset, time=fieldset.time_interval.left) pfile.close() @@ -156,8 +156,8 @@ def test_pset_repeated_release_delayed_adding_deleting(fieldset, tmp_parquet, dt pset = ParticleSet( fieldset, - lon=np.zeros(npart), - lat=np.zeros(npart), + x=np.zeros(npart), + y=np.zeros(npart), pclass=MyParticle, time=fieldset.time_interval.left + [np.timedelta64(i + 1, "s") for i in range(npart)], ) @@ -183,7 +183,7 @@ def IncrLon(particles, fieldset): # pragma: no cover def test_file_warnings(fieldset, tmp_parquet): - pset = ParticleSet(fieldset, lon=[0, 0], lat=[0, 0], time=[np.timedelta64(0, "s"), np.timedelta64(1, "s")]) + pset = ParticleSet(fieldset, x=[0, 0], y=[0, 0], time=[np.timedelta64(0, "s"), np.timedelta64(1, "s")]) pfile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(2, "s")) with pytest.warns(ParticleSetWarning, match="Some of the particles have a start time difference.*"): pset.execute(AdvectionRK4, runtime=3, dt=1, output_file=pfile) @@ -208,7 +208,7 @@ def test_outputdt_types(outputdt, expectation, tmp_parquet): def test_write_timebackward(fieldset, tmp_parquet): release_time = fieldset.time_interval.left + [np.timedelta64(i + 1, "s") for i in range(3)] - pset = ParticleSet(fieldset, lat=[0, 1, 2], lon=[0, 0, 0], time=release_time) + pset = ParticleSet(fieldset, y=[0, 1, 2], x=[0, 0, 0], time=release_time) pfile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) pset.execute(DoNothing, runtime=np.timedelta64(3, "s"), dt=-np.timedelta64(1, "s"), output_file=pfile) @@ -256,7 +256,7 @@ def SampleP(particles, fieldset): # pragma: no cover if np.any(particles.time > 5 * 3600): _ = fieldset.P[particles] # To trigger sampling of the P field - pset = ParticleSet(fieldset, pclass=XiYiParticle, lon=[0, 0.2], lat=[0.2, 1]) + pset = ParticleSet(fieldset, pclass=XiYiParticle, x=[0, 0.2], y=[0.2, 1]) pfile = ParticleFile(tmp_parquet, outputdt=dt) pset.execute([SampleP, Get_XiYi, AdvectionRK4], endtime=10 * dt, dt=dt, output_file=pfile) @@ -290,7 +290,7 @@ def IncreaseAge(particles, fieldset): # pragma: no cover particles.age += particles.dt time = fieldset.time_interval.left + np.arange(npart) * np.timedelta64(1, "s") - pset = ParticleSet(fieldset, pclass=AgeParticle, lon=npart * [0], lat=npart * [0], time=time) + pset = ParticleSet(fieldset, pclass=AgeParticle, x=npart * [0], y=npart * [0], time=time) ofile = ParticleFile(tmp_parquet, outputdt=outputdt) pset.execute(IncreaseAge, runtime=np.timedelta64(npart * 2, "s"), dt=np.timedelta64(1, "s"), output_file=ofile) @@ -310,29 +310,29 @@ def test_reset_dt(fieldset, tmp_parquet): dt = np.timedelta64(20, "s") def Update_lon(particles, fieldset): # pragma: no cover - particles.dlon += 0.1 + particles.dx += 0.1 particle = get_default_particle(np.float64) - pset = ParticleSet(fieldset, pclass=particle, lon=[0], lat=[0]) + pset = ParticleSet(fieldset, pclass=particle, x=[0], y=[0]) ofile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(50, "s")) pset.execute(Update_lon, runtime=5 * dt, dt=dt, output_file=ofile) - assert np.allclose(pset.lon, 0.6) + assert np.allclose(pset.x, 0.6) def test_correct_misaligned_outputdt_dt(fieldset, tmp_parquet): """Testing that outputdt does not need to be a multiple of dt.""" def Update_lon(particles, fieldset): # pragma: no cover - particles.lon += particles.dt + particles.x += particles.dt particle = get_default_particle(np.float64) - pset = ParticleSet(fieldset, pclass=particle, lon=[0], lat=[0]) + pset = ParticleSet(fieldset, pclass=particle, x=[0], y=[0]) ofile = ParticleFile(tmp_parquet, outputdt=np.timedelta64(3, "s")) pset.execute(Update_lon, runtime=np.timedelta64(11, "s"), dt=np.timedelta64(2, "s"), output_file=ofile) df = pd.read_parquet(tmp_parquet) - assert np.allclose(df["lon"].values, [0, 3, 6, 9]) + assert np.allclose(df["x"].values, [0, 3, 6, 9]) assert np.allclose(df.time - df.time.min(), [0, 3, 6, 9]) @@ -342,8 +342,8 @@ def setup_pset_execute(*, fieldset: FieldSet, outputdt: timedelta, execute_kwarg pset = ParticleSet( fieldset, pclass=particle_class, - lon=np.full(npart, fieldset.U.data.lon.mean()), - lat=np.full(npart, fieldset.U.data.lat.mean()), + x=np.full(npart, fieldset.U.data.lon.mean()), + y=np.full(npart, fieldset.U.data.lat.mean()), ) with tempfile.TemporaryDirectory() as dir: @@ -413,7 +413,7 @@ def test_particlefile_init(tmp_parquet): def test_particlefile_init_existing_path_modes(fieldset, tmp_parquet): - pset = ParticleSet(fieldset, pclass=Particle, lon=0, lat=0) + pset = ParticleSet(fieldset, pclass=Particle, x=0, y=0) first_file = ParticleFile(tmp_parquet, outputdt=np.timedelta64(1, "s")) pset.execute(DoNothing, runtime=np.timedelta64(10, "s"), dt=np.timedelta64(1, "s"), output_file=first_file) @@ -472,13 +472,13 @@ def test_pfile_write_custom_particle(): ) def test_pfile_set_towrite_False(fieldset, tmp_parquet): npart = 10 - pset = ParticleSet(fieldset, pclass=Particle, lon=np.linspace(0, 1, npart), lat=0.5 * np.ones(npart)) + pset = ParticleSet(fieldset, pclass=Particle, x=np.linspace(0, 1, npart), y=0.5 * np.ones(npart)) pset.set_variable_write_status("z", False) pset.set_variable_write_status("lat", False) pfile = pset.ParticleFile(tmp_parquet, outputdt=1) def Update_lon(particles, fieldset): # pragma: no cover - particles.dlon += 0.1 + particles.dx += 0.1 pset.execute(Update_lon, runtime=10, output_file=pfile) diff --git a/tests/test_particleset.py b/tests/test_particleset.py index f288f9654..879677bf8 100644 --- a/tests/test_particleset.py +++ b/tests/test_particleset.py @@ -20,9 +20,9 @@ def test_pset_create_lon_lat(fieldset): npart = 100 lon = np.linspace(0, 1, npart, dtype=np.float32) lat = np.linspace(1, 0, npart, dtype=np.float32) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle) - assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) - assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) + pset = ParticleSet(fieldset, x=lon, y=lat, pclass=Particle) + assert np.allclose([p.x for p in pset], lon, rtol=1e-12) + assert np.allclose([p.y for p in pset], lat, rtol=1e-12) def test_create_empty_pset(fieldset): @@ -38,7 +38,7 @@ def test_pset_with_pids(fieldset, offset, npart=100): lon = np.linspace(0, 1, npart) lat = np.linspace(1, 0, npart) trajectory_ids = np.arange(offset, npart + offset) - pset = ParticleSet(fieldset, lon=lon, lat=lat, particle_ids=trajectory_ids) + pset = ParticleSet(fieldset, x=lon, y=lat, particle_ids=trajectory_ids) assert np.allclose([p.particle_id for p in pset], trajectory_ids, atol=1e-12) @@ -46,10 +46,10 @@ def test_pset_with_pids(fieldset, offset, npart=100): def test_pset_customvars_on_pset(fieldset, aslist): if aslist: MyParticle = Particle.add_variable([Variable("sample_var"), Variable("sample_var2")]) - pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle, sample_var=5.0, sample_var2=10.0) + pset = ParticleSet(fieldset, x=0, y=0, pclass=MyParticle, sample_var=5.0, sample_var2=10.0) else: MyParticle = Particle.add_variable(Variable("sample_var")) - pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle, sample_var=5.0) + pset = ParticleSet(fieldset, x=0, y=0, pclass=MyParticle, sample_var=5.0) pset.execute(DoNothing, dt=np.timedelta64(1, "s"), runtime=np.timedelta64(21, "s")) assert np.allclose([p.sample_var for p in pset], 5.0) @@ -58,9 +58,9 @@ def test_pset_customvars_on_pset(fieldset, aslist): def test_pset_custominit_on_pset_attrgetter(fieldset): - MyParticle = Particle.add_variable(Variable("sample_var", initial=attrgetter("lon"))) + MyParticle = Particle.add_variable(Variable("sample_var", initial=attrgetter("x"))) - pset = ParticleSet(fieldset, lon=3, lat=0, pclass=MyParticle) + pset = ParticleSet(fieldset, x=3, y=0, pclass=MyParticle) pset.execute(DoNothing, dt=np.timedelta64(1, "s"), runtime=np.timedelta64(21, "s")) assert np.allclose([p.sample_var for p in pset], 3.0) @@ -71,9 +71,9 @@ def test_pset_custominit_on_pclass(fieldset, pset_override): MyParticle = Particle.add_variable(Variable("sample_var", initial=4)) if pset_override: - pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle, sample_var=5) + pset = ParticleSet(fieldset, x=0, y=0, pclass=MyParticle, sample_var=5) else: - pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle) + pset = ParticleSet(fieldset, x=0, y=0, pclass=MyParticle) pset.execute(DoNothing, dt=np.timedelta64(1, "s"), runtime=np.timedelta64(21, "s")) @@ -93,30 +93,30 @@ def test_pset_custominit_on_pclass(fieldset, pset_override): ) def test_particleset_init_time_type(fieldset, time, expectation): with expectation: - ParticleSet(fieldset, lon=[0.2], lat=[5.0], time=[time], pclass=Particle) + ParticleSet(fieldset, x=[0.2], y=[5.0], time=[time], pclass=Particle) def test_pset_create_outside_time(fieldset): time = xr.date_range("1999", "2001", 20) with pytest.warns(ParticleSetWarning, match="Some particles are set to be released*"): - ParticleSet(fieldset, pclass=Particle, lon=[0] * len(time), lat=[0] * len(time), time=time) + ParticleSet(fieldset, pclass=Particle, x=[0] * len(time), y=[0] * len(time), time=time) def test_pset_starttime_not_multiple_dt(fieldset): times = [0, 1, 2] datetimes = [fieldset.time_interval.left + np.timedelta64(t, "s") for t in times] - pset = ParticleSet(fieldset, lon=[0] * len(times), lat=[0] * len(times), pclass=Particle, time=datetimes) + pset = ParticleSet(fieldset, x=[0] * len(times), y=[0] * len(times), pclass=Particle, time=datetimes) def Addlon(particles, fieldset): # pragma: no cover - particles.dlon += particles.dt + particles.dx += particles.dt pset.execute(Addlon, dt=np.timedelta64(2, "s"), runtime=np.timedelta64(8, "s"), verbose_progress=False) - assert np.allclose([p.lon + p.dlon for p in pset], [8 - t for t in times]) + assert np.allclose([p.x + p.dx for p in pset], [8 - t for t in times]) def test_populate_indices(fieldset): npart = 11 - pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + pset = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.linspace(1, 0, npart)) pset.populate_indices() np.testing.assert_equal(round_and_hash_float_array(pset.ei, decimals=0), 935996932384571063274191) @@ -125,33 +125,33 @@ def test_pset_add_explicit(fieldset): npart = 11 lon = np.linspace(0, 1, npart) lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset, lon=lon[0], lat=lat[0], pclass=Particle) + pset = ParticleSet(fieldset, x=lon[0], y=lat[0], pclass=Particle) for i in range(1, npart): - particle = ParticleSet(pclass=Particle, lon=lon[i], lat=lat[i], fieldset=fieldset) + particle = ParticleSet(pclass=Particle, x=lon[i], y=lat[i], fieldset=fieldset) pset.add(particle) assert len(pset) == npart - assert np.allclose([p.lon for p in pset], lon, atol=1e-12) - assert np.allclose([p.lat for p in pset], lat, atol=1e-12) + assert np.allclose([p.x for p in pset], lon, atol=1e-12) + assert np.allclose([p.y for p in pset], lat, atol=1e-12) assert np.allclose(np.diff(pset._data["particle_id"]), np.ones(pset._data["particle_id"].size - 1), atol=1e-12) def test_pset_add_implicit(fieldset): - pset = ParticleSet(fieldset, lon=np.zeros(3), lat=np.ones(3), pclass=Particle) - pset += ParticleSet(fieldset, lon=np.ones(4), lat=np.zeros(4), pclass=Particle) + pset = ParticleSet(fieldset, x=np.zeros(3), y=np.ones(3), pclass=Particle) + pset += ParticleSet(fieldset, x=np.ones(4), y=np.zeros(4), pclass=Particle) assert len(pset) == 7 assert np.allclose(np.diff(pset._data["particle_id"]), np.ones(6), atol=1e-12) def test_pset_add_implicit_in_loop(fieldset, npart=10): - pset = ParticleSet(fieldset, lon=[], lat=[]) + pset = ParticleSet(fieldset, x=[], y=[]) for _ in range(npart): - pset += ParticleSet(pclass=Particle, lon=0.1, lat=0.1, fieldset=fieldset) + pset += ParticleSet(pclass=Particle, x=0.1, y=0.1, fieldset=fieldset) assert pset.size == npart def test_pset_merge_inplace(fieldset, npart=100): - pset1 = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) - pset2 = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(0, 1, npart)) + pset1 = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.linspace(1, 0, npart)) + pset2 = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.linspace(0, 1, npart)) assert pset1.size == npart assert pset2.size == npart pset1.add(pset2) @@ -161,7 +161,7 @@ def test_pset_merge_inplace(fieldset, npart=100): def test_pset_remove_index(fieldset, npart=100): lon = np.linspace(0, 1, npart) lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset, lon=lon, lat=lat) + pset = ParticleSet(fieldset, x=lon, y=lat) indices_to_remove = [0, 10, 20] pset.remove_indices(indices_to_remove) assert pset.size == 97 @@ -170,7 +170,7 @@ def test_pset_remove_index(fieldset, npart=100): def test_pset_iterator(fieldset): npart = 10 - pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.ones(npart)) + pset = ParticleSet(fieldset, x=np.zeros(npart), y=np.ones(npart)) for i, particle in enumerate(pset): assert particle.particle_id == i assert i == npart - 1 diff --git a/tests/test_particleset_execute.py b/tests/test_particleset_execute.py index b4183cce7..3b2d0735f 100644 --- a/tests/test_particleset_execute.py +++ b/tests/test_particleset_execute.py @@ -54,13 +54,13 @@ def test_pset_execute_invalid_arguments(fieldset, fieldset_no_time_interval): ValueError, match="dt must be a non-zero datetime.timedelta or np.timedelta64 object, got .*", ): - ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute(AdvectionRK4, dt=dt) + ParticleSet(fieldset, x=[0.2], y=[5.0], pclass=Particle).execute(AdvectionRK4, dt=dt) with pytest.raises( ValueError, match="runtime and endtime are mutually exclusive - provide one or the other. Got .*", ): - ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute( + ParticleSet(fieldset, x=[0.2], y=[5.0], pclass=Particle).execute( AdvectionRK4, runtime=np.timedelta64(1, "s"), endtime=np.datetime64("2100-01-01"), dt=np.timedelta64(1, "s") ) @@ -69,7 +69,7 @@ def test_pset_execute_invalid_arguments(fieldset, fieldset_no_time_interval): ValueError, match=msg, ): - ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute( + ParticleSet(fieldset, x=[0.2], y=[5.0], pclass=Particle).execute( AdvectionRK4, endtime=np.datetime64("1990-01-01"), dt=np.timedelta64(1, "s") ) @@ -77,7 +77,7 @@ def test_pset_execute_invalid_arguments(fieldset, fieldset_no_time_interval): ValueError, match=msg, ): - ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute( + ParticleSet(fieldset, x=[0.2], y=[5.0], pclass=Particle).execute( AdvectionRK4, endtime=np.datetime64("2100-01-01"), dt=np.timedelta64(-1, "s") ) @@ -85,7 +85,7 @@ def test_pset_execute_invalid_arguments(fieldset, fieldset_no_time_interval): ValueError, match="The endtime must be of the same type as the fieldset.time_interval start time. Got .*", ): - ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute( + ParticleSet(fieldset, x=[0.2], y=[5.0], pclass=Particle).execute( AdvectionRK4, endtime=12345, dt=np.timedelta64(1, "s") ) @@ -93,7 +93,7 @@ def test_pset_execute_invalid_arguments(fieldset, fieldset_no_time_interval): ValueError, match="The runtime must be provided when the time_interval is not defined for a fieldset.", ): - ParticleSet(fieldset_no_time_interval, lon=[0.2], lat=[5.0], pclass=Particle).execute( + ParticleSet(fieldset_no_time_interval, x=[0.2], y=[5.0], pclass=Particle).execute( AdvectionRK4, dt=np.timedelta64(1, "s") ) @@ -109,7 +109,7 @@ def test_pset_execute_invalid_arguments(fieldset, fieldset_no_time_interval): ], ) def test_particleset_runtime_type(fieldset, runtime, expectation): - pset = ParticleSet(fieldset, lon=[0.2], lat=[5.0], z=[50.0], pclass=Particle) + pset = ParticleSet(fieldset, x=[0.2], y=[5.0], z=[50.0], pclass=Particle) with expectation: pset.execute(runtime=runtime, dt=np.timedelta64(10, "s"), kernels=DoNothing) @@ -125,7 +125,7 @@ def test_particleset_runtime_type(fieldset, runtime, expectation): ], ) def test_particleset_endtime_type(fieldset, endtime, expectation): - pset = ParticleSet(fieldset, lon=[0.2], lat=[5.0], z=[50.0], pclass=Particle) + pset = ParticleSet(fieldset, x=[0.2], y=[5.0], z=[50.0], pclass=Particle) with expectation: pset.execute(endtime=endtime, dt=np.timedelta64(10, "m"), kernels=DoNothing) @@ -137,7 +137,7 @@ def test_particleset_run_to_endtime(fieldset): def SampleU(particles, fieldset): # pragma: no cover _ = fieldset.U[particles] - pset = ParticleSet(fieldset, lon=[0.2], lat=[5.0], time=[starttime]) + pset = ParticleSet(fieldset, x=[0.2], y=[5.0], time=[starttime]) pset.execute(SampleU, endtime=endtime, dt=np.timedelta64(1, "D")) assert np.timedelta64(int(pset[0].time), "s") + fieldset.time_interval.left == endtime @@ -153,7 +153,7 @@ def test_particleset_run_RK_to_endtime_fwd_bwd(fieldset, kernel, dt): fieldset.U.data[:] = 0.0 fieldset.V.data[:] = 0.0 - pset = ParticleSet(fieldset, pclass=DEFAULT_PARTICLES[kernel], lon=[0.2], lat=[5.0], time=[starttime]) + pset = ParticleSet(fieldset, pclass=DEFAULT_PARTICLES[kernel], x=[0.2], y=[5.0], time=[starttime]) pset.execute(kernel, endtime=endtime, dt=dt) assert pset[0].time == fieldset.time_interval.time_length_as_flt @@ -172,7 +172,7 @@ def SampleU(particles, fieldset): # pragma: no cover particles.var = fieldset.U[particles] print(fieldset.U.grid.lon) - pset = ParticleSet(fieldset, pclass=MyParticle, lon=fieldset.U.grid.lon[-1], lat=fieldset.U.grid.lat[-1]) + pset = ParticleSet(fieldset, pclass=MyParticle, x=fieldset.U.grid.lon[-1], y=fieldset.U.grid.lat[-1]) pset.execute(SampleU, runtime=np.timedelta64(1, "D"), dt=np.timedelta64(1, "D")) np.testing.assert_equal(pset[0].var, 1) @@ -181,10 +181,10 @@ def test_particleset_interpolate_outside_domainedge(zonal_flow_fieldset): fieldset = zonal_flow_fieldset def SampleU(particles, fieldset): # pragma: no cover - particles.dlon = fieldset.U[particles] + particles.dx = fieldset.U[particles] dlat = 1e-3 - pset = ParticleSet(fieldset, lon=fieldset.U.grid.lon[-1], lat=fieldset.U.grid.lat[-1] + dlat) + pset = ParticleSet(fieldset, x=fieldset.U.grid.lon[-1], y=fieldset.U.grid.lat[-1] + dlat) with pytest.raises(FieldOutOfBoundError): pset.execute(SampleU, runtime=np.timedelta64(2, "D"), dt=np.timedelta64(1, "D")) @@ -198,17 +198,17 @@ def AddDt(particles, fieldset): # pragma: no cover particles.added_dt += particles.dt pclass = Particle.add_variable(Variable("added_dt", dtype=np.float32, initial=0)) - pset = ParticleSet(fieldset, pclass=pclass, lon=0, lat=0) + pset = ParticleSet(fieldset, pclass=pclass, x=0, y=0) pset.execute(AddDt, runtime=dt * 10, dt=dt) np.testing.assert_allclose(pset[0].added_dt, 10.0 * timedelta_to_float(dt), atol=1e-5) def test_pset_remove_particle_in_kernel(fieldset): npart = 100 - pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + pset = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.linspace(1, 0, npart)) def DeleteKernel(particles, fieldset): # pragma: no cover - particles.state = np.where((particles.lon >= 0.4) & (particles.lon <= 0.6), StatusCode.Delete, particles.state) + particles.state = np.where((particles.x >= 0.4) & (particles.x <= 0.6), StatusCode.Delete, particles.state) pset.execute(DeleteKernel, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s")) indices = [i for i in range(npart) if not (40 <= i < 60)] @@ -220,7 +220,7 @@ def DeleteKernel(particles, fieldset): # pragma: no cover @pytest.mark.parametrize("npart", [1, 100]) def test_pset_stop_simulation(fieldset, npart): - pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.zeros(npart), pclass=Particle) + pset = ParticleSet(fieldset, x=np.zeros(npart), y=np.zeros(npart), pclass=Particle) def Delete(particles, fieldset): # pragma: no cover particles[particles.time >= 4].state = StatusCode.StopExecution @@ -231,19 +231,19 @@ def Delete(particles, fieldset): # pragma: no cover @pytest.mark.parametrize("with_delete", [True, False]) def test_pset_multi_execute(fieldset, with_delete, npart=10, n=5): - pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) + pset = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.zeros(npart)) def AddLat(particles, fieldset): # pragma: no cover - particles.dlat += 0.1 + particles.dy += 0.1 for _ in range(n): pset.execute(AddLat, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s")) if with_delete: pset.remove_indices(len(pset) - 1) if with_delete: - assert np.allclose(pset.lat, n * 0.1, atol=1e-12) + assert np.allclose(pset.y, n * 0.1, atol=1e-12) else: - assert np.allclose([p.lat - n * 0.1 for p in pset], np.zeros(npart), rtol=1e-12) + assert np.allclose([p.y - n * 0.1 for p in pset], np.zeros(npart), rtol=1e-12) @pytest.mark.parametrize( @@ -254,7 +254,7 @@ def test_execution_endtime(fieldset, starttime, endtime, dt): starttime = fieldset.time_interval.left + np.timedelta64(starttime, "s") endtime = fieldset.time_interval.left + np.timedelta64(endtime, "s") dt = np.timedelta64(dt, "s") - pset = ParticleSet(fieldset, time=starttime, lon=0, lat=0) + pset = ParticleSet(fieldset, time=starttime, x=0, y=0) pset.execute(DoNothing, endtime=endtime, dt=dt) assert pset.time == timedelta_to_float(endtime - fieldset.time_interval.left) @@ -265,12 +265,12 @@ def test_dont_run_particles_outside_starttime(fieldset): endtime = fieldset.time_interval.left + np.timedelta64(8, "s") def AddLon(particles, fieldset): # pragma: no cover - particles.lon += 1 + particles.x += 1 - pset = ParticleSet(fieldset, lon=np.zeros(len(start_times)), lat=np.zeros(len(start_times)), time=start_times) + pset = ParticleSet(fieldset, x=np.zeros(len(start_times)), y=np.zeros(len(start_times)), time=start_times) pset.execute(AddLon, dt=np.timedelta64(1, "s"), endtime=endtime) - np.testing.assert_array_equal(pset.lon, [8, 6, 0]) + np.testing.assert_array_equal(pset.x, [8, 6, 0]) assert pset.time[0:1] == timedelta_to_float(endtime - fieldset.time_interval.left) assert pset.time[2] == timedelta_to_float( start_times[2] - fieldset.time_interval.left @@ -280,10 +280,10 @@ def AddLon(particles, fieldset): # pragma: no cover start_times = [fieldset.time_interval.right - np.timedelta64(t, "s") for t in [0, 2, 10]] endtime = fieldset.time_interval.right - np.timedelta64(8, "s") - pset = ParticleSet(fieldset, lon=np.zeros(len(start_times)), lat=np.zeros(len(start_times)), time=start_times) + pset = ParticleSet(fieldset, x=np.zeros(len(start_times)), y=np.zeros(len(start_times)), time=start_times) pset.execute(AddLon, dt=-np.timedelta64(1, "s"), endtime=endtime) - np.testing.assert_array_equal(pset.lon, [8, 6, 0]) + np.testing.assert_array_equal(pset.x, [8, 6, 0]) assert pset.time[0:1] == timedelta_to_float(endtime - fieldset.time_interval.left) assert pset.time[2] == timedelta_to_float( start_times[2] - fieldset.time_interval.left @@ -293,7 +293,7 @@ def AddLon(particles, fieldset): # pragma: no cover def test_some_particles_throw_outofbounds(zonal_flow_fieldset): npart = 100 lon = np.linspace(0, 9e5, npart) - pset = ParticleSet(zonal_flow_fieldset, lon=lon, lat=np.zeros_like(lon)) + pset = ParticleSet(zonal_flow_fieldset, x=lon, y=np.zeros_like(lon)) with pytest.raises(FieldOutOfBoundError): pset.execute(AdvectionEE, runtime=np.timedelta64(1_000_000, "s"), dt=np.timedelta64(10_000, "s")) @@ -301,23 +301,23 @@ def test_some_particles_throw_outofbounds(zonal_flow_fieldset): def test_delete_on_all_errors(fieldset): def MoveRight(particles, fieldset): # pragma: no cover - particles.dlon += 1 - fieldset.U[particles.time, particles.z, particles.lat, particles.lon, particles] + particles.dx += 1 + fieldset.U[particles.time, particles.z, particles.y, particles.x, particles] def DeleteAllErrorParticles(particles, fieldset): # pragma: no cover particles[particles.state > 20].state = StatusCode.Delete - pset = ParticleSet(fieldset, lon=[1e5, 2], lat=[0, 0]) + pset = ParticleSet(fieldset, x=[1e5, 2], y=[0, 0]) pset.execute([MoveRight, DeleteAllErrorParticles], runtime=np.timedelta64(10, "s"), dt=np.timedelta64(1, "s")) assert len(pset) == 0 def test_some_particles_throw_outoftime(fieldset): time = [fieldset.time_interval.left + np.timedelta64(t, "D") for t in [0, 350]] - pset = ParticleSet(fieldset, lon=np.zeros_like(time), lat=np.zeros_like(time), time=time) + pset = ParticleSet(fieldset, x=np.zeros_like(time), y=np.zeros_like(time), time=time) def FieldAccessOutsideTime(particles, fieldset): # pragma: no cover - fieldset.U[particles.time + 400 * 86400, particles.z, particles.lat, particles.lon, particles] + fieldset.U[particles.time + 400 * 86400, particles.z, particles.y, particles.x, particles] with pytest.raises(OutsideTimeInterval): pset.execute(FieldAccessOutsideTime, runtime=np.timedelta64(1, "D"), dt=np.timedelta64(10, "D")) @@ -332,25 +332,25 @@ def test_raise_general_error(): ... def test_errorinterpolation(fieldset): class NaNInterpolator(ScalarInterpolator): # pragma: no cover def interp(self, particle_positions, grid_positions, field): - return np.nan * np.zeros_like(particle_positions["lon"]) + return np.nan * np.zeros_like(particle_positions["x"]) def SampleU(particles, fieldset): # pragma: no cover - fieldset.U[particles.time, particles.z, particles.lat, particles.lon, particles] + fieldset.U[particles.time, particles.z, particles.y, particles.x, particles] fieldset.U.interp_method = NaNInterpolator() - pset = ParticleSet(fieldset, lon=[0, 2], lat=[0, 0]) + pset = ParticleSet(fieldset, x=[0, 2], y=[0, 0]) with pytest.raises(FieldInterpolationError): pset.execute(SampleU, runtime=np.timedelta64(2, "s"), dt=np.timedelta64(1, "s")) def test_execution_check_stopallexecution(fieldset): def addoneLon(particles, fieldset): # pragma: no cover - particles.dlon += 1 - particles[particles.lon + particles.dlon >= 10].state = StatusCode.StopAllExecution + particles.dx += 1 + particles[particles.x + particles.dx >= 10].state = StatusCode.StopAllExecution - pset = ParticleSet(fieldset, lon=[0, 0], lat=[0, 0]) + pset = ParticleSet(fieldset, x=[0, 0], y=[0, 0]) pset.execute(addoneLon, runtime=np.timedelta64(20, "s"), dt=np.timedelta64(1, "s")) - np.testing.assert_allclose(pset.lon, 9) + np.testing.assert_allclose(pset.x, 9) np.testing.assert_allclose(pset.time, 9) @@ -358,21 +358,21 @@ def test_execution_recover_out_of_bounds(fieldset): npart = 2 def MoveRight(particles, fieldset): # pragma: no cover - fieldset.U[particles.time, particles.z, particles.lat, particles.lon + 0.1, particles] - particles.dlon += 0.1 + fieldset.U[particles.time, particles.z, particles.y, particles.x + 0.1, particles] + particles.dx += 0.1 def MoveLeft(particles, fieldset): # pragma: no cover inds = np.where(particles.state == StatusCode.ErrorOutOfBounds) - particles[inds].dlon -= 1.0 + particles[inds].dx -= 1.0 particles[inds].state = StatusCode.Success lon = np.linspace(0.05, 6.95, npart) lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset, lon=lon, lat=lat) + pset = ParticleSet(fieldset, x=lon, y=lat) pset.execute([MoveRight, MoveLeft], runtime=np.timedelta64(60, "s"), dt=np.timedelta64(1, "s")) assert len(pset) == npart - np.testing.assert_allclose(pset.lon, [6.05, 5.95], rtol=1e-5) - np.testing.assert_allclose(pset.lat, lat, rtol=1e-5) + np.testing.assert_allclose(pset.x, [6.05, 5.95], rtol=1e-5) + np.testing.assert_allclose(pset.y, lat, rtol=1e-5) @pytest.mark.parametrize( @@ -385,25 +385,25 @@ def test_execution_runtime(fieldset, starttime_flt, runtime_flt, dt, npart): runtime = np.timedelta64(runtime_flt, "s") sign_dt = np.sign(dt) dt = np.timedelta64(dt, "s") - pset = ParticleSet(fieldset, time=starttime, lon=np.zeros(npart), lat=np.zeros(npart)) + pset = ParticleSet(fieldset, time=starttime, x=np.zeros(npart), y=np.zeros(npart)) pset.execute(DoNothing, runtime=runtime, dt=dt) assert all([abs(p.time - starttime_flt - runtime_flt * sign_dt) < 1e-3 for p in pset]) def test_changing_dt_in_kernel(fieldset): def KernelCounter(particles, fieldset): # pragma: no cover - particles.lon += 1 + particles.x += 1 - pset = ParticleSet(fieldset, lon=np.zeros(1), lat=np.zeros(1)) + pset = ParticleSet(fieldset, x=np.zeros(1), y=np.zeros(1)) pset.execute(KernelCounter, dt=np.timedelta64(2, "s"), runtime=np.timedelta64(5, "s")) - assert pset.lon == 3 + assert pset.x == 3 assert pset.dt == 2 assert pset.time == 5 @pytest.mark.parametrize("npart", [1, 100]) def test_execution_fail_python_exception(fieldset, npart): - pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + pset = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.linspace(1, 0, npart)) def PythonFail(particles, fieldset): # pragma: no cover inds = np.argwhere(particles.time >= 10) @@ -428,29 +428,29 @@ def PythonFail(particles, fieldset): # pragma: no cover def test_execution_update_particle_in_kernel_function(fieldset, kernel_names, expected): npart = 2 - pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) + pset = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.zeros(npart)) def Lat1(particles, fieldset): # pragma: no cover def SetLat1(p): - p.lat = 1 + p.y = 1 - SetLat1(particles[(particles.lat == 0) & (particles.lon > 0.5)]) + SetLat1(particles[(particles.y == 0) & (particles.x > 0.5)]) def Lat2(particles, fieldset): # pragma: no cover def SetLat2(p): - p.lat = 2 + p.y = 2 - SetLat2(particles[(particles.lat == 0) & (particles.lon < 0.5)]) + SetLat2(particles[(particles.y == 0) & (particles.x < 0.5)]) def Lat1and2(particles, fieldset): # pragma: no cover def SetLat1(p): - p.lat = 1 + p.y = 1 def SetLat2(p): - p.lat = 2 + p.y = 2 - SetLat1(particles[(particles.lat == 0) & (particles.lon > 0.5)]) - SetLat2(particles[(particles.lat == 0) & (particles.lon < 0.5)]) + SetLat1(particles[(particles.y == 0) & (particles.x > 0.5)]) + SetLat2(particles[(particles.y == 0) & (particles.x < 0.5)]) if kernel_names == "Lat1": kernels = [Lat1] @@ -462,7 +462,7 @@ def SetLat2(p): kernels = [Lat1, Lat2] pset.execute(kernels, runtime=np.timedelta64(2, "s"), dt=np.timedelta64(1, "s")) - np.testing.assert_allclose(pset.lat, expected, rtol=1e-5) + np.testing.assert_allclose(pset.y, expected, rtol=1e-5) def test_uxstommelgyre_pset_execute(): @@ -470,8 +470,8 @@ def test_uxstommelgyre_pset_execute(): fieldset = FieldSet.from_ugrid_conventions(ds, mesh="spherical") pset = ParticleSet( fieldset, - lon=[30.0], - lat=[5.0], + x=[30.0], + y=[5.0], z=[50.0], time=[np.timedelta64(0, "s")], pclass=Particle, @@ -481,8 +481,8 @@ def test_uxstommelgyre_pset_execute(): runtime=np.timedelta64(10, "m"), dt=np.timedelta64(60, "s"), ) - np.testing.assert_allclose(pset[0].lon, 29.997387, atol=1e-3) - np.testing.assert_allclose(pset[0].lat, 4.998546, atol=1e-3) + np.testing.assert_allclose(pset[0].x, 29.997387, atol=1e-3) + np.testing.assert_allclose(pset[0].y, 4.998546, atol=1e-3) def test_uxstommelgyre_multiparticle_pset_execute(): @@ -490,8 +490,8 @@ def test_uxstommelgyre_multiparticle_pset_execute(): fieldset = FieldSet.from_ugrid_conventions(ds, mesh="spherical") pset = ParticleSet( fieldset, - lon=[30.0, 32.0], - lat=[5.0, 5.0], + x=[30.0, 32.0], + y=[5.0, 5.0], z=[50.0, 50.0], time=[np.timedelta64(0, "s")], pclass=Particle, @@ -509,8 +509,8 @@ def test_uxstommelgyre_pset_execute_output(): fieldset = FieldSet.from_ugrid_conventions(ds, mesh="spherical") pset = ParticleSet( fieldset, - lon=[30.0], - lat=[5.0], + x=[30.0], + y=[5.0], z=[50.0], time=[0.0], pclass=Particle, @@ -540,7 +540,7 @@ def test_uxgrid_particle_leaving_domain_raises(): # outflow boundary (domain spans lon, lat in [0, 20]). The particle crosses # lon=20 after 100 s of travel. lon_max = float(ds.uxgrid.node_lon.max()) - pset = ParticleSet(fieldset, lon=[lon_max - 0.1], lat=[10.0], z=[0.5], pclass=Particle) + pset = ParticleSet(fieldset, x=[lon_max - 0.1], y=[10.0], z=[0.5], pclass=Particle) with pytest.raises(GridSearchingError): pset.execute(AdvectionEE, runtime=np.timedelta64(120, "s"), dt=np.timedelta64(10, "s")) diff --git a/tests/test_particlesetview.py b/tests/test_particlesetview.py index e7ad7ef2a..a77ea37df 100644 --- a/tests/test_particlesetview.py +++ b/tests/test_particlesetview.py @@ -8,12 +8,12 @@ def test_execution_changing_particle_mask(fieldset): """Test that particle masks can change during kernel execution.""" npart = 10 initial_lons = np.linspace(0, 1, npart) - pset = ParticleSet(fieldset, lon=initial_lons.copy(), lat=np.zeros(npart)) + pset = ParticleSet(fieldset, x=initial_lons.copy(), y=np.zeros(npart)) def IncrementLowLon(particles, fieldset): # pragma: no cover # Increment lon for particles with lon < 0.5 # The mask changes as particles cross the threshold - particles[particles.lon < 0.5].dlon += 0.1 + particles[particles.x < 0.5].dx += 0.1 pset.execute(IncrementLowLon, runtime=np.timedelta64(5, "s"), dt=np.timedelta64(1, "s")) @@ -23,50 +23,50 @@ def IncrementLowLon(particles, fieldset): # pragma: no cover particles_started_high = initial_lons >= 0.5 # Low particles should have increased lon - assert np.all(pset.lon[particles_started_low] > initial_lons[particles_started_low]) + assert np.all(pset.x[particles_started_low] > initial_lons[particles_started_low]) # High particles should not have moved - assert np.allclose(pset.lon[particles_started_high], initial_lons[particles_started_high], atol=1e-6) + assert np.allclose(pset.x[particles_started_high], initial_lons[particles_started_high], atol=1e-6) def test_particle_mask_conditional_state_changes(fieldset): """Test setting particle state based on a condition using particle masks.""" npart = 10 initial_lons = np.linspace(0, 1, npart) - pset = ParticleSet(fieldset, lon=initial_lons.copy(), lat=np.zeros(npart)) + pset = ParticleSet(fieldset, x=initial_lons.copy(), y=np.zeros(npart)) def StopFastParticles(particles, fieldset): # pragma: no cover # Stop particles that have moved beyond lon=0.5 - particles[particles.lon > 0.5].state = StatusCode.StopExecution + particles[particles.x > 0.5].state = StatusCode.StopExecution def AdvanceLon(particles, fieldset): # pragma: no cover - particles.dlon += 0.2 + particles.dx += 0.2 pset.execute([AdvanceLon, StopFastParticles], runtime=np.timedelta64(5, "s"), dt=np.timedelta64(1, "s")) # All particles should have stopped when they crossed lon > 0.5 # Verify all final positions are > 0.5 (since they stop after crossing) - assert np.all(pset.lon > 0.5) + assert np.all(pset.x > 0.5) # Particles that started closer to 0.5 should have stopped sooner (lower final lon) # while particles that started farther should have moved more before stopping - assert pset.lon[0] < pset.lon[-1] # First particle stopped earliest, last stopped latest + assert pset.x[0] < pset.x[-1] # First particle stopped earliest, last stopped latest def test_particle_mask_conditional_updates(fieldset): """Test applying different updates to different particle subsets using masks.""" npart = 20 MyParticle = Particle.add_variable(Variable("temp", initial=10.0)) - pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.zeros(npart), pclass=MyParticle) + pset = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.zeros(npart), pclass=MyParticle) def ConditionalHeating(particles, fieldset): # pragma: no cover # Warm particles on the left, cool particles on the right - particles[particles.lon < 0.5].temp += 1.0 - particles[particles.lon >= 0.5].temp -= 0.5 + particles[particles.x < 0.5].temp += 1.0 + particles[particles.x >= 0.5].temp -= 0.5 pset.execute(ConditionalHeating, runtime=np.timedelta64(4, "s"), dt=np.timedelta64(1, "s")) # After 4 timesteps: left particles should be at 14.0, right at 8.0 - left_particles = pset.lon < 0.5 - right_particles = pset.lon >= 0.5 + left_particles = pset.x < 0.5 + right_particles = pset.x >= 0.5 assert np.allclose(pset.temp[left_particles], 14.0, atol=1e-6) assert np.allclose(pset.temp[right_particles], 8.0, atol=1e-6) @@ -75,13 +75,13 @@ def test_particle_mask_progressive_changes(fieldset): """Test masks that change dynamically as particle properties change during execution.""" npart = 10 # Start all particles at lon=0, they will progressively move right - pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.linspace(0, 1, npart)) + pset = ParticleSet(fieldset, x=np.zeros(npart), y=np.linspace(0, 1, npart)) def MoveAndStopAtBoundary(particles, fieldset): # pragma: no cover # Move all particles right - particles.dlon += 0.15 + particles.dx += 0.15 # Stop particles that cross lon=0.5 - particles[particles.lon + particles.dlon > 0.5].state = StatusCode.StopExecution + particles[particles.x + particles.dx > 0.5].state = StatusCode.StopExecution pset.execute(MoveAndStopAtBoundary, runtime=np.timedelta64(10, "s"), dt=np.timedelta64(1, "s")) @@ -90,8 +90,8 @@ def MoveAndStopAtBoundary(particles, fieldset): # pragma: no cover # After second step: all reach 0.30 # After third step: all reach 0.45 # After fourth step: all would reach 0.60, so they stop - assert np.all(pset.lon <= 0.6) - assert np.all(pset.lon >= 0.45) # At least 3 steps completed + assert np.all(pset.x <= 0.6) + assert np.all(pset.x >= 0.45) # At least 3 steps completed def test_particle_mask_multiple_sequential_operations(fieldset): @@ -101,13 +101,13 @@ def test_particle_mask_multiple_sequential_operations(fieldset): # Divide particles into three groups by initial position lons = np.linspace(0, 1, npart) - pset = ParticleSet(fieldset, lon=lons, lat=np.zeros(npart), pclass=MyParticle) + pset = ParticleSet(fieldset, x=lons, y=np.zeros(npart), pclass=MyParticle) def MultiMaskOperations(particles, fieldset): # pragma: no cover # Classify particles into groups based on lon - particles[particles.lon < 0.33].group = 1 - particles[(particles.lon >= 0.33) & (particles.lon < 0.67)].group = 2 - particles[particles.lon >= 0.67].group = 3 + particles[particles.x < 0.33].group = 1 + particles[(particles.x >= 0.33) & (particles.x < 0.67)].group = 2 + particles[particles.x >= 0.67].group = 3 # Apply different operations to each group particles[particles.group == 1].counter += 1 @@ -117,9 +117,9 @@ def MultiMaskOperations(particles, fieldset): # pragma: no cover pset.execute(MultiMaskOperations, runtime=np.timedelta64(5, "s"), dt=np.timedelta64(1, "s")) # Verify groups were assigned correctly and counters incremented appropriately - group1 = pset.lon < 0.33 - group2 = (pset.lon >= 0.33) & (pset.lon < 0.67) - group3 = pset.lon >= 0.67 + group1 = pset.x < 0.33 + group2 = (pset.x >= 0.33) & (pset.x < 0.67) + group3 = pset.x >= 0.67 assert np.allclose(pset.counter[group1], 5, atol=1e-6) # 5 timesteps * 1 assert np.allclose(pset.counter[group2], 10, atol=1e-6) # 5 timesteps * 2 @@ -131,13 +131,13 @@ def test_particle_mask_empty_mask_handling(fieldset): npart = 10 MyParticle = Particle.add_variable(Variable("modified", initial=0)) # All particles start at lon > 0 - pset = ParticleSet(fieldset, lon=np.linspace(0.1, 1.0, npart), lat=np.zeros(npart), pclass=MyParticle) + pset = ParticleSet(fieldset, x=np.linspace(0.1, 1.0, npart), y=np.zeros(npart), pclass=MyParticle) def ModifyNegativeLon(particles, fieldset): # pragma: no cover # This mask should be empty (no particles have lon < 0) - particles[particles.lon < 0].modified = 1 + particles[particles.x < 0].modified = 1 # This should affect all particles - particles.dlon += 0.01 + particles.dx += 0.01 # Should execute without errors even though the first mask is always empty pset.execute(ModifyNegativeLon, runtime=np.timedelta64(3, "s"), dt=np.timedelta64(1, "s")) @@ -145,25 +145,25 @@ def ModifyNegativeLon(particles, fieldset): # pragma: no cover # No particles should have been modified assert np.all(pset.modified == 0) # But all should have moved - assert np.all(pset.lon > 0.1) + assert np.all(pset.x > 0.1) def test_particle_mask_with_delete_state(fieldset): """Test using particle masks to delete particles based on conditions.""" npart = 20 - pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) + pset = ParticleSet(fieldset, x=np.linspace(0, 1, npart), y=np.zeros(npart)) initial_size = pset.size def DeleteEdgeParticles(particles, fieldset): # pragma: no cover # Delete particles at the edges - particles[(particles.lon < 0.2) | (particles.lon > 0.8)].state = StatusCode.Delete + particles[(particles.x < 0.2) | (particles.x > 0.8)].state = StatusCode.Delete def MoveLon(particles, fieldset): # pragma: no cover - particles.dlon += 0.01 + particles.dx += 0.01 pset.execute([DeleteEdgeParticles, MoveLon], runtime=np.timedelta64(2, "s"), dt=np.timedelta64(1, "s")) # Should have deleted edge particles assert pset.size < initial_size # Remaining particles should be in the middle range (with 0.02 of total displacement) - assert np.all((pset.lon >= 0.2) & (pset.lon <= 0.82)) + assert np.all((pset.x >= 0.2) & (pset.x <= 0.82)) diff --git a/tests/test_sigmagrids.py b/tests/test_sigmagrids.py index 196ce2dd1..ec05b81d0 100644 --- a/tests/test_sigmagrids.py +++ b/tests/test_sigmagrids.py @@ -68,10 +68,10 @@ def test_advection_3DCROCO(): Y = np.ones(X.size) * 100e3 pclass = Particle.add_variable(Variable("omega")) - pset = ParticleSet(fieldset=fieldset, pclass=pclass, lon=X, lat=Y, z=Z) + pset = ParticleSet(fieldset=fieldset, pclass=pclass, x=X, y=Y, z=Z) pset.execute( [AdvectionRK4_3D_CROCO, SampleOmegaCroco], runtime=np.timedelta64(runtime, "s"), dt=np.timedelta64(100, "s") ) np.testing.assert_allclose(pset.z, Z.flatten(), atol=5) # TODO lower this atol - np.testing.assert_allclose(pset.lon, [x + runtime for x in X.flatten()], atol=1e-3) + np.testing.assert_allclose(pset.x, [x + runtime for x in X.flatten()], atol=1e-3) diff --git a/tests/test_uxadvection.py b/tests/test_uxadvection.py index d3db9aecd..8ffd84b1a 100644 --- a/tests/test_uxadvection.py +++ b/tests/test_uxadvection.py @@ -18,11 +18,11 @@ def test_ux_constant_flow_face_centered_2D(integrator, tmp_parquet): dt = np.timedelta64(300, "s") fieldset = parcels.FieldSet.from_ugrid_conventions(ds, mesh="flat") - pset = parcels.ParticleSet(fieldset, lon=[5.0], lat=[5.0]) + pset = parcels.ParticleSet(fieldset, x=[5.0], y=[5.0]) pfile = parcels.ParticleFile(path=tmp_parquet, outputdt=dt) pset.execute(integrator, runtime=T, dt=dt, output_file=pfile, verbose_progress=False) expected_lon = 8.6 - np.testing.assert_allclose(pset.lon, expected_lon, atol=1e-5) + np.testing.assert_allclose(pset.x, expected_lon, atol=1e-5) df = pd.read_parquet(tmp_parquet) - np.testing.assert_allclose(df["lon"].iloc[-1], expected_lon, atol=1e-5) + np.testing.assert_allclose(df["x"].iloc[-1], expected_lon, atol=1e-5) diff --git a/tests/utils.py b/tests/utils.py index 40ddd2316..9f1b61f90 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -87,8 +87,8 @@ def create_simple_pset(n=1): return parcels.ParticleSet( fieldset=create_fieldset_unit_mesh(), pclass=parcels.Particle, - lon=zeros, - lat=zeros, + x=zeros, + y=zeros, depth=zeros, time=zeros, ) diff --git a/tests/validation/test_ux.py b/tests/validation/test_ux.py index 7771366f6..90ebb9466 100644 --- a/tests/validation/test_ux.py +++ b/tests/validation/test_ux.py @@ -72,23 +72,23 @@ def test_uniform_translation_exact(dataset_fn, integrator): ds = dataset_fn(nx=20, u0=T1_1_U0, v0=T1_1_V0) fieldset = parcels.FieldSet.from_ugrid_conventions(ds, mesh="flat") - pset = parcels.ParticleSet(fieldset, lon=[T1_1_LON0], lat=[T1_1_LAT0]) + pset = parcels.ParticleSet(fieldset, x=[T1_1_LON0], y=[T1_1_LAT0]) pset.execute(integrator, runtime=T1_1_RUNTIME, dt=T1_1_DT, verbose_progress=False) t = T1_1_RUNTIME / np.timedelta64(1, "s") - np.testing.assert_allclose(pset.lon, T1_1_LON0 + T1_1_U0 * t, atol=T1_1_TOL) - np.testing.assert_allclose(pset.lat, T1_1_LAT0 + T1_1_V0 * t, atol=T1_1_TOL) + np.testing.assert_allclose(pset.x, T1_1_LON0 + T1_1_U0 * t, atol=T1_1_TOL) + np.testing.assert_allclose(pset.y, T1_1_LAT0 + T1_1_V0 * t, atol=T1_1_TOL) def test_solid_body_rotation_node_centered_rk4_returns_to_start(): ds = solid_body_rotation_node_centered(nx=40, omega=T1_2_OMEGA) fieldset = parcels.FieldSet.from_ugrid_conventions(ds, mesh="flat") - pset = parcels.ParticleSet(fieldset, lon=[T1_2_LON0], lat=[T1_2_LAT0]) + pset = parcels.ParticleSet(fieldset, x=[T1_2_LON0], y=[T1_2_LAT0]) pset.execute(AdvectionRK4, runtime=T1_2_RUNTIME, dt=T1_2_DT, verbose_progress=False) - np.testing.assert_allclose(pset.lon, T1_2_LON0, atol=1e-6) - np.testing.assert_allclose(pset.lat, T1_2_LAT0, atol=1e-6) + np.testing.assert_allclose(pset.x, T1_2_LON0, atol=1e-6) + np.testing.assert_allclose(pset.y, T1_2_LAT0, atol=1e-6) @pytest.mark.parametrize("integrator", [AdvectionEE, AdvectionRK4], ids=["EE", "RK4"]) @@ -98,22 +98,22 @@ def test_solid_body_rotation_face_centered_runs_bounded(integrator): ds = solid_body_rotation_face_centered(nx=40, omega=T1_2_OMEGA) fieldset = parcels.FieldSet.from_ugrid_conventions(ds, mesh="flat") - pset = parcels.ParticleSet(fieldset, lon=[T1_2_LON0], lat=[T1_2_LAT0]) + pset = parcels.ParticleSet(fieldset, x=[T1_2_LON0], y=[T1_2_LAT0]) pset.execute(integrator, runtime=T1_2_RUNTIME, dt=T1_2_DT, verbose_progress=False) - assert abs(float(pset.lon[0])) < 5.0 - assert abs(float(pset.lat[0])) < 5.0 + assert abs(float(pset.x[0])) < 5.0 + assert abs(float(pset.y[0])) < 5.0 def test_helix_node_centered_rk4_3d_returns_to_start_with_exact_depth(): ds = solid_body_rotation_3d_node_centered(nx=40, nz=10, omega=T1_2_OMEGA, w0=T1_3_W0) fieldset = parcels.FieldSet.from_ugrid_conventions(ds, mesh="flat") - pset = parcels.ParticleSet(fieldset, lon=[T1_2_LON0], lat=[T1_2_LAT0], z=[T1_3_Z0]) + pset = parcels.ParticleSet(fieldset, x=[T1_2_LON0], y=[T1_2_LAT0], z=[T1_3_Z0]) pset.execute(AdvectionRK4_3D, runtime=T1_3_RUNTIME, dt=T1_3_DT, verbose_progress=False) t = T1_3_RUNTIME / np.timedelta64(1, "s") - np.testing.assert_allclose(pset.lon, T1_2_LON0, atol=1e-6) - np.testing.assert_allclose(pset.lat, T1_2_LAT0, atol=1e-6) + np.testing.assert_allclose(pset.x, T1_2_LON0, atol=1e-6) + np.testing.assert_allclose(pset.y, T1_2_LAT0, atol=1e-6) np.testing.assert_allclose(pset.z, T1_3_Z0 + T1_3_W0 * t, atol=1e-4) @@ -128,7 +128,7 @@ def test_helix_constant_vertical_velocity_exact_depth(dataset_fn): ds = dataset_fn(nx=40, nz=10, omega=T1_2_OMEGA, w0=T1_3_W0) fieldset = parcels.FieldSet.from_ugrid_conventions(ds, mesh="flat") - pset = parcels.ParticleSet(fieldset, lon=[T1_2_LON0], lat=[T1_2_LAT0], z=[T1_3_Z0]) + pset = parcels.ParticleSet(fieldset, x=[T1_2_LON0], y=[T1_2_LAT0], z=[T1_3_Z0]) pset.execute(AdvectionRK4_3D, runtime=T1_3_RUNTIME, dt=T1_3_DT, verbose_progress=False) t = T1_3_RUNTIME / np.timedelta64(1, "s")