Access to variable like attribute

Author: AntSimi

examples/02_eddy_identification/pet_filter_and_detection.py

@@ -62,20 +62,20 @@ def update_axes(ax, mappable=None):
 ax_a = fig.add_subplot(121, xlabel="Amplitude (cm)")
 ax_r = fig.add_subplot(122, xlabel="Speed Radius (km)")
 ax_a.hist(
-    merge_f["amplitude"] * 100,
+    merge_f.amplitude * 100,
     bins=arange(0.0005, 100, 1),
     label="Eddies in the filtered grid",
     histtype="step",
 )
 ax_a.hist(
-    merge_t["amplitude"] * 100,
+    merge_t.amplitude * 100,
     bins=arange(0.0005, 100, 1),
     label="Eddies without filter",
     histtype="step",
 )
 ax_a.set_xlim(0, 10)
-ax_r.hist(merge_f["radius_s"] / 1000.0, bins=arange(0, 300, 5), histtype="step")
-ax_r.hist(merge_t["radius_s"] / 1000.0, bins=arange(0, 300, 5), histtype="step")
+ax_r.hist(merge_f.radius_s / 1000.0, bins=arange(0, 300, 5), histtype="step")
+ax_r.hist(merge_t.radius_s / 1000.0, bins=arange(0, 300, 5), histtype="step")
 ax_r.set_xlim(0, 100)
 ax_a.legend()
 

examples/08_tracking_manipulation/pet_run_a_tracking.py

@@ -28,17 +28,17 @@
 c.prepare_merging()
 # We have now an eddy object
 eddies_area_tracker = c.merge(raw_data=False)
-eddies_area_tracker["virtual"][:] = eddies_area_tracker["time"] == 0
-eddies_area_tracker.filled_by_interpolation(eddies_area_tracker["virtual"] == 1)
+eddies_area_tracker.virtual[:] = eddies_area_tracker.time == 0
+eddies_area_tracker.filled_by_interpolation(eddies_area_tracker.virtual == 1)
 
 # %%
 # We run a traking with default tracker
 c = Correspondances(datasets=file_objects, virtual=3)
 c.track()
 c.prepare_merging()
 eddies_default_tracker = c.merge(raw_data=False)
-eddies_default_tracker["virtual"][:] = eddies_default_tracker["time"] == 0
-eddies_default_tracker.filled_by_interpolation(eddies_default_tracker["virtual"] == 1)
+eddies_default_tracker.virtual[:] = eddies_default_tracker.time == 0
+eddies_default_tracker.filled_by_interpolation(eddies_default_tracker.virtual == 1)
 
 # %%
 # Start GUI to compare tracking

notebooks/python_module/02_eddy_identification/pet_filter_and_detection.ipynb

@@ -109,7 +109,7 @@
       },
       "outputs": [],
       "source": [
-        "fig = plt.figure(figsize=(12, 5))\nax_a = fig.add_subplot(121, xlabel=\"Amplitude (cm)\")\nax_r = fig.add_subplot(122, xlabel=\"Speed Radius (km)\")\nax_a.hist(\n    merge_f[\"amplitude\"] * 100,\n    bins=arange(0.0005, 100, 1),\n    label=\"Eddies in the filtered grid\",\n    histtype=\"step\",\n)\nax_a.hist(\n    merge_t[\"amplitude\"] * 100,\n    bins=arange(0.0005, 100, 1),\n    label=\"Eddies without filter\",\n    histtype=\"step\",\n)\nax_a.set_xlim(0, 10)\nax_r.hist(merge_f[\"radius_s\"] / 1000.0, bins=arange(0, 300, 5), histtype=\"step\")\nax_r.hist(merge_t[\"radius_s\"] / 1000.0, bins=arange(0, 300, 5), histtype=\"step\")\nax_r.set_xlim(0, 100)\nax_a.legend()"
+        "fig = plt.figure(figsize=(12, 5))\nax_a = fig.add_subplot(121, xlabel=\"Amplitude (cm)\")\nax_r = fig.add_subplot(122, xlabel=\"Speed Radius (km)\")\nax_a.hist(\n    merge_f.amplitude * 100,\n    bins=arange(0.0005, 100, 1),\n    label=\"Eddies in the filtered grid\",\n    histtype=\"step\",\n)\nax_a.hist(\n    merge_t.amplitude * 100,\n    bins=arange(0.0005, 100, 1),\n    label=\"Eddies without filter\",\n    histtype=\"step\",\n)\nax_a.set_xlim(0, 10)\nax_r.hist(merge_f.radius_s / 1000.0, bins=arange(0, 300, 5), histtype=\"step\")\nax_r.hist(merge_t.radius_s / 1000.0, bins=arange(0, 300, 5), histtype=\"step\")\nax_r.set_xlim(0, 100)\nax_a.legend()"
       ]
     },
     {
@@ -176,7 +176,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.7.6"
+      "version": "3.7.7"
     }
   },
   "nbformat": 4,

notebooks/python_module/08_tracking_manipulation/pet_run_a_tracking.ipynb

