Removing time_origin for v4

As time will become a datetime64?timedelta64 object, no need anymore for time_origin and TimeConverter

Author: erikvansebille

parcels/particlefile.py

@@ -150,10 +150,6 @@ def fname(self):
     def vars_to_write(self):
         return self._vars_to_write
 
-    @property
-    def time_origin(self):
-        return self.particleset.time_origin
-
     def _create_variables_attribute_dict(self):
         """Creates the dictionary with variable attributes.
 
@@ -173,9 +169,8 @@ def _create_variables_attribute_dict(self):
             "lat": {"long_name": "", "standard_name": "latitude", "units": "degrees_north", "axis": "Y"},
         }
 
-        if self.time_origin.calendar is not None:
-            attrs["time"]["units"] = "seconds since " + str(self.time_origin)
-            attrs["time"]["calendar"] = _set_calendar(self.time_origin.calendar)
+        attrs["time"]["units"] = "seconds since "  # TODO fix units
+        attrs["time"]["calendar"] = "None"  # TODO fix calendar
 
         for vname in self.vars_to_write:
             if vname not in ["time", "lat", "lon", "depth", "id"]:

parcels/particleset.py

@@ -17,21 +17,14 @@
 from parcels.particle import Particle
 from parcels.particledata import ParticleData, ParticleDataIterator
 from parcels.particlefile import ParticleFile
-from parcels.tools.converters import _get_cftime_calendars, convert_to_flat_array
+from parcels.tools.converters import convert_to_flat_array
 from parcels.tools.loggers import logger
 from parcels.tools.statuscodes import StatusCode
 from parcels.tools.warnings import ParticleSetWarning
 
 __all__ = ["ParticleSet"]
 
 
-def _convert_to_reltime(time):
-    """Check to determine if the value of the time parameter needs to be converted to a relative value (relative to the time_origin)."""
-    if isinstance(time, np.datetime64) or (hasattr(time, "calendar") and time.calendar in _get_cftime_calendars()):
-        return True
-    return False
-
-
 class ParticleSet:
     """Class for storing particle and executing kernel over them.
 
