Add method to create obs from array

Nb obs by network
get track slice

Author: AntSimi

README.md

@@ -10,7 +10,7 @@
 
 Method was described in :
 
-[Pegliasco, C., Delepoulle, A., Morrow, R., Faugère, Y., and Dibarboure, G.: META3.1exp : A new Global Mesoscale Eddy Trajectories Atlas derived from altimetry, Earth Syst. Sci. Data Discuss.](https://doi.org/10.5194/essd-2021-300)
+[Pegliasco, C., Delepoulle, A., Morrow, R., Faugère, Y., and Dibarboure, G.: META3.1exp : A new Global Mesoscale Eddy Trajectories Atlas derived from altimetry, Earth Syst. Sci. Data Discuss.](https://doi.org/10.5194/essd-14-1087-2022)
 
 [Mason, E., A. Pascual, and J. C. McWilliams, 2014: A new sea surface height–based code for oceanic mesoscale eddy tracking.](https://doi.org/10.1175/JTECH-D-14-00019.1)
 

src/py_eddy_tracker/observations/groups.py

@@ -66,7 +66,7 @@ def get_missing_indices(
     return indices
 
 
-def advect(x, y, c, t0, n_days):
+def advect(x, y, c, t0, n_days, u_name='u', v_name='v'):
     """
     Advect particles from t0 to t0 + n_days, with data cube.
 
@@ -75,13 +75,15 @@ def advect(x, y, c, t0, n_days):
     :param `~py_eddy_tracker.dataset.grid.GridCollection` c: GridCollection with speed for particles
     :param int t0: julian day of advection start
     :param int n_days: number of days to advect
+    :param str u_name: variable name for u component
+    :param str v_name: variable name for v component
     """
 
     kw = dict(nb_step=6, time_step=86400 / 6)
     if n_days < 0:
         kw["backward"] = True
         n_days = -n_days
-    p = c.advect(x, y, "u", "v", t_init=t0, **kw)
+    p = c.advect(x, y, u_name, v_name, t_init=t0, **kw)
     for _ in range(n_days):
         t, x, y = p.__next__()
     return t, x, y
@@ -125,7 +127,6 @@ def particle_candidate(
     else:
         x, y, i_start = e.create_particles(step_mesh, intern=True)
         print("The contour_start was not correct, speed contour is used")
-
     # Advection
     t_end, x, y = advect(x, y, c, t_start, **kwargs)
 

src/py_eddy_tracker/observations/network.py

@@ -161,6 +161,16 @@ def index_network(self):
             self._index_network = build_index(self.track)
         return self._index_network
 
+    def network_size(self, id_networks):
+        """
+        Return size for specified network
+
+        :param list,array id_networks: ids to identify network
+        """
+        i = id_networks - self.index_network[2]
+        i_start, i_stop = self.index_network[0][i], self.index_network[1][i]
+        return i_stop - i_start
+    
     def network_slice(self, id_network):
         """
         Return slice for one network
@@ -679,7 +689,13 @@ def display_timeline(
         """
         self.only_one_network()
         j = 0
-        line_kw = dict(ls="-", marker="+", markersize=6, zorder=1, lw=3,)
+        line_kw = dict(
+            ls="-",
+            marker="+",
+            markersize=6,
+            zorder=1,
+            lw=3,
+        )
         line_kw.update(kwargs)
         mappables = dict(lines=list())
 
@@ -912,7 +928,10 @@ def event_map(self, ax, **kwargs):
         """Add the merging and splitting events to a map"""
         j = 0
         mappables = dict()
-        symbol_kw = dict(markersize=10, color="k",)
+        symbol_kw = dict(
+            markersize=10,
+            color="k",
+        )
         symbol_kw.update(kwargs)
         symbol_kw_split = symbol_kw.copy()
         symbol_kw_split["markersize"] += 4
@@ -941,7 +960,13 @@ def event_map(self, ax, **kwargs):
         return mappables
 
     def scatter(
-        self, ax, name="time", factor=1, ref=None, edgecolor_cycle=None, **kwargs,
+        self,
+        ax,
+        name="time",
+        factor=1,
+        ref=None,
+        edgecolor_cycle=None,
+        **kwargs,
     ):
         """
         This function scatters the path of each network, with the merging and splitting events

src/py_eddy_tracker/observations/observation.py

@@ -130,7 +130,7 @@ def shifted_ellipsoid_degrees_mask2(lon0, lat0, lon1, lat1, minor=1.5, major=1.5
             if dx > major[j]:
                 m[j, i] = False
                 continue
-            d_normalize = dx ** 2 / major[j] ** 2 + dy ** 2 / minor ** 2
+            d_normalize = dx**2 / major[j] ** 2 + dy**2 / minor**2
             m[j, i] = d_normalize < 1.0
     return m
 
@@ -729,7 +729,11 @@ def load_file(cls, filename, **kwargs):
         .. code-block:: python
 
             kwargs_latlon_300 = dict(
-                include_vars=["longitude", "latitude",], indexs=dict(obs=slice(0, 300)),
+                include_vars=[
+                    "longitude",
+                    "latitude",
+                ],
+                indexs=dict(obs=slice(0, 300)),
             )
             small_dataset = TrackEddiesObservations.load_file(
                 filename, **kwargs_latlon_300
@@ -1047,6 +1051,19 @@ def compare_units(input_unit, output_unit, name):
                     output_unit,
                 )
 
+    @classmethod
+    def from_array(cls, arrays, **kwargs):
+        nb = arrays["time"].size
+        # if hasattr(handler, "track_array_variables"):
+        #     kwargs["track_array_variables"] = handler.track_array_variables
+        #     kwargs["array_variables"] = handler.array_variables.split(",")
+        # if len(handler.track_extra_variables) > 1:
+        #     kwargs["track_extra_variables"] = handler.track_extra_variables.split(",")
+        eddies = cls(size=nb, **kwargs)
+        for k, v in arrays.items():
+            eddies.obs[k] = v
+        return eddies
+
     @classmethod
     def from_zarr(cls, handler):
         nb_obs = len(handler.dimensions[cls.obs_dimension(handler)])
@@ -1302,7 +1319,7 @@ def fixed_ellipsoid_mask(
             if isinstance(minor, ndarray):
                 minor = minor[index_self]
             # focal distance
-            f_degree = ((major ** 2 - minor ** 2) ** 0.5) / (
+            f_degree = ((major**2 - minor**2) ** 0.5) / (
                 111.2 * cos(radians(self.lat[index_self]))
             )
 
@@ -2010,7 +2027,11 @@ def bins_stat(self, xname, bins=None, yname=None, method=None, mask=None):
 
     def format_label(self, label):
         t0, t1 = self.period
-        return label.format(t0=t0, t1=t1, nb_obs=len(self),)
+        return label.format(
+            t0=t0,
+            t1=t1,
+            nb_obs=len(self),
+        )
 
     def display(self, ax, ref=None, extern_only=False, intern_only=False, **kwargs):
         """Plot the speed and effective (dashed) contour of the eddies
@@ -2381,7 +2402,14 @@ def grid_count_pixel_in(
         x_, y_ = reduce_size(x_, y_)
         v = create_vertice(x_, y_)
         (x_start, x_stop), (y_start, y_stop) = bbox_indice_regular(
-            v, x_bounds, y_bounds, xstep, ystep, N, is_circular, x_size,
+            v,
+            x_bounds,
+            y_bounds,
+            xstep,
+            ystep,
+            N,
+            is_circular,
+            x_size,
         )
         i, j = get_pixel_in_regular(v, x_c, y_c, x_start, x_stop, y_start, y_stop)
         grid_count_(grid, i, j)

src/py_eddy_tracker/observations/tracking.py

@@ -68,6 +68,10 @@ def __init__(self, *args, **kwargs):
         self.__obs_by_track = None
         self.__nb_track = None
 
+    def track_slice(self, track):
+        i0 = self.index_from_track[track]
+        return slice(i0, i0 + self.nb_obs_by_track[track])
+
     def iter_track(self):
         """
         Yield track
@@ -582,7 +586,10 @@ def close_tracks(self, other, nb_obs_min=10, **kwargs):
     def format_label(self, label):
         t0, t1 = self.period
         return label.format(
-            t0=t0, t1=t1, nb_obs=len(self), nb_tracks=(self.nb_obs_by_track != 0).sum(),
+            t0=t0,
+            t1=t1,
+            nb_obs=len(self),
+            nb_tracks=(self.nb_obs_by_track != 0).sum(),
         )
 
     def plot(self, ax, ref=None, **kwargs):