@@ -62,7 +62,7 @@
       },
       "outputs": [],
       "source": [
-        "c = Correspondances(datasets=file_objects, class_method=AreaTracker, virtual=3)\nc.track()\nc.prepare_merging()\n# We have now an eddy object\neddies_area_tracker = c.merge(raw_data=False)\neddies_area_tracker[\"virtual\"][:] = eddies_area_tracker[\"time\"] == 0\neddies_area_tracker.filled_by_interpolation(eddies_area_tracker[\"virtual\"] == 1)"
+        "c = Correspondances(datasets=file_objects, class_method=AreaTracker, virtual=3)\nc.track()\nc.prepare_merging()\n# We have now an eddy object\neddies_area_tracker = c.merge(raw_data=False)\neddies_area_tracker.virtual[:] = eddies_area_tracker.time == 0\neddies_area_tracker.filled_by_interpolation(eddies_area_tracker.virtual == 1)"
       ]
     },
     {
@@ -80,7 +80,7 @@
       },
       "outputs": [],
       "source": [
-        "c = Correspondances(datasets=file_objects, virtual=3)\nc.track()\nc.prepare_merging()\neddies_default_tracker = c.merge(raw_data=False)\neddies_default_tracker[\"virtual\"][:] = eddies_default_tracker[\"time\"] == 0\neddies_default_tracker.filled_by_interpolation(eddies_default_tracker[\"virtual\"] == 1)"
+        "c = Correspondances(datasets=file_objects, virtual=3)\nc.track()\nc.prepare_merging()\neddies_default_tracker = c.merge(raw_data=False)\neddies_default_tracker.virtual[:] = eddies_default_tracker.time == 0\neddies_default_tracker.filled_by_interpolation(eddies_default_tracker.virtual == 1)"
       ]
     },
     {

setup.cfg

@@ -10,3 +10,7 @@ versionfile_source = src/py_eddy_tracker/_version.py
 versionfile_build = py_eddy_tracker/_version.py
 tag_prefix =
 parentdir_prefix =
+
+[tool:pytest]
+filterwarnings=
+	ignore:tostring.*is deprecated

src/py_eddy_tracker/dataset/grid.py

@@ -551,15 +551,16 @@ def grid_tiles(self, varname, slice_x, slice_y):
 
     def high_filter(self, grid_name, w_cut, **kwargs):
         """Return the grid high-pass filtered, by substracting to the grid the low-pass filter (default: order=1)
+
         :param grid_name: the name of the grid
         :param int, w_cut: the half-power wavelength cutoff (km)
-
         """
         result = self._low_filter(grid_name, w_cut, **kwargs)
         self.vars[grid_name] -= result
 
     def low_filter(self, grid_name, w_cut, **kwargs):
         """Return the grid low-pass filtered (default: order=1)
+
         :param grid_name: the name of the grid
         :param int, w_cut: the half-power wavelength cutoff (km)
         """
@@ -804,28 +805,25 @@ def eddy_identification(
                         track_array_variables=sampling,
                         array_variables=array_variables,
                     )
-
-                    obs.obs["height_max_speed_contour"] = self.contours.cvalues[
-                        i_max_speed
-                    ]
-                    obs.obs["height_external_contour"] = cvalues
-                    obs.obs["height_inner_contour"] = self.contours.cvalues[i_inner]
+                    obs.height_max_speed_contour[:] = self.contours.cvalues[i_max_speed]
+                    obs.height_external_contour[:] = cvalues
+                    obs.height_inner_contour[:] = self.contours.cvalues[i_inner]
                     array_size = speed_array.shape[0]
-                    obs.obs["nb_contour_selected"] = array_size
+                    obs.nb_contour_selected[:] = array_size
                     if speed_array.shape[0] == 1:
-                        obs.obs["uavg_profile"][:] = speed_array[0]
+                        obs.uavg_profile[:] = speed_array[0]
                     else:
-                        obs.obs["uavg_profile"] = raw_resample(speed_array, sampling)
-                    obs.obs["amplitude"] = amp.amplitude
-                    obs.obs["speed_average"] = max_average_speed
-                    obs.obs["num_point_e"] = contour.lon.shape[0]
+                        obs.uavg_profile[:] = raw_resample(speed_array, sampling)
+                    obs.amplitude[:] = amp.amplitude
+                    obs.speed_average[:] = max_average_speed
+                    obs.num_point_e[:] = contour.lon.shape[0]
                     xy_e = uniform_resample(contour.lon, contour.lat, **out_sampling)
-                    obs.obs["contour_lon_e"], obs.obs["contour_lat_e"] = xy_e
-                    obs.obs["num_point_s"] = speed_contour.lon.shape[0]
+                    obs.contour_lon_e[:], obs.contour_lat_e[:] = xy_e
+                    obs.num_point_s[:] = speed_contour.lon.shape[0]
                     xy_s = uniform_resample(
                         speed_contour.lon, speed_contour.lat, **out_sampling
                     )
-                    obs.obs["contour_lon_s"], obs.obs["contour_lat_s"] = xy_s
+                    obs.contour_lon_s[:], obs.contour_lat_s[:] = xy_s
 
                     # FIXME : we use a contour without resampling
                     # First, get position based on innermost contour
@@ -841,20 +839,20 @@ def eddy_identification(
                         create_vertice(*xy_e)
                     )
 
-                    obs.obs["radius_s"] = eddy_radius_s
-                    obs.obs["radius_e"] = eddy_radius_e
-                    obs.obs["shape_error_e"] = aerr_e
-                    obs.obs["shape_error_s"] = aerr_s
-                    obs.obs["speed_area"] = poly_area(
+                    obs.radius_s[:] = eddy_radius_s
+                    obs.radius_e[:] = eddy_radius_e
+                    obs.shape_error_e[:] = aerr_e
+                    obs.shape_error_s[:] = aerr_s
+                    obs.speed_area[:] = poly_area(
                         *coordinates_to_local(*xy_s, lon0=centlon_s, lat0=centlat_s)
                     )
-                    obs.obs["effective_area"] = poly_area(
+                    obs.effective_area[:] = poly_area(
                         *coordinates_to_local(*xy_e, lon0=centlon_s, lat0=centlat_s)
                     )
-                    obs.obs["lon"] = centlon_s
-                    obs.obs["lat"] = centlat_s
-                    obs.obs["lon_max"] = centlon_i
-                    obs.obs["lat_max"] = centlat_i
+                    obs.lon[:] = centlon_s
+                    obs.lat[:] = centlat_s
+                    obs.lon_max[:] = centlon_i
+                    obs.lat_max[:] = centlat_i
                     if aerr > 99.9 or aerr_s > 99.9:
                         logger.warning(
                             "Strange shape at this step! shape_error : %f, %f",
@@ -874,18 +872,14 @@ def eddy_identification(
             else:
                 eddies = EddiesObservations.concatenate(eddies)
             eddies.sign_type = 1 if anticyclonic_search else -1
-            eddies.obs["time"] = (date - datetime(1950, 1, 1)).total_seconds() / 86400.0
+            eddies.time[:] = (date - datetime(1950, 1, 1)).total_seconds() / 86400.0
 
             # normalization longitude between 0 - 360, because storage have an offset on 180
-            eddies.obs["lon_max"] %= 360
-            eddies.obs["lon"] %= 360
-            ref = eddies.obs["lon"] - 180
-            eddies.obs["contour_lon_e"] = (
-                (eddies.obs["contour_lon_e"].T - ref) % 360 + ref
-            ).T
-            eddies.obs["contour_lon_s"] = (
-                (eddies.obs["contour_lon_s"].T - ref) % 360 + ref
-            ).T
+            eddies.lon_max[:] %= 360
+            eddies.lon[:] %= 360
+            ref = eddies.lon - 180
+            eddies.contour_lon_e[:] = ((eddies.contour_lon_e.T - ref) % 360 + ref).T
+            eddies.contour_lon_s[:] = ((eddies.contour_lon_s.T - ref) % 360 + ref).T
             a_and_c.append(eddies)
 
         if in_h_unit is not None:

src/py_eddy_tracker/featured_tracking/old_tracker_reference.py

@@ -22,13 +22,7 @@ def mask_function(self, other, distance):
         # Compute Parameter of ellips
         minor, major = 1.05, 1.5
         y = self.basic_formula_ellips_major_axis(
-            self.obs["lat"],
-            degrees=True,
-            c0=minor,
-            cmin=minor,
-            cmax=major,
-            lat1=23,
-            lat2=5,
+            self.lat, degrees=True, c0=minor, cmin=minor, cmax=major, lat1=23, lat2=5,
         )
         # mask from ellips
         mask = self.shifted_ellipsoid_degrees_mask(
@@ -37,11 +31,7 @@ def mask_function(self, other, distance):
 
         # We check ratio (maybe not usefull)
         check_ratio(
-            mask,
-            self.obs["amplitude"],
-            other.obs["amplitude"],
-            self.obs["radius_e"],
-            other.obs["radius_e"],
+            mask, self.amplitude, other.amplitude, self.radius_e, other.radius_e,
         )
         indexs_closest = where(mask)
         mask[indexs_closest] = self.across_ground(
@@ -76,7 +66,7 @@ def post_process_link(self, other, i_self, i_other):
             for i in where(nb_link > 1)[0]:
                 m = i == i_other
                 multiple_in = i_self[m]
-                i_keep = self.obs["amplitude"][multiple_in].argmax()
+                i_keep = self.amplitude[multiple_in].argmax()
                 m[where(m)[0][i_keep]] = False
                 mask[m] = False
 

src/py_eddy_tracker/observations/network.py

@@ -116,7 +116,7 @@ def build_dataset(self, group):
         if display_iteration:
             print()
         eddies = eddies.add_fields(("track",))
-        eddies.obs["track"][new_i] = group
+        eddies.track[new_i] = group
         return eddies