@@ -126,7 +119,6 @@ def __init__(
         else:
             raise NotImplementedError("particle time must be a datetime or date object")
 
-        time = np.array([self.time_origin.reltime(t) if _convert_to_reltime(t) else t for t in time])
         assert lon.size == time.size, "time and positions (lon, lat, depth) do not have the same lengths."
         if fieldset.time_interval:
             _warn_particle_times_outside_fieldset_time_bounds(time, fieldset.time_interval)

parcels/tools/converters.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import inspect
-from datetime import timedelta
 from math import cos, pi
 
 import cftime
@@ -13,7 +12,6 @@
     "GeographicPolar",
     "GeographicPolarSquare",
     "GeographicSquare",
-    "TimeConverter",
     "UnitConverter",
     "convert_to_flat_array",
     "unitconverters_map",
@@ -42,122 +40,6 @@ def _get_cftime_calendars() -> list[str]:
     return [getattr(cftime, cf_datetime)(1990, 1, 1).calendar for cf_datetime in _get_cftime_datetimes()]
 
 
-class TimeConverter:
-    """Converter class for dates with different calendars in FieldSets
-
-    Parameters
-    ----------
-    time_origin : float, integer, numpy.datetime64 or cftime.DatetimeNoLeap
-        time origin of the class.
-    """
-
-    def __init__(self, time_origin: float | np.datetime64 | np.timedelta64 | cftime.datetime = 0):
-        self.time_origin = time_origin
-        self.calendar: str | None = None
-        if isinstance(time_origin, np.datetime64):
-            self.calendar = "np_datetime64"
-        elif isinstance(time_origin, np.timedelta64):
-            self.calendar = "np_timedelta64"
-        elif isinstance(time_origin, cftime.datetime):
-            self.calendar = time_origin.calendar
-
-    def reltime(self, time: TimeConverter | np.datetime64 | np.timedelta64 | cftime.datetime) -> float | npt.NDArray:
-        """Method to compute the difference, in seconds, between a time and the time_origin
-        of the TimeConverter
-
-        Parameters
-        ----------
-        time :
-
-
-        Returns
-        -------
-        type
-            time - self.time_origin
-
-        """
-        time = time.time_origin if isinstance(time, TimeConverter) else time
-        if self.calendar in ["np_datetime64", "np_timedelta64"]:
-            return (time - self.time_origin) / np.timedelta64(1, "s")  # type: ignore
-        elif self.calendar in _get_cftime_calendars():
-            if isinstance(time, (list, np.ndarray)):
-                try:
-                    return np.array([(t - self.time_origin).total_seconds() for t in time])  # type: ignore
-                except ValueError:
-                    raise ValueError(
-                        f"Cannot subtract 'time' (a {type(time)} object) from a {self.calendar} calendar.\n"
-                        f"Provide 'time' as a {type(self.time_origin)} object?"
-                    )
-            else:
-                try:
-                    return (time - self.time_origin).total_seconds()  # type: ignore
-                except ValueError:
-                    raise ValueError(
-                        f"Cannot subtract 'time' (a {type(time)} object) from a {self.calendar} calendar.\n"
-                        f"Provide 'time' as a {type(self.time_origin)} object?"
-                    )
-        elif self.calendar is None:
-            return time - self.time_origin  # type: ignore
-        else:
-            raise RuntimeError(f"Calendar {self.calendar} not implemented in TimeConverter")
-
-    def fulltime(self, time):
-        """Method to convert a time difference in seconds to a date, based on the time_origin
-
-        Parameters
-        ----------
-        time :
-
-
-        Returns
-        -------
-        type
-            self.time_origin + time
-
-        """
-        time = time.time_origin if isinstance(time, TimeConverter) else time
-        if self.calendar in ["np_datetime64", "np_timedelta64"]:
-            if isinstance(time, (list, np.ndarray)):
-                return [self.time_origin + np.timedelta64(int(t), "s") for t in time]
-            else:
-                return self.time_origin + np.timedelta64(int(time), "s")
-        elif self.calendar in _get_cftime_calendars():
-            return self.time_origin + timedelta(seconds=time)
-        elif self.calendar is None:
-            return self.time_origin + time
-        else:
-            raise RuntimeError(f"Calendar {self.calendar} not implemented in TimeConverter")
-
-    def __repr__(self):
-        return f"{self.time_origin}"
-
-    def __eq__(self, other):
-        other = other.time_origin if isinstance(other, TimeConverter) else other
-        return self.time_origin == other
-
-    def __ne__(self, other):
-        other = other.time_origin if isinstance(other, TimeConverter) else other
-        if not isinstance(other, type(self.time_origin)):
-            return True
-        return self.time_origin != other
-
-    def __gt__(self, other):
-        other = other.time_origin if isinstance(other, TimeConverter) else other
-        return self.time_origin > other
-
-    def __lt__(self, other):
-        other = other.time_origin if isinstance(other, TimeConverter) else other
-        return self.time_origin < other
-
-    def __ge__(self, other):
-        other = other.time_origin if isinstance(other, TimeConverter) else other
-        return self.time_origin >= other
-
-    def __le__(self, other):
-        other = other.time_origin if isinstance(other, TimeConverter) else other
-        return self.time_origin <= other
-
-
 class UnitConverter:
     """Interface class for spatial unit conversion during field sampling that performs no conversion."""
 

parcels/tools/statuscodes.py

@@ -69,8 +69,6 @@ class TimeExtrapolationError(RuntimeError):
     """Utility error class to propagate erroneous time extrapolation sampling."""
 
     def __init__(self, time, field=None):
-        if field is not None and field.grid.time_origin and time is not None:
-            time = field.grid.time_origin.fulltime(time)
         message = (
             f"{field.name if field else 'Field'} sampled outside time domain at time {time}."
             " Try setting allow_time_extrapolation to True."
@@ -86,23 +84,12 @@ class KernelError(RuntimeError):
     """General particle kernel error with optional custom message."""
 
     def __init__(self, particle, fieldset=None, msg=None):
-        message = (
-            f"{particle.state}\n"
-            f"Particle {particle}\n"
-            f"Time: {_parse_particletime(particle.time, fieldset)}\n"
-            f"timestep dt: {particle.dt}\n"
-        )
+        message = f"{particle.state}\nParticle {particle}\nTime: {particle.time}\ntimestep dt: {particle.dt}\n"
         if msg:
             message += msg
         super().__init__(message)
 
 
-def _parse_particletime(time, fieldset):
-    if fieldset is not None and fieldset.time_origin:
-        time = fieldset.time_origin.fulltime(time)
-    return time
-
-
 AllParcelsErrorCodes = {
     FieldSamplingError: StatusCode.Error,
     FieldOutOfBoundError: StatusCode.ErrorOutOfBounds,

parcels/xgrid.py

@@ -8,7 +8,6 @@
 from parcels import xgcm
 from parcels._index_search import _search_indices_curvilinear_2d
 from parcels.basegrid import BaseGrid
-from parcels.tools.converters import TimeConverter
 
 _XGRID_AXES_ORDERING = "ZYX"
 _XGRID_AXES = Literal["X", "Y", "Z"]
@@ -130,16 +129,6 @@ def zdim(self):
     def tdim(self):
         return get_cell_edge_count_along_dim(self.xgcm_grid.axes.get("T"))
 
-    @property
-    def time_origin(self):
-        """
-        Note
-        ----
-        Included for compatibility with v3 codebase. May be removed in future.
-        TODO v4: Evaluate
-        """
-        return TimeConverter(self._datetimes[0])
-
     @property
     def _z4d(self) -> Literal[0, 1]:
         """

tests/tools/test_converters.py

@@ -22,7 +22,6 @@
     GridTestCase(datasets["ds_2d_left"], "ydim", Y),
     GridTestCase(datasets["ds_2d_left"], "zdim", Z),
     GridTestCase(datasets["ds_2d_left"], "tdim", T),
-    GridTestCase(datasets["ds_2d_left"], "time_origin", TimeConverter(datasets["ds_2d_left"].time.values[0])),
 ]
 
 
@@ -56,7 +55,6 @@ def test_xgrid_properties_ground_truth(ds, attr, expected):
         "ydim",
         "zdim",
         "tdim",
-        "time_origin",
         "_gtype",
     ],
 )
@@ -69,7 +67,6 @@ def test_xgrid_against_old(ds, attr):
         lat=ds.lat.values,
         depth=ds.depth.values,
         time=ds.time.values.astype("float64") / 1e9,
-        time_origin=TimeConverter(ds.time.values[0]),
         mesh="spherical",
     )
     actual = getattr(grid, attr)