Change name of files

Author: adelepoulle

src/py_eddy_tracker/grid/__init__.py

@@ -5,7 +5,7 @@
 from pyproj import Proj
 import numpy as np
 import logging
-from ..make_eddy_tracker_list_obj import nearest
+from ..tracking_objects import nearest
 
 
 class PyEddyTracker(object):

src/py_eddy_tracker/py_eddy_tracker_classes.py renamed to src/py_eddy_tracker/property_functions.py

@@ -33,8 +33,9 @@
 import numpy as np
 from datetime import datetime
 from pyproj import Proj
-from .make_eddy_tracker_list_obj import uniform_resample, nearest
-from .py_eddy_tracker_property_classes import Amplitude, EddiesObservations
+from .tracking_objects import uniform_resample, nearest
+from .observations import EddiesObservations
+from .property_objects import Amplitude
 from .tools import distance, winding_number_poly, fit_circle_c
 from matplotlib.path import Path as BasePath
 from scipy.interpolate import griddata
@@ -415,7 +416,11 @@ def collection_loop(contours, grd, rtime, a_list_obj, c_list_obj,
                     continue
 
             # Instantiate new EddyObservation object
-            properties = EddiesObservations(size=1)
+            properties = EddiesObservations(
+                size=1,
+                track_array_variables=eddy.track_array_variables_sampling,
+                array_variables=eddy.track_array_variables
+                )
 
             # Set indices to bounding box around eddy
             eddy.set_bounds(cont.lon, cont.lat, grd)
@@ -467,9 +472,8 @@ def collection_loop(contours, grd, rtime, a_list_obj, c_list_obj,
                     args = (eddy, contours, centlon_e, centlat_e, cont, grd,
                             anticyclonic_search)
 
-                    #~ if eddy.track_array_variables > 10:
-                        #~ print ':)'
-                        #~ exit()
+                    #~ if eddy.track_array_variables > 0:
+                        
                     if not eddy.track_extra_variables:
                         # (uavg, centlon_s, centlat_s,
                         # eddy_radius_s, contlon_s, contlat_s,
@@ -518,6 +522,14 @@ def collection_loop(contours, grd, rtime, a_list_obj, c_list_obj,
                     # See CSS11 section B4
                     properties.obs['lon'] = centlon_s
                     properties.obs['lat'] = centlat_s
+                    if 'contour_lon' in eddy.track_array_variables:
+                        properties.obs['contour_lon'], properties.obs['contour_lat'] = uniform_resample(
+                            cont.lon, cont.lat,
+                            fixed_size=eddy.track_array_variables_sampling)
+                    if 'contour_lon_s' in eddy.track_array_variables:
+                        properties.obs['contour_lon_s'], properties.obs['contour_lat_s'] = uniform_resample(
+                            contlon_s, contlat_s,
+                            fixed_size=eddy.track_array_variables_sampling)
 
                     if not has_ts:  # for AVISO
                         eddy.update_eddy_properties(properties)

src/py_eddy_tracker/py_eddy_tracker_property_classes.py renamed to src/py_eddy_tracker/property_objects.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-
 """
 ===========================================================================
 This file is part of py-eddy-tracker.
@@ -37,171 +36,21 @@
 from netCDF4 import Dataset
 from .tools import index_from_nearest_path, distance_matrix
 from . import VAR_DESCR, VAR_DESCR_inv
+from .observations import EddiesObservations
 import logging
 
 
-class EddiesObservations(object):
-    """
-    Class to hold eddy properties *amplitude* and counts of
-    *local maxima/minima* within a closed region of a sea level anomaly field.
-
-    Variables:
-      centlon:
-        Longitude centroid coordinate
-
-      centlat:
-        Latitude centroid coordinate
-
-      eddy_radius_s:
-        Speed based radius
-
-      eddy_radius_e:
-        Effective radius
-
-      amplitude:
-        Eddy amplitude
-
-      uavg:
-        Average eddy swirl speed
-
-      teke:
-        Average eddy kinetic energy within eddy
-
-      rtime:
-        Time
+class VirtualEddiesObservations(EddiesObservations):
+    """Class to work with virtual obs
     """
 
-    def __init__(self, size=0, track_extra_variables=False):
-        self.track_extra_variables = track_extra_variables
-        for elt in self.elements:
-            if elt not in VAR_DESCR:
-                raise Exception('Unknown element : %s' % elt)
-        self.observations = np.zeros(size, dtype=self.dtype)
-        self.active = True
-        self.sign_type = None
-
-    def __repr__(self):
-        return str(self.observations)
-
-    @property
-    def dtype(self):
-        dtype = list()
-        for elt in self.elements:
-            dtype.append((elt, VAR_DESCR[elt][
-                'compute_type' if 'compute_type' in VAR_DESCR[elt] else
-                'nc_type']))
-        return dtype
-
-    @property
-    def elements(self):
-        elements = [
-            'lon',  # 'centlon'
-            'lat',  # 'centlat'
-            'radius_s',  # 'eddy_radius_s'
-            'radius_e',  # 'eddy_radius_e'
-            'amplitude',  # 'amplitude'
-            'speed_radius',  # 'uavg'
-            'eke',  # 'teke'
-            'time']  # 'rtime'
-
-        if self.track_extra_variables:
-            elements += ['contour_e',
-                         'contour_s',
-                         'uavg_profile',
-                         'shape_error',
-                         ]
-        return elements
-
-    def coherence(self, other):
-        return self.track_extra_variables == other.track_extra_variables
-    
-    def merge(self, other):
-        nb_obs_self = len(self)
-        nb_obs = nb_obs_self + len(other)
-        eddies = self.__class__(size=nb_obs)
-        eddies.obs[:nb_obs_self] = self.obs[:]
-        eddies.obs[nb_obs_self:] = other.obs[:]
-        eddies.sign_type = self.sign_type
-        return eddies
-
-    def reset(self):
-        self.observations = np.zeros(0, dtype=self.dtype)
-
-    @property
-    def obs(self):
-        return self.observations
-
-    def __len__(self):
-        return len(self.observations)
-
-    def __iter__(self):
-        for obs in self.obs:
-            yield obs
-
-    def insert_observations(self, other, index):
-        if not self.coherence(other):
-            raise Exception('Observations with no coherence')
-        insert_size = len(other.obs)
-        self_size = len(self.obs)
-        new_size = self_size + insert_size
-        if self_size == 0:
-            self.observations = other.obs
-            return self
-        elif insert_size == 0:
-            return self
-        if index < 0:
-            index = self_size + index + 1
-        eddies = self.__class__(new_size, self.track_extra_variables)
-        eddies.obs[:index] = self.obs[:index]
-        eddies.obs[index: index + insert_size] = other.obs
-        eddies.obs[index + insert_size:] = self.obs[index:]
-        self.observations = eddies.obs
-        return self
-
-    def append(self, other):
-        return self + other
-
-    def __add__(self, other):
-        return self.insert_observations(other, -1)
-
-    def distance_matrix(self, other):
-        """ Use haversine distance for distance matrix between every old and
-        new eddy"""
-        dist_mat = np.empty((len(self), len(other)))
-        distance_matrix(self.obs['lon'], self.obs['lat'],
-                        other.obs['lon'], other.obs['lat'],
-                        dist_mat)
-        return dist_mat
-
-    def index(self, index):
-        size = 1
-        if hasattr(index, '__iter__'):
-            size = len(index)
-        eddies = self.__class__(size, self.track_extra_variables)
-        eddies.obs[:] = self.obs[index]
-        return eddies
-    
-    @staticmethod
-    def load_from_netcdf(filename):
-        with Dataset(filename) as h_nc:
-            nb_obs = len(h_nc.dimensions['Nobs'])
-            eddies = EddiesObservations(size=nb_obs)
-            for variable in h_nc.variables:
-                if variable == 'cyc':
-                    continue
-                eddies.obs[VAR_DESCR_inv[variable]] = h_nc.variables[variable][:]
-            eddies.sign_type = h_nc.variables['cyc'][0]
-        return eddies
-
-
-class VirtualEddiesObservations(EddiesObservations):
-    
     @property
     def elements(self):
         elements = super(VirtualEddiesObservations, self).elements
         elements.extend(['track', 'segment_size', 'dlon', 'dlat'])
         return elements
-    
+
+
 class TrackEddiesObservations(EddiesObservations):
 
     def extract_longer_eddies(self, nb_min, nb_obs):

src/py_eddy_tracker/make_eddy_tracker_list_obj.py renamed to src/py_eddy_tracker/tracking_objects.py

@@ -42,7 +42,7 @@
 from . import VAR_DESCR
 import numpy as np
 import logging
-from .py_eddy_tracker_property_classes import EddiesObservations
+from .observations import EddiesObservations
 
 
 def nearest(lon_pt, lat_pt, lon2d, lat2d):
@@ -65,7 +65,8 @@ def nearest(lon_pt, lat_pt, lon2d, lat2d):
     return i_x, i_y
 
 
-def uniform_resample(x_val, y_val, **kwargs):
+def uniform_resample(x_val, y_val, method='interp1d', extrapolate=None,
+        num_fac=2, fixed_size=None):
     """
     Resample contours to have (nearly) equal spacing
        x_val, y_val    : input contour coordinates
@@ -74,20 +75,18 @@ def uniform_resample(x_val, y_val, **kwargs):
                  (Akima is slightly slower, but may be more accurate)
        extrapolate : IS NOT RELIABLE (sometimes nans occur)
     """
-    method = kwargs.get('method', 'interp1d')
-    extrapolate = kwargs.get('extrapolate', None)
-    num_fac = kwargs.get('num_fac', 2)
-
     # Get distances
     dist = np.empty_like(x_val)
     dist[0] = 0
     distance_vector(
         x_val[:-1], y_val[:-1], x_val[1:], y_val[1:], dist[1:])
     dist.cumsum(out=dist)
     # Get uniform distances
+    if fixed_size is None:
+        fixed_size = dist.size * num_fac
     d_uniform = np.linspace(0,
                             dist[-1],
-                            num=dist.size * num_fac,
+                            num=fixed_size,
                             endpoint=True)
 
     # Do 1d interpolations
@@ -478,11 +477,14 @@ def set_global_attr_netcdf(
         h_nc.evolve_area_max = self.evolve_area_max
 
     def create_variable(self, handler_nc, kwargs_variable,
-                        attr_variable):
+                        attr_variable, scale_factor=None):
         var = handler_nc.createVariable(
             zlib=True,
             complevel=1,
             **kwargs_variable)
+        if scale_factor is not None:
+            var.scale_factor = scale_factor
+            print scale_factor, kwargs_variable
         for attr, attr_value in attr_variable.iteritems():
             var.setncattr(attr, attr_value)
 #         var.setncattr('min', var[:].min())
@@ -540,7 +542,8 @@ def create_netcdf(self, directory, savedir, grd=None, ymin=None, ymax=None,
                 dict(varname=VAR_DESCR[key_name]['nc_name'],
                      datatype=VAR_DESCR[key_name]['nc_type'],
                      dimensions=VAR_DESCR[key_name]['nc_dims']),
-                VAR_DESCR[key_name]['nc_attr']
+                VAR_DESCR[key_name]['nc_attr'],
+                scale_factor=VAR_DESCR[key_name].get('scale_factor', None)
                 )
         h_nc.close()
 
@@ -701,7 +704,11 @@ def __init__(self, sign_type, grd, date, **kwargs):
 
         self.sla = None
 
-        self.observations = EddiesObservations(self.track_extra_variables)
+        self.observations = EddiesObservations(
+            track_array_variables=self.track_array_variables_sampling,
+            array_variables=self.track_array_variables
+            )
+
         self.index = 0  # counter
         self.pad = 2
         self.pixel_threshold = None
@@ -750,18 +757,20 @@ def set_global_attr_netcdf(self, h_nc):
         h_nc.urcrnrlat = self.grd.latmax
 
     def create_variable(self, handler_nc, kwargs_variable,
-                        attr_variable, data, scale_factor=None):
+                        attr_variable, data, scale_factor=None, add_offset=None):
         var = handler_nc.createVariable(
             zlib=True,
             complevel=1,
             **kwargs_variable)
         for attr, attr_value in attr_variable.iteritems():
             var.setncattr(attr, attr_value)
-            var[:] = data
-            var.set_auto_maskandscale(False)
-            if scale_factor is not None:
-                var.scale_factor = scale_factor
-            
+        if scale_factor is not None:
+            var.scale_factor = scale_factor
+            if add_offset is not None:
+                var.add_offset = add_offset
+            else:
+                var.add_offset = 0
+        var[:] = data
         try:
             var.setncattr('min', var[:].min())
             var.setncattr('max', var[:].max())
@@ -779,17 +788,22 @@ def write_netcdf(self, path='./'):
             # Create dimensions
             logging.debug('Create Dimensions "Nobs" : %d', eddy_size)
             h_nc.createDimension('Nobs', eddy_size)
+            if self.track_array_variables_sampling != 0:
+                h_nc.createDimension('NbSample', self.track_array_variables_sampling)
             # Iter on variables to create:
-            for name, _ in self.observations.dtype:
+            for dtype in self.observations.dtype:
+                name = dtype[0]
                 logging.debug('Create Variable %s', VAR_DESCR[name]['nc_name'])
                 self.create_variable(
                     h_nc,
                     dict(varname=VAR_DESCR[name]['nc_name'],
-                         datatype=VAR_DESCR[name]['nc_type'],
+                         datatype=VAR_DESCR[name]['output_type'],
                          dimensions=VAR_DESCR[name]['nc_dims']),
                     VAR_DESCR[name]['nc_attr'],
                     self.observations.obs[name],
-                    scale_factor=None if 'scale_factor' not in VAR_DESCR[name] else VAR_DESCR[name]['scale_factor'])
+                    scale_factor=VAR_DESCR[name].get('scale_factor', None),
+                    add_offset=VAR_DESCR[name].get('add_offset', None)
+                    )
 
             # Add cyclonic information
             self.create_variable(

src/scripts/EddyIdentification

@@ -36,11 +36,11 @@ from multiprocessing import Pool
 import numpy as np
 
 from py_eddy_tracker import EddyParser
-from py_eddy_tracker.py_eddy_tracker_classes import \
+from py_eddy_tracker.property_functions import \
     collection_loop, func_hann2d_fast
-from py_eddy_tracker.py_eddy_tracker_property_classes import SwirlSpeed
+from py_eddy_tracker.property_objects import SwirlSpeed
 from py_eddy_tracker.grid.aviso import AvisoGrid
-from py_eddy_tracker.make_eddy_tracker_list_obj import IdentificationList
+from py_eddy_tracker.tracking_objects import IdentificationList
 
 
 def circle_process(paths):