From d67269457836bcaee09f34f0727aba0b9d49474a Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Tue, 22 Jun 2021 15:45:44 +0200 Subject: [PATCH 01/19] add initial CMIP interface --- atlite/cutout.py | 2 + atlite/data.py | 8 +- atlite/datasets/__init__.py | 4 +- atlite/datasets/cmip.py | 220 ++++++++++++++++++++++++++++++++++++ atlite/datasets/cmip.yml | 9 ++ 5 files changed, 238 insertions(+), 5 deletions(-) create mode 100644 atlite/datasets/cmip.py create mode 100644 atlite/datasets/cmip.yml diff --git a/atlite/cutout.py b/atlite/cutout.py index a4a501e4..db263e7b 100644 --- a/atlite/cutout.py +++ b/atlite/cutout.py @@ -126,6 +126,8 @@ def __init__(self, path, **cutoutparams): gebco_path: str Path to find the gebco netcdf file. Only necessary when including the gebco module. + roughness_path: + Path to external roughness dataset parallel : bool, default False Whether to open dataset in parallel mode. Take effect for all xr.open_mfdataset usages. diff --git a/atlite/data.py b/atlite/data.py index 60dadcad..95397168 100644 --- a/atlite/data.py +++ b/atlite/data.py @@ -42,14 +42,16 @@ def get_features(cutout, module, features, tmpdir=None): cutout, feature, tmpdir=tmpdir, lock=lock, **parameters ) datasets.append(feature_data) - datasets = compute(*datasets) ds = xr.merge(datasets, compat="equals") for v in ds: - ds[v].attrs["module"] = module fd = datamodules[module].features.items() - ds[v].attrs["feature"] = [k for k, l in fd if v in l].pop() + if v in fd: + ds[v].attrs["module"] = module + + print([k for k, l in fd if v in l]) + ds[v].attrs["feature"] = [k for k, l in fd if v in l].pop() return ds diff --git a/atlite/datasets/__init__.py b/atlite/datasets/__init__.py index 0b7ca9c4..b7a14bef 100644 --- a/atlite/datasets/__init__.py +++ b/atlite/datasets/__init__.py @@ -4,6 +4,6 @@ # # SPDX-License-Identifier: GPL-3.0-or-later -from . import era5, sarah, gebco +from . import era5, sarah, gebco, cmip -modules = {"era5": era5, "sarah": sarah, "gebco": gebco} +modules = {"era5": era5, "sarah": sarah, "gebco": gebco, "cmip":cmip} diff --git a/atlite/datasets/cmip.py b/atlite/datasets/cmip.py new file mode 100644 index 00000000..4eb97571 --- /dev/null +++ b/atlite/datasets/cmip.py @@ -0,0 +1,220 @@ +""" +Module for downloading and preparing data from the ESGF servers +to be used in atlite + + +""" + +import xarray as xr +from pyesgf.search import SearchConnection + +import logging +import yaml +import dask +from pathlib import Path +import pkg_resources +from ..gis import maybe_swap_spatial_dims +from pyesgf.logon import LogonManager +import numpy as np + +logger = logging.getLogger(__name__) + +features = { + "wind" : ["wnd10m"], + "influx" : ["influx","outflux"], + "temperature" : ["temperature"], + "runoff" : ["runoff"] +} +CMIP_SETUP_FILE = Path(pkg_resources.resource_filename(__name__,'cmip.yml')) + + +crs = 4326 + +static_features = {"height"} + +dask.config.set({'array.slicing.split_large_chunks': True}) + +def search_ESGF(esgf_params, url='https://esgf-data.dkrz.de/esg-search'): + conn = SearchConnection(url, distrib=True) + ctx = conn.new_context( + latest=True, + **esgf_params + ) + + if ctx.hit_count==0: + ctx = ctx.constrain(frequency=esgf_params['frequency']+'Pt') + if ctx.hit_count==0: + raise(ValueError("No results found in the ESGF_database")) + latest = ctx.search()[0] + return latest.file_context().search() + + +def get_data_influx(esgf_params,cutout,**retrieval_params): + """Get influx data for given retrieval parameters.""" + coords = cutout.coords + ds = retrieve_data(esgf_params, coords, + variables=["rsds","rsus"], + **retrieval_params, + ) + + ds = _rename_and_fix_coords(ds, cutout.dt) + + ds = ds.rename({"rsds": "influx", "rsus": "outflux"}) + + return ds + + +def get_data_temperature(esgf_params,cutout,**retrieval_params): + """Get temperature for given retrieval parameters.""" + coords = cutout.coords + ds = retrieve_data(esgf_params, coords, + variables=["tas"], **retrieval_params + ) + + ds = _rename_and_fix_coords(ds, cutout.dt) + ds = ds.rename({"tas": "temperature"}) + + + return ds + + +def get_data_wind(esgf_params,cutout,**retrieval_params): + """Get wind for given retrieval parameters""" + + coords = cutout.coords + ds = retrieve_data(esgf_params, coords, ['sfcWind'], **retrieval_params) + ds = _rename_and_fix_coords(ds, cutout.dt) + ds = ds.rename({'sfcWind':'wnd{:0d}'.format(int(ds.sfcWind.height.values))}) + return ds + +def retrieve_data(esgf_params, coords,variables , + chunks=None, tmpdir=None, lock=None, **updates): + """ + Download data from egsf database + + """ + time = coords['time'].to_index() + years = time.year.unique() + dsets = [] + for variable in variables: + esgf_params['variable'] = variable + search_results = search_ESGF(esgf_params) + + files = [f.opendap_url for f in search_results if int(f.opendap_url.split('_')[-1][:4]) in years] + dsets.append(xr.open_mfdataset(files,chunks=chunks,concat_dim=['time'])) + ds = xr.merge(dsets) + + ds.attrs = {**ds.attrs, **esgf_params} + return ds + +def _rename_and_fix_coords(ds, dt,add_lon_lat=True, add_ctime=True): + """Rename 'longitude' and 'latitude' columns to 'x' and 'y' and fix roundings. + + Optionally (add_lon_lat, default:True) preserves latitude and longitude + columns as 'lat' and 'lon'. + + CMIP specifics; shif the longitude from 0..360 to -180..180. In addition + CMIP sometimes specify the time in the center of the output intervall this shifted + to the beginning. + """ + ds = ds.assign_coords(lon=(((ds.lon + 180) % 360) - 180)) + ds.lon.attrs['valid_max'] = 180 + ds.lon.attrs['valid_min'] = -180 + ds = ds.sortby('lon') + + ds = ds.rename({"lon": "x", "lat": "y"}) + # round coords since cds coords are float32 which would lead to mismatches + # ds = ds.assign_coords( + # x=np.round(ds.x.astype(float), 5), y=np.round(ds.y.astype(float), 5) + # ) + + ds = maybe_swap_spatial_dims(ds) + if add_lon_lat: + ds = ds.assign_coords(lon=ds.coords["x"], lat=ds.coords["y"]) + if add_ctime: + ds = ds.assign_coords(ctime=ds.coords['time']) + + # shift averaged data to beginning of bin + ds = ds.assign_coords(time=ds.coords['time'].dt.floor(dt)) + + + return ds + +def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): + """ + Retrieve data from the ESGF CMIP database. + + This front-end function downloads data for a specific feature and formats + it to match the given Cutout. + + Parameters + ---------- + cutout : atlite.Cutout + feature : str + Name of the feature data to retrieve. Must be in + `atlite.datasets.era5.features` + tmpdir : str/Path + Directory where the temporary netcdf files are stored. + **creation_parameters : + Additional keyword arguments. The only effective argument is 'sanitize' + (default True) which sets sanitization of the data on or off. + + Returns + ------- + xarray.Dataset + Dataset of dask arrays of the retrieved variables. + + """ + coords = cutout.coords + + # sanitize = creation_parameters.get("sanitize", True) + + if creation_parameters.get("esgf_params")== None: + with open(CMIP_SETUP_FILE , 'r') as f: + cmip_params = yaml.safe_load(f) + + model = creation_parameters.get("model") + if model: + try: + esgf_params = cmip_params[model] + except: + KeyError(f'{model} not reconized, update cmip.yml') + else: + raise(ValueError('Model not specified')) + else: + esgf_params = cutout.data.attrs.pop('esgf_params') + if esgf_params.get("frequency")==None: + if cutout.dt =='H': + freq = 'h' + elif cutout.dt =='3H': + freq = '3hr' + elif cutout.dt =='6H': + freq = '6hr' + elif cutout.dt == 'D': + freq = 'day' + elif cutout.dt =='M': + freq = 'mon' + elif cutout.dt == 'Y': + freq ='year' + else: + raise(ValueError(f'{cutout.dt} not valid time frequency in CMIP')) + + + retrieval_params = { + "chunks": cutout.chunks, + "tmpdir": tmpdir, + "lock": lock + } + + func = globals().get(f"get_data_{feature}") + # sanitize_func = globals().get(f"sanitize_{feature}") + + logger.info(f"Requesting data for feature {feature}...") + ds = func(esgf_params, cutout, **retrieval_params) + ds = ds.sel(time=coords['time']) + bounds = cutout.bounds + ds = ds.sel(x=slice(bounds[0],bounds[2]),y=slice(bounds[1],bounds[3])) + ds = ds.interp({'x':cutout.data.x, 'y':cutout.data.y}) + return ds + + diff --git a/atlite/datasets/cmip.yml b/atlite/datasets/cmip.yml new file mode 100644 index 00000000..8548becc --- /dev/null +++ b/atlite/datasets/cmip.yml @@ -0,0 +1,9 @@ +EC-Earth3: + data_node: 'esg-dn2.nsc.liu.se' + source_id: 'EC-Earth3' + variant_label: 'r1i1p1f1' + experiment_id: 'ssp126' + frequency: '3hr' + project: 'CMIP6' + + From 12912ca7d1f43aadf3866048e9b953e94d8f200f Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Wed, 23 Jun 2021 10:55:01 +0200 Subject: [PATCH 02/19] working cmip interface with atlite --- atlite/cutout.py | 3 ++- atlite/data.py | 11 +++++------ atlite/datasets/cmip.py | 24 +++++++++++++++++++----- atlite/datasets/cmip.yml | 4 ++-- 4 files changed, 28 insertions(+), 14 deletions(-) diff --git a/atlite/cutout.py b/atlite/cutout.py index db263e7b..edf5aa15 100644 --- a/atlite/cutout.py +++ b/atlite/cutout.py @@ -147,6 +147,7 @@ def __init__(self, path, **cutoutparams): chunks = cutoutparams.pop("chunks", {"time": 100}) storable_chunks = {f"chunksize_{k}": v for k, v in (chunks or {}).items()} + self.esgf_params = cutoutparams.pop("esgf_params", None) # Backward compatibility for xs, ys, months and years if {"xs", "ys"}.intersection(cutoutparams): warn( @@ -306,7 +307,7 @@ def transform_r(self): def dx(self): x = self.coords["x"] return round((x[-1] - x[0]).item() / (x.size - 1), 8) - + @property def dy(self): y = self.coords["y"] diff --git a/atlite/data.py b/atlite/data.py index 95397168..4567f6ee 100644 --- a/atlite/data.py +++ b/atlite/data.py @@ -19,6 +19,7 @@ from dask.utils import SerializableLock from dask.diagnostics import ProgressBar import logging +from itertools import chain logger = logging.getLogger(__name__) @@ -43,14 +44,12 @@ def get_features(cutout, module, features, tmpdir=None): ) datasets.append(feature_data) datasets = compute(*datasets) - ds = xr.merge(datasets, compat="equals") + fd = datamodules[module].features.items() + datavars = list(chain(*[l for k, l in fd])) for v in ds: - fd = datamodules[module].features.items() - if v in fd: - ds[v].attrs["module"] = module - - print([k for k, l in fd if v in l]) + ds[v].attrs["module"] = module + if v in datavars: ds[v].attrs["feature"] = [k for k, l in fd if v in l].pop() return ds diff --git a/atlite/datasets/cmip.py b/atlite/datasets/cmip.py index 4eb97571..695ed2a5 100644 --- a/atlite/datasets/cmip.py +++ b/atlite/datasets/cmip.py @@ -48,6 +48,17 @@ def search_ESGF(esgf_params, url='https://esgf-data.dkrz.de/esg-search'): latest = ctx.search()[0] return latest.file_context().search() +def get_data_runoff(esgf_params,cutout,**retrieval_params): + """Get runoff data for given retrieval parameters""" + coords = cutout.coords + ds = retrieve_data(esgf_params, coords, + variables=["mrro"], + **retrieval_params, + ) + ds = _rename_and_fix_coords(ds, cutout.dt) + ds = ds.rename({'mrro':'runoff'}) + return ds + def get_data_influx(esgf_params,cutout,**retrieval_params): """Get influx data for given retrieval parameters.""" @@ -73,6 +84,7 @@ def get_data_temperature(esgf_params,cutout,**retrieval_params): ds = _rename_and_fix_coords(ds, cutout.dt) ds = ds.rename({"tas": "temperature"}) + ds = ds.drop_vars('height') return ds @@ -84,7 +96,8 @@ def get_data_wind(esgf_params,cutout,**retrieval_params): coords = cutout.coords ds = retrieve_data(esgf_params, coords, ['sfcWind'], **retrieval_params) ds = _rename_and_fix_coords(ds, cutout.dt) - ds = ds.rename({'sfcWind':'wnd{:0d}'.format(int(ds.sfcWind.height.values))}) + ds = ds.rename({'sfcWind':'wnd{:0d}m'.format(int(ds.sfcWind.height.values))}) + ds = ds.drop_vars('height') return ds def retrieve_data(esgf_params, coords,variables , @@ -99,15 +112,16 @@ def retrieve_data(esgf_params, coords,variables , for variable in variables: esgf_params['variable'] = variable search_results = search_ESGF(esgf_params) - files = [f.opendap_url for f in search_results if int(f.opendap_url.split('_')[-1][:4]) in years] + dsets.append(xr.open_mfdataset(files,chunks=chunks,concat_dim=['time'])) ds = xr.merge(dsets) ds.attrs = {**ds.attrs, **esgf_params} + return ds -def _rename_and_fix_coords(ds, dt,add_lon_lat=True, add_ctime=True): +def _rename_and_fix_coords(ds, dt,add_lon_lat=True, add_ctime=False): """Rename 'longitude' and 'latitude' columns to 'x' and 'y' and fix roundings. Optionally (add_lon_lat, default:True) preserves latitude and longitude @@ -169,7 +183,7 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): # sanitize = creation_parameters.get("sanitize", True) - if creation_parameters.get("esgf_params")== None: + if cutout.esgf_params== None: with open(CMIP_SETUP_FILE , 'r') as f: cmip_params = yaml.safe_load(f) @@ -182,7 +196,7 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): else: raise(ValueError('Model not specified')) else: - esgf_params = cutout.data.attrs.pop('esgf_params') + esgf_params = cutout.esgf_params if esgf_params.get("frequency")==None: if cutout.dt =='H': freq = 'h' diff --git a/atlite/datasets/cmip.yml b/atlite/datasets/cmip.yml index 8548becc..784b7878 100644 --- a/atlite/datasets/cmip.yml +++ b/atlite/datasets/cmip.yml @@ -1,7 +1,7 @@ EC-Earth3: - data_node: 'esg-dn2.nsc.liu.se' + data_node: 'esgf-cnr.hpc.cineca.it' source_id: 'EC-Earth3' - variant_label: 'r1i1p1f1' + variant_label: 'r4i1p1f1' experiment_id: 'ssp126' frequency: '3hr' project: 'CMIP6' From ca50bd29acc48b44655ba29bd749f3d944a9885e Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Wed, 23 Jun 2021 13:04:01 +0200 Subject: [PATCH 03/19] update dependencies --- atlite/cutout.py | 4 +- atlite/data.py | 6 +- atlite/datasets/__init__.py | 2 +- atlite/datasets/cmip.py | 173 +++++++++++++++++++----------------- environment.yaml | 1 + 5 files changed, 101 insertions(+), 85 deletions(-) diff --git a/atlite/cutout.py b/atlite/cutout.py index 24267a9f..9125bb82 100644 --- a/atlite/cutout.py +++ b/atlite/cutout.py @@ -126,7 +126,7 @@ def __init__(self, path, **cutoutparams): gebco_path: str Path to find the gebco netcdf file. Only necessary when including the gebco module. - roughness_path: + roughness_path: Path to external roughness dataset parallel : bool, default False Whether to open dataset in parallel mode. Take effect for all @@ -316,7 +316,7 @@ def dx(self): """Spatial resolution on the x coordinates.""" x = self.coords["x"] return round((x[-1] - x[0]).item() / (x.size - 1), 8) - + @property def dy(self): """Spatial resolution on the y coordinates.""" diff --git a/atlite/data.py b/atlite/data.py index 4567f6ee..ba2cbc70 100644 --- a/atlite/data.py +++ b/atlite/data.py @@ -45,11 +45,15 @@ def get_features(cutout, module, features, tmpdir=None): datasets.append(feature_data) datasets = compute(*datasets) ds = xr.merge(datasets, compat="equals") + # for v in ds: + # ds[v].attrs["module"] = module + # fd = datamodules[module].features.items() + # ds[v].attrs["feature"] = [k for k, l in fd if v in l].pop() fd = datamodules[module].features.items() datavars = list(chain(*[l for k, l in fd])) for v in ds: ds[v].attrs["module"] = module - if v in datavars: + if v in datavars: ds[v].attrs["feature"] = [k for k, l in fd if v in l].pop() return ds diff --git a/atlite/datasets/__init__.py b/atlite/datasets/__init__.py index b7a14bef..ecba72bf 100644 --- a/atlite/datasets/__init__.py +++ b/atlite/datasets/__init__.py @@ -6,4 +6,4 @@ from . import era5, sarah, gebco, cmip -modules = {"era5": era5, "sarah": sarah, "gebco": gebco, "cmip":cmip} +modules = {"era5": era5, "sarah": sarah, "gebco": gebco, "cmip": cmip} diff --git a/atlite/datasets/cmip.py b/atlite/datasets/cmip.py index 695ed2a5..da0564ac 100644 --- a/atlite/datasets/cmip.py +++ b/atlite/datasets/cmip.py @@ -14,57 +14,71 @@ from pathlib import Path import pkg_resources from ..gis import maybe_swap_spatial_dims -from pyesgf.logon import LogonManager import numpy as np +# Null context for running a with statements wihout any context +try: + from contextlib import nullcontext +except ImportError: + # for Python verions < 3.7: + import contextlib + + @contextlib.contextmanager + def nullcontext(): + yield + + logger = logging.getLogger(__name__) features = { - "wind" : ["wnd10m"], - "influx" : ["influx","outflux"], - "temperature" : ["temperature"], - "runoff" : ["runoff"] + "wind": ["wnd10m"], + "influx": ["influx", "outflux"], + "temperature": ["temperature"], + "runoff": ["runoff"], } -CMIP_SETUP_FILE = Path(pkg_resources.resource_filename(__name__,'cmip.yml')) +CMIP_SETUP_FILE = Path(pkg_resources.resource_filename(__name__, "cmip.yml")) crs = 4326 static_features = {"height"} -dask.config.set({'array.slicing.split_large_chunks': True}) +dask.config.set({"array.slicing.split_large_chunks": True}) -def search_ESGF(esgf_params, url='https://esgf-data.dkrz.de/esg-search'): + +def search_ESGF(esgf_params, url="https://esgf-data.dkrz.de/esg-search"): conn = SearchConnection(url, distrib=True) - ctx = conn.new_context( - latest=True, - **esgf_params - ) - - if ctx.hit_count==0: - ctx = ctx.constrain(frequency=esgf_params['frequency']+'Pt') - if ctx.hit_count==0: - raise(ValueError("No results found in the ESGF_database")) + ctx = conn.new_context(latest=True, **esgf_params) + + if ctx.hit_count == 0: + ctx = ctx.constrain(frequency=esgf_params["frequency"] + "Pt") + if ctx.hit_count == 0: + raise (ValueError("No results found in the ESGF_database")) latest = ctx.search()[0] return latest.file_context().search() -def get_data_runoff(esgf_params,cutout,**retrieval_params): + +def get_data_runoff(esgf_params, cutout, **retrieval_params): """Get runoff data for given retrieval parameters""" coords = cutout.coords - ds = retrieve_data(esgf_params, coords, + ds = retrieve_data( + esgf_params, + coords, variables=["mrro"], **retrieval_params, ) ds = _rename_and_fix_coords(ds, cutout.dt) - ds = ds.rename({'mrro':'runoff'}) + ds = ds.rename({"mrro": "runoff"}) return ds -def get_data_influx(esgf_params,cutout,**retrieval_params): +def get_data_influx(esgf_params, cutout, **retrieval_params): """Get influx data for given retrieval parameters.""" coords = cutout.coords - ds = retrieve_data(esgf_params, coords, - variables=["rsds","rsus"], + ds = retrieve_data( + esgf_params, + coords, + variables=["rsds", "rsus"], **retrieval_params, ) @@ -75,85 +89,89 @@ def get_data_influx(esgf_params,cutout,**retrieval_params): return ds -def get_data_temperature(esgf_params,cutout,**retrieval_params): +def get_data_temperature(esgf_params, cutout, **retrieval_params): """Get temperature for given retrieval parameters.""" coords = cutout.coords - ds = retrieve_data(esgf_params, coords, - variables=["tas"], **retrieval_params - ) + ds = retrieve_data(esgf_params, coords, variables=["tas"], **retrieval_params) ds = _rename_and_fix_coords(ds, cutout.dt) ds = ds.rename({"tas": "temperature"}) - ds = ds.drop_vars('height') - + ds = ds.drop_vars("height") return ds -def get_data_wind(esgf_params,cutout,**retrieval_params): +def get_data_wind(esgf_params, cutout, **retrieval_params): """Get wind for given retrieval parameters""" coords = cutout.coords - ds = retrieve_data(esgf_params, coords, ['sfcWind'], **retrieval_params) + ds = retrieve_data(esgf_params, coords, ["sfcWind"], **retrieval_params) ds = _rename_and_fix_coords(ds, cutout.dt) - ds = ds.rename({'sfcWind':'wnd{:0d}m'.format(int(ds.sfcWind.height.values))}) - ds = ds.drop_vars('height') + ds = ds.rename({"sfcWind": "wnd{:0d}m".format(int(ds.sfcWind.height.values))}) + ds = ds.drop_vars("height") return ds -def retrieve_data(esgf_params, coords,variables , - chunks=None, tmpdir=None, lock=None, **updates): + +def retrieve_data( + esgf_params, coords, variables, chunks=None, tmpdir=None, lock=None, **updates +): """ Download data from egsf database """ - time = coords['time'].to_index() + time = coords["time"].to_index() years = time.year.unique() dsets = [] for variable in variables: - esgf_params['variable'] = variable + esgf_params["variable"] = variable search_results = search_ESGF(esgf_params) - files = [f.opendap_url for f in search_results if int(f.opendap_url.split('_')[-1][:4]) in years] + files = [ + f.opendap_url + for f in search_results + if int(f.opendap_url.split("_")[-1][:4]) in years + ] - dsets.append(xr.open_mfdataset(files,chunks=chunks,concat_dim=['time'])) + dsets.append(xr.open_mfdataset(files, chunks=chunks, concat_dim=["time"])) ds = xr.merge(dsets) ds.attrs = {**ds.attrs, **esgf_params} - + return ds -def _rename_and_fix_coords(ds, dt,add_lon_lat=True, add_ctime=False): + +def _rename_and_fix_coords(ds, dt, add_lon_lat=True, add_ctime=False): """Rename 'longitude' and 'latitude' columns to 'x' and 'y' and fix roundings. Optionally (add_lon_lat, default:True) preserves latitude and longitude columns as 'lat' and 'lon'. CMIP specifics; shif the longitude from 0..360 to -180..180. In addition - CMIP sometimes specify the time in the center of the output intervall this shifted - to the beginning. + CMIP sometimes specify the time in the center of the output intervall this shifted + to the beginning. """ ds = ds.assign_coords(lon=(((ds.lon + 180) % 360) - 180)) - ds.lon.attrs['valid_max'] = 180 - ds.lon.attrs['valid_min'] = -180 - ds = ds.sortby('lon') + ds.lon.attrs["valid_max"] = 180 + ds.lon.attrs["valid_min"] = -180 + ds = ds.sortby("lon") ds = ds.rename({"lon": "x", "lat": "y"}) # round coords since cds coords are float32 which would lead to mismatches # ds = ds.assign_coords( # x=np.round(ds.x.astype(float), 5), y=np.round(ds.y.astype(float), 5) # ) - + ds = maybe_swap_spatial_dims(ds) if add_lon_lat: ds = ds.assign_coords(lon=ds.coords["x"], lat=ds.coords["y"]) if add_ctime: - ds = ds.assign_coords(ctime=ds.coords['time']) - - # shift averaged data to beginning of bin - ds = ds.assign_coords(time=ds.coords['time'].dt.floor(dt)) + ds = ds.assign_coords(ctime=ds.coords["time"]) + # shift averaged data to beginning of bin + ds = ds.assign_coords(time=ds.coords["time"].dt.floor(dt)) return ds + def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): """ Retrieve data from the ESGF CMIP database. @@ -183,52 +201,45 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): # sanitize = creation_parameters.get("sanitize", True) - if cutout.esgf_params== None: - with open(CMIP_SETUP_FILE , 'r') as f: + if cutout.esgf_params == None: + with open(CMIP_SETUP_FILE, "r") as f: cmip_params = yaml.safe_load(f) - + model = creation_parameters.get("model") if model: try: esgf_params = cmip_params[model] except: - KeyError(f'{model} not reconized, update cmip.yml') + KeyError(f"{model} not reconized, update cmip.yml") else: - raise(ValueError('Model not specified')) + raise (ValueError("Model not specified")) else: esgf_params = cutout.esgf_params - if esgf_params.get("frequency")==None: - if cutout.dt =='H': - freq = 'h' - elif cutout.dt =='3H': - freq = '3hr' - elif cutout.dt =='6H': - freq = '6hr' - elif cutout.dt == 'D': - freq = 'day' - elif cutout.dt =='M': - freq = 'mon' - elif cutout.dt == 'Y': - freq ='year' + if esgf_params.get("frequency") == None: + if cutout.dt == "H": + freq = "h" + elif cutout.dt == "3H": + freq = "3hr" + elif cutout.dt == "6H": + freq = "6hr" + elif cutout.dt == "D": + freq = "day" + elif cutout.dt == "M": + freq = "mon" + elif cutout.dt == "Y": + freq = "year" else: - raise(ValueError(f'{cutout.dt} not valid time frequency in CMIP')) - + raise (ValueError(f"{cutout.dt} not valid time frequency in CMIP")) - retrieval_params = { - "chunks": cutout.chunks, - "tmpdir": tmpdir, - "lock": lock - } + retrieval_params = {"chunks": cutout.chunks, "tmpdir": tmpdir, "lock": lock} func = globals().get(f"get_data_{feature}") # sanitize_func = globals().get(f"sanitize_{feature}") logger.info(f"Requesting data for feature {feature}...") ds = func(esgf_params, cutout, **retrieval_params) - ds = ds.sel(time=coords['time']) + ds = ds.sel(time=coords["time"]) bounds = cutout.bounds - ds = ds.sel(x=slice(bounds[0],bounds[2]),y=slice(bounds[1],bounds[3])) - ds = ds.interp({'x':cutout.data.x, 'y':cutout.data.y}) + ds = ds.sel(x=slice(bounds[0], bounds[2]), y=slice(bounds[1], bounds[3])) + ds = ds.interp({"x": cutout.data.x, "y": cutout.data.y}) return ds - - diff --git a/environment.yaml b/environment.yaml index 6a1b9ba5..72030069 100644 --- a/environment.yaml +++ b/environment.yaml @@ -26,6 +26,7 @@ dependencies: - shapely - progressbar2 - tqdm + - esgf-pyclient # dev tools - black From 04840f4982d8add638d0fa82692760dcebdb610d Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Thu, 24 Jun 2021 09:59:55 +0200 Subject: [PATCH 04/19] add esgf-pyclient --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index c498d725..5dc62d47 100644 --- a/setup.py +++ b/setup.py @@ -43,6 +43,7 @@ "pyproj>=2", "geopandas", "cdsapi", + "esgf-pyclient", ], extras_require={ "docs": ["numpydoc", "sphinx", "sphinx_rtd_theme", "nbsphinx", "nbsphinx-link"], From d23f0517f66a06ea04a79fbd43d4bd0d00385971 Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Thu, 24 Jun 2021 10:02:45 +0200 Subject: [PATCH 05/19] change orography to geopotential --- atlite/datasets/era5.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/atlite/datasets/era5.py b/atlite/datasets/era5.py index f351a865..cdc18d65 100644 --- a/atlite/datasets/era5.py +++ b/atlite/datasets/era5.py @@ -181,7 +181,8 @@ def sanitize_runoff(ds): def get_data_height(retrieval_params): """Get height data for given retrieval parameters.""" - ds = retrieve_data(variable="orography", **retrieval_params) + ds = retrieve_data(variable='geopotential',**retrieval_params) + #ds = retrieve_data(variable="orography", **retrieval_params) ds = _rename_and_clean_coords(ds) ds = _add_height(ds) From 22d7f98185ca6786efbb0893499f4f1d58fcd4cc Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Mon, 28 Jun 2021 12:06:32 +0200 Subject: [PATCH 06/19] add sanitize_runoff cmip --- atlite/cutout.py | 12 +++++++++--- atlite/datasets/cmip.py | 38 ++++++++++++++++++++++++++------------ 2 files changed, 35 insertions(+), 15 deletions(-) diff --git a/atlite/cutout.py b/atlite/cutout.py index 9125bb82..5eb91698 100644 --- a/atlite/cutout.py +++ b/atlite/cutout.py @@ -78,7 +78,7 @@ def __init__(self, path, **cutoutparams): NetCDF from which to load or where to store the cutout. module : str or list The dataset(s) which works as a basis for the cutout. Available - modules are "era5", "sarah" and "gebco". + modules are "era5", "sarah", "cmip" and "gebco". This is necessary when building a new cutout. If more than one module is given, their order determines how atlite fills up missing features when preparing the cutout with @@ -126,8 +126,14 @@ def __init__(self, path, **cutoutparams): gebco_path: str Path to find the gebco netcdf file. Only necessary when including the gebco module. - roughness_path: - Path to external roughness dataset + esgf_params: dict + Parameters to be used in search on the ESGF database. + model: str + The ESGF search parameters can also be specified in the cmip.yml file, + then model correspond to the name of the model specifed in the cmip.yml file. + roughness_path: str + Path to external roughness dataset, required for converting CMIP + winds. parallel : bool, default False Whether to open dataset in parallel mode. Take effect for all xr.open_mfdataset usages. diff --git a/atlite/datasets/cmip.py b/atlite/datasets/cmip.py index da0564ac..dc3e472c 100644 --- a/atlite/datasets/cmip.py +++ b/atlite/datasets/cmip.py @@ -71,6 +71,12 @@ def get_data_runoff(esgf_params, cutout, **retrieval_params): ds = ds.rename({"mrro": "runoff"}) return ds +def sanitize_runoff(ds): + """Sanitize retrieved runoff data.""" + ds["runoff"] = ds["runoff"].clip(min=0.0) + return ds + + def get_data_influx(esgf_params, cutout, **retrieval_params): """Get influx data for given retrieval parameters.""" @@ -88,6 +94,11 @@ def get_data_influx(esgf_params, cutout, **retrieval_params): return ds +def sanitize_inflow(ds): + """Sanitize retrieved inflow data.""" + ds['influx'] = ds['influx'].clip(min=0.0) + return ds + def get_data_temperature(esgf_params, cutout, **retrieval_params): """Get temperature for given retrieval parameters.""" @@ -113,8 +124,7 @@ def get_data_wind(esgf_params, cutout, **retrieval_params): def retrieve_data( - esgf_params, coords, variables, chunks=None, tmpdir=None, lock=None, **updates -): + esgf_params, coords, variables, chunks=None, tmpdir=None, lock=None): """ Download data from egsf database @@ -122,16 +132,19 @@ def retrieve_data( time = coords["time"].to_index() years = time.year.unique() dsets = [] - for variable in variables: - esgf_params["variable"] = variable - search_results = search_ESGF(esgf_params) - files = [ - f.opendap_url - for f in search_results - if int(f.opendap_url.split("_")[-1][:4]) in years - ] - - dsets.append(xr.open_mfdataset(files, chunks=chunks, concat_dim=["time"])) + if lock is None: + lock = nullcontext() + with lock: + for variable in variables: + esgf_params["variable"] = variable + search_results = search_ESGF(esgf_params) + files = [ + f.opendap_url + for f in search_results + if int(f.opendap_url.split("_")[-1][:4]) in years + ] + + dsets.append(xr.open_mfdataset(files, chunks=chunks, concat_dim=["time"])) ds = xr.merge(dsets) ds.attrs = {**ds.attrs, **esgf_params} @@ -234,6 +247,7 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): retrieval_params = {"chunks": cutout.chunks, "tmpdir": tmpdir, "lock": lock} func = globals().get(f"get_data_{feature}") + # sanitize_func = globals().get(f"sanitize_{feature}") logger.info(f"Requesting data for feature {feature}...") From 70c3b3d1e4eee5bfea19c94d011877447adc09e3 Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Tue, 29 Jun 2021 13:24:55 +0200 Subject: [PATCH 07/19] add cmip example --- examples/cmip_interface_example.ipynb | 424 ++++++++++++++++++++++++++ 1 file changed, 424 insertions(+) create mode 100644 examples/cmip_interface_example.ipynb diff --git a/examples/cmip_interface_example.ipynb b/examples/cmip_interface_example.ipynb new file mode 100644 index 00000000..d1fc29bc --- /dev/null +++ b/examples/cmip_interface_example.ipynb @@ -0,0 +1,424 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "91245dec-e5bc-4acf-b8bf-b8d67652c927", + "metadata": {}, + "outputs": [], + "source": [ + "from atlite.datasets.era5 import retrieve_data, _rename_and_clean_coords, retrieval_times, _area\n", + "from dask.utils import SerializableLock\n", + "import xarray as xr\n", + "import atlite\n", + "import logging\n", + "import cdsapi\n", + "from cartopy.io import shapereader\n", + "import geopandas as gpd\n", + "import cartopy.crs as ccrs\n", + "from cartopy.mpl.gridliner import LongitudeFormatter, LatitudeFormatter\n", + "import matplotlib.pyplot as plt\n", + "logging.basicConfig(level=logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "14dfd92a-93df-4109-9302-e3c53bbbd436", + "metadata": {}, + "outputs": [], + "source": [ + "def natural_earth_shapes_EU(join_dict, drop_non_Europe=['MA','DZ','TN','GI']):\n", + " # Download shape file (high resolution)\n", + " shpfilename = shapereader.natural_earth(resolution='10m',\n", + " category='cultural',\n", + " name='admin_1_states_provinces')\n", + "\n", + " \n", + " df =gpd.read_file(shpfilename)\n", + " df = df.cx[-13:32,35:80]\n", + " df = df[['iso_a2','geometry']]\n", + " df = df.dissolve('iso_a2')\n", + " df.index = list(df.index)\n", + " drop_regions = drop_non_Europe\n", + " # Absorbe microstates\n", + " for main_r,sub_rs in join_dict.items():\n", + " temp_main = df.loc[main_r,'geometry']\n", + " for sub_r in sub_rs:\n", + " drop_regions.append(sub_r)\n", + " temp_r = df.loc[sub_r,'geometry']\n", + " \n", + " temp_main = temp_main.union(temp_r)\n", + " temp_main = gpd.GeoSeries([temp_main])\n", + " df.loc[[main_r],'geometry'] = temp_main.values\n", + " \n", + " df = df.drop(index=drop_regions)\n", + " return df\n" + ] + }, + { + "cell_type": "markdown", + "id": "7b336846-42b6-46c8-b3c1-3ec4c842b043", + "metadata": {}, + "source": [ + "Create Europe shapefile" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6b9b4066-abcd-4d21-9b9a-7bb337be5c32", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "join_dict = {'FR':['GG','AD','MC'],'IT':['VA','SM'], 'GB':['JE','IM'],'FI':['AX'],'DK':['FO'],\n", + " 'CH':['LI'], 'BE':['LU'],'RS':['XK']}\n", + "europe = natural_earth_shapes_EU(join_dict)\n" + ] + }, + { + "cell_type": "markdown", + "id": "0fd0e3fc-c3a0-4caa-a648-702508f23810", + "metadata": {}, + "source": [ + "## CMIP Solar capacites" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3e70b8bf-674f-4a7a-801b-fa3724497acd", + "metadata": {}, + "outputs": [], + "source": [ + "cutout_cmip = atlite.Cutout(path='cmip_europe.nc',module=['cmip'],\n", + " x=slice(-13,45),\n", + " y=slice(32,83),\n", + " time='2021-01',\n", + " model='EC-Earth3'\n", + " ,dt='3H',dx=1, dy=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e8f45edf-38e0-46b6-9695-588522ec36fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[########################################] | 100% Completed | 2min 19.6s\n" + ] + }, + { + "data": { + "text/plain": [ + "\n", + " x = -13.00 ⟷ 45.00, dx = 1.00\n", + " y = 32.00 ⟷ 83.00, dy = 1.00\n", + " time = 2021-01-01 ⟷ 2021-01-31, dt = 3H\n", + " module = cmip\n", + " prepared_features = ['wind', 'influx', 'temperature', 'runoff']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cutout_cmip.prepare()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "77cb0d9e-da20-4feb-8d16-391b46d75112", + "metadata": {}, + "outputs": [], + "source": [ + "pv_cp = cutout_cmip.pv('CSi',shapes=europe,orientation='latitude_optimal', capacity_factor=True, per_unit=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1b2ab27e-9d20-4812-8fde-3e1009444599", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax = plt.subplots(figsize=(8,5))\n", + "pv_cp.sel(dim_0='DE').plot()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "62d4ec83-d2b8-4f5e-8b9a-4eb24697d251", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, '1 Jaunary Mean PV Solar EC-Earth3')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax = plt.subplots(subplot_kw=dict(projection=ccrs.PlateCarree()),figsize=(8,10))\n", + "europe['mean_cf_pv'] = pv_cp.mean(dim='time')\n", + "europe.plot(column='mean_cf_pv', ax=ax, legend=True)\n", + "ax.set_title('1 Jaunary Mean PV Solar EC-Earth3')" + ] + }, + { + "cell_type": "markdown", + "id": "4d679ffb-d7b1-481c-937f-d1768ada6b36", + "metadata": {}, + "source": [ + "## Wind Capacity factor CMIP" + ] + }, + { + "cell_type": "markdown", + "id": "1472aa3a-6c27-471d-856b-d2c0f2a7a149", + "metadata": {}, + "source": [ + "The surface roughness is not available from the CMIP database so ERA5 roughness is used instead.|" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8e26f07c-2224-4180-a7e3-2b377d18fb4c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + }, + { + "data": { + "text/plain": [ + "Result(content_length=1149236,content_type=application/x-netcdf,location=https://download-0013.copernicus-climate.eu/cache-compute-0013/cache/data2/adaptor.mars.internal-1624960156.6650481-4977-12-177b4b20-717b-4d6d-b681-d6f1395d71cc.nc)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import cdsapi\n", + "\n", + "c = cdsapi.Client()\n", + "\n", + "c.retrieve(\n", + " 'reanalysis-era5-single-levels-monthly-means',\n", + " {\n", + " 'format': 'netcdf',\n", + " 'product_type': 'monthly_averaged_reanalysis',\n", + " 'variable': 'forecast_surface_roughness',\n", + " 'year': '2019',\n", + " 'month': [\n", + " '01', '02', '03',\n", + " '04', '05', '06',\n", + " '07', '08', '09',\n", + " '10', '11', '12',\n", + " ],\n", + " 'area': [\n", + " 83, -13, 32,\n", + " 45,\n", + " ],\n", + " 'time': '00:00',\n", + " },\n", + " 'roughness.nc')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0eedd381-bc61-4f8b-a824-e00e8d0e3b08", + "metadata": {}, + "outputs": [], + "source": [ + "from atlite.datasets.era5 import _rename_and_clean_coords" + ] + }, + { + "cell_type": "markdown", + "id": "9dfead8a-d4fe-46fd-8a50-24e18b8f6ade", + "metadata": {}, + "source": [ + "Create roughness data based on 1 year average from ERA5. Then interpolate the ERA5 data into the resolution of CMIP." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "42048d1e-ce07-4122-90dc-30cfb4172c5c", + "metadata": {}, + "outputs": [], + "source": [ + "roughness = xr.open_dataset('roughness.nc')\n", + "\n", + "roughness = roughness.rename({'fsr':'roughness'})\n", + "\n", + "roughness = roughness.mean(dim='time')\n", + "\n", + "roughness = _rename_and_clean_coords(roughness)\n", + "roughness.roughness.attrs['prepared_feature'] = 'wind'\n", + "\n", + "da = roughness.roughness.interp_like(cutout_cmip.data['influx'].isel(time=0))\n", + "\n", + "cutout_cmip.data = cutout_cmip.data.assign(roughness=da)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "98f87440-fa21-4f6a-aadf-8ab8b29f0d40", + "metadata": {}, + "outputs": [], + "source": [ + "cp_wind = cutout_cmip.wind('Vestas_V112_3MW', shapes=europe,capacity_factor=True, per_unit=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1ef1ff37-81ec-4658-89e9-3fc0480b9c04", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax = plt.subplots(figsize=(8,5))\n", + "cp_wind.sel(dim_0='DE').plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3c473932-7a77-4d5c-9c5e-c5397f34b918", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Single Jaunary Mean wind capacites EC-Earth3')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax = plt.subplots(subplot_kw=dict(projection=ccrs.PlateCarree()),figsize=(8,10))\n", + "europe['mean_cp_wind'] = cp_wind.mean(dim='time')\n", + "europe.plot(column='mean_cp_wind', ax=ax, legend=True)\n", + "ax.set_title('Single Jaunary Mean wind capacites EC-Earth3')" + ] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a0ff51f4cd4d09d7f2d7c95f167bffda2f0eb462 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 29 Jun 2021 12:29:00 +0000 Subject: [PATCH 08/19] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- atlite/cutout.py | 2 +- atlite/datasets/cmip.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/atlite/cutout.py b/atlite/cutout.py index 5eb91698..bafec778 100644 --- a/atlite/cutout.py +++ b/atlite/cutout.py @@ -132,7 +132,7 @@ def __init__(self, path, **cutoutparams): The ESGF search parameters can also be specified in the cmip.yml file, then model correspond to the name of the model specifed in the cmip.yml file. roughness_path: str - Path to external roughness dataset, required for converting CMIP + Path to external roughness dataset, required for converting CMIP winds. parallel : bool, default False Whether to open dataset in parallel mode. Take effect for all diff --git a/atlite/datasets/cmip.py b/atlite/datasets/cmip.py index dc3e472c..43fc13ad 100644 --- a/atlite/datasets/cmip.py +++ b/atlite/datasets/cmip.py @@ -71,13 +71,13 @@ def get_data_runoff(esgf_params, cutout, **retrieval_params): ds = ds.rename({"mrro": "runoff"}) return ds + def sanitize_runoff(ds): """Sanitize retrieved runoff data.""" ds["runoff"] = ds["runoff"].clip(min=0.0) return ds - def get_data_influx(esgf_params, cutout, **retrieval_params): """Get influx data for given retrieval parameters.""" coords = cutout.coords @@ -94,9 +94,10 @@ def get_data_influx(esgf_params, cutout, **retrieval_params): return ds + def sanitize_inflow(ds): """Sanitize retrieved inflow data.""" - ds['influx'] = ds['influx'].clip(min=0.0) + ds["influx"] = ds["influx"].clip(min=0.0) return ds @@ -123,8 +124,7 @@ def get_data_wind(esgf_params, cutout, **retrieval_params): return ds -def retrieve_data( - esgf_params, coords, variables, chunks=None, tmpdir=None, lock=None): +def retrieve_data(esgf_params, coords, variables, chunks=None, tmpdir=None, lock=None): """ Download data from egsf database From ec92ef40ba4088dc83a654b49facfce3e22c5146 Mon Sep 17 00:00:00 2001 From: Ove Haugvaldstad Date: Wed, 30 Jun 2021 10:58:48 +0200 Subject: [PATCH 09/19] add sanitize functionallity of CMIP data --- atlite/data.py | 4 - atlite/datasets/cmip.py | 56 +- atlite/datasets/cmip.yml | 9 - examples/cmip_interface_example.ipynb | 1087 ++++++++++++++++++++++++- 4 files changed, 1087 insertions(+), 69 deletions(-) delete mode 100644 atlite/datasets/cmip.yml diff --git a/atlite/data.py b/atlite/data.py index ba2cbc70..e17f5e26 100644 --- a/atlite/data.py +++ b/atlite/data.py @@ -45,10 +45,6 @@ def get_features(cutout, module, features, tmpdir=None): datasets.append(feature_data) datasets = compute(*datasets) ds = xr.merge(datasets, compat="equals") - # for v in ds: - # ds[v].attrs["module"] = module - # fd = datamodules[module].features.items() - # ds[v].attrs["feature"] = [k for k, l in fd if v in l].pop() fd = datamodules[module].features.items() datavars = list(chain(*[l for k, l in fd])) for v in ds: diff --git a/atlite/datasets/cmip.py b/atlite/datasets/cmip.py index 43fc13ad..576e1882 100644 --- a/atlite/datasets/cmip.py +++ b/atlite/datasets/cmip.py @@ -1,22 +1,22 @@ +# -*- coding: utf-8 -*- +# SPDX-FileCopyrightText: 2020-2021 The Atlite Authors +# +# SPDX-License-Identifier: GPL-3.0-or-later """ Module for downloading and preparing data from the ESGF servers -to be used in atlite - - +to be used in atlite. """ import xarray as xr from pyesgf.search import SearchConnection import logging -import yaml import dask from pathlib import Path -import pkg_resources from ..gis import maybe_swap_spatial_dims import numpy as np -# Null context for running a with statements wihout any context +# Null context for running a with statements without any context try: from contextlib import nullcontext except ImportError: @@ -36,20 +36,15 @@ def nullcontext(): "temperature": ["temperature"], "runoff": ["runoff"], } -CMIP_SETUP_FILE = Path(pkg_resources.resource_filename(__name__, "cmip.yml")) - crs = 4326 -static_features = {"height"} - dask.config.set({"array.slicing.split_large_chunks": True}) def search_ESGF(esgf_params, url="https://esgf-data.dkrz.de/esg-search"): conn = SearchConnection(url, distrib=True) ctx = conn.new_context(latest=True, **esgf_params) - if ctx.hit_count == 0: ctx = ctx.constrain(frequency=esgf_params["frequency"] + "Pt") if ctx.hit_count == 0: @@ -158,9 +153,8 @@ def _rename_and_fix_coords(ds, dt, add_lon_lat=True, add_ctime=False): Optionally (add_lon_lat, default:True) preserves latitude and longitude columns as 'lat' and 'lon'. - CMIP specifics; shif the longitude from 0..360 to -180..180. In addition - CMIP sometimes specify the time in the center of the output intervall this shifted - to the beginning. + CMIP specifics; shift the longitude from 0..360 to -180..180. In addition + CMIP sometimes specify the time in the center of the output intervall this shifted to the beginning. """ ds = ds.assign_coords(lon=(((ds.lon + 180) % 360) - 180)) ds.lon.attrs["valid_max"] = 180 @@ -168,10 +162,6 @@ def _rename_and_fix_coords(ds, dt, add_lon_lat=True, add_ctime=False): ds = ds.sortby("lon") ds = ds.rename({"lon": "x", "lat": "y"}) - # round coords since cds coords are float32 which would lead to mismatches - # ds = ds.assign_coords( - # x=np.round(ds.x.astype(float), 5), y=np.round(ds.y.astype(float), 5) - # ) ds = maybe_swap_spatial_dims(ds) if add_lon_lat: @@ -197,7 +187,7 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): cutout : atlite.Cutout feature : str Name of the feature data to retrieve. Must be in - `atlite.datasets.era5.features` + `atlite.datasets.cmip.features` tmpdir : str/Path Directory where the temporary netcdf files are stored. **creation_parameters : @@ -212,20 +202,10 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): """ coords = cutout.coords - # sanitize = creation_parameters.get("sanitize", True) + sanitize = creation_parameters.get("sanitize", True) if cutout.esgf_params == None: - with open(CMIP_SETUP_FILE, "r") as f: - cmip_params = yaml.safe_load(f) - - model = creation_parameters.get("model") - if model: - try: - esgf_params = cmip_params[model] - except: - KeyError(f"{model} not reconized, update cmip.yml") - else: - raise (ValueError("Model not specified")) + raise (ValueError("ESGF search parameters not provided")) else: esgf_params = cutout.esgf_params if esgf_params.get("frequency") == None: @@ -243,17 +223,27 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): freq = "year" else: raise (ValueError(f"{cutout.dt} not valid time frequency in CMIP")) + else: + freq = esgf_params.get("frequency") + + esgf_params['frequency'] = freq retrieval_params = {"chunks": cutout.chunks, "tmpdir": tmpdir, "lock": lock} func = globals().get(f"get_data_{feature}") - # sanitize_func = globals().get(f"sanitize_{feature}") - logger.info(f"Requesting data for feature {feature}...") + + ds = func(esgf_params, cutout, **retrieval_params) ds = ds.sel(time=coords["time"]) bounds = cutout.bounds ds = ds.sel(x=slice(bounds[0], bounds[2]), y=slice(bounds[1], bounds[3])) ds = ds.interp({"x": cutout.data.x, "y": cutout.data.y}) + + if globals().get(f"sanitize_{feature}") != None and sanitize: + sanitize_func = globals().get(f"sanitize_{feature}") + ds = sanitize_func(ds) + + return ds diff --git a/atlite/datasets/cmip.yml b/atlite/datasets/cmip.yml deleted file mode 100644 index 784b7878..00000000 --- a/atlite/datasets/cmip.yml +++ /dev/null @@ -1,9 +0,0 @@ -EC-Earth3: - data_node: 'esgf-cnr.hpc.cineca.it' - source_id: 'EC-Earth3' - variant_label: 'r4i1p1f1' - experiment_id: 'ssp126' - frequency: '3hr' - project: 'CMIP6' - - diff --git a/examples/cmip_interface_example.ipynb b/examples/cmip_interface_example.ipynb index d1fc29bc..6404c548 100644 --- a/examples/cmip_interface_example.ipynb +++ b/examples/cmip_interface_example.ipynb @@ -8,7 +8,6 @@ "outputs": [], "source": [ "from atlite.datasets.era5 import retrieve_data, _rename_and_clean_coords, retrieval_times, _area\n", - "from dask.utils import SerializableLock\n", "import xarray as xr\n", "import atlite\n", "import logging\n", @@ -16,7 +15,6 @@ "from cartopy.io import shapereader\n", "import geopandas as gpd\n", "import cartopy.crs as ccrs\n", - "from cartopy.mpl.gridliner import LongitudeFormatter, LatitudeFormatter\n", "import matplotlib.pyplot as plt\n", "logging.basicConfig(level=logging.INFO)" ] @@ -87,41 +85,1085 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "3e70b8bf-674f-4a7a-801b-fa3724497acd", "metadata": {}, "outputs": [], "source": [ + "esgf_params = {\n", + " 'data_node': 'esgf-cnr.hpc.cineca.it',\n", + " 'source_id': 'EC-Earth3',\n", + " 'variant_label':'r4i1p1f1',\n", + " 'experiment_id': 'ssp126',\n", + " 'project' : 'CMIP6',\n", + " 'frequency':'3hr'\n", + "}\n", + "\n", "cutout_cmip = atlite.Cutout(path='cmip_europe.nc',module=['cmip'],\n", " x=slice(-13,45),\n", " y=slice(32,83),\n", " time='2021-01',\n", - " model='EC-Earth3'\n", - " ,dt='3H',dx=1, dy=1)" + " esgf_params=esgf_params,\n", + " dt='3H',dx=1, dy=1)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "e8f45edf-38e0-46b6-9695-588522ec36fe", "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "[########################################] | 100% Completed | 2min 19.6s\n" + "Python 3.8.10 | packaged by conda-forge | (default, May 11 2021, 07:01:05) \n", + "Type 'copyright', 'credits' or 'license' for more information\n", + "IPython 7.25.0 -- An enhanced Interactive Python. Type '?' for help.\n", + "\n", + "Out[1]: \n", + "[Delayed('get_data-73bbfd02-d114-4cfa-95fb-c65f88da4ba7'),\n", + " Delayed('get_data-7b05ec5f-c770-4a59-a6c4-e8531d79a371'),\n", + " Delayed('get_data-d93baf5c-a436-4a99-b9d4-db28cd4d0635'),\n", + " Delayed('get_data-6ce844cf-ff14-4745-8594-9e7d6e3cf9ba')]\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "---------------------------------------------------------------------------\n", + "KeyError Traceback (most recent call last)\n", + "~/atlite/atlite/data.py in \n", + "----> 1 datasets = compute(*datasets)\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/base.py in compute(*args, **kwargs)\n", + " 563 postcomputes.append(x.__dask_postcompute__())\n", + " 564 \n", + "--> 565 results = schedule(dsk, keys, **kwargs)\n", + " 566 return repack([f(r, *a) for r, (f, a) in zip(results, postcomputes)])\n", + " 567 \n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/threaded.py in get(dsk, result, cache, num_workers, pool, **kwargs)\n", + " 74 pools[thread][num_workers] = pool\n", + " 75 \n", + "---> 76 results = get_async(\n", + " 77 pool.apply_async,\n", + " 78 len(pool._pool),\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in get_async(apply_async, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, **kwargs)\n", + " 485 _execute_task(task, data) # Re-execute locally\n", + " 486 else:\n", + "--> 487 raise_exception(exc, tb)\n", + " 488 res, worker_id = loads(res_info)\n", + " 489 state[\"cache\"][key] = res\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in reraise(exc, tb)\n", + " 315 if exc.__traceback__ is not tb:\n", + " 316 raise exc.with_traceback(tb)\n", + "--> 317 raise exc\n", + " 318 \n", + " 319 \n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in execute_task(key, task_info, dumps, loads, get_id, pack_exception)\n", + " 220 try:\n", + " 221 task, data = loads(task_info)\n", + "--> 222 result = _execute_task(task, data)\n", + " 223 id = get_id()\n", + " 224 result = dumps((result, id))\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/core.py in _execute_task(arg, cache, dsk)\n", + " 119 # temporaries by their reference count and can execute certain\n", + " 120 # operations in-place.\n", + "--> 121 return func(*(_execute_task(a, cache) for a in args))\n", + " 122 elif not ishashable(arg):\n", + " 123 return arg\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/utils.py in apply(func, args, kwargs)\n", + " 33 def apply(func, args, kwargs=None):\n", + " 34 if kwargs:\n", + "---> 35 return func(*args, **kwargs)\n", + " 36 else:\n", + " 37 return func(*args)\n", + "\n", + "~/atlite/atlite/datasets/cmip.py in get_data(cutout, feature, tmpdir, lock, **creation_parameters)\n", + " 236 \n", + " 237 ds = func(esgf_params, cutout, **retrieval_params)\n", + "--> 238 ds = ds.sel(time=coords[\"time\"])\n", + " 239 bounds = cutout.bounds\n", + " 240 ds = ds.sel(x=slice(bounds[0], bounds[2]), y=slice(bounds[1], bounds[3]))\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/dataset.py in sel(self, indexers, method, tolerance, drop, **indexers_kwargs)\n", + " 2363 \"\"\"\n", + " 2364 indexers = either_dict_or_kwargs(indexers, indexers_kwargs, \"sel\")\n", + "-> 2365 pos_indexers, new_indexes = remap_label_indexers(\n", + " 2366 self, indexers=indexers, method=method, tolerance=tolerance\n", + " 2367 )\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/coordinates.py in remap_label_indexers(obj, indexers, method, tolerance, **indexers_kwargs)\n", + " 419 }\n", + " 420 \n", + "--> 421 pos_indexers, new_indexes = indexing.remap_label_indexers(\n", + " 422 obj, v_indexers, method=method, tolerance=tolerance\n", + " 423 )\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in remap_label_indexers(data_obj, indexers, method, tolerance)\n", + " 272 coords_dtype = data_obj.coords[dim].dtype\n", + " 273 label = maybe_cast_to_coords_dtype(label, coords_dtype)\n", + "--> 274 idxr, new_idx = convert_label_indexer(index, label, dim, method, tolerance)\n", + " 275 pos_indexers[dim] = idxr\n", + " 276 if new_idx is not None:\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in convert_label_indexer(index, label, index_name, method, tolerance)\n", + " 200 indexer = get_indexer_nd(index, label, method, tolerance)\n", + " 201 if np.any(indexer < 0):\n", + "--> 202 raise KeyError(f\"not all values found in index {index_name!r}\")\n", + " 203 \n", + " 204 if new_index is not None:\n", + "\n", + "KeyError: \"not all values found in index 'time'\"\n", + "\n", + "---------------------------------------------------------------------------\n", + "KeyError Traceback (most recent call last)\n", + "~/atlite/atlite/data.py in \n", + "----> 1 datasets = compute(datasets[0])\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/base.py in compute(*args, **kwargs)\n", + " 563 postcomputes.append(x.__dask_postcompute__())\n", + " 564 \n", + "--> 565 results = schedule(dsk, keys, **kwargs)\n", + " 566 return repack([f(r, *a) for r, (f, a) in zip(results, postcomputes)])\n", + " 567 \n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/threaded.py in get(dsk, result, cache, num_workers, pool, **kwargs)\n", + " 74 pools[thread][num_workers] = pool\n", + " 75 \n", + "---> 76 results = get_async(\n", + " 77 pool.apply_async,\n", + " 78 len(pool._pool),\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in get_async(apply_async, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, **kwargs)\n", + " 485 _execute_task(task, data) # Re-execute locally\n", + " 486 else:\n", + "--> 487 raise_exception(exc, tb)\n", + " 488 res, worker_id = loads(res_info)\n", + " 489 state[\"cache\"][key] = res\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in reraise(exc, tb)\n", + " 315 if exc.__traceback__ is not tb:\n", + " 316 raise exc.with_traceback(tb)\n", + "--> 317 raise exc\n", + " 318 \n", + " 319 \n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in execute_task(key, task_info, dumps, loads, get_id, pack_exception)\n", + " 220 try:\n", + " 221 task, data = loads(task_info)\n", + "--> 222 result = _execute_task(task, data)\n", + " 223 id = get_id()\n", + " 224 result = dumps((result, id))\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/core.py in _execute_task(arg, cache, dsk)\n", + " 119 # temporaries by their reference count and can execute certain\n", + " 120 # operations in-place.\n", + "--> 121 return func(*(_execute_task(a, cache) for a in args))\n", + " 122 elif not ishashable(arg):\n", + " 123 return arg\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/utils.py in apply(func, args, kwargs)\n", + " 33 def apply(func, args, kwargs=None):\n", + " 34 if kwargs:\n", + "---> 35 return func(*args, **kwargs)\n", + " 36 else:\n", + " 37 return func(*args)\n", + "\n", + "~/atlite/atlite/datasets/cmip.py in get_data(cutout, feature, tmpdir, lock, **creation_parameters)\n", + " 236 \n", + " 237 ds = func(esgf_params, cutout, **retrieval_params)\n", + "--> 238 ds = ds.sel(time=coords[\"time\"])\n", + " 239 bounds = cutout.bounds\n", + " 240 ds = ds.sel(x=slice(bounds[0], bounds[2]), y=slice(bounds[1], bounds[3]))\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/dataset.py in sel(self, indexers, method, tolerance, drop, **indexers_kwargs)\n", + " 2363 \"\"\"\n", + " 2364 indexers = either_dict_or_kwargs(indexers, indexers_kwargs, \"sel\")\n", + "-> 2365 pos_indexers, new_indexes = remap_label_indexers(\n", + " 2366 self, indexers=indexers, method=method, tolerance=tolerance\n", + " 2367 )\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/coordinates.py in remap_label_indexers(obj, indexers, method, tolerance, **indexers_kwargs)\n", + " 419 }\n", + " 420 \n", + "--> 421 pos_indexers, new_indexes = indexing.remap_label_indexers(\n", + " 422 obj, v_indexers, method=method, tolerance=tolerance\n", + " 423 )\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in remap_label_indexers(data_obj, indexers, method, tolerance)\n", + " 272 coords_dtype = data_obj.coords[dim].dtype\n", + " 273 label = maybe_cast_to_coords_dtype(label, coords_dtype)\n", + "--> 274 idxr, new_idx = convert_label_indexer(index, label, dim, method, tolerance)\n", + " 275 pos_indexers[dim] = idxr\n", + " 276 if new_idx is not None:\n", + "\n", + "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in convert_label_indexer(index, label, index_name, method, tolerance)\n", + " 200 indexer = get_indexer_nd(index, label, method, tolerance)\n", + " 201 if np.any(indexer < 0):\n", + "--> 202 raise KeyError(f\"not all values found in index {index_name!r}\")\n", + " 203 \n", + " 204 if new_index is not None:\n", + "\n", + "KeyError: \"not all values found in index 'time'\"\n", + "\n", + "\n" ] }, + { + "output_type": "error", + "ename": "KeyError", + "evalue": "\"not all values found in index 'time'\"", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcutout_cmip\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprepare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/atlite/atlite/data.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"tmpdir\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmkdtemp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 111\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0mrmtree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"tmpdir\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/atlite/atlite/data.py\u001b[0m in \u001b[0;36mcutout_prepare\u001b[0;34m(cutout, features, tmpdir, overwrite)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Calculating and writing with module {module}:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0mmissing_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmissing_vars\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munique\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"feature\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_features\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcutout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmissing_features\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtmpdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtmpdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0mprepared\u001b[0m \u001b[0;34m|=\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmissing_features\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/atlite/atlite/data.py\u001b[0m in \u001b[0;36mget_features\u001b[0;34m(cutout, module, features, tmpdir)\u001b[0m\n\u001b[1;32m 45\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mIPython\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mIPython\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0membed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0mdatasets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdatasets\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mxr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmerge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompat\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"equals\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0;31m# for v in ds:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/base.py\u001b[0m in \u001b[0;36mcompute\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 563\u001b[0m \u001b[0mpostcomputes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dask_postcompute__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 564\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdsk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 566\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrepack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpostcomputes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/threaded.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(dsk, result, cache, num_workers, pool, **kwargs)\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0mpools\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mthread\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnum_workers\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 76\u001b[0;31m results = get_async(\n\u001b[0m\u001b[1;32m 77\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_async\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pool\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py\u001b[0m in \u001b[0;36mget_async\u001b[0;34m(apply_async, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, **kwargs)\u001b[0m\n\u001b[1;32m 485\u001b[0m \u001b[0m_execute_task\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Re-execute locally\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 486\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 487\u001b[0;31m \u001b[0mraise_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 488\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mworker_id\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres_info\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 489\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"cache\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py\u001b[0m in \u001b[0;36mreraise\u001b[0;34m(exc, tb)\u001b[0m\n\u001b[1;32m 315\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 317\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 318\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 319\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py\u001b[0m in \u001b[0;36mexecute_task\u001b[0;34m(key, task_info, dumps, loads, get_id, pack_exception)\u001b[0m\n\u001b[1;32m 220\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtask_info\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 222\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_execute_task\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 223\u001b[0m \u001b[0mid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_id\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdumps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/core.py\u001b[0m in \u001b[0;36m_execute_task\u001b[0;34m(arg, cache, dsk)\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;31m# temporaries by their reference count and can execute certain\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;31m# operations in-place.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 121\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_execute_task\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 122\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mishashable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/utils.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(func, args, kwargs)\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 36\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/atlite/atlite/datasets/cmip.py\u001b[0m in \u001b[0;36mget_data\u001b[0;34m(cutout, feature, tmpdir, lock, **creation_parameters)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mesgf_params\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcutout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mretrieval_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcoords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"time\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0mbounds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcutout\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/dataset.py\u001b[0m in \u001b[0;36msel\u001b[0;34m(self, indexers, method, tolerance, drop, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 2363\u001b[0m \"\"\"\n\u001b[1;32m 2364\u001b[0m \u001b[0mindexers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0meither_dict_or_kwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindexers_kwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"sel\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2365\u001b[0;31m pos_indexers, new_indexes = remap_label_indexers(\n\u001b[0m\u001b[1;32m 2366\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mindexers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2367\u001b[0m )\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/coordinates.py\u001b[0m in \u001b[0;36mremap_label_indexers\u001b[0;34m(obj, indexers, method, tolerance, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 419\u001b[0m }\n\u001b[1;32m 420\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 421\u001b[0;31m pos_indexers, new_indexes = indexing.remap_label_indexers(\n\u001b[0m\u001b[1;32m 422\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_indexers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 423\u001b[0m )\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py\u001b[0m in \u001b[0;36mremap_label_indexers\u001b[0;34m(data_obj, indexers, method, tolerance)\u001b[0m\n\u001b[1;32m 272\u001b[0m \u001b[0mcoords_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmaybe_cast_to_coords_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcoords_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 274\u001b[0;31m \u001b[0midxr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconvert_label_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 275\u001b[0m \u001b[0mpos_indexers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0midxr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnew_idx\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py\u001b[0m in \u001b[0;36mconvert_label_indexer\u001b[0;34m(index, label, index_name, method, tolerance)\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_indexer_nd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 201\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 202\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"not all values found in index {index_name!r}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 203\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnew_index\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: \"not all values found in index 'time'\"" + ] + } + ], + "source": [ + "cutout_cmip.prepare()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1e7d9a8c-2919-49ca-a389-db0b3e4d2371", + "metadata": {}, + "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:      (time: 248, x: 59, y: 52)\n",
+       "Coordinates:\n",
+       "  * x            (x) int64 -13 -12 -11 -10 -9 -8 -7 -6 ... 39 40 41 42 43 44 45\n",
+       "  * y            (y) int64 32 33 34 35 36 37 38 39 ... 76 77 78 79 80 81 82 83\n",
+       "  * time         (time) datetime64[ns] 2021-01-01 ... 2021-01-31T21:00:00\n",
+       "    lon          (x) float64 dask.array<chunksize=(59,), meta=np.ndarray>\n",
+       "    lat          (y) float64 dask.array<chunksize=(52,), meta=np.ndarray>\n",
+       "Data variables:\n",
+       "    wnd10m       (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
+       "    influx       (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
+       "    outflux      (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
+       "    temperature  (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
+       "    runoff       (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
+       "Attributes: (12/56)\n",
+       "    module:                          cmip\n",
+       "    prepared_features:               ['runoff', 'temperature', 'wind', 'influx']\n",
+       "    chunksize_time:                  100\n",
+       "    model:                           EC-Earth3\n",
+       "    dt:                              3H\n",
+       "    dx:                              1\n",
+       "    ...                              ...\n",
+       "    tracking_id:                     hdl:21.14100/c38fc6f8-7b95-4a22-a21d-a01...\n",
+       "    history:                         2019-08-05T08:01:37Z ; CMOR rewrote data...\n",
+       "    DODS_EXTRA.Unlimited_Dimension:  time\n",
+       "    data_node:                       esgf-cnr.hpc.cineca.it\n",
+       "    project:                         CMIP6\n",
+       "    variable:                        sfcWind
" + ], "text/plain": [ - "\n", - " x = -13.00 ⟷ 45.00, dx = 1.00\n", - " y = 32.00 ⟷ 83.00, dy = 1.00\n", - " time = 2021-01-01 ⟷ 2021-01-31, dt = 3H\n", - " module = cmip\n", - " prepared_features = ['wind', 'influx', 'temperature', 'runoff']" + "\n", + "Dimensions: (time: 248, x: 59, y: 52)\n", + "Coordinates:\n", + " * x (x) int64 -13 -12 -11 -10 -9 -8 -7 -6 ... 39 40 41 42 43 44 45\n", + " * y (y) int64 32 33 34 35 36 37 38 39 ... 76 77 78 79 80 81 82 83\n", + " * time (time) datetime64[ns] 2021-01-01 ... 2021-01-31T21:00:00\n", + " lon (x) float64 dask.array\n", + " lat (y) float64 dask.array\n", + "Data variables:\n", + " wnd10m (time, y, x) float32 dask.array\n", + " influx (time, y, x) float32 dask.array\n", + " outflux (time, y, x) float32 dask.array\n", + " temperature (time, y, x) float32 dask.array\n", + " runoff (time, y, x) float32 dask.array\n", + "Attributes: (12/56)\n", + " module: cmip\n", + " prepared_features: ['runoff', 'temperature', 'wind', 'influx']\n", + " chunksize_time: 100\n", + " model: EC-Earth3\n", + " dt: 3H\n", + " dx: 1\n", + " ... ...\n", + " tracking_id: hdl:21.14100/c38fc6f8-7b95-4a22-a21d-a01...\n", + " history: 2019-08-05T08:01:37Z ; CMOR rewrote data...\n", + " DODS_EXTRA.Unlimited_Dimension: time\n", + " data_node: esgf-cnr.hpc.cineca.it\n", + " project: CMIP6\n", + " variable: sfcWind" ] }, "execution_count": 6, @@ -130,7 +1172,7 @@ } ], "source": [ - "cutout_cmip.prepare()" + "cutout_cmip.data" ] }, { @@ -152,7 +1194,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 8, @@ -195,7 +1237,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAAItCAYAAACq4nqPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAADHzUlEQVR4nOzddXib19n48e8Ry8zMFCd2mJsmbdImZYa13bqt3but6zruftvewTtm6roO2q7bSuu6wspMScMMhpiZQZJlycLz+0OO4yR2YjvG+HyuS1dsPY/Ocx7b0a1D9xFSShRFURRlttJMdQUURVEUZSqpQKgoiqLMaioQKoqiKLOaCoSKoijKrKYCoaIoijKr6aa6AoqiKMrUu2R9sOzs8k3KtfYecr0hpbx0Ui42AioQKoqiKHR2+dj1RtqkXEubWB4zKRcaIRUIFUVRFCTgxz/V1ZgSaoxQURRFmdVUi1BRFEUBJD6pWoSKoiiKMuuoQKgoiqLMaqprVFEURemfLDM7N2FQLUJFURRlVlMtQkVRFAVQyycURVEUZVZSLUJFURQFicQ3SzdqVy1CRVEUZVZTLUJFURQFULNGFUVRFGVWUi1CRVEUBQn4VItQURRFUWYf1SJUFEVRADVGqCiKoiizkmoRKoqiKIExQrWOUFEURVFmH9UiVBRFUQBmaaZR1SJUFEVRZjkVCBVFUZRZTXWNKoqiKIGk22r5hKIoiqLMPqpFqCiKooAE3+xsEKoWoaIoijK7qRahoiiKgkQtn1AURVGUWUm1CBVFURRA4ENMdSWmhGoRKoqiKLOaahEqiqIogTFCNWtUURRFUWYf1SJUFEVRANQYoaIoiqLMRqpFqCiKogQ25lUtQkVRFEWZfVQgVBRFUQDwSzEpjzMRQlwqhDgqhKgQQnxziONCCPGH/uOHhBBL+p+fI4Q4MOhhE0J8+UzXU12jiqIoyrQhhNACDwAbgQZgtxDiRSll8aDTLgNy+x8rgT8DK6WUR4FFg8ppBJ4/0zVVi1BRFEWZTlYAFVLKKimlG3gKuOakc64BHpUBO4AIIUTiSedcBFRKKWvPdEHVIlQURVEme7JMjBBiz6DvH5RSPtj/dTJQP+hYA4FW32BDnZMMNA967hbgXyOpjAqEiqIoymTrkFIuG+bYUNH45Jw3pz1HCGEArga+NZLKqECoKIqiIBH4psdoWQOQOuj7FKBplOdcBuyTUraO5ILT4q4VRVEUpd9uIFcIkdnfsrsFePGkc14EPt4/e3QVYJVSDu4WvZURdouCahEqiqIo/UaytGGiSSm9Qoh7gDcALfCIlLJICHFX//G/AK8ClwMVgAO449jrhRBBBGacfnak11SBUFEURZlWpJSvEgh2g5/7y6CvJfD5YV7rAKJHcz0VCBVFURSVYk1RFEVRZivVIlQURVEAgU/OzrbR7LxrRVEURemnWoSKoigKEvDP0rbR7LxrRVEURemnWoSKoigKoGaNKoqiKMqspFqEiqIoClKqWaOKoiiKMiupQKgoiqLMaqprVFEURQHArybLKIqiKMrso1qEiqIoSn/S7dnZNpqdd60oiqIo/VSLUFEURUEl3VYURVGUWUq1CBVFURSVdFtRFEVRZivVIlQURVEA8Em1jlBRFEVRZh3VIlQURVGQCLWOUFEURVFmI9UiVBRFUQDwq3WEiqIoijL7qBahoiiKonKNKoqiKMpspQKhoiiKMquprlFFURQlsHxCLahXFEVRlNlHtQgVRVEUQCXdVhRFUZRZSbUIFUVRFKREbcyrKIqiKLORahEqiqIogMCPmjWqKIqiKLOOahEqiqIogRRraoxQURRFUWYf1SJUFEVRAJV0W1EURVFmJdUiVBRFUZAI/CrXqKIoiqLMPqpFqCiKogBqjFBRFEVRZiUVCBVFUZRZTXWNKoqiKEjArxbUK4qiKMrso1qEiqIoCiDwqaTbiqIoijL7qBahoiiKosYIFUVRFGW2Ui1CRVEUBUCNESqKoijKbKRahIqiKApSCjVGqCiKoiizkWoRKoqiKAD4VItQURRFUWYf1SJUFEVRAusI1axRRVEURZl9VItQURRFAYQaI1QURVGU2UgFQkUZZ0KIGiHExVNdj6kihMgQQkghhOpxmkECuUbFpDymGxUIx4EQ4h4hxB4hhEsI8Y8znHuhEKJhkqo2YYQQ3+9/s/viSc9/uf/5709BnWqEEE4hhF0I0SqE+LsQIkQI8VchxKNDnL+g/3cWNcSxFCHEs0KIDiGEVQhxWAjxyUm5kRPrcSyo2E96fGTQOSuEEK8KISxCiC4hxC4hxB2nKXPwz+nY449nUcdRBX4hxC1CiKP9P9c2IcQ/hRBhY72+opwtFQjHRxPwY+CRqa7IWI3x03sZ8ImTnvt4//NT5SopZQiwBFgOfAf4B3C9ECL4pHM/DrwspewaopzHgHogHYjuP7d1oioNZ/wdREgpQwY9/t3/mtXAu8AHQE5/XT8HXHaGy111Unn3jHN9T2crsEZKGQ5kEZir8OMxlqUoZ00FwnEgpXxOSvlfoHO0rxVC3CGEKBFC9AghqoQQnx107JNCiA9POl8KIXL6v/6HEOIBIcQr/a/fKYTIHnTufUKIeiGETQixVwixdtCx7wshnhFCPC6EsAHfFEI4hBDRg85ZKoRoF0Loh6n+biBICFHQf34BYO5/fnCdrxRCHOhvsWwTQiwYdOybQojK/voXCyGuO/n+hRC/FkJ0CyGqhRBneoMHQErZCLwGFEoptwONwA2DytYCtwH/HKaI5cA/pJS9UkqvlHK/lPK1Qa+/WghR1H9P7wsh5g5VSH9rbXv/ec1CiD8KIQyDjkshxOeFEOVA+Uju7SS/Av4ppfyFlLJDBuyVUt48hrIQQmQLId4VQnT2t4afEEJEDDpeI4T4hhDiENArhPgXkAa81N+y/H+DivuoEKKuv5xvH3tSSlkvpewYdJ6PQBBXppgPzaQ8ppvpV6PZpw24EggD7gB+J4RYMorX3wr8AIgEKoCfDDq2G1gERAFPAv8RQpgGHb8GeAaIAH4DvA8MfgP9GPCUlNJzmus/RqC1BIHW4QldkP338gjwWQKtlb8CLwohjP2nVAJrgfD++3hcCJE4qIiVwFEgBvgl8DchxBkHGYQQqcDlwP7+px4dVE+AiwE9gWA5lB3AA/3deGknlZ0H/Av4MhALvEogEBhOKSXwJv+V/vqvBi4C7j7pnGv773Peme7rpHoE9Zf5zGhed6ZigZ8BScBcIBX4/knn3ApcQaCVeitQx/EW5i8HnXc+MIfAPX9v8IcFIcT5Qggr0EPgA8rvx/EeFGVUVCCcYlLKV6SUlf2f5D8A3iQQGEbqOSnlLimlF3iCQOA7VvbjUsrO/hbNbwAjgTemY7ZLKf8rpfRLKZ0EWkcfg4EW060EAt3pPA7c2t9qvKX/+8E+DfxVSrlTSumTUv4TcAGr+uv4HyllU38d/k2gVbRi0OtrpZQPSSl9/fVLBOJPU5//CiEswIcEugt/2v/8Y8AFQoiU/u8/Djx5miB/E7AF+C5Q3d+iXd5/7CPAK1LKt/pf/2sCLeHzTi6kv3W2o/93UEPgg8AFJ532MyllV//vYDgd/a3KY4+5BD78aIDm07xuOP89qbxP99e3ov++XFLKduC3Q9T3D/2tutPVF+AHUkqnlPIgcBBYeOyAlPLD/q7RFAKt2pox3IMyjiSTM1FGTZZRTiGEuEwIsUMEJjlYCLRiYkZRRMugrx1AyKCyv9bf7WrtLzv8pLLrTyrrBWCeECIL2AhYpZS7TndxKWUdgZboT4FyKeXJZaYDXxv8pkuglZHUX8ePD+o2tQCFJ9Vx4P6klI7+L0MY3rVSyggpZbqU8u5jb9b99dwMfEwIEUKgFTZctyhSym4p5TellAUEAu8BAsFD9Ne9dtC5fgI/y+STyxFC5AkhXhZCtPR3Qf+UU3+/J//MhhLTf1/HHiVAN+An8OFgSEKI18TxCTEfHXTo2pPKe6j//DghxFNCiMb++j4+xvrCaf42j+nvwn4deGqEZSqzgBDiUhGYUFUhhPjmEMeFEOIP/ccPDe5FE0JEiMCwT2n/+9/qM11PBcIp1N89+CyBFkW8lDKCQDfbsY9MvUDQoPMTRlH2WuAbBLo6I/vLtg4qGwIzpo9/I2Uf8DTwUeB2ztwaPOZR4Guc1C3arx74yUlvukFSyn8JIdKBh4B7gOj+Oh45qY7j6Z8EWoI3ANVSyn0jeVH/eNavCQTAKAKTo9KPHe8PjqkExiFP9megFMiVUoYB/8up9ydPedXI6uUAtjNo7HOIcy4bNCHmiREU+7P++izor+/HRlDfMdV/EB2QfcazlAnnRzMpj9Pp7416gMCEr3kEepxOHja4DMjtf3yGwP+zY+4DXpdS5hPohSg5032rQDgOhBC6/rE3LaAVQpjEyGbUGQh0V7YD3v6JIJsGHT8IFAghFvWX//1RVCsU8PaXrRNCfI/AOOSZPAp8EriaU7s5h/NvAvV+eohjDwF3CSFW9n+KCxZCXCGECAWCCbyJtkNg4hCBFuFEeZZAwPoBp2kN9tflF0KIwv7fbSiBmZgVUspOAvd5hRDiov4u4a8R6O7dNkRRoYANsAsh8vvLGU//D/ikEOLron+ikxBioRBirC2sUMAOWIQQycDXR/CaVgKzP0dECPFRIURa/99DOoFx7XfGVFvlXLSCwP+1Kimlm0BvwTUnnXMN8Gj/kNIOIEIIkSgCy3DWAX8DkFK6pZSWM11QBcLx8R3ACXyTwCdoZ/9zw5EAUsoe4IsE3li7CcxifHHgJCnLgB8CbxMYO/vwlJKG9waBiSBlBLrx+hhBl5aUciuB7rZ9/WNaZ9Q/DvT2UGNGUso9BMYJ/0jgHisIBFqklMUEJulsJ/BmOp/A1PoJIaXs5XgwPFPrKAh4HrAAVQRagFf3l3OUwO/5fqADuIrAZBH3EOXcS+D32kPgQ8G/x1h9izhx3d9X++uyDdjQ/6gSQnQBDxLoWTidl04q7/n+539AYOmJFXgFeG4EdfsZ8J3+7u17R3D+PAIfGuwEft9HCfyNKFNISvBJMSkPIEYE1l4fe3xmUFWSOfG9qoFThx2GOyeLwAfrvwsh9gshHhanLps6hZDybHs1lNEQQlwN/FBKuWiq6zIcIcS7BCaSPDzVdVEUZXLEz4uStz256cwnjoPfL/73XinlsqGOCSFuAi6RUv5P//e3AyuklF8YdM4rBCaZfdj//TsEekcEgRnfa6SUO4UQ9wE2KeV3T1cflQJpEvV3l94A7JnqugxHBGZGLuHUrghFUc5x02RGZwOBXptjUgiMy4/kHAk0SCl39j//DIGeutNSXaOTRAgRDnQRWHz8gymuzpCEEP8k0A375f5uW0VRlMm2G8gVQmSKwNrcWxg0ZNTvReDj/ePMqwjMcG+WUrYA9UKIY8vELgKKz3RB1SKcJFJKKyObrDJlpJQnp0tTFGWWCKwjnPq2kZTSK4S4h8A8By3wiJSySAhxV//xvxAYA7+cwJwDB4FkJMd8AXiiP4hWnXRsSCoQKoqiKNOKlPJVTprw1R8Aj30tgc8P89oDwJDjj8M5bSC89NJLZUdHx+lOURRFUSbJ3r1735BSXjpR5fsmbAnv9HbaQNjR0cGePdN2XoeiKMqsIoQYTdYpZYRU16iiKIoysDHvbDT1I6OKoiiKMoVUIFQURVFmNdU1qiiKosA0WT4xFWbnXSuKoihKP9UiVBRFUQDwz9LlE6pFqCiKosxqqkWoKIqiDGzDNBupFqGiKIoyq6kWoaIoigKgZo0qiqIoymykWoSKMsWqD9ei0WowmA3EpkTjtPcRGhky1dVSZpnANkxqjFBRlEng7nPT53ABIKUkKjESo9lAdFIUNUfq6W61EthlRlGUyaBahIoyTqSU+H1+tDrtKcd6rb28+Kc3qS2px97dy7JNizCY9CRmx7PwwgLCYwJ7Nucszhy2/F6bg1f++hbp81Io31fN4Q9LyCxM49I7N5BRkDpwnq2rh83PbCcxI47FFy9Ao1Gfd5WRma3rCFUgVJRx4PP5+PC5XRx87wjGICNXfm4TsSnR7H5tP4/+4GkSs+LZcOv5xKfH8ItP/JGdr+wbeO3CCwvIX5HDxo9fQE+XHWtHD329Lhw9TiytVm689yrMwSZMwUaEEPzqjgewddrR6bUkZyfQ1WIhKiGC0KgQHvn2v2ira0dKyUt/epOgMDOZhWm01LSx+url2Dp6yFmSiRCC+PQYUvOTp3Wg9Pv9OGxOulosdDR20dPZQ1RiJLlLszAFGae6eso5QpyuC2bZsmVS7UeozEY+n4+miha6mi3EpESRnJM45HlSSupKGynfW8XhzcXUFNVjabehN+iwttvIXJDO/PPnUnmwmsNbSrF19oy4DuExoSRmxZOcl8jSjQs5/7oV/L+Lf0jprgoAgsLMFJ6fT/neKoxmAwazgYayZvw+/4jK1+m1mENMOHr60Gg1aLUaNLrAv9FJUSy8sIArPruRzMK0Edd5LJy9fRRtPYrL4cLv8+P3+fF5ffh8fqRfYg41k5afRFRiJKZgI3qDflyu6/P5aa3rICYpEoNxfMqcaEKIvVLKUe2+PlJRc2PlJX+/biKKPsVTqx+asPsYCxUIlXOS1+PF5XDh7vNg6+whZU4SWu2pXZYns7RbcdicvP3YZp76+fN43F60Oi1X330JCy6Yxwf/2U5wqJnU/GTS5iZTeH4+5hAzUkoObynh/ae20tVqobG8mZoj9eN6T6n5yTQcbZq08UONVsP/PXsv5129fFKup5yZCoQTQ3WNKtOSz+dj23930WvrY/2ta3jh/tfoau6mZGc5Ffur2XDbWm791nU8+ZPnKN9XxfnXraSrpZva4gZ6rQ4cNgc+nx+9UU9UQgT/8/OPUXDeHGqL63n2d6/Q2dxFQkYcGz9+Afkrcgeu+9Kf3+TR7z99Yl28Pp7/w6s8/4dXT6mnVqdl8UWFXH33pay+ahkxyVGU7qqgfG8ViVnxaDQCv1+i02uxdvQQGhVCZFw4McnRxKXFoNVr8bg8aLQahBAIIdBoNWg0AqERtNd38urDb2MwGbB32yc0CKbkJTJneQ5LNy5k/rq5xKXFTOtuU2X8zdZ1hCoQKtOSVqtFo9VSvq+K95/6kD6Hi+bKVrpaLAC8/si7vP7Iu+gNOkwhJva8dZDI+HDmrszFYDag0WpYffUychZlIqXktb+9y4t/ep2tz+/C5XQPXOfFP71B/oocvvrQXWTOT+eWb15LW10Hrz/y7ojqmVGYyl2/+QR9Djc/vuW3GEwGshakc+md60mfl3rCuR63h2d/9wpleyup2F9NWEwouUuyaChroqW6DUdPHz2dPVjabeP2czyTvGXZ3HP/p0jOTSAsKnTSrqso04nqGlWmLa/Hyzc2/YhDHxSP+rVpc5MJjQpBCMHqq5aRtTCDX93xAF3N3UOeH5UQwR93/ZzYlGh6rb3clv45HDbnGa8zZ3k2l9yxgSd/8iwdjV0DzweFmvn5m99l7srjrU2fz8e7T3xIYlYcPr8EKfF5fHg9PmqL6tn+8h70Rj0Gox69UUdPdy/OHidBYUEEhZoICg9C+iU9XXbK9lTS3Wod0c/CHGIiJS+RupJGXE43sSnRpMxJIikrngs+ch4LLyxQLb8ZYqK7Rjc+csNEFH2Kp8/767TqGlWBUJnWerrtPPObl3jyp88BMO+8OSy9eAE6g449bxzg8JaSEZVz/vUrqTpYQ1Nl67DnBIWZufhj6/jsbz5ByY4y7rvrQeqPNo26zlqdlsSsOG7++jVc9qmLcPe5cfQ4B5ZICCHw+/1jDj5t9R28+tDbVB+uw+V043a68bg8uPs8eFweXE438Rmx3PnjW4lLjyU6KRKtVovH7UGj0Qy5vEOZGSY0EObHyYsmKRA+s+YvKhAqymhIKXnniS1ExoeTNjeF1tp2HvjiI9QWN+Bxecb1Wqn5yVjarKy4fDFX3XUJD3zpEcr3Vo2pLK1OS2hUCG5nIBAGhZkxmg187eHPoTfpefuxzfR02clfkcv8dXNZsG7euN7LdOHuc+P3S7XcYRyoQDgxVCBUph0pJR88vQ2/X5KzOJO0/GSklGx5dgdHPiwFAovLvW4vGQVpVB+p5b1/bT2ra5qCjfT1uk54LjYlmqUbF/Dh87uwW3rPqvyhBIWZmbMsm7i0WCLiwoiICyc8NvBvbEo0qXOSpl3rrbvNypEPS+ls6iI4PAhbRw/hsWFEJUYSEhFEd4uFiLhwtHotGQWp6PQ6ulsteNxe4lJjprr6M95EBsLI/Di54ZEbJ6LoUzy35s/TKhCqyTLKtHNs9uR/fv0ClQdquOWb13LHj29l3Y2rWX7ZYv785X/w/lNbcfeNrTUYERvGog2FdDZ1c3hLCTHJUTxS8nt+fvv9bHth98B57Q2dvP7395i/bi71JY30Wh143N7xuk0cNif73z2CTq8lITOO9vpOPC4PBpOBtTet4qsP3jVu1xqJXpuDX9/5J6ISIlhx+RKWXDz/lDV7kXHhrLxiyajW3UXGR4xzTRVlfKlAqExLF9x8HmtvXMVbj37AfXc9iMvhZvlli1l8USFffegubvjKFTRWtNBrcfDBf7bR2dSNz+tD+iW9Ngft9Z3Dlr3oovl86/Ev0tHQSW1xA3nLsrn/nr+x761DA+cEhZlZtL6QS+/cgNvp5rVH3uXw5tFP2jlGp9eStzyHT/zgI3jdXiLjw9Eb9Vjardg6AovsPW5vYGH+lhJ8Hh9/vfdR3E43cemxJGbGccFHzhvRWsixCg4L4v+euRdLuxUhxLAL12fK4nNl9GZr0m0VCJVpS6PRcMkn15O1IJ2eLnv/2ODfaalp49I71rP2hlUApOYn8cbf36OhrInDW0rxeX3Dlrl000ISM+P48LmdrLtxNXFpsQB84Y+f4qavXYXOoMPlcIMAnyeQ3aR421EMJj05S7LQajX0OVwjHjf81uNfZPU1yzEFBdKjHXMsI02f3cWOV/by1j8/OOF1ZXsqTylrzoqcYTPcjKeI2PAJv4aiTCcqECrTXu6SrIGvL/tUoAvviR89g8/rZ/0ta8hfkUv+ilyklLzwx9epK2lAq9PicXvxebzEpcWSUZiK0AgWrS8kJCJ4oDy/309tUT373zmCrbOHvW8fonRn+bjUOyI2jLR5KZiDTaccE0KQPjeFlLxEcpdmkTEvleaqVjoau9DptdAfNLU6LaZgI+YQE2W7KyndWUFTRQt2Sy9ej5eEjDhS85NZuL5gyOsoykhJVItQUWaM4LAgPvOrj5/yvBCCa79w2QnPHd5SwjuPb6axopnlly7mnSe2sPv1/XhcHjwuLx2NXTRXDb+kYtR1Cw/igptW02PpJTgsKPDuchparZboxEhu/vo17H3rIM/d9wp73jxyysQdgP/e/9opz33ut59Eb9ShN6j/yooyVup/j3JO62qx8O6/PsRp7+OdJ7ZgCjIO7AV4jMGkZ97qPKKTo7C222iuasNg0gceZgNGs4HYlBiklLz/1NZTXj/Yedcu54t/+vSYZnsu3biQpRsX4vP5OLqrgj98/mEqD9Sc9jV/+do/iU6KZOH6ApZuXEhEXDiePg+VB2swmAzc+LUrJ3RcUTm3qBahopyD1t24Cr1RR21RAwsvnEdPdy9+n5/QyGBaazvo6+3D7/PjcXmxW3oJjw4sBei1OrB391J/tIk+ex8ed2CiTEhE0GkDoXYcFqy/+tA7/PN7T2HtOPNOFVJKOhq7eOfxLbzz+JaB5wvWzOH//eMeFQQVZQRUIFTOaUIIzrt6OV63l7cf34LT7sQcbOK6L11O0bYyKg5UYzIb8Pn8A1lZvB4f1nYbljYr3S2WExJdn5zWzBxiIj4jFrfTjVan5TO/PrXLdiSklPz7F//l8IclHNlSiqPHiSnIiDHIgCnYhDHIwMILCshckM6RD0vY8fLeIVPAhUYGc/d9d3LRR9eeMDlHUc5EIlSLUFHOZUnZCTz50+cGuhpf+subpz1foxHEpsacdreHeefN4TtPfYXYlOizrp8QgjXXrWD5ZYsJiw4lOilyyBRs//nNS7z3r60n1GveeXPYePsF5K/MGVjErijKyKn/McqskLM4k/u2/phdr+7ntb+9g9fjo6Ohk7a6jhN2ozjG75e01rYPW15weBDf+8/XiE6MHLc6ps5JPuM5C9bN5VtPfAmAkMhgDEY9WQvTCY0MGbd6KLOXH9UiVJRzmtFsZO0NqwbWH0IgD+azv3uFwx+W4OkLdIsm5ySSvSiDzc9sp7vViqXNSq/VMfCanMWZfPqXt49rEBypOctzmLM8Z9KvqyjnMhUIlVnNYDJw67eu41auo72hk/f/vY2X//omb/zjPQwmPRqtZmApg0YjWHTRfG762tUsWl8wxTVXlHEm1axRRZn1YlOiuelrV3HtFy7l8OYSGsqaefpXL9DXG+gi9fslDquD2NToGb1/X2dzN+31HeSvyD3zyYoyC6hAqCgn0Rv0LLl4AUsuXsCySxai1WmpPFCDvn+9YXBY0FRXcUyaq1qxdfYQnxGrgqCiDKICoaKcRlJ2AgDx6bFTXJOzFx4bRmJW/FRXQ5mmZnOKtZnbv6MoyqgEhZqnugqKMi2pFqGiKIoCqBahoiiKosxKqkWoKIqizOoUa6pFqCiKosxqqkWoKIqiACBVi1BRFEVRZh/VIlQURVGA2Zt0W7UIFUVRlFlNtQgVRVEUpEq6rSjKePL5fDz54+fobOoif1Uel96xfqqrpCjKMFQgVJQJoNVquf7Ll7PzlX3MXZU31dVRlBGZrbNGVSBUlAkSHB7MhtvWTnU1FEU5AxUIFUVRFFCZZRRFURRldlKBUFEURZnVVNeooiiKAszeyTKqRagoiqLMaqpFqCiKoiCZvQvqVYtQURRFmdVUi1BRFEUBGUizNhupFqGiKIoyq6kWoaIoigKobZgURVEUZVZSLUJFURQFiVpHqCiKoiizkmoRKoqiKKik24qiKIoyTQghLhVCHBVCVAghvjnEcSGE+EP/8UNCiCWDjtUIIQ4LIQ4IIfaM5HqqRagoiqIA02MdoRBCCzwAbAQagN1CiBellMWDTrsMyO1/rAT+3P/vMeullB0jvaZqESqKoijTyQqgQkpZJaV0A08B15x0zjXAozJgBxAhhEgc6wXP2Rbha397h3f/9SEtVa385v0fEJcWO9VVUpRJIaVEiONjPSU7y4mMDychIw6Aom1HqS1u4MjWEhIz41l7wypikqMIiQgetsyDHxTR2dTN/LVz6WqxADBnWfaE3ocy+SZx1mjMSd2WD0opH+z/OhmoH3SsgRNbe8Odkww0E5gA+6YQQgJ/HVTusM6ZQNjdamHHy3sJjw0jLDqUoLAg7vzJbWQUpGAOMU919RRlwng9XnT6wH9lv9/PC398nawF6RSsmYNWp2XP6wfQ6rWkzU0mPCYMt8tDc1ULoZEh6Aw6/D4/7j43Pd2Src/vIjg8iLU3rEJKybO/e5ldr+3H3m2nfF/1wDWTsuMJjQrhm499kdjUaLpbrRjNBiLiwk8IwooyjA4p5bJhjg31B3Ryp+3pzlkjpWwSQsQBbwkhSqWUm09XmXMmEHrcXpZuXKBafso5zdJuRavTUr6vmszCVJ7+1YtoNIIr79qE3++nqbKV9beuISI2nKd/9QIGk4EP/7uTqoO1AAghSJmTRHtdBxs/cSFrr19JdFIkLzzwBv/66XO4nG4+/4c7AXA53cSmxuBxeWit7UCn15JekMr8tXNJzIxn4ycuoGRHOV8+/ztYO3oASMlL5HvP3IvH5UH6JSlzkrB19pCQEacCpDJSDUDqoO9TgKaRniOlPPZvmxDieQJdrbMjEMalxkx1FRRlQtg6e6g4UMPrj7zDnjcOkr0og6BQM0FhZi64aTXpBalsf2EPidlxfP/6X5O3NItP/fSjvPzXt3D2OJl33pyBQJiYHc+mT1zIZZ/aQHhMGOX7qvj+9b9i39uHMQUbSZubzIZb1wDw2sPv8K+fPUd3qxWA0MhgDCY9ts4eshdm0FbXwc8+eh92S+9AXTsaurhr8dfx+/zkLsmksaIFc4iJm++9hrzl2aTOSSI8Jmzyf4jKGUk5bRbU7wZyhRCZQCNwC3DbSee8CNwjhHiKQLepVUrZLIQIBjRSyp7+rzcBPzzTBYU8zTShZcuWyT17RjT7VFGUceb3+7G0WYlKiMTSbsXn9eN2urB12YlOjOTxHz3Lzlf2Yrf0EpsSzcorl3LogyKaK1sJDg+ir9eFpd02UJ4QgrU3ruIbj36BpooW/vWz53j3yQ9PuOZVn7uEtLnJbP7Pdjoau2iuaj3hePq8FCLjw0nMSqDiQDUt1W30dNlHfE+hUSFs+vgFmIJN3Pq/12E0G8/uhzTLCCH2nqZL8ayYc5Jkzm8/PRFFn+LINT887X0IIS4Hfg9ogUeklD8RQtwFIKX8iwh0L/wRuBRwAHdIKfcIIbKA5/uL0QFPSil/cqb6nDMtQkWZjrrbrDRXtTJvVR6VB2tor+9kzoocIuPCAXDanRx8vxi9UcfSjQsB2PfOYaoP1VK2t5LM+ensfesgCemxFK6dy6HNxQgCgyHLNi1ixWWL6bHY2f/OYZ773cv4/YEPtj3dvafUZcnGBdz2v9fTZ+/j13c+wNHdlaec89Kf3zjt/dQWN1Bb3IC7z0P53qpR/SxikqNYc+0K9EY9phDTQF2V6WO6LKiXUr4KvHrSc38Z9LUEPj/E66qAhaO9ngqEijIBXn34HcJjQrB22mmrbaezqZuwmBAcdid/+vLfue1/ryezMI03//kBpbvKiYgNwxRkImdJBjmLMvC4PFjabVQeqMbr9vLh87s4srWUoLAg2mrbB4LIHT++lXce38LhzSVnDCwhEUHseGkvz/7+5VG14gBiUqKJTY3B5/PTUNpAa207AEazgdXXLCchIw6tTkN8eixet5e+XheOHifOHic+r5+MwlQuvn2dagEq05IKhIoyAcJjQ9n2wm7efWILXo+P2NQYCtbMITQqmHsfuZum8mb+8PmHufj2dcSmRmMw6jnw/mFMIQb+9q0n2fPGQa79wmVc96UrOLy5hKqDtTSUNZ9wjTf/8T5Hd1Wg1WtxO91nrNMHT2/ng6e3D3tcCMH89YUg+pcX+30gNPT0uKirbMdSFlifnDU/E5/D2R/o+nj/qa0nlBOfHsvcVblcffel1B9t4uKPraW2uAGd4fRvNz3dvex+t4jKQ/WsvGQ+yVlxRCdEnPG+lPEzHRbUTwU1Rqgo46S5qpVXH3qbzpZuEjPj2fbCbi6540IOvlcMQtLVYuXKz25k/7uH2fvmIaztNh4+8lue+PEz1JY00FrTgc/rw2FzMvj/Zd6ybFpr2gZmZo63qMRI4tJj6XH6aG2wjPh1sYnhxMSFgN+P0+agrbYdW2egjunzUshamIHRbCA1P5l/fPcpVl21lKqDtSTnJhKcGIMpyEh8ajQXXLcMj9vL9z/2Z/QmHTEJERzcWoY52EjhqhyERpCYEcvlt59PWt6Y10yfEyZ6jDDz15+ZiKJPUXLdDybsPsZCtQgVZZSklLTWttNU2Uqv1YEp2IhWp2Hny/toq2vH5/NT62zgqw9/jl/c/ge6Wiz0dNkxBRmp2FfN7tcOYOvsITkngcbyZrweH82VbSfMvhysbM+pY3njxRRiIiw5joryEWejGtDebKW92TrwvZR68lflUbqjbGAsEcAYbGTuhoVYup0IvY7a0iai3FB+qB6dQce/738Dj8sbqE+QkfmrcknMiGXh2jlotRpa6zsJjwpRrcNJME1mjU46FQgVZYT6HC7K91ZxaHMxRVtLKdtTibWjh4i4cG773+so31dFRmEapiAD+945zK/vfIDIhAh0Bh3mEBPSL3n3yS1Y2m2k5iezYN08fnzL7+jrdU3ZPeUuy6HkcPOZTxwBIQS6oOPJK2JSYwmOCiE0IZrivbUnnNt5KJAUxOv2nvB8n8PF609sJTIujG2vHcDR00dKTjzzV+dSV9ZMW0MXF39kNUsuyAegpa6DqqJGUnMSyJibNC73ocw+KhAqykm2vbCbp37xPN96/EskZsUPPO+097H/ncP862fPodPr0Jv0mIKNJGXH09Vi5fCWEg5vKSExKx6vJ/AGX1vUQGJWHIs3zOeNf7wHQFh0KO31Hbzy4FunXLtw3Ty8UoPfL9EbtHTVtp6yhGG8hEWHUlbaNi5lzV2YQnNZAw3FdSQvnUOvrQ+L1YGl2Q7No5uYA9DddnzZR2t9FzUlHwCQkB7DumuXcW3WVzAHG+np7kVv1GEONjFveRZJGbFExIYSkxSJ1+1l3wclJGfFkT4nicTMWNLyEjAY9eNyz+caiVAtQkWZjbyewAzHkIhgdry8l4e/+TixqdF88YFPk5gVj9/vR6PRIKWkaGspGq2G6798JQXnzcHldPH245tpr+/k2d+9PFDmyYGroaz5hIkuts4e9CY96Ysy0ep06M16QsJDcNt7Qauj4kDDwLk6g5b5FxZStLlo3JcbOGwO9DFB+MahLA2SmPQ4PEJHbVnLOJR4nNPeR2RsGAaTnqAQEw984ym8bi89/a1Jj8uLx2VnxxuHzlhWeHQIWQUpXHzzStLmJJFVkIxGo/YemO1UIFRmJY/bg6XNxp43DvDeU1v59C8+Rm1xPTEpUfi8frIXZVB5sIYPn99JeEwY195zGWuuXUHe0iwOflCM3dJLR2MXtk47zZWteFye0V2/z4NGo6HF5sXd5gRszFuSgb3TdsJ5XrePksPNxM3NwCR81BypO+t7zyhMIzgiGK3RQNH++jGnPgsODyItLwG/lBTtrz3zC85Cj6UXr+fsQ7a1087+zaXs31wKBALjgvPyWHPFIuavziUqPvysrzGTzdJJoyoQKrOLu8/NH+5+GLu1l+jESFwON13N3bz4pzewdtg4sqWU1PxkPnx+F4/87xM0lDWz6ZMX4nZ5eOuf79Na205odCg1R+qoL22ks6mLPsfYxvj8fj9+n3/g++J9NQCkLcwgOMhA5cEa3I7AsoiOFhtSSuZfWIj0+7F19OD3+uho6sLtcJGQlUBwRBBOrwaH3UliahR4PNi77XQ2dg1MxJm/YQElBxuhOfD92eT/7LU6OLqvhvwVWWMuY6TGIwgOxdppZ8tL+9jy0j4MJj3zV+dSuCqHwlU5FKzIVvlRZwkVCJVZxWAycNXdl9DdauHge0VExIWx8sollO4sp2xvJV6PDyHgV5/8IwVr8skoTCM2JZrroz6Jy+kmIi4cZ4+T4PAghEbQ2dQ9UPbcCwoxhAXjsjloOdqA1qDF5/Fjae46oQ4ajaBw0xKqqruHfIOvq2jtr6uRuUuy0EhJ0dajCCFOmdgSFBOFzuunrdsN3cfXEtq6Gwe+lhojBeuzcfa6OXrk5NzFYxcUaiI6OYriXaPLMDNdufs87H2vmL3vBfZ/zchP4jM/upHClTnoz7AG8pwwfXKNTrpZ8NtVZjuf14el3YpGqyU4PIiu5m72vXUIY5ABn09yZEspTnsfoZEhzFmRw6aPX0BceiwtVa00lDfTUN5M/spcLvroWswhJpoqW7G0Wak4UI30S6wdPfi8Ppo6XfRWWwIXNfTv7aeH8IIo4pIiCDLrkW4PDksPGr0eoT39m47b5aWkv8tRGx6MVqclLimC4FATeo2g6mAdjh7nGe9fCMHRQ41nPG+0HD19JJnO3YknNaVN/O9NfyAqPpxPfPNqYlMiCQ41kzE3SU24OceoQKick1xOFx2NXfz89vsBiEmOZNmmRRRtOwrA+devxOv2kpAVT3JOAsFhQUgpcdqdeN0+3n5sM/EZsXhcXhxWB3WdPfz204FUhxFx4WQUpnJ4c8kJ14xNCKPXdmpg6u3po/roSRNImoZeMzgcn9ePz+unoap94DmNRlBw/hyKPjw6qrLGU3tDJyk58bTUdeB1T0z35VTrarXyu688BoDBpCc4zMxFN63kgmuXkTkvGa1Wg6W9h4jY0Cmu6TiYpYOEKrOMck45+EERHQ1dlO+tZPHF89FotaTkJp6wDGIwv99PbUkDdSWNWNtttNUF9t3b8uwOfvzSt9j5yj7ef3orNUfq6bU6CAoPJnvlHLxaHQatoKeti6biBuZsWETRgfohrzGRDCY9YRFBhIUYB7ZamgpCI4hJjCQiLgyv10d18fi3QKejxIxYVmwsxO/102N18D/fu25CF/5PZGYZU3ayTPvFXRNR9CnKb/retMosowKhcs5oq2vntb+9yxWf3UhMUtQZz2+uauWVh97GYXMQnxpLe2MnR7aWojfoOLq7kuTcBGJTY2g42oTH6yd+YQ7VZa0nTHCZLjLmJOLrdVJ/dHwWx58NoREUrMrlyM6Kqa7KpDOY9Cy/qIB7fnEr5mAjRrNhXMtXgXBiqK5R5ZwRlxbLJ37wkRGdK6Vk56v76G61EBYVisPuxGF3YgwyUl/SgJTyhPV/cy9bQXnR+E00GW/mIAMl+6bHpBXplxzZVkZschTxGdEc2TFxKeKmG3efh62vHKCurIXuNivLNhSQkB7DbV+9fEZMuFGTZRRllomMCyd/RS7hMaHseeMgnU3ddDUfnwUan51ITEYcPr1xWgdBCIwXTjftjV3Ep0dPdTWmRH15YEz4/ef3kJgRy0e/dsUU10g5HRUIlVlDSsnR3RWYQ0w8/K0n8Pv8lO2pQqMRdLVYmLM8G7/PP7CpbXxuEkfL2vF5p19X6MmqjjYTnZ2A1u2hrb5zqqtD+twkhFbDkZ2zpzU4nOaadh76/rN87ic3T3VVzmi2bsOkcgsps4KUEpfTjSnYyIH3iohLjUGj0XDrN69j7uo8Lr1zAz6v/4QxnUOv7yU+RDMjFlU77S4iw81THgS1ei2F5+VRW9ZCTcnoW9GpufHEJkeSkhNHeHTIGfcwnCmO7KzgHz97Ab9/+n+omo3Ojb8yRTkNu6WXqkM1bH5mB/VHm2g42kRXc2Ax+963DuFxeTCaDeiN+hO2QjKHBxGRHEuTZeonoIyEy+snOjGCzmbLlFw/JjkSY5DxrCbJ1JcHkgmk5ydy1Z0XcPMXLuH5v77Lk799BZdzdGnsppOqIw0EhZimuhqnJVFjhIpyznH3ufnPr1/inSe3YG23DWwaO9ixHKEupxvXoF3eF165koryNoqLZkYQBKivbMMUZCB7UTqVByZ/KUVCWgxHdo1PV2htaTMmcxGZ85K59jPrmbcii5ce+YCdbx4GICjERHe77QylTB/mEBN3fudaleB7mlKBUDnneNweDm8uofJgLYc2F9HX2zdkEByKOTyIjDXzKZqATCyTwevxUX1k8tczAhzZXk7ekgxqjjbj7jv71tvR/TX86I4HMZoNXPvp9Wy4YQWf+OZVdLXamLsskw9e2EvloXoMZj2Ht5dTcahu2rUajWYDV915ATd9fiNhUSFTXZ3Tk4BqESrKzObz+bB329nx8j4+fH4nTRUt9FodJ+QDPZ2FV6ygoclG+ZGZGQTDIoNJy4rhSP/OClOhbF8NWfNTaanvxNHTNy5luvs8lOypork2kOzg/CsXY+2ys+GGFWy4YQUAfb0u3vjXNrLnp5Kel8i21w7wxpPbKD9Uf8rmv5NlwXm5fP2BO4hJjJiS6ysjpwKhcs6oLWrA7/fTXNVKW10HTnsf1nYbOr2WuLQYnPY+ulutw77eIwXWztFvIjtdpGRObRA8pupwPYVrcsdt/aCUkkPbyoFAou/68hbWXb2Uaz+zAZ1eC4Ap2Mg1/7N+4DWX3LaGS25bg6W9h9L91XS32Wiqbsfaacfa2UNzTQcuhxuP24vD7hy3lmRqbjybbjmPBWvyyFuUPi5lTqbZOmtUBUJlxmur76Cttp2ebjtBYUE0VbbgdroJDg/ivKuX091mpfJAzUAQ1Gg1xGXGYwgyYggyEhwdjsPtp7J05owHDqW2oo2C8+dQvrcK9xR3ER7ZWs68ldlUlzbjtI9PyxACib7LD9ZRfrCOJ3/7KjFJERSuymXZhnksOC+PkPCgE86PiA1l1aYFpy1TSomtq5em6jZK91az9dUD1B5txm5xDPsajVZDVHwYcxZnkD0/lbTcBOatyCYyNmxc7lOZXCrFmjKjOXv7eOuf7+Pz+WmrbQ90kf39PTyn6Q7T6rSEzs3Cbj3zzg0zUU5BMhW7pkd6s3mrcijePTkZb8zBRj73k5vZeMvqcSnPbnVg7bTj6OnDae/D4/ESmxRJXEo0RrN+SpbVTGSKNWNWskz+8ecnouhTVH/02yrFmqKMF3OwiZzFmTSUt/Ds7/6BTq8lOS+RmtNMGPF5faRlxFB8cGomlYxVaEQQF12/jNL9tRQsz+TVJ7cDkJGXiJSS4FAzna1WrN0Ozrt6KbVFDej0WiwdPVg7RjZZaLwV76ggc37qpCThdva6eOxXL9NY1cYn//easy4vJDzolBamcm5SgVCZcUp3lVO6s4Jrv3AZPq+Pl//6Fg1lTZhDTDh6nKcNggAhkSFUlbVOUm3PTlhUMAajnl6bk8Xnz+F//vdqPB4flo4eNt28CiklaTmBnTXsNic+j4+wqOCBafruPg///OkLdLZYKNtfS3NN++kuN65SchMIjwnB75u8gafgUDPrr1+O2+VRewaOmlDrCBVlpshfkUvesmwAnvjxs6TNS8Hj8lC2Z2RdcIlzU6lumJoW0mjZunrJX5zOp751JVqthu6OHnw+Hwmpp+bwDB2i9WIw6fn0D28c+P7ovmoe/+XL7HmnaELrDYHxuclMsRYeHUL+skzS5iTOiGxAyvShAqEyI2k0Gj54ehu1xfVEJ0dRvL0Mo9mA3++nr9d12teaw4KA6RsIwyKDySlMoXBFFhdes4SwyBCCQoxIKc96QfacJZmYgozjVNPhmYIM2LpHt/nw2YiICeWr932c5RcVTNo1z0mzdNaoSnOgzChtde3YugJBrKaonos/fgERseGkF6QSERd2xiCYsyqf4uLp3S1q6+7lwNYyUnPiSUyLITjUhBDirIKgr38PRbvVQUPlxN+/KdiI0TS+e/GdjqWjh+999AGeuu/1gXs95uj+Gv7zxzdpqe2geHcllikaL1WmL9UiVKYtn9dHS00b3S1W5p2Xh8fl4cD7Rfi9fna/vh+f3887T26heYRv7PlrC2izTa/MI0NJzozlsttWs3z93LMuy+fz89B3/8P88/KYuywLieTKOy7gT9/4F37/xH38j0+PofzQ5E9G+vd9b7Dm8kWk5iYMPBeTGIFWp6W+ooU5izOmf4YXZdKpQKhMW9VH6vD7/Fjarex+/QAfPruDnCVZbP3vLva/c3jE5Wg0gvlXrqToQMME1nZ8zFuWyee+fx05hanjUl6fw0VafhKvP/Yhf/n206TmxmMKMk5oEITAovr8pRnYLQ56bU46W4ZPZDCe+hwu/v7TF7j3/k8MJLmOTojg+rsumpTrz2hSJd1WlGknZ1Emzt4++hwuKg/UkJidwDO/femEzXPPJCwugviFOTMiCAJ0tlg5vKOSpIzYs96twNZl54cf/wtFg3aD6Bhhurmz5XF5Kd4euG7uovRJC4QAtaVNOHr6pv1uD8r0oQKhMu34vD46m7tpLG/mpb+8ibWjh0UXzsPvlxhM+lEldO7t6kH22ClYlEJTo5Xu9uk9PtTa0MWDP36B7W8d4eu/+yixSZFjKufIjgqe/PXLJwTBqRAWHUz3JKetM5j0NFW3DeT4lFIihMDv96vdH85klk6WUYFQmVZcThdb/7ubf//yv7TXdQzsFl97pA67xYHP6xtVeT6vj4odgfybC69ePe0DoVanYeNNK7jwqiVjCoJOex/3f/1J3ntm1wTUbvRsnb1kxkeQuCqH9qZuWuomfuPgmpImvnH970nKjGXTravx+yR73itm5aZCVm5cQPqcxAmvgzKzqECoTBslO8t5+JuPU7K97JQUaT6vf8RB0BhkRG8yYO86Mej5Jnhc7GzlFKbwnb/cQXxK1Jhe/87TO3j4+89imWbBfnBWmfR5ydQenZycrk3V7fzjpy8OfF+8q5IPnt/LDZ+7iA03rpyUOsw8aoxQUaZMbXEDD33jMYq3lZ0Q8FLyEll342r0Rj3bX9pD2Z6hF2hHp8SQvCSXliYrXW02fEBQdDQRMaGEhJrw+fyUHpq+44RBoSbu+fGNYwqC1k4737j2t3S2WE6bKHqq5S7OoGMU47sToaqogd999QmKdlVy3WcuIqU/K48yu6lAqEwKr8fLrlf3s3TTAozm4wu6m6ta+fcvX+DwlmKs7baBIGgw6YlKCEx7X3nlUsr2VKLRDj2+M2ddAS2dLooPnDhd3+3y0tbYTdvE3dZZ0WgEabkJLDwvl4uuX0p45Mim9btdHurLWqgtbeKZB96kvrx1yvbcOxOhEaTnJ2EONVMywsw/E83r9vLqox8SnxrDzV/YNNXVmV6md6fJhFGBUJlQfr+fmiP1VB2qpb60gcqDNaTmJ7P66qXoDXp2vrqPjIJUqo/UUVcS6EKLT49l3Y2rSMiM5/CWYn58829pbzh1bEmr01J4+QqKDsys5Nlzl2SwfMM8UrJiKViWSVRcOD6ff0SJsTuau/n9lx4jY14yz/3pbU63e8x0IP2S4DAzTZOY43Q4CWnRFK7KJTjMRHh0KBd/RHWPKgEqECrjTkpJ0bajlO4s59JPbeDVh96mu81KdGIkIRE6Oho6efT/nmbXq/upLW5ACLj67ktZdcVSdHot0UmRBEcE01TRwv53Dg8bIEwhZqoqpmt777iouDDWXr6QuUszaW3o4qa7NpySC1Or1RAVHz5sGT6vj2f++BY73zxEye4q9r5XPNHVHjdFOyoQGsHcZVn0OdzUV7Tg9Yxu0tN46Gi2EJMUwfrrl5OWpybMDGl6f66aMCoQKuNOCEFIRDBBoWZ6bQ7Ou3YFfb0u/v6dJ6k5Uk9IRDDxGbG01XcgpURK2P3GAYxmA7bOHjoau854Db1JT3h+Bm1Nlom/oTEICQ8iJiGc3h4nX/r5R1i6Ln9Er6spaaSj2ULGnEQi48PparVitzioLmnC7fZQMkl7+4036ZeU7AqM7xrNBuauyqG1oYu2hjP/rseL1+Pjqd+/zvbXDvLn97+jEnMrA1QgVMaNz+vDae+jra4dv89PTXED1k4b1YfrEEKDtd2GTq/FbunFfuDEhMyN5aObSejp8xAbEzQtA+Hi8/P4yN0Xk56XgMftHdUyiNjkKDqaLHi9fr58yS+oKWkkPT+JysMzq/v3dFxON4e3lgEwd2U2JXuqJ/X69eUtHNhylMUj/HAya0hAZZZRlNFz97l54YE32P/OIWJSonE5XJhDzQSHBVG8rZTgiGCWXLSALc9ux9rRg/+khMhnw9bchU6vnZJutmPMwUZiEiOor2hFq9OwetN8bvvCJjLnJo2pPI/LQ8HKbJ787at0NHfj9fjOqSB4spKdleQtyaCquHHSfo86gw5Xn3tSrqXMDCoQKmPmtDv58LmdtNa0Yevsob2+k7b6DoLDgtDqtQSFmenrdbH5me24HC50ei3ucQyEwVGheNundhKGs9dFn8PFbV+8hOiEMLILUsjIH/v4U4/Fwbdv+gM1pU3j+qFhOjOYDJP6Ycbd5+EHH/8Ll3/8fK6+80LS88f2oeVcNM3nXk0YFQiVUZFS8vZjm3E53dQW1aM1aPG6vVxzz2VotRr2v3OY3W8coL26E40m0M3i90vMIaZRpUYbCa1x8rb5OR2DSU9GfgLnX7bwrMedindVUl3cOO1ng46X1NwESvdNbtfoMa8++iGvPvoh0QnhZBem0udw4XJ6uOsnN5G/JHNK6qRMjVkfCP1+P263F9Mk7p02EzWUN+P3+els6sJg1nPg/SM09c/+K99bxSsPvQ2AKchInyOwJ+DgHQ6c9r5xr1PdvnLCYmOwdU/+IvKPfukSgkJNRMSEkjc/lZTsuHEpNzkrDoNZj8tx7nfd5a/IoqW2c0q7tiGQ6HxwUvC3/71j9gbC2fH56xSzMhCWHmlgx+ajWC0OcvIT6e6yk5OXwPLzctHqtFNdvWnB5/Oh1WqpOVLHfx94jdQ5yTSUNVG6swKf14fd0kt7fSfhMaHMW51HV4uFXksvlnbbpNWxu6mLwoL0KQmEbz+7my/85CYWnZ+HdpiF/mNRuDqX37z8db586S+m7SL5s5WWn4QxyEDp3pqprsopImJCWX/DCpWge5aZVYHQ6XDRVN/Fs09sJzwiiK4OO53tPVx23RJCw8wqCPaTUvLMb14mLDqEg5uLaK5sY99bh8hZkkVnUxf27l5M/VvcWDt6cPQ4aattPyU/6GTQTVFLvrWhi6j4sHENgsdYxnlS0XQRHh1CfHoMZQfrproqw7J09HDv1b9h/upcfvn8V6a6OsokmVWB0BxkJHtOIt/88Q1otRpKjzTQ0d5DbNzwC5lnG5fTxYH3jmAONXFoczG1RxowBRsxBhnZ8/qBgS5O2eMkIjYMW5edygM1U1Zfq31qdpy/+pNryZigXQx8Xh9R8eGTtnfgZChcnUP54YZpHQQHK9pZwb//8Dof+eKlU12VyTVLl0/Myrb/sU/xSSlRWLt6cY3zJI6ZrKvFwpGtR6krbmDnK/uo2F9NbVE9DpuTuatyyShMJSk7nsj4CGxd9ildlBwSGUJD1eTPGo2MCcXv82Pr7j3zyWOwYuN8vvz729HpZ34PRUhkMHlLMzmyqwqXc+aMewb2vlTzBmaLWdUiPNnubeUsXZ2N0aSf6qpMG8HhQSxaX8jhzcWkzU2maOtRerp76enupa2uY6qrdwJ7t5309FhCkuNoa7FNyl6DRrOBu75/HfmLM+hzuAkf245JZ5Sen8iyiwvY8dqhibnAJMhfnkV1SRNlB2qnuipD0hl0xCVHYjDqScqKpWR3Nd39Y9yFq3K4+lMXTm0Fp4BQk2Vmn8Ursti7o5KEMe4Cfi4KiwolJimSzsYufB4fOYszsXbYsLRaTxkDPHm3+LS5yXQ1W7BbJqalNJTaA9VwoBq9SU/BpmUTnoDb5XQTmxRJXPLE/s0IIag6PH23jTqd1DkJeL2S0n01U12VYaXmxvO5n36ExWuPZ5dxuzxY2nswBRkwBRsnZPxXmZ5mdSCMigll45WLproa04rP68Pa2UOvzUFnU/cJuz5oNGJgSUTh+fl0tVhoqmgBQG/Uk5STQEdD1wlLKCaLp89Dw75yNDrzCcs2JkLp/lrmLsmYsPL9fj8anQa7dfruLTiUkIggMuYlc2Tn0HtGTqXkrDgWrMkLPFbnDpng3GDUEzfGTZHPCRK1fEJRGsqbaapoptfqIDopimWXLMLaYUOj1aDRauhutWAwGYiIDcPldGNtt7HqyqX4fH7cTje2/hmkk0mj1RCTHovOqEcTFYW1fuKTOJuCJnbsyGHv45n738TRM/5rLydC+txk9CYdVUcapmUQ1Oo0fPW+25m3PHuqq6JMUyoQTiNSyimdfBKTHIXP66W+pJHNz+zA7XRjDjENuRfgMY3lzaTNTcFu6R3RrhHjrXDjEoqLW8AL9E7O9WuPji5B+GjVFDWy7ZUDE3qN8ZBVmIIhyMjRfTXTNhOOOdjIV36nguDICDVrVJk6jQ1dvPzfvbz39tTuMWcKMpI+N5XUuSnc8OUrOO/a5fR02clelD7sa/x+SU1R/ZQEQYCjW44QP8HjdSfb/MoBnL0T1/WbNT91WnfRxadFM2d5FlUlTTTXtBOfFj3VVRrSdZ/dwLMVv2Xt1UumuirKNKcC4RTx+fxs23KUfXuqeehP75KTl0BuXvxUV4vm6lYiYsPIXpyJ3ydZfc1yEjKHrpdGE9h3MCw6dJJreZyrtw97VT0R0SGTds3u9h7uvfEPfPma39FQ2cZjv32Nnv7xvPFoGdWVNTN3WRbJ2fGsv3EF5v7kBZMhe34qGf07Z0QnRgx8LYQgJSeetdcuxRBkJD41ml+/+DV+8NjdE5I+bzxsfmGv2nNwtOQkPaYZ1TU6Rfr6PAgheP7pXSxflU1UdAhxp9mhfLIkZsZzaHMRdcX1HHjvMJnz0zGZj4+JZS/KIDY1mo6GLpJzEyjeVobQCGydE790YTjWVguFy/OxdNon7ZpVJU0AfHbjz/H7JR+8tJ+v/OoWOltsLF03h+Aw86jK6+t1YQo24u7zEJ8SxY1f2MSNX9zEkW3lLF0/j+52K4e3luP1+Ck/WEtPdy9CCIRGjDkLjTnYiEarYf55uSRmxGK3OsldmIbeqCclJ57swhTMISY6WyxAYOlISHjQwOudvX28/9xuImPDsE7iz36k1DpAZaRUIJwi27aU8d7bRdisDrQ6LbFxYVNdpQEt1e1kFqYTmxJNr6UXIQKTUq749MW0N3ay981DZBSmsuXZndMiFVhCXjKlh6ZmqcGxGaqN1e3ce+P9zFuaQVpuPK4+N1EnZSza8uJeVl+2EEdPH6GRwQghaKntIDYlivamblJy4jGY9PQ5tGi0GrxuL+n5Sdi6e0nOiSc0IhhziAmtVhAZF461y87ON0a2ztBo1mMwGUjNiWfRBXOJT4tGq9WgN+pYsGYO4dEhw7aeohMihinTQPrcZH7+7Jc5sKWUB//vWZz2Pvx+SXJWHD2WXtobpy47znWf2TBl156xpmFrbTKoQDiJentdmEx6tFoNGy+dz4aLC3ji0Q9JSAyfVl04mz5xIc1VrXz+/jvpbOymvb6T6MQo1t64ivs//zA+r4/aovppEQQBYjLi6Shtm+pqAFC8t4Yf3/V3EtOj+fIvbiF6UCu/YGUOti47bzyxjdjkSCJiwkjIjKHqSD3Z81MH/gbCokLoc7hoqGjFYNITFhVMQloMCekxPHv/m1QVN3JxYSpJWXH0OVyU7K4iIiaUtobAOG14TCjxqVGEhAfT3W7l7p/dQnxaNKYgI6GRwSO6D7/fT0eT5ZSxyh6Lg9CIQKtQo9Ewb1kWABdcu4x11yzF75dotRqklPQ5XDx9/5u88PD7k959KoQgIT1mUq+pzFzidGMay5Ytk3v27JnE6sw+r7ywj8uuWjywd990Ye2wcf89DxOfHsf516/g3798gdKd5XS3WECMvTtuJDQawfLLFtPdaqVsz6nT8TUaQcHGJQiNwOmF6qMtE1aXs7HuykV85O6LyZqXfMoxn9dHj8WB3qgjODTQjdrR1E3MGZI79NocBIWaEULQ1tDF8395m8x5KRSszMZuc6I36EjLS0Cn1yGlHAhM48Xt8mAwBjIxeT0+bF12ouLD8fv9fPsj93PwwzKiEsKJSYwgMjaUucuyyZyXzN9++NyEz7Y9mVanYeH5c/j+o59Dbzg3PvMLIfZKKZdNRNnG9FSZ+I0vTUTRp6j9/Ncn7D7G4tz465jBrrhmes5oe+73r7DuxtX4/ZLUOclExIQRGhmCz+vH0mY9cwFjFJsSjVanIS0/maqDQ6fm8vslVoeXptrhl3VMtaSMGNJyE/B5h/7AoNVpiYg5cZLRmYIgQHDY8TG60IggPv3DG4fdLkgIgVY79Acsv9+P3ydHnc/UYNTz2y8/xvINBVi77DzwzafIyE/C2mkfSE/W2Wyhs9kCwI43Do+q/PHk8/qxdtop2V1FVmHKCeObijKYCoRTpNfeR/AkzgYcreWXLeahbzxOeEwov/rkH4mMj6C1tp2I2DDS56XQWttO3wQsIfB5fRSuzcfv8w+5flGr0xKzeM60DYJGs4EV6+dy/WcuRKPRkjM/ZcKuNZLZpNauXkIjzBzZXU1sYgQ9Vicx8WE88cA7dLRYMRh19NqcpGTGEh0fTlxyBCFhZpatmzNsd31ETCg//czDA9/XlDaN2z2Nt8bKNhoqW8lfOks32h0NyaxdR6gC4QSQUmKzOgmPGP4T6HQOgtCf5ksjKNp6lKwF6Vz0sXXUlzZScaCGo7sqJqxrtKvFgt/n57JPX8wrD719SrD1eX0kJIbT2Tp5GwCPRMacROavzqFgaSbVpY2ER4Wg02unZOzX2tXLns1HefPZ3di6HXg8Xqydvdhtw2f92b+t4oTv45IiSEiNQgiBx+0lPDKY4DAz5mAjVYfrTskzO10tPD+PTbeed07s5KFMHBUIJ4Cj10VZSRPBISaCQox4vT6yc+Kn1YSYM+mo7+TCj6whvSCVvKVZBIWaeffJLRTvKEOr0+Dz+ibkuhqthmWbFpGSl8jn77uTJ37yLJY2Ky6He2CNnq9vcvOYjkTN0WYaqtpIy4ln+fp5uJweEtMmb7JG2eEGPnjlACX7a3G7vNRXtuF2jX2j5LYmC21NllOeL5yfROWBmmkdBPMWpbP2qiWkzUkkb1G6CoLKGalAOM7++se32baljM/ecxEZ2bFYunqJj59es0JH4oKPnIdGo8Fu6eXo7goSMuN458kttNV2EBYdisflwdZpP+sF5PHpsWQvymD3a/vJXpzJmmuWc+mdgWnvl9yxngXrC2iubuPZhzdjb2ij5MNi3EyPNzatTsO1d17Asw++x3mb5rPuqsUYzXrmLJy4N9+u9h6e/dsHXHrTChLToqksbqKzzUbZ4Xreem4vPZaJS9SdlhFN6a4KvJ6J+RA0HgwmPTd/YRNrrlg81VWZkdQ2TMpZ83n9aLSCm29dhcfj4+3Xj7Dx0vmYJzhJ80TQagNv5F0tFu7//MPojXqikyLR6jTjkk7NaDaw4MICrvzMRpZftoiOxi7iUmPQ6o4HECEESZnxmIJNNNd3odMbWXj1KooOTI/tia7+xFrO21RIYlo0G65fRnd7D9HxYRMSBA/tqqKhqp3//vND6ivbeOXJHVx1+3l8/EubyJ6XRH1l2ynbZI0XIaCgIJGyfdXTOggCuPs8/PTTD1OwModP/u/VgUQBFgcRsWGEhJtP+UAqpaSxso3OFgt5i9MxB0/vIQtlYqhAOI60Og0XXzIfs9lAr93FBRumPmXa2aoraaT+aGAyRNWh8dlgNTQymAtvOZ8bvnIFyTmJQCCjzXCi4sIJiwqh7GAdkxkCNVoNMQnh9FgdOO2B7ticwhTOv2whi87PI6cgGa1OO7CWzpxunLC6LFiRxYIVWUTFhbLtrSI+9oWLiU2MoL3ZgkajIT03nsKlGbQ2dlNf1T6u105KieTItrJxLXMi+f2Sw9vL+d5H/4Tf58fZ60IIwXmXLyJ3YSrXfnoDxv5sSe89t5vfffkxvB4fa65YzJd/+9HZPbt0mrQIhRCXAvcBWuBhKeXPTzou+o9fDjiAT0op9w06rgX2AI1SyivPdD0VCPv5vH66uuzDZnh54PdvUlnewroNc2lv7SE7J47mZgstzRa0Gg0H99ei02lpa7NhNut54OE7J/kOJsaaa5fz8e/fzJv/eI+2uo6z3usvZ3EmX3nws+QuyRpVd/GStXMoO1h3VtceLSECrVK9XkdUVhg33XURF1+/7IRW60Tz+fxUFDViMuvZ+W4Juz84isPexw/vfhSdTktGXgIhYSYuv3UVEsY9CAI01nWRkB5DS23HuJc9kXoHTQ6SUrL1lf1sfWU/LXWdrLtmKW//ewfvPrNr4Jytr+yndF81n/zW1Vx886qpqLLCQBB7ANgINAC7hRAvSikH70pwGZDb/1gJ/Ln/32O+BJQAI0rZNesDYV1tB7t3VPLic3tZsjyTL9172Snn1FS1s/3DMlpbrBQfaRxYqDycgvkpRESMLIPHdKfRaLj9ezdx+/du4t0nt/Dcfa9Qvq8av89PUKh5xPsPRiVGcvO9V3PV5zaNKQdkVFwYuf1LESyddjpbrBO+Aa/P66e1oYuQMDO581NJz4sfUxBsqGojOTN2TOPEGo1gxzvF/PefH9LncJ9wbMWF+Vz5sdXExIcTER3CF354Pb/95tNUH22hx+Jg/dWL8Xl8bH5tZGnYhiUEUQkRMy4QDuf1x7fy+uNbhzyWkBaNEAKfz692qJ86K4AKKWUVgBDiKeAaYHAgvAZ4VAYmKewQQkQIIRKllM1CiBTgCuAnwFdHcsFZGwjfeu0Qvb0unn5yO+1tPSxcnM6lVyw85bySokYeefB93P3jL77TLBtYfX4un73nYpKSI2fc5JiR2HDbWjbcthZrh42yPZU8f/9rVB6owdJqGTIoxaZEozfquPMnt7FoQyHhMWPPp3rVx88ne14yzzz4LkmZsXz46kGY4EB4jN3m5OiBujGPH6VkxY352j6vn8w5CWTlJ6LTa7ngioUYTQby5qeQmn1iufHJkfzisc/S2WajrambvMIU/vLjl8Z87cE8ruk7S3Q8peYmkLswTQXBiRcjhBictuxBKeWD/V8nA/WDjjVwYmtvuHOSgWbg98D/A0a8Lc6sDYRlR5t58fm9xMSEEhsXxjU3LmNO/5Yzg7U0WzhysA7vMBlCdDoNF1w0jxtvWUlObsJEV3taCI8JY86KHC69Yz2pc5L44OntGIOM1BbX4/V4mbd6DolZ8RSen48p2IjeoB+X60bEhpKaHY852MgHL+4flzJHwhxiZNkF+aTljH7M19Xnxm51EhkbOmwGmNPR6bUsWJXNuy/u53++cQUpmbFnfI3BqGPuonR6e5wc2F6BzqAjOjGc6OTIwKxAIag6VDcw7jkS9c02TMHGCUmiMJ18+PJ+jGYDd37n2oFUcrPJJM4a7ThNirWhWhEn12zIc4QQVwJtUsq9QogLR1qZczIQulwejGf4I159fh6VFW2sWJXNytU5ZGQdf4NxuTxseb+UlmYLtdUd5M1N4mhx0wmtweAQI0FBBq65YTmrz88lbZYl+A2LCmXdjasByJw//Ma94ykpPYbr/udCvv+ph8988ji65OaV5C1MG9G5fr+fg9sr2PzyfrxuHynZcay7ctFZ9RDodFru+f51xCScuk1XILm1G3Pw8Yk6of2TPV58aici3Ize5aG520Fz9/GlFUGhJrLnJaMnMDO4re70M4G1Oh2ZizI4svXomO9jJli4Jo87/veaWRkEp5EGIHXQ9ynAyemLhjvnRuBqIcTlgAkIE0I8LqX82OkueE4GwuGCoM/np6Kshd5eF5GRwdz7rStJ6t/dvLS4kYjIYBISI/D7JU8+upX606Tx0ut1BAUZsXT3Eh4eREN9F4f211JV2UZefmJg4kyLldAwE+ERQfT1eXD0ujCbDVx4cQF6tch3SD6vj23vl5KUGkX2nMRTjkdEh3D1J9fyu683TNpU/pcf28oPN8w7YzDrc7j443ee4Z3n9hASZuarv76VVRsLz7qbPCTMjNfr462XD7BnWwVX3rSc+YsDHz6EEBhMQ/+960x6aoeZPOPodVNeGkiCHRkVzJzlmRzdXT1wXHL8I3dyWhSuLts5HwQBtr5ygF7bn/nsD28ibU7CmFrxM9r0SLG2G8gVQmQCjcAtwG0nnfMicE//+OFKwCqlbAa+1f+gv0V475mCIExwIJRSTquxMkevi6MlTVSWt/LZL1xMUJCRhrpOXnv5IDarg907K/njg3dQUd5CVFQIlq5eenqG3j7G6/GRkBRBWWkzX/jM32keIgvHcOpqO/nUXevH6a5mPq/Xx6N/eY/tH5TS1WEnITmS3z3yqWHP33DtUna9U8QHL01O92hETChBoaffaNfZ6+KuTb+grX//vYiYUFZvmn9W162raecPP32Z7k47jXWdHMtdUHK4nlvuXMemqxah02mHHc8qXDSyVmx3Vy/dXb1kLckg2KzD64empm5iY8Mwm3SYkDT29J7VvcwkB7Yc5fMX/5Rny3+LaQauAZ7ppJReIcQ9wBsElk88IqUsEkLc1X/8L8CrBJZOVBBYPnHH2VxzQgPhdAqCAKFhZvR6HQsXpxMUFOhKqqpsIzTUxNtvHKbX3sfuXVUsXJRGWLiZ2PiwYQOh3d7HzpPyM47EvMJkLrtq0dncxjnF4/Hy42/8hx2bj7c2KkqbaarrJCMnHnuPk9YmC2lZsej1x/9cN964gojoEF74x5YJr2NCahTx/T0Hh3dWUrA885SWgsF44n+lpIwYSvfXkr94bN3G5aVNfPsLj2PtPjVTTGuzlft+8hLPP7mdj392PWsvLhiyjNSM0XXXV1W0nvD94GsnJ0YwLzmKsj2VeN3Te1H9eJB+yS/vfoRVlyzE7fJw5SfXTXWVJp5k2qwjlFK+SiDYDX7uL4O+lsDnz1DG+8D7I7neOdk1ejrVVW3kD5oUs279XCCQPmr71nL27a7mpef3snJ1DjVV7ej1Wjzj1AWn02n44c9vPm0y7nOV3+9H+iW9vS5qK9sIDjXR1mLl2ce2cWjfiQv18wuTiYgOAQJBMTQ86IQgCLD0gnzCo0N4/akduCY47+VtX9xEREwoDZVt7P/wKPNXZp9yjtfrIzImlD6nmys+toZLbl5J/Emb2o7GU49sGTIIDlZX3cF9P3uZpatzCAo+cTG/q8/Ds09sH/P1T9bYbKPbrCcmKZKWmnNjGcXpSCnZ/vohtr9+iO/87dNTXR1lgs2qQNjeZmPVmlwK56ee8HyvvY+uzl5uu30NHq+P5oZuHv37Fmw2J95xTC59462rCAs/fRfbuaizo4dffOdZairbyJuXTH5BMlXlLRzeV8v8JRnkFybT1mzF5/OjN+r40revIqJ/J/VFy7OGLTenMIXP/t91/OFbT09o/W3dDnxeHy8/vpVP3Hv5kOcYTQZWXFTA3CXpLD5/zlldr8fmpLmhe2TnWp18/bP/YMWaXC7YWEBPTx87t5Txxgv7sFlHtsZzpHKSwznyfvGZTzwHaLSagR1WjnV3zwrTpEU42WZVIIyJDSUmNvSULtvgEBNXXLN4YCFtR3sPHe09WPsTGOsNWjxn2R00b34KN926atp1F0+0jjYbX/2fR4iODSV3bhLLVmezdFUOJUcasFmdbH2v5ITzl67KJmsUy1A23bySsMhgHv7JC7TUn30O1JMZTXryF6fx/U89zAVXLzlhdubJNt64nJjEiLO63otP7+Lxh94/Y2twsIrSZipKm3nyb5vP6tqnJSV+AdkL06kcZsPkc4HeqOP2r1/JpR9dw443DvGX7/6H9CEmbSnnllkVCIcKQlJK9u+tYeHidDa/V0zRkQYO76/D5fKgN2hZujyLtlYrtdUdp11MfzrrLy7gW/93zawLggDNjd1cecMyHL0u+pweXvrPLl57fh8bLlvA/p1VAz/T4BAjRqOepvoubBYHYUN0H0spaW22kDBoJ3etVsOaSxcQkxjB33/xMkW7q8ZtNqkpyMDHvnIpD/34RTRaDRffsPy058eOYIf505FS8saL+0cVBCeNEBwp7yAtOQJzsBHnObaeUKvT8I/dPyYyLmxg8tHGW1az4aaVcJY7rMwkaveJWcbvl3z4QSm5cxKYk5+Ix+PjaGkzpUVNZOfGM2duEpdeuYgXn99Dd0nvqLYbEgKiY0IxBxnYsLGA625aMSuDIMC37n6UuMRwcuYkkpAcSUNtF0HBBp7+54cYjDqc/WnDeu0ueu0uYuLDuP8Xr5CWEYPN6mTdxfOYvyQDCHyQSRgm2KTlxPO139zGr7/yBId2jH4S01A++uVLWbg6h4d/8iJ/eu3r41Lm6fTYnHS0Ta8Nh09W12ghZ1Em1duOnvUWXJMlOTuOPoebzmbLwHNCCDILkrn6zgvInp9G6d5qImJCT5mBqzLMzA6zNhBqNGJgogxAU2M3MTGhhIWZ0Oo0rDovhw/eK+adN46MrlytICs7jo52OxGRwcyZm0TwabrTznUajaCxrovGQQu2Hb3uYc/vaLVxaG8Nm98qAiAzJ24gEA6nz+Gis9XK77/xFEWD1sKdjaSMGG749IXUlbewZO0cMofIOjTeGmo76XMGfjYajSA1M5aQcDMeKem0OAgJNiClJNhkxOf3oxECjZSg1SD8EqEV+L1+HD191FW3Ex0TisPhJn1OAo1tVkI1WhrGYaJLRW0XWfOSqSmaHtthncmlH13DZR87n8oj9TTXtJO/JJPUvASEEAMfUHNOmjcwa82MzzbjbtYGwpMlJUdy+VWLuPGWlfi8fg4frB1IcnxsRwqtVkNb66nJnjVagd8XeM7vk7Q2W7nptlWEhZmJjR17fs2Zzu32BpJUj2Kn9LUXzeO6W1exe1s5GTnxXLipcNhzfV4f9TUdxCeG88dv/wdr58jXusUkRrDovFyCw8w4evoQGkFMQji9PX0c2VXJ5394I0II4lOjufe3Hx1xuWcjLiEcKaFweQa1TRYqWy3Qahk43jqKjSU0QXqae/tASg6VBpJy+MODKFyWgd/nx+f109FqpbOtZ1R11Bu0pGbGIlpnxgSSaz69nktuW0NwmJkF5+Wx4Ly8qa6SMg2pQDhIW6uNoGADv/3Fq9x86yq2fVjOtTcu54N3i+lzetiwqYDKslaqq9pwDX5zl5CZHYdWK4iMCmH9RfNIz4zlsUc28/67Jay/aB6rz88lMipk6m5uCng9Pv785F386P/9m4qjLSN6TXhkEAWL0khIiSQ65njOXKfDRY+tD6/Xh9Gkp+RQPQ/+/k1amyxotIJf/ukT/OW7z5yx/NCIID765UuQfsnlt513SlYWd58Hrf74InWT2YDJPDmLqmPiwihYnc2uXZWB/vWzMPBZbVA53VYH3dbj449mk57CZRnUlrXSYzvzDNOU9Gh6TVpKOq1EhpsxnpeLw+Ul2+XBFGZGE2LC091Lc3kLdsvUj3MuWz+Pm+/ZROgsXK6kjI4KhAQmKfztL++xbUsZ8xemctc9F+N0utFqBR63l09/bgM2q5Py8hZKS5rQaE58k/L7JdWVbf3ftbJ7R+UJxw/sreF3v4TklCh+9ptbSEw+u0kVM0VQsJEP3y0e0Zt6VHQIH/vMhRQsDHRRvfPKQW76+JqBritzkJGXn9nDU3/fwk//eDv7d1VhMAT+fKVfotVr+f7Dn+L/7nyY6tKT0xIGhEYE8cdX7iXuND//4dKVTRabve+sg+BIOfs8HChtwmTUU7A0naK9x2eDhoabScuLx9MX+MAnpeRIcyf0BurWPWiyTIlOCw534AHMz4qjYl8N4dEhpCxOR/olCEFPYzf1w/xuJkLxniqsnT1ExZ+ao1UZxiztGlUjwYDN6mTF6hxCw0wsWZZJRlYsUkqkDOzOXVLcxJXXLWFeQTJR0cFj3gevsaGLuz/1CO+9XTQwSeRc5vf7eek/u6noz2k5FKNJz6IVmXzy8xex9uJ5RESH4OrzcM1HViKEoKPNxn0/eYlPXnMfD//hLRy9Lv7629fZ/sFRhEag0QrSs2I5sr+W2KRIvvrrW9AZhs7j6vP5sXbZJ+p2x8WVU5B1qM/l4WBpE+mFScxfmUn+ykyIDWZfdSuHmzs53NzJkZauEQfonshgIi6YS0tqNHs67Ozt6mVvp51yk445ly4gJikSrW7i33ocPX188MLeCb+OMvOpFiEQHhHE/IWp/PaBjw90ib39+mGWrcwiJTWKV17Yj6P3fK6+fhkxsaH837fO3AU3HLu9j59+/7+sWZvH939203jdwrTkdnv5yCfPp7ykmd1by6gsaz3lnPjEcJauzObw/lr+9chmmhu6yZuXROGiNM7fMI+CRWncePt5vNO/uazfLyk6GNiGrLO9h1/+5RMsWJqBpasXn9fHm0/vOiEFmEarwWDU4fdJHD197HqniNxpPDEiJSWaufOSKSlunNwLC0FlTQeFC1M5ePTsWm01nUN/2JAIDrRYIS6MwoRwKvfVnNV1RiJ/aeaEX+NcIaRaPnHO6+114ff7+XDzUerrOrn8ysUkpwQ20D2WHNzpcBESasLvl/T09HHxpfNZuTqH89YGMoUc3F/LD77z7LjUp7KiddolJR9vJpOB8zfMIysvgU98bj0fu+J3dLafODmj1+5iw2Xz+eX3nh/IplJW3ERZcRMNtZ386L6PYg4yEBsXRkPdqbuBfPdLT/Clb1/FRZcvxNnr4to713H+ZQupq2ghOTOWvAVpBIeZ6XO66Wyxkty/n5/f76e1yULiWaRBG29HixqIjAoiLzuO+up27M7J7zUQGkFBbiIlFc0Ttu9xQpiZzpLJCfRh/RmKFOV0zulA+OZrh6it7aC9zUZ1VTt5cxLY8kEpkVEhxMWH89RjzbhcXkqLG7FZnSQkRnD9R1ZwyeUL+fYPrjuhrKMlTfzyxy8OzA49Wy3NVg4frGfBCHcImMkSkyN57fm9xCdGnBIIL7lmMVLC139wHS89s5vnHt8+kNvV7fHS3NBFYkoUP/jdrdh7+mhu6OadVw+ye1sF6y+dz5f+90rM/QnUzcFGzMGxJGXEsmB1zgnXMZkNA0EQoPRII/d++u8sX5PLnfdcRPpZ7CJ/tqSUVB6uJzYhnIiYUA4/v4sQex/ZWfH0mQzUddpxjmLm7ViEhppISYvG0+elvccxYUEQoMXmZOmCNCzvFE3cRfpN1lZd54zpsQ3TpDsnA6HF0ss7bx7hbw++j9sdeAMRAkLDTMzJT6Kl0cKz/9pJy6AFthDYieKRv77H3ILkEzbaPbi/lv8+s5u21tMvdr7quqVYLQ5qq9tpauo+Y1q23//qVR54+E7MkzQrcaoU17Sy6arFPPP4thOe1+u1HNhVTXuzFbu9j8/dexkXXb5gYMD+aFETnR09OBxuXH0e5s5PIWdOIlqdBqNJT1JqFM//ayehYSYuuWbJwOSZkZg7P4X7/vE/HNpbQ0jY5OZ/7Wi2UFfWjJQSj8tLd7uN9DmJRMSE4nF5MZj0NFS00tViBQLdu1lZcXS1WNBoNaQvyaSorQe3d2yZjgaLiAgiMioYY4iRI2XDj+WOJ4NWM+HZWqLiw/nir25TyyWUETnnAqHP66ep0UJ5WQsez/FP0VIGkm7brX3Yh9laCaCrs5ev3fM4X/jqJcd3pkiPxt7Tx7d/cB3791Tz7ltF3HjrSizdDpoau1l1Xi4LFqURFRPC5+54mM6OkU3IqK/tZPN7JVxy+cKzu+lprNfpRkpJZ48D7eJY3LGCpOAgYqQevUZDWFYkkVFhnJ+XjNGkJzTMTNHBOuYUJFNyqJ6NVy7k3s/8nSP761iwNIOgIANoBHu2lpNfmMI1H1kxpt3EhRDkzk0id4wL5S02B60dPbR22Kiq78Ta48Tj8VGQl8iFK/Mwn2b2aenean7yPw+d8rxWp8Hvk6dkbPH7/DSUH19+UvRuEfmrcjlkObuk2mFhZrwGDRVN45+j9XRyYkIpfXt0iSpGY+n6eXzrr58ieJI/4JwTZukYoThdmqRly5bJPXv2TGJ1zt72rWW8/OJ+3G4vQUEG9u6uJi4+HJNBR/kI17LNX5hKbFwYy1ZksfGyBQA4HC6aGrrJyUugtcWK2+0lNS164DVSSr74mX9QWjK6iQZ6vZa7v7SJxcsySEyKPGVpxrngSFUzSEiIDuVr979AcfWpk2aMei1/+/atzEk73kV5bAxVSkl5SRNvv3KQ6NgwdDoNPp//hOUVgzldHl7fUcLS/FTCg02Eh5z9G6LfL2lqs/Lqe0d4b0cZdU1DLyg3GXX89Se3EWw2EB0ZjOGk7aO8Hh8/uvOv7Hpr7IHAHGzEkRGPZ4y5b4/Jyo6jvPHUcdfJEBdmIgVByebScSvzus9uIHNeCkvXzyUq7txcMiGE2CulXDYRZZtSUmXKF746EUWfovKbX52w+xiLc65FuHpNHstXZrPlg6O8/eZh8uYk0tXeQ1l1B4PfMnU6DR6vn6HCzuGD9WTnxiM0ggsumofBoCMoyEhOXmBXhLj4sBMX1BNYgmGxjH4Xb4/Hx32/fg2AsHAzF140j89+/uJTNnqdyQqzEnG6PLR02rhpwyLu/88WumwnLriOCgvmpS1HkOcXEBpkIjk2fCDIPfTCduZmJHD3149vgTR4olFVYyddtl6iwoIHguR/3jnAW7vKuHBJDjdftGjMda+q6+CXD75FUVkz/hF05/W5vDz2/E6+8/nL0OuPL+Pw+yWHiup56U9vU1/VRlxaNF63F4/Li8ftxev2jng8Kzw2DIvXd/YTrfRTt3qqzdZHYkI4pmAjfWNI4H3Z7efzqe8GxvHLDtTy7J/f5tavXK4Wz58lNWt0hujuslNb08HhQ/X4/ZLgYCORkcEULkylurKNsDAzO7ZX8NQT2/D7JVFRwcTFhZ0Q8KKig3H7/OSnx3Ckfyr+YBqtwOlwUzg/9ZRxp95eF9++9ylWrM7hto+vGXg+PCKIPz50J3fc+mecTjfeMYzf2KxOXnxuL53tPXz3RzdMylqryeLz+3n4xR00dVhPCYIAzZ02/vPuQV7fUYq1t4/c1FhWF2aw5UAl114wn7WLTtyXUAiB3y/ZVVzLntJ6Xt1WjNmop7HDxg0XLkCj0bAoN4kQswFHn5sg08jHYbutDto6e6hv7ub+f35AR/fo1h6+vfUoe4/Uk5Uag06rwWJz0NxuCyyWB0gKHfJ1AolBq8Wg0aDXatBrBHqNBp0Q6DQCrRDoAC2CCOnDHGwiTKOj7mjrQDrAMzGbDYSEmoiNC0Oj06ARTOjEmNM52GJl6Zo8it88POrXZhemDHR9Ll6Xz+J1+eNdPWUWmXGBsKnRQnFxI4/9Y8vAwnaNVhAZGTwwNmc2GwaOdXX1YuvpIyktiujokMAu6Q4XVZVtHD5cT86ceCrLWomMDCY0zEx9bQef++JGrh1iyx2/X/LD7zxLcmoUV1675JTj4RFBPPjop/nzH95m3fq57N5RwRuvHhr1PW7dUsbd//M3vvnda8jMnrrZjGfD5/OfkLk/xGzkJ3ddwZNv7qWpwzZkMPRLibU3ECzK69tp7rCxdlEWaxYcD4JFVS28sbMUm6OPhlYLBytO7Yp++p0DJMWEERUWRGVjJ71ONxcvzyMy7NTWgr3XxeGyJorKmqhp6KKqvoPaxrMfM+u2OthrrRvVayQCl8+Py+cHzwhe0J8uzRSpJycnlopDwy9JmFuQjE6vpbvHSW1jF+GxIZinQT6N/e02Ci5dgNbioO5IA0778OP3x2TkJ7H6snN3XH1KqRbh9Od2eenqsuNxe4mMDMbW48Tj9uH3yRMmqDhPWn/l9fhobOiiseHUN7iK8laMJj15cxNZd+FcFi/NGEiyfTIpJT//7a2n7ZKKiQ3juz+6nv17a9i9s3LY886koa6L6NihWw4zwVDb10gpCTEbR5yZJzLUTGxEML976n2W5aeiEfDgCzvo7Ttz66epw8YvHn8XgLULs+iw9qLTatiwKIfqhk4276rgUGkj7dM808xI9Lm9mMJNREQEERZuxmDQoTfoOFoS2FLMFGSgy+akrvL43//RylPHaaeCX8Lh/tmx+eflUjuC1qHH7eX7t/+ZO797HfNX5QQyDGmmPqgrM9eMCoQGo461F+STkRlLfEIEB/fX8tYbo+9WOZnL5WHvnmquuWHZsEEQRrc32eN/30LXKHZDOEav1+Lx+NDptXz3//2bH/3iZsLCp/+4h9vjxevz43B5EIDZqMOo1+H1S4x6HQ+9uJ2XthSRnxFHUmwYQSY9sREhQ7bojqlvs/Doa4HJWlsPjX17pbK6dvLT41g+N42ymjYKchP502Obz4kgeEyrxU5Hn4vOvkHjbXpBae0otqyYYnohmHdBPmg0dNd20FzVNuR5jf3Pf++jD2A0GzAY9Xzhl7ey6pIFk1ndc4/KLDNz2Hv62L2zkr89+N4pE1bOhsfj4923iphXkHLW+we6Xd5RrWk7JrDW0YxGIwgNMxMTG8a2LWVccsXCaZeBxu+XtFnsRASb8Pj8/PX5bew9Wo9Oq6G7x0m3zcH5CzP50s0X0NZt51B5E82dNpo7j6/FbO22Mzc9njaLnU7r6D80jFRrdw8PvbiDh17cwcr0FN7eehRH30j6HmeO+hYLyQnhtPW3roBJS949Xg63Dqp7qIkFy7Mo31017PkeV2CyEcCP7nyQL/zyVi796Jphz1eU4cyoQCil5I3XDvGvJ7ah6285jTUB9lC2fFDK7Z9ce8ZA2NjQRY/NSf685CGPd3baqR8iHdiZSAld/XkaO9p7qK5sw2Z1MGdu0qSPFXo8PprbrOh0GjRC4PX5B5YQBJsNNLVasdgcZKXF0Ol08t/Nh3CdNOvxYEUz+8sa+dUT7xI0xLo6n89PSW0rmkl8w3ZJH/v3nzpB6lwQkRhKa4t1yJnQM44QVGsFczfNp2QE3aV+n5/d7xxh2YaCQIahEKPqLh2LWdoinJHrCHt7XWz5oBSbzcGrLx0gOiaUILOB4qJGrNax74OWmRXHL35zK1HRw+8b2NZi5dc/f5n9e2q47qblrFqTy85tFURGBtPc1E1tTQdpGTHs2l5BeHgQ1VVtZ51EIyExgocf/wzGMSwcHy2/X9LQ3E1YqAmzyUBVXTvPvLqfPYdq6ew+tdVmNunZcP4cgiOD+Pe7+3F7p3dKK71WQ3Cf5pxrER6Tnxg9ZHLzmWhufBiGbgdlu0Y/1l64KocfPXkPpqBzK2vThK4jTE6VaXdPzjrC8u+odYRnLTjYyPIVWQQFG7nx5lU89eQ2OjvsVFW1YbWe+fXDqa5q4603D/ORW1cPe05cQjjf+t41PPvvXbz+ykGe/8/uU84pOtwAMOIMM2fS2+uiva2HlNSJTRDt9fn54z/e455PXIhOp+VQaSNf/sF/BtLUDcXZ5+GVt4+wYEHKtA+CADGhwXRaTp8qbybr5ezTrk2mCLMBc2UrLoeLjCWZuMwGfEjMdhcV7xaPOVfokR0VPP/gO1x1xwWEzIAxdmVqzchACAzsXv7h5lIeefD9cSv3TMGrx+bkjVcPcXB/LckpkdisjglNm7h0RRbf+cF1aLSCv/7xbaxWJ9ExIeh0GlJTo1m6IovwcVpE7PV4iY4I4f0d5bz67hF2HawZ8Ws9E5w7cjzMTY6js+ncDYIA9c3dhJr19DlnRos3JsRIq6UXr9s3bllmEtJjuOjGFeQvycQcYhqXMmeN6f/feELM2EAI0NTYzTNP7wJAb9ASHRVCS8vYm4QREUHc/snzT3vO4YN1ZGbHccvHzqOpsZsvfvYfWC1j7449k727qvjpD/6LViPYsa3ilOMGg45Lr1zIp+++CNNZ7q6+bV81f31yy6hfl5MZx4G6yUnYfDasjj5SkyOx2M4uR+d0ZzTOnEBY0d5D5LIsgo82Yx1mH8PRSs2JZ9G6fApX5pz5ZEVhhgZCp9PNgX01bN9WjtGgIyMzlsioYJBgsTrG/CZwyWULCQ09fV7KY3sTQmDrmrHMDh2t3TuGHyNxu728+Nxe8vITzzp599bdoxuLSU2OJDQqCIdnZrzpNnXbaOq2kZsbS5/FRWv7udM6jI4IJiUuHG+fl6NFTTNqwozHJwkLMsI4BcLd7xSRPidRBcIxUMsnZhCnw03Z0WbefauIvv5JDzXVZ7deKjUtmquvXzqq1wQFG0/ZKWCqnG4cbyScfW52Hhj9Wj1tf6qzmaSxy0q0OLslMtPJwrwkSvbXU1wf6A2ZSUEQwO7ykBETSlv96WdaH/srO9P9rbliMTfds2lc6qbMDjMmEPr9krffPIzP6yc4xMQ7g4LgWGi0guioELRaDR0dPVy0sYD4+JFnrG9rtfH3B9+n46SNZqdCckoUl5xFyikpJfc98t6ouwzrG7upb+xmwYKUMV97KjhcbuamxtDaMfW/u7MVGxVCW103fr+ccQFwMMNJiSxiFibjW5dKmEsiuvsgzEil1k1SdDj3rlpKfEoUXa02fn7X32gZtFTJHGLC5XARFjX8zG9FOdmMCYT799XQ1+fB7faye3cVvfbRZ6xfsCiNDRcVEBJqIjTURHJKFAmJEbjd3jNuf+T3S3psTp5+cgdVFa3s21M9LVpCJpOea29aNubdKvpcHn75lzd5c3PJqF+blBBBaEwQe2obmVHtECFo7u1FiAnfH3bCHcuOk5Efh8EL1RVDZ2OZbhIyozBHGBGANtKI3SfJzVpD2xtH0YcaYV0aRe0dgZO1QG9gHD44yEhoVjSxsZHEJkfxy/9+lY8v+TYA0QnhXHb7Wm750iVTc1PKjDVjAuGcOQns31vN00/twO8LvHuZTjM7zmw2kJIaRXlZC0uXZXLhhnksX5VNTMyp+TtPN87ndnt55YX9PP6PLTh6XWPaVWIimM0GLr6kkKuuWzrmxfbd1l7uvPexUaUai4oIptvaS2iwiZAQIzUd3czEtkh0iJkOeRZrbaaZmsYuFueeuMmwwaQnOikUIQRagxZTmAGCdQi3v3/LicBej16nl4bSdjx945ep6XQyFyVSp3fS0dPfkhvcEbEiMvDvsSA4SHpsJNevmk96bOTAczGJEXzkS5dQuqeanzz9xVGlQVSGMMM/GI7VjAmEQcEmNl4yH41GQ0+Pk+KiRhy9LpxGN5aTZm1qtIKIyCC+9NVLkcDcYTLAjITBoGPBojSCggwYDDq0Wg05eQlYunsH1gueSWxcGJ0dPePSgoyJDWXleTlk58azcHE6aekxoy7D5fKwZU8lXd29o3rjmDc/mYN1zQTFmejoc9HePnPyWJ5M6515wft0tFoN7U3HA7vepCN8ZQzFrf3BRgLW/sdQMjSYDUFkx0RhEFr0TonQCToqu+lsHL9JRWkF8ezr64QzbzJxil/fcQV5SbEnPCeE4JPfugaX062CoDJmMyYQajSC9IxYLtpYQPnRFpavzGLze6UUHWnAZnOSkhpNdHQI+fOSWLEym8IFqeOWnzMrJ47PfXEjCMHcgmQiI4OxWhz8+4nt9DndRMeE8o+HPzjhNYlJEcQnhBOfEM67bxWNSxDU6TRIKUlIjOCqa0c3seeYqrp23tteRo+9j9joUDLTYmgZ4ezJ2sp24mJCaLHamVFdoUOosgy9w/xMZTToiJgXiX5eGEFSS4mlk7LW0aX5c7q9HGk6sWs1NSOcObkZ+LSS3poewpJD8fS4kVF6PA0OENBc0UXK3Di0cUY6DrRj6xx6OZEEbFHAGD8/Pb/jCN+4fv2Qx4zmcyuDzJRQSbdnjvSMWNIzYiktaeKLX70UnVZLR2cPSUmRZ37xGAkhTlg2AYG9Bz/z+YsGvs8vSOKl5/Zit7tYtz6flefl8uf73uStNw4PdOWejaBgI/MKklmxKpvMnDiaG7vp7nYQFGQgIyv2zAUAbV09VNS043B6sPe68Pn8rF+Vh/RLbG43Oo3ALyUaoaGktAnPSVk9eh1u0s3R/YFwZrM5+ohPCSXIq6WxxTLV1TlrDqcbn19yuGV806vVd1qp729GJsWFUtzWv160f1g42Ggge10yB5paoRGWLkokqs2FJ1aHUWhxSz89bhcJWjNHP6glTmNiLPuIhAeZWJo9syZlKTPHjAuEx+TPPT4eMpFB8GR+vxyYWNNQ30Vri4WuDjt6g45rb1pORmYslm4HD//5XbZuKRu36zp6XezZVcWeXSdm4//KNy4/bSBs7ezh1Q+LefGDI3RY7MxPiccr/UivxOf1UVrfTnlzJ07XiWOtGSmRxISYkQiqq9ro6XURZDbQ7j5HFqMLQavVzrKM5HMiEALYu/oIMRmwj2C/xrFo6j51lm2vy82hpuPBd29jf6A8aXeteo2NhRelY/GObaa3yaBj/fzsMb1WGQXVIlRGyu3yIjSCH3z7GWqqpmacbM26OSxaks756463VP1SYnX2Ud7eSYu1h11bq3h7+9ETZkburR5+/7/Balq7qWk93n24tCAFKeBox6mTGGaSmPBgevvcA4F/siaITIb66k5iYkNwmrz4/NNjUtcxPr+ffY1jzz60ODOZhk7rCRNlFGW8qEA4ShqN4Fc/fYkt75fi853dm41er8Vk0tPn8oDklK7Ik0VGBbNhYwGxcWHc8JGVA89XdnTxh/e3sbWqjh7X8WUlq8MTx2V5QF5yDFU17WRlxdLjnJjWxmQwGXQkJIZzpKmVxNAwooPMoNcQnBOKod1H91nsXDJddLTbWbwwiUqnle7ec6T1Dry+/yhBRj3/d8vGqa7KuU21CJWRKC1u5NCB2tMGwYTEcNIyYjAYdBzcV0tPT2CKnBCQk5dAckoUJpMeg0mH2+UlOSWKtRfm897bgY2BQ0JNJCSGY7e7KC1qpLXVyqVXLCRymEXCzx44wusl5ac8f7ivk/krk0GC3wg1u1txjaEF5PH6yMqMxRCkx6jX4fLMjFaUQaclIykKo1FHj89DXaeF/fWBVkmr10GrzTGwh2JcbDBZ6QkECx3WTgfNrdYzfjCZrnw+PzbnGKZlTnO5SaOfIa0oI6EC4QjV13WydfNR/vnwB8OuJVx9fi6337GW3DmJA885HW52bq8gOSWS1hYrIaEmFi3JQEqJpbuX998pYc3aPOISwvnYJ9eeUF5YeBBJyWfuCvIO0w1md7nZ7jreFboiP4GakjbcrtG9wVe3dlNNoJt0YX4y+ysbR/X6yWbQaZmXm4DN7aaoZeiu3JM3EW6z99JmP77fYmpWGF6/n8TgEI4eGFl38nRRUdRKzNxQWs+BSU3H6LQa1hVkTXU1zmkCNWtUOY2WZgs/+/5/KS9rQavVoNVqyMtPJCzczM5BO0JcsGHeCUEQwBxk4MKL5gGccEwIQWRUCNfdtPys62dzjizLzi5HC7pMDUtjkmk+3Emf043bPbru3cNljSzJT2Zf+fQJhvFRISTEhuPXSKSEA/VN7K47u+BVb7WREhaKtfF4MElOjCAqNoT2ZtuIl5xMpoioIBLSIvGa4ED99N8NZDihJiOr5qRh0GupaesmISKUT29aSUr0yFMgKspoqEA4DLfLy8EDtdRUtvPko1vRG7RccfVi7v7SJvQGLUIEsnJ0ddp5980itDoNF20qnPR6urxe7K6Rj9t5/X72d7bijg+0iFbHplCy9XhigEC+keHNyYints0ytsqOs8LsRLRaDYfbWmlo6B10ZHzWODbYejAZtMzPT6S4tBmdTkNdXw8tWjuFCxIwaLTofILDI0ysMFEkMGd+Io2+Xva0z9wAeMznLlvFbesWj9s6YEU5ExUIh7FzewV2ex/RsaEYjDp+8quPkJOXcMI5QgiiY0K56bZVU1LHFlsPP33jfd46euo+hafj9h3vFnSK41+nZEURlGymbMvwrb1uZx+d1t5hj0+mkupW8nLiJnQsr8/n47C9g5wF8RxpbQNP4M35UFsbRq2GxbEJaIQgOjJ4VKnqxktQsIGEwmj2NYzv+sGp9MvnP8Drl3xi/diSRihnQXWNzm4ejw+NRgykaVp7Yf7AsfPW5p31prdnS0pJeXsnR1s7qGjv5FBTC3vrG3F5zy4IVNssxKyKxqjVUtbVxUJOvx9jmMlIX1gQXbapn2Hp8/spKWthbnocRR0Tt4ylz+vjSFt7YLbTIC6fnx0tTQSl6Klx95I1L5pogwmv3UtZxcQHpvjkcGxhfg6dQ0HwmPte2sKli+cQH6F2kVAmngqE/fR67bDHxisIurxeLM4+yto6yIuNoa7bggRWpJ8+Y8bjuw/wzP4jlLSO/5u9ta8Pa9/xGYbF3e0kro4mus9AQ0UnvT0ndruWVbeh02nIT4+jtG567HRgDpraDykOjxeEoKqrmyogIzKC5MQIGpstE3bN9JwY6unFZhv9Liwzgc8vuf33/+Lnt1/GEpVRZnKoFGvKRPH6/TjdHkJNRow6HfGhIdz97xc50hz4FH9lYf5pA+GBhmZ+9Pp7k1Vdet0eKjq7qAAS8kLIckag02twWF3U13QTEmYkPT6SIzUtk1anMymtaCUzKZLqjumRP7TJbsNk1pOSHkVDbRcx8aHE5ETQUtKJpevsW9KpmdGUuS14znId63TXarHzxYdf5KVv30FkyOl7KhTlbKhAOMGaLDbCzSY8Ph96baDVefOSQspe78Dt8/Fa0VHmJcTi8fnJjokixGggzGQkNy4GAXTYe1mZkUpJSxu2vsn99N/SY6cFO3gBAyQvC6fJZqPXbGXuqhRKdkztJJFjXB4vPruXnLgoWqz2UU0eGm/5GXHU2210OvpwB0PBmlSq7BYqmhtJz4ogLyOCsn1NSCAtO5rgODMgcHb10VzbRebSRHqlF6NGiwR0DklzRRc9tuOtdpvViSZ0dkwk8fr8tFntKhBOllnaIhTyNKlHli1bJvfs2TOJ1Tl3eb0+Xnv5AOevm0NkVAgPbdvNr9/5cNjzgw0GXF7vsGsEp4PVMcn8//buOz6yszz0+O8950xv6l0raXtf79redTe2Ma5gSDAt4IC5FFNyA0m4hBJyEyCElHsJKYQaAiSEGzoYjME27vbu2l7vrtfbm8qqazR9zsx57x+j1UqrrlVb6fl+PvpYmnPmnHdk7TzzvOV5U9EM/b0pujrjBEMekonsvG5YHPJ7KK0KcXiKOy9cKL/XRaQ8wKnuvnHPW1leQpn24rgVz7YOn5Q0VrGCqnCQqrSH4y93oijsQpJv9BCb5LKZi92WxmruvmozN1+yGu84e4cuBUqp3Vrry2bj2r7qet1074dn49IjHPjsh2ftdUzH0v6rmkOWZQ7bOmlHYz2KsT+AJbILv5TZU12FN3J/sYuimjBdiSSrSsoJ5V3gaHo6ErS1ROd0w6ZYMkP2dJ5LllXy4pl2JvoYUV4UIJHKkrHz067PWRzy0lBbys5TE6+tPNJZ6HYezVgVe870FzLzwDovGyvKMTOg0ew8fXEt9J+uPSfa2HOija88+Cx/9NrruF4W1s+eJZoRSiCcQad7oyQyWZr7olzRVE/Q4xnz3LKAf9H8zSVtm6RdKGK9f8hmvW6fSX1lkM72uV1WkLFz7D96hrDXzfL6Mo709IzZrRxZ76WXBDEnw0ajimDUSy6T56Ujo08EUgrWL68ilkiTyeaoLA3RlkhMKgheqHQ2S0dfnNNdY+2uu7id7OzlI9/8ORvqK6kvKyLgcfMnr7te1huKCyaBcBocrXn5TCed8QQne/soC/jpS6X52988TiKbRQGrykv54t2vprG0mFg6Q1ciSWUoyM5TzaytLCfi83L18mU8cezUfL+cWbG8pBhO2XR2jty6Z64k0ln2Hm5l2456kvkcew8UJvgoBSGfh8hWDy877SSxQcELuhXChec2VZZQ5gQAeF63cImqxdNroTDYPaRqTXPL3AX5TTXV7Dt28S+YvxDpbI7nj7WyqaGau7avlyA4w2TWqBiTozUp28bvcvHJn/+a+/cfGrfrUgOHOru59z9+wOs2r+fbO1+gP52hNFAY8E9mc2Tzeez8xVnUeSKmUuSOpujrm9/dDzZtq8bxwlF/N630s+rqcvx5F4eNTpSC/c7Y6++OOz0cp6fwg4JdnKaqNER8z8z+Pwt53axaVk7e0Ci7sMGu3+vCsAyONXfTlyxMktlYU8n+4/MXBAMeN4l5nIQ01K3b1nDT5pU0VZbMd1PEIiGBcBIU4LEs7HyeRCbLbetXk8hmefjQMdK5sXdiaOnr5x8ffXrw5874/C9CnwtryspoPjZ/awyVgtrKIo6W9Azurg6w12nj7MBsj556kG7SZbzgzOyykbqGYp7sPW/27UCS2VRVRG0ugsdrgaHZ0FTFvmOzv2wl7POwvLFssFJdh5PkaKIXv+Vii6+C1tYoHX3zV9C7IhJkc2P1xCeKqZOMUIxFKYWlFBgGn3/trTz48hEOtneNGwSXKsswUB3z83upLg8TXufjOVcLe9TMB4ynnOOsraiedq3VrWtqcWyHtu4YdZURWuwYz/eO3c7j8T6OAwysnAhZbtZtrOLk4W6Sment9D6eLVtqiLuzdLoTJLw2R0/10j9kt/tYLsvjsWZKS32sr6vG7rWJJtL0xpJztqZxc0M1G5dVzsm9xNIhgXCKTnT3cqSzm//cvWe+m7Iglfh9nN7XMy/3LlsW4BHX8ZmquT2SglR9mi3Bajp7E7T2jr0DRcTvZfmyEtI6j4OmL5vmqbOZnwdO9U197DSWy7Iz2kZxrZfVvkoy3VnMeoNQ2kN/VwrLMunuSxJNpCc9A9ZtmRQFfVTXhHmUE2ADNpxORFlTU06+WZPIDg+63dkU3dkUEY+HlGmjw5rGeIh4KjtrSzq8bou/vud2rlnXhDVQBlHMMI1khGJyVlWUsaqijGw+z6mePrbUVfOLlw5xsqdvzhe8L0TVgSDH9chuM7dlkr3AuqgT2bu7jeuvauK3/uOzdo8Sd5Bn4q14PSbbVtXy8qmOEdmZx2WxrKKIp7pbZjwoazRJbUOl5kWrvRC4TGAgSXKXmuRwWG2VkiFHWy7Oduo4fKCTZMZmbWMFmfIcSXLEdYY2O0anSnGYkR9eDkY72dGwjF2HRx+bjNrn/t5PhxI4QU1TMkLLLMxq1Vpz1doGCYJiVkggnKY/vuncJrrvvPIyHK15vrmV/W0d/HTvyxxo78TvsuhPZ5bUhyzveX9SlmlQURbC2aRxa5PgGQ9KQTaZ49jJHvIX0KVmKMWGS6vI9OZQhqK3J4nT6xDxe4kyMzu0Gygu9zWSz4OywE4X2pt28jwZbcZfYlHpDWM7DkpBZzpBNG+zK9E2o0HQNBSbV1ZwPNGD7eTZ2dM86vWzFD5svJw7tyHxo5ygYVMR9RTxfK6N7NDdOiZo44v9bYS97mFdpKNJO4Vr+mepOP2amopZua4YTmaNigtiKMWl9bVcWl/LDauWk3cc2mNxnj3ZzAvNbTx+7OR8N3HWrKgoIZpME0tnyJTarLixjKiZwq/d7DPO4MdNC1Fs5cCQsqplK/1cmq6nT6XwZ1yc3NtLfyLNyqYyzHoTd8ag+0SS1vZChrF6ZTm5ek23maRZFx57RB2HosL1Ni2rInM0R0xnZiwIOWieSR1ni2rgxZMjZ5km8zlOJs7LgNTM9jCVBf2Eyy12dU+/pN3JXB8n6Zvy81I5m0i5h+pYkLYJJshUegIcOzY7FX2Onunmvi/9kKvXNnKys5cr1jSQdxwCHjeNFcUyg1RcEAmEMyznOOxva+fmtStpLC1mR2M9//jo0zx94jSV4SBoaIkuvN3Np6vI70VX2MTsfjSwK3cCzksKTjB6MewulaS1Osq+7nZwKTZcUUnkgJd8o+YZ8yS4oWSTl/qNRXSrJE/p0+cC3CiBbq86Aytn8tUBGtY5dbzYMT9bHWk0jTVhnuk+PS/3BziTjLO8uIRQ2k1snMywPZOgdmWQspiXZMamrWfm/s4TmSy7jjSz60jhw8CPntk/eMwyDX78sbfjtkwqIrJtk5g66XCfYZZhcOv61ZjGuV/tfdds57EPvZstNVWc6Y9RGvDPYwtnjqEUK2qLOZbtJKGzJPXU15kFLA9no9p+2nlh3Rl2meeqtPSQZo86QzP9szcJZhwew6InOX/rITfVV8xrEDzrWH8P7jIIuMfv+mxJxXnR7CIS9E75HsvKi6bVtlze4Y6//Do/3fnStJ4vhtBz9LXASCCcA6ZhYOfyfOjGq1lbVU534uJfT9hQGmH9+hKeUUfJTVjRc2wHox1cWlFDtS8EClymQWOoaNg5XlNxXa2fVzUEePXyAK9qCHDvJoN7NxmoWfxX5TfcbPLVouYjAgP1pWEOZhbGno8AHakE/kqDzQ3jj9dpKKx9nKJoIs3K6tJptg7++4m99CXmt4iDuDhJIJwjleEgR7t6ONTeNfHJF4G2sm5esC88U4naaZ7rbsFWOS6vrKMuFKYhAvdscHFtjR+fZfDWjVki4Wfw+J8Gz9N4/E/TmdtDzDnMLY2z0xW2pbSaS0pqONOboD0+94vHA24XnohBOr+w1qqeScZpyfdhGuN8OFCwO3OG9RuraagsnvCalmHgc7uIpTLUlxZNu22tvf289rPfpD85MxOlliKl5+ZroZExwjnSk0hyw6rlfPOe13Pfd39M9CJdalFfEiFcY7InM/qsxenqziTJ5NP4LIOGiEmv8xxFEXhlBNrH6HFNO0k8vme5Z8NWupMuTsccTkSz9Ns5JtM4UykaQsX4LTeKQik9n8tFJp+jK5PgxWQbl1bX09ITm9T1ZorHMlnfUMbTPQuzDm1HKsGO5cvYdWTskm9pJ8+z0VZ2lNfAKMOrhlLUlUZI2zmuWLOM3niKnliSbStqefbwaZLZLB7LwjSMKZV2u3xVHWH/1LtlxdImgXCOlAyMC15aX8unbruJv33oMVqj81eQejq8lkWiKs7xbIxqV4ScztOZi08YI6p8Ls6khq+1WxXxUBeyeLg5MfjYG9faJJ0zWEYEJvne5+DQ6+zG8EKDFxrKwWv4CFrlAGQyjRztCZLTmjPJGP3ZNDE7Q1OoGK/l4uXo2F2PIZcH02tz3bpaXj4dpSOeGPPcmbSpqWLBBsFB5/UlRVweNvnK6dZpYrkMzakYPsMkqXMj6pS++vJ1fPiu6ygJFv5N5B2Hxw+cIJd36E+mufvqTTRUlPC9x/dwoHlqXcMP7T3KX37v17z+yk2sq5cKNFO2ALO1uSCBcB7csXENt29YzZPHTvHTfS9zoqeX55sX/q4C2XyeGhUk0BnkdG9hn8Hq9RHacqMvoPZZBnc2evF4jvPt/cPflOpCFqXBvdxQu5kyn0PIk+JAd4iS0AFiY8wynay0kyKdOU0sfgOPtnaiz7temc/PicTY93Apg42llWgjw/7+k6A0gVovV+YbeOrI7MwedZkGOcehtjjMgfj8zFCdikxqeHGEVf4SXtjXQnVJiGhvnA0VJcSTGYKWiRMJkOgoBEK/x8Vbr982GAShsG3W5SvrONLWTXNXH//+8HM442wYPp5c3uG/n9zLgeYOvv2Hb0IpJTtUiAlJIJxHVeEg77r6Mv7m14/Nd1MmZXNjJZateCFaeKPWQMjw0sbogbDca5ExdpHNKd62dhm/PJGnM22zMuylPnKKHjtJIPA0KSBlw7LiIuIzNSSmNGXBFlZFKjkUHR70ujNjT1a6vLKSo4lWDqUGqtMMvIcmdJo96iBXrl7DibYEbbGpjRsaCq7bUkzWBstU5HKaeMLAMl3k85o+leRkvJc21Uc2u7B3JSnx+HjxdPuwSUTHU314XBZtPYVejpPthd95d+zc79pQis++9TbW1g2fbOP3uElnc1QXh6jfvoENy6r4+q938vShk1QXh6mIBDEMxYqqUp49dJqOaJy3vmIrtSURfr77APtOtg/LOD94x9Vct6GJQ61drKktn81fxeKyQGd0zgUJhPNEKcWykiK+9tRu3nnVZTx8ePbKgs2UF46PLBDdfyLP6sYKDmU7cCl4RV2AE/05Qm6DjRXN9NgOaOjVu7mqweJI51Z21HTTkR2ZAcdzfTPaXo0iMcXC6KayyOjRC1orBS9yEF+Nh82xZURTWU72jl1OzO+2uHRtCENBzN3NS+mDhS5FDZgQLvHjxMs5PGRdaV4v7CAIUOULER2SZdf5QjQaEV6wx96cOOTz8Lm33cY165tGPe51W3jdhYlPl62s47KVddi5PIahiKUyxNNZ6kojaK050xejuriwceRdOzYAcOB0O//8y6cwlUF/Ms3yylIpxyYmTQLhPHKZJteuaORrT+2a76ZM203bUxjh41yhTPrsDhzyrClsu0jPefEkr3NcVt2Cxj2rbfKbAWzHxlFHWVvURFsyPmFXm890sbG0gpQz8fT7lM5wNHgYHYArKlcRj0LKzpHPazriCTbVl9LibmFNWYC90YOFwDfKRMb+XBK8J7lpdROPHoliOxfHx/H2dJzCi1L4TYvaXJAXjg0PghG/l1TWZl1dBVetbeTWratpnGL1F5dlAlAU8FE0sJenUmowCA61rr6SL77rtQD8yb/9jN54knJZXD8linlZqjsqpdStwBcoVNL9qtb6c+cdVwPHbweSwNu11s8ppbzAo4CHQnz7b631pya6nwTCedZYWsTWumqePXn6otyvsC/qwheMkZ5EAAHotlsnPmmaFIo1oU3cXn039f7ltKROUOGp4a9e/BbfOtg5eF6VL0ROO3Slz01+WVcW4aX40andT8Fe5zCEhjxYBvtUJziQzAUmdZ2X4se5fsVKfn14dsqTzYaw10N/KsvKTIT9bSN7Cq5Z38jKqjJuu3QNlZEQxnjLLWbY53//jgWzibCYOqWUCfwTcDPQDOxUSv1Eaz20YsJtwKqBrx3Avwz8NwPcqLWOK6VcwONKqV9orZ9mHBII51nA7SaRtbnv2it46tgpHjx4ZL6bNCUP7M7yO4FLMCM7yeu5X/O2OriJDeGtoDSbiy6nxH1uTEhRzKdf+DXPdcL2ilrOzpnoz0fJOHmWh2sxDDgzgx9Ahs7LOB7rZV1RPQf6J15vmSaJoeBiSAp70kleWbaSTHeOwyc7hx2LBLx4XBaHW7t41807Rs3eZptSiqDXM+f3XRQWxt/fduCI1voYgFLqu8BdwNBAeBfw71prDTytlCpSSlVrrdsY3Noa18DXhK9KAuECsLf1DL8+eJS7t248u4H6ReWnT+R5zZ0+Evm5XQ7iM/3cUfMGGvwrRp0ZWOEJ8WzvQdrsaGG7IuDtK64mlSvl+6d20Z7pGzy3cxJzX8IuL/325Bdrx+w0aIsGfwUtqW5y44z/HU20smNFJYYd5qlTXQs6IGrgt6nj7DDq8LldBLxuqmvCJIJZXrDP4KBpsop4ZN9RKYYtxlKmlBo6JvRlrfWXB76vBYZ+emymkO0NNdo5tUDbQEa5m0Ll4X/SWj8zUWMkEC4A+9oKszAfOXyc5WUlHO2an41tp+rVV7oI+HPYwZfnPAgCpPJJHut8gMbG94963G1aXFrSyM9aCpsoV3jDXFrSQJ+dwmu6eKHnJHv6Ru7ocElpOXmd52g0js90URGwMJVBLJeg1O+lwl0GKDJ5jctQHIp20RQqRVHYreFMKkYslyKvIWHbRDwBHBxOJ8evKnQi2Q60s6LeyzJ3Pb85snCrEGXJ85j3JCwHtzI5Qu/ghw2ALpLcffWW+WugmJY5rPrSpbW+bKxmjPLY+S0b8xytdR64RClVBPxQKbVRa71vvMZIIJxniWyWM/2FdKQznqA8GMBQatrrqOZSJquwS5+BeZzouKv3cUxl8eZl7x41K/xfG2/jaLyDM6koH914O6XeELbO47Vc/OmmO/i9x79CXp+rleo1XZxItuDgUB6I4DdMWtLD1/V1Z/uG/axNOJY6N4vSsAw2hmvY092F33JxOtlBnz35xfjxXBrtUig0esFMXxiDKgTFOxvXErezPNJyDICKQJCgd3YnRYlFqxmoH/JzHXD+5IIJz9Fa9ymlHgFuBSQQLmStff3UREKDVWZeOrNwiixP5Fe7M2xcdjWXXtJNu/PyvLRhW9GVbCu+csxF0xG3n89u/V3aU/1cVbGSx9oPkc7nuKt+KyfjXcOCIIDXOLe7Qq8dndTS/vNv7eBwLNHMmuJyuux2Yvk4y/wVnJogIxzKMDR14SCn+88PoIXZmgtNU7iYumCESn+QMl+AK6rqJ36SWHgWxufvncAqpVQT0AK8CXjLeef8BPjAwPjhDiCqtW5TSpUD9kAQ9AGvBP56ohtKIJxnYZ+Xy5bV8pO98xNILozidHeeTUYfF7ABxQVpCq5mbXjzuOesCFWwIlRYxB20PGScHLW+IqLZJJuKatnbd27qf5+dpNwoZVkowOHEiWm3SyloSxcmkmyMNLGnd2obM+9PHKaoOMC1lUW4lZuHDvVyw4oKWuxmal11PNcSpW+CXePnyrbyGm5vXEtjuJg3rpbuUHFhtNY5pdQHgAcoLJ/4utZ6v1LqvQPHvwTcT2HpxBEKyyfeMfD0auCbA+OEBvA9rfXPJrqnBMJ5drSz+yINggU3bDXozY2cPj+aMk8VWjt0Z2cu6+1IT6003dbSBrozcZRS1PlLuKVmIytCFfzo9POD53RmYthOnvpQFadTk3ttYwlZPg5Ex15oPp4+OzHYpbpjZQUHkodY5q/gmZO9pKZYKGA2FXt8FHt8+Kzx9yoUYrK01vdTCHZDH/vSkO81MGJygNb6RWDrVO8npRfm2cUyMWYse48qiqzx96fzGj7uW/GnfGLd3/NnG77AX236Km9teB8bw9sueK+/vdFd5JypBYVST5BMzsZ2ctyz4mpWhSu5o2Yzxe5z6/767CR+FRrnKpNjKIPVoRrcxoV95jyZLHx4aEl1cWVD0YKZVRqw3PztNXdQFbjw35VYAJboxrySEc6zi6HY9niOttkc/VEDW5pWs2FllkTSRbi8lc5coWRclbeO32t4L8v8Kwaf47cCXF5yLZeXXEtz8jgPnPkhralTdGWnXmy6z+7h68f/D29e9m5Crsikn+exXKQcm1OJHopcPh7rPEy/PbwowEvRDpaFKkdMlpmKqJ0gaidYFaylMx2nO3ths2vz2iHoj3HLaove/hKencExZb/lotTno8LvoTSYxzCyJNN+nmzuIqdH7/u2nTwBl0yKERc3CYTzSGvNzlMjp+9ffBR7jmfZcxy2r1Go0kLgCFph3trwPur9o9eXBKjzN/HO5R/G0Q4dmTa+fPTzU+463d//HH978GNcUXoDV5TeQLF7crucF7n9aK1pCJTxv7fcxT8ffIjDsXP3TuQyHOjNsL1sNQfih0ZMipmspkAVHsNDqYcLDoSXlRbTkj6ImwDdqUIJMUsZ5LUz7Q/aG8tKqSw9Q9Q5MfgaBycJ+eDqVSW48GHkK9GOwYPHz036MQ2DnJPHbZrTfk1igVigm+bOhUUfCLXWxO0T5JwYfqsWt1lEYRx1/u1ra6cjNjd73M0Fv8vF6y6rw++rYnlwDY2B1biNyWULhjKo8tZyc9Vr+e6pL0/8hPP02T388sz3eajjZ9xR/UauK78FQ03c81/sCRC0PNTmivnude/lW8ee4rvHn+VM+lwx7We7TnFZ6SqOJI/iTGNW0PHEGTZHlnModmHZv9dw0ZEpfHCydZoVVTEaqjL0O22Yyk1E1WPk/aSzPvpSGsOAYh90JjRJO0c279Aajw9mdy7D5LplJURdO+nXI2e/npVkoPvebEEbcOuqzXTHvHSnslxd3YBfMkJxkVvUgbAv8xIvdf8dfZl95HUKUARcDVxa8dd4zFJyTiEIKWXh6BzZfA9KGbQnH6XMt4OQazmWEcIyfLPSvocOHZuV606W2zTRgJ0vLAQ0lSKv9ZTXMfrdLj5xyw3csm4VQc+FvSlWeKov6PlZJ8MPW/6dJ7t+zdbiK7mm7OYJu0xdpkWpWciu3tS4gzc1bufmB/+OWC6Nx7DIODl2dZ+mKVgDRoxue+wdJ4Yr/A4rPMXE7CQuw8Ke4njmUGnHpsa7lub0PrTK06sLtVGVAods4WcD8IJrYJP2fsDjLlQgBqjQUKJWgIKoc5J+dXRKo7RKQTcvQhhKw9BQMfcl1MQskoxwcXG0zYnof9Kd3jnkUU3CPsGjLW/EUB4cnRnz+Uf6vgaAqbyE3esIuVfgt6op8m7CY5RgKDfpfDt9mf0k7RaSuVZ8ViW1wTsp8mwglWuhK7WTYu8WQu6VmOpcgIilYzx6pJUvP7FzrNvPqoDbzd1bN/KB667gYEcXjx89iZ3P851dL1ATCbOhugKvZfG958ddg4rf7eKa5Q387etuw2PNzJ9SvX85q4MbORQf/94Tac+08ssz36c728FbG9436ef5rcL/p69c+XaSuSxFLh+nkj385swBXo620ZLQrIms5EjyyIRdpfX+MHWBOE4+zHO97RcUBM86GO1hVWQFralj0+rHUgp6OXpByxEtZbEy2IDt5GgKLJveRYRYQJQe55P/ZZddpnftuji2CNI6z+G+rxDPHievs3SmnkJhkNNT20B1JhjKi8IgrwvFnN1GMeX+qzCVl1j2KKd7bF44cS29CTe/PTx3pcm21dewo6Gee3ZspcQ/Mstt7y9sV+R3u3jpTAdHu3r43IOPDmaM5/uzW2/g9y6/ZMbbmczF+fSBD5PIXfjvRqH4yNrPUeOb3ht2VzrGvx19nN5sktfUXcLunpN89fCjrC2OcCo1dlfn1eWVKNUDaNozbYStGg72uYnak9ulYyIbI7XE8ofIM7fLKExl8LaG3+WOmhvRWsvu73NMKbV7nNJkF8RfUa/X3P3h2bj0CC/884dn7XVMx6LICHvTe3j2zB+QdSZTB2T2OXp4Yeas00tL/OeDPwcDcM2G/Rxt+V1O99ZwrGv2g/XvXrKBv7zjlZjG2ONmleFz+7dd2bSMK5uW8YatG9nX1sFXntxJ2OshmbVZU1nONcsbWFk+MwWVc45NXufxmIX+PL8VpNxdNSOBUKN54MwPeEfTH07peclcln19zWwprueaitXE7DQhl4/X1m3j+so1fOPo4wTMIC/FDo/IDEOWm87sfvSQfqb+XCtN4RBBcwUJ2+DFvrYRVW2mYl+0hSvKVtKcnts1qJcUbeCOmhsBJAiKRWNRBMJUrmPBTICZiuU13+e+GkikVnO8/Qrao2F+uX92Js/cd82OcYPgWNyWxbb6Gv7ljXcB0J9KE/Z5Z6RNH/3xA3zurlsAhTWktJntZNkYuRSX4eZwfP8F3+dA/x4y+fRgoJ0Mt2GysagWj+niivIV7O4+wfF4J8lclqDLy/UVa3ix7zSGcjiSOE3GKVR5Kff4qfK3kx5loV/aiZF2XgDg0rIaTF3Hs92tUwqICkWxO8DqcHDOgyBAlbd84pPExUvGCC9eNcGb0eQ43PsVYvbFs5/f2Q/UQf8hNjUdYhOwedn1xNNleFxx7t+zhtZoBpdhkMjaaA1/+ponaO/ZyNGOKva2OJzpn9xeehHfzOzPNhNBsC+VpjueYG/rGRytsQYWm/dkO9kXfY6gFeLmqrtYHdrIg+0/Ym/0wrrnM06a3b1PcFXZTZN+jmWYWMa5D1eXljZyMHqGNZEqAM6kotQHSjidqCdqr+eHLU/QnukhmbMx1cT/rNwqQjKvGW9oYjTby+poSe+jefK7Qc0Yn+kl5JJd38XisygCIUDIvYJS3+W4zDA96efmuznTVlHyW87WaXnnTQ8AoB0PhU4+E9NIEao7wMo6uGUbPLTn/dy/b+JgGM9kCXtnJpObrlM9fXz96d389shx2qIxiv0+OmNxKsOFqiRBK8x15bcMnt8QWMG9TR/il2e+zwNnfnBB9/5xy3dYHlhDla9u2tc4GwQBqnwRqnwRLikpjD3eVLWJHzU/y+6eQxS5XCTyI7u7q70VRFw+Xo6dROkAz/VMvGHv+Yx5Kura4K/lQ2v+B7W+qolPFhetpbqOcNGUWAu7V7M88lYsFWAhVuefDkMVvkwzg2lmsczUiPGoLQ3P8d7r43z09kPcuj7IyvIQN68LUuL3EvK6uW1jgPfd0M8P9l5YILlQLX393POt/+Y/d79IazSGBnqSqWGVddzGyKw166TZUrSdbUVXUuWtnfb9006KLxz+c3b2PDblLGwyqv1F3Lf6VXxo7atZHlxGlXd4wChxF1PrbiWgjnFZWFPl+RXlnqmVJTNQtKfmvtC2QrEi2EDWsSc+WYiL0KLJCAF8VhWm4cNlhLGdya71uriVFj1FaVHh+xuLnuBGCsHzps0DVUesQmYSdq+hLbGM6sCN89LOWCZDLDNyuUpb//AJMXmdxxwy3qswqPU18PtNfwDAkdhL/Ouxz5N1xl76MpZkPsG3T/4zxxOHuKP6jQSsme/m21DUwIaiezkWP8bDnQ/zeNfjuJSLlb4U6fy5Um1KwQ0Vh+m1N/Hgmc7Bx82BIgDrwhW4DYNiTxZNFwoThziOTnJ0jmswaDQPdTzJ4fgJPrf5o7gNKa69KC3QOqBzYdFkhAD92cO0Jx8hrRuIqVs449yBVtPvCrvYnM0goRAAzwbBAkWV//p5aRdAeTDApfUjM7oVZcPLoZnnTXo6f4LLytB6Xl3zZvxmgOl6ouvX/MX+P+Bo/GXyenaWHywPLufexnu5u+5ulFJoRgvcrRS7HmB9uIJVoXJeWVXElRUd3FAZIOh5GrfrSRLOLpLOCRLOUVJOO4ZxgkuL6yhy+Wel3UO9rtzPfTU+mnyFwHc62cpnXvoiydzMLAERYqFYVBmh1gad+k6ejx4EmqnyVlJpdOOoVTgqgOkcB91P1riKM3YEt6EwFRQbXbj0M/Pd/FmVsE9hOwnc5vxUAvFYJivKS/jtkeODj929dSPXrWyc8rWuK7+FK0tv4P62/8dDHRNuNTaqtJPiHw7/b8JWEdtLrydohbGURSqfwNEOyXycy0quGVYsfKqUUtxadStRO0rGfp5MfvS6snU+g7zKEh+YURrXe8e8ZiqfIJXfS6U3TL9tMf0Ko6O7pcTP64tP41O9uJzCHorX1ZRzNL+FUjNKSP2SfO4msGTfwUVpiWaEiyoQZglxIHZq8Of2dAc5Zztd2S7Axm2sADRZpw/oGzzv8qJ6wuPUWryYGbioCtzIxtKPzlsQBAh6PFzRUM/P9x2kPVbIVEv9089qXIabu2p/j6jdy+7eJ6Z9nf5cH79u//GIx31mgFWhDdO+7lmGMnjzsjcDb+bpzm/zVNe/DzuutcIxXyKR65/SdRP5fi4v3cQz3RdetL3EZXJtsYsrgjka1eMYunfYG6KhO1ll/Hqw68xN15jXEuJitKgCYaW3ljJPJc2pE0BhbKMQBAvGGlfa09+BwaXsiBi4nPkpezbT/FYtdcFXUxe6k4BrYZTBuqKpntKAn/ZYnCKfl7s2r7vga97T+AEuLb6Kbxz/AraemYkkxa4yPrrur/GaM9f9aDtpujLHRzzuMYvJ5qY+3gmQHb3gDxawPuQlndd4TMXe2PhrLUwUq7076ci04vduo4rxC1Po/r8AqwFlrZxWu8e8rtaQ2w/ZZ8F3N8qQPQ7F3FhUgRCg3t80GAgnK+tkaPLXY+UfWhQTTjeWfoyG8O9iqIU1qcFjWfzXO97IU8dPc6izi+VlM1OZZkNkGx9e82n2RnfybM9jdGUubFf5XruLHzR/i6vLXsky//IZqaDSmnqJo7EnRzyuyY8YF50MhUKjcSm4rsRH0NRkHEWTrx+/6sXJPz9wnodLQjfRnHFzKulwNJVm+B+5JuHk0RQDrZxIv0ClN4warzSh04bueg3aewvKext4rkep6a9T1ToNmcfQiW+AvWug3RoC75z2NcXUKZbu8olFFwg3hLfxVPfDkz6/2lvFKm8ay/kVSs3PGq0Lowi4lhF2ryHsXk2JdxtlvgVTwm8Et2Vx/aomfCWnORZ/mabAmhkJNDW+emp89ewoeQVPdT9EU2A1B/r34DY87IvupjV9auKLDPFMzyM80/MIld5arih5BZeWXEXENf3AXe5pwjI8ZJ3haz61dshNsRi3QnFnSR8+/W1eGQqSd3rOHXQYttJQk6FM3U+ZFy7xgmFupT9fTsRsQdGP1nEcJ0E+n2Wlbzul+ghKT6abNgfpn6PTPwcVQnteCe4dKLJgVoG1CoyqwYpPOnes8LMxMsvWPe8Ee0hPjCoC7+1T+p0IcSEWXSDcGLmUgBWaVJ3KBl8dKzwHMPSpiyoTNJWf2uBtlHi3UuG/Fo9ZPN9NGlO/3YdCDW6FdCbdwn+c/BInk0fwm0FeXfMmrii9YVJ7B05GkbuE26pfD8Da8GYAbqi4nc8c+CPiUxyHA2hPt/Dj1u/w49bvUO2tZ114CztKXzHlNY192bYRQRAgp2OsCTaxLzb6WJ+BwQ3FIYIcBfJkVA0e2nA5J9CK4UFwAgoLnd9PkCyj1VEPGho13u9IRUBHwXMLWE2QOwz2HnC6IP0TyHeg7aHjtRbaKAJc4LQBBtpsAM9VA9dKDlzjvOEI9zYwFu7f9KImGeHikHHSpPOTm97tNc1CELyI+KwadlT9MyH38vluyqQ0J09Q41tG3O7nkc5f8GT3bwY/pCTzcZ7rfYpLinbgn4U1fWf5rSD3Nn2ILx7+CwxlTnvJRFv6NG3p0zzc8XNuq349N1e+dtIB3NZpvGaYdH5koOnPvsiG0OXktKLP7sdtWFS4LbIO1LtOEtAPDp7r1oWZnJP54BbxXklt+L209H8FyyiiLvJeHJ0haR+mL/U4mdwpck6UTK6NIlcNbqdz9AupAKr8YZRRhM53o8xzS160EwenB4wiyB1Dx2ywnx04misEyUEO5I9DcuRY6TCZh9A974DgH6A8V078QoW4QIsuECZycfxmgFhu4gX17Zl+6md/OdaM8ls1uM3xN5pdSB7u+Pm4ewseju9nf//zXF5y7Yzf29EOhjJI5OKEXUV8ZtO/Yjs2Xz72eVpTp6YdFDWa+9v+H493PsiGyFauLL2JhsDYyyy0dni681ujBsGzYtmd1Hsr2Ox6msHOTYMpfUJ3GaUsL/0M8cweLCNCZehNZHNncHSKppK/x22WARDybKUy+IbB58WTP8MX/wzK6R55UVWEKv5yoftT62FBEEAZQTAKH2K0awuq+J/Q8S8AFtgvQb4FnJbJv4iz7N3o/o9D+K/AvRWlLmzDZzE5ahaqLl0MFl0gfKzrgUkFwYKL63/6yqJ3siz0O3jOezNayK4pfxVd2TP0ZMeecv/bjl9wafHVM9Y9etbZ6wWs4GAVmb5sN3fX30ulp4Zeu5u/P/hJcnrypcOKXCVknSypfIL+XB9PdT/MU90Pc2PFnby65s1jvoZSTyOtqfF30ojaCeq87hHbeJ3PVCGqQm8hlTtBT/KBwcdtp5t4Zg/Lij58bjcWC6qCv4ephhcgyOY7MVUQ0/AR8F4Dxp+D8haeoGPo9C9QnleA50aUEcHJPAU6B1YtmMtQQwqLayeO7v8UpB8AZrAEXL4Z3fu2Qjdq8D3gf6ds/SRmxaKqLKO1Zk/fsxOfOMBUJhfLB6Aq/42sLf4gAVf9fDdlSrYUXc7Nla8d95xqX/2MB8GxFLlLaQqsxm8FqfU1sLX4ikk/9+qyV/KpDV/kg6v+jDp/07BjD3X8jM+//FF6siO7F/M6R61//DWJm4J1bPQemzAIAtSE30Vt5H3o8wK4wkVeJ+lK/JRE9gAAlhGmPPhaTGP4RsyxzG7i2cLCfWUUgftKsA+gox9D506irJXo7B50z9vQmSfBWgtGEbrvjyHxdXT8H9Hxf0YnvwfpH6NcW8H/pgnbPi06io59Ht13Hzr7PDr9G/QMLZURQ+g5/FpgFlVGeCJxeNQ3otGUucvYFOjjYpgoWuq9nC3lf4Gao2Ax064svZEfNH8Te5TMK2AGefOy98xDqwofnAxMPIaXjDN+AKr3NfH6undgKIMaXz1/vOYzJHIx0vkUB2N7+a/TX6UtfZp/PPxpPrrub3Ab57ryLMNNwCol4qohareOuLaBIqIOYDuT24g47NmGZYRYV/FVEtmD9CR/ScC9gXh2HyHPFsKeK4imHyeafoqa8L2jXqPUfys634pOfBW8d4BOotO/AvdVEP+7Ye9VuvftFN4qCt3Iepyu7lmVeQideQgAVfECSHepmCEX5zvrGBL5+Kg7GIwmlovh4Jv4xHlW6r2c7VVfnPGqMLHsUY70fZ3j0e+Sc2a3dmR7umXMPfoS+TgvRueniIFSirc0vIePr/87VgbXcU3ZzawKjszcFIp3r/jIiKw1YIUo9VRwVdlNNPpXAYXJWslRZiwvC2zl7Su+xp21f0bYVTV43c2hOq6KlGIPKcg9ccPPtSPgXkPQs4Vo+hmqQ/cQTT/F6egXKPHfTEXw7mFPyztpUvYxMrlWHJ0pdHW6LitkerkT4FoF6e+PcdPZqck6dQqsNQPduGKmKT03XwvNogqED3f8bNK7EmScDAu9XzTsXsPllf8Ha5S1V5PVnX6OPZ1/zv7uv0UP2QndbZYQcq+iO72LU7Gx3vxmRk7bLA+uHfN40Jq/0m8AEVcJH1z1Z9xdfy//Y/kf4Tuvosza8Bb85vizWl9T+xYa/au4tPhqityjj+EaymRl6GpurvoDTOXCa7gJcwDbfnpK7X2p/R5imT2DPxd5r6U28h6S2ZdpKPoodZH3AWCdV5klk2/heO+nae3/KobyoKxlKPcl4PRC8tuQ+uGU2jEvfG/CKPvpRds7IhamRdM1ejJxhCPxA+OeEzCDRFwhLGUQtly49M/nqHVTZyov26u+iGuamWA618GBni/QHP8pAB6zlFj2KNWBm2gIvx6PWUyl/1oq/TM/W/N8Je4KovbY693K3BVjHptrXtNHY2A1B/pfGHys0b8Syxj/n8qK4Fo+tOYvxp2F6ugMe9ruojp0LzW+JsrMFDnnyJTbqMlxoONeLqt7shDQlInbLMPtK8wKtdTofzN+1wrWlX8VfX52Z8xMhZ+5oDxXzXcTFreFnRvMmkXxscrRDo91/Wri83BY4+1gtftXVBkLNwgCbCj9CD5reruBa615seszmMqLz6oBIJPvJpVrpTpw80w2c1JS+SQtqZOjHjOVRchVNLcNmsDNlXfhGlKe7hdn/ptP7H0vP2v9L5K5cUqPwZhdwACG8rC+4uvknE5+Z9nfETGa0Xp6dUZzTi9Huz9BNj/5Atgp+xhKGRjnj63pJNgvgFkP3rtQwT9ABT88rXbNNh37vzJRRsy4iz4QpvNJvnniH9jZ89iE56bySR6NKrReWDU4R+O3pr8bu1KK7VVfYHP5J1lb/AEqfNfiNkvYVPbJeVmDeCzx8pjHKjzV06q1OZtWBNfyqqrfGfZYLBflwfYf8VcH/mRaFWrO8lg1lPpvI5E9QE1o9Iksk5XI7uPljvdg54dn23knSX6UyT9eq2nEYwCaMD2BP6M38BGMor8Bzw3o5H9cUNtmTf4oZH47361YtJbqGOFF3zVqKJO90V2TPj+vc/SqV1LCL2axVRfuZOz/Ue6/8KoadaE7KfNtxzKCFzTWOF292W6M8wLdtqIrKfdWsz/6HMuDa+a8TZOxKrQe2kY+3p/rI6/H2PZhknyu5eSdBAH3OsLe7exvfyvZ/Cg3G0fQvYX1ld8kkd3Pmdi3KPXfBsrAUsXkdRyfq2HEc0Zbg9ce+y9O9P0VIfdWkvbLuFQxIToLpdQWKB37HFhNM777hVi6LvqMcFfP44NvTAEzOG7X1FkvRJt5KXPTgp4r05l6hlRu/JmECfs0T7T+Pkf6vjHueW6zeF6CIBQWs8ez/VxXfuvgY5eVXMPt1Xfzx2s+y+tq75mXdk2k1tdAwBp9G6CuzBRmeI7BNAIYyoPP1cSW6p9QHXon9ZEPU+q/c1LPj2f3cKz7E9j5XtxmLT7XKkwVQCljWBAcLTMcqiL4BjZVfZ+AewNKuelK3Y/y3VGYTbpQ5U+ju+7E6fsQ2knMd2sWF1lHeHE6u+XSquAGonYvicz4YzhnLfOaCzJFPyvnxHiq7V2siNxDbfAOLGPkUo+e9HNU+K5leeSt415rPrdjchserq+8lUw+zYbwVnLaZkNkG1DIUNQCqHaec2wsY/jvyG14eEPdO/nGif+LQrG95Dp2lL6isI7QO9P7OxqYKkh7/LsE3RsnPLfE90pCnktwm5V0JX9Kb/Ihck43NeF3j8j6zsS+ScR7FUHPplGvppTC71pBQ/Ef01D8x+ceD/1PdCwL2Wcu9MXNEgfSv4DwJ4HAhGcLMZ6LPhBWeWvZEN6G1/TRlj49qedcW+THpSeeXDPfEvYJjkW/RbF3C2H3qhHH60N30Z3ahZ3vx2Mt7LJrHtM7uBvEbLOdLC5j8outRwSPVDOPdf2KE4nCjM4NkW28peG9M9rGoU72/TUR79WU6ttpi311grMdelK/oi/9OF6rnsbij1MReD2n+v6OM7HvUBl6C16rnpBnKx6rhurwvZOeXKLtQ2AEwOlD93+6MIFmITLrwHsbylpb2LJJiAt00QfC68pv5bLia/jTve+iwb+CYncZp5PHxjzfa3ixnJcW/LZLRZ6N1AVfQ1Nk/LJVpQt478H5Ml4QdLQzWIw7nusnp21K3OXDzlHK4PGuczs+RLOT3+poOqpD78BrNlLkuZ5YZidJ++CEpdYcnSRpH+SljnsIe7ZTF7mPtti3OdX3eQBK/XewpvyLhd6AUXoE0rkWXEYpPclf0tL/r6wu/yI+ew868WVU6Q/BfXmhaDY2C6ovy1yGKv3JqPsaigu0QCeyzIWLPhBC4Y3rLzf+C34zyDdP/AOt6uSYExqyjk3WuASPnniW6XxZVfQe1hS/TwoMzwJDGYMVYsKuomEzQNP5JG7Dy3O953aSL3VX8IqK2dskNpbZQ0/y15T67yDoWUt1+B2ksocH2tMMOo9lFOG2KsnkzlDku5bOxI/oSz0yGCz7M8/Sn3mWYu+N1Ec+hNuqoj32XbR2xlx47h2YlVwWuJOW/i+Ry3WDUVh/qPv/srAfoHsrZHezcKrKgPLfI0FQzLhFEQh9pn+wGojLcI87q88hzxN9US4vuoWgfgzFyM1S51OZbwfLI2+TIDhFWmu6sx2UeSrZ3fME7ZlWbqt6/Zi/x0w+zUv9z+M2vOS0zd7oLjrSrdT4lvFU98MArA5t5F3L/2RY3dCZFk0/TlvsG3itOoKetZQHXgMBaO3/GqWeTRzt/hg5p4eAeyOVwTfjd61kTdk/kbIP05/ZRX9mJ12JHwPQm36I3vRDhDyXUhl8E639XyHs3U7QvWXMgJjJtRDxXk3Qc0lhH0GjDGU1ohPfAN03a6972qzG+W7B4iYZ4cUvmUtwMLZ3wvOqvOUY5BZcEARYXfSeGa8rulhl8mnchoc+u4evHPsb4rl+NoS38UzPb8nrHA93/JxX17yJau8yXo69iNtwYyqLjnQbB2N76bPP7b/nMXy8f+XHeaTz/sHH7qp5y6wGQYC6yPupCf8PUnahO19rTVfyp5zo/cyw8xLZfRzr+TgAPtcqmoo/Qco+QjbXRsC9Cb9rLX2p32I7HbjNasqDr6Wt/xuc7P0bVpX9H7TO4h1l5xKvq4Gmkk8WfvBcC+5rCh8e3FeBvQed+j7kxq/YNJd0/F/AfUWhCIBOgf0ymOUo10STjIQY26IKhF7TR6m7fNwFzz7TzzrvHpSefEWOuVLtv0XG/KbAY3pJ55O82PfsYOWaJ7t/M3g862T4fvM3J7yOQvG2hvfREFjBW/338bt1v49Cjbl8Yqal7GOcif0H9ZEPkrQPc7L38xOcf5iXOn4fj1nLsqI/ojz4WuKZfSwv+RQHO+8jltkNaGoj76Y28m6y+U6O93yGusj7CHrGn7CklBqoQFOMy/cGDNdmdM8bxn3OnLJ3o9u3Uhi7HKAiEP4kyveaeWvWYqBYumOEF/06wqEK4z/jVym5MtS/IIMgQLF39CnuYmxe00+dv4liV9m0r7EquIFNRYUPIKayCFrhOQuCAAH3Onyu5WSdTop8V7O24l/HrAIzVCbfQl/6Mex8N9l8O4bysb7ym1QEX4/CoC9VGAc3lY/V5V8gnWsdVqz7LDvfSyzzHGn7FNl8J72pRzjZ9zek0r8pbNO04NhgbQQ1MFaoo+joR9C55vltlrhoLaqMsGDssbWgFULpkW8E86XEu401xe9HKROXCuK1Kue7SRelFcG1fHjNXxLLRenKdLC793H29u3CYXKbTd5U+epZbuHEasLvGPw+6N7AJTW/4Gj3R+lM/GjU81eWfp5E9gCdiR+StI9QHXr74HjosqIPAeAyS8k7cQzlJa9ThD2XEs/upT/9PAH3GsyBSSexzHO4zDK8rmUDbTlX+s3JTTzUMCdUBDxXF8YwXRvA+1p07C8g+Z3CcaMMzJr5beNisJCrjMyiRRUI43Y/LQML7Ec9nouRV+ux9O65a9QoFCaXlH+amuAtGJOohCMmFnYVEXYVUetrYEvR5RyOvcRPW/+DU8lj6AlmAEx0fD4Yyk1D8cfGDIRJ+whNJZ/ENMIUea8GZaB1HjWkR8QySkjnWgi41+A4aQzlpsR/IzmnfzAIApT4bxr8Pp1rxmvVDf6sPDeAWY6O/+v8TZ4xG1DFX0NZ5xUyCH0CjQuS/1bYSirzK/DeOuolhBjPonoXfr7vabJOhlJ3Bd3ZjhHH14Q2sTyyjlL36zFw0Z89yLHot8hPsGZrpm0o/Qh1oTvm9J5LzarQej685tMcix/kwfYfcSJxBI1DKj9ygtQPW77FiuDaSW/qPFfOnzAzVGv/16gKvoXa8HswjdE3qfVYVaTTxwFwm4W1kin7GKaK0Bz7EnWR95J34pjGub0WvVYdWjsk7ZcJuNeDexsYflRQo2Pjj13OCqMSVfJvKHNkEXqlTAj9KVirwL1jZKAUU7ZUxwgXVSAMu4r41IYvUuIuI+fY2NqmNXWKfdHdrA5tYF34kmHn1/AqmiJv4eWef+BUbG42JTWVn7qgBMG5sjy4hvcE/xcAOSfHQx0/4+dt/zXsnEQuRluqmYbAivlo4phKfDfRlfgZxb7r8Fh1nIl9a8jRPCd6P8vaii8Bhdmmoy0ViXivpC/1OGHvDnL5HrqTvyDk2U5P8lfURd6LaQTROoca0jOhVKHkW1/qCSKmH515DJx28L99ICAZaPs5SN/PbM+3V/43gDH2kIFSCvx3z2obxOK3qALhlqLtg99bhgsLFyuCa1kxzu7oHrOULeX/Gw20xH8xYUWPqTKVj9rgHeSdBG3J33BV9VenvdmuOOd4/BDVvnq85sgarGOxDItXVb2WPrubnT2PkXUKewH+fuMHF1wQBCj130bE8z2KfTdQFriLvJOkM/F9gu6t5JweelOPkLZPDYztaUANC4haazK50/hcKzGUC7dVSV3k/dj5PtZVfAM730vSPojbrMDnWj7s3h6rhnh2L82Z56gKvhXLcEPuKOhedPoByB0C3xshfwKyT0/+Rflej3JtA51GO52Qb4H0L4HRy8Dp7C5UIM8ie6tamBZoQey5IH9dA9xGEUxyckXYvZYtZX+GRuOzKjGUh5wTJ26fJOhqxGOW4GDTm96DodyU+QoBOpPvxWMWz96LWEKWBVZMu2D3G+rfyR3Vb6Qz00ZXpoOwVTSzjZshSpmsLvsShmFgGl4aiz9Of/oZNlR+i5R9lJc7343LLBs41xj477nfSTz7IplcC6X+W7HzfSgMsvlu0rkjlPgLGzRHzCsA0Nohm+/AbZajlEnOiVHku44i37WY+VZIPoz2XEfOWIHLrAHvrSjP9WgnWghkyoVO/wYyDzIe5X0VyvOKwvcDj2nnk5D6ATr5n4XAepbnVlTR3w/LVoWYDfIXNmBdyR+SyXfTHP/JiGMKkyLPZsp9OzAMD8vDb8U8bzzJbUbwu86NY5h4qfBfM+wcCYIz50I38w1YQQLWKhoDI4uZLyQu69ykFtPwUR78HUzDT9CziTXlX6I9/t1hszyHCnm2EPJsKVzHLALAMsN4rCpyTj+WMbRnwsHOd+A2KwfOL/yt5pwYadz4gveBzkGuC+17G3nABSgjAv43DlzDjR43ELrBHGWfRCMCgXegAu9A546go58Ce2ch07RfLIxTijmhJpcLLDqLah3hhVBK0RC+G1OdX8dQcUX1v3JN7TdZU/I+VhW9c0QQFGIuGMpDfeQDgz9H009SGRy/KPvoNHa+m7yTGtzdXimLoGfziHFGywhhGZGzLaAr9TOea7udvtQjIy/ruQq8t1MIkUOoIvDcBK5LwGwct2XKWokq/kcwV4DuQ6fHzzCFmAmSEQ5R4t3CldVfpjn+c070/ycAm8o+Pti1KcR8G9pNaKoA0/ksaxp+fEZhwb7JxGOsLrOUbK6DvvTjnOj9LCHPpZQFRm4grIwSVNH/LXSXZp9B2y+gPLeAaz1KudA6PakausoohuKvoGOfRnmunPLrExdAxggFQLF3M8Xezawuejf92UMUT1CSSlw8tNOHk3kOZdVguMaeQHWxqA7fM2f3clsVaPJUBN9AU/Enxh23U0YEvK9CeV81/HE1+jKPUa9h1aGKvzTt9goxFdI1OgaPVUq5/0qyeuy6pWJhyes8epzKGMoownBvxMn8ZsxzLkY5Z/b+RpP20cHvKwKvY0XJXw1bdyjEYiCBcAJ+q3q+myAmyVTmhF1vyqzACr5/jlo0N85OerHzvSSyhZ0iMrkzF3zdTK6FtH1uk2ulLNkebJFTem6+FhrpGhUXPa01aSc1uCflUqS15nDXh0nah/FYNbjNClaUfhbLCJPJtQEOhvIPzgadSM7px3FssvmFWaBeiJkkgXCW2Pl+WTg/R5RSSzoIAtj5DmLZ5wGIZZ4H8qRzJ8k5MTK5UwCYKkjEexWmEcRrNWI7XSwv+XO01thOF5YRxlCFGdF5J4nXtQyfu3F+XpCYexopui1mlgRBMZfcViXb655HKUXO6SeTayXnROlPP0Nv6hHi2RfI6zg9qV8NPsdrNXCi93N0xr8PwCU1D2KYhUDosarm5XUIMR8kEAqxSJwdv7OMMJa78EEs4t1BXeSDvNz5LkBjGSUE3ZswDT8uswJT+Snz34kmP7joXixdC3H8bi5IIBRikdE6j+30DO44oZRiXcVC3GBXiIVBAqEQi4xS5mAQFGJKlmhGKMsnhBBCLGmSEQohhECxdMcIJSMUQgixpElGKIQQorCGcImuI5SMUAghxJImGaEQQghAxgiFEEKIJUkyQiGEEAWSEQohhBBLjwRCIYQQC4pS6lal1EGl1BGl1EdHOa6UUv8wcPxFpdS2gcfrlVIPK6UOKKX2K6X+52TuJ12jQgghgIUxWUYpZQL/BNwMNAM7lVI/0Vq/NOS024BVA187gH8Z+G8O+COt9XNKqRCwWyn14HnPHUEyQiGEEAvJduCI1vqY1joLfBe467xz7gL+XRc8DRQppaq11m1a6+cAtNYx4ABQO9ENx80Id+/evfvs1i5CCCHmXdesXVkDzpylhGVKqV1Dfv6y1vrLA9/XAqeHHGumkO0NNdo5tUDb2QeUUo3AVuCZiRozbiDUWl820QWEEEKIKeoaJ76Mln2dH6HHPUcpFQS+D/yh1rp/osbIGKEQQoiCBTBGSCG7qx/ycx3QOtlzlFIuCkHwO1rrH0zmhjJGKIQQYiHZCaxSSjUppdzAm4CfnHfOT4B7BmaPXgFEtdZtqjCW9zXggNb67yd7Q8kIhRBCAAtj1qjWOqeU+gDwAGACX9da71dKvXfg+JeA+4HbgSNAEnjHwNOvBt4G7FVKvTDw2Me01vePd08JhEIIIRaUgcB1/3mPfWnI9xp4/yjPe5zRxw/HJYFQCCFEgWzDJIQQQiw9khEKIYQAFsYY4XyQjFAIIcSSJhmhEEKIwhpCyQiFEEKIpUcyQiGEEChAyaxRIYQQYumRQCiEEGJJk65RIYQQBc58N2B+SEYohBBiSZOMUAghBCCTZYQQQoglSTJCIYQQsqBeCCGEWKokIxRCCAFo2YZJCCGEWIokIxRCCAHINkxCCCHEkiQZoRBCiAIZIxRCCCGWHskIhRBCgAYltUaFEEKIpUcyQiGEEAUyRiiEEEIsPZIRCiGEKFiaCaFkhEIIIZY2CYRCCCGWNOkaFUIIAcjGvEIIIcSSJBmhEEKIAskIhRBCiKVHMkIhhBCFpRNSYk0IIYRYeiQjFEIIgULLrFEhhBBiKZKMUAghRIFkhEIIIcTSIxmhEEKIAskIhRBCiKVHMkIhhBCyjlAIIYRYqiQjFEIIAcjuE0IIIcSSJIFQCCHEkiZdo0IIIQqka1QIIYRYeiQjFEIIAWjJCIUQQoilSDJCIYQQhQX1khEKIYQQS49khEIIIQqkxJoQQgix9EhGKIQQApASa0IIIcSSJBmhEEKIAskIhRBCiKVHMkIhhBADG/NKRiiEEEIsOZIRCiGEQGqNCiGEEEuUBEIhhBBLmnSNCiGEKJCuUSGEEGLpkYxQCCFEgWSEQgghxNIjgVAIIcS5BfVz8TUBpdStSqmDSqkjSqmPjnJcKaX+YeD4i0qpbUOOfV0p1aGU2jfZly6BUAghxIKhlDKBfwJuA9YDb1ZKrT/vtNuAVQNf7wb+ZcixfwNunco9JRAKIYSgsKDemZuv8W0Hjmitj2mts8B3gbvOO+cu4N91wdNAkVKqGkBr/SjQM5VXLoFQCCHEXCtTSu0a8vXuIcdqgdNDfm4eeIwpnjNpMmtUCCFEwdzNGu3SWl82xjE1ymPnN2wy50yaZIRCCCEWkmagfsjPdUDrNM6ZNAmEQgghFtKs0Z3AKqVUk1LKDbwJ+Ml55/wEuGdg9ugVQFRr3Tbdly6BUAghxIKhtc4BHwAeAA4A39Na71dKvVcp9d6B0+4HjgFHgK8A7zv7fKXUfwJPAWuUUs1KqXdOdE8ZIxRCCFGwQCrLaK3vpxDshj72pSHfa+D9Yzz3zVO9n2SEQgghljTJCIUQQhQskIxwrklGKIQQYkmTQCiEEGJJk65RIYQQFEqsSdeoEEIIseRIRiiEEGJgQf2EBbEXJckIhRBCLGmSEQohhCiQMUIhhBBi6ZGMUAghRIFkhEIIIcTSIxmhEEIIYFJbJC1KkhEKIYRY0iQjFEIIMVBYRtYRCiGEEEuOZIRCCCEKZIxQCCGEWHokIxRCCFEg6wiFEEKIpUcCoRBCiCVNukaFEEIUukVlGyYhhBBi6ZGMUAghRIFMlhFCCCGWHskIhRBCAKBljFAIIYRYeiQjFEIIwUDV7fluxLyQjFAIIcSSJhmhEEII0EjRbSGEEGIpkoxQCCFEgWzMK4QQQiw9khEKIYRAA1rGCIUQQoilRzJCIYQQhTWEMkYohBBCLD0SCIUQQixp0jUqhBACkMkyQgghxJIkGaEQQogCmSwjhBBCLD1KL9FtN4QQQpyjlPolUDZHt+vSWt86R/eakARCIYQQS5p0jQohhFjSJBAKIYRY0iQQCiGEWNIkEAohhFjSJBAKIYRY0v4/cXrEFQIewSgAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -338,7 +1380,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 14, @@ -381,7 +1423,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -402,9 +1444,8 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" + "name": "python3810jvsc74a57bd06862fd12474ff4e8f506c71d9bf19f0b72121611dc4c16d7b8461434e8b6255f", + "display_name": "Python 3.8.10 64-bit ('atlite_dev': conda)" }, "language_info": { "codemirror_mode": { @@ -421,4 +1462,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 5a8307fc8934fd3a0519b44c8bd399544609f94a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 30 Jun 2021 09:00:32 +0000 Subject: [PATCH 10/19] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- atlite/datasets/cmip.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/atlite/datasets/cmip.py b/atlite/datasets/cmip.py index 576e1882..406fdf45 100644 --- a/atlite/datasets/cmip.py +++ b/atlite/datasets/cmip.py @@ -225,8 +225,8 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): raise (ValueError(f"{cutout.dt} not valid time frequency in CMIP")) else: freq = esgf_params.get("frequency") - - esgf_params['frequency'] = freq + + esgf_params["frequency"] = freq retrieval_params = {"chunks": cutout.chunks, "tmpdir": tmpdir, "lock": lock} @@ -234,16 +234,14 @@ def get_data(cutout, feature, tmpdir, lock=None, **creation_parameters): logger.info(f"Requesting data for feature {feature}...") - ds = func(esgf_params, cutout, **retrieval_params) ds = ds.sel(time=coords["time"]) bounds = cutout.bounds ds = ds.sel(x=slice(bounds[0], bounds[2]), y=slice(bounds[1], bounds[3])) ds = ds.interp({"x": cutout.data.x, "y": cutout.data.y}) - + if globals().get(f"sanitize_{feature}") != None and sanitize: sanitize_func = globals().get(f"sanitize_{feature}") ds = sanitize_func(ds) - return ds From 3f01d28c446a0e5c0d083db4e7d2a66fec518938 Mon Sep 17 00:00:00 2001 From: Ove Westermoen Haugvaldstad Date: Mon, 5 Jul 2021 10:32:10 +0200 Subject: [PATCH 11/19] cmip data available for the future --- atlite/cutout.py | 2 +- atlite/gis.py | 9 +++++++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/atlite/cutout.py b/atlite/cutout.py index bafec778..953360cf 100644 --- a/atlite/cutout.py +++ b/atlite/cutout.py @@ -211,7 +211,7 @@ def __init__(self, path, **cutoutparams): ) from exc # TODO: check for dx, dy, x, y fine with module requirements - coords = get_coords(x, y, time, **cutoutparams) + coords = get_coords(x, y, time,module=module, **cutoutparams) attrs = { "module": module, diff --git a/atlite/gis.py b/atlite/gis.py index 0556fa3a..1edeaa88 100644 --- a/atlite/gis.py +++ b/atlite/gis.py @@ -65,12 +65,17 @@ def get_coords(x, y, time, dx=0.25, dy=0.25, dt="h", **kwargs): """ x = slice(*sorted([x.start, x.stop])) y = slice(*sorted([y.start, y.stop])) - + if 'cmip' in kwargs.get('module'): + start="2015" + end = "2100" + else: + start="1979" + end="now" ds = xr.Dataset( { "x": np.round(np.arange(-180, 180, dx), 9), "y": np.round(np.arange(-90, 90, dy), 9), - "time": pd.date_range(start="1979", end="now", freq=dt), + "time": pd.date_range(start=start, end=end, freq=dt), } ) ds = ds.assign_coords(lon=ds.coords["x"], lat=ds.coords["y"]) From c69293e2dfb171e268609e203530425f4da79d6e Mon Sep 17 00:00:00 2001 From: Ove Westermoen Haugvaldstad Date: Mon, 5 Jul 2021 10:33:10 +0200 Subject: [PATCH 12/19] update example to use future data --- examples/cmip_interface_example.ipynb | 417 ++++++++------------------ 1 file changed, 122 insertions(+), 295 deletions(-) diff --git a/examples/cmip_interface_example.ipynb b/examples/cmip_interface_example.ipynb index 6404c548..69f524b8 100644 --- a/examples/cmip_interface_example.ipynb +++ b/examples/cmip_interface_example.ipynb @@ -2,8 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, - "id": "91245dec-e5bc-4acf-b8bf-b8d67652c927", + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -21,8 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "14dfd92a-93df-4109-9302-e3c53bbbd436", + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +54,6 @@ }, { "cell_type": "markdown", - "id": "7b336846-42b6-46c8-b3c1-3ec4c842b043", "metadata": {}, "source": [ "Create Europe shapefile" @@ -64,8 +61,7 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "6b9b4066-abcd-4d21-9b9a-7bb337be5c32", + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -77,7 +73,6 @@ }, { "cell_type": "markdown", - "id": "0fd0e3fc-c3a0-4caa-a648-702508f23810", "metadata": {}, "source": [ "## CMIP Solar capacites" @@ -85,262 +80,106 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "3e70b8bf-674f-4a7a-801b-fa3724497acd", + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "KeyError", + "evalue": "'2031-01'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.DatetimeEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32mpandas\\_libs\\hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.Int64HashTable.get_item\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32mpandas\\_libs\\hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.Int64HashTable.get_item\u001b[1;34m()\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: 1924992000000000000", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3080\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3081\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3082\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.DatetimeEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.DatetimeEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: Timestamp('2031-01-01 00:00:00')", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\pandas\\core\\indexes\\datetimes.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 685\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 686\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mIndex\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 687\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3082\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3083\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3084\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: Timestamp('2031-01-01 00:00:00')", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\6/ipykernel_11608/2564099409.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 8\u001b[0m }\n\u001b[0;32m 9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m cutout_cmip = atlite.Cutout(path='cmip_europe_2031.nc',module=['cmip'],\n\u001b[0m\u001b[0;32m 11\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m13\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m45\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m32\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m83\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mc:\\users\\ovewh\\documents\\atlite\\atlite\\cutout.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, path, **cutoutparams)\u001b[0m\n\u001b[0;32m 212\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 213\u001b[0m \u001b[1;31m# TODO: check for dx, dy, x, y fine with module requirements\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 214\u001b[1;33m \u001b[0mcoords\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mget_coords\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmodule\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmodule\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mcutoutparams\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 215\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 216\u001b[0m attrs = {\n", + "\u001b[1;32mc:\\users\\ovewh\\documents\\atlite\\atlite\\gis.py\u001b[0m in \u001b[0;36mget_coords\u001b[1;34m(x, y, time, dx, dy, dt, **kwargs)\u001b[0m\n\u001b[0;32m 81\u001b[0m )\n\u001b[0;32m 82\u001b[0m \u001b[0mds\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mds\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0massign_coords\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlon\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mds\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"x\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlat\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mds\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"y\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 83\u001b[1;33m \u001b[0mds\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mds\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 84\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mds\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 85\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\xarray\\core\\dataset.py\u001b[0m in \u001b[0;36msel\u001b[1;34m(self, indexers, method, tolerance, drop, **indexers_kwargs)\u001b[0m\n\u001b[0;32m 2363\u001b[0m \"\"\"\n\u001b[0;32m 2364\u001b[0m \u001b[0mindexers\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meither_dict_or_kwargs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"sel\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2365\u001b[1;33m pos_indexers, new_indexes = remap_label_indexers(\n\u001b[0m\u001b[0;32m 2366\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2367\u001b[0m )\n", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\xarray\\core\\coordinates.py\u001b[0m in \u001b[0;36mremap_label_indexers\u001b[1;34m(obj, indexers, method, tolerance, **indexers_kwargs)\u001b[0m\n\u001b[0;32m 419\u001b[0m }\n\u001b[0;32m 420\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 421\u001b[1;33m pos_indexers, new_indexes = indexing.remap_label_indexers(\n\u001b[0m\u001b[0;32m 422\u001b[0m \u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv_indexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 423\u001b[0m )\n", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m in \u001b[0;36mremap_label_indexers\u001b[1;34m(data_obj, indexers, method, tolerance)\u001b[0m\n\u001b[0;32m 272\u001b[0m \u001b[0mcoords_dtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 273\u001b[0m \u001b[0mlabel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmaybe_cast_to_coords_dtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlabel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcoords_dtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 274\u001b[1;33m \u001b[0midxr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_idx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mconvert_label_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 275\u001b[0m \u001b[0mpos_indexers\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0midxr\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 276\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mnew_idx\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m in \u001b[0;36mconvert_label_indexer\u001b[1;34m(index, label, index_name, method, tolerance)\u001b[0m\n\u001b[0;32m 189\u001b[0m \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindex\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlabel_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 190\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 191\u001b[1;33m \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindex\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlabel_value\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 192\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mlabel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkind\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"b\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 193\u001b[0m \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlabel\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\.conda\\envs\\atlite_workflow\\lib\\site-packages\\pandas\\core\\indexes\\datetimes.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 686\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mIndex\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 687\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 688\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0morig_key\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 689\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 690\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m_maybe_cast_for_get_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[0mTimestamp\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: '2031-01'" + ] + } + ], "source": [ - "esgf_params = {\n", - " 'data_node': 'esgf-cnr.hpc.cineca.it',\n", - " 'source_id': 'EC-Earth3',\n", - " 'variant_label':'r4i1p1f1',\n", - " 'experiment_id': 'ssp126',\n", - " 'project' : 'CMIP6',\n", - " 'frequency':'3hr'\n", - "}\n", - "\n", - "cutout_cmip = atlite.Cutout(path='cmip_europe.nc',module=['cmip'],\n", - " x=slice(-13,45),\n", - " y=slice(32,83),\n", - " time='2021-01',\n", - " esgf_params=esgf_params,\n", + "esgf_params = {\r\n", + " 'data_node': 'esgf-cnr.hpc.cineca.it',\r\n", + " 'source_id': 'EC-Earth3',\r\n", + " 'variant_label':'r4i1p1f1',\r\n", + " 'experiment_id': 'ssp126',\r\n", + " 'project' : 'CMIP6',\r\n", + " 'frequency':'3hr'\r\n", + "}\r\n", + "\r\n", + "cutout_cmip = atlite.Cutout(path='cmip_europe_2031.nc',module=['cmip'],\r\n", + " x=slice(-13,45),\r\n", + " y=slice(32,83),\r\n", + " time='2031-01',\r\n", + " esgf_params=esgf_params,\r\n", " dt='3H',dx=1, dy=1)" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "e8f45edf-38e0-46b6-9695-588522ec36fe", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\r\n", + "import pandas as pd\r\n", + "ds = xr.Dataset(\r\n", + " {\r\n", + " \"x\": np.round(np.arange(-180, 180, 1), 9),\r\n", + " \"y\": np.round(np.arange(-90, 90, 1), 9),\r\n", + " \"time\": pd.date_range(start='2015', end='2100', freq=dt),\r\n", + " }\r\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "Python 3.8.10 | packaged by conda-forge | (default, May 11 2021, 07:01:05) \n", - "Type 'copyright', 'credits' or 'license' for more information\n", - "IPython 7.25.0 -- An enhanced Interactive Python. Type '?' for help.\n", - "\n", - "Out[1]: \n", - "[Delayed('get_data-73bbfd02-d114-4cfa-95fb-c65f88da4ba7'),\n", - " Delayed('get_data-7b05ec5f-c770-4a59-a6c4-e8531d79a371'),\n", - " Delayed('get_data-d93baf5c-a436-4a99-b9d4-db28cd4d0635'),\n", - " Delayed('get_data-6ce844cf-ff14-4745-8594-9e7d6e3cf9ba')]\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "---------------------------------------------------------------------------\n", - "KeyError Traceback (most recent call last)\n", - "~/atlite/atlite/data.py in \n", - "----> 1 datasets = compute(*datasets)\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/base.py in compute(*args, **kwargs)\n", - " 563 postcomputes.append(x.__dask_postcompute__())\n", - " 564 \n", - "--> 565 results = schedule(dsk, keys, **kwargs)\n", - " 566 return repack([f(r, *a) for r, (f, a) in zip(results, postcomputes)])\n", - " 567 \n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/threaded.py in get(dsk, result, cache, num_workers, pool, **kwargs)\n", - " 74 pools[thread][num_workers] = pool\n", - " 75 \n", - "---> 76 results = get_async(\n", - " 77 pool.apply_async,\n", - " 78 len(pool._pool),\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in get_async(apply_async, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, **kwargs)\n", - " 485 _execute_task(task, data) # Re-execute locally\n", - " 486 else:\n", - "--> 487 raise_exception(exc, tb)\n", - " 488 res, worker_id = loads(res_info)\n", - " 489 state[\"cache\"][key] = res\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in reraise(exc, tb)\n", - " 315 if exc.__traceback__ is not tb:\n", - " 316 raise exc.with_traceback(tb)\n", - "--> 317 raise exc\n", - " 318 \n", - " 319 \n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in execute_task(key, task_info, dumps, loads, get_id, pack_exception)\n", - " 220 try:\n", - " 221 task, data = loads(task_info)\n", - "--> 222 result = _execute_task(task, data)\n", - " 223 id = get_id()\n", - " 224 result = dumps((result, id))\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/core.py in _execute_task(arg, cache, dsk)\n", - " 119 # temporaries by their reference count and can execute certain\n", - " 120 # operations in-place.\n", - "--> 121 return func(*(_execute_task(a, cache) for a in args))\n", - " 122 elif not ishashable(arg):\n", - " 123 return arg\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/utils.py in apply(func, args, kwargs)\n", - " 33 def apply(func, args, kwargs=None):\n", - " 34 if kwargs:\n", - "---> 35 return func(*args, **kwargs)\n", - " 36 else:\n", - " 37 return func(*args)\n", - "\n", - "~/atlite/atlite/datasets/cmip.py in get_data(cutout, feature, tmpdir, lock, **creation_parameters)\n", - " 236 \n", - " 237 ds = func(esgf_params, cutout, **retrieval_params)\n", - "--> 238 ds = ds.sel(time=coords[\"time\"])\n", - " 239 bounds = cutout.bounds\n", - " 240 ds = ds.sel(x=slice(bounds[0], bounds[2]), y=slice(bounds[1], bounds[3]))\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/dataset.py in sel(self, indexers, method, tolerance, drop, **indexers_kwargs)\n", - " 2363 \"\"\"\n", - " 2364 indexers = either_dict_or_kwargs(indexers, indexers_kwargs, \"sel\")\n", - "-> 2365 pos_indexers, new_indexes = remap_label_indexers(\n", - " 2366 self, indexers=indexers, method=method, tolerance=tolerance\n", - " 2367 )\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/coordinates.py in remap_label_indexers(obj, indexers, method, tolerance, **indexers_kwargs)\n", - " 419 }\n", - " 420 \n", - "--> 421 pos_indexers, new_indexes = indexing.remap_label_indexers(\n", - " 422 obj, v_indexers, method=method, tolerance=tolerance\n", - " 423 )\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in remap_label_indexers(data_obj, indexers, method, tolerance)\n", - " 272 coords_dtype = data_obj.coords[dim].dtype\n", - " 273 label = maybe_cast_to_coords_dtype(label, coords_dtype)\n", - "--> 274 idxr, new_idx = convert_label_indexer(index, label, dim, method, tolerance)\n", - " 275 pos_indexers[dim] = idxr\n", - " 276 if new_idx is not None:\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in convert_label_indexer(index, label, index_name, method, tolerance)\n", - " 200 indexer = get_indexer_nd(index, label, method, tolerance)\n", - " 201 if np.any(indexer < 0):\n", - "--> 202 raise KeyError(f\"not all values found in index {index_name!r}\")\n", - " 203 \n", - " 204 if new_index is not None:\n", - "\n", - "KeyError: \"not all values found in index 'time'\"\n", - "\n", - "---------------------------------------------------------------------------\n", - "KeyError Traceback (most recent call last)\n", - "~/atlite/atlite/data.py in \n", - "----> 1 datasets = compute(datasets[0])\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/base.py in compute(*args, **kwargs)\n", - " 563 postcomputes.append(x.__dask_postcompute__())\n", - " 564 \n", - "--> 565 results = schedule(dsk, keys, **kwargs)\n", - " 566 return repack([f(r, *a) for r, (f, a) in zip(results, postcomputes)])\n", - " 567 \n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/threaded.py in get(dsk, result, cache, num_workers, pool, **kwargs)\n", - " 74 pools[thread][num_workers] = pool\n", - " 75 \n", - "---> 76 results = get_async(\n", - " 77 pool.apply_async,\n", - " 78 len(pool._pool),\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in get_async(apply_async, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, **kwargs)\n", - " 485 _execute_task(task, data) # Re-execute locally\n", - " 486 else:\n", - "--> 487 raise_exception(exc, tb)\n", - " 488 res, worker_id = loads(res_info)\n", - " 489 state[\"cache\"][key] = res\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in reraise(exc, tb)\n", - " 315 if exc.__traceback__ is not tb:\n", - " 316 raise exc.with_traceback(tb)\n", - "--> 317 raise exc\n", - " 318 \n", - " 319 \n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py in execute_task(key, task_info, dumps, loads, get_id, pack_exception)\n", - " 220 try:\n", - " 221 task, data = loads(task_info)\n", - "--> 222 result = _execute_task(task, data)\n", - " 223 id = get_id()\n", - " 224 result = dumps((result, id))\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/core.py in _execute_task(arg, cache, dsk)\n", - " 119 # temporaries by their reference count and can execute certain\n", - " 120 # operations in-place.\n", - "--> 121 return func(*(_execute_task(a, cache) for a in args))\n", - " 122 elif not ishashable(arg):\n", - " 123 return arg\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/utils.py in apply(func, args, kwargs)\n", - " 33 def apply(func, args, kwargs=None):\n", - " 34 if kwargs:\n", - "---> 35 return func(*args, **kwargs)\n", - " 36 else:\n", - " 37 return func(*args)\n", - "\n", - "~/atlite/atlite/datasets/cmip.py in get_data(cutout, feature, tmpdir, lock, **creation_parameters)\n", - " 236 \n", - " 237 ds = func(esgf_params, cutout, **retrieval_params)\n", - "--> 238 ds = ds.sel(time=coords[\"time\"])\n", - " 239 bounds = cutout.bounds\n", - " 240 ds = ds.sel(x=slice(bounds[0], bounds[2]), y=slice(bounds[1], bounds[3]))\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/dataset.py in sel(self, indexers, method, tolerance, drop, **indexers_kwargs)\n", - " 2363 \"\"\"\n", - " 2364 indexers = either_dict_or_kwargs(indexers, indexers_kwargs, \"sel\")\n", - "-> 2365 pos_indexers, new_indexes = remap_label_indexers(\n", - " 2366 self, indexers=indexers, method=method, tolerance=tolerance\n", - " 2367 )\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/coordinates.py in remap_label_indexers(obj, indexers, method, tolerance, **indexers_kwargs)\n", - " 419 }\n", - " 420 \n", - "--> 421 pos_indexers, new_indexes = indexing.remap_label_indexers(\n", - " 422 obj, v_indexers, method=method, tolerance=tolerance\n", - " 423 )\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in remap_label_indexers(data_obj, indexers, method, tolerance)\n", - " 272 coords_dtype = data_obj.coords[dim].dtype\n", - " 273 label = maybe_cast_to_coords_dtype(label, coords_dtype)\n", - "--> 274 idxr, new_idx = convert_label_indexer(index, label, dim, method, tolerance)\n", - " 275 pos_indexers[dim] = idxr\n", - " 276 if new_idx is not None:\n", - "\n", - "~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py in convert_label_indexer(index, label, index_name, method, tolerance)\n", - " 200 indexer = get_indexer_nd(index, label, method, tolerance)\n", - " 201 if np.any(indexer < 0):\n", - "--> 202 raise KeyError(f\"not all values found in index {index_name!r}\")\n", - " 203 \n", - " 204 if new_index is not None:\n", - "\n", - "KeyError: \"not all values found in index 'time'\"\n", - "\n", - "\n" + "[########################################] | 100% Completed | 53.6s\n" ] }, { - "output_type": "error", - "ename": "KeyError", - "evalue": "\"not all values found in index 'time'\"", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcutout_cmip\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprepare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/atlite/atlite/data.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"tmpdir\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmkdtemp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 111\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0mrmtree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"tmpdir\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/atlite/atlite/data.py\u001b[0m in \u001b[0;36mcutout_prepare\u001b[0;34m(cutout, features, tmpdir, overwrite)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Calculating and writing with module {module}:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0mmissing_features\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmissing_vars\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munique\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"feature\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_features\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcutout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmissing_features\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtmpdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtmpdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0mprepared\u001b[0m \u001b[0;34m|=\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmissing_features\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/atlite/atlite/data.py\u001b[0m in \u001b[0;36mget_features\u001b[0;34m(cutout, module, features, tmpdir)\u001b[0m\n\u001b[1;32m 45\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeature_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mIPython\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mIPython\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0membed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0mdatasets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdatasets\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mxr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmerge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompat\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"equals\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0;31m# for v in ds:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/base.py\u001b[0m in \u001b[0;36mcompute\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 563\u001b[0m \u001b[0mpostcomputes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dask_postcompute__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 564\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdsk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 566\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrepack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpostcomputes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/threaded.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(dsk, result, cache, num_workers, pool, **kwargs)\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0mpools\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mthread\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnum_workers\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 76\u001b[0;31m results = get_async(\n\u001b[0m\u001b[1;32m 77\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_async\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pool\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py\u001b[0m in \u001b[0;36mget_async\u001b[0;34m(apply_async, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, **kwargs)\u001b[0m\n\u001b[1;32m 485\u001b[0m \u001b[0m_execute_task\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Re-execute locally\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 486\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 487\u001b[0;31m \u001b[0mraise_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 488\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mworker_id\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres_info\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 489\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"cache\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py\u001b[0m in \u001b[0;36mreraise\u001b[0;34m(exc, tb)\u001b[0m\n\u001b[1;32m 315\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 317\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 318\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 319\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/local.py\u001b[0m in \u001b[0;36mexecute_task\u001b[0;34m(key, task_info, dumps, loads, get_id, pack_exception)\u001b[0m\n\u001b[1;32m 220\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtask_info\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 222\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_execute_task\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 223\u001b[0m \u001b[0mid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_id\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdumps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/core.py\u001b[0m in \u001b[0;36m_execute_task\u001b[0;34m(arg, cache, dsk)\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;31m# temporaries by their reference count and can execute certain\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;31m# operations in-place.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 121\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_execute_task\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 122\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mishashable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/dask/utils.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(func, args, kwargs)\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 36\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/atlite/atlite/datasets/cmip.py\u001b[0m in \u001b[0;36mget_data\u001b[0;34m(cutout, feature, tmpdir, lock, **creation_parameters)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mesgf_params\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcutout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mretrieval_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcoords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"time\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0mbounds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcutout\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/dataset.py\u001b[0m in \u001b[0;36msel\u001b[0;34m(self, indexers, method, tolerance, drop, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 2363\u001b[0m \"\"\"\n\u001b[1;32m 2364\u001b[0m \u001b[0mindexers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0meither_dict_or_kwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindexers_kwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"sel\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2365\u001b[0;31m pos_indexers, new_indexes = remap_label_indexers(\n\u001b[0m\u001b[1;32m 2366\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mindexers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2367\u001b[0m )\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/coordinates.py\u001b[0m in \u001b[0;36mremap_label_indexers\u001b[0;34m(obj, indexers, method, tolerance, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 419\u001b[0m }\n\u001b[1;32m 420\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 421\u001b[0;31m pos_indexers, new_indexes = indexing.remap_label_indexers(\n\u001b[0m\u001b[1;32m 422\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_indexers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 423\u001b[0m )\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py\u001b[0m in \u001b[0;36mremap_label_indexers\u001b[0;34m(data_obj, indexers, method, tolerance)\u001b[0m\n\u001b[1;32m 272\u001b[0m \u001b[0mcoords_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmaybe_cast_to_coords_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcoords_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 274\u001b[0;31m \u001b[0midxr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconvert_label_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 275\u001b[0m \u001b[0mpos_indexers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0midxr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnew_idx\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/atlite_dev/lib/python3.8/site-packages/xarray/core/indexing.py\u001b[0m in \u001b[0;36mconvert_label_indexer\u001b[0;34m(index, label, index_name, method, tolerance)\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_indexer_nd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 201\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 202\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"not all values found in index {index_name!r}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 203\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnew_index\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: \"not all values found in index 'time'\"" - ] + "data": { + "text/plain": [ + "\n", + " x = -13.00 ⟷ 45.00, dx = 1.00\n", + " y = 32.00 ⟷ 83.00, dy = 1.00\n", + " time = 2021-01-01 ⟷ 2021-01-31, dt = 3H\n", + " module = cmip\n", + " prepared_features = ['wind', 'influx', 'temperature', 'runoff']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -350,7 +189,6 @@ { "cell_type": "code", "execution_count": 6, - "id": "1e7d9a8c-2919-49ca-a389-db0b3e4d2371", "metadata": {}, "outputs": [ { @@ -710,8 +548,8 @@ "
<xarray.Dataset>\n",
        "Dimensions:      (time: 248, x: 59, y: 52)\n",
        "Coordinates:\n",
