From bb798c7c06ae599f0ac2f2402b08f39eec2c6923 Mon Sep 17 00:00:00 2001 From: Alba Vilanova Cortezon Date: Fri, 12 May 2023 13:46:40 +0200 Subject: [PATCH 1/9] Rotated nested, changed new and documentation --- CHANGELOG.md | 8 + nes/create_nes.py | 11 +- nes/nc_projections/__init__.py | 1 + nes/nc_projections/default_nes.py | 34 +++-- nes/nc_projections/latlon_nes.py | 98 +++++++++---- nes/nc_projections/lcc_nes.py | 79 +++++++--- nes/nc_projections/mercator_nes.py | 77 +++++++--- nes/nc_projections/points_nes.py | 46 ++++-- nes/nc_projections/points_nes_ghost.py | 35 ++--- nes/nc_projections/points_nes_providentia.py | 36 ++--- nes/nc_projections/rotated_nes.py | 76 +++++++--- nes/nc_projections/rotated_nested_nes.py | 147 +++++++++++++++++++ 12 files changed, 487 insertions(+), 161 deletions(-) create mode 100644 nes/nc_projections/rotated_nested_nes.py diff --git a/CHANGELOG.md b/CHANGELOG.md index cee701d..75c131f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # NES CHANGELOG +### 1.1.3 +* Release date: Unknown +* Changes and new features: + * Rotated nested projection + * Improved documentation + * Bugs fixing: + * The input arguments in function new() have been corrected + ### 1.1.2 * Release date: 2023/05/15 * Changes and new features: diff --git a/nes/create_nes.py b/nes/create_nes.py index c10dd67..7444bb5 100644 --- a/nes/create_nes.py +++ b/nes/create_nes.py @@ -34,8 +34,6 @@ def create_nes(comm=None, info=False, projection=None, parallel_method='Y', bala Index of the first level to use. last_level : int, None Index of the last level to use. None if it is the last. - kwargs : - Projection dependent parameters to create it from scratch. """ if comm is None: @@ -66,6 +64,8 @@ def create_nes(comm=None, info=False, projection=None, parallel_method='Y', bala required_vars = ['inc_lat', 'inc_lon'] elif projection == 'rotated': required_vars = ['centre_lat', 'centre_lon', 'west_boundary', 'south_boundary', 'inc_rlat', 'inc_rlon'] + elif projection == 'rotated-nested': + required_vars = ['parent_grid_path', 'parent_ratio', 'i_parent_start', 'j_parent_start', 'n_rlat', 'n_rlon'] elif projection == 'lcc': required_vars = ['lat_1', 'lat_2', 'lon_0', 'lat_0', 'nx', 'ny', 'inc_x', 'inc_y', 'x_0', 'y_0'] elif projection == 'mercator': @@ -106,6 +106,11 @@ def create_nes(comm=None, info=False, projection=None, parallel_method='Y', bala avoid_first_hours=avoid_first_hours, avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, balanced=balanced, create_nes=True, times=times, **kwargs) + elif projection == 'rotated-nested': + nessy = RotatedNestedNes(comm=comm, dataset=None, xarray=False, info=info, parallel_method=parallel_method, + avoid_first_hours=avoid_first_hours, avoid_last_hours=avoid_last_hours, + first_level=first_level, last_level=last_level, balanced=balanced, + create_nes=True, times=times, **kwargs) elif projection == 'lcc': nessy = LCCNes(comm=comm, dataset=None, xarray=False, info=info, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, avoid_last_hours=avoid_last_hours, @@ -139,8 +144,6 @@ def from_shapefile(path, method=None, parallel_method='Y', **kwargs): parallel_method : str Indicates the parallelization method that you want. Default: 'Y'. accepted values: ['X', 'Y', 'T']. - kwargs : - Projection and projection dependent parameters to create it from scratch. """ # Create NES diff --git a/nes/nc_projections/__init__.py b/nes/nc_projections/__init__.py index fc6bc15..d4c4b9f 100644 --- a/nes/nc_projections/__init__.py +++ b/nes/nc_projections/__init__.py @@ -1,6 +1,7 @@ from .default_nes import Nes from .latlon_nes import LatLonNes from .rotated_nes import RotatedNes +from .rotated_nested_nes import RotatedNestedNes from .points_nes import PointsNes from .points_nes_ghost import PointsNesGHOST from .points_nes_providentia import PointsNesProvidentia diff --git a/nes/nc_projections/default_nes.py b/nes/nc_projections/default_nes.py index 4b99cab..eb8e1a0 100644 --- a/nes/nc_projections/default_nes.py +++ b/nes/nc_projections/default_nes.py @@ -84,6 +84,11 @@ class Nes(object): Name of the dimensions of the Latitude values. _lon_dim : None or tuple Name of the dimensions of the Longitude values. + projection : pyproj.Proj + Grid projection. + projection_data : dict + Dictionary with the projection information. + """ def __init__(self, comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='Y', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, @@ -106,9 +111,6 @@ class Nes(object): parallel_method : str Indicates the parallelization method that you want. Default over Y axis accepted values: ['X', 'Y', 'T']. - balanced : bool - Indicates if you want a balanced parallelization or not. - Balanced dataset cannot be written in chunking mode. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int @@ -119,10 +121,11 @@ class Nes(object): Index of the last level to use. None if it is the last. create_nes : bool Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. times : List[datetime] or None List of times to substitute the current ones while creation. - kwargs : - Projection dependent parameters to create it from scratch """ # MPI Initialization @@ -276,8 +279,9 @@ class Nes(object): self.first_level = None @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create_nes=False, balanced=False, - parallel_method='Y', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='Y', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, + balanced=False, times=None, **kwargs): """ Initialize the Nes class. @@ -293,27 +297,29 @@ class Nes(object): NetCDF4-python Dataset to initialize the class. xarray: bool (Not working) Indicates if you want to use xarray as default. + parallel_method : str + Indicates the parallelization method that you want. Default over Y axis + accepted values: ['X', 'Y', 'T']. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - parallel_method : str - Indicates the parallelization method that you want. Default over Y axis - accepted values: ['X', 'Y', 'T']. - balanced : bool - Indicates if you want a balanced parallelization or not. - Balanced dataset cannot be written in chunking mode. first_level : int Index of the first level to use. last_level : int or None Index of the last level to use. None if it is the last. create_nes : bool Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : List[datetime] or None + List of times to substitute the current ones while creation. """ new = Nes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, avoid_last_hours=avoid_last_hours, first_level=first_level, - last_level=last_level, create=create_nes, balanced=balanced) + last_level=last_level, create_nes=create_nes, balanced=balanced, times=times, **kwargs) return new diff --git a/nes/nc_projections/latlon_nes.py b/nes/nc_projections/latlon_nes.py index 43a37a8..4b38959 100644 --- a/nes/nc_projections/latlon_nes.py +++ b/nes/nc_projections/latlon_nes.py @@ -45,6 +45,17 @@ class LatLonNes(Nes): Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. """ super(LatLonNes, self).__init__(comm=comm, path=path, info=info, dataset=dataset, @@ -68,8 +79,9 @@ class LatLonNes(Nes): self.free_vars('crs') @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create=False, balanced=False, - parallel_method='Y', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='Y', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, + balanced=False, times=None, **kwargs): """ Initialize the Nes class. @@ -85,19 +97,31 @@ class LatLonNes(Nes): NetCDF4-python Dataset to initialize the class. xarray: bool: (Not working) Indicates if you want to use xarray as default. + parallel_method : str + Indicates the parallelization method that you want. Default: 'Y'. + Accepted values: ['X', 'Y', 'T']. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - parallel_method : str - Indicates the parallelization method that you want. Default: 'Y'. - Accepted values: ['X', 'Y', 'T']. + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. """ - new = LatLonNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, balanced=balanced, - parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, - avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level) - + new = LatLonNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, + parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, + avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, + create_nes=create_nes, balanced=balanced, times=times, **kwargs) + return new def _get_pyproj_projection(self): @@ -126,8 +150,8 @@ class LatLonNes(Nes): self.free_vars('crs') else: projection_data = {'grid_mapping_name': 'latitude_longitude', - 'semi_major_axis': str(self.earth_radius[1]), - 'inverse_flattening': str(0), + 'semi_major_axis': self.earth_radius[1], + 'inverse_flattening': 0, } if 'dtype' in projection_data.keys(): @@ -150,9 +174,24 @@ class LatLonNes(Nes): """ projection_data = {'grid_mapping_name': 'latitude_longitude', - 'semi_major_axis': str(self.earth_radius[1]), - 'inverse_flattening': str(0), + 'semi_major_axis': self.earth_radius[1], + 'inverse_flattening': 0, + 'inc_lat': kwargs['inc_lat'], + 'inc_lon': kwargs['inc_lon'], + } + # Global domain + if len(kwargs) == 2: + projection_data['lat_orig'] = -90 + projection_data['lon_orig'] = -180 + projection_data['n_lat'] = int(180 // np.float64(projection_data['inc_lat'])) + projection_data['n_lon'] = int(360 // np.float64(projection_data['inc_lon'])) + # Other domains + else: + projection_data['lat_orig'] = kwargs['lat_orig'] + projection_data['lon_orig'] = kwargs['lon_orig'] + projection_data['n_lat'] = kwargs['n_lat'] + projection_data['n_lon'] = kwargs['n_lon'] self.projection_data = projection_data self.projection = self._get_pyproj_projection() @@ -189,30 +228,29 @@ class LatLonNes(Nes): Dictionary with data of centre longitudes in 1D """ - inc_lat = kwargs['inc_lat'] - inc_lon = kwargs['inc_lon'] + # Get grid resolution + inc_lat = np.float64(self.projection_data['inc_lat']) + inc_lon = np.float64(self.projection_data['inc_lon']) - # Global domain - if len(kwargs) == 2: - lat_orig = -90 - lon_orig = -180 - n_lat = int(180 // inc_lat) - n_lon = int(360 // inc_lon) - - # Other domains - else: - lat_orig = kwargs['lat_orig'] - lon_orig = kwargs['lon_orig'] - n_lat = kwargs['n_lat'] - n_lon = kwargs['n_lon'] + # Get coordinates origen + lat_orig = np.float64(self.projection_data['lat_orig']) + lon_orig = np.float64(self.projection_data['lon_orig']) + + # Get number of coordinates + n_lat = int(self.projection_data['n_lat']) + n_lon = int(self.projection_data['n_lon']) # Calculate centre latitudes lat_c_orig = lat_orig + (inc_lat / 2) - centre_lat = np.linspace(lat_c_orig, lat_c_orig + (inc_lat * (n_lat - 1)), n_lat) + centre_lat = np.linspace(lat_c_orig, + lat_c_orig + (inc_lat * (n_lat - 1)), + n_lat, dtype=np.float64) # Calculate centre longitudes lon_c_orig = lon_orig + (inc_lon / 2) - centre_lon = np.linspace(lon_c_orig, lon_c_orig + (inc_lon * (n_lon - 1)), n_lon) + centre_lon = np.linspace(lon_c_orig, + lon_c_orig + (inc_lon * (n_lon - 1)), + n_lon, dtype=np.float64) return {'data': centre_lat}, {'data': centre_lon} diff --git a/nes/nc_projections/lcc_nes.py b/nes/nc_projections/lcc_nes.py index cf48cad..536bd3c 100644 --- a/nes/nc_projections/lcc_nes.py +++ b/nes/nc_projections/lcc_nes.py @@ -60,6 +60,17 @@ class LCCNes(Nes): Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. """ super(LCCNes, self).__init__(comm=comm, path=path, info=info, dataset=dataset, @@ -91,8 +102,9 @@ class LCCNes(Nes): self.free_vars('crs') @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create=False, balanced=False, - parallel_method='Y', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='Y', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, + balanced=False, times=None, **kwargs): """ Initialize the Nes class. @@ -108,19 +120,31 @@ class LCCNes(Nes): NetCDF4-python Dataset to initialize the class. xarray: bool: (Not working) Indicates if you want to use xarray as default. + parallel_method : str + Indicates the parallelization method that you want. Default: 'Y'. + Accepted values: ['X', 'Y', 'T']. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - parallel_method : str - Indicates the parallelization method that you want. Default: 'Y'. - Accepted values: ['X', 'Y', 'T']. - """ - - new = LCCNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, balanced=balanced, + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. + """ + + new = LCCNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, - avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level) - + avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, + create_nes=create_nes, balanced=balanced, times=times, **kwargs) + return new def filter_coordinates_selection(self): @@ -207,9 +231,13 @@ class LCCNes(Nes): """ projection_data = {'grid_mapping_name': 'lambert_conformal_conic', - 'standard_parallel': [str(kwargs['lat_1']), str(kwargs['lat_2'])], - 'longitude_of_central_meridian': str(kwargs['lon_0']), - 'latitude_of_projection_origin': str(kwargs['lat_0']), + 'standard_parallel': [kwargs['lat_1'], kwargs['lat_2']], + 'longitude_of_central_meridian': kwargs['lon_0'], + 'latitude_of_projection_origin': kwargs['lat_0'], + 'x_0': kwargs['x_0'], 'y_0': kwargs['y_0'], + 'inc_x': kwargs['inc_x'], 'inc_y': kwargs['inc_y'], + 'nx': kwargs['nx'], 'ny': kwargs['ny'], + } self.projection_data = projection_data @@ -287,15 +315,24 @@ class LCCNes(Nes): NetCDF object. """ + # Get projection details on x + x_0 = np.float64(self.projection_data['x_0']) + inc_x = np.float64(self.projection_data['inc_x']) + nx = int(self.projection_data['nx']) + + # Get projection details on y + y_0 = np.float64(self.projection_data['y_0']) + inc_y = np.float64(self.projection_data['inc_y']) + ny = int(self.projection_data['ny']) + # Create a regular grid in metres (1D) - self._x = {'data': np.linspace(kwargs['x_0'] + (kwargs['inc_x'] / 2), - kwargs['x_0'] + (kwargs['inc_x'] / 2) + - (kwargs['inc_x'] * (kwargs['nx'] - 1)), kwargs['nx'], - dtype=np.float64)} - self._y = {'data': np.linspace(kwargs['y_0'] + (kwargs['inc_y'] / 2), - kwargs['y_0'] + (kwargs['inc_y'] / 2) + - (kwargs['inc_y'] * (kwargs['ny'] - 1)), kwargs['ny'], - dtype=np.float64)} + self._x = {'data': np.linspace(x_0 + (inc_x / 2), + x_0 + (inc_x / 2) + (inc_x * (nx - 1)), + nx, dtype=np.float64)} + self._y = {'data': np.linspace(y_0 + (inc_y / 2), + y_0 + (inc_y / 2) + (inc_y * (ny - 1)), + ny, dtype=np.float64)} + # Create a regular grid in metres (1D to 2D) x = np.array([self._x['data']] * len(self._y['data'])) diff --git a/nes/nc_projections/mercator_nes.py b/nes/nc_projections/mercator_nes.py index 3b74b39..7845566 100644 --- a/nes/nc_projections/mercator_nes.py +++ b/nes/nc_projections/mercator_nes.py @@ -60,6 +60,18 @@ class MercatorNes(Nes): Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + times : list, None + List of times to substitute the current ones while creation. + """ super(MercatorNes, self).__init__(comm=comm, path=path, info=info, dataset=dataset, @@ -91,8 +103,9 @@ class MercatorNes(Nes): self.free_vars('crs') @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create=False, balanced=False, - parallel_method='Y', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='Y', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, + balanced=False, times=None, **kwargs): """ Initialize the Nes class. @@ -108,19 +121,31 @@ class MercatorNes(Nes): NetCDF4-python Dataset to initialize the class. xarray: bool: (Not working) Indicates if you want to use xarray as default. + parallel_method : str + Indicates the parallelization method that you want. Default: 'Y'. + Accepted values: ['X', 'Y', 'T']. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - parallel_method : str - Indicates the parallelization method that you want. Default: 'Y'. - Accepted values: ['X', 'Y', 'T']. - """ - - new = MercatorNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, balanced=balanced, + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. + """ + + new = MercatorNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, - avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level) - + avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, + create_nes=create_nes, balanced=balanced, times=times, **kwargs) + return new def filter_coordinates_selection(self): @@ -192,9 +217,13 @@ class MercatorNes(Nes): """ projection_data = {'grid_mapping_name': 'mercator', - 'standard_parallel': str(kwargs['lat_ts']), # TODO: Check if True + 'standard_parallel': kwargs['lat_ts'], # TODO: Check if True 'longitude_of_projection_origin': kwargs['lon_0'], - } + 'x_0': kwargs['x_0'], 'y_0': kwargs['y_0'], + 'inc_x': kwargs['inc_x'], 'inc_y': kwargs['inc_y'], + 'nx': kwargs['nx'], 'ny': kwargs['ny'], + } + self.projection_data = projection_data self.projection = self._get_pyproj_projection() @@ -266,17 +295,23 @@ class MercatorNes(Nes): Calculate centre latitudes and longitudes from grid details. """ - # Create a regular grid in metres (1D) - self._x = {'data': np.linspace(kwargs['x_0'] + (kwargs['inc_x'] / 2), - kwargs['x_0'] + (kwargs['inc_x'] / 2) + - (kwargs['inc_x'] * (kwargs['nx'] - 1)), kwargs['nx'], - dtype=np.float64)} + # Get projection details on x + x_0 = np.float64(self.projection_data['x_0']) + inc_x = np.float64(self.projection_data['inc_x']) + nx = int(self.projection_data['nx']) + # Get projection details on y + y_0 = np.float64(self.projection_data['y_0']) + inc_y = np.float64(self.projection_data['inc_y']) + ny = int(self.projection_data['ny']) - self._y = {'data': np.linspace(kwargs['y_0'] + (kwargs['inc_y'] / 2), - kwargs['y_0'] + (kwargs['inc_y'] / 2) + - (kwargs['inc_y'] * (kwargs['ny'] - 1)), kwargs['ny'], - dtype=np.float64)} + # Create a regular grid in metres (1D) + self._x = {'data': np.linspace(x_0 + (inc_x / 2), + x_0 + (inc_x / 2) + (inc_x * (nx - 1)), + nx, dtype=np.float64)} + self._y = {'data': np.linspace(y_0 + (inc_y / 2), + y_0 + (inc_y / 2) + (inc_y * (ny - 1)), + ny, dtype=np.float64)} # Create a regular grid in metres (1D to 2D) x = np.array([self._x['data']] * len(self._y['data'])) diff --git a/nes/nc_projections/points_nes.py b/nes/nc_projections/points_nes.py index 46be2fe..ee54184 100644 --- a/nes/nc_projections/points_nes.py +++ b/nes/nc_projections/points_nes.py @@ -30,7 +30,7 @@ class PointsNes(Nes): """ def __init__(self, comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='X', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, - times=None, **kwargs): + balanced=False, times=None, **kwargs): """ Initialize the PointsNes class. @@ -55,6 +55,17 @@ class PointsNes(Nes): Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. """ super(PointsNes, self).__init__(comm=comm, path=path, info=info, dataset=dataset, @@ -82,8 +93,9 @@ class PointsNes(Nes): self._lon_dim = ('station',) @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create=False, balanced=False, - parallel_method='X', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='X', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, + create_nes=False, balanced=False, times=None, **kwargs): """ Initialize the Nes class. @@ -99,19 +111,31 @@ class PointsNes(Nes): NetCDF4-python Dataset to initialize the class. xarray: bool: (Not working) Indicates if you want to use xarray as default. + parallel_method : str + Indicates the parallelization method that you want. Default: 'X'. + accepted values: ['X', 'T']. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - parallel_method : str - Indicates the parallelization method that you want. Default: 'X'. - accepted values: ['X', 'T']. - """ - - new = PointsNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, balanced=balanced, + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. + """ + + new = PointsNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, - avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level) - + avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, + create_nes=create_nes, balanced=balanced, times=times, **kwargs) + return new def _get_projection(self): diff --git a/nes/nc_projections/points_nes_ghost.py b/nes/nc_projections/points_nes_ghost.py index ce84ecc..09c5a44 100644 --- a/nes/nc_projections/points_nes_ghost.py +++ b/nes/nc_projections/points_nes_ghost.py @@ -27,7 +27,7 @@ class PointsNesGHOST(PointsNes): def __init__(self, comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='X', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, - times=None, **kwargs): + balanced=False, times=None, **kwargs): """ Initialize the PointsNesGHOST class. @@ -50,19 +50,17 @@ class PointsNesGHOST(PointsNes): Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - balanced : bool - Indicates if you want a balanced parallelization or not. - Balanced dataset cannot be written in chunking mode. first_level : int Index of the first level to use. last_level : int, None Index of the last level to use. None if it is the last. create_nes : bool Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. times : list, None List of times to substitute the current ones while creation. - kwargs : - Projection dependent parameters to create it from scratch. """ super(PointsNesGHOST, self).__init__(comm=comm, path=path, info=info, dataset=dataset, @@ -80,8 +78,9 @@ class PointsNesGHOST(PointsNes): self.qa = self._get_coordinate_values(self._qa, 'X') @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create_nes=False, balanced=False, - parallel_method='X', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='X', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, + balanced=False, times=None, **kwargs): """ Initialize the PointsNesGHOST class. @@ -97,16 +96,9 @@ class PointsNesGHOST(PointsNes): NetCDF4-python Dataset to initialize the class. xarray: bool: (Not working) Indicates if you want to use xarray as default. - avoid_first_hours : int - Number of hours to remove from first time steps. - avoid_last_hours : int - Number of hours to remove from last time steps. parallel_method : str Indicates the parallelization method that you want. Default: 'X'. Accepted values: ['X']. - balanced : bool - Indicates if you want a balanced parallelization or not. - Balanced dataset cannot be written in chunking mode. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int @@ -117,13 +109,18 @@ class PointsNesGHOST(PointsNes): Index of the last level to use. None if it is the last. create_nes : bool Indicates if you want to create the object from scratch (True) or through an existing file. - + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. """ - new = PointsNesGHOST(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, balanced=balanced, + new = PointsNesGHOST(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, - avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level) - + avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, + create_nes=create_nes, balanced=balanced, times=times, **kwargs) + return new def _create_dimensions(self, netcdf): diff --git a/nes/nc_projections/points_nes_providentia.py b/nes/nc_projections/points_nes_providentia.py index 8484aec..533e4a8 100644 --- a/nes/nc_projections/points_nes_providentia.py +++ b/nes/nc_projections/points_nes_providentia.py @@ -36,7 +36,7 @@ class PointsNesProvidentia(PointsNes): """ def __init__(self, comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='X', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, - times=None, model_centre_lon=None, model_centre_lat=None, grid_edge_lon=None, grid_edge_lat=None, + balanced=False, times=None, model_centre_lon=None, model_centre_lat=None, grid_edge_lon=None, grid_edge_lat=None, **kwargs): """ Initialize the PointsNesProvidentia class @@ -60,15 +60,15 @@ class PointsNesProvidentia(PointsNes): Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - balanced : bool - Indicates if you want a balanced parallelization or not. - Balanced dataset cannot be written in chunking mode. first_level : int Index of the first level to use. last_level : int, None Index of the last level to use. None if it is the last. create_nes : bool Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. times : list, None List of times to substitute the current ones while creation. model_centre_lon : dict @@ -79,8 +79,6 @@ class PointsNesProvidentia(PointsNes): Grid edge longitudes dictionary with the portion of 'data' corresponding to the rank values. grid_edge_lat : dict Grid edge latitudes dictionary with the portion of 'data' corresponding to the rank values. - kwargs : - Projection dependent parameters to create it from scratch. """ super(PointsNesProvidentia, self).__init__(comm=comm, path=path, info=info, dataset=dataset, @@ -110,9 +108,11 @@ class PointsNesProvidentia(PointsNes): self.grid_edge_lat = self._get_coordinate_values(self._grid_edge_lat, '') @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create_nes=False, balanced=False, - parallel_method='X', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, - model_centre_lon=None, model_centre_lat=None, grid_edge_lon=None, grid_edge_lat=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='X', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, + create_nes=False, balanced=False, times=None, + model_centre_lon=None, model_centre_lat=None, grid_edge_lon=None, grid_edge_lat=None, + **kwargs): """ Initialize the PointsNesProvidentia class. @@ -128,15 +128,9 @@ class PointsNesProvidentia(PointsNes): NetCDF4-python Dataset to initialize the class. xarray: bool: (Not working) Indicates if you want to use xarray as default. - avoid_first_hours : int - Number of hours to remove from first time steps. - avoid_last_hours : int - Number of hours to remove from last time steps. parallel_method : str Indicates the parallelization method that you want. Default: 'X'. Accepted values: ['X']. - balanced : bool - Indicates if you want a balanced parallelization or not. Balanced dataset cannot be written in chunking mode avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int @@ -145,6 +139,11 @@ class PointsNesProvidentia(PointsNes): Index of the first level to use last_level : int, None Index of the last level to use. None if it is the last. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. create_nes : bool Indicates if you want to create the object from scratch (True) or through an existing file. model_centre_lon : dict @@ -157,11 +156,12 @@ class PointsNesProvidentia(PointsNes): Grid edge latitudes dictionary with the portion of 'data' corresponding to the rank values. """ - new = PointsNesProvidentia(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, balanced=balanced, + new = PointsNesProvidentia(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, - model_centre_lon=model_centre_lon, model_centre_lat=model_centre_lat, - grid_edge_lon=grid_edge_lon, grid_edge_lat=grid_edge_lat) + create_nes=create_nes, balanced=balanced, times=times, + model_centre_lon=model_centre_lon, model_centre_lat=model_centre_lat, + grid_edge_lon=grid_edge_lon, grid_edge_lat=grid_edge_lat, **kwargs) return new diff --git a/nes/nc_projections/rotated_nes.py b/nes/nc_projections/rotated_nes.py index 3cd6f99..806930c 100644 --- a/nes/nc_projections/rotated_nes.py +++ b/nes/nc_projections/rotated_nes.py @@ -26,9 +26,6 @@ class RotatedNes(Nes): Rotated latitudes dictionary with the portion of 'data' corresponding to the rank values. rlon : dict Rotated longitudes dictionary with the portion of 'data' corresponding to the rank values. - projection_data : dict - Dictionary with the projection information. - 'grid_north_pole_latitude' and 'grid_north_pole_longitude' keys. _var_dim : tuple Tuple with the name of the Y and X dimensions for the variables. ('rlat', 'rlon') for a rotated projection. @@ -64,6 +61,17 @@ class RotatedNes(Nes): Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. """ super(RotatedNes, self).__init__(comm=comm, path=path, @@ -94,8 +102,9 @@ class RotatedNes(Nes): self._lon_dim = ('rlat', 'rlon') @staticmethod - def new(comm=None, path=None, info=False, dataset=None, xarray=False, create=False, balanced=False, - parallel_method='Y', avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None): + def new(comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='Y', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, + create_nes=False, balanced=False, times=None, **kwargs): """ Initialize the Nes class. @@ -111,18 +120,27 @@ class RotatedNes(Nes): NetCDF4-python Dataset to initialize the class. xarray: bool: (Not working) Indicates if you want to use xarray as default. + parallel_method : str + Indicates the parallelization method that you want. Default: 'Y'. + Accepted values: ['X', 'Y', 'T']. avoid_first_hours : int Number of hours to remove from first time steps. avoid_last_hours : int Number of hours to remove from last time steps. - parallel_method : str - Indicates the parallelization method that you want. Default: 'Y'. - Accepted values: ['X', 'Y', 'T']. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. """ - new = RotatedNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, balanced=balanced, + new = RotatedNes(comm=comm, path=path, info=info, dataset=dataset, xarray=xarray, parallel_method=parallel_method, avoid_first_hours=avoid_first_hours, - avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level) + avoid_last_hours=avoid_last_hours, first_level=first_level, last_level=last_level, + create_nes=create_nes, balanced=balanced, times=times, **kwargs) + return new def filter_coordinates_selection(self): @@ -196,6 +214,10 @@ class RotatedNes(Nes): projection_data = {'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 90 - kwargs['centre_lat'], 'grid_north_pole_longitude': -180 + kwargs['centre_lon'], + 'inc_rlat': kwargs['inc_rlat'], + 'inc_rlon': kwargs['inc_rlon'], + 'south_boundary': kwargs['south_boundary'], + 'west_boundary': kwargs['west_boundary'], } self.projection_data = projection_data @@ -264,7 +286,7 @@ class RotatedNes(Nes): return None - def _create_rotated_coordinates(self, **kwargs): + def _create_rotated_coordinates(self): """ Calculate rotated latitudes and longitudes from grid details. @@ -276,19 +298,29 @@ class RotatedNes(Nes): Rotated longitudes dictionary with the complete 'data' key for all the values and the rest of the attributes. """ + # Get grid resolution + inc_rlon = np.float64(self.projection_data['inc_rlon']) + inc_rlat = np.float64(self.projection_data['inc_rlat']) + + # Get south and west boundaries + south_boundary = np.float64(self.projection_data['south_boundary']) + west_boundary = np.float64(self.projection_data['west_boundary']) + # Calculate rotated latitudes - n_lat = int((abs(kwargs['south_boundary']) / kwargs['inc_rlat']) * 2 + 1) - rlat = np.linspace(kwargs['south_boundary'], kwargs['south_boundary'] + - (kwargs['inc_rlat'] * (n_lat - 1)), n_lat) + n_lat = int((abs(south_boundary) / inc_rlat) * 2 + 1) + rlat = np.linspace(south_boundary, + south_boundary + (inc_rlat * (n_lat - 1)), + n_lat, dtype=np.float64) # Calculate rotated longitudes - n_lon = int((abs(kwargs['west_boundary']) / kwargs['inc_rlon']) * 2 + 1) - rlon = np.linspace(kwargs['west_boundary'], kwargs['west_boundary'] + - (kwargs['inc_rlon'] * (n_lon - 1)), n_lon) + n_lon = int((abs(west_boundary) / inc_rlon) * 2 + 1) + rlon = np.linspace(west_boundary, + west_boundary + (inc_rlon * (n_lon - 1)), + n_lon, dtype=np.float64) return {'data': rlat}, {'data': rlon} - def rotated2latlon(self, lon_deg, lat_deg, lon_min=-180, **kwargs): + def rotated2latlon(self, lon_deg, lat_deg, lon_min=-180): """ Calculate the unrotated coordinates using the rotated ones. @@ -357,12 +389,11 @@ class RotatedNes(Nes): """ # Complete dimensions - self._rlat, self._rlon = self._create_rotated_coordinates(**kwargs) + self._rlat, self._rlon = self._create_rotated_coordinates() # Calculate centre latitudes and longitudes (1D to 2D) centre_lon, centre_lat = self.rotated2latlon(np.array([self._rlon['data']] * len(self._rlat['data'])), - np.array([self._rlat['data']] * len(self._rlon['data'])).T, - **kwargs) + np.array([self._rlat['data']] * len(self._rlon['data'])).T) return {'data': centre_lat}, {'data': centre_lon} @@ -477,7 +508,7 @@ class RotatedNes(Nes): """ var.grid_mapping = 'rotated_pole' - var.coordinates = "lat lon" + var.coordinates = 'lat lon' return None @@ -589,4 +620,3 @@ class RotatedNes(Nes): crs="EPSG:4326") return centroids_gdf - diff --git a/nes/nc_projections/rotated_nested_nes.py b/nes/nc_projections/rotated_nested_nes.py new file mode 100644 index 0000000..e56f427 --- /dev/null +++ b/nes/nc_projections/rotated_nested_nes.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python + +import numpy as np +from netCDF4 import Dataset +from .rotated_nes import RotatedNes + +class RotatedNestedNes(RotatedNes): + + def __init__(self, comm=None, path=None, info=False, dataset=None, xarray=False, parallel_method='Y', + avoid_first_hours=0, avoid_last_hours=0, first_level=0, last_level=None, create_nes=False, + balanced=False, times=None, **kwargs): + """ + Initialize the RotatedNestedNes class. + + Parameters + ---------- + comm: MPI.COMM + MPI Communicator. + path: str + Path to the NetCDF to initialize the object. + info: bool + Indicates if you want to get reading/writing info. + dataset: Dataset + NetCDF4-python Dataset to initialize the class. + xarray: bool: + (Not working) Indicates if you want to use xarray as default. + parallel_method : str + Indicates the parallelization method that you want. Default: 'Y'. + Accepted values: ['X', 'Y', 'T']. + avoid_first_hours : int + Number of hours to remove from first time steps. + avoid_last_hours : int + Number of hours to remove from last time steps. + first_level : int + Index of the first level to use. + last_level : int, None + Index of the last level to use. None if it is the last. + create_nes : bool + Indicates if you want to create the object from scratch (True) or through an existing file. + balanced : bool + Indicates if you want a balanced parallelization or not. + Balanced dataset cannot be written in chunking mode. + times : list, None + List of times to substitute the current ones while creation. + """ + + super(RotatedNestedNes, self).__init__(comm=comm, path=path, + info=info, dataset=dataset, balanced=balanced, + xarray=xarray, parallel_method=parallel_method, + avoid_first_hours=avoid_first_hours, avoid_last_hours=avoid_last_hours, + first_level=first_level, last_level=last_level, create_nes=create_nes, + times=times, **kwargs) + + @staticmethod + def _get_parent_attributes(projection_data): + """ + Get projection attributes from parent grid. + + Parameters + ---------- + projection_data : dict + Dictionary with the projection information. + + Returns + ------- + projection_data : dict + Dictionary with the projection information, including parameters from the parent grid. + """ + + # Read variables from parent grid + netcdf = Dataset(projection_data['parent_grid_path'], mode='r') + rlat = netcdf.variables['rlat'][:] + rlon = netcdf.variables['rlon'][:] + rotated_pole = netcdf.variables['rotated_pole'] + + # j_parent_start starts at index 1 so we must subtract 1 + projection_data['inc_rlat'] = (rlat[1] - rlat[0]) / projection_data['parent_ratio'] + projection_data['1st_rlat'] = rlat[int(projection_data['j_parent_start']) - 1] + + # i_parent_start starts at index 1 so we must subtract 1 + projection_data['inc_rlon'] = (rlon[1] - rlon[0]) / projection_data['parent_ratio'] + projection_data['1st_rlon'] = rlon[int(projection_data['i_parent_start']) - 1] + + projection_data['grid_north_pole_longitude'] = rotated_pole.grid_north_pole_longitude + projection_data['grid_north_pole_latitude'] = rotated_pole.grid_north_pole_latitude + + netcdf.close() + + return projection_data + + def _create_projection(self, **kwargs): + """ + Create 'projection' and 'projection_data' from projection arguments. + """ + + projection_data = {'grid_mapping_name': "", # TODO: Add name + 'parent_grid_path': kwargs['parent_grid_path'], + 'parent_ratio': kwargs['parent_ratio'], + 'i_parent_start': kwargs['i_parent_start'], + 'j_parent_start': kwargs['j_parent_start'], + 'n_rlat': kwargs['n_rlat'], + 'n_rlon': kwargs['n_rlon'] + } + + projection_data = self._get_parent_attributes(projection_data) + + self.projection_data = projection_data + self.projection = self._get_pyproj_projection() + + return None + + def _create_rotated_coordinates(self): + """ + Calculate rotated latitudes and longitudes from grid details. + + Returns + ---------- + _rlat : dict + Rotated latitudes dictionary with the complete 'data' key for all the values and the rest of the attributes. + _rlon : dict + Rotated longitudes dictionary with the complete 'data' key for all the values and the rest of the attributes. + """ + + # Get grid resolution + inc_rlon = self.projection_data['inc_rlon'] + inc_rlat = self.projection_data['inc_rlat'] + + # Get number of rotated coordinates + n_rlat = self.projection_data['n_rlat'] + n_rlon = self.projection_data['n_rlon'] + + # Get first coordinates + first_rlat = self.projection_data['1st_rlat'] + first_rlon = self.projection_data['1st_rlon'] + + # Calculate rotated latitudes + rlat = np.linspace(first_rlat, + first_rlat + (inc_rlat * (n_rlat - 1)), + n_rlat, dtype=np.float64) + + # Calculate rotated longitudes + rlon = np.linspace(first_rlon, + first_rlon + (inc_rlon * (n_rlon - 1)), + n_rlon, dtype=np.float64) + + return {'data': rlat}, {'data': rlon} + \ No newline at end of file -- GitLab From 6b977729bca2dc41beb52a8036afc02e0ebd9efc Mon Sep 17 00:00:00 2001 From: Alba Vilanova Date: Fri, 12 May 2023 15:43:06 +0200 Subject: [PATCH 2/9] Add rotated nested tutorial and tests tutorials 1 and 2 --- .../1.1.Read_Write_Regular.ipynb | 8 +- .../1.2.Read_Write_Rotated.ipynb | 6 +- .../1.3.Read_Write_Points.ipynb | 52 +- .../1.Introduction/1.4.Read_Write_LCC.ipynb | 6 +- .../1.5.Read_Write_Mercator.ipynb | 6 +- tutorials/2.Creation/2.1.Create_Regular.ipynb | 14 +- tutorials/2.Creation/2.2.Create_Rotated.ipynb | 10 +- .../2.Creation/2.3.Create_Points_XVPCA.ipynb | 10 +- .../2.4.Create_Points_Port_Barcelona.ipynb | 4 +- .../2.Creation/2.5.Create_Points_CSIC.ipynb | 4 +- tutorials/2.Creation/2.6.Create_LCC.ipynb | 16 +- .../2.Creation/2.7.Create_Mercator.ipynb | 14 +- tutorials/2.Creation/2.8.Create_Global.ipynb | 14 +- .../2.9.Create_Rotated_Nested.ipynb | 482 ++++++++++++++++++ 14 files changed, 578 insertions(+), 68 deletions(-) create mode 100644 tutorials/2.Creation/2.9.Create_Rotated_Nested.ipynb diff --git a/tutorials/1.Introduction/1.1.Read_Write_Regular.ipynb b/tutorials/1.Introduction/1.1.Read_Write_Regular.ipynb index a50f8c2..1b14e14 100644 --- a/tutorials/1.Introduction/1.1.Read_Write_Regular.ipynb +++ b/tutorials/1.Introduction/1.1.Read_Write_Regular.ipynb @@ -54,7 +54,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -410,16 +410,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/1.Introduction/1.2.Read_Write_Rotated.ipynb b/tutorials/1.Introduction/1.2.Read_Write_Rotated.ipynb index 112e91a..cc61f96 100644 --- a/tutorials/1.Introduction/1.2.Read_Write_Rotated.ipynb +++ b/tutorials/1.Introduction/1.2.Read_Write_Rotated.ipynb @@ -54,7 +54,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -757,9 +757,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/1.Introduction/1.3.Read_Write_Points.ipynb b/tutorials/1.Introduction/1.3.Read_Write_Points.ipynb index 0345f8d..bb0e102 100644 --- a/tutorials/1.Introduction/1.3.Read_Write_Points.ipynb +++ b/tutorials/1.Introduction/1.3.Read_Write_Points.ipynb @@ -53,7 +53,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -655,35 +655,35 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_start_date. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_start_date. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_zone. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_zone. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable street_type. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable street_type. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable country_code. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable country_code. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable ccaa. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable ccaa. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_area. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_area. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable city. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable city. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_emep. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_emep. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_type. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_type. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable country. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable country. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_code. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_code. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_end_date. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_end_date. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_rural_back. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_rural_back. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_ozone_classification. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_ozone_classification. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n" ] }, @@ -802,11 +802,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:2966: UserWarning: Column names longer than 10 characters will be truncated when saved to ESRI Shapefile.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3009: UserWarning: Column names longer than 10 characters will be truncated when saved to ESRI Shapefile.\n", " self.shapefile.to_file(path)\n" ] } @@ -847,7 +847,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 17, @@ -1311,11 +1311,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes_ghost.py:332: UserWarning: WARNING!!! Different data types for variable country. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes_ghost.py:329: UserWarning: WARNING!!! Different data types for variable country. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes_ghost.py:332: UserWarning: WARNING!!! Different data types for variable land_use. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes_ghost.py:329: UserWarning: WARNING!!! Different data types for variable land_use. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes_ghost.py:332: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes_ghost.py:329: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n" ] }, @@ -1369,11 +1369,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes_ghost.py:332: UserWarning: WARNING!!! Different data types for variable country. Input dtype=. Data dtype=. Data dtype=. Data dtype=. Data dtype=. Data dtype=. Data dtype=" + "" ] }, "execution_count": 4, @@ -756,9 +756,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/1.Introduction/1.5.Read_Write_Mercator.ipynb b/tutorials/1.Introduction/1.5.Read_Write_Mercator.ipynb index 4896e13..ed62407 100644 --- a/tutorials/1.Introduction/1.5.Read_Write_Mercator.ipynb +++ b/tutorials/1.Introduction/1.5.Read_Write_Mercator.ipynb @@ -54,7 +54,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -511,9 +511,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/2.Creation/2.1.Create_Regular.ipynb b/tutorials/2.Creation/2.1.Create_Regular.ipynb index 4395caf..6908582 100644 --- a/tutorials/2.Creation/2.1.Create_Regular.ipynb +++ b/tutorials/2.Creation/2.1.Create_Regular.ipynb @@ -106,8 +106,14 @@ "data": { "text/plain": [ "{'grid_mapping_name': 'latitude_longitude',\n", - " 'semi_major_axis': '6378137.0',\n", - " 'inverse_flattening': '0'}" + " 'semi_major_axis': 6378137.0,\n", + " 'inverse_flattening': 0,\n", + " 'inc_lat': 0.05,\n", + " 'inc_lon': 0.1,\n", + " 'lat_orig': 29.995,\n", + " 'lon_orig': -30.0,\n", + " 'n_lat': 840,\n", + " 'n_lon': 900}" ] }, "execution_count": 6, @@ -311,9 +317,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/2.Creation/2.2.Create_Rotated.ipynb b/tutorials/2.Creation/2.2.Create_Rotated.ipynb index cb27f4c..47492ff 100644 --- a/tutorials/2.Creation/2.2.Create_Rotated.ipynb +++ b/tutorials/2.Creation/2.2.Create_Rotated.ipynb @@ -108,7 +108,11 @@ "text/plain": [ "{'grid_mapping_name': 'rotated_latitude_longitude',\n", " 'grid_north_pole_latitude': 39,\n", - " 'grid_north_pole_longitude': -170}" + " 'grid_north_pole_longitude': -170,\n", + " 'inc_rlat': 0.15,\n", + " 'inc_rlon': 0.15,\n", + " 'south_boundary': -27,\n", + " 'west_boundary': -35}" ] }, "execution_count": 6, @@ -312,9 +316,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/2.Creation/2.3.Create_Points_XVPCA.ipynb b/tutorials/2.Creation/2.3.Create_Points_XVPCA.ipynb index a578cd7..f5eca19 100644 --- a/tutorials/2.Creation/2.3.Create_Points_XVPCA.ipynb +++ b/tutorials/2.Creation/2.3.Create_Points_XVPCA.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# How to create points grids (XVPCA)" + "# How to create points datasets (XVPCA)" ] }, { @@ -1334,13 +1334,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_code. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_code. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable area_classification. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable area_classification. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable pm10. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable pm10. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n" ] }, diff --git a/tutorials/2.Creation/2.4.Create_Points_Port_Barcelona.ipynb b/tutorials/2.Creation/2.4.Create_Points_Port_Barcelona.ipynb index 099f203..f52bc62 100644 --- a/tutorials/2.Creation/2.4.Create_Points_Port_Barcelona.ipynb +++ b/tutorials/2.Creation/2.4.Create_Points_Port_Barcelona.ipynb @@ -454,7 +454,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=float64.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=float64.\n", " warnings.warn(msg)\n" ] }, @@ -658,7 +658,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n" ] }, diff --git a/tutorials/2.Creation/2.5.Create_Points_CSIC.ipynb b/tutorials/2.Creation/2.5.Create_Points_CSIC.ipynb index 7b6d735..3a456e2 100644 --- a/tutorials/2.Creation/2.5.Create_Points_CSIC.ipynb +++ b/tutorials/2.Creation/2.5.Create_Points_CSIC.ipynb @@ -308,7 +308,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n" ] }, @@ -523,7 +523,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:337: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/points_nes.py:361: UserWarning: WARNING!!! Different data types for variable station_name. Input dtype=. Data dtype=object.\n", " warnings.warn(msg)\n" ] }, diff --git a/tutorials/2.Creation/2.6.Create_LCC.ipynb b/tutorials/2.Creation/2.6.Create_LCC.ipynb index c2df974..c4bbd89 100644 --- a/tutorials/2.Creation/2.6.Create_LCC.ipynb +++ b/tutorials/2.Creation/2.6.Create_LCC.ipynb @@ -129,9 +129,15 @@ "data": { "text/plain": [ "{'grid_mapping_name': 'lambert_conformal_conic',\n", - " 'standard_parallel': ['37', '43'],\n", - " 'longitude_of_central_meridian': '-3',\n", - " 'latitude_of_projection_origin': '40'}" + " 'standard_parallel': [37, 43],\n", + " 'longitude_of_central_meridian': -3,\n", + " 'latitude_of_projection_origin': 40,\n", + " 'x_0': -807847.688,\n", + " 'y_0': -797137.125,\n", + " 'inc_x': 4000,\n", + " 'inc_y': 4000,\n", + " 'nx': 397,\n", + " 'ny': 397}" ] }, "execution_count": 7, @@ -325,9 +331,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/2.Creation/2.7.Create_Mercator.ipynb b/tutorials/2.Creation/2.7.Create_Mercator.ipynb index 51e6f98..df5c29b 100644 --- a/tutorials/2.Creation/2.7.Create_Mercator.ipynb +++ b/tutorials/2.Creation/2.7.Create_Mercator.ipynb @@ -106,8 +106,14 @@ "data": { "text/plain": [ "{'grid_mapping_name': 'mercator',\n", - " 'standard_parallel': '-1.5',\n", - " 'longitude_of_projection_origin': -18.0}" + " 'standard_parallel': -1.5,\n", + " 'longitude_of_projection_origin': -18.0,\n", + " 'x_0': -126017.5,\n", + " 'y_0': -5407460.0,\n", + " 'inc_x': 50000,\n", + " 'inc_y': 50000,\n", + " 'nx': 210,\n", + " 'ny': 236}" ] }, "execution_count": 6, @@ -311,9 +317,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/2.Creation/2.8.Create_Global.ipynb b/tutorials/2.Creation/2.8.Create_Global.ipynb index 6465b78..fbda3b3 100644 --- a/tutorials/2.Creation/2.8.Create_Global.ipynb +++ b/tutorials/2.Creation/2.8.Create_Global.ipynb @@ -98,8 +98,14 @@ "data": { "text/plain": [ "{'grid_mapping_name': 'latitude_longitude',\n", - " 'semi_major_axis': '6378137.0',\n", - " 'inverse_flattening': '0'}" + " 'semi_major_axis': 6378137.0,\n", + " 'inverse_flattening': 0,\n", + " 'inc_lat': 0.5,\n", + " 'inc_lon': 0.5,\n", + " 'lat_orig': -90,\n", + " 'lon_orig': -180,\n", + " 'n_lat': 360,\n", + " 'n_lon': 720}" ] }, "execution_count": 6, @@ -303,9 +309,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3015: UserWarning: No vertical level has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", " warnings.warn(msg)\n", - "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3026: UserWarning: No time has been specified. The first one will be selected.\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", " warnings.warn(msg)\n" ] } diff --git a/tutorials/2.Creation/2.9.Create_Rotated_Nested.ipynb b/tutorials/2.Creation/2.9.Create_Rotated_Nested.ipynb new file mode 100644 index 0000000..c77c991 --- /dev/null +++ b/tutorials/2.Creation/2.9.Create_Rotated_Nested.ipynb @@ -0,0 +1,482 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to create rotated nested grids" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from nes import *\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import geopandas as gpd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Create dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define grid details" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Parent grid" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "path = '/gpfs/projects/bsc32/models/NES_tutorial_data/O3_all-000_2021080300.nc'\n", + "parent_nessy = open_netcdf(path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Rotated nested grid" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "projection='rotated-nested'\n", + "parent_ratio = 0.5\n", + "i_parent_start = 20\n", + "j_parent_start = 20\n", + "n_rlat = 40\n", + "n_rlon = 50\n", + "nessy = create_nes(comm=None, info=False, projection=projection,\n", + " parent_grid_path=path, parent_ratio=parent_ratio,\n", + " i_parent_start=i_parent_start, j_parent_start=j_parent_start,\n", + " n_rlat=n_rlat, n_rlon=n_rlon)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read projection" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Proj('+proj=ob_tran +o_proj=longlat +ellps=WGS84 +R=6356752.3142 +o_lat_p=39.0 +o_lon_p=-170.0', preserve_units=True)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nessy.projection" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'grid_mapping_name': '',\n", + " 'parent_grid_path': '/gpfs/projects/bsc32/models/NES_tutorial_data/O3_all-000_2021080300.nc',\n", + " 'parent_ratio': 0.5,\n", + " 'i_parent_start': 20,\n", + " 'j_parent_start': 20,\n", + " 'n_rlat': 40,\n", + " 'n_rlon': 50,\n", + " 'inc_rlat': 0.40000152587890625,\n", + " '1st_rlat': -23.200000762939453,\n", + " 'inc_rlon': 0.40000152587890625,\n", + " '1st_rlon': -31.200000762939453,\n", + " 'grid_north_pole_longitude': -170.0,\n", + " 'grid_north_pole_latitude': 39.0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nessy.projection_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
geometry
FID
0POLYGON ((-22.21497 16.22040, -22.05071 16.303...
1POLYGON ((-22.05071 16.30307, -21.88618 16.385...
2POLYGON ((-21.88618 16.38536, -21.72137 16.467...
3POLYGON ((-21.72137 16.46727, -21.55629 16.548...
4POLYGON ((-21.55629 16.54881, -21.39094 16.629...
......
95116POLYGON ((87.25127 59.16191, 87.43401 59.01025...
95117POLYGON ((87.43401 59.01025, 87.61561 58.85849...
95118POLYGON ((87.61561 58.85849, 87.79608 58.70663...
95119POLYGON ((87.79608 58.70663, 87.97545 58.55466...
95120POLYGON ((87.97545 58.55466, 88.15372 58.40259...
\n", + "

95121 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " geometry\n", + "FID \n", + "0 POLYGON ((-22.21497 16.22040, -22.05071 16.303...\n", + "1 POLYGON ((-22.05071 16.30307, -21.88618 16.385...\n", + "2 POLYGON ((-21.88618 16.38536, -21.72137 16.467...\n", + "3 POLYGON ((-21.72137 16.46727, -21.55629 16.548...\n", + "4 POLYGON ((-21.55629 16.54881, -21.39094 16.629...\n", + "... ...\n", + "95116 POLYGON ((87.25127 59.16191, 87.43401 59.01025...\n", + "95117 POLYGON ((87.43401 59.01025, 87.61561 58.85849...\n", + "95118 POLYGON ((87.61561 58.85849, 87.79608 58.70663...\n", + "95119 POLYGON ((87.79608 58.70663, 87.97545 58.55466...\n", + "95120 POLYGON ((87.97545 58.55466, 88.15372 58.40259...\n", + "\n", + "[95121 rows x 1 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parent_nessy.create_shapefile()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
geometry
FID
0POLYGON ((-20.81569 21.02923, -20.46071 21.187...
1POLYGON ((-20.46071 21.18765, -20.10450 21.344...
2POLYGON ((-20.10450 21.34440, -19.74707 21.499...
3POLYGON ((-19.74707 21.49948, -19.38842 21.652...
4POLYGON ((-19.38842 21.65288, -19.02855 21.804...
......
1995POLYGON ((-7.87339 41.57399, -7.35841 41.66807...
1996POLYGON ((-7.35841 41.66807, -6.84183 41.75947...
1997POLYGON ((-6.84183 41.75947, -6.32368 41.84819...
1998POLYGON ((-6.32368 41.84819, -5.80401 41.93421...
1999POLYGON ((-5.80401 41.93421, -5.28284 42.01751...
\n", + "

2000 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " geometry\n", + "FID \n", + "0 POLYGON ((-20.81569 21.02923, -20.46071 21.187...\n", + "1 POLYGON ((-20.46071 21.18765, -20.10450 21.344...\n", + "2 POLYGON ((-20.10450 21.34440, -19.74707 21.499...\n", + "3 POLYGON ((-19.74707 21.49948, -19.38842 21.652...\n", + "4 POLYGON ((-19.38842 21.65288, -19.02855 21.804...\n", + "... ...\n", + "1995 POLYGON ((-7.87339 41.57399, -7.35841 41.66807...\n", + "1996 POLYGON ((-7.35841 41.66807, -6.84183 41.75947...\n", + "1997 POLYGON ((-6.84183 41.75947, -6.32368 41.84819...\n", + "1998 POLYGON ((-6.32368 41.84819, -5.80401 41.93421...\n", + "1999 POLYGON ((-5.80401 41.93421, -5.28284 42.01751...\n", + "\n", + "[2000 rows x 1 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nessy.create_shapefile()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, figsize=(19, 7))\n", + "parent_nessy.shapefile.plot(ax=ax, facecolor=\"grey\", edgecolor=\"grey\")\n", + "nessy.shapefile.plot(ax=ax, facecolor=\"blue\", edgecolor=\"blue\")\n", + "countries = gpd.read_file('/esarchive/shapefiles/gadm_country_mask/gadm_country_ISO3166.shp')\n", + "countries.plot(ax=ax, facecolor=\"none\", edgecolor='black', linewidth=0.3)\n", + "ax.margins(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Write dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Write NetCDF" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rank 000: Creating rotated_nested_grid.nc\n", + "Rank 000: NetCDF ready to write\n", + "Rank 000: Dimensions done\n" + ] + } + ], + "source": [ + "nessy.to_netcdf('rotated_nested_grid.nc', info=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Write shapefile" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3058: UserWarning: No vertical level has been specified. The first one will be selected.\n", + " warnings.warn(msg)\n", + "/esarchive/scratch/avilanova/software/NES/nes/nc_projections/default_nes.py:3069: UserWarning: No time has been specified. The first one will be selected.\n", + " warnings.warn(msg)\n" + ] + } + ], + "source": [ + "nessy.to_shapefile('rotated_nested_grid_shp')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} -- GitLab From db7bb0ab93f49ccd26e37fdc0c217e2c20b1e8b6 Mon Sep 17 00:00:00 2001 From: ctena Date: Thu, 25 May 2023 14:56:35 +0200 Subject: [PATCH 3/9] GFAS area is working as expected --- nes/nes_formats/cmaq_format.py | 2 +- nes/nes_formats/wrf_chem_format.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nes/nes_formats/cmaq_format.py b/nes/nes_formats/cmaq_format.py index 649d9d5..f27bc77 100644 --- a/nes/nes_formats/cmaq_format.py +++ b/nes/nes_formats/cmaq_format.py @@ -104,7 +104,7 @@ def to_cmaq_units(self): dict Variable in the MONARCH units """ - self.calculate_grid_area() + self.calculate_grid_area(overwrite=False) for var_name in self.variables.keys(): if isinstance(self.variables[var_name]['data'], np.ndarray): if self.variables[var_name]['units'] == 'mol.s-1': diff --git a/nes/nes_formats/wrf_chem_format.py b/nes/nes_formats/wrf_chem_format.py index a74da56..77bf937 100644 --- a/nes/nes_formats/wrf_chem_format.py +++ b/nes/nes_formats/wrf_chem_format.py @@ -122,7 +122,7 @@ def to_wrf_chem_units(self): dict Variable in the MONARCH units """ - self.calculate_grid_area() + self.calculate_grid_area(overwrite=False) for var_name in self.variables.keys(): if isinstance(self.variables[var_name]['data'], np.ndarray): if self.variables[var_name]['units'] == 'mol.h-1.km-2': -- GitLab From e12ad3a75b2496c64b0faf27c2b9a492e99a7af6 Mon Sep 17 00:00:00 2001 From: ctena Date: Tue, 30 May 2023 16:52:59 +0200 Subject: [PATCH 4/9] NES new get_fids function --- nes/nc_projections/default_nes.py | 16 ++++++++++++++++ nes/nc_projections/lcc_nes.py | 14 ++++---------- nes/nc_projections/mercator_nes.py | 10 ++-------- nes/nc_projections/rotated_nes.py | 10 ++-------- 4 files changed, 24 insertions(+), 26 deletions(-) diff --git a/nes/nc_projections/default_nes.py b/nes/nc_projections/default_nes.py index eb8e1a0..f996df5 100644 --- a/nes/nc_projections/default_nes.py +++ b/nes/nc_projections/default_nes.py @@ -3450,3 +3450,19 @@ class Nes(object): earth_radius_dict = {'WGS84': [6356752.3142, 6378137.0]} return earth_radius_dict[ellps] + + def get_fids(self): + """ + Obtain the FIDs in a 2D format + + Returns + ------- + np.array + 2D array with the FID data + """ + fids = np.arange(self._lat['data'].shape[0] * self._lon['data'].shape[-1]) + fids = fids.reshape((self._lat['data'].shape[0], self._lon['data'].shape[-1])) + fids = fids[self.write_axis_limits['y_min']:self.write_axis_limits['y_max'], + self.write_axis_limits['x_min']:self.write_axis_limits['x_max']] + + return fids diff --git a/nes/nc_projections/lcc_nes.py b/nes/nc_projections/lcc_nes.py index 536bd3c..0f7ff21 100644 --- a/nes/nc_projections/lcc_nes.py +++ b/nes/nc_projections/lcc_nes.py @@ -216,8 +216,8 @@ class LCCNes(Nes): if 'dimensions' in projection_data.keys(): del projection_data['dimensions'] - if not isinstance(projection_data['standard_parallel'], list): - projection_data['standard_parallel'] = [projection_data['standard_parallel'].split(', ')[0], + if isinstance(projection_data['standard_parallel'], str): + projection_data['standard_parallel'] = [projection_data['standard_parallel'].split(', ')[0], projection_data['standard_parallel'].split(', ')[1]] self.projection_data = projection_data @@ -526,10 +526,7 @@ class LCCNes(Nes): (aux_b_lons[i, 0], aux_b_lats[i, 0])])) # Create dataframe cointaining all polygons - fids = np.arange(self._lat['data'].shape[0] * self._lat['data'].shape[1]) - fids = fids.reshape((self._lat['data'].shape[0], self._lat['data'].shape[1])) - fids = fids[self.read_axis_limits['y_min']:self.read_axis_limits['y_max'], - self.read_axis_limits['x_min']:self.read_axis_limits['x_max']] + fids = self.get_fids() gdf = gpd.GeoDataFrame(index=pd.Index(name='FID', data=fids.ravel()), geometry=geometry, crs="EPSG:4326") @@ -558,10 +555,7 @@ class LCCNes(Nes): self.lat['data'][lat_ind, lon_ind])) # Create dataframe cointaining all points - fids = np.arange(self._lat['data'].shape[0] * self._lat['data'].shape[1]) - fids = fids.reshape((self._lat['data'].shape[0], self._lat['data'].shape[1])) - fids = fids[self.read_axis_limits['y_min']:self.read_axis_limits['y_max'], - self.read_axis_limits['x_min']:self.read_axis_limits['x_max']] + fids = self.get_fids() centroids_gdf = gpd.GeoDataFrame(index=pd.Index(name='FID', data=fids.ravel()), geometry=centroids, crs="EPSG:4326") diff --git a/nes/nc_projections/mercator_nes.py b/nes/nc_projections/mercator_nes.py index 7845566..01b3819 100644 --- a/nes/nc_projections/mercator_nes.py +++ b/nes/nc_projections/mercator_nes.py @@ -504,10 +504,7 @@ class MercatorNes(Nes): (aux_b_lons[i, 0], aux_b_lats[i, 0])])) # Create dataframe cointaining all polygons - fids = np.arange(self._lat['data'].shape[0] * self._lat['data'].shape[1]) - fids = fids.reshape((self._lat['data'].shape[0], self._lat['data'].shape[1])) - fids = fids[self.read_axis_limits['y_min']:self.read_axis_limits['y_max'], - self.read_axis_limits['x_min']:self.read_axis_limits['x_max']] + fids = self.get_fids() gdf = gpd.GeoDataFrame(index=pd.Index(name='FID', data=fids.ravel()), geometry=geometry, crs="EPSG:4326") @@ -536,10 +533,7 @@ class MercatorNes(Nes): self.lat['data'][lat_ind, lon_ind])) # Create dataframe cointaining all points - fids = np.arange(self._lat['data'].shape[0] * self._lat['data'].shape[1]) - fids = fids.reshape((self._lat['data'].shape[0], self._lat['data'].shape[1])) - fids = fids[self.read_axis_limits['y_min']:self.read_axis_limits['y_max'], - self.read_axis_limits['x_min']:self.read_axis_limits['x_max']] + fids = self.get_fids() centroids_gdf = gpd.GeoDataFrame(index=pd.Index(name='FID', data=fids.ravel()), geometry=centroids, crs="EPSG:4326") diff --git a/nes/nc_projections/rotated_nes.py b/nes/nc_projections/rotated_nes.py index 806930c..b771985 100644 --- a/nes/nc_projections/rotated_nes.py +++ b/nes/nc_projections/rotated_nes.py @@ -579,10 +579,7 @@ class RotatedNes(Nes): (aux_b_lons[i, 0], aux_b_lats[i, 0])])) # Create dataframe cointaining all polygons - fids = np.arange(self._lat['data'].shape[0] * self._lat['data'].shape[1]) - fids = fids.reshape((self._lat['data'].shape[0], self._lat['data'].shape[1])) - fids = fids[self.read_axis_limits['y_min']:self.read_axis_limits['y_max'], - self.read_axis_limits['x_min']:self.read_axis_limits['x_max']] + fids = self.get_fids() gdf = gpd.GeoDataFrame(index=pd.Index(name='FID', data=fids.ravel()), geometry=geometry, crs="EPSG:4326") @@ -611,10 +608,7 @@ class RotatedNes(Nes): self.lat['data'][lat_ind, lon_ind])) # Create dataframe cointaining all points - fids = np.arange(self._lat['data'].shape[0] * self._lat['data'].shape[1]) - fids = fids.reshape((self._lat['data'].shape[0], self._lat['data'].shape[1])) - fids = fids[self.read_axis_limits['y_min']:self.read_axis_limits['y_max'], - self.read_axis_limits['x_min']:self.read_axis_limits['x_max']] + fids = self.get_fids() centroids_gdf = gpd.GeoDataFrame(index=pd.Index(name='FID', data=fids.ravel()), geometry=centroids, crs="EPSG:4326") -- GitLab From def6b4f40ac815ef727d23257c252e4598a0a554 Mon Sep 17 00:00:00 2001 From: ctena Date: Tue, 30 May 2023 16:53:29 +0200 Subject: [PATCH 5/9] GFAS working --- nes/methods/spatial_join.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nes/methods/spatial_join.py b/nes/methods/spatial_join.py index 20dcd06..8ffc11a 100644 --- a/nes/methods/spatial_join.py +++ b/nes/methods/spatial_join.py @@ -232,7 +232,7 @@ def spatial_join_intersection(self, ext_shp, info=False): var_list.remove('geometry') grid_shp = self.shapefile - grid_shp['FID_grid'] = grid_shp.index + grid_shp['WRF-CHEM_grid'] = grid_shp.index grid_shp = grid_shp.reset_index() # Get intersected areas -- GitLab From 1f2899de65699f80dba8be1a476f1ce3ae2827bb Mon Sep 17 00:00:00 2001 From: ctena Date: Tue, 6 Jun 2023 16:13:29 +0200 Subject: [PATCH 6/9] Fixed month to day timedelta metadata --- nes/nc_projections/default_nes.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/nes/nc_projections/default_nes.py b/nes/nc_projections/default_nes.py index f996df5..cad089f 100644 --- a/nes/nc_projections/default_nes.py +++ b/nes/nc_projections/default_nes.py @@ -14,6 +14,7 @@ import geopandas as gpd from shapely.geometry import Polygon, Point from copy import deepcopy, copy import datetime +from dateutil.relativedelta import relativedelta import pyproj from ..methods import vertical_interpolation, horizontal_interpolation, cell_measures, spatial_join from ..nes_formats import to_netcdf_cams_ra, to_netcdf_monarch, to_monarch_units, to_netcdf_cmaq, to_cmaq_units, \ @@ -1526,20 +1527,20 @@ class Nes(object): start_date = datetime.datetime(int(start_date_str[0:4]), int(start_date_str[5:7]), int(start_date_str[8:10])) - new_time = [] - for current_date in time: + new_time_deltas = [] + for month_delta in time[:]: # Transform current_date into number of days since base date - current_date = num2date(current_date, self.__parse_time_unit(units), calendar=calendar) + current_date = start_date + relativedelta(months=month_delta) # Calculate number of days between base date and the other dates - n_days = (current_date - start_date).days + n_days = int((current_date - start_date).days) # Store in list - new_time.append(n_days) + new_time_deltas.append(n_days) - return new_time + return new_time_deltas def __parse_time(self, time): """ -- GitLab From bf22fc8add0b99c0cfd46b9f7fe973595588c051 Mon Sep 17 00:00:00 2001 From: ctena Date: Thu, 8 Jun 2023 15:45:00 +0200 Subject: [PATCH 7/9] Added climatology options --- nes/nc_projections/default_nes.py | 101 +++++++++++++++++++++++++----- 1 file changed, 84 insertions(+), 17 deletions(-) diff --git a/nes/nc_projections/default_nes.py b/nes/nc_projections/default_nes.py index cad089f..25be311 100644 --- a/nes/nc_projections/default_nes.py +++ b/nes/nc_projections/default_nes.py @@ -162,6 +162,11 @@ class Nes(object): # Get minor and major axes of Earth self.earth_radius = self.get_earth_radius('WGS84') + # Time resolution and climatology will be modified, if needed, during the time variable reading + self._time_resolution = 'hours' + self._climatology = False + self._climatology_var_name = 'climatology_bounds' # Default var_name but can be changed if the input is dif + # NetCDF object if create_nes: @@ -179,6 +184,7 @@ class Nes(object): # Complete dimensions self._time = times + self._time_bnds = self.__get_time_bnds(create_nes) self._lat_bnds, self._lon_bnds = self.__get_coordinates_bnds(create_nes) self._lev = {'data': np.array([0]), @@ -536,6 +542,15 @@ class Nes(object): return None + def set_climatology(self, is_climatology): + if not isinstance(is_climatology, bool): + raise TypeError("Only boolean values are accepted") + self._climatology = is_climatology + return None + + def get_climatology(self): + return self._climatology + def set_levels(self, levels): """ Modify the original level values with new ones. @@ -601,6 +616,16 @@ class Nes(object): return None + def set_time_resolution(self, new_resolution): + accepted_resolutions = ['second', 'seconds', 'minute', 'minutes', 'hour', 'hours', 'day', 'days'] + if new_resolution in accepted_resolutions: + self._time_resolution = new_resolution + else: + raise ValueError("Time resolution '{0}' is not accepted. Use one of this: {1}".format( + new_resolution, accepted_resolutions)) + return True + + @staticmethod def create_single_spatial_bounds(coordinates, inc, spatial_nv=2, inverse=False): """ @@ -1592,11 +1617,39 @@ class Nes(object): """ if 'h @' in t_units: - t_units = 'hour since {0}-{1}-{2} {3}:{4}:{5} UTC'.format( + t_units = 'hours since {0}-{1}-{2} {3}:{4}:{5} UTC'.format( t_units[4:8], t_units[8:10], t_units[10:12], t_units[13:15], t_units[15:17], t_units[17:-4]) return t_units + @staticmethod + def __get_time_resolution_from_units(units): + """ + Parses the time units to get the time resolution + + Parameters + ---------- + units : str + Time variable units + + Returns + ------- + str + Time variable resolution + """ + if 'day' in units or 'days' in units: + resolution = 'days' + elif 'hour' in units or 'hours' in units: + resolution = 'hours' + elif 'minute' in units or 'minutes' in units: + resolution = 'minutes' + elif 'second' in units or 'seconds' in units: + resolution = 'seconds' + else: + # Default resolution is 'hours' + resolution = 'hours' + return resolution + def __get_time(self): """ Get the NetCDF file time values. @@ -1613,6 +1666,12 @@ class Nes(object): if self.master: nc_var = self.netcdf.variables['time'] time_data, units, calendar = self.__parse_time(nc_var) + # Extracting time resolution depending on the units + self._time_resolution = self.__get_time_resolution_from_units(units) + # Checking if it is a climatology dataset + if hasattr(nc_var, 'climatology'): + self._climatology = True + self._climatology_var_name = nc_var.climatology time = num2date(time_data, units, calendar=calendar) time = [aux.replace(second=0, microsecond=0) for aux in time] else: @@ -1637,23 +1696,24 @@ class Nes(object): List of time bounds (datetime) of the NetCDF data. """ - if self.is_xarray: - time_bnds = self.variables['time_bnds'] - else: - if self.master: - if not create_nes: - if 'time_bnds' in self.netcdf.variables.keys(): - time = self.netcdf.variables['time'] - nc_var = self.netcdf.variables['time_bnds'] - time_bnds = num2date(nc_var[:], self.__parse_time_unit(time.units), - calendar=time.calendar).tolist() + if self.master: + if not create_nes: + if 'time_bnds' in self.netcdf.variables.keys() or self._climatology: + time = self.netcdf.variables['time'] + if self._climatology: + nc_var = self.netcdf.variables[self._climatology_var_name] else: - time_bnds = None + nc_var = self.netcdf.variables['time_bnds'] + time_bnds = num2date(nc_var[:], self.__parse_time_unit(time.units), + calendar=time.calendar).tolist() else: time_bnds = None else: time_bnds = None - time_bnds = self.comm.bcast(time_bnds, root=0) + else: + time_bnds = None + + time_bnds = self.comm.bcast(time_bnds, root=0) self.free_vars('time_bnds') @@ -2299,20 +2359,27 @@ class Nes(object): # TIMES time_var = netcdf.createVariable('time', np.float64, ('time',), zlib=self.zip_lvl > 0, complevel=self.zip_lvl) - time_var.units = 'hours since {0}'.format(self._time[0].strftime('%Y-%m-%d %H:%M:%S')) + time_var.units = '{0} since {1}'.format(self._time_resolution, self._time[0].strftime('%Y-%m-%d %H:%M:%S')) time_var.standard_name = 'time' time_var.calendar = 'standard' time_var.long_name = 'time' if self._time_bnds is not None: - time_var.bounds = 'time_bnds' + if self._climatology: + time_var.climatology = self._climatology_var_name + else: + time_var.bounds = 'time_bnds' if self.size > 1: time_var.set_collective(True) time_var[:] = date2num(self._time[:], time_var.units, time_var.calendar) # TIME BOUNDS if self._time_bnds is not None: - time_bnds_var = netcdf.createVariable('time_bnds', np.float64, ('time', 'time_nv',), zlib=self.zip_lvl, - complevel=self.zip_lvl) + if self._climatology: + time_bnds_var = netcdf.createVariable(self._climatology_var_name, np.float64, ('time', 'time_nv',), + zlib=self.zip_lvl, complevel=self.zip_lvl) + else: + time_bnds_var = netcdf.createVariable('time_bnds', np.float64, ('time', 'time_nv',), + zlib=self.zip_lvl, complevel=self.zip_lvl) if self.size > 1: time_bnds_var.set_collective(True) time_bnds_var[:] = date2num(self._time_bnds, time_var.units, calendar='standard') -- GitLab From 89017b43efd73978192a6c6fc8881f6844099cb4 Mon Sep 17 00:00:00 2001 From: ctena Date: Fri, 16 Jun 2023 16:27:05 +0200 Subject: [PATCH 8/9] Upgrading NES version. --- CHANGELOG.md | 7 ++++++- nes/__init__.py | 4 ++-- nes/methods/spatial_join.py | 2 +- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 75c131f..afcc8b6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,12 +1,17 @@ # NES CHANGELOG ### 1.1.3 -* Release date: Unknown +* Release date: 2023/06/16 * Changes and new features: * Rotated nested projection * Improved documentation + * New function get_fids() + * Climatology options added + * Milliseconds, seconds, minutes and days time units accepted + * Option to change the time units' resolution. * Bugs fixing: * The input arguments in function new() have been corrected + * Months to day time units fixed ### 1.1.2 * Release date: 2023/05/15 diff --git a/nes/__init__.py b/nes/__init__.py index 777a4bc..9a39cac 100644 --- a/nes/__init__.py +++ b/nes/__init__.py @@ -1,5 +1,5 @@ -__date__ = "2023-05-15" -__version__ = "1.1.2" +__date__ = "2023-06-16" +__version__ = "1.1.3" from .load_nes import open_netcdf, concatenate_netcdfs from .create_nes import create_nes, from_shapefile diff --git a/nes/methods/spatial_join.py b/nes/methods/spatial_join.py index 8ffc11a..20dcd06 100644 --- a/nes/methods/spatial_join.py +++ b/nes/methods/spatial_join.py @@ -232,7 +232,7 @@ def spatial_join_intersection(self, ext_shp, info=False): var_list.remove('geometry') grid_shp = self.shapefile - grid_shp['WRF-CHEM_grid'] = grid_shp.index + grid_shp['FID_grid'] = grid_shp.index grid_shp = grid_shp.reset_index() # Get intersected areas -- GitLab From d53b06f902da4b6447fd2a738e00ecf3620d1dd7 Mon Sep 17 00:00:00 2001 From: ctena Date: Thu, 22 Jun 2023 09:41:57 +0200 Subject: [PATCH 9/9] Preparing v1.1.3 --- nes/__init__.py | 2 +- nes/nc_projections/default_nes.py | 112 +++++++++++++++++++++++++ tests/run_scalability_tests_nord3v2.sh | 2 +- tests/test_bash_mn4.cmd | 2 +- tests/test_bash_nord3v2.cmd | 2 +- tutorials/Jupyter_bash_nord3v2.cmd | 2 +- 6 files changed, 117 insertions(+), 5 deletions(-) diff --git a/nes/__init__.py b/nes/__init__.py index 9a39cac..884723b 100644 --- a/nes/__init__.py +++ b/nes/__init__.py @@ -1,4 +1,4 @@ -__date__ = "2023-06-16" +__date__ = "2023-06-22" __version__ = "1.1.3" from .load_nes import open_netcdf, concatenate_netcdfs diff --git a/nes/nc_projections/default_nes.py b/nes/nc_projections/default_nes.py index 96dd65b..1aad7f7 100644 --- a/nes/nc_projections/default_nes.py +++ b/nes/nc_projections/default_nes.py @@ -2357,6 +2357,117 @@ class Nes(object): netcdf4-python open dataset. """ + self._create_dimension_variables_64(netcdf) + + return None + + def _create_dimension_variables_32(self, netcdf): + """ + Create the 'time', 'time_bnds', 'lev', 'lat', 'lat_bnds', 'lon' and 'lon_bnds' variables. + + Parameters + ---------- + netcdf : Dataset + netcdf4-python open dataset. + """ + + # TIMES + time_var = netcdf.createVariable('time', np.float32, ('time',), zlib=self.zip_lvl > 0, complevel=self.zip_lvl) + time_var.units = '{0} since {1}'.format(self._time_resolution, self._time[0].strftime('%Y-%m-%d %H:%M:%S')) + time_var.standard_name = 'time' + time_var.calendar = 'standard' + time_var.long_name = 'time' + if self._time_bnds is not None: + if self._climatology: + time_var.climatology = self._climatology_var_name + else: + time_var.bounds = 'time_bnds' + if self.size > 1: + time_var.set_collective(True) + time_var[:] = date2num(self._time[:], time_var.units, time_var.calendar) + + # TIME BOUNDS + if self._time_bnds is not None: + if self._climatology: + time_bnds_var = netcdf.createVariable(self._climatology_var_name, np.float64, ('time', 'time_nv',), + zlib=self.zip_lvl, complevel=self.zip_lvl) + else: + time_bnds_var = netcdf.createVariable('time_bnds', np.float64, ('time', 'time_nv',), + zlib=self.zip_lvl, complevel=self.zip_lvl) + if self.size > 1: + time_bnds_var.set_collective(True) + time_bnds_var[:] = date2num(self._time_bnds, time_var.units, calendar='standard') + + # LEVELS + lev = netcdf.createVariable('lev', np.float32, ('lev',), + zlib=self.zip_lvl > 0, complevel=self.zip_lvl) + if 'units' in self._lev.keys(): + lev.units = Units(self._lev['units'], formatted=True).units + else: + lev.units = '' + if 'positive' in self._lev.keys(): + lev.positive = self._lev['positive'] + + if self.size > 1: + lev.set_collective(True) + lev[:] = np.array(self._lev['data'], dtype=np.float32) + + # LATITUDES + lat = netcdf.createVariable('lat', np.float32, self._lat_dim, + zlib=self.zip_lvl > 0, complevel=self.zip_lvl) + lat.units = 'degrees_north' + lat.axis = 'Y' + lat.long_name = 'latitude coordinate' + lat.standard_name = 'latitude' + if self._lat_bnds is not None: + lat.bounds = 'lat_bnds' + if self.size > 1: + lat.set_collective(True) + lat[:] = np.array(self._lat['data'], dtype=np.float32) + + # LATITUDES BOUNDS + if self._lat_bnds is not None: + lat_bnds_var = netcdf.createVariable('lat_bnds', np.float32, + self._lat_dim + ('spatial_nv',), + zlib=self.zip_lvl > 0, complevel=self.zip_lvl) + if self.size > 1: + lat_bnds_var.set_collective(True) + lat_bnds_var[:] = np.array(self._lat_bnds['data'], dtype=np.float32) + + # LONGITUDES + lon = netcdf.createVariable('lon', np.float32, self._lon_dim, + zlib=self.zip_lvl > 0, complevel=self.zip_lvl) + lon.units = 'degrees_east' + lon.axis = 'X' + lon.long_name = 'longitude coordinate' + lon.standard_name = 'longitude' + if self._lon_bnds is not None: + lon.bounds = 'lon_bnds' + if self.size > 1: + lon.set_collective(True) + lon[:] = np.array(self._lon['data'], dtype=np.float32) + + # LONGITUDES BOUNDS + if self._lon_bnds is not None: + lon_bnds_var = netcdf.createVariable('lon_bnds', np.float32, + self._lon_dim + ('spatial_nv',), + zlib=self.zip_lvl > 0, complevel=self.zip_lvl) + if self.size > 1: + lon_bnds_var.set_collective(True) + lon_bnds_var[:] = np.array(self._lon_bnds['data'], dtype=np.float32) + + return None + + def _create_dimension_variables_64(self, netcdf): + """ + Create the 'time', 'time_bnds', 'lev', 'lat', 'lat_bnds', 'lon' and 'lon_bnds' variables. + + Parameters + ---------- + netcdf : Dataset + netcdf4-python open dataset. + """ + # TIMES time_var = netcdf.createVariable('time', np.float64, ('time',), zlib=self.zip_lvl > 0, complevel=self.zip_lvl) time_var.units = '{0} since {1}'.format(self._time_resolution, self._time[0].strftime('%Y-%m-%d %H:%M:%S')) @@ -2444,6 +2555,7 @@ class Nes(object): return None + def _create_cell_measures(self, netcdf): # CELL AREA diff --git a/tests/run_scalability_tests_nord3v2.sh b/tests/run_scalability_tests_nord3v2.sh index a2c5a18..0bd1291 100644 --- a/tests/run_scalability_tests_nord3v2.sh +++ b/tests/run_scalability_tests_nord3v2.sh @@ -5,7 +5,7 @@ SRCPATH="/gpfs/scratch/bsc32/bsc32538/NES_tests/NES/tests" module purge module load Python/3.7.4-GCCcore-8.3.0 -module load NES/1.1.2-nord3-v2-foss-2019b-Python-3.7.4 +module load NES/1.1.3-nord3-v2-foss-2019b-Python-3.7.4 for EXE in "1.1-test_read_write_projection.py" "1.2-test_create_projection.py" "1.3-test_selecting.py" "2.1-test_spatial_join.py" "2.2-test_create_shapefile.py" "2.3-test_bounds.py" "2.4-test_cell_area.py" "3.1-test_vertical_interp.py" "3.2-test_horiz_interp_bilinear.py" "3.3-test_horiz_interp_conservative.py" "4.1-test_daily_stats.py" "4.2-test_sum.py" "4.3-test_write_timestep.py" diff --git a/tests/test_bash_mn4.cmd b/tests/test_bash_mn4.cmd index 4a68c28..a7e8c73 100644 --- a/tests/test_bash_mn4.cmd +++ b/tests/test_bash_mn4.cmd @@ -15,7 +15,7 @@ module purge module use /gpfs/projects/bsc32/software/suselinux/11/modules/all -module load NES/1.1.2-mn4-foss-2019b-Python-3.7.4 +module load NES/1.1.3-mn4-foss-2019b-Python-3.7.4 module load OpenMPI/4.0.5-GCC-8.3.0-mn4 cd /gpfs/projects/bsc32/models/NES_master/tests || exit diff --git a/tests/test_bash_nord3v2.cmd b/tests/test_bash_nord3v2.cmd index 795048c..f66a17b 100644 --- a/tests/test_bash_nord3v2.cmd +++ b/tests/test_bash_nord3v2.cmd @@ -14,7 +14,7 @@ module purge -module load NES/1.1.2-nord3-v2-foss-2019b-Python-3.7.4 +module load NES/1.1.3-nord3-v2-foss-2019b-Python-3.7.4 cd /gpfs/projects/bsc32/models/NES_master/tests || exit diff --git a/tutorials/Jupyter_bash_nord3v2.cmd b/tutorials/Jupyter_bash_nord3v2.cmd index 82c3894..c6a91fa 100644 --- a/tutorials/Jupyter_bash_nord3v2.cmd +++ b/tutorials/Jupyter_bash_nord3v2.cmd @@ -25,7 +25,7 @@ localhost:${port} (prefix w/ https:// if using password) # load modules or conda environments here module load jupyterlab/3.0.9-foss-2019b-Python-3.7.4 -module load NES/1.1.2-nord3-v2-foss-2019b-Python-3.7.4 +module load NES/1.1.3-nord3-v2-foss-2019b-Python-3.7.4 # DON'T USE ADDRESS BELOW. -- GitLab