Implement getattr for Particles

Using temporary TestParticle class for now

Author: erikvansebille

parcels/kernel.py

@@ -186,16 +186,16 @@ def Setcoords(particle, fieldset, time):  # pragma: no cover
             particle_dlon = 0  # noqa
             particle_dlat = 0  # noqa
             particle_ddepth = 0  # noqa
-            particle["lon"][:] = particle.lon_nextloop
-            particle["lat"][:] = particle.lat_nextloop
-            particle["depth"][:] = particle.depth_nextloop
-            particle["time"][:] = particle.time_nextloop
+            particle.lon = particle.lon_nextloop
+            particle.lat = particle.lat_nextloop
+            particle.depth = particle.depth_nextloop
+            particle.time = particle.time_nextloop
 
         def Updatecoords(particle, fieldset, time):  # pragma: no cover
-            particle["lon_nextloop"][:] = particle.lon + particle_dlon  # type: ignore[name-defined] # noqa
-            particle["lat_nextloop"][:] = particle.lat + particle_dlat  # type: ignore[name-defined] # noqa
-            particle["depth_nextloop"][:] = particle.depth + particle_ddepth  # type: ignore[name-defined] # noqa
-            particle["time_nextloop"][:] = particle.time + particle.dt
+            particle.lon_nextloop = particle.lon + particle_dlon  # type: ignore[name-defined] # noqa
+            particle.lat_nextloop = particle.lat + particle_dlat  # type: ignore[name-defined] # noqa
+            particle.depth_nextloop = particle.depth + particle_ddepth  # type: ignore[name-defined] # noqa
+            particle.time_nextloop = particle.time + particle.dt
 
         self._pyfunc = (Setcoords + self + Updatecoords)._pyfunc
 
@@ -377,9 +377,9 @@ def evaluate_particle(self, p, endtime):
             computational integration timestep
         """
         while p.state in [StatusCode.Evaluate, StatusCode.Repeat]:
-            pre_dt = p["dt"]
+            pre_dt = p.dt
 
-            sign_dt = np.sign(p.dt.values).astype(int)
+            sign_dt = np.sign(p.dt).astype(int)
             if sign_dt * (p.time_nextloop - endtime) > np.timedelta64(0, "ns"):
                 return p
 
@@ -399,5 +399,5 @@ def evaluate_particle(self, p, endtime):
             else:
                 p.state = res
 
-            p["dt"][:] = pre_dt
+            p.dt = pre_dt
         return p

parcels/particleset.py

@@ -23,6 +23,28 @@
 __all__ = ["ParticleSet"]
 
 
+class TestParticle:
+    # Temporary class to allow for testing of ParticleSet without needing to change v3-Particle class. TODO update the Particle class
+    def __init__(self, data, index=None):
+        self._data = data
+        self._index = index
+
+    def __getattr__(self, name):
+        if name in ["_data", "_index"]:
+            return object.__getattribute__(self, name)
+        _data = object.__getattribute__(self, "_data")
+        if name in _data:
+            return _data[name].values[self._index]
+        else:
+            return False
+
+    def __setattr__(self, name, value):
+        if name in ["_data", "_index"]:
+            object.__setattr__(self, name, value)
+        else:
+            self._data[name][self._index] = value
+
+
 class ParticleSet:
     """Class for storing particle and executing kernel over them.
 
@@ -138,25 +160,18 @@ def __init__(
 
         self._data = xr.Dataset(
             {
-                "lon": (
-                    ["trajectory", "obs"],
-                    np.array(lon[:, np.newaxis], dtype=lonlatdepth_dtype),
-                ),  # TODO check if newaxis is needed
-                "lat": (["trajectory", "obs"], np.array(lat[:, np.newaxis], dtype=lonlatdepth_dtype)),
-                "depth": (["trajectory", "obs"], np.array(depth[:, np.newaxis], dtype=lonlatdepth_dtype)),
-                "time": (["trajectory", "obs"], np.array(time[:, np.newaxis])),
-                "dt": (["trajectory", "obs"], np.timedelta64(1, "ns") * np.ones((len(pid_orig), 1))),
-                "state": (["trajectory", "obs"], np.zeros((len(pid_orig), 1), dtype=np.int32)),
-                "lon_nextloop": (
-                    ["trajectory", "obs"],
-                    np.array(lon[:, np.newaxis], dtype=lonlatdepth_dtype),
-                ),  # TODO check if newaxis is needed
-                "lat_nextloop": (["trajectory", "obs"], np.array(lat[:, np.newaxis], dtype=lonlatdepth_dtype)),
-                "depth_nextloop": (["trajectory", "obs"], np.array(depth[:, np.newaxis], dtype=lonlatdepth_dtype)),
-                "time_nextloop": (["trajectory", "obs"], np.array(time[:, np.newaxis])),
+                "lon": (["trajectory"], lon),
+                "lat": (["trajectory"], lat),
+                "depth": (["trajectory"], depth),
+                "time": (["trajectory"], time),
+                "dt": (["trajectory"], np.timedelta64(1, "ns") * np.ones(len(pid_orig))),
+                "state": (["trajectory"], np.zeros((len(pid_orig)), dtype=np.int32)),
+                "lon_nextloop": (["trajectory"], lon),
+                "lat_nextloop": (["trajectory"], lat),
+                "depth_nextloop": (["trajectory"], depth),
+                "time_nextloop": (["trajectory"], time),
             },
             coords={
-                "obs": ("obs", [0]),
                 "trajectory": ("trajectory", pid_orig),
             },
             attrs={
@@ -179,7 +194,7 @@ def __iter__(self):
 
     def __next__(self):
         if self._index < len(self):
-            p = self._data.sel(trajectory=self._index)
+            p = self.__getitem__(self._index)
             self._index += 1
             return p
         raise StopIteration
@@ -202,7 +217,7 @@ def __getattr__(self, name):
 
     def __getitem__(self, index):
         """Get a single particle by index."""
-        return self._data.sel(trajectory=index)
+        return TestParticle(self._data, index=index)
 
     @staticmethod
     def lonlatdepth_dtype_from_field_interp_method(field):

tests/v4/test_particleset.py

@@ -104,8 +104,8 @@ def test_pset_add_explicit(fieldset):
         particle = ParticleSet(pclass=Particle, lon=lon[i], lat=lat[i], fieldset=fieldset)
         pset.add(particle)
     assert len(pset) == npart
-    assert np.allclose(pset._data["lon"][:, 0], lon, atol=1e-12)
-    assert np.allclose(pset._data["lat"][:, 0], lat, atol=1e-12)
+    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(np.diff(pset._data.trajectory), np.ones(pset._data.trajectory.size - 1), atol=1e-12)