-       "  * x            (x) int64 -13 -12 -11 -10 -9 -8 -7 -6 ... 39 40 41 42 43 44 45\n",
-       "  * y            (y) int64 32 33 34 35 36 37 38 39 ... 76 77 78 79 80 81 82 83\n",
+       "  * x            (x) int32 -13 -12 -11 -10 -9 -8 -7 -6 ... 39 40 41 42 43 44 45\n",
+       "  * y            (y) int32 32 33 34 35 36 37 38 39 ... 76 77 78 79 80 81 82 83\n",
        "  * time         (time) datetime64[ns] 2021-01-01 ... 2021-01-31T21:00:00\n",
        "    lon          (x) float64 dask.array<chunksize=(59,), meta=np.ndarray>\n",
        "    lat          (y) float64 dask.array<chunksize=(52,), meta=np.ndarray>\n",
@@ -721,29 +559,29 @@
        "    outflux      (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
        "    temperature  (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
        "    runoff       (time, y, x) float32 dask.array<chunksize=(100, 52, 59), meta=np.ndarray>\n",
-       "Attributes: (12/56)\n",
+       "Attributes: (12/55)\n",
        "    module:                          cmip\n",
-       "    prepared_features:               ['runoff', 'temperature', 'wind', 'influx']\n",
+       "    prepared_features:               ['influx', 'wind', 'runoff', 'temperature']\n",
        "    chunksize_time:                  100\n",
-       "    model:                           EC-Earth3\n",
        "    dt:                              3H\n",
        "    dx:                              1\n",
+       "    dy:                              1\n",
        "    ...                              ...\n",
        "    tracking_id:                     hdl:21.14100/c38fc6f8-7b95-4a22-a21d-a01...\n",
        "    history:                         2019-08-05T08:01:37Z ; CMOR rewrote data...\n",
        "    DODS_EXTRA.Unlimited_Dimension:  time\n",
        "    data_node:                       esgf-cnr.hpc.cineca.it\n",
        "    project:                         CMIP6\n",
-       "    variable:                        sfcWind