Renamed attribute obs_dimname to obs_dim, consistent with Xarray practice

Author: knutfrode

examples/example_find_positions_at_obs_times.py

@@ -25,7 +25,7 @@
 def gridwaves(tds):
     t = tds[['lat', 'lon',
              'time']].traj.gridtime(tds['time_waves_imu'].squeeze())
-    return t.traj.to_2d(obs_dimname='obs_waves_imu')
+    return t.traj.to_2d(obs_dim='obs_waves_imu')
 
 
 dsw = ds.groupby('trajectory').map(gridwaves)

tests/test_read_sfy.py

@@ -8,7 +8,7 @@ def test_interpret_sfy(test_data):
     ds = xr.open_dataset(test_data / 'bug32.nc')
     print(ds)
 
-    assert ds.traj.obs_dimname == 'package'
+    assert ds.traj.obs_dim == 'package'
     assert ds.traj.time_varname == 'position_time'
 
     assert ds.traj.is_2d()

trajan/accessor.py

@@ -26,10 +26,10 @@ def detect_tx_dim(ds):
         raise ValueError("Could not determine x / lon variable")
 
 
-def detect_time_dim(ds, obs_dimname):
-    logger.debug(f'Detecting time-dimension for "{obs_dimname}"..')
+def detect_time_dim(ds, obs_dim):
+    logger.debug(f'Detecting time-dimension for "{obs_dim}"..')
     for v in ds.variables:
-        if obs_dimname in ds[v].dims and 'time' in v:
+        if obs_dim in ds[v].dims and 'time' in v:
             return v
 
     raise ValueError("no time dimension detected")
@@ -47,7 +47,7 @@ def __new__(cls, ds):
             ds = ds.expand_dims({'trajectory': 1})
             ds['trajectory'].attrs['cf_role'] = 'trajectory_id'
 
-        obs_dimname = None
+        obs_dim = None
         time_varname = None
 
         tx = detect_tx_dim(ds)
@@ -62,7 +62,7 @@ def __new__(cls, ds):
             # NOTE: this is probably not standard; something to point to the CF conventions?
             # NOTE: for now, there is no discovery of the "index" dim, this is hardcorded; any way to do better?
             if "index" in tx.dims:
-                obs_dimname = "index"
+                obs_dim = "index"
 
                 # discover the timecoord variable name #######################
                 # find all variables with standard_name "time"
@@ -90,30 +90,30 @@ def __new__(cls, ds):
                 else:
                     raise ValueError(f"cannot deduce rowsizevar; we have the following candidates: {with_dim_trajectory = }")
                 # sanity check
-                if not np.sum(ds[rowsizevar].to_numpy()) == len(ds[obs_dimname]):
+                if not np.sum(ds[rowsizevar].to_numpy()) == len(ds[obs_dim]):
                     raise ValueError("mismatch between the index length and the sum of the deduced trajectory lengths")
 
                 logger.debug(
-                    f"1D storage dataset; detected: {obs_dimname = }, {timecoord = }, {trajectorycoord = }, {rowsizevar}"
+                    f"1D storage dataset; detected: {obs_dim = }, {timecoord = }, {trajectorycoord = }, {rowsizevar}"
                 )
 
-                return ocls(ds, obs_dimname, timecoord, trajectorycoord, rowsizevar)
+                return ocls(ds, obs_dim, timecoord, trajectorycoord, rowsizevar)
 
             else:
                 logging.warning(f"{ds} has {tx.dims = } which is of dimension 1 but is not index; this is a bit unusual; try to parse with Traj1d or Traj2d")
 
         # we have a ds where 2D arrays are used to store data, this is either Traj1d or Traj2d
         # there may also be some slightly unusual cases where these Traj1d and Traj2d classes will be used on data with 1D arrays
         if 'obs' in tx.dims:
-            obs_dimname = 'obs'
-            time_varname = detect_time_dim(ds, obs_dimname)
+            obs_dim = 'obs'
+            time_varname = detect_time_dim(ds, obs_dim)
 
         elif 'index' in tx.dims:
-            obs_dimname = 'obs'
-            time_varname = detect_time_dim(ds, obs_dimname)
+            obs_dim = 'obs'
+            time_varname = detect_time_dim(ds, obs_dim)
 
         elif 'time' in tx.dims:
-            obs_dimname = 'time'
+            obs_dim = 'time'
             time_varname = 'time'
 
         else:
@@ -122,18 +122,18 @@ def __new__(cls, ds):
                         'cf_role',
                         None) == 'trajectory_id' and not 'traj' in d:
 
-                    obs_dimname = d
-                    time_varname = detect_time_dim(ds, obs_dimname)
+                    obs_dim = d
+                    time_varname = detect_time_dim(ds, obs_dim)
 
                     break
 
-            if obs_dimname is None:
+            if obs_dim is None:
                 logger.warning('No time or obs dimension detected.')
 
         logger.debug(
-            f"Detected obs-dim: {obs_dimname}, detected time-dim: {time_varname}.")
+            f"Detected obs-dim: {obs_dim}, detected time-variable: {time_varname}.")
 
-        if obs_dimname is None:
+        if obs_dim is None:
             ocls = Traj1d
 
         elif len(ds[time_varname].shape) <= 1:
@@ -146,7 +146,7 @@ def __new__(cls, ds):
 
         else:
             raise ValueError(
-                f'Time dimension has shape greater than 2: {ds["time_varname"].shape}'
+                f'Time variable has more than two dimensions: {ds[time_varname].shape}'
             )
 
-        return ocls(ds, obs_dimname, time_varname)
+        return ocls(ds, obs_dim, time_varname)

trajan/ragged.py

@@ -14,12 +14,12 @@ class ContiguousRagged(Traj):
     trajdim: str
     rowvar: str
 
-    def __init__(self, ds, obs_dimname, time_varname, trajectorycoord, rowsizevar):
+    def __init__(self, ds, obs_dim, time_varname, trajectorycoord, rowsizevar):
         self.trajdim = trajectorycoord
         self.rowvar = rowsizevar
-        super().__init__(ds, obs_dimname, time_varname)
+        super().__init__(ds, obs_dim, time_varname)
 
-    def to_2d(self, obs_dimname='obs'):
+    def to_2d(self, obs_dim='obs'):
         """This actually converts a contiguous ragged xarray Dataset into an xarray Dataset that follows the Traj2d conventions."""
         global_attrs = self.ds.attrs
 
@@ -70,7 +70,7 @@ def to_2d(self, obs_dimname='obs'):
 
             # trajectory vars
             'time':
-            xr.DataArray(dims=["trajectory", obs_dimname],
+            xr.DataArray(dims=["trajectory", obs_dim],
                          data=array_time,
                          attrs={
                              "standard_name": "time",
@@ -81,7 +81,7 @@ def to_2d(self, obs_dimname='obs'):
 
         # now add all "normal" variables
         # NOTE: for now, we only consider scalar vars; if we want to consider more complex vars (e.g., spectra), this will need updated
-        # NOTE: such an update would typically need to look at the dims of the variable, and if there are additional dims to obs_dimname, create a higer dim variable
+        # NOTE: such an update would typically need to look at the dims of the variable, and if there are additional dims to obs_dim, create a higer dim variable
 
         for crrt_data_var in self.ds.data_vars:
             attrs = self.ds[crrt_data_var].attrs
@@ -90,9 +90,9 @@ def to_2d(self, obs_dimname='obs'):
                 continue
 
             if len(self.ds[crrt_data_var].dims
-                   ) != 1 or self.ds[crrt_data_var].dims[0] != self.obs_dimname:
+                   ) != 1 or self.ds[crrt_data_var].dims[0] != self.obs_dim:
                 raise ValueError(
-                    f"data_vars element {crrt_data_var} has dims {self.ds[crrt_data_var].dims}, expected {(self.obs_dimname,)}"
+                    f"data_vars element {crrt_data_var} has dims {self.ds[crrt_data_var].dims}, expected {(self.obs_dim,)}"
                 )
 
             crrt_var = np.full((nbr_trajectories, longest_trajectory), np.nan)
@@ -119,7 +119,7 @@ def to_2d(self, obs_dimname='obs'):
                 crrt_data_var = "lat"
 
             ds_converted_to_traj2d[crrt_data_var] = \
-                xr.DataArray(dims=["trajectory", obs_dimname],
+                xr.DataArray(dims=["trajectory", obs_dim],
                              data=crrt_var,
                              attrs=attrs)
 

trajan/traj.py

@@ -33,10 +33,10 @@ def detect_tx_dim(ds):
         raise ValueError("Could not determine x / lon variable")
 
 
-def detect_time_dim(ds, obs_dimname):
-    logger.debug(f'Detecting time-dimension for "{obs_dimname}"..')
+def detect_time_dim(ds, obs_dim):
+    logger.debug(f'Detecting time-dimension for "{obs_dim}"..')
     for v in ds.variables:
-        if obs_dimname in ds[v].dims and 'time' in v:
+        if obs_dim in ds[v].dims and 'time' in v:
             return v
 
     raise ValueError("no time dimension detected")
@@ -50,12 +50,12 @@ class Traj:
 
     __gcrs__: pyproj.CRS
 
-    def __init__(self, ds, obs_dimname, time_varname):
+    def __init__(self, ds, obs_dim, time_varname):
         self.ds = ds
         self.__plot__ = None
         self.__animate__ = None
         self.__gcrs__ = pyproj.CRS.from_epsg(4326)
-        self.obs_dimname = obs_dimname  # dimension along which time increases
+        self.obs_dim = obs_dim  # dimension along which time increases
         self.time_varname = time_varname
 
     def __repr__(self):
@@ -528,18 +528,18 @@ def distance_to_next(self):
 
         lon = self.ds.lon
         lat = self.ds.lat
-        lenobs = self.ds.sizes[self.obs_dimname]
-        lonfrom = lon.isel({self.obs_dimname: slice(0, lenobs - 1)})
-        latfrom = lat.isel({self.obs_dimname: slice(0, lenobs - 1)})
-        lonto = lon.isel({self.obs_dimname: slice(1, lenobs)})
-        latto = lat.isel({self.obs_dimname: slice(1, lenobs)})
+        lenobs = self.ds.sizes[self.obs_dim]
+        lonfrom = lon.isel({self.obs_dim: slice(0, lenobs - 1)})
+        latfrom = lat.isel({self.obs_dim: slice(0, lenobs - 1)})
+        lonto = lon.isel({self.obs_dim: slice(1, lenobs)})
+        latto = lat.isel({self.obs_dim: slice(1, lenobs)})
         geod = pyproj.Geod(ellps='WGS84')
         azimuth_forward, a2, distance = geod.inv(lonfrom, latfrom, lonto,
                                                  latto)
 
         distance = xr.DataArray(distance, coords=lonfrom.coords, dims=lon.dims)
-        distance = xr.concat((distance, distance.isel({self.obs_dimname: -1})),
-                             dim=self.obs_dimname)  # repeating last time step to
+        distance = xr.concat((distance, distance.isel({self.obs_dim: -1})),
+                             dim=self.obs_dim)  # repeating last time step to
         return distance
 
     def azimuth_to_next(self):
@@ -560,11 +560,11 @@ def azimuth_to_next(self):
         # TODO: method is almost duplicate of "distance_to_next" above
         lon = self.ds.lon
         lat = self.ds.lat
-        lenobs = self.ds.dims[self.obs_dimname]
-        lonfrom = lon.isel({self.obs_dimname: slice(0, lenobs - 1)})
-        latfrom = lat.isel({self.obs_dimname: slice(0, lenobs - 1)})
-        lonto = lon.isel({self.obs_dimname: slice(1, lenobs)})
-        latto = lat.isel({self.obs_dimname: slice(1, lenobs)})
+        lenobs = self.ds.dims[self.obs_dim]
+        lonfrom = lon.isel({self.obs_dim: slice(0, lenobs - 1)})
+        latfrom = lat.isel({self.obs_dim: slice(0, lenobs - 1)})
+        lonto = lon.isel({self.obs_dim: slice(1, lenobs)})
+        latto = lat.isel({self.obs_dim: slice(1, lenobs)})
         geod = pyproj.Geod(ellps='WGS84')
         azimuth_forward, a2, distance = geod.inv(lonfrom, latfrom, lonto,
                                                  latto)
@@ -573,8 +573,8 @@ def azimuth_to_next(self):
                                        coords=lonfrom.coords,
                                        dims=lon.dims)
         azimuth_forward = xr.concat(
-            (azimuth_forward, azimuth_forward.isel({self.obs_dimname: -1})),
-            dim=self.obs_dimname)  # repeating last time step to
+            (azimuth_forward, azimuth_forward.isel({self.obs_dim: -1})),
+            dim=self.obs_dim)  # repeating last time step to
         return azimuth_forward
 
     def velocity_components(self):
@@ -890,7 +890,7 @@ def condense_obs(self) -> xr.Dataset:
         """
 
     @abstractmethod
-    def to_2d(self, obs_dimname='obs') -> xr.Dataset:
+    def to_2d(self, obs_dim='obs') -> xr.Dataset:
         """
         Convert dataset into a 2D dataset from.
         """

trajan/traj1d.py

@@ -14,8 +14,8 @@ class Traj1d(Traj):
     A structured dataset, where each trajectory is always given at the same times. Typically the output from a model or from a gridded dataset.
     """
 
-    def __init__(self, ds, obs_dimname, time_varname):
-        super().__init__(ds, obs_dimname, time_varname)
+    def __init__(self, ds, obs_dim, time_varname):
+        super().__init__(ds, obs_dim, time_varname)
 
     def timestep(self):
         """Time step between observations in seconds."""
@@ -28,14 +28,14 @@ def is_1d(self):
     def is_2d(self):
         return False
 
-    def to_2d(self, obs_dimname='obs'):
+    def to_2d(self, obs_dim='obs'):
         ds = self.ds.copy()
         time = ds[self.time_varname].rename({
-            self.time_varname: obs_dimname
+            self.time_varname: obs_dim
         }).expand_dims(dim={'trajectory': ds.sizes['trajectory']})
-        ds = ds.rename({self.time_varname: obs_dimname})
+        ds = ds.rename({self.time_varname: obs_dim})
         ds[self.time_varname] = time
-        ds[obs_dimname] = np.arange(0, ds.sizes[obs_dimname])
+        ds[obs_dim] = np.arange(0, ds.sizes[obs_dim])
 
         return ds
 
@@ -101,8 +101,8 @@ def skill(self, other, method='liu-weissberg', **kwargs):
             )
 
         diff = np.max(
-            np.abs((self.ds[self.obs_dimname] -
-                    other[other.traj.obs_dimname]).astype('timedelta64[s]').astype(
+            np.abs((self.ds[self.obs_dim] -
+                    other[other.traj.obs_dim]).astype('timedelta64[s]').astype(
                         np.float64)))
 
         if not np.isclose(diff, 0):
@@ -112,11 +112,11 @@ def skill(self, other, method='liu-weissberg', **kwargs):
 
         s = np.zeros((self.ds.sizes['trajectory']), dtype=np.float32)
 
-        # ds = self.ds.dropna(dim=self.obs_dimname)
-        # other = other.dropna(dim=other.traj.obs_dimname)
+        # ds = self.ds.dropna(dim=self.obs_dim)
+        # other = other.dropna(dim=other.traj.obs_dim)
 
-        ds = self.ds.transpose('trajectory', self.obs_dimname, ...)
-        other = other.transpose('trajectory', other.traj.obs_dimname, ...)
+        ds = self.ds.transpose('trajectory', self.obs_dim, ...)
+        other = other.transpose('trajectory', other.traj.obs_dim, ...)
 
         lon0 = ds.traj.tlon
         lat0 = ds.traj.tlat
@@ -165,9 +165,9 @@ def gridtime(self, times, time_varname=None, round=True):
 
         ds = self.ds
 
-        if self.obs_dimname != time_varname:
+        if self.obs_dim != time_varname:
             ds = ds.rename({
-                self.obs_dimname: time_varname
+                self.obs_dim: time_varname
             }).set_index({time_varname: time_varname})
 
         _, ui = np.unique(ds[time_varname], return_index=True)