From 16d9ecff6421d95d4a256d5bdbfa7168941e71ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 11:58:39 -0400 Subject: [PATCH 001/105] PASSED: test_base.py --- pyproject.toml | 31 +- src/xsdba/__init__.py | 20 + src/xsdba/base.py | 688 +++++++++++++++++++++++++++ src/xsdba/nbutils.py | 425 +++++++++++++++++ src/xsdba/options.py | 230 +++++++++ src/xsdba/testing.py | 248 ++++++++++ src/xsdba/utils.py | 1044 +++++++++++++++++++++++++++++++++++++++++ tests/conftest.py | 303 ++++++++++++ tests/test_base.py | 242 ++++++++++ 9 files changed, 3228 insertions(+), 3 deletions(-) create mode 100644 src/xsdba/base.py create mode 100644 src/xsdba/nbutils.py create mode 100644 src/xsdba/options.py create mode 100644 src/xsdba/testing.py create mode 100644 src/xsdba/utils.py create mode 100644 tests/conftest.py create mode 100644 tests/test_base.py diff --git a/pyproject.toml b/pyproject.toml index 8d2ba64..c2e58f8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,3 +1,5 @@ +# SPLIT: many checks removed + [build-system] requires = ["flit_core >=3.9,<4"] build-backend = "flit_core.buildapi" @@ -67,7 +69,13 @@ docs = [ "pandoc", "ipython", "ipykernel", - "jupyter_client" + "jupyter_client", + # ADD + "sphinx-autobuild >=2024.4.16", + "sphinx-autodoc-typehints", + "sphinx-mdinclude", + "sphinxcontrib-bibtex", + "sphinxcontrib-svg2pdfconverter[Cairosvg]" ] all = ["xsdba[dev]", "xsdba[docs]"] @@ -227,9 +235,18 @@ ignore_missing_imports = true [tool.numpydoc_validation] checks = [ "all", # report on all checks, except the below + "ES01", "EX01", + "GL01", + "GL08", + "PR01", + "PR08", + "RT01", + "RT03", "SA01", - "ES01" + "SA04", + "SS03", + "SS06" ] # remember to use single quotes for regex in TOML exclude = [ @@ -277,7 +294,15 @@ ignore = [ "COM", # commas "D205", # blank-line-after-summary "D400", # ends-in-period - "D401" # non-imperative-mood + "D401", # non-imperative-mood + # WIP xsdba + "D200", + "FLY002", + "N801", + "N803", + "N806", + "PTH123", + "S310" ] preview = true select = [ diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 453dc9d..10e0d80 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -18,6 +18,26 @@ # limitations under the License. ################################################################################### +from __future__ import annotations + +from . import base, utils + +# , adjustment +# from . import adjustment, base, detrending, measures, processing, properties, utils +# from .adjustment import * +from .base import Grouper +from .options import set_options + +# from .processing import stack_variables, unstack_variables + +# TODO: ISIMIP ? Used for precip freq adjustment in biasCorrection.R +# Hempel, S., Frieler, K., Warszawski, L., Schewe, J., & Piontek, F. (2013). A trend-preserving bias correction – +# The ISI-MIP approach. Earth System Dynamics, 4(2), 219–236. https://doi.org/10.5194/esd-4-219-2013 +# If SBCK is installed, create adjustment classes wrapping SBCK's algorithms. +# if hasattr(adjustment, "_generate_SBCK_classes"): +# for cls in adjustment._generate_SBCK_classes(): +# adjustment.__dict__[cls.__name__] = cls + __author__ = """Trevor James Smith""" __email__ = "smith.trevorj@ouranos.ca" __version__ = "0.1.0" diff --git a/src/xsdba/base.py b/src/xsdba/base.py new file mode 100644 index 0000000..8b254d1 --- /dev/null +++ b/src/xsdba/base.py @@ -0,0 +1,688 @@ +""" +Base Classes and Developer Tools +================================ +""" + +from __future__ import annotations + +from collections.abc import Sequence +from inspect import _empty, signature # noqa +from typing import Callable + +import dask.array as dsk +import jsonpickle +import numpy as np +import xarray as xr +from boltons.funcutils import wraps +from xclim.core.calendar import get_calendar +from xclim.core.options import OPTIONS, SDBA_ENCODE_CF +from xclim.core.utils import uses_dask + + +# ## Base class for the sdba module +class Parametrizable(dict): + """Helper base class resembling a dictionary. + + This object is _completely_ defined by the content of its internal dictionary, accessible through item access + (`self['attr']`) or in `self.parameters`. When serializing and restoring this object, only members of that internal + dict are preserved. All other attributes set directly with `self.attr = value` will not be preserved upon + serialization and restoration of the object with `[json]pickle` dictionary. Other variables set with + `self.var = data` will be lost in the serialization process. + This class is best serialized and restored with `jsonpickle`. + """ + + _repr_hide_params = [] + + def __getstate__(self): + """For (json)pickle, a Parametrizable should be defined by its internal dict only.""" + return self.parameters + + def __setstate__(self, state): + """For (json)pickle, a Parametrizable in only defined by its internal dict.""" + self.update(state) + + def __getattr__(self, attr): + """Get attributes.""" + try: + return self.__getitem__(attr) + except KeyError as err: + # Raise the proper error type for getattr + raise AttributeError(*err.args) from err + + @property + def parameters(self) -> dict: + """All parameters as a dictionary. Read-only.""" + return dict(**self) + + def __repr__(self) -> str: + """Return a string representation.""" + # Get default values from the init signature + defaults = { + # A default value of None could mean an empty mutable object + n: [p.default] if p.default is not None else [[], {}, set(), None] + for n, p in signature(self.__init__).parameters.items() + if p.default is not _empty + } + # The representation only includes the parameters with a value different from their default + # and those not explicitly excluded. + params = ", ".join([f"{k}={v!r}" for k, v in self.items() if k not in self._repr_hide_params and v not in defaults.get(k, [])]) + return f"{self.__class__.__name__}({params})" + + +class ParametrizableWithDataset(Parametrizable): + """Parametrizable class that also has a `ds` attribute storing a dataset.""" + + _attribute = "_xclim_parameters" + + @classmethod + def from_dataset(cls, ds: xr.Dataset): + """Create an instance from a dataset. + + The dataset must have a global attribute with a name corresponding to `cls._attribute`, + and that attribute must be the result of `jsonpickle.encode(object)` where object is + of the same type as this object. + """ + obj = jsonpickle.decode(ds.attrs[cls._attribute]) # noqa: S301 + obj.set_dataset(ds) + return obj + + def set_dataset(self, ds: xr.Dataset) -> None: + """Store an xarray dataset in the `ds` attribute. + + Useful with custom object initialization or if some external processing was performed. + """ + self.ds = ds + self.ds.attrs[self._attribute] = jsonpickle.encode(self) + + +class Grouper(Parametrizable): + """Grouper inherited class for parameterizable classes.""" + + _repr_hide_params = ["dim", "prop"] # For a concise repr + # Two constants for use of `map_blocks` and `map_groups`. + # They provide better code readability, nothing more + PROP = "" + DIM = "" + ADD_DIMS = "" + + def __init__( + self, + group: str, + window: int = 1, + add_dims: Sequence[str] | set[str] | None = None, + ): + """Create the Grouper object. + + Parameters + ---------- + group : str + The usual grouping name as xarray understands it. Ex: "time.month" or "time". + The dimension name before the dot is the "main dimension" stored in `Grouper.dim` and + the property name after is stored in `Grouper.prop`. + window : int + If larger than 1, a centered rolling window along the main dimension is created when grouping data. + Units are the sampling frequency of the data along the main dimension. + add_dims : Optional[Union[Sequence[str], str]] + Additional dimensions that should be reduced in grouping operations. This behaviour is also controlled + by the `main_only` parameter of the `apply` method. If any of these dimensions are absent from the + DataArrays, they will be omitted. + """ + if "." in group: + dim, prop = group.split(".") + else: + dim, prop = group, "group" + + if isinstance(add_dims, str): + add_dims = [add_dims] + + add_dims = add_dims or [] + super().__init__( + dim=dim, + add_dims=add_dims, + prop=prop, + name=group, + window=window, + ) + + @classmethod + def from_kwargs(cls, **kwargs) -> dict[str, Grouper]: + """Parameterize groups using kwargs.""" + kwargs["group"] = cls( + group=kwargs.pop("group"), + window=kwargs.pop("window", 1), + add_dims=kwargs.pop("add_dims", []), + ) + return kwargs + + @property + def freq(self): + """Format a frequency string corresponding to the group. + + For use with xarray's resampling functions. + """ + return { + "group": "YS", + "season": "QS-DEC", + "month": "MS", + "week": "W", + "dayofyear": "D", + }.get(self.prop, None) + + @property + def prop_name(self): + """Create a significant name for the grouping.""" + return "year" if self.prop == "group" else self.prop + + def get_coordinate(self, ds: xr.Dataset | None = None) -> xr.DataArray: + """Return the coordinate as in the output of group.apply. + + Currently, only implemented for groupings with prop == `month` or `dayofyear`. + For prop == `dayfofyear`, a ds (Dataset or DataArray) can be passed to infer + the max day of year from the available years and calendar. + """ + if self.prop == "month": + return xr.DataArray(np.arange(1, 13), dims=("month",), name="month") + if self.prop == "season": + return xr.DataArray(["DJF", "MAM", "JJA", "SON"], dims=("season",), name="season") + if self.prop == "dayofyear": + if ds is not None: + cal = get_calendar(ds, dim=self.dim) + mdoy = max(xr.coding.calendar_ops._days_in_year(yr, cal) for yr in np.unique(ds[self.dim].dt.year)) + else: + mdoy = 365 + return xr.DataArray(np.arange(1, mdoy + 1), dims="dayofyear", name="dayofyear") + if self.prop == "group": + return xr.DataArray([1], dims=("group",), name="group") + # TODO: woups what happens when there is no group? (prop is None) + raise NotImplementedError("No grouping found.") + + def group( + self, + da: xr.DataArray | xr.Dataset | None = None, + main_only: bool = False, + **das: xr.DataArray, + ) -> xr.core.groupby.GroupBy: # pylint: disable=no-member + """Return a xr.core.groupby.GroupBy object. + + More than one array can be combined to a dataset before grouping using the `das` kwargs. + A new `window` dimension is added if `self.window` is larger than 1. + If `Grouper.dim` is 'time', but 'prop' is None, the whole array is grouped together. + + When multiple arrays are passed, some of them can be grouped along the same group as self. + They are broadcast, merged to the grouping dataset and regrouped in the output. + """ + if das: + from .utils import broadcast # pylint: disable=cyclic-import + + if da is not None: + das[da.name] = da + + da = xr.Dataset(data_vars={name: das.pop(name) for name in list(das.keys()) if self.dim in das[name].dims}) + + # "Ungroup" the grouped arrays + da = da.assign({name: broadcast(var, da[self.dim], group=self, interp="nearest") for name, var in das.items()}) + + if not main_only and self.window > 1: + da = da.rolling(center=True, **{self.dim: self.window}).construct(window_dim="window") + if uses_dask(da): + # Rechunk. There might be padding chunks. + da = da.chunk({self.dim: -1}) + + if self.prop == "group": + group = self.get_index(da) + else: + group = self.name + + return da.groupby(group) + + def get_index( + self, + da: xr.DataArray | xr.Dataset, + interp: bool | None = None, + ) -> xr.DataArray: + """Return the group index of each element along the main dimension. + + Parameters + ---------- + da : xr.DataArray or xr.Dataset + The input array/dataset for which the group index is returned. + It must have `Grouper.dim` as a coordinate. + interp : bool, optional + If True, the returned index can be used for interpolation. Only value for month + grouping, where integer values represent the middle of the month, all other + days are linearly interpolated in between. + + Returns + ------- + xr.DataArray + The index of each element along `Grouper.dim`. + If `Grouper.dim` is `time` and `Grouper.prop` is None, a uniform array of True is returned. + If `Grouper.prop` is a time accessor (month, dayofyear, etc.), a numerical array is returned, + with a special case of `month` and `interp=True`. + If `Grouper.dim` is not `time`, the dim is simply returned. + """ + if self.prop == "group": + if self.dim == "time": + return xr.full_like(da[self.dim], 1, dtype=int).rename("group") + return da[self.dim].rename("group") + + ind = da.indexes[self.dim] + if self.prop == "week": + i = da[self.dim].copy(data=ind.isocalendar().week).astype(int) + elif self.prop == "season": + i = da[self.dim].copy(data=ind.month % 12 // 3) + else: + i = getattr(ind, self.prop) + + if not np.issubdtype(i.dtype, np.integer): + raise ValueError(f"Index {self.name} is not of type int (rather {i.dtype}), " f"but {self.__class__.__name__} requires integer indexes.") + + if interp and self.dim == "time" and self.prop == "month": + i = ind.month - 0.5 + ind.day / ind.days_in_month + + xi = xr.DataArray( + i, + dims=self.dim, + coords={self.dim: da.coords[self.dim]}, + name=self.dim + " group index", + ) + + # Expand dimensions of index to match the dimensions of da + # We want vectorized indexing with no broadcasting + # xi = xi.broadcast_like(da) + xi.name = self.prop + return xi + + def apply( + self, + func: Callable | str, + da: xr.DataArray | dict[str, xr.DataArray] | xr.Dataset, + main_only: bool = False, + **kwargs, + ) -> xr.DataArray | xr.Dataset: + r"""Apply a function group-wise on DataArrays. + + Parameters + ---------- + func : Callable or str + The function to apply to the groups, either a callable or a `xr.core.groupby.GroupBy` method name as a string. + The function will be called as `func(group, dim=dims, **kwargs)`. See `main_only` for the behaviour of `dims`. + da : xr.DataArray or dict[str, xr.DataArray] or xr.Dataset + The DataArray on which to apply the function. Multiple arrays can be passed through a dictionary. + A dataset will be created before grouping. + main_only : bool + Whether to call the function with the main dimension only (if True) or with all grouping dims + (if False, default) (including the window and dimensions given through `add_dims`). + The dimensions used are also written in the "group_compute_dims" attribute. + If all the input arrays are missing one of the 'add_dims', it is silently omitted. + \*\*kwargs + Other keyword arguments to pass to the function. + + Returns + ------- + xr.DataArray or xr.Dataset + Attributes "group", "group_window" and "group_compute_dims" are added. + + If the function did not reduce the array: + + - The output is sorted along the main dimension. + - The output is rechunked to match the chunks on the input + If multiple inputs with differing chunking were given as inputs, + the chunking with the smallest number of chunks is used. + + If the function reduces the array: + + - If there is only one group, the singleton dimension is squeezed out of the output + - The output is rechunked as to have only 1 chunk along the new dimension. + + + Notes + ----- + For the special case where a Dataset is returned, but only some of its variable where reduced by the grouping, + xarray's `GroupBy.map` will broadcast everything back to the ungrouped dimensions. To overcome this issue, + function may add a "_group_apply_reshape" attribute set to `True` on the variables that should be reduced and + these will be re-grouped by calling `da.groupby(self.name).first()`. + """ + if isinstance(da, (dict, xr.Dataset)): + grpd = self.group(main_only=main_only, **da) + dim_chunks = min( # Get smallest chunking to rechunk if the operation is non-grouping + [d.chunks[d.get_axis_num(self.dim)] for d in da.values() if uses_dask(d) and self.dim in d.dims] + or [[]], # pass [[]] if no DataArrays have chunks so min doesn't fail + key=len, + ) + else: + grpd = self.group(da, main_only=main_only) + # Get chunking to rechunk is the operation is non-grouping + # To match the behaviour of the case above, an empty list signifies that dask is not used for the input. + dim_chunks = [] if not uses_dask(da) else da.chunks[da.get_axis_num(self.dim)] + + if main_only: + dims = self.dim + else: + dims = [self.dim] + self.add_dims + if self.window > 1: + dims += ["window"] + + if isinstance(func, str): + out = getattr(grpd, func)(dim=dims, **kwargs) + else: + out = grpd.map(func, dim=dims, **kwargs) + + # Case where the function wants to return more than one variable. + # and that some have grouped dims and other have the same dimensions as the input. + # In that specific case, groupby broadcasts everything back to the input's dim, copying the grouped data. + if isinstance(out, xr.Dataset): + for name, outvar in out.data_vars.items(): + if "_group_apply_reshape" in outvar.attrs: + out[name] = self.group(outvar, main_only=True).first(skipna=False, keep_attrs=True) + del out[name].attrs["_group_apply_reshape"] + + # Save input parameters as attributes of output DataArray. + out.attrs["group"] = self.name + out.attrs["group_compute_dims"] = dims + out.attrs["group_window"] = self.window + + # On non-reducing ops, drop the constructed window + if self.window > 1 and "window" in out.dims: + out = out.isel(window=self.window // 2, drop=True) + + # If the grouped operation did not reduce the array, the result is sometimes unsorted along dim + if self.dim in out.dims: + out = out.sortby(self.dim) + # The expected behavior for downstream methods would be to conserve chunking along dim + if uses_dask(out): + # or -1 in case dim_chunks is [], when no input is chunked + # (only happens if the operation is chunking the output) + out = out.chunk({self.dim: dim_chunks or -1}) + if self.prop == "season" and self.prop in out.coords: + # Special case for "DIM.season", it is often returned in alphabetical order, + # but that doesn't fit the coord given in get_coordinate + out = out.sel(season=np.array(["DJF", "MAM", "JJA", "SON"])) + if self.prop in out.dims and uses_dask(out): + # Same as above : downstream methods expect only one chunk along the group + out = out.chunk({self.prop: -1}) + + return out + + +def parse_group(func: Callable, kwargs=None, allow_only=None) -> Callable: + """Parse the kwargs given to a function to set the `group` arg with a Grouper object. + + This function can be used as a decorator, in which case the parsing and updating of the kwargs is done at call time. + It can also be called with a function from which extract the default group and kwargs to update, + in which case it returns the updated kwargs. + + If `allow_only` is given, an exception is raised when the parsed group is not within that list. + """ + sig = signature(func) + if "group" in sig.parameters: + default_group = sig.parameters["group"].default + else: + default_group = None + + def _update_kwargs(_kwargs, allowed=None): + if default_group or "group" in _kwargs: + _kwargs.setdefault("group", default_group) + if not isinstance(_kwargs["group"], Grouper): + _kwargs = Grouper.from_kwargs(**_kwargs) + if allowed is not None and "group" in _kwargs and _kwargs["group"].prop not in allowed: + raise ValueError(f"Grouping on {_kwargs['group'].prop_name} is not allowed for this " f"function. Should be one of {allowed}.") + return _kwargs + + if kwargs is not None: # Not used as a decorator + return _update_kwargs(kwargs, allowed=allow_only) + + # else (then it's a decorator) + @wraps(func) + def _parse_group(*f_args, **f_kwargs): + f_kwargs = _update_kwargs(f_kwargs, allowed=allow_only) + return func(*f_args, **f_kwargs) + + return _parse_group + + +def duck_empty(dims: xr.DataArray.dims, sizes, dtype="float64", chunks=None) -> xr.DataArray: + """Return an empty DataArray based on a numpy or dask backend, depending on the "chunks" argument.""" + shape = [sizes[dim] for dim in dims] + if chunks: + chnks = [chunks.get(dim, (sizes[dim],)) for dim in dims] + content = dsk.empty(shape, chunks=chnks, dtype=dtype) + else: + content = np.empty(shape, dtype=dtype) + return xr.DataArray(content, dims=dims) + + +def _decode_cf_coords(ds: xr.Dataset): + """Decode coords in-place.""" + crds = xr.decode_cf(ds.coords.to_dataset()) + for crdname in list(ds.coords.keys()): + ds[crdname] = crds[crdname] + # decode_cf introduces an encoding key for the dtype, which can confuse the netCDF writer + dtype = ds[crdname].encoding.get("dtype") + if np.issubdtype(dtype, np.timedelta64) or np.issubdtype(dtype, np.datetime64): + del ds[crdname].encoding["dtype"] + + +def map_blocks( # noqa: C901 + reduces: Sequence[str] | None = None, **out_vars +) -> Callable: + r"""Decorator for declaring functions and wrapping them into a map_blocks. + + Takes care of constructing the template dataset. Dimension order is not preserved. + The decorated function must always have the signature: ``func(ds, **kwargs)``, where ds is a DataArray or a Dataset. + It must always output a dataset matching the mapping passed to the decorator. + + Parameters + ---------- + reduces : sequence of strings + Name of the dimensions that are removed by the function. + \*\*out_vars + Mapping from variable names in the output to their *new* dimensions. + The placeholders ``Grouper.PROP``, ``Grouper.DIM`` and ``Grouper.ADD_DIMS`` can be used to signify + ``group.prop``,``group.dim`` and ``group.add_dims`` respectively. + If an output keeps a dimension that another loses, that dimension name must be given in ``reduces`` and in + the list of new dimensions of the first output. + """ + + def merge_dimensions(*seqs): + """Merge several dimensions lists while preserving order.""" + out = seqs[0].copy() + for seq in seqs[1:]: + last_index = 0 + for e in seq: + if e in out: + indx = out.index(e) + if indx < last_index: + raise ValueError("Dimensions order mismatch, lists are not mergeable.") + last_index = indx + else: + out.insert(last_index + 1, e) + return out + + # Ordered list of all added dimensions + out_dims = merge_dimensions(*out_vars.values()) + # List of dimensions reduced by the function. + red_dims = reduces or [] + + def _decorator(func): # noqa: C901 + # @wraps(func, hide_wrapped=True) + @parse_group + def _map_blocks(ds, **kwargs): # noqa: C901 + if isinstance(ds, xr.Dataset): + ds = ds.unify_chunks() + + # Get group if present + group = kwargs.get("group") + + # Ensure group is given as it might not be in the signature of the wrapped func + if {Grouper.PROP, Grouper.DIM, Grouper.ADD_DIMS}.intersection(out_dims + red_dims) and group is None: + raise ValueError("Missing required `group` argument.") + + # Make translation dict + if group is not None: + placeholders = { + Grouper.PROP: [group.prop], + Grouper.DIM: [group.dim], + Grouper.ADD_DIMS: group.add_dims, + } + else: + placeholders = {} + + # Get new dimensions (in order), translating placeholders to real names. + new_dims = [] + for dim in out_dims: + new_dims.extend(placeholders.get(dim, [dim])) + + reduced_dims = [] + for dim in red_dims: + reduced_dims.extend(placeholders.get(dim, [dim])) + + for dim in new_dims: + if dim in ds.dims and dim not in reduced_dims: + raise ValueError(f"Dimension {dim} is meant to be added by the " "computation but it is already on one of the inputs.") + if uses_dask(ds): + # Use dask if any of the input is dask-backed. + chunks = dict(ds.chunks) if isinstance(ds, xr.Dataset) else dict(zip(ds.dims, ds.chunks)) + badchunks = {} + if group is not None: + badchunks.update({dim: chunks.get(dim) for dim in group.add_dims + [group.dim] if len(chunks.get(dim, [])) > 1}) + badchunks.update({dim: chunks.get(dim) for dim in reduced_dims if len(chunks.get(dim, [])) > 1}) + if badchunks: + raise ValueError(f"The dimension(s) over which we group, reduce or interpolate cannot be chunked ({badchunks}).") + else: + chunks = None + + # Dimensions untouched by the function. + base_dims = list(set(ds.dims) - set(new_dims) - set(reduced_dims)) + + # All dimensions of the output data, new_dims are added at the end on purpose. + all_dims = base_dims + new_dims + # The coordinates of the output data. + added_coords = [] + coords = {} + sizes = {} + for dim in all_dims: + if dim == group.prop: + coords[group.prop] = group.get_coordinate(ds=ds) + elif dim == group.dim: + coords[group.dim] = ds[group.dim] + elif dim in kwargs: + coords[dim] = xr.DataArray(kwargs[dim], dims=(dim,), name=dim) + elif dim in ds.dims: + # If a dim has no coords : some sdba function will add them, so to be safe we add them right now + # and note them to remove them afterwards. + if dim not in ds.coords: + added_coords.append(dim) + ds[dim] = ds[dim] + coords[dim] = ds[dim] + else: + raise ValueError(f"This function adds the {dim} dimension, its coordinate must be provided as a keyword argument.") + sizes.update({name: crd.size for name, crd in coords.items()}) + + # Create the output dataset, but empty + tmpl = xr.Dataset(coords=coords) + if isinstance(ds, xr.Dataset): + # Get largest dtype of the inputs, assign it to the output. + dtype = max((da.dtype for da in ds.data_vars.values()), key=lambda d: d.itemsize) + else: + dtype = ds.dtype + + for var, dims in out_vars.items(): + var_new_dims = [] + for dim in dims: + var_new_dims.extend(placeholders.get(dim, [dim])) + # Out variables must have the base dims + new_dims + dims = base_dims + var_new_dims + # duck empty calls dask if chunks is not None + tmpl[var] = duck_empty(dims, sizes, dtype=dtype, chunks=chunks) + + if OPTIONS[SDBA_ENCODE_CF]: + ds = ds.copy() + # Optimization to circumvent the slow pickle.dumps(cftime_array) + # List of the keys to avoid changing the coords dict while iterating over it. + for crd in list(ds.coords.keys()): + if xr.core.common._contains_cftime_datetimes(ds[crd].variable): # noqa + ds[crd] = xr.conventions.encode_cf_variable(ds[crd].variable) + + def _call_and_transpose_on_exit(dsblock, **f_kwargs): + """Call the decorated func and transpose to ensure the same dim order as on the template.""" + try: + _decode_cf_coords(dsblock) + func_out = func(dsblock, **f_kwargs).transpose(*all_dims) + except Exception as err: + raise ValueError(f"{func.__name__} failed on block with coords : {dsblock.coords}.") from err + return func_out + + # Fancy patching for explicit dask task names + _call_and_transpose_on_exit.__name__ = f"block_{func.__name__}" + + # Remove all auxiliary coords on both tmpl and ds + extra_coords = {name: crd for name, crd in ds.coords.items() if name not in crd.dims} + ds = ds.drop_vars(extra_coords.keys()) + # Coords not sharing dims with `all_dims` (like scalar aux coord on reduced 1D input) are absent from tmpl + tmpl = tmpl.drop_vars(extra_coords.keys(), errors="ignore") + + # Call + out = ds.map_blocks(_call_and_transpose_on_exit, template=tmpl, kwargs=kwargs) + # Add back the extra coords, but only those which have compatible dimensions (like xarray would have done) + out = out.assign_coords({name: crd for name, crd in extra_coords.items() if set(crd.dims).issubset(out.dims)}) + + # Finally remove coords we added... 'ignore' in case they were already removed. + out = out.drop_vars(added_coords, errors="ignore") + return out + + _map_blocks.__dict__["func"] = func + return _map_blocks + + return _decorator + + +def map_groups(reduces: Sequence[str] | None = None, main_only: bool = False, **out_vars) -> Callable: + r"""Decorator for declaring functions acting only on groups and wrapping them into a map_blocks. + + This is the same as `map_blocks` but adds a call to `group.apply()` in the mapped func and the default + value of `reduces` is changed. + + The decorated function must have the signature: ``func(ds, dim, **kwargs)``. + Where ds is a DataAray or Dataset, dim is the `group.dim` (and add_dims). The `group` argument + is stripped from the kwargs, but must evidently be provided in the call. + + Parameters + ---------- + reduces : sequence of str, optional + Dimensions that are removed from the inputs by the function. Defaults to [Grouper.DIM, Grouper.ADD_DIMS] + if main_only is False, and [Grouper.DIM] if main_only is True. See :py:func:`map_blocks`. + main_only : bool + Same as for :py:meth:`Grouper.apply`. + \*\*out_vars + Mapping from variable names in the output to their *new* dimensions. + The placeholders ``Grouper.PROP``, ``Grouper.DIM`` and ``Grouper.ADD_DIMS`` can be used to signify + ``group.prop``,``group.dim`` and ``group.add_dims``, respectively. + If an output keeps a dimension that another loses, that dimension name must be given in `reduces` and in + the list of new dimensions of the first output. + + See Also + -------- + map_blocks + """ + def_reduces = [Grouper.DIM] + if not main_only: + def_reduces.append(Grouper.ADD_DIMS) + reduces = reduces or def_reduces + + def _decorator(func): + decorator = map_blocks(reduces=reduces, **out_vars) + + def _apply_on_group(dsblock, **kwargs): + group = kwargs.pop("group") + return group.apply(func, dsblock, main_only=main_only, **kwargs) + + # Fancy patching for explicit dask task names + _apply_on_group.__name__ = f"group_{func.__name__}" + + # wraps(func, injected=['dim'], hide_wrapped=True)( + wrapper = decorator(_apply_on_group) + wrapper.__dict__["func"] = func + return wrapper + + return _decorator diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py new file mode 100644 index 0000000..355fbdd --- /dev/null +++ b/src/xsdba/nbutils.py @@ -0,0 +1,425 @@ +# pylint: disable=no-value-for-parameter +""" +Numba-accelerated Utilities +=========================== +""" + +from __future__ import annotations + +from collections.abc import Hashable, Sequence + +import numpy as np +from numba import boolean, float32, float64, guvectorize, njit +from xarray import DataArray, apply_ufunc +from xarray.core import utils + +try: + from fastnanquantile.xrcompat import xr_apply_nanquantile + + USE_FASTNANQUANTILE = True +except ImportError: + USE_FASTNANQUANTILE = False + + +@njit( + fastmath={"arcp", "contract", "reassoc", "nsz", "afn"}, + nogil=True, + cache=False, +) +def _get_indexes(arr: np.array, virtual_indexes: np.array, valid_values_count: np.array) -> tuple[np.array, np.array]: + """Get the valid indexes of arr neighbouring virtual_indexes. + + Parameters + ---------- + arr : array-like + virtual_indexes : array-like + valid_values_count : array-like + + Returns + ------- + array-like, array-like + A tuple of virtual_indexes neighbouring indexes (previous and next) + + Notes + ----- + This is a companion function to linear interpolation of quantiles. + """ + previous_indexes = np.asarray(np.floor(virtual_indexes)) + next_indexes = np.asarray(previous_indexes + 1) + indexes_above_bounds = virtual_indexes >= valid_values_count - 1 + # When indexes is above max index, take the max value of the array + if indexes_above_bounds.any(): + previous_indexes[indexes_above_bounds] = -1 + next_indexes[indexes_above_bounds] = -1 + # When indexes is below min index, take the min value of the array + indexes_below_bounds = virtual_indexes < 0 + if indexes_below_bounds.any(): + previous_indexes[indexes_below_bounds] = 0 + next_indexes[indexes_below_bounds] = 0 + if (arr.dtype is np.dtype(np.float64)) or (arr.dtype is np.dtype(np.float32)): + # After the sort, slices having NaNs will have for last element a NaN + virtual_indexes_nans = np.isnan(virtual_indexes) + if virtual_indexes_nans.any(): + previous_indexes[virtual_indexes_nans] = -1 + next_indexes[virtual_indexes_nans] = -1 + previous_indexes = previous_indexes.astype(np.intp) + next_indexes = next_indexes.astype(np.intp) + return previous_indexes, next_indexes + + +@njit( + fastmath={"arcp", "contract", "reassoc", "nsz", "afn"}, + nogil=True, + cache=False, +) +def _linear_interpolation( + left: np.array, + right: np.array, + gamma: np.array, +) -> np.array: + """Compute the linear interpolation weighted by gamma on each point of two same shape arrays. + + Parameters + ---------- + left : array_like + Left bound. + right : array_like + Right bound. + gamma : array_like + The interpolation weight. + + Returns + ------- + array_like + + Notes + ----- + This is a companion function for `_nan_quantile_1d` + """ + diff_b_a = np.subtract(right, left) + lerp_interpolation = np.asarray(np.add(left, diff_b_a * gamma)) + ind = gamma >= 0.5 + lerp_interpolation[ind] = right[ind] - diff_b_a[ind] * (1 - gamma[ind]) + return lerp_interpolation + + +@njit( + fastmath={"arcp", "contract", "reassoc", "nsz", "afn"}, + nogil=True, + cache=False, +) +def _nan_quantile_1d( + arr: np.array, + quantiles: np.array, + alpha: float = 1.0, + beta: float = 1.0, +) -> float | np.array: + """Get the quantiles of the 1-dimensional array. + + A linear interpolation is performed using alpha and beta. + + Notes + ----- + By default, `alpha == beta == 1` which performs the 7th method of :cite:t:`hyndman_sample_1996`. + with `alpha == beta == 1/3` we get the 8th method. alpha == beta == 1 reproduces the behaviour of `np.nanquantile`. + """ + # We need at least two values to do an interpolation + valid_values_count = (~np.isnan(arr)).sum() + + # Computation of indexes + virtual_indexes = valid_values_count * quantiles + (alpha + quantiles * (1 - alpha - beta)) - 1 + virtual_indexes = np.asarray(virtual_indexes) + previous_indexes, next_indexes = _get_indexes(arr, virtual_indexes, valid_values_count) + # Sorting + arr.sort() + + previous = arr[previous_indexes] + next_elements = arr[next_indexes] + + # Linear interpolation + gamma = np.asarray(virtual_indexes - previous_indexes, dtype=arr.dtype) + interpolation = _linear_interpolation(previous, next_elements, gamma) + # When an interpolation is in Nan range, (near the end of the sorted array) it means + # we can clip to the array max value. + result = np.where(np.isnan(interpolation), arr[np.intp(valid_values_count) - 1], interpolation) + return result + + +@guvectorize( + [(float32[:], float32, float32[:]), (float64[:], float64, float64[:])], + "(n),()->()", + nopython=True, + cache=False, +) +def _vecquantiles(arr, rnk, res): + if np.isnan(rnk): + res[0] = np.NaN + else: + res[0] = np.nanquantile(arr, rnk) + + +def vecquantiles(da: DataArray, rnk: DataArray, dim: str | Sequence[Hashable]) -> DataArray: + """For when the quantile (rnk) is different for each point. + + da and rnk must share all dimensions but dim. + + Parameters + ---------- + da : xarray.DataArray + The data to compute the quantiles on. + rnk : xarray.DataArray + The quantiles to compute. + dim : str or sequence of str + The dimension along which to compute the quantiles. + + Returns + ------- + xarray.DataArray + The quantiles computed along the `dim` dimension. + """ + tem = utils.get_temp_dimname(da.dims, "temporal") + dims = [dim] if isinstance(dim, str) else dim + da = da.stack({tem: dims}) + da = da.transpose(*rnk.dims, tem) + + res = DataArray( + _vecquantiles(da.values, rnk.values), + dims=rnk.dims, + coords=rnk.coords, + attrs=da.attrs, + ) + return res + + +@njit +def _wrapper_quantile1d(arr, q): + out = np.empty((arr.shape[0], q.size), dtype=arr.dtype) + for index in range(out.shape[0]): + out[index] = _nan_quantile_1d(arr[index], q) + return out + + +def _quantile(arr, q, nreduce): + if arr.ndim == nreduce: + out = _nan_quantile_1d(arr.flatten(), q) + else: + # dimensions that are reduced by quantile + red_axis = np.arange(len(arr.shape) - nreduce, len(arr.shape)) + reduction_dim_size = np.prod([arr.shape[idx] for idx in red_axis]) + # kept dimensions + keep_axis = np.arange(len(arr.shape) - nreduce) + final_shape = [arr.shape[idx] for idx in keep_axis] + [len(q)] + # reshape as (keep_dims, red_dims), compute, reshape back + arr = arr.reshape(-1, reduction_dim_size) + out = _wrapper_quantile1d(arr, q) + out = out.reshape(final_shape) + return out + + +def quantile(da: DataArray, q: np.ndarray, dim: str | Sequence[Hashable]) -> DataArray: + """Compute the quantiles from a fixed list `q`. + + Parameters + ---------- + da : xarray.DataArray + The data to compute the quantiles on. + q : array-like + The quantiles to compute. + dim : str or sequence of str + The dimension along which to compute the quantiles. + + Returns + ------- + xarray.DataArray + The quantiles computed along the `dim` dimension. + """ + if USE_FASTNANQUANTILE is True: + return xr_apply_nanquantile(da, dim=dim, q=q).rename({"quantile": "quantiles"}) + else: + qc = np.array(q, dtype=da.dtype) + dims = [dim] if isinstance(dim, str) else dim + kwargs = dict(nreduce=len(dims), q=qc) + res = ( + apply_ufunc( + _quantile, + da, + input_core_dims=[dims], + exclude_dims=set(dims), + output_core_dims=[["quantiles"]], + output_dtypes=[da.dtype], + dask_gufunc_kwargs=dict(output_sizes={"quantiles": len(q)}), + dask="parallelized", + kwargs=kwargs, + ) + .assign_coords(quantiles=q) + .assign_attrs(da.attrs) + ) + return res + + +@njit( + [ + float32[:, :](float32[:, :]), + float64[:, :](float64[:, :]), + ], + fastmath=False, + nogil=True, + cache=False, +) +def remove_NaNs(x): # noqa + """Remove NaN values from series.""" + remove = np.zeros_like(x[0, :], dtype=boolean) + for i in range(x.shape[0]): + remove = remove | np.isnan(x[i, :]) + return x[:, ~remove] + + +@njit( + [ + float32(float32[:, :], float32[:, :]), + float64(float64[:, :], float64[:, :]), + ], + fastmath=True, + nogil=True, + cache=False, +) +def _correlation(X, Y): + """Compute a correlation as the mean of pairwise distances between points in X and Y. + + X is KxN and Y is KxM, the result is the mean of the MxN distances. + Similar to scipy.spatial.distance.cdist(X, Y, 'euclidean') + """ + d = 0 + for i in range(X.shape[1]): + for j in range(Y.shape[1]): + d1 = 0 + for k in range(X.shape[0]): + d1 += (X[k, i] - Y[k, j]) ** 2 + d += np.sqrt(d1) + return d / (X.shape[1] * Y.shape[1]) + + +@njit( + [ + float32(float32[:, :]), + float64(float64[:, :]), + ], + fastmath=True, + nogil=True, + cache=False, +) +def _autocorrelation(X): + """Mean of the NxN pairwise distances of points in X of shape KxN. + + Similar to scipy.spatial.distance.pdist(..., 'euclidean') + """ + d = 0 + for i in range(X.shape[1]): + for j in range(i): + d1 = 0 + for k in range(X.shape[0]): + d1 += (X[k, i] - X[k, j]) ** 2 + d += np.sqrt(d1) + return (2 * d) / X.shape[1] ** 2 + + +@guvectorize( + [ + (float32[:, :], float32[:, :], float32[:]), + (float64[:, :], float64[:, :], float64[:]), + ], + "(k, n),(k, m)->()", + nopython=True, + cache=False, +) +def _escore(tgt, sim, out): + """E-score based on the Székely-Rizzo e-distances between clusters. + + tgt and sim are KxN and KxM, where dimensions are along K and observations along M and N. + When N > 0, only this many points of target and sim are used, taken evenly distributed in the series. + When std is True, X and Y are standardized according to the nanmean and nanstd (ddof = 1) of X. + """ + sim = remove_NaNs(sim) + tgt = remove_NaNs(tgt) + + n1 = sim.shape[1] + n2 = tgt.shape[1] + + sXY = _correlation(tgt, sim) + sXX = _autocorrelation(tgt) + sYY = _autocorrelation(sim) + + w = n1 * n2 / (n1 + n2) + out[0] = w * (sXY + sXY - sXX - sYY) / 2 + + +@njit( + fastmath=False, + nogil=True, + cache=False, +) +def _first_and_last_nonnull(arr): + """For each row of arr, get the first and last non NaN elements.""" + out = np.empty((arr.shape[0], 2)) + for i in range(arr.shape[0]): + idxs = np.where(~np.isnan(arr[i]))[0] + if idxs.size > 0: + out[i] = arr[i][idxs[np.array([0, -1])]] + else: + out[i] = np.array([np.NaN, np.NaN]) + return out + + +@njit( + fastmath=False, + nogil=True, + cache=False, +) +def _extrapolate_on_quantiles(interp, oldx, oldg, oldy, newx, newg, method="constant"): # noqa + """Apply extrapolation to the output of interpolation on quantiles with a given grouping. + + Arguments are the same as _interp_on_quantiles_2D. + """ + bnds = _first_and_last_nonnull(oldx) + xp = np.arange(bnds.shape[0]) + toolow = newx < np.interp(newg, xp, bnds[:, 0]) + toohigh = newx > np.interp(newg, xp, bnds[:, 1]) + if method == "constant": + constants = _first_and_last_nonnull(oldy) + cnstlow = np.interp(newg, xp, constants[:, 0]) + cnsthigh = np.interp(newg, xp, constants[:, 1]) + interp[toolow] = cnstlow[toolow] + interp[toohigh] = cnsthigh[toohigh] + else: # 'nan' + interp[toolow] = np.NaN + interp[toohigh] = np.NaN + return interp + + +@njit( + fastmath=False, + nogil=True, + cache=False, +) +def _pairwise_haversine_and_bins(lond, latd, transpose=False): + """Inter-site distances with the haversine approximation.""" + N = lond.shape[0] + lon = np.deg2rad(lond) + lat = np.deg2rad(latd) + dists = np.full((N, N), np.nan) + for i in range(N - 1): + for j in range(i + 1, N): + dlon = lon[j] - lon[i] + dists[i, j] = 6367 * np.arctan2( + np.sqrt( + (np.cos(lat[j]) * np.sin(dlon)) ** 2 + (np.cos(lat[i]) * np.sin(lat[j]) - np.sin(lat[i]) * np.cos(lat[j]) * np.cos(dlon)) ** 2 + ), + np.sin(lat[i]) * np.sin(lat[j]) + np.cos(lat[i]) * np.cos(lat[j]) * np.cos(dlon), + ) + if transpose: + dists[j, i] = dists[i, j] + mn = np.nanmin(dists) + mx = np.nanmax(dists) + if transpose: + np.fill_diagonal(dists, 0) + return dists, mn, mx diff --git a/src/xsdba/options.py b/src/xsdba/options.py new file mode 100644 index 0000000..2c8e142 --- /dev/null +++ b/src/xsdba/options.py @@ -0,0 +1,230 @@ +""" +Global or contextual options for xsdba, similar to xarray.set_options. +""" + +# XC remove: metadata locales, do we need them? + +from __future__ import annotations + +from inspect import signature +from typing import Callable + +from boltons.funcutils import wraps + +# from .locales import _valid_locales # from XC, not reproduced for now +from .utils import ValidationError, raise_warn_or_log + +# METADATA_LOCALES = "metadata_locales" +DATA_VALIDATION = "data_validation" +CF_COMPLIANCE = "cf_compliance" +CHECK_MISSING = "check_missing" +MISSING_OPTIONS = "missing_options" +SDBA_EXTRA_OUTPUT = "sdba_extra_output" +SDBA_ENCODE_CF = "sdba_encode_cf" +KEEP_ATTRS = "keep_attrs" +AS_DATASET = "as_dataset" + +MISSING_METHODS: dict[str, Callable] = {} + +OPTIONS = { + # METADATA_LOCALES: [], + DATA_VALIDATION: "raise", + CF_COMPLIANCE: "warn", + CHECK_MISSING: "any", + MISSING_OPTIONS: {}, + SDBA_EXTRA_OUTPUT: False, + SDBA_ENCODE_CF: False, + KEEP_ATTRS: "xarray", + AS_DATASET: False, +} + +_LOUDNESS_OPTIONS = frozenset(["log", "warn", "raise"]) +_KEEP_ATTRS_OPTIONS = frozenset(["xarray", True, False]) + + +def _valid_missing_options(mopts): + for meth, opts in mopts.items(): + cls = MISSING_METHODS.get(meth, None) + if ( + cls is None # Method must be registered + # All options must exist + or any([opt not in OPTIONS[MISSING_OPTIONS][meth] for opt in opts.keys()]) + # Method option validator must pass, default validator is always True. + or not cls.validate(**opts) # noqa + ): + return False + return True + + +_VALIDATORS = { + # METADATA_LOCALES: _valid_locales, + DATA_VALIDATION: _LOUDNESS_OPTIONS.__contains__, + CF_COMPLIANCE: _LOUDNESS_OPTIONS.__contains__, + CHECK_MISSING: lambda meth: meth != "from_context" and meth in MISSING_METHODS, + MISSING_OPTIONS: _valid_missing_options, + SDBA_EXTRA_OUTPUT: lambda opt: isinstance(opt, bool), + SDBA_ENCODE_CF: lambda opt: isinstance(opt, bool), + KEEP_ATTRS: _KEEP_ATTRS_OPTIONS.__contains__, + AS_DATASET: lambda opt: isinstance(opt, bool), +} + + +def _set_missing_options(mopts): + for meth, opts in mopts.items(): + OPTIONS[MISSING_OPTIONS][meth].update(opts) + + +# def _set_metadata_locales(locales): +# if isinstance(locales, str): +# OPTIONS[METADATA_LOCALES] = [locales] +# else: +# OPTIONS[METADATA_LOCALES] = locales + + +_SETTERS = { + MISSING_OPTIONS: _set_missing_options, + # METADATA_LOCALES: _set_metadata_locales, +} + + +def register_missing_method(name: str) -> Callable: + """Register missing method.""" + + def _register_missing_method(cls): + sig = signature(cls.is_missing) + opts = { + key: param.default if param.default != param.empty else None + for key, param in sig.parameters.items() + if key not in ["self", "null", "count"] + } + + MISSING_METHODS[name] = cls + OPTIONS[MISSING_OPTIONS][name] = opts + return cls + + return _register_missing_method + + +def _run_check(func, option, *args, **kwargs): + """Run function and customize exception handling based on option.""" + try: + func(*args, **kwargs) + except ValidationError as err: + raise_warn_or_log(err, OPTIONS[option], stacklevel=4) + + +def datacheck(func: Callable) -> Callable: + """Decorate functions checking data inputs validity.""" + + @wraps(func) + def run_check(*args, **kwargs): + return _run_check(func, DATA_VALIDATION, *args, **kwargs) + + return run_check + + +def cfcheck(func: Callable) -> Callable: + """Decorate functions checking CF-compliance of DataArray attributes. + + Functions should raise ValidationError exceptions whenever attributes are non-conformant. + """ + + @wraps(func) + def run_check(*args, **kwargs): + return _run_check(func, CF_COMPLIANCE, *args, **kwargs) + + return run_check + + +class set_options: + """Set options for xclim in a controlled context. + + Attributes + ---------- + metadata_locales : list[Any] + List of IETF language tags or tuples of language tags and a translation dict, or + tuples of language tags and a path to a json file defining translation of attributes. + Default: ``[]``. + data_validation : {"log", "raise", "error"} + Whether to "log", "raise" an error or 'warn' the user on inputs that fail the data checks in + :py:func:`xclim.core.datachecks`. Default: ``"raise"``. + cf_compliance : {"log", "raise", "error"} + Whether to "log", "raise" an error or "warn" the user on inputs that fail the CF compliance checks in + :py:func:`xclim.core.cfchecks`. Default: ``"warn"``. + check_missing : {"any", "wmo", "pct", "at_least_n", "skip"} + How to check for missing data and flag computed indicators. + Available methods are "any", "wmo", "pct", "at_least_n" and "skip". + Missing method can be registered through the `xclim.core.options.register_missing_method` decorator. + Default: ``"any"`` + missing_options : dict + Dictionary of options to pass to the missing method. Keys must the name of + missing method and values must be mappings from option names to values. + run_length_ufunc : str + Whether to use the 1D ufunc version of run length algorithms or the dask-ready broadcasting version. + Default is ``"auto"``, which means the latter is used for dask-backed and large arrays. + sdba_extra_output : bool + Whether to add diagnostic variables to outputs of sdba's `train`, `adjust` + and `processing` operations. Details about these additional variables are given in the object's + docstring. When activated, `adjust` will return a Dataset with `scen` and those extra diagnostics + For `processing` functions, see the doc, the output type might change, or not depending on the + algorithm. Default: ``False``. + sdba_encode_cf : bool + Whether to encode cf coordinates in the ``map_blocks`` optimization that most adjustment methods are based on. + This should have no impact on the results, but should run much faster in the graph creation phase. + keep_attrs : bool or str + Controls attributes handling in indicators. If True, attributes from all inputs are merged + using the `drop_conflicts` strategy and then updated with xclim-provided attributes. + If ``as_dataset`` is also True and a dataset was passed to the ``ds`` argument of the Indicator, + the dataset's attributes are copied to the indicator's output. + If False, attributes from the inputs are ignored. If "xarray", xclim will use xarray's `keep_attrs` option. + Note that xarray's "default" is equivalent to False. Default: ``"xarray"``. + as_dataset : bool + If True, indicators output datasets. If False, they output DataArrays. Default :``False``. + + Examples + -------- + You can use ``set_options`` either as a context manager: + + >>> import xclim + >>> ds = xr.open_dataset(path_to_tas_file).tas + >>> with xclim.set_options(metadata_locales=["fr"]): + ... out = xclim.atmos.tg_mean(ds) + ... + + Or to set global options: + + .. code-block:: python + + import xclim + + xclim.set_options(missing_options={"pct": {"tolerance": 0.04}}) + """ + + def __init__(self, **kwargs): + self.old = {} + for k, v in kwargs.items(): + if k not in OPTIONS: + raise ValueError(f"argument name {k!r} is not in the set of valid options {set(OPTIONS)!r}") + if k in _VALIDATORS and not _VALIDATORS[k](v): + raise ValueError(f"option {k!r} given an invalid value: {v!r}") + + self.old[k] = OPTIONS[k] + + self._update(kwargs) + + def __enter__(self): + """Context management.""" + return + + @staticmethod + def _update(kwargs): + """Update values.""" + for k, v in kwargs.items(): + if k in _SETTERS: + _SETTERS[k](v) + else: + OPTIONS[k] = v + + def __exit__(self, option_type, value, traceback): # noqa: F841 + """Context management.""" + self._update(self.old) diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py new file mode 100644 index 0000000..579037b --- /dev/null +++ b/src/xsdba/testing.py @@ -0,0 +1,248 @@ +"""Testing utilities for xsdba.""" + +import hashlib +import logging +import os +from pathlib import Path +from urllib.error import HTTPError, URLError +from urllib.request import urlopen, urlretrieve + +import pandas as pd +import xarray as xr +from platformdirs import user_cache_dir +from xarray import open_dataset as _open_dataset + +__all__ = ["test_timeseries"] + +# keeping xclim-testdata for now, since it's still this on gitHub +_default_cache_dir = Path(user_cache_dir("xclim-testdata")) + +# XC +TESTDATA_BRANCH = os.getenv("XCLIM_TESTDATA_BRANCH", "main") +"""Sets the branch of Ouranosinc/xclim-testdata to use when fetching testing datasets. + +Notes +----- +When running tests locally, this can be set for both `pytest` and `tox` by exporting the variable: + +.. code-block:: console + + $ export XCLIM_TESTDATA_BRANCH="my_testing_branch" + +or setting the variable at runtime: + +.. code-block:: console + + $ env XCLIM_TESTDATA_BRANCH="my_testing_branch" pytest + +""" + +logger = logging.getLogger("xsdba") + +try: + from pytest_socket import SocketBlockedError +except ImportError: + SocketBlockedError = None + + +# XC +def test_timeseries( + values, + start: str = "2000-07-01", + units: str | None = None, + freq: str = "D", + as_dataset: bool = False, + cftime: bool = False, +) -> xr.DataArray | xr.Dataset: + """Create a generic timeseries object based on pre-defined dictionaries of existing variables.""" + if cftime: + coords = xr.cftime_range(start, periods=len(values), freq=freq) + else: + coords = pd.date_range(start, periods=len(values), freq=freq) + + attrs = {} if units is None else {"units": units} + + da = xr.DataArray(values, coords=[coords], dims="time", attrs=attrs) + + if as_dataset: + return da.to_dataset() + else: + return da + + +# XC +def file_md5_checksum(f_name): + hash_md5 = hashlib.md5() # noqa: S324 + with open(f_name, "rb") as f: + hash_md5.update(f.read()) + return hash_md5.hexdigest() + + +# XC (oh dear) +def _get( + fullname: Path, + github_url: str, + branch: str, + suffix: str, + cache_dir: Path, +) -> Path: + cache_dir = cache_dir.absolute() + local_file = cache_dir / branch / fullname + md5_name = fullname.with_suffix(f"{suffix}.md5") + md5_file = cache_dir / branch / md5_name + + if not github_url.lower().startswith("http"): + raise ValueError(f"GitHub URL not safe: '{github_url}'.") + + if local_file.is_file(): + local_md5 = file_md5_checksum(local_file) + try: + url = "/".join((github_url, "raw", branch, md5_name.as_posix())) + msg = f"Attempting to fetch remote file md5: {md5_name.as_posix()}" + logger.info(msg) + urlretrieve(url, md5_file) # nosec + with open(md5_file) as f: + remote_md5 = f.read() + if local_md5.strip() != remote_md5.strip(): + local_file.unlink() + msg = f"MD5 checksum for {local_file.as_posix()} does not match upstream md5. " "Attempting new download." + warnings.warn(msg) + except HTTPError: + msg = f"{md5_name.as_posix()} not accessible in remote repository. " "Unable to determine validity with upstream repo." + warnings.warn(msg) + except URLError: + msg = f"{md5_name.as_posix()} not found in remote repository. " "Unable to determine validity with upstream repo." + warnings.warn(msg) + except SocketBlockedError: + msg = f"Unable to access {md5_name.as_posix()} online. Testing suite is being run with `--disable-socket`." + warnings.warn(msg) + + if not local_file.is_file(): + # This will always leave this directory on disk. + # We may want to add an option to remove it. + local_file.parent.mkdir(exist_ok=True, parents=True) + + url = "/".join((github_url, "raw", branch, fullname.as_posix())) + msg = f"Fetching remote file: {fullname.as_posix()}" + logger.info(msg) + try: + urlretrieve(url, local_file) # nosec + except HTTPError as e: + msg = f"{fullname.as_posix()} not accessible in remote repository. Aborting file retrieval." + raise FileNotFoundError(msg) from e + except URLError as e: + msg = f"{fullname.as_posix()} not found in remote repository. " "Verify filename and repository address. Aborting file retrieval." + raise FileNotFoundError(msg) from e + # gives TypeError: catching classes that do not inherit from BaseException is not allowed + except SocketBlockedError as e: + msg = ( + f"Unable to access {fullname.as_posix()} online. Testing suite is being run with `--disable-socket`. " + f"If you intend to run tests with this option enabled, please download the file beforehand with the " + f"following console command: `xclim prefetch_testing_data`." + ) + raise FileNotFoundError(msg) from e + try: + url = "/".join((github_url, "raw", branch, md5_name.as_posix())) + msg = f"Fetching remote file md5: {md5_name.as_posix()}" + logger.info(msg) + urlretrieve(url, md5_file) # nosec + except (HTTPError, URLError) as e: + msg = ( + f"{md5_name.as_posix()} not accessible online. " + "Unable to determine validity of file from upstream repo. " + "Aborting file retrieval." + ) + local_file.unlink() + raise FileNotFoundError(msg) from e + + local_md5 = file_md5_checksum(local_file) + try: + with open(md5_file) as f: + remote_md5 = f.read() + if local_md5.strip() != remote_md5.strip(): + local_file.unlink() + msg = f"{local_file.as_posix()} and md5 checksum do not match. " "There may be an issue with the upstream origin data." + raise OSError(msg) + except OSError as e: + logger.error(e) + + return local_file + + +# XC +# idea copied from xclim that it borrowed from raven that it borrowed from xclim that borrowed it from xarray that was borrowed from Seaborn +def open_dataset( + name: str | os.PathLike[str], + suffix: str | None = None, + dap_url: str | None = None, + github_url: str = "https://github.com/Ouranosinc/xclim-testdata", + branch: str = "main", + cache: bool = True, + cache_dir: Path = _default_cache_dir, + **kwargs, +) -> xr.Dataset: + r"""Open a dataset from the online GitHub-like repository. + + If a local copy is found then always use that to avoid network traffic. + + Parameters + ---------- + name : str or os.PathLike + Name of the file containing the dataset. + suffix : str, optional + If no suffix is given, assumed to be netCDF ('.nc' is appended). For no suffix, set "". + dap_url : str, optional + URL to OPeNDAP folder where the data is stored. If supplied, supersedes github_url. + github_url : str + URL to GitHub repository where the data is stored. + branch : str, optional + For GitHub-hosted files, the branch to download from. + cache_dir : Path + The directory in which to search for and write cached data. + cache : bool + If True, then cache data locally for use on subsequent calls. + \*\*kwargs + For NetCDF files, keywords passed to :py:func:`xarray.open_dataset`. + + Returns + ------- + Union[Dataset, Path] + + See Also + -------- + xarray.open_dataset + """ + if isinstance(name, (str, os.PathLike)): + name = Path(name) + if suffix is None: + suffix = ".nc" + fullname = name.with_suffix(suffix) + + if dap_url is not None: + dap_file_address = urljoin(dap_url, str(name)) + try: + ds = _open_dataset(audit_url(dap_file_address, context="OPeNDAP"), **kwargs) + return ds + except URLError: + raise + except OSError: + msg = f"OPeNDAP file not read. Verify that the service is available: '{dap_file_address}'" + logger.error(msg) + raise OSError(msg) + + local_file = _get( + fullname=fullname, + github_url=github_url, + branch=branch, + suffix=suffix, + cache_dir=cache_dir, + ) + + try: + ds = _open_dataset(local_file, **kwargs) + if not cache: + ds = ds.load() + local_file.unlink() + return ds + except OSError as err: + raise err diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py new file mode 100644 index 0000000..2a9a27e --- /dev/null +++ b/src/xsdba/utils.py @@ -0,0 +1,1044 @@ +""" +Statistical Downscaling and Bias Adjustment Utilities +===================================================== +""" + +from __future__ import annotations + +import itertools +from typing import Callable +from warnings import warn + +import numpy as np +import xarray as xr +from boltons.funcutils import wraps +from dask import array as dsk +from scipy.interpolate import griddata, interp1d +from scipy.stats import spearmanr +from xarray.core.utils import get_temp_dimname + +from .base import Grouper, parse_group +from .nbutils import _extrapolate_on_quantiles + +MULTIPLICATIVE = "*" +ADDITIVE = "+" + + +# XC +class ValidationError(ValueError): + """Error raised when input data to an indicator fails the validation tests.""" + + @property + def msg(self): # noqa + return self.args[0] + + +# XC +def raise_warn_or_log( + err: Exception, + mode: str, + msg: str | None = None, + err_type: type = ValueError, + stacklevel: int = 1, +): + """Raise, warn or log an error according. + + Parameters + ---------- + err : Exception + An error. + mode : {'ignore', 'log', 'warn', 'raise'} + What to do with the error. + msg : str, optional + The string used when logging or warning. + Defaults to the `msg` attr of the error (if present) or to "Failed with ". + err_type : type + The type of error/exception to raise. + stacklevel : int + Stacklevel when warning. Relative to the call of this function (1 is added). + """ + message = msg or getattr(err, "msg", f"Failed with {err!r}.") + if mode == "ignore": + pass + elif mode == "log": + logger.info(message) + elif mode == "warn": + warnings.warn(message, stacklevel=stacklevel + 1) + else: # mode == "raise" + raise err from err_type(message) + + +def _ecdf_1d(x, value): + sx = np.r_[-np.inf, np.sort(x, axis=None)] + return np.searchsorted(sx, value, side="right") / np.sum(~np.isnan(sx)) + + +def map_cdf_1d(x, y, y_value): + """Return the value in `x` with the same CDF as `y_value` in `y`.""" + q = _ecdf_1d(y, y_value) + _func = np.nanquantile + return _func(x, q=q) + + +def map_cdf( + ds: xr.Dataset, + *, + y_value: xr.DataArray, + dim, +): + """Return the value in `x` with the same CDF as `y_value` in `y`. + + This function is meant to be wrapped in a `Grouper.apply`. + + Parameters + ---------- + ds : xr.Dataset + Variables: x, Values from which to pick, + y, Reference values giving the ranking + y_value : float, array + Value within the support of `y`. + dim : str + Dimension along which to compute quantile. + + Returns + ------- + array + Quantile of `x` with the same CDF as `y_value` in `y`. + """ + return xr.apply_ufunc( + map_cdf_1d, + ds.x, + ds.y, + input_core_dims=[dim] * 2, + output_core_dims=[["x"]], + vectorize=True, + keep_attrs=True, + kwargs={"y_value": np.atleast_1d(y_value)}, + output_dtypes=[ds.x.dtype], + ) + + +def ecdf(x: xr.DataArray, value: float, dim: str = "time") -> xr.DataArray: + """Return the empirical CDF of a sample at a given value. + + Parameters + ---------- + x : array + Sample. + value : float + The value within the support of `x` for which to compute the CDF value. + dim : str + Dimension name. + + Returns + ------- + xr.DataArray + Empirical CDF. + """ + return (x <= value).sum(dim) / x.notnull().sum(dim) + + +# XC +def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: + """Evaluate whether dask is installed and array is loaded as a dask array. + + Parameters + ---------- + das: xr.DataArray or xr.Dataset + DataArrays or Datasets to check. + + Returns + ------- + bool + True if any of the passed objects is using dask. + """ + if len(das) > 1: + return any([uses_dask(da) for da in das]) + da = das[0] + if isinstance(da, xr.DataArray) and isinstance(da.data, dsk.Array): + return True + if isinstance(da, xr.Dataset) and any(isinstance(var.data, dsk.Array) for var in da.variables.values()): + return True + return False + + +# XC +def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: + r"""Ensure that the input DataArray has chunks of at least the given size. + + If only one chunk is too small, it is merged with an adjacent chunk. + If many chunks are too small, they are grouped together by merging adjacent chunks. + + Parameters + ---------- + da : xr.DataArray + The input DataArray, with or without the dask backend. Does nothing when passed a non-dask array. + \*\*minchunks : dict[str, int] + A kwarg mapping from dimension name to minimum chunk size. + Pass -1 to force a single chunk along that dimension. + + Returns + ------- + xr.DataArray + """ + if not uses_dask(da): + return da + + all_chunks = dict(zip(da.dims, da.chunks)) + chunking = {} + for dim, minchunk in minchunks.items(): + chunks = all_chunks[dim] + if minchunk == -1 and len(chunks) > 1: + # Rechunk to single chunk only if it's not already one + chunking[dim] = -1 + + toosmall = np.array(chunks) < minchunk # Chunks that are too small + if toosmall.sum() > 1: + # Many chunks are too small, merge them by groups + fac = np.ceil(minchunk / min(chunks)).astype(int) + chunking[dim] = tuple(sum(chunks[i : i + fac]) for i in range(0, len(chunks), fac)) + # Reset counter is case the last chunks are still too small + chunks = chunking[dim] + toosmall = np.array(chunks) < minchunk + if toosmall.sum() == 1: + # Only one, merge it with adjacent chunk + ind = np.where(toosmall)[0][0] + new_chunks = list(chunks) + sml = new_chunks.pop(ind) + new_chunks[max(ind - 1, 0)] += sml + chunking[dim] = tuple(new_chunks) + + if chunking: + return da.chunk(chunks=chunking) + return da + + +# XC +def _interpolate_doy_calendar(source: xr.DataArray, doy_max: int, doy_min: int = 1) -> xr.DataArray: + """Interpolate from one set of dayofyear range to another. + + Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 + to 365). + + Parameters + ---------- + source : xr.DataArray + Array with `dayofyear` coordinates. + doy_max : int + The largest day of the year allowed by calendar. + doy_min : int + The smallest day of the year in the output. + This parameter is necessary when the target time series does not span over a full year (e.g. JJA season). + Default is 1. + + Returns + ------- + xr.DataArray + Interpolated source array over coordinates spanning the target `dayofyear` range. + """ + if "dayofyear" not in source.coords.keys(): + raise AttributeError("Source should have `dayofyear` coordinates.") + + # Interpolate to fill na values + da = source + if uses_dask(source): + # interpolate_na cannot run on chunked dayofyear. + da = source.chunk(dict(dayofyear=-1)) + filled_na = da.interpolate_na(dim="dayofyear") + + # Interpolate to target dayofyear range + filled_na.coords["dayofyear"] = np.linspace(start=doy_min, stop=doy_max, num=len(filled_na.coords["dayofyear"])) + + return filled_na.interp(dayofyear=range(doy_min, doy_max + 1)) + + +# XC +def ensure_longest_doy(func: Callable) -> Callable: + """Ensure that selected day is the longest day of year for x and y dims.""" + + @wraps(func) + def _ensure_longest_doy(x, y, *args, **kwargs): + if hasattr(x, "dims") and hasattr(y, "dims") and "dayofyear" in x.dims and "dayofyear" in y.dims and x.dayofyear.max() != y.dayofyear.max(): + warn( + ( + "get_correction received inputs defined on different dayofyear ranges. " + "Interpolating to the longest range. Results could be strange." + ), + stacklevel=4, + ) + if x.dayofyear.max() < y.dayofyear.max(): + x = _interpolate_doy_calendar(x, int(y.dayofyear.max()), int(y.dayofyear.min())) + else: + y = _interpolate_doy_calendar(y, int(x.dayofyear.max()), int(x.dayofyear.min())) + return func(x, y, *args, **kwargs) + + return _ensure_longest_doy + + +@ensure_longest_doy +def get_correction(x: xr.DataArray, y: xr.DataArray, kind: str) -> xr.DataArray: + """Return the additive or multiplicative correction/adjustment factors.""" + with xr.set_options(keep_attrs=True): + if kind == ADDITIVE: + out = y - x + elif kind == MULTIPLICATIVE: + out = y / x + else: + raise ValueError("kind must be + or *.") + + if isinstance(out, xr.DataArray): + out.attrs["kind"] = kind + return out + + +@ensure_longest_doy +def apply_correction(x: xr.DataArray, factor: xr.DataArray, kind: str | None = None) -> xr.DataArray: + """Apply the additive or multiplicative correction/adjustment factors. + + If kind is not given, default to the one stored in the "kind" attribute of factor. + """ + kind = kind or factor.get("kind", None) + with xr.set_options(keep_attrs=True): + out: xr.DataArray + if kind == ADDITIVE: + out = x + factor + elif kind == MULTIPLICATIVE: + out = x * factor + else: + raise ValueError("kind must be `+` or `*`.") + return out + + +def invert(x: xr.DataArray, kind: str | None = None) -> xr.DataArray: + """Invert a DataArray either by addition (-x) or by multiplication (1/x). + + If kind is not given, default to the one stored in the "kind" attribute of x. + """ + kind = kind or x.get("kind", None) + with xr.set_options(keep_attrs=True): + if kind == ADDITIVE: + return -x + if kind == MULTIPLICATIVE: + return 1 / x # type: ignore + raise ValueError + + +@parse_group +def broadcast( + grouped: xr.DataArray, + x: xr.DataArray, + *, + group: str | Grouper = "time", + interp: str = "nearest", + sel: dict[str, xr.DataArray] | None = None, +) -> xr.DataArray: + """Broadcast a grouped array back to the same shape as a given array. + + Parameters + ---------- + grouped : xr.DataArray + The grouped array to broadcast like `x`. + x : xr.DataArray + The array to broadcast grouped to. + group : str or Grouper + Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + interp : {'nearest', 'linear', 'cubic'} + The interpolation method to use, + sel : dict[str, xr.DataArray] + Mapping of grouped coordinates to x coordinates (other than the grouping one). + + Returns + ------- + xr.DataArray + """ + if sel is None: + sel = {} + + if group.prop != "group" and group.prop not in sel: + sel.update({group.prop: group.get_index(x, interp=interp != "nearest")}) + + if sel: + # Extract the correct mean factor for each time step. + if interp == "nearest": # Interpolate both the time group and the quantile. + grouped = grouped.sel(sel, method="nearest") + else: # Find quantile for nearest time group and quantile. + # For `.interp` we need to explicitly pass the shared dims + # (see pydata/xarray#4463 and Ouranosinc/xclim#449,567) + sel.update({dim: x[dim] for dim in set(grouped.dims).intersection(set(x.dims))}) + if group.prop != "group": + grouped = add_cyclic_bounds(grouped, group.prop, cyclic_coords=False) + + if interp == "cubic" and len(sel.keys()) > 1: + interp = "linear" + warn( + "Broadcasting operations in multiple dimensions can only be done with linear and nearest-neighbor" + " interpolation, not cubic. Using linear." + ) + + grouped = grouped.interp(sel, method=interp).astype(grouped.dtype) + + for var in sel.keys(): + if var in grouped.coords and var not in grouped.dims: + grouped = grouped.drop_vars(var) + + if group.prop == "group" and "group" in grouped.dims: + grouped = grouped.squeeze("group", drop=True) + return grouped + + +def equally_spaced_nodes(n: int, eps: float | None = None) -> np.ndarray: + """Return nodes with `n` equally spaced points within [0, 1], optionally adding two end-points. + + Parameters + ---------- + n : int + Number of equally spaced nodes. + eps : float, optional + Distance from 0 and 1 of added end nodes. If None (default), do not add endpoints. + + Returns + ------- + np.array + Nodes between 0 and 1. Nodes can be seen as the middle points of `n` equal bins. + + Warnings + -------- + Passing a small `eps` will effectively clip the scenario to the bounds of the reference + on the historical period in most cases. With normal quantile mapping algorithms, this can + give strange result when the reference does not show as many extremes as the simulation does. + + Notes + ----- + For n=4, eps=0 : 0---x------x------x------x---1 + """ + dq = 1 / n / 2 + q = np.linspace(dq, 1 - dq, n) + if eps is None: + return q + return np.insert(np.append(q, 1 - eps), 0, eps) + + +def add_cyclic_bounds(da: xr.DataArray, att: str, cyclic_coords: bool = True) -> xr.DataArray | xr.Dataset: + """Reindex an array to include the last slice at the beginning and the first at the end. + + This is done to allow interpolation near the end-points. + + Parameters + ---------- + da : xr.DataArray or xr.Dataset + An array + att : str + The name of the coordinate to make cyclic + cyclic_coords : bool + If True, the coordinates are made cyclic as well, + if False, the new values are guessed using the same step as their neighbour. + + Returns + ------- + xr.DataArray or xr.Dataset + da but with the last element along att prepended and the last one appended. + """ + qmf = da.pad({att: (1, 1)}, mode="wrap") + + if not cyclic_coords: + vals = qmf.coords[att].values + diff = da.coords[att].diff(att) + vals[0] = vals[1] - diff[0] + vals[-1] = vals[-2] + diff[-1] + qmf = qmf.assign_coords({att: vals}) + qmf[att].attrs.update(da.coords[att].attrs) + return ensure_chunk_size(qmf, **{att: -1}) + + +def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 + mask_new = np.isnan(newx) + mask_old = np.isnan(oldy) | np.isnan(oldx) + out = np.full_like(newx, np.NaN, dtype=f"float{oldy.dtype.itemsize * 8}") + if np.all(mask_new) or np.all(mask_old): + warn( + "All-NaN slice encountered in interp_on_quantiles", + category=RuntimeWarning, + ) + return out + + if extrap == "constant": + fill_value = ( + oldy[~np.isnan(oldy)][0], + oldy[~np.isnan(oldy)][-1], + ) + else: # extrap == 'nan' + fill_value = np.NaN + + out[~mask_new] = interp1d( + oldx[~mask_old], + oldy[~mask_old], + kind=method, + bounds_error=False, + fill_value=fill_value, + )(newx[~mask_new]) + return out + + +def _interp_on_quantiles_2D(newx, newg, oldx, oldy, oldg, method, extrap): # noqa + mask_new = np.isnan(newx) | np.isnan(newg) + mask_old = np.isnan(oldy) | np.isnan(oldx) | np.isnan(oldg) + out = np.full_like(newx, np.NaN, dtype=f"float{oldy.dtype.itemsize * 8}") + if np.all(mask_new) or np.all(mask_old): + warn( + "All-NaN slice encountered in interp_on_quantiles", + category=RuntimeWarning, + ) + return out + out[~mask_new] = griddata( + (oldx[~mask_old], oldg[~mask_old]), + oldy[~mask_old], + (newx[~mask_new], newg[~mask_new]), + method=method, + ) + if method == "nearest" or extrap != "nan": + # 'nan' extrapolation implicit for cubic and linear interpolation. + out = _extrapolate_on_quantiles(out, oldx, oldg, oldy, newx, newg, extrap) + return out + + +SEASON_MAP = {"DJF": 0, "MAM": 1, "JJA": 2, "SON": 3} + +map_season_to_int = np.vectorize(SEASON_MAP.get) + + +@parse_group +def interp_on_quantiles( + newx: xr.DataArray, + xq: xr.DataArray, + yq: xr.DataArray, + *, + group: str | Grouper = "time", + method: str = "linear", + extrapolation: str = "constant", +): + """Interpolate values of yq on new values of x. + + Interpolate in 2D with :py:func:`scipy.interpolate.griddata` if grouping is used, in 1D otherwise, with + :py:class:`scipy.interpolate.interp1d`. + Any NaNs in `xq` or `yq` are removed from the input map. + Similarly, NaNs in newx are left NaNs. + + Parameters + ---------- + newx : xr.DataArray + The values at which to evaluate `yq`. If `group` has group information, + `new` should have a coordinate with the same name as the group name + In that case, 2D interpolation is used. + xq, yq : xr.DataArray + Coordinates and values on which to interpolate. The interpolation is done + along the "quantiles" dimension if `group` has no group information. + If it does, interpolation is done in 2D on "quantiles" and on the group dimension. + group : str or Grouper + The dimension and grouping information. (ex: "time" or "time.month"). + Defaults to "time". + method : {'nearest', 'linear', 'cubic'} + The interpolation method. + extrapolation : {'constant', 'nan'} + The extrapolation method used for values of `newx` outside the range of `xq`. + See notes. + + Notes + ----- + Extrapolation methods: + + - 'nan' : Any value of `newx` outside the range of `xq` is set to NaN. + - 'constant' : Values of `newx` smaller than the minimum of `xq` are set to the first + value of `yq` and those larger than the maximum, set to the last one (first and + last non-nan values along the "quantiles" dimension). When the grouping is "time.month", + these limits are linearly interpolated along the month dimension. + """ + dim = group.dim + prop = group.prop + + if prop == "group": + if "group" in xq.dims: + xq = xq.squeeze("group", drop=True) + if "group" in yq.dims: + yq = yq.squeeze("group", drop=True) + + out = xr.apply_ufunc( + _interp_on_quantiles_1D, + newx, + xq, + yq, + kwargs={"method": method, "extrap": extrapolation}, + input_core_dims=[[dim], ["quantiles"], ["quantiles"]], + output_core_dims=[[dim]], + vectorize=True, + dask="parallelized", + output_dtypes=[yq.dtype], + ) + return out + + if prop not in xq.dims: + xq = xq.expand_dims({prop: group.get_coordinate()}) + if prop not in yq.dims: + yq = yq.expand_dims({prop: group.get_coordinate()}) + + # Adding the cyclic bounds fails for string coordinates like seasons + # That's why we map the seasons to integers + if prop == "season": + xq = xq.assign_coords(season=map_season_to_int(xq.season)) + yq = yq.assign_coords(season=map_season_to_int(yq.season)) + + xq = add_cyclic_bounds(xq, prop, cyclic_coords=False) + yq = add_cyclic_bounds(yq, prop, cyclic_coords=False) + newg = group.get_index(newx, interp=method != "nearest") + oldg = xq[prop].expand_dims(quantiles=xq.coords["quantiles"]) + + return xr.apply_ufunc( + _interp_on_quantiles_2D, + newx, + newg, + xq, + yq, + oldg, + kwargs={"method": method, "extrap": extrapolation}, + input_core_dims=[ + [dim], + [dim], + [prop, "quantiles"], + [prop, "quantiles"], + [prop, "quantiles"], + ], + output_core_dims=[[dim]], + vectorize=True, + dask="parallelized", + output_dtypes=[yq.dtype], + ) + + +def rank(da: xr.DataArray, dim: str | list[str] = "time", pct: bool = False) -> xr.DataArray: + """Ranks data along a dimension. + + Replicates `xr.DataArray.rank` but as a function usable in a Grouper.apply(). Xarray's docstring is below: + + Equal values are assigned a rank that is the average of the ranks that would have been otherwise assigned to all the + values within that set. Ranks begin at 1, not 0. If pct, computes percentage ranks, ranging from 0 to 1. + + A list of dimensions can be provided and the ranks are then computed separately for each dimension. + + Parameters + ---------- + da: xr.DataArray + Source array. + dim : str | list[str], hashable + Dimension(s) over which to compute rank. + pct : bool, optional + If True, compute percentage ranks, otherwise compute integer ranks. + Percentage ranks range from 0 to 1, in opposition to xarray's implementation, + where they range from 1/N to 1. + + Returns + ------- + DataArray + DataArray with the same coordinates and dtype 'float64'. + + Notes + ----- + The `bottleneck` library is required. NaNs in the input array are returned as NaNs. + + See Also + -------- + xarray.DataArray.rank + """ + da_dims, da_coords = da.dims, da.coords + dims = dim if isinstance(dim, list) else [dim] + rnk_dim = dims[0] if len(dims) == 1 else get_temp_dimname(da_dims, "temp") + + # multi-dimensional ranking through stacking + if len(dims) > 1: + da = da.stack(**{rnk_dim: dims}) + rnk = da.rank(rnk_dim, pct=pct) + + if pct: + mn = rnk.min(rnk_dim) + mx = rnk.max(rnk_dim) + rnk = mx * (rnk - mn) / (mx - mn) + + if len(dims) > 1: + rnk = rnk.unstack(rnk_dim).transpose(*da_dims).drop_vars([d for d in dims if d not in da_coords]) + return rnk + + +def pc_matrix(arr: np.ndarray | dsk.Array) -> np.ndarray | dsk.Array: + """Construct a Principal Component matrix. + + This matrix can be used to transform points in arr to principal components + coordinates. Note that this function does not manage NaNs; if a single observation is null, all elements + of the transformation matrix involving that variable will be NaN. + + Parameters + ---------- + arr : numpy.ndarray or dask.array.Array + 2D array (M, N) of the M coordinates of N points. + + Returns + ------- + numpy.ndarray or dask.array.Array + MxM Array of the same type as arr. + """ + # Get appropriate math module + mod = dsk if isinstance(arr, dsk.Array) else np + + # Covariance matrix + cov = mod.cov(arr) + + # Get eigenvalues and eigenvectors + # There are no such method yet in dask, but we are lucky: + # the SVD decomposition of a symmetric matrix gives the eigen stuff. + # And covariance matrices are by definition symmetric! + # Numpy has a hermitian=True option to accelerate, but not dask... + kwargs = {} if mod is dsk else {"hermitian": True} + eig_vec, eig_vals, _ = mod.linalg.svd(cov, **kwargs) + + # The PC matrix is the eigen vectors matrix scaled by the square root of the eigen values + return eig_vec * mod.sqrt(eig_vals) + + +def best_pc_orientation_simple(R: np.ndarray, Hinv: np.ndarray, val: float = 1000) -> np.ndarray: + """Return best orientation vector according to a simple test. + + Eigenvectors returned by `pc_matrix` do not have a defined orientation. + Given an inverse transform `Hinv` and a transform `R`, this returns the orientation minimizing the projected + distance for a test point far from the origin. + + This trick is inspired by the one exposed in :cite:t:`sdba-hnilica_multisite_2017`. For each possible orientation vector, + the test point is reprojected and the distance from the original point is computed. The orientation + minimizing that distance is chosen. + + Parameters + ---------- + R : np.ndarray + MxM Matrix defining the final transformation. + Hinv : np.ndarray + MxM Matrix defining the (inverse) first transformation. + val : float + The coordinate of the test point (same for all axes). It should be much + greater than the largest furthest point in the array used to define B. + + Returns + ------- + np.ndarray + Mx1 vector of orientation correction (1 or -1). + + See Also + -------- + sdba.adjustment.PrincipalComponentAdjustment + + References + ---------- + :cite:cts:`sdba-hnilica_multisite_2017` + """ + m = R.shape[0] + P = np.diag(val * np.ones(m)) + signs = dict(itertools.zip_longest(itertools.product(*[[1, -1]] * m), [None])) + for orient in list(signs.keys()): + # Compute new error + signs[orient] = np.linalg.norm(P - ((orient * R) @ Hinv) @ P) + return np.array(min(signs, key=lambda o: signs[o])) + + +def best_pc_orientation_full( + R: np.ndarray, + Hinv: np.ndarray, + Rmean: np.ndarray, + Hmean: np.ndarray, + hist: np.ndarray, +) -> np.ndarray: + """Return best orientation vector for `A` according to the method of :cite:t:`sdba-alavoine_distinct_2022`. + + Eigenvectors returned by `pc_matrix` do not have a defined orientation. + Given an inverse transform `Hinv`, a transform `R`, the actual and target origins `Hmean` and `Rmean` and the matrix + of training observations `hist`, this computes a scenario for all possible orientations and return the orientation + that maximizes the Spearman correlation coefficient of all variables. The correlation is computed for each variable + individually, then averaged. + + This trick is explained in :cite:t:`sdba-alavoine_distinct_2022`. + See docstring of :py:func:`sdba.adjustment.PrincipalComponentAdjustment`. + + Parameters + ---------- + R : np.ndarray + MxM Matrix defining the final transformation. + Hinv : np.ndarray + MxM Matrix defining the (inverse) first transformation. + Rmean : np.ndarray + M vector defining the target distribution center point. + Hmean : np.ndarray + M vector defining the original distribution center point. + hist : np.ndarray + MxN matrix of all training observations of the M variables/sites. + + Returns + ------- + np.ndarray + M vector of orientation correction (1 or -1). + + References + ---------- + :cite:cts:`sdba-alavoine_distinct_2022` + + See Also + -------- + sdba.adjustment.PrincipalComponentAdjustment + """ + # All possible orientation vectors + m = R.shape[0] + signs = dict(itertools.zip_longest(itertools.product(*[[1, -1]] * m), [None])) + for orient in list(signs.keys()): + # Calculate scen for hist + scen = np.atleast_2d(Rmean).T + ((orient * R) @ Hinv) @ (hist - np.atleast_2d(Hmean).T) + # Correlation for each variable + corr = [spearmanr(hist[i, :], scen[i, :])[0] for i in range(hist.shape[0])] + # Store mean correlation + signs[orient] = np.mean(corr) + # Return orientation that maximizes the correlation + return np.array(max(signs, key=lambda o: signs[o])) + + +def get_clusters_1d(data: np.ndarray, u1: float, u2: float) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Get clusters of a 1D array. + + A cluster is defined as a sequence of values larger than u2 with at least one value larger than u1. + + Parameters + ---------- + data : 1D ndarray + Values to get clusters from. + u1 : float + Extreme value threshold, at least one value in the cluster must exceed this. + u2 : float + Cluster threshold, values above this can be part of a cluster. + + Returns + ------- + (np.array, np.array, np.array, np.array) + + References + ---------- + `getcluster` of Extremes.jl (:cite:cts:`sdba-jalbert_extreme_2022`). + """ + # Boolean array, True where data is over u2 + # We pad with values under u2, so that clusters never start or end at boundaries. + exce = np.concatenate(([u2 - 1], data, [u2 - 1])) > u2 + + # 1 just before the start of the cluster + # -1 on the last element of the cluster + bounds = np.diff(exce.astype(np.int32)) + # We add 1 to get the first element and sub 1 to get the same index as in data + starts = np.where(bounds == 1)[0] + # We sub 1 to get the same index as in data and add 1 to get the element after (for python slicing) + ends = np.where(bounds == -1)[0] + + cl_maxpos = [] + cl_maxval = [] + cl_start = [] + cl_end = [] + for start, end in zip(starts, ends): + cluster_max = data[start:end].max() + if cluster_max > u1: + cl_maxval.append(cluster_max) + cl_maxpos.append(start + np.argmax(data[start:end])) + cl_start.append(start) + cl_end.append(end - 1) + + return ( + np.array(cl_start), + np.array(cl_end), + np.array(cl_maxpos), + np.array(cl_maxval), + ) + + +def get_clusters(data: xr.DataArray, u1, u2, dim: str = "time") -> xr.Dataset: + """Get cluster count, maximum and position along a given dim. + + See `get_clusters_1d`. Used by `adjustment.ExtremeValues`. + + Parameters + ---------- + data: 1D ndarray + Values to get clusters from. + u1 : float + Extreme value threshold, at least one value in the cluster must exceed this. + u2 : float + Cluster threshold, values above this can be part of a cluster. + dim : str + Dimension name. + + Returns + ------- + xr.Dataset + With variables, + - `nclusters` : Number of clusters for each point (with `dim` reduced), int + - `start` : First index in the cluster (`dim` reduced, new `cluster`), int + - `end` : Last index in the cluster, inclusive (`dim` reduced, new `cluster`), int + - `maxpos` : Index of the maximal value within the cluster (`dim` reduced, new `cluster`), int + - `maximum` : Maximal value within the cluster (`dim` reduced, new `cluster`), same dtype as data. + + For `start`, `end` and `maxpos`, -1 means NaN and should always correspond to a `NaN` in `maximum`. + The length along `cluster` is half the size of "dim", the maximal theoretical number of clusters. + """ + + def _get_clusters(arr, u1, u2, N): + st, ed, mp, mv = get_clusters_1d(arr, u1, u2) + count = len(st) + pad = [-1] * (N - count) + return ( + np.append(st, pad), + np.append(ed, pad), + np.append(mp, pad), + np.append(mv, [np.NaN] * (N - count)), + count, + ) + + # The largest possible number of clusters. Ex: odd positions are < u2, even positions are > u1. + N = data[dim].size // 2 + + starts, ends, maxpos, maxval, nclusters = xr.apply_ufunc( + _get_clusters, + data, + u1, + u2, + input_core_dims=[[dim], [], []], + output_core_dims=[["cluster"], ["cluster"], ["cluster"], ["cluster"], []], + kwargs={"N": N}, + dask="parallelized", + vectorize=True, + dask_gufunc_kwargs={ + "meta": ( + np.array((), dtype=int), + np.array((), dtype=int), + np.array((), dtype=int), + np.array((), dtype=data.dtype), + np.array((), dtype=int), + ), + "output_sizes": {"cluster": N}, + }, + ) + + ds = xr.Dataset( + { + "start": starts, + "end": ends, + "maxpos": maxpos, + "maximum": maxval, + "nclusters": nclusters, + } + ) + + return ds + + +def rand_rot_matrix(crd: xr.DataArray, num: int = 1, new_dim: str | None = None) -> xr.DataArray: + r"""Generate random rotation matrices. + + Rotation matrices are members of the SO(n) group, where n is the matrix size (`crd.size`). + They can be characterized as orthogonal matrices with determinant 1. A square matrix :math:`R` + is a rotation matrix if and only if :math:`R^t = R^{−1}` and :math:`\mathrm{det} R = 1`. + + Parameters + ---------- + crd: xr.DataArray + 1D coordinate DataArray along which the rotation occurs. + The output will be square with the same coordinate replicated, + the second renamed to `new_dim`. + num : int + If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. + new_dim : str + Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". + + Returns + ------- + xr.DataArray + float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. + + References + ---------- + :cite:cts:`sdba-mezzadri_how_2007` + + """ + if num > 1: + return xr.concat([rand_rot_matrix(crd, num=1) for i in range(num)], "matrices") + + N = crd.size + dim = crd.dims[0] + # Rename and rebuild second coordinate : "prime" axis. + if new_dim is None: + new_dim = dim + "_prime" + crd2 = xr.DataArray(crd.values, dims=new_dim, name=new_dim, attrs=crd.attrs) + + # Random floats from the standardized normal distribution + Z = np.random.standard_normal((N, N)) + + # QR decomposition and manipulation from Mezzadri 2006 + Q, R = np.linalg.qr(Z) + num = np.diag(R) + denum = np.abs(num) + lam = np.diag(num / denum) # "lambda" + return xr.DataArray(Q @ lam, dims=(dim, new_dim), coords={dim: crd, new_dim: crd2}).astype("float32") + + +def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): + """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" + ds.attrs.update(ref.attrs) + extras = ds.variables if isinstance(ds, xr.Dataset) else ds.coords + others = ref.variables if isinstance(ref, xr.Dataset) else ref.coords + for name, var in extras.items(): + if name in others: + var.attrs.update(ref[name].attrs) + + +def _pairwise_spearman(da, dims): + """Area-averaged pairwise temporal correlation. + + With skipna-shortcuts for cases where all times or all points are NaN. + """ + da = da - da.mean(dims) + da = da.stack(_spatial=dims).reset_index("_spatial").drop_vars(["_spatial"], errors=["ignore"]) + + def _skipna_correlation(data): + nv, _nt = data.shape + # Mask of which variable are all NaN + mask_omit = np.isnan(data).all(axis=1) + # Remove useless variables + data_noallnan = data[~mask_omit, :] + # Mask of which times are nan on all variables + mask_skip = np.isnan(data_noallnan).all(axis=0) + # Remove those times (they'll be omitted anyway) + data_nonan = data_noallnan[:, ~mask_skip] + + # We still have a possibility that a NaN was unique to a variable and time. + # If this is the case, it will be a lot longer, but what can we do. + coef = spearmanr(data_nonan, axis=1, nan_policy="omit").correlation + + # The output + out = np.empty((nv, nv), dtype=coef.dtype) + # A 2D mask of removed variables + M = (mask_omit)[:, np.newaxis] | (mask_omit)[np.newaxis, :] + out[~M] = coef.flatten() + out[M] = np.nan + return out + + return xr.apply_ufunc( + _skipna_correlation, + da, + input_core_dims=[["_spatial", "time"]], + output_core_dims=[["_spatial", "_spatial2"]], + vectorize=True, + output_dtypes=[float], + dask="parallelized", + dask_gufunc_kwargs={ + "output_sizes": { + "_spatial": da._spatial.size, + "_spatial2": da._spatial.size, + }, + "allow_rechunk": True, + }, + ).rename("correlation") diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..d41ad10 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,303 @@ +# noqa: D104 +# XC: Many things deactivated, not sure what will be necessary +from __future__ import annotations + +import os +import re +import shutil +import sys +import time +import warnings +from datetime import datetime as dt +from functools import partial +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest +import xarray as xr +from filelock import FileLock +from packaging.version import Version + +from xsdba.testing import TESTDATA_BRANCH +from xsdba.testing import open_dataset as _open_dataset +from xsdba.testing import test_timeseries + +# import xclim +# from xclim import __version__ as __xclim_version__ +# from xclim.core.calendar import max_doy +# from xclim.testing import helpers +# from xclim.testing.utils import _default_cache_dir # noqa +# from xclim.testing.utils import get_file +# from xclim.testing.utils import open_dataset as _open_dataset + +# ADAPT +# if ( +# re.match(r"^\d+\.\d+\.\d+$", __xclim_version__) +# and helpers.TESTDATA_BRANCH == "main" +# ): +# # This does not need to be emitted on GitHub Workflows and ReadTheDocs +# if not os.getenv("CI") and not os.getenv("READTHEDOCS"): +# warnings.warn( +# f'`xclim` {__xclim_version__} is running tests against the "main" branch of `Ouranosinc/xclim-testdata`. ' +# "It is possible that changes in xclim-testdata may be incompatible with test assertions in this version. " +# "Please be sure to check https://github.com/Ouranosinc/xclim-testdata for more information.", +# UserWarning, +# ) + +# if re.match(r"^v\d+\.\d+\.\d+", helpers.TESTDATA_BRANCH): +# # Find the date of last modification of xclim source files to generate a calendar version +# install_date = dt.strptime( +# time.ctime(os.path.getmtime(xclim.__file__)), +# "%a %b %d %H:%M:%S %Y", +# ) +# install_calendar_version = ( +# f"{install_date.year}.{install_date.month}.{install_date.day}" +# ) + +# if Version(helpers.TESTDATA_BRANCH) > Version(install_calendar_version): +# warnings.warn( +# f"Installation date of `xclim` ({install_date.ctime()}) " +# f"predates the last release of `xclim-testdata` ({helpers.TESTDATA_BRANCH}). " +# "It is very likely that the testing data is incompatible with this build of `xclim`.", +# UserWarning, +# ) + + +@pytest.fixture +def random() -> np.random.Generator: + return np.random.default_rng(seed=list(map(ord, "𝕽𝔞𝖓𝔡𝖔𝔪"))) + + +# ADAPT +# @pytest.fixture +# def tmp_netcdf_filename(tmpdir) -> Path: +# yield Path(tmpdir).joinpath("testfile.nc") + + +@pytest.fixture(autouse=True, scope="session") +def threadsafe_data_dir(tmp_path_factory) -> Path: + yield Path(tmp_path_factory.getbasetemp().joinpath("data")) + + +@pytest.fixture(scope="session") +def open_dataset(threadsafe_data_dir): + def _open_session_scoped_file(file: str | os.PathLike, branch: str = TESTDATA_BRANCH, **xr_kwargs): + xr_kwargs.setdefault("engine", "h5netcdf") + return _open_dataset(file, cache_dir=threadsafe_data_dir, branch=branch, **xr_kwargs) + + return _open_session_scoped_file + + +@pytest.fixture +def lat_series(): + def _lat_series(values): + return xr.DataArray( + values, + dims=("lat",), + coords={"lat": values}, + attrs={"standard_name": "latitude", "units": "degrees_north"}, + name="lat", + ) + + return _lat_series + + +# ADAPT +# @pytest.fixture +# def per_doy(): +# def _per_doy(values, calendar="standard", units="kg m-2 s-1"): +# n = max_doy[calendar] +# if len(values) != n: +# raise ValueError( +# "Values must be same length as number of days in calendar." +# ) +# coords = xr.IndexVariable("dayofyear", np.arange(1, n + 1)) +# return xr.DataArray( +# values, coords=[coords], attrs={"calendar": calendar, "units": units} +# ) + +# return _per_doy + + +@pytest.fixture +def areacella() -> xr.DataArray: + """Return a rectangular grid of grid cell area.""" + r = 6100000 + lon_bnds = np.arange(-180, 181, 1) + lat_bnds = np.arange(-90, 91, 1) + d_lon = np.diff(lon_bnds) + d_lat = np.diff(lat_bnds) + lon = np.convolve(lon_bnds, [0.5, 0.5], "valid") + lat = np.convolve(lat_bnds, [0.5, 0.5], "valid") + area = r * np.radians(d_lat)[:, np.newaxis] * r * np.cos(np.radians(lat)[:, np.newaxis]) * np.radians(d_lon) + return xr.DataArray( + data=area, + dims=("lat", "lon"), + coords={"lon": lon, "lat": lat}, + attrs={"r": r, "units": "m2", "standard_name": "cell_area"}, + ) + + +areacello = areacella + + +# ADAPT? +# @pytest.fixture(scope="session") +# def open_dataset(threadsafe_data_dir): +# def _open_session_scoped_file( +# file: str | os.PathLike, branch: str = helpers.TESTDATA_BRANCH, **xr_kwargs +# ): +# xr_kwargs.setdefault("engine", "h5netcdf") +# return _open_dataset( +# file, cache_dir=threadsafe_data_dir, branch=branch, **xr_kwargs +# ) + +# return _open_session_scoped_file + + +# ADAPT? +# @pytest.fixture(autouse=True, scope="session") +# def add_imports(xdoctest_namespace, threadsafe_data_dir) -> None: +# """Add these imports into the doctests scope.""" +# ns = xdoctest_namespace +# ns["np"] = np +# ns["xr"] = xclim.testing # xr.open_dataset(...) -> xclim.testing.open_dataset(...) +# ns["xclim"] = xclim +# ns["open_dataset"] = partial( +# _open_dataset, +# cache_dir=threadsafe_data_dir, +# branch=helpers.TESTDATA_BRANCH, +# engine="h5netcdf", +# ) # Needed for modules where xarray is imported as `xr` + + +@pytest.fixture(autouse=True, scope="function") +def add_example_dataarray(xdoctest_namespace, timeseries) -> None: + ns = xdoctest_namespace + ns["da"] = timeseries(np.random.rand(365) * 20 + 253.15) + + +@pytest.fixture(autouse=True, scope="session") +def is_matplotlib_installed(xdoctest_namespace) -> None: + def _is_matplotlib_installed(): + try: + import matplotlib # noqa + + return + except ImportError: + return pytest.skip("This doctest requires matplotlib to be installed.") + + ns = xdoctest_namespace + ns["is_matplotlib_installed"] = _is_matplotlib_installed + + +# ADAPT or REMOVE? +# @pytest.fixture(scope="function") +# def atmosds(threadsafe_data_dir) -> xr.Dataset: +# return _open_dataset( +# threadsafe_data_dir.joinpath("atmosds.nc"), +# cache_dir=threadsafe_data_dir, +# branch=helpers.TESTDATA_BRANCH, +# engine="h5netcdf", +# ).load() + + +# @pytest.fixture(scope="function") +# def ensemble_dataset_objects() -> dict: +# edo = dict() +# edo["nc_files_simple"] = [ +# "EnsembleStats/BCCAQv2+ANUSPLIN300_ACCESS1-0_historical+rcp45_r1i1p1_1950-2100_tg_mean_YS.nc", +# "EnsembleStats/BCCAQv2+ANUSPLIN300_BNU-ESM_historical+rcp45_r1i1p1_1950-2100_tg_mean_YS.nc", +# "EnsembleStats/BCCAQv2+ANUSPLIN300_CCSM4_historical+rcp45_r1i1p1_1950-2100_tg_mean_YS.nc", +# "EnsembleStats/BCCAQv2+ANUSPLIN300_CCSM4_historical+rcp45_r2i1p1_1950-2100_tg_mean_YS.nc", +# ] +# edo["nc_files_extra"] = [ +# "EnsembleStats/BCCAQv2+ANUSPLIN300_CNRM-CM5_historical+rcp45_r1i1p1_1970-2050_tg_mean_YS.nc" +# ] +# edo["nc_files"] = edo["nc_files_simple"] + edo["nc_files_extra"] +# return edo + + +# @pytest.fixture(scope="session") +# def lafferty_sriver_ds() -> xr.Dataset: +# """Get data from Lafferty & Sriver unit test. + +# Notes +# ----- +# https://github.com/david0811/lafferty-sriver_2023_npjCliAtm/tree/main/unit_test +# """ +# fn = get_file( +# "uncertainty_partitioning/seattle_avg_tas.csv", +# cache_dir=_default_cache_dir, +# branch=helpers.TESTDATA_BRANCH, +# ) + +# df = pd.read_csv(fn, parse_dates=["time"]).rename( +# columns={"ssp": "scenario", "ensemble": "downscaling"} +# ) + +# # Make xarray dataset +# return xr.Dataset.from_dataframe( +# df.set_index(["scenario", "model", "downscaling", "time"]) +# ) + + +# @pytest.fixture(scope="session", autouse=True) +# def gather_session_data(threadsafe_data_dir, worker_id, xdoctest_namespace): +# """Gather testing data on pytest run. + +# When running pytest with multiple workers, one worker will copy data remotely to _default_cache_dir while +# other workers wait using lockfile. Once the lock is released, all workers will then copy data to their local +# threadsafe_data_dir.As this fixture is scoped to the session, it will only run once per pytest run. + +# Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset as well as add the +# example file paths to the xdoctest_namespace, used when running doctests. +# """ +# if ( +# not _default_cache_dir.joinpath(helpers.TESTDATA_BRANCH).exists() +# or helpers.PREFETCH_TESTING_DATA +# ): +# if helpers.PREFETCH_TESTING_DATA: +# print("`XCLIM_PREFETCH_TESTING_DATA` set. Prefetching testing data...") +# if sys.platform == "win32": +# raise OSError( +# "UNIX-style file-locking is not supported on Windows. " +# "Consider running `$ xclim prefetch_testing_data` to download testing data." +# ) +# elif worker_id in ["master"]: +# helpers.populate_testing_data(branch=helpers.TESTDATA_BRANCH) +# else: +# _default_cache_dir.mkdir(exist_ok=True, parents=True) +# lockfile = _default_cache_dir.joinpath(".lock") +# test_data_being_written = FileLock(lockfile) +# with test_data_being_written: +# # This flag prevents multiple calls from re-attempting to download testing data in the same pytest run +# helpers.populate_testing_data(branch=helpers.TESTDATA_BRANCH) +# _default_cache_dir.joinpath(".data_written").touch() +# with test_data_being_written.acquire(): +# if lockfile.exists(): +# lockfile.unlink() +# shutil.copytree(_default_cache_dir, threadsafe_data_dir) +# helpers.generate_atmos(threadsafe_data_dir) +# xdoctest_namespace.update(helpers.add_example_file_paths(threadsafe_data_dir)) + + +# @pytest.fixture(scope="session", autouse=True) +# def cleanup(request): +# """Cleanup a testing file once we are finished. + +# This flag prevents remote data from being downloaded multiple times in the same pytest run. +# """ + +# def remove_data_written_flag(): +# flag = _default_cache_dir.joinpath(".data_written") +# if flag.exists(): +# flag.unlink() + +# request.addfinalizer(remove_data_written_flag) + + +@pytest.fixture +def timeseries(): + return test_timeseries diff --git a/tests/test_base.py b/tests/test_base.py new file mode 100644 index 0000000..04157a9 --- /dev/null +++ b/tests/test_base.py @@ -0,0 +1,242 @@ +# pylint: disable=missing-kwoa +from __future__ import annotations + +import jsonpickle +import numpy as np +import pytest +import xarray as xr + +from xsdba import set_options +from xsdba.base import Grouper, Parametrizable, map_blocks, map_groups + + +class ATestSubClass(Parametrizable): + pass + + +def test_param_class(): + gr = Grouper(group="time.month") + in_params = dict(anint=4, abool=True, astring="a string", adict={"key": "val"}, group=gr) + obj = Parametrizable(**in_params) + + assert obj.parameters == in_params + + assert repr(obj).startswith("Parametrizable(anint=4, abool=True, astring='a string', adict={'key': 'val'}, " "group=Grouper(") + + s = jsonpickle.encode(obj) + obj2 = jsonpickle.decode(s) # noqa: S301 + assert obj.parameters == obj2.parameters + + +@pytest.mark.parametrize( + "group,window,nvals", + [("time", 1, 366), ("time.month", 1, 31), ("time.dayofyear", 5, 1)], +) +def test_grouper_group(timeseries, group, window, nvals): + da = timeseries(np.ones(366), start="2000-01-01") + + grouper = Grouper(group, window=window) + grpd = grouper.group(da) + + if window > 1: + assert "window" in grpd.dims + + assert grpd.count().max() == nvals + + +@pytest.mark.parametrize( + "group,interp,val90", + [("time", False, True), ("time.month", False, 3), ("time.month", True, 3.5)], +) +def test_grouper_get_index(timeseries, group, interp, val90): + da = timeseries(np.ones(366), start="2000-01-01") + grouper = Grouper(group) + indx = grouper.get_index(da, interp=interp) + # 90 is March 31st + assert indx[90] == val90 + + +# xarray does not yet access "week" or "weekofyear" with groupby in a pandas-compatible way for cftime objects. +# See: https://github.com/pydata/xarray/discussions/6375 +@pytest.mark.filterwarnings("ignore:dt.weekofyear and dt.week have been deprecated") +@pytest.mark.slow +@pytest.mark.parametrize( + "group,n", + [("time", 1), ("time.month", 12), ("time.week", 52)], +) +@pytest.mark.parametrize("use_dask", [True, False]) +def test_grouper_apply(timeseries, use_dask, group, n): + da1 = timeseries(np.arange(366), start="2000-01-01") + da2 = timeseries(np.zeros(366), start="2000-01-01") + da0 = xr.concat((da1, da2), dim="lat") + + grouper = Grouper(group) + if not group.startswith("time"): + da0 = da0.rename(time=grouper.dim) + da1 = da1.rename(time=grouper.dim) + da2 = da2.rename(time=grouper.dim) + + if use_dask: + da0 = da0.chunk({"lat": 1, grouper.dim: -1}) + da1 = da1.chunk({grouper.dim: -1}) + da2 = da2.chunk({grouper.dim: -1}) + + # Normal monthly mean + out_mean = grouper.apply("mean", da0) + if grouper.prop != "group": + exp = da0.groupby(group).mean() + else: + exp = da0.mean(dim=grouper.dim).expand_dims("group").T + np.testing.assert_array_equal(out_mean, exp) + + # With additional dimension included + grouper = Grouper(group, add_dims=["lat"]) + out = grouper.apply("mean", da0) + assert out.ndim == 1 + np.testing.assert_array_equal(out, exp.mean("lat")) + assert out.attrs["group"] == group + assert out.attrs["group_compute_dims"] == [grouper.dim, "lat"] + assert out.attrs["group_window"] == 1 + + # Additional but main_only + out = grouper.apply("mean", da0, main_only=True) + np.testing.assert_array_equal(out, out_mean) + + # With window + win_grouper = Grouper(group, window=5) + out = win_grouper.apply("mean", da0) + rolld = da0.rolling({win_grouper.dim: 5}, center=True).construct(window_dim="window") + if grouper.prop != "group": + exp = rolld.groupby(group).mean(dim=[win_grouper.dim, "window"]) + else: + exp = rolld.mean(dim=[grouper.dim, "window"]).expand_dims("group").T + np.testing.assert_array_equal(out, exp) + + # With function + nongrouping-grouped + grouper = Grouper(group) + + def normalize(grp, dim): + return grp / grp.mean(dim=dim) + + normed = grouper.apply(normalize, da0) + assert normed.shape == da0.shape + if use_dask: + assert normed.chunks == ((1, 1), (366,)) + + # With window + nongrouping-grouped + out = win_grouper.apply(normalize, da0) + assert out.shape == da0.shape + + # Mixed output + def mixed_reduce(grdds, dim=None): + da1 = grdds.da1.mean(dim=dim) + da2 = grdds.da2 / grdds.da2.mean(dim=dim) + da1.attrs["_group_apply_reshape"] = True + return xr.Dataset(data_vars={"da1_mean": da1, "norm_da2": da2}) + + out = grouper.apply(mixed_reduce, {"da1": da1, "da2": da2}) + assert grouper.prop not in out.norm_da2.dims + assert grouper.prop in out.da1_mean.dims + + if use_dask: + assert out.da1_mean.chunks == ((n,),) + assert out.norm_da2.chunks == ((366,),) + + # Mixed input + def normalize_from_precomputed(grpds, dim=None): + return (grpds.da0 / grpds.da1_mean).mean(dim=dim) + + out = grouper.apply(normalize_from_precomputed, {"da0": da0, "da1_mean": out.da1_mean}).isel(lat=0) + if grouper.prop == "group": + exp = normed.mean("time").isel(lat=0) + else: + exp = normed.groupby(group).mean().isel(lat=0) + assert grouper.prop in out.dims + np.testing.assert_allclose(out, exp, rtol=1e-10) + + +class TestMapBlocks: + def test_lat_lon(self, timeseries): + da0 = timeseries(np.arange(366), start="2000-01-01") + da0 = da0.expand_dims(lat=[1, 2, 3, 4]).chunk() + + # Test dim parsing + @map_blocks(reduces=["lat"], data=["lon"]) + def func(ds, *, group, lon=None): + assert group.window == 5 + d = ds.da0.rename(lat="lon") + return d.rename("data").to_dataset() + + # Raises on missing coords + with pytest.raises(ValueError, match="This function adds the lon dimension*"): + data = func(xr.Dataset(dict(da0=da0)), group="time.dayofyear", window=5) + + data = func( + xr.Dataset(dict(da0=da0)), + group="time.dayofyear", + window=5, + lon=[1, 2, 3, 4], + ).load() + assert set(data.data.dims) == {"time", "lon"} + + def test_grouper_prop(self, timeseries): + da0 = timeseries(np.arange(366), start="2000-01-01") + da0 = da0.expand_dims(lat=[1, 2, 3, 4]).chunk() + + @map_groups(data=[Grouper.PROP]) + def func(ds, *, dim): + assert isinstance(dim, list) + d = ds.da0.mean(dim) + return d.rename("data").to_dataset() + + data = func( + xr.Dataset(dict(da0=da0)), + group="time.dayofyear", + window=5, + add_dims=["lat"], + ).load() + assert set(data.data.dims) == {"dayofyear"} + + def test_grouper_prop_main_only(self, timeseries): + da0 = timeseries(np.arange(366), start="2000-01-01") + da0 = da0.expand_dims(lat=[1, 2, 3, 4]).chunk() + + @map_groups(data=[Grouper.PROP], main_only=True) + def func(ds, *, dim): + assert isinstance(dim, str) + data = ds.da0.mean(dim) + return data.rename("data").to_dataset() + + # with a scalar aux coord + data = func( + xr.Dataset(dict(da0=da0.isel(lat=0, drop=True)), coords=dict(leftover=1)), + group="time.dayofyear", + ).load() + assert set(data.data.dims) == {"dayofyear"} + assert "leftover" in data + + def test_raises_error(self, timeseries): + da0 = timeseries(np.arange(366), start="2000-01-01") + da0 = da0.expand_dims(lat=[1, 2, 3, 4]).chunk(lat=1) + + # Test dim parsing + @map_blocks(reduces=["lat"], data=[]) + def func(ds, *, group, lon=None): + return ds.da0.rename("data").to_dataset() + + with pytest.raises(ValueError, match="cannot be chunked"): + func(xr.Dataset(dict(da0=da0)), group="time") + + @pytest.mark.parametrize("use_dask", [True, False]) + def test_dataarray_cfencode(self, use_dask, open_dataset): + ds = open_dataset("sdba/CanESM2_1950-2100.nc") + if use_dask: + ds = ds.chunk() + + @map_blocks(reduces=["location"], data=[]) + def func(ds, *, group): + d = ds.mean("location") + return d.rename("data").to_dataset() + + with set_options(sdba_encode_cf=True): + func(ds.convert_calendar("noleap").tasmax, group=Grouper("time")) From c484509f2ec374342ebf2d695212014078df0262 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 12:05:16 -0400 Subject: [PATCH 002/105] update authorship --- .zenodo.json | 5 +++++ AUTHORS.rst | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/.zenodo.json b/.zenodo.json index 265816f..78f23fb 100644 --- a/.zenodo.json +++ b/.zenodo.json @@ -5,6 +5,11 @@ "name": "Smith, Trevor James", "affiliation": "Ouranos, Montréal, Québec, Canada", "orcid": "0000-0001-5393-8359" + }, + { + "name": "Dupuis, Éric", + "affiliation": "Ouranos, Montréal, Québec, Canada", + "orcid": "0000-0001-7976-4596" } ], "keywords": [ diff --git a/AUTHORS.rst b/AUTHORS.rst index 3c59d7d..c5698c2 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -10,7 +10,7 @@ Development Lead Co-Developers ------------- -None yet. Why not be the first? +* Éric Dupuis `@coxipi `_ Contributors ------------ From a7a91b1339ee731bf054b1d251182d5f641d8e2f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 25 Jul 2024 16:06:46 +0000 Subject: [PATCH 003/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .zenodo.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.zenodo.json b/.zenodo.json index 78f23fb..431f44b 100644 --- a/.zenodo.json +++ b/.zenodo.json @@ -5,7 +5,7 @@ "name": "Smith, Trevor James", "affiliation": "Ouranos, Montréal, Québec, Canada", "orcid": "0000-0001-5393-8359" - }, + }, { "name": "Dupuis, Éric", "affiliation": "Ouranos, Montréal, Québec, Canada", From b830f7fb0bd6f552830638c212bb4b52f10189fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 12:52:32 -0400 Subject: [PATCH 004/105] PASSED: test_nbutils.py --- tests/test_nbutils.py | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 tests/test_nbutils.py diff --git a/tests/test_nbutils.py b/tests/test_nbutils.py new file mode 100644 index 0000000..5364c18 --- /dev/null +++ b/tests/test_nbutils.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr +from xclim.sdba import nbutils as nbu + + +class TestQuantiles: + @pytest.mark.parametrize("uses_dask", [True, False]) + def test_quantile(self, open_dataset, uses_dask): + da = (open_dataset("sdba/CanESM2_1950-2100.nc").sel(time=slice("1950", "1955")).pr).load() + if uses_dask: + da = da.chunk({"location": 1}) + else: + da = da.load() + q = np.linspace(0.1, 0.99, 50) + out_nbu = nbu.quantile(da, q, dim="time").transpose("location", ...) + out_xr = da.quantile(q=q, dim="time").transpose("location", ...) + np.testing.assert_array_almost_equal(out_nbu.values, out_xr.values) + + def test_edge_cases(self): + q = np.linspace(0.1, 0.99, 50) + + # only 1 non-null value + da = xr.DataArray([1] + [np.nan] * 100, dims="dim_0") + out_nbu = nbu.quantile(da, q, dim="dim_0") + np.testing.assert_array_equal(out_nbu.values, np.full_like(q, 1)) + + # only NANs + da = xr.DataArray([np.nan] * 100, dims="dim_0") + out_nbu = nbu.quantile(da, q, dim="dim_0") + np.testing.assert_array_equal(out_nbu.values, np.full_like(q, np.nan)) From 0abb877aec28dee2c299046ba68479be1833b1f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 13:12:05 -0400 Subject: [PATCH 005/105] PASSED: test_utils.py --- src/xsdba/testing.py | 37 ++++++- tests/conftest.py | 6 +- tests/test_utils.py | 225 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 266 insertions(+), 2 deletions(-) create mode 100644 tests/test_utils.py diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 579037b..7cdb0d0 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -1,5 +1,6 @@ """Testing utilities for xsdba.""" +import warnings import hashlib import logging import os @@ -11,8 +12,9 @@ import xarray as xr from platformdirs import user_cache_dir from xarray import open_dataset as _open_dataset +import collections -__all__ = ["test_timeseries"] +__all__ = ["test_timeseries", "test_timelonlatseries"] # keeping xclim-testdata for now, since it's still this on gitHub _default_cache_dir = Path(user_cache_dir("xclim-testdata")) @@ -44,6 +46,39 @@ except ImportError: SocketBlockedError = None +def test_timelonlatseries(values, name, start="2000-01-01"): + """Create a DataArray with time, lon and lat dimensions.""" + coords = collections.OrderedDict() + for dim, n in zip(("time", "lon", "lat"), values.shape): + if dim == "time": + coords[dim] = pd.date_range(start, periods=n, freq="D") + else: + coords[dim] = xr.IndexVariable(dim, np.arange(n)) + + if name == "tas": + attrs = { + "standard_name": "air_temperature", + "cell_methods": "time: mean within days", + "units": "K", + "kind": "+", + } + elif name == "pr": + attrs = { + "standard_name": "precipitation_flux", + "cell_methods": "time: sum over day", + "units": "kg m-2 s-1", + "kind": "*", + } + else: + raise ValueError(f"Name `{name}` not supported.") + + return xr.DataArray( + values, + coords=coords, + dims=list(coords.keys()), + name=name, + attrs=attrs, + ) # XC def test_timeseries( diff --git a/tests/conftest.py b/tests/conftest.py index d41ad10..dc66a6b 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -21,7 +21,7 @@ from xsdba.testing import TESTDATA_BRANCH from xsdba.testing import open_dataset as _open_dataset -from xsdba.testing import test_timeseries +from xsdba.testing import test_timeseries, test_timelonlatseries # import xclim # from xclim import __version__ as __xclim_version__ @@ -89,6 +89,10 @@ def _open_session_scoped_file(file: str | os.PathLike, branch: str = TESTDATA_BR return _open_session_scoped_file +@pytest.fixture +def timelonlatseries(): + return test_timelonlatseries + @pytest.fixture def lat_series(): def _lat_series(values): diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..1b729c2 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,225 @@ +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr +from scipy.stats import norm + +from xclim.sdba import nbutils as nbu +from xclim.sdba import utils as u +from xclim.sdba.base import Grouper + + +def test_ecdf(timelonlatseries, random): + dist = norm(5, 2) + r = dist.rvs(10000, random_state=random) + q = [0.01, 0.5, 0.99] + x = xr.DataArray(dist.ppf(q), dims=("q",)) + np.testing.assert_allclose(u.ecdf(timelonlatseries(r, "tas"), x), q, 3) + + # With NaNs + r[:2000] = np.nan + np.testing.assert_allclose(u.ecdf(timelonlatseries(r, "tas"), x), q, 3) + + +def test_map_cdf(timelonlatseries, random): + n = 10000 + xd = norm(5, 2) + yd = norm(7, 3) + + q = [0.1, 0.5, 0.99] + x_value = u.map_cdf( + xr.Dataset( + dict( + x=timelonlatseries(xd.rvs(n, random_state=random), "pr"), + y=timelonlatseries(yd.rvs(n, random_state=random), "pr"), + ) + ), + y_value=yd.ppf(q), + dim=["time"], + ) + np.testing.assert_allclose(x_value, xd.ppf(q), 0.1) + + # Scalar + q = 0.5 + x_value = u.map_cdf( + xr.Dataset( + dict( + x=timelonlatseries(xd.rvs(n, random_state=random), "pr"), + y=timelonlatseries(yd.rvs(n, random_state=random), "pr"), + ) + ), + y_value=yd.ppf(q), + dim=["time"], + ) + np.testing.assert_allclose(x_value, [xd.ppf(q)], 0.1) + + +def test_equally_spaced_nodes(): + x = u.equally_spaced_nodes(5, eps=1e-4) + assert len(x) == 7 + d = np.diff(x) + np.testing.assert_almost_equal(d[0], d[1] / 2, 3) + + x = u.equally_spaced_nodes(1) + np.testing.assert_almost_equal(x[0], 0.5) + + +@pytest.mark.parametrize( + "interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)] +) +@pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) +def test_interp_on_quantiles_constant(interp, expi, extrap, expe): + quantiles = np.linspace(0, 1, num=25) + xq = xr.DataArray( + np.linspace(205, 229, num=25), + dims=("quantiles",), + coords={"quantiles": quantiles}, + ) + + yq = xr.DataArray( + np.linspace(2, 4.4, num=25), + dims=("quantiles",), + coords={"quantiles": quantiles}, + ) + + newx = xr.DataArray( + np.linspace(240, 200, num=41) - 0.5, + dims=("time",), + coords={"time": xr.cftime_range("1900-03-01", freq="D", periods=41)}, + ) + newx = newx.where(newx > 201) # Put some NaNs in newx + + xq = xq.expand_dims(lat=[1, 2, 3]) + yq = yq.expand_dims(lat=[1, 2, 3]) + newx = newx.expand_dims(lat=[1, 2, 3]) + + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) + + if np.isnan(expe): + assert out.isel(time=0).isnull().all() + else: + assert out.isel(lat=1, time=0) == expe + np.testing.assert_allclose(out.isel(time=25), expi) + assert out.isel(time=-1).isnull().all() + + xq = xq.where(xq != 220) + yq = yq.where(yq != 3) + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) + + if np.isnan(expe): + assert out.isel(time=0).isnull().all() + else: + assert out.isel(lat=1, time=0) == expe + np.testing.assert_allclose(out.isel(time=25), expi) + assert out.isel(time=-1).isnull().all() + + +def test_interp_on_quantiles_monthly(random): + t = xr.cftime_range("2000-01-01", "2030-12-31", freq="D", calendar="noleap") + ref = xr.DataArray( + ( + -20 * np.cos(2 * np.pi * t.dayofyear / 365) + + 2 * random.random(t.size) + + 273.15 + + 0.1 * (t - t[0]).days / 365 + ), # "warming" of 1K per decade, + dims=("time",), + coords={"time": t}, + attrs={"units": "K"}, + ) + sim = xr.DataArray( + ( + -18 * np.cos(2 * np.pi * t.dayofyear / 365) + + 2 * random.random(t.size) + + 273.15 + + 0.11 * (t - t[0]).days / 365 + ), # "warming" of 1.1K per decade + dims=("time",), + coords={"time": t}, + attrs={"units": "K"}, + ) + + ref = ref.sel(time=slice(None, "2015-01-01")) + hist = sim.sel(time=slice(None, "2015-01-01")) + + group = Grouper("time.month") + quantiles = u.equally_spaced_nodes(15, eps=1e-6) + ref_q = group.apply(nbu.quantile, ref, main_only=True, q=quantiles) + hist_q = group.apply(nbu.quantile, hist, main_only=True, q=quantiles) + af = u.get_correction(hist_q, ref_q, "+") + + for interp in ["nearest", "linear", "cubic"]: + afi = u.interp_on_quantiles( + sim, hist_q, af, group="time.month", method=interp, extrapolation="constant" + ) + assert afi.isnull().sum("time") == 0, interp + + +@pytest.mark.parametrize( + "interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)] +) +@pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) +def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): + quantiles = np.linspace(0, 1, num=30) + xq = xr.DataArray( + np.append(np.linspace(205, 229, num=25), [np.nan] * 5), + dims=("quantiles",), + coords={"quantiles": quantiles}, + ) + + yq = xr.DataArray( + np.append(np.linspace(2, 4.4, num=25), [np.nan] * 5), + dims=("quantiles",), + coords={"quantiles": quantiles}, + ) + + newx = xr.DataArray( + np.linspace(240, 200, num=41) - 0.5, + dims=("time",), + coords={"time": xr.cftime_range("1900-03-01", freq="D", periods=41)}, + ) + newx = newx.where(newx > 201) # Put some NaNs in newx + + xq = xq.expand_dims(lat=[1, 2, 3]) + yq = yq.expand_dims(lat=[1, 2, 3]) + newx = newx.expand_dims(lat=[1, 2, 3]) + + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) + + if np.isnan(expe): + assert out.isel(time=0).isnull().all() + else: + assert out.isel(lat=1, time=0) == expe + np.testing.assert_allclose(out.isel(time=25), expi) + assert out.isel(time=-1).isnull().all() + + xq = xq.where(xq != 220) + yq = yq.where(yq != 3) + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) + + if np.isnan(expe): + assert out.isel(time=0).isnull().all() + else: + assert out.isel(lat=1, time=0) == expe + np.testing.assert_allclose(out.isel(time=25), expi) + assert out.isel(time=-1).isnull().all() + + +def test_rank(random): + arr = random.random((10, 10, 1000)) + da = xr.DataArray(arr, dims=("x", "y", "time")) + + ranks = u.rank(da, dim="time", pct=False) + + exp = arr.argsort().argsort() + 1 + + np.testing.assert_array_equal(ranks.values, exp) From 44f108d11ebd5b81b21979ed117c8c32a1590b10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 13:53:10 -0400 Subject: [PATCH 006/105] True xclim independance (oops) --- src/xsdba/base.py | 72 +++++++++++++++++++++++++++++++++++++++++-- src/xsdba/options.py | 2 +- src/xsdba/testing.py | 21 +++++++++++++ src/xsdba/utils.py | 69 ++--------------------------------------- tests/test_nbutils.py | 2 +- tests/test_utils.py | 7 +++-- 6 files changed, 98 insertions(+), 75 deletions(-) diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 8b254d1..cfe2ec1 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -14,9 +14,9 @@ import numpy as np import xarray as xr from boltons.funcutils import wraps -from xclim.core.calendar import get_calendar -from xclim.core.options import OPTIONS, SDBA_ENCODE_CF -from xclim.core.utils import uses_dask +from xsdba.options import OPTIONS, SDBA_ENCODE_CF +import datetime as pydt +import cftime # ## Base class for the sdba module @@ -94,6 +94,72 @@ def set_dataset(self, ds: xr.Dataset) -> None: self.ds = ds self.ds.attrs[self._attribute] = jsonpickle.encode(self) +# XC put here to avoid circular import +def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: + """Evaluate whether dask is installed and array is loaded as a dask array. + + Parameters + ---------- + das: xr.DataArray or xr.Dataset + DataArrays or Datasets to check. + + Returns + ------- + bool + True if any of the passed objects is using dask. + """ + if len(das) > 1: + return any([uses_dask(da) for da in das]) + da = das[0] + if isinstance(da, xr.DataArray) and isinstance(da.data, dsk.Array): + return True + if isinstance(da, xr.Dataset) and any(isinstance(var.data, dsk.Array) for var in da.variables.values()): + return True + return False + + +# XC put here to avoid circular import +def get_calendar(obj: Any, dim: str = "time") -> str: + """Return the calendar of an object. + + Parameters + ---------- + obj : Any + An object defining some date. + If `obj` is an array/dataset with a datetime coordinate, use `dim` to specify its name. + Values must have either a datetime64 dtype or a cftime dtype. + `obj` can also be a python datetime.datetime, a cftime object or a pandas Timestamp + or an iterable of those, in which case the calendar is inferred from the first value. + dim : str + Name of the coordinate to check (if `obj` is a DataArray or Dataset). + + Raises + ------ + ValueError + If no calendar could be inferred. + + Returns + ------- + str + The Climate and Forecasting (CF) calendar name. + Will always return "standard" instead of "gregorian", following CF conventions 1.9. + """ + if isinstance(obj, (xr.DataArray, xr.Dataset)): + return obj[dim].dt.calendar + elif isinstance(obj, xr.CFTimeIndex): + obj = obj.values[0] + else: + obj = np.take(obj, 0) + # Take zeroth element, overcome cases when arrays or lists are passed. + if isinstance(obj, pydt.datetime): # Also covers pandas Timestamp + return "standard" + if isinstance(obj, cftime.datetime): + if obj.calendar == "gregorian": + return "standard" + return obj.calendar + + raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") + class Grouper(Parametrizable): """Grouper inherited class for parameterizable classes.""" diff --git a/src/xsdba/options.py b/src/xsdba/options.py index 2c8e142..0ceb6dc 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -12,7 +12,7 @@ from boltons.funcutils import wraps # from .locales import _valid_locales # from XC, not reproduced for now -from .utils import ValidationError, raise_warn_or_log +from .logging import ValidationError, raise_warn_or_log # METADATA_LOCALES = "metadata_locales" DATA_VALIDATION = "data_validation" diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 7cdb0d0..1ce7bda 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -7,6 +7,7 @@ from pathlib import Path from urllib.error import HTTPError, URLError from urllib.request import urlopen, urlretrieve +from urllib.parse import urljoin, urlparse import pandas as pd import xarray as xr @@ -112,6 +113,26 @@ def file_md5_checksum(f_name): hash_md5.update(f.read()) return hash_md5.hexdigest() +# XC +def audit_url(url: str, context: str = None) -> str: + """Check if the URL is well-formed. + + Raises + ------ + URLError + If the URL is not well-formed. + """ + msg = "" + result = urlparse(url) + if result.scheme == "http": + msg = f"{context if context else ''} URL is not using secure HTTP: '{url}'".strip() + if not all([result.scheme, result.netloc]): + msg = f"{context if context else ''} URL is not well-formed: '{url}'".strip() + + if msg: + logger.error(msg) + raise URLError(msg) + return url # XC (oh dear) def _get( diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 2a9a27e..34b6a6b 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -9,6 +9,7 @@ from typing import Callable from warnings import warn + import numpy as np import xarray as xr from boltons.funcutils import wraps @@ -17,57 +18,13 @@ from scipy.stats import spearmanr from xarray.core.utils import get_temp_dimname -from .base import Grouper, parse_group +from .base import Grouper, parse_group, uses_dask from .nbutils import _extrapolate_on_quantiles MULTIPLICATIVE = "*" ADDITIVE = "+" -# XC -class ValidationError(ValueError): - """Error raised when input data to an indicator fails the validation tests.""" - - @property - def msg(self): # noqa - return self.args[0] - - -# XC -def raise_warn_or_log( - err: Exception, - mode: str, - msg: str | None = None, - err_type: type = ValueError, - stacklevel: int = 1, -): - """Raise, warn or log an error according. - - Parameters - ---------- - err : Exception - An error. - mode : {'ignore', 'log', 'warn', 'raise'} - What to do with the error. - msg : str, optional - The string used when logging or warning. - Defaults to the `msg` attr of the error (if present) or to "Failed with ". - err_type : type - The type of error/exception to raise. - stacklevel : int - Stacklevel when warning. Relative to the call of this function (1 is added). - """ - message = msg or getattr(err, "msg", f"Failed with {err!r}.") - if mode == "ignore": - pass - elif mode == "log": - logger.info(message) - elif mode == "warn": - warnings.warn(message, stacklevel=stacklevel + 1) - else: # mode == "raise" - raise err from err_type(message) - - def _ecdf_1d(x, value): sx = np.r_[-np.inf, np.sort(x, axis=None)] return np.searchsorted(sx, value, side="right") / np.sum(~np.isnan(sx)) @@ -138,28 +95,6 @@ def ecdf(x: xr.DataArray, value: float, dim: str = "time") -> xr.DataArray: return (x <= value).sum(dim) / x.notnull().sum(dim) -# XC -def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: - """Evaluate whether dask is installed and array is loaded as a dask array. - - Parameters - ---------- - das: xr.DataArray or xr.Dataset - DataArrays or Datasets to check. - - Returns - ------- - bool - True if any of the passed objects is using dask. - """ - if len(das) > 1: - return any([uses_dask(da) for da in das]) - da = das[0] - if isinstance(da, xr.DataArray) and isinstance(da.data, dsk.Array): - return True - if isinstance(da, xr.Dataset) and any(isinstance(var.data, dsk.Array) for var in da.variables.values()): - return True - return False # XC diff --git a/tests/test_nbutils.py b/tests/test_nbutils.py index 5364c18..e67e98e 100644 --- a/tests/test_nbutils.py +++ b/tests/test_nbutils.py @@ -3,7 +3,7 @@ import numpy as np import pytest import xarray as xr -from xclim.sdba import nbutils as nbu +from xsdba import nbutils as nbu class TestQuantiles: diff --git a/tests/test_utils.py b/tests/test_utils.py index 1b729c2..c45d43a 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -5,9 +5,10 @@ import xarray as xr from scipy.stats import norm -from xclim.sdba import nbutils as nbu -from xclim.sdba import utils as u -from xclim.sdba.base import Grouper +from xsdba import nbutils as nbu +from xsdba import utils as u +from xsdba.base import Grouper + def test_ecdf(timelonlatseries, random): From bee1a17d848d9622c8364147e20144cc5450fb41 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 25 Jul 2024 17:54:53 +0000 Subject: [PATCH 007/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/base.py | 6 ++++-- src/xsdba/testing.py | 14 +++++++++----- src/xsdba/utils.py | 3 --- tests/conftest.py | 3 ++- tests/test_nbutils.py | 1 + tests/test_utils.py | 39 +++++++++------------------------------ 6 files changed, 25 insertions(+), 41 deletions(-) diff --git a/src/xsdba/base.py b/src/xsdba/base.py index cfe2ec1..598d981 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -5,18 +5,19 @@ from __future__ import annotations +import datetime as pydt from collections.abc import Sequence from inspect import _empty, signature # noqa from typing import Callable +import cftime import dask.array as dsk import jsonpickle import numpy as np import xarray as xr from boltons.funcutils import wraps + from xsdba.options import OPTIONS, SDBA_ENCODE_CF -import datetime as pydt -import cftime # ## Base class for the sdba module @@ -94,6 +95,7 @@ def set_dataset(self, ds: xr.Dataset) -> None: self.ds = ds self.ds.attrs[self._attribute] = jsonpickle.encode(self) + # XC put here to avoid circular import def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: """Evaluate whether dask is installed and array is loaded as a dask array. diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 1ce7bda..e2b3a76 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -1,21 +1,21 @@ """Testing utilities for xsdba.""" -import warnings +import collections import hashlib import logging import os +import warnings from pathlib import Path from urllib.error import HTTPError, URLError -from urllib.request import urlopen, urlretrieve from urllib.parse import urljoin, urlparse +from urllib.request import urlopen, urlretrieve import pandas as pd import xarray as xr from platformdirs import user_cache_dir from xarray import open_dataset as _open_dataset -import collections -__all__ = ["test_timeseries", "test_timelonlatseries"] +__all__ = ["test_timelonlatseries", "test_timeseries"] # keeping xclim-testdata for now, since it's still this on gitHub _default_cache_dir = Path(user_cache_dir("xclim-testdata")) @@ -47,6 +47,7 @@ except ImportError: SocketBlockedError = None + def test_timelonlatseries(values, name, start="2000-01-01"): """Create a DataArray with time, lon and lat dimensions.""" coords = collections.OrderedDict() @@ -81,6 +82,7 @@ def test_timelonlatseries(values, name, start="2000-01-01"): attrs=attrs, ) + # XC def test_timeseries( values, @@ -113,7 +115,8 @@ def file_md5_checksum(f_name): hash_md5.update(f.read()) return hash_md5.hexdigest() -# XC + +# XC def audit_url(url: str, context: str = None) -> str: """Check if the URL is well-formed. @@ -134,6 +137,7 @@ def audit_url(url: str, context: str = None) -> str: raise URLError(msg) return url + # XC (oh dear) def _get( fullname: Path, diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 34b6a6b..4d2a6ad 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -9,7 +9,6 @@ from typing import Callable from warnings import warn - import numpy as np import xarray as xr from boltons.funcutils import wraps @@ -95,8 +94,6 @@ def ecdf(x: xr.DataArray, value: float, dim: str = "time") -> xr.DataArray: return (x <= value).sum(dim) / x.notnull().sum(dim) - - # XC def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: r"""Ensure that the input DataArray has chunks of at least the given size. diff --git a/tests/conftest.py b/tests/conftest.py index dc66a6b..b4039c0 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -21,7 +21,7 @@ from xsdba.testing import TESTDATA_BRANCH from xsdba.testing import open_dataset as _open_dataset -from xsdba.testing import test_timeseries, test_timelonlatseries +from xsdba.testing import test_timelonlatseries, test_timeseries # import xclim # from xclim import __version__ as __xclim_version__ @@ -93,6 +93,7 @@ def _open_session_scoped_file(file: str | os.PathLike, branch: str = TESTDATA_BR def timelonlatseries(): return test_timelonlatseries + @pytest.fixture def lat_series(): def _lat_series(values): diff --git a/tests/test_nbutils.py b/tests/test_nbutils.py index e67e98e..a539826 100644 --- a/tests/test_nbutils.py +++ b/tests/test_nbutils.py @@ -3,6 +3,7 @@ import numpy as np import pytest import xarray as xr + from xsdba import nbutils as nbu diff --git a/tests/test_utils.py b/tests/test_utils.py index c45d43a..aa0085d 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -10,7 +10,6 @@ from xsdba.base import Grouper - def test_ecdf(timelonlatseries, random): dist = norm(5, 2) r = dist.rvs(10000, random_state=random) @@ -66,9 +65,7 @@ def test_equally_spaced_nodes(): np.testing.assert_almost_equal(x[0], 0.5) -@pytest.mark.parametrize( - "interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)] -) +@pytest.mark.parametrize("interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)]) @pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) def test_interp_on_quantiles_constant(interp, expi, extrap, expe): quantiles = np.linspace(0, 1, num=25) @@ -95,9 +92,7 @@ def test_interp_on_quantiles_constant(interp, expi, extrap, expe): yq = yq.expand_dims(lat=[1, 2, 3]) newx = newx.expand_dims(lat=[1, 2, 3]) - out = u.interp_on_quantiles( - newx, xq, yq, group="time", method=interp, extrapolation=extrap - ) + out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) if np.isnan(expe): assert out.isel(time=0).isnull().all() @@ -108,9 +103,7 @@ def test_interp_on_quantiles_constant(interp, expi, extrap, expe): xq = xq.where(xq != 220) yq = yq.where(yq != 3) - out = u.interp_on_quantiles( - newx, xq, yq, group="time", method=interp, extrapolation=extrap - ) + out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) if np.isnan(expe): assert out.isel(time=0).isnull().all() @@ -124,10 +117,7 @@ def test_interp_on_quantiles_monthly(random): t = xr.cftime_range("2000-01-01", "2030-12-31", freq="D", calendar="noleap") ref = xr.DataArray( ( - -20 * np.cos(2 * np.pi * t.dayofyear / 365) - + 2 * random.random(t.size) - + 273.15 - + 0.1 * (t - t[0]).days / 365 + -20 * np.cos(2 * np.pi * t.dayofyear / 365) + 2 * random.random(t.size) + 273.15 + 0.1 * (t - t[0]).days / 365 ), # "warming" of 1K per decade, dims=("time",), coords={"time": t}, @@ -135,10 +125,7 @@ def test_interp_on_quantiles_monthly(random): ) sim = xr.DataArray( ( - -18 * np.cos(2 * np.pi * t.dayofyear / 365) - + 2 * random.random(t.size) - + 273.15 - + 0.11 * (t - t[0]).days / 365 + -18 * np.cos(2 * np.pi * t.dayofyear / 365) + 2 * random.random(t.size) + 273.15 + 0.11 * (t - t[0]).days / 365 ), # "warming" of 1.1K per decade dims=("time",), coords={"time": t}, @@ -155,15 +142,11 @@ def test_interp_on_quantiles_monthly(random): af = u.get_correction(hist_q, ref_q, "+") for interp in ["nearest", "linear", "cubic"]: - afi = u.interp_on_quantiles( - sim, hist_q, af, group="time.month", method=interp, extrapolation="constant" - ) + afi = u.interp_on_quantiles(sim, hist_q, af, group="time.month", method=interp, extrapolation="constant") assert afi.isnull().sum("time") == 0, interp -@pytest.mark.parametrize( - "interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)] -) +@pytest.mark.parametrize("interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)]) @pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): quantiles = np.linspace(0, 1, num=30) @@ -190,9 +173,7 @@ def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): yq = yq.expand_dims(lat=[1, 2, 3]) newx = newx.expand_dims(lat=[1, 2, 3]) - out = u.interp_on_quantiles( - newx, xq, yq, group="time", method=interp, extrapolation=extrap - ) + out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) if np.isnan(expe): assert out.isel(time=0).isnull().all() @@ -203,9 +184,7 @@ def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): xq = xq.where(xq != 220) yq = yq.where(yq != 3) - out = u.interp_on_quantiles( - newx, xq, yq, group="time", method=interp, extrapolation=extrap - ) + out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) if np.isnan(expe): assert out.isel(time=0).isnull().all() From b15a67caf8ff50fa5769f7c9539d0178763ef12b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 13:56:04 -0400 Subject: [PATCH 008/105] new file forgotten --- src/xsdba/logging.py | 55 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 src/xsdba/logging.py diff --git a/src/xsdba/logging.py b/src/xsdba/logging.py new file mode 100644 index 0000000..0415091 --- /dev/null +++ b/src/xsdba/logging.py @@ -0,0 +1,55 @@ +""" +Logging utilities +================================ +""" + +from __future__ import annotations +import logging as _logging +import warnings + +logger = _logging.getLogger("xsdba") + + +# XC put here to avoid circular import +class ValidationError(ValueError): + """Error raised when input data to an indicator fails the validation tests.""" + + @property + def msg(self): # noqa + return self.args[0] + + +# XC put here to avoid circular import +def raise_warn_or_log( + err: Exception, + mode: str, + msg: str | None = None, + err_type: type = ValueError, + stacklevel: int = 1, +): + """Raise, warn or log an error according. + + Parameters + ---------- + err : Exception + An error. + mode : {'ignore', 'log', 'warn', 'raise'} + What to do with the error. + msg : str, optional + The string used when logging or warning. + Defaults to the `msg` attr of the error (if present) or to "Failed with ". + err_type : type + The type of error/exception to raise. + stacklevel : int + Stacklevel when warning. Relative to the call of this function (1 is added). + """ + message = msg or getattr(err, "msg", f"Failed with {err!r}.") + if mode == "ignore": + pass + elif mode == "log": + logger.info(message) + elif mode == "warn": + warnings.warn(message, stacklevel=stacklevel + 1) + else: # mode == "raise" + raise err from err_type(message) + From ebc94577162bf4125a2069d8a61d941cf5191ed2 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 25 Jul 2024 17:59:22 +0000 Subject: [PATCH 009/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/logging.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/xsdba/logging.py b/src/xsdba/logging.py index 0415091..630f8d3 100644 --- a/src/xsdba/logging.py +++ b/src/xsdba/logging.py @@ -4,6 +4,7 @@ """ from __future__ import annotations + import logging as _logging import warnings @@ -52,4 +53,3 @@ def raise_warn_or_log( warnings.warn(message, stacklevel=stacklevel + 1) else: # mode == "raise" raise err from err_type(message) - From 6546d4486b1b9c80218108c0d9ea0ab6f488fc74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 14:02:16 -0400 Subject: [PATCH 010/105] PASSED: test_loess.py --- src/xsdba/loess.py | 278 ++++++++++++++++++++++++++++++++++++++++++++ tests/test_loess.py | 85 ++++++++++++++ 2 files changed, 363 insertions(+) create mode 100644 src/xsdba/loess.py create mode 100644 tests/test_loess.py diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py new file mode 100644 index 0000000..abb1548 --- /dev/null +++ b/src/xsdba/loess.py @@ -0,0 +1,278 @@ +""" +LOESS Smoothing Submodule +========================= +""" + +from __future__ import annotations + +from typing import Callable +from warnings import warn + +import numba +import numpy as np +import xarray as xr + + +@numba.njit +def _gaussian_weighting(x): # pragma: no cover + """ + Kernel function for loess with a gaussian shape. + + The span f covers 95% of the gaussian. + """ + w = np.exp(-(x**2) / (2 * (1 / 1.96) ** 2)) + w[x >= 1] = 0 + return w + + +@numba.njit +def _tricube_weighting(x): # pragma: no cover + """Kernel function for loess with a tricubic shape.""" + w = (1 - x**3) ** 3 + w[x >= 1] = 0 + return w + + +@numba.njit +def _constant_regression(xi, x, y, w): # pragma: no cover + return (w * y).sum() / w.sum() + + +@numba.njit +def _linear_regression(xi, x, y, w): # pragma: no cover + b = np.array([np.sum(w * y), np.sum(w * y * x)]) + A = np.array([[np.sum(w), np.sum(w * x)], [np.sum(w * x), np.sum(w * x * x)]]) + beta = np.linalg.solve(A, b) + return beta[0] + beta[1] * xi + + +@numba.njit +def _loess_nb( + x, + y, + f=0.5, + niter=2, + weight_func=_tricube_weighting, + reg_func=_linear_regression, + dx=0, + skipna=True, +): # pragma: no cover + """1D Locally weighted regression: fits a nonparametric regression curve to a scatter plot. + + The arrays x and y contain an equal number of elements; each pair (x[i], y[i]) defines + a data point in the scatter plot. The function returns the estimated (smooth) values of y. + Originally proposed in :cite:t:`sdba-cleveland_robust_1979`. + + Users should call `utils.loess_smoothing`. See that function for the main documentation. + + Parameters + ---------- + x : np.ndarray + X-coordinates of the points. + y : np.ndarray + Y-coordinates of the points. + f : float + Parameter controlling the shape of the weight curve. Behavior depends on the weighting function. + niter : int + Number of robustness iterations to execute. + weight_func : numba func + Numba function giving the weights when passed abs(x - xi) / hi + dx : float + The spacing of the x coordinates. If above 0, this enables the optimization for equally spaced x coordinates. + Must be 0 if spacing is unequal (default). + skipna : bool + If True (default), remove NaN values before computing the loess. The output has the + same missing values as the input. + + References + ---------- + :cite:cts:`sdba-cleveland_robust_1979` + + Code adapted from: :cite:cts:`sdba-gramfort_lowess_2015` + """ + if skipna: + nan = np.isnan(y) + out = np.full(x.size, np.NaN) + y = y[~nan] + x = x[~nan] + if x.size == 0: + return out + + n = x.size + yest = np.zeros(n) + delta = np.ones(n) + + # Number of points included in the weights calculation + if dx == 0: + # No opt. directly the nearest int + r = int(np.round(f * n)) + # With unequal spacing, the rth closest point could be up to r points on either size. + HW = min(r + 2, n) + R = min(2 * HW, n) + else: + # Equal spacing, the nearest odd number equal or above f * n + r = int(2 * (f * n // 2) + 1) + # half width of the weights + hw = int((r - 1) / 2) + # Number of values sent to the weight func. Just a bit larger than the window. + R = min(r + 4, n) + HW = hw + 2 + + for iteration in range(niter): + for i in range(n): + # We can pass only a subset of the arrays as we already know where the rth closest point will be. + if i < HW: + xi = x[:R] + yi = y[:R] + di = delta[:R] + elif i >= n - HW - 1: + di = delta[n - R :] + xi = x[n - R :] + yi = y[n - R :] + else: + di = delta[i - HW : i + HW + 1] + xi = x[i - HW : i + HW + 1] + yi = y[i - HW : i + HW + 1] + + if dx > 0: + # When x is equally spaced, we don't need to recompute the weights each time. + # We can also skip the sorting part. + # However, contrary to a moving mean, the weights change shape near the edges + if i <= HW or i >= n - HW: + # Near the edges and on the first iteration away from them, + # compute the weights. + diffs = np.abs(xi - x[i]) + + if i < hw: + h = (r - i) * dx + elif i >= n - hw: + h = (i - (n - r) + 1) * dx + else: + h = (hw + 1) * dx + wi = weight_func(diffs / h) + # Is it expected that `wi` always be assigned before first being called? + w = di * wi # pylint: disable=E0606 + else: + # The weights computation is repeated niter times + # The distance of points from the current centre point. + diffs = np.abs(xi - x[i]) + # h is the distance of the rth closest point. + h = np.sort(diffs)[r] + # The weights will be 0 everywhere diffs > h. + w = di * weight_func(diffs / h) + yest[i] = reg_func(x[i], xi, yi, w) + + if iteration < niter - 1: + residuals = y - yest + s = np.median(np.abs(residuals)) + xres = residuals / (6.0 * s) + delta = (1 - xres**2) ** 2 + delta[np.abs(xres) >= 1] = 0 + + if skipna: + out[~nan] = yest + return out + return yest + + +def loess_smoothing( + da: xr.DataArray, + dim: str = "time", + d: int = 1, + f: float = 0.5, + niter: int = 2, + weights: str | Callable = "tricube", + equal_spacing: bool | None = None, + skipna: bool = True, +): + r"""Locally weighted regression in 1D: fits a nonparametric regression curve to a scatter plot. + + Returns a smoothed curve along given dimension. The regression is computed for each point using a subset of + neighbouring points as given from evaluating the weighting function locally. + Follows the procedure of :cite:t:`sdba-cleveland_robust_1979`. + + Parameters + ---------- + da: xr.DataArray + The data to smooth using the loess approach. + dim : str + Name of the dimension along which to perform the loess. + d : [0, 1] + Degree of the local regression. + f : float + Parameter controlling the shape of the weight curve. Behavior depends on the weighting function, + but it usually represents the span of the weighting function in reference to x-coordinates + normalized from 0 to 1. + niter : int + Number of robustness iterations to execute. + weights : ["tricube", "gaussian"] or callable + Shape of the weighting function, see notes. The user can provide a function or a string: + "tricube" : a smooth top-hat like curve. + "gaussian" : a gaussian curve, f gives the span for 95% of the values. + equal_spacing : bool, optional + Whether to use the equal spacing optimization. If `None` (the default), it is activated only if the + x-axis is equally-spaced. When activated, `dx = x[1] - x[0]`. + skipna : bool + If True (default), skip missing values (as marked by NaN). The output will have the + same missing values as the input. + + Notes + ----- + As stated in :cite:t:`sdba-cleveland_robust_1979`, the weighting function :math:`W(x)` should respect the following + conditions: + + - :math:`W(x) > 0` for :math:`|x| < 1` + - :math:`W(-x) = W(x)` + - :math:`W(x)` is non-increasing for :math:`x \ge 0` + - :math:`W(x) = 0` for :math:`|x| \ge 0` + + If a Callable is provided, it should only accept the 1D `np.ndarray` :math:`x` which is an absolute value + function going from 1 to 0 to 1 around :math:`x_i`, for all values where :math:`x - x_i < h_i` with + :math:`h_i` the distance of the rth nearest neighbor of :math:`x_i`, :math:`r = f * size(x)`. + + References + ---------- + :cite:cts:`sdba-cleveland_robust_1979` + + Code adapted from: :cite:cts:`sdba-gramfort_lowess_2015` + """ + x = da[dim] + x = ((x - x[0]) / (x[-1] - x[0])).astype(float) + + weight_func = {"tricube": _tricube_weighting, "gaussian": _gaussian_weighting}.get( + weights, weights + ) + + reg_func = {0: _constant_regression, 1: _linear_regression}[d] + + diffx = np.diff(da[dim]) + if np.all(diffx == diffx[0]): + if equal_spacing is None: + equal_spacing = True + elif equal_spacing: + warn( + "The equal spacing optimization was requested, but the x axis is not equally spaced. Strange results might occur." + ) + if equal_spacing: + dx = float(x[1] - x[0]) + else: + dx = 0 + + return xr.apply_ufunc( + _loess_nb, + x, + da, + input_core_dims=[[dim], [dim]], + output_core_dims=[[dim]], + vectorize=True, + kwargs={ + "f": f, + "weight_func": weight_func, + "niter": niter, + "reg_func": reg_func, + "dx": dx, + "skipna": skipna, + }, + dask="parallelized", + output_dtypes=[float], + ) diff --git a/tests/test_loess.py b/tests/test_loess.py new file mode 100644 index 0000000..aac12a0 --- /dev/null +++ b/tests/test_loess.py @@ -0,0 +1,85 @@ +from __future__ import annotations + +import numpy as np +import pandas as pd +import pytest +import xarray as xr + +from xsdba.loess import _constant_regression # noqa +from xsdba.loess import _gaussian_weighting # noqa +from xsdba.loess import _linear_regression # noqa +from xsdba.loess import _loess_nb # noqa +from xsdba.loess import _tricube_weighting # noqa +from xsdba.loess import loess_smoothing + + +@pytest.mark.slow +@pytest.mark.parametrize( + "d,f,w,n,dx,exp", + [ + (0, 0.2, _tricube_weighting, 1, False, [-0.0698081, -0.3623449]), + (0, 0.31, _tricube_weighting, 2, True, [-0.0052623, -0.1453554]), + (1, 0.2, _tricube_weighting, 3, True, [-0.0555941, -0.9219777]), + (1, 0.2, _tricube_weighting, 4, False, [-0.0691396, -0.9155697]), + (1, 0.4, _gaussian_weighting, 2, False, [0.00287228, -0.4469015]), + ], +) +def test_loess_nb(d, f, w, n, dx, exp): + regfun = {0: _constant_regression, 1: _linear_regression}[d] + x = np.linspace(0, 1, num=100) + y = np.sin(x * np.pi * 10) + ys = _loess_nb( # dx is non 0 if dx is True + x, y, f=f, reg_func=regfun, weight_func=w, niter=n, dx=(x[1] - x[0]) * int(dx) + ) + + assert np.isclose(ys[50], exp[0]) + assert np.isclose(ys[-1], exp[1]) + + +@pytest.mark.slow +@pytest.mark.parametrize("use_dask", [True, False]) +def test_loess_smoothing(use_dask, open_dataset): + tas = open_dataset( + "cmip3/tas.sresb1.giss_model_e_r.run1.atm.da.nc", + chunks={"lat": 1} if use_dask else None, + ).tas.isel(lon=0, time=slice(0, 740)) + tas = tas.where(tas.time.dt.dayofyear != 360) # Put NaNs + + tasmooth = loess_smoothing(tas, f=0.1).load() + + np.testing.assert_allclose(tasmooth.isel(lat=0, time=0), 263.19834) + np.testing.assert_array_equal(tasmooth.isnull(), tas.isnull().T) + + # Same but with one missing time, so the x axis is not equally spaced + tas2 = tas.where(tas.time != tas.time[-3], drop=True) + tasmooth2 = loess_smoothing(tas2, f=0.1) + + np.testing.assert_allclose( + tasmooth.isel(time=slice(None, 700)), + tasmooth2.isel(time=slice(None, 700)), + rtol=1e-3, + atol=1e-2, + ) + + # Same but we force not to use the optimization + tasmooth3 = loess_smoothing(tas, f=0.1, equal_spacing=False) + np.testing.assert_allclose(tasmooth, tasmooth3, rtol=1e-3, atol=1e-3) + + +@pytest.mark.slow +@pytest.mark.parametrize("use_dask", [True, False]) +def test_loess_smoothing_nan(use_dask): + # create data with one axis full of nan + data = np.random.randn(2, 2, 10) + data[0, 0] = [np.nan] * 10 + da = xr.DataArray( + data, + dims=["scenario", "model", "time"], + coords={"time": pd.date_range("2000-01-01", periods=10, freq="YS")}, + ).chunk({"time": -1}) + + out = loess_smoothing(da) + + assert out.dims == da.dims + # check that the output is all nan on the axis with nan in the input + assert np.isnan(out.values[0, 0]).all() From eb0fe2d4853d0693ceb859c2d234f60d7e4e83ff Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 25 Jul 2024 18:03:05 +0000 Subject: [PATCH 011/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/loess.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py index abb1548..3125d22 100644 --- a/src/xsdba/loess.py +++ b/src/xsdba/loess.py @@ -239,9 +239,7 @@ def loess_smoothing( x = da[dim] x = ((x - x[0]) / (x[-1] - x[0])).astype(float) - weight_func = {"tricube": _tricube_weighting, "gaussian": _gaussian_weighting}.get( - weights, weights - ) + weight_func = {"tricube": _tricube_weighting, "gaussian": _gaussian_weighting}.get(weights, weights) reg_func = {0: _constant_regression, 1: _linear_regression}[d] @@ -250,9 +248,7 @@ def loess_smoothing( if equal_spacing is None: equal_spacing = True elif equal_spacing: - warn( - "The equal spacing optimization was requested, but the x axis is not equally spaced. Strange results might occur." - ) + warn("The equal spacing optimization was requested, but the x axis is not equally spaced. Strange results might occur.") if equal_spacing: dx = float(x[1] - x[0]) else: From 4a3c7c1652688415c3a589dca4ab9f7f33969be1 Mon Sep 17 00:00:00 2001 From: Zeitsperre <10819524+Zeitsperre@users.noreply.github.com> Date: Thu, 25 Jul 2024 14:59:43 -0400 Subject: [PATCH 012/105] disable ruff autoformat, add rst directives to .flake8 --- .flake8 | 5 ++ .pre-commit-config.yaml | 2 +- src/xsdba/base.py | 153 ++++++++++++++++++++++++++++++++-------- src/xsdba/loess.py | 8 ++- src/xsdba/nbutils.py | 34 ++++++--- src/xsdba/options.py | 4 +- src/xsdba/testing.py | 28 ++++++-- src/xsdba/utils.py | 76 +++++++++++++++----- tests/conftest.py | 16 ++++- tests/test_base.py | 17 +++-- tests/test_nbutils.py | 4 +- tests/test_utils.py | 38 +++++++--- 12 files changed, 303 insertions(+), 82 deletions(-) diff --git a/.flake8 b/.flake8 index 2112ec1..b2a7481 100644 --- a/.flake8 +++ b/.flake8 @@ -25,3 +25,8 @@ rst-roles = py:mod, py:obj, py:ref + ref, + cite:cts, + cite:p, + cite:t, + cite:ts diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ac86390..7f5c90d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -46,7 +46,7 @@ repos: hooks: - id: ruff args: [ '--fix' ] - - id: ruff-format +# - id: ruff-format - repo: https://github.com/pycqa/flake8 rev: 7.1.0 hooks: diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 598d981..66c44a9 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -66,7 +66,13 @@ def __repr__(self) -> str: } # The representation only includes the parameters with a value different from their default # and those not explicitly excluded. - params = ", ".join([f"{k}={v!r}" for k, v in self.items() if k not in self._repr_hide_params and v not in defaults.get(k, [])]) + params = ", ".join( + [ + f"{k}={v!r}" + for k, v in self.items() + if k not in self._repr_hide_params and v not in defaults.get(k, []) + ] + ) return f"{self.__class__.__name__}({params})" @@ -115,7 +121,9 @@ def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: da = das[0] if isinstance(da, xr.DataArray) and isinstance(da.data, dsk.Array): return True - if isinstance(da, xr.Dataset) and any(isinstance(var.data, dsk.Array) for var in da.variables.values()): + if isinstance(da, xr.Dataset) and any( + isinstance(var.data, dsk.Array) for var in da.variables.values() + ): return True return False @@ -251,14 +259,21 @@ def get_coordinate(self, ds: xr.Dataset | None = None) -> xr.DataArray: if self.prop == "month": return xr.DataArray(np.arange(1, 13), dims=("month",), name="month") if self.prop == "season": - return xr.DataArray(["DJF", "MAM", "JJA", "SON"], dims=("season",), name="season") + return xr.DataArray( + ["DJF", "MAM", "JJA", "SON"], dims=("season",), name="season" + ) if self.prop == "dayofyear": if ds is not None: cal = get_calendar(ds, dim=self.dim) - mdoy = max(xr.coding.calendar_ops._days_in_year(yr, cal) for yr in np.unique(ds[self.dim].dt.year)) + mdoy = max( + xr.coding.calendar_ops._days_in_year(yr, cal) + for yr in np.unique(ds[self.dim].dt.year) + ) else: mdoy = 365 - return xr.DataArray(np.arange(1, mdoy + 1), dims="dayofyear", name="dayofyear") + return xr.DataArray( + np.arange(1, mdoy + 1), dims="dayofyear", name="dayofyear" + ) if self.prop == "group": return xr.DataArray([1], dims=("group",), name="group") # TODO: woups what happens when there is no group? (prop is None) @@ -285,13 +300,26 @@ def group( if da is not None: das[da.name] = da - da = xr.Dataset(data_vars={name: das.pop(name) for name in list(das.keys()) if self.dim in das[name].dims}) + da = xr.Dataset( + data_vars={ + name: das.pop(name) + for name in list(das.keys()) + if self.dim in das[name].dims + } + ) # "Ungroup" the grouped arrays - da = da.assign({name: broadcast(var, da[self.dim], group=self, interp="nearest") for name, var in das.items()}) + da = da.assign( + { + name: broadcast(var, da[self.dim], group=self, interp="nearest") + for name, var in das.items() + } + ) if not main_only and self.window > 1: - da = da.rolling(center=True, **{self.dim: self.window}).construct(window_dim="window") + da = da.rolling(center=True, **{self.dim: self.window}).construct( + window_dim="window" + ) if uses_dask(da): # Rechunk. There might be padding chunks. da = da.chunk({self.dim: -1}) @@ -343,7 +371,10 @@ def get_index( i = getattr(ind, self.prop) if not np.issubdtype(i.dtype, np.integer): - raise ValueError(f"Index {self.name} is not of type int (rather {i.dtype}), " f"but {self.__class__.__name__} requires integer indexes.") + raise ValueError( + f"Index {self.name} is not of type int (rather {i.dtype}), " + f"but {self.__class__.__name__} requires integer indexes." + ) if interp and self.dim == "time" and self.prop == "month": i = ind.month - 0.5 + ind.day / ind.days_in_month @@ -414,7 +445,11 @@ def apply( if isinstance(da, (dict, xr.Dataset)): grpd = self.group(main_only=main_only, **da) dim_chunks = min( # Get smallest chunking to rechunk if the operation is non-grouping - [d.chunks[d.get_axis_num(self.dim)] for d in da.values() if uses_dask(d) and self.dim in d.dims] + [ + d.chunks[d.get_axis_num(self.dim)] + for d in da.values() + if uses_dask(d) and self.dim in d.dims + ] or [[]], # pass [[]] if no DataArrays have chunks so min doesn't fail key=len, ) @@ -422,7 +457,9 @@ def apply( grpd = self.group(da, main_only=main_only) # Get chunking to rechunk is the operation is non-grouping # To match the behaviour of the case above, an empty list signifies that dask is not used for the input. - dim_chunks = [] if not uses_dask(da) else da.chunks[da.get_axis_num(self.dim)] + dim_chunks = ( + [] if not uses_dask(da) else da.chunks[da.get_axis_num(self.dim)] + ) if main_only: dims = self.dim @@ -442,7 +479,9 @@ def apply( if isinstance(out, xr.Dataset): for name, outvar in out.data_vars.items(): if "_group_apply_reshape" in outvar.attrs: - out[name] = self.group(outvar, main_only=True).first(skipna=False, keep_attrs=True) + out[name] = self.group(outvar, main_only=True).first( + skipna=False, keep_attrs=True + ) del out[name].attrs["_group_apply_reshape"] # Save input parameters as attributes of output DataArray. @@ -493,8 +532,15 @@ def _update_kwargs(_kwargs, allowed=None): _kwargs.setdefault("group", default_group) if not isinstance(_kwargs["group"], Grouper): _kwargs = Grouper.from_kwargs(**_kwargs) - if allowed is not None and "group" in _kwargs and _kwargs["group"].prop not in allowed: - raise ValueError(f"Grouping on {_kwargs['group'].prop_name} is not allowed for this " f"function. Should be one of {allowed}.") + if ( + allowed is not None + and "group" in _kwargs + and _kwargs["group"].prop not in allowed + ): + raise ValueError( + f"Grouping on {_kwargs['group'].prop_name} is not allowed for this " + f"function. Should be one of {allowed}." + ) return _kwargs if kwargs is not None: # Not used as a decorator @@ -509,7 +555,9 @@ def _parse_group(*f_args, **f_kwargs): return _parse_group -def duck_empty(dims: xr.DataArray.dims, sizes, dtype="float64", chunks=None) -> xr.DataArray: +def duck_empty( + dims: xr.DataArray.dims, sizes, dtype="float64", chunks=None +) -> xr.DataArray: """Return an empty DataArray based on a numpy or dask backend, depending on the "chunks" argument.""" shape = [sizes[dim] for dim in dims] if chunks: @@ -561,7 +609,9 @@ def merge_dimensions(*seqs): if e in out: indx = out.index(e) if indx < last_index: - raise ValueError("Dimensions order mismatch, lists are not mergeable.") + raise ValueError( + "Dimensions order mismatch, lists are not mergeable." + ) last_index = indx else: out.insert(last_index + 1, e) @@ -583,7 +633,9 @@ def _map_blocks(ds, **kwargs): # noqa: C901 group = kwargs.get("group") # Ensure group is given as it might not be in the signature of the wrapped func - if {Grouper.PROP, Grouper.DIM, Grouper.ADD_DIMS}.intersection(out_dims + red_dims) and group is None: + if {Grouper.PROP, Grouper.DIM, Grouper.ADD_DIMS}.intersection( + out_dims + red_dims + ) and group is None: raise ValueError("Missing required `group` argument.") # Make translation dict @@ -607,16 +659,37 @@ def _map_blocks(ds, **kwargs): # noqa: C901 for dim in new_dims: if dim in ds.dims and dim not in reduced_dims: - raise ValueError(f"Dimension {dim} is meant to be added by the " "computation but it is already on one of the inputs.") + raise ValueError( + f"Dimension {dim} is meant to be added by the " + "computation but it is already on one of the inputs." + ) if uses_dask(ds): # Use dask if any of the input is dask-backed. - chunks = dict(ds.chunks) if isinstance(ds, xr.Dataset) else dict(zip(ds.dims, ds.chunks)) + chunks = ( + dict(ds.chunks) + if isinstance(ds, xr.Dataset) + else dict(zip(ds.dims, ds.chunks)) + ) badchunks = {} if group is not None: - badchunks.update({dim: chunks.get(dim) for dim in group.add_dims + [group.dim] if len(chunks.get(dim, [])) > 1}) - badchunks.update({dim: chunks.get(dim) for dim in reduced_dims if len(chunks.get(dim, [])) > 1}) + badchunks.update( + { + dim: chunks.get(dim) + for dim in group.add_dims + [group.dim] + if len(chunks.get(dim, [])) > 1 + } + ) + badchunks.update( + { + dim: chunks.get(dim) + for dim in reduced_dims + if len(chunks.get(dim, [])) > 1 + } + ) if badchunks: - raise ValueError(f"The dimension(s) over which we group, reduce or interpolate cannot be chunked ({badchunks}).") + raise ValueError( + f"The dimension(s) over which we group, reduce or interpolate cannot be chunked ({badchunks})." + ) else: chunks = None @@ -644,14 +717,18 @@ def _map_blocks(ds, **kwargs): # noqa: C901 ds[dim] = ds[dim] coords[dim] = ds[dim] else: - raise ValueError(f"This function adds the {dim} dimension, its coordinate must be provided as a keyword argument.") + raise ValueError( + f"This function adds the {dim} dimension, its coordinate must be provided as a keyword argument." + ) sizes.update({name: crd.size for name, crd in coords.items()}) # Create the output dataset, but empty tmpl = xr.Dataset(coords=coords) if isinstance(ds, xr.Dataset): # Get largest dtype of the inputs, assign it to the output. - dtype = max((da.dtype for da in ds.data_vars.values()), key=lambda d: d.itemsize) + dtype = max( + (da.dtype for da in ds.data_vars.values()), key=lambda d: d.itemsize + ) else: dtype = ds.dtype @@ -669,7 +746,9 @@ def _map_blocks(ds, **kwargs): # noqa: C901 # Optimization to circumvent the slow pickle.dumps(cftime_array) # List of the keys to avoid changing the coords dict while iterating over it. for crd in list(ds.coords.keys()): - if xr.core.common._contains_cftime_datetimes(ds[crd].variable): # noqa + if xr.core.common._contains_cftime_datetimes( + ds[crd].variable + ): # noqa ds[crd] = xr.conventions.encode_cf_variable(ds[crd].variable) def _call_and_transpose_on_exit(dsblock, **f_kwargs): @@ -678,22 +757,34 @@ def _call_and_transpose_on_exit(dsblock, **f_kwargs): _decode_cf_coords(dsblock) func_out = func(dsblock, **f_kwargs).transpose(*all_dims) except Exception as err: - raise ValueError(f"{func.__name__} failed on block with coords : {dsblock.coords}.") from err + raise ValueError( + f"{func.__name__} failed on block with coords : {dsblock.coords}." + ) from err return func_out # Fancy patching for explicit dask task names _call_and_transpose_on_exit.__name__ = f"block_{func.__name__}" # Remove all auxiliary coords on both tmpl and ds - extra_coords = {name: crd for name, crd in ds.coords.items() if name not in crd.dims} + extra_coords = { + name: crd for name, crd in ds.coords.items() if name not in crd.dims + } ds = ds.drop_vars(extra_coords.keys()) # Coords not sharing dims with `all_dims` (like scalar aux coord on reduced 1D input) are absent from tmpl tmpl = tmpl.drop_vars(extra_coords.keys(), errors="ignore") # Call - out = ds.map_blocks(_call_and_transpose_on_exit, template=tmpl, kwargs=kwargs) + out = ds.map_blocks( + _call_and_transpose_on_exit, template=tmpl, kwargs=kwargs + ) # Add back the extra coords, but only those which have compatible dimensions (like xarray would have done) - out = out.assign_coords({name: crd for name, crd in extra_coords.items() if set(crd.dims).issubset(out.dims)}) + out = out.assign_coords( + { + name: crd + for name, crd in extra_coords.items() + if set(crd.dims).issubset(out.dims) + } + ) # Finally remove coords we added... 'ignore' in case they were already removed. out = out.drop_vars(added_coords, errors="ignore") @@ -705,7 +796,9 @@ def _call_and_transpose_on_exit(dsblock, **f_kwargs): return _decorator -def map_groups(reduces: Sequence[str] | None = None, main_only: bool = False, **out_vars) -> Callable: +def map_groups( + reduces: Sequence[str] | None = None, main_only: bool = False, **out_vars +) -> Callable: r"""Decorator for declaring functions acting only on groups and wrapping them into a map_blocks. This is the same as `map_blocks` but adds a call to `group.apply()` in the mapped func and the default diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py index 3125d22..abb1548 100644 --- a/src/xsdba/loess.py +++ b/src/xsdba/loess.py @@ -239,7 +239,9 @@ def loess_smoothing( x = da[dim] x = ((x - x[0]) / (x[-1] - x[0])).astype(float) - weight_func = {"tricube": _tricube_weighting, "gaussian": _gaussian_weighting}.get(weights, weights) + weight_func = {"tricube": _tricube_weighting, "gaussian": _gaussian_weighting}.get( + weights, weights + ) reg_func = {0: _constant_regression, 1: _linear_regression}[d] @@ -248,7 +250,9 @@ def loess_smoothing( if equal_spacing is None: equal_spacing = True elif equal_spacing: - warn("The equal spacing optimization was requested, but the x axis is not equally spaced. Strange results might occur.") + warn( + "The equal spacing optimization was requested, but the x axis is not equally spaced. Strange results might occur." + ) if equal_spacing: dx = float(x[1] - x[0]) else: diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index 355fbdd..548a4c3 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -26,7 +26,9 @@ nogil=True, cache=False, ) -def _get_indexes(arr: np.array, virtual_indexes: np.array, valid_values_count: np.array) -> tuple[np.array, np.array]: +def _get_indexes( + arr: np.array, virtual_indexes: np.array, valid_values_count: np.array +) -> tuple[np.array, np.array]: """Get the valid indexes of arr neighbouring virtual_indexes. Parameters @@ -127,9 +129,13 @@ def _nan_quantile_1d( valid_values_count = (~np.isnan(arr)).sum() # Computation of indexes - virtual_indexes = valid_values_count * quantiles + (alpha + quantiles * (1 - alpha - beta)) - 1 + virtual_indexes = ( + valid_values_count * quantiles + (alpha + quantiles * (1 - alpha - beta)) - 1 + ) virtual_indexes = np.asarray(virtual_indexes) - previous_indexes, next_indexes = _get_indexes(arr, virtual_indexes, valid_values_count) + previous_indexes, next_indexes = _get_indexes( + arr, virtual_indexes, valid_values_count + ) # Sorting arr.sort() @@ -141,7 +147,9 @@ def _nan_quantile_1d( interpolation = _linear_interpolation(previous, next_elements, gamma) # When an interpolation is in Nan range, (near the end of the sorted array) it means # we can clip to the array max value. - result = np.where(np.isnan(interpolation), arr[np.intp(valid_values_count) - 1], interpolation) + result = np.where( + np.isnan(interpolation), arr[np.intp(valid_values_count) - 1], interpolation + ) return result @@ -158,7 +166,9 @@ def _vecquantiles(arr, rnk, res): res[0] = np.nanquantile(arr, rnk) -def vecquantiles(da: DataArray, rnk: DataArray, dim: str | Sequence[Hashable]) -> DataArray: +def vecquantiles( + da: DataArray, rnk: DataArray, dim: str | Sequence[Hashable] +) -> DataArray: """For when the quantile (rnk) is different for each point. da and rnk must share all dimensions but dim. @@ -375,7 +385,9 @@ def _first_and_last_nonnull(arr): nogil=True, cache=False, ) -def _extrapolate_on_quantiles(interp, oldx, oldg, oldy, newx, newg, method="constant"): # noqa +def _extrapolate_on_quantiles( + interp, oldx, oldg, oldy, newx, newg, method="constant" +): # noqa """Apply extrapolation to the output of interpolation on quantiles with a given grouping. Arguments are the same as _interp_on_quantiles_2D. @@ -412,9 +424,15 @@ def _pairwise_haversine_and_bins(lond, latd, transpose=False): dlon = lon[j] - lon[i] dists[i, j] = 6367 * np.arctan2( np.sqrt( - (np.cos(lat[j]) * np.sin(dlon)) ** 2 + (np.cos(lat[i]) * np.sin(lat[j]) - np.sin(lat[i]) * np.cos(lat[j]) * np.cos(dlon)) ** 2 + (np.cos(lat[j]) * np.sin(dlon)) ** 2 + + ( + np.cos(lat[i]) * np.sin(lat[j]) + - np.sin(lat[i]) * np.cos(lat[j]) * np.cos(dlon) + ) + ** 2 ), - np.sin(lat[i]) * np.sin(lat[j]) + np.cos(lat[i]) * np.cos(lat[j]) * np.cos(dlon), + np.sin(lat[i]) * np.sin(lat[j]) + + np.cos(lat[i]) * np.cos(lat[j]) * np.cos(dlon), ) if transpose: dists[j, i] = dists[i, j] diff --git a/src/xsdba/options.py b/src/xsdba/options.py index 0ceb6dc..5d3c028 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -204,7 +204,9 @@ def __init__(self, **kwargs): self.old = {} for k, v in kwargs.items(): if k not in OPTIONS: - raise ValueError(f"argument name {k!r} is not in the set of valid options {set(OPTIONS)!r}") + raise ValueError( + f"argument name {k!r} is not in the set of valid options {set(OPTIONS)!r}" + ) if k in _VALIDATORS and not _VALIDATORS[k](v): raise ValueError(f"option {k!r} given an invalid value: {v!r}") diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index e2b3a76..bdd92ee 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -6,6 +6,7 @@ import os import warnings from pathlib import Path +from typing import Optional from urllib.error import HTTPError, URLError from urllib.parse import urljoin, urlparse from urllib.request import urlopen, urlretrieve @@ -117,7 +118,7 @@ def file_md5_checksum(f_name): # XC -def audit_url(url: str, context: str = None) -> str: +def audit_url(url: str, context: Optional[str] = None) -> str: """Check if the URL is well-formed. Raises @@ -165,13 +166,22 @@ def _get( remote_md5 = f.read() if local_md5.strip() != remote_md5.strip(): local_file.unlink() - msg = f"MD5 checksum for {local_file.as_posix()} does not match upstream md5. " "Attempting new download." + msg = ( + f"MD5 checksum for {local_file.as_posix()} does not match upstream md5. " + "Attempting new download." + ) warnings.warn(msg) except HTTPError: - msg = f"{md5_name.as_posix()} not accessible in remote repository. " "Unable to determine validity with upstream repo." + msg = ( + f"{md5_name.as_posix()} not accessible in remote repository. " + "Unable to determine validity with upstream repo." + ) warnings.warn(msg) except URLError: - msg = f"{md5_name.as_posix()} not found in remote repository. " "Unable to determine validity with upstream repo." + msg = ( + f"{md5_name.as_posix()} not found in remote repository. " + "Unable to determine validity with upstream repo." + ) warnings.warn(msg) except SocketBlockedError: msg = f"Unable to access {md5_name.as_posix()} online. Testing suite is being run with `--disable-socket`." @@ -191,7 +201,10 @@ def _get( msg = f"{fullname.as_posix()} not accessible in remote repository. Aborting file retrieval." raise FileNotFoundError(msg) from e except URLError as e: - msg = f"{fullname.as_posix()} not found in remote repository. " "Verify filename and repository address. Aborting file retrieval." + msg = ( + f"{fullname.as_posix()} not found in remote repository. " + "Verify filename and repository address. Aborting file retrieval." + ) raise FileNotFoundError(msg) from e # gives TypeError: catching classes that do not inherit from BaseException is not allowed except SocketBlockedError as e: @@ -221,7 +234,10 @@ def _get( remote_md5 = f.read() if local_md5.strip() != remote_md5.strip(): local_file.unlink() - msg = f"{local_file.as_posix()} and md5 checksum do not match. " "There may be an issue with the upstream origin data." + msg = ( + f"{local_file.as_posix()} and md5 checksum do not match. " + "There may be an issue with the upstream origin data." + ) raise OSError(msg) except OSError as e: logger.error(e) diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 4d2a6ad..20eee3c 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -128,7 +128,9 @@ def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: if toosmall.sum() > 1: # Many chunks are too small, merge them by groups fac = np.ceil(minchunk / min(chunks)).astype(int) - chunking[dim] = tuple(sum(chunks[i : i + fac]) for i in range(0, len(chunks), fac)) + chunking[dim] = tuple( + sum(chunks[i : i + fac]) for i in range(0, len(chunks), fac) + ) # Reset counter is case the last chunks are still too small chunks = chunking[dim] toosmall = np.array(chunks) < minchunk @@ -146,7 +148,9 @@ def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: # XC -def _interpolate_doy_calendar(source: xr.DataArray, doy_max: int, doy_min: int = 1) -> xr.DataArray: +def _interpolate_doy_calendar( + source: xr.DataArray, doy_max: int, doy_min: int = 1 +) -> xr.DataArray: """Interpolate from one set of dayofyear range to another. Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 @@ -179,7 +183,9 @@ def _interpolate_doy_calendar(source: xr.DataArray, doy_max: int, doy_min: int = filled_na = da.interpolate_na(dim="dayofyear") # Interpolate to target dayofyear range - filled_na.coords["dayofyear"] = np.linspace(start=doy_min, stop=doy_max, num=len(filled_na.coords["dayofyear"])) + filled_na.coords["dayofyear"] = np.linspace( + start=doy_min, stop=doy_max, num=len(filled_na.coords["dayofyear"]) + ) return filled_na.interp(dayofyear=range(doy_min, doy_max + 1)) @@ -190,7 +196,13 @@ def ensure_longest_doy(func: Callable) -> Callable: @wraps(func) def _ensure_longest_doy(x, y, *args, **kwargs): - if hasattr(x, "dims") and hasattr(y, "dims") and "dayofyear" in x.dims and "dayofyear" in y.dims and x.dayofyear.max() != y.dayofyear.max(): + if ( + hasattr(x, "dims") + and hasattr(y, "dims") + and "dayofyear" in x.dims + and "dayofyear" in y.dims + and x.dayofyear.max() != y.dayofyear.max() + ): warn( ( "get_correction received inputs defined on different dayofyear ranges. " @@ -199,9 +211,13 @@ def _ensure_longest_doy(x, y, *args, **kwargs): stacklevel=4, ) if x.dayofyear.max() < y.dayofyear.max(): - x = _interpolate_doy_calendar(x, int(y.dayofyear.max()), int(y.dayofyear.min())) + x = _interpolate_doy_calendar( + x, int(y.dayofyear.max()), int(y.dayofyear.min()) + ) else: - y = _interpolate_doy_calendar(y, int(x.dayofyear.max()), int(x.dayofyear.min())) + y = _interpolate_doy_calendar( + y, int(x.dayofyear.max()), int(x.dayofyear.min()) + ) return func(x, y, *args, **kwargs) return _ensure_longest_doy @@ -224,7 +240,9 @@ def get_correction(x: xr.DataArray, y: xr.DataArray, kind: str) -> xr.DataArray: @ensure_longest_doy -def apply_correction(x: xr.DataArray, factor: xr.DataArray, kind: str | None = None) -> xr.DataArray: +def apply_correction( + x: xr.DataArray, factor: xr.DataArray, kind: str | None = None +) -> xr.DataArray: """Apply the additive or multiplicative correction/adjustment factors. If kind is not given, default to the one stored in the "kind" attribute of factor. @@ -296,7 +314,9 @@ def broadcast( else: # Find quantile for nearest time group and quantile. # For `.interp` we need to explicitly pass the shared dims # (see pydata/xarray#4463 and Ouranosinc/xclim#449,567) - sel.update({dim: x[dim] for dim in set(grouped.dims).intersection(set(x.dims))}) + sel.update( + {dim: x[dim] for dim in set(grouped.dims).intersection(set(x.dims))} + ) if group.prop != "group": grouped = add_cyclic_bounds(grouped, group.prop, cyclic_coords=False) @@ -350,7 +370,9 @@ def equally_spaced_nodes(n: int, eps: float | None = None) -> np.ndarray: return np.insert(np.append(q, 1 - eps), 0, eps) -def add_cyclic_bounds(da: xr.DataArray, att: str, cyclic_coords: bool = True) -> xr.DataArray | xr.Dataset: +def add_cyclic_bounds( + da: xr.DataArray, att: str, cyclic_coords: bool = True +) -> xr.DataArray | xr.Dataset: """Reindex an array to include the last slice at the beginning and the first at the end. This is done to allow interpolation near the end-points. @@ -545,7 +567,9 @@ def interp_on_quantiles( ) -def rank(da: xr.DataArray, dim: str | list[str] = "time", pct: bool = False) -> xr.DataArray: +def rank( + da: xr.DataArray, dim: str | list[str] = "time", pct: bool = False +) -> xr.DataArray: """Ranks data along a dimension. Replicates `xr.DataArray.rank` but as a function usable in a Grouper.apply(). Xarray's docstring is below: @@ -594,7 +618,11 @@ def rank(da: xr.DataArray, dim: str | list[str] = "time", pct: bool = False) -> rnk = mx * (rnk - mn) / (mx - mn) if len(dims) > 1: - rnk = rnk.unstack(rnk_dim).transpose(*da_dims).drop_vars([d for d in dims if d not in da_coords]) + rnk = ( + rnk.unstack(rnk_dim) + .transpose(*da_dims) + .drop_vars([d for d in dims if d not in da_coords]) + ) return rnk @@ -633,7 +661,9 @@ def pc_matrix(arr: np.ndarray | dsk.Array) -> np.ndarray | dsk.Array: return eig_vec * mod.sqrt(eig_vals) -def best_pc_orientation_simple(R: np.ndarray, Hinv: np.ndarray, val: float = 1000) -> np.ndarray: +def best_pc_orientation_simple( + R: np.ndarray, Hinv: np.ndarray, val: float = 1000 +) -> np.ndarray: """Return best orientation vector according to a simple test. Eigenvectors returned by `pc_matrix` do not have a defined orientation. @@ -725,7 +755,9 @@ def best_pc_orientation_full( signs = dict(itertools.zip_longest(itertools.product(*[[1, -1]] * m), [None])) for orient in list(signs.keys()): # Calculate scen for hist - scen = np.atleast_2d(Rmean).T + ((orient * R) @ Hinv) @ (hist - np.atleast_2d(Hmean).T) + scen = np.atleast_2d(Rmean).T + ((orient * R) @ Hinv) @ ( + hist - np.atleast_2d(Hmean).T + ) # Correlation for each variable corr = [spearmanr(hist[i, :], scen[i, :])[0] for i in range(hist.shape[0])] # Store mean correlation @@ -734,7 +766,9 @@ def best_pc_orientation_full( return np.array(max(signs, key=lambda o: signs[o])) -def get_clusters_1d(data: np.ndarray, u1: float, u2: float) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: +def get_clusters_1d( + data: np.ndarray, u1: float, u2: float +) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: """Get clusters of a 1D array. A cluster is defined as a sequence of values larger than u2 with at least one value larger than u1. @@ -868,7 +902,9 @@ def _get_clusters(arr, u1, u2, N): return ds -def rand_rot_matrix(crd: xr.DataArray, num: int = 1, new_dim: str | None = None) -> xr.DataArray: +def rand_rot_matrix( + crd: xr.DataArray, num: int = 1, new_dim: str | None = None +) -> xr.DataArray: r"""Generate random rotation matrices. Rotation matrices are members of the SO(n) group, where n is the matrix size (`crd.size`). @@ -914,7 +950,9 @@ def rand_rot_matrix(crd: xr.DataArray, num: int = 1, new_dim: str | None = None) num = np.diag(R) denum = np.abs(num) lam = np.diag(num / denum) # "lambda" - return xr.DataArray(Q @ lam, dims=(dim, new_dim), coords={dim: crd, new_dim: crd2}).astype("float32") + return xr.DataArray( + Q @ lam, dims=(dim, new_dim), coords={dim: crd, new_dim: crd2} + ).astype("float32") def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): @@ -933,7 +971,11 @@ def _pairwise_spearman(da, dims): With skipna-shortcuts for cases where all times or all points are NaN. """ da = da - da.mean(dims) - da = da.stack(_spatial=dims).reset_index("_spatial").drop_vars(["_spatial"], errors=["ignore"]) + da = ( + da.stack(_spatial=dims) + .reset_index("_spatial") + .drop_vars(["_spatial"], errors=["ignore"]) + ) def _skipna_correlation(data): nv, _nt = data.shape diff --git a/tests/conftest.py b/tests/conftest.py index b4039c0..2fa621a 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -82,9 +82,13 @@ def threadsafe_data_dir(tmp_path_factory) -> Path: @pytest.fixture(scope="session") def open_dataset(threadsafe_data_dir): - def _open_session_scoped_file(file: str | os.PathLike, branch: str = TESTDATA_BRANCH, **xr_kwargs): + def _open_session_scoped_file( + file: str | os.PathLike, branch: str = TESTDATA_BRANCH, **xr_kwargs + ): xr_kwargs.setdefault("engine", "h5netcdf") - return _open_dataset(file, cache_dir=threadsafe_data_dir, branch=branch, **xr_kwargs) + return _open_dataset( + file, cache_dir=threadsafe_data_dir, branch=branch, **xr_kwargs + ) return _open_session_scoped_file @@ -135,7 +139,13 @@ def areacella() -> xr.DataArray: d_lat = np.diff(lat_bnds) lon = np.convolve(lon_bnds, [0.5, 0.5], "valid") lat = np.convolve(lat_bnds, [0.5, 0.5], "valid") - area = r * np.radians(d_lat)[:, np.newaxis] * r * np.cos(np.radians(lat)[:, np.newaxis]) * np.radians(d_lon) + area = ( + r + * np.radians(d_lat)[:, np.newaxis] + * r + * np.cos(np.radians(lat)[:, np.newaxis]) + * np.radians(d_lon) + ) return xr.DataArray( data=area, dims=("lat", "lon"), diff --git a/tests/test_base.py b/tests/test_base.py index 04157a9..476c34a 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -16,12 +16,17 @@ class ATestSubClass(Parametrizable): def test_param_class(): gr = Grouper(group="time.month") - in_params = dict(anint=4, abool=True, astring="a string", adict={"key": "val"}, group=gr) + in_params = dict( + anint=4, abool=True, astring="a string", adict={"key": "val"}, group=gr + ) obj = Parametrizable(**in_params) assert obj.parameters == in_params - assert repr(obj).startswith("Parametrizable(anint=4, abool=True, astring='a string', adict={'key': 'val'}, " "group=Grouper(") + assert repr(obj).startswith( + "Parametrizable(anint=4, abool=True, astring='a string', adict={'key': 'val'}, " + "group=Grouper(" + ) s = jsonpickle.encode(obj) obj2 = jsonpickle.decode(s) # noqa: S301 @@ -105,7 +110,9 @@ def test_grouper_apply(timeseries, use_dask, group, n): # With window win_grouper = Grouper(group, window=5) out = win_grouper.apply("mean", da0) - rolld = da0.rolling({win_grouper.dim: 5}, center=True).construct(window_dim="window") + rolld = da0.rolling({win_grouper.dim: 5}, center=True).construct( + window_dim="window" + ) if grouper.prop != "group": exp = rolld.groupby(group).mean(dim=[win_grouper.dim, "window"]) else: @@ -146,7 +153,9 @@ def mixed_reduce(grdds, dim=None): def normalize_from_precomputed(grpds, dim=None): return (grpds.da0 / grpds.da1_mean).mean(dim=dim) - out = grouper.apply(normalize_from_precomputed, {"da0": da0, "da1_mean": out.da1_mean}).isel(lat=0) + out = grouper.apply( + normalize_from_precomputed, {"da0": da0, "da1_mean": out.da1_mean} + ).isel(lat=0) if grouper.prop == "group": exp = normed.mean("time").isel(lat=0) else: diff --git a/tests/test_nbutils.py b/tests/test_nbutils.py index a539826..d865290 100644 --- a/tests/test_nbutils.py +++ b/tests/test_nbutils.py @@ -10,7 +10,9 @@ class TestQuantiles: @pytest.mark.parametrize("uses_dask", [True, False]) def test_quantile(self, open_dataset, uses_dask): - da = (open_dataset("sdba/CanESM2_1950-2100.nc").sel(time=slice("1950", "1955")).pr).load() + da = ( + open_dataset("sdba/CanESM2_1950-2100.nc").sel(time=slice("1950", "1955")).pr + ).load() if uses_dask: da = da.chunk({"location": 1}) else: diff --git a/tests/test_utils.py b/tests/test_utils.py index aa0085d..2759bd0 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -65,7 +65,9 @@ def test_equally_spaced_nodes(): np.testing.assert_almost_equal(x[0], 0.5) -@pytest.mark.parametrize("interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)]) +@pytest.mark.parametrize( + "interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)] +) @pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) def test_interp_on_quantiles_constant(interp, expi, extrap, expe): quantiles = np.linspace(0, 1, num=25) @@ -92,7 +94,9 @@ def test_interp_on_quantiles_constant(interp, expi, extrap, expe): yq = yq.expand_dims(lat=[1, 2, 3]) newx = newx.expand_dims(lat=[1, 2, 3]) - out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) if np.isnan(expe): assert out.isel(time=0).isnull().all() @@ -103,7 +107,9 @@ def test_interp_on_quantiles_constant(interp, expi, extrap, expe): xq = xq.where(xq != 220) yq = yq.where(yq != 3) - out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) if np.isnan(expe): assert out.isel(time=0).isnull().all() @@ -117,7 +123,10 @@ def test_interp_on_quantiles_monthly(random): t = xr.cftime_range("2000-01-01", "2030-12-31", freq="D", calendar="noleap") ref = xr.DataArray( ( - -20 * np.cos(2 * np.pi * t.dayofyear / 365) + 2 * random.random(t.size) + 273.15 + 0.1 * (t - t[0]).days / 365 + -20 * np.cos(2 * np.pi * t.dayofyear / 365) + + 2 * random.random(t.size) + + 273.15 + + 0.1 * (t - t[0]).days / 365 ), # "warming" of 1K per decade, dims=("time",), coords={"time": t}, @@ -125,7 +134,10 @@ def test_interp_on_quantiles_monthly(random): ) sim = xr.DataArray( ( - -18 * np.cos(2 * np.pi * t.dayofyear / 365) + 2 * random.random(t.size) + 273.15 + 0.11 * (t - t[0]).days / 365 + -18 * np.cos(2 * np.pi * t.dayofyear / 365) + + 2 * random.random(t.size) + + 273.15 + + 0.11 * (t - t[0]).days / 365 ), # "warming" of 1.1K per decade dims=("time",), coords={"time": t}, @@ -142,11 +154,15 @@ def test_interp_on_quantiles_monthly(random): af = u.get_correction(hist_q, ref_q, "+") for interp in ["nearest", "linear", "cubic"]: - afi = u.interp_on_quantiles(sim, hist_q, af, group="time.month", method=interp, extrapolation="constant") + afi = u.interp_on_quantiles( + sim, hist_q, af, group="time.month", method=interp, extrapolation="constant" + ) assert afi.isnull().sum("time") == 0, interp -@pytest.mark.parametrize("interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)]) +@pytest.mark.parametrize( + "interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)] +) @pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): quantiles = np.linspace(0, 1, num=30) @@ -173,7 +189,9 @@ def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): yq = yq.expand_dims(lat=[1, 2, 3]) newx = newx.expand_dims(lat=[1, 2, 3]) - out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) if np.isnan(expe): assert out.isel(time=0).isnull().all() @@ -184,7 +202,9 @@ def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): xq = xq.where(xq != 220) yq = yq.where(yq != 3) - out = u.interp_on_quantiles(newx, xq, yq, group="time", method=interp, extrapolation=extrap) + out = u.interp_on_quantiles( + newx, xq, yq, group="time", method=interp, extrapolation=extrap + ) if np.isnan(expe): assert out.isel(time=0).isnull().all() From 9daf8798073e2691b59e26e8158e64b58dfc97d4 Mon Sep 17 00:00:00 2001 From: Zeitsperre <10819524+Zeitsperre@users.noreply.github.com> Date: Thu, 25 Jul 2024 15:18:11 -0400 Subject: [PATCH 013/105] fix numpydoc docstrings, add bibliography directives for later --- .flake8 | 3 ++ pyproject.toml | 1 + src/xsdba/base.py | 15 +++--- src/xsdba/loess.py | 6 +-- src/xsdba/logging.py | 2 +- src/xsdba/nbutils.py | 9 ++-- src/xsdba/testing.py | 12 +++-- src/xsdba/utils.py | 116 +++++++++++++++++++++---------------------- 8 files changed, 85 insertions(+), 79 deletions(-) diff --git a/.flake8 b/.flake8 index b2a7481..e66374b 100644 --- a/.flake8 +++ b/.flake8 @@ -12,6 +12,9 @@ ignore = F, W503 per-file-ignores = +rst-directives = + bibliography, + autolink-skip rst-roles = doc, mod, diff --git a/pyproject.toml b/pyproject.toml index c85b19c..82341a7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -239,6 +239,7 @@ checks = [ "GL01", "GL08", "PR01", + "PR07", "PR08", "RT01", "RT03", diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 66c44a9..f9a63fa 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Base Classes and Developer Tools ================================ """ @@ -8,7 +8,7 @@ import datetime as pydt from collections.abc import Sequence from inspect import _empty, signature # noqa -from typing import Callable +from typing import Any, Callable import cftime import dask.array as dsk @@ -104,11 +104,11 @@ def set_dataset(self, ds: xr.Dataset) -> None: # XC put here to avoid circular import def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: - """Evaluate whether dask is installed and array is loaded as a dask array. + r"""Evaluate whether dask is installed and array is loaded as a dask array. Parameters ---------- - das: xr.DataArray or xr.Dataset + \*das : xr.DataArray or xr.Dataset DataArrays or Datasets to check. Returns @@ -414,7 +414,7 @@ def apply( (if False, default) (including the window and dimensions given through `add_dims`). The dimensions used are also written in the "group_compute_dims" attribute. If all the input arrays are missing one of the 'add_dims', it is silently omitted. - \*\*kwargs + \*\*kwargs : dict Other keyword arguments to pass to the function. Returns @@ -434,7 +434,6 @@ def apply( - If there is only one group, the singleton dimension is squeezed out of the output - The output is rechunked as to have only 1 chunk along the new dimension. - Notes ----- For the special case where a Dataset is returned, but only some of its variable where reduced by the grouping, @@ -592,7 +591,7 @@ def map_blocks( # noqa: C901 ---------- reduces : sequence of strings Name of the dimensions that are removed by the function. - \*\*out_vars + \*\*out_vars : dict Mapping from variable names in the output to their *new* dimensions. The placeholders ``Grouper.PROP``, ``Grouper.DIM`` and ``Grouper.ADD_DIMS`` can be used to signify ``group.prop``,``group.dim`` and ``group.add_dims`` respectively. @@ -815,7 +814,7 @@ def map_groups( if main_only is False, and [Grouper.DIM] if main_only is True. See :py:func:`map_blocks`. main_only : bool Same as for :py:meth:`Grouper.apply`. - \*\*out_vars + \*\*out_vars : dict Mapping from variable names in the output to their *new* dimensions. The placeholders ``Grouper.PROP``, ``Grouper.DIM`` and ``Grouper.ADD_DIMS`` can be used to signify ``group.prop``,``group.dim`` and ``group.add_dims``, respectively. diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py index abb1548..65a1a6e 100644 --- a/src/xsdba/loess.py +++ b/src/xsdba/loess.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 LOESS Smoothing Submodule ========================= """ @@ -76,7 +76,7 @@ def _loess_nb( niter : int Number of robustness iterations to execute. weight_func : numba func - Numba function giving the weights when passed abs(x - xi) / hi + Numba function giving the weights when passed abs(x - xi) / hi. dx : float The spacing of the x coordinates. If above 0, this enables the optimization for equally spaced x coordinates. Must be 0 if spacing is unequal (default). @@ -193,7 +193,7 @@ def loess_smoothing( Parameters ---------- - da: xr.DataArray + da : xr.DataArray The data to smooth using the loess approach. dim : str Name of the dimension along which to perform the loess. diff --git a/src/xsdba/logging.py b/src/xsdba/logging.py index 630f8d3..7ba684b 100644 --- a/src/xsdba/logging.py +++ b/src/xsdba/logging.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Logging utilities ================================ """ diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index 548a4c3..91950ae 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -1,5 +1,5 @@ # pylint: disable=no-value-for-parameter -""" +"""# noqa: SS01 Numba-accelerated Utilities =========================== """ @@ -26,10 +26,11 @@ nogil=True, cache=False, ) -def _get_indexes( +def _get_indexes( # noqa: PR07 arr: np.array, virtual_indexes: np.array, valid_values_count: np.array ) -> tuple[np.array, np.array]: - """Get the valid indexes of arr neighbouring virtual_indexes. + """ + Get the valid indexes of arr neighbouring virtual_indexes. Parameters ---------- @@ -40,7 +41,7 @@ def _get_indexes( Returns ------- array-like, array-like - A tuple of virtual_indexes neighbouring indexes (previous and next) + A tuple of virtual_indexes neighbouring indexes (previous and next). Notes ----- diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index bdd92ee..8cf3faa 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -1,16 +1,18 @@ """Testing utilities for xsdba.""" +from __future__ import annotations + import collections import hashlib import logging import os import warnings from pathlib import Path -from typing import Optional from urllib.error import HTTPError, URLError from urllib.parse import urljoin, urlparse from urllib.request import urlopen, urlretrieve +import numpy as np import pandas as pd import xarray as xr from platformdirs import user_cache_dir @@ -118,7 +120,7 @@ def file_md5_checksum(f_name): # XC -def audit_url(url: str, context: Optional[str] = None) -> str: +def audit_url(url: str, context: str | None = None) -> str: """Check if the URL is well-formed. Raises @@ -273,11 +275,11 @@ def open_dataset( URL to GitHub repository where the data is stored. branch : str, optional For GitHub-hosted files, the branch to download from. - cache_dir : Path - The directory in which to search for and write cached data. cache : bool If True, then cache data locally for use on subsequent calls. - \*\*kwargs + cache_dir : Path + The directory in which to search for and write cached data. + \*\*kwargs : dict For NetCDF files, keywords passed to :py:func:`xarray.open_dataset`. Returns diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 20eee3c..9127311 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Statistical Downscaling and Bias Adjustment Utilities ===================================================== """ @@ -49,17 +49,18 @@ def map_cdf( Parameters ---------- ds : xr.Dataset - Variables: x, Values from which to pick, - y, Reference values giving the ranking + Variables: + x : Values from which to pick. + y : Reference values giving the ranking. y_value : float, array - Value within the support of `y`. + Value within the support of `y`. dim : str - Dimension along which to compute quantile. + Dimension along which to compute quantile. Returns ------- array - Quantile of `x` with the same CDF as `y_value` in `y`. + Quantile of `x` with the same CDF as `y_value` in `y`. """ return xr.apply_ufunc( map_cdf_1d, @@ -380,17 +381,17 @@ def add_cyclic_bounds( Parameters ---------- da : xr.DataArray or xr.Dataset - An array + An array. att : str - The name of the coordinate to make cyclic + The name of the coordinate to make cyclic. cyclic_coords : bool - If True, the coordinates are made cyclic as well, - if False, the new values are guessed using the same step as their neighbour. + If True, the coordinates are made cyclic as well. + If False, the new values are guessed using the same step as their neighbour. Returns ------- xr.DataArray or xr.Dataset - da but with the last element along att prepended and the last one appended. + A DataArray or Dataset but with the last element along att prepended and the last one appended. """ qmf = da.pad({att: (1, 1)}, mode="wrap") @@ -570,7 +571,7 @@ def interp_on_quantiles( def rank( da: xr.DataArray, dim: str | list[str] = "time", pct: bool = False ) -> xr.DataArray: - """Ranks data along a dimension. + """Rank data along a dimension. Replicates `xr.DataArray.rank` but as a function usable in a Grouper.apply(). Xarray's docstring is below: @@ -581,18 +582,18 @@ def rank( Parameters ---------- - da: xr.DataArray - Source array. + da : xr.DataArray + Source array. dim : str | list[str], hashable - Dimension(s) over which to compute rank. + Dimension(s) over which to compute rank. pct : bool, optional - If True, compute percentage ranks, otherwise compute integer ranks. - Percentage ranks range from 0 to 1, in opposition to xarray's implementation, - where they range from 1/N to 1. + If True, compute percentage ranks, otherwise compute integer ranks. + Percentage ranks range from 0 to 1, in opposition to xarray's implementation, + where they range from 1/N to 1. Returns ------- - DataArray + xr.DataArray DataArray with the same coordinates and dtype 'float64'. Notes @@ -607,7 +608,7 @@ def rank( dims = dim if isinstance(dim, list) else [dim] rnk_dim = dims[0] if len(dims) == 1 else get_temp_dimname(da_dims, "temp") - # multi-dimensional ranking through stacking + # multidimensional ranking through stacking if len(dims) > 1: da = da.stack(**{rnk_dim: dims}) rnk = da.rank(rnk_dim, pct=pct) @@ -636,12 +637,12 @@ def pc_matrix(arr: np.ndarray | dsk.Array) -> np.ndarray | dsk.Array: Parameters ---------- arr : numpy.ndarray or dask.array.Array - 2D array (M, N) of the M coordinates of N points. + 2D array (M, N) of the M coordinates of N points. Returns ------- numpy.ndarray or dask.array.Array - MxM Array of the same type as arr. + MxM Array of the same type as arr. """ # Get appropriate math module mod = dsk if isinstance(arr, dsk.Array) else np @@ -677,17 +678,17 @@ def best_pc_orientation_simple( Parameters ---------- R : np.ndarray - MxM Matrix defining the final transformation. + MxM Matrix defining the final transformation. Hinv : np.ndarray - MxM Matrix defining the (inverse) first transformation. + MxM Matrix defining the (inverse) first transformation. val : float - The coordinate of the test point (same for all axes). It should be much - greater than the largest furthest point in the array used to define B. + The coordinate of the test point (same for all axes). It should be much + greater than the largest furthest point in the array used to define B. Returns ------- np.ndarray - Mx1 vector of orientation correction (1 or -1). + Mx1 vector of orientation correction (1 or -1). See Also -------- @@ -727,20 +728,20 @@ def best_pc_orientation_full( Parameters ---------- R : np.ndarray - MxM Matrix defining the final transformation. + MxM Matrix defining the final transformation. Hinv : np.ndarray - MxM Matrix defining the (inverse) first transformation. + MxM Matrix defining the (inverse) first transformation. Rmean : np.ndarray - M vector defining the target distribution center point. + M vector defining the target distribution center point. Hmean : np.ndarray - M vector defining the original distribution center point. + M vector defining the original distribution center point. hist : np.ndarray - MxN matrix of all training observations of the M variables/sites. + MxN matrix of all training observations of the M variables/sites. Returns ------- np.ndarray - M vector of orientation correction (1 or -1). + M vector of orientation correction (1 or -1). References ---------- @@ -776,11 +777,11 @@ def get_clusters_1d( Parameters ---------- data : 1D ndarray - Values to get clusters from. + Values to get clusters from. u1 : float - Extreme value threshold, at least one value in the cluster must exceed this. + Extreme value threshold, at least one value in the cluster must exceed this. u2 : float - Cluster threshold, values above this can be part of a cluster. + Cluster threshold, values above this can be part of a cluster. Returns ------- @@ -829,27 +830,27 @@ def get_clusters(data: xr.DataArray, u1, u2, dim: str = "time") -> xr.Dataset: Parameters ---------- - data: 1D ndarray - Values to get clusters from. + data : 1D ndarray + Values to get clusters from. u1 : float - Extreme value threshold, at least one value in the cluster must exceed this. + Extreme value threshold, at least one value in the cluster must exceed this. u2 : float - Cluster threshold, values above this can be part of a cluster. + Cluster threshold, values above this can be part of a cluster. dim : str - Dimension name. + Dimension name. Returns ------- xr.Dataset - With variables, - - `nclusters` : Number of clusters for each point (with `dim` reduced), int - - `start` : First index in the cluster (`dim` reduced, new `cluster`), int - - `end` : Last index in the cluster, inclusive (`dim` reduced, new `cluster`), int - - `maxpos` : Index of the maximal value within the cluster (`dim` reduced, new `cluster`), int - - `maximum` : Maximal value within the cluster (`dim` reduced, new `cluster`), same dtype as data. - - For `start`, `end` and `maxpos`, -1 means NaN and should always correspond to a `NaN` in `maximum`. - The length along `cluster` is half the size of "dim", the maximal theoretical number of clusters. + With variables, + - `nclusters` : Number of clusters for each point (with `dim` reduced), int + - `start` : First index in the cluster (`dim` reduced, new `cluster`), int + - `end` : Last index in the cluster, inclusive (`dim` reduced, new `cluster`), int + - `maxpos` : Index of the maximal value within the cluster (`dim` reduced, new `cluster`), int + - `maximum` : Maximal value within the cluster (`dim` reduced, new `cluster`), same dtype as data. + + For `start`, `end` and `maxpos`, -1 means NaN and should always correspond to a `NaN` in `maximum`. + The length along `cluster` is half the size of "dim", the maximal theoretical number of clusters. """ def _get_clusters(arr, u1, u2, N): @@ -913,24 +914,23 @@ def rand_rot_matrix( Parameters ---------- - crd: xr.DataArray - 1D coordinate DataArray along which the rotation occurs. - The output will be square with the same coordinate replicated, - the second renamed to `new_dim`. + crd : xr.DataArray + 1D coordinate DataArray along which the rotation occurs. + The output will be square with the same coordinate replicated, + the second renamed to `new_dim`. num : int - If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. + If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. new_dim : str - Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". + Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". Returns ------- xr.DataArray - float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. + Data of type float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. References ---------- :cite:cts:`sdba-mezzadri_how_2007` - """ if num > 1: return xr.concat([rand_rot_matrix(crd, num=1) for i in range(num)], "matrices") From 0f78ee73c73e31e1ca779f9544c9227e27b10c85 Mon Sep 17 00:00:00 2001 From: Zeitsperre <10819524+Zeitsperre@users.noreply.github.com> Date: Thu, 25 Jul 2024 15:20:57 -0400 Subject: [PATCH 014/105] remove blanket noqa statements --- src/xsdba/base.py | 6 ++---- src/xsdba/logging.py | 3 ++- src/xsdba/nbutils.py | 6 ++---- src/xsdba/options.py | 2 +- src/xsdba/utils.py | 2 +- tests/conftest.py | 4 ++-- tests/test_loess.py | 14 ++++++++------ 7 files changed, 18 insertions(+), 19 deletions(-) diff --git a/src/xsdba/base.py b/src/xsdba/base.py index f9a63fa..45c97a7 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -7,7 +7,7 @@ import datetime as pydt from collections.abc import Sequence -from inspect import _empty, signature # noqa +from inspect import _empty, signature from typing import Any, Callable import cftime @@ -745,9 +745,7 @@ def _map_blocks(ds, **kwargs): # noqa: C901 # Optimization to circumvent the slow pickle.dumps(cftime_array) # List of the keys to avoid changing the coords dict while iterating over it. for crd in list(ds.coords.keys()): - if xr.core.common._contains_cftime_datetimes( - ds[crd].variable - ): # noqa + if xr.core.common._contains_cftime_datetimes(ds[crd].variable): ds[crd] = xr.conventions.encode_cf_variable(ds[crd].variable) def _call_and_transpose_on_exit(dsblock, **f_kwargs): diff --git a/src/xsdba/logging.py b/src/xsdba/logging.py index 7ba684b..79ee33c 100644 --- a/src/xsdba/logging.py +++ b/src/xsdba/logging.py @@ -16,7 +16,8 @@ class ValidationError(ValueError): """Error raised when input data to an indicator fails the validation tests.""" @property - def msg(self): # noqa + def msg(self): + """Return the error message.""" return self.args[0] diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index 91950ae..9a0a58c 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -277,7 +277,7 @@ def quantile(da: DataArray, q: np.ndarray, dim: str | Sequence[Hashable]) -> Dat nogil=True, cache=False, ) -def remove_NaNs(x): # noqa +def remove_NaNs(x): # noqa: N802 """Remove NaN values from series.""" remove = np.zeros_like(x[0, :], dtype=boolean) for i in range(x.shape[0]): @@ -386,9 +386,7 @@ def _first_and_last_nonnull(arr): nogil=True, cache=False, ) -def _extrapolate_on_quantiles( - interp, oldx, oldg, oldy, newx, newg, method="constant" -): # noqa +def _extrapolate_on_quantiles(interp, oldx, oldg, oldy, newx, newg, method="constant"): """Apply extrapolation to the output of interpolation on quantiles with a given grouping. Arguments are the same as _interp_on_quantiles_2D. diff --git a/src/xsdba/options.py b/src/xsdba/options.py index 5d3c028..ef48f11 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -50,7 +50,7 @@ def _valid_missing_options(mopts): # All options must exist or any([opt not in OPTIONS[MISSING_OPTIONS][meth] for opt in opts.keys()]) # Method option validator must pass, default validator is always True. - or not cls.validate(**opts) # noqa + or not cls.validate(**opts) ): return False return True diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 9127311..0728b79 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -434,7 +434,7 @@ def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 return out -def _interp_on_quantiles_2D(newx, newg, oldx, oldy, oldg, method, extrap): # noqa +def _interp_on_quantiles_2D(newx, newg, oldx, oldy, oldg, method, extrap): # noqa: N802 mask_new = np.isnan(newx) | np.isnan(newg) mask_old = np.isnan(oldy) | np.isnan(oldx) | np.isnan(oldg) out = np.full_like(newx, np.NaN, dtype=f"float{oldy.dtype.itemsize * 8}") diff --git a/tests/conftest.py b/tests/conftest.py index 2fa621a..3cca5df 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -27,7 +27,7 @@ # from xclim import __version__ as __xclim_version__ # from xclim.core.calendar import max_doy # from xclim.testing import helpers -# from xclim.testing.utils import _default_cache_dir # noqa +# from xclim.testing.utils import _default_cache_dir # from xclim.testing.utils import get_file # from xclim.testing.utils import open_dataset as _open_dataset @@ -197,7 +197,7 @@ def add_example_dataarray(xdoctest_namespace, timeseries) -> None: def is_matplotlib_installed(xdoctest_namespace) -> None: def _is_matplotlib_installed(): try: - import matplotlib # noqa + import matplotlib return except ImportError: diff --git a/tests/test_loess.py b/tests/test_loess.py index aac12a0..aa58831 100644 --- a/tests/test_loess.py +++ b/tests/test_loess.py @@ -5,12 +5,14 @@ import pytest import xarray as xr -from xsdba.loess import _constant_regression # noqa -from xsdba.loess import _gaussian_weighting # noqa -from xsdba.loess import _linear_regression # noqa -from xsdba.loess import _loess_nb # noqa -from xsdba.loess import _tricube_weighting # noqa -from xsdba.loess import loess_smoothing +from xsdba.loess import ( + _constant_regression, + _gaussian_weighting, + _linear_regression, + _loess_nb, + _tricube_weighting, + loess_smoothing, +) @pytest.mark.slow From a8706ade9a7bbef407bb93dce35a7da990a127ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Thu, 25 Jul 2024 23:18:27 -0400 Subject: [PATCH 015/105] PASSED: test_detrending (simple units handling added) --- environment-dev.yml | 11 ++++ pyproject.toml | 1 + src/xsdba/base.py | 6 +-- src/xsdba/loess.py | 2 +- src/xsdba/nbutils.py | 8 +-- src/xsdba/units.py | 44 +++++++++++++++ src/xsdba/utils.py | 8 +-- tests/test_detrending.py | 114 +++++++++++++++++++++++++++++++++++++++ tests/test_utils.py | 4 +- 9 files changed, 183 insertions(+), 15 deletions(-) create mode 100644 src/xsdba/units.py create mode 100644 tests/test_detrending.py diff --git a/environment-dev.yml b/environment-dev.yml index 1cb020c..f44f60b 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -3,6 +3,16 @@ channels: - conda-forge dependencies: - python >=3.9,<3.13 + # - xarray >=2022.05.0.dev0 + - xarray + - cftime + - dask # why was this not installed?? + - jsonpickle + - boltons + - scipy + - numba + - numpy<2.0 # to accomodate numba + # Dev tools and testing - pip >=24.0 - bump-my-version >=0.24.3 @@ -22,3 +32,4 @@ dependencies: - numpydoc >=1.7.0 - pre-commit >=3.5.0 - ruff >=0.5.0 + - xdoctest diff --git a/pyproject.toml b/pyproject.toml index c85b19c..fba22c2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -267,6 +267,7 @@ addopts = [ ] filterwarnings = ["ignore::UserWarning"] testpaths = "tests" +usefixtures = "xdoctest_namespace" [tool.ruff] src = ["xsdba"] diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 598d981..cfe2ec1 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -5,19 +5,18 @@ from __future__ import annotations -import datetime as pydt from collections.abc import Sequence from inspect import _empty, signature # noqa from typing import Callable -import cftime import dask.array as dsk import jsonpickle import numpy as np import xarray as xr from boltons.funcutils import wraps - from xsdba.options import OPTIONS, SDBA_ENCODE_CF +import datetime as pydt +import cftime # ## Base class for the sdba module @@ -95,7 +94,6 @@ def set_dataset(self, ds: xr.Dataset) -> None: self.ds = ds self.ds.attrs[self._attribute] = jsonpickle.encode(self) - # XC put here to avoid circular import def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: """Evaluate whether dask is installed and array is loaded as a dask array. diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py index abb1548..f20974e 100644 --- a/src/xsdba/loess.py +++ b/src/xsdba/loess.py @@ -92,7 +92,7 @@ def _loess_nb( """ if skipna: nan = np.isnan(y) - out = np.full(x.size, np.NaN) + out = np.full(x.size, np.nan) y = y[~nan] x = x[~nan] if x.size == 0: diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index 355fbdd..70f4a49 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -153,7 +153,7 @@ def _nan_quantile_1d( ) def _vecquantiles(arr, rnk, res): if np.isnan(rnk): - res[0] = np.NaN + res[0] = np.nan else: res[0] = np.nanquantile(arr, rnk) @@ -366,7 +366,7 @@ def _first_and_last_nonnull(arr): if idxs.size > 0: out[i] = arr[i][idxs[np.array([0, -1])]] else: - out[i] = np.array([np.NaN, np.NaN]) + out[i] = np.array([np.nan, np.nan]) return out @@ -391,8 +391,8 @@ def _extrapolate_on_quantiles(interp, oldx, oldg, oldy, newx, newg, method="cons interp[toolow] = cnstlow[toolow] interp[toohigh] = cnsthigh[toohigh] else: # 'nan' - interp[toolow] = np.NaN - interp[toohigh] = np.NaN + interp[toolow] = np.nan + interp[toohigh] = np.nan return interp diff --git a/src/xsdba/units.py b/src/xsdba/units.py new file mode 100644 index 0000000..721bf73 --- /dev/null +++ b/src/xsdba/units.py @@ -0,0 +1,44 @@ +""" +Units Handling Submodule +======================== +""" + +import pint +import inspect +from functools import wraps +import xarray as xr + +def extract_units(arg): + if not (isinstance(arg, (str, xr.DataArray)) or np.isscalar(arg)): + raise TypeError ("Argument must be a str, DataArray, or scalar.") + elif isinstance(arg, xr.DataArray): + ustr = None if "units" not in arg.attrs else arg.attrs["units"] + elif isinstance(arg, str): + # XC + _, ustr = arg.split(" ", maxsplit=1) + else: # (scalar case) + ustr = None + return ustr if ustr is None else pint.Quantity(1, ustr).units + + +def check_units(args_to_check): + # if no units are present (DataArray without units attribute or float), then no check is performed + # if units are present, then check is performed + # in mixed cases, an error is raised + def decorator(func): + @wraps(func) + def wrapper(*args, **kwargs): + # dictionnary {arg_name:arg} for all args of func + arg_dict = dict(zip(inspect.getfullargspec(func).args, args)) + # Obtain units (or None if no units) of all args + units = [] + for arg_name in args_to_check: + if arg_name not in arg_dict: + raise ValueError(f"Argument '{arg_name}' not found in function arguments.") + units.append(extract_units(arg_dict[arg_name])) + # Check that units are consistent + if len(set(units)) > 1: + raise ValueError(f"{args_to_check} must have the same units (or no units). Got {units}") + return func(*args, **kwargs) + return wrapper + return decorator \ No newline at end of file diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 4d2a6ad..15553ea 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -385,7 +385,7 @@ def add_cyclic_bounds(da: xr.DataArray, att: str, cyclic_coords: bool = True) -> def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 mask_new = np.isnan(newx) mask_old = np.isnan(oldy) | np.isnan(oldx) - out = np.full_like(newx, np.NaN, dtype=f"float{oldy.dtype.itemsize * 8}") + out = np.full_like(newx, np.nan, dtype=f"float{oldy.dtype.itemsize * 8}") if np.all(mask_new) or np.all(mask_old): warn( "All-NaN slice encountered in interp_on_quantiles", @@ -399,7 +399,7 @@ def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 oldy[~np.isnan(oldy)][-1], ) else: # extrap == 'nan' - fill_value = np.NaN + fill_value = np.nan out[~mask_new] = interp1d( oldx[~mask_old], @@ -414,7 +414,7 @@ def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 def _interp_on_quantiles_2D(newx, newg, oldx, oldy, oldg, method, extrap): # noqa mask_new = np.isnan(newx) | np.isnan(newg) mask_old = np.isnan(oldy) | np.isnan(oldx) | np.isnan(oldg) - out = np.full_like(newx, np.NaN, dtype=f"float{oldy.dtype.itemsize * 8}") + out = np.full_like(newx, np.nan, dtype=f"float{oldy.dtype.itemsize * 8}") if np.all(mask_new) or np.all(mask_old): warn( "All-NaN slice encountered in interp_on_quantiles", @@ -826,7 +826,7 @@ def _get_clusters(arr, u1, u2, N): np.append(st, pad), np.append(ed, pad), np.append(mp, pad), - np.append(mv, [np.NaN] * (N - count)), + np.append(mv, [np.nan] * (N - count)), count, ) diff --git a/tests/test_detrending.py b/tests/test_detrending.py new file mode 100644 index 0000000..de7b4fe --- /dev/null +++ b/tests/test_detrending.py @@ -0,0 +1,114 @@ +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr +from scipy.signal import windows + +from xsdba import Grouper +from xsdba.detrending import ( + LoessDetrend, + MeanDetrend, + NoDetrend, + PolyDetrend, + RollingMeanDetrend, +) + + + + +def test_poly_detrend_and_from_ds(timelonlatseries, tmp_path): + x = timelonlatseries(np.arange(20 * 365.25), "tas") + + poly = PolyDetrend(degree=1) + fx = poly.fit(x) + dx = fx.detrend(x) + xt = fx.retrend(dx) + + # The precision suffers due to 2 factors: + # - The date is approximate (middle of the period) + # - The last period may not be complete. + np.testing.assert_array_almost_equal(dx, 0) + np.testing.assert_array_almost_equal(xt, x) + + file = tmp_path / "test_polydetrend.nc" + fx.ds.to_netcdf(file) + + ds = xr.open_dataset(file) + fx2 = PolyDetrend.from_dataset(ds) + + xr.testing.assert_equal(fx.ds, fx2.ds) + dx2 = fx2.detrend(x) + np.testing.assert_array_equal(dx, dx2) + + +@pytest.mark.slow +def test_loess_detrend(timelonlatseries): + x = timelonlatseries(np.arange(12 * 365.25), "tas") + det = LoessDetrend(group="time", d=0, niter=1, f=0.2) + fx = det.fit(x) + dx = fx.detrend(x) + xt = fx.retrend(dx) + + # Strong boundary effects in LOESS, remove ~ f * Nx on each side. + np.testing.assert_array_almost_equal(dx.isel(time=slice(880, 3500)), 0) + np.testing.assert_array_almost_equal(xt, x) + + +def test_mean_detrend(timelonlatseries): + x = timelonlatseries(np.arange(20 * 365.25), "tas") + + md = MeanDetrend().fit(x) + assert (md.ds.trend == x.mean()).all() + + anomaly = md.detrend(x) + x2 = md.retrend(anomaly) + + np.testing.assert_array_almost_equal(x, x2) + + +def test_rollingmean_detrend(timelonlatseries): + x = timelonlatseries(np.arange(12 * 365.25), "tas") + det = RollingMeanDetrend(group="time", win=29, min_periods=1) + fx = det.fit(x) + dx = fx.detrend(x) + xt = fx.retrend(dx) + + np.testing.assert_array_almost_equal(dx.isel(time=slice(30, 3500)), 0) + np.testing.assert_array_almost_equal(xt, x) + + # weights + grouping + x = xr.DataArray( + np.sin(2 * np.pi * np.arange(11 * 365) / 365), + dims=("time",), + coords={ + "time": xr.cftime_range( + "2010-01-01", periods=11 * 365, freq="D", calendar="noleap" + ) + }, + ) + w = windows.get_window("triang", 11, False) + det = RollingMeanDetrend( + group=Grouper("time.dayofyear", window=3), win=11, weights=w + ) + fx = det.fit(x) + assert fx.ds.trend.notnull().sum() == 365 + + +def test_no_detrend(timelonlatseries): + x = timelonlatseries(np.arange(12 * 365.25), "tas") + + det = NoDetrend(group="time.dayofyear", kind="+") + + with pytest.raises(ValueError, match="You must call fit()"): + det.retrend(x) + + with pytest.raises(ValueError, match="You must call fit()"): + det.detrend(x) + + assert repr(det).endswith("unfitted>") + + fit = det.fit(x) + + np.testing.assert_array_equal(fit.retrend(x), x) + np.testing.assert_array_equal(fit.detrend(x), x) diff --git a/tests/test_utils.py b/tests/test_utils.py index aa0085d..fb36284 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -66,7 +66,7 @@ def test_equally_spaced_nodes(): @pytest.mark.parametrize("interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)]) -@pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) +@pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.nan)]) def test_interp_on_quantiles_constant(interp, expi, extrap, expe): quantiles = np.linspace(0, 1, num=25) xq = xr.DataArray( @@ -147,7 +147,7 @@ def test_interp_on_quantiles_monthly(random): @pytest.mark.parametrize("interp,expi", [("nearest", 2.9), ("linear", 2.95), ("cubic", 2.95)]) -@pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.NaN)]) +@pytest.mark.parametrize("extrap,expe", [("constant", 4.4), ("nan", np.nan)]) def test_interp_on_quantiles_constant_with_nan(interp, expi, extrap, expe): quantiles = np.linspace(0, 1, num=30) xq = xr.DataArray( From 36f9009223adb4615437842d3f775d44dafec961 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 26 Jul 2024 03:22:32 +0000 Subject: [PATCH 016/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- environment-dev.yml | 2 +- src/xsdba/units.py | 30 +++++++++++++++++++----------- tests/test_detrending.py | 2 -- 3 files changed, 20 insertions(+), 14 deletions(-) diff --git a/environment-dev.yml b/environment-dev.yml index f44f60b..76b576e 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -12,7 +12,7 @@ dependencies: - scipy - numba - numpy<2.0 # to accomodate numba - + # Dev tools and testing - pip >=24.0 - bump-my-version >=0.24.3 diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 721bf73..4e6090d 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -3,21 +3,23 @@ ======================== """ -import pint import inspect from functools import wraps -import xarray as xr -def extract_units(arg): +import pint +import xarray as xr + + +def extract_units(arg): if not (isinstance(arg, (str, xr.DataArray)) or np.isscalar(arg)): - raise TypeError ("Argument must be a str, DataArray, or scalar.") - elif isinstance(arg, xr.DataArray): + raise TypeError("Argument must be a str, DataArray, or scalar.") + elif isinstance(arg, xr.DataArray): ustr = None if "units" not in arg.attrs else arg.attrs["units"] elif isinstance(arg, str): # XC - _, ustr = arg.split(" ", maxsplit=1) - else: # (scalar case) - ustr = None + _, ustr = arg.split(" ", maxsplit=1) + else: # (scalar case) + ustr = None return ustr if ustr is None else pint.Quantity(1, ustr).units @@ -34,11 +36,17 @@ def wrapper(*args, **kwargs): units = [] for arg_name in args_to_check: if arg_name not in arg_dict: - raise ValueError(f"Argument '{arg_name}' not found in function arguments.") + raise ValueError( + f"Argument '{arg_name}' not found in function arguments." + ) units.append(extract_units(arg_dict[arg_name])) # Check that units are consistent if len(set(units)) > 1: - raise ValueError(f"{args_to_check} must have the same units (or no units). Got {units}") + raise ValueError( + f"{args_to_check} must have the same units (or no units). Got {units}" + ) return func(*args, **kwargs) + return wrapper - return decorator \ No newline at end of file + + return decorator diff --git a/tests/test_detrending.py b/tests/test_detrending.py index de7b4fe..a94269e 100644 --- a/tests/test_detrending.py +++ b/tests/test_detrending.py @@ -15,8 +15,6 @@ ) - - def test_poly_detrend_and_from_ds(timelonlatseries, tmp_path): x = timelonlatseries(np.arange(20 * 365.25), "tas") From 9f9279bd7191b17b031cbee7516871d564dc6d15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Fri, 26 Jul 2024 09:43:04 -0400 Subject: [PATCH 017/105] forgot to add detrending (rule SS01 broken) --- src/xsdba/detrending.py | 339 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 339 insertions(+) create mode 100644 src/xsdba/detrending.py diff --git a/src/xsdba/detrending.py b/src/xsdba/detrending.py new file mode 100644 index 0000000..47ad7f3 --- /dev/null +++ b/src/xsdba/detrending.py @@ -0,0 +1,339 @@ +""" +Detrending Objects Utilities +============================ +""" + +from __future__ import annotations + +import xarray as xr + +from .base import Grouper, ParametrizableWithDataset, map_groups, parse_group +from .loess import loess_smoothing +from .units import check_units +from .utils import ADDITIVE, apply_correction, invert + + +class BaseDetrend(ParametrizableWithDataset): + """Base class for detrending objects. + + Defines three methods: + + fit(da) : Compute trend from da and return a new _fitted_ Detrend object. + detrend(da) : Return detrended array. + retrend(da) : Puts trend back on da. + + A fitted `Detrend` object is unique to the trend coordinate of the object used in `fit`, (usually 'time'). + The computed trend is stored in ``Detrend.ds.trend``. + + Subclasses should implement ``_get_trend_group()`` or ``_get_trend()``. + The first will be called in a ``group.apply(..., main_only=True)``, and should return a single DataArray. + The second allows the use of functions wrapped in :py:func:`map_groups` and should also return a single DataArray. + + The subclasses may reimplement ``_detrend`` and ``_retrend``. + """ + + @parse_group + def __init__(self, *, group: Grouper | str = "time", kind: str = "+", **kwargs): + """Initialize Detrending object. + + Parameters + ---------- + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The fit is performed along the group's main dim. + kind : {'*', '+'} + The way the trend is removed or added, either additive or multiplicative. + """ + super().__init__(group=group, kind=kind, **kwargs) + + @property + def fitted(self): + """Return whether instance is fitted.""" + return hasattr(self, "ds") + + def fit(self, da: xr.DataArray): + """Extract the trend of a DataArray along a specific dimension. + + Returns a new object that can be used for detrending and retrending. + Fitted objects are unique to the fitted coordinate used. + """ + new = self.__class__(**self.parameters) + new.set_dataset(new._get_trend(da).rename("trend").to_dataset()) + new.ds.trend.attrs["units"] = da.attrs.get("units", "") + return new + + def _get_trend(self, da: xr.DataArray): + """Compute the trend along the self.group.dim as found on da. + + If da is a DataArray (and has a `dtype` attribute), the trend is cast to have the same dtype. + + Notes + ----- + This method applies `_get_trend_group` with `self.group`. + """ + out = self.group.apply( + self._get_trend_group, + da, + ) + if hasattr(da, "dtype"): + out = out.astype(da.dtype) + return out.rename("trend") + + def detrend(self, da: xr.DataArray): + """Remove the previously fitted trend from a DataArray.""" + if not self.fitted: + raise ValueError("You must call fit() before detrending.") + return self._detrend(da, self.ds.trend) + + def retrend(self, da: xr.DataArray): + """Put the previously fitted trend back on a DataArray.""" + if not self.fitted: + raise ValueError("You must call fit() before retrending") + return self._retrend(da, self.ds.trend) + + @check_units(["da", "trend"]) + def _detrend(self, da, trend): + """Detrend.""" + # Remove trend from series + return apply_correction(da, invert(trend, self.kind), self.kind) + + @check_units(["da", "trend"]) + def _retrend(self, da, trend): + """Retrend.""" + # Add trend to series + return apply_correction(da, trend, self.kind) + + def _get_trend_group(self, grpd, *, dim): + """Get trend for a group.""" + raise NotImplementedError + + def __repr__(self): + """Format instance representation.""" + rep = super().__repr__() + if not self.fitted: + return f"<{rep} | unfitted>" + return rep + + +class NoDetrend(BaseDetrend): + """Convenience class for polymorphism. Does nothing.""" + + def _get_trend_group(self, da, *, dim): + """Placeholder.""" + return da.isel({d: 0 for d in dim}) + + def _detrend(self, da, trend): + """Placeholder.""" + return da + + def _retrend(self, da, trend): + """Placeholder.""" + return da + + +class MeanDetrend(BaseDetrend): + """Simple detrending removing only the mean from the data, quite similar to normalizing.""" + + def _get_trend(self, da): + """Trend.""" + return _meandetrend_get_trend(da, **self).trend + + +@map_groups(trend=[Grouper.DIM]) +def _meandetrend_get_trend(da, *, dim, kind): + """Mean detrend.""" + trend = da.mean(dim).broadcast_like(da) + return trend.rename("trend").to_dataset() + + +class PolyDetrend(BaseDetrend): + """Detrend time series using a polynomial regression. + + Attributes + ---------- + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The fit is performed along the group's main dim. + kind : {'*', '+'} + The way the trend is removed or added, either additive or multiplicative. + degree : int + The order of the polynomial to fit. + preserve_mean : bool + Whether to preserve the mean when de/re-trending. + If True, the trend has its mean removed before it is used. + """ + + def __init__(self, group="time", kind=ADDITIVE, degree=4, preserve_mean=False): + """Init.""" + super().__init__( + group=group, kind=kind, degree=degree, preserve_mean=preserve_mean + ) + + def _get_trend(self, da): + """Trend.""" + # Estimate trend over da + trend = _polydetrend_get_trend(da, **self) + return trend.trend + + +@map_groups(trend=[Grouper.DIM]) +def _polydetrend_get_trend(da, *, dim, degree, preserve_mean, kind): + """Polydetrend, atomic func on 1 group.""" + if len(dim) > 1: + da = da.mean(dim[1:]) + dim = dim[0] + pfc = da.polyfit(dim=dim, deg=degree) + trend = xr.polyval(coord=da[dim], coeffs=pfc.polyfit_coefficients) + + if preserve_mean: + trend = apply_correction(trend, invert(trend.mean(dim=dim), kind), kind) + out = trend.rename("trend").to_dataset() + return out + + +class LoessDetrend(BaseDetrend): + """Detrend time series using a LOESS regression. + + The fit is a piecewise linear regression. For each point, the contribution of all + neighbors is weighted by a bell-shaped curve (gaussian) with parameters sigma (std). + The x-coordinate of the DataArray is scaled to [0,1] before the regression is computed. + + Attributes + ---------- + group : str or Grouper + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The fit is performed along the group's main dim. + kind : {'*', '+'} + The way the trend is removed or added, either additive or multiplicative. + d : {0, 1} + Order of the local regression. Only 0 and 1 currently implemented. + f : float + Parameter controlling the span of the weights, between 0 and 1. + niter : int + Number of robustness iterations to execute. + weights : ["tricube", "gaussian"] + Shape of the weighting function: + "tricube" : a smooth top-hat like curve, f gives the span of non-zero values. + "gaussian" : a gaussian curve, f gives the span for 95% of the values. + skipna : bool + If True (default), missing values are not included in the loess trend computation + and thus are not propagated. The output will have the same missing values as the input. + + Notes + ----- + LOESS smoothing is computationally expensive. As it relies on a loop on gridpoints, it can be useful to use + smaller than usual chunks. Moreover, it suffers from heavy boundary effects. As a rule of thumb, the outermost + N * f/2 points should be considered dubious. (N is the number of points along each group) + """ + + def __init__( + self, + group="time", + kind=ADDITIVE, + f=0.2, + niter=1, + d=0, + weights="tricube", + equal_spacing=None, + skipna=True, + ): + """Init.""" + super().__init__( + group=group, + kind=kind, + f=f, + niter=niter, + d=d, + weights=weights, + equal_spacing=equal_spacing, + skipna=skipna, + ) + + def _get_trend(self, da): + """Trend.""" + # Estimate trend over da + trend = _loessdetrend_get_trend(da, **self) + return trend.trend + + +@map_groups(trend=[Grouper.DIM]) +def _loessdetrend_get_trend( + da, *, dim, f, niter, d, weights, equal_spacing, skipna, kind +): + """Loessdetrend.""" + if len(dim) > 1: + da = da.mean(dim[1:]) + trend = loess_smoothing( + da, + dim=dim[0], + f=f, + niter=niter, + d=d, + weights=weights, + equal_spacing=equal_spacing, + skipna=skipna, + ) + return trend.rename("trend").to_dataset() + + +class RollingMeanDetrend(BaseDetrend): + """Detrend time series using a rolling mean. + + Attributes + ---------- + group : str or Grouper + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The fit is performed along the group's main dim. + kind : {'*', '+'} + The way the trend is removed or added, either additive or multiplicative. + win : int + The size of the rolling window. Units are the steps of the grouped data, which + means this detrending is best use with either `group='time'` or + `group='time.dayofyear'`. Other grouping will have large jumps included within the + windows and :py`:class:`LoessDetrend` might offer a better solution. + weights : sequence of floats, optional + Sequence of length `win`. Defaults to None, which means a flat window. + min_periods : int, optional + Minimum number of observations in window required to have a value, otherwise the + result is NaN. See :py:meth:`xarray.DataArray.rolling`. + Defaults to None, which sets it equal to `win`. Setting both `weights` and this + is not implemented yet. + + Notes + ----- + As for the :py:class:`LoessDetrend` detrending, important boundary effects are to be expected. + """ + + def __init__( + self, group="time", kind=ADDITIVE, win=30, weights=None, min_periods=None + ): + """Init.""" + if weights is not None: + weights = xr.DataArray(weights, dims=("window",)) + weights = weights / weights.sum() + if min_periods is not None: + raise NotImplementedError( + "Setting both `min_periods` and `weights` is not implemented yet." + ) + super().__init__( + group=group, kind=kind, win=win, weights=weights, min_periods=min_periods + ) + + def _get_trend(self, da): + """Trend.""" + # Estimate trend over da + trend = _rollingmean_get_trend(da, **self) + return trend.trend + + +@map_groups(trend=[Grouper.DIM]) +def _rollingmean_get_trend(da, *, dim, kind, win, weights, min_periods): + """Rollingmean trend.""" + if len(dim) > 1: + da = da.mean(dim[1:]) + roll = da.rolling(center=True, min_periods=min_periods, **{dim[0]: win}) + if weights is not None: + trend = roll.construct("window").dot(weights) + else: + trend = roll.mean() + return trend.rename("trend").to_dataset() From 8673e2c6c01ea7d373ffc9f7aa21bf238a3b5ba2 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Fri, 26 Jul 2024 12:15:24 -0400 Subject: [PATCH 018/105] credit where it's due --- AUTHORS.rst | 5 +++-- CHANGELOG.rst | 4 ++-- pyproject.toml | 2 ++ 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index c5698c2..5c4e362 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,12 +5,13 @@ Credits Development Lead ---------------- -* Trevor James Smith `@Zeitsperre `_ +* Éric Dupuis `@coxipi `_ Co-Developers ------------- -* Éric Dupuis `@coxipi `_ +* Pascal Bourgault `@aulemahal `_ +* Trevor James Smith `@Zeitsperre `_ Contributors ------------ diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 91f608e..8b415e8 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -5,7 +5,7 @@ Changelog `Unreleased `_ (latest) ------------------------------------------------------------ -Contributors: +Contributors: Éric Dupuis (:user:`coxipi`), Trevor James Smith (:user:`Zeitsperre`). Changes ^^^^^^^ @@ -20,7 +20,7 @@ Fixes `v0.1.0 `_ ---------------------------------------------------------- -Contributors: Trevor James Smith (:user:`Ouranosinc`) +Contributors: Trevor James Smith (:user:`Zeitsperre`) Changes ^^^^^^^ diff --git a/pyproject.toml b/pyproject.toml index 63b1480..7ab1d1a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,9 +7,11 @@ build-backend = "flit_core.buildapi" [project] name = "xsdba" authors = [ + {name = "Éric Dupuis", email = "dupuis.eric@ouranos.ca"}, {name = "Trevor James Smith", email = "smith.trevorj@ouranos.ca"} ] maintainers = [ + {name = "Éric Dupuis", email = "dupuis.eric@ouranos.ca"}, {name = "Trevor James Smith", email = "smith.trevorj@ouranos.ca"} ] readme = {file = "README.rst", content-type = "text/x-rst"} From 77fbd7a8c558dab9b5c5ec168e13136705ca41c3 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Fri, 26 Jul 2024 12:17:23 -0400 Subject: [PATCH 019/105] drop Python3.8 --- pyproject.toml | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 7ab1d1a..c7f89f3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,7 +26,6 @@ classifiers = [ "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", @@ -95,7 +94,6 @@ xsdba = "xsdba.cli:app" [tool.black] target-version = [ - "py38", "py39", "py310", "py311", @@ -212,7 +210,7 @@ exclude = [ [tool.isort] profile = "black" -py_version = 38 +py_version = 39 [tool.mypy] files = "." @@ -275,7 +273,7 @@ usefixtures = "xdoctest_namespace" [tool.ruff] src = ["xsdba"] line-length = 150 -target-version = "py38" +target-version = "py39" exclude = [ ".eggs", ".git", From 8dcb0fb6697d60e0a1eaaed1d1fe1eee872cd102 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Fri, 26 Jul 2024 12:24:24 -0400 Subject: [PATCH 020/105] linting --- src/xsdba/detrending.py | 2 +- src/xsdba/units.py | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/xsdba/detrending.py b/src/xsdba/detrending.py index 47ad7f3..e0977fb 100644 --- a/src/xsdba/detrending.py +++ b/src/xsdba/detrending.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Detrending Objects Utilities ============================ """ diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 4e6090d..85db532 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Units Handling Submodule ======================== """ @@ -11,6 +11,7 @@ def extract_units(arg): + """Extract units from a string, DataArray, or scalar.""" if not (isinstance(arg, (str, xr.DataArray)) or np.isscalar(arg)): raise TypeError("Argument must be a str, DataArray, or scalar.") elif isinstance(arg, xr.DataArray): @@ -24,6 +25,8 @@ def extract_units(arg): def check_units(args_to_check): + """Decorator to check that all arguments have the same units (or no units).""" + # if no units are present (DataArray without units attribute or float), then no check is performed # if units are present, then check is performed # in mixed cases, an error is raised From fa3f64eb0440cbc330a5396b7b4fb9341f11037c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Fri, 26 Jul 2024 22:21:00 -0400 Subject: [PATCH 021/105] PASSED: test_processing.py (no hydro conv & missing EQM) --- environment-dev.yml | 1 + src/xsdba/__init__.py | 2 +- src/xsdba/_processing.py | 210 ++++++++++ src/xsdba/base.py | 126 +++++- src/xsdba/formatting.py | 202 +++++++++ src/xsdba/processing.py | 883 +++++++++++++++++++++++++++++++++++++++ src/xsdba/testing.py | 21 +- src/xsdba/units.py | 304 +++++++++++++- tests/conftest.py | 3 +- tests/test_processing.py | 305 ++++++++++++++ 10 files changed, 2025 insertions(+), 32 deletions(-) create mode 100644 src/xsdba/_processing.py create mode 100644 src/xsdba/formatting.py create mode 100644 src/xsdba/processing.py create mode 100644 tests/test_processing.py diff --git a/environment-dev.yml b/environment-dev.yml index 76b576e..d07fbbb 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -12,6 +12,7 @@ dependencies: - scipy - numba - numpy<2.0 # to accomodate numba + - cf-xarray # to accomodate numba # Dev tools and testing - pip >=24.0 diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 10e0d80..19b5c05 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -20,7 +20,7 @@ from __future__ import annotations -from . import base, utils +from . import base, utils, units, detrending, processing # , adjustment # from . import adjustment, base, detrending, measures, processing, properties, utils diff --git a/src/xsdba/_processing.py b/src/xsdba/_processing.py new file mode 100644 index 0000000..cd2566b --- /dev/null +++ b/src/xsdba/_processing.py @@ -0,0 +1,210 @@ +""" +Compute Functions Submodule +=========================== + +Here are defined the functions wrapped by map_blocks or map_groups. +The user-facing, metadata-handling functions should be defined in processing.py. +""" + +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np +import xarray as xr + +from . import nbutils as nbu +from .base import Grouper, map_groups +from .utils import ADDITIVE, apply_correction, ecdf, invert, rank + + +@map_groups( + sim_ad=[Grouper.ADD_DIMS, Grouper.DIM], pth=[Grouper.PROP], dP0=[Grouper.PROP] +) +def _adapt_freq( + ds: xr.Dataset, + *, + dim: Sequence[str], + thresh: float = 0, +) -> xr.Dataset: + r""" + Adapt frequency of values under thresh of `sim`, in order to match ref. + + This is the compute function, see :py:func:`xclim.sdba.processing.adapt_freq` for the user-facing function. + + Parameters + ---------- + ds : xr.Dataset + With variables : "ref", Target/reference data, usually observed data and "sim", Simulated data. + dim : str, or sequence of strings + Dimension name(s). If more than one, the probabilities and quantiles are computed within all the dimensions. + If `window` is in the names, it is removed before the correction + and the final timeseries is corrected along dim[0] only. + group : Union[str, Grouper] + Grouping information, see base.Grouper + thresh : float + Threshold below which values are considered zero. + + Returns + ------- + xr.Dataset, with the following variables: + + - `sim_adj`: Simulated data with the same frequency of values under threshold than ref. + Adjustment is made group-wise. + - `pth` : For each group, the smallest value of sim that was not frequency-adjusted. All values smaller were + either left as zero values or given a random value between thresh and pth. + NaN where frequency adaptation wasn't needed. + - `dP0` : For each group, the percentage of values that were corrected in sim. + """ + # Compute the probability of finding a value <= thresh + # This is the "dry-day frequency" in the precipitation case + P0_sim = ecdf(ds.sim, thresh, dim=dim) + P0_ref = ecdf(ds.ref, thresh, dim=dim) + + # The proportion of values <= thresh in sim that need to be corrected, compared to ref + dP0 = (P0_sim - P0_ref) / P0_sim + + if dP0.isnull().all(): + # All NaN slice. + pth = dP0.copy() + sim_ad = ds.sim.copy() + else: + # Compute : ecdf_ref^-1( ecdf_sim( thresh ) ) + # The value in ref with the same rank as the first non-zero value in sim. + # pth is meaningless when freq. adaptation is not needed + pth = nbu.vecquantiles(ds.ref, P0_sim, dim).where(dP0 > 0) + + # Probabilities and quantiles computed within all dims, but correction along the first one only. + sim = ds.sim + # Get the percentile rank of each value in sim. + rnk = rank(sim, dim=dim, pct=True) + + # Frequency-adapted sim + sim_ad = sim.where( + dP0 < 0, # dP0 < 0 means no-adaptation. + sim.where( + (rnk < P0_ref) | (rnk > P0_sim), # Preserve current values + # Generate random numbers ~ U[T0, Pth] + (pth.broadcast_like(sim) - thresh) + * np.random.random_sample(size=sim.shape) + + thresh, + ), + ) + + # Tell group_apply that these will need reshaping (regrouping) + # This is needed since if any variable comes out a `groupby` with the original group axis, + # the whole output is broadcasted back to the original dims. + pth.attrs["_group_apply_reshape"] = True + dP0.attrs["_group_apply_reshape"] = True + return xr.Dataset(data_vars={"pth": pth, "dP0": dP0, "sim_ad": sim_ad}) + + +@map_groups( + reduces=[Grouper.DIM, Grouper.PROP], data=[Grouper.DIM], norm=[Grouper.PROP] +) +def _normalize( + ds: xr.Dataset, + *, + dim: Sequence[str], + kind: str = ADDITIVE, +) -> xr.Dataset: + """Normalize an array by removing its mean. + + Parameters + ---------- + ds : xr.Dataset + The variable `data` is normalized. + If a `norm` variable is present, is uses this one instead of computing the norm again. + group : Union[str, Grouper] + Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + dim : sequence of strings + Dimension name(s). + kind : {'+', '*'} + How to apply the adjustment, using either additive or multiplicative methods. + + Returns + ------- + xr.Dataset + Group-wise anomaly of x + + Notes + ----- + Normalization is performed group-wise. + """ + if "norm" in ds: + norm = ds.norm + else: + norm = ds.data.mean(dim=dim) + norm.attrs["_group_apply_reshape"] = True + + return xr.Dataset( + dict(data=apply_correction(ds.data, invert(norm, kind), kind), norm=norm) + ) + + +@map_groups(reordered=[Grouper.DIM], main_only=False) +def _reordering(ds: xr.Dataset, *, dim: str) -> xr.Dataset: + """Group-wise reordering. + + Parameters + ---------- + ds : xr.Dataset + With variables: + - sim : The timeseries to reorder. + - ref : The timeseries whose rank to use. + dim : str + The dimension along which to reorder. + + Returns + ------- + xr.Dataset + The reordered timeseries. + """ + + def _reordering_1d(data, ordr): + return np.sort(data)[np.argsort(np.argsort(ordr))] + + def _reordering_2d(data, ordr): + data_r = data.ravel() + ordr_r = ordr.ravel() + reorder = np.sort(data_r)[np.argsort(np.argsort(ordr_r))] + return reorder.reshape(data.shape)[ + :, int(data.shape[1] / 2) + ] # pick the middle of the window + + if {"window", "time"} == set(dim): + return ( + xr.apply_ufunc( + _reordering_2d, + ds.sim, + ds.ref, + input_core_dims=[["time", "window"], ["time", "window"]], + output_core_dims=[["time"]], + vectorize=True, + dask="parallelized", + output_dtypes=[ds.sim.dtype], + ) + .rename("reordered") + .to_dataset() + ) + elif len(dim) == 1: + return ( + xr.apply_ufunc( + _reordering_1d, + ds.sim, + ds.ref, + input_core_dims=[dim, dim], + output_core_dims=[dim], + vectorize=True, + dask="parallelized", + output_dtypes=[ds.sim.dtype], + ) + .rename("reordered") + .to_dataset() + ) + else: + raise ValueError( + f"Reordering can only be done along one dimension." + f" If there is more than one, they should be `window` and `time`." + f" The dimensions are {dim}." + ) diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 45c97a7..682efdb 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -8,7 +8,11 @@ import datetime as pydt from collections.abc import Sequence from inspect import _empty, signature -from typing import Any, Callable +from typing import Any, Callable, NewType, TypeVar +from pint import Quantity + + +import itertools import cftime import dask.array as dsk @@ -16,10 +20,21 @@ import numpy as np import xarray as xr from boltons.funcutils import wraps +import pandas as pd from xsdba.options import OPTIONS, SDBA_ENCODE_CF +# XC: +#: Type annotation for strings representing full dates (YYYY-MM-DD), may include time. +DateStr = NewType("DateStr", str) + +#: Type annotation for strings representing dates without a year (MM-DD). +DayOfYearStr = NewType("DayOfYearStr", str) + +#: Type annotation for thresholds and other not-exactly-a-variable quantities +Quantified = TypeVar("Quantified", xr.DataArray, str, Quantity) + # ## Base class for the sdba module class Parametrizable(dict): """Helper base class resembling a dictionary. @@ -102,6 +117,17 @@ def set_dataset(self, ds: xr.Dataset) -> None: self.ds.attrs[self._attribute] = jsonpickle.encode(self) +# XC + +def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): + """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" + ds.attrs.update(ref.attrs) + extras = ds.variables if isinstance(ds, xr.Dataset) else ds.coords + others = ref.variables if isinstance(ref, xr.Dataset) else ref.coords + for name, var in extras.items(): + if name in others: + var.attrs.update(ref[name].attrs) + # XC put here to avoid circular import def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: r"""Evaluate whether dask is installed and array is loaded as a dask array. @@ -127,6 +153,60 @@ def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: return True return False +# XC +# Maximum day of year in each calendar. +max_doy = { + "standard": 366, + "gregorian": 366, + "proleptic_gregorian": 366, + "julian": 366, + "noleap": 365, + "365_day": 365, + "all_leap": 366, + "366_day": 366, + "360_day": 360, +} + +# XC +def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: + """Parse an offset string. + + Parse a frequency offset and, if needed, convert to cftime-compatible components. + + Parameters + ---------- + freq : str + Frequency offset. + + Returns + ------- + multiplier : int + Multiplier of the base frequency. "[n]W" is always replaced with "[7n]D", + as xarray doesn't support "W" for cftime indexes. + offset_base : str + Base frequency. + is_start_anchored : bool + Whether coordinates of this frequency should correspond to the beginning of the period (`True`) + or its end (`False`). Can only be False when base is Y, Q or M; in other words, xclim assumes frequencies finer + than monthly are all start-anchored. + anchor : str, optional + Anchor date for bases Y or Q. As xarray doesn't support "W", + neither does xclim (anchor information is lost when given). + + """ + # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) + offset = pd.tseries.frequencies.to_offset(freq) + base, *anchor = offset.name.split("-") + anchor = anchor[0] if len(anchor) > 0 else None + start = ("S" in base) or (base[0] not in "AYQM") + if base.endswith("S") or base.endswith("E"): + base = base[:-1] + mult = offset.n + if base == "W": + mult = 7 * mult + base = "D" + anchor = None + return mult, base, start, anchor # XC put here to avoid circular import def get_calendar(obj: Any, dim: str = "time") -> str: @@ -171,6 +251,50 @@ def get_calendar(obj: Any, dim: str = "time") -> str: raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") +# XC +def gen_call_string(funcname: str, *args, **kwargs) -> str: + r"""Generate a signature string for use in the history attribute. + + DataArrays and Dataset are replaced with their name, while Nones, floats, ints and strings are printed directly. + All other objects have their type printed between < >. + + Arguments given through positional arguments are printed positionnally and those + given through keywords are printed prefixed by their name. + + Parameters + ---------- + funcname : str + Name of the function + \*args, \*\*kwargs + Arguments given to the function. + + Example + ------- + >>> A = xr.DataArray([1], dims=("x",), name="A") + >>> gen_call_string("func", A, b=2.0, c="3", d=[10] * 100) + "func(A, b=2.0, c='3', d=)" + """ + elements = [] + chain = itertools.chain(zip([None] * len(args), args), kwargs.items()) + for name, val in chain: + if isinstance(val, xr.DataArray): + rep = val.name or "" + elif isinstance(val, (int, float, str, bool)) or val is None: + rep = repr(val) + else: + rep = repr(val) + if len(rep) > 50: + rep = f"<{type(val).__name__}>" + + if name is not None: + rep = f"{name}={rep}" + + elements.append(rep) + + return f"{funcname}({', '.join(elements)})" + + + class Grouper(Parametrizable): """Grouper inherited class for parameterizable classes.""" diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py new file mode 100644 index 0000000..2df3446 --- /dev/null +++ b/src/xsdba/formatting.py @@ -0,0 +1,202 @@ +""" +Formatting Utilities +=================================== +""" +from __future__ import annotations + +import datetime as dt +import xarray as xr +from boltons.funcutils import wraps +from inspect import signature +import itertools + +# XC +def merge_attributes( + attribute: str, + *inputs_list: xr.DataArray | xr.Dataset, + new_line: str = "\n", + missing_str: str | None = None, + **inputs_kws: xr.DataArray | xr.Dataset, +) -> str: + r"""Merge attributes from several DataArrays or Datasets. + + If more than one input is given, its name (if available) is prepended as: " : ". + + Parameters + ---------- + attribute : str + The attribute to merge. + inputs_list : xr.DataArray or xr.Dataset + The datasets or variables that were used to produce the new object. + Inputs given that way will be prefixed by their `name` attribute if available. + new_line : str + The character to put between each instance of the attributes. Usually, in CF-conventions, + the history attributes uses '\\n' while cell_methods uses ' '. + missing_str : str + A string that is printed if an input doesn't have the attribute. Defaults to None, in which + case the input is simply skipped. + \*\*inputs_kws : xr.DataArray or xr.Dataset + Mapping from names to the datasets or variables that were used to produce the new object. + Inputs given that way will be prefixes by the passed name. + + Returns + ------- + str + The new attribute made from the combination of the ones from all the inputs. + """ + inputs = [] + for in_ds in inputs_list: + inputs.append((getattr(in_ds, "name", None), in_ds)) + inputs += list(inputs_kws.items()) + + merged_attr = "" + for in_name, in_ds in inputs: + if attribute in in_ds.attrs or missing_str is not None: + if in_name is not None and len(inputs) > 1: + merged_attr += f"{in_name}: " + merged_attr += in_ds.attrs.get( + attribute, "" if in_name is None else missing_str + ) + merged_attr += new_line + + if len(new_line) > 0: + return merged_attr[: -len(new_line)] # Remove the last added new_line + return merged_attr + +# XC +def update_history( + hist_str: str, + *inputs_list: xr.DataArray | xr.Dataset, + new_name: str | None = None, + **inputs_kws: xr.DataArray | xr.Dataset, +) -> str: + r"""Return a history string with the timestamped message and the combination of the history of all inputs. + + The new history entry is formatted as "[] : - xclim version: ." + + Parameters + ---------- + hist_str : str + The string describing what has been done on the data. + \*inputs_list : xr.DataArray or xr.Dataset + The datasets or variables that were used to produce the new object. + Inputs given that way will be prefixed by their "name" attribute if available. + new_name : str, optional + The name of the newly created variable or dataset to prefix hist_msg. + \*\*inputs_kws : xr.DataArray or xr.Dataset + Mapping from names to the datasets or variables that were used to produce the new object. + Inputs given that way will be prefixes by the passed name. + + Returns + ------- + str + The combine history of all inputs starting with `hist_str`. + + See Also + -------- + merge_attributes + """ + from xsdba import ( # pylint: disable=cyclic-import,import-outside-toplevel + __version__, + ) + + merged_history = merge_attributes( + "history", + *inputs_list, + new_line="\n", + missing_str="", + **inputs_kws, + ) + if len(merged_history) > 0 and not merged_history.endswith("\n"): + merged_history += "\n" + merged_history += ( + f"[{dt.datetime.now():%Y-%m-%d %H:%M:%S}] {new_name or ''}: " + f"{hist_str} - xsdba version: {__version__}" + ) + return merged_history + +# XC +def update_xsdba_history(func: Callable): + """Decorator that auto-generates and fills the history attribute. + + The history is generated from the signature of the function and added to the first output. + Because of a limitation of the `boltons` wrapper, all arguments passed to the wrapped function + will be printed as keyword arguments. + """ + + @wraps(func) + def _call_and_add_history(*args, **kwargs): + """Call the function and then generate and add the history attr.""" + outs = func(*args, **kwargs) + + if isinstance(outs, tuple): + out = outs[0] + else: + out = outs + + if not isinstance(out, (xr.DataArray, xr.Dataset)): + raise TypeError( + f"Decorated `update_xclim_history` received a non-xarray output from {func.__name__}." + ) + + da_list = [arg for arg in args if isinstance(arg, xr.DataArray)] + da_dict = { + name: arg for name, arg in kwargs.items() if isinstance(arg, xr.DataArray) + } + + # The wrapper hides how the user passed the arguments (positional or keyword) + # Instead of having it all position, we have it all keyword-like for explicitness. + bound_args = signature(func).bind(*args, **kwargs) + attr = update_history( + gen_call_string(func.__name__, **bound_args.arguments), + *da_list, + new_name=out.name if isinstance(out, xr.DataArray) else None, + **da_dict, + ) + out.attrs["history"] = attr + return outs + + return _call_and_add_history + + +# XC +def gen_call_string(funcname: str, *args, **kwargs) -> str: + r"""Generate a signature string for use in the history attribute. + + DataArrays and Dataset are replaced with their name, while Nones, floats, ints and strings are printed directly. + All other objects have their type printed between < >. + + Arguments given through positional arguments are printed positionnally and those + given through keywords are printed prefixed by their name. + + Parameters + ---------- + funcname : str + Name of the function + \*args, \*\*kwargs + Arguments given to the function. + + Example + ------- + >>> A = xr.DataArray([1], dims=("x",), name="A") + >>> gen_call_string("func", A, b=2.0, c="3", d=[10] * 100) + "func(A, b=2.0, c='3', d=)" + """ + elements = [] + chain = itertools.chain(zip([None] * len(args), args), kwargs.items()) + for name, val in chain: + if isinstance(val, xr.DataArray): + rep = val.name or "" + elif isinstance(val, (int, float, str, bool)) or val is None: + rep = repr(val) + else: + rep = repr(val) + if len(rep) > 50: + rep = f"<{type(val).__name__}>" + + if name is not None: + rep = f"{name}={rep}" + + elements.append(rep) + + return f"{funcname}({', '.join(elements)})" \ No newline at end of file diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py new file mode 100644 index 0000000..0ab5eaf --- /dev/null +++ b/src/xsdba/processing.py @@ -0,0 +1,883 @@ +# pylint: disable=missing-kwoa +""" +Pre- and Post-Processing Submodule +================================== +""" +from __future__ import annotations + +import types +from collections.abc import Sequence +from typing import cast + +import dask.array as dsk +import numpy as np +import xarray as xr +from xarray.core.utils import get_temp_dimname +from xsdba.base import get_calendar, max_doy, parse_offset, uses_dask +from xsdba.formatting import update_xsdba_history +# from xclim.core.units import convert_units_to, infer_context, units + +from ._processing import _adapt_freq, _normalize, _reordering +from .base import Grouper +from .nbutils import _escore +from .utils import ADDITIVE, copy_all_attrs +from .units import check_units, harmonize_units, convert_units_to + + +__all__ = [ + "adapt_freq", + "escore", + "from_additive_space", + "grouped_time_indexes", + "jitter", + "jitter_over_thresh", + "jitter_under_thresh", + "normalize", + "reordering", + "stack_variables", + "standardize", + "to_additive_space", + "unstack_variables", + "unstandardize", +] + + +@update_xsdba_history +@harmonize_units(["ref", "sim", "thresh"]) +def adapt_freq( + ref: xr.DataArray, + sim: xr.DataArray, + *, + group: Grouper | str, + thresh: str = "0 mm d-1", +) -> tuple[xr.DataArray, xr.DataArray, xr.DataArray]: + r""" + Adapt frequency of values under thresh of `sim`, in order to match ref. + + This is useful when the dry-day frequency in the simulations is higher than in the references. This function + will create new non-null values for `sim`/`hist`, so that adjustment factors are less wet-biased. + Based on :cite:t:`sdba-themesl_empirical-statistical_2012`. + + Parameters + ---------- + ref : xr.Dataset + Target/reference data, usually observed data, with a "time" dimension. + sim : xr.Dataset + Simulated data, with a "time" dimension. + group : str or Grouper + Grouping information, see base.Grouper + thresh : str + Threshold below which values are considered zero, a quantity with units. + + Returns + ------- + sim_adj : xr.DataArray + Simulated data with the same frequency of values under threshold than ref. + Adjustment is made group-wise. + pth : xr.DataArray + For each group, the smallest value of sim that was not frequency-adjusted. + All values smaller were either left as zero values or given a random value between thresh and pth. + NaN where frequency adaptation wasn't needed. + dP0 : xr.DataArray + For each group, the percentage of values that were corrected in sim. + + Notes + ----- + With :math:`P_0^r` the frequency of values under threshold :math:`T_0` in the reference (ref) and + :math:`P_0^s` the same for the simulated values, :math:`\\Delta P_0 = \\frac{P_0^s - P_0^r}{P_0^s}`, + when positive, represents the proportion of values under :math:`T_0` that need to be corrected. + + The correction replaces a proportion :math:`\\Delta P_0` of the values under :math:`T_0` in sim by a uniform random + number between :math:`T_0` and :math:`P_{th}`, where :math:`P_{th} = F_{ref}^{-1}( F_{sim}( T_0 ) )` and + `F(x)` is the empirical cumulative distribution function (CDF). + + References + ---------- + :cite:cts:`sdba-themesl_empirical-statistical_2012` + + """ + out = _adapt_freq(xr.Dataset(dict(sim=sim, ref=ref)), group=group, thresh=thresh) + + # Set some metadata + copy_all_attrs(out, sim) + out.sim_ad.attrs.update(sim.attrs) + out.sim_ad.attrs.update( + references="Themeßl et al. (2012), Empirical-statistical downscaling and error correction of regional climate " + "models and its impact on the climate change signal, Climatic Change, DOI 10.1007/s10584-011-0224-4." + ) + out.pth.attrs.update( + long_name="Smallest value of the timeseries not corrected by frequency adaptation.", + units=sim.units, + ) + out.dP0.attrs.update( + long_name=f"Proportion of values smaller than {thresh} in the timeseries corrected by frequency adaptation", + ) + + return out.sim_ad, out.pth, out.dP0 + + +def jitter_under_thresh(x: xr.DataArray, thresh: str) -> xr.DataArray: + """Replace values smaller than threshold by a uniform random noise. + + Warnings + -------- + Not to be confused with R's jitter, which adds uniform noise instead of replacing values. + + Parameters + ---------- + x : xr.DataArray + Values. + thresh : str + Threshold under which to add uniform random noise to values, a quantity with units. + + Returns + ------- + xr.DataArray + + Notes + ----- + If thresh is high, this will change the mean value of x. + """ + j: xr.DataArray = jitter(x, lower=thresh, upper=None, minimum=None, maximum=None) + return j + + +def jitter_over_thresh(x: xr.DataArray, thresh: str, upper_bnd: str) -> xr.DataArray: + """Replace values greater than threshold by a uniform random noise. + + Warnings + -------- + Not to be confused with R's jitter, which adds uniform noise instead of replacing values. + + Parameters + ---------- + x : xr.DataArray + Values. + thresh : str + Threshold over which to add uniform random noise to values, a quantity with units. + upper_bnd : str + Maximum possible value for the random noise, a quantity with units. + + Returns + ------- + xr.DataArray + + Notes + ----- + If thresh is low, this will change the mean value of x. + + """ + j: xr.DataArray = jitter( + x, lower=None, upper=thresh, minimum=None, maximum=upper_bnd + ) + return j + + +@update_xsdba_history +@harmonize_units(["x", "lower", "upper", "minimum", "maximum"]) +def jitter( + x: xr.DataArray, + lower: str | None = None, + upper: str | None = None, + minimum: str | None = None, + maximum: str | None = None, +) -> xr.DataArray: + """Replace values under a threshold and values above another by a uniform random noise. + + Warnings + -------- + Not to be confused with R's `jitter`, which adds uniform noise instead of replacing values. + + Parameters + ---------- + x : xr.DataArray + Values. + lower : str, optional + Threshold under which to add uniform random noise to values, a quantity with units. + If None, no jittering is performed on the lower end. + upper : str, optional + Threshold over which to add uniform random noise to values, a quantity with units. + If None, no jittering is performed on the upper end. + minimum : str, optional + Lower limit (excluded) for the lower end random noise, a quantity with units. + If None but `lower` is not None, 0 is used. + maximum : str, optional + Upper limit (excluded) for the upper end random noise, a quantity with units. + If `upper` is not None, it must be given. + + Returns + ------- + xr.DataArray + Same as `x` but values < lower are replaced by a uniform noise in range (minimum, lower) + and values >= upper are replaced by a uniform noise in range [upper, maximum). + The two noise distributions are independent. + """ + # with units.context(infer_context(x.attrs.get("standard_name"))): + out: xr.DataArray = x + notnull = x.notnull() + if lower is not None: + jitter_lower = np.array(lower).astype(float) + jitter_min = np.array(minimum if minimum is not None else 0).astype(float) + jitter_min = jitter_min + np.finfo(x.dtype).eps + if uses_dask(x): + jitter_dist = dsk.random.uniform( + low=jitter_min, high=jitter_lower, size=x.shape, chunks=x.chunks + ) + else: + jitter_dist = np.random.uniform( + low=jitter_min, high=jitter_lower, size=x.shape + ) + out = out.where( + ~((x < jitter_lower) & notnull), jitter_dist.astype(x.dtype) + ) + if upper is not None: + if maximum is None: + raise ValueError("If 'upper' is given, so must 'maximum'.") + jitter_upper = np.array(upper).astype(float) + jitter_max = np.array(maximum).astype(float) + if uses_dask(x): + jitter_dist = dsk.random.uniform( + low=jitter_upper, high=jitter_max, size=x.shape, chunks=x.chunks + ) + else: + jitter_dist = np.random.uniform( + low=jitter_upper, high=jitter_max, size=x.shape + ) + out = out.where( + ~((x >= jitter_upper) & notnull), jitter_dist.astype(x.dtype) + ) + + copy_all_attrs(out, x) # copy attrs and same units + return out + + +@update_xsdba_history +@harmonize_units(["data","norm"]) +def normalize( + data: xr.DataArray, + norm: xr.DataArray | None = None, + *, + group: Grouper | str, + kind: str = ADDITIVE, +) -> tuple[xr.DataArray, xr.DataArray]: + """Normalize an array by removing its mean. + + Normalization if performed group-wise and according to `kind`. + + Parameters + ---------- + data : xr.DataArray + The variable to normalize. + norm : xr.DataArray, optional + If present, it is used instead of computing the norm again. + group : str or Grouper + Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details.. + kind : {'+', '*'} + If `kind` is "+", the mean is subtracted from the mean and if it is '*', it is divided from the data. + + Returns + ------- + xr.DataArray + Groupwise anomaly. + norm : xr.DataArray + Mean over each group. + """ + ds = xr.Dataset(dict(data=data)) + + if norm is not None: + ds = ds.assign(norm=norm) + + out = _normalize(ds, group=group, kind=kind) + copy_all_attrs(out, ds) + out.data.attrs.update(data.attrs) + out.norm.attrs["units"] = data.attrs["units"] + return out.data.rename(data.name), out.norm + + +def uniform_noise_like( + da: xr.DataArray, low: float = 1e-6, high: float = 1e-3 +) -> xr.DataArray: + """Return a uniform noise array of the same shape as da. + + Noise is uniformly distributed between low and high. + Alternative method to `jitter_under_thresh` for avoiding zeroes. + """ + mod: types.ModuleType + kw: dict + if uses_dask(da): + mod = dsk + kw = {"chunks": da.chunks} + else: + mod = np + kw = {} + + return da.copy( + data=(high - low) * mod.random.random_sample(size=da.shape, **kw) + low + ) + + +@update_xsdba_history +def standardize( + da: xr.DataArray, + mean: xr.DataArray | None = None, + std: xr.DataArray | None = None, + dim: str = "time", +) -> tuple[xr.DataArray | xr.Dataset, xr.DataArray, xr.DataArray]: + """Standardize a DataArray by centering its mean and scaling it by its standard deviation. + + Either of both of mean and std can be provided if need be. + + Returns + ------- + out : xr.DataArray or xr.Dataset + Standardized data. + mean : xr.DataArray + Mean. + std : xr.DataArray + Standard Deviation. + """ + if mean is None: + mean = da.mean(dim, keep_attrs=True) + if std is None: + std = da.std(dim, keep_attrs=True) + out = (da - mean) / std + copy_all_attrs(out, da) + return out, mean, std + + +@update_xsdba_history +def unstandardize(da: xr.DataArray, mean: xr.DataArray, std: xr.DataArray): + """Rescale a standardized array by performing the inverse operation of `standardize`.""" + out = (std * da) + mean + copy_all_attrs(out, da) + return out + + +@update_xsdba_history +def reordering(ref: xr.DataArray, sim: xr.DataArray, group: str = "time") -> xr.Dataset: + """Reorders data in `sim` following the order of ref. + + The rank structure of `ref` is used to reorder the elements of `sim` along dimension "time", optionally doing the + operation group-wise. + + Parameters + ---------- + sim : xr.DataArray + Array to reorder. + ref : xr.DataArray + Array whose rank order sim should replicate. + group : str + Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + + Returns + ------- + xr.Dataset + sim reordered according to ref's rank order. + + References + ---------- + :cite:cts:`sdba-cannon_multivariate_2018` + + """ + ds = xr.Dataset({"sim": sim, "ref": ref}) + out: xr.Dataset = _reordering(ds, group=group).reordered + copy_all_attrs(out, sim) + return out + + +@update_xsdba_history +def escore( + tgt: xr.DataArray, + sim: xr.DataArray, + dims: Sequence[str] = ("variables", "time"), + N: int = 0, # noqa + scale: bool = False, +) -> xr.DataArray: + r"""Energy score, or energy dissimilarity metric, based on :cite:t:`sdba-szekely_testing_2004` and :cite:t:`sdba-cannon_multivariate_2018`. + + Parameters + ---------- + tgt: xr.DataArray + Target observations. + sim: xr.DataArray + Candidate observations. Must have the same dimensions as `tgt`. + dims: sequence of 2 strings + The name of the dimensions along which the variables and observation points are listed. + `tgt` and `sim` can have different length along the second one, but must be equal along the first one. + The result will keep all other dimensions. + N : int + If larger than 0, the number of observations to use in the score computation. The points are taken + evenly distributed along `obs_dim`. + scale : bool + Whether to scale the data before computing the score. If True, both arrays as scaled according + to the mean and standard deviation of `tgt` along `obs_dim`. (std computed with `ddof=1` and both + statistics excluding NaN values). + + Returns + ------- + xr.DataArray + e-score with dimensions not in `dims`. + + Notes + ----- + Explanation adapted from the "energy" R package documentation. + The e-distance between two clusters :math:`C_i`, :math:`C_j` (tgt and sim) of size :math:`n_i,n_j` + proposed by :cite:t:`sdba-szekely_testing_2004` is defined by: + + .. math:: + + e(C_i,C_j) = \frac{1}{2}\frac{n_i n_j}{n_i + n_j} \left[2 M_{ij} − M_{ii} − M_{jj}\right] + + where + + .. math:: + + M_{ij} = \frac{1}{n_i n_j} \sum_{p = 1}^{n_i} \sum_{q = 1}^{n_j} \left\Vert X_{ip} − X{jq} \right\Vert. + + :math:`\Vert\cdot\Vert` denotes Euclidean norm, :math:`X_{ip}` denotes the p-th observation in the i-th cluster. + + The input scaling and the factor :math:`\frac{1}{2}` in the first equation are additions of + :cite:t:`sdba-cannon_multivariate_2018` to the metric. With that factor, the test becomes identical to the one + defined by :cite:t:`sdba-baringhaus_new_2004`. + This version is tested against values taken from Alex Cannon's MBC R package :cite:p:`sdba-cannon_mbc_2020`. + + References + ---------- + :cite:cts:`sdba-baringhaus_new_2004,sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-szekely_testing_2004` + + """ + pts_dim, obs_dim = dims + + if N > 0: + # If N non-zero we only take around N points, evenly distributed + sim_step = int(np.ceil(sim[obs_dim].size / N)) + sim = sim.isel({obs_dim: slice(None, None, sim_step)}) + tgt_step = int(np.ceil(tgt[obs_dim].size / N)) + tgt = tgt.isel({obs_dim: slice(None, None, tgt_step)}) + + if scale: + tgt, avg, std = standardize(tgt) + sim, _, _ = standardize(sim, avg, std) + + # The dimension renaming is to allow different coordinates. + # Otherwise, apply_ufunc tries to align both obs_dim together. + new_dim = get_temp_dimname(tgt.dims, obs_dim) + sim = sim.rename({obs_dim: new_dim}) + out: xr.DataArray = xr.apply_ufunc( + _escore, + tgt, + sim, + input_core_dims=[[pts_dim, obs_dim], [pts_dim, new_dim]], + output_dtypes=[sim.dtype], + dask="parallelized", + ) + + out.name = "escores" + out = out.assign_attrs( + dict( + long_name="Energy dissimilarity metric", + description=f"Escores computed from {N or 'all'} points.", + references="Székely, G. J. and Rizzo, M. L. (2004) Testing for Equal Distributions in High Dimension, InterStat, November (5)", + ) + ) + return out + + +def _get_number_of_elements_by_year(time): + """Get the number of elements in time in a year by inferring its sampling frequency. + + Only calendar with uniform year lengths are supported : 360_day, noleap, all_leap. + """ + cal = get_calendar(time) + + # Calendar check + if cal in ["standard", "gregorian", "default", "proleptic_gregorian"]: + raise ValueError( + "For moving window computations, the data must have a uniform calendar (360_day, no_leap or all_leap)" + ) + + mult, freq, _, _ = parse_offset(xr.infer_freq(time)) + days_in_year = max_doy[cal] + elements_in_year = {"Q": 4, "M": 12, "D": days_in_year, "h": days_in_year * 24} + N_in_year = elements_in_year.get(freq, 1) / mult + if N_in_year % 1 != 0: + raise ValueError( + f"Sampling frequency of the data must be Q, M, D or h and evenly divide a year (got {mult}{freq})." + ) + + return int(N_in_year) + + +@update_xsdba_history +@harmonize_units(["data", "lower_bound", "upper_bound"]) +def to_additive_space( + data: xr.DataArray, + lower_bound: str, + upper_bound: str | None = None, + trans: str = "log", +): + r"""Transform a non-additive variable into an additive space by the means of a log or logit transformation. + + Based on :cite:t:`sdba-alavoine_distinct_2022`. + + Parameters + ---------- + data : xr.DataArray + A variable that can't usually be bias-adjusted by additive methods. + lower_bound : str + The smallest physical value of the variable, excluded, as a Quantity string. + The data should only have values strictly larger than this bound. + upper_bound : str, optional + The largest physical value of the variable, excluded, as a Quantity string. + Only relevant for the logit transformation. + The data should only have values strictly smaller than this bound. + trans : {'log', 'logit'} + The transformation to use. See notes. + + Notes + ----- + Given a variable that is not usable in an additive adjustment, this applies a transformation to a space where + additive methods are sensible. Given :math:`X` the variable, :math:`b_-` the lower physical bound of that variable + and :math:`b_+` the upper physical bound, two transformations are currently implemented to get :math:`Y`, + the additive-ready variable. :math:`\ln` is the natural logarithm. + + - `log` + + .. math:: + + Y = \ln\left( X - b_- \right) + + Usually used for variables with only a lower bound, like precipitation (`pr`, `prsn`, etc) + and daily temperature range (`dtr`). Both have a lower bound of 0. + + - `logit` + + .. math:: + + X' = (X - b_-) / (b_+ - b_-) + Y = \ln\left(\frac{X'}{1 - X'} \right) + + Usually used for variables with both a lower and a upper bound, like relative and specific humidity, + cloud cover fraction, etc. + + This will thus produce `Infinity` and `NaN` values where :math:`X == b_-` or :math:`X == b_+`. + We recommend using :py:func:`jitter_under_thresh` and :py:func:`jitter_over_thresh` to remove those issues. + + See Also + -------- + from_additive_space : for the inverse transformation. + jitter_under_thresh : Remove values exactly equal to the lower bound. + jitter_over_thresh : Remove values exactly equal to the upper bound. + + References + ---------- + :cite:cts:`sdba-alavoine_distinct_2022` + + """ + # with units.context(infer_context(data.attrs.get("standard_name"))): + lower_bound_array = np.array(lower_bound).astype(float) + if upper_bound is not None: + upper_bound_array = np.array(upper_bound).astype( + float + ) + + with xr.set_options(keep_attrs=True), np.errstate(divide="ignore"): + if trans == "log": + out = cast(xr.DataArray, np.log(data - lower_bound_array)) + elif trans == "logit" and upper_bound is not None: + data_prime = (data - lower_bound_array) / ( + upper_bound_array - lower_bound_array # pylint: disable=E0606 + ) + out = cast(xr.DataArray, np.log(data_prime / (1 - data_prime))) + else: + raise NotImplementedError("`trans` must be one of 'log' or 'logit'.") + + # Attributes to remember all this. + out = out.assign_attrs(sdba_transform=trans) + out = out.assign_attrs(sdba_transform_lower=lower_bound_array) + if upper_bound is not None: + out = out.assign_attrs(sdba_transform_upper=upper_bound_array) + if "units" in out.attrs: + out = out.assign_attrs(sdba_transform_units=out.attrs.pop("units")) + out = out.assign_attrs(units="") + return out + + +@update_xsdba_history +@harmonize_units(["units", "lower_bound", "upper_bound"]) +def from_additive_space( + data: xr.DataArray, + lower_bound: str | None = None, + upper_bound: str | None = None, + trans: str | None = None, + units: str | None = None, +): + r"""Transform back to the physical space a variable that was transformed with `to_additive_space`. + + Based on :cite:t:`sdba-alavoine_distinct_2022`. + If parameters are not present on the attributes of the data, they must be all given are arguments. + + Parameters + ---------- + data : xr.DataArray + A variable that was transformed by :py:func:`to_additive_space`. + lower_bound : str, optional + The smallest physical value of the variable, as a Quantity string. + The final data will have no value smaller or equal to this bound. + If None (default), the `sdba_transform_lower` attribute is looked up on `data`. + upper_bound : str, optional + The largest physical value of the variable, as a Quantity string. + Only relevant for the logit transformation. + The final data will have no value larger or equal to this bound. + If None (default), the `sdba_transform_upper` attribute is looked up on `data`. + trans : {'log', 'logit'}, optional + The transformation to use. See notes. + If None (the default), the `sdba_transform` attribute is looked up on `data`. + units : str, optional + The units of the data before transformation to the additive space. + If None (the default), the `sdba_transform_units` attribute is looked up on `data`. + + Returns + ------- + xr.DataArray + The physical variable. Attributes are conserved, even if some might be incorrect. + Except units which are taken from `sdba_transform_units` if available. + All `sdba_transform*` attributes are deleted. + + Notes + ----- + Given a variable that is not usable in an additive adjustment, :py:func:`to_additive_space` applied a transformation + to a space where additive methods are sensible. Given :math:`Y` the transformed variable, :math:`b_-` the + lower physical bound of that variable and :math:`b_+` the upper physical bound, two back-transformations are + currently implemented to get :math:`X`, the physical variable. + + - `log` + + .. math:: + + X = e^{Y} + b_- + + - `logit` + + .. math:: + + X' = \frac{1}{1 + e^{-Y}} + X = X * (b_+ - b_-) + b_- + + See Also + -------- + to_additive_space : for the original transformation. + + References + ---------- + :cite:cts:`sdba-alavoine_distinct_2022` + + """ + if trans is None and lower_bound is None and units is None: + try: + trans = data.attrs["sdba_transform"] + units = data.attrs["sdba_transform_units"] + lower_bound_array = np.array(data.attrs["sdba_transform_lower"]).astype( + float + ) + if trans == "logit": + upper_bound_array = np.array(data.attrs["sdba_transform_upper"]).astype( + float + ) + except KeyError as err: + raise ValueError( + f"Attribute {err!s} must be present on the input data " + "or all parameters must be given as arguments." + ) from err + elif ( + trans is not None + and lower_bound is not None + and units is not None + and (upper_bound is not None or trans == "log") + ): + # FIXME: convert_units_to is causing issues since it can't handle all variations of Quantified here + lower_bound_array = np.array(lower_bound).astype(float) + if trans == "logit": + upper_bound_array = np.array(upper_bound).astype( + float + ) + else: + raise ValueError( + "Parameters missing. Either all parameters are given as attributes of data, " + "or all of them are given as input arguments." + ) + + with xr.set_options(keep_attrs=True): + if trans == "log": + out = np.exp(data) + lower_bound_array + elif trans == "logit": + out_prime = 1 / (1 + np.exp(-data)) + out = ( + out_prime + * (upper_bound_array - lower_bound_array) # pylint: disable=E0606 + + lower_bound_array + ) + else: + raise NotImplementedError("`trans` must be one of 'log' or 'logit'.") + + # Remove unneeded attributes, put correct units back. + out.attrs.pop("sdba_transform", None) + out.attrs.pop("sdba_transform_lower", None) + out.attrs.pop("sdba_transform_upper", None) + out.attrs.pop("sdba_transform_units", None) + out = out.assign_attrs(units=units) + return out + + +def stack_variables(ds: xr.Dataset, rechunk: bool = True, dim: str = "multivar"): + """Stack different variables of a dataset into a single DataArray with a new "variables" dimension. + + Variable attributes are all added as lists of attributes to the new coordinate, prefixed with "_". + Variables are concatenated in the new dimension in alphabetical order, to ensure + coherent behaviour with different datasets. + + Parameters + ---------- + ds : xr.Dataset + Input dataset. + rechunk : bool + If True (default), dask arrays are rechunked with `variables : -1`. + dim : str + Name of dimension along which variables are indexed. + + Returns + ------- + xr.DataArray + The transformed variable. Attributes are conserved, even if some might be incorrect, except for units, + which are replaced with `""`. Old units are stored in `sdba_transformation_units`. + A `sdba_transform` attribute is added, set to the transformation method. `sdba_transform_lower` and + `sdba_transform_upper` are also set if the requested bounds are different from the defaults. + + Array with variables stacked along `dim` dimension. Units are set to "". + + """ + # Store original arrays' attributes + attrs: dict = {} + # sort to have coherent order with different datasets + data_vars = sorted(ds.data_vars.items(), key=lambda e: e[0]) + nvar = len(data_vars) + for i, (nm, var) in enumerate(data_vars): + for name, attr in var.attrs.items(): + attrs.setdefault(f"_{name}", [None] * nvar)[i] = attr + + # Special key used for later `unstacking` + attrs["is_variables"] = True + var_crd = xr.DataArray([nm for nm, vr in data_vars], dims=(dim,), name=dim) + + da = xr.concat([vr for nm, vr in data_vars], var_crd, combine_attrs="drop") + + if uses_dask(da) and rechunk: + da = da.chunk({dim: -1}) + + da.attrs.update(ds.attrs) + da.attrs["units"] = "" + da[dim].attrs.update(attrs) + return da.rename("multivariate") + + +def unstack_variables(da: xr.DataArray, dim: str | None = None) -> xr.Dataset: + """Unstack a DataArray created by `stack_variables` to a dataset. + + Parameters + ---------- + da : xr.DataArray + Array holding different variables along `dim` dimension. + dim : str, optional + Name of dimension along which the variables are stacked. + If not specified (default), `dim` is inferred from attributes of the coordinate. + + Returns + ------- + xr.Dataset + Dataset holding each variable in an individual DataArray. + """ + if dim is None: + for _dim, _crd in da.coords.items(): + if _crd.attrs.get("is_variables"): + dim = str(_dim) + break + else: + raise ValueError("No variable coordinate found, were attributes removed?") + + ds = xr.Dataset( + {name.item(): da.sel({dim: name.item()}, drop=True) for name in da[dim]}, + attrs=da.attrs, + ) + del ds.attrs["units"] + + # Reset attributes + for name, attr_list in da[dim].attrs.items(): + if not name.startswith("_"): + continue + for attr, var in zip(attr_list, da[dim]): + if attr is not None: + ds[var.item()].attrs[name[1:]] = attr + + return ds + + +def grouped_time_indexes(times, group): + """Time indexes for every group blocks + + Time indexes can be used to implement a pseudo-"numpy.groupies" approach to grouping. + + Parameters + ---------- + times : xr.DataArray + Time dimension in the dataset of interest. + group : str or Grouper + Grouping information, see base.Grouper + + Returns + ------- + g_idxs : xr.DataArray + Time indexes of the blocks (only using `group.name` and not `group.window`). + gw_idxs : xr.DataArray + Time indexes of the blocks (built with a rolling window of `group.window` if any). + """ + + def _get_group_complement(da, group): + # complement of "dayofyear": "year", etc. + gr = group if isinstance(group, str) else group.name + if gr == "time.dayofyear": + return da.time.dt.year + if gr == "time.month": + return da.time.dt.strftime("%Y-%d") + + # does not work with group == "time.month" + group = group if isinstance(group, Grouper) else Grouper(group) + gr, win = group.name, group.window + # get time indices (0,1,2,...) for each block + timeind = xr.DataArray(np.arange(times.size), coords={"time": times}) + win_dim0, win_dim = ( + get_temp_dimname(timeind.dims, lab) for lab in ["win_dim0", "win_dim"] + ) + if gr == "time.dayofyear": + # time indices for each block with window = 1 + g_idxs = timeind.groupby(gr).apply( + lambda da: da.assign_coords(time=_get_group_complement(da, gr)).rename( + {"time": "year"} + ) + ) + # time indices for each block with general window + da = timeind.rolling(time=win, center=True).construct(window_dim=win_dim0) + gw_idxs = da.groupby(gr).apply( + lambda da: da.assign_coords(time=_get_group_complement(da, gr)).stack( + {win_dim: ["time", win_dim0]} + ) + ) + gw_idxs = gw_idxs.transpose(..., win_dim) + elif gr == "time": + gw_idxs = timeind.rename({"time": win_dim}).expand_dims({win_dim0: [-1]}) + g_idxs = gw_idxs.copy() + else: + raise NotImplementedError(f"Grouping {gr} not implemented.") + gw_idxs.attrs["group"] = (gr, win) + gw_idxs.attrs["time_dim"] = win_dim + gw_idxs.attrs["group_dim"] = [d for d in g_idxs.dims if d != win_dim][0] + return g_idxs, gw_idxs diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 8cf3faa..f8a4a55 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -51,8 +51,9 @@ SocketBlockedError = None -def test_timelonlatseries(values, name, start="2000-01-01"): +def test_timelonlatseries(values, attrs = None, start="2000-01-01"): """Create a DataArray with time, lon and lat dimensions.""" + attrs = {} if attrs is None else attrs coords = collections.OrderedDict() for dim, n in zip(("time", "lon", "lat"), values.shape): if dim == "time": @@ -60,28 +61,10 @@ def test_timelonlatseries(values, name, start="2000-01-01"): else: coords[dim] = xr.IndexVariable(dim, np.arange(n)) - if name == "tas": - attrs = { - "standard_name": "air_temperature", - "cell_methods": "time: mean within days", - "units": "K", - "kind": "+", - } - elif name == "pr": - attrs = { - "standard_name": "precipitation_flux", - "cell_methods": "time: sum over day", - "units": "kg m-2 s-1", - "kind": "*", - } - else: - raise ValueError(f"Name `{name}` not supported.") - return xr.DataArray( values, coords=coords, dims=list(coords.keys()), - name=name, attrs=attrs, ) diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 4e6090d..ca2fcd5 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -8,38 +8,153 @@ import pint import xarray as xr +import numpy as np +from copy import deepcopy +from .base import Quantified, copy_all_attrs + +# this dependency is "necessary" for convert_units_to +# if we only do checks, we could get rid of it +import cf_xarray.units +# shamelessly adapted from `cf-xarray` (which adopted it from MetPy and xclim itself) +units = deepcopy(cf_xarray.units.units) +# Switch this flag back to False. Not sure what that implies, but it breaks some tests. +units.force_ndarray_like = False # noqa: F841 +# Another alias not included by cf_xarray +units.define("@alias percent = pct") + +# XC +def units2pint(value: xr.DataArray | str | units.Quantity) -> pint.Unit: + """Return the pint Unit for the DataArray units. + + Parameters + ---------- + value : xr.DataArray or str or pint.Quantity + Input data array or string representing a unit (with no magnitude). + + Returns + ------- + pint.Unit + Units of the data array. + """ + if isinstance(value, str): + unit = value + elif isinstance(value, xr.DataArray): + unit = value.attrs["units"] + elif isinstance(value, units.Quantity): + # This is a pint.PlainUnit, which is not the same as a pint.Unit + return cast(pint.Unit, value.units) + else: + raise NotImplementedError(f"Value of type `{type(value)}` not supported.") + + # Catch user errors undetected by Pint + degree_ex = ["deg", "degree", "degrees"] + unit_ex = [ + "C", + "K", + "F", + "Celsius", + "Kelvin", + "Fahrenheit", + "celsius", + "kelvin", + "fahrenheit", + ] + possibilities = [f"{d} {u}" for d in degree_ex for u in unit_ex] + if unit.strip() in possibilities: + raise ValidationError( + "Remove white space from temperature units, e.g. use `degC`." + ) + + return units.parse_units(unit) + +# XC +def str2pint(val: str) -> pint.Quantity: + """Convert a string to a pint.Quantity, splitting the magnitude and the units. + + Parameters + ---------- + val : str + A quantity in the form "[{magnitude} ]{units}", where magnitude can be cast to a float and + units is understood by `units2pint`. + + Returns + ------- + pint.Quantity + Magnitude is 1 if no magnitude was present in the string. + """ + mstr, *ustr = val.split(" ", maxsplit=1) + try: + if ustr: + return units.Quantity(float(mstr), units=units2pint(ustr[0])) + return units.Quantity(float(mstr)) + except ValueError: + return units.Quantity(1, units2pint(val)) + +# XC +# def ensure_delta(unit: str) -> str: +# """Return delta units for temperature. + +# For dimensions where delta exist in pint (Temperature), it replaces the temperature unit by delta_degC or +# delta_degF based on the input unit. For other dimensionality, it just gives back the input units. + +# Parameters +# ---------- +# unit : str +# unit to transform in delta (or not) +# """ +# u = units2pint(unit) +# d = 1 * u +# # +# delta_unit = pint2cfunits(d - d) +# # replace kelvin/rankine by delta_degC/F +# if "kelvin" in u._units: +# delta_unit = pint2cfunits(u / units2pint("K") * units2pint("delta_degC")) +# if "degree_Rankine" in u._units: +# delta_unit = pint2cfunits(u / units2pint("°R") * units2pint("delta_degF")) +# return delta_unit def extract_units(arg): if not (isinstance(arg, (str, xr.DataArray)) or np.isscalar(arg)): - raise TypeError("Argument must be a str, DataArray, or scalar.") + print(arg) + raise TypeError(f"Argument must be a str, DataArray, or scalar. Got {type(arg)}") elif isinstance(arg, xr.DataArray): ustr = None if "units" not in arg.attrs else arg.attrs["units"] elif isinstance(arg, str): - # XC - _, ustr = arg.split(" ", maxsplit=1) + ustr = str2pint(arg).units else: # (scalar case) ustr = None return ustr if ustr is None else pint.Quantity(1, ustr).units + def check_units(args_to_check): + """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" # if no units are present (DataArray without units attribute or float), then no check is performed # if units are present, then check is performed # in mixed cases, an error is raised - def decorator(func): + def _decorator(func): @wraps(func) - def wrapper(*args, **kwargs): + def _wrapper(*args, **kwargs): # dictionnary {arg_name:arg} for all args of func arg_dict = dict(zip(inspect.getfullargspec(func).args, args)) # Obtain units (or None if no units) of all args units = [] for arg_name in args_to_check: - if arg_name not in arg_dict: + if isinstance(arg_name, str): + value = arg_dict[arg_name] + key = arg_name + if isinstance(arg_name, dict): # support for Dataset, or a dict of thresholds + key, val = list(arg_name.keys())[0], list(arg_name.values())[0] + value = arg_dict[key][val] + if value is None: # optional argument, should be ignored + args_to_check.remove(arg_name) + continue + if key not in arg_dict: raise ValueError( f"Argument '{arg_name}' not found in function arguments." ) - units.append(extract_units(arg_dict[arg_name])) + units.append(extract_units(value)) # Check that units are consistent if len(set(units)) > 1: raise ValueError( @@ -47,6 +162,177 @@ def wrapper(*args, **kwargs): ) return func(*args, **kwargs) - return wrapper + return _wrapper + + return _decorator + + +# XC simplified +def convert_units_to( # noqa: C901 + source: Quantified, + target: Quantified | units.Unit, +) -> xr.DataArray | float: + """Convert a mathematical expression into a value with the same units as a DataArray. + + If the dimensionalities of source and target units differ, automatic CF conversions + will be applied when possible. See :py:func:`xclim.core.units.cf_conversion`. + + Parameters + ---------- + source : str or xr.DataArray or units.Quantity + The value to be converted, e.g. '4C' or '1 mm/d'. + target : str or xr.DataArray or units.Quantity or units.Unit + Target array of values to which units must conform. + + Returns + ------- + xr.DataArray or float + The source value converted to target's units. + The outputted type is always similar to `source` initial type. + Attributes are preserved unless an automatic CF conversion is performed, + in which case only the new `standard_name` appears in the result. + + See Also + -------- + cf_conversion + amount2rate + rate2amount + amount2lwethickness + lwethickness2amount + """ + # Target units + target_unit = extract_units(target) + source_unit = extract_units(source) + if target_unit == source_unit: + return source if isinstance(source, str) is False else str2pint(source).m + else: # Convert units + if isinstance(source, xr.DataArray): + out = source.copy(data=units.convert(source.data, source_unit, target_unit)) + out = out.assign_attrs(units=target_unit) + else: + out = str2pint(source).to(target_unit) + return out + + +def _fill_args_dict(args, kwargs, args_to_check, func): + """ Combine args and kwargs into a dict.""" + args_dict = {} + signature = inspect.signature(func) + for ik, (k,v) in enumerate(signature.parameters.items()): + if ik < len(args): + value = args[ik] + if ik >= len(args): + value = v.default if k not in kwargs else kwargs[k] + args_dict[k] = value + return args_dict +def _split_args_kwargs(args, func): + """Assign Keyword only arguments to kwargs.""" + kwargs = {} + signature = inspect.signature(func) + indices_to_pop = [] + for ik, (k,v) in enumerate(signature.parameters.items()): + if v.kind == inspect.Parameter.KEYWORD_ONLY: + indices_to_pop.append(ik) + kwargs[k] = v + indices_to_pop.sort(reverse=True) + for ind in indices_to_pop: + args.pop(ind) + return args, kwargs + + +# TODO: make it work with Dataset for real +# TODO: add a switch to prevent string from being converted to float? +def harmonize_units(args_to_check): + """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" + # if no units are present (DataArray without units attribute or float), then no check is performed + # if units are present, then check is performed + # in mixed cases, an error is raised + def _decorator(func): + @wraps(func) + def _wrapper(*args, **kwargs): + arg_names = inspect.getfullargspec(func).args + args_dict = _fill_args_dict(list(args),kwargs, args_to_check, func) + first_arg_name = args_to_check[0] + first_arg = args_dict[first_arg_name] + for arg_name in args_to_check[1:]: + if isinstance(arg_name, str): + value = args_dict[arg_name] + key = arg_name + if isinstance(arg_name, dict): # support for Dataset, or a dict of thresholds + key, val = list(arg_name.keys())[0], list(arg_name.values())[0] + value = args_dict[key][val] + if value is None: # optional argument, should be ignored + args_to_check.remove(arg_name) + continue + if key not in args_dict: + raise ValueError( + f"Argument '{arg_name}' not found in function arguments." + ) + args_dict[key] = convert_units_to(value, first_arg) + args = list(args_dict.values()) + args, kwargs = _split_args_kwargs(args, kwargs, func) + return func(*args, **kwargs) + + return _wrapper + + return _decorator + + + +def _add_default_kws(params_dict, params_to_check, func): + """ Combine args and kwargs into a dict.""" + args_dict = {} + signature = inspect.signature(func) + for ik, (k,v) in enumerate(signature.parameters.items()): + if k not in params_dict and k in params_to_check: + if v.default != inspect._empty: + params_dict[k] = v.default + return params_dict + +def harmonize_units(params_to_check): + """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" + # if no units are present (DataArray without units attribute or float), then no check is performed + # if units are present, then check is performed + # in mixed cases, an error is raised + def _decorator(func): + @wraps(func) + def _wrapper(*args, **kwargs): + params_func = inspect.signature(func).parameters.keys() + if set(params_to_check).issubset(set(params_func)) is False: + raise ValueError( + f"`harmonize_units' inputs `{params_to_check}` should be a subset of " + f"`{func.__name__}`'s arguments: `{params_func}` (arguments that can contain units)" + ) + arg_names = inspect.getfullargspec(func).args + args_dict = dict(zip(arg_names, args)) + params_dict = args_dict | {k:v for k,v in kwargs.items()} + params_dict = {k:v for k,v in params_dict.items() if k in params_to_check} + params_dict = _add_default_kws(params_dict, params_to_check, func) + params_dict_keys = [k for k in params_dict.keys()] + if set(params_dict.keys()) != set(params_to_check): + raise ValueError ( + f"{params_to_check} were passed but only {params_dict.keys()} were found " + f"in `{func.__name__}`'s arguments" + ) + first_param = params_dict[params_to_check[0]] + for param_name in params_dict.keys(): + if isinstance(param_name, str): + value = params_dict[param_name] + key = param_name + if isinstance(param_name, dict): # support for Dataset, or a dict of thresholds + key, val = list(param_name.keys())[0], list(param_name.values())[0] + value = params_dict[key][val] + if value is None: # optional argument, should be ignored + continue + params_dict[key] = convert_units_to(value, first_param) + for k in [k for k in params_dict.keys() if k not in args_dict.keys()]: + kwargs[k] = params_dict[k] + params_dict.pop(k) + args = list(args) + for iarg in range(len(args)): + if arg_names[iarg] in params_dict.keys(): + args[iarg] = params_dict[arg_names[iarg]] + return func(*args, **kwargs) + return _wrapper - return decorator + return _decorator \ No newline at end of file diff --git a/tests/conftest.py b/tests/conftest.py index 3cca5df..fd5fb63 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -19,9 +19,8 @@ from filelock import FileLock from packaging.version import Version -from xsdba.testing import TESTDATA_BRANCH +from xsdba.testing import TESTDATA_BRANCH, test_timelonlatseries, test_timeseries from xsdba.testing import open_dataset as _open_dataset -from xsdba.testing import test_timelonlatseries, test_timeseries # import xclim # from xclim import __version__ as __xclim_version__ diff --git a/tests/test_processing.py b/tests/test_processing.py new file mode 100644 index 0000000..c3b9b54 --- /dev/null +++ b/tests/test_processing.py @@ -0,0 +1,305 @@ +from __future__ import annotations + +import numpy as np +import pandas as pd +import pytest +import xarray as xr + +from xsdba.units import units +# from xsdba.adjustment import EmpiricalQuantileMapping +from xsdba.base import Grouper +from xsdba.processing import ( + adapt_freq, + escore, + from_additive_space, + jitter, + jitter_over_thresh, + jitter_under_thresh, + normalize, + reordering, + stack_variables, + standardize, + to_additive_space, + unstack_variables, + unstandardize, +) + + +def test_jitter_both(): + da = xr.DataArray([0.5, 2.1, np.nan], attrs={"units": "K"}) + out = jitter(da, lower="1 K", upper="2 K", maximum="3 K") + + assert da[0] != out[0] + assert da[0] < 1 + assert da[0] > 0 + + assert da[1] != out[1] + assert da[1] < 3 + assert da[1] > 2 + + +def test_jitter_under_thresh(): + da = xr.DataArray([0.5, 2.1, np.nan], attrs={"units": "K"}) + out = jitter_under_thresh(da, "1 K") + + assert da[0] != out[0] + assert da[0] < 1 + assert da[0] > 0 + np.testing.assert_allclose(da[1:], out[1:]) + assert ( + "jitter(x=, lower='1 K', upper=None, minimum=None, maximum=None) - xsdba version" + in out.attrs["history"] + ) + + +def test_jitter_over_thresh(): + da = xr.DataArray([0.5, 2.1, np.nan], attrs={"units": "m"}) + out = jitter_over_thresh(da, "200 cm", "0.003 km") + + assert da[1] != out[1] + assert da[1] < 3 + assert da[1] > 2 + np.testing.assert_allclose(da[[0, 2]], out[[0, 2]]) + assert out.units == "m" + + +@pytest.mark.parametrize("use_dask", [True, False]) +def test_adapt_freq(use_dask, random): + time = pd.date_range("1990-01-01", "2020-12-31", freq="D") + prvals = random.integers(0, 100, size=(time.size, 3)) + pr = xr.DataArray( + prvals, + coords={"time": time, "lat": [0, 1, 2]}, + dims=("time", "lat"), + attrs={"units": "mm d-1"}, + ) + + if use_dask: + pr = pr.chunk({"lat": 1}) + group = Grouper("time.month") + with xr.set_options(keep_attrs=True): + prsim = xr.where(pr < 20, pr / 20, pr) + prref = xr.where(pr < 10, pr / 20, pr) + sim_ad, pth, dP0 = adapt_freq(prref, prsim, thresh="1 mm d-1", group=group) + + # Where the input is considered zero + input_zeros = sim_ad.where(prsim <= 1) + + # The proportion of corrected values (time.size * 3 * 0.2 is the theoretical number of values under 1 in prsim) + dP0_out = (input_zeros > 1).sum() / (time.size * 3 * 0.2) + np.testing.assert_allclose(dP0_out, 0.5, atol=0.1) + + # Assert that corrected values were generated in the range ]1, 20 + tol[ + corrected = ( + input_zeros.where(input_zeros > 1) + .stack(flat=["lat", "time"]) + .reset_index("flat") + .dropna("flat") + ) + assert ((corrected < 20.1) & (corrected > 1)).all() + + # Assert that non-corrected values are untouched + # Again we add a 0.5 tol because of randomness. + xr.testing.assert_equal( + sim_ad.where(prsim > 20.1), + prsim.where(prsim > 20.5).transpose("lat", "time"), + ) + # Assert that Pth and dP0 are approx the good values + np.testing.assert_allclose(pth, 20, rtol=0.05) + np.testing.assert_allclose(dP0, 0.5, atol=0.25) + assert sim_ad.units == "mm d-1" + assert sim_ad.attrs["references"].startswith("Themeßl") + assert pth.units == "mm d-1" + + +@pytest.mark.parametrize("use_dask", [True, False]) +def test_adapt_freq_add_dims(use_dask, random): + time = pd.date_range("1990-01-01", "2020-12-31", freq="D") + prvals = random.integers(0, 100, size=(time.size, 3)) + pr = xr.DataArray( + prvals, + coords={"time": time, "lat": [0, 1, 2]}, + dims=("time", "lat"), + attrs={"units": "mm d-1"}, + ) + + if use_dask: + pr = pr.chunk() + group = Grouper("time.month", add_dims=["lat"]) + with xr.set_options(keep_attrs=True): + prsim = xr.where(pr < 20, pr / 20, pr) + prref = xr.where(pr < 10, pr / 20, pr) + sim_ad, pth, _dP0 = adapt_freq(prref, prsim, thresh="1 mm d-1", group=group) + assert set(sim_ad.dims) == set(prsim.dims) + assert "lat" not in pth.dims + + group = Grouper("time.dayofyear", window=5) + with xr.set_options(keep_attrs=True): + prsim = xr.where(pr < 20, pr / 20, pr) + prref = xr.where(pr < 10, pr / 20, pr) + sim_ad, pth, _dP0 = adapt_freq(prref, prsim, thresh="1 mm d-1", group=group) + assert set(sim_ad.dims) == set(prsim.dims) + + +def test_escore(): + x = np.array([1, 4, 3, 6, 4, 7, 5, 8, 4, 5, 3, 7]).reshape(2, 6) + y = np.array([6, 6, 3, 8, 5, 7, 3, 7, 3, 6, 4, 3]).reshape(2, 6) + + x = xr.DataArray(x, dims=("variables", "time")) + y = xr.DataArray(y, dims=("variables", "time")) + + # Value taken from escore of Cannon's MBC R package. + out = escore(x, y) + np.testing.assert_allclose(out, 1.90018550338863) + assert "escore(" in out.attrs["history"] + assert out.attrs["references"].startswith("Székely") + + +def test_standardize(random): + x = random.standard_normal((2, 10000)) + x[0, 50] = np.nan + x = xr.DataArray(x, dims=("x", "y"), attrs={"units": "m"}) + + xp, avg, std = standardize(x, dim="y") + + np.testing.assert_allclose(avg, 0, atol=4e-2) + np.testing.assert_allclose(std, 1, atol=2e-2) + + xp, avg, std = standardize(x, mean=avg, dim="y") + np.testing.assert_allclose(std, 1, atol=2e-2) + + y = unstandardize(xp, 0, 1) + + np.testing.assert_allclose(x, y, atol=0.1) + assert avg.units == xp.units + + +def test_reordering(): + y = xr.DataArray(np.arange(1, 11), dims=("time",), attrs={"a": 1, "units": "K"}) + x = xr.DataArray(np.arange(10, 20)[::-1], dims=("time",)) + + out = reordering(x, y, group="time") + + np.testing.assert_array_equal(out, np.arange(1, 11)[::-1]) + out.attrs.pop("history") + assert out.attrs == y.attrs + + +def test_reordering_with_window(): + time = list( + xr.date_range("2000-01-01", "2000-01-04", freq="D", calendar="noleap") + ) + list(xr.date_range("2001-01-01", "2001-01-04", freq="D", calendar="noleap")) + + x = xr.DataArray( + np.arange(1, 9, 1), + dims=("time"), + coords={"time": time}, + ) + + y = xr.DataArray( + np.arange(8, 0, -1), + dims=("time"), + coords={"time": time}, + ) + + group = Grouper(group="time.dayofyear", window=3) + out = reordering(x, y, group=group) + + np.testing.assert_array_equal(out, [3.0, 3.0, 2.0, 2.0, 7.0, 7.0, 6.0, 6.0]) + out.attrs.pop("history") + assert out.attrs == y.attrs + + +def test_to_additive(timelonlatseries): + # log + pr = timelonlatseries(np.array([0, 1e-5, 1, np.e**10]), attrs={"units": "mm/d"}) + prlog = to_additive_space(pr, lower_bound="0 mm/d", trans="log") + np.testing.assert_allclose(prlog, [-np.Inf, -11.512925, 0, 10]) + assert prlog.attrs["sdba_transform"] == "log" + assert prlog.attrs["sdba_transform_units"] == "mm/d" + + # with xr.set_options(keep_attrs=True): + # pr1 = pr + 1 + # with units.context("hydro"): + # prlog2 = to_additive_space(pr1, trans="log", lower_bound="1.0 kg m-2 s-1") + # np.testing.assert_allclose(prlog2, [-np.Inf, -11.512925, 0, 10]) + # assert prlog2.attrs["sdba_transform_lower"] == 1.0 + + # logit + hurs = timelonlatseries(np.array([0, 1e-3, 90, 100]), attrs={"units": "%"}) + + hurslogit = to_additive_space( + hurs, lower_bound="0 %", trans="logit", upper_bound="100 %" + ) + np.testing.assert_allclose( + hurslogit, [-np.Inf, -11.5129154649, 2.197224577, np.Inf] + ) + assert hurslogit.attrs["sdba_transform"] == "logit" + assert hurslogit.attrs["sdba_transform_units"] == "%" + + with xr.set_options(keep_attrs=True): + hursscl = hurs * 4 + 200 + hurslogit2 = to_additive_space( + hursscl, trans="logit", lower_bound="2", upper_bound="6" + ) + np.testing.assert_allclose( + hurslogit2, [-np.Inf, -11.5129154649, 2.197224577, np.Inf] + ) + assert hurslogit2.attrs["sdba_transform_lower"] == 200.0 + assert hurslogit2.attrs["sdba_transform_upper"] == 600.0 + + +def test_from_additive(timelonlatseries): + # log + pr = timelonlatseries(np.array([0, 1e-5, 1, np.e**10]), attrs={"units":"mm/d"}) + pr2 = from_additive_space( + to_additive_space(pr, lower_bound="0 mm/d", trans="log") + ) + np.testing.assert_allclose(pr[1:], pr2[1:]) + pr2.attrs.pop("history") + assert pr.attrs == pr2.attrs + + # logit + hurs = timelonlatseries(np.array([0, 1e-5, 0.9, 1]), attrs={"units":"%"}) + hurs2 = from_additive_space( + to_additive_space(hurs, lower_bound="0 %", trans="logit", upper_bound="100 %") + ) + np.testing.assert_allclose(hurs[1:-1], hurs2[1:-1]) + + +def test_normalize(timelonlatseries, random): + tas = timelonlatseries( + random.standard_normal((int(365.25 * 36),)) + 273.15, attrs={"units": "K"}, start="2000-01-01" + ) + + xp, norm = normalize(tas, group="time.dayofyear") + np.testing.assert_allclose(norm, 273.15, atol=1) + + xp2, norm = normalize(tas, norm=norm, group="time.dayofyear") + np.testing.assert_allclose(xp, xp2) + + +def test_stack_variables(open_dataset): + ds1 = open_dataset("sdba/CanESM2_1950-2100.nc") + ds2 = open_dataset("sdba/ahccd_1950-2013.nc") + + da1 = stack_variables(ds1) + da2 = stack_variables(ds2) + + assert list(da1.multivar.values) == ["pr", "tasmax"] + assert da1.multivar.attrs["_standard_name"] == [ + "precipitation_flux", + "air_temperature", + ] + assert da2.multivar.attrs["is_variables"] + assert da1.multivar.equals(da2.multivar) + + da1p = da1.sortby("multivar", ascending=False) + +# XSDBA FUTURE PR +# with pytest.raises(ValueError, match="Inputs have different multivariate"): +# EmpiricalQuantileMapping.train(da1p, da2) + + ds1p = unstack_variables(da1) + + xr.testing.assert_equal(ds1, ds1p) From 4c521be23ae7523782295ff548cc0175311fc329 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 27 Jul 2024 02:25:06 +0000 Subject: [PATCH 022/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/testing.py | 2 +- src/xsdba/units.py | 95 ++++++++++++++++++++++++++------------------ 2 files changed, 57 insertions(+), 40 deletions(-) diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index f8a4a55..ce74241 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -51,7 +51,7 @@ SocketBlockedError = None -def test_timelonlatseries(values, attrs = None, start="2000-01-01"): +def test_timelonlatseries(values, attrs=None, start="2000-01-01"): """Create a DataArray with time, lon and lat dimensions.""" attrs = {} if attrs is None else attrs coords = collections.OrderedDict() diff --git a/src/xsdba/units.py b/src/xsdba/units.py index f5df707..08c303e 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -4,17 +4,18 @@ """ import inspect +from copy import deepcopy from functools import wraps +# this dependency is "necessary" for convert_units_to +# if we only do checks, we could get rid of it +import cf_xarray.units +import numpy as np import pint import xarray as xr -import numpy as np -from copy import deepcopy + from .base import Quantified, copy_all_attrs -# this dependency is "necessary" for convert_units_to -# if we only do checks, we could get rid of it -import cf_xarray.units # shamelessly adapted from `cf-xarray` (which adopted it from MetPy and xclim itself) units = deepcopy(cf_xarray.units.units) # Switch this flag back to False. Not sure what that implies, but it breaks some tests. @@ -22,7 +23,8 @@ # Another alias not included by cf_xarray units.define("@alias percent = pct") -# XC + +# XC def units2pint(value: xr.DataArray | str | units.Quantity) -> pint.Unit: """Return the pint Unit for the DataArray units. @@ -67,6 +69,7 @@ def units2pint(value: xr.DataArray | str | units.Quantity) -> pint.Unit: return units.parse_units(unit) + # XC def str2pint(val: str) -> pint.Quantity: """Convert a string to a pint.Quantity, splitting the magnitude and the units. @@ -90,6 +93,7 @@ def str2pint(val: str) -> pint.Quantity: except ValueError: return units.Quantity(1, units2pint(val)) + # XC # def ensure_delta(unit: str) -> str: # """Return delta units for temperature. @@ -118,7 +122,9 @@ def extract_units(arg): """Extract units from a string, DataArray, or scalar.""" if not (isinstance(arg, (str, xr.DataArray)) or np.isscalar(arg)): print(arg) - raise TypeError(f"Argument must be a str, DataArray, or scalar. Got {type(arg)}") + raise TypeError( + f"Argument must be a str, DataArray, or scalar. Got {type(arg)}" + ) elif isinstance(arg, xr.DataArray): ustr = None if "units" not in arg.attrs else arg.attrs["units"] elif isinstance(arg, str): @@ -128,9 +134,9 @@ def extract_units(arg): return ustr if ustr is None else pint.Quantity(1, ustr).units - def check_units(args_to_check): """Decorator to check that all arguments have the same units (or no units).""" + # if no units are present (DataArray without units attribute or float), then no check is performed # if units are present, then check is performed # in mixed cases, an error is raised @@ -142,13 +148,15 @@ def _wrapper(*args, **kwargs): # Obtain units (or None if no units) of all args units = [] for arg_name in args_to_check: - if isinstance(arg_name, str): + if isinstance(arg_name, str): value = arg_dict[arg_name] key = arg_name - if isinstance(arg_name, dict): # support for Dataset, or a dict of thresholds + if isinstance( + arg_name, dict + ): # support for Dataset, or a dict of thresholds key, val = list(arg_name.keys())[0], list(arg_name.values())[0] value = arg_dict[key][val] - if value is None: # optional argument, should be ignored + if value is None: # optional argument, should be ignored args_to_check.remove(arg_name) continue if key not in arg_dict: @@ -207,35 +215,37 @@ def convert_units_to( # noqa: C901 if target_unit == source_unit: return source if isinstance(source, str) is False else str2pint(source).m else: # Convert units - if isinstance(source, xr.DataArray): + if isinstance(source, xr.DataArray): out = source.copy(data=units.convert(source.data, source_unit, target_unit)) out = out.assign_attrs(units=target_unit) - else: + else: out = str2pint(source).to(target_unit) return out def _fill_args_dict(args, kwargs, args_to_check, func): - """ Combine args and kwargs into a dict.""" + """Combine args and kwargs into a dict.""" args_dict = {} signature = inspect.signature(func) - for ik, (k,v) in enumerate(signature.parameters.items()): + for ik, (k, v) in enumerate(signature.parameters.items()): if ik < len(args): value = args[ik] if ik >= len(args): value = v.default if k not in kwargs else kwargs[k] args_dict[k] = value return args_dict + + def _split_args_kwargs(args, func): """Assign Keyword only arguments to kwargs.""" kwargs = {} signature = inspect.signature(func) indices_to_pop = [] - for ik, (k,v) in enumerate(signature.parameters.items()): - if v.kind == inspect.Parameter.KEYWORD_ONLY: + for ik, (k, v) in enumerate(signature.parameters.items()): + if v.kind == inspect.Parameter.KEYWORD_ONLY: indices_to_pop.append(ik) - kwargs[k] = v - indices_to_pop.sort(reverse=True) + kwargs[k] = v + indices_to_pop.sort(reverse=True) for ind in indices_to_pop: args.pop(ind) return args, kwargs @@ -245,6 +255,7 @@ def _split_args_kwargs(args, func): # TODO: add a switch to prevent string from being converted to float? def harmonize_units(args_to_check): """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" + # if no units are present (DataArray without units attribute or float), then no check is performed # if units are present, then check is performed # in mixed cases, an error is raised @@ -252,17 +263,19 @@ def _decorator(func): @wraps(func) def _wrapper(*args, **kwargs): arg_names = inspect.getfullargspec(func).args - args_dict = _fill_args_dict(list(args),kwargs, args_to_check, func) + args_dict = _fill_args_dict(list(args), kwargs, args_to_check, func) first_arg_name = args_to_check[0] first_arg = args_dict[first_arg_name] for arg_name in args_to_check[1:]: - if isinstance(arg_name, str): + if isinstance(arg_name, str): value = args_dict[arg_name] key = arg_name - if isinstance(arg_name, dict): # support for Dataset, or a dict of thresholds + if isinstance( + arg_name, dict + ): # support for Dataset, or a dict of thresholds key, val = list(arg_name.keys())[0], list(arg_name.values())[0] value = args_dict[key][val] - if value is None: # optional argument, should be ignored + if value is None: # optional argument, should be ignored args_to_check.remove(arg_name) continue if key not in args_dict: @@ -279,19 +292,20 @@ def _wrapper(*args, **kwargs): return _decorator - def _add_default_kws(params_dict, params_to_check, func): - """ Combine args and kwargs into a dict.""" + """Combine args and kwargs into a dict.""" args_dict = {} signature = inspect.signature(func) - for ik, (k,v) in enumerate(signature.parameters.items()): - if k not in params_dict and k in params_to_check: + for ik, (k, v) in enumerate(signature.parameters.items()): + if k not in params_dict and k in params_to_check: if v.default != inspect._empty: params_dict[k] = v.default return params_dict + def harmonize_units(params_to_check): """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" + # if no units are present (DataArray without units attribute or float), then no check is performed # if units are present, then check is performed # in mixed cases, an error is raised @@ -299,41 +313,44 @@ def _decorator(func): @wraps(func) def _wrapper(*args, **kwargs): params_func = inspect.signature(func).parameters.keys() - if set(params_to_check).issubset(set(params_func)) is False: + if set(params_to_check).issubset(set(params_func)) is False: raise ValueError( f"`harmonize_units' inputs `{params_to_check}` should be a subset of " f"`{func.__name__}`'s arguments: `{params_func}` (arguments that can contain units)" ) arg_names = inspect.getfullargspec(func).args args_dict = dict(zip(arg_names, args)) - params_dict = args_dict | {k:v for k,v in kwargs.items()} - params_dict = {k:v for k,v in params_dict.items() if k in params_to_check} + params_dict = args_dict | {k: v for k, v in kwargs.items()} + params_dict = {k: v for k, v in params_dict.items() if k in params_to_check} params_dict = _add_default_kws(params_dict, params_to_check, func) params_dict_keys = [k for k in params_dict.keys()] - if set(params_dict.keys()) != set(params_to_check): - raise ValueError ( + if set(params_dict.keys()) != set(params_to_check): + raise ValueError( f"{params_to_check} were passed but only {params_dict.keys()} were found " f"in `{func.__name__}`'s arguments" ) first_param = params_dict[params_to_check[0]] for param_name in params_dict.keys(): - if isinstance(param_name, str): + if isinstance(param_name, str): value = params_dict[param_name] key = param_name - if isinstance(param_name, dict): # support for Dataset, or a dict of thresholds + if isinstance( + param_name, dict + ): # support for Dataset, or a dict of thresholds key, val = list(param_name.keys())[0], list(param_name.values())[0] value = params_dict[key][val] - if value is None: # optional argument, should be ignored + if value is None: # optional argument, should be ignored continue params_dict[key] = convert_units_to(value, first_param) - for k in [k for k in params_dict.keys() if k not in args_dict.keys()]: + for k in [k for k in params_dict.keys() if k not in args_dict.keys()]: kwargs[k] = params_dict[k] params_dict.pop(k) args = list(args) - for iarg in range(len(args)): - if arg_names[iarg] in params_dict.keys(): + for iarg in range(len(args)): + if arg_names[iarg] in params_dict.keys(): args[iarg] = params_dict[arg_names[iarg]] return func(*args, **kwargs) + return _wrapper - return _decorator \ No newline at end of file + return _decorator From e55317191ea7b228b7763480f3b409cd0a72c040 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Mon, 29 Jul 2024 09:43:11 -0400 Subject: [PATCH 023/105] incorporate EQM in test_processing (+ add fixtures) --- src/xsdba/testing.py | 9 ++++++++- tests/conftest.py | 22 ++++++++++++++++++++++ tests/test_processing.py | 7 +++---- 3 files changed, 33 insertions(+), 5 deletions(-) diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index f8a4a55..e96eda3 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -51,7 +51,7 @@ SocketBlockedError = None -def test_timelonlatseries(values, attrs = None, start="2000-01-01"): +def test_timelonlatseries(values, attrs=None, start="2000-01-01"): """Create a DataArray with time, lon and lat dimensions.""" attrs = {} if attrs is None else attrs coords = collections.OrderedDict() @@ -307,3 +307,10 @@ def open_dataset( return ds except OSError as err: raise err + + +# XC +def nancov(X): + """Drop observations with NaNs from Numpy's cov.""" + X_na = np.isnan(X).any(axis=0) + return np.cov(X[:, ~X_na]) diff --git a/tests/conftest.py b/tests/conftest.py index 3cca5df..4be3140 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -22,6 +22,7 @@ from xsdba.testing import TESTDATA_BRANCH from xsdba.testing import open_dataset as _open_dataset from xsdba.testing import test_timelonlatseries, test_timeseries +from xsdba.utils import apply_correction, equally_spaced_nodes # import xclim # from xclim import __version__ as __xclim_version__ @@ -93,6 +94,27 @@ def _open_session_scoped_file( return _open_session_scoped_file +# XC +@pytest.fixture +def mon_triangular(): + return np.array(list(range(1, 7)) + list(range(7, 1, -1))) / 7 + + +# XC (name changed) +@pytest.fixture +def mon_timelonlatseries(series, mon_triangular): + def _mon_timelonlatseries(values, name): + """Random time series whose mean varies over a monthly cycle.""" + x = timelonlatseries(values, name) + m = mon_triangular + factor = timelonlatseriesseries(m[x.time.dt.month - 1], name) + + with xr.set_options(keep_attrs=True): + return apply_correction(x, factor, x.kind) + + return _mon_series + + @pytest.fixture def timelonlatseries(): return test_timelonlatseries diff --git a/tests/test_processing.py b/tests/test_processing.py index 1cb77f5..85df267 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -5,7 +5,7 @@ import pytest import xarray as xr -# from xsdba.adjustment import EmpiricalQuantileMapping +from xsdba.adjustment import EmpiricalQuantileMapping from xsdba.base import Grouper from xsdba.processing import ( adapt_freq, @@ -296,9 +296,8 @@ def test_stack_variables(open_dataset): da1p = da1.sortby("multivar", ascending=False) - # XSDBA FUTURE PR - # with pytest.raises(ValueError, match="Inputs have different multivariate"): - # EmpiricalQuantileMapping.train(da1p, da2) + with pytest.raises(ValueError, match="Inputs have different multivariate"): + EmpiricalQuantileMapping.train(da1p, da2) ds1p = unstack_variables(da1) From 266631447f4d423dba638f6dafe5172878c1a743 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Mon, 29 Jul 2024 16:33:06 -0400 Subject: [PATCH 024/105] PASSED: test_adjustment.py (except internet/open_dataset) --- .github/workflows/main.yml | 3 + pyproject.toml | 8 +- src/xsdba/__init__.py | 2 +- src/xsdba/_adjustment.py | 948 +++++++++++++++++++++ src/xsdba/adjustment.py | 1642 ++++++++++++++++++++++++++++++++++++ src/xsdba/base.py | 138 ++- src/xsdba/formatting.py | 20 +- src/xsdba/testing.py | 29 + src/xsdba/units.py | 27 +- tests/conftest.py | 76 +- tests/test_adjustment.py | 884 +++++++++++++++++++ 11 files changed, 3697 insertions(+), 80 deletions(-) create mode 100644 src/xsdba/_adjustment.py create mode 100644 src/xsdba/adjustment.py create mode 100644 tests/test_adjustment.py diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 9a5f05e..4f0f97c 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,5 +1,8 @@ name: xsdba Testing Suite +env: + XCLIM_TESTDATA_BRANCH: v2023.12.14 + on: push: branches: diff --git a/pyproject.toml b/pyproject.toml index c7f89f3..108a79d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -50,6 +50,8 @@ dev = [ "coverage >=7.5.0", "coveralls >=4.0.0", "mypy", + "netcdf4", + "h5", "numpydoc >=1.7.0", "pytest >=8.2.2", "pytest-cov >=5.0.0", @@ -239,8 +241,11 @@ checks = [ "GL01", "GL08", "PR01", + "PR02", # + "PR04", # "PR07", "PR08", + "PR10", # "RT01", "RT03", "SA01", @@ -303,7 +308,8 @@ ignore = [ "N803", "N806", "PTH123", - "S310" + "S310", + "PERF401" # don't force list comprehensions ] preview = true select = [ diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 108a53d..9554388 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -20,7 +20,7 @@ from __future__ import annotations -from . import base, detrending, processing, units, utils +from . import adjustment, base, detrending, processing, testing, units, utils # , adjustment # from . import adjustment, base, detrending, measures, processing, properties, utils diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py new file mode 100644 index 0000000..a038845 --- /dev/null +++ b/src/xsdba/_adjustment.py @@ -0,0 +1,948 @@ +# pylint: disable=no-value-for-parameter +"""# noqa: SS01 +Adjustment Algorithms +===================== + +This file defines the different steps, to be wrapped into the Adjustment objects. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import Callable + +import numpy as np +import xarray as xr + +from . import nbutils as nbu +from . import utils as u +from ._processing import _adapt_freq +from .base import Grouper, map_blocks, map_groups +from .detrending import PolyDetrend +from .options import set_options +from .processing import escore, jitter_under_thresh, reordering, standardize +from .units import convert_units_to, units + +# from xclim.indices.stats import _fitfunc_1d + + +def _adapt_freq_hist(ds: xr.Dataset, adapt_freq_thresh: str): + """Adapt frequency of null values of `hist` in order to match `ref`.""" + # ADAPT: Drop context altogether? + # with units.context(infer_context(ds.ref.attrs.get("standard_name"))): + thresh = convert_units_to(adapt_freq_thresh, ds.ref) + dim = ["time"] + ["window"] * ("window" in ds.hist.dims) + return _adapt_freq.func( + xr.Dataset(dict(sim=ds.hist, ref=ds.ref)), thresh=thresh, dim=dim + ).sim_ad + + +@map_groups( + af=[Grouper.PROP, "quantiles"], + hist_q=[Grouper.PROP, "quantiles"], + scaling=[Grouper.PROP], +) +def dqm_train( + ds: xr.Dataset, + *, + dim: str, + kind: str, + quantiles: np.ndarray, + adapt_freq_thresh: str | None = None, + jitter_under_thresh_value: str | None = None, +) -> xr.Dataset: + """Train step on one group. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : training target + hist : training data + dim : str + The dimension along which to compute the quantiles. + kind : str + The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + quantiles : array-like + The quantiles to compute. + adapt_freq_thresh : str, optional + Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Default is None, meaning that frequency adaptation is not performed. + jitter_under_thresh_value : str, optional + Threshold under which to add uniform random noise to values, a quantity with units. + Default is None, meaning that jitter under thresh is not performed. + + Returns + ------- + xr.Dataset + The dataset containing the adjustment factors, the quantiles over the training data, and the scaling factor. + """ + ds["hist"] = ( + jitter_under_thresh(ds.hist, jitter_under_thresh_value) + if jitter_under_thresh_value + else ds.hist + ) + ds["hist"] = ( + _adapt_freq_hist(ds, adapt_freq_thresh) if adapt_freq_thresh else ds.hist + ) + + refn = u.apply_correction(ds.ref, u.invert(ds.ref.mean(dim), kind), kind) + histn = u.apply_correction(ds.hist, u.invert(ds.hist.mean(dim), kind), kind) + + ref_q = nbu.quantile(refn, quantiles, dim) + hist_q = nbu.quantile(histn, quantiles, dim) + + af = u.get_correction(hist_q, ref_q, kind) + mu_ref = ds.ref.mean(dim) + mu_hist = ds.hist.mean(dim) + scaling = u.get_correction(mu_hist, mu_ref, kind=kind) + + return xr.Dataset(data_vars=dict(af=af, hist_q=hist_q, scaling=scaling)) + + +@map_groups( + af=[Grouper.PROP, "quantiles"], + hist_q=[Grouper.PROP, "quantiles"], +) +def eqm_train( + ds: xr.Dataset, + *, + dim: str, + kind: str, + quantiles: np.ndarray, + adapt_freq_thresh: str | None = None, + jitter_under_thresh_value: str | None = None, +) -> xr.Dataset: + """EQM: Train step on one group. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : training target + hist : training data + dim : str + The dimension along which to compute the quantiles. + kind : str + The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + quantiles : array-like + The quantiles to compute. + adapt_freq_thresh : str, optional + Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Default is None, meaning that frequency adaptation is not performed. + jitter_under_thresh_value : str, optional + Threshold under which to add uniform random noise to values, a quantity with units. + Default is None, meaning that jitter under thresh is not performed. + + Returns + ------- + xr.Dataset + The dataset containing the adjustment factors and the quantiles over the training data. + """ + ds["hist"] = ( + jitter_under_thresh(ds.hist, jitter_under_thresh_value) + if jitter_under_thresh_value + else ds.hist + ) + ds["hist"] = ( + _adapt_freq_hist(ds, adapt_freq_thresh) if adapt_freq_thresh else ds.hist + ) + ref_q = nbu.quantile(ds.ref, quantiles, dim) + hist_q = nbu.quantile(ds.hist, quantiles, dim) + + af = u.get_correction(hist_q, ref_q, kind) + + return xr.Dataset(data_vars=dict(af=af, hist_q=hist_q)) + + +def _npdft_train(ref, hist, rots, quantiles, method, extrap, n_escore, standardize): + r"""Npdf transform to correct a source `hist` into target `ref`. + + Perform a rotation, bias correct `hist` into `ref` with QuantileDeltaMapping, and rotate back. + Do this iteratively over all rotations `rots` and conserve adjustment factors `af_q` in each iteration. + + Notes + ----- + This function expects numpy inputs. The input arrays `ref,hist` are expected to be 2-dimensional arrays with shape: + `(len(nfeature), len(time))`, where `nfeature` is the dimension which is mixed by the multivariate bias adjustment + (e.g. a `multivar` dimension), i.e. `pts_dims[0]` in :py:func:`mbcn_train`. `rots` are rotation matrices with shape + `(len(iterations), len(nfeature), len(nfeature))`. + """ + if standardize: + ref = (ref - np.nanmean(ref, axis=-1, keepdims=True)) / ( + np.nanstd(ref, axis=-1, keepdims=True) + ) + hist = (hist - np.nanmean(hist, axis=-1, keepdims=True)) / ( + np.nanstd(hist, axis=-1, keepdims=True) + ) + af_q = np.zeros((len(rots), ref.shape[0], len(quantiles))) + escores = np.zeros(len(rots)) * np.NaN + if n_escore > 0: + ref_step, hist_step = ( + int(np.ceil(arr.shape[1] / n_escore)) for arr in [ref, hist] + ) + for ii in range(len(rots)): + rot = rots[0] if ii == 0 else rots[ii] @ rots[ii - 1].T + ref, hist = rot @ ref, rot @ hist + # loop over variables + for iv in range(ref.shape[0]): + ref_q, hist_q = nbu._quantile(ref[iv], quantiles), nbu._quantile( + hist[iv], quantiles + ) + af_q[ii, iv] = ref_q - hist_q + af = u._interp_on_quantiles_1D( + u._rank_bn(hist[iv]), + quantiles, + af_q[ii, iv], + method=method, + extrap=extrap, + ) + hist[iv] = hist[iv] + af + if n_escore > 0: + escores[ii] = nbu._escore(ref[:, ::ref_step], hist[:, ::hist_step]) + hist = rots[-1].T @ hist + return af_q, escores + + +def mbcn_train( + ds: xr.Dataset, + rot_matrices: xr.DataArray, + pts_dims: Sequence[str], + quantiles: np.ndarray, + gw_idxs: xr.DataArray, + interp: str, + extrapolation: str, + n_escore: int, +) -> xr.Dataset: + """Npdf transform training. + + Adjusting factors obtained for each rotation in the npdf transform and conserved to be applied in + the adjusting step in :py:func:`mcbn_adjust`. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : training target + hist : training data + rot_matrices : xr.DataArray + The rotation matrices as a 3D array ('iterations', , ), with shape (n_iter, , ). + pts_dims : sequence of str + The name of the "multivariate" dimension and its primed counterpart. Defaults to "multivar", which + is the normal case when using :py:func:`xclim.sdba.base.stack_variables`, and "multivar_prime". + quantiles : array-like + The quantiles to compute. + gw_idxs : xr.DataArray + Indices of the times in each windowed time group. + interp : str + The interpolation method to use. + extrapolation : str + The extrapolation method to use. + n_escore : int + Number of elements to include in the e_score test (0 for all, < 0 to skip). + + Returns + ------- + xr.Dataset + The dataset containing the adjustment factors and the quantiles over the training data + (only the npdf transform of mbcn). + """ + # unpack data + ref = ds.ref + hist = ds.hist + gr_dim = gw_idxs.attrs["group_dim"] + + # npdf training core + af_q_l = [] + escores_l = [] + + # loop over time blocks + for ib in range(gw_idxs[gr_dim].size): + # indices in a given time block + indices = gw_idxs[{gr_dim: ib}].fillna(-1).astype(int).values + ind = indices[indices >= 0] + + # npdft training : multiple rotations on standardized datasets + # keep track of adjustment factors in each rotation for later use + af_q, escores = xr.apply_ufunc( + _npdft_train, + ref[{"time": ind}], + hist[{"time": ind}], + rot_matrices, + quantiles, + input_core_dims=[ + [pts_dims[0], "time"], + [pts_dims[0], "time"], + ["iterations", pts_dims[1], pts_dims[0]], + ["quantiles"], + ], + output_core_dims=[ + ["iterations", pts_dims[1], "quantiles"], + ["iterations"], + ], + dask="parallelized", + output_dtypes=[hist.dtype, hist.dtype], + kwargs={ + "method": interp, + "extrap": extrapolation, + "n_escore": n_escore, + "standardize": True, + }, + vectorize=True, + ) + af_q_l.append(af_q.expand_dims({gr_dim: [ib]})) + escores_l.append(escores.expand_dims({gr_dim: [ib]})) + af_q = xr.concat(af_q_l, dim=gr_dim) + escores = xr.concat(escores_l, dim=gr_dim) + out = xr.Dataset(dict(af_q=af_q, escores=escores)).assign_coords( + {"quantiles": quantiles, gr_dim: gw_idxs[gr_dim].values} + ) + return out + + +def _npdft_adjust(sim, af_q, rots, quantiles, method, extrap): + """Npdf transform adjusting. + + Adjusting factors `af_q` obtained in the training step are applied on the simulated data `sim` at each iterated + rotation, see :py:func:`_npdft_train`. + + This function expects numpy inputs. `sim` can be a 2-d array with shape: `(len(nfeature), len(time))`, or + a 3-d array with shape: `(len(period), len(nfeature), len(time))`, allowing to adjust multiple climatological periods + all at once. `nfeature` is the dimension which is mixed by the multivariate bias adjustment + (e.g. a `multivar` dimension), i.e. `pts_dims[0]` in :py:func:`mbcn_train`. `rots` are rotation matrices with shape + `(len(iterations), len(nfeature), len(nfeature))`. + """ + # add dummy dim if period_dim absent to uniformize the function below + # This could be done at higher level, not sure where is best + if dummy_dim_added := (len(sim.shape) == 2): + sim = sim[:, np.newaxis, :] + + # adjust npdft + for ii in range(len(rots)): + rot = rots[0] if ii == 0 else rots[ii] @ rots[ii - 1].T + sim = np.einsum("ij,j...->i...", rot, sim) + # loop over variables + for iv in range(sim.shape[0]): + af = u._interp_on_quantiles_1D_multi( + u._rank_bn(sim[iv], axis=-1), + quantiles, + af_q[ii, iv], + method=method, + extrap=extrap, + ) + sim[iv] = sim[iv] + af + + rot = rots[-1].T + sim = np.einsum("ij,j...->i...", rot, sim) + if dummy_dim_added: + sim = sim[:, 0, :] + + return sim + + +def mbcn_adjust( + ref: xr.Dataset, + hist: xr.Dataset, + sim: xr.Dataset, + ds: xr.Dataset, + pts_dims: Sequence[str], + interp: str, + extrapolation: str, + base: Callable, + base_kws_vars: dict, + adj_kws: dict, + period_dim: str | None, +) -> xr.DataArray: + """Perform the adjustment portion MBCn multivariate bias correction technique. + + The function :py:func:`mbcn_train` pre-computes the adjustment factors for each rotation + in the npdf portion of the MBCn algorithm. The rest of adjustment is performed here + in `mbcn_adjust``. + + Parameters + ---------- + ref : xr.DataArray + training target. + hist : xr.DataArray + training data. + sim : xr.DataArray + data to adjust (stacked with multivariate dimension). + ds : xr.Dataset + Dataset variables: + rot_matrices : Rotation matrices used in the training step. + af_q : Adjustment factors obtained in the training step for the npdf transform + g_idxs : Indices of the times in each time group + gw_idxs: Indices of the times in each windowed time group + pts_dims : [str, str] + The name of the "multivariate" dimension and its primed counterpart. Defaults to "multivar", which + is the normal case when using :py:func:`xclim.sdba.base.stack_variables`, and "multivar_prime". + interp : str + Interpolation method for the npdf transform (same as in the training step). + extrapolation : str + Extrapolation method for the npdf transform (same as in the training step). + base : BaseAdjustment + Bias-adjustment class used for the univariate bias correction. + base_kws_vars : Dict + Options for univariate training for the scenario that is reordered with the output of npdf transform. + The arguments are those expected by TrainAdjust classes along with + - kinds : Dict of correction kinds for each variable (e.g. {"pr":"*", "tasmax":"+"}). + adj_kws : Dict + Options for univariate adjust for the scenario that is reordered with the output of npdf transform. + period_dim : str, optional + Name of the period dimension used when stacking time periods of `sim` using :py:func:`xclim.core.calendar.stack_periods`. + If specified, the interpolation of the npdf transform is performed only once and applied on all periods simultaneously. + This should be more performant, but also more memory intensive. Defaults to `None`: No optimization will be attempted. + + Returns + ------- + xr.Dataset + The adjusted data. + """ + # unpacking training parameters + rot_matrices = ds.rot_matrices + af_q = ds.af_q + quantiles = af_q.quantiles + g_idxs = ds.g_idxs + gw_idxs = ds.gw_idxs + gr_dim = gw_idxs.attrs["group_dim"] + win = gw_idxs.attrs["group"][1] + + # this way of handling was letting open the possibility to perform + # interpolation for multiple periods in the simulation all at once + # in principle, avoiding redundancy. Need to test this on small data + # to confirm it works, and on big data to check performance. + dims = ["time"] if period_dim is None else [period_dim, "time"] + + # mbcn core + scen_mbcn = xr.zeros_like(sim) + for ib in range(gw_idxs[gr_dim].size): + # indices in a given time block (with and without the window) + indices_gw = gw_idxs[{gr_dim: ib}].fillna(-1).astype(int).values + ind_gw = indices_gw[indices_gw >= 0] + indices_g = g_idxs[{gr_dim: ib}].fillna(-1).astype(int).values + ind_g = indices_g[indices_g >= 0] + + # 1. univariate adjustment of sim -> scen + # the kind may differ depending on the variables + scen_block = xr.zeros_like(sim[{"time": ind_gw}]) + for iv, v in enumerate(sim[pts_dims[0]].values): + sl = {"time": ind_gw, pts_dims[0]: iv} + with set_options(sdba_extra_output=False): + ADJ = base.train( + ref[sl], hist[sl], **base_kws_vars[v], skip_input_checks=True + ) + scen_block[{pts_dims[0]: iv}] = ADJ.adjust( + sim[sl], **adj_kws, skip_input_checks=True + ) + + # 2. npdft adjustment of sim + npdft_block = xr.apply_ufunc( + _npdft_adjust, + standardize(sim[{"time": ind_gw}].copy(), dim="time")[0], + af_q[{gr_dim: ib}], + rot_matrices, + quantiles, + input_core_dims=[ + [pts_dims[0]] + dims, + ["iterations", pts_dims[1], "quantiles"], + ["iterations", pts_dims[1], pts_dims[0]], + ["quantiles"], + ], + output_core_dims=[ + [pts_dims[0]] + dims, + ], + dask="parallelized", + output_dtypes=[sim.dtype], + kwargs={"method": interp, "extrap": extrapolation}, + vectorize=True, + ) + + # 3. reorder scen according to npdft results + reordered = reordering(ref=npdft_block, sim=scen_block) + if win > 1: + # keep central value of window (intersecting indices in gw_idxs and g_idxs) + scen_mbcn[{"time": ind_g}] = reordered[{"time": np.in1d(ind_gw, ind_g)}] + else: + scen_mbcn[{"time": ind_g}] = reordered + + return scen_mbcn.to_dataset(name="scen") + + +@map_blocks(reduces=[Grouper.PROP, "quantiles"], scen=[]) +def qm_adjust( + ds: xr.Dataset, *, group: Grouper, interp: str, extrapolation: str, kind: str +) -> xr.Dataset: + """QM (DQM and EQM): Adjust step on one block. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + af : Adjustment factors + hist_q : Quantiles over the training data + sim : Data to adjust. + group : Grouper + The grouper object. + interp : str + The interpolation method to use. + extrapolation : str + The extrapolation method to use. + kind : str + The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + + Returns + ------- + xr.Dataset + The adjusted data. + """ + af = u.interp_on_quantiles( + ds.sim, + ds.hist_q, + ds.af, + group=group, + method=interp, + extrapolation=extrapolation, + ) + + scen: xr.DataArray = u.apply_correction(ds.sim, af, kind).rename("scen") + out = scen.to_dataset() + return out + + +@map_blocks(reduces=[Grouper.PROP, "quantiles"], scen=[], trend=[]) +def dqm_adjust( + ds: xr.Dataset, + *, + group: Grouper, + interp: str, + kind: str, + extrapolation: str, + detrend: int | PolyDetrend, +) -> xr.Dataset: + """DQM adjustment on one block. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + scaling : Scaling factor between ref and hist + af : Adjustment factors + hist_q : Quantiles over the training data + sim : Data to adjust + group : Grouper + The grouper object. + interp : str + The interpolation method to use. + kind : str + The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + extrapolation : str + The extrapolation method to use. + detrend : int | PolyDetrend + The degree of the polynomial detrending to apply. If 0, no detrending is applied. + + Returns + ------- + xr.Dataset + The adjusted data and the trend. + """ + scaled_sim = u.apply_correction( + ds.sim, + u.broadcast( + ds.scaling, + ds.sim, + group=group, + interp=interp if group.prop != "dayofyear" else "nearest", + ), + kind, + ).assign_attrs({"units": ds.sim.units}) + + if isinstance(detrend, int): + detrending = PolyDetrend(degree=detrend, kind=kind, group=group) + else: + detrending = detrend + + detrending = detrending.fit(scaled_sim) + ds["sim"] = detrending.detrend(scaled_sim) + scen = qm_adjust.func( + ds, + group=group, + interp=interp, + extrapolation=extrapolation, + kind=kind, + ).scen + scen = detrending.retrend(scen) + + out = xr.Dataset({"scen": scen, "trend": detrending.ds.trend}) + return out + + +@map_blocks(reduces=[Grouper.PROP, "quantiles"], scen=[], sim_q=[]) +def qdm_adjust(ds: xr.Dataset, *, group, interp, extrapolation, kind) -> xr.Dataset: + """QDM: Adjust process on one block. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + af : Adjustment factors + hist_q : Quantiles over the training data + sim : Data to adjust. + """ + sim_q = group.apply(u.rank, ds.sim, main_only=True, pct=True) + af = u.interp_on_quantiles( + sim_q, + ds.quantiles, + ds.af, + group=group, + method=interp, + extrapolation=extrapolation, + ) + scen = u.apply_correction(ds.sim, af, kind) + return xr.Dataset(dict(scen=scen, sim_q=sim_q)) + + +@map_blocks( + reduces=[Grouper.ADD_DIMS, Grouper.DIM], + af=[Grouper.PROP], + hist_thresh=[Grouper.PROP], +) +def loci_train(ds: xr.Dataset, *, group, thresh) -> xr.Dataset: + """LOCI: Train on one block. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : training target + hist : training data + """ + s_thresh = group.apply( + u.map_cdf, ds.rename(hist="x", ref="y"), y_value=thresh + ).isel(x=0) + sth = u.broadcast(s_thresh, ds.hist, group=group) + ws = xr.where(ds.hist >= sth, ds.hist, np.nan) + wo = xr.where(ds.ref >= thresh, ds.ref, np.nan) + + ms = group.apply("mean", ws, skipna=True) + mo = group.apply("mean", wo, skipna=True) + + # Adjustment factor + af = u.get_correction(ms - s_thresh, mo - thresh, u.MULTIPLICATIVE) + return xr.Dataset({"af": af, "hist_thresh": s_thresh}) + + +@map_blocks(reduces=[Grouper.PROP], scen=[]) +def loci_adjust(ds: xr.Dataset, *, group, thresh, interp) -> xr.Dataset: + """LOCI: Adjust on one block. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + hist_thresh : Hist's equivalent thresh from ref + sim : Data to adjust + """ + sth = u.broadcast(ds.hist_thresh, ds.sim, group=group, interp=interp) + factor = u.broadcast(ds.af, ds.sim, group=group, interp=interp) + with xr.set_options(keep_attrs=True): + scen: xr.DataArray = ( + (factor * (ds.sim - sth) + thresh).clip(min=0).rename("scen") + ) + out = scen.to_dataset() + return out + + +@map_groups(af=[Grouper.PROP]) +def scaling_train(ds: xr.Dataset, *, dim, kind) -> xr.Dataset: + """Scaling: Train on one group. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : training target + hist : training data + """ + mhist = ds.hist.mean(dim) + mref = ds.ref.mean(dim) + af: xr.DataArray = u.get_correction(mhist, mref, kind).rename("af") + out = af.to_dataset() + return out + + +@map_blocks(reduces=[Grouper.PROP], scen=[]) +def scaling_adjust(ds: xr.Dataset, *, group, interp, kind) -> xr.Dataset: + """Scaling: Adjust on one block. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + af : Adjustment factors. + sim : Data to adjust. + """ + af = u.broadcast(ds.af, ds.sim, group=group, interp=interp) + scen: xr.DataArray = u.apply_correction(ds.sim, af, kind).rename("scen") + out = scen.to_dataset() + return out + + +def npdf_transform(ds: xr.Dataset, **kwargs) -> xr.Dataset: + r"""N-pdf transform : Iterative univariate adjustment in random rotated spaces. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : Reference multivariate timeseries + hist : simulated timeseries on the reference period + sim : Simulated timeseries on the projected period. + rot_matrices : Random rotation matrices. + \*\*kwargs + pts_dim : multivariate dimension name + base : Adjustment class + base_kws : Kwargs for initialising the adjustment object + adj_kws : Kwargs of the `adjust` call + n_escore : Number of elements to include in the e_score test (0 for all, < 0 to skip). + + Returns + ------- + xr.Dataset + Dataset with `scenh`, `scens` and `escores` DataArrays, where `scenh` and `scens` are `hist` and `sim` + respectively after adjustment according to `ref`. If `n_escore` is negative, `escores` will be filled with NaNs. + """ + ref = ds.ref.rename(time_hist="time") + hist = ds.hist.rename(time_hist="time") + sim = ds.sim + dim = kwargs["pts_dim"] + + escores = [] + for i, R in enumerate(ds.rot_matrices.transpose("iterations", ...)): + # @ operator stands for matrix multiplication (along named dimensions): x@R = R@x + # @R rotates an array defined over dimension x unto new dimension x'. x@R = x' + refp = ref @ R + histp = hist @ R + simp = sim @ R + + # Perform univariate adjustment in rotated space (x') + ADJ = kwargs["base"].train( + refp, histp, **kwargs["base_kws"], skip_input_checks=True + ) + scenhp = ADJ.adjust(histp, **kwargs["adj_kws"], skip_input_checks=True) + scensp = ADJ.adjust(simp, **kwargs["adj_kws"], skip_input_checks=True) + + # Rotate back to original dimension x'@R = x + # Note that x'@R is a back rotation because the matrix multiplication is now done along x' due to xarray + # operating along named dimensions. + # In normal linear algebra, this is equivalent to taking @R.T, the back rotation. + hist = scenhp @ R + sim = scensp @ R + + # Compute score + if kwargs["n_escore"] >= 0: + escores.append( + escore( + ref, + hist, + dims=(dim, "time"), + N=kwargs["n_escore"], + scale=True, + ).expand_dims(iterations=[i]) + ) + + if kwargs["n_escore"] >= 0: + escores = xr.concat(escores, "iterations") + else: + # All NaN, but with the proper shape. + escores = ( + ref.isel({dim: 0, "time": 0}) * hist.isel({dim: 0, "time": 0}) + ).expand_dims(iterations=ds.iterations) * np.NaN + + return xr.Dataset( + data_vars={ + "scenh": hist.rename(time="time_hist").transpose(*ds.hist.dims), + "scen": sim.transpose(*ds.sim.dims), + "escores": escores, + } + ) + + +# TODO: incorporate xclim.stats +# def _fit_on_cluster(data, thresh, dist, cluster_thresh): +# """Extract clusters on 1D data and fit "dist" on the maximums.""" +# _, _, _, maximums = u.get_clusters_1d(data, thresh, cluster_thresh) +# params = list( +# _fitfunc_1d(maximums - thresh, dist=dist, floc=0, nparams=3, method="ML") +# ) +# # We forced 0, put back thresh. +# params[-2] = thresh +# return params + + +# def _extremes_train_1d(ref, hist, ref_params, *, q_thresh, cluster_thresh, dist, N): +# """Train for method ExtremeValues, only for 1D input along time.""" +# # Find quantile q_thresh +# thresh = ( +# np.quantile(ref[ref >= cluster_thresh], q_thresh) +# + np.quantile(hist[hist >= cluster_thresh], q_thresh) +# ) / 2 + +# # Fit genpareto on cluster maximums on ref (if needed) and hist. +# if np.isnan(ref_params).all(): +# ref_params = _fit_on_cluster(ref, thresh, dist, cluster_thresh) + +# hist_params = _fit_on_cluster(hist, thresh, dist, cluster_thresh) + +# # Find probabilities of extremes according to fitted dist +# Px_ref = dist.cdf(ref[ref >= thresh], *ref_params) +# hist = hist[hist >= thresh] +# Px_hist = dist.cdf(hist, *hist_params) + +# # Find common probabilities range. +# Pmax = min(Px_ref.max(), Px_hist.max()) +# Pmin = max(Px_ref.min(), Px_hist.min()) +# Pcommon = (Px_hist <= Pmax) & (Px_hist >= Pmin) +# Px_hist = Px_hist[Pcommon] + +# # Find values of hist extremes if they followed ref's distribution. +# hist_in_ref = dist.ppf(Px_hist, *ref_params) + +# # Adjustment factors, unsorted +# af = hist_in_ref / hist[Pcommon] +# # sort them in Px order, and pad to have N values. +# order = np.argsort(Px_hist) +# px_hist = np.pad(Px_hist[order], ((0, N - af.size),), constant_values=np.NaN) +# af = np.pad(af[order], ((0, N - af.size),), constant_values=np.NaN) + +# return px_hist, af, thresh + + +# @map_blocks( +# reduces=["time"], px_hist=["quantiles"], af=["quantiles"], thresh=[Grouper.PROP] +# ) +# def extremes_train( +# ds: xr.Dataset, +# *, +# group: Grouper, +# q_thresh: float, +# cluster_thresh: float, +# dist, +# quantiles: np.ndarray, +# ) -> xr.Dataset: +# """Train extremes for a given variable series. + +# Parameters +# ---------- +# ds : xr.Dataset +# Dataset containing the reference and historical data. +# group : Grouper +# The grouper object. +# q_thresh : float +# The quantile threshold to use. +# cluster_thresh : float +# The threshold for clustering. +# dist : Any +# The distribution to fit. +# quantiles : array-like +# The quantiles to compute. + +# Returns +# ------- +# xr.Dataset +# The dataset containing the quantiles, the adjustment factors, and the threshold. +# """ +# px_hist, af, thresh = xr.apply_ufunc( +# _extremes_train_1d, +# ds.ref, +# ds.hist, +# ds.ref_params or np.NaN, +# input_core_dims=[("time",), ("time",), ()], +# output_core_dims=[("quantiles",), ("quantiles",), ()], +# vectorize=True, +# kwargs={ +# "q_thresh": q_thresh, +# "cluster_thresh": cluster_thresh, +# "dist": dist, +# "N": len(quantiles), +# }, +# ) +# # Outputs of map_blocks must have dimensions. +# if not isinstance(thresh, xr.DataArray): +# thresh = xr.DataArray(thresh) +# thresh = thresh.expand_dims(group=[1]) +# return xr.Dataset( +# {"px_hist": px_hist, "af": af, "thresh": thresh}, +# coords={"quantiles": quantiles}, +# ) + + +# def _fit_cluster_and_cdf(data, thresh, dist, cluster_thresh): +# """Fit 1D cluster maximums and immediately compute CDF.""" +# fut_params = _fit_on_cluster(data, thresh, dist, cluster_thresh) +# return dist.cdf(data, *fut_params) + + +# @map_blocks(reduces=["quantiles", Grouper.PROP], scen=[]) +# def extremes_adjust( +# ds: xr.Dataset, +# *, +# group: Grouper, +# frac: float, +# power: float, +# dist, +# interp: str, +# extrapolation: str, +# cluster_thresh: float, +# ) -> xr.Dataset: +# """Adjust extremes to reflect many distribution factors. + +# Parameters +# ---------- +# ds : xr.Dataset +# Dataset containing the reference and historical data. +# group : Grouper +# The grouper object. +# frac : float +# The fraction of the transition function. +# power : float +# The power of the transition function. +# dist : Any +# The distribution to fit. +# interp : str +# The interpolation method to use. +# extrapolation : str +# The extrapolation method to use. +# cluster_thresh : float +# The threshold for clustering. + +# Returns +# ------- +# xr.Dataset +# The dataset containing the adjusted data. +# """ +# # Find probabilities of extremes of fut according to its own cluster-fitted dist. +# px_fut = xr.apply_ufunc( +# _fit_cluster_and_cdf, +# ds.sim, +# ds.thresh, +# input_core_dims=[["time"], []], +# output_core_dims=[["time"]], +# kwargs={"dist": dist, "cluster_thresh": cluster_thresh}, +# vectorize=True, +# ) + +# # Find factors by interpolating from hist probs to fut probs. apply them. +# af = u.interp_on_quantiles( +# px_fut, ds.px_hist, ds.af, method=interp, extrapolation=extrapolation +# ) +# scen = u.apply_correction(ds.sim, af, "*") + +# # Smooth transition function between simulation and scenario. +# transition = ( +# ((ds.sim - ds.thresh) / ((ds.sim.max("time")) - ds.thresh)) / frac +# ) ** power +# transition = transition.clip(0, 1) + +# adjusted: xr.DataArray = (transition * scen) + ((1 - transition) * ds.scen) +# out = adjusted.rename("scen").squeeze("group", drop=True).to_dataset() +# return out diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py new file mode 100644 index 0000000..f39daca --- /dev/null +++ b/src/xsdba/adjustment.py @@ -0,0 +1,1642 @@ +# pylint: disable=missing-kwoa +"""# noqa: SS01 +Adjustment Methods +================== +""" +from __future__ import annotations + +from inspect import signature +from typing import Any +from warnings import warn + +import numpy as np +import xarray as xr +from xarray.core.dataarray import DataArray + +from xsdba.base import get_calendar +from xsdba.formatting import gen_call_string, update_history +from xsdba.options import OPTIONS, SDBA_EXTRA_OUTPUT, set_options +from xsdba.units import convert_units_to +from xsdba.utils import uses_dask + +from ._adjustment import ( # extremes_adjust,; extremes_train, + dqm_adjust, + dqm_train, + eqm_train, + loci_adjust, + loci_train, + mbcn_adjust, + mbcn_train, + npdf_transform, + qdm_adjust, + qm_adjust, + scaling_adjust, + scaling_train, +) +from .base import Grouper, ParametrizableWithDataset, parse_group +from .processing import grouped_time_indexes +from .utils import ( + ADDITIVE, + best_pc_orientation_full, + best_pc_orientation_simple, + equally_spaced_nodes, + pc_matrix, + rand_rot_matrix, +) + +# from xclim.indices import stats + + +__all__ = [ + "LOCI", + "BaseAdjustment", + "DetrendedQuantileMapping", + "EmpiricalQuantileMapping", + # "ExtremeValues", + "MBCn", + "NpdfTransform", + "PrincipalComponents", + "QuantileDeltaMapping", + "Scaling", +] + + +class BaseAdjustment(ParametrizableWithDataset): + """Base class for adjustment objects. + + Children classes should implement the `train` and / or the `adjust` method. + + This base class defined the basic input and output checks. It should only be used for a real adjustment + if neither `TrainAdjust` nor `Adjust` fit the algorithm. + """ + + _allow_diff_calendars = True + _attribute = "_xclim_adjustment" + + def __init__(self, *args, _trained=False, **kwargs): + if _trained: + super().__init__(*args, **kwargs) + else: + raise ValueError( + "As of xclim 0.29, Adjustment object should be initialized through their `train` or `adjust` methods." + ) + + @classmethod + def _check_inputs(cls, *inputs, group): + """Raise an error if there are chunks along the main dimension. + + Also raises if :py:attr:`BaseAdjustment._allow_diff_calendars` is False and calendars differ. + """ + for inda in inputs: + if uses_dask(inda) and len(inda.chunks[inda.get_axis_num(group.dim)]) > 1: + raise ValueError( + f"Multiple chunks along the main adjustment dimension {group.dim} is not supported." + ) + + # All calendars used by the inputs + calendars = {get_calendar(inda, group.dim) for inda in inputs} + if not cls._allow_diff_calendars and len(calendars) > 1: + raise ValueError( + "Inputs are defined on different calendars," + f" this is not supported for {cls.__name__} adjustment." + ) + + # Check multivariate dimensions + mvcrds = [] + for inda in inputs: + for crd in inda.coords.values(): + if crd.attrs.get("is_variables", False): + mvcrds.append(crd) + if mvcrds and ( + not all(mvcrds[0].equals(mv) for mv in mvcrds[1:]) + or len(mvcrds) != len(inputs) + ): + coords = {mv.name for mv in mvcrds} + raise ValueError( + f"Inputs have different multivariate coordinates: {', '.join(coords)}." + ) + + if group.prop == "dayofyear" and ( + "default" in calendars or "standard" in calendars + ): + warn( + "Strange results could be returned when using `dayofyear` grouping " + "on data defined in the 'proleptic_gregorian' calendar." + ) + + @classmethod + def _harmonize_units(cls, *inputs, target: dict[str] | str | None = None): + """Convert all inputs to the same units. + + If the target unit is not given, the units of the first input are used. + + Returns the converted inputs and the target units. + """ + + def _harmonize_units_multivariate( + *inputs, dim, target: dict[str] | None = None + ): + def _convert_units_to(inda, dim, target): + varss = inda[dim].values + input_units = { + v: inda[dim].attrs["_units"][iv] for iv, v in enumerate(varss) + } + if input_units == target: + return inda + input_standard_names = { + v: inda[dim].attrs["_standard_name"][iv] + for iv, v in enumerate(varss) + } + for iv, v in enumerate(varss): + inda.attrs["units"] = input_units[v] + inda.attrs["standard_name"] = input_standard_names[v] + inda[{dim: iv}] = convert_units_to(inda[{dim: iv}], target[v]) + inda[dim].attrs["_units"][iv] = target[v] + inda.attrs["units"] = "" + inda.attrs.pop("standard_name") + return inda + + if target is None: + if "_units" not in inputs[0][dim].attrs or any( + [u is None for u in inputs[0][dim].attrs["_units"]] + ): + error_msg = ( + "Units are missing in some or all of the stacked variables." + "The dataset stacked with `stack_variables` given as input should include units for every variable." + ) + raise ValueError(error_msg) + + target = { + v: inputs[0][dim].attrs["_units"][iv] + for iv, v in enumerate(inputs[0][dim].values) + } + return ( + _convert_units_to(inda, dim=dim, target=target) for inda in inputs + ), target + + for _dim, _crd in inputs[0].coords.items(): + if _crd.attrs.get("is_variables"): + return _harmonize_units_multivariate(*inputs, dim=_dim, target=target) + + if target is None: + target = inputs[0].units + + return (convert_units_to(inda, target) for inda in inputs), target + + @classmethod + def _train(cls, ref, hist, **kwargs): + raise NotImplementedError() + + def _adjust(self, sim, *args, **kwargs): + raise NotImplementedError() + + +class TrainAdjust(BaseAdjustment): + """Base class for adjustment objects obeying the train-adjust scheme. + + Children classes should implement these methods: + + - ``_train(ref, hist, **kwargs)``, classmethod receiving the training target and data, + returning a training dataset and parameters to store in the object. + + - ``_adjust(sim, **kwargs)``, receiving the projected data and some arguments, + returning the `scen` DataArray. + """ + + _allow_diff_calendars = True + _attribute = "_xclim_adjustment" + _repr_hide_params = ["hist_calendar", "train_units"] + + @classmethod + def train(cls, ref: DataArray, hist: DataArray, **kwargs) -> TrainAdjust: + r"""Train the adjustment object. + + Refer to the class documentation for the algorithm details. + + Parameters + ---------- + ref : DataArray + Training target, usually a reference time series drawn from observations. + hist : DataArray + Training data, usually a model output whose biases are to be adjusted. + \*\*kwargs + Algorithm-specific keyword arguments, see class doc. + """ + kwargs = parse_group(cls._train, kwargs) + skip_checks = kwargs.pop("skip_input_checks", False) + + if not skip_checks: + if "group" in kwargs: + cls._check_inputs(ref, hist, group=kwargs["group"]) + + (ref, hist), train_units = cls._harmonize_units(ref, hist) + else: + train_units = "" + + ds, params = cls._train(ref, hist, **kwargs) + obj = cls( + _trained=True, + hist_calendar=get_calendar(hist), + train_units=train_units, + **params, + ) + obj.set_dataset(ds) + return obj + + def adjust(self, sim: DataArray, *args, **kwargs): + r"""Return bias-adjusted data. + + Refer to the class documentation for the algorithm details. + + Parameters + ---------- + sim : DataArray + Time series to be bias-adjusted, usually a model output. + \*args : xr.DataArray + Other DataArrays needed for the adjustment (usually none). + \*\*kwargs + Algorithm-specific keyword arguments, see class doc. + """ + skip_checks = kwargs.pop("skip_input_checks", False) + if not skip_checks: + if "group" in self: + self._check_inputs(sim, *args, group=self.group) + + (sim, *args), _ = self._harmonize_units(sim, *args, target=self.train_units) + + out = self._adjust(sim, *args, **kwargs) + + if isinstance(out, xr.DataArray): + out = out.rename("scen").to_dataset() + + scen = out.scen + + # Keep attrs + scen.attrs.update(sim.attrs) + for name, crd in sim.coords.items(): + if name in scen.coords: + scen[name].attrs.update(crd.attrs) + params = gen_call_string("", **kwargs)[1:-1] # indexing to remove added ( ) + infostr = f"{self!s}.adjust(sim, {params})" + scen.attrs["history"] = update_history(f"Bias-adjusted with {infostr}", sim) + scen.attrs["bias_adjustment"] = infostr + + _is_multivariate = any( + [_crd.attrs.get("is_variables") for _crd in sim.coords.values()] + ) + if _is_multivariate is False: + scen.attrs["units"] = self.train_units + + if OPTIONS[SDBA_EXTRA_OUTPUT]: + return out + return scen + + def set_dataset(self, ds: xr.Dataset): + """Store an xarray dataset in the `ds` attribute. + + Useful with custom object initialization or if some external processing was performed. + """ + super().set_dataset(ds) + self.ds.attrs["adj_params"] = str(self) + + @classmethod + def _train(cls, ref: DataArray, hist: DataArray, *kwargs): + raise NotImplementedError() + + def _adjust(self, sim, **kwargs): + raise NotImplementedError() + + +class Adjust(BaseAdjustment): + """Adjustment with no intermediate trained object. + + Children classes should implement a `_adjust` classmethod taking as input the three DataArrays + and returning the scen dataset/array. + """ + + @classmethod + def adjust( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + sim: xr.DataArray, + **kwargs, + ) -> xr.Dataset: + r"""Return bias-adjusted data. Refer to the class documentation for the algorithm details. + + Parameters + ---------- + ref : DataArray + Training target, usually a reference time series drawn from observations. + hist : DataArray + Training data, usually a model output whose biases are to be adjusted. + sim : DataArray + Time series to be bias-adjusted, usually a model output. + \*\*kwargs + Algorithm-specific keyword arguments, see class doc. + + Returns + ------- + xr.Dataset + The bias-adjusted Dataset. + """ + kwargs = parse_group(cls._adjust, kwargs) + skip_checks = kwargs.pop("skip_input_checks", False) + + if not skip_checks: + if "group" in kwargs: + cls._check_inputs(ref, hist, sim, group=kwargs["group"]) + + (ref, hist, sim), _ = cls._harmonize_units(ref, hist, sim) + + out: xr.Dataset | xr.DataArray = cls._adjust(ref, hist, sim, **kwargs) + + if isinstance(out, xr.DataArray): + out = out.rename("scen").to_dataset() + + scen = out.scen + + params = ", ".join([f"{k}={v!r}" for k, v in kwargs.items()]) + infostr = f"{cls.__name__}.adjust(ref, hist, sim, {params})" + scen.attrs["history"] = update_history(f"Bias-adjusted with {infostr}", sim) + scen.attrs["bias_adjustment"] = infostr + + _is_multivariate = any( + [_crd.attrs.get("is_variables") for _crd in sim.coords.values()] + ) + if _is_multivariate is False: + scen.attrs["units"] = ref.units + + if OPTIONS[SDBA_EXTRA_OUTPUT]: + return out + return scen + + +class EmpiricalQuantileMapping(TrainAdjust): + """Empirical Quantile Mapping bias-adjustment. + + Adjustment factors are computed between the quantiles of `ref` and `sim`. + Values of `sim` are matched to the corresponding quantiles of `hist` and corrected accordingly. + + .. math:: + + F^{-1}_{ref} (F_{hist}(sim)) + + where :math:`F` is the cumulative distribution function (CDF) and `mod` stands for model data. + + Attributes + ---------- + Train step + + nquantiles : int or 1d array of floats + The number of quantiles to use. Two endpoints at 1e-6 and 1 - 1e-6 will be added. + An array of quantiles [0, 1] can also be passed. Defaults to 20 quantiles. + kind : {'+', '*'} + The adjustment kind, either additive or multiplicative. Defaults to "+". + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Default is "time", meaning an single adjustment group along dimension "time". + adapt_freq_thresh : str | None + Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Default is None, meaning that frequency adaptation is not performed. + + Adjust step: + + interp : {'nearest', 'linear', 'cubic'} + The interpolation method to use when interpolating the adjustment factors. Defaults to "nearest". + extrapolation : {'constant', 'nan'} + The type of extrapolation to use. See :py:func:`xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + + References + ---------- + :cite:cts:`sdba-deque_frequency_2007` + """ + + _allow_diff_calendars = False + + @classmethod + def _train( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + nquantiles: int | np.ndarray = 20, + kind: str = ADDITIVE, + group: str | Grouper = "time", + adapt_freq_thresh: str | None = None, + jitter_under_thresh_value: str | None = None, + ) -> tuple[xr.Dataset, dict[str, Any]]: + if np.isscalar(nquantiles): + quantiles = equally_spaced_nodes(nquantiles).astype(ref.dtype) + else: + quantiles = nquantiles.astype(ref.dtype) + + ds = eqm_train( + xr.Dataset({"ref": ref, "hist": hist}), + group=group, + kind=kind, + quantiles=quantiles, + adapt_freq_thresh=adapt_freq_thresh, + jitter_under_thresh_value=jitter_under_thresh_value, + ) + + ds.af.attrs.update( + standard_name="Adjustment factors", + long_name="Quantile mapping adjustment factors", + ) + ds.hist_q.attrs.update( + standard_name="Model quantiles", + long_name="Quantiles of model on the reference period", + ) + return ds, {"group": group, "kind": kind} + + def _adjust(self, sim, interp="nearest", extrapolation="constant"): + return qm_adjust( + xr.Dataset({"af": self.ds.af, "hist_q": self.ds.hist_q, "sim": sim}), + group=self.group, + interp=interp, + extrapolation=extrapolation, + kind=self.kind, + ).scen + + +class DetrendedQuantileMapping(TrainAdjust): + r"""Detrended Quantile Mapping bias-adjustment. + + The algorithm follows these steps, 1-3 being the 'train' and 4-6, the 'adjust' steps. + + 1. A scaling factor that would make the mean of `hist` match the mean of `ref` is computed. + 2. `ref` and `hist` are normalized by removing the "dayofyear" mean. + 3. Adjustment factors are computed between the quantiles of the normalized `ref` and `hist`. + 4. `sim` is corrected by the scaling factor, and either normalized by "dayofyear" and detrended group-wise + or directly detrended per "dayofyear", using a linear fit (modifiable). + 5. Values of detrended `sim` are matched to the corresponding quantiles of normalized `hist` and corrected accordingly. + 6. The trend is put back on the result. + + .. math:: + + F^{-1}_{ref}\left\{F_{hist}\left[\frac{\overline{hist}\cdot sim}{\overline{sim}}\right]\right\}\frac{\overline{sim}}{\overline{hist}} + + where :math:`F` is the cumulative distribution function (CDF) and :math:`\overline{xyz}` is the linear trend of the data. + This equation is valid for multiplicative adjustment. Based on the DQM method of :cite:p:`sdba-cannon_bias_2015`. + + Parameters + ---------- + Train step: + + nquantiles : int or 1d array of floats + The number of quantiles to use. See :py:func:`~xclim.sdba.utils.equally_spaced_nodes`. + An array of quantiles [0, 1] can also be passed. Defaults to 20 quantiles. + kind : {'+', '*'} + The adjustment kind, either additive or multiplicative. Defaults to "+". + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Default is "time", meaning a single adjustment group along dimension "time". + adapt_freq_thresh : str | None + Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Default is None, meaning that frequency adaptation is not performed. + + Adjust step: + + interp : {'nearest', 'linear', 'cubic'} + The interpolation method to use when interpolating the adjustment factors. Defaults to "nearest". + detrend : int or BaseDetrend instance + The method to use when detrending. If an int is passed, it is understood as a PolyDetrend (polynomial detrending) degree. + Defaults to 1 (linear detrending). + extrapolation : {'constant', 'nan'} + The type of extrapolation to use. See :py:func:`xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + + References + ---------- + :cite:cts:`sdba-cannon_bias_2015` + """ + + _allow_diff_calendars = False + + @classmethod + def _train( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + nquantiles: int | np.ndarray = 20, + kind: str = ADDITIVE, + group: str | Grouper = "time", + adapt_freq_thresh: str | None = None, + jitter_under_thresh_value: str | None = None, + ): + if group.prop not in ["group", "dayofyear"]: + warn( + f"Using DQM with a grouping other than 'dayofyear' is not recommended (received {group.name})." + ) + + if np.isscalar(nquantiles): + quantiles = equally_spaced_nodes(nquantiles).astype(ref.dtype) + else: + quantiles = nquantiles.astype(ref.dtype) + + ds = dqm_train( + xr.Dataset({"ref": ref, "hist": hist}), + group=group, + quantiles=quantiles, + kind=kind, + adapt_freq_thresh=adapt_freq_thresh, + jitter_under_thresh_value=jitter_under_thresh_value, + ) + + ds.af.attrs.update( + standard_name="Adjustment factors", + long_name="Quantile mapping adjustment factors", + ) + ds.hist_q.attrs.update( + standard_name="Model quantiles", + long_name="Quantiles of model on the reference period", + ) + ds.scaling.attrs.update( + standard_name="Scaling factor", + description="Scaling factor making the mean of hist match the one of hist.", + ) + return ds, {"group": group, "kind": kind} + + def _adjust( + self, + sim, + interp="nearest", + extrapolation="constant", + detrend=1, + ): + scen = dqm_adjust( + self.ds.assign(sim=sim), + interp=interp, + extrapolation=extrapolation, + detrend=detrend, + group=self.group, + kind=self.kind, + ).scen + # Detrending needs units. + scen.attrs["units"] = sim.units + return scen + + +class QuantileDeltaMapping(EmpiricalQuantileMapping): + r"""Quantile Delta Mapping bias-adjustment. + + Adjustment factors are computed between the quantiles of `ref` and `hist`. + Quantiles of `sim` are matched to the corresponding quantiles of `hist` and corrected accordingly. + + .. math:: + + sim\frac{F^{-1}_{ref}\left[F_{sim}(sim)\right]}{F^{-1}_{hist}\left[F_{sim}(sim)\right]} + + where :math:`F` is the cumulative distribution function (CDF). This equation is valid for multiplicative adjustment. + The algorithm is based on the "QDM" method of :cite:p:`sdba-cannon_bias_2015`. + + Parameters + ---------- + Train step: + + nquantiles : int or 1d array of floats + The number of quantiles to use. See :py:func:`~xclim.sdba.utils.equally_spaced_nodes`. + An array of quantiles [0, 1] can also be passed. Defaults to 20 quantiles. + kind : {'+', '*'} + The adjustment kind, either additive or multiplicative. Defaults to "+". + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Default is "time", meaning a single adjustment group along dimension "time". + + Adjust step: + + interp : {'nearest', 'linear', 'cubic'} + The interpolation method to use when interpolating the adjustment factors. Defaults to "nearest". + extrapolation : {'constant', 'nan'} + The type of extrapolation to use. See :py:func:`xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + + Extra diagnostics + ----------------- + In adjustment: + + quantiles : The quantile of each value of `sim`. The adjustment factor is interpolated using this as the "quantile" axis on `ds.af`. + + References + ---------- + :cite:cts:`sdba-cannon_bias_2015` + """ + + def _adjust(self, sim, interp="nearest", extrapolation="constant"): + out = qdm_adjust( + xr.Dataset({"sim": sim, "af": self.ds.af, "hist_q": self.ds.hist_q}), + group=self.group, + interp=interp, + extrapolation=extrapolation, + kind=self.kind, + ) + if OPTIONS[SDBA_EXTRA_OUTPUT]: + out.sim_q.attrs.update(long_name="Group-wise quantiles of `sim`.") + return out + return out.scen + + +# class ExtremeValues(TrainAdjust): +# r"""Adjustment correction for extreme values. + +# The tail of the distribution of adjusted data is corrected according to the bias between the parametric Generalized +# Pareto distributions of the simulated and reference data :cite:p:`sdba-roy_extremeprecip_2023`. The distributions are composed of the +# maximal values of clusters of "large" values. With "large" values being those above `cluster_thresh`. Only extreme +# values, whose quantile within the pool of large values are above `q_thresh`, are re-adjusted. See `Notes`. + +# This adjustment method should be considered experimental and used with care. + +# Parameters +# ---------- +# Train step : + +# cluster_thresh : Quantity (str with units) +# The threshold value for defining clusters. +# q_thresh : float +# The quantile of "extreme" values, [0, 1[. Defaults to 0.95. +# ref_params : xr.DataArray, optional +# Distribution parameters to use instead of fitting a GenPareto distribution on `ref`. + +# Adjust step: + +# scen : DataArray +# This is a second-order adjustment, so the adjust method needs the first-order +# adjusted timeseries in addition to the raw "sim". +# interp : {'nearest', 'linear', 'cubic'} +# The interpolation method to use when interpolating the adjustment factors. Defaults to "linear". +# extrapolation : {'constant', 'nan'} +# The type of extrapolation to use. See :py:func:`~xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". +# frac : float +# Fraction where the cutoff happens between the original scen and the corrected one. +# See Notes, ]0, 1]. Defaults to 0.25. +# power : float +# Shape of the correction strength, see Notes. Defaults to 1.0. + +# Notes +# ----- +# Extreme values are extracted from `ref`, `hist` and `sim` by finding all "clusters", i.e. runs of consecutive values +# above `cluster_thresh`. The `q_thresh`th percentile of these values is taken on `ref` and `hist` and becomes +# `thresh`, the extreme value threshold. The maximal value of each cluster, if it exceeds that new threshold, is taken +# and Generalized Pareto distributions are fitted to them, for both `ref` and `hist`. The probabilities associated +# with each of these extremes in `hist` is used to find the corresponding value according to `ref`'s distribution. +# Adjustment factors are computed as the bias between those new extremes and the original ones. + +# In the adjust step, a Generalized Pareto distributions is fitted on the cluster-maximums of `sim` and it is used to +# associate a probability to each extreme, values over the `thresh` compute in the training, without the clustering. +# The adjustment factors are computed by interpolating the trained ones using these probabilities and the +# probabilities computed from `hist`. + +# Finally, the adjusted values (:math:`C_i`) are mixed with the pre-adjusted ones (`scen`, :math:`D_i`) using the +# following transition function: + +# .. math:: + +# V_i = C_i * \tau + D_i * (1 - \tau) + +# Where :math:`\tau` is a function of sim's extreme values (unadjusted, :math:`S_i`) +# and of arguments ``frac`` (:math:`f`) and ``power`` (:math:`p`): + +# .. math:: + +# \tau = \left(\frac{1}{f}\frac{S - min(S)}{max(S) - min(S)}\right)^p + +# Code based on an internal Matlab source and partly ib the `biascorrect_extremes` function of the julia package +# "ClimateTools.jl" :cite:p:`sdba-roy_juliaclimateclimatetoolsjl_2021`. + +# Because of limitations imposed by the lazy computing nature of the dask backend, it +# is not possible to know the number of cluster extremes in `ref` and `hist` at the +# moment the output data structure is created. This is why the code tries to estimate +# that number and usually overestimates it. In the training dataset, this translated +# into a `quantile` dimension that is too large and variables `af` and `px_hist` are +# assigned NaNs on extra elements. This has no incidence on the calculations +# themselves but requires more memory than is useful. + +# References +# ---------- +# :cite:cts:`sdba-roy_juliaclimateclimatetoolsjl_2021` +# :cite:cts:`sdba-roy_extremeprecip_2023` +# """ + +# @classmethod +# def _train( +# cls, +# ref: xr.DataArray, +# hist: xr.DataArray, +# *, +# cluster_thresh: str, +# ref_params: xr.Dataset | None = None, +# q_thresh: float = 0.95, +# ): +# cluster_thresh = convert_units_to(cluster_thresh, ref, context="infer") + +# # Approximation of how many "quantiles" values we will get: +# N = (1 - q_thresh) * ref.time.size * 1.05 # extra padding for safety + +# # ref_params: cast nan to f32 not to interfere with map_blocks dtype parsing +# # ref and hist are f32, we want to have f32 in the output. +# ds = extremes_train( +# xr.Dataset( +# { +# "ref": ref, +# "hist": hist, +# "ref_params": ref_params or np.float32(np.NaN), +# } +# ), +# q_thresh=q_thresh, +# cluster_thresh=cluster_thresh, +# dist=stats.get_dist("genpareto"), +# quantiles=np.arange(int(N)), +# group="time", +# ) + +# ds.px_hist.attrs.update( +# long_name="Probability of extremes in hist", +# description="Parametric probabilities of extremes in the common domain of hist and ref.", +# ) +# ds.af.attrs.update( +# long_name="Extremes adjustment factor", +# description="Multiplicative adjustment factor of extremes from hist to ref.", +# ) +# ds.thresh.attrs.update( +# long_name=f"{q_thresh * 100}th percentile extreme value threshold", +# description=f"Mean of the {q_thresh * 100}th percentile of large values (x > {cluster_thresh}) of ref and hist.", +# ) + +# return ds.drop_vars(["quantiles"]), {"cluster_thresh": cluster_thresh} + +# def _adjust( +# self, +# sim: xr.DataArray, +# scen: xr.DataArray, +# *, +# frac: float = 0.25, +# power: float = 1.0, +# interp: str = "linear", +# extrapolation: str = "constant", +# ): +# # Quantiles coord : cheat and assign 0 - 1, so we can use `extrapolate_qm`. +# ds = self.ds.assign( +# quantiles=(np.arange(self.ds.quantiles.size) + 1) +# / (self.ds.quantiles.size + 1) +# ) + +# scen = extremes_adjust( +# ds.assign(sim=sim, scen=scen), +# cluster_thresh=self.cluster_thresh, +# dist=stats.get_dist("genpareto"), +# frac=frac, +# power=power, +# interp=interp, +# extrapolation=extrapolation, +# group="time", +# ) + +# return scen + + +class LOCI(TrainAdjust): + r"""Local Intensity Scaling (LOCI) bias-adjustment. + + This bias adjustment method is designed to correct daily precipitation time series by considering wet and dry days + separately :cite:p:`sdba-schmidli_downscaling_2006`. + + Multiplicative adjustment factors are computed such that the mean of `hist` matches the mean of `ref` for values + above a threshold. + + The threshold on the training target `ref` is first mapped to `hist` by finding the quantile in `hist` having the same + exceedance probability as thresh in `ref`. The adjustment factor is then given by + + .. math:: + + s = \frac{\left \langle ref: ref \geq t_{ref} \right\rangle - t_{ref}}{\left \langle hist : hist \geq t_{hist} \right\rangle - t_{hist}} + + In the case of precipitations, the adjustment factor is the ratio of wet-days intensity. + + For an adjustment factor `s`, the bias-adjustment of `sim` is: + + .. math:: + + sim(t) = \max\left(t_{ref} + s \cdot (hist(t) - t_{hist}), 0\right) + + Attributes + ---------- + Train step: + + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Default is "time", meaning a single adjustment group along dimension "time". + thresh : str + The threshold in `ref` above which the values are scaled. + + Adjust step: + + interp : {'nearest', 'linear', 'cubic'} + The interpolation method to use then interpolating the adjustment factors. Defaults to "linear". + + References + ---------- + :cite:cts:`sdba-schmidli_downscaling_2006` + """ + + _allow_diff_calendars = False + + @classmethod + def _train( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + thresh: str, + group: str | Grouper = "time", + ): + thresh = convert_units_to(thresh, ref) + ds = loci_train( + xr.Dataset({"ref": ref, "hist": hist}), group=group, thresh=thresh + ) + ds.af.attrs.update(long_name="LOCI adjustment factors") + ds.hist_thresh.attrs.update(long_name="Threshold over modeled data") + return ds, {"group": group, "thresh": thresh} + + def _adjust(self, sim, interp="linear"): + return loci_adjust( + xr.Dataset( + {"hist_thresh": self.ds.hist_thresh, "af": self.ds.af, "sim": sim} + ), + group=self.group, + thresh=self.thresh, + interp=interp, + ).scen + + +class Scaling(TrainAdjust): + """Scaling bias-adjustment. + + Simple bias-adjustment method scaling variables by an additive or multiplicative factor so that the mean of `hist` + matches the mean of `ref`. + + Parameters + ---------- + Train step: + + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Default is "time", meaning an single adjustment group along dimension "time". + kind : {'+', '*'} + The adjustment kind, either additive or multiplicative. Defaults to "+". + + Adjust step: + + interp : {'nearest', 'linear', 'cubic'} + The interpolation method to use then interpolating the adjustment factors. Defaults to "nearest". + """ + + _allow_diff_calendars = False + + @classmethod + def _train( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + group: str | Grouper = "time", + kind: str = ADDITIVE, + ): + ds = scaling_train( + xr.Dataset({"ref": ref, "hist": hist}), group=group, kind=kind + ) + ds.af.attrs.update(long_name="Scaling adjustment factors") + return ds, {"group": group, "kind": kind} + + def _adjust(self, sim, interp="nearest"): + return scaling_adjust( + xr.Dataset({"sim": sim, "af": self.ds.af}), + group=self.group, + interp=interp, + kind=self.kind, + ).scen + + +class PrincipalComponents(TrainAdjust): + r"""Principal component adjustment. + + This bias-correction method maps model simulation values to the observation space through principal components + :cite:p:`sdba-hnilica_multisite_2017`. Values in the simulation space (multiple variables, or multiple sites) can be + thought of as coordinate along axes, such as variable, temperature, etc. Principal components (PC) are a + linear combinations of the original variables where the coefficients are the eigenvectors of the covariance matrix. + Values can then be expressed as coordinates along the PC axes. The method makes the assumption that bias-corrected + values have the same coordinates along the PC axes of the observations. By converting from the observation PC space + to the original space, we get bias corrected values. See `Notes` for a mathematical explanation. + + Warnings + -------- + Be aware that *principal components* is meant here as the algebraic operation defining a coordinate system + based on the eigenvectors, not statistical principal component analysis. + + Attributes + ---------- + group : Union[str, Grouper] + The main dimension and grouping information. See Notes. + See :py:class:`xclim.sdba.base.Grouper` for details. + The adjustment will be performed on each group independently. + Default is "time", meaning a single adjustment group along dimension "time". + best_orientation : {'simple', 'full'} + Which method to use when searching for the best principal component orientation. + See :py:func:`~xclim.sdba.utils.best_pc_orientation_simple` and + :py:func:`~xclim.sdba.utils.best_pc_orientation_full`. + "full" is more precise, but it is much slower. + crd_dim : str + The data dimension along which the multiple simulation space dimensions are taken. + For a multivariate adjustment, this usually is "multivar", as returned by `sdba.stack_variables`. + For a multisite adjustment, this should be the spatial dimension. + The training algorithm currently doesn't support any chunking + along either `crd_dim`. `group.dim` and `group.add_dims`. + + Notes + ----- + The input data is understood as a set of N points in a :math:`M`-dimensional space. + + - :math:`M` is taken along `crd_dim`. + + - :math:`N` is taken along the dimensions given through `group` : (the main `dim` but also, if requested, the `add_dims` and `window`). + + The principal components (PC) of `hist` and `ref` are used to defined new coordinate systems, centered on their + respective means. The training step creates a matrix defining the transformation from `hist` to `ref`: + + .. math:: + + scen = e_{R} + \mathrm{\mathbf{T}}(sim - e_{H}) + + Where: + + .. math:: + + \mathrm{\mathbf{T}} = \mathrm{\mathbf{R}}\mathrm{\mathbf{H}}^{-1} + + :math:`\mathrm{\mathbf{R}}` is the matrix transforming from the PC coordinates computed on `ref` to the data + coordinates. Similarly, :math:`\mathrm{\mathbf{H}}` is transform from the `hist` PC to the data coordinates + (:math:`\mathrm{\mathbf{H}}` is the inverse transformation). :math:`e_R` and :math:`e_H` are the centroids of the + `ref` and `hist` distributions respectively. Upon running the `adjust` step, one may decide to use :math:`e_S`, + the centroid of the `sim` distribution, instead of :math:`e_H`. + + References + ---------- + :cite:cts:`sdba-hnilica_multisite_2017,sdba-alavoine_distinct_2022` + """ + + @classmethod + def _train( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + crd_dim: str, + best_orientation: str = "simple", + group: str | Grouper = "time", + ): + all_dims = set(ref.dims + hist.dims) + + # Dimension name for the "points" + lblP = xr.core.utils.get_temp_dimname(all_dims, "points") + + # Rename coord on ref, multiindex do not like conflicting coordinates names + lblM = crd_dim + lblR = xr.core.utils.get_temp_dimname(ref.dims, lblM + "_out") + ref = ref.rename({lblM: lblR}) + + # The real thing, acting on 2D numpy arrays + def _compute_transform_matrix(reference, historical): + """Return the transformation matrix converting simulation coordinates to observation coordinates.""" + # Get transformation matrix from PC coords to ref, dropping points with a NaN coord. + ref_na = np.isnan(reference).any(axis=0) + R = pc_matrix(reference[:, ~ref_na]) + # Get transformation matrix from PC coords to hist, dropping points with a NaN coord. + hist_na = np.isnan(historical).any(axis=0) + H = pc_matrix(historical[:, ~hist_na]) + # This step needs vectorize with dask, but vectorize doesn't work with dask, argh. + # Invert to get transformation matrix from hist to PC coords. + Hinv = np.linalg.inv(H) + # Fancy tricks to choose the best orientation on each axis. + # (using eigenvectors, the output axes orientation is undefined) + if best_orientation == "simple": + orient = best_pc_orientation_simple(R, Hinv) + elif best_orientation == "full": + orient = best_pc_orientation_full( + R, Hinv, reference.mean(axis=1), historical.mean(axis=1), historical + ) + else: + raise ValueError( + f"Unknown `best_orientation` method: {best_orientation}." + ) + # Get transformation matrix + return (R * orient) @ Hinv + + # The group wrapper + def _compute_transform_matrices(ds, dim): + """Apply `_compute_transform_matrix` along dimensions other than time and the variables to map.""" + # The multiple PC-space dimensions are along lblR and lblM + # Matrix multiplication in xarray behaves as a dot product across + # same-name dimensions, instead of reducing according to the dimension order, + # as in numpy or normal maths. + if len(dim) > 1: + reference = ds.ref.stack({lblP: dim}) + historical = ds.hist.stack({lblP: dim}) + else: + reference = ds.ref.rename({dim[0]: lblP}) + historical = ds.hist.rename({dim[0]: lblP}) + transformation = xr.apply_ufunc( + _compute_transform_matrix, + reference, + historical, + input_core_dims=[[lblR, lblP], [lblM, lblP]], + output_core_dims=[[lblR, lblM]], + vectorize=True, + dask="parallelized", + output_dtypes=[float], + ) + return transformation + + # Transformation matrix, from model coords to ref coords. + trans = group.apply(_compute_transform_matrices, {"ref": ref, "hist": hist}) + trans.attrs.update(long_name="Transformation from training to target spaces.") + + ref_mean = group.apply("mean", ref) # Centroids of ref + ref_mean.attrs.update(long_name="Centroid point of target.") + + hist_mean = group.apply("mean", hist) # Centroids of hist + hist_mean.attrs.update(long_name="Centroid point of training.") + + ds = xr.Dataset(dict(trans=trans, ref_mean=ref_mean, hist_mean=hist_mean)) + + ds.attrs["_reference_coord"] = lblR + ds.attrs["_model_coord"] = lblM + return ds, {"group": group} + + def _adjust(self, sim): + lblR = self.ds.attrs["_reference_coord"] + lblM = self.ds.attrs["_model_coord"] + + vmean = self.group.apply("mean", sim) + + def _compute_adjust(ds, dim): + """Apply the mapping transformation.""" + scenario = ds.ref_mean + ds.trans.dot((ds.sim - ds.vmean), [lblM]) + return scenario + + scen = ( + self.group.apply( + _compute_adjust, + { + "ref_mean": self.ds.ref_mean, + "trans": self.ds.trans, + "sim": sim, + "vmean": vmean, + }, + main_only=True, + ) + .rename({lblR: lblM}) + .rename("scen") + ) + return scen + + +class NpdfTransform(Adjust): + r"""N-dimensional probability density function transform. + + This adjustment object combines both training and adjust steps in the `adjust` class method. + + A multivariate bias-adjustment algorithm described by :cite:t:`sdba-cannon_multivariate_2018`, as part of the MBCn + algorithm, based on a color-correction algorithm described by :cite:t:`sdba-pitie_n-dimensional_2005`. + + This algorithm in itself, when used with QuantileDeltaMapping, is NOT trend-preserving. + The full MBCn algorithm includes a reordering step provided here by :py:func:`xclim.sdba.processing.reordering`. + + See notes for an explanation of the algorithm. + + Parameters + ---------- + base : BaseAdjustment + An univariate bias-adjustment class. This is untested for anything else than QuantileDeltaMapping. + base_kws : dict, optional + Arguments passed to the training of the univariate adjustment. + n_escore : int + The number of elements to send to the escore function. The default, 0, means all elements are included. + Pass -1 to skip computing the escore completely. + Small numbers result in less significant scores, but the execution time goes up quickly with large values. + n_iter : int + The number of iterations to perform. Defaults to 20. + pts_dim : str + The name of the "multivariate" dimension. Defaults to "multivar", which is the + normal case when using :py:func:`xclim.sdba.base.stack_variables`. + adj_kws : dict, optional + Dictionary of arguments to pass to the adjust method of the univariate adjustment. + rot_matrices : xr.DataArray, optional + The rotation matrices as a 3D array ('iterations', , ), with shape (n_iter, , ). + If left empty, random rotation matrices will be automatically generated. + + Notes + ----- + The historical reference (:math:`T`, for "target"), simulated historical (:math:`H`) and simulated projected (:math:`S`) + datasets are constructed by stacking the timeseries of N variables together. The algorithm is broken into the + following steps: + + 1. Rotate the datasets in the N-dimensional variable space with :math:`\mathbf{R}`, a random rotation NxN matrix. + + .. math:: + + \tilde{\mathbf{T}} = \mathbf{T}\mathbf{R} \ + \tilde{\mathbf{H}} = \mathbf{H}\mathbf{R} \ + \tilde{\mathbf{S}} = \mathbf{S}\mathbf{R} + + 2. An univariate bias-adjustment :math:`\mathcal{F}` is used on the rotated datasets. + The adjustments are made in additive mode, for each variable :math:`i`. + + .. math:: + + \hat{\mathbf{H}}_i, \hat{\mathbf{S}}_i = \mathcal{F}\left(\tilde{\mathbf{T}}_i, \tilde{\mathbf{H}}_i, \tilde{\mathbf{S}}_i\right) + + 3. The bias-adjusted datasets are rotated back. + + .. math:: + + \mathbf{H}' = \hat{\mathbf{H}}\mathbf{R} \\ + \mathbf{S}' = \hat{\mathbf{S}}\mathbf{R} + + These three steps are repeated a certain number of times, prescribed by argument ``n_iter``. At each + iteration, a new random rotation matrix is generated. + + The original algorithm :cite:p:`sdba-pitie_n-dimensional_2005`, stops the iteration when some distance score converges. + Following cite:t:`sdba-cannon_multivariate_2018` and the MBCn implementation in :cite:t:`sdba-cannon_mbc_2020`, we + instead fix the number of iterations. + + As done by cite:t:`sdba-cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from + :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xclim.sdba.processing.escore`). + + The random matrices are generated following a method laid out by :cite:t:`sdba-mezzadri_how_2007`. + + This is only part of the full MBCn algorithm, see :ref:`notebooks/sdba:Statistical Downscaling and Bias-Adjustment` + for an example on how to replicate the full method with xclim. This includes a standardization of the simulated data + beforehand, an initial univariate adjustment and the reordering of those adjusted series according to the rank + structure of the output of this algorithm. + + References + ---------- + :cite:cts:`sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` + """ + + @classmethod + def _adjust( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + sim: xr.DataArray, + *, + base: TrainAdjust = QuantileDeltaMapping, + base_kws: dict[str, Any] | None = None, + n_escore: int = 0, + n_iter: int = 20, + pts_dim: str = "multivar", + adj_kws: dict[str, Any] | None = None, + rot_matrices: xr.DataArray | None = None, + ) -> xr.Dataset: + if base_kws is None: + base_kws = {} + if "kind" in base_kws: + warn( + f'The adjustment kind cannot be controlled when using {cls.__name__}, it defaults to "+".' + ) + base_kws.setdefault("kind", "+") + + # Assuming sim has the same coords as hist + # We get the safest new name of the rotated dim. + rot_dim = xr.core.utils.get_temp_dimname( + set(ref.dims).union(hist.dims).union(sim.dims), pts_dim + "_prime" + ) + + # Get the rotation matrices + rot_matrices = rot_matrices or rand_rot_matrix( + ref[pts_dim], num=n_iter, new_dim=rot_dim + ).rename(matrices="iterations") + + # Call a map_blocks on the iterative function + # Sadly, this is a bit too complicated for map_blocks, we'll do it by hand. + escores_tmpl = xr.broadcast( + ref.isel({pts_dim: 0, "time": 0}), + hist.isel({pts_dim: 0, "time": 0}), + )[0].expand_dims(iterations=rot_matrices.iterations) + + template = xr.Dataset( + data_vars={ + "scenh": xr.full_like(hist, np.NaN).rename(time="time_hist"), + "scen": xr.full_like(sim, np.NaN), + "escores": escores_tmpl, + } + ) + + # Input data, rename time dim on sim since it can't be aligned with ref or hist. + ds = xr.Dataset( + data_vars={ + "ref": ref.rename(time="time_hist"), + "hist": hist.rename(time="time_hist"), + "sim": sim, + "rot_matrices": rot_matrices, + } + ) + + kwargs = { + "base": base, + "base_kws": base_kws, + "n_escore": n_escore, + "n_iter": n_iter, + "pts_dim": pts_dim, + "adj_kws": adj_kws or {}, + } + + with set_options(sdba_extra_output=False): + out = ds.map_blocks(npdf_transform, template=template, kwargs=kwargs) + + out = out.assign(rotation_matrices=rot_matrices) + out.scenh.attrs["units"] = hist.units + return out + + +class MBCn(TrainAdjust): + r"""Multivariate bias correction function using the N-dimensional probability density function transform. + + A multivariate bias-adjustment algorithm described by :cite:t:`sdba-cannon_multivariate_2018` + based on a color-correction algorithm described by :cite:t:`sdba-pitie_n-dimensional_2005`. + + This algorithm in itself, when used with QuantileDeltaMapping, is NOT trend-preserving. + The full MBCn algorithm includes a reordering step provided here by :py:func:`xclim.sdba.processing.reordering`. + + See notes for an explanation of the algorithm. + + Attributes + ---------- + Train step + + ref : xr.DataArray + Reference dataset. + hist : xr.DataArray + Historical dataset. + base_kws : dict, optional + Arguments passed to the training in the npdf transform. + adj_kws : dict, optional + Arguments passed to the adjusting in the npdf transform. + n_escore : int + The number of elements to send to the escore function. The default, 0, means all elements are included. + Pass -1 to skip computing the escore completely. + Small numbers result in less significant scores, but the execution time goes up quickly with large values. + n_iter : int + The number of iterations to perform. Defaults to 20. + pts_dim : str + The name of the "multivariate" dimension. Defaults to "multivar", which is the + normal case when using :py:func:`xclim.sdba.base.stack_variables`. + rot_matrices: xr.DataArray, optional + The rotation matrices as a 3D array ('iterations', , ), with shape (n_iter, , ). + If left empty, random rotation matrices will be automatically generated. + + Adjust step + + ref : xr.DataArray + Target reference dataset also needed for univariate bias correction preceding npdf transform + hist: xr.DataArray + Source dataset also needed for univariate bias correction preceding npdf transform + sim : xr.DataArray + Source dataset to adjust. + base : BaseAdjustment + Bias-adjustment class used for the univariate bias correction. + base_kws : dict, optional + Arguments passed to the training in the univariate bias correction + adj_kws : dict, optional + Arguments passed to the adjusting in the univariate bias correction + period_dim : str, optional + Name of the period dimension used when stacking time periods of `sim` using :py:func:`xclim.core.calendar.stack_periods`. + If specified, the interpolation of the npdf transform is performed only once and applied on all periods simultaneously. + This should be more performant, but also more memory intensive. + + Training (only npdf transform training) + + 1. Standardize `ref` and `hist` (see ``xclim.sdba.processing.standardize``.) + + 2. Rotate the datasets in the N-dimensional variable space with :math:`\mathbf{R}`, a random rotation NxN matrix. + + .. math:: + + \tilde{\mathbf{T}} = \mathbf{T}\mathbf{R} \ + \tilde{\mathbf{H}} = \mathbf{H}\mathbf{R} + + 3. QuantileDeltaMapping is used to perform bias adjustment :math:`\mathcal{F}` on the rotated datasets. + The adjustment factor is conserved for later use in the adjusting step. The adjustments are made in additive mode, + for each variable :math:`i`. + + .. math:: + + \hat{\mathbf{H}}_i, \hat{\mathbf{S}}_i = \mathcal{F}\left(\tilde{\mathbf{T}}_i, \tilde{\mathbf{H}}_i, \tilde{\mathbf{S}}_i\right) + + 4. The bias-adjusted datasets are rotated back. + + .. math:: + + \mathbf{H}' = \hat{\mathbf{H}}\mathbf{R} \\ + \mathbf{S}' = \hat{\mathbf{S}}\mathbf{R} + + 5. Repeat steps 2,3,4 three steps ``n_iter`` times, i.e. the number of randomly generated rotation matrices. + + Adjusting + + 1. Perform the same steps as in training, with `ref, hist` replaced with `sim`. Step 3. of the training is modified, here we + simply reuse the adjustment factors previously found in the training step to bias correct the standardized `sim` directly. + + 2. Using the original (unstandardized) `ref,hist, sim`, perform a univariate bias adjustment using the ``base_scen`` class + on `sim`. + + 3. Reorder the dataset found in step 2. according to the ranks of the dataset found in step 1. + + The original algorithm :cite:p:`sdba-pitie_n-dimensional_2005`, stops the iteration when some distance score converges. + Following cite:t:`sdba-cannon_multivariate_2018` and the MBCn implementation in :cite:t:`sdba-cannon_mbc_2020`, we + instead fix the number of iterations. + + As done by cite:t:`sdba-cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from + :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xclim.sdba.processing.escore`). + + The random matrices are generated following a method laid out by :cite:t:`sdba-mezzadri_how_2007`. + + References + ---------- + :cite:cts:`sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` + + Notes + ----- + * Only "time" and "time.dayofyear" (with a suitable window) are implemented as possible values for `group`. + * The historical reference (:math:`T`, for "target"), simulated historical (:math:`H`) and simulated projected (:math:`S`) + datasets are constructed by stacking the timeseries of N variables together using ``xsdba.base.stack_variables``. + """ + + @classmethod + def _train( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + base_kws: dict[str, Any] | None = None, + adj_kws: dict[str, Any] | None = None, + n_escore: int = -1, + n_iter: int = 20, + pts_dim: str = "multivar", + rot_matrices: xr.DataArray | None = None, + ): + # set default values for non-specified parameters + base_kws = base_kws if base_kws is not None else {} + adj_kws = adj_kws if adj_kws is not None else {} + base_kws.setdefault("nquantiles", 20) + base_kws.setdefault("group", Grouper("time", 1)) + adj_kws.setdefault("interp", "nearest") + adj_kws.setdefault("extrapolation", "constant") + + if np.isscalar(base_kws["nquantiles"]): + base_kws["nquantiles"] = equally_spaced_nodes(base_kws["nquantiles"]) + if isinstance(base_kws["group"], str): + base_kws["group"] = Grouper(base_kws["group"], 1) + if base_kws["group"].name == "time.month": + NotImplementedError( + "Received `group==time.month` in `base_kws`. Monthly grouping is not currently supported in the MBCn class." + ) + # stack variables and prepare rotations + if rot_matrices is not None: + if pts_dim != rot_matrices.attrs["crd_dim"]: + raise ValueError( + f"`crd_dim` attribute of `rot_matrices` ({rot_matrices.attrs['crd_dim']}) does not correspond to `pts_dim` ({pts_dim})." + ) + else: + rot_dim = xr.core.utils.get_temp_dimname( + set(ref.dims).union(hist.dims), pts_dim + "_prime" + ) + rot_matrices = rand_rot_matrix( + ref[pts_dim], num=n_iter, new_dim=rot_dim + ).rename(matrices="iterations") + pts_dims = [rot_matrices.attrs[d] for d in ["crd_dim", "new_dim"]] + + # time indices corresponding to group and windowed group + # used to divide datasets as map_blocks or groupby would do + _, gw_idxs = grouped_time_indexes(ref.time, base_kws["group"]) + + # training, obtain adjustment factors of the npdf transform + ds = xr.Dataset(dict(ref=ref, hist=hist)) + params = { + "quantiles": base_kws["nquantiles"], + "interp": adj_kws["interp"], + "extrapolation": adj_kws["extrapolation"], + "pts_dims": pts_dims, + "n_escore": n_escore, + } + out = mbcn_train(ds, rot_matrices=rot_matrices, gw_idxs=gw_idxs, **params) + params["group"] = base_kws["group"] + + # postprocess + out["rot_matrices"] = rot_matrices + + out.af_q.attrs.update( + standard_name="Adjustment factors", + long_name="Quantile mapping adjustment factors", + ) + return out, params + + def _adjust( + self, + sim: xr.DataArray, + ref: xr.DataArray, + hist: xr.DataArray, + *, + base: TrainAdjust = QuantileDeltaMapping, + base_kws_vars: dict[str, Any] | None = None, + adj_kws: dict[str, Any] | None = None, + period_dim=None, + ): + # set default values for non-specified parameters + base_kws_vars = base_kws_vars or {} + pts_dim = self.pts_dims[0] + for v in sim[pts_dim].values: + base_kws_vars.setdefault(v, {}) + base_kws_vars[v].setdefault("group", self.group) + if isinstance(base_kws_vars[v]["group"], str): + base_kws_vars[v]["group"] = Grouper(base_kws_vars[v]["group"], 1) + if base_kws_vars[v]["group"] != self.group: + raise ValueError( + f"`group` input in _train and _adjust must be the same." + f"Got {self.group} and {base_kws_vars[v]['group']}" + ) + base_kws_vars[v].pop("group") + + base_kws_vars[v].setdefault("nquantiles", self.ds.af_q.quantiles.values) + if np.isscalar(base_kws_vars[v]["nquantiles"]): + base_kws_vars[v]["nquantiles"] = equally_spaced_nodes( + base_kws_vars[v]["nquantiles"] + ) + if "is_variables" in sim[pts_dim].attrs: + if self.train_units == "": + _, units = self._harmonize_units(sim) + else: + units = self.train_units + + if "jitter_under_thresh_value" in base_kws_vars[v]: + base_kws_vars[v]["jitter_under_thresh_value"] = str( + convert_units_to( + base_kws_vars[v]["jitter_under_thresh_value"], + units[v], + ) + ) + if "adapt_freq_thresh" in base_kws_vars[v]: + base_kws_vars[v]["adapt_freq_thresh"] = str( + convert_units_to( + base_kws_vars[v]["adapt_freq_thresh"], + units[v], + ) + ) + + adj_kws = adj_kws or {} + adj_kws.setdefault("interp", self.interp) + adj_kws.setdefault("extrapolation", self.extrapolation) + + g_idxs, gw_idxs = grouped_time_indexes(ref.time, self.group) + ds = self.ds.copy() + ds["g_idxs"] = g_idxs + ds["gw_idxs"] = gw_idxs + + # adjust (adjust for npft transform, train/adjust for univariate bias correction) + out = mbcn_adjust( + ref=ref, + hist=hist, + sim=sim, + ds=ds, + pts_dims=self.pts_dims, + interp=self.interp, + extrapolation=self.extrapolation, + base=base, + base_kws_vars=base_kws_vars, + adj_kws=adj_kws, + period_dim=period_dim, + ) + + return out + + +try: + import SBCK +except ImportError: # noqa: S110 + # SBCK is not installed, we will not generate the SBCK classes. + pass +else: + + class _SBCKAdjust(Adjust): + sbck = None # The method + + @classmethod + def _adjust(cls, ref, hist, sim, *, multi_dim=None, **kwargs): + # Check inputs + fit_needs_sim = "X1" in signature(cls.sbck.fit).parameters + for k, v in signature(cls.sbck.__init__).parameters.items(): + if ( + v.default == v.empty + and v.kind != v.VAR_KEYWORD + and k != "self" + and k not in kwargs + ): + raise ValueError( + f"Argument {k} is not optional for SBCK method {cls.sbck.__name__}." + ) + + ref = ref.rename(time="time_cal") + hist = hist.rename(time="time_cal") + sim = sim.rename(time="time_tgt") + + if multi_dim: + input_core_dims = [ + ("time_cal", multi_dim), + ("time_cal", multi_dim), + ("time_tgt", multi_dim), + ] + else: + input_core_dims = [("time_cal",), ("time_cal",), ("time_tgt",)] + + return xr.apply_ufunc( + cls._apply_sbck, + ref, + hist, + sim, + input_core_dims=input_core_dims, + kwargs={"method": cls.sbck, "fit_needs_sim": fit_needs_sim, **kwargs}, + vectorize=True, + keep_attrs=True, + dask="parallelized", + output_core_dims=[input_core_dims[-1]], + output_dtypes=[sim.dtype], + ).rename(time_tgt="time") + + @staticmethod + def _apply_sbck(ref, hist, sim, method, fit_needs_sim, **kwargs): + obj = method(**kwargs) + if fit_needs_sim: + obj.fit(ref, hist, sim) + else: + obj.fit(ref, hist) + scen = obj.predict(sim) + if sim.ndim == 1: + return scen[:, 0] + return scen + + def _parse_sbck_doc(cls): + def _parse(s): + s = s.replace("\t", " ") + n = min(len(line) - len(line.lstrip()) for line in s.split("\n") if line) + lines = [] + for line in s.split("\n"): + line = line[n:] if line else line + if set(line).issubset({"=", " "}): + line = line.replace("=", "-") + elif set(line).issubset({"-", " "}): + line = line.replace("-", "~") + lines.append(line) + return lines + + return "\n".join( + [ + f"SBCK_{cls.__name__}", + "=" * (5 + len(cls.__name__)), + ( + f"This Adjustment object was auto-generated from the {cls.__name__} " + " object of package SBCK. See :ref:`Experimental wrap of SBCK`." + ), + "", + ( + "The adjust method accepts ref, hist, sim and all arguments listed " + 'below in "Parameters". It also accepts a `multi_dim` argument ' + "specifying the dimension across which to take the 'features' and " + "is valid for multivariate methods only. See :py:func:`xclim.sdba.stack_variables`." + "In the description below, `n_features` is the size of the `multi_dim` " + "dimension. There is no way of specifying parameters across other " + "dimensions for the moment." + ), + "", + *_parse(cls.__doc__), + *_parse(cls.__init__.__doc__), + " Copyright(c) 2021 Yoann Robin.", + ] + ) + + def _generate_SBCK_classes(): # noqa: N802 + classes = [] + for clsname in dir(SBCK): + cls = getattr(SBCK, clsname) + if ( + not clsname.startswith("_") + and isinstance(cls, type) + and hasattr(cls, "fit") + and hasattr(cls, "predict") + ): + doc = _parse_sbck_doc(cls) + classes.append( + type( + f"SBCK_{clsname}", (_SBCKAdjust,), {"sbck": cls, "__doc__": doc} + ) + ) + return classes diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 9734d22..fce999a 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -8,6 +8,7 @@ import datetime as pydt import itertools from collections.abc import Sequence +from enum import IntEnum from inspect import _empty, signature from typing import Any, Callable, NewType, TypeVar @@ -118,6 +119,99 @@ def set_dataset(self, ds: xr.Dataset) -> None: # XC +class InputKind(IntEnum): + """Constants for input parameter kinds. + + For use by external parses to determine what kind of data the indicator expects. + On the creation of an indicator, the appropriate constant is stored in + :py:attr:`xclim.core.indicator.Indicator.parameters`. The integer value is what gets stored in the output + of :py:meth:`xclim.core.indicator.Indicator.json`. + + For developers : for each constant, the docstring specifies the annotation a parameter of an indice function + should use in order to be picked up by the indicator constructor. Notice that we are using the annotation format + as described in `PEP 604 `_, i.e. with '|' indicating a union and without import + objects from `typing`. + """ + + VARIABLE = 0 + """A data variable (DataArray or variable name). + + Annotation : ``xr.DataArray``. + """ + OPTIONAL_VARIABLE = 1 + """An optional data variable (DataArray or variable name). + + Annotation : ``xr.DataArray | None``. The default should be None. + """ + QUANTIFIED = 2 + """A quantity with units, either as a string (scalar), a pint.Quantity (scalar) or a DataArray (with units set). + + Annotation : ``xclim.core.utils.Quantified`` and an entry in the :py:func:`xclim.core.units.declare_units` + decorator. "Quantified" translates to ``str | xr.DataArray | pint.util.Quantity``. + """ + FREQ_STR = 3 + """A string representing an "offset alias", as defined by pandas. + + See the Pandas documentation on :ref:`timeseries.offset_aliases` for a list of valid aliases. + + Annotation : ``str`` + ``freq`` as the parameter name. + """ + NUMBER = 4 + """A number. + + Annotation : ``int``, ``float`` and unions thereof, potentially optional. + """ + STRING = 5 + """A simple string. + + Annotation : ``str`` or ``str | None``. In most cases, this kind of parameter makes sense + with choices indicated in the docstring's version of the annotation with curly braces. + See :ref:`notebooks/extendxclim:Defining new indices`. + """ + DAY_OF_YEAR = 6 + """A date, but without a year, in the MM-DD format. + + Annotation : :py:obj:`xclim.core.utils.DayOfYearStr` (may be optional). + """ + DATE = 7 + """A date in the YYYY-MM-DD format, may include a time. + + Annotation : :py:obj:`xclim.core.utils.DateStr` (may be optional). + """ + NUMBER_SEQUENCE = 8 + """A sequence of numbers + + Annotation : ``Sequence[int]``, ``Sequence[float]`` and unions thereof, may include single ``int`` and ``float``, + may be optional. + """ + BOOL = 9 + """A boolean flag. + + Annotation : ``bool``, may be optional. + """ + DICT = 10 + """A dictionary. + + Annotation : ``dict`` or ``dict | None``, may be optional. + """ + KWARGS = 50 + """A mapping from argument name to value. + + Developers : maps the ``**kwargs``. Please use as little as possible. + """ + DATASET = 70 + """An xarray dataset. + + Developers : as indices only accept DataArrays, this should only be added on the indicator's constructor. + """ + OTHER_PARAMETER = 99 + """An object that fits None of the previous kinds. + + Developers : This is the fallback kind, it will raise an error in xclim's unit tests if used. + """ + + +# XC def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" ds.attrs.update(ref.attrs) @@ -194,7 +288,6 @@ def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: anchor : str, optional Anchor date for bases Y or Q. As xarray doesn't support "W", neither does xclim (anchor information is lost when given). - """ # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) offset = pd.tseries.frequencies.to_offset(freq) @@ -254,49 +347,6 @@ def get_calendar(obj: Any, dim: str = "time") -> str: raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") -# XC -def gen_call_string(funcname: str, *args, **kwargs) -> str: - r"""Generate a signature string for use in the history attribute. - - DataArrays and Dataset are replaced with their name, while Nones, floats, ints and strings are printed directly. - All other objects have their type printed between < >. - - Arguments given through positional arguments are printed positionnally and those - given through keywords are printed prefixed by their name. - - Parameters - ---------- - funcname : str - Name of the function - \*args, \*\*kwargs - Arguments given to the function. - - Example - ------- - >>> A = xr.DataArray([1], dims=("x",), name="A") - >>> gen_call_string("func", A, b=2.0, c="3", d=[10] * 100) - "func(A, b=2.0, c='3', d=)" - """ - elements = [] - chain = itertools.chain(zip([None] * len(args), args), kwargs.items()) - for name, val in chain: - if isinstance(val, xr.DataArray): - rep = val.name or "" - elif isinstance(val, (int, float, str, bool)) or val is None: - rep = repr(val) - else: - rep = repr(val) - if len(rep) > 50: - rep = f"<{type(val).__name__}>" - - if name is not None: - rep = f"{name}={rep}" - - elements.append(rep) - - return f"{funcname}({', '.join(elements)})" - - class Grouper(Parametrizable): """Grouper inherited class for parameterizable classes.""" diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 89f3bbe..de5bbfb 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Formatting Utilities =================================== """ @@ -29,9 +29,9 @@ def merge_attributes( ---------- attribute : str The attribute to merge. - inputs_list : xr.DataArray or xr.Dataset + \*inputs_list : xr.DataArray or xr.Dataset The datasets or variables that were used to produce the new object. - Inputs given that way will be prefixed by their `name` attribute if available. + Inputs given that way will be prefixed by their "name" attribute if available. new_line : str The character to put between each instance of the attributes. Usually, in CF-conventions, the history attributes uses '\\n' while cell_methods uses ' '. @@ -47,9 +47,7 @@ def merge_attributes( str The new attribute made from the combination of the ones from all the inputs. """ - inputs = [] - for in_ds in inputs_list: - inputs.append((getattr(in_ds, "name", None), in_ds)) + inputs = [getattr(in_ds, "name", None) for in_ds in inputs_list] inputs += list(inputs_kws.items()) merged_attr = "" @@ -165,7 +163,11 @@ def _call_and_add_history(*args, **kwargs): # XC -def gen_call_string(funcname: str, *args, **kwargs) -> str: +def gen_call_string( + funcname: str, + *args, + **kwargs, +) -> str: r"""Generate a signature string for use in the history attribute. DataArrays and Dataset are replaced with their name, while Nones, floats, ints and strings are printed directly. @@ -177,9 +179,7 @@ def gen_call_string(funcname: str, *args, **kwargs) -> str: Parameters ---------- funcname : str - Name of the function - \*args, \*\*kwargs - Arguments given to the function. + Name of the function. Example ------- diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index e96eda3..18fc108 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -16,8 +16,11 @@ import pandas as pd import xarray as xr from platformdirs import user_cache_dir +from scipy.stats import gamma from xarray import open_dataset as _open_dataset +from xsdba.utils import equally_spaced_nodes + __all__ = ["test_timelonlatseries", "test_timeseries"] # keeping xclim-testdata for now, since it's still this on gitHub @@ -51,6 +54,32 @@ SocketBlockedError = None +def test_cannon_2015_dist(): # noqa: D103 + # ref ~ gamma(k=4, theta=7.5) mu: 30, sigma: 15 + ref = gamma(4, scale=7.5) + + # hist ~ gamma(k=8.15, theta=3.68) mu: 30, sigma: 10.5 + hist = gamma(8.15, scale=3.68) + + # sim ~ gamma(k=16, theta=2.63) mu: 42, sigma: 10.5 + sim = gamma(16, scale=2.63) + + return ref, hist, sim + + +def test_cannon_2015_rvs(n, random=True): # noqa: D103 + # Frozen distributions + fd = test_cannon_2015_dist() + + if random: + r = [d.rvs(n) for d in fd] + else: + u = equally_spaced_nodes(n, None) + r = [d.ppf(u) for d in fd] + + return map(lambda x: test_timelonlatseries(x, attrs={"units": "kg/m/m/s"}), r) + + def test_timelonlatseries(values, attrs=None, start="2000-01-01"): """Create a DataArray with time, lon and lat dimensions.""" attrs = {} if attrs is None else attrs diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 08c303e..634d9a0 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -7,21 +7,24 @@ from copy import deepcopy from functools import wraps +import pint + # this dependency is "necessary" for convert_units_to # if we only do checks, we could get rid of it -import cf_xarray.units + + +try: + # allows to use cf units + import cf_xarray.units +except ImportError: # noqa: S110 + # cf-xarray is not installed, this will not be used + pass import numpy as np -import pint import xarray as xr from .base import Quantified, copy_all_attrs -# shamelessly adapted from `cf-xarray` (which adopted it from MetPy and xclim itself) -units = deepcopy(cf_xarray.units.units) -# Switch this flag back to False. Not sure what that implies, but it breaks some tests. -units.force_ndarray_like = False # noqa: F841 -# Another alias not included by cf_xarray -units.define("@alias percent = pct") +units = pint.get_application_registry() # XC @@ -120,13 +123,17 @@ def str2pint(val: str) -> pint.Quantity: def extract_units(arg): """Extract units from a string, DataArray, or scalar.""" - if not (isinstance(arg, (str, xr.DataArray)) or np.isscalar(arg)): + if not ( + isinstance(arg, (str, xr.DataArray, pint.Unit, units.Unit)) or np.isscalar(arg) + ): print(arg) raise TypeError( f"Argument must be a str, DataArray, or scalar. Got {type(arg)}" ) elif isinstance(arg, xr.DataArray): ustr = None if "units" not in arg.attrs else arg.attrs["units"] + elif isinstance(arg, pint.Unit | units.Unit): + ustr = f"{arg:cf}" # XC: from pint2cfunits elif isinstance(arg, str): ustr = str2pint(arg).units else: # (scalar case) @@ -219,7 +226,7 @@ def convert_units_to( # noqa: C901 out = source.copy(data=units.convert(source.data, source_unit, target_unit)) out = out.assign_attrs(units=target_unit) else: - out = str2pint(source).to(target_unit) + out = str2pint(source).to(target_unit).m return out diff --git a/tests/conftest.py b/tests/conftest.py index 4be3140..2897a0a 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -21,7 +21,12 @@ from xsdba.testing import TESTDATA_BRANCH from xsdba.testing import open_dataset as _open_dataset -from xsdba.testing import test_timelonlatseries, test_timeseries +from xsdba.testing import ( + test_cannon_2015_dist, + test_cannon_2015_rvs, + test_timelonlatseries, + test_timeseries, +) from xsdba.utils import apply_correction, equally_spaced_nodes # import xclim @@ -65,6 +70,49 @@ # ) +@pytest.fixture +def cannon_2015_rvs(): + return test_cannon_2015_rvs + + +@pytest.fixture +def cannon_2015_dist(): + return test_cannon_2015_dist + + +# @pytest.fixture +# def ref_hist_sim_tuto(socket_enabled): # noqa: F841 +# """Return ref, hist, sim time series of air temperature. + +# socket_enabled is a fixture that enables the use of the internet to download the tutorial dataset while the +# `--disable-socket` flag has been called. This fixture will crash if the `air_temperature` tutorial file is +# not on disk while the internet is unavailable. +# """ + +# def _ref_hist_sim_tuto(sim_offset=3, delta=0.1, smth_win=3, trend=True): +# ds = xr.tutorial.open_dataset("air_temperature") +# ref = ds.air.resample(time="D").mean(keep_attrs=True) +# hist = ref.rolling(time=smth_win, min_periods=1).mean(keep_attrs=True) + delta +# hist.attrs["units"] = ref.attrs["units"] +# sim_time = hist.time + np.timedelta64(730 + sim_offset * 365, "D").astype( +# " np.random.Generator: return np.random.default_rng(seed=list(map(ord, "𝕽𝔞𝖓𝔡𝖔𝔪"))) @@ -102,17 +150,17 @@ def mon_triangular(): # XC (name changed) @pytest.fixture -def mon_timelonlatseries(series, mon_triangular): - def _mon_timelonlatseries(values, name): +def mon_timelonlatseries(timelonlatseries, mon_triangular): + def _mon_timelonlatseries(values, attrs): """Random time series whose mean varies over a monthly cycle.""" - x = timelonlatseries(values, name) + x = timelonlatseries(values, attrs) m = mon_triangular - factor = timelonlatseriesseries(m[x.time.dt.month - 1], name) + factor = timelonlatseries(m[x.time.dt.month - 1], attrs) with xr.set_options(keep_attrs=True): return apply_correction(x, factor, x.kind) - return _mon_series + return _mon_timelonlatseries @pytest.fixture @@ -230,14 +278,14 @@ def _is_matplotlib_installed(): # ADAPT or REMOVE? -# @pytest.fixture(scope="function") -# def atmosds(threadsafe_data_dir) -> xr.Dataset: -# return _open_dataset( -# threadsafe_data_dir.joinpath("atmosds.nc"), -# cache_dir=threadsafe_data_dir, -# branch=helpers.TESTDATA_BRANCH, -# engine="h5netcdf", -# ).load() +@pytest.fixture(scope="function") +def atmosds(threadsafe_data_dir) -> xr.Dataset: + return _open_dataset( + threadsafe_data_dir.joinpath("atmosds.nc"), + cache_dir=threadsafe_data_dir, + branch=TESTDATA_BRANCH, + engine="h5netcdf", + ).load() # @pytest.fixture(scope="function") diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py new file mode 100644 index 0000000..ff9479b --- /dev/null +++ b/tests/test_adjustment.py @@ -0,0 +1,884 @@ +# pylint: disable=no-member +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr +from scipy.stats import genpareto, norm, uniform + +from xsdba import adjustment +from xsdba.adjustment import ( # ExtremeValues, + LOCI, + DetrendedQuantileMapping, + EmpiricalQuantileMapping, + PrincipalComponents, + QuantileDeltaMapping, + Scaling, +) +from xsdba.base import Grouper +from xsdba.options import set_options +from xsdba.processing import ( + jitter_under_thresh, + stack_variables, + uniform_noise_like, + unstack_variables, +) +from xsdba.testing import nancov +from xsdba.units import convert_units_to +from xsdba.utils import ( + ADDITIVE, + MULTIPLICATIVE, + apply_correction, + get_correction, + invert, +) + + +class TestLoci: + @pytest.mark.parametrize("group,dec", (["time", 2], ["time.month", 1])) + def test_time_and_from_ds(self, timelonlatseries, group, dec, tmp_path, random): + n = 10000 + u = random.random(n) + + xd = uniform(loc=0, scale=3) + x = xd.ppf(u) + + attrs = {"units": "kg m-2 s-1", "kind": MULTIPLICATIVE} + + hist = sim = timelonlatseries(x, attrs={"units": "kg m-2 s-1"}) + y = x * 2 + thresh = 2 + ref_fit = timelonlatseries(y, attrs={"units": "kg m-2 s-1"}).where( + y > thresh, 0.1 + ) + ref = timelonlatseries(y, attrs={"units": "kg m-2 s-1"}) + + loci = LOCI.train(ref_fit, hist, group=group, thresh=f"{thresh} kg m-2 s-1") + np.testing.assert_array_almost_equal(loci.ds.hist_thresh, 1, dec) + np.testing.assert_array_almost_equal(loci.ds.af, 2, dec) + + p = loci.adjust(sim) + np.testing.assert_array_almost_equal(p, ref, dec) + + assert "history" in p.attrs + assert "Bias-adjusted with LOCI(" in p.attrs["history"] + + file = tmp_path / "test_loci.nc" + loci.ds.to_netcdf(file) + + ds = xr.open_dataset(file) + loci2 = LOCI.from_dataset(ds) + + xr.testing.assert_equal(loci.ds, loci2.ds) + + p2 = loci2.adjust(sim) + np.testing.assert_array_equal(p, p2) + + # @pytest.mark.requires_internet + # def test_reduce_dims(self, ref_hist_sim_tuto): + # ref, hist, _sim = ref_hist_sim_tuto() + # hist = hist.expand_dims(member=[0, 1]) + # ref = ref.expand_dims(member=hist.member) + # LOCI.train(ref, hist, group="time", thresh="283 K", add_dims=["member"]) + + +@pytest.mark.slow +class TestScaling: + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + def test_time(self, kind, units, timelonlatseries, random): + n = 10000 + u = random.random(n) + + xd = uniform(loc=2, scale=1) + x = xd.ppf(u) + + attrs = {"units": units, "kind": kind} + + hist = sim = timelonlatseries(x, attrs=attrs) + ref = timelonlatseries(apply_correction(x, 2, kind), attrs=attrs) + if kind == ADDITIVE: + ref = convert_units_to(ref, "degC") + + scaling = Scaling.train(ref, hist, group="time", kind=kind) + np.testing.assert_array_almost_equal(scaling.ds.af, 2) + + p = scaling.adjust(sim) + np.testing.assert_array_almost_equal(p, ref) + + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + def test_mon_u( + self, + mon_timelonlatseries, + timelonlatseries, + mon_triangular, + kind, + units, + random, + ): + n = 10000 + u = random.random(n) + + xd = uniform(loc=2, scale=1) + x = xd.ppf(u) + + attrs = {"units": units, "kind": kind} + + hist = sim = timelonlatseries(x, attrs=attrs) + ref = mon_timelonlatseries(apply_correction(x, 2, kind), attrs=attrs) + + # Test train + scaling = Scaling.train(ref, hist, group="time.month", kind=kind) + expected = apply_correction(mon_triangular, 2, kind) + np.testing.assert_array_almost_equal(scaling.ds.af, expected) + + # Test predict + p = scaling.adjust(sim) + np.testing.assert_array_almost_equal(p, ref) + + def test_add_dim(self, timelonlatseries, mon_timelonlatseries, random): + n = 10000 + u = random.random((n, 4)) + + xd = uniform(loc=2, scale=1) + x = xd.ppf(u) + units, kind = "K", ADDITIVE + attrs = {"units": units, "kind": kind} + + hist = sim = timelonlatseries(x, attrs=attrs) + ref = mon_timelonlatseries(apply_correction(x, 2, "+"), attrs=attrs) + + group = Grouper("time.month", add_dims=["lon"]) + + scaling = Scaling.train(ref, hist, group=group, kind="+") + assert "lon" not in scaling.ds + p = scaling.adjust(sim) + assert "lon" in p.dims + np.testing.assert_array_almost_equal(p.transpose(*ref.dims), ref) + + +@pytest.mark.slow +class TestDQM: + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + def test_quantiles(self, timelonlatseries, kind, units, random): + """Train on + hist: U + ref: Normal + + Predict on hist to get ref + """ + ns = 10000 + u = random.random(ns) + + # Define distributions + xd = uniform(loc=10, scale=1) + yd = norm(loc=12, scale=1) + + # Generate random numbers with u so we get exact results for comparison + x = xd.ppf(u) + y = yd.ppf(u) + + # Test train + attrs = {"units": units, "kind": kind} + + hist = sim = timelonlatseries(x, attrs=attrs) + ref = timelonlatseries(y, attrs=attrs) + + DQM = DetrendedQuantileMapping.train( + ref, + hist, + kind=kind, + group="time", + nquantiles=50, + ) + p = DQM.adjust(sim, interp="linear") + + q = DQM.ds.quantiles + ex = apply_correction(xd.ppf(q), invert(xd.mean(), kind), kind) + ey = apply_correction(yd.ppf(q), invert(yd.mean(), kind), kind) + expected = get_correction(ex, ey, kind) + + # Results are not so good at the endpoints + np.testing.assert_array_almost_equal( + DQM.ds.af[:, 2:-2], expected[np.newaxis, 2:-2], 1 + ) + + # Test predict + # Accept discrepancies near extremes + middle = (x > 1e-2) * (x < 0.99) + np.testing.assert_array_almost_equal(p[middle], ref[middle], 1) + + # PB 13-01-21 : This seems the same as the next test. + # Test with sim not equal to hist + # ff = series(np.ones(ns) * 1.1, name) + # sim2 = apply_correction(sim, ff, kind) + # ref2 = apply_correction(ref, ff, kind) + + # p2 = DQM.adjust(sim2, interp="linear") + + # np.testing.assert_array_almost_equal(p2[middle], ref2[middle], 1) + + # Test with actual trend in sim + attrs = {"units": units, "kind": kind} + + trend = timelonlatseries( + np.linspace(-0.2, 0.2, ns) + (1 if kind == MULTIPLICATIVE else 0), + attrs=attrs, + ) + sim3 = apply_correction(sim, trend, kind) + ref3 = apply_correction(ref, trend, kind) + p3 = DQM.adjust(sim3, interp="linear") + np.testing.assert_array_almost_equal(p3[middle], ref3[middle], 1) + + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + @pytest.mark.parametrize("add_dims", [True, False]) + def test_mon_u( + self, mon_timelonlatseries, timelonlatseries, kind, units, add_dims, random + ): + """ + Train on + hist: U + ref: U + monthly cycle + + Predict on hist to get ref + """ + n = 5000 + u = random.random(n) + + # Define distributions + xd = uniform(loc=2, scale=0.1) + yd = uniform(loc=4, scale=0.1) + noise = uniform(loc=0, scale=1e-7) + + # Generate random numbers + x = xd.ppf(u) + y = yd.ppf(u) + noise.ppf(u) + attrs = {"units": units, "kind": kind} + # Test train + hist, ref = timelonlatseries(x, attrs=attrs), mon_timelonlatseries( + y, attrs=attrs + ) + + trend = np.linspace(-0.2, 0.2, n) + int(kind == MULTIPLICATIVE) + ref_t = mon_timelonlatseries(apply_correction(y, trend, kind), attrs=attrs) + sim = timelonlatseries(apply_correction(x, trend, kind), attrs=attrs) + + if add_dims: + ref = ref.expand_dims(lat=[0, 1, 2]).chunk({"lat": 1}) + hist = hist.expand_dims(lat=[0, 1, 2]).chunk({"lat": 1}) + sim = sim.expand_dims(lat=[0, 1, 2]).chunk({"lat": 1}) + ref_t = ref_t.expand_dims(lat=[0, 1, 2]) + + DQM = DetrendedQuantileMapping.train( + ref, hist, kind=kind, group="time.month", nquantiles=5 + ) + mqm = DQM.ds.af.mean(dim="quantiles") + p = DQM.adjust(sim) + + if add_dims: + mqm = mqm.isel(lat=0) + np.testing.assert_array_almost_equal(mqm, int(kind == MULTIPLICATIVE), 1) + np.testing.assert_allclose(p.transpose(..., "time"), ref_t, rtol=0.1, atol=0.5) + + # def test_cannon_and_from_ds(self, cannon_2015_rvs, tmp_path, random): + # ref, hist, sim = cannon_2015_rvs(15000, random=random) + + # DQM = DetrendedQuantileMapping.train(ref, hist, kind="*", group="time") + # p = DQM.adjust(sim) + + # np.testing.assert_almost_equal(p.mean(), 41.6, 0) + # np.testing.assert_almost_equal(p.std(), 15.0, 0) + + # file = tmp_path / "test_dqm.nc" + # DQM.ds.to_netcdf(file) + + # ds = xr.open_dataset(file) + # DQM2 = DetrendedQuantileMapping.from_dataset(ds) + + # xr.testing.assert_equal(DQM.ds, DQM2.ds) + + # p2 = DQM2.adjust(sim) + # np.testing.assert_array_equal(p, p2) + + +@pytest.mark.slow +class TestQDM: + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + def test_quantiles(self, timelonlatseries, kind, units, random): + """Train on + x : U(1,1) + y : U(1,2) + + """ + u = random.random(10000) + + # Define distributions + xd = uniform(loc=1, scale=1) + yd = uniform(loc=2, scale=4) + + # Generate random numbers with u so we get exact results for comparison + x = xd.ppf(u) + y = yd.ppf(u) + + # Test train + attrs = {"units": units, "kind": kind} + hist = sim = timelonlatseries(x, attrs=attrs) + ref = timelonlatseries(y, attrs=attrs) + + QDM = QuantileDeltaMapping.train( + ref.astype("float32"), + hist.astype("float32"), + kind=kind, + group="time", + nquantiles=10, + ) + p = QDM.adjust(sim.astype("float32"), interp="linear") + + q = QDM.ds.coords["quantiles"] + expected = get_correction(xd.ppf(q), yd.ppf(q), kind)[np.newaxis, :] + + # Results are not so good at the endpoints + np.testing.assert_array_almost_equal(QDM.ds.af, expected, 1) + + # Test predict + # Accept discrepancies near extremes + middle = (u > 1e-2) * (u < 0.99) + np.testing.assert_array_almost_equal(p[middle], ref[middle], 1) + + # Test dtype control of map_blocks + assert QDM.ds.af.dtype == "float32" + assert p.dtype == "float32" + + @pytest.mark.parametrize("use_dask", [True, False]) + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + @pytest.mark.parametrize("add_dims", [True, False]) + def test_mon_u( + self, + mon_timelonlatseries, + timelonlatseries, + mon_triangular, + add_dims, + kind, + units, + use_dask, + random, + ): + """ + Train on + hist: U + ref: U + monthly cycle + + Predict on hist to get ref + """ + u = random.random(10000) + + # Define distributions + xd = uniform(loc=1, scale=1) + yd = uniform(loc=2, scale=2) + noise = uniform(loc=0, scale=1e-7) + + # Generate random numbers + x = xd.ppf(u) + y = yd.ppf(u) + noise.ppf(u) + + # Test train + attrs = {"units": units, "kind": kind} + + ref = mon_timelonlatseries(y, attrs=attrs) + hist = sim = timelonlatseries(x, attrs=attrs) + if use_dask: + ref = ref.chunk({"time": -1}) + hist = hist.chunk({"time": -1}) + sim = sim.chunk({"time": -1}) + if add_dims: + ref = ref.expand_dims(site=[0, 1, 2, 3, 4]).drop_vars("site") + hist = hist.expand_dims(site=[0, 1, 2, 3, 4]).drop_vars("site") + sim = sim.expand_dims(site=[0, 1, 2, 3, 4]).drop_vars("site") + sel = {"site": 0} + else: + sel = {} + + QDM = QuantileDeltaMapping.train( + ref, hist, kind=kind, group="time.month", nquantiles=40 + ) + p = QDM.adjust(sim, interp="linear" if kind == "+" else "nearest") + + q = QDM.ds.coords["quantiles"] + expected = get_correction(xd.ppf(q), yd.ppf(q), kind) + + expected = apply_correction( + mon_triangular[:, np.newaxis], expected[np.newaxis, :], kind + ) + np.testing.assert_array_almost_equal( + QDM.ds.af.sel(quantiles=q, **sel), expected, 1 + ) + + # Test predict + np.testing.assert_allclose(p, ref.transpose(*p.dims), rtol=0.1, atol=0.2) + + def test_seasonal(self, timelonlatseries, random): + u = random.random(10000) + kind = "+" + units = "K" + # Define distributions + xd = uniform(loc=1, scale=1) + yd = uniform(loc=2, scale=4) + + # Generate random numbers with u so we get exact results for comparison + x = xd.ppf(u) + y = yd.ppf(u) + + # Test train + attrs = {"units": units, "kind": kind} + + hist = sim = timelonlatseries(x, attrs=attrs) + ref = timelonlatseries(y, attrs=attrs) + + QDM = QuantileDeltaMapping.train( + ref.astype("float32"), + hist.astype("float32"), + kind=kind, + group="time.season", + nquantiles=10, + ) + p = QDM.adjust(sim.astype("float32"), interp="linear") + + # Test predict + # Accept discrepancies near extremes + middle = (u > 1e-2) * (u < 0.99) + np.testing.assert_array_almost_equal(p[middle], ref[middle], 1) + + def test_cannon_and_diagnostics(self, cannon_2015_dist, cannon_2015_rvs): + ref, hist, sim = cannon_2015_rvs(15000, random=False) + + # Quantile mapping + with set_options(sdba_extra_output=True): + QDM = QuantileDeltaMapping.train( + ref, hist, kind="*", group="time", nquantiles=50 + ) + scends = QDM.adjust(sim) + + assert isinstance(scends, xr.Dataset) + + # Theoretical results + # ref, hist, sim = cannon_2015_dist + # u1 = equally_spaced_nodes(1001, None) + # u = np.convolve(u1, [0.5, 0.5], mode="valid") + # pu = ref.ppf(u) * sim.ppf(u) / hist.ppf(u) + # pu1 = ref.ppf(u1) * sim.ppf(u1) / hist.ppf(u1) + # pdf = np.diff(u1) / np.diff(pu1) + + # mean = np.trapz(pdf * pu, pu) + # mom2 = np.trapz(pdf * pu ** 2, pu) + # std = np.sqrt(mom2 - mean ** 2) + bc_sim = scends.scen + np.testing.assert_almost_equal(bc_sim.mean(), 41.5, 1) + np.testing.assert_almost_equal(bc_sim.std(), 16.7, 0) + + +@pytest.mark.slow +class TestQM: + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + def test_quantiles(self, timelonlatseries, kind, units, random): + """Train on + hist: U + ref: Normal + + Predict on hist to get ref + """ + u = random.random(10000) + + # Define distributions + xd = uniform(loc=10, scale=1) + yd = norm(loc=12, scale=1) + + # Generate random numbers with u so we get exact results for comparison + x = xd.ppf(u) + y = yd.ppf(u) + + # Test train + attrs = {"units": units, "kind": kind} + + hist = sim = timelonlatseries(x, attrs={"units": units}) + ref = timelonlatseries(y, attrs={"units": units}) + + QM = EmpiricalQuantileMapping.train( + ref, + hist, + kind=kind, + group="time", + nquantiles=50, + ) + p = QM.adjust(sim, interp="linear") + + q = QM.ds.coords["quantiles"] + expected = get_correction(xd.ppf(q), yd.ppf(q), kind)[np.newaxis, :] + # Results are not so good at the endpoints + np.testing.assert_array_almost_equal(QM.ds.af[:, 2:-2], expected[:, 2:-2], 1) + + # Test predict + # Accept discrepancies near extremes + middle = (x > 1e-2) * (x < 0.99) + np.testing.assert_array_almost_equal(p[middle], ref[middle], 1) + + @pytest.mark.parametrize( + "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] + ) + def test_mon_u( + self, + mon_timelonlatseries, + timelonlatseries, + mon_triangular, + kind, + units, + random, + ): + """ + Train on + hist: U + ref: U + monthly cycle + + Predict on hist to get ref + """ + u = random.random(10000) + + # Define distributions + xd = uniform(loc=2, scale=0.1) + yd = uniform(loc=4, scale=0.1) + noise = uniform(loc=0, scale=1e-7) + + # Generate random numbers + x = xd.ppf(u) + y = yd.ppf(u) + noise.ppf(u) + + # Test train + attrs = {"units": units, "kind": kind} + + hist = sim = timelonlatseries(x, attrs=attrs) + ref = mon_timelonlatseries(y, attrs=attrs) + + QM = EmpiricalQuantileMapping.train( + ref, hist, kind=kind, group="time.month", nquantiles=5 + ) + p = QM.adjust(sim) + mqm = QM.ds.af.mean(dim="quantiles") + expected = apply_correction(mon_triangular, 2, kind) + np.testing.assert_array_almost_equal(mqm, expected, 1) + + # Test predict + np.testing.assert_array_almost_equal(p, ref, 2) + + # @pytest.mark.parametrize("use_dask", [True, False]) + # @pytest.mark.filterwarnings("ignore::RuntimeWarning") + # def test_add_dims(self, use_dask, open_dataset): + # with set_options(sdba_encode_cf=use_dask): + # if use_dask: + # chunks = {"location": -1} + # else: + # chunks = None + # ref = ( + # open_dataset( + # "sdba/ahccd_1950-2013.nc", + # chunks=chunks, + # drop_variables=["lat", "lon"], + # ) + # .sel(time=slice("1981", "2010")) + # .tasmax + # ) + # ref = convert_units_to(ref, "K") + # ref = ref.isel(location=1, drop=True).expand_dims(location=["Amos"]) + + # dsim = open_dataset( + # "sdba/CanESM2_1950-2100.nc", + # chunks=chunks, + # drop_variables=["lat", "lon"], + # ).tasmax + # hist = dsim.sel(time=slice("1981", "2010")) + # sim = dsim.sel(time=slice("2041", "2070")) + + # # With add_dims, "does it run" test + # group = Grouper("time.dayofyear", window=5, add_dims=["location"]) + # EQM = EmpiricalQuantileMapping.train(ref, hist, group=group) + # EQM.adjust(sim).load() + + # # Without, sanity test. + # group = Grouper("time.dayofyear", window=5) + # EQM2 = EmpiricalQuantileMapping.train(ref, hist, group=group) + # scen2 = EQM2.adjust(sim).load() + # assert scen2.sel(location=["Kugluktuk", "Vancouver"]).isnull().all() + + +class TestPrincipalComponents: + @pytest.mark.parametrize( + "group", (Grouper("time.month"), Grouper("time", add_dims=["lon"])) + ) + def test_simple(self, group, random): + n = 15 * 365 + m = 2 # A dummy dimension to test vectorizing. + ref_y = norm.rvs(loc=10, scale=1, size=(m, n), random_state=random) + ref_x = norm.rvs(loc=3, scale=2, size=(m, n), random_state=random) + sim_x = norm.rvs(loc=4, scale=2, size=(m, n), random_state=random) + sim_y = sim_x + norm.rvs(loc=1, scale=1, size=(m, n), random_state=random) + + ref = xr.DataArray( + [ref_x, ref_y], dims=("lat", "lon", "time"), attrs={"units": "degC"} + ) + ref["time"] = xr.cftime_range("1990-01-01", periods=n, calendar="noleap") + sim = xr.DataArray( + [sim_x, sim_y], dims=("lat", "lon", "time"), attrs={"units": "degC"} + ) + sim["time"] = ref["time"] + + PCA = PrincipalComponents.train(ref, sim, group=group, crd_dim="lat") + scen = PCA.adjust(sim) + + def _assert(ds): + cov_ref = nancov(ds.ref.transpose("lat", "pt")) + cov_sim = nancov(ds.sim.transpose("lat", "pt")) + cov_scen = nancov(ds.scen.transpose("lat", "pt")) + + # PC adjustment makes the covariance of scen match the one of ref. + np.testing.assert_allclose(cov_ref - cov_scen, 0, atol=1e-6) + with pytest.raises(AssertionError): + np.testing.assert_allclose(cov_ref - cov_sim, 0, atol=1e-6) + + def _group_assert(ds, dim): + if "lon" not in dim: + for lon in ds.lon: + _assert(ds.sel(lon=lon).stack(pt=dim)) + else: + _assert(ds.stack(pt=dim)) + return ds + + group.apply(_group_assert, {"ref": ref, "sim": sim, "scen": scen}) + + # @pytest.mark.parametrize("use_dask", [True, False]) + # @pytest.mark.parametrize("pcorient", ["full", "simple"]) + # def test_real_data(self, atmosds, use_dask, pcorient): + # ref = stack_variables( + # xr.Dataset( + # {"tasmax": atmosds.tasmax, "tasmin": atmosds.tasmin, "tas": atmosds.tas} + # ) + # ).isel(location=3) + # hist = stack_variables( + # xr.Dataset( + # { + # "tasmax": 1.001 * atmosds.tasmax, + # "tasmin": atmosds.tasmin - 0.25, + # "tas": atmosds.tas + 1, + # } + # ) + # ).isel(location=3) + # with xr.set_options(keep_attrs=True): + # sim = hist + 5 + # sim["time"] = sim.time + np.timedelta64(10, "Y").astype(" 1], q_thresh) +# base[base > qv] = genpareto.rvs( +# c, loc=qv, scale=s, size=base[base > qv].shape, random_state=random +# ) +# return xr.DataArray( +# base, +# dims=("time",), +# coords={ +# "time": xr.cftime_range("1990-01-01", periods=n, calendar="noleap") +# }, +# attrs={"units": "mm/day", "thresh": qv}, +# ) + +# ref = jitter_under_thresh(gen_testdata(-0.1, 2), "1e-3 mm/d") +# hist = jitter_under_thresh(gen_testdata(-0.1, 2), "1e-3 mm/d") +# sim = gen_testdata(-0.15, 2.5) + +# EQM = EmpiricalQuantileMapping.train( +# ref, hist, group="time.dayofyear", nquantiles=15, kind="*" +# ) + +# scen = EQM.adjust(sim) + +# EX = ExtremeValues.train(ref, hist, cluster_thresh=c_thresh, q_thresh=q_thresh) +# qv = (ref.thresh + hist.thresh) / 2 +# np.testing.assert_allclose(EX.ds.thresh, qv, atol=0.15, rtol=0.01) + +# scen2 = EX.adjust(scen, sim, frac=frac, power=power) + +# # What to test??? +# # Test if extreme values of sim are still extreme +# exval = sim > EX.ds.thresh +# assert (scen2.where(exval) > EX.ds.thresh).sum() > ( +# scen.where(exval) > EX.ds.thresh +# ).sum() + +# @pytest.mark.slow +# def test_real_data(self, open_dataset): +# dsim = open_dataset("sdba/CanESM2_1950-2100.nc").chunk() +# dref = open_dataset("sdba/ahccd_1950-2013.nc").chunk() + +# ref = convert_units_to( +# dref.sel(time=slice("1950", "2009")).pr, "mm/d", context="hydro" +# ) +# hist = convert_units_to( +# dsim.sel(time=slice("1950", "2009")).pr, "mm/d", context="hydro" +# ) + +# quantiles = np.linspace(0.01, 0.99, num=50) + +# with xr.set_options(keep_attrs=True): +# ref = ref + uniform_noise_like(ref, low=1e-6, high=1e-3) +# hist = hist + uniform_noise_like(hist, low=1e-6, high=1e-3) + +# EQM = EmpiricalQuantileMapping.train( +# ref, hist, group=Grouper("time.dayofyear", window=31), nquantiles=quantiles +# ) + +# scen = EQM.adjust(hist, interp="linear", extrapolation="constant") + +# EX = ExtremeValues.train(ref, hist, cluster_thresh="1 mm/day", q_thresh=0.97) +# new_scen = EX.adjust(scen, hist, frac=0.000000001) +# new_scen.load() + + +def test_raise_on_multiple_chunks(timelonlatseries): + ref = timelonlatseries(np.arange(730).astype(float)).chunk({"time": 365}) + with pytest.raises(ValueError): + EmpiricalQuantileMapping.train(ref, ref, group=Grouper("time.month")) + + +def test_default_grouper_understood(timelonlatseries): + attrs = {"units": "K", "kind": ADDITIVE} + + ref = timelonlatseries(np.arange(730).astype(float), attrs={"units": "K"}) + + EQM = EmpiricalQuantileMapping.train(ref, ref) + EQM.adjust(ref) + assert EQM.group.dim == "time" + + +class TestSBCKutils: + @pytest.mark.slow + @pytest.mark.parametrize( + "method", + [m for m in dir(adjustment) if m.startswith("SBCK_")], + ) + @pytest.mark.parametrize("use_dask", [True]) # do we gain testing both? + def test_sbck(self, method, use_dask, random): + SBCK = pytest.importorskip("SBCK", minversion="0.4.0") + + n = 10 * 365 + m = 2 # A dummy dimension to test vectorization. + ref_y = norm.rvs(loc=10, scale=1, size=(m, n), random_state=random) + ref_x = norm.rvs(loc=3, scale=2, size=(m, n), random_state=random) + hist_x = norm.rvs(loc=11, scale=1.2, size=(m, n), random_state=random) + hist_y = norm.rvs(loc=4, scale=2.2, size=(m, n), random_state=random) + sim_x = norm.rvs(loc=12, scale=2, size=(m, n), random_state=random) + sim_y = norm.rvs(loc=3, scale=1.8, size=(m, n), random_state=random) + + ref = xr.Dataset( + { + "tasmin": xr.DataArray( + ref_x, dims=("lon", "time"), attrs={"units": "degC"} + ), + "tasmax": xr.DataArray( + ref_y, dims=("lon", "time"), attrs={"units": "degC"} + ), + } + ) + ref["time"] = xr.cftime_range("1990-01-01", periods=n, calendar="noleap") + + hist = xr.Dataset( + { + "tasmin": xr.DataArray( + hist_x, dims=("lon", "time"), attrs={"units": "degC"} + ), + "tasmax": xr.DataArray( + hist_y, dims=("lon", "time"), attrs={"units": "degC"} + ), + } + ) + hist["time"] = ref["time"] + + sim = xr.Dataset( + { + "tasmin": xr.DataArray( + sim_x, dims=("lon", "time"), attrs={"units": "degC"} + ), + "tasmax": xr.DataArray( + sim_y, dims=("lon", "time"), attrs={"units": "degC"} + ), + } + ) + sim["time"] = xr.cftime_range("2090-01-01", periods=n, calendar="noleap") + + if use_dask: + ref = ref.chunk({"lon": 1}) + hist = hist.chunk({"lon": 1}) + sim = sim.chunk({"lon": 1}) + + if "TSMBC" in method: + kws = {"lag": 1} + elif "MBCn" in method: + kws = {"metric": SBCK.metrics.energy} + else: + kws = {} + + scen = getattr(adjustment, method).adjust( + stack_variables(ref), + stack_variables(hist), + stack_variables(sim), + multi_dim="multivar", + **kws, + ) + unstack_variables(scen).load() From b59911ce6c77da698dfda0f5880ee8f10213c379 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Tue, 30 Jul 2024 20:09:46 -0400 Subject: [PATCH 025/105] PASSED: test_properties.py (pytest.warning remain) --- pyproject.toml | 5 +- src/xsdba/__init__.py | 11 +- src/xsdba/base.py | 180 +-- src/xsdba/calendar.py | 1663 ++++++++++++++++++++++ src/xsdba/datachecks.py | 123 ++ src/xsdba/formatting.py | 493 ++++++- src/xsdba/locales.py | 331 +++++ src/xsdba/logging.py | 4 + src/xsdba/options.py | 24 +- src/xsdba/processing.py | 4 +- src/xsdba/properties.py | 1577 ++++++++++++++++++++ src/xsdba/typing.py | 133 ++ src/xsdba/units.py | 330 +++-- src/xsdba/utils.py | 54 +- src/xsdba/xclim_submodules/generic.py | 941 ++++++++++++ src/xsdba/xclim_submodules/run_length.py | 1538 ++++++++++++++++++++ src/xsdba/xclim_submodules/stats.py | 622 ++++++++ tests/test_properties.py | 577 ++++++++ 18 files changed, 8373 insertions(+), 237 deletions(-) create mode 100644 src/xsdba/calendar.py create mode 100644 src/xsdba/datachecks.py create mode 100644 src/xsdba/locales.py create mode 100644 src/xsdba/properties.py create mode 100644 src/xsdba/typing.py create mode 100644 src/xsdba/xclim_submodules/generic.py create mode 100644 src/xsdba/xclim_submodules/run_length.py create mode 100644 src/xsdba/xclim_submodules/stats.py create mode 100644 tests/test_properties.py diff --git a/pyproject.toml b/pyproject.toml index 108a79d..455fdf2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -309,7 +309,10 @@ ignore = [ "N806", "PTH123", "S310", - "PERF401" # don't force list comprehensions + "PERF401", # don't force list comprehensions + "PERF203", # allow try/except in loop + "E501", # line too long + "W505" # doc line too long ] preview = true select = [ diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 9554388..20483b4 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -20,7 +20,16 @@ from __future__ import annotations -from . import adjustment, base, detrending, processing, testing, units, utils +from . import ( + adjustment, + base, + detrending, + processing, + properties, + testing, + units, + utils, +) # , adjustment # from . import adjustment, base, detrending, measures, processing, properties, utils diff --git a/src/xsdba/base.py b/src/xsdba/base.py index fce999a..293876f 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -8,7 +8,6 @@ import datetime as pydt import itertools from collections.abc import Sequence -from enum import IntEnum from inspect import _empty, signature from typing import Any, Callable, NewType, TypeVar @@ -19,19 +18,10 @@ import pandas as pd import xarray as xr from boltons.funcutils import wraps -from pint import Quantity from xsdba.options import OPTIONS, SDBA_ENCODE_CF -# XC: -#: Type annotation for strings representing full dates (YYYY-MM-DD), may include time. -DateStr = NewType("DateStr", str) - -#: Type annotation for strings representing dates without a year (MM-DD). -DayOfYearStr = NewType("DayOfYearStr", str) - -#: Type annotation for thresholds and other not-exactly-a-variable quantities -Quantified = TypeVar("Quantified", xr.DataArray, str, Quantity) +from .typing import InputKind # ## Base class for the sdba module @@ -116,112 +106,6 @@ def set_dataset(self, ds: xr.Dataset) -> None: self.ds.attrs[self._attribute] = jsonpickle.encode(self) -# XC - - -class InputKind(IntEnum): - """Constants for input parameter kinds. - - For use by external parses to determine what kind of data the indicator expects. - On the creation of an indicator, the appropriate constant is stored in - :py:attr:`xclim.core.indicator.Indicator.parameters`. The integer value is what gets stored in the output - of :py:meth:`xclim.core.indicator.Indicator.json`. - - For developers : for each constant, the docstring specifies the annotation a parameter of an indice function - should use in order to be picked up by the indicator constructor. Notice that we are using the annotation format - as described in `PEP 604 `_, i.e. with '|' indicating a union and without import - objects from `typing`. - """ - - VARIABLE = 0 - """A data variable (DataArray or variable name). - - Annotation : ``xr.DataArray``. - """ - OPTIONAL_VARIABLE = 1 - """An optional data variable (DataArray or variable name). - - Annotation : ``xr.DataArray | None``. The default should be None. - """ - QUANTIFIED = 2 - """A quantity with units, either as a string (scalar), a pint.Quantity (scalar) or a DataArray (with units set). - - Annotation : ``xclim.core.utils.Quantified`` and an entry in the :py:func:`xclim.core.units.declare_units` - decorator. "Quantified" translates to ``str | xr.DataArray | pint.util.Quantity``. - """ - FREQ_STR = 3 - """A string representing an "offset alias", as defined by pandas. - - See the Pandas documentation on :ref:`timeseries.offset_aliases` for a list of valid aliases. - - Annotation : ``str`` + ``freq`` as the parameter name. - """ - NUMBER = 4 - """A number. - - Annotation : ``int``, ``float`` and unions thereof, potentially optional. - """ - STRING = 5 - """A simple string. - - Annotation : ``str`` or ``str | None``. In most cases, this kind of parameter makes sense - with choices indicated in the docstring's version of the annotation with curly braces. - See :ref:`notebooks/extendxclim:Defining new indices`. - """ - DAY_OF_YEAR = 6 - """A date, but without a year, in the MM-DD format. - - Annotation : :py:obj:`xclim.core.utils.DayOfYearStr` (may be optional). - """ - DATE = 7 - """A date in the YYYY-MM-DD format, may include a time. - - Annotation : :py:obj:`xclim.core.utils.DateStr` (may be optional). - """ - NUMBER_SEQUENCE = 8 - """A sequence of numbers - - Annotation : ``Sequence[int]``, ``Sequence[float]`` and unions thereof, may include single ``int`` and ``float``, - may be optional. - """ - BOOL = 9 - """A boolean flag. - - Annotation : ``bool``, may be optional. - """ - DICT = 10 - """A dictionary. - - Annotation : ``dict`` or ``dict | None``, may be optional. - """ - KWARGS = 50 - """A mapping from argument name to value. - - Developers : maps the ``**kwargs``. Please use as little as possible. - """ - DATASET = 70 - """An xarray dataset. - - Developers : as indices only accept DataArrays, this should only be added on the indicator's constructor. - """ - OTHER_PARAMETER = 99 - """An object that fits None of the previous kinds. - - Developers : This is the fallback kind, it will raise an error in xclim's unit tests if used. - """ - - -# XC -def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): - """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" - ds.attrs.update(ref.attrs) - extras = ds.variables if isinstance(ds, xr.Dataset) else ds.coords - others = ref.variables if isinstance(ref, xr.Dataset) else ref.coords - for name, var in extras.items(): - if name in others: - var.attrs.update(ref[name].attrs) - - # XC put here to avoid circular import def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: r"""Evaluate whether dask is installed and array is loaded as a dask array. @@ -1020,3 +904,65 @@ def _apply_on_group(dsblock, **kwargs): return wrapper return _decorator + + +def infer_kind_from_parameter(param) -> InputKind: + """Return the appropriate InputKind constant from an ``inspect.Parameter`` object. + + Parameters + ---------- + param : Parameter + + Notes + ----- + The correspondence between parameters and kinds is documented in :py:class:`xclim.core.utils.InputKind`. + """ + if param.annotation is not _empty: + annot = set( + param.annotation.replace("xarray.", "").replace("xr.", "").split(" | ") + ) + else: + annot = {"no_annotation"} + + if "DataArray" in annot and "None" not in annot and param.default is not None: + return InputKind.VARIABLE + + annot = annot - {"None"} + + if "DataArray" in annot: + return InputKind.OPTIONAL_VARIABLE + + if param.name == "freq": + return InputKind.FREQ_STR + + if param.kind == param.VAR_KEYWORD: + return InputKind.KWARGS + + if annot == {"Quantified"}: + return InputKind.QUANTIFIED + + if "DayOfYearStr" in annot: + return InputKind.DAY_OF_YEAR + + if annot.issubset({"int", "float"}): + return InputKind.NUMBER + + if annot.issubset({"int", "float", "Sequence[int]", "Sequence[float]"}): + return InputKind.NUMBER_SEQUENCE + + if annot.issuperset({"str"}): + return InputKind.STRING + + if annot == {"DateStr"}: + return InputKind.DATE + + if annot == {"bool"}: + return InputKind.BOOL + + if annot == {"dict"}: + return InputKind.DICT + + if annot == {"Dataset"}: + return InputKind.DATASET + + return InputKind.OTHER_PARAMETER diff --git a/src/xsdba/calendar.py b/src/xsdba/calendar.py new file mode 100644 index 0000000..e32cdcd --- /dev/null +++ b/src/xsdba/calendar.py @@ -0,0 +1,1663 @@ +""" +Calendar Handling Utilities +=========================== + +Helper function to handle dates, times and different calendars with xarray. +""" + +from __future__ import annotations + +import datetime as pydt +from collections.abc import Sequence +from typing import Any, TypeVar +from warnings import warn + +import cftime +import numpy as np +import pandas as pd +import xarray as xr +from xarray.coding.cftime_offsets import to_cftime_datetime +from xarray.coding.cftimeindex import CFTimeIndex +from xarray.core import dtypes +from xarray.core.resample import DataArrayResample, DatasetResample + +from .base import uses_dask +from .formatting import update_xsdba_history +from .typing import DayOfYearStr + +__all__ = [ + "DayOfYearStr", + "adjust_doy_calendar", + "build_climatology_bounds", + "climatological_mean_doy", + "common_calendar", + "compare_offsets", + "construct_offset", + "convert_calendar", + "convert_doy", + "date_range", + "date_range_like", + "datetime_to_decimal_year", + "days_in_year", + "days_since_to_doy", + "doy_from_string", + "doy_to_days_since", + "ensure_cftime_array", + "get_calendar", + "interp_calendar", + "is_offset_divisor", + "max_doy", + "parse_offset", + "percentile_doy", + "resample_doy", + "select_time", + "stack_periods", + "time_bnds", + "uniform_calendars", + "unstack_periods", + "within_bnds_doy", +] + +# Maximum day of year in each calendar. +max_doy = { + "standard": 366, + "gregorian": 366, + "proleptic_gregorian": 366, + "julian": 366, + "noleap": 365, + "365_day": 365, + "all_leap": 366, + "366_day": 366, + "360_day": 360, +} + +# Some xclim.core.utils functions made accessible here for backwards compatibility reasons. +datetime_classes = cftime._cftime.DATE_TYPES + +# Names of calendars that have the same number of days for all years +uniform_calendars = ("noleap", "all_leap", "365_day", "366_day", "360_day") + + +DataType = TypeVar("DataType", xr.DataArray, xr.Dataset) + + +def _get_usecf_and_warn(calendar: str, xcfunc: str, xrfunc: str): + if calendar == "default": + calendar = "standard" + use_cftime = False + msg = " and use use_cftime=False instead of calendar='default' to get numpy objects." + else: + use_cftime = None + msg = "" + warn( + f"`xclim` function {xcfunc} is deprecated in favour of {xrfunc} and will be removed in v0.51.0. Please adjust your script{msg}.", + FutureWarning, + ) + return calendar, use_cftime + + +def days_in_year(year: int, calendar: str = "proleptic_gregorian") -> int: + """Deprecated : use :py:func:`xarray.coding.calendar_ops._days_in_year` instead. Passing use_cftime=False instead of calendar='default'. + + Return the number of days in the input year according to the input calendar. + """ + calendar, usecf = _get_usecf_and_warn( + calendar, "days_in_year", "xarray.coding.calendar_ops._days_in_year" + ) + return xr.coding.calendar_ops._days_in_year(year, calendar, use_cftime=usecf) + + +def doy_from_string(doy: DayOfYearStr, year: int, calendar: str) -> int: + """Return the day-of-year corresponding to a "MM-DD" string for a given year and calendar.""" + MM, DD = doy.split("-") + return datetime_classes[calendar](year, int(MM), int(DD)).timetuple().tm_yday + + +def date_range(*args, **kwargs) -> pd.DatetimeIndex | CFTimeIndex: + """Deprecated : use :py:func:`xarray.date_range` instead. Passing use_cftime=False instead of calendar='default'. + + Wrap a Pandas date_range object. + + Uses pd.date_range (if calendar == 'default') or xr.cftime_range (otherwise). + """ + calendar, usecf = _get_usecf_and_warn( + kwargs.pop("calendar", "default"), "date_range", "xarray.date_range" + ) + return xr.date_range(*args, calendar=calendar, use_cftime=usecf, **kwargs) + + +def get_calendar(obj: Any, dim: str = "time") -> str: + """Return the calendar of an object. + + Parameters + ---------- + obj : Any + An object defining some date. + If `obj` is an array/dataset with a datetime coordinate, use `dim` to specify its name. + Values must have either a datetime64 dtype or a cftime dtype. + `obj` can also be a python datetime.datetime, a cftime object or a pandas Timestamp + or an iterable of those, in which case the calendar is inferred from the first value. + dim : str + Name of the coordinate to check (if `obj` is a DataArray or Dataset). + + Raises + ------ + ValueError + If no calendar could be inferred. + + Returns + ------- + str + The Climate and Forecasting (CF) calendar name. + Will always return "standard" instead of "gregorian", following CF conventions 1.9. + """ + if isinstance(obj, (xr.DataArray, xr.Dataset)): + return obj[dim].dt.calendar + elif isinstance(obj, xr.CFTimeIndex): + obj = obj.values[0] + else: + obj = np.take(obj, 0) + # Take zeroth element, overcome cases when arrays or lists are passed. + if isinstance(obj, pydt.datetime): # Also covers pandas Timestamp + return "standard" + if isinstance(obj, cftime.datetime): + if obj.calendar == "gregorian": + return "standard" + return obj.calendar + + raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") + + +def common_calendar(calendars: Sequence[str], join="outer") -> str: + """Return a calendar common to all calendars from a list. + + Uses the hierarchy: 360_day < noleap < standard < all_leap. + Returns "default" only if all calendars are "default." + + Parameters + ---------- + calendars: Sequence of string + List of calendar names. + join : {'inner', 'outer'} + The criterion for the common calendar. + + - 'outer': the common calendar is the smallest calendar (in number of days by year) that will include all the + dates of the other calendars. + When converting the data to this calendar, no timeseries will lose elements, but some + might be missing (gaps or NaNs in the series). + - 'inner': the common calendar is the smallest calendar of the list. + When converting the data to this calendar, no timeseries will have missing elements (no gaps or NaNs), + but some might be dropped. + + Examples + -------- + >>> common_calendar(["360_day", "noleap", "default"], join="outer") + 'standard' + >>> common_calendar(["360_day", "noleap", "default"], join="inner") + '360_day' + """ + if all(cal == "default" for cal in calendars): + return "default" + + trans = { + "proleptic_gregorian": "standard", + "gregorian": "standard", + "default": "standard", + "366_day": "all_leap", + "365_day": "noleap", + "julian": "standard", + } + ranks = {"360_day": 0, "noleap": 1, "standard": 2, "all_leap": 3} + calendars = sorted([trans.get(cal, cal) for cal in calendars], key=ranks.get) + + if join == "outer": + return calendars[-1] + if join == "inner": + return calendars[0] + raise NotImplementedError(f"Unknown join criterion `{join}`.") + + +def _convert_doy_date(doy: int, year: int, src, tgt): + fracpart = doy - int(doy) + date = src(year, 1, 1) + pydt.timedelta(days=int(doy - 1)) + try: + same_date = tgt(date.year, date.month, date.day) + except ValueError: + return np.nan + else: + if tgt is pydt.datetime: + return float(same_date.timetuple().tm_yday) + fracpart + return float(same_date.dayofyr) + fracpart + + +def convert_doy( + source: xr.DataArray | xr.Dataset, + target_cal: str, + source_cal: str | None = None, + align_on: str = "year", + missing: Any = np.nan, + dim: str = "time", +) -> xr.DataArray: + """Convert the calendar of day of year (doy) data. + + Parameters + ---------- + source : xr.DataArray or xr.Dataset + Day of year data (range [1, 366], max depending on the calendar). + If a Dataset, the function is mapped to each variables with attribute `is_day_of_year == 1`. + target_cal : str + Name of the calendar to convert to. + source_cal : str, optional + Calendar the doys are in. If not given, uses the "calendar" attribute of `source` or, + if absent, the calendar of its `dim` axis. + align_on : {'date', 'year'} + If 'year' (default), the doy is seen as a "percentage" of the year and is simply rescaled unto the new doy range. + This always result in floating point data, changing the decimal part of the value. + if 'date', the doy is seen as a specific date. See notes. This never changes the decimal part of the value. + missing : Any + If `align_on` is "date" and the new doy doesn't exist in the new calendar, this value is used. + dim : str + Name of the temporal dimension. + """ + if isinstance(source, xr.Dataset): + return source.map( + lambda da: ( + da + if da.attrs.get("is_dayofyear") != 1 + else convert_doy( + da, + target_cal, + source_cal=source_cal, + align_on=align_on, + missing=missing, + dim=dim, + ) + ) + ) + + source_cal = source_cal or source.attrs.get("calendar", get_calendar(source[dim])) + is_calyear = xr.infer_freq(source[dim]) in ("YS-JAN", "Y-DEC", "YE-DEC") + + if is_calyear: # Fast path + year_of_the_doy = source[dim].dt.year + else: # Doy might refer to a date from the year after the timestamp. + year_of_the_doy = source[dim].dt.year + 1 * (source < source[dim].dt.dayofyear) + + if align_on == "year": + if source_cal in ["noleap", "all_leap", "360_day"]: + max_doy_src = max_doy[source_cal] + else: + max_doy_src = xr.apply_ufunc( + xr.coding.calendar_ops._days_in_year, + year_of_the_doy, + vectorize=True, + dask="parallelized", + kwargs={"calendar": source_cal}, + ) + if target_cal in ["noleap", "all_leap", "360_day"]: + max_doy_tgt = max_doy[target_cal] + else: + max_doy_tgt = xr.apply_ufunc( + xr.coding.calendar_ops._days_in_year, + year_of_the_doy, + vectorize=True, + dask="parallelized", + kwargs={"calendar": target_cal}, + ) + new_doy = source.copy(data=source * max_doy_tgt / max_doy_src) + elif align_on == "date": + new_doy = xr.apply_ufunc( + _convert_doy_date, + source, + year_of_the_doy, + vectorize=True, + dask="parallelized", + kwargs={ + "src": datetime_classes[source_cal], + "tgt": datetime_classes[target_cal], + }, + ) + else: + raise NotImplementedError('"align_on" must be one of "date" or "year".') + return new_doy.assign_attrs(is_dayofyear=np.int32(1), calendar=target_cal) + + +def convert_calendar( + source: xr.DataArray | xr.Dataset, + target: xr.DataArray | str, + align_on: str | None = None, + missing: Any | None = None, + doy: bool | str = False, + dim: str = "time", +) -> DataType: + """Deprecated : use :py:meth:`xarray.Dataset.convert_calendar` or :py:meth:`xarray.DataArray.convert_calendar` + or :py:func:`xarray.coding.calendar_ops.convert_calendar` instead. Passing use_cftime=False instead of calendar='default'. + + Convert a DataArray/Dataset to another calendar using the specified method. + """ + if isinstance(target, xr.DataArray): + raise NotImplementedError( + "In `xclim` v0.50.0, `convert_calendar` is a direct copy of `xarray.coding.calendar_ops.convert_calendar`. " + "To retrieve the previous behaviour with target as a DataArray, convert the source first then reindex to the target." + ) + if doy is not False: + raise NotImplementedError( + "In `xclim` v0.50.0, `convert_calendar` is a direct copy of `xarray.coding.calendar_ops.convert_calendar`. " + "To retrieve the previous behaviour of doy=True, do convert_doy(obj, target_cal).convert_cal(target_cal)." + ) + target, _usecf = _get_usecf_and_warn( + target, + "convert_calendar", + "xarray.coding.calendar_ops.convert_calendar or obj.convert_calendar", + ) + return xr.coding.calendar_ops.convert_calendar( + source, target, dim=dim, align_on=align_on, missing=missing + ) + + +def interp_calendar( + source: xr.DataArray | xr.Dataset, + target: xr.DataArray, + dim: str = "time", +) -> xr.DataArray | xr.Dataset: + """Deprecated : use :py:func:`xarray.coding.calendar_ops.interp_calendar` instead. + + Interpolates a DataArray/Dataset to another calendar based on decimal year measure. + """ + _, _ = _get_usecf_and_warn( + "standard", "interp_calendar", "xarray.coding.calendar_ops.interp_calendar" + ) + return xr.coding.calendar_ops.interp_calendar(source, target, dim=dim) + + +def ensure_cftime_array(time: Sequence) -> np.ndarray | Sequence[cftime.datetime]: + """Convert an input 1D array to a numpy array of cftime objects. + + Python's datetime are converted to cftime.DatetimeGregorian ("standard" calendar). + + Parameters + ---------- + time : sequence + A 1D array of datetime-like objects. + + Returns + ------- + np.ndarray + + Raises + ------ + ValueError: When unable to cast the input. + """ + if isinstance(time, xr.DataArray): + time = time.indexes["time"] + elif isinstance(time, np.ndarray): + time = pd.DatetimeIndex(time) + if isinstance(time, xr.CFTimeIndex): + return time.values + if isinstance(time[0], cftime.datetime): + return time + if isinstance(time[0], pydt.datetime): + return np.array( + [cftime.DatetimeGregorian(*ele.timetuple()[:6]) for ele in time] + ) + raise ValueError("Unable to cast array to cftime dtype") + + +def datetime_to_decimal_year(times: xr.DataArray, calendar: str = "") -> xr.DataArray: + """Deprecated : use :py:func:`xarray.coding.calendar_ops_datetime_to_decimal_year` instead. + + Convert a datetime xr.DataArray to decimal years according to its calendar or the given one. + """ + _, _ = _get_usecf_and_warn( + "standard", + "datetime_to_decimal_year", + "xarray.coding.calendar_ops._datetime_to_decimal_year", + ) + return xr.coding.calendar_ops._datetime_to_decimal_year( + times, dim="time", calendar=calendar + ) + + +@update_xsdba_history +def percentile_doy( + arr: xr.DataArray, + window: int = 5, + per: float | Sequence[float] = 10.0, + alpha: float = 1.0 / 3.0, + beta: float = 1.0 / 3.0, + copy: bool = True, +) -> xr.DataArray: + """Percentile value for each day of the year. + + Return the climatological percentile over a moving window around each day of the year. Different quantile estimators + can be used by specifying `alpha` and `beta` according to specifications given by :cite:t:`hyndman_sample_1996`. + The default definition corresponds to method 8, which meets multiple desirable statistical properties for sample + quantiles. Note that `numpy.percentile` corresponds to method 7, with alpha and beta set to 1. + + Parameters + ---------- + arr : xr.DataArray + Input data, a daily frequency (or coarser) is required. + window : int + Number of time-steps around each day of the year to include in the calculation. + per : float or sequence of floats + Percentile(s) between [0, 100] + alpha : float + Plotting position parameter. + beta : float + Plotting position parameter. + copy : bool + If True (default) the input array will be deep-copied. It's a necessary step + to keep the data integrity, but it can be costly. + If False, no copy is made of the input array. It will be mutated and rendered + unusable but performances may significantly improve. + Put this flag to False only if you understand the consequences. + + Returns + ------- + xr.DataArray + The percentiles indexed by the day of the year. + For calendars with 366 days, percentiles of doys 1-365 are interpolated to the 1-366 range. + + References + ---------- + :cite:cts:`hyndman_sample_1996` + """ + from .utils import calc_perc # pylint: disable=import-outside-toplevel + + # Ensure arr sampling frequency is daily or coarser + # but cowardly escape the non-inferrable case. + if compare_offsets(xr.infer_freq(arr.time) or "D", "<", "D"): + raise ValueError("input data should have daily or coarser frequency") + + rr = arr.rolling(min_periods=1, center=True, time=window).construct("window") + + crd = xr.Coordinates.from_pandas_multiindex( + pd.MultiIndex.from_arrays( + (rr.time.dt.year.values, rr.time.dt.dayofyear.values), + names=("year", "dayofyear"), + ), + "time", + ) + rr = rr.drop_vars("time").assign_coords(crd) + rrr = rr.unstack("time").stack(stack_dim=("year", "window")) + + if rrr.chunks is not None and len(rrr.chunks[rrr.get_axis_num("stack_dim")]) > 1: + # Preserve chunk size + time_chunks_count = len(arr.chunks[arr.get_axis_num("time")]) + doy_chunk_size = np.ceil(len(rrr.dayofyear) / (window * time_chunks_count)) + rrr = rrr.chunk(dict(stack_dim=-1, dayofyear=doy_chunk_size)) + + if np.isscalar(per): + per = [per] + + p = xr.apply_ufunc( + calc_perc, + rrr, + input_core_dims=[["stack_dim"]], + output_core_dims=[["percentiles"]], + keep_attrs=True, + kwargs=dict(percentiles=per, alpha=alpha, beta=beta, copy=copy), + dask="parallelized", + output_dtypes=[rrr.dtype], + dask_gufunc_kwargs=dict(output_sizes={"percentiles": len(per)}), + ) + p = p.assign_coords(percentiles=xr.DataArray(per, dims=("percentiles",))) + + # The percentile for the 366th day has a sample size of 1/4 of the other days. + # To have the same sample size, we interpolate the percentile from 1-365 doy range to 1-366 + if p.dayofyear.max() == 366: + p = adjust_doy_calendar(p.sel(dayofyear=(p.dayofyear < 366)), arr) + + p.attrs.update(arr.attrs.copy()) + + # Saving percentile attributes + p.attrs["climatology_bounds"] = build_climatology_bounds(arr) + p.attrs["window"] = window + p.attrs["alpha"] = alpha + p.attrs["beta"] = beta + return p.rename("per") + + +def build_climatology_bounds(da: xr.DataArray) -> list[str]: + """Build the climatology_bounds property with the start and end dates of input data. + + Parameters + ---------- + da : xr.DataArray + The input data. + Must have a time dimension. + """ + n = len(da.time) + return da.time[0 :: n - 1].dt.strftime("%Y-%m-%d").values.tolist() + + +def compare_offsets(freqA: str, op: str, freqB: str) -> bool: + """Compare offsets string based on their approximate length, according to a given operator. + + Offset are compared based on their length approximated for a period starting + after 1970-01-01 00:00:00. If the offsets are from the same category (same first letter), + only the multiplier prefix is compared (QS-DEC == QS-JAN, MS < 2MS). + "Business" offsets are not implemented. + + Parameters + ---------- + freqA : str + RHS Date offset string ('YS', '1D', 'QS-DEC', ...) + op : {'<', '<=', '==', '>', '>=', '!='} + Operator to use. + freqB : str + LHS Date offset string ('YS', '1D', 'QS-DEC', ...) + + Returns + ------- + bool + freqA op freqB + """ + from ..indices.generic import get_op # pylint: disable=import-outside-toplevel + + # Get multiplier and base frequency + t_a, b_a, _, _ = parse_offset(freqA) + t_b, b_b, _, _ = parse_offset(freqB) + + if b_a != b_b: + # Different base freq, compare length of first period after beginning of time. + t = pd.date_range("1970-01-01T00:00:00.000", periods=2, freq=freqA) + t_a = (t[1] - t[0]).total_seconds() + t = pd.date_range("1970-01-01T00:00:00.000", periods=2, freq=freqB) + t_b = (t[1] - t[0]).total_seconds() + # else Same base freq, compare multiplier only. + + return get_op(op)(t_a, t_b) + + +def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: + """Parse an offset string. + + Parse a frequency offset and, if needed, convert to cftime-compatible components. + + Parameters + ---------- + freq : str + Frequency offset. + + Returns + ------- + multiplier : int + Multiplier of the base frequency. "[n]W" is always replaced with "[7n]D", + as xarray doesn't support "W" for cftime indexes. + offset_base : str + Base frequency. + is_start_anchored : bool + Whether coordinates of this frequency should correspond to the beginning of the period (`True`) + or its end (`False`). Can only be False when base is Y, Q or M; in other words, xclim assumes frequencies finer + than monthly are all start-anchored. + anchor : str, optional + Anchor date for bases Y or Q. As xarray doesn't support "W", + neither does xclim (anchor information is lost when given). + + """ + # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) + offset = pd.tseries.frequencies.to_offset(freq) + base, *anchor = offset.name.split("-") + anchor = anchor[0] if len(anchor) > 0 else None + start = ("S" in base) or (base[0] not in "AYQM") + if base.endswith("S") or base.endswith("E"): + base = base[:-1] + mult = offset.n + if base == "W": + mult = 7 * mult + base = "D" + anchor = None + return mult, base, start, anchor + + +def construct_offset(mult: int, base: str, start_anchored: bool, anchor: str | None): + """Reconstruct an offset string from its parts. + + Parameters + ---------- + mult : int + The period multiplier (>= 1). + base : str + The base period string (one char). + start_anchored : bool + If True and base in [Y, Q, M], adds the "S" flag, False add "E". + anchor : str, optional + The month anchor of the offset. Defaults to JAN for bases YS and QS and to DEC for bases YE and QE. + + Returns + ------- + str + An offset string, conformant to pandas-like naming conventions. + + Notes + ----- + This provides the mirror opposite functionality of :py:func:`parse_offset`. + """ + start = ("S" if start_anchored else "E") if base in "YAQM" else "" + if anchor is None and base in "AQY": + anchor = "JAN" if start_anchored else "DEC" + return ( + f"{mult if mult > 1 else ''}{base}{start}{'-' if anchor else ''}{anchor or ''}" + ) + + +def is_offset_divisor(divisor: str, offset: str): + """Check that divisor is a divisor of offset. + + A frequency is a "divisor" of another if a whole number of periods of the + former fit within a single period of the latter. + + Parameters + ---------- + divisor : str + The divisor frequency. + offset: str + The large frequency. + + Returns + ------- + bool + + Examples + -------- + >>> is_offset_divisor("QS-Jan", "YS") + True + >>> is_offset_divisor("QS-DEC", "YS-JUL") + False + >>> is_offset_divisor("D", "M") + True + """ + if compare_offsets(divisor, ">", offset): + return False + # Reconstruct offsets anchored at the start of the period + # to have comparable quantities, also get "offset" objects + mA, bA, _sA, aA = parse_offset(divisor) + offAs = pd.tseries.frequencies.to_offset(construct_offset(mA, bA, True, aA)) + + mB, bB, _sB, aB = parse_offset(offset) + offBs = pd.tseries.frequencies.to_offset(construct_offset(mB, bB, True, aB)) + tB = pd.date_range("1970-01-01T00:00:00", freq=offBs, periods=13) + + if bA in ["W", "D", "h", "min", "s", "ms", "us", "ms"] or bB in [ + "W", + "D", + "h", + "min", + "s", + "ms", + "us", + "ms", + ]: + # Simple length comparison is sufficient for submonthly freqs + # In case one of bA or bB is > W, we test many to be sure. + tA = pd.date_range("1970-01-01T00:00:00", freq=offAs, periods=13) + return np.all( + (np.diff(tB)[:, np.newaxis] / np.diff(tA)[np.newaxis, :]) % 1 == 0 + ) + + # else, we test alignment with some real dates + # If both fall on offAs, then is means divisor is aligned with offset at those dates + # if N=13 is True, then it is always True + # As divisor <= offset, this means divisor is a "divisor" of offset. + return all(offAs.is_on_offset(d) for d in tB) + + +def _interpolate_doy_calendar( + source: xr.DataArray, doy_max: int, doy_min: int = 1 +) -> xr.DataArray: + """Interpolate from one set of dayofyear range to another. + + Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 + to 365). + + Parameters + ---------- + source : xr.DataArray + Array with `dayofyear` coordinates. + doy_max : int + The largest day of the year allowed by calendar. + doy_min : int + The smallest day of the year in the output. + This parameter is necessary when the target time series does not span over a full year (e.g. JJA season). + Default is 1. + + Returns + ------- + xr.DataArray + Interpolated source array over coordinates spanning the target `dayofyear` range. + """ + if "dayofyear" not in source.coords.keys(): + raise AttributeError("Source should have `dayofyear` coordinates.") + + # Interpolate to fill na values + da = source + if uses_dask(source): + # interpolate_na cannot run on chunked dayofyear. + da = source.chunk(dict(dayofyear=-1)) + filled_na = da.interpolate_na(dim="dayofyear") + + # Interpolate to target dayofyear range + filled_na.coords["dayofyear"] = np.linspace( + start=doy_min, stop=doy_max, num=len(filled_na.coords["dayofyear"]) + ) + + return filled_na.interp(dayofyear=range(doy_min, doy_max + 1)) + + +def adjust_doy_calendar( + source: xr.DataArray, target: xr.DataArray | xr.Dataset +) -> xr.DataArray: + """Interpolate from one set of dayofyear range to another calendar. + + Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 to 365). + + Parameters + ---------- + source : xr.DataArray + Array with `dayofyear` coordinate. + target : xr.DataArray or xr.Dataset + Array with `time` coordinate. + + Returns + ------- + xr.DataArray + Interpolated source array over coordinates spanning the target `dayofyear` range. + """ + max_target_doy = int(target.time.dt.dayofyear.max()) + min_target_doy = int(target.time.dt.dayofyear.min()) + + def has_same_calendar(): + # case of full year (doys between 1 and 360|365|366) + return source.dayofyear.max() == max_doy[get_calendar(target)] + + def has_similar_doys(): + # case of partial year (e.g. JJA, doys between 152|153 and 243|244) + return ( + source.dayofyear.min == min_target_doy + and source.dayofyear.max == max_target_doy + ) + + if has_same_calendar() or has_similar_doys(): + return source + return _interpolate_doy_calendar(source, max_target_doy, min_target_doy) + + +def resample_doy(doy: xr.DataArray, arr: xr.DataArray | xr.Dataset) -> xr.DataArray: + """Create a temporal DataArray where each day takes the value defined by the day-of-year. + + Parameters + ---------- + doy : xr.DataArray + Array with `dayofyear` coordinate. + arr : xr.DataArray or xr.Dataset + Array with `time` coordinate. + + Returns + ------- + xr.DataArray + An array with the same dimensions as `doy`, except for `dayofyear`, which is + replaced by the `time` dimension of `arr`. Values are filled according to the + day of year value in `doy`. + """ + if "dayofyear" not in doy.coords: + raise AttributeError("Source should have `dayofyear` coordinates.") + + # Adjust calendar + adoy = adjust_doy_calendar(doy, arr) + + out = adoy.rename(dayofyear="time").reindex(time=arr.time.dt.dayofyear) + out["time"] = arr.time + + return out + + +def time_bnds( # noqa: C901 + time: ( + xr.DataArray + | xr.Dataset + | CFTimeIndex + | pd.DatetimeIndex + | DataArrayResample + | DatasetResample + ), + freq: str | None = None, + precision: str | None = None, +): + """Find the time bounds for a datetime index. + + As we are using datetime indices to stand in for period indices, assumptions regarding the period + are made based on the given freq. + + Parameters + ---------- + time : DataArray, Dataset, CFTimeIndex, DatetimeIndex, DataArrayResample or DatasetResample + Object which contains a time index as a proxy representation for a period index. + freq : str, optional + String specifying the frequency/offset such as 'MS', '2D', or '3min' + If not given, it is inferred from the time index, which means that index must + have at least three elements. + precision : str, optional + A timedelta representation that :py:class:`pandas.Timedelta` understands. + The time bounds will be correct up to that precision. If not given, + 1 ms ("1U") is used for CFtime indexes and 1 ns ("1N") for numpy datetime64 indexes. + + Returns + ------- + DataArray + The time bounds: start and end times of the periods inferred from the time index and a frequency. + It has the original time index along it's `time` coordinate and a new `bnds` coordinate. + The dtype and calendar of the array are the same as the index. + + Notes + ----- + xclim assumes that indexes for greater-than-day frequencies are "floored" down to a daily resolution. + For example, the coordinate "2000-01-31 00:00:00" with a "ME" frequency is assumed to mean a period + going from "2000-01-01 00:00:00" to "2000-01-31 23:59:59.999999". + + Similarly, it assumes that daily and finer frequencies yield indexes pointing to the period's start. + So "2000-01-31 00:00:00" with a "3h" frequency, means a period going from "2000-01-31 00:00:00" to + "2000-01-31 02:59:59.999999". + """ + if isinstance(time, (xr.DataArray, xr.Dataset)): + time = time.indexes[time.name] + elif isinstance(time, (DataArrayResample, DatasetResample)): + for grouper in time.groupers: + if "time" in grouper.dims: + datetime = grouper.unique_coord.data + freq = freq or grouper.grouper.freq + if datetime.dtype == "O": + time = xr.CFTimeIndex(datetime) + else: + time = pd.DatetimeIndex(datetime) + break + + else: + raise ValueError( + 'Got object resampled along another dimension than "time".' + ) + + if freq is None and hasattr(time, "freq"): + freq = time.freq + if freq is None: + freq = xr.infer_freq(time) + elif hasattr(freq, "freqstr"): + # When freq is a Offset + freq = freq.freqstr + + freq_base, freq_is_start = parse_offset(freq)[1:3] + + # Normalizing without using `.normalize` because cftime doesn't have it + floor = {"hour": 0, "minute": 0, "second": 0, "microsecond": 0, "nanosecond": 0} + if freq_base in ["h", "min", "s", "ms", "us", "ns"]: + floor.pop("hour") + if freq_base in ["min", "s", "ms", "us", "ns"]: + floor.pop("minute") + if freq_base in ["s", "ms", "us", "ns"]: + floor.pop("second") + if freq_base in ["us", "ns"]: + floor.pop("microsecond") + if freq_base == "ns": + floor.pop("nanosecond") + + if isinstance(time, xr.CFTimeIndex): + period = xr.coding.cftime_offsets.to_offset(freq) + is_on_offset = period.onOffset + eps = pd.Timedelta(precision or "1us").to_pytimedelta() + day = pd.Timedelta("1D").to_pytimedelta() + floor.pop("nanosecond") # unsupported by cftime + else: + period = pd.tseries.frequencies.to_offset(freq) + is_on_offset = period.is_on_offset + eps = pd.Timedelta(precision or "1ns") + day = pd.Timedelta("1D") + + def shift_time(t): + if not is_on_offset(t): + if freq_is_start: + t = period.rollback(t) + else: + t = period.rollforward(t) + return t.replace(**floor) + + time_real = list(map(shift_time, time)) + + cls = time.__class__ + if freq_is_start: + tbnds = [cls(time_real), cls([t + period - eps for t in time_real])] + else: + tbnds = [ + cls([t - period + day for t in time_real]), + cls([t + day - eps for t in time_real]), + ] + return xr.DataArray( + tbnds, dims=("bnds", "time"), coords={"time": time}, name="time_bnds" + ).transpose() + + +def climatological_mean_doy( + arr: xr.DataArray, window: int = 5 +) -> tuple[xr.DataArray, xr.DataArray]: + """Calculate the climatological mean and standard deviation for each day of the year. + + Parameters + ---------- + arr : xarray.DataArray + Input array. + window : int + Window size in days. + + Returns + ------- + xarray.DataArray, xarray.DataArray + Mean and standard deviation. + """ + rr = arr.rolling(min_periods=1, center=True, time=window).construct("window") + + # Create empty percentile array + g = rr.groupby("time.dayofyear") + + m = g.mean(["time", "window"]) + s = g.std(["time", "window"]) + + return m, s + + +def within_bnds_doy( + arr: xr.DataArray, *, low: xr.DataArray, high: xr.DataArray +) -> xr.DataArray: + """Return whether array values are within bounds for each day of the year. + + Parameters + ---------- + arr : xarray.DataArray + Input array. + low : xarray.DataArray + Low bound with dayofyear coordinate. + high : xarray.DataArray + High bound with dayofyear coordinate. + + Returns + ------- + xarray.DataArray + """ + low = resample_doy(low, arr) + high = resample_doy(high, arr) + return (low < arr) * (arr < high) + + +def _doy_days_since_doys( + base: xr.DataArray, start: DayOfYearStr | None = None +) -> tuple[xr.DataArray, xr.DataArray, xr.DataArray]: + """Calculate dayofyear to days since, or the inverse. + + Parameters + ---------- + base : xr.DataArray + 1D time coordinate. + start : DayOfYearStr, optional + A date to compute the offset relative to. If note given, start_doy is the same as base_doy. + + Returns + ------- + base_doy : xr.DataArray + Day of year for each element in base. + start_doy : xr.DataArray + Day of year of the "start" date. + The year used is the one the start date would take as a doy for the corresponding base element. + doy_max : xr.DataArray + Number of days (maximum doy) for the year of each value in base. + """ + calendar = get_calendar(base) + + base_doy = base.dt.dayofyear + + doy_max = xr.apply_ufunc( + xr.coding.calendar_ops._days_in_year, + base.dt.year, + vectorize=True, + kwargs={"calendar": calendar}, + ) + + if start is not None: + mm, dd = map(int, start.split("-")) + starts = xr.apply_ufunc( + lambda y: datetime_classes[calendar](y, mm, dd), + base.dt.year, + vectorize=True, + ) + start_doy = starts.dt.dayofyear + start_doy = start_doy.where(start_doy >= base_doy, start_doy + doy_max) + else: + start_doy = base_doy + + return base_doy, start_doy, doy_max + + +def doy_to_days_since( + da: xr.DataArray, + start: DayOfYearStr | None = None, + calendar: str | None = None, +) -> xr.DataArray: + """Convert day-of-year data to days since a given date. + + This is useful for computing meaningful statistics on doy data. + + Parameters + ---------- + da : xr.DataArray + Array of "day-of-year", usually int dtype, must have a `time` dimension. + Sampling frequency should be finer or similar to yearly and coarser than daily. + start : date of year str, optional + A date in "MM-DD" format, the base day of the new array. If None (default), the `time` axis is used. + Passing `start` only makes sense if `da` has a yearly sampling frequency. + calendar : str, optional + The calendar to use when computing the new interval. + If None (default), the calendar attribute of the data or of its `time` axis is used. + All time coordinates of `da` must exist in this calendar. + No check is done to ensure doy values exist in this calendar. + + Returns + ------- + xr.DataArray + Same shape as `da`, int dtype, day-of-year data translated to a number of days since a given date. + If start is not None, there might be negative values. + + Notes + ----- + The time coordinates of `da` are considered as the START of the period. For example, a doy value of + 350 with a timestamp of '2020-12-31' is understood as '2021-12-16' (the 350th day of 2021). + Passing `start=None`, will use the time coordinate as the base, so in this case the converted value + will be 350 "days since time coordinate". + + Examples + -------- + >>> from xarray import DataArray + >>> time = date_range("2020-07-01", "2021-07-01", freq="AS-JUL") + >>> # July 8th 2020 and Jan 2nd 2022 + >>> da = DataArray([190, 2], dims=("time",), coords={"time": time}) + >>> # Convert to days since Oct. 2nd, of the data's year. + >>> doy_to_days_since(da, start="10-02").values + array([-86, 92]) + """ + base_calendar = get_calendar(da) + calendar = calendar or da.attrs.get("calendar", base_calendar) + dac = da.convert_calendar(calendar) + + base_doy, start_doy, doy_max = _doy_days_since_doys(dac.time, start) + + # 2cases: + # val is a day in the same year as its index : da - offset + # val is a day in the next year : da + doy_max - offset + out = xr.where(dac > base_doy, dac, dac + doy_max) - start_doy + out.attrs.update(da.attrs) + if start is not None: + out.attrs.update(units=f"days after {start}") + else: + starts = np.unique(out.time.dt.strftime("%m-%d")) + if len(starts) == 1: + out.attrs.update(units=f"days after {starts[0]}") + else: + out.attrs.update(units="days after time coordinate") + + out.attrs.pop("is_dayofyear", None) + out.attrs.update(calendar=calendar) + return out.convert_calendar(base_calendar).rename(da.name) + + +def days_since_to_doy( + da: xr.DataArray, + start: DayOfYearStr | None = None, + calendar: str | None = None, +) -> xr.DataArray: + """Reverse the conversion made by :py:func:`doy_to_days_since`. + + Converts data given in days since a specific date to day-of-year. + + Parameters + ---------- + da : xr.DataArray + The result of :py:func:`doy_to_days_since`. + start : DateOfYearStr, optional + `da` is considered as days since that start date (in the year of the time index). + If None (default), it is read from the attributes. + calendar : str, optional + Calendar the "days since" were computed in. + If None (default), it is read from the attributes. + + Returns + ------- + xr.DataArray + Same shape as `da`, values as `day of year`. + + Examples + -------- + >>> from xarray import DataArray + >>> time = date_range("2020-07-01", "2021-07-01", freq="AS-JUL") + >>> da = DataArray( + ... [-86, 92], + ... dims=("time",), + ... coords={"time": time}, + ... attrs={"units": "days since 10-02"}, + ... ) + >>> days_since_to_doy(da).values + array([190, 2]) + """ + if start is None: + unitstr = da.attrs.get("units", " time coordinate").split(" ", maxsplit=2)[-1] + if unitstr != "time coordinate": + start = unitstr + + base_calendar = get_calendar(da) + calendar = calendar or da.attrs.get("calendar", base_calendar) + + dac = da.convert_calendar(calendar) + + _, start_doy, doy_max = _doy_days_since_doys(dac.time, start) + + # 2cases: + # val is a day in the same year as its index : da + offset + # val is a day in the next year : da + offset - doy_max + out = dac + start_doy + out = xr.where(out > doy_max, out - doy_max, out) + + out.attrs.update( + {k: v for k, v in da.attrs.items() if k not in ["units", "calendar"]} + ) + out.attrs.update(calendar=calendar, is_dayofyear=1) + return out.convert_calendar(base_calendar).rename(da.name) + + +def date_range_like(source: xr.DataArray, calendar: str) -> xr.DataArray: + """Deprecated : use :py:func:`xarray.date_range_like` instead. Passing use_cftime=False instead of calendar='default'. + + Generate a datetime array with the same frequency, start and end as another one, but in a different calendar. + """ + calendar, usecf = _get_usecf_and_warn( + calendar, "date_range_like", "xarray.date_range_like" + ) + return xr.coding.calendar_ops.date_range_like( + source=source, calendar=calendar, use_cftime=usecf + ) + + +def select_time( + da: xr.DataArray | xr.Dataset, + drop: bool = False, + season: str | Sequence[str] | None = None, + month: int | Sequence[int] | None = None, + doy_bounds: tuple[int, int] | None = None, + date_bounds: tuple[str, str] | None = None, + include_bounds: bool | tuple[bool, bool] = True, +) -> DataType: + """Select entries according to a time period. + + This conveniently improves xarray's :py:meth:`xarray.DataArray.where` and + :py:meth:`xarray.DataArray.sel` with fancier ways of indexing over time elements. + In addition to the data `da` and argument `drop`, only one of `season`, `month`, + `doy_bounds` or `date_bounds` may be passed. + + Parameters + ---------- + da : xr.DataArray or xr.Dataset + Input data. + drop : bool + Whether to drop elements outside the period of interest or to simply mask them (default). + season : string or sequence of strings, optional + One or more of 'DJF', 'MAM', 'JJA' and 'SON'. + month : integer or sequence of integers, optional + Sequence of month numbers (January = 1 ... December = 12) + doy_bounds : 2-tuple of integers, optional + The bounds as (start, end) of the period of interest expressed in day-of-year, integers going from + 1 (January 1st) to 365 or 366 (December 31st). + If calendar awareness is needed, consider using ``date_bounds`` instead. + date_bounds : 2-tuple of strings, optional + The bounds as (start, end) of the period of interest expressed as dates in the month-day (%m-%d) format. + include_bounds : bool or 2-tuple of booleans + Whether the bounds of `doy_bounds` or `date_bounds` should be inclusive or not. + Either one value for both or a tuple. Default is True, meaning bounds are inclusive. + + Returns + ------- + xr.DataArray or xr.Dataset + Selected input values. If ``drop=False``, this has the same length as ``da`` (along dimension 'time'), + but with masked (NaN) values outside the period of interest. + + Examples + -------- + Keep only the values of fall and spring. + + >>> ds = open_dataset("ERA5/daily_surface_cancities_1990-1993.nc") + >>> ds.time.size + 1461 + >>> out = select_time(ds, drop=True, season=["MAM", "SON"]) + >>> out.time.size + 732 + + Or all values between two dates (included). + + >>> out = select_time(ds, drop=True, date_bounds=("02-29", "03-02")) + >>> out.time.values + array(['1990-03-01T00:00:00.000000000', '1990-03-02T00:00:00.000000000', + '1991-03-01T00:00:00.000000000', '1991-03-02T00:00:00.000000000', + '1992-02-29T00:00:00.000000000', '1992-03-01T00:00:00.000000000', + '1992-03-02T00:00:00.000000000', '1993-03-01T00:00:00.000000000', + '1993-03-02T00:00:00.000000000'], dtype='datetime64[ns]') + """ + N = sum(arg is not None for arg in [season, month, doy_bounds, date_bounds]) + if N > 1: + raise ValueError(f"Only one method of indexing may be given, got {N}.") + + if N == 0: + return da + + def _get_doys(_start, _end, _inclusive): + if _start <= _end: + _doys = np.arange(_start, _end + 1) + else: + _doys = np.concatenate((np.arange(_start, 367), np.arange(0, _end + 1))) + if not _inclusive[0]: + _doys = _doys[1:] + if not _inclusive[1]: + _doys = _doys[:-1] + return _doys + + if isinstance(include_bounds, bool): + include_bounds = (include_bounds, include_bounds) + + if season is not None: + if isinstance(season, str): + season = [season] + mask = da.time.dt.season.isin(season) + + elif month is not None: + if isinstance(month, int): + month = [month] + mask = da.time.dt.month.isin(month) + + elif doy_bounds is not None: + mask = da.time.dt.dayofyear.isin(_get_doys(*doy_bounds, include_bounds)) + + elif date_bounds is not None: + # This one is a bit trickier. + start, end = date_bounds + time = da.time + calendar = get_calendar(time) + if calendar not in uniform_calendars: + # For non-uniform calendars, we can't simply convert dates to doys + # conversion to all_leap is safe for all non-uniform calendar as it doesn't remove any date. + time = time.convert_calendar("all_leap") + # values of time are the _old_ calendar + # and the new calendar is in the coordinate + calendar = "all_leap" + + # Get doy of date, this is now safe because the calendar is uniform. + doys = _get_doys( + to_cftime_datetime(f"2000-{start}", calendar).dayofyr, + to_cftime_datetime(f"2000-{end}", calendar).dayofyr, + include_bounds, + ) + mask = time.time.dt.dayofyear.isin(doys) + # Needed if we converted calendar, this puts back the correct coord + mask["time"] = da.time + + else: + raise ValueError( + "Must provide either `season`, `month`, `doy_bounds` or `date_bounds`." + ) + + return da.where(mask, drop=drop) + + +def _month_is_first_period_month(time, freq): + """Returns True if the given time is from the first month of freq.""" + if isinstance(time, cftime.datetime): + frq_monthly = xr.coding.cftime_offsets.to_offset("MS") + frq = xr.coding.cftime_offsets.to_offset(freq) + if frq_monthly.onOffset(time): + return frq.onOffset(time) + return frq.onOffset(frq_monthly.rollback(time)) + # Pandas + time = pd.Timestamp(time) + frq_monthly = pd.tseries.frequencies.to_offset("MS") + frq = pd.tseries.frequencies.to_offset(freq) + if frq_monthly.is_on_offset(time): + return frq.is_on_offset(time) + return frq.is_on_offset(frq_monthly.rollback(time)) + + +def stack_periods( + da: xr.Dataset | xr.DataArray, + window: int = 30, + stride: int | None = None, + min_length: int | None = None, + freq: str = "YS", + dim: str = "period", + start: str = "1970-01-01", + align_days: bool = True, + pad_value=dtypes.NA, +): + """Construct a multi-period array. + + Stack different equal-length periods of `da` into a new 'period' dimension. + + This is similar to ``da.rolling(time=window).construct(dim, stride=stride)``, but adapted for arguments + in terms of a base temporal frequency that might be non-uniform (years, months, etc.). + It is reversible for some cases (see `stride`). + A rolling-construct method will be much more performant for uniform periods (days, weeks). + + Parameters + ---------- + da : xr.Dataset or xr.DataArray + An xarray object with a `time` dimension. + Must have a uniform timestep length. + Output might be strange if this does not use a uniform calendar (noleap, 360_day, all_leap). + window : int + The length of the moving window as a multiple of ``freq``. + stride : int, optional + At which interval to take the windows, as a multiple of ``freq``. + For the operation to be reversible with :py:func:`unstack_periods`, it must divide `window` into an odd number of parts. + Default is `window` (no overlap between periods). + min_length : int, optional + Windows shorter than this are not included in the output. + Given as a multiple of ``freq``. Default is ``window`` (every window must be complete). + Similar to the ``min_periods`` argument of ``da.rolling``. + If ``freq`` is annual or quarterly and ``min_length == ``window``, the first period is considered complete + if the first timestep is in the first month of the period. + freq : str + Units of ``window``, ``stride`` and ``min_length``, as a frequency string. + Must be larger or equal to the data's sampling frequency. + Note that this function offers an easier interface for non-uniform period (like years or months) + but is much slower than a rolling-construct method. + dim : str + The new dimension name. + start : str + The `start` argument passed to :py:func:`xarray.date_range` to generate the new placeholder + time coordinate. + align_days : bool + When True (default), an error is raised if the output would have unaligned days across periods. + If `freq = 'YS'`, day-of-year alignment is checked and if `freq` is "MS" or "QS", we check day-in-month. + Only uniform-calendar will pass the test for `freq='YS'`. + For other frequencies, only the `360_day` calendar will work. + This check is ignored if the sampling rate of the data is coarser than "D". + pad_value : Any + When some periods are shorter than others, this value is used to pad them at the end. + Passed directly as argument ``fill_value`` to :py:func:`xarray.concat`, + the default is the same as on that function. + + Return + ------ + xr.DataArray + A DataArray with a new `period` dimension and a `time` dimension with the length of the longest window. + The new time coordinate has the same frequency as the input data but is generated using + :py:func:`xarray.date_range` with the given `start` value. + That coordinate is the same for all periods, depending on the choice of ``window`` and ``freq``, it might make sense. + But for unequal periods or non-uniform calendars, it will certainly not. + If ``stride`` is a divisor of ``window``, the correct timeseries can be reconstructed with :py:func:`unstack_periods`. + The coordinate of `period` is the first timestep of each window. + """ + from xsdba.units import ( # Import in function to avoid cyclical imports; ensure_cf_units, + infer_sampling_units, + ) + + stride = stride or window + min_length = min_length or window + if stride > window: + raise ValueError( + f"Stride must be less than or equal to window. Got {stride} > {window}." + ) + + srcfreq = xr.infer_freq(da.time) + cal = da.time.dt.calendar + use_cftime = da.time.dtype == "O" + + if ( + compare_offsets(srcfreq, "<=", "D") + and align_days + and ( + (freq.startswith(("Y", "A")) and cal not in uniform_calendars) + or (freq.startswith(("Q", "M")) and window > 1 and cal != "360_day") + ) + ): + if freq.startswith(("Y", "A")): + u = "year" + else: + u = "month" + raise ValueError( + f"Stacking {window}{freq} periods will result in unaligned day-of-{u}. " + f"Consider converting the calendar of your data to one with uniform {u} lengths, " + "or pass `align_days=False` to disable this check." + ) + + # Convert integer inputs to freq strings + mult, *args = parse_offset(freq) + win_frq = construct_offset(mult * window, *args) + strd_frq = construct_offset(mult * stride, *args) + minl_frq = construct_offset(mult * min_length, *args) + + # The same time coord as da, but with one extra element. + # This way, the last window's last index is not returned as None by xarray's grouper. + time2 = xr.DataArray( + xr.date_range( + da.time[0].item(), + freq=srcfreq, + calendar=cal, + periods=da.time.size + 1, + use_cftime=use_cftime, + ), + dims=("time",), + name="time", + ) + + periods = [] + # longest = 0 + # Iterate over strides, but recompute the full window for each stride start + for strd_slc in da.resample(time=strd_frq).groups.values(): + win_resamp = time2.isel(time=slice(strd_slc.start, None)).resample(time=win_frq) + # Get slice for first group + win_slc = win_resamp._group_indices[0] + if min_length < window: + # If we ask for a min_length period instead is it complete ? + min_resamp = time2.isel(time=slice(strd_slc.start, None)).resample( + time=minl_frq + ) + min_slc = min_resamp._group_indices[0] + open_ended = min_slc.stop is None + else: + # The end of the group slice is None if no outside-group value was found after the last element + # As we added an extra step to time2, we avoid the case where a group ends exactly on the last element of ds + open_ended = win_slc.stop is None + if open_ended: + # Too short, we got to the end + break + if ( + strd_slc.start == 0 + and parse_offset(freq)[1] in "YAQ" + and min_length == window + and not _month_is_first_period_month(da.time[0].item(), freq) + ): + # For annual or quarterly frequencies (which can be anchor-based), + # if the first time is not in the first month of the first period, + # then the first period is incomplete but by a fractional amount. + continue + periods.append( + slice( + strd_slc.start + win_slc.start, + ( + (strd_slc.start + win_slc.stop) + if win_slc.stop is not None + else da.time.size + ), + ) + ) + + # Make coordinates + lengths = xr.DataArray( + [slc.stop - slc.start for slc in periods], + dims=(dim,), + attrs={"long_name": "Length of each period"}, + ) + longest = lengths.max().item() + # Length as a pint-ready array : with proper units, but values are not usable as indexes anymore + m, u = infer_sampling_units(da) + lengths = lengths * m + # ADAPT: cf-agnostic + # lengths.attrs["units"] = ensure_cf_units(u) + + # Start points for each period and remember parameters for unstacking + starts = xr.DataArray( + [da.time[slc.start].item() for slc in periods], + dims=(dim,), + attrs={ + "long_name": "Start of the period", + # Save parameters so that we can unstack. + "window": window, + "stride": stride, + "freq": freq, + "unequal_lengths": int(len(np.unique(lengths)) > 1), + }, + ) + # The "fake" axis that all periods share + fake_time = xr.date_range( + start, periods=longest, freq=srcfreq, calendar=cal, use_cftime=use_cftime + ) + # Slice and concat along new dim. We drop the index and add a new one so that xarray can concat them together. + out = xr.concat( + [ + da.isel(time=slc) + .drop_vars("time") + .assign_coords(time=np.arange(slc.stop - slc.start)) + for slc in periods + ], + dim, + join="outer", + fill_value=pad_value, + ) + out = out.assign_coords( + time=(("time",), fake_time, da.time.attrs.copy()), + **{f"{dim}_length": lengths, dim: starts}, + ) + out.time.attrs.update(long_name="Placeholder time axis") + return out + + +def unstack_periods(da: xr.DataArray | xr.Dataset, dim: str = "period"): + """Unstack an array constructed with :py:func:`stack_periods`. + + Can only work with periods stacked with a ``stride`` that divides ``window`` in an odd number of sections. + When ``stride`` is smaller than ``window``, only the center-most stride of each window is kept, + except for the beginning and end which are taken from the first and last windows. + + Parameters + ---------- + da : xr.DataArray + As constructed by :py:func:`stack_periods`, attributes of the period coordinates must have been preserved. + dim : str + The period dimension name. + + Notes + ----- + The following table shows which strides are included (``o``) in the unstacked output. + + In this example, ``stride`` was a fifth of ``window`` and ``min_length`` was four (4) times ``stride``. + The row index ``i`` the period index in the stacked dataset, + columns are the stride-long section of the original timeseries. + + .. table:: Unstacking example with ``stride < window``. + + === === === === === === === === + i 0 1 2 3 4 5 6 + === === === === === === === === + 3 x x o o + 2 x x o x x + 1 x x o x x + 0 o o o x x + === === === === === === === === + """ + from xclim.core.units import infer_sampling_units + + try: + starts = da[dim] + window = starts.attrs["window"] + stride = starts.attrs["stride"] + freq = starts.attrs["freq"] + unequal_lengths = bool(starts.attrs["unequal_lengths"]) + except (AttributeError, KeyError) as err: + raise ValueError( + f"`unstack_periods` can't find the window, stride and freq attributes on the {dim} coordinates." + ) from err + + if unequal_lengths: + try: + lengths = da[f"{dim}_length"] + except KeyError as err: + raise ValueError( + f"`unstack_periods` can't find the `{dim}_length` coordinate." + ) from err + # Get length as number of points + m, _ = infer_sampling_units(da.time) + lengths = lengths // m + else: + # It is acceptable to lose "{dim}_length" if they were all equal + lengths = xr.DataArray([da.time.size] * da[dim].size, dims=(dim,)) + + # Convert from the fake axis to the real one + time_as_delta = da.time - da.time[0] + if da.time.dtype == "O": + # cftime can't add with np.timedelta64 (restriction comes from numpy which refuses to add O with m8) + time_as_delta = pd.TimedeltaIndex( + time_as_delta + ).to_pytimedelta() # this array is O, numpy complies + else: + # Xarray will return int when iterating over datetime values, this returns timestamps + starts = pd.DatetimeIndex(starts) + + def _reconstruct_time(_time_as_delta, _start): + times = _time_as_delta + _start + return xr.DataArray(times, dims=("time",), coords={"time": times}, name="time") + + # Easy case: + if window == stride: + # just concat them all + periods = [] + for i, (start, length) in enumerate(zip(starts.values, lengths.values)): + real_time = _reconstruct_time(time_as_delta, start) + periods.append( + da.isel(**{dim: i}, drop=True) + .isel(time=slice(0, length)) + .assign_coords(time=real_time.isel(time=slice(0, length))) + ) + return xr.concat(periods, "time") + + # Difficult and ambiguous case + if (window / stride) % 2 != 1: + raise NotImplementedError( + "`unstack_periods` can't work with strides that do not divide the window into an odd number of parts." + f"Got {window} / {stride} which is not an odd integer." + ) + + # Non-ambiguous overlapping case + Nwin = window // stride + mid = (Nwin - 1) // 2 # index of the center window + + mult, *args = parse_offset(freq) + strd_frq = construct_offset(mult * stride, *args) + + periods = [] + for i, (start, length) in enumerate(zip(starts.values, lengths.values)): + real_time = _reconstruct_time(time_as_delta, start) + slices = real_time.resample(time=strd_frq)._group_indices + if i == 0: + slc = slice(slices[0].start, min(slices[mid].stop, length)) + elif i == da.period.size - 1: + slc = slice(slices[mid].start, min(slices[Nwin - 1].stop or length, length)) + else: + slc = slice(slices[mid].start, min(slices[mid].stop, length)) + periods.append( + da.isel(**{dim: i}, drop=True) + .isel(time=slc) + .assign_coords(time=real_time.isel(time=slc)) + ) + + return xr.concat(periods, "time") diff --git a/src/xsdba/datachecks.py b/src/xsdba/datachecks.py new file mode 100644 index 0000000..9269046 --- /dev/null +++ b/src/xsdba/datachecks.py @@ -0,0 +1,123 @@ +""" +Data Checks +=========== + +Utilities designed to check the validity of data inputs. +""" + +from __future__ import annotations + +from collections.abc import Sequence + +import xarray as xr + +from .calendar import compare_offsets, parse_offset +from .logging import ValidationError +from .options import datacheck + + +@datacheck +def check_freq(var: xr.DataArray, freq: str | Sequence[str], strict: bool = True): + """Raise an error if not series has not the expected temporal frequency or is not monotonically increasing. + + Parameters + ---------- + var : xr.DataArray + Input array. + freq : str or sequence of str + The expected temporal frequencies, using Pandas frequency terminology ({'Y', 'M', 'D', 'h', 'min', 's', 'ms', 'us'}) + and multiples thereof. To test strictly for 'W', pass '7D' with `strict=True`. + This ignores the start/end flag and the anchor (ex: 'YS-JUL' will validate against 'Y'). + strict : bool + Whether multiples of the frequencies are considered invalid or not. With `strict` set to False, a '3h' series + will not raise an error if freq is set to 'h'. + + Raises + ------ + ValidationError + - If the frequency of `var` is not inferrable. + - If the frequency of `var` does not match the requested `freq`. + """ + if isinstance(freq, str): + freq = [freq] + exp_base = [parse_offset(frq)[1] for frq in freq] + v_freq = xr.infer_freq(var.time) + if v_freq is None: + raise ValidationError( + "Unable to infer the frequency of the time series. " + "To mute this, set xclim's option data_validation='log'." + ) + v_base = parse_offset(v_freq)[1] + if v_base not in exp_base or ( + strict and all(compare_offsets(v_freq, "!=", frq) for frq in freq) + ): + raise ValidationError( + f"Frequency of time series not {'strictly' if strict else ''} in {freq}. " + "To mute this, set xclim's option data_validation='log'." + ) + + +def check_daily(var: xr.DataArray): + """Raise an error if not series has a frequency other that daily, or is not monotonically increasing. + + Notes + ----- + This does not check for gaps in series. + """ + return check_freq(var, "D") + + +@datacheck +def check_common_time(inputs: Sequence[xr.DataArray]): + """Raise an error if the list of inputs doesn't have a single common frequency. + + Raises + ------ + ValidationError + - if the frequency of any input can't be inferred + - if inputs have different frequencies + - if inputs have a daily or hourly frequency, but they are not given at the same time of day. + + Parameters + ---------- + inputs : Sequence of xr.DataArray + Input arrays. + """ + # Check all have the same freq + freqs = [xr.infer_freq(da.time) for da in inputs] + if None in freqs: + raise ValidationError( + "Unable to infer the frequency of the time series. " + "To mute this, set xclim's option data_validation='log'." + ) + if len(set(freqs)) != 1: + raise ValidationError( + f"Inputs have different frequencies. Got : {freqs}." + "To mute this, set xclim's option data_validation='log'." + ) + + # Check if anchor is the same + freq = freqs[0] + base = parse_offset(freq)[1] + fmt = {"h": ":%M", "D": "%H:%M"} + if base in fmt: + outs = {da.indexes["time"][0].strftime(fmt[base]) for da in inputs} + if len(outs) > 1: + raise ValidationError( + f"All inputs have the same frequency ({freq}), but they are not anchored on the same minutes (got {outs}). " + f"xarray's alignment would silently fail. You can try to fix this with `da.resample('{freq}').mean()`." + "To mute this, set xclim's option data_validation='log'." + ) + + +def is_percentile_dataarray(source: xr.DataArray) -> bool: + """Evaluate whether a DataArray is a Percentile. + + A percentile dataarray must have climatology_bounds attributes and either a + quantile or percentiles coordinate, the window is not mandatory. + """ + return ( + isinstance(source, xr.DataArray) + and source.attrs.get("climatology_bounds", None) is not None + and ("quantile" in source.coords or "percentiles" in source.coords) + ) diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index de5bbfb..77c1c08 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -7,11 +7,342 @@ import datetime as dt import itertools -from inspect import signature +import re +import string +import warnings +from ast import literal_eval +from collections.abc import Sequence +from fnmatch import fnmatch +from inspect import _empty, signature +from typing import Any, Callable import xarray as xr from boltons.funcutils import wraps +from .typing import KIND_ANNOTATION, InputKind + + +class AttrFormatter(string.Formatter): + """A formatter for frequently used attribute values. + + See the doc of format_field() for more details. + """ + + def __init__( + self, + mapping: dict[str, Sequence[str]], + modifiers: Sequence[str], + ) -> None: + """Initialize the formatter. + + Parameters + ---------- + mapping : dict[str, Sequence[str]] + A mapping from values to their possible variations. + modifiers : Sequence[str] + The list of modifiers, must be the as long as the longest value of `mapping`. + Cannot include reserved modifier 'r'. + """ + super().__init__() + if "r" in modifiers: + raise ValueError("Modifier 'r' is reserved for default raw formatting.") + self.modifiers = modifiers + self.mapping = mapping + + def format(self, format_string: str, /, *args: Any, **kwargs: Any) -> str: + r"""Format a string. + + Parameters + ---------- + format_string: str + \*args: Any + \*\*kwargs: Any + + Returns + ------- + str + """ + # ADAPT: THIS IS VERY CLIMATE, WILL BE REMOVED + # for k, v in DEFAULT_FORMAT_PARAMS.items(): + # if k not in kwargs: + # kwargs.update({k: v}) + return super().format(format_string, *args, **kwargs) + + def format_field(self, value, format_spec): + """Format a value given a formatting spec. + + If `format_spec` is in this Formatter's modifiers, the corresponding variation + of value is given. If `format_spec` is 'r' (raw), the value is returned unmodified. + If `format_spec` is not specified but `value` is in the mapping, the first variation is returned. + + Examples + -------- + Let's say the string "The dog is {adj1}, the goose is {adj2}" is to be translated + to French and that we know that possible values of `adj` are `nice` and `evil`. + In French, the genre of the noun changes the adjective (cat = chat is masculine, + and goose = oie is feminine) so we initialize the formatter as: + + >>> fmt = AttrFormatter( + ... { + ... "nice": ["beau", "belle"], + ... "evil": ["méchant", "méchante"], + ... "smart": ["intelligent", "intelligente"], + ... }, + ... ["m", "f"], + ... ) + >>> fmt.format( + ... "Le chien est {adj1:m}, l'oie est {adj2:f}, le gecko est {adj3:r}", + ... adj1="nice", + ... adj2="evil", + ... adj3="smart", + ... ) + "Le chien est beau, l'oie est méchante, le gecko est smart" + + The base values may be given using unix shell-like patterns: + + >>> fmt = AttrFormatter( + ... {"YS-*": ["annuel", "annuelle"], "MS": ["mensuel", "mensuelle"]}, + ... ["m", "f"], + ... ) + >>> fmt.format( + ... "La moyenne {freq:f} est faite sur un échantillon {src_timestep:m}", + ... freq="YS-JUL", + ... src_timestep="MS", + ... ) + 'La moyenne annuelle est faite sur un échantillon mensuel' + """ + baseval = self._match_value(value) + if baseval is None: # Not something we know how to translate + if format_spec in self.modifiers + [ + "r" + ]: # Woops, however a known format spec was asked + warnings.warn( + f"Requested formatting `{format_spec}` for unknown string `{value}`." + ) + format_spec = "" + return super().format_field(value, format_spec) + # Thus, known value + + if not format_spec: # (None or '') No modifiers, return first + return self.mapping[baseval][0] + + if format_spec == "r": # Raw modifier + return super().format_field(value, "") + + if format_spec in self.modifiers: # Known modifier + if len(self.mapping[baseval]) == 1: # But unmodifiable entry + return self.mapping[baseval][0] + # Known modifier, modifiable entry + return self.mapping[baseval][self.modifiers.index(format_spec)] + # Known value but unknown modifier, must be a built-in one, only works for the default val... + return super().format_field(self.mapping[baseval][0], format_spec) + + def _match_value(self, value): + if isinstance(value, str): + for mapval in self.mapping.keys(): + if fnmatch(value, mapval): + return mapval + return None + + +# Tag mappings between keyword arguments and long-form text. +default_formatter = AttrFormatter( + { + # Arguments to "freq" + "D": ["daily", "days"], + "YS": ["annual", "years"], + "YS-*": ["annual", "years"], + "MS": ["monthly", "months"], + "QS-*": ["seasonal", "seasons"], + # Arguments to "indexer" + "DJF": ["winter"], + "MAM": ["spring"], + "JJA": ["summer"], + "SON": ["fall"], + "norm": ["Normal"], + "m1": ["january"], + "m2": ["february"], + "m3": ["march"], + "m4": ["april"], + "m5": ["may"], + "m6": ["june"], + "m7": ["july"], + "m8": ["august"], + "m9": ["september"], + "m10": ["october"], + "m11": ["november"], + "m12": ["december"], + # Arguments to "op / reducer / stat" (for example for generic.stats) + "integral": ["integrated", "integral"], + "count": ["count"], + "doymin": ["day of minimum"], + "doymax": ["day of maximum"], + "mean": ["average"], + "max": ["maximal", "maximum"], + "min": ["minimal", "minimum"], + "sum": ["total", "sum"], + "std": ["standard deviation"], + "var": ["variance"], + "absamp": ["absolute amplitude"], + "relamp": ["relative amplitude"], + # For when we are formatting indicator classes with empty options + "": [""], + }, + ["adj", "noun"], +) + + +def parse_doc(doc: str) -> dict[str, str]: + """Crude regex parsing reading an indice docstring and extracting information needed in indicator construction. + + The appropriate docstring syntax is detailed in :ref:`notebooks/extendxclim:Defining new indices`. + + Parameters + ---------- + doc : str + The docstring of an indice function. + + Returns + ------- + dict + A dictionary with all parsed sections. + """ + if doc is None: + return {} + + out = {} + + sections = re.split(r"(\w+\s?\w+)\n\s+-{3,50}", doc) # obj.__doc__.split('\n\n') + intro = sections.pop(0) + if intro: + intro_content = list(map(str.strip, intro.strip().split("\n\n"))) + if len(intro_content) == 1: + out["title"] = intro_content[0] + elif len(intro_content) >= 2: + out["title"], abstract = intro_content[:2] + out["abstract"] = " ".join(map(str.strip, abstract.splitlines())) + + for i in range(0, len(sections), 2): + header, content = sections[i : i + 2] + + if header in ["Notes", "References"]: + out[header.lower()] = content.replace("\n ", "\n").strip() + elif header == "Parameters": + out["parameters"] = _parse_parameters(content) + elif header == "Returns": + rets = _parse_returns(content) + if rets: + meta = list(rets.values())[0] + if "long_name" in meta: + out["long_name"] = meta["long_name"] + return out + + +def _parse_parameters(section): + """Parse the 'parameters' section of a docstring into a dictionary. + + Works by mapping the parameter name to its description and, potentially, to its set of choices. + The type annotation are not parsed, except for fixed sets of values (listed as "{'a', 'b', 'c'}"). + The annotation parsing only accepts strings, numbers, `None` and `nan` (to represent `numpy.nan`). + """ + curr_key = None + params = {} + for line in section.split("\n"): + if line.startswith(" " * 6): # description + s = " " if params[curr_key]["description"] else "" + params[curr_key]["description"] += s + line.strip() + elif line.startswith(" " * 4) and ":" in line: # param title + name, annot = line.split(":", maxsplit=1) + curr_key = name.strip() + params[curr_key] = {"description": ""} + match = re.search(r".*(\{.*\}).*", annot) + if match: + try: + choices = literal_eval(match.groups()[0]) + params[curr_key]["choices"] = choices + except ValueError: # noqa: S110 + # If the literal_eval fails, we just ignore the choices. + pass + return params + + +def _parse_returns(section): + """Parse the returns section of a docstring into a dictionary mapping the parameter name to its description.""" + curr_key = None + params = {} + for line in section.split("\n"): + if line.strip(): + if line.startswith(" " * 6): # long_name + s = " " if params[curr_key]["long_name"] else "" + params[curr_key]["long_name"] += s + line.strip() + elif line.startswith(" " * 4): # param title + annot, *name = reversed(line.split(":", maxsplit=1)) + if name: + curr_key = name[0].strip() + else: + curr_key = None + params[curr_key] = {"long_name": ""} + annot, *unit = annot.split(",", maxsplit=1) + if unit: + params[curr_key]["units"] = unit[0].strip() + return params + + +# XC +def prefix_attrs(source: dict, keys: Sequence, prefix: str) -> dict: + """Rename some keys of a dictionary by adding a prefix. + + Parameters + ---------- + source : dict + Source dictionary, for example data attributes. + keys : sequence + Names of keys to prefix. + prefix : str + Prefix to prepend to keys. + + Returns + ------- + dict + Dictionary of attributes with some keys prefixed. + """ + out = {} + for key, val in source.items(): + if key in keys: + out[f"{prefix}{key}"] = val + else: + out[key] = val + return out + + +# XC +def unprefix_attrs(source: dict, keys: Sequence, prefix: str) -> dict: + """Remove prefix from keys in a dictionary. + + Parameters + ---------- + source : dict + Source dictionary, for example data attributes. + keys : sequence + Names of original keys for which prefix should be removed. + prefix : str + Prefix to remove from keys. + + Returns + ------- + dict + Dictionary of attributes whose keys were prefixed, with prefix removed. + """ + out = {} + n = len(prefix) + for key, val in source.items(): + k = key[n:] + if (k in keys) and key.startswith(prefix): + out[k] = val + elif key not in out: + out[key] = val + return out + # XC def merge_attributes( @@ -205,3 +536,163 @@ def gen_call_string( elements.append(rep) return f"{funcname}({', '.join(elements)})" + + +# XC +def _gen_parameters_section( + parameters: dict[str, dict[str, Any]], allowed_periods: list[str] | None = None +) -> str: + """Generate the "parameters" section of the indicator docstring. + + Parameters + ---------- + parameters : dict + Parameters dictionary (`Ind.parameters`). + allowed_periods : list of str, optional + Restrict parameters to specific periods. Default: None. + + Returns + ------- + str + """ + section = "Parameters\n----------\n" + for name, param in parameters.items(): + desc_str = param.description + if param.kind == InputKind.FREQ_STR: + desc_str += ( + " See https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset" + "-aliases for available options." + ) + if allowed_periods is not None: + desc_str += ( + f" Restricted to frequencies equivalent to one of {allowed_periods}" + ) + if param.kind == InputKind.VARIABLE: + defstr = f"Default : `ds.{param.default}`. " + elif param.kind == InputKind.OPTIONAL_VARIABLE: + defstr = "" + elif param.default is not _empty: + defstr = f"Default : {param.default}. " + else: + defstr = "Required. " + if "choices" in param: + annotstr = str(param.choices) + else: + annotstr = KIND_ANNOTATION[param.kind] + if "units" in param and param.units is not None: + unitstr = f"[Required units : {param.units}]" + else: + unitstr = "" + section += f"{name} {': ' if annotstr else ''}{annotstr}\n {desc_str}\n {defstr}{unitstr}\n" + return section + + +def _gen_returns_section(cf_attrs: Sequence[dict[str, Any]]) -> str: + """Generate the "Returns" section of an indicator's docstring. + + Parameters + ---------- + cf_attrs : Sequence[Dict[str, Any]] + The list of attributes, usually Indicator.cf_attrs. + + Returns + ------- + str + """ + section = "Returns\n-------\n" + for attrs in cf_attrs: + if not section.endswith("\n"): + section += "\n" + section += f"{attrs['var_name']} : DataArray\n" + section += f" {attrs.get('long_name', '')}" + if "standard_name" in attrs: + section += f" ({attrs['standard_name']})" + if "units" in attrs: + section += f" [{attrs['units']}]" + added_section = "" + for key, attr in attrs.items(): + if key not in ["long_name", "standard_name", "units", "var_name"]: + if callable(attr): + attr = "" + added_section += f" **{key}**: {attr};" + if added_section: + section = f"{section}, with additional attributes:{added_section[:-1]}" + section += "\n" + return section + + +def generate_indicator_docstring(ind) -> str: + """Generate an indicator's docstring from keywords. + + Parameters + ---------- + ind + Indicator instance + + Returns + ------- + str + """ + header = f"{ind.title} (realm: {ind.realm})\n\n{ind.abstract}\n" + + special = "" + + if hasattr(ind, "missing"): # Only ResamplingIndicators + special += f'This indicator will check for missing values according to the method "{ind.missing}".\n' + if hasattr(ind.compute, "__module__"): + special += f"Based on indice :py:func:`~{ind.compute.__module__}.{ind.compute.__name__}`.\n" + if ind.injected_parameters: + special += "With injected parameters: " + special += ", ".join( + [f"{k}={v}" for k, v in ind.injected_parameters.items()] + ) + special += ".\n" + if ind.keywords: + special += f"Keywords : {ind.keywords}.\n" + + parameters = _gen_parameters_section( + ind.parameters, getattr(ind, "allowed_periods", None) + ) + + returns = _gen_returns_section(ind.cf_attrs) + + extras = "" + for section in ["notes", "references"]: + if getattr(ind, section): + extras += f"{section.capitalize()}\n{'-' * len(section)}\n{getattr(ind, section)}\n\n" + + doc = f"{header}\n{special}\n{parameters}\n{returns}\n{extras}" + return doc + + +def get_percentile_metadata(data: xr.DataArray, prefix: str) -> dict[str, str]: + """Get the metadata related to percentiles from the given DataArray as a dictionary. + + Parameters + ---------- + data : xr.DataArray + Must be a percentile DataArray, this means the necessary metadata + must be available in its attributes and coordinates. + prefix : str + The prefix to be used in the metadata key. + Usually this takes the form of "tasmin_per" or equivalent. + + Returns + ------- + dict + A mapping of the configuration used to compute these percentiles. + """ + # handle case where da was created with `quantile()` method + if "quantile" in data.coords: + percs = data.coords["quantile"].values * 100 + elif "percentiles" in data.coords: + percs = data.coords["percentiles"].values + else: + percs = "" + clim_bounds = data.attrs.get("climatology_bounds", "") + + return { + f"{prefix}_thresh": percs, + f"{prefix}_window": data.attrs.get("window", ""), + f"{prefix}_period": clim_bounds, + } diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py new file mode 100644 index 0000000..1eba691 --- /dev/null +++ b/src/xsdba/locales.py @@ -0,0 +1,331 @@ +""" +Internationalization +==================== + +This module defines methods and object to help the internationalization of metadata for +climate indicators computed by xclim. Go to :ref:`notebooks/customize:Adding translated metadata` to see +how to use this feature. + +All the methods and objects in this module use localization data given in JSON files. +These files are expected to be defined as in this example for French: + +.. code-block:: + + { + "attrs_mapping": { + "modifiers": ["", "f", "mpl", "fpl"], + "YS": ["annuel", "annuelle", "annuels", "annuelles"], + "YS-*": ["annuel", "annuelle", "annuels", "annuelles"], + # ... and so on for other frequent parameters translation... + }, + "DTRVAR": { + "long_name": "Variabilité de l'amplitude de la température diurne", + "description": "Variabilité {freq:f} de l'amplitude de la température diurne (définie comme la moyenne de la variation journalière de l'amplitude de température sur une période donnée)", + "title": "Variation quotidienne absolue moyenne de l'amplitude de la température diurne", + "comment": "", + "abstract": "La valeur absolue de la moyenne de l'amplitude de la température diurne.", + }, + # ... and so on for other indicators... + } + +Indicators are named by subclass identifier, the same as in the indicator registry (`xclim.core.indicators.registry`), +but which can differ from the callable name. In this case, the indicator is called through +`atmos.daily_temperature_range_variability`, but its identifier is `DTRVAR`. +Use the `ind.__class__.__name__` accessor to get its registry name. + +Here, the usual parameter passed to the formatting of "description" is "freq" and is usually translated from "YS" +to "annual". However, in French and in this sentence, the feminine form should be used, so the "f" modifier is added +by the translator so that the formatting function knows which translation to use. Acceptable entries for the mappings +are limited to what is already defined in `xclim.core.indicators.utils.default_formatter`. + +For user-provided internationalization dictionaries, only the "attrs_mapping" and its "modifiers" key are mandatory, +all other entries (translations of frequent parameters and all indicator entries) are optional. +For xclim-provided translations (for now only French), all indicators must have en entry and the "attrs_mapping" +entries must match exactly the default formatter. +Those default translations are found in the `xclim/locales` folder. +""" + +from __future__ import annotations + +import json +import warnings +from collections.abc import Sequence +from copy import deepcopy +from pathlib import Path + +from .formatting import AttrFormatter, default_formatter + +TRANSLATABLE_ATTRS = [ + "long_name", + "description", + "comment", + "title", + "abstract", + "keywords", +] +""" +List of attributes to consider translatable when generating locale dictionaries. +""" + +_LOCALES = {} + + +def list_locales(): + """List of loaded locales. Includes all loaded locales, no matter how complete the translations are.""" + return list(_LOCALES.keys()) + + +def _valid_locales(locales): + """Check if the locales are valid.""" + if isinstance(locales, str): + return True + return all( + [ + # A locale is valid if it is a string from the list + (isinstance(locale, str) and locale in _LOCALES) + or ( + # Or if it is a tuple of a string and either a file or a dict. + not isinstance(locale, str) + and isinstance(locale[0], str) + and (isinstance(locale[1], dict) or Path(locale[1]).is_file()) + ) + for locale in locales + ] + ) + + +def get_local_dict(locale: str | Sequence[str] | tuple[str, dict]) -> tuple[str, dict]: + """Return all translated metadata for a given locale. + + Parameters + ---------- + locale: str or sequence of str + IETF language tag or a tuple of the language tag and a translation dict, or a tuple of the language + tag and a path to a json file defining translation of attributes. + + Raises + ------ + UnavailableLocaleError + If the given locale is not available. + + Returns + ------- + str + The best fitting locale string + dict + The available translations in this locale. + """ + _valid_locales([locale]) + + if isinstance(locale, str): + if locale not in _LOCALES: + raise UnavailableLocaleError(locale) + + return locale, deepcopy(_LOCALES[locale]) + + if isinstance(locale[1], dict): + trans = locale[1] + else: + # Thus, a string pointing to a json file + trans = read_locale_file(locale[1]) + + if locale[0] in _LOCALES: + loaded_trans = deepcopy(_LOCALES[locale[0]]) + # Passed translations have priority + loaded_trans.update(trans) + trans = loaded_trans + return locale[0], trans + + +def get_local_attrs( + indicator: str | Sequence[str], + *locales: str | Sequence[str] | tuple[str, dict], + names: Sequence[str] | None = None, + append_locale_name: bool = True, +) -> dict: + """Get all attributes of an indicator in the requested locales. + + Parameters + ---------- + indicator : str or sequence of strings + Indicator's class name, usually the same as in `xc.core.indicator.registry`. + If multiple names are passed, the attrs from each indicator are merged, + with the highest priority set to the first name. + locales : str or tuple of str + IETF language tag or a tuple of the language tag and a translation dict, or a tuple of the language tag + and a path to a json file defining translation of attributes. + names : sequence of str, optional + If given, only returns translations of attributes in this list. + append_locale_name : bool + If True (default), append the language tag (as "{attr_name}_{locale}") to the returned attributes. + + Raises + ------ + ValueError + If `append_locale_name` is False and multiple `locales` are requested. + + Returns + ------- + dict + All CF attributes available for given indicator and locales. + Warns and returns an empty dict if none were available. + """ + if isinstance(indicator, str): + indicator = [indicator] + + if not append_locale_name and len(locales) > 1: + raise ValueError( + "`append_locale_name` cannot be False if multiple locales are requested." + ) + + attrs = {} + for locale in locales: + loc_name, loc_dict = get_local_dict(locale) + loc_name = f"_{loc_name}" if append_locale_name else "" + local_attrs = loc_dict.get(indicator[-1], {}) + for other_ind in indicator[-2::-1]: + local_attrs.update(loc_dict.get(other_ind, {})) + if not local_attrs: + warnings.warn( + f"Attributes of indicator {', '.join(indicator)} in language {locale} " + "were requested, but none were found." + ) + else: + for name in TRANSLATABLE_ATTRS: + if (names is None or name in names) and name in local_attrs: + attrs[f"{name}{loc_name}"] = local_attrs[name] + return attrs + + +def get_local_formatter( + locale: str | Sequence[str] | tuple[str, dict] +) -> AttrFormatter: + """Return an AttrFormatter instance for the given locale. + + Parameters + ---------- + locale: str or tuple of str + IETF language tag or a tuple of the language tag and a translation dict, or a tuple of the language tag + and a path to a json file defining translation of attributes. + """ + _, loc_dict = get_local_dict(locale) + if "attrs_mapping" in loc_dict: + attrs_mapping = loc_dict["attrs_mapping"].copy() + mods = attrs_mapping.pop("modifiers") + return AttrFormatter(attrs_mapping, mods) + + warnings.warn( + "No `attrs_mapping` entry found for locale {loc_name}, using default (english) formatter." + ) + return default_formatter + + +class UnavailableLocaleError(ValueError): + """Error raised when a locale is requested but doesn't exist.""" + + def __init__(self, locale): + super().__init__( + f"Locale {locale} not available. Use `xclim.core.locales.list_locales()` to see available languages." + ) + + +def read_locale_file( + filename, module: str | None = None, encoding: str = "UTF8" +) -> dict[str, dict]: + """Read a locale file (.json) and return its dictionary. + + Parameters + ---------- + filename : PathLike + The file to read. + module : str, optional + If module is a string, this module name is added to all identifiers translated in this file. + Defaults to None, and no module name is added (as if the indicator was an official xclim indicator). + encoding : str + The encoding to use when reading the file. + Defaults to UTF-8, overriding python's default mechanism which is machine dependent. + """ + locdict: dict[str, dict] + with open(filename, encoding=encoding) as f: + locdict = json.load(f) + + if module is not None: + locdict = { + (k if k == "attrs_mapping" else f"{module}.{k}"): v + for k, v in locdict.items() + } + return locdict + + +def load_locale(locdata: str | Path | dict[str, dict], locale: str): + """Load translations from a json file into xclim. + + Parameters + ---------- + locdata : str or Path or dictionary + Either a loaded locale dictionary or a path to a json file. + locale : str + The locale name (IETF tag). + """ + if isinstance(locdata, (str, Path)): + filename = Path(locdata) + locdata = read_locale_file(filename) + + if locale in _LOCALES: + _LOCALES[locale].update(locdata) + else: + _LOCALES[locale] = locdata + + +def generate_local_dict(locale: str, init_english: bool = False) -> dict: + """Generate a dictionary with keys for each indicator and translatable attributes. + + Parameters + ---------- + locale : str + Locale in the IETF format + init_english : bool + If True, fills the initial dictionary with the english versions of the attributes. + Defaults to False. + """ + from ..core.indicator import registry # pylint: disable=import-outside-toplevel + + if locale in _LOCALES: + _, attrs = get_local_dict(locale) + for ind_name in attrs.copy().keys(): + if ind_name != "attrs_mapping" and ind_name not in registry: + attrs.pop(ind_name) + else: + attrs = {} + + attrs_mapping = attrs.setdefault("attrs_mapping", {}) + attrs_mapping.setdefault("modifiers", [""]) + for key, value in default_formatter.mapping.items(): + attrs_mapping.setdefault(key, [value[0]]) + + eng_attr = "" + for ind_name, indicator in registry.items(): + ind_attrs = attrs.setdefault(ind_name, {}) + for translatable_attr in set(TRANSLATABLE_ATTRS).difference( + set(indicator._cf_names) + ): + if init_english: + eng_attr = getattr(indicator, translatable_attr) + if not isinstance(eng_attr, str): + eng_attr = "" + ind_attrs.setdefault(f"{translatable_attr}", eng_attr) + + for cf_attrs in indicator.cf_attrs: + # In the case of single output, put var attrs in main dict + if len(indicator.cf_attrs) > 1: + ind_attrs = attrs.setdefault(f"{ind_name}.{cf_attrs['var_name']}", {}) + + for translatable_attr in set(TRANSLATABLE_ATTRS).intersection( + set(indicator._cf_names) + ): + if init_english: + eng_attr = cf_attrs.get(translatable_attr) + if not isinstance(eng_attr, str): + eng_attr = "" + ind_attrs.setdefault(f"{translatable_attr}", eng_attr) + return attrs diff --git a/src/xsdba/logging.py b/src/xsdba/logging.py index 79ee33c..14ae2c3 100644 --- a/src/xsdba/logging.py +++ b/src/xsdba/logging.py @@ -54,3 +54,7 @@ def raise_warn_or_log( warnings.warn(message, stacklevel=stacklevel + 1) else: # mode == "raise" raise err from err_type(message) + + +class MissingVariableError(ValueError): + """Error raised when a dataset is passed to an indicator but one of the needed variable is missing.""" diff --git a/src/xsdba/options.py b/src/xsdba/options.py index ef48f11..cd34814 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -11,14 +11,15 @@ from boltons.funcutils import wraps -# from .locales import _valid_locales # from XC, not reproduced for now +from .locales import _valid_locales from .logging import ValidationError, raise_warn_or_log -# METADATA_LOCALES = "metadata_locales" +METADATA_LOCALES = "metadata_locales" DATA_VALIDATION = "data_validation" CF_COMPLIANCE = "cf_compliance" CHECK_MISSING = "check_missing" MISSING_OPTIONS = "missing_options" +RUN_LENGTH_UFUNC = "run_length_ufunc" SDBA_EXTRA_OUTPUT = "sdba_extra_output" SDBA_ENCODE_CF = "sdba_encode_cf" KEEP_ATTRS = "keep_attrs" @@ -27,11 +28,12 @@ MISSING_METHODS: dict[str, Callable] = {} OPTIONS = { - # METADATA_LOCALES: [], + METADATA_LOCALES: [], DATA_VALIDATION: "raise", CF_COMPLIANCE: "warn", CHECK_MISSING: "any", MISSING_OPTIONS: {}, + RUN_LENGTH_UFUNC: "auto", SDBA_EXTRA_OUTPUT: False, SDBA_ENCODE_CF: False, KEEP_ATTRS: "xarray", @@ -39,6 +41,7 @@ } _LOUDNESS_OPTIONS = frozenset(["log", "warn", "raise"]) +_RUN_LENGTH_UFUNC_OPTIONS = frozenset(["auto", True, False]) _KEEP_ATTRS_OPTIONS = frozenset(["xarray", True, False]) @@ -57,11 +60,12 @@ def _valid_missing_options(mopts): _VALIDATORS = { - # METADATA_LOCALES: _valid_locales, + METADATA_LOCALES: _valid_locales, DATA_VALIDATION: _LOUDNESS_OPTIONS.__contains__, CF_COMPLIANCE: _LOUDNESS_OPTIONS.__contains__, CHECK_MISSING: lambda meth: meth != "from_context" and meth in MISSING_METHODS, MISSING_OPTIONS: _valid_missing_options, + RUN_LENGTH_UFUNC: _RUN_LENGTH_UFUNC_OPTIONS.__contains__, SDBA_EXTRA_OUTPUT: lambda opt: isinstance(opt, bool), SDBA_ENCODE_CF: lambda opt: isinstance(opt, bool), KEEP_ATTRS: _KEEP_ATTRS_OPTIONS.__contains__, @@ -74,16 +78,16 @@ def _set_missing_options(mopts): OPTIONS[MISSING_OPTIONS][meth].update(opts) -# def _set_metadata_locales(locales): -# if isinstance(locales, str): -# OPTIONS[METADATA_LOCALES] = [locales] -# else: -# OPTIONS[METADATA_LOCALES] = locales +def _set_metadata_locales(locales): + if isinstance(locales, str): + OPTIONS[METADATA_LOCALES] = [locales] + else: + OPTIONS[METADATA_LOCALES] = locales _SETTERS = { MISSING_OPTIONS: _set_missing_options, - # METADATA_LOCALES: _set_metadata_locales, + METADATA_LOCALES: _set_metadata_locales, } diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 992b198..4e37cb3 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -14,7 +14,7 @@ import xarray as xr from xarray.core.utils import get_temp_dimname -from xsdba.base import get_calendar, max_doy, parse_offset, uses_dask +from xsdba.calendar import get_calendar, max_doy, parse_offset, uses_dask from xsdba.formatting import update_xsdba_history from ._processing import _adapt_freq, _normalize, _reordering @@ -388,7 +388,7 @@ def escore( tgt: xr.DataArray, sim: xr.DataArray, dims: Sequence[str] = ("variables", "time"), - N: int = 0, # noqa + N: int = 0, scale: bool = False, ) -> xr.DataArray: r"""Energy score, or energy dissimilarity metric, based on :cite:t:`sdba-szekely_testing_2004` and :cite:t:`sdba-cannon_multivariate_2018`. diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py new file mode 100644 index 0000000..648cc51 --- /dev/null +++ b/src/xsdba/properties.py @@ -0,0 +1,1577 @@ +# pylint: disable=missing-kwoa +""" +Properties Submodule +==================== +SDBA diagnostic tests are made up of statistical properties and measures. Properties are calculated on both simulation +and reference datasets. They collapse the time dimension to one value. + +This framework for the diagnostic tests was inspired by the `VALUE `_ project. +Statistical Properties is the xclim term for 'indices' in the VALUE project. + +""" +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np +import xarray as xr +import xclim as xc +from scipy import stats +from statsmodels.tsa import stattools + +import xsdba.xclim_submodules.run_length as rl +from xsdba.indicator import Indicator, base_registry +from xsdba.units import ( + convert_units_to, + ensure_delta, + pint2str, + to_agg_units, + units2pint, +) +from xsdba.utils import uses_dask +from xsdba.xclim_submodules.generic import compare, select_resample_op +from xsdba.xclim_submodules.stats import fit, parametric_quantile + +from .base import Grouper, map_groups, parse_group, parse_offset +from .nbutils import _pairwise_haversine_and_bins +from .utils import _pairwise_spearman, copy_all_attrs + + +class StatisticalProperty(Indicator): + """Base indicator class for statistical properties used for validating bias-adjusted outputs. + + Statistical properties reduce the time dimension, sometimes adding a grouping dimension + according to the passed value of `group` (e.g.: group='time.month' means the loss of the + time dimension and the addition of a month one). + + Statistical properties are generally unit-generic. To use those indicator in a workflow, it + is recommended to wrap them with a virtual submodule, creating one specific indicator for + each variable input (or at least for each possible dimensionality). + + Statistical properties may restrict the sampling frequency of the input, they usually take in a + single variable (named "da" in unit-generic instances). + + """ + + aspect = None + """The aspect the statistical property studies: marginal, temporal, multivariate or spatial.""" + + measure = "xclim.sdba.measures.BIAS" + """The default measure to use when comparing the properties of two datasets. + This gives the registry id. See :py:meth:`get_measure`.""" + + allowed_groups = None + """A list of allowed groupings. A subset of dayofyear, week, month, season or group. + The latter stands for no temporal grouping.""" + + realm = "generic" + + @classmethod + def _ensure_correct_parameters(cls, parameters): + if "group" not in parameters: + raise ValueError( + f"{cls.__name__} require a 'group' argument, use the base Indicator" + " class if your computation doesn't perform any regrouping." + ) + return super()._ensure_correct_parameters(parameters) + + def _preprocess_and_checks(self, das, params): + """Check if group is allowed.""" + # Convert grouping and check if allowed: + if isinstance(params["group"], str): + params["group"] = Grouper(params["group"]) + + if self.allowed_groups is not None: + if params["group"].prop not in self.allowed_groups: + raise ValueError( + f"Grouping period {params['group'].prop_name} is not allowed for property " + f"{self.identifier} (needs something in " + f"{map(lambda g: '.' + g.replace('group', ''), self.allowed_groups)})." + ) + + return das, params + + def _postprocess(self, outs, das, params): + """Squeeze `group` dim if needed.""" + outs = super()._postprocess(outs, das, params) + + for i in range(len(outs)): + if "group" in outs[i].dims: + outs[i] = outs[i].squeeze("group", drop=True) + + return outs + + def get_measure(self): + """Get the statistical measure indicator that is best used with this statistical property.""" + from xclim.core.indicator import registry + + return registry[self.measure].get_instance() + + +base_registry["StatisticalProperty"] = StatisticalProperty + + +@parse_group +def _mean(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: + """Mean. + + Mean over all years at the time resolution. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the temporal average is performed separately for each month. + + Returns + ------- + xr.DataArray, [same as input] + Mean of the variable. + """ + units = da.units + if group.prop != "group": + da = da.groupby(group.name) + out = da.mean(dim=group.dim) + return out.assign_attrs(units=units) + + +mean = StatisticalProperty( + identifier="mean", + aspect="marginal", + cell_methods="time: mean", + compute=_mean, +) + + +@parse_group +def _var(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: + """Variance. + + Variance of the variable over all years at the time resolution. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the variance is performed separately for each month. + + Returns + ------- + xr.DataArray, [square of the input units] + Variance of the variable. + """ + units = da.units + if group.prop != "group": + da = da.groupby(group.name) + out = da.var(dim=group.dim) + u2 = units2pint(units) ** 2 + out.attrs["units"] = pint2str(u2) + return out + + +var = StatisticalProperty( + identifier="var", + aspect="marginal", + cell_methods="time: var", + compute=_var, + measure="xclim.sdba.measures.RATIO", +) + + +@parse_group +def _std(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: + """Standard Deviation. + + Standard deviation of the variable over all years at the time resolution. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the standard deviation is performed separately for each month. + + Returns + ------- + xr.DataArray, + Standard deviation of the variable. + """ + units = da.units + if group.prop != "group": + da = da.groupby(group.name) + out = da.std(dim=group.dim) + out.attrs["units"] = units + return out + + +std = StatisticalProperty( + identifier="std", + aspect="marginal", + cell_methods="time: std", + compute=_std, + measure="xclim.sdba.measures.RATIO", +) + + +@parse_group +def _skewness(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: + """Skewness. + + Skewness of the distribution of the variable over all years at the time resolution. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the skewness is performed separately for each month. + + Returns + ------- + xr.DataArray, [dimensionless] + Skewness of the variable. + + See Also + -------- + scipy.stats.skew + """ + if group.prop != "group": + da = da.groupby(group.name) + out = xr.apply_ufunc( + stats.skew, + da, + input_core_dims=[[group.dim]], + vectorize=True, + dask="parallelized", + ) + out.attrs["units"] = "" + return out + + +skewness = StatisticalProperty( + identifier="skewness", aspect="marginal", compute=_skewness, units="" +) + + +@parse_group +def _quantile( + da: xr.DataArray, *, q: float = 0.98, group: str | Grouper = "time" +) -> xr.DataArray: + """Quantile. + + Returns the quantile q of the distribution of the variable over all years at the time resolution. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + q : float + Quantile to be calculated. Should be between 0 and 1. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the quantile is computed separately for each month. + + Returns + ------- + xr.DataArray, [same as input] + Quantile {q} of the variable. + """ + units = da.units + if group.prop != "group": + da = da.groupby(group.name) + out = da.quantile(q, dim=group.dim, keep_attrs=True).drop_vars("quantile") + return out.assign_attrs(units=units) + + +quantile = StatisticalProperty( + identifier="quantile", aspect="marginal", compute=_quantile +) + + +def _spell_length_distribution( + da: xr.DataArray, + *, + method: str = "amount", + op: str = ">=", + thresh: str = "1 mm d-1", + window: int = 1, + stat: str = "mean", + stat_resample: str | None = None, + group: str | Grouper = "time", + resample_before_rl: bool = True, +) -> xr.DataArray: + """Spell length distribution. + + Statistic of spell length distribution when the variable respects a condition (defined by an operation, a method and + a threshold). + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + method: {'amount', 'quantile'} + Method to choose the threshold. + 'amount': The threshold is directly the quantity in {thresh}. It needs to have the same units as {da}. + 'quantile': The threshold is calculated as the quantile {thresh} of the distribution. + op : {">", "<", ">=", "<="} + Operation to verify the condition for a spell. + The condition for a spell is variable {op} threshold. + thresh : str or float + Threshold on which to evaluate the condition to have a spell. + String with units if the method is "amount". + Float of the quantile if the method is "quantile". + window : int + Number of consecutive days respecting the constraint in order to begin a spell. + Default is 1, which is equivalent to `_threshold_count` + stat : {'mean', 'sum', 'max','min'} + Statistics to apply to the remaining time dimension after resampling (e.g. Jan 1980-2010) + stat_resample : {'mean', 'sum', 'max','min'}, optional + Statistics to apply to the resampled input at the {group} (e.g. 1-31 Jan 1980). + If `None`, the same method as `stat` will be used. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the spell lengths are computed separately for each month. + resample_before_rl : bool + Determines if the resampling should take place before or after the run + length encoding (or a similar algorithm) is applied to runs. + + Returns + ------- + xr.DataArray, [units of the sampling frequency] + {stat} of spell length distribution when the variable is {op} the {method} {thresh} for {window} consecutive day(s). + """ + group = group if isinstance(group, Grouper) else Grouper(group) + + ops = {">": np.greater, "<": np.less, ">=": np.greater_equal, "<=": np.less_equal} + + @map_groups(out=[Grouper.PROP], main_only=True) + def _spell_stats( + ds, + *, + dim, + method, + thresh, + window, + op, + freq, + resample_before_rl, + stat, + stat_resample, + ): + # PB: This prevents an import error in the distributed dask scheduler, but I don't know why. + import xarray.core.resample_cftime # noqa: F401, pylint: disable=unused-import + + da = ds.data + mask = ~(da.isel({dim: 0}).isnull()).drop_vars( + dim + ) # mask of the ocean with NaNs + if method == "quantile": + thresh = da.quantile(thresh, dim=dim).drop_vars("quantile") + + cond = op(da, thresh) + out = rl.resample_and_rl( + cond, + resample_before_rl, + rl.rle_statistics, + reducer=stat_resample, + window=window, + dim=dim, + freq=freq, + ) + out = getattr(out, stat)(dim=dim) + out = out.where(mask) + return out.rename("out").to_dataset() + + # threshold is an amount that will be converted to the right units + if method == "amount": + thresh = convert_units_to(thresh, da) # , context="infer") + elif method != "quantile": + raise ValueError( + f"{method} is not a valid method. Choose 'amount' or 'quantile'." + ) + + out = _spell_stats( + da.rename("data").to_dataset(), + group=group, + method=method, + thresh=thresh, + window=window, + op=ops[op], + freq=group.freq, + resample_before_rl=resample_before_rl, + stat=stat, + stat_resample=stat_resample or stat, + ).out + return to_agg_units(out, da, op="count") + + +spell_length_distribution = StatisticalProperty( + identifier="spell_length_distribution", + aspect="temporal", + compute=_spell_length_distribution, +) + + +@parse_group +def _threshold_count( + da: xr.DataArray, + *, + method: str = "amount", + op: str = ">=", + thresh: str = "1 mm d-1", + stat: str = "mean", + stat_resample: str | None = None, + group: str | Grouper = "time", +) -> xr.DataArray: + r"""Correlation between two variables. + + Spearman or Pearson correlation coefficient between two variables at the time resolution. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + method : {'amount', 'quantile'} + Method to choose the threshold. + 'amount': The threshold is directly the quantity in {thresh}. It needs to have the same units as {da}. + 'quantile': The threshold is calculated as the quantile {thresh} of the distribution. + op : {">", "<", ">=", "<="} + Operation to verify the condition for a spell. + The condition for a spell is variable {op} threshold. + thresh : str or float + Threshold on which to evaluate the condition to have a spell. + String with units if the method is "amount". + Float of the quantile if the method is "quantile". + stat : {'mean', 'sum', 'max','min'} + Statistics to apply to the remaining time dimension after resampling (e.g. Jan 1980-2010) + stat_resample : {'mean', 'sum', 'max','min'}, optional + Statistics to apply to the resampled input at the {group} (e.g. 1-31 Jan 1980). If `None`, the same method as `stat` will be used. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. For 'time.month', the correlation would be calculated on each month separately, + but with all the years together. + + Returns + ------- + xr.DataArray, [dimensionless] + {stat} number of days when the variable is {op} the {method} {thresh}. + + Notes + ----- + This corresponds to ``xclim.sdba.properties._spell_length_distribution`` with `window=1`. + """ + return _spell_length_distribution( + da, + method=method, + op=op, + thresh=thresh, + stat=stat, + stat_resample=stat_resample, + group=group, + window=1, + ) + + +threshold_count = StatisticalProperty( + identifier="threshold_count", aspect="temporal", compute=_threshold_count +) + + +@parse_group +def _acf( + da: xr.DataArray, *, lag: int = 1, group: str | Grouper = "time.season" +) -> xr.DataArray: + """Autocorrelation. + + Autocorrelation with a lag over a time resolution and averaged over all years. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + lag : int + Lag. + group : {'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the autocorrelation is calculated over each month separately for all years. + Then, the autocorrelation for all Jan/Feb/... is averaged over all years, giving 12 outputs for each grid point. + + Returns + ------- + xr.DataArray, [dimensionless] + Lag-{lag} autocorrelation of the variable over a {group.prop} and averaged over all years. + + See Also + -------- + statsmodels.tsa.stattools.acf + + References + ---------- + :cite:cts:`alavoine_distinct_2022` + """ + + def acf_last(x, nlags): + """Statsmodels acf calculates acf for lag 0 to nlags, this return only the last one.""" + # As we resample + group, timeseries are quite short and fft=False seems more performant + out_last = stattools.acf(x, nlags=nlags, fft=False) + return out_last[-1] + + @map_groups(out=[Grouper.PROP], main_only=True) + def __acf(ds, *, dim, lag, freq): + out = xr.apply_ufunc( + acf_last, + ds.data.resample({dim: freq}), + input_core_dims=[[dim]], + vectorize=True, + kwargs={"nlags": lag}, + ) + out = out.mean("__resample_dim__") + return out.rename("out").to_dataset() + + out = __acf( + da.rename("data").to_dataset(), group=group, lag=lag, freq=group.freq + ).out + out.attrs["units"] = "" + return out + + +acf = StatisticalProperty( + identifier="acf", + aspect="temporal", + allowed_groups=["season", "month"], + compute=_acf, +) + + +# group was kept even though "time" is the only acceptable arg to keep the signature similar to other properties +# @parse_group doesn't work well here because of `window` +def _annual_cycle( + da: xr.DataArray, + *, + stat: str = "absamp", + window: int = 31, + group: str | Grouper = "time", +) -> xr.DataArray: + r"""Annual cycle statistics. + + A daily climatology is calculated and optionally smoothed with a (circular) moving average. + The requested statistic is returned. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + stat : {'absamp','relamp', 'phase', 'min', 'max', 'asymmetry'} + - 'absamp' is the peak-to-peak amplitude. (max - min). In the same units as the input. + - 'relamp' is a relative percentage. 100 * (max - min) / mean (Recommended for precipitation). Dimensionless. + - 'phase' is the day of year of the maximum. + - 'max' is the maximum. Same units as the input. + - 'min' is the minimum. Same units as the input. + - 'asymmetry' is the length of the period going from the minimum to the maximum. In years between 0 and 1. + window : int + Size of the window for the moving average filtering. Deactivate this feature by passing window = 1. + + Returns + ------- + xr.DataArray, [same units as input or dimensionless or time] + {stat} of the annual cycle. + """ + group = group if isinstance(group, Grouper) else Grouper(group) + units = da.units + + ac = da.groupby("time.dayofyear").mean() + if window > 1: # smooth the cycle + # We want the rolling mean to be circular. There's no built-in method to do this in xarray, + # we'll pad the array and extract the meaningful part. + ac = ( + ac.pad(dayofyear=(window // 2), mode="wrap") + .rolling(dayofyear=window, center=True) + .mean() + .isel(dayofyear=slice(window // 2, -(window // 2))) + ) + # TODO: In April 2024, use a match-case. + if stat == "absamp": + out = ac.max("dayofyear") - ac.min("dayofyear") + out.attrs["units"] = xc.core.units.ensure_delta(units) + elif stat == "relamp": + out = (ac.max("dayofyear") - ac.min("dayofyear")) * 100 / ac.mean("dayofyear") + out.attrs["units"] = "%" + elif stat == "phase": + out = ac.idxmax("dayofyear") + out.attrs.update(units="", is_dayofyear=np.int32(1)) + elif stat == "min": + out = ac.min("dayofyear") + out.attrs["units"] = units + elif stat == "max": + out = ac.max("dayofyear") + out.attrs["units"] = units + elif stat == "asymmetry": + out = (ac.idxmax("dayofyear") - ac.idxmin("dayofyear")) % 365 / 365 + out.attrs["units"] = "yr" + else: + raise NotImplementedError(f"{stat} is not a valid annual cycle statistic.") + return out + + +annual_cycle_amplitude = StatisticalProperty( + identifier="annual_cycle_amplitude", + aspect="temporal", + compute=_annual_cycle, + parameters={"stat": "absamp"}, + allowed_groups=["group"], + cell_methods="time: mean time: range", +) + +relative_annual_cycle_amplitude = StatisticalProperty( + identifier="relative_annual_cycle_amplitude", + aspect="temporal", + compute=_annual_cycle, + units="%", + parameters={"stat": "relamp"}, + allowed_groups=["group"], + cell_methods="time: mean time: range", + measure="xclim.sdba.measures.RATIO", +) + +annual_cycle_phase = StatisticalProperty( + identifier="annual_cycle_phase", + aspect="temporal", + units="", + compute=_annual_cycle, + parameters={"stat": "phase"}, + cell_methods="time: range", + allowed_groups=["group"], + measure="xclim.sdba.measures.CIRCULAR_BIAS", +) + +annual_cycle_asymmetry = StatisticalProperty( + identifier="annual_cycle_asymmetry", + aspect="temporal", + compute=_annual_cycle, + parameters={"stat": "asymmetry"}, + allowed_groups=["group"], + units="yr", +) + +annual_cycle_minimum = StatisticalProperty( + identifier="annual_cycle_minimum", + aspect="temporal", + units="", + compute=_annual_cycle, + parameters={"stat": "min"}, + cell_methods="time: mean time: min", + allowed_groups=["group"], +) + +annual_cycle_maximum = StatisticalProperty( + identifier="annual_cycle_maximum", + aspect="temporal", + compute=_annual_cycle, + parameters={"stat": "max"}, + cell_methods="time: mean time: max", + allowed_groups=["group"], +) + + +# @parse_group +def _annual_statistic( + da: xr.DataArray, + *, + stat: str = "absamp", + window: int = 31, + group: str | Grouper = "time", +): + """Annual range statistics. + + Compute a statistic on each year of data and return the interannual average. This is similar + to the annual cycle, but with the statistic and average operations inverted. + + Parameters + ---------- + da: xr.DataArray + Data. + stat : {'absamp', 'relamp', 'phase'} + The statistic to return. + window : int + Size of the window for the moving average filtering. Deactivate this feature by passing window = 1. + + Returns + ------- + xr.DataArray, [same units as input or dimensionless] + Average annual {stat}. + """ + units = da.units + + if window > 1: + da = da.rolling(time=window, center=True).mean() + + yrs = da.resample(time="YS") + + if stat == "absamp": + out = yrs.max() - yrs.min() + out.attrs["units"] = ensure_delta(units) + elif stat == "relamp": + out = (yrs.max() - yrs.min()) * 100 / yrs.mean() + out.attrs["units"] = "%" + elif stat == "phase": + out = yrs.map(xr.DataArray.idxmax).dt.dayofyear + out.attrs.update(units="", is_dayofyear=np.int32(1)) + else: + raise NotImplementedError(f"{stat} is not a valid annual cycle statistic.") + return out.mean("time", keep_attrs=True) + + +mean_annual_range = StatisticalProperty( + identifier="mean_annual_range", + aspect="temporal", + compute=_annual_statistic, + parameters={"stat": "absamp"}, + allowed_groups=["group"], +) + +mean_annual_relative_range = StatisticalProperty( + identifier="mean_annual_relative_range", + aspect="temporal", + compute=_annual_statistic, + parameters={"stat": "relamp"}, + allowed_groups=["group"], + units="%", + measure="xclim.sdba.measures.RATIO", +) + +mean_annual_phase = StatisticalProperty( + identifier="mean_annual_phase", + aspect="temporal", + compute=_annual_statistic, + parameters={"stat": "phase"}, + allowed_groups=["group"], + units="", + measure="xclim.sdba.measures.CIRCULAR_BIAS", +) + + +@parse_group +def _corr_btw_var( + da1: xr.DataArray, + da2: xr.DataArray, + *, + corr_type: str = "Spearman", + group: str | Grouper = "time", + output: str = "correlation", +) -> xr.DataArray: + r"""Correlation between two variables. + + Spearman or Pearson correlation coefficient between two variables at the time resolution. + + Parameters + ---------- + da1 : xr.DataArray + First variable on which to calculate the diagnostic. + da2 : xr.DataArray + Second variable on which to calculate the diagnostic. + corr_type: {'Pearson','Spearman'} + Type of correlation to calculate. + output: {'correlation', 'pvalue'} + Whether to return the correlation coefficient or the p-value. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. For 'time.month', the correlation would be calculated on each month separately, + but with all the years together. + + Returns + ------- + xr.DataArray, [dimensionless] + {corr_type} correlation coefficient + """ + if corr_type.lower() not in {"pearson", "spearman"}: + raise ValueError( + f"{corr_type} is not a valid type. Choose 'Pearson' or 'Spearman'." + ) + + index = {"correlation": 0, "pvalue": 1}[output] + + def _first_output_1d(a, b, index, corr_type): + """Only keep the correlation (first output) from the scipy function.""" + # for points in the water with NaNs + if np.isnan(a).all(): + return np.nan + aok = ~np.isnan(a) + bok = ~np.isnan(b) + if corr_type == "Pearson": + return stats.pearsonr(a[aok & bok], b[aok & bok])[index] + return stats.spearmanr(a[aok & bok], b[aok & bok])[index] + + @map_groups(out=[Grouper.PROP], main_only=True) + def _first_output(ds, *, dim, index, corr_type): + out = xr.apply_ufunc( + _first_output_1d, + ds.a, + ds.b, + input_core_dims=[[dim], [dim]], + vectorize=True, + dask="parallelized", + kwargs={"index": index, "corr_type": corr_type}, + ) + return out.rename("out").to_dataset() + + out = _first_output( + xr.Dataset({"a": da1, "b": da2}), group=group, index=index, corr_type=corr_type + ).out + out.attrs["units"] = "" + return out + + +corr_btw_var = StatisticalProperty( + identifier="corr_btw_var", aspect="multivariate", compute=_corr_btw_var +) + + +def _bivariate_spell_length_distribution( + da1: xr.DataArray, + da2: xr.DataArray, + *, + method1: str = "amount", + method2: str = "amount", + op1: str = ">=", + op2: str = ">=", + thresh1: str = "1 mm d-1", + thresh2: str = "1 mm d-1", + window: int = 1, + stat: str = "mean", + stat_resample: str | None = None, + group: str | Grouper = "time", + resample_before_rl: bool = True, +) -> xr.DataArray: + """Spell length distribution with bivariate condition. + + Statistic of spell length distribution when two variables respect individual conditions (defined by an operation, a method, + and a threshold). + + Parameters + ---------- + da1 : xr.DataArray + First variable on which to calculate the diagnostic. + da2 : xr.DataArray + Second variable on which to calculate the diagnostic. + method1 : {'amount', 'quantile'} + Method to choose the threshold. + 'amount': The threshold is directly the quantity in {thresh}. It needs to have the same units as {da}. + 'quantile': The threshold is calculated as the quantile {thresh} of the distribution. + method2 : {'amount', 'quantile'} + Method to choose the threshold. + 'amount': The threshold is directly the quantity in {thresh}. It needs to have the same units as {da}. + 'quantile': The threshold is calculated as the quantile {thresh} of the distribution. + op1 : {">", "<", ">=", "<="} + Operation to verify the condition for a spell. + The condition for a spell is variable {op1} threshold. + op2 : {">", "<", ">=", "<="} + Operation to verify the condition for a spell. + The condition for a spell is variable {op2} threshold. + thresh1 : str or float + Threshold on which to evaluate the condition to have a spell. + String with units if the method is "amount". + Float of the quantile if the method is "quantile". + thresh2 : str or float + Threshold on which to evaluate the condition to have a spell. + String with units if the method is "amount". + Float of the quantile if the method is "quantile". + window : int + Number of consecutive days respecting the constraint in order to begin a spell. + Default is 1, which is equivalent to `_bivariate_threshold_count` + stat : {'mean', 'sum', 'max','min'} + Statistics to apply to the remaining time dimension after resampling (e.g. Jan 1980-2010) + stat_resample : {'mean', 'sum', 'max','min'}, optional + Statistics to apply to the resampled input at the {group} (e.g. 1-31 Jan 1980). If `None`, the same method as `stat` will be used. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. If 'time.month', the spell lengths are computed separately for each month. + resample_before_rl : bool + Determines if the resampling should take place before or after the run + length encoding (or a similar algorithm) is applied to runs. + + Returns + ------- + xr.DataArray, [units of the sampling frequency] + {stat} of spell length distribution when the first variable is {op1} the {method1} {thresh1} + and the second variable is {op2} the {method2} {thresh2} for {window} consecutive day(s). + """ + group = group if isinstance(group, Grouper) else Grouper(group) + ops = { + ">": np.greater, + "<": np.less, + ">=": np.greater_equal, + "<=": np.less_equal, + } + + @map_groups(out=[Grouper.PROP], main_only=True) + def _bivariate_spell_stats( + ds, + *, + dim, + methods, + threshs, + opss, + freq, + window, + resample_before_rl, + stat, + stat_resample, + ): + # PB: This prevents an import error in the distributed dask scheduler, but I don't know why. + import xarray.core.resample_cftime # noqa: F401, pylint: disable=unused-import + + conds = [] + masks = [] + for da, thresh, op, method in zip([ds.da1, ds.da2], threshs, opss, methods): + masks.append( + ~(da.isel({dim: 0}).isnull()).drop_vars(dim) + ) # mask of the ocean with NaNs + if method == "quantile": + thresh = da.quantile(thresh, dim=dim).drop_vars("quantile") + conds.append(op(da, thresh)) + mask = masks[0] & masks[1] + cond = conds[0] & conds[1] + out = rl.resample_and_rl( + cond, + resample_before_rl, + rl.rle_statistics, + reducer=stat_resample, + window=window, + dim=dim, + freq=freq, + ) + out = getattr(out, stat)(dim=dim) + out = out.where(mask) + return out.rename("out").to_dataset() + + # threshold is an amount that will be converted to the right units + methods = [method1, method2] + threshs = [thresh1, thresh2] + for i, da in enumerate([da1, da2]): + if methods[i] == "amount": + # ADAPT: will this work? + threshs[i] = convert_units_to(threshs[i], da) # , context="infer") + elif methods[i] != "quantile": + raise ValueError( + f"{methods[i]} is not a valid method. Choose 'amount' or 'quantile'." + ) + + out = _bivariate_spell_stats( + xr.Dataset({"da1": da1, "da2": da2}), + group=group, + threshs=threshs, + methods=methods, + opss=[ops[op1], ops[op2]], + window=window, + freq=group.freq, + resample_before_rl=resample_before_rl, + stat=stat, + stat_resample=stat_resample or stat, + ).out + return to_agg_units(out, da1, op="count") + + +bivariate_spell_length_distribution = StatisticalProperty( + identifier="bivariate_spell_length_distribution", + aspect="temporal", + compute=_bivariate_spell_length_distribution, +) + + +@parse_group +def _bivariate_threshold_count( + da1: xr.DataArray, + da2: xr.DataArray, + *, + method1: str = "amount", + method2: str = "amount", + op1: str = ">=", + op2: str = ">=", + thresh1: str = "1 mm d-1", + thresh2: str = "1 mm d-1", + stat: str = "mean", + stat_resample: str | None = None, + group: str | Grouper = "time", +) -> xr.DataArray: + """Count the number of time steps where two variables respect given conditions. + + Statistic of number of time steps when two variables respect individual conditions (defined by an operation, a method, + and a threshold). + + Parameters + ---------- + da1 : xr.DataArray + First variable on which to calculate the diagnostic. + da2 : xr.DataArray + Second variable on which to calculate the diagnostic. + method1 : {'amount', 'quantile'} + Method to choose the threshold. + 'amount': The threshold is directly the quantity in {thresh}. It needs to have the same units as {da}. + 'quantile': The threshold is calculated as the quantile {thresh} of the distribution. + method2 : {'amount', 'quantile'} + Method to choose the threshold. + 'amount': The threshold is directly the quantity in {thresh}. It needs to have the same units as {da}. + 'quantile': The threshold is calculated as the quantile {thresh} of the distribution. + op1 : {">", "<", ">=", "<="} + Operation to verify the condition for a spell. + The condition for a spell is variable {op} threshold. + op2 : {">", "<", ">=", "<="} + Operation to verify the condition for a spell. + The condition for a spell is variable {op} threshold. + thresh1 : str or float + Threshold on which to evaluate the condition to have a spell. + String with units if the method is "amount". + Float of the quantile if the method is "quantile". + thresh2 : str or float + Threshold on which to evaluate the condition to have a spell. + String with units if the method is "amount". + Float of the quantile if the method is "quantile". + stat : {'mean', 'sum', 'max','min'} + Statistics to apply to the remaining time dimension after resampling (e.g. Jan 1980-2010) + stat_resample : {'mean', 'sum', 'max','min'}, optional + Statistics to apply to the resampled input at the {group} (e.g. 1-31 Jan 1980). + If `None`, the same method as `stat` will be used. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. + e.g. For 'time.month', the correlation would be calculated on each month separately, + but with all the years together. + + Returns + ------- + xr.DataArray, [dimensionless] + {stat} number of days when the first variable is {op1} the {method1} {thresh1} + and the second variable is {op2} the {method2} {thresh2} for {window} consecutive day(s). + + Notes + ----- + This corresponds to ``xclim.sdba.properties._bivariate_spell_length_distribution`` with `window=1`. + """ + return _bivariate_spell_length_distribution( + da1, + da2, + method1=method1, + method2=method2, + op1=op1, + op2=op2, + thresh1=thresh1, + thresh2=thresh2, + window=1, + stat=stat, + stat_resample=stat_resample, + group=group, + ) + + +bivariate_threshold_count = StatisticalProperty( + identifier="bivariate_threshold_count", + aspect="multivariate", + compute=_bivariate_threshold_count, +) + + +@parse_group +def _relative_frequency( + da: xr.DataArray, + *, + op: str = ">=", + thresh: str = "1 mm d-1", + group: str | Grouper = "time", +) -> xr.DataArray: + """Relative Frequency. + + Relative Frequency of days with variable respecting a condition (defined by an operation and a threshold) at the + time resolution. The relative frequency is the number of days that satisfy the condition divided by the total number + of days. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + op : {">", "<", ">=", "<="} + Operation to verify the condition. + The condition is variable {op} threshold. + thresh : str + Threshold on which to evaluate the condition. + group : {'time', 'time.season', 'time.month'} + Grouping on the output. + e.g. For 'time.month', the relative frequency would be calculated on each month, with all years included. + + Returns + ------- + xr.DataArray, [dimensionless] + Relative frequency of values {op} {thresh}. + """ + # mask of the ocean with NaNs + mask = ~(da.isel({group.dim: 0}).isnull()).drop_vars(group.dim) + ops: dict[str, np.ufunc] = { + ">": np.greater, + "<": np.less, + ">=": np.greater_equal, + "<=": np.less_equal, + } + t = convert_units_to(thresh, da) # , context="infer") + length = da.sizes[group.dim] + cond = ops[op](da, t) + if group.prop != "group": # change the time resolution if necessary + cond = cond.groupby(group.name) + # length of the groupBy groups + length = np.array([len(v) for k, v in cond.groups.items()]) + for _ in range(da.ndim - 1): # add empty dimension(s) to match input + length = np.expand_dims(length, axis=-1) + # count days with the condition and divide by total nb of days + out = cond.sum(dim=group.dim, skipna=False) / length + out = out.where(mask, np.nan) + out.attrs["units"] = "" + return out + + +relative_frequency = StatisticalProperty( + identifier="relative_frequency", aspect="temporal", compute=_relative_frequency +) + + +@parse_group +def _transition_probability( + da: xr.DataArray, + *, + initial_op: str = ">=", + final_op: str = ">=", + thresh: str = "1 mm d-1", + group: str | Grouper = "time", +) -> xr.DataArray: + """Transition probability. + + Probability of transition from the initial state to the final state. The states are + booleans comparing the value of the day to the threshold with the operator. + + The transition occurs when consecutive days are both in the given states. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + initial_op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Operation to verify the condition for the initial state. + The condition is variable {op} threshold. + final_op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Operation to verify the condition for the final state. + The condition is variable {op} threshold. + thresh : str + Threshold on which to evaluate the condition. + group : {"time", "time.season", "time.month"} + Grouping on the output. + e.g. For "time.month", the transition probability would be calculated on each month, with all years included. + + Returns + ------- + xr.DataArray, [dimensionless] + Transition probability of values {initial_op} {thresh} to values {final_op} {thresh}. + """ + # mask of the ocean with NaNs + mask = ~(da.isel({group.dim: 0}).isnull()).drop_vars(group.dim) + + today = da.isel(time=slice(0, -1)) + tomorrow = da.shift(time=-1).isel(time=slice(0, -1)) + + t = convert_units_to(thresh, da) # , context="infer") + cond = compare(today, initial_op, t) * compare(tomorrow, final_op, t) + out = group.apply("mean", cond) + out = out.where(mask, np.nan) + out.attrs["units"] = "" + return out + + +transition_probability = StatisticalProperty( + identifier="transition_probability", + aspect="temporal", + compute=_transition_probability, +) + + +@parse_group +def _trend( + da: xr.DataArray, + *, + group: str | Grouper = "time", + output: str = "slope", +) -> xr.DataArray: + """Linear Trend. + + The data is averaged over each time resolution and the inter-annual trend is returned. + This function will rechunk along the grouping dimension. + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + output : {'slope', 'intercept', 'rvalue', 'pvalue', 'stderr', 'intercept_stderr'} + The attributes of the linear regression to return, as defined in scipy.stats.linregress: + 'slope' is the slope of the regression line. + 'intercept' is the intercept of the regression line. + 'rvalue' is The Pearson correlation coefficient. + The square of rvalue is equal to the coefficient of determination. + 'pvalue' is the p-value for a hypothesis test whose null hypothesis is that the slope is zero, + using Wald Test with t-distribution of the test statistic. + 'stderr' is the standard error of the estimated slope (gradient), under the assumption of residual normality. + 'intercept_stderr' is the standard error of the estimated intercept, under the assumption of residual normality. + group : {'time', 'time.season', 'time.month'} + Grouping on the output. + + Returns + ------- + xr.DataArray, [units of input per year or dimensionless] + {output} of the interannual linear trend. + + See Also + -------- + scipy.stats.linregress + + numpy.polyfit + """ + units = da.units + + da = da.resample({group.dim: group.freq}) # separate all the {group} + da_mean = da.mean(dim=group.dim) # avg over all {group} + if uses_dask(da_mean): + da_mean = da_mean.chunk({group.dim: -1}) + if group.prop != "group": + da_mean = da_mean.groupby(group.name) # group all month/season together + + def modified_lr( + x, + ): # modify linregress to fit into apply_ufunc and only return slope + return getattr(stats.linregress(list(range(len(x))), x), output) + + out = xr.apply_ufunc( + modified_lr, + da_mean, + input_core_dims=[[group.dim]], + vectorize=True, + dask="parallelized", + ) + out.attrs["units"] = f"{units}/year" + return out + + +trend = StatisticalProperty(identifier="trend", aspect="temporal", compute=_trend) + + +@parse_group +def _return_value( + da: xr.DataArray, + *, + period: int = 20, + op: str = "max", + method: str = "ML", + group: str | Grouper = "time", +) -> xr.DataArray: + r"""Return value. + + Return the value corresponding to a return period. On average, the return value will be exceeded + (or not exceed for op='min') every return period (e.g. 20 years). The return value is computed by first extracting + the variable annual maxima/minima, fitting a statistical distribution to the maxima/minima, + then estimating the percentile associated with the return period (eg. 95th percentile (1/20) for 20 years) + + Parameters + ---------- + da : xr.DataArray + Variable on which to calculate the diagnostic. + period : int + Return period. Number of years over which to check if the value is exceeded (or not for op='min'). + op : {'max','min'} + Whether we are looking for a probability of exceedance ('max', right side of the distribution) + or a probability of non-exceedance (min, left side of the distribution). + method : {"ML", "PWM"} + Fitting method, either maximum likelihood (ML) or probability weighted moments (PWM), also called L-Moments. + The PWM method is usually more robust to outliers. + group : {'time', 'time.season', 'time.month'} + Grouping of the output. A distribution of the extremes is done for each group. + + Returns + ------- + xr.DataArray, [same as input] + {period}-{group.prop_name} {op} return level of the variable. + """ + + @map_groups(out=[Grouper.PROP], main_only=True) + def frequency_analysis_method(ds, *, dim, method): + sub = select_resample_op(ds.x, op=op) + params = fit(sub, dist="genextreme", method=method) + out = parametric_quantile(params, q=1 - 1.0 / period) + return out.isel(quantile=0, drop=True).rename("out").to_dataset() + + out = frequency_analysis_method( + da.rename("x").to_dataset(), method=method, group=group + ).out + return out.assign_attrs(units=da.units) + + +return_value = StatisticalProperty( + identifier="return_value", aspect="temporal", compute=_return_value +) + + +@parse_group +def _spatial_correlogram( + da: xr.DataArray, + *, + dims: Sequence[str] | None = None, + bins: int = 100, + group: str = "time", + method: int = 1, +): + """Spatial correlogram. + + Compute the pairwise spatial correlations (Spearman) and averages them based on the pairwise distances. + This collapses the spatial and temporal dimensions and returns a distance bins dimension. + Needs coordinates for longitude and latitude. This property is heavy to compute, and it will + need to create a NxN array in memory (outside of dask), where N is the number of spatial points. + There are shortcuts for all-nan time-slices or spatial points, but scipy's nan-omitting algorithm + is extremely slow, so the presence of any lone NaN will increase the computation time. Based on an idea + from :cite:p:`francois_multivariate_2020`. + + Parameters + ---------- + da : xr.DataArray + Data. + dims : sequence of strings, optional + Name of the spatial dimensions. Once these are stacked, the longitude and latitude coordinates must be 1D. + bins : int + Same as argument `bins` from :py:meth:`xarray.DataArray.groupby_bins`. + If given as a scalar, the equal-width bin limits are generated here + (instead of letting xarray do it) to improve performance. + group : str + Useless for now. + + Returns + ------- + xr.DataArray, [dimensionless] + Inter-site correlogram as a function of distance. + """ + if dims is None: + dims = [d for d in da.dims if d != "time"] + + corr = _pairwise_spearman(da, dims) + dists, mn, mx = _pairwise_haversine_and_bins( + corr.cf["longitude"].values, corr.cf["latitude"].values + ) + dists = xr.DataArray(dists, dims=corr.dims, coords=corr.coords, name="distance") + if np.isscalar(bins): + bins = np.linspace(mn * 0.9999, mx * 1.0001, bins + 1) + if uses_dask(corr): + dists = dists.chunk() + + w = np.diff(bins) + centers = xr.DataArray( + bins[:-1] + w / 2, + dims=("distance_bins",), + attrs={ + "units": "km", + "long_name": f"Centers of the intersite distance bins (width of {w[0]:.3f} km)", + }, + ) + + dists = dists.where(corr.notnull()) + + def _bin_corr(corr, distance): + """Bin and mean.""" + return stats.binned_statistic( + distance.flatten(), corr.flatten(), statistic="mean", bins=bins + ).statistic + + # (_spatial, _spatial2) -> (_spatial, distance_bins) + binned = xr.apply_ufunc( + _bin_corr, + corr, + dists, + input_core_dims=[["_spatial", "_spatial2"], ["_spatial", "_spatial2"]], + output_core_dims=[["distance_bins"]], + dask="parallelized", + vectorize=True, + output_dtypes=[float], + dask_gufunc_kwargs={ + "allow_rechunk": True, + "output_sizes": {"distance_bins": bins}, + }, + ) + binned = ( + binned.assign_coords(distance_bins=centers) + .rename(distance_bins="distance") + .assign_attrs(units="") + .rename("corr") + ) + return binned + + +spatial_correlogram = StatisticalProperty( + identifier="spatial_correlogram", + aspect="spatial", + compute=_spatial_correlogram, + allowed_groups=["group"], +) + + +def _decorrelation_length( + da: xr.DataArray, + *, + radius: int | float = 300, + thresh: float = 0.50, + dims: Sequence[str] | None = None, + bins: int = 100, + group: xr.Coordinate | str | None = "time", # FIXME: this needs to be clarified +): + """Decorrelation length. + + Distance from a grid cell where the correlation with its neighbours goes below the threshold. + A correlogram is calculated for each grid cell following the method from + ``xclim.sdba.properties.spatial_correlogram``. Then, we find the first bin closest to the correlation threshold. + + Parameters + ---------- + da : xr.DataArray + Data. + radius : float + Radius (in km) defining the region where correlations will be calculated between a point and its neighbours. + thresh : float + Threshold correlation defining decorrelation. + The decorrelation length is defined as the center of the distance bin that has a correlation closest + to this threshold. + dims : sequence of strings + Name of the spatial dimensions. Once these are stacked, the longitude and latitude coordinates must be 1D. + bins : int + Same as argument `bins` from :py:meth:`scipy.stats.binned_statistic`. + If given as a scalar, the equal-width bin limits from 0 to radius are generated here + (instead of letting scipy do it) to improve performance. + group : xarray.Coordinate or str, optional + Useless for now. + + Returns + ------- + xr.DataArray, [km] + Decorrelation length. + + Notes + ----- + Calculating this property requires a lot of memory. It will not work with large datasets. + """ + if dims is None and group is not None: + dims = [d for d in da.dims if d != group.dim] + + corr = _pairwise_spearman(da, dims) + + dists, _, _ = _pairwise_haversine_and_bins( + corr.cf["longitude"].values, corr.cf["latitude"].values, transpose=True + ) + + dists = xr.DataArray(dists, dims=corr.dims, coords=corr.coords, name="distance") + + trans_dists = xr.DataArray( + dists.T, dims=corr.dims, coords=corr.coords, name="distance" + ) + + if np.isscalar(bins): + bin_array = np.linspace(0, radius, bins + 1) + elif isinstance(bins, np.ndarray): + bin_array = bins + else: + raise ValueError("bins must be a scalar or a numpy array.") + + if uses_dask(corr): + dists = dists.chunk() + trans_dists = trans_dists.chunk() + + w = np.diff(bin_array) + centers = xr.DataArray( + bin_array[:-1] + w / 2, + dims=("distance_bins",), + attrs={ + "units": "km", + "long_name": f"Centers of the intersite distance bins (width of {w[0]:.3f} km)", + }, + ) + ds = xr.Dataset({"corr": corr, "distance": dists, "distance2": trans_dists}) + + # only keep points inside the radius + ds = ds.where(ds.distance < radius) + ds = ds.where(ds.distance2 < radius) + + def _bin_corr(_corr, _distance): + """Bin and mean.""" + mask_nan = ~np.isnan(_corr) + binned_corr = stats.binned_statistic( + _distance[mask_nan], _corr[mask_nan], statistic="mean", bins=bin_array + ) + stat = binned_corr.statistic + return stat + + # (_spatial, _spatial2) -> (_spatial, distance_bins) + binned = ( + xr.apply_ufunc( + _bin_corr, + ds.corr, + ds.distance, + input_core_dims=[["_spatial2"], ["_spatial2"]], + output_core_dims=[["distance_bins"]], + dask="parallelized", + vectorize=True, + output_dtypes=[float], + dask_gufunc_kwargs={ + "allow_rechunk": True, + "output_sizes": {"distance_bins": len(bin_array)}, + }, + ) + .rename("corr") + .to_dataset() + ) + + binned = ( + binned.assign_coords(distance_bins=centers) + .rename(distance_bins="distance") + .assign_attrs(units="") + ) + + closest = abs(binned.corr - thresh).idxmin(dim="distance") + binned["decorrelation_length"] = closest + + # get back to 2d lat and lon + # if 'lat' in dims and 'lon' in dims: + if len(dims) > 1: + binned = binned.set_index({"_spatial": dims}) + out = binned.decorrelation_length.unstack() + else: + out = binned.swap_dims({"_spatial": dims[0]}).decorrelation_length + + copy_all_attrs(out, da) + + out.attrs["units"] = "km" + return out + + +decorrelation_length = StatisticalProperty( + identifier="decorrelation_length", + aspect="spatial", + compute=_decorrelation_length, + allowed_groups=["group"], +) + + +def first_eof(): + """EOF Statistical Property (function removed). + + Warnings + -------- + Due to a licensing issue, eofs-based functionality has been permanently removed. + Please excuse the inconvenience. + For more information, see: https://github.com/Ouranosinc/xclim/issues/1620 + """ + raise RuntimeError( + "Due to a licensing issue, eofs-based functionality has been permanently removed. " + "Please excuse the inconvenience. " + "For more information, see: https://github.com/Ouranosinc/xclim/issues/1620" + ) diff --git a/src/xsdba/typing.py b/src/xsdba/typing.py new file mode 100644 index 0000000..ac96ad2 --- /dev/null +++ b/src/xsdba/typing.py @@ -0,0 +1,133 @@ +"""# noqa: SS01 +Typing Utilities +=================================== +""" + +from __future__ import annotations + +from enum import IntEnum +from typing import NewType, TypeVar + +import xarray as xr +from pint import Quantity + +# XC: +#: Type annotation for strings representing full dates (YYYY-MM-DD), may include time. +DateStr = NewType("DateStr", str) + +#: Type annotation for strings representing dates without a year (MM-DD). +DayOfYearStr = NewType("DayOfYearStr", str) + +#: Type annotation for thresholds and other not-exactly-a-variable quantities +Quantified = TypeVar("Quantified", xr.DataArray, str, Quantity) + + +# XC +class InputKind(IntEnum): + """Constants for input parameter kinds. + + For use by external parses to determine what kind of data the indicator expects. + On the creation of an indicator, the appropriate constant is stored in + :py:attr:`xclim.core.indicator.Indicator.parameters`. The integer value is what gets stored in the output + of :py:meth:`xclim.core.indicator.Indicator.json`. + + For developers : for each constant, the docstring specifies the annotation a parameter of an indice function + should use in order to be picked up by the indicator constructor. Notice that we are using the annotation format + as described in `PEP 604 `_, i.e. with '|' indicating a union and without import + objects from `typing`. + """ + + VARIABLE = 0 + """A data variable (DataArray or variable name). + + Annotation : ``xr.DataArray``. + """ + OPTIONAL_VARIABLE = 1 + """An optional data variable (DataArray or variable name). + + Annotation : ``xr.DataArray | None``. The default should be None. + """ + QUANTIFIED = 2 + """A quantity with units, either as a string (scalar), a pint.Quantity (scalar) or a DataArray (with units set). + + Annotation : ``xclim.core.utils.Quantified`` and an entry in the :py:func:`xclim.core.units.declare_units` + decorator. "Quantified" translates to ``str | xr.DataArray | pint.util.Quantity``. + """ + FREQ_STR = 3 + """A string representing an "offset alias", as defined by pandas. + + See the Pandas documentation on :ref:`timeseries.offset_aliases` for a list of valid aliases. + + Annotation : ``str`` + ``freq`` as the parameter name. + """ + NUMBER = 4 + """A number. + + Annotation : ``int``, ``float`` and unions thereof, potentially optional. + """ + STRING = 5 + """A simple string. + + Annotation : ``str`` or ``str | None``. In most cases, this kind of parameter makes sense + with choices indicated in the docstring's version of the annotation with curly braces. + See :ref:`notebooks/extendxclim:Defining new indices`. + """ + DAY_OF_YEAR = 6 + """A date, but without a year, in the MM-DD format. + + Annotation : :py:obj:`xclim.core.utils.DayOfYearStr` (may be optional). + """ + DATE = 7 + """A date in the YYYY-MM-DD format, may include a time. + + Annotation : :py:obj:`xclim.core.utils.DateStr` (may be optional). + """ + NUMBER_SEQUENCE = 8 + """A sequence of numbers + + Annotation : ``Sequence[int]``, ``Sequence[float]`` and unions thereof, may include single ``int`` and ``float``, + may be optional. + """ + BOOL = 9 + """A boolean flag. + + Annotation : ``bool``, may be optional. + """ + DICT = 10 + """A dictionary. + + Annotation : ``dict`` or ``dict | None``, may be optional. + """ + KWARGS = 50 + """A mapping from argument name to value. + + Developers : maps the ``**kwargs``. Please use as little as possible. + """ + DATASET = 70 + """An xarray dataset. + + Developers : as indices only accept DataArrays, this should only be added on the indicator's constructor. + """ + OTHER_PARAMETER = 99 + """An object that fits None of the previous kinds. + + Developers : This is the fallback kind, it will raise an error in xclim's unit tests if used. + """ + + +KIND_ANNOTATION = { + InputKind.VARIABLE: "str or DataArray", + InputKind.OPTIONAL_VARIABLE: "str or DataArray, optional", + InputKind.QUANTIFIED: "quantity (string or DataArray, with units)", + InputKind.FREQ_STR: "offset alias (string)", + InputKind.NUMBER: "number", + InputKind.NUMBER_SEQUENCE: "number or sequence of numbers", + InputKind.STRING: "str", + InputKind.DAY_OF_YEAR: "date (string, MM-DD)", + InputKind.DATE: "date (string, YYYY-MM-DD)", + InputKind.BOOL: "boolean", + InputKind.DICT: "dict", + InputKind.DATASET: "Dataset, optional", + InputKind.KWARGS: "", + InputKind.OTHER_PARAMETER: "Any", +} diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 634d9a0..484182f 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -19,14 +19,75 @@ except ImportError: # noqa: S110 # cf-xarray is not installed, this will not be used pass +import warnings + import numpy as np import xarray as xr -from .base import Quantified, copy_all_attrs +from .calendar import parse_offset +from .typing import Quantified +from .utils import copy_all_attrs units = pint.get_application_registry() +FREQ_UNITS = { + "D": "d", + "W": "week", +} +""" +Resampling frequency units for :py:func:`xclim.core.units.infer_sampling_units`. + +Mapping from offset base to CF-compliant unit. Only constant-length frequencies are included. +""" + + +def infer_sampling_units( + da: xr.DataArray, + deffreq: str | None = "D", + dim: str = "time", +) -> tuple[int, str]: + """Infer a multiplier and the units corresponding to one sampling period. + + Parameters + ---------- + da : xr.DataArray + A DataArray from which to take coordinate `dim`. + deffreq : str, optional + If no frequency is inferred from `da[dim]`, take this one. + dim : str + Dimension from which to infer the frequency. + + Raises + ------ + ValueError + If the frequency has no exact corresponding units. + + Returns + ------- + int + The magnitude (number of base periods per period) + str + Units as a string, understandable by pint. + """ + dimmed = getattr(da, dim) + freq = xr.infer_freq(dimmed) + if freq is None: + freq = deffreq + + multi, base, _, _ = parse_offset(freq) + try: + out = multi, FREQ_UNITS.get(base, base) + except KeyError as err: + raise ValueError( + f"Sampling frequency {freq} has no corresponding units." + ) from err + if out == (7, "d"): + # Special case for weekly frequency. xarray's CFTimeOffsets do not have "W". + return 1, "week" + return out + + # XC def units2pint(value: xr.DataArray | str | units.Quantity) -> pint.Unit: """Return the pint Unit for the DataArray units. @@ -97,28 +158,73 @@ def str2pint(val: str) -> pint.Quantity: return units.Quantity(1, units2pint(val)) -# XC -# def ensure_delta(unit: str) -> str: -# """Return delta units for temperature. - -# For dimensions where delta exist in pint (Temperature), it replaces the temperature unit by delta_degC or -# delta_degF based on the input unit. For other dimensionality, it just gives back the input units. - -# Parameters -# ---------- -# unit : str -# unit to transform in delta (or not) -# """ -# u = units2pint(unit) -# d = 1 * u -# # -# delta_unit = pint2cfunits(d - d) -# # replace kelvin/rankine by delta_degC/F -# if "kelvin" in u._units: -# delta_unit = pint2cfunits(u / units2pint("K") * units2pint("delta_degC")) -# if "degree_Rankine" in u._units: -# delta_unit = pint2cfunits(u / units2pint("°R") * units2pint("delta_degF")) -# return delta_unit +def pint2str(value: units.Quantity | units.Unit) -> str: + """A unit string from a `pint` unit. + + Parameters + ---------- + value : pint.Unit + Input unit. + + Returns + ------- + str + Units + + Notes + ----- + If cf-xarray is installed, the units will be converted to cf units. + """ + if isinstance(value, (pint.Quantity, units.Quantity)): + value = value.units + + # Issue originally introduced in https://github.com/hgrecco/pint/issues/1486 + # Should be resolved in pint v0.24. See: https://github.com/hgrecco/pint/issues/1913 + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=DeprecationWarning) + return f"{value:cf}".replace("dimensionless", "") + + +DELTA_ABSOLUTE_TEMP = { + units.delta_degC: units.kelvin, + units.delta_degF: units.rankine, +} + + +def ensure_absolute_temperature(units: str): + """Convert temperature units to their absolute counterpart, assuming they represented a difference (delta). + + Celsius becomes Kelvin, Fahrenheit becomes Rankine. Does nothing for other units. + """ + a = str2pint(units) + # ensure a delta pint unit + a = a - 0 * a + if a.units in DELTA_ABSOLUTE_TEMP: + return pint2str(DELTA_ABSOLUTE_TEMP[a.units]) + return units + + +def ensure_delta(unit: str) -> str: + """Return delta units for temperature. + + For dimensions where delta exist in pint (Temperature), it replaces the temperature unit by delta_degC or + delta_degF based on the input unit. For other dimensionality, it just gives back the input units. + + Parameters + ---------- + unit : str + unit to transform in delta (or not) + """ + u = units2pint(unit) + d = 1 * u + # + delta_unit = pint2str(d - d) + # replace kelvin/rankine by delta_degC/F + if "kelvin" in u._units: + delta_unit = pint2str(u / units2pint("K") * units2pint("delta_degC")) + if "degree_Rankine" in u._units: + delta_unit = pint2str(u / units2pint("°R") * units2pint("delta_degF")) + return delta_unit def extract_units(arg): @@ -126,16 +232,15 @@ def extract_units(arg): if not ( isinstance(arg, (str, xr.DataArray, pint.Unit, units.Unit)) or np.isscalar(arg) ): - print(arg) raise TypeError( f"Argument must be a str, DataArray, or scalar. Got {type(arg)}" ) elif isinstance(arg, xr.DataArray): ustr = None if "units" not in arg.attrs else arg.attrs["units"] elif isinstance(arg, pint.Unit | units.Unit): - ustr = f"{arg:cf}" # XC: from pint2cfunits + ustr = pint2str(arg) # XC: from pint2str elif isinstance(arg, str): - ustr = str2pint(arg).units + ustr = pint2str(str2pint(arg).units) else: # (scalar case) ustr = None return ustr if ustr is None else pint.Quantity(1, ustr).units @@ -230,75 +335,6 @@ def convert_units_to( # noqa: C901 return out -def _fill_args_dict(args, kwargs, args_to_check, func): - """Combine args and kwargs into a dict.""" - args_dict = {} - signature = inspect.signature(func) - for ik, (k, v) in enumerate(signature.parameters.items()): - if ik < len(args): - value = args[ik] - if ik >= len(args): - value = v.default if k not in kwargs else kwargs[k] - args_dict[k] = value - return args_dict - - -def _split_args_kwargs(args, func): - """Assign Keyword only arguments to kwargs.""" - kwargs = {} - signature = inspect.signature(func) - indices_to_pop = [] - for ik, (k, v) in enumerate(signature.parameters.items()): - if v.kind == inspect.Parameter.KEYWORD_ONLY: - indices_to_pop.append(ik) - kwargs[k] = v - indices_to_pop.sort(reverse=True) - for ind in indices_to_pop: - args.pop(ind) - return args, kwargs - - -# TODO: make it work with Dataset for real -# TODO: add a switch to prevent string from being converted to float? -def harmonize_units(args_to_check): - """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" - - # if no units are present (DataArray without units attribute or float), then no check is performed - # if units are present, then check is performed - # in mixed cases, an error is raised - def _decorator(func): - @wraps(func) - def _wrapper(*args, **kwargs): - arg_names = inspect.getfullargspec(func).args - args_dict = _fill_args_dict(list(args), kwargs, args_to_check, func) - first_arg_name = args_to_check[0] - first_arg = args_dict[first_arg_name] - for arg_name in args_to_check[1:]: - if isinstance(arg_name, str): - value = args_dict[arg_name] - key = arg_name - if isinstance( - arg_name, dict - ): # support for Dataset, or a dict of thresholds - key, val = list(arg_name.keys())[0], list(arg_name.values())[0] - value = args_dict[key][val] - if value is None: # optional argument, should be ignored - args_to_check.remove(arg_name) - continue - if key not in args_dict: - raise ValueError( - f"Argument '{arg_name}' not found in function arguments." - ) - args_dict[key] = convert_units_to(value, first_arg) - args = list(args_dict.values()) - args, kwargs = _split_args_kwargs(args, kwargs, func) - return func(*args, **kwargs) - - return _wrapper - - return _decorator - - def _add_default_kws(params_dict, params_to_check, func): """Combine args and kwargs into a dict.""" args_dict = {} @@ -361,3 +397,107 @@ def _wrapper(*args, **kwargs): return _wrapper return _decorator + + +def to_agg_units( + out: xr.DataArray, orig: xr.DataArray, op: str, dim: str = "time" +) -> xr.DataArray: + """Set and convert units of an array after an aggregation operation along the sampling dimension (time). + + Parameters + ---------- + out : xr.DataArray + The output array of the aggregation operation, no units operation done yet. + orig : xr.DataArray + The original array before the aggregation operation, + used to infer the sampling units and get the variable units. + op : {'min', 'max', 'mean', 'std', 'var', 'doymin', 'doymax', 'count', 'integral', 'sum'} + The type of aggregation operation performed. "integral" is mathematically equivalent to "sum", + but the units are multiplied by the timestep of the data (requires an inferrable frequency). + dim : str + The time dimension along which the aggregation was performed. + + Returns + ------- + xr.DataArray + + Examples + -------- + Take a daily array of temperature and count number of days above a threshold. + `to_agg_units` will infer the units from the sampling rate along "time", so + we ensure the final units are correct: + + >>> time = xr.cftime_range("2001-01-01", freq="D", periods=365) + >>> tas = xr.DataArray( + ... np.arange(365), + ... dims=("time",), + ... coords={"time": time}, + ... attrs={"units": "degC"}, + ... ) + >>> cond = tas > 100 # Which days are boiling + >>> Ndays = cond.sum("time") # Number of boiling days + >>> Ndays.attrs.get("units") + None + >>> Ndays = to_agg_units(Ndays, tas, op="count") + >>> Ndays.units + 'd' + + Similarly, here we compute the total heating degree-days, but we have weekly data: + + >>> time = xr.cftime_range("2001-01-01", freq="7D", periods=52) + >>> tas = xr.DataArray( + ... np.arange(52) + 10, + ... dims=("time",), + ... coords={"time": time}, + ... ) + >>> dt = (tas - 16).assign_attrs(units="delta_degC") + >>> degdays = dt.clip(0).sum("time") # Integral of temperature above a threshold + >>> degdays = to_agg_units(degdays, dt, op="integral") + >>> degdays.units + 'K week' + + Which we can always convert to the more common "K days": + + >>> degdays = convert_units_to(degdays, "K days") + >>> degdays.units + 'K d' + """ + if op in ["amin", "min", "amax", "max", "mean", "sum"]: + out.attrs["units"] = orig.attrs["units"] + + elif op in ["std"]: + out.attrs["units"] = ensure_absolute_temperature(orig.attrs["units"]) + + elif op in ["var"]: + out.attrs["units"] = pint2str( + str2pint(ensure_absolute_temperature(orig.units)) ** 2 + ) + + elif op in ["doymin", "doymax"]: + out.attrs.update( + units="", is_dayofyear=np.int32(1), calendar=get_calendar(orig) + ) + + elif op in ["count", "integral"]: + m, freq_u_raw = infer_sampling_units(orig[dim]) + orig_u = str2pint(ensure_absolute_temperature(orig.units)) + freq_u = str2pint(freq_u_raw) + out = out * m + + if op == "count": + out.attrs["units"] = freq_u_raw + elif op == "integral": + if "[time]" in orig_u.dimensionality: + # We need to simplify units after multiplication + out_units = (orig_u * freq_u).to_reduced_units() + out = out * out_units.magnitude + out.attrs["units"] = pint2str(out_units) + else: + out.attrs["units"] = pint2str(orig_u * freq_u) + else: + raise ValueError( + f"Unknown aggregation op {op}. " + "Known ops are [min, max, mean, std, var, doymin, doymax, count, integral, sum]." + ) + + return out diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index b816f80..34dcdfb 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -955,16 +955,6 @@ def rand_rot_matrix( ).astype("float32") -def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): - """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" - ds.attrs.update(ref.attrs) - extras = ds.variables if isinstance(ds, xr.Dataset) else ds.coords - others = ref.variables if isinstance(ref, xr.Dataset) else ref.coords - for name, var in extras.items(): - if name in others: - var.attrs.update(ref[name].attrs) - - def _pairwise_spearman(da, dims): """Area-averaged pairwise temporal correlation. @@ -1016,3 +1006,47 @@ def _skipna_correlation(data): "allow_rechunk": True, }, ).rename("correlation") + + +# ADAPT: Maybe this is not the best place +def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): + """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" + ds.attrs.update(ref.attrs) + extras = ds.variables if isinstance(ds, xr.Dataset) else ds.coords + others = ref.variables if isinstance(ref, xr.Dataset) else ref.coords + for name, var in extras.items(): + if name in others: + var.attrs.update(ref[name].attrs) + + +# ADAPT: Maybe this is not the best place +def load_module(path: os.PathLike, name: str | None = None): + """Load a python module from a python file, optionally changing its name. + + Examples + -------- + Given a path to a module file (.py): + + .. code-block:: python + + from pathlib import Path + import os + + path = Path("path/to/example.py") + + The two following imports are equivalent, the second uses this method. + + .. code-block:: python + + os.chdir(path.parent) + import example as mod1 + + os.chdir(previous_working_dir) + mod2 = load_module(path) + mod1 == mod2 + """ + path = Path(path) + spec = importlib.util.spec_from_file_location(name or path.stem, path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) # This executes code, effectively loading the module + return mod diff --git a/src/xsdba/xclim_submodules/generic.py b/src/xsdba/xclim_submodules/generic.py new file mode 100644 index 0000000..91697d3 --- /dev/null +++ b/src/xsdba/xclim_submodules/generic.py @@ -0,0 +1,941 @@ +""" +Generic Indices Submodule +========================= + +Helper functions for common generic actions done in the computation of indices. +""" + +from __future__ import annotations + +import warnings +from collections.abc import Sequence +from typing import Callable + +import cftime +import numpy as np +import xarray +import xarray as xr +from xarray.coding.cftime_offsets import _MONTH_ABBREVIATIONS + +from xsdba.calendar import doy_to_days_since, get_calendar, select_time +from xsdba.typing import DayOfYearStr, Quantified, Quantity +from xsdba.units import ( + convert_units_to, + harmonize_units, + pint2str, + str2pint, + to_agg_units, +) + +from . import run_length as rl + +__all__ = [ + "aggregate_between_dates", + "binary_ops", + "compare", + "count_level_crossings", + "count_occurrences", + "cumulative_difference", + "default_freq", + "detrend", + "diurnal_temperature_range", + "domain_count", + "doymax", + "doymin", + "extreme_temperature_range", + "first_day_threshold_reached", + "first_occurrence", + "get_daily_events", + "get_op", + "get_zones", + "interday_diurnal_temperature_range", + "last_occurrence", + "select_resample_op", + "spell_length", + "statistics", + "temperature_sum", + "threshold_count", + "thresholded_statistics", +] + +binary_ops = {">": "gt", "<": "lt", ">=": "ge", "<=": "le", "==": "eq", "!=": "ne"} + + +def select_resample_op( + da: xr.DataArray, op: str, freq: str = "YS", out_units=None, **indexer +) -> xr.DataArray: + """Apply operation over each period that is part of the index selection. + + Parameters + ---------- + da : xr.DataArray + Input data. + op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral', 'argmax', 'argmin'} or func + Reduce operation. Can either be a DataArray method or a function that can be applied to a DataArray. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + out_units : str, optional + Output units to assign. Only necessary if `op` is function not supported by :py:func:`xclim.core.units.to_agg_units`. + indexer : {dim: indexer, }, optional + Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, + month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are + considered. + + Returns + ------- + xr.DataArray + The maximum value for each period. + """ + da = select_time(da, **indexer) + r = da.resample(time=freq) + if op in _xclim_ops: + op = _xclim_ops[op] + if isinstance(op, str): + out = getattr(r, op.replace("integral", "sum"))(dim="time", keep_attrs=True) + else: + with xr.set_options(keep_attrs=True): + out = r.map(op) + op = op.__name__ + if out_units is not None: + return out.assign_attrs(units=out_units) + return to_agg_units(out, da, op) + + +def select_rolling_resample_op( + da: xr.DataArray, + op: str, + window: int, + window_center: bool = True, + window_op: str = "mean", + freq: str = "YS", + out_units=None, + **indexer, +) -> xr.DataArray: + """Apply operation over each period that is part of the index selection, using a rolling window before the operation. + + Parameters + ---------- + da : xr.DataArray + Input data. + op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral', 'argmax', 'argmin'} or func + Reduce operation. Can either be a DataArray method or a function that can be applied to a DataArray. + window : int + Size of the rolling window (centered). + window_center : bool + If True, the window is centered on the date. If False, the window is right-aligned. + window_op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral'} + Operation to apply to the rolling window. Default: 'mean'. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. Applied after the rolling window. + out_units : str, optional + Output units to assign. Only necessary if `op` is function not supported by :py:func:`xclim.core.units.to_agg_units`. + indexer : {dim: indexer, }, optional + Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, + month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are + considered. + + Returns + ------- + xr.DataArray + The array for which the operation has been applied over each period. + """ + rolled = getattr( + da.rolling(time=window, center=window_center), + window_op.replace("integral", "sum"), + )() + rolled = to_agg_units(rolled, da, window_op) + return select_resample_op(rolled, op=op, freq=freq, out_units=out_units, **indexer) + + +def doymax(da: xr.DataArray) -> xr.DataArray: + """Return the day of year of the maximum value.""" + i = da.argmax(dim="time") + out = da.time.dt.dayofyear.isel(time=i, drop=True) + return to_agg_units(out, da, "doymax") + + +def doymin(da: xr.DataArray) -> xr.DataArray: + """Return the day of year of the minimum value.""" + i = da.argmin(dim="time") + out = da.time.dt.dayofyear.isel(time=i, drop=True) + return to_agg_units(out, da, "doymin") + + +_xclim_ops = {"doymin": doymin, "doymax": doymax} + + +def default_freq(**indexer) -> str: + """Return the default frequency.""" + freq = "YS-JAN" + if indexer: + group, value = indexer.popitem() + if group == "season": + month = 12 # The "season" scheme is based on YS-DEC + elif group == "month": + month = np.take(value, 0) + elif group == "doy_bounds": + month = cftime.num2date(value[0] - 1, "days since 2004-01-01").month + elif group == "date_bounds": + month = int(value[0][:2]) + else: + raise ValueError(f"Unknown group `{group}`.") + freq = "YS-" + _MONTH_ABBREVIATIONS[month] + return freq + + +def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: + """Get python's comparing function according to its name of representation and validate allowed usage. + + Accepted op string are keys and values of xclim.indices.generic.binary_ops. + + Parameters + ---------- + op : str + Operator. + constrain : sequence of str, optional + A tuple of allowed operators. + """ + if op == "gteq": + warnings.warn(f"`{op}` is being renamed `ge` for compatibility.") + op = "ge" + if op == "lteq": + warnings.warn(f"`{op}` is being renamed `le` for compatibility.") + op = "le" + + if op in binary_ops.keys(): + binary_op = binary_ops[op] + elif op in binary_ops.values(): + binary_op = op + else: + raise ValueError(f"Operation `{op}` not recognized.") + + constraints = list() + if isinstance(constrain, (list, tuple, set)): + constraints.extend([binary_ops[c] for c in constrain]) + constraints.extend(constrain) + elif isinstance(constrain, str): + constraints.extend([binary_ops[constrain], constrain]) + + if constrain: + if op not in constraints: + raise ValueError(f"Operation `{op}` not permitted for indice.") + + return xr.core.ops.get_op(binary_op) + + +def compare( + left: xr.DataArray, + op: str, + right: float | int | np.ndarray | xr.DataArray, + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + """Compare a dataArray to a threshold using given operator. + + Parameters + ---------- + left : xr.DataArray + A DatArray being evaluated against `right`. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + right : float, int, np.ndarray, or xr.DataArray + A value or array-like being evaluated against left`. + constrain : sequence of str, optional + Optionally allowed conditions. + + Returns + ------- + xr.DataArray + Boolean mask of the comparison. + """ + return get_op(op, constrain)(left, right) + + +def threshold_count( + da: xr.DataArray, + op: str, + threshold: float | int | xr.DataArray, + freq: str, + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + """Count number of days where value is above or below threshold. + + Parameters + ---------- + da : xr.DataArray + Input data. + op : {">", "<", ">=", "<=", "gt", "lt", "ge", "le"} + Logical operator. e.g. arr > thresh. + threshold : Union[float, int] + Threshold value. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + constrain : sequence of str, optional + Optionally allowed conditions. + + Returns + ------- + xr.DataArray + The number of days meeting the constraints for each period. + """ + if constrain is None: + constrain = (">", "<", ">=", "<=") + + c = compare(da, op, threshold, constrain) * 1 + return c.resample(time=freq).sum(dim="time") + + +def domain_count( + da: xr.DataArray, + low: float | int | xr.DataArray, + high: float | int | xr.DataArray, + freq: str, +) -> xr.DataArray: + """Count number of days where value is within low and high thresholds. + + A value is counted if it is larger than `low`, and smaller or equal to `high`, i.e. in `]low, high]`. + + Parameters + ---------- + da : xr.DataArray + Input data. + low : scalar or DataArray + Minimum threshold value. + high : scalar or DataArray + Maximum threshold value. + freq : str + Resampling frequency defining the periods defined in :ref:`timeseries.resampling`. + + Returns + ------- + xr.DataArray + The number of days where value is within [low, high] for each period. + """ + c = compare(da, ">", low) * compare(da, "<=", high) * 1 + return c.resample(time=freq).sum(dim="time") + + +def get_daily_events( + da: xr.DataArray, + threshold: float | int | xr.DataArray, + op: str, + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + """Return a 0/1 mask when a condition is True or False. + + Parameters + ---------- + da : xr.DataArray + Input data. + threshold : float + Threshold value. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + constrain : sequence of str, optional + Optionally allowed conditions. + + Notes + ----- + The function returns: + + - ``1`` where operator(da, da_value) is ``True`` + - ``0`` where operator(da, da_value) is ``False`` + - ``nan`` where da is ``nan`` + + Returns + ------- + xr.DataArray + """ + events = compare(da, op, threshold, constrain) * 1 + events = events.where(~(np.isnan(da))) + events = events.rename("events") + return events + + +# CF-INDEX-META Indices + + +@harmonize_units(["low_data", "high_data", "threshold"]) +def count_level_crossings( + low_data: xr.DataArray, + high_data: xr.DataArray, + threshold: Quantified, + freq: str, + *, + op_low: str = "<", + op_high: str = ">=", +) -> xr.DataArray: + """Calculate the number of times low_data is below threshold while high_data is above threshold. + + First, the threshold is transformed to the same standard_name and units as the input data, + then the thresholding is performed, and finally, the number of occurrences is counted. + + Parameters + ---------- + low_data : xr.DataArray + Variable that must be under the threshold. + high_data : xr.DataArray + Variable that must be above the threshold. + threshold : Quantified + Threshold. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + op_low : {"<", "<=", "lt", "le"} + Comparison operator for low_data. Default: "<". + op_high : {">", ">=", "gt", "ge"} + Comparison operator for high_data. Default: ">=". + + Returns + ------- + xr.DataArray + """ + # Convert units to low_data + lower = compare(low_data, op_low, threshold, constrain=("<", "<=")) + higher = compare(high_data, op_high, threshold, constrain=(">", ">=")) + + out = (lower & higher).resample(time=freq).sum() + return to_agg_units(out, low_data, "count", dim="time") + + +@harmonize_units(["data", "threshold"]) +def count_occurrences( + data: xr.DataArray, + threshold: Quantified, + freq: str, + op: str, + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + """Calculate the number of times some condition is met. + + First, the threshold is transformed to the same standard_name and units as the input data. + Then the thresholding is performed as condition(data, threshold), + i.e. if condition is `<`, then this counts the number of times `data < threshold`. + Finally, count the number of occurrences when condition is met. + + Parameters + ---------- + data : xr.DataArray + An array. + threshold : Quantified + Threshold. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + constrain : sequence of str, optional + Optionally allowed conditions. + + Returns + ------- + xr.DataArray + """ + cond = compare(data, op, threshold, constrain) + + out = cond.resample(time=freq).sum() + return to_agg_units(out, data, "count", dim="time") + + +@harmonize_units(["data", "threshold"]) +def first_occurrence( + data: xr.DataArray, + threshold: Quantified, + freq: str, + op: str, + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + """Calculate the first time some condition is met. + + First, the threshold is transformed to the same standard_name and units as the input data. + Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. + Finally, locate the first occurrence when condition is met. + + Parameters + ---------- + data : xr.DataArray + Input data. + threshold : Quantified + Threshold. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + constrain : sequence of str, optional + Optionally allowed conditions. + + Returns + ------- + xr.DataArray + """ + cond = compare(data, op, threshold, constrain) + + out = cond.resample(time=freq).map( + rl.first_run, + window=1, + dim="time", + coord="dayofyear", + ) + out.attrs["units"] = "" + return out + + +@harmonize_units(["data", "threshold"]) +def last_occurrence( + data: xr.DataArray, + threshold: Quantified, + freq: str, + op: str, + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + """Calculate the last time some condition is met. + + First, the threshold is transformed to the same standard_name and units as the input data. + Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. + Finally, locate the last occurrence when condition is met. + + Parameters + ---------- + data : xr.DataArray + Input data. + threshold : Quantified + Threshold. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + constrain : sequence of str, optional + Optionally allowed conditions. + + Returns + ------- + xr.DataArray + """ + cond = compare(data, op, threshold, constrain) + + out = cond.resample(time=freq).map( + rl.last_run, + window=1, + dim="time", + coord="dayofyear", + ) + out.attrs["units"] = "" + return out + + +@harmonize_units(["data", "threshold"]) +def spell_length( + data: xr.DataArray, threshold: Quantified, reducer: str, freq: str, op: str +) -> xr.DataArray: + """Calculate statistics on lengths of spells. + + First, the threshold is transformed to the same standard_name and units as the input data. + Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. + Then the spells are determined, and finally the statistics according to the specified reducer are calculated. + + Parameters + ---------- + data : xr.DataArray + Input data. + threshold : Quantified + Threshold. + reducer : {'max', 'min', 'mean', 'sum'} + Reducer. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + + Returns + ------- + xr.DataArray + """ + cond = compare(data, op, threshold) + + out = cond.resample(time=freq).map( + rl.rle_statistics, + reducer=reducer, + window=1, + dim="time", + ) + return to_agg_units(out, data, "count") + + +def statistics(data: xr.DataArray, reducer: str, freq: str) -> xr.DataArray: + """Calculate a simple statistic of the data. + + Parameters + ---------- + data : xr.DataArray + Input data. + reducer : {'max', 'min', 'mean', 'sum'} + Reducer. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + + Returns + ------- + xr.DataArray + """ + out = getattr(data.resample(time=freq), reducer)() + out.attrs["units"] = data.attrs["units"] + return out + + +@harmonize_units(["data", "threshold"]) +def thresholded_statistics( + data: xr.DataArray, + op: str, + threshold: Quantified, + reducer: str, + freq: str, + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + """Calculate a simple statistic of the data for which some condition is met. + + First, the threshold is transformed to the same standard_name and units as the input data. + Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. + Finally, the statistic is calculated for those data values that fulfill the condition. + + Parameters + ---------- + data : xr.DataArray + Input data. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + threshold : Quantified + Threshold. + reducer : {'max', 'min', 'mean', 'sum'} + Reducer. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + constrain : sequence of str, optional + Optionally allowed conditions. Default: None. + + Returns + ------- + xr.DataArray + """ + cond = compare(data, op, threshold, constrain) + + out = getattr(data.where(cond).resample(time=freq), reducer)() + out.attrs["units"] = data.attrs["units"] + return out + + +def aggregate_between_dates( + data: xr.DataArray, + start: xr.DataArray | DayOfYearStr, + end: xr.DataArray | DayOfYearStr, + op: str = "sum", + freq: str | None = None, +) -> xr.DataArray: + """Aggregate the data over a period between start and end dates and apply the operator on the aggregated data. + + Parameters + ---------- + data : xr.DataArray + Data to aggregate between start and end dates. + start : xr.DataArray or DayOfYearStr + Start dates (as day-of-year) for the aggregation periods. + end : xr.DataArray or DayOfYearStr + End (as day-of-year) dates for the aggregation periods. + op : {'min', 'max', 'sum', 'mean', 'std'} + Operator. + freq : str, optional + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. Default: `None`. + + Returns + ------- + xr.DataArray, [dimensionless] + Aggregated data between the start and end dates. If the end date is before the start date, returns np.nan. + If there is no start and/or end date, returns np.nan. + """ + + def _get_days(_bound, _group, _base_time): + """Get bound in number of days since base_time. Bound can be a days_since array or a DayOfYearStr.""" + if isinstance(_bound, str): + b_i = rl.index_of_date(_group.time, _bound, max_idxs=1) + if not b_i.size > 0: + return None + return (_group.time.isel(time=b_i[0]) - _group.time.isel(time=0)).dt.days + if _base_time in _bound.time: + return _bound.sel(time=_base_time) + return None + + if freq is None: + frequencies = [] + for bound in [start, end]: + try: + frequencies.append(xr.infer_freq(bound.time)) + except AttributeError: + frequencies.append(None) + + good_freq = set(frequencies) - {None} + + if len(good_freq) != 1: + raise ValueError( + f"Non-inferrable resampling frequency or inconsistent frequencies. Got start, end = {frequencies}." + " Please consider providing `freq` manually." + ) + freq = good_freq.pop() + + cal = get_calendar(data, dim="time") + + if not isinstance(start, str): + start = start.convert_calendar(cal) + start.attrs["calendar"] = cal + start = doy_to_days_since(start) + if not isinstance(end, str): + end = end.convert_calendar(cal) + end.attrs["calendar"] = cal + end = doy_to_days_since(end) + + out = [] + for base_time, indexes in data.resample(time=freq).groups.items(): + # get group slice + group = data.isel(time=indexes) + + start_d = _get_days(start, group, base_time) + end_d = _get_days(end, group, base_time) + + # convert bounds for this group + if start_d is not None and end_d is not None: + days = (group.time - base_time).dt.days + days[days < 0] = np.nan + + masked = group.where((days >= start_d) & (days <= end_d - 1)) + res = getattr(masked, op)(dim="time", skipna=True) + res = xr.where( + ((start_d > end_d) | (start_d.isnull()) | (end_d.isnull())), np.nan, res + ) + # Re-add the time dimension with the period's base time. + res = res.expand_dims(time=[base_time]) + out.append(res) + else: + # Get an array with the good shape, put nans and add the new time. + res = (group.isel(time=0) * np.nan).expand_dims(time=[base_time]) + out.append(res) + continue + + return xr.concat(out, dim="time") + + +@harmonize_units(["data", "threshold"]) +def cumulative_difference( + data: xr.DataArray, threshold: Quantified, op: str, freq: str | None = None +) -> xr.DataArray: + """Calculate the cumulative difference below/above a given value threshold. + + Parameters + ---------- + data : xr.DataArray + Data for which to determine the cumulative difference. + threshold : Quantified + The value threshold. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le"} + Logical operator. e.g. arr > thresh. + freq : str, optional + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + If `None`, no resampling is performed. Default: `None`. + + Returns + ------- + xr.DataArray + """ + if op in ["<", "<=", "lt", "le"]: + diff = (threshold - data).clip(0) + elif op in [">", ">=", "gt", "ge"]: + diff = (data - threshold).clip(0) + else: + raise NotImplementedError(f"Condition not supported: '{op}'.") + + if freq is not None: + diff = diff.resample(time=freq).sum(dim="time") + + return to_agg_units(diff, data, op="integral") + + +@harmonize_units(["data", "threshold"]) +def first_day_threshold_reached( + data: xr.DataArray, + *, + threshold: Quantified, + op: str, + after_date: DayOfYearStr, + window: int = 1, + freq: str = "YS", + constrain: Sequence[str] | None = None, +) -> xr.DataArray: + r"""First day of values exceeding threshold. + + Returns first day of period where values reach or exceed a threshold over a given number of days, + limited to a starting calendar date. + + Parameters + ---------- + data : xarray.DataArray + Dataset being evaluated. + threshold : str + Threshold on which to base evaluation. + op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} + Logical operator. e.g. arr > thresh. + after_date : str + Date of the year after which to look for the first event. Should have the format '%m-%d'. + window : int + Minimum number of days with values above threshold needed for evaluation. Default: 1. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + Default: "YS". + constrain : sequence of str, optional + Optionally allowed conditions. + + Returns + ------- + xarray.DataArray, [dimensionless] + Day of the year when value reaches or exceeds a threshold over a given number of days for the first time. + If there is no such day, returns np.nan. + """ + cond = compare(data, op, threshold, constrain=constrain) + + out: xarray.DataArray = cond.resample(time=freq).map( + rl.first_run_after_date, + window=window, + date=after_date, + dim="time", + coord="dayofyear", + ) + out.attrs.update(units="", is_dayofyear=np.int32(1), calendar=get_calendar(data)) + return out + + +def _get_zone_bins( + zone_min: Quantity, + zone_max: Quantity, + zone_step: Quantity, +): + """Bin boundary values as defined by zone parameters. + + Parameters + ---------- + zone_min : Quantity + Left boundary of the first zone + zone_max : Quantity + Right boundary of the last zone + zone_step: Quantity + Size of zones + + Returns + ------- + xarray.DataArray, [units of `zone_step`] + Array of values corresponding to each zone: [zone_min, zone_min+step, ..., zone_max] + """ + units = pint2str(str2pint(zone_step)) + mn, mx, step = ( + convert_units_to(str2pint(z), units) for z in [zone_min, zone_max, zone_step] + ) + bins = np.arange(mn, mx + step, step) + if (mx - mn) % step != 0: + warnings.warn( + "`zone_max` - `zone_min` is not an integer multiple of `zone_step`. Last zone will be smaller." + ) + bins[-1] = mx + return xr.DataArray(bins, attrs={"units": units}) + + +def get_zones( + da: xr.DataArray, + zone_min: Quantity | None = None, + zone_max: Quantity | None = None, + zone_step: Quantity | None = None, + bins: xr.DataArray | list[Quantity] | None = None, + exclude_boundary_zones: bool = True, + close_last_zone_right_boundary: bool = True, +) -> xr.DataArray: + r"""Divide data into zones and attribute a zone coordinate to each input value. + + Divide values into zones corresponding to bins of width zone_step beginning at zone_min and ending at zone_max. + Bins are inclusive on the left values and exclusive on the right values. + + Parameters + ---------- + da : xarray.DataArray + Input data + zone_min : Quantity | None + Left boundary of the first zone + zone_max : Quantity | None + Right boundary of the last zone + zone_step: Quantity | None + Size of zones + bins : xr.DataArray | list[Quantity] | None + Zones to be used, either as a DataArray with appropriate units or a list of Quantity + exclude_boundary_zones : Bool + Determines whether a zone value is attributed for values in ]`-np.inf`, `zone_min`[ and [`zone_max`, `np.inf`\ [. + close_last_zone_right_boundary : Bool + Determines if the right boundary of the last zone is closed. + + Returns + ------- + xarray.DataArray, [dimensionless] + Zone index for each value in `da`. Zones are returned as an integer range, starting from `0` + """ + # Check compatibility of arguments + zone_params = np.array([zone_min, zone_max, zone_step]) + if bins is None: + if (zone_params == [None] * len(zone_params)).any(): + raise ValueError( + "`bins` is `None` as well as some or all of [`zone_min`, `zone_max`, `zone_step`]. " + "Expected defined parameters in one of these cases." + ) + elif set(zone_params) != {None}: + warnings.warn( + "Expected either `bins` or [`zone_min`, `zone_max`, `zone_step`], got both. " + "`bins` will be used." + ) + + # Get zone bins (if necessary) + bins = bins if bins is not None else _get_zone_bins(zone_min, zone_max, zone_step) + if isinstance(bins, list): + bins = sorted([convert_units_to(b, da) for b in bins]) + else: + bins = convert_units_to(bins, da) + + def _get_zone(_da): + return np.digitize(_da, bins) - 1 + + zones = xr.apply_ufunc(_get_zone, da, dask="parallelized") + + if close_last_zone_right_boundary: + zones = zones.where(da != bins[-1], _get_zone(bins[-2])) + if exclude_boundary_zones: + zones = zones.where( + (zones != _get_zone(bins[0] - 1)) & (zones != _get_zone(bins[-1])) + ) + + return zones + + +def detrend( + ds: xr.DataArray | xr.Dataset, dim="time", deg=1 +) -> xr.DataArray | xr.Dataset: + """Detrend data along a given dimension computing a polynomial trend of a given order. + + Parameters + ---------- + ds : xr.Dataset or xr.DataArray + The data to detrend. If a Dataset, detrending is done on all data variables. + dim : str + Dimension along which to compute the trend. + deg : int + Degree of the polynomial to fit. + + Returns + ------- + xr.Dataset or xr.DataArray + Same as `ds`, but with its trend removed (subtracted). + """ + if isinstance(ds, xr.Dataset): + return ds.map(detrend, keep_attrs=False, dim=dim, deg=deg) + # is a DataArray + # detrend along a single dimension + coeff = ds.polyfit(dim=dim, deg=deg) + trend = xr.polyval(ds[dim], coeff.polyfit_coefficients) + with xr.set_options(keep_attrs=True): + return ds - trend diff --git a/src/xsdba/xclim_submodules/run_length.py b/src/xsdba/xclim_submodules/run_length.py new file mode 100644 index 0000000..e84704c --- /dev/null +++ b/src/xsdba/xclim_submodules/run_length.py @@ -0,0 +1,1538 @@ +""" +Run-Length Algorithms Submodule +=============================== + +Computation of statistics on runs of True values in boolean arrays. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from datetime import datetime +from warnings import warn + +import numpy as np +import xarray as xr +from numba import njit +from xarray.core.utils import get_temp_dimname + +from xsdba.base import uses_dask +from xsdba.options import OPTIONS, RUN_LENGTH_UFUNC +from xsdba.typing import DateStr, DayOfYearStr + +npts_opt = 9000 +""" +Arrays with less than this number of data points per slice will trigger +the use of the ufunc version of run lengths algorithms. +""" +# XC: all copied from xc + + +def use_ufunc( + ufunc_1dim: bool | str, + da: xr.DataArray, + dim: str = "time", + freq: str | None = None, + index: str = "first", +) -> bool: + """Return whether the ufunc version of run length algorithms should be used with this DataArray or not. + + If ufunc_1dim is 'from_context', the parameter is read from xclim's global (or context) options. + If it is 'auto', this returns False for dask-backed array and for arrays with more than :py:const:`npts_opt` + points per slice along `dim`. + + Parameters + ---------- + ufunc_1dim : {'from_context', 'auto', True, False} + The method for handling the ufunc parameters. + da : xr.DataArray + Input array. + dim : str + The dimension along which to find runs. + freq : str + Resampling frequency. + index : {'first', 'last'} + If 'first' (default), the run length is indexed with the first element in the run. + If 'last', with the last element in the run. + + Returns + ------- + bool + If ufunc_1dim is "auto", returns True if the array is on dask or too large. + Otherwise, returns ufunc_1dim. + """ + if ufunc_1dim is True and freq is not None: + raise ValueError( + "Resampling after run length operations is not implemented for 1d method" + ) + + if ufunc_1dim == "from_context": + ufunc_1dim = OPTIONS[RUN_LENGTH_UFUNC] + + if ufunc_1dim == "auto": + ufunc_1dim = not uses_dask(da) and (da.size // da[dim].size) < npts_opt + # If resampling after run length is set up for the computation, the 1d method is not implemented + # Unless ufunc_1dim is specifically set to False (in which case we flag an error above), + # we simply forbid this possibility. + return (index == "first") and (ufunc_1dim) and (freq is None) + + +def resample_and_rl( + da: xr.DataArray, + resample_before_rl: bool, + compute, + *args, + freq: str, + dim: str = "time", + **kwargs, +) -> xr.DataArray: + """Wrap run length algorithms to control if resampling occurs before or after the algorithms. + + Parameters + ---------- + da: xr.DataArray + N-dimensional array (boolean). + resample_before_rl : bool + Determines whether if input arrays of runs `da` should be separated in period before + or after the run length algorithms are applied. + compute + Run length function to apply + args + Positional arguments needed in `compute`. + dim: str + The dimension along which to find runs. + freq : str + Resampling frequency. + kwargs + Keyword arguments needed in `compute`. + + Returns + ------- + xr.DataArray + Output of compute resampled according to frequency {freq}. + """ + if resample_before_rl: + out = da.resample({dim: freq}).map( + compute, args=args, freq=None, dim=dim, **kwargs + ) + else: + out = compute(da, *args, dim=dim, freq=freq, **kwargs) + return out + + +def _cumsum_reset_on_zero( + da: xr.DataArray, + dim: str = "time", + index: str = "last", +) -> xr.DataArray: + """Compute the cumulative sum for each series of numbers separated by zero. + + Parameters + ---------- + da : xr.DataArray + Input array. + dim : str + Dimension name along which the cumulative sum is taken. + index : {'first', 'last'} + If 'first', the largest value of the cumulative sum is indexed with the first element in the run. + If 'last'(default), with the last element in the run. + + Returns + ------- + xr.DataArray + An array with cumulative sums. + """ + if index == "first": + da = da[{dim: slice(None, None, -1)}] + + # Example: da == 100110111 -> cs_s == 100120123 + cs = da.cumsum(dim=dim) # cumulative sum e.g. 111233456 + cs2 = cs.where(da == 0) # keep only numbers at positions of zeroes e.g. N11NN3NNN + cs2[{dim: 0}] = 0 # put a zero in front e.g. 011NN3NNN + cs2 = cs2.ffill(dim=dim) # e.g. 011113333 + out = cs - cs2 + + if index == "first": + out = out[{dim: slice(None, None, -1)}] + + return out + + +# TODO: Check if rle would be more performant with ffill/bfill instead of two times [{dim: slice(None, None, -1)}] +def rle( + da: xr.DataArray, + dim: str = "time", + index: str = "first", +) -> xr.DataArray: + """Generate basic run length function. + + Parameters + ---------- + da : xr.DataArray + Input array. + dim : str + Dimension name. + index : {'first', 'last'} + If 'first' (default), the run length is indexed with the first element in the run. + If 'last', with the last element in the run. + + Returns + ------- + xr.DataArray + Values are 0 where da is False (out of runs). + """ + da = da.astype(int) + + # "first" case: Algorithm is applied on inverted array and output is inverted back + if index == "first": + da = da[{dim: slice(None, None, -1)}] + + # Get cumulative sum for each series of 1, e.g. da == 100110111 -> cs_s == 100120123 + cs_s = _cumsum_reset_on_zero(da, dim) + + # Keep total length of each series (and also keep 0's), e.g. 100120123 -> 100N20NN3 + # Keep numbers with a 0 to the right and also the last number + cs_s = cs_s.where(da.shift({dim: -1}, fill_value=0) == 0) + out = cs_s.where(da == 1, 0) # Reinsert 0's at their original place + + # Inverting back if needed e.g. 100N20NN3 -> 3NN02N001. This is the output of + # `rle` for 111011001 with index == "first" + if index == "first": + out = out[{dim: slice(None, None, -1)}] + + return out + + +def rle_statistics( + da: xr.DataArray, + reducer: str, + window: int, + dim: str = "time", + freq: str | None = None, + ufunc_1dim: str | bool = "from_context", + index: str = "first", +) -> xr.DataArray: + """Return the length of consecutive run of True values, according to a reducing operator. + + Parameters + ---------- + da : xr.DataArray + N-dimensional array (boolean). + reducer : str + Name of the reducing function. + window : int + Minimal length of consecutive runs to be included in the statistics. + dim : str + Dimension along which to calculate consecutive run; Default: 'time'. + freq : str + Resampling frequency. + ufunc_1dim : Union[str, bool] + Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal + usage based on number of data points. Using 1D_ufunc=True is typically more efficient + for DataArray with a small number of grid points. + It can be modified globally through the "run_length_ufunc" global option. + index : {'first', 'last'} + If 'first' (default), the run length is indexed with the first element in the run. + If 'last', with the last element in the run. + + Returns + ------- + xr.DataArray, [int] + Length of runs of True values along dimension, according to the reducing function (float) + If there are no runs (but the data is valid), returns 0. + """ + ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, index=index, freq=freq) + if ufunc_1dim: + rl_stat = statistics_run_ufunc(da, reducer, window, dim) + else: + d = rle(da, dim=dim, index=index) + + def get_rl_stat(d): + rl_stat = getattr(d.where(d >= window), reducer)(dim=dim) + rl_stat = xr.where((d.isnull() | (d < window)).all(dim=dim), 0, rl_stat) + return rl_stat + + if freq is None: + rl_stat = get_rl_stat(d) + else: + rl_stat = d.resample({dim: freq}).map(get_rl_stat) + + return rl_stat + + +def longest_run( + da: xr.DataArray, + dim: str = "time", + freq: str | None = None, + ufunc_1dim: str | bool = "from_context", + index: str = "first", +) -> xr.DataArray: + """Return the length of the longest consecutive run of True values. + + Parameters + ---------- + da : xr.DataArray + N-dimensional array (boolean). + dim : str + Dimension along which to calculate consecutive run; Default: 'time'. + freq : str + Resampling frequency. + ufunc_1dim : Union[str, bool] + Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal + usage based on number of data points. Using 1D_ufunc=True is typically more efficient + for DataArray with a small number of grid points. + It can be modified globally through the "run_length_ufunc" global option. + index : {'first', 'last'} + If 'first', the run length is indexed with the first element in the run. + If 'last', with the last element in the run. + + Returns + ------- + xr.DataArray, [int] + Length of the longest run of True values along dimension (int). + """ + return rle_statistics( + da, + reducer="max", + window=1, + dim=dim, + freq=freq, + ufunc_1dim=ufunc_1dim, + index=index, + ) + + +def windowed_run_events( + da: xr.DataArray, + window: int, + dim: str = "time", + freq: str | None = None, + ufunc_1dim: str | bool = "from_context", + index: str = "first", +) -> xr.DataArray: + """Return the number of runs of a minimum length. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum run length. + When equal to 1, an optimized version of the algorithm is used. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + freq : str + Resampling frequency. + ufunc_1dim : Union[str, bool] + Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal + usage based on number of data points. Using 1D_ufunc=True is typically more efficient + for DataArray with a small number of grid points. + Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. + index : {'first', 'last'} + If 'first', the run length is indexed with the first element in the run. + If 'last', with the last element in the run. + + Returns + ------- + xr.DataArray, [int] + Number of distinct runs of a minimum length (int). + """ + ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, index=index, freq=freq) + + if ufunc_1dim: + out = windowed_run_events_ufunc(da, window, dim) + + else: + if window == 1: + shift = 1 * (index == "first") + -1 * (index == "last") + d = xr.where(da.shift({dim: shift}, fill_value=0) == 0, 1, 0) + d = d.where(da == 1, 0) + else: + d = rle(da, dim=dim, index=index) + d = xr.where(d >= window, 1, 0) + if freq is not None: + d = d.resample({dim: freq}) + out = d.sum(dim=dim) + + return out + + +def windowed_run_count( + da: xr.DataArray, + window: int, + dim: str = "time", + freq: str | None = None, + ufunc_1dim: str | bool = "from_context", + index: str = "first", +) -> xr.DataArray: + """Return the number of consecutive true values in array for runs at least as long as given duration. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum run length. + When equal to 1, an optimized version of the algorithm is used. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + freq : str + Resampling frequency. + ufunc_1dim : Union[str, bool] + Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal + usage based on number of data points. Using 1D_ufunc=True is typically more efficient + for DataArray with a small number of grid points. + Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. + index : {'first', 'last'} + If 'first', the run length is indexed with the first element in the run. + If 'last', with the last element in the run. + + Returns + ------- + xr.DataArray, [int] + Total number of `True` values part of a consecutive runs of at least `window` long. + """ + ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, index=index, freq=freq) + + if ufunc_1dim: + out = windowed_run_count_ufunc(da, window, dim) + + elif window == 1 and freq is None: + out = da.sum(dim=dim) + + else: + d = rle(da, dim=dim, index=index) + d = d.where(d >= window, 0) + if freq is not None: + d = d.resample({dim: freq}) + out = d.sum(dim=dim) + + return out + + +def _boundary_run( + da: xr.DataArray, + window: int, + dim: str, + freq: str | None, + coord: str | bool | None, + ufunc_1dim: str | bool, + position: str, +) -> xr.DataArray: + """Return the index of the first item of the first or last run of at least a given length. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive run to accumulate values. + When equal to 1, an optimized version of the algorithm is used. + dim : str + Dimension along which to calculate consecutive run. + freq : str + Resampling frequency. + coord : Optional[str] + If not False, the function returns values along `dim` instead of indexes. + If `dim` has a datetime dtype, `coord` can also be a str of the name of the + DateTimeAccessor object to use (ex: 'dayofyear'). + ufunc_1dim : Union[str, bool] + Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal + usage based on number of data points. Using 1D_ufunc=True is typically more efficient + for DataArray with a small number of grid points. + Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. + position : {"first", "last"} + Determines if the algorithm finds the "first" or "last" run + + Returns + ------- + xr.DataArray + Index (or coordinate if `coord` is not False) of first item in first (last) valid run. + Returns np.nan if there are no valid runs. + """ + + def coord_transform(out, da): + """Transforms indexes to coordinates if needed, and drops obsolete dim.""" + if coord: + crd = da[dim] + if isinstance(coord, str): + crd = getattr(crd.dt, coord) + + out = lazy_indexing(crd, out) + + if dim in out.coords: + out = out.drop_vars(dim) + return out + + # general method to get indices (or coords) of first run + def find_boundary_run(runs, position): + if position == "last": + runs = runs[{dim: slice(None, None, -1)}] + dmax_ind = runs.argmax(dim=dim) + # If there are no runs, dmax_ind will be 0: We must replace this with NaN + out = dmax_ind.where(dmax_ind != runs.argmin(dim=dim)) + if position == "last": + out = runs[dim].size - out - 1 + runs = runs[{dim: slice(None, None, -1)}] + out = coord_transform(out, runs) + return out + + ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, freq=freq) + + da = da.fillna(0) # We expect a boolean array, but there could be NaNs nonetheless + if window == 1: + if freq is not None: + out = da.resample({dim: freq}).map(find_boundary_run, position=position) + else: + out = find_boundary_run(da, position) + + elif ufunc_1dim: + if position == "last": + da = da[{dim: slice(None, None, -1)}] + out = first_run_ufunc(x=da, window=window, dim=dim) + if position == "last" and not coord: + out = da[dim].size - out - 1 + da = da[{dim: slice(None, None, -1)}] + out = coord_transform(out, da) + + else: + # _cusum_reset_on_zero() is an intermediate step in rle, which is sufficient here + d = _cumsum_reset_on_zero(da, dim=dim, index=position) + d = xr.where(d >= window, 1, 0) + # for "first" run, return "first" element in the run (and conversely for "last" run) + if freq is not None: + out = d.resample({dim: freq}).map(find_boundary_run, position=position) + else: + out = find_boundary_run(d, position) + + return out + + +def first_run( + da: xr.DataArray, + window: int, + dim: str = "time", + freq: str | None = None, + coord: str | bool | None = False, + ufunc_1dim: str | bool = "from_context", +) -> xr.DataArray: + """Return the index of the first item of the first run of at least a given length. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive run to accumulate values. + When equal to 1, an optimized version of the algorithm is used. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + freq : str + Resampling frequency. + coord : Optional[str] + If not False, the function returns values along `dim` instead of indexes. + If `dim` has a datetime dtype, `coord` can also be a str of the name of the + DateTimeAccessor object to use (ex: 'dayofyear'). + ufunc_1dim : Union[str, bool] + Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal + usage based on number of data points. Using 1D_ufunc=True is typically more efficient + for DataArray with a small number of grid points. + Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. + + Returns + ------- + xr.DataArray + Index (or coordinate if `coord` is not False) of first item in first valid run. + Returns np.nan if there are no valid runs. + """ + out = _boundary_run( + da, + window=window, + dim=dim, + freq=freq, + coord=coord, + ufunc_1dim=ufunc_1dim, + position="first", + ) + return out + + +def last_run( + da: xr.DataArray, + window: int, + dim: str = "time", + freq: str | None = None, + coord: str | bool | None = False, + ufunc_1dim: str | bool = "from_context", +) -> xr.DataArray: + """Return the index of the last item of the last run of at least a given length. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive run to accumulate values. + When equal to 1, an optimized version of the algorithm is used. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + freq : str + Resampling frequency. + coord : Optional[str] + If not False, the function returns values along `dim` instead of indexes. + If `dim` has a datetime dtype, `coord` can also be a str of the name of the + DateTimeAccessor object to use (ex: 'dayofyear'). + ufunc_1dim : Union[str, bool] + Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal + usage based on number of data points. Using `1D_ufunc=True` is typically more efficient + for a DataArray with a small number of grid points. + Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. + + Returns + ------- + xr.DataArray + Index (or coordinate if `coord` is not False) of last item in last valid run. + Returns np.nan if there are no valid runs. + """ + out = _boundary_run( + da, + window=window, + dim=dim, + freq=freq, + coord=coord, + ufunc_1dim=ufunc_1dim, + position="last", + ) + return out + + +# TODO: Add window arg +# TODO: Inverse window arg to tolerate holes? +def run_bounds(mask: xr.DataArray, dim: str = "time", coord: bool | str = True): + """Return the start and end dates of boolean runs along a dimension. + + Parameters + ---------- + mask : xr.DataArray + Boolean array. + dim : str + Dimension along which to look for runs. + coord : bool or str + If `True`, return values of the coordinate, if a string, returns values from `dim.dt.`. + If `False`, return indexes. + + Returns + ------- + xr.DataArray + With ``dim`` reduced to "events" and "bounds". The events dim is as long as needed, padded with NaN or NaT. + """ + if uses_dask(mask): + raise NotImplementedError( + "Dask arrays not supported as we can't know the final event number before computing." + ) + + diff = xr.concat( + (mask.isel({dim: [0]}).astype(int), mask.astype(int).diff(dim)), dim + ) + + nstarts = (diff == 1).sum(dim).max().item() + + def _get_indices(arr, *, N): + out = np.full((N,), np.nan, dtype=float) + inds = np.where(arr)[0] + out[: len(inds)] = inds + return out + + starts = xr.apply_ufunc( + _get_indices, + diff == 1, + input_core_dims=[[dim]], + output_core_dims=[["events"]], + kwargs={"N": nstarts}, + vectorize=True, + ) + + ends = xr.apply_ufunc( + _get_indices, + diff == -1, + input_core_dims=[[dim]], + output_core_dims=[["events"]], + kwargs={"N": nstarts}, + vectorize=True, + ) + + if coord: + crd = mask[dim] + if isinstance(coord, str): + crd = getattr(crd.dt, coord) + + starts = lazy_indexing(crd, starts) + ends = lazy_indexing(crd, ends) + return xr.concat((starts, ends), "bounds") + + +def keep_longest_run( + da: xr.DataArray, dim: str = "time", freq: str | None = None +) -> xr.DataArray: + """Keep the longest run along a dimension. + + Parameters + ---------- + da : xr.DataArray + Boolean array. + dim : str + Dimension along which to check for the longest run. + freq : str + Resampling frequency. + + Returns + ------- + xr.DataArray, [bool] + Boolean array similar to da but with only one run, the (first) longest. + """ + # Get run lengths + rls = rle(da, dim) + + def get_out(rls): + out = xr.where( + # Construct an integer array and find the max + rls[dim].copy(data=np.arange(rls[dim].size)) == rls.argmax(dim), + rls + 1, # Add one to the First longest run + rls, + ) + out = out.ffill(dim) == out.max(dim) + return out + + if freq is not None: + out = rls.resample({dim: freq}).map(get_out) + else: + out = get_out(rls) + + return da.copy(data=out.transpose(*da.dims).data) + + +def extract_events( + da_start: xr.DataArray, + window_start: int, + da_stop: xr.DataArray, + window_stop: int, + dim: str = "time", +) -> xr.DataArray: + """Extract events, i.e. runs whose starting and stopping points are defined through run length conditions. + + Parameters + ---------- + da_start : xr.DataArray + Input array where run sequences are searched to define the start points in the main runs + window_start: int, + Number of True (1) values needed to start a run in `da_start` + da_stop : xr.DataArray + Input array where run sequences are searched to define the stop points in the main runs + window_stop: int, + Number of True (1) values needed to start a run in `da_stop` + dim : str + Dimension name. + + Returns + ------- + xr.DataArray + Output array with 1's when in a run sequence and with 0's elsewhere. + + Notes + ----- + A season (as defined in ``season``) could be considered as an event with `window_stop == window_start` and `da_stop == 1 - da_start`, + although it has more constraints on when to start and stop a run through the `date` argument. + """ + da_start = da_start.astype(int).fillna(0) + da_stop = da_stop.astype(int).fillna(0) + + start_runs = _cumsum_reset_on_zero(da_start, dim=dim, index="first") + stop_runs = _cumsum_reset_on_zero(da_stop, dim=dim, index="first") + start_positions = xr.where(start_runs >= window_start, 1, np.NaN) + stop_positions = xr.where(stop_runs >= window_stop, 0, np.NaN) + + # start positions (1) are f-filled until a stop position (0) is met + runs = stop_positions.combine_first(start_positions).ffill(dim=dim).fillna(0) + + return runs + + +def season( + da: xr.DataArray, + window: int, + date: DayOfYearStr | None = None, + dim: str = "time", + coord: str | bool | None = False, +) -> xr.Dataset: + """Calculate the bounds of a season along a dimension. + + A "season" is a run of True values that may include breaks under a given length (`window`). + The start is computed as the first run of `window` True values, then end as the first subsequent run + of `window` False values. If a date is passed, it must be included in the season. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive values to start and end the season. + date : DayOfYearStr, optional + The date (in MM-DD format) that a run must include to be considered valid. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + coord : Optional[str] + If not False, the function returns values along `dim` instead of indexes. + If `dim` has a datetime dtype, `coord` can also be a str of the name of the + DateTimeAccessor object to use (ex: 'dayofyear'). + + Returns + ------- + xr.Dataset + "dim" is reduced to "season_bnds" with 2 elements : season start and season end, both indices of da[dim]. + + Notes + ----- + The run can include holes of False or NaN values, so long as they do not exceed the window size. + + If a date is given, the season start and end are forced to be on each side of this date. This means that + even if the "real" season has been over for a long time, this is the date used in the length calculation. + Example : Length of the "warm season", where T > 25°C, with date = 1st August. Let's say the temperature is over + 25 for all June, but July and august have very cold temperatures. Instead of returning 30 days (June), the function + will return 61 days (July + June). + """ + beg = first_run(da, window=window, dim=dim) + # Invert the condition and mask all values after beginning + # we fillna(0) as so to differentiate series with no runs and all-nan series + not_da = (~da).where(da[dim].copy(data=np.arange(da[dim].size)) >= beg.fillna(0)) + + # Mask also values after "date" + mid_idx = index_of_date(da[dim], date, max_idxs=1, default=0) + if mid_idx.size == 0: + # The date is not within the group. Happens at boundaries. + base = da.isel({dim: 0}) # To have the proper shape + beg = xr.full_like(base, np.nan, float).drop_vars(dim) + end = xr.full_like(base, np.nan, float).drop_vars(dim) + length = xr.full_like(base, np.nan, float).drop_vars(dim) + else: + if date is not None: + # If the beginning was after the mid date, both bounds are NaT. + valid_start = beg < mid_idx.squeeze() + else: + valid_start = True + + not_da = not_da.where(da[dim] >= da[dim][mid_idx][0]) + end = first_run( + not_da, + window=window, + dim=dim, + ) + # If there was a beginning but no end, season goes to the end of the array + no_end = beg.notnull() & end.isnull() + + # Length + length = end - beg + + # No end: length is actually until the end of the array, so it is missing 1 + length = xr.where(no_end, da[dim].size - beg, length) + # Where the beginning was before the mid-date, invalid. + length = length.where(valid_start) + # Where there were data points, but no season : put 0 length + length = xr.where(beg.isnull() & end.notnull(), 0, length) + + # No end: end defaults to the last element (this differs from length, but heh) + end = xr.where(no_end, da[dim].size - 1, end) + + # Where the beginning was before the mid-date + beg = beg.where(valid_start) + end = end.where(valid_start) + + if coord: + crd = da[dim] + if isinstance(coord, str): + crd = getattr(crd.dt, coord) + coordstr = coord + else: + coordstr = dim + beg = lazy_indexing(crd, beg) + end = lazy_indexing(crd, end) + else: + coordstr = "index" + + out = xr.Dataset({"start": beg, "end": end, "length": length}) + + out.start.attrs.update( + long_name="Start of the season.", + description=f"First {coordstr} of a run of at least {window} steps respecting the condition.", + ) + out.end.attrs.update( + long_name="End of the season.", + description=f"First {coordstr} of a run of at least {window} " + "steps breaking the condition, starting after `start`.", + ) + out.length.attrs.update( + long_name="Length of the season.", + description="Number of steps of the original series in the season, between 'start' and 'end'.", + ) + return out + + +def season_length( + da: xr.DataArray, + window: int, + date: DayOfYearStr | None = None, + dim: str = "time", +) -> xr.DataArray: + """Return the length of the longest semi-consecutive run of True values (optionally including a given date). + + A "season" is a run of True values that may include breaks under a given length (`window`). + The start is computed as the first run of `window` True values, then end as the first subsequent run + of `window` False values. If a date is passed, it must be included in the season. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive values to start and end the season. + date : DayOfYearStr, optional + The date (in MM-DD format) that a run must include to be considered valid. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + + Returns + ------- + xr.DataArray, [int] + Length of the longest run of True values along a given dimension (inclusive of a given date) + without breaks longer than a given length. + + Notes + ----- + The run can include holes of False or NaN values, so long as they do not exceed the window size. + + If a date is given, the season start and end are forced to be on each side of this date. This means that + even if the "real" season has been over for a long time, this is the date used in the length calculation. + Example : Length of the "warm season", where T > 25°C, with date = 1st August. Let's say the temperature is over + 25 for all June, but July and august have very cold temperatures. Instead of returning 30 days (June), the function + will return 61 days (July + June). + """ + seas = season(da, window, date, dim, coord=False) + return seas.length + + +def run_end_after_date( + da: xr.DataArray, + window: int, + date: DayOfYearStr = "07-01", + dim: str = "time", + coord: bool | str | None = "dayofyear", +) -> xr.DataArray: + """Return the index of the first item after the end of a run after a given date. + + The run must begin before the date. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive run to accumulate values. + date : str + The date after which to look for the end of a run. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + coord : Optional[Union[bool, str]] + If not False, the function returns values along `dim` instead of indexes. + If `dim` has a datetime dtype, `coord` can also be a str of the name of the + DateTimeAccessor object to use (ex: 'dayofyear'). + + Returns + ------- + xr.DataArray + Index (or coordinate if `coord` is not False) of last item in last valid run. + Returns np.nan if there are no valid runs. + """ + mid_idx = index_of_date(da[dim], date, max_idxs=1, default=0) + if mid_idx.size == 0: # The date is not within the group. Happens at boundaries. + return xr.full_like(da.isel({dim: 0}), np.nan, float).drop_vars(dim) + + end = first_run( + (~da).where(da[dim] >= da[dim][mid_idx][0]), + window=window, + dim=dim, + coord=coord, + ) + beg = first_run(da.where(da[dim] < da[dim][mid_idx][0]), window=window, dim=dim) + + if coord: + last = da[dim][-1] + if isinstance(coord, str): + last = getattr(last.dt, coord) + else: + last = da[dim].size - 1 + + end = xr.where(end.isnull() & beg.notnull(), last, end) + return end.where(beg.notnull()).drop_vars(dim, errors="ignore") + + +def first_run_after_date( + da: xr.DataArray, + window: int, + date: DayOfYearStr | None = "07-01", + dim: str = "time", + coord: bool | str | None = "dayofyear", +) -> xr.DataArray: + """Return the index of the first item of the first run after a given date. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive run to accumulate values. + date : DayOfYearStr + The date after which to look for the run. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + coord : Optional[Union[bool, str]] + If not False, the function returns values along `dim` instead of indexes. + If `dim` has a datetime dtype, `coord` can also be a str of the name of the + DateTimeAccessor object to use (ex: 'dayofyear'). + + Returns + ------- + xr.DataArray + Index (or coordinate if `coord` is not False) of first item in the first valid run. + Returns np.nan if there are no valid runs. + """ + mid_idx = index_of_date(da[dim], date, max_idxs=1, default=0) + if mid_idx.size == 0: # The date is not within the group. Happens at boundaries. + return xr.full_like(da.isel({dim: 0}), np.nan, float).drop_vars(dim) + + return first_run( + da.where(da[dim] >= da[dim][mid_idx][0]), + window=window, + dim=dim, + coord=coord, + ) + + +def last_run_before_date( + da: xr.DataArray, + window: int, + date: DayOfYearStr = "07-01", + dim: str = "time", + coord: bool | str | None = "dayofyear", +) -> xr.DataArray: + """Return the index of the last item of the last run before a given date. + + Parameters + ---------- + da : xr.DataArray + Input N-dimensional DataArray (boolean). + window : int + Minimum duration of consecutive run to accumulate values. + date : DayOfYearStr + The date before which to look for the last event. + dim : str + Dimension along which to calculate consecutive run (default: 'time'). + coord : Optional[Union[bool, str]] + If not False, the function returns values along `dim` instead of indexes. + If `dim` has a datetime dtype, `coord` can also be a str of the name of the + DateTimeAccessor object to use (ex: 'dayofyear'). + + Returns + ------- + xr.DataArray + Index (or coordinate if `coord` is not False) of last item in last valid run. + Returns np.nan if there are no valid runs. + """ + mid_idx = index_of_date(da[dim], date, default=-1) + + if mid_idx.size == 0: # The date is not within the group. Happens at boundaries. + return xr.full_like(da.isel({dim: 0}), np.nan, float).drop_vars(dim) + + run = da.where(da[dim] <= da[dim][mid_idx][0]) + return last_run(run, window=window, dim=dim, coord=coord) + + +@njit +def _rle_1d(ia): + y = ia[1:] != ia[:-1] # pairwise unequal (string safe) + i = np.append(np.nonzero(y)[0], ia.size - 1) # must include last element position + rl = np.diff(np.append(-1, i)) # run lengths + pos = np.cumsum(np.append(0, rl))[:-1] # positions + return ia[i], rl, pos + + +def rle_1d( + arr: int | float | bool | Sequence[int | float | bool], +) -> tuple[np.array, np.array, np.array]: + """Return the length, starting position and value of consecutive identical values. + + Parameters + ---------- + arr : Sequence[Union[int, float, bool]] + Array of values to be parsed. + + Returns + ------- + values : np.array + The values taken by arr over each run. + run lengths : np.array + The length of each run. + start position : np.array + The starting index of each run. + + Examples + -------- + >>> from xclim.indices.run_length import rle_1d + >>> a = [1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3] + >>> rle_1d(a) + (array([1, 2, 3]), array([2, 4, 6]), array([0, 2, 6])) + """ + ia = np.asarray(arr) + n = len(ia) + + if n == 0: + warn("run length array empty") + # Returning None makes some other 1d func below fail. + return np.array(np.nan), 0, np.array(np.nan) + return _rle_1d(ia) + + +def first_run_1d(arr: Sequence[int | float], window: int) -> int | np.nan: + """Return the index of the first item of a run of at least a given length. + + Parameters + ---------- + arr : Sequence[Union[int, float]] + Input array. + window : int + Minimum duration of consecutive run to accumulate values. + + Returns + ------- + int or np.nan + Index of first item in first valid run. + Returns np.nan if there are no valid runs. + """ + v, rl, pos = rle_1d(arr) + ind = np.where(v * rl >= window, pos, np.inf).min() + + if np.isinf(ind): + return np.nan + return ind + + +def statistics_run_1d(arr: Sequence[bool], reducer: str, window: int) -> int: + """Return statistics on lengths of run of identical values. + + Parameters + ---------- + arr : Sequence[bool] + Input array (bool) + reducer : {'mean', 'sum', 'min', 'max', 'std'} + Reducing function name. + window : int + Minimal length of runs to be included in the statistics + + Returns + ------- + int + Statistics on length of runs. + """ + v, rl = rle_1d(arr)[:2] + if not np.any(v) or np.all(v * rl < window): + return 0 + func = getattr(np, f"nan{reducer}") + return func(np.where(v * rl >= window, rl, np.NaN)) + + +def windowed_run_count_1d(arr: Sequence[bool], window: int) -> int: + """Return the number of consecutive true values in array for runs at least as long as given duration. + + Parameters + ---------- + arr : Sequence[bool] + Input array (bool). + window : int + Minimum duration of consecutive run to accumulate values. + + Returns + ------- + int + Total number of true values part of a consecutive run at least `window` long. + """ + v, rl = rle_1d(arr)[:2] + return np.where(v * rl >= window, rl, 0).sum() + + +def windowed_run_events_1d(arr: Sequence[bool], window: int) -> xr.DataArray: + """Return the number of runs of a minimum length. + + Parameters + ---------- + arr : Sequence[bool] + Input array (bool). + window : int + Minimum run length. + + Returns + ------- + xr.DataArray, [int] + Number of distinct runs of a minimum length. + """ + v, rl, _ = rle_1d(arr) + return (v * rl >= window).sum() + + +def windowed_run_count_ufunc( + x: xr.DataArray | Sequence[bool], window: int, dim: str +) -> xr.DataArray: + """Dask-parallel version of windowed_run_count_1d, ie: the number of consecutive true values in array for runs at least as long as given duration. + + Parameters + ---------- + x : Sequence[bool] + Input array (bool). + window : int + Minimum duration of consecutive run to accumulate values. + dim : str + Dimension along which to calculate windowed run. + + Returns + ------- + xr.DataArray + A function operating along the time dimension of a dask-array. + """ + return xr.apply_ufunc( + windowed_run_count_1d, + x, + input_core_dims=[[dim]], + vectorize=True, + dask="parallelized", + output_dtypes=[int], + keep_attrs=True, + kwargs={"window": window}, + ) + + +def windowed_run_events_ufunc( + x: xr.DataArray | Sequence[bool], window: int, dim: str +) -> xr.DataArray: + """Dask-parallel version of windowed_run_events_1d, ie: the number of runs at least as long as given duration. + + Parameters + ---------- + x : Sequence[bool] + Input array (bool). + window : int + Minimum run length. + dim : str + Dimension along which to calculate windowed run. + + Returns + ------- + xr.DataArray + A function operating along the time dimension of a dask-array. + """ + return xr.apply_ufunc( + windowed_run_events_1d, + x, + input_core_dims=[[dim]], + vectorize=True, + dask="parallelized", + output_dtypes=[int], + keep_attrs=True, + kwargs={"window": window}, + ) + + +def statistics_run_ufunc( + x: xr.DataArray | Sequence[bool], + reducer: str, + window: int, + dim: str = "time", +) -> xr.DataArray: + """Dask-parallel version of statistics_run_1d, ie: the {reducer} number of consecutive true values in array. + + Parameters + ---------- + x : Sequence[bool] + Input array (bool) + reducer: {'min', 'max', 'mean', 'sum', 'std'} + Reducing function name. + window : int + Minimal length of runs. + dim : str + The dimension along which the runs are found. + + Returns + ------- + xr.DataArray + A function operating along the time dimension of a dask-array. + """ + return xr.apply_ufunc( + statistics_run_1d, + x, + input_core_dims=[[dim]], + kwargs={"reducer": reducer, "window": window}, + vectorize=True, + dask="parallelized", + output_dtypes=[float], + keep_attrs=True, + ) + + +def first_run_ufunc( + x: xr.DataArray | Sequence[bool], + window: int, + dim: str, +) -> xr.DataArray: + """Dask-parallel version of first_run_1d, ie: the first entry in array of consecutive true values. + + Parameters + ---------- + x : Union[xr.DataArray, Sequence[bool]] + Input array (bool). + window : int + Minimum run length. + dim : str + The dimension along which the runs are found. + + Returns + ------- + xr.DataArray + A function operating along the time dimension of a dask-array. + """ + ind = xr.apply_ufunc( + first_run_1d, + x, + input_core_dims=[[dim]], + vectorize=True, + dask="parallelized", + output_dtypes=[float], + keep_attrs=True, + kwargs={"window": window}, + ) + + return ind + + +def lazy_indexing( + da: xr.DataArray, index: xr.DataArray, dim: str | None = None +) -> xr.DataArray: + """Get values of `da` at indices `index` in a NaN-aware and lazy manner. + + Parameters + ---------- + da : xr.DataArray + Input array. If not 1D, `dim` must be given and must not appear in index. + index : xr.DataArray + N-d integer indices, if da is not 1D, all dimensions of index must be in da + dim : str, optional + Dimension along which to index, unused if `da` is 1D, should not be present in `index`. + + Returns + ------- + xr.DataArray + Values of `da` at indices `index`. + """ + if da.ndim == 1: + # Case where da is 1D and index is N-D + # Slightly better performance using map_blocks, over an apply_ufunc + def _index_from_1d_array(indices, array): + return array[indices] + + idx_ndim = index.ndim + if idx_ndim == 0: + # The 0-D index case, we add a dummy dimension to help dask + dim = get_temp_dimname(da.dims, "x") + index = index.expand_dims(dim) + # Which indexes to mask. + invalid = index.isnull() + # NaN-indexing doesn't work, so fill with 0 and cast to int + index = index.fillna(0).astype(int) + + # No need for coords, we extract by integer index. + # Renaming with no name to fix bug in xr 2024.01.0 + tmpname = get_temp_dimname(da.dims, "temp") + da2 = xr.DataArray(da.data, dims=(tmpname,), name=None) + # for each chunk of index, take corresponding values from da + out = index.map_blocks(_index_from_1d_array, args=(da2,)).rename(da.name) + # mask where index was NaN. Drop any auxiliary coord, they are already on `out`. + # Chunked aux coord would have the same name on both sides and xarray will want to check if they are equal, which means loading them + # making lazy_indexing not lazy. + out = out.where( + ~invalid.drop_vars( + [crd for crd in invalid.coords if crd not in invalid.dims] + ) + ) + if idx_ndim == 0: + # 0-D case, drop useless coords and dummy dim + out = out.drop_vars(da.dims[0], errors="ignore").squeeze() + return out.drop_vars(dim or da.dims[0], errors="ignore") + + # Case where index.dims is a subset of da.dims. + if dim is None: + diff_dims = set(da.dims) - set(index.dims) + if len(diff_dims) == 0: + raise ValueError( + "da must have at least one dimension more than index for lazy_indexing." + ) + if len(diff_dims) > 1: + raise ValueError( + "If da has more than one dimension more than index, the indexing dim must be given through `dim`" + ) + dim = diff_dims.pop() + + def _index_from_nd_array(array, indices): + return np.take_along_axis(array, indices[..., np.newaxis], axis=-1)[..., 0] + + return xr.apply_ufunc( + _index_from_nd_array, + da, + index.astype(int), + input_core_dims=[[dim], []], + output_core_dims=[[]], + dask="parallelized", + output_dtypes=[da.dtype], + ) + + +def index_of_date( + time: xr.DataArray, + date: DateStr | DayOfYearStr | None, + max_idxs: int | None = None, + default: int = 0, +) -> np.ndarray: + """Get the index of a date in a time array. + + Parameters + ---------- + time : xr.DataArray + An array of datetime values, any calendar. + date : DayOfYearStr or DateStr, optional + A string in the "yyyy-mm-dd" or "mm-dd" format. + If None, returns default. + max_idxs : int, optional + Maximum number of returned indexes. + default : int + Index to return if date is None. + + Raises + ------ + ValueError + If there are most instances of `date` in `time` than `max_idxs`. + + Returns + ------- + numpy.ndarray + 1D array of integers, indexes of `date` in `time`. + """ + if date is None: + return np.array([default]) + try: + date = datetime.strptime(date, "%Y-%m-%d") + year_cond = time.dt.year == date.year + except ValueError: + date = datetime.strptime(date, "%m-%d") + year_cond = True + + idxs = np.where( + year_cond & (time.dt.month == date.month) & (time.dt.day == date.day) + )[0] + if max_idxs is not None and idxs.size > max_idxs: + raise ValueError( + f"More than {max_idxs} instance of date {date} found in the coordinate array." + ) + return idxs + + +def suspicious_run_1d( + arr: np.ndarray, + window: int = 10, + op: str = ">", + thresh: float | None = None, +) -> np.ndarray: + """Return True where the array contains a run of identical values. + + Parameters + ---------- + arr : numpy.ndarray + Array of values to be parsed. + window : int + Minimum run length. + op : {">", ">=", "==", "<", "<=", "eq", "gt", "lt", "gteq", "lteq", "ge", "le"} + Operator for threshold comparison. Defaults to ">". + thresh : float, optional + Threshold compared against which values are checked for identical values. + + Returns + ------- + numpy.ndarray + Whether or not the data points are part of a run of identical values. + """ + v, rl, pos = rle_1d(arr) + sus_runs = rl >= window + if thresh is not None: + if op in {">", "gt"}: + sus_runs = sus_runs & (v > thresh) + elif op in {"<", "lt"}: + sus_runs = sus_runs & (v < thresh) + elif op in {"==", "eq"}: + sus_runs = sus_runs & (v == thresh) + elif op in {"!=", "ne"}: + sus_runs = sus_runs & (v != thresh) + elif op in {">=", "gteq", "ge"}: + sus_runs = sus_runs & (v >= thresh) + elif op in {"<=", "lteq", "le"}: + sus_runs = sus_runs & (v <= thresh) + else: + raise NotImplementedError(f"{op}") + + out = np.zeros_like(arr, dtype=bool) + for st, l in zip(pos[sus_runs], rl[sus_runs]): # noqa: E741 + out[st : st + l] = True # noqa: E741 + return out + + +def suspicious_run( + arr: xr.DataArray, + dim: str = "time", + window: int = 10, + op: str = ">", + thresh: float | None = None, +) -> xr.DataArray: + """Return True where the array contains has runs of identical values, vectorized version. + + In opposition to other run length functions, here the output has the same shape as the input. + + Parameters + ---------- + arr : xr.DataArray + Array of values to be parsed. + dim : str + Dimension along which to check for runs (default: "time"). + window : int + Minimum run length. + op : {">", ">=", "==", "<", "<=", "eq", "gt", "lt", "gteq", "lteq"} + Operator for threshold comparison, defaults to ">". + thresh : float, optional + Threshold above which values are checked for identical values. + + Returns + ------- + xarray.DataArray + """ + return xr.apply_ufunc( + suspicious_run_1d, + arr, + input_core_dims=[[dim]], + output_core_dims=[[dim]], + vectorize=True, + dask="parallelized", + output_dtypes=[bool], + keep_attrs=True, + kwargs=dict(window=window, op=op, thresh=thresh), + ) diff --git a/src/xsdba/xclim_submodules/stats.py b/src/xsdba/xclim_submodules/stats.py new file mode 100644 index 0000000..4a26152 --- /dev/null +++ b/src/xsdba/xclim_submodules/stats.py @@ -0,0 +1,622 @@ +"""Statistic-related functions. See the `frequency_analysis` notebook for examples.""" + +from __future__ import annotations + +import json +import warnings +from collections.abc import Sequence +from typing import Any + +import numpy as np +import scipy.stats +import xarray as xr + +from xsdba.base import uses_dask +from xsdba.formatting import prefix_attrs, unprefix_attrs, update_history +from xsdba.typing import DateStr, Quantified +from xsdba.units import convert_units_to + +from . import generic + +__all__ = [ + "_fit_start", + "dist_method", + "fa", + "fit", + "frequency_analysis", + "get_dist", + "parametric_cdf", + "parametric_quantile", +] + + +# Fit the parameters. +# This would also be the place to impose constraints on the series minimum length if needed. +def _fitfunc_1d(arr, *, dist, nparams, method, **fitkwargs): + """Fit distribution parameters.""" + x = np.ma.masked_invalid(arr).compressed() # pylint: disable=no-member + + # Return NaNs if array is empty. + if len(x) <= 1: + return np.asarray([np.nan] * nparams) + + # Estimate parameters + if method in ["ML", "MLE"]: + args, kwargs = _fit_start(x, dist.name, **fitkwargs) + params = dist.fit(x, *args, method="mle", **kwargs, **fitkwargs) + elif method == "MM": + params = dist.fit(x, method="mm", **fitkwargs) + elif method == "PWM": + params = list(dist.lmom_fit(x).values()) + elif method == "APP": + args, kwargs = _fit_start(x, dist.name, **fitkwargs) + kwargs.setdefault("loc", 0) + params = list(args) + [kwargs["loc"], kwargs["scale"]] + else: + raise NotImplementedError(f"Unknown method `{method}`.") + + params = np.asarray(params) + + # Fill with NaNs if one of the parameters is NaN + if np.isnan(params).any(): + params[:] = np.nan + + return params + + +def fit( + da: xr.DataArray, + dist: str | scipy.stats.rv_continuous = "norm", + method: str = "ML", + dim: str = "time", + **fitkwargs: Any, +) -> xr.DataArray: + r"""Fit an array to a univariate distribution along the time dimension. + + Parameters + ---------- + da : xr.DataArray + Time series to be fitted along the time dimension. + dist : str or rv_continuous distribution object + Name of the univariate distribution, such as beta, expon, genextreme, gamma, gumbel_r, lognorm, norm + (see :py:mod:scipy.stats for full list) or the distribution object itself. + method : {"ML" or "MLE", "MM", "PWM", "APP"} + Fitting method, either maximum likelihood (ML or MLE), method of moments (MM) or approximate method (APP). + Can also be the probability weighted moments (PWM), also called L-Moments, if a compatible `dist` object is passed. + The PWM method is usually more robust to outliers. + dim : str + The dimension upon which to perform the indexing (default: "time"). + \*\*fitkwargs + Other arguments passed directly to :py:func:`_fitstart` and to the distribution's `fit`. + + Returns + ------- + xr.DataArray + An array of fitted distribution parameters. + + Notes + ----- + Coordinates for which all values are NaNs will be dropped before fitting the distribution. If the array still + contains NaNs, the distribution parameters will be returned as NaNs. + """ + method = method.upper() + method_name = { + "ML": "maximum likelihood", + "MM": "method of moments", + "MLE": "maximum likelihood", + "PWM": "probability weighted moments", + "APP": "approximative method", + } + if method not in method_name: + raise ValueError(f"Fitting method not recognized: {method}") + + # Get the distribution + dist = get_dist(dist) + + if method == "PWM" and not hasattr(dist, "lmom_fit"): + raise ValueError( + f"The given distribution {dist} does not implement the PWM fitting method. Please pass an instance from the lmoments3 package." + ) + + shape_params = [] if dist.shapes is None else dist.shapes.split(",") + dist_params = shape_params + ["loc", "scale"] + + data = xr.apply_ufunc( + _fitfunc_1d, + da, + input_core_dims=[[dim]], + output_core_dims=[["dparams"]], + vectorize=True, + dask="parallelized", + output_dtypes=[float], + keep_attrs=True, + kwargs=dict( + # Don't know how APP should be included, this works for now + dist=dist, + nparams=len(dist_params), + method=method, + **fitkwargs, + ), + dask_gufunc_kwargs={"output_sizes": {"dparams": len(dist_params)}}, + ) + + # Add coordinates for the distribution parameters and transpose to original shape (with dim -> dparams) + dims = [d if d != dim else "dparams" for d in da.dims] + out = data.assign_coords(dparams=dist_params).transpose(*dims) + + out.attrs = prefix_attrs( + da.attrs, ["standard_name", "long_name", "units", "description"], "original_" + ) + attrs = dict( + long_name=f"{dist.name} parameters", + description=f"Parameters of the {dist.name} distribution", + method=method, + estimator=method_name[method].capitalize(), + scipy_dist=dist.name, + units="", + history=update_history( + f"Estimate distribution parameters by {method_name[method]} method along dimension {dim}.", + new_name="fit", + data=da, + ), + ) + out.attrs.update(attrs) + return out + + +def parametric_quantile( + p: xr.DataArray, + q: float | Sequence[float], + dist: str | scipy.stats.rv_continuous | None = None, +) -> xr.DataArray: + """Return the value corresponding to the given distribution parameters and quantile. + + Parameters + ---------- + p : xr.DataArray + Distribution parameters returned by the `fit` function. + The array should have dimension `dparams` storing the distribution parameters, + and attribute `scipy_dist`, storing the name of the distribution. + q : float or Sequence of float + Quantile to compute, which must be between `0` and `1`, inclusive. + dist: str, rv_continuous instance, optional + The distribution name or instance if the `scipy_dist` attribute is not available on `p`. + + Returns + ------- + xarray.DataArray + An array of parametric quantiles estimated from the distribution parameters. + + Notes + ----- + When all quantiles are above 0.5, the `isf` method is used instead of `ppf` because accuracy is sometimes better. + """ + q = np.atleast_1d(q) + + dist = get_dist(dist or p.attrs["scipy_dist"]) + + # Create a lambda function to facilitate passing arguments to dask. There is probably a better way to do this. + if np.all(q > 0.5): + + def func(x): + return dist.isf(1 - q, *x) + + else: + + def func(x): + return dist.ppf(q, *x) + + data = xr.apply_ufunc( + func, + p, + input_core_dims=[["dparams"]], + output_core_dims=[["quantile"]], + vectorize=True, + dask="parallelized", + output_dtypes=[float], + keep_attrs=True, + dask_gufunc_kwargs={"output_sizes": {"quantile": len(q)}}, + ) + + # Assign quantile coordinates and transpose to preserve original dimension order + dims = [d if d != "dparams" else "quantile" for d in p.dims] + out = data.assign_coords(quantile=q).transpose(*dims) + out.attrs = unprefix_attrs(p.attrs, ["units", "standard_name"], "original_") + + attrs = dict( + long_name=f"{dist.name} quantiles", + description=f"Quantiles estimated by the {dist.name} distribution", + cell_methods="dparams: ppf", + history=update_history( + "Compute parametric quantiles from distribution parameters", + new_name="parametric_quantile", + parameters=p, + ), + ) + out.attrs.update(attrs) + return out + + +def parametric_cdf( + p: xr.DataArray, + v: float | Sequence[float], + dist: str | scipy.stats.rv_continuous | None = None, +) -> xr.DataArray: + """Return the cumulative distribution function corresponding to the given distribution parameters and value. + + Parameters + ---------- + p : xr.DataArray + Distribution parameters returned by the `fit` function. + The array should have dimension `dparams` storing the distribution parameters, + and attribute `scipy_dist`, storing the name of the distribution. + v : float or Sequence of float + Value to compute the CDF. + dist: str, rv_continuous instance, optional + The distribution name or instance is the `scipy_dist` attribute is not available on `p`. + + Returns + ------- + xarray.DataArray + An array of parametric CDF values estimated from the distribution parameters. + """ + v = np.atleast_1d(v) + + dist = get_dist(dist or p.attrs["scipy_dist"]) + + # Create a lambda function to facilitate passing arguments to dask. There is probably a better way to do this. + def func(x): + return dist.cdf(v, *x) + + data = xr.apply_ufunc( + func, + p, + input_core_dims=[["dparams"]], + output_core_dims=[["cdf"]], + vectorize=True, + dask="parallelized", + output_dtypes=[float], + keep_attrs=True, + dask_gufunc_kwargs={"output_sizes": {"cdf": len(v)}}, + ) + + # Assign quantile coordinates and transpose to preserve original dimension order + dims = [d if d != "dparams" else "cdf" for d in p.dims] + out = data.assign_coords(cdf=v).transpose(*dims) + out.attrs = unprefix_attrs(p.attrs, ["units", "standard_name"], "original_") + + attrs = dict( + long_name=f"{dist.name} cdf", + description=f"CDF estimated by the {dist.name} distribution", + cell_methods="dparams: cdf", + history=update_history( + "Compute parametric cdf from distribution parameters", + new_name="parametric_cdf", + parameters=p, + ), + ) + out.attrs.update(attrs) + return out + + +def fa( + da: xr.DataArray, + t: int | Sequence, + dist: str | scipy.stats.rv_continuous = "norm", + mode: str = "max", + method: str = "ML", +) -> xr.DataArray: + """Return the value corresponding to the given return period. + + Parameters + ---------- + da : xr.DataArray + Maximized/minimized input data with a `time` dimension. + t : int or Sequence of int + Return period. The period depends on the resolution of the input data. If the input array's resolution is + yearly, then the return period is in years. + dist : str or rv_continuous instance + Name of the univariate distribution, such as: + `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm` + Or the distribution instance itself. + mode : {'min', 'max} + Whether we are looking for a probability of exceedance (max) or a probability of non-exceedance (min). + method : {"ML", "MLE", "MOM", "PWM", "APP"} + Fitting method, either maximum likelihood (ML or MLE), method of moments (MOM) or approximate method (APP). + Also accepts probability weighted moments (PWM), also called L-Moments, if `dist` is an instance from the lmoments3 library. + The PWM method is usually more robust to outliers. + + Returns + ------- + xarray.DataArray + An array of values with a 1/t probability of exceedance (if mode=='max'). + + See Also + -------- + scipy.stats : For descriptions of univariate distribution types. + """ + # Fit the parameters of the distribution + p = fit(da, dist, method=method) + t = np.atleast_1d(t) + + if mode in ["max", "high"]: + q = 1 - 1.0 / t + + elif mode in ["min", "low"]: + q = 1.0 / t + + else: + raise ValueError(f"Mode `{mode}` should be either 'max' or 'min'.") + + # Compute the quantiles + out = ( + parametric_quantile(p, q, dist) + .rename({"quantile": "return_period"}) + .assign_coords(return_period=t) + ) + out.attrs["mode"] = mode + return out + + +def frequency_analysis( + da: xr.DataArray, + mode: str, + t: int | Sequence[int], + dist: str | scipy.stats.rv_continuous, + window: int = 1, + freq: str | None = None, + method: str = "ML", + **indexer: int | float | str, +) -> xr.DataArray: + r"""Return the value corresponding to a return period. + + Parameters + ---------- + da : xarray.DataArray + Input data. + mode : {'min', 'max'} + Whether we are looking for a probability of exceedance (high) or a probability of non-exceedance (low). + t : int or sequence + Return period. The period depends on the resolution of the input data. If the input array's resolution is + yearly, then the return period is in years. + dist : str or rv_continuous + Name of the univariate distribution, e.g. `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm`. + Or an instance of the distribution. + window : int + Averaging window length (days). + freq : str, optional + Resampling frequency. If None, the frequency is assumed to be 'YS' unless the indexer is season='DJF', + in which case `freq` would be set to `YS-DEC`. + method : {"ML" or "MLE", "MOM", "PWM", "APP"} + Fitting method, either maximum likelihood (ML or MLE), method of moments (MOM) or approximate method (APP). + Also accepts probability weighted moments (PWM), also called L-Moments, if `dist` is an instance from the lmoments3 library. + The PWM method is usually more robust to outliers. + \*\*indexer + Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, + month=1 to select January, or month=[6,7,8] to select summer months. If indexer is not provided, all values are + considered. + + Returns + ------- + xarray.DataArray + An array of values with a 1/t probability of exceedance or non-exceedance when mode is high or low respectively. + + See Also + -------- + scipy.stats : For descriptions of univariate distribution types. + """ + # Apply rolling average + attrs = da.attrs.copy() + if window > 1: + da = da.rolling(time=window).mean(skipna=False) + da.attrs.update(attrs) + + # Assign default resampling frequency if not provided + freq = freq or generic.default_freq(**indexer) + + # Extract the time series of min or max over the period + sel = generic.select_resample_op(da, op=mode, freq=freq, **indexer) + + if uses_dask(sel): + sel = sel.chunk({"time": -1}) + # Frequency analysis + return fa(sel, t, dist=dist, mode=mode, method=method) + + +def get_dist(dist: str | scipy.stats.rv_continuous): + """Return a distribution object from `scipy.stats`.""" + if isinstance(dist, scipy.stats.rv_continuous): + return dist + + dc = getattr(scipy.stats, dist, None) + if dc is None: + e = f"Statistical distribution `{dist}` is not found in scipy.stats." + raise ValueError(e) + return dc + + +def _fit_start(x, dist: str, **fitkwargs: Any) -> tuple[tuple, dict]: + r"""Return initial values for distribution parameters. + + Providing the ML fit method initial values can help the optimizer find the global optimum. + + Parameters + ---------- + x : array-like + Input data. + dist : str + Name of the univariate distribution, e.g. `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm`. + (see :py:mod:scipy.stats). Only `genextreme` and `weibull_exp` distributions are supported. + \*\*fitkwargs + Kwargs passed to fit. + + Returns + ------- + tuple, dict + + References + ---------- + :cite:cts:`coles_introduction_2001,cohen_parameter_2019, thom_1958, cooke_1979, muralidhar_1992` + + """ + x = np.asarray(x) + m = x.mean() + v = x.var() + + if dist == "genextreme": + s = np.sqrt(6 * v) / np.pi + return (0.1,), {"loc": m - 0.57722 * s, "scale": s} + + if dist == "genpareto" and "floc" in fitkwargs: + # Taken from julia' Extremes. Case for when "mu/loc" is known. + t = fitkwargs["floc"] + if not np.isclose(t, 0): + m = (x - t).mean() + v = (x - t).var() + + c = 0.5 * (1 - m**2 / v) + scale = (1 - c) * m + return (c,), {"scale": scale} + + if dist in "weibull_min": + s = x.std() + loc = x.min() - 0.01 * s + chat = np.pi / np.sqrt(6) / (np.log(x - loc)).std() + scale = ((x - loc) ** chat).mean() ** (1 / chat) + return (chat,), {"loc": loc, "scale": scale} + + if dist in ["gamma"]: + if "floc" in fitkwargs: + loc0 = fitkwargs["floc"] + else: + xs = sorted(x) + x1, x2, xn = xs[0], xs[1], xs[-1] + # muralidhar_1992 would suggest the following, but it seems more unstable + # using cooke_1979 for now + # n = len(x) + # cv = x.std() / x.mean() + # p = (0.48265 + 0.32967 * cv) * n ** (-0.2984 * cv) + # xp = xs[int(p/100*n)] + xp = x2 + loc0 = (x1 * xn - xp**2) / (x1 + xn - 2 * xp) + loc0 = loc0 if loc0 < x1 else (0.9999 * x1 if x1 > 0 else 1.0001 * x1) + x_pos = x - loc0 + x_pos = x_pos[x_pos > 0] + m = x_pos.mean() + log_of_mean = np.log(m) + mean_of_logs = np.log(x_pos).mean() + A = log_of_mean - mean_of_logs + a0 = (1 + np.sqrt(1 + 4 * A / 3)) / (4 * A) + scale0 = m / a0 + kwargs = {"scale": scale0, "loc": loc0} + return (a0,), kwargs + + if dist in ["fisk"]: + if "floc" in fitkwargs: + loc0 = fitkwargs["floc"] + else: + xs = sorted(x) + x1, x2, xn = xs[0], xs[1], xs[-1] + loc0 = (x1 * xn - x2**2) / (x1 + xn - 2 * x2) + loc0 = loc0 if loc0 < x1 else (0.9999 * x1 if x1 > 0 else 1.0001 * x1) + x_pos = x - loc0 + x_pos = x_pos[x_pos > 0] + # method of moments: + # LHS is computed analytically with the two-parameters log-logistic distribution + # and depends on alpha,beta + # RHS is from the sample + # = m + # / ^2 = m2/m**2 + # solving these equations yields + m = x_pos.mean() + m2 = (x_pos**2).mean() + scale0 = 2 * m**3 / (m2 + m**2) + c0 = np.pi * m / np.sqrt(3) / np.sqrt(m2 - m**2) + kwargs = {"scale": scale0, "loc": loc0} + return (c0,), kwargs + return (), {} + + +def _dist_method_1D( # noqa: N802 + *args, dist: str | scipy.stats.rv_continuous, function: str, **kwargs: Any +) -> xr.DataArray: + r"""Statistical function for given argument on given distribution initialized with params. + + See :py:ref:`scipy:scipy.stats.rv_continuous` for all available functions and their arguments. + Every method where `"*args"` are the distribution parameters can be wrapped. + + Parameters + ---------- + \*args + The arguments for the requested scipy function. + dist : str + The scipy name of the distribution. + function : str + The name of the function to call. + \*\*kwargs + Other parameters to pass to the function call. + + Returns + ------- + array_like + """ + dist = get_dist(dist) + return getattr(dist, function)(*args, **kwargs) + + +def dist_method( + function: str, + fit_params: xr.DataArray, + arg: xr.DataArray | None = None, + dist: str | scipy.stats.rv_continuous | None = None, + **kwargs: Any, +) -> xr.DataArray: + r"""Vectorized statistical function for given argument on given distribution initialized with params. + + Methods where `"*args"` are the distribution parameters can be wrapped, except those that reduce dimensions ( + e.g. `nnlf`) or create new dimensions (eg: 'rvs' with size != 1, 'stats' with more than one moment, 'interval', + 'support'). + + Parameters + ---------- + function : str + The name of the function to call. + fit_params : xr.DataArray + Distribution parameters are along `dparams`, in the same order as given by :py:func:`fit`. + arg : array_like, optional + The first argument for the requested function if different from `fit_params`. + dist : str pr rv_continuous, optional + The distribution name or instance. Defaults to the `scipy_dist` attribute or `fit_params`. + \*\*kwargs + Other parameters to pass to the function call. + + Returns + ------- + array_like + Same shape as arg. + + See Also + -------- + scipy:scipy.stats.rv_continuous : for all available functions and their arguments. + """ + # Typically the data to be transformed + arg = [arg] if arg is not None else [] + if function == "nnlf": + raise ValueError( + "This method is not supported because it reduces the dimensionality of the data." + ) + + # We don't need to set `input_core_dims` because we're explicitly splitting the parameters here. + args = arg + [fit_params.sel(dparams=dp) for dp in fit_params.dparams.values] + + return xr.apply_ufunc( + _dist_method_1D, + *args, + kwargs={ + "dist": dist or fit_params.attrs["scipy_dist"], + "function": function, + **kwargs, + }, + output_dtypes=[float], + dask="parallelized", + ) diff --git a/tests/test_properties.py b/tests/test_properties.py new file mode 100644 index 0000000..5b693bf --- /dev/null +++ b/tests/test_properties.py @@ -0,0 +1,577 @@ +from __future__ import annotations + +import numpy as np +import pandas as pd +import pytest +import xarray as xr +from xarray import set_options + +from xsdba import properties +from xsdba.units import convert_units_to + + +class TestProperties: + def test_mean(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1980"), location="Vancouver") + .pr + ).load() + + out_year = properties.mean(sim) + np.testing.assert_array_almost_equal(out_year.values, [3.0016028e-05]) + + out_season = properties.mean(sim, group="time.season") + np.testing.assert_array_almost_equal( + out_season.values, + [4.6115547e-05, 1.7220482e-05, 2.8805329e-05, 2.825359e-05], + ) + + assert out_season.long_name.startswith("Mean") + + def test_var(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1980"), location="Vancouver") + .pr + ).load() + + out_year = properties.var(sim) + np.testing.assert_array_almost_equal(out_year.values, [2.5884779e-09]) + + out_season = properties.var(sim, group="time.season") + np.testing.assert_array_almost_equal( + out_season.values, + [3.9270796e-09, 1.2538864e-09, 1.9057025e-09, 2.8776632e-09], + ) + assert out_season.long_name.startswith("Variance") + assert out_season.units == "kg2 m-4 s-2" + + def test_std(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1980"), location="Vancouver") + .pr + ).load() + + out_year = properties.std(sim) + np.testing.assert_array_almost_equal(out_year.values, [5.08770208398345e-05]) + + out_season = properties.std(sim, group="time.season") + np.testing.assert_array_almost_equal( + out_season.values, + [6.2666411e-05, 3.5410259e-05, 4.3654352e-05, 5.3643853e-05], + ) + assert out_season.long_name.startswith("Standard deviation") + assert out_season.units == "kg m-2 s-1" + + def test_skewness(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1980"), location="Vancouver") + .pr + ).load() + + out_year = properties.skewness(sim) + np.testing.assert_array_almost_equal(out_year.values, [2.8497460898513745]) + + out_season = properties.skewness(sim, group="time.season") + np.testing.assert_array_almost_equal( + out_season.values, + [ + 2.036650744163691, + 3.7909534745807147, + 2.416590445325826, + 3.3521301798559566, + ], + ) + assert out_season.long_name.startswith("Skewness") + assert out_season.units == "" + + def test_quantile(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1980"), location="Vancouver") + .pr + ).load() + + out_year = properties.quantile(sim, q=0.2) + np.testing.assert_array_almost_equal(out_year.values, [2.8109431013945154e-07]) + + out_season = properties.quantile(sim, group="time.season", q=0.2) + np.testing.assert_array_almost_equal( + out_season.values, + [ + 1.5171653330980917e-06, + 9.822543773907455e-08, + 1.8135805248675763e-07, + 4.135342521749408e-07, + ], + ) + assert out_season.long_name.startswith("Quantile 0.2") + + # TODO: test theshold_count? it's the same a test_spell_length_distribution + def test_spell_length_distribution(self, open_dataset): + ds = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .load() + ) + + # test pr, with amount method + sim = ds.pr + kws = {"op": "<", "group": "time.month", "thresh": "1.157e-05 kg/m/m/s"} + outd = { + stat: properties.spell_length_distribution(da=sim, **kws, stat=stat) + .sel(month=1) + .values + for stat in ["mean", "max", "min"] + } + np.testing.assert_array_almost_equal( + [outd[k] for k in ["mean", "max", "min"]], [2.44127, 10, 1] + ) + + # test tasmax, with quantile method + simt = ds.tasmax + kws = {"thresh": 0.9, "op": ">=", "method": "quantile", "group": "time.month"} + outd = { + stat: properties.spell_length_distribution(da=simt, **kws, stat=stat).sel( + month=6 + ) + for stat in ["mean", "max", "min"] + } + np.testing.assert_array_almost_equal( + [outd[k].values for k in ["mean", "max", "min"]], [3.0, 6, 1] + ) + + # test varia + with pytest.raises( + ValueError, + match="percentile is not a valid method. Choose 'amount' or 'quantile'.", + ): + properties.spell_length_distribution(simt, method="percentile") + + assert ( + outd["mean"].long_name + == "Average of spell length distribution when the variable is >= the quantile 0.9 for 1 consecutive day(s)." + ) + + def test_spell_length_distribution_mixed_stat(self, open_dataset): + + time = pd.date_range("2000-01-01", periods=2 * 365, freq="D") + tas = xr.DataArray( + np.array([0] * 365 + [40] * 365), + dims=("time"), + coords={"time": time}, + attrs={"units": "degC"}, + ) + + kws_sum = dict( + thresh="30 degC", op=">=", stat="sum", stat_resample="sum", group="time" + ) + out_sum = properties.spell_length_distribution(tas, **kws_sum).values + kws_mixed = dict( + thresh="30 degC", op=">=", stat="mean", stat_resample="sum", group="time" + ) + out_mixed = properties.spell_length_distribution(tas, **kws_mixed).values + + assert out_sum == 365 + assert out_mixed == 182.5 + + @pytest.mark.parametrize( + "window,expected_amount,expected_quantile", + [ + (1, [2.333333, 4, 1], [3, 6, 1]), + (3, [1.333333, 4, 0], [2, 6, 0]), + ], + ) + def test_bivariate_spell_length_distribution( + self, open_dataset, window, expected_amount, expected_quantile + ): + ds = ( + open_dataset("sdba/CanESM2_1950-2100.nc").sel( + time=slice("1950", "1952"), location="Vancouver" + ) + ).load() + tx = ds.tasmax + with set_options(keep_attrs=True): + tn = tx - 5 + + # test with amount method + kws = { + "thresh1": "0 degC", + "thresh2": "0 degC", + "op1": ">", + "op2": "<=", + "group": "time.month", + "window": window, + } + outd = { + stat: properties.bivariate_spell_length_distribution( + da1=tx, da2=tn, **kws, stat=stat + ) + .sel(month=1) + .values + for stat in ["mean", "max", "min"] + } + np.testing.assert_array_almost_equal( + [outd[k] for k in ["mean", "max", "min"]], expected_amount + ) + + # test with quantile method + kws = { + "thresh1": 0.9, + "thresh2": 0.9, + "op1": ">", + "op2": ">", + "method1": "quantile", + "method2": "quantile", + "group": "time.month", + "window": window, + } + outd = { + stat: properties.bivariate_spell_length_distribution( + da1=tx, da2=tn, **kws, stat=stat + ) + .sel(month=6) + .values + for stat in ["mean", "max", "min"] + } + np.testing.assert_array_almost_equal( + [outd[k] for k in ["mean", "max", "min"]], expected_quantile + ) + + def test_acf(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .pr + ).load() + + out = properties.acf(sim, lag=1, group="time.month").sel(month=1) + np.testing.assert_array_almost_equal(out.values, [0.11242357313756905]) + + # FIXME + # with pytest.raises(ValueError, match="Grouping period year is not allowed for"): + # properties.acf(sim, group="time") + + assert out.long_name.startswith("Lag-1 autocorrelation") + assert out.units == "" + + def test_annual_cycle(self, open_dataset): + simt = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .tasmax + ).load() + + amp = properties.annual_cycle_amplitude(simt) + relamp = properties.relative_annual_cycle_amplitude(simt) + phase = properties.annual_cycle_phase(simt) + + np.testing.assert_allclose( + [amp.values, relamp.values, phase.values], + [16.74645996, 5.802083, 167], + rtol=1e-6, + ) + # FIXME + # with pytest.raises( + # ValueError, + # match="Grouping period season is not allowed for property", + # ): + # properties.annual_cycle_amplitude(simt, group="time.season") + + # with pytest.raises( + # ValueError, + # match="Grouping period month is not allowed for property", + # ): + # properties.annual_cycle_phase(simt, group="time.month") + + assert amp.long_name.startswith("Absolute amplitude of the annual cycle") + assert phase.long_name.startswith("Phase of the annual cycle") + assert amp.units == "delta_degC" + assert relamp.units == "%" + assert phase.units == "" + + def test_annual_range(self, open_dataset): + simt = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .tasmax + ).load() + + # Initial annual cycle was this with window = 1 + amp = properties.mean_annual_range(simt, window=1) + relamp = properties.mean_annual_relative_range(simt, window=1) + phase = properties.mean_annual_phase(simt, window=1) + + np.testing.assert_allclose( + [amp.values, relamp.values, phase.values], + [34.039806, 11.793684020675501, 165.33333333333334], + ) + + amp = properties.mean_annual_range(simt) + relamp = properties.mean_annual_relative_range(simt) + phase = properties.mean_annual_phase(simt) + + np.testing.assert_array_almost_equal( + [amp.values, relamp.values, phase.values], + [18.715261, 6.480101, 181.6666667], + ) + # FIXME + # with pytest.raises( + # ValueError, + # match="Grouping period season is not allowed for property", + # ): + # properties.mean_annual_range(simt, group="time.season") + + # with pytest.raises( + # ValueError, + # match="Grouping period month is not allowed for property", + # ): + # properties.mean_annual_phase(simt, group="time.month") + + assert amp.long_name.startswith("Average annual absolute amplitude") + assert phase.long_name.startswith("Average annual phase") + assert amp.units == "delta_degC" + assert relamp.units == "%" + assert phase.units == "" + + def test_corr_btw_var(self, open_dataset): + simt = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .tasmax + ).load() + + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .pr + ).load() + + pc = properties.corr_btw_var(simt, sim, corr_type="Pearson") + pp = properties.corr_btw_var( + simt, sim, corr_type="Pearson", output="pvalue" + ).values + sc = properties.corr_btw_var(simt, sim).values + sp = properties.corr_btw_var(simt, sim, output="pvalue").values + sc_jan = ( + properties.corr_btw_var(simt, sim, group="time.month").sel(month=1).values + ) + sim[0] = np.nan + pc_nan = properties.corr_btw_var(sim, simt, corr_type="Pearson").values + + np.testing.assert_array_almost_equal( + [pc.values, pp, sc, sp, sc_jan, pc_nan], + [ + -0.20849051347480407, + 3.2160438749049577e-12, + -0.3449358561881698, + 5.97619379511559e-32, + 0.28329503745038936, + -0.2090292, + ], + ) + assert pc.long_name == "Pearson correlation coefficient" + assert pc.units == "" + + with pytest.raises( + ValueError, + match="pear is not a valid type. Choose 'Pearson' or 'Spearman'.", + ): + properties.corr_btw_var(sim, simt, group="time", corr_type="pear") + + def test_relative_frequency(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .pr + ).load() + + test = properties.relative_frequency(sim, thresh="2.8925e-04 kg/m^2/s", op=">=") + testjan = ( + properties.relative_frequency( + sim, thresh="2.8925e-04 kg/m^2/s", op=">=", group="time.month" + ) + .sel(month=1) + .values + ) + np.testing.assert_array_almost_equal( + [test.values, testjan], [0.0045662100456621, 0.010752688172043012] + ) + assert test.long_name == "Relative frequency of values >= 2.8925e-04 kg/m^2/s." + assert test.units == "" + + def test_transition(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .pr + ).load() + + test = properties.transition_probability( + da=sim, initial_op="<", final_op=">=", thresh="1.157e-05 kg/m^2/s" + ) + + np.testing.assert_array_almost_equal([test.values], [0.14076782449725778]) + assert ( + test.long_name + == "Transition probability of values < 1.157e-05 kg/m^2/s to values >= 1.157e-05 kg/m^2/s." + ) + assert test.units == "" + + def test_trend(self, open_dataset): + simt = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1952"), location="Vancouver") + .tasmax + ).load() + + slope = properties.trend(simt).values + intercept = properties.trend(simt, output="intercept").values + rvalue = properties.trend(simt, output="rvalue").values + pvalue = properties.trend(simt, output="pvalue").values + stderr = properties.trend(simt, output="stderr").values + intercept_stderr = properties.trend(simt, output="intercept_stderr").values + + np.testing.assert_array_almost_equal( + [slope, intercept, rvalue, pvalue, stderr, intercept_stderr], + [ + -0.133711111111111, + 288.762132222222222, + -0.9706433333333333, + 0.1546344444444444, + 0.033135555555555, + 0.042776666666666, + ], + 4, + ) + + slope = properties.trend(simt, group="time.month").sel(month=1) + intercept = ( + properties.trend(simt, output="intercept", group="time.month") + .sel(month=1) + .values + ) + rvalue = ( + properties.trend(simt, output="rvalue", group="time.month") + .sel(month=1) + .values + ) + pvalue = ( + properties.trend(simt, output="pvalue", group="time.month") + .sel(month=1) + .values + ) + stderr = ( + properties.trend(simt, output="stderr", group="time.month") + .sel(month=1) + .values + ) + intercept_stderr = ( + properties.trend(simt, output="intercept_stderr", group="time.month") + .sel(month=1) + .values + ) + + np.testing.assert_array_almost_equal( + [slope.values, intercept, rvalue, pvalue, stderr, intercept_stderr], + [ + 0.8254511111111111, + 281.76353222222222, + 0.576843333333333, + 0.6085644444444444, + 1.1689105555555555, + 1.509056666666666, + ], + 4, + ) + + assert slope.long_name.startswith("Slope of the interannual linear trend") + assert slope.units == "K/year" + + def test_return_value(self, open_dataset): + simt = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "2010"), location="Vancouver") + .tasmax + ).load() + + out_y = properties.return_value(simt) + + out_djf = ( + properties.return_value(simt, op="min", group="time.season") + .sel(season="DJF") + .values + ) + + np.testing.assert_array_almost_equal( + [out_y.values, out_djf], [313.154, 278.072], 3 + ) + assert out_y.long_name.startswith("20-year maximal return level") + + @pytest.mark.slow + def test_spatial_correlogram(self, open_dataset): + # This also tests sdba.utils._pairwise_spearman and sdba.nbutils._pairwise_haversine_and_bins + # Test 1, does it work with 1D data? + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1981", "2010")) + .tasmax + ).load() + + out = properties.spatial_correlogram(sim, dims=["location"], bins=3) + np.testing.assert_allclose(out, [-1, np.nan, 0], atol=1e-6) + + # Test 2, not very exhaustive, this is more of a detect-if-we-break-it test. + sim = open_dataset("NRCANdaily/nrcan_canada_daily_tasmax_1990.nc").tasmax + out = properties.spatial_correlogram( + sim.isel(lon=slice(0, 50)), dims=["lon", "lat"], bins=20 + ) + np.testing.assert_allclose( + out[:5], + [0.95099902, 0.83028772, 0.66874473, 0.48893958, 0.30915054], + ) + np.testing.assert_allclose( + out.distance[:5], + [26.543199, 67.716227, 108.889254, 150.062282, 191.23531], + rtol=5e-07, + ) + + @pytest.mark.slow + def test_decorrelation_length(self, open_dataset): + sim = ( + open_dataset("NRCANdaily/nrcan_canada_daily_tasmax_1990.nc") + .tasmax.isel(lon=slice(0, 5), lat=slice(0, 1)) + .load() + ) + + out = properties.decorrelation_length( + sim, dims=["lat", "lon"], bins=10, radius=30 + ) + np.testing.assert_allclose( + out[0], + [4.5, 4.5, 4.5, 4.5, 10.5], + ) + + # ADAPT? The plan was not to allow mm/d -> kg m-2 s-1 in xsdba + # def test_get_measure(self, open_dataset): + # sim = ( + # open_dataset("sdba/CanESM2_1950-2100.nc") + # .sel(time=slice("1981", "2010"), location="Vancouver") + # .pr + # ).load() + + # ref = ( + # open_dataset("sdba/ahccd_1950-2013.nc") + # .sel(time=slice("1981", "2010"), location="Vancouver") + # .pr + # ).load() + + # sim = convert_units_to(sim, ref) + # sim_var = properties.var(sim) + # ref_var = properties.var(ref) + + # meas = properties.var.get_measure()(sim_var, ref_var) + # np.testing.assert_allclose(meas, [0.408327], rtol=1e-3) From 448cb03130c6af4e7e3d9f6743a6f4ac3f35c253 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= Date: Tue, 30 Jul 2024 20:11:29 -0400 Subject: [PATCH 026/105] forgot indicators --- src/xsdba/indicator.py | 1320 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1320 insertions(+) create mode 100644 src/xsdba/indicator.py diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py new file mode 100644 index 0000000..5348a2e --- /dev/null +++ b/src/xsdba/indicator.py @@ -0,0 +1,1320 @@ +""" +Indicator Utilities +=================== + +The `Indicator` class wraps indices computations with pre- and post-processing functionality. Prior to computations, +the class runs data and metadata health checks. After computations, the class masks values that should be considered +missing and adds metadata attributes to the object. + +There are many ways to construct indicators. A good place to start is +`this notebook `_. + +Dictionary and YAML parser +-------------------------- + +To construct indicators dynamically, xclim can also use dictionaries and parse them from YAML files. +This is especially useful for generating whole indicator "submodules" from files. +This functionality is inspired by the work of `clix-meta `_. + +YAML file structure +~~~~~~~~~~~~~~~~~~~ + +Indicator-defining yaml files are structured in the following way. +Most entries of the `indicators` section are mirroring attributes of +the :py:class:`Indicator`, please refer to its documentation for more +details on each. + +.. code-block:: yaml + + module: # Defaults to the file name + realm: # If given here, applies to all indicators that do not already provide it. + keywords: # Merged with indicator-specific keywords (joined with a space) + references: # Merged with indicator-specific references (joined with a new line) + base: # Defaults to "Daily" and applies to all indicators that do not give it. + doc: # Defaults to a minimal header, only valid if the module doesn't already exist. + variables: # Optional section if indicators declared below rely on variables unknown to xclim + # (not in `xclim.core.utils.VARIABLES`) + # The variables are not module-dependent and will overwrite any already existing with the same name. + : + canonical_units: # required + description: # required + standard_name: # optional + cell_methods: # optional + indicators: + : + # From which Indicator to inherit + base: # Defaults to module-wide base class + # If the name startswith a '.', the base class is taken from the current module + # (thus an indicator declared _above_). + # Available classes are listed in `xclim.core.indicator.registry` and + # `xclim.core.indicator.base_registry`. + + # General metadata, usually parsed from the `compute`'s docstring when possible. + realm: # defaults to module-wide realm. One of "atmos", "land", "seaIce", "ocean". + title: + abstract: <abstract> + keywords: <keywords> # Space-separated, merged to module-wide keywords. + references: <references> # newline-seperated, merged to module-wide references. + notes: <notes> + + # Other options + missing: <missing method name> + missing_options: + # missing options mapping + allowed_periods: [<list>, <of>, <allowed>, <periods>] + + # Compute function + compute: <function name> # Referring to a function in `Indices` module (xclim.indices.generic or xclim.indices) + input: # When "compute" is a generic function, this is a mapping from argument name to the expected variable. + # This will allow the input units and CF metadata checks to run on the inputs. + # Can also be used to modify the expected variable, as long as it has the same dimensionality + # Ex: tas instead of tasmin. + # Can refer to a variable declared in the `variables` section above. + <var name in compute> : <variable official name> + ... + +Parameters +---------- + <param name>: <param data> # Simplest case, to inject parameters in the compute function. + <param name>: # To change parameters metadata or to declare units when "compute" is a generic function. + units: <param units> # Only valid if "compute" points to a generic function + default : <param default> + description: <param description> + kind: <param kind> # Override the parameter kind. + # This is mostly useful for transforming an optional variable into a required one by passing ``kind: 0``. + ... + ... # and so on. + +All fields are optional. Other fields found in the yaml file will trigger errors in xclim. +In the following, the section under `<identifier>` is referred to as `data`. When creating indicators from +a dictionary, with :py:meth:`Indicator.from_dict`, the input dict must follow the same structure of `data`. + +When a module is built from a yaml file, the yaml is first validated against the schema (see xclim/data/schema.yml) +using the YAMALE library (:cite:p:`lopker_yamale_2022`). See the "Extending xclim" notebook for more info. + +Inputs +~~~~~~ +As xclim has strict definitions of possible input variables (see :py:data:`xclim.core.utils.variables`), +the mapping of `data.input` simply links an argument name from the function given in "compute" +to one of those official variables. + +""" + +from __future__ import annotations + +import re +import warnings +import weakref +from collections import OrderedDict, defaultdict +from copy import deepcopy +from dataclasses import asdict, dataclass +from functools import reduce +from inspect import Parameter as _Parameter +from inspect import Signature +from inspect import _empty as _empty_default # noqa +from inspect import signature +from os import PathLike +from pathlib import Path +from types import ModuleType +from typing import Any, Callable, Optional, Union +from collections.abc import Sequence + +import numpy as np +import xarray +import yamale +from xarray import DataArray, Dataset +from yaml import safe_load + +from .base import Grouper, infer_kind_from_parameter +from .calendar import parse_offset +from .datachecks import is_percentile_dataarray +from .formatting import ( + AttrFormatter, + default_formatter, + gen_call_string, + generate_indicator_docstring, + get_percentile_metadata, + merge_attributes, + parse_doc, + update_history, +) +from .locales import ( + TRANSLATABLE_ATTRS, + get_local_attrs, + get_local_formatter, + load_locale, + read_locale_file, +) +from .logging import MissingVariableError, ValidationError, raise_warn_or_log +from .options import ( + AS_DATASET, + CHECK_MISSING, + KEEP_ATTRS, + METADATA_LOCALES, + MISSING_METHODS, + MISSING_OPTIONS, + OPTIONS, +) +from .typing import InputKind +from .units import check_units, convert_units_to, units +from .utils import load_module + +# Indicators registry +registry = {} # Main class registry +base_registry = {} +_indicators_registry = defaultdict(list) # Private instance registry + + +class _empty: + pass + + +@dataclass +class Parameter: + """Class for storing an indicator's controllable parameter. + + For retrocompatibility, this class implements a "getitem" and a special "contains". + + Example + ------- + >>> p = Parameter(InputKind.NUMBER, default=2, description="A simple number") + >>> p.units is Parameter._empty # has not been set + True + >>> "units" in p # Easier/retrocompatible way to test if units are set + False + >>> p.description + 'A simple number' + """ + + _empty = _empty + + kind: InputKind + default: Any = _empty_default + description: str = "" + units: str = _empty + choices: set = _empty + value: Any = _empty + + def update(self, other: dict) -> None: + """Update a parameter's values from a dict.""" + for k, v in other.items(): + if hasattr(self, k): + setattr(self, k, v) + else: + raise AttributeError(f"Unexpected parameter field '{k}'.") + + @classmethod + def is_parameter_dict(cls, other: dict) -> bool: + """Return whether indicator has a parameter dictionary.""" + return set(other.keys()).issubset( + cls.__dataclass_fields__.keys() # pylint: disable=no-member + ) + + # def __getitem__(self, key) -> str: + # """Return an item in retro-compatible fashion.""" + # try: + # return str(getattr(self, key)) + # except AttributeError as err: + # raise KeyError(key) from err + + def __contains__(self, key) -> bool: + """Imitate previous behaviour where "units" and "choices" were missing, instead of being "_empty".""" + return getattr(self, key, _empty) is not _empty + + def asdict(self) -> dict: + """Format indicators as a dictionary.""" + return {k: v for k, v in asdict(self).items() if v is not _empty} + + @property + def injected(self) -> bool: + """Indicate whether values are injected.""" + return self.value is not _empty + + +class IndicatorRegistrar: + """Climate Indicator registering object.""" + + def __new__(cls): + """Add subclass to registry.""" + name = cls.__name__.upper() + module = cls.__module__ + # If the module is not one of xclim's default, prepend the submodule name. + if module.startswith("xclim.indicators"): + submodule = module.split(".")[2] + if submodule not in ["atmos", "generic", "land", "ocean", "seaIce"]: + name = f"{submodule}.{name}" + else: + name = f"{module}.{name}" + if name in registry: + warnings.warn( + f"Class {name} already exists and will be overwritten.", stacklevel=1 + ) + registry[name] = cls + cls._registry_id = name + return super().__new__(cls) + + def __init__(self): + _indicators_registry[self.__class__].append(weakref.ref(self)) + + @classmethod + def get_instance(cls): + """Return first found instance. + + Raises `ValueError` if no instance exists. + """ + for inst_ref in _indicators_registry[cls]: + inst = inst_ref() + if inst is not None: + return inst + raise ValueError( + f"There is no existing instance of {cls.__name__}. " + "Either none were created or they were all garbage-collected." + ) + + +class Indicator(IndicatorRegistrar): + r"""Climate indicator base class. + + Climate indicator object that, when called, computes an indicator and assigns its output a number of + CF-compliant attributes. Some of these attributes can be *templated*, allowing metadata to reflect + the value of call arguments. + + Instantiating a new indicator returns an instance but also creates and registers a custom subclass + in :py:data:`xclim.core.indicator.registry`. + + Attributes in `Indicator.cf_attrs` will be formatted and added to the output variable(s). + This attribute is a list of dictionaries. For convenience and retro-compatibility, + standard CF attributes (names listed in :py:attr:`xclim.core.indicator.Indicator._cf_names`) + can be passed as strings or list of strings directly to the indicator constructor. + + A lot of the Indicator's metadata is parsed from the underlying `compute` function's + docstring and signature. Input variables and parameters are listed in + :py:attr:`xclim.core.indicator.Indicator.parameters`, while parameters that will be + injected in the compute function are in :py:attr:`xclim.core.indicator.Indicator.injected_parameters`. + Both are simply views of :py:attr:`xclim.core.indicator.Indicator._all_parameters`. + + Compared to their base `compute` function, indicators add the possibility of using dataset as input, + with the injected argument `ds` in the call signature. All arguments that were indicated + by the compute function to be variables (DataArrays) through annotations will be promoted + to also accept strings that correspond to variable names in the `ds` dataset. + + Parameters + ---------- + identifier : str + Unique ID for class registry, should be a valid slug. + realm : {'atmos', 'seaIce', 'land', 'ocean'} + General domain of validity of the indicator. Indicators created outside xclim.indicators must set this attribute. + compute : func + The function computing the indicators. It should return one or more DataArray. + cf_attrs : list of dicts + Attributes to be formatted and added to the computation's output. + See :py:attr:`xclim.core.indicator.Indicator.cf_attrs`. + title : str + A succinct description of what is in the computed outputs. Parsed from `compute` docstring if None (first paragraph). + abstract : str + A long description of what is in the computed outputs. Parsed from `compute` docstring if None (second paragraph). + keywords : str + Comma separated list of keywords. Parsed from `compute` docstring if None (from a "Keywords" section). + references : str + Published or web-based references that describe the data or methods used to produce it. Parsed from + `compute` docstring if None (from the "References" section). + notes : str + Notes regarding computing function, for example the mathematical formulation. Parsed from `compute` + docstring if None (form the "Notes" section). + src_freq : str, sequence of strings, optional + The expected frequency of the input data. Can be a list for multiple frequencies, or None if irrelevant. + context : str + The `pint` unit context, for example use 'hydro' to allow conversion from kg m-2 s-1 to mm/day. + + Notes + ----- + All subclasses created are available in the `registry` attribute and can be used to define custom subclasses + or parse all available instances. + """ + + # Officially-supported metadata attributes on the output variables + _cf_names = [ + "var_name", + "standard_name", + "long_name", + "units", + "cell_methods", + "description", + "comment", + ] + + # metadata fields that are formatted as free text (first letter capitalized) + _text_fields = ["long_name", "description", "comment"] + # Class attributes that are function (so we know which to convert to static methods) + _funcs = ["compute"] + # Mapping from name in the compute function to official (CMIP6) variable name + _variable_mapping = {} + + # Will become the class's name + identifier = None + + context = "none" + src_freq = None + + # Global metadata (must be strings, not attributed to the output) + realm = None + title = "" + abstract = "" + keywords = "" + references = "" + notes = "" + _version_deprecated = "" + + # Note: typing and class types in this call signature will cause errors with sphinx-autodoc-typehints + # See: https://github.com/tox-dev/sphinx-autodoc-typehints/issues/186#issuecomment-1450739378 + _all_parameters: dict = {} + """A dictionary mapping metadata about the input parameters to the indicator. + + Keys are the arguments of the "compute" function. All parameters are listed, even + those "injected", absent from the indicator's call signature. All are instances of + :py:class:`xclim.core.indicator.Parameter`. + """ + + # Note: typing and class types in this call signature will cause errors with sphinx-autodoc-typehints + # See: https://github.com/tox-dev/sphinx-autodoc-typehints/issues/186#issuecomment-1450739378 + cf_attrs: list[dict[str, str]] = None + """A list of metadata information for each output of the indicator. + + It minimally contains a "var_name" entry, and may contain : "standard_name", "long_name", + "units", "cell_methods", "description" and "comment" on official xclim indicators. Other + fields could also be present if the indicator was created from outside xclim. + + var_name: + Output variable(s) name(s). For derived single-output indicators, this field is not + inherited from the parent indicator and defaults to the identifier. + standard_name: + Variable name, must be in the CF standard names table (this is not checked). + long_name: + Descriptive variable name. Parsed from `compute` docstring if not given. + (first line after the output dtype, only works on single output function). + units: + Representative units of the physical quantity. + cell_methods: + List of blank-separated words of the form "name: method". Must respect the + CF-conventions and vocabulary (not checked). + description: + Sentence(s) meant to clarify the qualifiers of the fundamental quantities, such as which + surface a quantity is defined on or what the flux sign conventions are. + comment: + Miscellaneous information about the data or methods used to produce it. + """ + + def __new__(cls, **kwds): # noqa: C901 + """Create subclass from arguments.""" + identifier = kwds.get("identifier", cls.identifier) + if identifier is None: + raise AttributeError("`identifier` has not been set.") + + if "compute" in kwds: + # Parsed parameters and metadata override parent's params entirely. + parameters, docmeta = cls._parse_indice( + kwds["compute"], kwds.get("parameters", {}) + ) + for name, value in docmeta.items(): + # title, abstract, references, notes, long_name + kwds.setdefault(name, value) + + # Inject parameters (subclasses can override or extend this through _injected_parameters) + for name, param in cls._injected_parameters(): + if name in parameters: + raise ValueError( + f"Class {cls.__name__} can't wrap indices that have a `{name}`" + " argument as it conflicts with arguments it injects." + ) + parameters[name] = param + else: # inherit parameters from base class + parameters = deepcopy(cls._all_parameters) + + # Update parameters with passed parameters + cls._update_parameters(parameters, kwds.pop("parameters", {})) + + # Input variable mapping (to change variable names in signature and expected units/cf attrs). + cls._parse_var_mapping(kwds.pop("input", {}), parameters, kwds) + + # Raise on incorrect params, sort params, modify var defaults in-place if needed + parameters = cls._ensure_correct_parameters(parameters) + + # If needed, wrap compute with declare units + if "compute" in kwds: + if not hasattr(kwds["compute"], "in_units") and "_variable_mapping" in kwds: + # We actually need the inverse mapping (to get cmip6 name -> arg name) + inv_var_map = dict(map(reversed, kwds["_variable_mapping"].items())) + # parameters has already been update above. + # kwds["compute"] = declare_units( + # **{ + # inv_var_map[k]: m.units + # for k, m in parameters.items() + # if "units" in m and k in inv_var_map + # } + # )(kwds["compute"]) + + if hasattr(kwds["compute"], "in_units"): + varmap = kwds.get("_variable_mapping", {}) + for name, unit in kwds["compute"].in_units.items(): + parameters[varmap.get(name, name)].units = unit + + # All updates done. + kwds["_all_parameters"] = parameters + + # Parse kwds to organize `cf_attrs` + # And before converting callables to static methods + kwds["cf_attrs"] = cls._parse_output_attrs(kwds, identifier) + # Parse keywords + if "keywords" in kwds: + kwds["keywords"] = cls.keywords + " " + kwds.get("keywords") + + # Convert function objects to static methods. + for key in cls._funcs: + if key in kwds and callable(kwds[key]): + kwds[key] = staticmethod(kwds[key]) + + # ADAPT: Get rid of this + # Infer realm for built-in xclim instances + # if cls.__module__.startswith(__package__.split(".", maxsplit=1)[0]): + # xclim_realm = cls.__module__.split(".")[2] + # else: + xclim_realm = None + + # ADAPT: Get rid of this + # Priority given to passed realm -> parent's realm -> location of the class declaration (official inds only) + kwds.setdefault("realm", cls.realm or xclim_realm) + # if kwds["realm"] not in ["atmos", "seaIce", "land", "ocean", "generic"]: + # raise AttributeError( + # "Indicator's realm must be given as one of 'atmos', 'seaIce', 'land', 'ocean' or 'generic'" + # ) + + # Create new class object + new = type(identifier.upper(), (cls,), kwds) + + # Forcing the module is there so YAML-generated submodules are correctly seen by IndicatorRegistrar. + if kwds.get("module") is not None: + new.__module__ = f"xclim.indicators.{kwds['module']}" + else: + # If the module was not forced, set the module to the base class' module. + # Otherwise, all indicators will have module `xclim.core.indicator`. + new.__module__ = cls.__module__ + + # Add the created class to the registry + # This will create an instance from the new class and call __init__. + return super().__new__(new) + + @staticmethod + def _parse_indice(compute, passed_parameters): # noqa: F841 + """Parse the compute function. + + - Metadata is extracted from the docstring + - Parameters are parsed from the docstring (description, choices), decorator (units), signature (kind, default) + + 'passed_parameters' is only needed when compute is a generic function + (not decorated by `declare_units`) and it takes a string parameter. In that case + we need to check if that parameter has units (which have been passed explicitly). + + """ + docmeta = parse_doc(compute.__doc__) + params_dict = docmeta.pop("parameters", {}) # override parent's parameters + + compute_sig = signature(compute) + # Check that the `Parameters` section of the docstring does not include parameters + # that are not in the `compute` function signature. + if not set(params_dict.keys()).issubset(compute_sig.parameters.keys()): + raise ValueError( + f"Malformed docstring on {compute} : the parameters " + f"{set(params_dict.keys()) - set(compute_sig.parameters.keys())} " + "are absent from the signature." + ) + for name, param in compute_sig.parameters.items(): + meta = params_dict.setdefault(name, {}) + meta["default"] = param.default + meta["kind"] = infer_kind_from_parameter(param) + + parameters = {name: Parameter(**param) for name, param in params_dict.items()} + return parameters, docmeta + + @classmethod + def _injected_parameters(cls): + """Create a list of tuples for arguments to inject, (name, Parameter).""" + return [ + ( + "ds", + Parameter( + kind=InputKind.DATASET, + default=None, + description="A dataset with the variables given by name.", + ), + ) + ] + + @classmethod + def _update_parameters(cls, parameters, passed): + """Update parameters with the ones passed.""" + try: + for key, val in passed.items(): + if isinstance(val, dict) and Parameter.is_parameter_dict(val): + # modified meta + parameters[key].update(val) + elif key in parameters: + parameters[key].value = val + else: + raise KeyError(key) + except KeyError as err: + raise ValueError( + f"Parameter {err} was passed but it does not exist on the " + f"compute function (not one of {parameters.keys()})" + ) from err + + @classmethod + def _parse_var_mapping(cls, variable_mapping, parameters, kwds): + """Parse the variable mapping passed in `input` and update `parameters` in-place.""" + # Update parameters + for old_name, new_name in variable_mapping.items(): + meta = parameters[new_name] = parameters.pop(old_name) + # try: + # varmeta = VARIABLES[new_name] + # except KeyError as err: + # raise ValueError( + # f"Compute argument {old_name} was mapped to variable " + # f"{new_name} which is not understood by xclim or CMIP6. Please" + # " use names listed in `xclim.core.utils.VARIABLES`." + # ) from err + # if meta.units is not _empty: + # try: + # check_units(varmeta["canonical_units"], meta.units) + # except ValidationError as err: + # raise ValueError( + # "When changing the name of a variable by passing `input`, " + # "the units dimensionality must stay the same. Got: old = " + # f"{meta.units}, new = {varmeta['canonical_units']}" + # ) from err + # meta.units = varmeta.get("dimensions", varmeta["canonical_units"]) + # meta.description = varmeta["description"] + + if variable_mapping: + # Update mapping attribute + new_variable_mapping = deepcopy(cls._variable_mapping) + new_variable_mapping.update(variable_mapping) + kwds["_variable_mapping"] = new_variable_mapping + + @classmethod + def _ensure_correct_parameters(cls, parameters): + """Ensure the parameters are correctly set and ordered.""" + # Set default values, otherwise the signature binding chokes + # on missing arguments when passing only `ds`. + for name, meta in parameters.items(): + if not meta.injected: + if meta.kind == InputKind.OPTIONAL_VARIABLE: + meta.default = None + elif meta.kind in [InputKind.VARIABLE]: + meta.default = name + + # Sort parameters : Var, Opt Var, all params, ds, injected params. + def sortkey(kv): + if not kv[1].injected: + if kv[1].kind in [ + InputKind.VARIABLE, + InputKind.OPTIONAL_VARIABLE, + InputKind.KWARGS, + ]: + return kv[1].kind + return 2 + return 99 + + return dict(sorted(parameters.items(), key=sortkey)) + + @classmethod + def _parse_output_attrs( # noqa: C901 + cls, kwds: dict[str, Any], identifier: str + ) -> list[dict[str, str | Callable]]: + """CF-compliant metadata attributes for all output variables.""" + parent_cf_attrs = cls.cf_attrs + cf_attrs = kwds.get("cf_attrs") + if isinstance(cf_attrs, dict): + # Single output indicator, but we store as a list anyway. + cf_attrs = [cf_attrs] + elif cf_attrs is None: + # Attributes were passed the "old" way, with lists or strings directly (only _cf_names) + # We need to get the number of outputs first, defaulting to the length of parent's cf_attrs or 1 + n_outs = len(parent_cf_attrs) if parent_cf_attrs is not None else 1 + for name in cls._cf_names: + arg = kwds.get(name) + if isinstance(arg, (tuple, list)): + n_outs = len(arg) + + # Populate new cf_attrs from parsing cf_names passed directly. + cf_attrs = [{} for _ in range(n_outs)] + for name in cls._cf_names: + values = kwds.pop(name, None) + if values is None: # None passed, skip + continue + if not isinstance(values, (tuple, list)): + # a single string or callable, same for all outputs + values = [values] * n_outs + elif len(values) != n_outs: # A sequence of the wrong length. + raise ValueError( + f"Attribute {name} has {len(values)} elements but xclim expected {n_outs}." + ) + for attrs, value in zip(cf_attrs, values): + if value: # Skip the empty ones (None or "") + attrs[name] = value + # else we assume a list of dicts + + # For single output, var_name defaults to identifier. + if len(cf_attrs) == 1 and "var_name" not in cf_attrs[0]: + cf_attrs[0]["var_name"] = identifier + + # update from parent, if they have the same length. + if parent_cf_attrs is not None and len(parent_cf_attrs) == len(cf_attrs): + for old, new in zip(parent_cf_attrs, cf_attrs): + for attr, value in old.items(): + new.setdefault(attr, value) + + # check if we have var_names for everybody + for i, var in enumerate(cf_attrs, start=1): + if "var_name" not in var: + raise ValueError(f"Output #{i} is missing a var_name! Got: {var}.") + + return cf_attrs + + @classmethod + def from_dict( + cls, + data: dict, + identifier: str, + module: str | None = None, + ): + """Create an indicator subclass and instance from a dictionary of parameters. + + Most parameters are passed directly as keyword arguments to the class constructor, except: + + - "base" : A subclass of Indicator or a name of one listed in + :py:data:`xclim.core.indicator.registry` or + :py:data:`xclim.core.indicator.base_registry`. When passed, it acts as if + `from_dict` was called on that class instead. + - "compute" : A string function name translates to a + :py:mod:`xclim.indices.generic` or :py:mod:`xclim.indices` function. + + Parameters + ---------- + data: dict + The exact structure of this dictionary is detailed in the submodule documentation. + identifier : str + The name of the subclass and internal indicator name. + module : str + The module name of the indicator. This is meant to be used only if the indicator + is part of a dynamically generated submodule, to override the module of the base class. + """ + data = data.copy() + if "base" in data: + if isinstance(data["base"], str): + parts = data["base"].split(".") + registry_id = ".".join([*parts[:-1], parts[-1].upper()]) + cls = registry.get(registry_id, base_registry.get(data["base"])) + if cls is None: + raise ValueError( + f"Requested base class {data['base']} is neither in the " + "indicators registry nor in base classes registry." + ) + else: + cls = data["base"] + + compute = data.get("compute", None) + # data.compute refers to a function in xclim.indices.generic or xclim.indices (in this order of priority). + # It can also directly be a function (like if a module was passed to build_indicator_module_from_yaml) + if isinstance(compute, str): + compute_func = getattr( + indices.generic, compute, getattr(indices, compute, None) + ) + if compute_func is None: + raise ImportError( + f"Indice function {compute} not found in xclim.indices or " + "xclim.indices.generic." + ) + data["compute"] = compute_func + + return cls(identifier=identifier, module=module, **data) + + def __init__(self, **kwds): + """Run checks and organizes the metadata.""" + # keywords of kwds that are class attributes have already been set in __new__ + self._check_identifier(self.identifier) + + # Validation is done : register the instance. + super().__init__() + + self.__signature__ = self._gen_signature() + + # Generate docstring + self.__doc__ = generate_indicator_docstring(self) + + def _gen_signature(self): + """Generate the correct signature.""" + # Update call signature + variables = [] + parameters = [] + compute_sig = signature(self.compute) + for name, meta in self.parameters.items(): + if meta.kind in [ + InputKind.VARIABLE, + InputKind.OPTIONAL_VARIABLE, + ]: + annot = Union[DataArray, str] + if meta.kind == InputKind.OPTIONAL_VARIABLE: + annot = Optional[annot] + variables.append( + _Parameter( + name, + kind=_Parameter.POSITIONAL_OR_KEYWORD, + default=meta.default, + annotation=annot, + ) + ) + elif meta.kind == InputKind.KWARGS: + parameters.append(_Parameter(name, kind=_Parameter.VAR_KEYWORD)) + elif meta.kind == InputKind.DATASET: + parameters.append( + _Parameter( + name, + kind=_Parameter.KEYWORD_ONLY, + annotation=Dataset, + default=meta.default, + ) + ) + else: + parameters.append( + _Parameter( + name, + kind=_Parameter.KEYWORD_ONLY, + default=meta.default, + annotation=compute_sig.parameters[name].annotation, + ) + ) + + ret_ann = DataArray if self.n_outs == 1 else tuple[(DataArray,) * self.n_outs] + return Signature(variables + parameters, return_annotation=ret_ann) + + def __call__(self, *args, **kwds): + """Call function of Indicator class.""" + # Put the variables in `das`, parse them according to the following annotations: + # das : OrderedDict of variables (required + non-None optionals) + # params : OrderedDict of parameters (var_kwargs as a single argument, if any) + + if self._version_deprecated: + self._show_deprecation_warning() # noqa + + das, params, dsattrs = self._parse_variables_from_call(args, kwds) + + if OPTIONS[KEEP_ATTRS] is True or ( + OPTIONS[KEEP_ATTRS] == "xarray" + and xarray.core.options._get_keep_attrs(False) + ): + out_attrs = xarray.core.merge.merge_attrs( + [da.attrs for da in das.values()], "drop_conflicts" + ) + out_attrs.pop("units", None) + else: + out_attrs = {} + out_attrs = [out_attrs.copy() for i in range(self.n_outs)] + + # Get correct variable names for the compute function. + inv_var_map = dict(map(reversed, self._variable_mapping.items())) + compute_das = {inv_var_map.get(nm, nm): das[nm] for nm in das} + + # Compute the indicator values, ignoring NaNs and missing values. + # Filter the passed parameters to only keep the ones needed by compute. + kwargs = {} + var_kwargs = {} + for nm, pa in signature(self.compute).parameters.items(): + if pa.kind == _Parameter.VAR_KEYWORD: + var_kwargs = params[nm] + elif nm not in compute_das and nm in params: + kwargs[nm] = params[nm] + + with xarray.set_options(keep_attrs=False): + outs = self.compute(**compute_das, **kwargs, **var_kwargs) + + if isinstance(outs, DataArray): + outs = [outs] + + if len(outs) != self.n_outs: + raise ValueError( + f"Indicator {self.identifier} was wrongly defined. Expected " + f"{self.n_outs} outputs, got {len(outs)}." + ) + + # Metadata attributes from templates + var_id = None + for out, attrs, base_attrs in zip(outs, out_attrs, self.cf_attrs): + if self.n_outs > 1: + var_id = base_attrs["var_name"] + attrs.update(units=out.units) + attrs.update( + self._update_attrs( + params.copy(), + das, + base_attrs, + names=self._cf_names, + var_id=var_id, + ) + ) + + # Convert to output units + outs = [ + convert_units_to(out, attrs["units"]) for out, attrs in zip(outs, out_attrs) + ] + + outs = self._postprocess(outs, das, params) + + # Update variable attributes + for out, attrs in zip(outs, out_attrs): + var_name = attrs.pop("var_name") + out.attrs.update(attrs) + out.name = var_name + + if OPTIONS[AS_DATASET]: + out = Dataset({o.name: o for o in outs}) + if OPTIONS[KEEP_ATTRS] is True or ( + OPTIONS[KEEP_ATTRS] == "xarray" + and xarray.core.options._get_keep_attrs(False) + ): + out.attrs.update(dsattrs) + out.attrs["history"] = update_history( + self._history_string(das, params), + out, + new_name=self.identifier, + ) + return out + + # Return a single DataArray in case of single output, otherwise a tuple + if self.n_outs == 1: + return outs[0] + return tuple(outs) + + def _parse_variables_from_call(self, args, kwds) -> tuple[OrderedDict, dict]: + """Extract variable and optional variables from call arguments.""" + # Bind call arguments to `compute` arguments and set defaults. + ba = self.__signature__.bind(*args, **kwds) + ba.apply_defaults() + + # Assign inputs passed as strings from ds. + self._assign_named_args(ba) + + # Extract variables + inject injected + das = OrderedDict() + params = ba.arguments.copy() + for name, param in self._all_parameters.items(): + if not param.injected: + # If a variable pop the arg + if is_percentile_dataarray(params[name]): + # duplicate percentiles DA in both das and params + das[name] = params[name] + elif param.kind in [InputKind.VARIABLE, InputKind.OPTIONAL_VARIABLE]: + data = params.pop(name) + # If a non-optional variable OR None, store the arg + if param.kind == InputKind.VARIABLE or data is not None: + das[name] = data + else: + params[name] = param.value + + ds = ba.arguments.get("ds") + dsattrs = ds.attrs if ds is not None else {} + return das, params, dsattrs + + def _assign_named_args(self, ba): + """Assign inputs passed as strings from ds.""" + ds = ba.arguments.get("ds") + + for name, val in ba.arguments.items(): + kind = self.parameters[name].kind + + if kind <= InputKind.OPTIONAL_VARIABLE: + if isinstance(val, str) and ds is None: + raise ValueError( + "Passing variable names as string requires giving the `ds` " + f"dataset (got {name}='{val}')" + ) + if (isinstance(val, str) or val is None) and ds is not None: + # Set default name for DataArray + key = val or name + + if key in ds: + ba.arguments[name] = ds[key] + elif kind == InputKind.VARIABLE: + raise MissingVariableError( + f"For input '{name}', variable '{key}' " + "was not found in the input dataset." + ) + + def _postprocess(self, outs, das, params): + """Actions to done after computing.""" + return outs + + def _bind_call(self, func, **das): + """Call function using `__call__` `DataArray` arguments. + + This will try to bind keyword arguments to `func` arguments. If this fails, + `func` is called with positional arguments only. + + Notes + ----- + This method is used to support two main use cases. + + In use case #1, we have two compute functions with arguments in a different order: + `func1(tasmin, tasmax)` and `func2(tasmax, tasmin)` + + In use case #2, we have two compute functions with arguments that have different names: + `generic_func(da)` and `custom_func(tas)` + + Passing a dictionary of arguments will solve #1, but not #2. + """ + # First try to bind arguments to function. + try: + ba = signature(func).bind(**das) + except TypeError: + # If this fails, simply call the function using positional arguments + return func(*das.values()) + else: + # Call the func using bound arguments + return func(*ba.args, **ba.kwargs) + + @classmethod + def _get_translated_metadata( + cls, locale, var_id=None, names=None, append_locale_name=True + ): + """Get raw translated metadata for the current indicator and a given locale. + + All available translated metadata from the current indicator and those it is + based on are merged, with the highest priority set to the current one. + """ + var_id = var_id or "" + if var_id: + var_id = "." + var_id + + family_tree = [] + cl = cls + while hasattr(cl, "_registry_id"): + family_tree.append(cl._registry_id + var_id) + # The indicator mechanism always has single inheritance. + cl = cl.__bases__[0] + + return get_local_attrs( + family_tree, + locale, + names=names, + append_locale_name=append_locale_name, + ) + + def _update_attrs( + self, + args: dict[str, Any], + das: dict[str, DataArray], + attrs: dict[str, str], + var_id: str | None = None, + names: Sequence[str] | None = None, + ): + """Format attributes with the run-time values of `compute` call parameters. + + Cell methods and history attributes are updated, adding to existing values. + The language of the string is taken from the `OPTIONS` configuration dictionary. + + Parameters + ---------- + args : dict[str, Any] + Keyword arguments of the `compute` call. + das : dict[str, DataArray] + Input arrays. + attrs : dict[str, str] + The attributes to format and update. + var_id : str + The identifier to use when requesting the attributes translations. + Defaults to the class name (for the translations) or the `identifier` field of + the class (for the history attribute). + If given, the identifier will be converted to uppercase to get the translation + attributes. This is meant for multi-outputs indicators. + names : sequence of str, optional + List of attribute names for which to get a translation. + + Returns + ------- + dict + Attributes with {} expressions replaced by call argument values. With updated `cell_methods` and `history`. + `cell_methods` is not added if `names` is given and those not contain `cell_methods`. + """ + # FIXME: Some tests fail without this, the groups are not properly parsed before + # e.g. test_properties::TestProperties::test_return_value fails + if "group" in args and isinstance(args["group"], str): + args["group"] = Grouper(args["group"]) + + out = self._format(attrs, args) + for locale in OPTIONS[METADATA_LOCALES]: + out.update( + self._format( + self._get_translated_metadata( + locale, var_id=var_id, names=names or list(attrs.keys()) + ), + args=args, + formatter=get_local_formatter(locale), + ) + ) + + # Get history and cell method attributes from source data + attrs = defaultdict(str) + if names is None or "cell_methods" in names: + attrs["cell_methods"] = merge_attributes( + "cell_methods", new_line=" ", missing_str=None, **das + ) + if "cell_methods" in out: + attrs["cell_methods"] += " " + out.pop("cell_methods") + + attrs["history"] = update_history( + self._history_string(das, args), + new_name=out.get("var_name"), + **das, + ) + + attrs.update(out) + return attrs + + def _history_string(self, das, params): + kwargs = dict(**das) + for k, v in params.items(): + if self._all_parameters[k].injected: + continue + if self._all_parameters[k].kind == InputKind.KWARGS: + kwargs.update(**v) + elif self._all_parameters[k].kind != InputKind.DATASET: + kwargs[k] = v + return gen_call_string(self._registry_id, **kwargs) + + @staticmethod + def _check_identifier(identifier: str) -> None: + """Verify that the identifier is a proper slug.""" + if not re.match(r"^[-\w]+$", identifier): + warnings.warn( + "The identifier contains non-alphanumeric characters. It could make " + "life difficult for downstream software reusing this class.", + UserWarning, + ) + + @classmethod + def translate_attrs(cls, locale: str | Sequence[str], fill_missing: bool = True): + """Return a dictionary of unformatted translated translatable attributes. + + Translatable attributes are defined in :py:const:`xclim.core.locales.TRANSLATABLE_ATTRS`. + + Parameters + ---------- + locale : str or sequence of str + The POSIX name of the locale or a tuple of a locale name and a path to a json file defining translations. + See `xclim.locale` for details. + fill_missing : bool + If True (default) fill the missing attributes by their english values. + """ + + def _translate(cf_attrs, names, var_id=None): + attrs = cls._get_translated_metadata( + locale, + var_id=var_id, + names=names, + append_locale_name=False, + ) + if fill_missing: + for name in names: + if name not in attrs and cf_attrs.get(name): + attrs[name] = cf_attrs.get(name) + return attrs + + # Translate global attrs + attrs = _translate( + cls.__dict__, + # Translate only translatable attrs that are not variable attrs + set(TRANSLATABLE_ATTRS).difference(set(cls._cf_names)), + ) + # Translate variable attrs + attrs["cf_attrs"] = [] + var_id = None + for cf_attrs in cls.cf_attrs: # Translate for each variable + if len(cls.cf_attrs) > 1: + var_id = cf_attrs["var_name"] + attrs["cf_attrs"].append( + _translate( + cf_attrs, + set(TRANSLATABLE_ATTRS).intersection(cls._cf_names), + var_id=var_id, + ) + ) + return attrs + + @classmethod + def json(self, args=None): + """Return a serializable dictionary representation of the class. + + Parameters + ---------- + args : mapping, optional + Arguments as passed to the call method of the indicator. + If not given, the default arguments will be used when formatting the attributes. + + Notes + ----- + This is meant to be used by a third-party library wanting to wrap this class into another interface. + + """ + names = ["identifier", "title", "abstract", "keywords"] + out = {key: getattr(self, key) for key in names} + out = self._format(out, args) + + # Format attributes + out["outputs"] = [self._format(attrs, args) for attrs in self.cf_attrs] + out["notes"] = self.notes + + # We need to deepcopy, otherwise empty defaults get overwritten! + # All those tweaks are to ensure proper serialization of the returned dictionary. + out["parameters"] = { + k: p.asdict() if not p.injected else deepcopy(p.value) + for k, p in self._all_parameters.items() + } + for name, param in list(out["parameters"].items()): + if not self._all_parameters[name].injected: + param["kind"] = param["kind"].value # Get the int. + if "choices" in param: # A set is stored, convert to list + param["choices"] = list(param["choices"]) + if param["default"] is _empty_default: + del param["default"] + elif callable(param): # Rare special case (doy_qmax and doy_qmin). + out["parameters"][name] = f"{param.__module__}.{param.__name__}" + + return out + + @classmethod + def _format( + cls, + attrs: dict, + args: dict | None = None, + formatter: AttrFormatter = default_formatter, + ) -> dict: + """Format attributes including {} tags with arguments. + + Parameters + ---------- + attrs : dict + Attributes containing tags to replace with arguments' values. + args : dict, optional + Function call arguments. If not given, the default arguments will be used when formatting the attributes. + formatter : AttrFormatter + Plaintext mappings for indicator attributes. + + Returns + ------- + dict + """ + # Use defaults + if args is None: + args = { + k: p.default if not p.injected else p.value + for k, p in cls._all_parameters.items() + } + + # Prepare arguments + mba = {} + # Add formatting {} around values to be able to replace them with _attrs_mapping using format. + for k, v in args.items(): + if isinstance(v, units.Quantity): + mba[k] = f"{v:g~P}" + elif isinstance(v, (int, float)): + mba[k] = f"{v:g}" + # TODO: What about InputKind.NUMBER_SEQUENCE + elif k == "indexer": + if v and v not in [_empty, _empty_default]: + dk, dv = v.copy().popitem() + if dk == "month": + dv = f"m{dv}" + elif dk in ("doy_bounds", "date_bounds"): + dv = f"{dv[0]} to {dv[1]}" + mba["indexer"] = dv + else: + mba["indexer"] = args.get("freq") or "YS" + elif is_percentile_dataarray(v): + mba.update(get_percentile_metadata(v, k)) + elif ( + isinstance(v, DataArray) + and cls._all_parameters[k].kind == InputKind.QUANTIFIED + ): + mba[k] = "<an array>" + else: + mba[k] = v + out = {} + for key, val in attrs.items(): + if callable(val): + val = val(**mba) + + out[key] = formatter.format(val, **mba) + + if key in cls._text_fields: + out[key] = out[key].strip().capitalize() + + return out + + # The following static methods are meant to be replaced to define custom indicators. + @staticmethod + def compute(*args, **kwds): + """Compute the indicator. + + This would typically be a function from `xclim.indices`. + """ + raise NotImplementedError + + def __getattr__(self, attr): + """Return the attribute.""" + if attr in self._cf_names: + out = [meta.get(attr, "") for meta in self.cf_attrs] + if len(out) == 1: + return out[0] + return out + raise AttributeError(attr) + + @property + def n_outs(self): + """Return the length of all cf_attrs.""" + return len(self.cf_attrs) + + @property + def parameters(self): + """Create a dictionary of controllable parameters. + + Similar to :py:attr:`Indicator._all_parameters`, but doesn't include injected parameters. + """ + return { + name: param + for name, param in self._all_parameters.items() + if not param.injected + } + + @property + def injected_parameters(self): + """Return a dictionary of all injected parameters. + + Opposite of :py:meth:`Indicator.parameters`. + """ + return { + name: param.value + for name, param in self._all_parameters.items() + if param.injected + } + + @property + def is_generic(self): + """Return True if the indicator is "generic", meaning that it can accept variables with any units.""" + return not hasattr(self.compute, "in_units") + + def _show_deprecation_warning(self): + warnings.warn( + f"`{self.title}` is deprecated as of `xclim` v{self._version_deprecated} and will be removed " + "in a future release. See the `xclim` release notes for more information: " + f"https://xclim.readthedocs.io/en/stable/history.html", + FutureWarning, + stacklevel=3, + ) From ca8bb7538f3dd5a8ada92ba59a48f003a37a307e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 30 Jul 2024 20:29:45 -0400 Subject: [PATCH 027/105] PASSED: test_measures.py --- src/xsdba/measures.py | 512 ++++++++++++++++++++++++++++++++++++++++ src/xsdba/properties.py | 16 +- tests/test_measures.py | 102 ++++++++ 3 files changed, 621 insertions(+), 9 deletions(-) create mode 100644 src/xsdba/measures.py create mode 100644 tests/test_measures.py diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py new file mode 100644 index 0000000..bcbefae --- /dev/null +++ b/src/xsdba/measures.py @@ -0,0 +1,512 @@ +"""# noqa: SS01 +Measures Submodule +================== +Measures compare adjusted simulations to a reference + +SDBA diagnostic tests are made up of properties and measures. Measures compare adjusted simulations to a reference, +through statistical properties or directly. This framework for the diagnostic tests was inspired by the +`VALUE <http://www.value-cost.eu/>`_ project. +""" + +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np +import xarray as xr + +from xsdba.indicator import Indicator, base_registry + +# ADAPT +# from xclim.core.units import ensure_delta +from .base import Grouper +from .typing import InputKind +from .units import check_units, ensure_delta +from .utils import _pairwise_spearman + + +class StatisticalMeasure(Indicator): + """Base indicator class for statistical measures used when validating bias-adjusted outputs. + + Statistical measures use input data where the time dimension was reduced, usually by the computation + of a :py:class:`xclim.sdba.properties.StatisticalProperty` instance. They usually take two arrays + as input: "sim" and "ref", "sim" being measured against "ref". The two arrays must have identical + coordinates on their common dimensions. + + Statistical measures are generally unit-generic. If the inputs have different units, "sim" is converted + to match "ref". + """ + + # realm = "generic" + + @classmethod + def _ensure_correct_parameters(cls, parameters): + inputs = {k for k, p in parameters.items() if p.kind == InputKind.VARIABLE} + if not inputs.issuperset({"sim", "ref"}): + raise ValueError( + f"{cls.__name__} requires 'sim' and 'ref' as inputs. Got {inputs}." + ) + return super()._ensure_correct_parameters(parameters) + + @check_units([{"das": "ref"}, {"das": "sim"}]) + def _preprocess_and_checks(self, das, params): + """Perform parent's checks and also check convert units so that sim matches ref.""" + das, params = super()._preprocess_and_checks(das, params) + + # Convert grouping and check if allowed: + sim = das["sim"] + ref = das["ref"] + + # Check if common coordinates are identical. + newsim, newref = xr.broadcast(sim, ref) + for dim in set(sim.dims).union(ref.dims): + if [sim[dim].size, ref[dim].size] != [newsim[dim].size, newref[dim].size]: + raise ValueError( + f"Common dimension {dim} has different coordinates between ref and sim." + ) + return das, params + + +class StatisticalPropertyMeasure(Indicator): + """Base indicator class for statistical properties that include the comparison measure, used when validating bias-adjusted outputs. + + StatisticalPropertyMeasure objects combine the functionalities of + :py:class:`xclim.sdba.properties.StatisticalProperty` and + :py:class:`xclim.sdba.properties.StatisticalMeasure`. + + Statistical properties usually reduce the time dimension and sometimes more dimensions + (for example in spatial properties), sometimes adding a grouping dimension according to + the passed value of `group` (e.g.: group='time.month' means the loss of the time dimension + and the addition of a month one). + + Statistical measures usually take two arrays as input: "sim" and "ref", "sim" being measured against "ref". + + Statistical property-measures are generally unit-generic. If the inputs have different units, + "sim" is converted to match "ref". + """ + + aspect = None + """The aspect the statistical property studies: marginal, temporal, multivariate or spatial.""" + + allowed_groups = None + """A list of allowed groupings. A subset of dayofyear, week, month, season or group. + The latter stands for no temporal grouping.""" + + # realm = "generic" + + @classmethod + def _ensure_correct_parameters(cls, parameters): + inputs = {k for k, p in parameters.items() if p.kind == InputKind.VARIABLE} + if not inputs.issuperset({"sim", "ref"}): + raise ValueError( + f"{cls.__name__} requires 'sim' and 'ref' as inputs. Got {inputs}." + ) + + if "group" not in parameters: + raise ValueError( + f"{cls.__name__} require a 'group' argument, use the base Indicator" + " class if your computation doesn't perform any regrouping." + ) + + return super()._ensure_correct_parameters(parameters) + + @check_units([{"das": "ref"}, {"das": "sim"}]) + def _preprocess_and_checks(self, das, params): + """Perform parent's checks and also check convert units so that sim matches ref.""" + das, params = super()._preprocess_and_checks(das, params) + + # Convert grouping and check if allowed: + if isinstance(params["group"], str): + params["group"] = Grouper(params["group"]) + + if self.allowed_groups is not None: + if params["group"].prop not in self.allowed_groups: + raise ValueError( + f"Grouping period {params['group'].prop_name} is not allowed for property " + f"{self.identifier} (needs something in " + f"{list(map(lambda g: '<dim>.' + g.replace('group', ''), self.allowed_groups))})." + ) + return das, params + + def _postprocess(self, outs, das, params): + """Squeeze `group` dim if needed.""" + outs = super()._postprocess(outs, das, params) + + for i in range(len(outs)): + if "group" in outs[i].dims: + outs[i] = outs[i].squeeze("group", drop=True) + + return outs + + +base_registry["StatisticalMeasure"] = StatisticalMeasure +base_registry["StatisticalPropertyMeasure"] = StatisticalPropertyMeasure + + +def _bias(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray: + """Bias. + + The bias is the simulation minus the reference. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (one value for each grid-point). + ref : xr.DataArray + data from the reference (observations) (one value for each grid-point). + + Returns + ------- + xr.DataArray, [same as ref] + Absolute bias. + """ + out = sim - ref + + out.attrs["units"] = ensure_delta(ref.attrs["units"]) + return out + + +bias = StatisticalMeasure(identifier="bias", compute=_bias) + + +def _relative_bias(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray: + """Relative Bias. + + The relative bias is the simulation minus reference, divided by the reference. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (one value for each grid-point). + ref : xr.DataArray + data from the reference (observations) (one value for each grid-point). + + Returns + ------- + xr.DataArray, [dimensionless] + Relative bias. + """ + out = (sim - ref) / ref + return out.assign_attrs(units="") + + +relative_bias = StatisticalMeasure( + identifier="relative_bias", compute=_relative_bias, units="" +) + + +def _circular_bias(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray: + """Circular bias. + + Bias considering circular time series. + E.g. The bias between doy 365 and doy 1 is 364, but the circular bias is -1. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (one value for each grid-point). + ref : xr.DataArray + data from the reference (observations) (one value for each grid-point). + + Returns + ------- + xr.DataArray, [days] + Circular bias. + """ + out = (sim - ref) % 365 + out = out.where( + out <= 365 / 2, 365 - out + ) # when condition false, replace by 2nd arg + out = out.where(ref >= sim, out * -1) # when condition false, replace by 2nd arg + return out.assign_attrs(units="days") + + +circular_bias = StatisticalMeasure( + identifier="circular_bias", compute=_circular_bias, units="days" +) + + +def _ratio(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray: + """Ratio. + + The ratio is the quotient of the simulation over the reference. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (one value for each grid-point). + ref : xr.DataArray + data from the reference (observations) (one value for each grid-point). + + Returns + ------- + xr.DataArray, [dimensionless] + Ratio. + """ + out = sim / ref + out.attrs["units"] = "" + return out + + +ratio = StatisticalMeasure(identifier="ratio", compute=_ratio, units="") + + +def _rmse( + sim: xr.DataArray, ref: xr.DataArray, group: str | Grouper = "time" +) -> xr.DataArray: + """Root mean square error. + + The root mean square error on the time dimension between the simulation and the reference. + + Parameters + ---------- + sim : xr.DataArray + Data from the simulation (a time-series for each grid-point). + ref : xr.DataArray + Data from the reference (observations) (a time-series for each grid-point). + group: str + Compute the property and measure for each temporal groups individually. + Currently not implemented. + + Returns + ------- + xr.DataArray, [same as ref] + Root mean square error. + """ + + def _rmse_internal(_sim: xr.DataArray, _ref: xr.DataArray) -> xr.DataArray: + _f: xr.DataArray = np.sqrt(np.mean((_sim - _ref) ** 2, axis=-1)) + return _f + + out = xr.apply_ufunc( + _rmse_internal, + sim, + ref, + input_core_dims=[["time"], ["time"]], + dask="parallelized", + ) + out = out.assign_attrs(units=ensure_delta(ref.units)) + return out + + +rmse = StatisticalPropertyMeasure( + identifier="rmse", + aspect="temporal", + compute=_rmse, + allowed_groups=["group"], + cell_methods="time: mean", +) + + +def _mae( + sim: xr.DataArray, ref: xr.DataArray, group: str | Grouper = "time" +) -> xr.DataArray: + """Mean absolute error. + + The mean absolute error on the time dimension between the simulation and the reference. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (a time-series for each grid-point). + ref : xr.DataArray + data from the reference (observations) (a time-series for each grid-point). + group : str + Compute the property and measure for each temporal groups individually. + Currently not implemented. + + Returns + ------- + xr.DataArray, [same as ref] + Mean absolute error. + """ + + def _mae_internal(_sim: xr.DataArray, _ref: xr.DataArray) -> xr.DataArray: + _f: xr.DataArray = np.mean(np.abs(_sim - _ref), axis=-1) + return _f + + out = xr.apply_ufunc( + _mae_internal, + sim, + ref, + input_core_dims=[["time"], ["time"]], + dask="parallelized", + ) + out = out.assign_attrs(units=ensure_delta(ref.units)) + return out + + +mae = StatisticalPropertyMeasure( + identifier="mae", + aspect="temporal", + compute=_mae, + allowed_groups=["group"], + cell_methods="time: mean", +) + + +def _annual_cycle_correlation( + sim: xr.DataArray, + ref: xr.DataArray, + window: int = 15, + group: str | Grouper = "time", +) -> xr.DataArray: + """Annual cycle correlation. + + Pearson correlation coefficient between the smooth day-of-year averaged annual cycles of the simulation and + the reference. In the smooth day-of-year averaged annual cycles, each day-of-year is averaged over all years + and over a window of days around that day. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (a time-series for each grid-point). + ref : xr.DataArray + data from the reference (observations) (a time-series for each grid-point). + window : int + Size of window around each day of year around which to take the mean. + E.g. If window=31, Jan 1st is averaged over from December 17th to January 16th. + group : str + Compute the property and measure for each temporal groups individually. + Currently not implemented. + + Returns + ------- + xr.DataArray, [dimensionless] + Annual cycle correlation. + """ + # group by day-of-year and window around each doy + grouper_test = Grouper("time.dayofyear", window=window) + # for each day, mean over X day window and over all years to create a smooth avg annual cycle + sim_annual_cycle = grouper_test.apply("mean", sim) + ref_annual_cycle = grouper_test.apply("mean", ref) + out = xr.corr(ref_annual_cycle, sim_annual_cycle, dim="dayofyear") + return out.assign_attrs(units="") + + +annual_cycle_correlation = StatisticalPropertyMeasure( + identifier="annual_cycle_correlation", + aspect="temporal", + compute=_annual_cycle_correlation, + allowed_groups=["group"], +) + + +def _scorr( + sim: xr.DataArray, + ref: xr.DataArray, + *, + dims: Sequence | None = None, + group: str | Grouper = "time", +): + """Spatial correllogram. + + Compute the inter-site correlations of each array, compute the difference in correlations and sum. + Taken from Vrac (2018). The spatial and temporal dimensions are reduced. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (a time-series for each grid-point). + ref : xr.DataArray + data from the reference (observations) (a time-series for each grid-point). + dims : sequence of strings, optional + Name of the spatial dimensions. If None (default), all dimensions except 'time' are used. + group : str + Compute the property and measure for each temporal groups individually. + Currently not implemented. + + Returns + ------- + xr.DataArray, [dimensionless] + Sum of the inter-site correlation differences. + """ + if dims is None: + dims = [d for d in sim.dims if d != "time"] + + refcorr = _pairwise_spearman(ref, dims) + simcorr = _pairwise_spearman(sim, dims) + S_corr = (simcorr - refcorr).sum(["_spatial", "_spatial2"]) + return S_corr.assign_attrs(units="") + + +scorr = StatisticalPropertyMeasure( + identifier="Scorr", aspect="spatial", compute=_scorr, allowed_groups=["group"] +) + + +def _taylordiagram( + sim: xr.DataArray, + ref: xr.DataArray, + dim: str = "time", + group: str | Grouper = "time", + normalize: bool = False, +) -> xr.DataArray: + """Taylor diagram. + + Compute the respective standard deviations of a simulation and a reference array, as well as the Pearson + correlation coefficient between both, all necessary parameters to plot points on a Taylor diagram. + + Parameters + ---------- + sim : xr.DataArray + data from the simulation (a time-series for each grid-point). + ref : xr.DataArray + data from the reference (observations) (a time-series for each grid-point). + dim : str + Dimension across which the correlation and standard deviation should be computed. + group : str + Compute the property and measure for each temporal groups individually. + Currently not implemented. + normalize : bool + If `True`, divide the standard deviations by the standard deviation of the reference. + Default is `False`. + + Returns + ------- + xr.DataArray, [same as ref] + Standard deviations of sim, ref and correlation coefficient between both. + """ + corr = xr.corr(sim, ref, dim=dim) + + ref_std = ref.std(dim=dim, skipna=True, keep_attrs=True) + sim_std = sim.std(dim=dim, skipna=True, keep_attrs=True) + + new_dim = xr.DataArray( + ["ref_std", "sim_std", "corr"], dims=("taylor_param",), name="taylor_param" + ) + + out = xr.concat( + [ref_std, sim_std, corr], + new_dim, + coords="minimal", + compat="override", # Take common coords from `ref_std`. + ).assign_attrs( + { + "correlation_type": "Pearson correlation coefficient", + "units": ref.units, + } + ) + + # Normalize the standard deviations byt the standard deviation of the reference. + if normalize: + if (out[{"taylor_param": 0}] == 0).any(): + raise ValueError( + "`ref_std =0` (homogeneous field) obtained, normalization is not possible." + ) + with xr.set_options(keep_attrs=True): + out[{"taylor_param": [0, 1]}] = ( + out[{"taylor_param": [0, 1]}] / out[{"taylor_param": 0}] + ) + out.attrs["normalized"] = True + out.attrs["units"] = "" + + return out + + +taylordiagram = StatisticalPropertyMeasure( + identifier="taylordiagram", + aspect="temporal", + compute=_taylordiagram, + allowed_groups=["group"], +) diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 648cc51..42ab202 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -1,5 +1,5 @@ # pylint: disable=missing-kwoa -""" +"""# noqa: SS01 Properties Submodule ==================== SDBA diagnostic tests are made up of statistical properties and measures. Properties are calculated on both simulation @@ -7,7 +7,6 @@ This framework for the diagnostic tests was inspired by the `VALUE <http://www.value-cost.eu/>`_ project. Statistical Properties is the xclim term for 'indices' in the VALUE project. - """ from __future__ import annotations @@ -50,7 +49,6 @@ class StatisticalProperty(Indicator): Statistical properties may restrict the sampling frequency of the input, they usually take in a single variable (named "da" in unit-generic instances). - """ aspect = None @@ -328,7 +326,7 @@ def _spell_length_distribution( Float of the quantile if the method is "quantile". window : int Number of consecutive days respecting the constraint in order to begin a spell. - Default is 1, which is equivalent to `_threshold_count` + Default is 1, which is equivalent to `_threshold_count`. stat : {'mean', 'sum', 'max','min'} Statistics to apply to the remaining time dimension after resampling (e.g. Jan 1980-2010) stat_resample : {'mean', 'sum', 'max','min'}, optional @@ -517,7 +515,7 @@ def _acf( """ def acf_last(x, nlags): - """Statsmodels acf calculates acf for lag 0 to nlags, this return only the last one.""" + """Calculates, like Statsmodels, acf for lag 0 to nlags, but returns only the last one.""" # As we resample + group, timeseries are quite short and fft=False seems more performant out_last = stattools.acf(x, nlags=nlags, fft=False) return out_last[-1] @@ -787,7 +785,7 @@ def _corr_btw_var( Returns ------- xr.DataArray, [dimensionless] - {corr_type} correlation coefficient + {corr_type} correlation coefficient. """ if corr_type.lower() not in {"pearson", "spearman"}: raise ValueError( @@ -883,7 +881,7 @@ def _bivariate_spell_length_distribution( Float of the quantile if the method is "quantile". window : int Number of consecutive days respecting the constraint in order to begin a spell. - Default is 1, which is equivalent to `_bivariate_threshold_count` + Default is 1, which is equivalent to `_bivariate_threshold_count`. stat : {'mean', 'sum', 'max','min'} Statistics to apply to the remaining time dimension after resampling (e.g. Jan 1980-2010) stat_resample : {'mean', 'sum', 'max','min'}, optional @@ -1210,6 +1208,8 @@ def _trend( ---------- da : xr.DataArray Variable on which to calculate the diagnostic. + group : {'time', 'time.season', 'time.month'} + Grouping on the output. output : {'slope', 'intercept', 'rvalue', 'pvalue', 'stderr', 'intercept_stderr'} The attributes of the linear regression to return, as defined in scipy.stats.linregress: 'slope' is the slope of the regression line. @@ -1220,8 +1220,6 @@ def _trend( using Wald Test with t-distribution of the test statistic. 'stderr' is the standard error of the estimated slope (gradient), under the assumption of residual normality. 'intercept_stderr' is the standard error of the estimated intercept, under the assumption of residual normality. - group : {'time', 'time.season', 'time.month'} - Grouping on the output. Returns ------- diff --git a/tests/test_measures.py b/tests/test_measures.py new file mode 100644 index 0000000..3d2483a --- /dev/null +++ b/tests/test_measures.py @@ -0,0 +1,102 @@ +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr + +from xsdba import measures + + +def test_bias(open_dataset): + sim = open_dataset("sdba/CanESM2_1950-2100.nc").sel(time="1950-01-01").tasmax + ref = open_dataset("sdba/nrcan_1950-2013.nc").sel(time="1950-01-01").tasmax + test = measures.bias(sim, ref).values + np.testing.assert_array_almost_equal(test, [[6.430237, 39.088974, 5.2402344]]) + + +def test_relative_bias(open_dataset): + sim = open_dataset("sdba/CanESM2_1950-2100.nc").sel(time="1950-01-01").tasmax + ref = open_dataset("sdba/nrcan_1950-2013.nc").sel(time="1950-01-01").tasmax + test = measures.relative_bias(sim, ref).values + np.testing.assert_array_almost_equal(test, [[0.02366494, 0.16392256, 0.01920133]]) + + +def test_circular_bias(): + sim = xr.DataArray( + data=np.array([1, 1, 1, 2, 365, 300]), attrs={"units": "", "long_name": "test"} + ) + ref = xr.DataArray( + data=np.array([2, 365, 300, 1, 1, 1]), attrs={"units": "", "long_name": "test"} + ) + test = measures.circular_bias(sim, ref).values + np.testing.assert_array_almost_equal(test, [1, 1, 66, -1, -1, -66]) + + +def test_ratio(open_dataset): + sim = open_dataset("sdba/CanESM2_1950-2100.nc").sel(time="1950-01-01").tasmax + ref = open_dataset("sdba/nrcan_1950-2013.nc").sel(time="1950-01-01").tasmax + test = measures.ratio(sim, ref).values + np.testing.assert_array_almost_equal(test, [[1.023665, 1.1639225, 1.0192013]]) + + +def test_rmse(open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc").sel(time=slice("1950", "1953")).tasmax + ) + ref = open_dataset("sdba/nrcan_1950-2013.nc").sel(time=slice("1950", "1953")).tasmax + test = measures.rmse(sim, ref).values + np.testing.assert_array_almost_equal(test, [5.4499755, 18.124086, 12.387193], 4) + + +def test_mae(open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc").sel(time=slice("1950", "1953")).tasmax + ) + ref = open_dataset("sdba/nrcan_1950-2013.nc").sel(time=slice("1950", "1953")).tasmax + test = measures.mae(sim, ref).values + np.testing.assert_array_almost_equal(test, [4.159672, 14.2148, 9.768536], 4) + + +def test_annual_cycle_correlation(open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc").sel(time=slice("1950", "1953")).tasmax + ) + ref = open_dataset("sdba/nrcan_1950-2013.nc").sel(time=slice("1950", "1953")).tasmax + test = ( + measures.annual_cycle_correlation(sim, ref, window=31) + .sel(location="Vancouver") + .values + ) + np.testing.assert_array_almost_equal(test, [0.94580488], 4) + + +@pytest.mark.slow +def test_scorr(open_dataset): + ref = open_dataset("NRCANdaily/nrcan_canada_daily_tasmin_1990.nc").tasmin + sim = open_dataset("NRCANdaily/nrcan_canada_daily_tasmax_1990.nc").tasmax + scorr = measures.scorr(sim.isel(lon=slice(0, 50)), ref.isel(lon=slice(0, 50))) + + np.testing.assert_allclose(scorr, [97374.2146243]) + + +def test_taylordiagram(open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1950", "1953"), location="Amos") + .tasmax + ) + ref = ( + open_dataset("sdba/nrcan_1950-2013.nc") + .sel(time=slice("1950", "1953"), location="Amos") + .tasmax + ) + test = measures.taylordiagram(sim, ref).values + np.testing.assert_array_almost_equal(test, [13.12244701, 6.76166582, 0.73230199], 4) + + # test normalization option + test_normalize = measures.taylordiagram(sim, ref, normalize=True).values + np.testing.assert_array_almost_equal( + test_normalize, + [13.12244701 / 13.12244701, 6.76166582 / 13.12244701, 0.73230199], + 4, + ) From a504b6c9fe8ae2a1800998403306fd050ff566b7 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 31 Jul 2024 00:30:20 +0000 Subject: [PATCH 028/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/indicator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py index 5348a2e..7254f54 100644 --- a/src/xsdba/indicator.py +++ b/src/xsdba/indicator.py @@ -106,6 +106,7 @@ import warnings import weakref from collections import OrderedDict, defaultdict +from collections.abc import Sequence from copy import deepcopy from dataclasses import asdict, dataclass from functools import reduce @@ -117,7 +118,6 @@ from pathlib import Path from types import ModuleType from typing import Any, Callable, Optional, Union -from collections.abc import Sequence import numpy as np import xarray From 91d2a96e7ebb6aad67ab215e0c654ca92ed075d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 30 Jul 2024 21:07:29 -0400 Subject: [PATCH 029/105] PASSED: test_units.py (still needs more tests) --- src/xsdba/detrending.py | 6 +- src/xsdba/indicator.py | 6 +- src/xsdba/measures.py | 6 +- src/xsdba/processing.py | 35 +++++------- src/xsdba/units.py | 24 +++----- tests/test_units.py | 120 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 153 insertions(+), 44 deletions(-) create mode 100644 tests/test_units.py diff --git a/src/xsdba/detrending.py b/src/xsdba/detrending.py index e0977fb..8d0ecab 100644 --- a/src/xsdba/detrending.py +++ b/src/xsdba/detrending.py @@ -9,7 +9,7 @@ from .base import Grouper, ParametrizableWithDataset, map_groups, parse_group from .loess import loess_smoothing -from .units import check_units +from .units import compare_units from .utils import ADDITIVE, apply_correction, invert @@ -91,13 +91,13 @@ def retrend(self, da: xr.DataArray): raise ValueError("You must call fit() before retrending") return self._retrend(da, self.ds.trend) - @check_units(["da", "trend"]) + @compare_units(["da", "trend"]) def _detrend(self, da, trend): """Detrend.""" # Remove trend from series return apply_correction(da, invert(trend, self.kind), self.kind) - @check_units(["da", "trend"]) + @compare_units(["da", "trend"]) def _retrend(self, da, trend): """Retrend.""" # Add trend to series diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py index 5348a2e..1ab6010 100644 --- a/src/xsdba/indicator.py +++ b/src/xsdba/indicator.py @@ -106,6 +106,7 @@ import warnings import weakref from collections import OrderedDict, defaultdict +from collections.abc import Sequence from copy import deepcopy from dataclasses import asdict, dataclass from functools import reduce @@ -117,7 +118,6 @@ from pathlib import Path from types import ModuleType from typing import Any, Callable, Optional, Union -from collections.abc import Sequence import numpy as np import xarray @@ -156,7 +156,7 @@ OPTIONS, ) from .typing import InputKind -from .units import check_units, convert_units_to, units +from .units import compare_units, convert_units_to, units from .utils import load_module # Indicators registry @@ -1149,7 +1149,7 @@ def _translate(cf_attrs, names, var_id=None): return attrs @classmethod - def json(self, args=None): + def json(cls, args=None): """Return a serializable dictionary representation of the class. Parameters diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py index bcbefae..0b1595a 100644 --- a/src/xsdba/measures.py +++ b/src/xsdba/measures.py @@ -21,7 +21,7 @@ # from xclim.core.units import ensure_delta from .base import Grouper from .typing import InputKind -from .units import check_units, ensure_delta +from .units import compare_units, ensure_delta from .utils import _pairwise_spearman @@ -48,7 +48,7 @@ def _ensure_correct_parameters(cls, parameters): ) return super()._ensure_correct_parameters(parameters) - @check_units([{"das": "ref"}, {"das": "sim"}]) + @compare_units([{"das": "ref"}, {"das": "sim"}]) def _preprocess_and_checks(self, das, params): """Perform parent's checks and also check convert units so that sim matches ref.""" das, params = super()._preprocess_and_checks(das, params) @@ -110,7 +110,7 @@ def _ensure_correct_parameters(cls, parameters): return super()._ensure_correct_parameters(parameters) - @check_units([{"das": "ref"}, {"das": "sim"}]) + @compare_units([{"das": "ref"}, {"das": "sim"}]) def _preprocess_and_checks(self, das, params): """Perform parent's checks and also check convert units so that sim matches ref.""" das, params = super()._preprocess_and_checks(das, params) diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 4e37cb3..a708a75 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -20,7 +20,7 @@ from ._processing import _adapt_freq, _normalize, _reordering from .base import Grouper from .nbutils import _escore -from .units import check_units, convert_units_to, harmonize_units +from .units import compare_units, convert_units_to, harmonize_units from .utils import ADDITIVE, copy_all_attrs # from xclim.core.units import convert_units_to, infer_context, units @@ -67,7 +67,7 @@ def adapt_freq( sim : xr.Dataset Simulated data, with a "time" dimension. group : str or Grouper - Grouping information, see base.Grouper + Grouping information, see base.Grouper. thresh : str Threshold below which values are considered zero, a quantity with units. @@ -96,7 +96,6 @@ def adapt_freq( References ---------- :cite:cts:`sdba-themesl_empirical-statistical_2012` - """ out = _adapt_freq(xr.Dataset(dict(sim=sim, ref=ref)), group=group, thresh=thresh) @@ -134,7 +133,7 @@ def jitter_under_thresh(x: xr.DataArray, thresh: str) -> xr.DataArray: Returns ------- - xr.DataArray + xr.DataArray. Notes ----- @@ -162,12 +161,11 @@ def jitter_over_thresh(x: xr.DataArray, thresh: str, upper_bnd: str) -> xr.DataA Returns ------- - xr.DataArray + xr.DataArray. Notes ----- If thresh is low, this will change the mean value of x. - """ j: xr.DataArray = jitter( x, lower=None, upper=thresh, minimum=None, maximum=upper_bnd @@ -353,29 +351,28 @@ def unstandardize(da: xr.DataArray, mean: xr.DataArray, std: xr.DataArray): @update_xsdba_history def reordering(ref: xr.DataArray, sim: xr.DataArray, group: str = "time") -> xr.Dataset: - """Reorders data in `sim` following the order of ref. + """Reorder data in `sim` following the order of ref. The rank structure of `ref` is used to reorder the elements of `sim` along dimension "time", optionally doing the operation group-wise. Parameters ---------- - sim : xr.DataArray - Array to reorder. ref : xr.DataArray Array whose rank order sim should replicate. + sim : xr.DataArray + Array to reorder. group : str Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. Returns ------- xr.Dataset - sim reordered according to ref's rank order. + Sim reordered according to ref's rank order. References ---------- - :cite:cts:`sdba-cannon_multivariate_2018` - + :cite:cts:`sdba-cannon_multivariate_2018`. """ ds = xr.Dataset({"sim": sim, "ref": ref}) out: xr.Dataset = _reordering(ds, group=group).reordered @@ -414,7 +411,7 @@ def escore( Returns ------- xr.DataArray - e-score with dimensions not in `dims`. + Return e-score with dimensions not in `dims`. Notes ----- @@ -441,8 +438,7 @@ def escore( References ---------- - :cite:cts:`sdba-baringhaus_new_2004,sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-szekely_testing_2004` - + :cite:cts:`sdba-baringhaus_new_2004,sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-szekely_testing_2004`. """ pts_dim, obs_dim = dims @@ -563,14 +559,14 @@ def to_additive_space( See Also -------- + Related functions from_additive_space : for the inverse transformation. jitter_under_thresh : Remove values exactly equal to the lower bound. jitter_over_thresh : Remove values exactly equal to the upper bound. References ---------- - :cite:cts:`sdba-alavoine_distinct_2022` - + :cite:cts:`sdba-alavoine_distinct_2022`. """ # with units.context(infer_context(data.attrs.get("standard_name"))): lower_bound_array = np.array(lower_bound).astype(float) @@ -666,7 +662,7 @@ def from_additive_space( References ---------- - :cite:cts:`sdba-alavoine_distinct_2022` + :cite:cts:`sdba-alavoine_distinct_2022`. """ if trans is None and lower_bound is None and units is None: @@ -748,7 +744,6 @@ def stack_variables(ds: xr.Dataset, rechunk: bool = True, dim: str = "multivar") `sdba_transform_upper` are also set if the requested bounds are different from the defaults. Array with variables stacked along `dim` dimension. Units are set to "". - """ # Store original arrays' attributes attrs: dict = {} @@ -825,7 +820,7 @@ def grouped_time_indexes(times, group): times : xr.DataArray Time dimension in the dataset of interest. group : str or Grouper - Grouping information, see base.Grouper + Grouping information, see base.Grouper. Returns ------- diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 484182f..6949cfc 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -24,12 +24,13 @@ import numpy as np import xarray as xr -from .calendar import parse_offset +from .calendar import get_calendar, parse_offset from .typing import Quantified from .utils import copy_all_attrs units = pint.get_application_registry() - +# Another alias not included by cf_xarray +units.define("@alias percent = pct") FREQ_UNITS = { "D": "d", @@ -66,7 +67,7 @@ def infer_sampling_units( Returns ------- int - The magnitude (number of base periods per period) + The magnitude (number of base periods per period). str Units as a string, understandable by pint. """ @@ -169,7 +170,7 @@ def pint2str(value: units.Quantity | units.Unit) -> str: Returns ------- str - Units + Units. Notes ----- @@ -213,7 +214,7 @@ def ensure_delta(unit: str) -> str: Parameters ---------- unit : str - unit to transform in delta (or not) + unit to transform in delta (or not). """ u = units2pint(unit) d = 1 * u @@ -246,7 +247,7 @@ def extract_units(arg): return ustr if ustr is None else pint.Quantity(1, ustr).units -def check_units(args_to_check): +def compare_units(args_to_check): """Decorator to check that all arguments have the same units (or no units).""" # if no units are present (DataArray without units attribute or float), then no check is performed @@ -312,14 +313,6 @@ def convert_units_to( # noqa: C901 The outputted type is always similar to `source` initial type. Attributes are preserved unless an automatic CF conversion is performed, in which case only the new `standard_name` appears in the result. - - See Also - -------- - cf_conversion - amount2rate - rate2amount - amount2lwethickness - lwethickness2amount """ # Target units target_unit = extract_units(target) @@ -346,6 +339,7 @@ def _add_default_kws(params_dict, params_to_check, func): return params_dict +# TODO: this changes the type of some variables (e.g. thresh : str -> float). This should probably not be allowed def harmonize_units(params_to_check): """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" @@ -460,7 +454,7 @@ def to_agg_units( >>> degdays = convert_units_to(degdays, "K days") >>> degdays.units - 'K d' + 'K d'. """ if op in ["amin", "min", "amax", "max", "mean", "sum"]: out.attrs["units"] = orig.attrs["units"] diff --git a/tests/test_units.py b/tests/test_units.py new file mode 100644 index 0000000..8c06bbf --- /dev/null +++ b/tests/test_units.py @@ -0,0 +1,120 @@ +from __future__ import annotations + +import numpy as np +import pandas as pd +import pint +import pint.errors +import pytest +import xarray as xr +from dask import array as dsk +from xclim import indices, set_options + +from xsdba.logging import ValidationError +from xsdba.typing import Quantified +from xsdba.units import ( + compare_units, + convert_units_to, + pint2str, + str2pint, + to_agg_units, + units, +) + +# ADAPT: More tests +# TODO: Test compare_units, harmonize_units + + +class TestUnits: + def test_temperature(self): + assert 4 * units.d == 4 * units.day + Q_ = units.Quantity # noqa + assert Q_(1, units.C) == Q_(1, units.degC) + + def test_lat_lon(self): + assert 100 * units.degreeN == 100 * units.degree + + def test_fraction(self): + q = 5 * units.percent + assert q.to("dimensionless") == 0.05 + + q = 5 * units.parse_units("pct") + assert q.to("dimensionless") == 0.05 + + +class TestConvertUnitsTo: + @pytest.mark.parametrize( + "alias", [units("Celsius"), units("degC"), units("C"), units("deg_C")] + ) + def test_temperature_aliases(self, alias): + assert alias == units("celsius") + + # def test_offset_confusion(self): + # out = convert_units_to("10 degC days", "K days") + # assert out == 10 + + +class TestUnitConversion: + def test_pint2str(self): + pytest.importorskip("cf-xarray") + u = units("mm/d") + assert pint2str(u.units) == "mm d-1" + + u = units("percent") + assert pint2str(u.units) == "%" + + u = units("pct") + assert pint2str(u.units) == "%" + + def test_units2pint(self, timelonlatseries): + pytest.importorskip("cf-xarray") + u = units2pint(timelonlatseries([1, 2], attrs={"units": "kg m-2 s-1"})) + assert pint2str(u) == "kg m-2 s-1" + + u = units2pint("m^3 s-1") + assert pint2str(u) == "m3 s-1" + + u = units2pint("%") + assert pint2str(u) == "%" + + u = units2pint("1") + assert pint2str(u) == "" + + # def test_pint_multiply(self, pr_series): + # a = timelonlatseries([1, 2, 3], attrs={"units": "kg m-2 /d"}) + # out = pint_multiply(a, 1 * units.days) + # assert out[0] == 1 * 60 * 60 * 24 + # assert out.units == "kg m-2" + + def test_str2pint(self): + Q_ = units.Quantity # noqa + assert str2pint("-0.78 m") == Q_(-0.78, units="meter") + assert str2pint("m kg/s") == Q_(1, units="meter kilogram/second") + assert str2pint("11.8 degC days") == Q_(11.8, units="delta_degree_Celsius days") + assert str2pint("nan m^2 K^-3").units == Q_(1, units="m²/K³").units + + +@pytest.mark.parametrize( + "in_u,opfunc,op,exp,exp_u", + [ + ("m/h", "sum", "integral", 8760, "m"), + ("m/h", "sum", "sum", 365, "m/h"), + ("K", "mean", "mean", 1, "K"), + ("", "sum", "count", 365, "d"), + ("", "sum", "count", 365, "d"), + ("kg m-2", "var", "var", 0, "kg2 m-4"), + ("°C", "argmax", "doymax", 0, ""), + ("°C", "sum", "integral", 365, "K d"), + ("°F", "sum", "integral", 365, "d °R"), # not sure why the order is different + ], +) +def test_to_agg_units(in_u, opfunc, op, exp, exp_u): + da = xr.DataArray( + np.ones((365,)), + dims=("time",), + coords={"time": xr.cftime_range("1993-01-01", periods=365, freq="D")}, + attrs={"units": in_u}, + ) + + out = to_agg_units(getattr(da, opfunc)(), da, op) + np.testing.assert_allclose(out, exp) + assert out.attrs["units"] == exp_u From ed49891be3c4c5c2344d40fcfc944ef27f4f79e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 30 Jul 2024 21:18:12 -0400 Subject: [PATCH 030/105] typo in list comprehension --- src/xsdba/formatting.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 77c1c08..5d58610 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -378,7 +378,7 @@ def merge_attributes( str The new attribute made from the combination of the ones from all the inputs. """ - inputs = [getattr(in_ds, "name", None) for in_ds in inputs_list] + inputs = [(getattr(in_ds, "name", None), in_ds) for in_ds in inputs_list] inputs += list(inputs_kws.items()) merged_attr = "" From cbcdf3c52b198b30071ac367fe76cd17eab50905 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 31 Jul 2024 11:15:01 -0400 Subject: [PATCH 031/105] don't use compare_units; test harmonize_units --- src/xsdba/detrending.py | 10 ++++--- src/xsdba/indicator.py | 4 +-- src/xsdba/measures.py | 9 +++---- src/xsdba/units.py | 22 +++++++--------- tests/test_detrending.py | 20 +++++++------- tests/test_units.py | 57 +++++++++++++++++++++++++++++----------- 6 files changed, 73 insertions(+), 49 deletions(-) diff --git a/src/xsdba/detrending.py b/src/xsdba/detrending.py index 8d0ecab..fcac1b7 100644 --- a/src/xsdba/detrending.py +++ b/src/xsdba/detrending.py @@ -9,7 +9,7 @@ from .base import Grouper, ParametrizableWithDataset, map_groups, parse_group from .loess import loess_smoothing -from .units import compare_units +from .units import harmonize_units from .utils import ADDITIVE, apply_correction, invert @@ -59,7 +59,9 @@ def fit(self, da: xr.DataArray): """ new = self.__class__(**self.parameters) new.set_dataset(new._get_trend(da).rename("trend").to_dataset()) - new.ds.trend.attrs["units"] = da.attrs.get("units", "") + if "units" in da.attrs: + new.ds.trend.attrs["units"] = da.attrs["units"] + return new def _get_trend(self, da: xr.DataArray): @@ -91,13 +93,13 @@ def retrend(self, da: xr.DataArray): raise ValueError("You must call fit() before retrending") return self._retrend(da, self.ds.trend) - @compare_units(["da", "trend"]) + @harmonize_units(["da", "trend"]) def _detrend(self, da, trend): """Detrend.""" # Remove trend from series return apply_correction(da, invert(trend, self.kind), self.kind) - @compare_units(["da", "trend"]) + @harmonize_units(["da", "trend"]) def _retrend(self, da, trend): """Retrend.""" # Add trend to series diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py index 1ab6010..dbca486 100644 --- a/src/xsdba/indicator.py +++ b/src/xsdba/indicator.py @@ -156,7 +156,7 @@ OPTIONS, ) from .typing import InputKind -from .units import compare_units, convert_units_to, units +from .units import convert_units_to, units from .utils import load_module # Indicators registry @@ -1149,7 +1149,7 @@ def _translate(cf_attrs, names, var_id=None): return attrs @classmethod - def json(cls, args=None): + def json(self, args=None): """Return a serializable dictionary representation of the class. Parameters diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py index 0b1595a..c10565f 100644 --- a/src/xsdba/measures.py +++ b/src/xsdba/measures.py @@ -21,7 +21,7 @@ # from xclim.core.units import ensure_delta from .base import Grouper from .typing import InputKind -from .units import compare_units, ensure_delta +from .units import convert_units_to, ensure_delta from .utils import _pairwise_spearman @@ -48,14 +48,14 @@ def _ensure_correct_parameters(cls, parameters): ) return super()._ensure_correct_parameters(parameters) - @compare_units([{"das": "ref"}, {"das": "sim"}]) def _preprocess_and_checks(self, das, params): """Perform parent's checks and also check convert units so that sim matches ref.""" das, params = super()._preprocess_and_checks(das, params) # Convert grouping and check if allowed: - sim = das["sim"] + das["sim"] = convert_units_to(das["sim"], das["ref"]) ref = das["ref"] + sim = das["sim"] # Check if common coordinates are identical. newsim, newref = xr.broadcast(sim, ref) @@ -110,11 +110,10 @@ def _ensure_correct_parameters(cls, parameters): return super()._ensure_correct_parameters(parameters) - @compare_units([{"das": "ref"}, {"das": "sim"}]) def _preprocess_and_checks(self, das, params): """Perform parent's checks and also check convert units so that sim matches ref.""" das, params = super()._preprocess_and_checks(das, params) - + das["sim"] = convert_units_to(das["sim"], das["ref"]) # Convert grouping and check if allowed: if isinstance(params["group"], str): params["group"] = Grouper(params["group"]) diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 6949cfc..41e162d 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -247,6 +247,7 @@ def extract_units(arg): return ustr if ustr is None else pint.Quantity(1, ustr).units +# TODO: Think, is this really needed? def compare_units(args_to_check): """Decorator to check that all arguments have the same units (or no units).""" @@ -340,9 +341,9 @@ def _add_default_kws(params_dict, params_to_check, func): # TODO: this changes the type of some variables (e.g. thresh : str -> float). This should probably not be allowed +# TODO: support for Datasets and dict like in compare_units? def harmonize_units(params_to_check): - """Check that units are compatible with dimensions, otherwise raise a `ValidationError`.""" - + """Compare units and perform a conversion if possible, otherwise raise a `ValidationError`.""" # if no units are present (DataArray without units attribute or float), then no check is performed # if units are present, then check is performed # in mixed cases, an error is raised @@ -351,7 +352,7 @@ def _decorator(func): def _wrapper(*args, **kwargs): params_func = inspect.signature(func).parameters.keys() if set(params_to_check).issubset(set(params_func)) is False: - raise ValueError( + raise TypeError( f"`harmonize_units' inputs `{params_to_check}` should be a subset of " f"`{func.__name__}`'s arguments: `{params_func}` (arguments that can contain units)" ) @@ -362,26 +363,21 @@ def _wrapper(*args, **kwargs): params_dict = _add_default_kws(params_dict, params_to_check, func) params_dict_keys = [k for k in params_dict.keys()] if set(params_dict.keys()) != set(params_to_check): - raise ValueError( + raise TypeError( f"{params_to_check} were passed but only {params_dict.keys()} were found " f"in `{func.__name__}`'s arguments" ) first_param = params_dict[params_to_check[0]] for param_name in params_dict.keys(): - if isinstance(param_name, str): - value = params_dict[param_name] - key = param_name - if isinstance( - param_name, dict - ): # support for Dataset, or a dict of thresholds - key, val = list(param_name.keys())[0], list(param_name.values())[0] - value = params_dict[key][val] + value = params_dict[param_name] if value is None: # optional argument, should be ignored continue - params_dict[key] = convert_units_to(value, first_param) + params_dict[param_name] = convert_units_to(value, first_param) + # reassign keyword arguments for k in [k for k in params_dict.keys() if k not in args_dict.keys()]: kwargs[k] = params_dict[k] params_dict.pop(k) + # reassign remaining arguments (passed as arg) args = list(args) for iarg in range(len(args)): if arg_names[iarg] in params_dict.keys(): diff --git a/tests/test_detrending.py b/tests/test_detrending.py index a94269e..06ad056 100644 --- a/tests/test_detrending.py +++ b/tests/test_detrending.py @@ -15,8 +15,8 @@ ) -def test_poly_detrend_and_from_ds(timelonlatseries, tmp_path): - x = timelonlatseries(np.arange(20 * 365.25), "tas") +def test_poly_detrend_and_from_ds(timeseries, tmp_path): + x = timeseries(np.arange(20 * 365.25)) poly = PolyDetrend(degree=1) fx = poly.fit(x) @@ -41,8 +41,8 @@ def test_poly_detrend_and_from_ds(timelonlatseries, tmp_path): @pytest.mark.slow -def test_loess_detrend(timelonlatseries): - x = timelonlatseries(np.arange(12 * 365.25), "tas") +def test_loess_detrend(timeseries): + x = timeseries(np.arange(12 * 365.25)) det = LoessDetrend(group="time", d=0, niter=1, f=0.2) fx = det.fit(x) dx = fx.detrend(x) @@ -53,8 +53,8 @@ def test_loess_detrend(timelonlatseries): np.testing.assert_array_almost_equal(xt, x) -def test_mean_detrend(timelonlatseries): - x = timelonlatseries(np.arange(20 * 365.25), "tas") +def test_mean_detrend(timeseries): + x = timeseries(np.arange(20 * 365.25)) md = MeanDetrend().fit(x) assert (md.ds.trend == x.mean()).all() @@ -65,8 +65,8 @@ def test_mean_detrend(timelonlatseries): np.testing.assert_array_almost_equal(x, x2) -def test_rollingmean_detrend(timelonlatseries): - x = timelonlatseries(np.arange(12 * 365.25), "tas") +def test_rollingmean_detrend(timeseries): + x = timeseries(np.arange(12 * 365.25)) det = RollingMeanDetrend(group="time", win=29, min_periods=1) fx = det.fit(x) dx = fx.detrend(x) @@ -93,8 +93,8 @@ def test_rollingmean_detrend(timelonlatseries): assert fx.ds.trend.notnull().sum() == 365 -def test_no_detrend(timelonlatseries): - x = timelonlatseries(np.arange(12 * 365.25), "tas") +def test_no_detrend(timeseries): + x = timeseries(np.arange(12 * 365.25)) det = NoDetrend(group="time.dayofyear", kind="+") diff --git a/tests/test_units.py b/tests/test_units.py index 8c06bbf..9300ed3 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -14,16 +14,13 @@ from xsdba.units import ( compare_units, convert_units_to, + harmonize_units, pint2str, str2pint, to_agg_units, units, ) -# ADAPT: More tests -# TODO: Test compare_units, harmonize_units - - class TestUnits: def test_temperature(self): assert 4 * units.d == 4 * units.day @@ -48,11 +45,6 @@ class TestConvertUnitsTo: def test_temperature_aliases(self, alias): assert alias == units("celsius") - # def test_offset_confusion(self): - # out = convert_units_to("10 degC days", "K days") - # assert out == 10 - - class TestUnitConversion: def test_pint2str(self): pytest.importorskip("cf-xarray") @@ -79,12 +71,6 @@ def test_units2pint(self, timelonlatseries): u = units2pint("1") assert pint2str(u) == "" - # def test_pint_multiply(self, pr_series): - # a = timelonlatseries([1, 2, 3], attrs={"units": "kg m-2 /d"}) - # out = pint_multiply(a, 1 * units.days) - # assert out[0] == 1 * 60 * 60 * 24 - # assert out.units == "kg m-2" - def test_str2pint(self): Q_ = units.Quantity # noqa assert str2pint("-0.78 m") == Q_(-0.78, units="meter") @@ -118,3 +104,44 @@ def test_to_agg_units(in_u, opfunc, op, exp, exp_u): out = to_agg_units(getattr(da, opfunc)(), da, op) np.testing.assert_allclose(out, exp) assert out.attrs["units"] == exp_u + + +class TestHarmonizeUnits: + def test_simple(self): + da = xr.DataArray([1,2], attrs={"units": "K"}) + thr = "1 K" + @harmonize_units(["da", "thr"]) + def gt(da, thr): + return (da > thr).sum().values + + assert gt(da, thr) == 1 + + def test_no_units(self): + da = xr.DataArray([1,2]) + thr = 1 + @harmonize_units(["da", "thr"]) + def gt(da, thr): + return (da > thr).sum().values + + assert gt(da, thr) == 1 + def test_wrong_decorator(self): + da = xr.DataArray([1,2], attrs={"units": "K"}) + thr = "1 K" + @harmonize_units(["da", "thrr"]) + def gt(da, thr): + return (da > thr).sum().values + + with pytest.raises(TypeError, match="should be a subset of"): + gt(da, thr) + + def test_wrong_input_catched_by_decorator(self): + da = xr.DataArray([1,2], attrs={"units": "K"}) + thr = "1 K" + @harmonize_units(["da", "thr"]) + def gt(da, thr): + return (da > thr).sum().values + + with pytest.raises(TypeError, match="were passed but only"): + gt(da) + + From 41fdd03c420ddebd70bac12da92593d6d8edd624 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 31 Jul 2024 11:16:14 -0400 Subject: [PATCH 032/105] test harmonize_units; don't use compare_units; --- src/xsdba/detrending.py | 2 +- src/xsdba/measures.py | 2 +- src/xsdba/units.py | 3 ++- tests/test_units.py | 35 ++++++++++++++++++++--------------- 4 files changed, 24 insertions(+), 18 deletions(-) diff --git a/src/xsdba/detrending.py b/src/xsdba/detrending.py index fcac1b7..426c3cd 100644 --- a/src/xsdba/detrending.py +++ b/src/xsdba/detrending.py @@ -61,7 +61,7 @@ def fit(self, da: xr.DataArray): new.set_dataset(new._get_trend(da).rename("trend").to_dataset()) if "units" in da.attrs: new.ds.trend.attrs["units"] = da.attrs["units"] - + return new def _get_trend(self, da: xr.DataArray): diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py index c10565f..b1b720a 100644 --- a/src/xsdba/measures.py +++ b/src/xsdba/measures.py @@ -21,7 +21,7 @@ # from xclim.core.units import ensure_delta from .base import Grouper from .typing import InputKind -from .units import convert_units_to, ensure_delta +from .units import convert_units_to, ensure_delta from .utils import _pairwise_spearman diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 41e162d..74375aa 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -341,9 +341,10 @@ def _add_default_kws(params_dict, params_to_check, func): # TODO: this changes the type of some variables (e.g. thresh : str -> float). This should probably not be allowed -# TODO: support for Datasets and dict like in compare_units? +# TODO: support for Datasets and dict like in compare_units? def harmonize_units(params_to_check): """Compare units and perform a conversion if possible, otherwise raise a `ValidationError`.""" + # if no units are present (DataArray without units attribute or float), then no check is performed # if units are present, then check is performed # in mixed cases, an error is raised diff --git a/tests/test_units.py b/tests/test_units.py index 9300ed3..61f8566 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -21,6 +21,7 @@ units, ) + class TestUnits: def test_temperature(self): assert 4 * units.d == 4 * units.day @@ -45,6 +46,7 @@ class TestConvertUnitsTo: def test_temperature_aliases(self, alias): assert alias == units("celsius") + class TestUnitConversion: def test_pint2str(self): pytest.importorskip("cf-xarray") @@ -107,41 +109,44 @@ def test_to_agg_units(in_u, opfunc, op, exp, exp_u): class TestHarmonizeUnits: - def test_simple(self): - da = xr.DataArray([1,2], attrs={"units": "K"}) + def test_simple(self): + da = xr.DataArray([1, 2], attrs={"units": "K"}) thr = "1 K" + @harmonize_units(["da", "thr"]) - def gt(da, thr): + def gt(da, thr): return (da > thr).sum().values assert gt(da, thr) == 1 - - def test_no_units(self): - da = xr.DataArray([1,2]) + + def test_no_units(self): + da = xr.DataArray([1, 2]) thr = 1 + @harmonize_units(["da", "thr"]) - def gt(da, thr): + def gt(da, thr): return (da > thr).sum().values assert gt(da, thr) == 1 - def test_wrong_decorator(self): - da = xr.DataArray([1,2], attrs={"units": "K"}) + + def test_wrong_decorator(self): + da = xr.DataArray([1, 2], attrs={"units": "K"}) thr = "1 K" + @harmonize_units(["da", "thrr"]) - def gt(da, thr): + def gt(da, thr): return (da > thr).sum().values with pytest.raises(TypeError, match="should be a subset of"): gt(da, thr) - def test_wrong_input_catched_by_decorator(self): - da = xr.DataArray([1,2], attrs={"units": "K"}) + def test_wrong_input_catched_by_decorator(self): + da = xr.DataArray([1, 2], attrs={"units": "K"}) thr = "1 K" + @harmonize_units(["da", "thr"]) - def gt(da, thr): + def gt(da, thr): return (da > thr).sum().values with pytest.raises(TypeError, match="were passed but only"): gt(da) - - From ea731e08f2c5bd9a31037a658b7c563cdeab1d66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 31 Jul 2024 11:25:18 -0400 Subject: [PATCH 033/105] PASSED: test_indicators.py (only core functionalities) --- tests/test_indicators.py | 887 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 887 insertions(+) create mode 100644 tests/test_indicators.py diff --git a/tests/test_indicators.py b/tests/test_indicators.py new file mode 100644 index 0000000..8392f85 --- /dev/null +++ b/tests/test_indicators.py @@ -0,0 +1,887 @@ +# pylint: disable=unsubscriptable-object,function-redefined +# Tests for the Indicator objects +from __future__ import annotations + +import gc +import json +from inspect import signature +from typing import Union + +import dask +import numpy as np +import pytest +import xarray as xr + +from xsdba.formatting import ( + AttrFormatter, + default_formatter, + merge_attributes, + parse_doc, + update_history, +) +from xsdba.indicator import Indicator, registry +from xsdba.units import convert_units_to, units +from xsdba.typing import InputKind, Quantified +from xsdba.logging import MissingVariableError +from xsdba.options import set_options + + +# # @declare_units(da="[temperature]", thresh="[temperature]") +# def uniindtemp_compute( +# da: xr.DataArray, +# thresh: Quantified = "0.0 degC", +# freq: str = "YS", +# method: str = "injected", +# ): +# """Docstring""" +# out = da - convert_units_to(thresh, da) +# out = out.resample(time=freq).mean() +# out.attrs["units"] = da.units +# return out + + +# uniIndTemp = Daily( +# realm="atmos", +# identifier="tmin", +# module="test", +# cf_attrs=[ +# dict( +# var_name="tmin{thresh}", +# units="K", +# long_name="{freq} mean surface temperature with {thresh} threshold.", +# standard_name="{freq} mean temperature", +# cell_methods="time: mean within {freq:noun}", +# another_attr="With a value.", +# ) +# ], +# compute=uniindtemp_compute, +# parameters={"method": "injected"}, +# ) + + +# @declare_units(da="[precipitation]") +# def uniindpr_compute(da: xr.DataArray, freq: str): +# """Docstring""" +# return da.resample(time=freq).mean(keep_attrs=True) + + +# uniIndPr = Daily( +# realm="atmos", +# identifier="prmax", +# cf_attrs=[dict(units="mm/s")], +# context="hydro", +# module="test", +# compute=uniindpr_compute, +# ) + + +# @declare_units(da="[temperature]") +# def uniclim_compute(da: xr.DataArray, freq="YS", **indexer): +# select = select_time(da, **indexer) +# return select.mean(dim="time", keep_attrs=True).expand_dims("time") + + +# uniClim = ResamplingIndicator( +# src_freq="D", +# realm="atmos", +# identifier="clim", +# cf_attrs=[dict(units="K")], +# module="test", +# compute=uniclim_compute, +# ) + + +# @declare_units(tas="[temperature]") +# def multitemp_compute(tas: xr.DataArray, freq: str): +# return ( +# tas.resample(time=freq).min(keep_attrs=True), +# tas.resample(time=freq).max(keep_attrs=True), +# ) + + +# multiTemp = Daily( +# realm="atmos", +# identifier="minmaxtemp", +# cf_attrs=[ +# dict( +# var_name="tmin", +# units="K", +# standard_name="Min temp", +# description="Grouped computation of tmax and tmin", +# ), +# dict( +# var_name="tmax", +# units="K", +# description="Grouped computation of tmax and tmin", +# ), +# ], +# module="test", +# compute=multitemp_compute, +# ) + + +# @declare_units(tas="[temperature]", tasmin="[temperature]", tasmax="[temperature]") +def multioptvar_compute( + tas: xr.DataArray | None = None, + tasmax: xr.DataArray | None = None, + tasmin: xr.DataArray | None = None, +): + if tas is None: + tasmax = convert_units_to(tasmax, tasmin) + return ((tasmin + tasmax) / 2).assign_attrs(units=tasmin.units) + return tas + + +multiOptVar = Indicator( + src_freq="D", + realm="atmos", + identifier="multiopt", + cf_attrs=[dict(units="K")], + module="test", + compute=multioptvar_compute, +) + + +# def test_attrs(tas_series): +# import datetime as dt + +# a = tas_series(np.arange(360.0)) +# txm = uniIndTemp(a, thresh="5 degC", freq="YS") +# assert txm.cell_methods == "time: mean time: mean within years" +# assert f"{dt.datetime.now():%Y-%m-%d %H}" in txm.attrs["history"] +# assert ( +# "TMIN(da=tas, thresh='5 degC', freq='YS') with options check_missing=any" +# in txm.attrs["history"] +# ) +# assert f"xclim version: {__version__}" in txm.attrs["history"] +# assert txm.name == "tmin5 degC" +# assert uniIndTemp.standard_name == "{freq} mean temperature" +# assert uniIndTemp.cf_attrs[0]["another_attr"] == "With a value." + +# thresh = xr.DataArray( +# [1], +# dims=("adim",), +# coords={"adim": [1]}, +# attrs={"long_name": "A thresh", "units": "degC"}, +# name="TT", +# ) +# txm = uniIndTemp(a, thresh=thresh, freq="YS") +# assert ( +# "TMIN(da=tas, thresh=TT, freq='YS') with options check_missing=any" +# in txm.attrs["history"] +# ) +# assert txm.attrs["long_name"].endswith("with <an array> threshold.") + + +@pytest.mark.parametrize( + "xcopt,xropt,exp", + [ + ("xarray", "default", False), + (True, False, True), + (False, True, False), + ("xarray", True, True), + ], +) +def test_keep_attrs(timelonlatseries, xcopt, xropt, exp): + tx = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tn = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tx.attrs.update(something="blabla", bing="bang", foo="bar") + tn.attrs.update(something="blabla", bing="bong") + with set_options(keep_attrs=xcopt): + with xr.set_options(keep_attrs=xropt): + tg = multiOptVar(tasmin=tn, tasmax=tx) + assert (tg.attrs.get("something") == "blabla") is exp + assert (tg.attrs.get("foo") == "bar") is exp + assert "bing" not in tg.attrs + + +def test_as_dataset(timelonlatseries): + tx = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tn = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tx.attrs.update(something="blabla", bing="bang", foo="bar") + tn.attrs.update(something="blabla", bing="bong") + dsin = xr.Dataset({"tasmax": tx, "tasmin": tn}, attrs={"fou": "barre"}) + with set_options(keep_attrs=True, as_dataset=True): + dsout = multiOptVar(ds=dsin) + assert isinstance(dsout, xr.Dataset) + assert dsout.attrs["fou"] == "barre" + assert dsout.multiopt.attrs.get("something") == "blabla" + + +# def test_as_dataset_multi(tas_series): +# tg = tas_series(np.arange(360.0)) +# with set_options(as_dataset=True): +# dsout = multiTemp(tas=tg, freq="YS") +# assert isinstance(dsout, xr.Dataset) +# assert "tmin" in dsout.data_vars +# assert "tmax" in dsout.data_vars + + +def test_opt_vars(timelonlatseries): + tn = timelonlatseries(np.zeros(365), attrs={"units":"K"}) + tx = timelonlatseries(np.zeros(365), attrs={"units":"K"}) + + multiOptVar(tasmin=tn, tasmax=tx) + assert multiOptVar.parameters["tasmin"].kind == InputKind.OPTIONAL_VARIABLE + + +# def test_registering(): +# assert "test.TMIN" in registry + +# # Because this has not been instantiated, it's not in any registry. +# class Test123(registry["test.TMIN"]): +# identifier = "test123" + +# assert "test.TEST123" not in registry +# Test123(module="test") +# assert "test.TEST123" in registry + +# # Confirm registries live in subclasses. +# class IndicatorNew(Indicator): +# pass + +# # Identifier must be given +# with pytest.raises(AttributeError, match="has not been set."): +# IndicatorNew() + +# # Realm must be given +# with pytest.raises(AttributeError, match="realm must be given"): +# IndicatorNew(identifier="i2d") + +# indnew = IndicatorNew(identifier="i2d", realm="atmos", module="test") +# assert "test.I2D" in registry +# assert registry["test.I2D"].get_instance() is indnew + +# del indnew +# gc.collect() +# with pytest.raises(ValueError, match="There is no existing instance"): +# registry["test.I2D"].get_instance() + + +# def test_module(): +# """Translations are keyed according to the module where the indicators are defined.""" +# assert atmos.tg_mean.__module__.split(".")[2] == "atmos" +# # Virtual module also are stored under xclim.indicators +# assert xclim.indicators.cf.fg.__module__ == "xclim.indicators.cf" # noqa: F821 +# assert ( +# xclim.indicators.icclim.GD4.__module__ == "xclim.indicators.icclim" +# ) # noqa: F821 + + +# def test_temp_unit_conversion(tas_series): +# a = tas_series(np.arange(365), start="2001-01-01") +# txk = uniIndTemp(a, freq="YS") + +# # This is not supposed to work +# uniIndTemp.units = "degC" +# txc = uniIndTemp(a, freq="YS") +# with pytest.raises(AssertionError): +# np.testing.assert_array_almost_equal(txk, txc + 273.15) + +# uniIndTemp.cf_attrs[0]["units"] = "degC" +# txc = uniIndTemp(a, freq="YS") +# np.testing.assert_array_almost_equal(txk, txc + 273.15) + + +# def test_multiindicator(tas_series): +# tas = tas_series(np.arange(366), start="2000-01-01") +# tmin, tmax = multiTemp(tas, freq="YS") + +# assert tmin[0] == tas.min() +# assert tmax[0] == tas.max() +# assert tmin.attrs["standard_name"] == "Min temp" +# assert tmin.attrs["description"] == "Grouped computation of tmax and tmin" +# assert tmax.attrs["description"] == "Grouped computation of tmax and tmin" +# assert multiTemp.units == ["K", "K"] + +# # Attrs passed as keywords - together +# ind = Daily( +# realm="atmos", +# identifier="minmaxtemp2", +# cf_attrs=[ +# dict( +# var_name="tmin", +# units="K", +# standard_name="Min temp", +# description="Grouped computation of tmax and tmin", +# ), +# dict( +# var_name="tmax", +# units="K", +# description="Grouped computation of tmax and tmin", +# ), +# ], +# compute=multitemp_compute, +# ) +# tmin, tmax = ind(tas, freq="YS") +# assert tmin[0] == tas.min() +# assert tmax[0] == tas.max() +# assert tmin.attrs["standard_name"] == "Min temp" +# assert tmin.attrs["description"] == "Grouped computation of tmax and tmin" +# assert tmax.attrs["description"] == "Grouped computation of tmax and tmin" + +# with pytest.raises(ValueError, match="Output #2 is missing a var_name!"): +# ind = Daily( +# realm="atmos", +# identifier="minmaxtemp2", +# cf_attrs=[ +# dict( +# var_name="tmin", +# units="K", +# ), +# dict( +# units="K", +# ), +# ], +# compute=multitemp_compute, +# ) + +# # Attrs passed as keywords - individually +# ind = Daily( +# realm="atmos", +# identifier="minmaxtemp3", +# var_name=["tmin", "tmax"], +# units="K", +# standard_name=["Min temp", ""], +# description="Grouped computation of tmax and tmin", +# compute=multitemp_compute, +# ) +# tmin, tmax = ind(tas, freq="YS") +# assert tmin[0] == tas.min() +# assert tmax[0] == tas.max() +# assert tmin.attrs["standard_name"] == "Min temp" +# assert tmin.attrs["description"] == "Grouped computation of tmax and tmin" +# assert tmax.attrs["description"] == "Grouped computation of tmax and tmin" +# assert ind.units == ["K", "K"] + +# # All must be the same length +# with pytest.raises(ValueError, match="Attribute var_name has 2 elements"): +# ind = Daily( +# realm="atmos", +# identifier="minmaxtemp3", +# var_name=["tmin", "tmax"], +# units="K", +# standard_name=["Min temp"], +# description="Grouped computation of tmax and tmin", +# compute=uniindpr_compute, +# ) + +# ind = Daily( +# realm="atmos", +# identifier="minmaxtemp4", +# var_name=["tmin", "tmax"], +# units="K", +# standard_name=["Min temp", ""], +# description="Grouped computation of tmax and tmin", +# compute=uniindtemp_compute, +# ) +# with pytest.raises(ValueError, match="Indicator minmaxtemp4 was wrongly defined"): +# _tmin, _tmax = ind(tas, freq="YS") + + +# def test_missing(tas_series): +# a = tas_series(np.ones(365, float), start="1/1/2000") + +# # By default, missing is set to "from_context", and the default missing option is "any" +# # Cannot set missing_options with "from_context" +# with pytest.raises(ValueError, match="Cannot set `missing_options`"): +# uniClim.__class__(missing_options={"tolerance": 0.01}) + +# # Null value +# a[5] = np.nan + +# m = uniIndTemp(a, freq="MS") +# assert m[0].isnull() + +# with set_options( +# check_missing="pct", missing_options={"pct": {"tolerance": 0.05}} +# ): +# m = uniIndTemp(a, freq="MS") +# assert not m[0].isnull() +# assert "check_missing=pct, missing_options={'tolerance': 0.05}" in m.history + +# with set_options(check_missing="wmo"): +# m = uniIndTemp(a, freq="YS") +# assert m[0].isnull() + +# # With freq=None +# c = uniClim(a) +# assert c.isnull() + +# # With indexer +# ci = uniClim(a, month=[2]) +# assert not ci.isnull() + +# out = uniClim(a, month=[1]) +# assert out.isnull() + + +# def test_missing_from_context(tas_series): +# a = tas_series(np.ones(365, float), start="1/1/2000") +# # Null value +# a[5] = np.nan + +# ind = uniIndTemp.__class__(missing="from_context") + +# m = ind(a, freq="MS") +# assert m[0].isnull() + + +# def test_json(timeseries): +# meta = uniIndPr.json() + +# expected = { +# "identifier", +# "title", +# "keywords", +# "abstract", +# "parameters", +# "history", +# "references", +# "notes", +# "outputs", +# } + +# output_exp = { +# "var_name", +# "units", +# "long_name", +# "standard_name", +# "cell_methods", +# "description", +# "comment", +# } + +# assert set(meta.keys()).issubset(expected) +# for output in meta["outputs"]: +# assert set(output.keys()).issubset(output_exp) + + +# def test_all_jsonable(official_indicators): +# problems = [] +# err = None +# for identifier, ind in official_indicators.items(): +# indinst = ind.get_instance() +# json.dumps(indinst.json()) +# try: +# json.dumps(indinst.json()) +# except (KeyError, TypeError) as e: +# problems.append(identifier) +# err = e +# if problems: +# raise ValueError( +# f"Indicators {problems} provide problematic json serialization.: {err}" +# ) + + +# def test_all_parameters_understood(official_indicators): +# problems = set() +# for identifier, ind in official_indicators.items(): +# indinst = ind.get_instance() +# for name, param in indinst.parameters.items(): +# if param.kind == InputKind.OTHER_PARAMETER: +# problems.add((identifier, name)) +# # this one we are ok with. +# if problems - { +# ("COOL_NIGHT_INDEX", "lat"), +# ("DRYNESS_INDEX", "lat"), +# # TODO: How should we handle the case of Literal[str]? +# ("GROWING_SEASON_END", "op"), +# ("GROWING_SEASON_START", "op"), +# }: +# raise ValueError( +# f"The following indicator/parameter couple {problems} use types not listed in InputKind." +# ) + + +# def test_signature(): +# sig = signature(xclim.atmos.solid_precip_accumulation) +# assert list(sig.parameters.keys()) == [ +# "pr", +# "tas", +# "thresh", +# "freq", +# "ds", +# "indexer", +# ] +# assert sig.parameters["pr"].annotation == Union[xr.DataArray, str] +# assert sig.parameters["tas"].default == "tas" +# assert sig.parameters["tas"].kind == sig.parameters["tas"].POSITIONAL_OR_KEYWORD +# assert sig.parameters["thresh"].kind == sig.parameters["thresh"].KEYWORD_ONLY +# assert sig.return_annotation == xr.DataArray + +# sig = signature(xclim.atmos.wind_speed_from_vector) +# assert sig.return_annotation == tuple[xr.DataArray, xr.DataArray] + + +# def test_doc(): +# doc = xclim.atmos.cffwis_indices.__doc__ +# assert doc.startswith("Canadian Fire Weather Index System indices. (realm: atmos)") +# assert "This indicator will check for missing values according to the method" in doc +# assert ( +# "Based on indice :py:func:`~xclim.indices.fire._cffwis.cffwis_indices`." in doc +# ) +# assert "ffmc0 : str or DataArray, optional" in doc +# assert "Returns\n-------" in doc +# assert "See :cite:t:`code-natural_resources_canada_data_nodate`, " in doc +# assert "the :py:mod:`xclim.indices.fire` module documentation," in doc +# assert ( +# "and the docstring of :py:func:`fire_weather_ufunc` for more information." +# in doc +# ) + + +# def test_delayed(tasmax_series): +# tasmax = tasmax_series(np.arange(360.0)).chunk({"time": 5}) +# out = uniIndTemp(tasmax) +# assert isinstance(out.data, dask.array.Array) + + +# def test_identifier(): +# with pytest.warns(UserWarning): +# uniIndPr.__class__(identifier="t_{}") + + +# def test_formatting(pr_series): +# out = atmos.wetdays(pr_series(np.arange(366)), thresh=1.0 * units.mm / units.day) +# # pint 0.10 now pretty print day as d. +# assert ( +# out.attrs["long_name"] +# == "Number of days with daily precipitation at or above 1 mm/d" +# ) +# assert out.attrs["description"] in [ +# "Annual number of days with daily precipitation at or above 1 mm/d." +# ] +# out = atmos.wetdays(pr_series(np.arange(366)), thresh=1.5 * units.mm / units.day) +# assert ( +# out.attrs["long_name"] +# == "Number of days with daily precipitation at or above 1.5 mm/d" +# ) +# assert out.attrs["description"] in [ +# "Annual number of days with daily precipitation at or above 1.5 mm/d." +# ] + + +# def test_parse_doc(): +# doc = parse_doc(tg_mean.__doc__) +# assert doc["title"] == "Mean of daily average temperature." +# assert ( +# doc["abstract"] +# == "Resample the original daily mean temperature series by taking the mean over each period." +# ) +# assert doc["parameters"]["tas"]["description"] == "Mean daily temperature." +# assert doc["parameters"]["freq"]["description"] == "Resampling frequency." +# assert doc["notes"].startswith("Let") +# assert "math::" in doc["notes"] +# assert "references" not in doc +# assert doc["long_name"] == "The mean daily temperature at the given time frequency" + +# doc = parse_doc(xclim.indices.saturation_vapor_pressure.__doc__) +# assert ( +# doc["parameters"]["ice_thresh"]["description"] +# == "Threshold temperature under which to switch to equations in reference to ice instead of water. " +# "If None (default) everything is computed with reference to water." +# ) +# assert "goff_low-pressure_1946" in doc["references"] + + +# def test_parsed_doc(): +# assert "tas" in xclim.atmos.liquid_precip_accumulation.parameters + +# params = xclim.atmos.drought_code.parameters +# assert params["tas"].description == "Noon temperature." +# assert params["tas"].units == "[temperature]" +# assert params["tas"].kind is InputKind.VARIABLE +# assert params["tas"].default == "tas" +# assert params["snd"].default is None +# assert params["snd"].kind is InputKind.OPTIONAL_VARIABLE +# assert params["snd"].units == "[length]" +# assert params["season_method"].kind is InputKind.STRING +# assert params["season_method"].choices == {"GFWED", None, "WF93", "LA08"} + +# params = xclim.atmos.standardized_precipitation_evapotranspiration_index.parameters +# assert params["fitkwargs"].kind is InputKind.DICT + + +def test_default_formatter(): + assert default_formatter.format("{freq}", freq="YS") == "annual" + assert default_formatter.format("{freq:noun}", freq="MS") == "months" + assert default_formatter.format("{month}", month="m3") == "march" + + +def test_AttrFormatter(): + fmt = AttrFormatter( + mapping={"evil": ["méchant", "méchante"], "nice": ["beau", "belle"]}, + modifiers=["m", "f"], + ) + # Normal cases + assert fmt.format("{adj:m}", adj="evil") == "méchant" + assert fmt.format("{adj:f}", adj="nice") == "belle" + # Missing mod: + assert fmt.format("{adj}", adj="evil") == "méchant" + # Mod with unknown value + with pytest.warns(match="Requested formatting `m` for unknown string `funny`."): + fmt.format("{adj:m}", adj="funny") + + +@pytest.mark.parametrize("new_line", ["<>", "\n"]) +@pytest.mark.parametrize("missing_str", ["<Missing>", None]) +def test_merge_attributes(missing_str, new_line): + a = xr.DataArray([0], attrs={"text": "Text1"}, name="a") + b = xr.DataArray([0], attrs={}) + c = xr.Dataset(attrs={"text": "Text3"}) + + merged = merge_attributes( + "text", a, missing_str=missing_str, new_line=new_line, b=b, c=c + ) + + assert merged.startswith("a: Text1") + + if missing_str is not None: + assert merged.count(new_line) == 2 + assert f"b: {missing_str}" in merged + else: + assert merged.count(new_line) == 1 + assert "b:" not in merged + + +def test_update_history(): + a = xr.DataArray([0], attrs={"history": "Text1"}, name="a") + b = xr.DataArray([0], attrs={"history": "Text2"}) + c = xr.Dataset(attrs={"history": "Text3"}) + + merged = update_history("text", a, new_name="d", b=b, c=c) + + assert "d: text" in merged.split("\n")[-1] + assert merged.startswith("a: Text1") + + +# def test_input_dataset(open_dataset): +# ds = open_dataset("ERA5/daily_surface_cancities_1990-1993.nc") + +# # Use defaults +# _ = xclim.atmos.daily_temperature_range(freq="YS", ds=ds) + +# # Use non-defaults (inverted on purpose) +# with set_options(cf_compliance="log"): +# _ = xclim.atmos.daily_temperature_range("tasmax", "tasmin", freq="YS", ds=ds) + +# # Use a mix +# _ = xclim.atmos.daily_temperature_range(tasmax=ds.tasmax, freq="YS", ds=ds) + +# # Inexistent variable: +# dsx = ds.drop_vars("tasmin") +# with pytest.raises(MissingVariableError): +# out = xclim.atmos.daily_temperature_range(freq="YS", ds=dsx) # noqa + +# # dataset not given +# with pytest.raises(ValueError): +# xclim.atmos.daily_temperature_range(tasmax="tmax") + + +# def test_indicator_from_dict(): +# d = dict( +# realm="atmos", +# cf_attrs=dict( +# var_name="tmean{threshold}", +# units="K", +# long_name="{freq} mean surface temperature", +# standard_name="{freq} mean temperature", +# cell_methods=[{"time": "mean within days"}], +# ), +# compute="thresholded_statistics", +# parameters=dict( +# threshold={"description": "A threshold temp"}, +# op="<", +# reducer="mean", +# ), +# input={"data": "tas"}, +# ) + +# ind = Daily.from_dict(d, identifier="tmean", module="test") + +# assert ind.realm == "atmos" +# # Parameters metadata modification +# assert ind.parameters["threshold"].description == "A threshold temp" +# # Injection of parameters +# assert ind.injected_parameters["op"] == "<" +# # Default value for input variable injected and meta injected +# assert ind._variable_mapping["data"] == "tas" +# assert signature(ind).parameters["tas"].default == "tas" +# assert ind.parameters["tas"].units == "[temperature]" + +# # Wrap a multi-output ind +# d = dict(base="wind_speed_from_vector") +# Indicator.from_dict(d, identifier="wsfv", module="test") + + +# def test_indicator_errors(): +# def func(data: xr.DataArray, thresh: str = "0 degC", freq: str = "YS"): # noqa +# return data + +# doc = [ +# "The title", +# "", +# " The abstract", +# "", +# " Parameters", +# " ----------", +# " data : xr.DataArray", +# " A variable.", +# " thresh : str", +# " A threshold", +# " freq : str", +# " The resampling frequency.", +# "", +# " Returns", +# " -------", +# " xr.DataArray, [K]", +# " An output", +# ] +# func.__doc__ = "\n".join(doc) + +# d = dict( +# realm="atmos", +# cf_attrs=dict( +# var_name="tmean{threshold}", +# units="K", +# long_name="{freq} mean surface temperature", +# standard_name="{freq} mean temperature", +# cell_methods=[{"time": "mean within days"}], +# ), +# compute=func, +# input={"data": "tas"}, +# ) +# ind = Daily(identifier="indi", module="test", **d) + +# with pytest.raises(AttributeError, match="`identifier` has not been set"): +# Daily(**d) + +# d["identifier"] = "bad_indi" +# d["module"] = "test" + +# bad_doc = doc[:12] + [" extra: bool", " Woupsi"] + doc[12:] +# func.__doc__ = "\n".join(bad_doc) +# with pytest.raises(ValueError, match="Malformed docstring"): +# Daily(**d) + +# func.__doc__ = "\n".join(doc) +# d["parameters"] = {} +# d["parameters"]["thresh"] = "1 degK" +# d["parameters"]["extra"] = "woopsi again" +# with pytest.raises(ValueError, match="Parameter 'extra' was passed but it does"): +# Daily(**d) + +# del d["parameters"]["extra"] +# d["input"]["data"] = "3nsd6sk72" +# with pytest.raises(ValueError, match="Compute argument data was mapped to"): +# Daily(**d) + +# d2 = dict(input={"tas": "sfcWind"}) +# with pytest.raises(ValueError, match="When changing the name of a variable by"): +# ind.__class__(**d2) + +# del d["input"] +# # with pytest.raises(ValueError, match="variable data is missing expected units"): +# # Daily(**d) + +# d["parameters"]["thresh"] = {"units": "K"} +# d["realm"] = "mercury" +# d["input"] = {"data": "tasmin"} +# with pytest.raises(AttributeError, match="Indicator's realm must be given as one"): +# Daily(**d) + +# def func(data: xr.DataArray, thresh: str = "0 degC"): +# return data + +# func.__doc__ = "\n".join(doc[:10] + doc[12:]) +# d = dict( +# realm="atmos", +# cf_attrs=dict( +# var_name="tmean{threshold}", +# units="K", +# long_name="{freq} mean surface temperature", +# standard_name="{freq} mean temperature", +# cell_methods=[{"time": "mean within days"}], +# ), +# compute=func, +# input={"data": "tas"}, +# ) +# with pytest.raises(ValueError, match="ResamplingIndicator require a 'freq'"): +# Daily(identifier="indi", module="test", **d) + + +# def test_indicator_call_errors(timeseries): +# tas = timeseries(np.arange(730), start="2001-01-01", units="K") +# uniIndTemp(da=tas, thresh="3 K") + +# with pytest.raises(TypeError, match="too many positional arguments"): +# uniIndTemp(tas, tas) + +# with pytest.raises(TypeError, match="got an unexpected keyword argument 'oups'"): +# uniIndTemp(tas, oups=3) + + +# def test_resamplingIndicator_new_error(): +# with pytest.raises(ValueError, match="ResamplingIndicator require a 'freq'"): +# Daily( +# realm="atmos", +# identifier="multiopt", +# cf_attrs=[dict(units="K")], +# module="test", +# compute=multioptvar_compute, +# ) + + +def test_resampling_indicator_with_indexing(timeseries): + tas = timeseries(np.ones(731) + 273.15, start="2003-01-01") + out = (tas>273.15).resample(time="YS").sum() + # out = xclim.atmos.tx_days_above(tas, thresh="0 degC", freq="YS") + np.testing.assert_allclose(out, [365, 366]) + + # out = xclim.atmos.tx_days_above(tas, thresh="0 degC", freq="YS", month=2) + # np.testing.assert_allclose(out, [28, 29]) + + # out = xclim.atmos.tx_days_above( + # tas, thresh="0 degC", freq="YS-JUL", doy_bounds=(1, 50) + # ) + # np.testing.assert_allclose(out, [50, 50, np.NaN]) + + # out = xclim.atmos.tx_days_above( + # tas, thresh="0 degC", freq="YS", date_bounds=("02-29", "04-01") + # ) + # np.testing.assert_allclose(out, [32, 33]) + + +# def test_all_inputs_known(): +# var_and_inds = list_input_variables() +# known_vars = ( +# set(var_and_inds.keys()) +# - { +# "dc0", +# "season_mask", +# "ffmc0", +# "dmc0", +# "kbdi0", +# "drought_factor", +# } # FWI optional inputs +# - {var for var in var_and_inds.keys() if var.endswith("_per")} # percentiles +# - {"pr_annual", "pr_cal", "wb_cal"} # other optional or uncommon +# - {"q", "da"} # Generic inputs +# - {"mrt", "wb"} # TODO: add Mean Radiant Temperature and water budget +# ) +# # if not set(VARIABLES.keys()).issuperset(known_vars): +# # raise AssertionError( +# # "All input variables of xclim indicators must be registered in " +# # "data/variables.yml, or skipped explicitly in this test. " +# # f"The yaml file is missing: {known_vars - VARIABLES.keys()}." +# # ) + + +# def test_freq_doc(): +# from xclim import atmos + +# doc = atmos.latitude_temperature_index.__doc__ +# allowed_periods = ["A"] +# exp = f"Restricted to frequencies equivalent to one of {allowed_periods}" +# assert exp in doc From 0db32bf7445dc7b3a93b7df976d4592c14ae874e Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 31 Jul 2024 15:26:13 +0000 Subject: [PATCH 034/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- tests/test_indicators.py | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/tests/test_indicators.py b/tests/test_indicators.py index 8392f85..d4664ae 100644 --- a/tests/test_indicators.py +++ b/tests/test_indicators.py @@ -19,12 +19,11 @@ parse_doc, update_history, ) -from xsdba.indicator import Indicator, registry -from xsdba.units import convert_units_to, units -from xsdba.typing import InputKind, Quantified +from xsdba.indicator import Indicator, registry from xsdba.logging import MissingVariableError from xsdba.options import set_options - +from xsdba.typing import InputKind, Quantified +from xsdba.units import convert_units_to, units # # @declare_units(da="[temperature]", thresh="[temperature]") # def uniindtemp_compute( @@ -183,11 +182,11 @@ def multioptvar_compute( ], ) def test_keep_attrs(timelonlatseries, xcopt, xropt, exp): - tx = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) - tn = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tx = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) + tn = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) tx.attrs.update(something="blabla", bing="bang", foo="bar") tn.attrs.update(something="blabla", bing="bong") - with set_options(keep_attrs=xcopt): + with set_options(keep_attrs=xcopt): with xr.set_options(keep_attrs=xropt): tg = multiOptVar(tasmin=tn, tasmax=tx) assert (tg.attrs.get("something") == "blabla") is exp @@ -196,12 +195,12 @@ def test_keep_attrs(timelonlatseries, xcopt, xropt, exp): def test_as_dataset(timelonlatseries): - tx = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) - tn = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tx = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) + tn = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) tx.attrs.update(something="blabla", bing="bang", foo="bar") tn.attrs.update(something="blabla", bing="bong") dsin = xr.Dataset({"tasmax": tx, "tasmin": tn}, attrs={"fou": "barre"}) - with set_options(keep_attrs=True, as_dataset=True): + with set_options(keep_attrs=True, as_dataset=True): dsout = multiOptVar(ds=dsin) assert isinstance(dsout, xr.Dataset) assert dsout.attrs["fou"] == "barre" @@ -218,8 +217,8 @@ def test_as_dataset(timelonlatseries): def test_opt_vars(timelonlatseries): - tn = timelonlatseries(np.zeros(365), attrs={"units":"K"}) - tx = timelonlatseries(np.zeros(365), attrs={"units":"K"}) + tn = timelonlatseries(np.zeros(365), attrs={"units": "K"}) + tx = timelonlatseries(np.zeros(365), attrs={"units": "K"}) multiOptVar(tasmin=tn, tasmax=tx) assert multiOptVar.parameters["tasmin"].kind == InputKind.OPTIONAL_VARIABLE @@ -835,7 +834,7 @@ def test_update_history(): def test_resampling_indicator_with_indexing(timeseries): tas = timeseries(np.ones(731) + 273.15, start="2003-01-01") - out = (tas>273.15).resample(time="YS").sum() + out = (tas > 273.15).resample(time="YS").sum() # out = xclim.atmos.tx_days_above(tas, thresh="0 degC", freq="YS") np.testing.assert_allclose(out, [365, 366]) From 45ca16e1a05c718ae7ae5370db2d91be73e126f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 31 Jul 2024 11:27:03 -0400 Subject: [PATCH 035/105] formatting --- tests/test_indicators.py | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/tests/test_indicators.py b/tests/test_indicators.py index 8392f85..d4664ae 100644 --- a/tests/test_indicators.py +++ b/tests/test_indicators.py @@ -19,12 +19,11 @@ parse_doc, update_history, ) -from xsdba.indicator import Indicator, registry -from xsdba.units import convert_units_to, units -from xsdba.typing import InputKind, Quantified +from xsdba.indicator import Indicator, registry from xsdba.logging import MissingVariableError from xsdba.options import set_options - +from xsdba.typing import InputKind, Quantified +from xsdba.units import convert_units_to, units # # @declare_units(da="[temperature]", thresh="[temperature]") # def uniindtemp_compute( @@ -183,11 +182,11 @@ def multioptvar_compute( ], ) def test_keep_attrs(timelonlatseries, xcopt, xropt, exp): - tx = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) - tn = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tx = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) + tn = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) tx.attrs.update(something="blabla", bing="bang", foo="bar") tn.attrs.update(something="blabla", bing="bong") - with set_options(keep_attrs=xcopt): + with set_options(keep_attrs=xcopt): with xr.set_options(keep_attrs=xropt): tg = multiOptVar(tasmin=tn, tasmax=tx) assert (tg.attrs.get("something") == "blabla") is exp @@ -196,12 +195,12 @@ def test_keep_attrs(timelonlatseries, xcopt, xropt, exp): def test_as_dataset(timelonlatseries): - tx = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) - tn = timelonlatseries(np.arange(360.0), attrs={"units":"K"}) + tx = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) + tn = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) tx.attrs.update(something="blabla", bing="bang", foo="bar") tn.attrs.update(something="blabla", bing="bong") dsin = xr.Dataset({"tasmax": tx, "tasmin": tn}, attrs={"fou": "barre"}) - with set_options(keep_attrs=True, as_dataset=True): + with set_options(keep_attrs=True, as_dataset=True): dsout = multiOptVar(ds=dsin) assert isinstance(dsout, xr.Dataset) assert dsout.attrs["fou"] == "barre" @@ -218,8 +217,8 @@ def test_as_dataset(timelonlatseries): def test_opt_vars(timelonlatseries): - tn = timelonlatseries(np.zeros(365), attrs={"units":"K"}) - tx = timelonlatseries(np.zeros(365), attrs={"units":"K"}) + tn = timelonlatseries(np.zeros(365), attrs={"units": "K"}) + tx = timelonlatseries(np.zeros(365), attrs={"units": "K"}) multiOptVar(tasmin=tn, tasmax=tx) assert multiOptVar.parameters["tasmin"].kind == InputKind.OPTIONAL_VARIABLE @@ -835,7 +834,7 @@ def test_update_history(): def test_resampling_indicator_with_indexing(timeseries): tas = timeseries(np.ones(731) + 273.15, start="2003-01-01") - out = (tas>273.15).resample(time="YS").sum() + out = (tas > 273.15).resample(time="YS").sum() # out = xclim.atmos.tx_days_above(tas, thresh="0 degC", freq="YS") np.testing.assert_allclose(out, [365, 366]) From 00ba5498b25f5d4eab7a4334fa559ae09ce5fb51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 1 Aug 2024 15:06:48 -0400 Subject: [PATCH 036/105] remove xc dependence, formatting, dependencies --- environment-dev.yml | 6 +++++- src/xsdba/properties.py | 3 +-- tests/{test_indicators.py => test_indicator.py} | 16 ++++++++-------- 3 files changed, 14 insertions(+), 11 deletions(-) rename tests/{test_indicators.py => test_indicator.py} (99%) diff --git a/environment-dev.yml b/environment-dev.yml index d07fbbb..154fc8c 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -1,6 +1,7 @@ name: xsdba channels: - conda-forge + - defaults dependencies: - python >=3.9,<3.13 # - xarray >=2022.05.0.dev0 @@ -12,7 +13,10 @@ dependencies: - scipy - numba - numpy<2.0 # to accomodate numba - - cf-xarray # to accomodate numba + - cf_xarray # to accomodate numba + - pint + - statsmodels + - yamale # Dev tools and testing - pip >=24.0 diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 42ab202..f902ef7 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -14,7 +14,6 @@ import numpy as np import xarray as xr -import xclim as xc from scipy import stats from statsmodels.tsa import stattools @@ -596,7 +595,7 @@ def _annual_cycle( # TODO: In April 2024, use a match-case. if stat == "absamp": out = ac.max("dayofyear") - ac.min("dayofyear") - out.attrs["units"] = xc.core.units.ensure_delta(units) + out.attrs["units"] = ensure_delta(units) elif stat == "relamp": out = (ac.max("dayofyear") - ac.min("dayofyear")) * 100 / ac.mean("dayofyear") out.attrs["units"] = "%" diff --git a/tests/test_indicators.py b/tests/test_indicator.py similarity index 99% rename from tests/test_indicators.py rename to tests/test_indicator.py index d4664ae..1c5d1af 100644 --- a/tests/test_indicators.py +++ b/tests/test_indicator.py @@ -131,7 +131,7 @@ def multioptvar_compute( return tas -multiOptVar = Indicator( +MultiOptVar = Indicator( src_freq="D", realm="atmos", identifier="multiopt", @@ -188,7 +188,7 @@ def test_keep_attrs(timelonlatseries, xcopt, xropt, exp): tn.attrs.update(something="blabla", bing="bong") with set_options(keep_attrs=xcopt): with xr.set_options(keep_attrs=xropt): - tg = multiOptVar(tasmin=tn, tasmax=tx) + tg = MultiOptVar(tasmin=tn, tasmax=tx) assert (tg.attrs.get("something") == "blabla") is exp assert (tg.attrs.get("foo") == "bar") is exp assert "bing" not in tg.attrs @@ -201,7 +201,7 @@ def test_as_dataset(timelonlatseries): tn.attrs.update(something="blabla", bing="bong") dsin = xr.Dataset({"tasmax": tx, "tasmin": tn}, attrs={"fou": "barre"}) with set_options(keep_attrs=True, as_dataset=True): - dsout = multiOptVar(ds=dsin) + dsout = MultiOptVar(ds=dsin) assert isinstance(dsout, xr.Dataset) assert dsout.attrs["fou"] == "barre" assert dsout.multiopt.attrs.get("something") == "blabla" @@ -220,8 +220,8 @@ def test_opt_vars(timelonlatseries): tn = timelonlatseries(np.zeros(365), attrs={"units": "K"}) tx = timelonlatseries(np.zeros(365), attrs={"units": "K"}) - multiOptVar(tasmin=tn, tasmax=tx) - assert multiOptVar.parameters["tasmin"].kind == InputKind.OPTIONAL_VARIABLE + MultiOptVar(tasmin=tn, tasmax=tx) + assert MultiOptVar.parameters["tasmin"].kind == InputKind.OPTIONAL_VARIABLE # def test_registering(): @@ -608,7 +608,7 @@ def test_default_formatter(): assert default_formatter.format("{month}", month="m3") == "march" -def test_AttrFormatter(): +def test_attr_formatter(): fmt = AttrFormatter( mapping={"evil": ["méchant", "méchante"], "nice": ["beau", "belle"]}, modifiers=["m", "f"], @@ -671,7 +671,7 @@ def test_update_history(): # # Inexistent variable: # dsx = ds.drop_vars("tasmin") # with pytest.raises(MissingVariableError): -# out = xclim.atmos.daily_temperature_range(freq="YS", ds=dsx) # noqa +# out = xclim.atmos.daily_temperature_range(freq="YS", ds=dsx) # # dataset not given # with pytest.raises(ValueError): @@ -715,7 +715,7 @@ def test_update_history(): # def test_indicator_errors(): -# def func(data: xr.DataArray, thresh: str = "0 degC", freq: str = "YS"): # noqa +# def func(data: xr.DataArray, thresh: str = "0 degC", freq: str = "YS"): # return data # doc = [ From 25ed32b771a26bdf5709ba22586233afcda5d58c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 1 Aug 2024 17:01:26 -0400 Subject: [PATCH 037/105] ExtremeValues added & tests & formatting --- environment-dev.yml | 5 +- src/xsdba/__init__.py | 2 +- src/xsdba/_adjustment.py | 385 ++++++++++++++++++++------------------- src/xsdba/adjustment.py | 320 ++++++++++++++++---------------- src/xsdba/locales.py | 2 +- src/xsdba/properties.py | 2 +- src/xsdba/units.py | 31 ++++ tests/test_adjustment.py | 292 ++++++++++++++--------------- tests/test_properties.py | 2 +- tests/test_units.py | 20 +- tests/test_utils.py | 16 +- 11 files changed, 566 insertions(+), 511 deletions(-) diff --git a/environment-dev.yml b/environment-dev.yml index 154fc8c..26b0eb9 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -13,10 +13,10 @@ dependencies: - scipy - numba - numpy<2.0 # to accomodate numba - - cf_xarray # to accomodate numba - pint - statsmodels - yamale + - bottleneck # Dev tools and testing - pip >=24.0 @@ -38,3 +38,6 @@ dependencies: - pre-commit >=3.5.0 - ruff >=0.5.0 - xdoctest + - h5netcdf + - netcdf4 + - cf_xarray # to accomodate numba diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 20483b4..c1c626e 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -33,7 +33,7 @@ # , adjustment # from . import adjustment, base, detrending, measures, processing, properties, utils -# from .adjustment import * +from .adjustment import * from .base import Grouper from .options import set_options diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index a038845..7ee5a0e 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -23,7 +23,7 @@ from .processing import escore, jitter_under_thresh, reordering, standardize from .units import convert_units_to, units -# from xclim.indices.stats import _fitfunc_1d +from .xclim_submodules.stats import _fitfunc_1d def _adapt_freq_hist(ds: xr.Dataset, adapt_freq_thresh: str): @@ -62,11 +62,11 @@ def dqm_train( dim : str The dimension along which to compute the quantiles. kind : str - The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + The kind of correction to compute. See :py:func:`xsdba.utils.get_correction`. quantiles : array-like The quantiles to compute. adapt_freq_thresh : str, optional - Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Threshold for frequency adaptation. See :py:class:`xsdba.processing.adapt_freq` for details. Default is None, meaning that frequency adaptation is not performed. jitter_under_thresh_value : str, optional Threshold under which to add uniform random noise to values, a quantity with units. @@ -124,11 +124,11 @@ def eqm_train( dim : str The dimension along which to compute the quantiles. kind : str - The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + The kind of correction to compute. See :py:func:`xsdba.utils.get_correction`. quantiles : array-like The quantiles to compute. adapt_freq_thresh : str, optional - Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Threshold for frequency adaptation. See :py:class:`xsdba.processing.adapt_freq` for details. Default is None, meaning that frequency adaptation is not performed. jitter_under_thresh_value : str, optional Threshold under which to add uniform random noise to values, a quantity with units. @@ -229,7 +229,7 @@ def mbcn_train( The rotation matrices as a 3D array ('iterations', <pts_dims[0]>, <pts_dims[1]>), with shape (n_iter, <N>, <N>). pts_dims : sequence of str The name of the "multivariate" dimension and its primed counterpart. Defaults to "multivar", which - is the normal case when using :py:func:`xclim.sdba.base.stack_variables`, and "multivar_prime". + is the normal case when using :py:func:`xsdba.base.stack_variables`, and "multivar_prime". quantiles : array-like The quantiles to compute. gw_idxs : xr.DataArray @@ -375,7 +375,7 @@ def mbcn_adjust( gw_idxs: Indices of the times in each windowed time group pts_dims : [str, str] The name of the "multivariate" dimension and its primed counterpart. Defaults to "multivar", which - is the normal case when using :py:func:`xclim.sdba.base.stack_variables`, and "multivar_prime". + is the normal case when using :py:func:`xsdba.base.stack_variables`, and "multivar_prime". interp : str Interpolation method for the npdf transform (same as in the training step). extrapolation : str @@ -488,7 +488,7 @@ def qm_adjust( extrapolation : str The extrapolation method to use. kind : str - The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + The kind of correction to compute. See :py:func:`xsdba.utils.get_correction`. Returns ------- @@ -534,7 +534,7 @@ def dqm_adjust( interp : str The interpolation method to use. kind : str - The kind of correction to compute. See :py:func:`xclim.sdba.utils.get_correction`. + The kind of correction to compute. See :py:func:`xsdba.utils.get_correction`. extrapolation : str The extrapolation method to use. detrend : int | PolyDetrend @@ -708,8 +708,15 @@ def npdf_transform(ds: xr.Dataset, **kwargs) -> xr.Dataset: Returns ------- xr.Dataset - Dataset with `scenh`, `scens` and `escores` DataArrays, where `scenh` and `scens` are `hist` and `sim` - respectively after adjustment according to `ref`. If `n_escore` is negative, `escores` will be filled with NaNs. + Dataset variables: + scenh : Scenario in the reference period (source `hist` transferred to target `ref` inside training) + scens : Scenario in the projected period (source `sim` transferred to target `ref` outside training) + escores : Index estimating the dissimilarity between `scenh` and `hist`. + + Notes + ----- + If `n_escore` is negative, `escores` will be filled with NaNs. + """ ref = ds.ref.rename(time_hist="time") hist = ds.hist.rename(time_hist="time") @@ -768,181 +775,181 @@ def npdf_transform(ds: xr.Dataset, **kwargs) -> xr.Dataset: # TODO: incorporate xclim.stats -# def _fit_on_cluster(data, thresh, dist, cluster_thresh): -# """Extract clusters on 1D data and fit "dist" on the maximums.""" -# _, _, _, maximums = u.get_clusters_1d(data, thresh, cluster_thresh) -# params = list( -# _fitfunc_1d(maximums - thresh, dist=dist, floc=0, nparams=3, method="ML") -# ) -# # We forced 0, put back thresh. -# params[-2] = thresh -# return params - - -# def _extremes_train_1d(ref, hist, ref_params, *, q_thresh, cluster_thresh, dist, N): -# """Train for method ExtremeValues, only for 1D input along time.""" -# # Find quantile q_thresh -# thresh = ( -# np.quantile(ref[ref >= cluster_thresh], q_thresh) -# + np.quantile(hist[hist >= cluster_thresh], q_thresh) -# ) / 2 - -# # Fit genpareto on cluster maximums on ref (if needed) and hist. -# if np.isnan(ref_params).all(): -# ref_params = _fit_on_cluster(ref, thresh, dist, cluster_thresh) - -# hist_params = _fit_on_cluster(hist, thresh, dist, cluster_thresh) - -# # Find probabilities of extremes according to fitted dist -# Px_ref = dist.cdf(ref[ref >= thresh], *ref_params) -# hist = hist[hist >= thresh] -# Px_hist = dist.cdf(hist, *hist_params) - -# # Find common probabilities range. -# Pmax = min(Px_ref.max(), Px_hist.max()) -# Pmin = max(Px_ref.min(), Px_hist.min()) -# Pcommon = (Px_hist <= Pmax) & (Px_hist >= Pmin) -# Px_hist = Px_hist[Pcommon] - -# # Find values of hist extremes if they followed ref's distribution. -# hist_in_ref = dist.ppf(Px_hist, *ref_params) - -# # Adjustment factors, unsorted -# af = hist_in_ref / hist[Pcommon] -# # sort them in Px order, and pad to have N values. -# order = np.argsort(Px_hist) -# px_hist = np.pad(Px_hist[order], ((0, N - af.size),), constant_values=np.NaN) -# af = np.pad(af[order], ((0, N - af.size),), constant_values=np.NaN) - -# return px_hist, af, thresh - - -# @map_blocks( -# reduces=["time"], px_hist=["quantiles"], af=["quantiles"], thresh=[Grouper.PROP] -# ) -# def extremes_train( -# ds: xr.Dataset, -# *, -# group: Grouper, -# q_thresh: float, -# cluster_thresh: float, -# dist, -# quantiles: np.ndarray, -# ) -> xr.Dataset: -# """Train extremes for a given variable series. - -# Parameters -# ---------- -# ds : xr.Dataset -# Dataset containing the reference and historical data. -# group : Grouper -# The grouper object. -# q_thresh : float -# The quantile threshold to use. -# cluster_thresh : float -# The threshold for clustering. -# dist : Any -# The distribution to fit. -# quantiles : array-like -# The quantiles to compute. - -# Returns -# ------- -# xr.Dataset -# The dataset containing the quantiles, the adjustment factors, and the threshold. -# """ -# px_hist, af, thresh = xr.apply_ufunc( -# _extremes_train_1d, -# ds.ref, -# ds.hist, -# ds.ref_params or np.NaN, -# input_core_dims=[("time",), ("time",), ()], -# output_core_dims=[("quantiles",), ("quantiles",), ()], -# vectorize=True, -# kwargs={ -# "q_thresh": q_thresh, -# "cluster_thresh": cluster_thresh, -# "dist": dist, -# "N": len(quantiles), -# }, -# ) -# # Outputs of map_blocks must have dimensions. -# if not isinstance(thresh, xr.DataArray): -# thresh = xr.DataArray(thresh) -# thresh = thresh.expand_dims(group=[1]) -# return xr.Dataset( -# {"px_hist": px_hist, "af": af, "thresh": thresh}, -# coords={"quantiles": quantiles}, -# ) - - -# def _fit_cluster_and_cdf(data, thresh, dist, cluster_thresh): -# """Fit 1D cluster maximums and immediately compute CDF.""" -# fut_params = _fit_on_cluster(data, thresh, dist, cluster_thresh) -# return dist.cdf(data, *fut_params) - - -# @map_blocks(reduces=["quantiles", Grouper.PROP], scen=[]) -# def extremes_adjust( -# ds: xr.Dataset, -# *, -# group: Grouper, -# frac: float, -# power: float, -# dist, -# interp: str, -# extrapolation: str, -# cluster_thresh: float, -# ) -> xr.Dataset: -# """Adjust extremes to reflect many distribution factors. - -# Parameters -# ---------- -# ds : xr.Dataset -# Dataset containing the reference and historical data. -# group : Grouper -# The grouper object. -# frac : float -# The fraction of the transition function. -# power : float -# The power of the transition function. -# dist : Any -# The distribution to fit. -# interp : str -# The interpolation method to use. -# extrapolation : str -# The extrapolation method to use. -# cluster_thresh : float -# The threshold for clustering. - -# Returns -# ------- -# xr.Dataset -# The dataset containing the adjusted data. -# """ -# # Find probabilities of extremes of fut according to its own cluster-fitted dist. -# px_fut = xr.apply_ufunc( -# _fit_cluster_and_cdf, -# ds.sim, -# ds.thresh, -# input_core_dims=[["time"], []], -# output_core_dims=[["time"]], -# kwargs={"dist": dist, "cluster_thresh": cluster_thresh}, -# vectorize=True, -# ) - -# # Find factors by interpolating from hist probs to fut probs. apply them. -# af = u.interp_on_quantiles( -# px_fut, ds.px_hist, ds.af, method=interp, extrapolation=extrapolation -# ) -# scen = u.apply_correction(ds.sim, af, "*") - -# # Smooth transition function between simulation and scenario. -# transition = ( -# ((ds.sim - ds.thresh) / ((ds.sim.max("time")) - ds.thresh)) / frac -# ) ** power -# transition = transition.clip(0, 1) - -# adjusted: xr.DataArray = (transition * scen) + ((1 - transition) * ds.scen) -# out = adjusted.rename("scen").squeeze("group", drop=True).to_dataset() -# return out +def _fit_on_cluster(data, thresh, dist, cluster_thresh): + """Extract clusters on 1D data and fit "dist" on the maximums.""" + _, _, _, maximums = u.get_clusters_1d(data, thresh, cluster_thresh) + params = list( + _fitfunc_1d(maximums - thresh, dist=dist, floc=0, nparams=3, method="ML") + ) + # We forced 0, put back thresh. + params[-2] = thresh + return params + + +def _extremes_train_1d(ref, hist, ref_params, *, q_thresh, cluster_thresh, dist, N): + """Train for method ExtremeValues, only for 1D input along time.""" + # Find quantile q_thresh + thresh = ( + np.quantile(ref[ref >= cluster_thresh], q_thresh) + + np.quantile(hist[hist >= cluster_thresh], q_thresh) + ) / 2 + + # Fit genpareto on cluster maximums on ref (if needed) and hist. + if np.isnan(ref_params).all(): + ref_params = _fit_on_cluster(ref, thresh, dist, cluster_thresh) + + hist_params = _fit_on_cluster(hist, thresh, dist, cluster_thresh) + + # Find probabilities of extremes according to fitted dist + Px_ref = dist.cdf(ref[ref >= thresh], *ref_params) + hist = hist[hist >= thresh] + Px_hist = dist.cdf(hist, *hist_params) + + # Find common probabilities range. + Pmax = min(Px_ref.max(), Px_hist.max()) + Pmin = max(Px_ref.min(), Px_hist.min()) + Pcommon = (Px_hist <= Pmax) & (Px_hist >= Pmin) + Px_hist = Px_hist[Pcommon] + + # Find values of hist extremes if they followed ref's distribution. + hist_in_ref = dist.ppf(Px_hist, *ref_params) + + # Adjustment factors, unsorted + af = hist_in_ref / hist[Pcommon] + # sort them in Px order, and pad to have N values. + order = np.argsort(Px_hist) + px_hist = np.pad(Px_hist[order], ((0, N - af.size),), constant_values=np.NaN) + af = np.pad(af[order], ((0, N - af.size),), constant_values=np.NaN) + + return px_hist, af, thresh + + +@map_blocks( + reduces=["time"], px_hist=["quantiles"], af=["quantiles"], thresh=[Grouper.PROP] +) +def extremes_train( + ds: xr.Dataset, + *, + group: Grouper, + q_thresh: float, + cluster_thresh: float, + dist, + quantiles: np.ndarray, +) -> xr.Dataset: + """Train extremes for a given variable series. + + Parameters + ---------- + ds : xr.Dataset + Dataset containing the reference and historical data. + group : Grouper + The grouper object. + q_thresh : float + The quantile threshold to use. + cluster_thresh : float + The threshold for clustering. + dist : Any + The distribution to fit. + quantiles : array-like + The quantiles to compute. + + Returns + ------- + xr.Dataset + The dataset containing the quantiles, the adjustment factors, and the threshold. + """ + px_hist, af, thresh = xr.apply_ufunc( + _extremes_train_1d, + ds.ref, + ds.hist, + ds.ref_params or np.NaN, + input_core_dims=[("time",), ("time",), ()], + output_core_dims=[("quantiles",), ("quantiles",), ()], + vectorize=True, + kwargs={ + "q_thresh": q_thresh, + "cluster_thresh": cluster_thresh, + "dist": dist, + "N": len(quantiles), + }, + ) + # Outputs of map_blocks must have dimensions. + if not isinstance(thresh, xr.DataArray): + thresh = xr.DataArray(thresh) + thresh = thresh.expand_dims(group=[1]) + return xr.Dataset( + {"px_hist": px_hist, "af": af, "thresh": thresh}, + coords={"quantiles": quantiles}, + ) + + +def _fit_cluster_and_cdf(data, thresh, dist, cluster_thresh): + """Fit 1D cluster maximums and immediately compute CDF.""" + fut_params = _fit_on_cluster(data, thresh, dist, cluster_thresh) + return dist.cdf(data, *fut_params) + + +@map_blocks(reduces=["quantiles", Grouper.PROP], scen=[]) +def extremes_adjust( + ds: xr.Dataset, + *, + group: Grouper, + frac: float, + power: float, + dist, + interp: str, + extrapolation: str, + cluster_thresh: float, +) -> xr.Dataset: + """Adjust extremes to reflect many distribution factors. + + Parameters + ---------- + ds : xr.Dataset + Dataset containing the reference and historical data. + group : Grouper + The grouper object. + frac : float + The fraction of the transition function. + power : float + The power of the transition function. + dist : Any + The distribution to fit. + interp : str + The interpolation method to use. + extrapolation : str + The extrapolation method to use. + cluster_thresh : float + The threshold for clustering. + + Returns + ------- + xr.Dataset + The dataset containing the adjusted data. + """ + # Find probabilities of extremes of fut according to its own cluster-fitted dist. + px_fut = xr.apply_ufunc( + _fit_cluster_and_cdf, + ds.sim, + ds.thresh, + input_core_dims=[["time"], []], + output_core_dims=[["time"]], + kwargs={"dist": dist, "cluster_thresh": cluster_thresh}, + vectorize=True, + ) + + # Find factors by interpolating from hist probs to fut probs. apply them. + af = u.interp_on_quantiles( + px_fut, ds.px_hist, ds.af, method=interp, extrapolation=extrapolation + ) + scen = u.apply_correction(ds.sim, af, "*") + + # Smooth transition function between simulation and scenario. + transition = ( + ((ds.sim - ds.thresh) / ((ds.sim.max("time")) - ds.thresh)) / frac + ) ** power + transition = transition.clip(0, 1) + + adjusted: xr.DataArray = (transition * scen) + ((1 - transition) * ds.scen) + out = adjusted.rename("scen").squeeze("group", drop=True).to_dataset() + return out diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index f39daca..3041aa7 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -19,7 +19,9 @@ from xsdba.units import convert_units_to from xsdba.utils import uses_dask -from ._adjustment import ( # extremes_adjust,; extremes_train, +from ._adjustment import ( + extremes_adjust, + extremes_train, dqm_adjust, dqm_train, eqm_train, @@ -44,7 +46,7 @@ rand_rot_matrix, ) -# from xclim.indices import stats +from .xclim_submodules import stats __all__ = [ @@ -52,7 +54,7 @@ "BaseAdjustment", "DetrendedQuantileMapping", "EmpiricalQuantileMapping", - # "ExtremeValues", + "ExtremeValues", "MBCn", "NpdfTransform", "PrincipalComponents", @@ -636,162 +638,162 @@ def _adjust(self, sim, interp="nearest", extrapolation="constant"): return out.scen -# class ExtremeValues(TrainAdjust): -# r"""Adjustment correction for extreme values. - -# The tail of the distribution of adjusted data is corrected according to the bias between the parametric Generalized -# Pareto distributions of the simulated and reference data :cite:p:`sdba-roy_extremeprecip_2023`. The distributions are composed of the -# maximal values of clusters of "large" values. With "large" values being those above `cluster_thresh`. Only extreme -# values, whose quantile within the pool of large values are above `q_thresh`, are re-adjusted. See `Notes`. - -# This adjustment method should be considered experimental and used with care. - -# Parameters -# ---------- -# Train step : - -# cluster_thresh : Quantity (str with units) -# The threshold value for defining clusters. -# q_thresh : float -# The quantile of "extreme" values, [0, 1[. Defaults to 0.95. -# ref_params : xr.DataArray, optional -# Distribution parameters to use instead of fitting a GenPareto distribution on `ref`. - -# Adjust step: - -# scen : DataArray -# This is a second-order adjustment, so the adjust method needs the first-order -# adjusted timeseries in addition to the raw "sim". -# interp : {'nearest', 'linear', 'cubic'} -# The interpolation method to use when interpolating the adjustment factors. Defaults to "linear". -# extrapolation : {'constant', 'nan'} -# The type of extrapolation to use. See :py:func:`~xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". -# frac : float -# Fraction where the cutoff happens between the original scen and the corrected one. -# See Notes, ]0, 1]. Defaults to 0.25. -# power : float -# Shape of the correction strength, see Notes. Defaults to 1.0. - -# Notes -# ----- -# Extreme values are extracted from `ref`, `hist` and `sim` by finding all "clusters", i.e. runs of consecutive values -# above `cluster_thresh`. The `q_thresh`th percentile of these values is taken on `ref` and `hist` and becomes -# `thresh`, the extreme value threshold. The maximal value of each cluster, if it exceeds that new threshold, is taken -# and Generalized Pareto distributions are fitted to them, for both `ref` and `hist`. The probabilities associated -# with each of these extremes in `hist` is used to find the corresponding value according to `ref`'s distribution. -# Adjustment factors are computed as the bias between those new extremes and the original ones. - -# In the adjust step, a Generalized Pareto distributions is fitted on the cluster-maximums of `sim` and it is used to -# associate a probability to each extreme, values over the `thresh` compute in the training, without the clustering. -# The adjustment factors are computed by interpolating the trained ones using these probabilities and the -# probabilities computed from `hist`. - -# Finally, the adjusted values (:math:`C_i`) are mixed with the pre-adjusted ones (`scen`, :math:`D_i`) using the -# following transition function: - -# .. math:: - -# V_i = C_i * \tau + D_i * (1 - \tau) - -# Where :math:`\tau` is a function of sim's extreme values (unadjusted, :math:`S_i`) -# and of arguments ``frac`` (:math:`f`) and ``power`` (:math:`p`): - -# .. math:: - -# \tau = \left(\frac{1}{f}\frac{S - min(S)}{max(S) - min(S)}\right)^p - -# Code based on an internal Matlab source and partly ib the `biascorrect_extremes` function of the julia package -# "ClimateTools.jl" :cite:p:`sdba-roy_juliaclimateclimatetoolsjl_2021`. - -# Because of limitations imposed by the lazy computing nature of the dask backend, it -# is not possible to know the number of cluster extremes in `ref` and `hist` at the -# moment the output data structure is created. This is why the code tries to estimate -# that number and usually overestimates it. In the training dataset, this translated -# into a `quantile` dimension that is too large and variables `af` and `px_hist` are -# assigned NaNs on extra elements. This has no incidence on the calculations -# themselves but requires more memory than is useful. - -# References -# ---------- -# :cite:cts:`sdba-roy_juliaclimateclimatetoolsjl_2021` -# :cite:cts:`sdba-roy_extremeprecip_2023` -# """ - -# @classmethod -# def _train( -# cls, -# ref: xr.DataArray, -# hist: xr.DataArray, -# *, -# cluster_thresh: str, -# ref_params: xr.Dataset | None = None, -# q_thresh: float = 0.95, -# ): -# cluster_thresh = convert_units_to(cluster_thresh, ref, context="infer") - -# # Approximation of how many "quantiles" values we will get: -# N = (1 - q_thresh) * ref.time.size * 1.05 # extra padding for safety - -# # ref_params: cast nan to f32 not to interfere with map_blocks dtype parsing -# # ref and hist are f32, we want to have f32 in the output. -# ds = extremes_train( -# xr.Dataset( -# { -# "ref": ref, -# "hist": hist, -# "ref_params": ref_params or np.float32(np.NaN), -# } -# ), -# q_thresh=q_thresh, -# cluster_thresh=cluster_thresh, -# dist=stats.get_dist("genpareto"), -# quantiles=np.arange(int(N)), -# group="time", -# ) - -# ds.px_hist.attrs.update( -# long_name="Probability of extremes in hist", -# description="Parametric probabilities of extremes in the common domain of hist and ref.", -# ) -# ds.af.attrs.update( -# long_name="Extremes adjustment factor", -# description="Multiplicative adjustment factor of extremes from hist to ref.", -# ) -# ds.thresh.attrs.update( -# long_name=f"{q_thresh * 100}th percentile extreme value threshold", -# description=f"Mean of the {q_thresh * 100}th percentile of large values (x > {cluster_thresh}) of ref and hist.", -# ) - -# return ds.drop_vars(["quantiles"]), {"cluster_thresh": cluster_thresh} - -# def _adjust( -# self, -# sim: xr.DataArray, -# scen: xr.DataArray, -# *, -# frac: float = 0.25, -# power: float = 1.0, -# interp: str = "linear", -# extrapolation: str = "constant", -# ): -# # Quantiles coord : cheat and assign 0 - 1, so we can use `extrapolate_qm`. -# ds = self.ds.assign( -# quantiles=(np.arange(self.ds.quantiles.size) + 1) -# / (self.ds.quantiles.size + 1) -# ) - -# scen = extremes_adjust( -# ds.assign(sim=sim, scen=scen), -# cluster_thresh=self.cluster_thresh, -# dist=stats.get_dist("genpareto"), -# frac=frac, -# power=power, -# interp=interp, -# extrapolation=extrapolation, -# group="time", -# ) - -# return scen +class ExtremeValues(TrainAdjust): + r"""Adjustment correction for extreme values. + + The tail of the distribution of adjusted data is corrected according to the bias between the parametric Generalized + Pareto distributions of the simulated and reference data :cite:p:`sdba-roy_extremeprecip_2023`. The distributions are composed of the + maximal values of clusters of "large" values. With "large" values being those above `cluster_thresh`. Only extreme + values, whose quantile within the pool of large values are above `q_thresh`, are re-adjusted. See `Notes`. + + This adjustment method should be considered experimental and used with care. + + Parameters + ---------- + Train step : + + cluster_thresh : Quantity (str with units) + The threshold value for defining clusters. + q_thresh : float + The quantile of "extreme" values, [0, 1[. Defaults to 0.95. + ref_params : xr.DataArray, optional + Distribution parameters to use instead of fitting a GenPareto distribution on `ref`. + + Adjust step: + + scen : DataArray + This is a second-order adjustment, so the adjust method needs the first-order + adjusted timeseries in addition to the raw "sim". + interp : {'nearest', 'linear', 'cubic'} + The interpolation method to use when interpolating the adjustment factors. Defaults to "linear". + extrapolation : {'constant', 'nan'} + The type of extrapolation to use. See :py:func:`~xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + frac : float + Fraction where the cutoff happens between the original scen and the corrected one. + See Notes, ]0, 1]. Defaults to 0.25. + power : float + Shape of the correction strength, see Notes. Defaults to 1.0. + + Notes + ----- + Extreme values are extracted from `ref`, `hist` and `sim` by finding all "clusters", i.e. runs of consecutive values + above `cluster_thresh`. The `q_thresh`th percentile of these values is taken on `ref` and `hist` and becomes + `thresh`, the extreme value threshold. The maximal value of each cluster, if it exceeds that new threshold, is taken + and Generalized Pareto distributions are fitted to them, for both `ref` and `hist`. The probabilities associated + with each of these extremes in `hist` is used to find the corresponding value according to `ref`'s distribution. + Adjustment factors are computed as the bias between those new extremes and the original ones. + + In the adjust step, a Generalized Pareto distributions is fitted on the cluster-maximums of `sim` and it is used to + associate a probability to each extreme, values over the `thresh` compute in the training, without the clustering. + The adjustment factors are computed by interpolating the trained ones using these probabilities and the + probabilities computed from `hist`. + + Finally, the adjusted values (:math:`C_i`) are mixed with the pre-adjusted ones (`scen`, :math:`D_i`) using the + following transition function: + + .. math:: + + V_i = C_i * \tau + D_i * (1 - \tau) + + Where :math:`\tau` is a function of sim's extreme values (unadjusted, :math:`S_i`) + and of arguments ``frac`` (:math:`f`) and ``power`` (:math:`p`): + + .. math:: + + \tau = \left(\frac{1}{f}\frac{S - min(S)}{max(S) - min(S)}\right)^p + + Code based on an internal Matlab source and partly ib the `biascorrect_extremes` function of the julia package + "ClimateTools.jl" :cite:p:`sdba-roy_juliaclimateclimatetoolsjl_2021`. + + Because of limitations imposed by the lazy computing nature of the dask backend, it + is not possible to know the number of cluster extremes in `ref` and `hist` at the + moment the output data structure is created. This is why the code tries to estimate + that number and usually overestimates it. In the training dataset, this translated + into a `quantile` dimension that is too large and variables `af` and `px_hist` are + assigned NaNs on extra elements. This has no incidence on the calculations + themselves but requires more memory than is useful. + + References + ---------- + :cite:cts:`sdba-roy_juliaclimateclimatetoolsjl_2021` + :cite:cts:`sdba-roy_extremeprecip_2023` + """ + + @classmethod + def _train( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + cluster_thresh: str, + ref_params: xr.Dataset | None = None, + q_thresh: float = 0.95, + ): + cluster_thresh = convert_units_to(cluster_thresh, ref) + + # Approximation of how many "quantiles" values we will get: + N = (1 - q_thresh) * ref.time.size * 1.05 # extra padding for safety + + # ref_params: cast nan to f32 not to interfere with map_blocks dtype parsing + # ref and hist are f32, we want to have f32 in the output. + ds = extremes_train( + xr.Dataset( + { + "ref": ref, + "hist": hist, + "ref_params": ref_params or np.float32(np.NaN), + } + ), + q_thresh=q_thresh, + cluster_thresh=cluster_thresh, + dist=stats.get_dist("genpareto"), + quantiles=np.arange(int(N)), + group="time", + ) + + ds.px_hist.attrs.update( + long_name="Probability of extremes in hist", + description="Parametric probabilities of extremes in the common domain of hist and ref.", + ) + ds.af.attrs.update( + long_name="Extremes adjustment factor", + description="Multiplicative adjustment factor of extremes from hist to ref.", + ) + ds.thresh.attrs.update( + long_name=f"{q_thresh * 100}th percentile extreme value threshold", + description=f"Mean of the {q_thresh * 100}th percentile of large values (x > {cluster_thresh}) of ref and hist.", + ) + + return ds.drop_vars(["quantiles"]), {"cluster_thresh": cluster_thresh} + + def _adjust( + self, + sim: xr.DataArray, + scen: xr.DataArray, + *, + frac: float = 0.25, + power: float = 1.0, + interp: str = "linear", + extrapolation: str = "constant", + ): + # Quantiles coord : cheat and assign 0 - 1, so we can use `extrapolate_qm`. + ds = self.ds.assign( + quantiles=(np.arange(self.ds.quantiles.size) + 1) + / (self.ds.quantiles.size + 1) + ) + + scen = extremes_adjust( + ds.assign(sim=sim, scen=scen), + cluster_thresh=self.cluster_thresh, + dist=stats.get_dist("genpareto"), + frac=frac, + power=power, + interp=interp, + extrapolation=extrapolation, + group="time", + ) + + return scen class LOCI(TrainAdjust): diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index 1eba691..8ff876e 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -148,7 +148,7 @@ def get_local_attrs( Parameters ---------- indicator : str or sequence of strings - Indicator's class name, usually the same as in `xc.core.indicator.registry`. + Indicator's class name, usually the same as in `xsdba.indicator.registry`. If multiple names are passed, the attrs from each indicator are merged, with the highest priority set to the first name. locales : str or tuple of str diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index f902ef7..098a526 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -387,7 +387,7 @@ def _spell_stats( # threshold is an amount that will be converted to the right units if method == "amount": - thresh = convert_units_to(thresh, da) # , context="infer") + thresh = convert_units_to(thresh, da) elif method != "quantile": raise ValueError( f"{method} is not a valid method. Choose 'amount' or 'quantile'." diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 74375aa..22c9dd5 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -186,12 +186,43 @@ def pint2str(value: units.Quantity | units.Unit) -> str: return f"{value:cf}".replace("dimensionless", "") +def pint_multiply( + da: xr.DataArray, q: pint.Quantity | str, out_units: str | None = None +) -> xr.DataArray: + """Multiply xarray.DataArray by pint.Quantity. + + Parameters + ---------- + da : xr.DataArray + Input array. + q : pint.Quantity or str + Multiplicative factor. + out_units : str, optional + Units the output array should be converted into. + + Returns + ------- + xr.DataArray + """ + q = q if isinstance(q, pint.Quantity) else str2pint(q) + a = 1 * units2pint(da) # noqa + f = a * q.to_base_units() + if out_units: + f = f.to(out_units) + else: + f = f.to_reduced_units() + out: xr.DataArray = da * f.magnitude + out = out.assign_attrs(units=pint2str(f.units)) + return out + + DELTA_ABSOLUTE_TEMP = { units.delta_degC: units.kelvin, units.delta_degF: units.rankine, } + def ensure_absolute_temperature(units: str): """Convert temperature units to their absolute counterpart, assuming they represented a difference (delta). diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index ff9479b..bd8b463 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -7,7 +7,8 @@ from scipy.stats import genpareto, norm, uniform from xsdba import adjustment -from xsdba.adjustment import ( # ExtremeValues, +from xsdba.adjustment import ( + ExtremeValues, LOCI, DetrendedQuantileMapping, EmpiricalQuantileMapping, @@ -24,7 +25,7 @@ unstack_variables, ) from xsdba.testing import nancov -from xsdba.units import convert_units_to +from xsdba.units import convert_units_to, pint_multiply from xsdba.utils import ( ADDITIVE, MULTIPLICATIVE, @@ -710,85 +711,84 @@ def _group_assert(ds, dim): # assert (ref - scen).mean().tasmin < 5e-3 -# class TestExtremeValues: -# @pytest.mark.parametrize( -# "c_thresh,q_thresh,frac,power", -# [ -# ["1 mm/d", 0.95, 0.25, 1], -# ["1 mm/d", 0.90, 1e-6, 1], -# ["0.007 m/week", 0.95, 0.25, 2], -# ], -# ) -# def test_simple(self, c_thresh, q_thresh, frac, power, random): -# n = 45 * 365 - -# def gen_testdata(c, s): -# base = np.clip( -# norm.rvs(loc=0, scale=s, size=(n,), random_state=random), 0, None -# ) -# qv = np.quantile(base[base > 1], q_thresh) -# base[base > qv] = genpareto.rvs( -# c, loc=qv, scale=s, size=base[base > qv].shape, random_state=random -# ) -# return xr.DataArray( -# base, -# dims=("time",), -# coords={ -# "time": xr.cftime_range("1990-01-01", periods=n, calendar="noleap") -# }, -# attrs={"units": "mm/day", "thresh": qv}, -# ) - -# ref = jitter_under_thresh(gen_testdata(-0.1, 2), "1e-3 mm/d") -# hist = jitter_under_thresh(gen_testdata(-0.1, 2), "1e-3 mm/d") -# sim = gen_testdata(-0.15, 2.5) - -# EQM = EmpiricalQuantileMapping.train( -# ref, hist, group="time.dayofyear", nquantiles=15, kind="*" -# ) - -# scen = EQM.adjust(sim) +class TestExtremeValues: + @pytest.mark.parametrize( + "c_thresh,q_thresh,frac,power", + [ + ["1 mm/d", 0.95, 0.25, 1], + ["1 mm/d", 0.90, 1e-6, 1], + ["0.007 m/week", 0.95, 0.25, 2], + ], + ) + def test_simple(self, c_thresh, q_thresh, frac, power, random): + n = 45 * 365 -# EX = ExtremeValues.train(ref, hist, cluster_thresh=c_thresh, q_thresh=q_thresh) -# qv = (ref.thresh + hist.thresh) / 2 -# np.testing.assert_allclose(EX.ds.thresh, qv, atol=0.15, rtol=0.01) + def gen_testdata(c, s): + base = np.clip( + norm.rvs(loc=0, scale=s, size=(n,), random_state=random), 0, None + ) + qv = np.quantile(base[base > 1], q_thresh) + base[base > qv] = genpareto.rvs( + c, loc=qv, scale=s, size=base[base > qv].shape, random_state=random + ) + return xr.DataArray( + base, + dims=("time",), + coords={ + "time": xr.cftime_range("1990-01-01", periods=n, calendar="noleap") + }, + attrs={"units": "mm/day", "thresh": qv}, + ) -# scen2 = EX.adjust(scen, sim, frac=frac, power=power) + ref = jitter_under_thresh(gen_testdata(-0.1, 2), "1e-3 mm/d") + hist = jitter_under_thresh(gen_testdata(-0.1, 2), "1e-3 mm/d") + sim = gen_testdata(-0.15, 2.5) -# # What to test??? -# # Test if extreme values of sim are still extreme -# exval = sim > EX.ds.thresh -# assert (scen2.where(exval) > EX.ds.thresh).sum() > ( -# scen.where(exval) > EX.ds.thresh -# ).sum() + EQM = EmpiricalQuantileMapping.train( + ref, hist, group="time.dayofyear", nquantiles=15, kind="*" + ) -# @pytest.mark.slow -# def test_real_data(self, open_dataset): -# dsim = open_dataset("sdba/CanESM2_1950-2100.nc").chunk() -# dref = open_dataset("sdba/ahccd_1950-2013.nc").chunk() + scen = EQM.adjust(sim) -# ref = convert_units_to( -# dref.sel(time=slice("1950", "2009")).pr, "mm/d", context="hydro" -# ) -# hist = convert_units_to( -# dsim.sel(time=slice("1950", "2009")).pr, "mm/d", context="hydro" -# ) + EX = ExtremeValues.train(ref, hist, cluster_thresh=c_thresh, q_thresh=q_thresh) + qv = (ref.thresh + hist.thresh) / 2 + np.testing.assert_allclose(EX.ds.thresh, qv, atol=0.15, rtol=0.01) -# quantiles = np.linspace(0.01, 0.99, num=50) + scen2 = EX.adjust(scen, sim, frac=frac, power=power) -# with xr.set_options(keep_attrs=True): -# ref = ref + uniform_noise_like(ref, low=1e-6, high=1e-3) -# hist = hist + uniform_noise_like(hist, low=1e-6, high=1e-3) + # What to test??? + # Test if extreme values of sim are still extreme + exval = sim > EX.ds.thresh + assert (scen2.where(exval) > EX.ds.thresh).sum() > ( + scen.where(exval) > EX.ds.thresh + ).sum() -# EQM = EmpiricalQuantileMapping.train( -# ref, hist, group=Grouper("time.dayofyear", window=31), nquantiles=quantiles -# ) + @pytest.mark.slow + def test_real_data(self, open_dataset): + dsim = open_dataset("sdba/CanESM2_1950-2100.nc")#.chunk() + dref = open_dataset("sdba/ahccd_1950-2013.nc")#.chunk() + ref = dref.sel(time=slice("1950", "2009")).pr + hist = dsim.sel(time=slice("1950", "2009")).pr + # TODO: Do we want to include standard conversions in xsdba tests? + # this is just convenient for now to keep those tests + hist = pint_multiply(hist, "1e-03 m^3/kg") + hist = convert_units_to(hist,ref) + + quantiles = np.linspace(0.01, 0.99, num=50) + + with xr.set_options(keep_attrs=True): + ref = ref + uniform_noise_like(ref, low=1e-6, high=1e-3) + hist = hist + uniform_noise_like(hist, low=1e-6, high=1e-3) + + EQM = EmpiricalQuantileMapping.train( + ref, hist, group=Grouper("time.dayofyear", window=31), nquantiles=quantiles + ) -# scen = EQM.adjust(hist, interp="linear", extrapolation="constant") + scen = EQM.adjust(hist, interp="linear", extrapolation="constant") -# EX = ExtremeValues.train(ref, hist, cluster_thresh="1 mm/day", q_thresh=0.97) -# new_scen = EX.adjust(scen, hist, frac=0.000000001) -# new_scen.load() + EX = ExtremeValues.train(ref, hist, cluster_thresh="1 mm/day", q_thresh=0.97) + new_scen = EX.adjust(scen, hist, frac=0.000000001) + new_scen.load() def test_raise_on_multiple_chunks(timelonlatseries): @@ -807,78 +807,78 @@ def test_default_grouper_understood(timelonlatseries): assert EQM.group.dim == "time" -class TestSBCKutils: - @pytest.mark.slow - @pytest.mark.parametrize( - "method", - [m for m in dir(adjustment) if m.startswith("SBCK_")], - ) - @pytest.mark.parametrize("use_dask", [True]) # do we gain testing both? - def test_sbck(self, method, use_dask, random): - SBCK = pytest.importorskip("SBCK", minversion="0.4.0") - - n = 10 * 365 - m = 2 # A dummy dimension to test vectorization. - ref_y = norm.rvs(loc=10, scale=1, size=(m, n), random_state=random) - ref_x = norm.rvs(loc=3, scale=2, size=(m, n), random_state=random) - hist_x = norm.rvs(loc=11, scale=1.2, size=(m, n), random_state=random) - hist_y = norm.rvs(loc=4, scale=2.2, size=(m, n), random_state=random) - sim_x = norm.rvs(loc=12, scale=2, size=(m, n), random_state=random) - sim_y = norm.rvs(loc=3, scale=1.8, size=(m, n), random_state=random) - - ref = xr.Dataset( - { - "tasmin": xr.DataArray( - ref_x, dims=("lon", "time"), attrs={"units": "degC"} - ), - "tasmax": xr.DataArray( - ref_y, dims=("lon", "time"), attrs={"units": "degC"} - ), - } - ) - ref["time"] = xr.cftime_range("1990-01-01", periods=n, calendar="noleap") - - hist = xr.Dataset( - { - "tasmin": xr.DataArray( - hist_x, dims=("lon", "time"), attrs={"units": "degC"} - ), - "tasmax": xr.DataArray( - hist_y, dims=("lon", "time"), attrs={"units": "degC"} - ), - } - ) - hist["time"] = ref["time"] - - sim = xr.Dataset( - { - "tasmin": xr.DataArray( - sim_x, dims=("lon", "time"), attrs={"units": "degC"} - ), - "tasmax": xr.DataArray( - sim_y, dims=("lon", "time"), attrs={"units": "degC"} - ), - } - ) - sim["time"] = xr.cftime_range("2090-01-01", periods=n, calendar="noleap") - - if use_dask: - ref = ref.chunk({"lon": 1}) - hist = hist.chunk({"lon": 1}) - sim = sim.chunk({"lon": 1}) - - if "TSMBC" in method: - kws = {"lag": 1} - elif "MBCn" in method: - kws = {"metric": SBCK.metrics.energy} - else: - kws = {} - - scen = getattr(adjustment, method).adjust( - stack_variables(ref), - stack_variables(hist), - stack_variables(sim), - multi_dim="multivar", - **kws, - ) - unstack_variables(scen).load() +# class TestSBCKutils: +# @pytest.mark.slow +# @pytest.mark.parametrize( +# "method", +# [m for m in dir(adjustment) if m.startswith("SBCK_")], +# ) +# @pytest.mark.parametrize("use_dask", [True]) # do we gain testing both? +# def test_sbck(self, method, use_dask, random): +# SBCK = pytest.importorskip("SBCK", minversion="0.4.0") + +# n = 10 * 365 +# m = 2 # A dummy dimension to test vectorization. +# ref_y = norm.rvs(loc=10, scale=1, size=(m, n), random_state=random) +# ref_x = norm.rvs(loc=3, scale=2, size=(m, n), random_state=random) +# hist_x = norm.rvs(loc=11, scale=1.2, size=(m, n), random_state=random) +# hist_y = norm.rvs(loc=4, scale=2.2, size=(m, n), random_state=random) +# sim_x = norm.rvs(loc=12, scale=2, size=(m, n), random_state=random) +# sim_y = norm.rvs(loc=3, scale=1.8, size=(m, n), random_state=random) + +# ref = xr.Dataset( +# { +# "tasmin": xr.DataArray( +# ref_x, dims=("lon", "time"), attrs={"units": "degC"} +# ), +# "tasmax": xr.DataArray( +# ref_y, dims=("lon", "time"), attrs={"units": "degC"} +# ), +# } +# ) +# ref["time"] = xr.cftime_range("1990-01-01", periods=n, calendar="noleap") + +# hist = xr.Dataset( +# { +# "tasmin": xr.DataArray( +# hist_x, dims=("lon", "time"), attrs={"units": "degC"} +# ), +# "tasmax": xr.DataArray( +# hist_y, dims=("lon", "time"), attrs={"units": "degC"} +# ), +# } +# ) +# hist["time"] = ref["time"] + +# sim = xr.Dataset( +# { +# "tasmin": xr.DataArray( +# sim_x, dims=("lon", "time"), attrs={"units": "degC"} +# ), +# "tasmax": xr.DataArray( +# sim_y, dims=("lon", "time"), attrs={"units": "degC"} +# ), +# } +# ) +# sim["time"] = xr.cftime_range("2090-01-01", periods=n, calendar="noleap") + +# if use_dask: +# ref = ref.chunk({"lon": 1}) +# hist = hist.chunk({"lon": 1}) +# sim = sim.chunk({"lon": 1}) + +# if "TSMBC" in method: +# kws = {"lag": 1} +# elif "MBCn" in method: +# kws = {"metric": SBCK.metrics.energy} +# else: +# kws = {} + +# scen = getattr(adjustment, method).adjust( +# stack_variables(ref), +# stack_variables(hist), +# stack_variables(sim), +# multi_dim="multivar", +# **kws, +# ) +# unstack_variables(scen).load() diff --git a/tests/test_properties.py b/tests/test_properties.py index 5b693bf..2e4403e 100644 --- a/tests/test_properties.py +++ b/tests/test_properties.py @@ -373,7 +373,7 @@ def test_corr_btw_var(self, open_dataset): -0.2090292, ], ) - assert pc.long_name == "Pearson correlation coefficient" + assert pc.long_name == "Pearson correlation coefficient." assert pc.units == "" with pytest.raises( diff --git a/tests/test_units.py b/tests/test_units.py index 61f8566..06969a0 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -7,7 +7,6 @@ import pytest import xarray as xr from dask import array as dsk -from xclim import indices, set_options from xsdba.logging import ValidationError from xsdba.typing import Quantified @@ -90,8 +89,14 @@ def test_str2pint(self): ("", "sum", "count", 365, "d"), ("", "sum", "count", 365, "d"), ("kg m-2", "var", "var", 0, "kg2 m-4"), - ("°C", "argmax", "doymax", 0, ""), - ("°C", "sum", "integral", 365, "K d"), + ("°C", "argmax", "doymax", 0, ("", "1")), # dependent on numpy/pint version + ( + "°C", + "sum", + "integral", + 365, + ("K d", "d K"), + ), # dependent on numpy/pint version ("°F", "sum", "integral", 365, "d °R"), # not sure why the order is different ], ) @@ -105,7 +110,14 @@ def test_to_agg_units(in_u, opfunc, op, exp, exp_u): out = to_agg_units(getattr(da, opfunc)(), da, op) np.testing.assert_allclose(out, exp) - assert out.attrs["units"] == exp_u + + if isinstance(exp_u, tuple): + if Version(__cfxr_version__) < Version("0.9.3"): + assert out.attrs["units"] == exp_u[0] + else: + assert out.attrs["units"] == exp_u[1] + else: + assert out.attrs["units"] == exp_u class TestHarmonizeUnits: diff --git a/tests/test_utils.py b/tests/test_utils.py index 2759bd0..35c01e9 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -10,19 +10,19 @@ from xsdba.base import Grouper -def test_ecdf(timelonlatseries, random): +def test_ecdf(timeseries, random): dist = norm(5, 2) r = dist.rvs(10000, random_state=random) q = [0.01, 0.5, 0.99] x = xr.DataArray(dist.ppf(q), dims=("q",)) - np.testing.assert_allclose(u.ecdf(timelonlatseries(r, "tas"), x), q, 3) + np.testing.assert_allclose(u.ecdf(timeseries(r, units="K" ), x), q, 3) # With NaNs r[:2000] = np.nan - np.testing.assert_allclose(u.ecdf(timelonlatseries(r, "tas"), x), q, 3) + np.testing.assert_allclose(u.ecdf(timeseries(r, units="K"), x), q, 3) -def test_map_cdf(timelonlatseries, random): +def test_map_cdf(timeseries, random): n = 10000 xd = norm(5, 2) yd = norm(7, 3) @@ -31,8 +31,8 @@ def test_map_cdf(timelonlatseries, random): x_value = u.map_cdf( xr.Dataset( dict( - x=timelonlatseries(xd.rvs(n, random_state=random), "pr"), - y=timelonlatseries(yd.rvs(n, random_state=random), "pr"), + x=timeseries(xd.rvs(n, random_state=random), units = "kg / m^2 / s"), + y=timeseries(yd.rvs(n, random_state=random), units = "kg / m^2 / s"), ) ), y_value=yd.ppf(q), @@ -45,8 +45,8 @@ def test_map_cdf(timelonlatseries, random): x_value = u.map_cdf( xr.Dataset( dict( - x=timelonlatseries(xd.rvs(n, random_state=random), "pr"), - y=timelonlatseries(yd.rvs(n, random_state=random), "pr"), + x=timeseries(xd.rvs(n, random_state=random), units="kg / m^2 / s"), + y=timeseries(yd.rvs(n, random_state=random), units="kg / m^2 / s"), ) ), y_value=yd.ppf(q), From 52546bc49d5b8329000f09b524c138c0bc92724f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 1 Aug 2024 17:02:10 -0400 Subject: [PATCH 038/105] formatting --- src/xsdba/_adjustment.py | 3 +-- src/xsdba/adjustment.py | 6 ++---- src/xsdba/units.py | 1 - tests/test_adjustment.py | 8 ++++---- tests/test_utils.py | 6 +++--- 5 files changed, 10 insertions(+), 14 deletions(-) diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index 7ee5a0e..637c1c2 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -22,7 +22,6 @@ from .options import set_options from .processing import escore, jitter_under_thresh, reordering, standardize from .units import convert_units_to, units - from .xclim_submodules.stats import _fitfunc_1d @@ -716,7 +715,7 @@ def npdf_transform(ds: xr.Dataset, **kwargs) -> xr.Dataset: Notes ----- If `n_escore` is negative, `escores` will be filled with NaNs. - + """ ref = ds.ref.rename(time_hist="time") hist = ds.hist.rename(time_hist="time") diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 3041aa7..4dfb9a0 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -20,11 +20,11 @@ from xsdba.utils import uses_dask from ._adjustment import ( - extremes_adjust, - extremes_train, dqm_adjust, dqm_train, eqm_train, + extremes_adjust, + extremes_train, loci_adjust, loci_train, mbcn_adjust, @@ -45,10 +45,8 @@ pc_matrix, rand_rot_matrix, ) - from .xclim_submodules import stats - __all__ = [ "LOCI", "BaseAdjustment", diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 22c9dd5..2342ad4 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -222,7 +222,6 @@ def pint_multiply( } - def ensure_absolute_temperature(units: str): """Convert temperature units to their absolute counterpart, assuming they represented a difference (delta). diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index bd8b463..b2aaf1e 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -8,10 +8,10 @@ from xsdba import adjustment from xsdba.adjustment import ( - ExtremeValues, LOCI, DetrendedQuantileMapping, EmpiricalQuantileMapping, + ExtremeValues, PrincipalComponents, QuantileDeltaMapping, Scaling, @@ -765,14 +765,14 @@ def gen_testdata(c, s): @pytest.mark.slow def test_real_data(self, open_dataset): - dsim = open_dataset("sdba/CanESM2_1950-2100.nc")#.chunk() - dref = open_dataset("sdba/ahccd_1950-2013.nc")#.chunk() + dsim = open_dataset("sdba/CanESM2_1950-2100.nc") # .chunk() + dref = open_dataset("sdba/ahccd_1950-2013.nc") # .chunk() ref = dref.sel(time=slice("1950", "2009")).pr hist = dsim.sel(time=slice("1950", "2009")).pr # TODO: Do we want to include standard conversions in xsdba tests? # this is just convenient for now to keep those tests hist = pint_multiply(hist, "1e-03 m^3/kg") - hist = convert_units_to(hist,ref) + hist = convert_units_to(hist, ref) quantiles = np.linspace(0.01, 0.99, num=50) diff --git a/tests/test_utils.py b/tests/test_utils.py index 35c01e9..7376e37 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -15,7 +15,7 @@ def test_ecdf(timeseries, random): r = dist.rvs(10000, random_state=random) q = [0.01, 0.5, 0.99] x = xr.DataArray(dist.ppf(q), dims=("q",)) - np.testing.assert_allclose(u.ecdf(timeseries(r, units="K" ), x), q, 3) + np.testing.assert_allclose(u.ecdf(timeseries(r, units="K"), x), q, 3) # With NaNs r[:2000] = np.nan @@ -31,8 +31,8 @@ def test_map_cdf(timeseries, random): x_value = u.map_cdf( xr.Dataset( dict( - x=timeseries(xd.rvs(n, random_state=random), units = "kg / m^2 / s"), - y=timeseries(yd.rvs(n, random_state=random), units = "kg / m^2 / s"), + x=timeseries(xd.rvs(n, random_state=random), units="kg / m^2 / s"), + y=timeseries(yd.rvs(n, random_state=random), units="kg / m^2 / s"), ) ), y_value=yd.ppf(q), From 45ec1b6ee6f7b8695c0df921b037bcbf1739ffeb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 1 Aug 2024 17:18:04 -0400 Subject: [PATCH 039/105] add MBCn tests --- src/xsdba/__init__.py | 1 + src/xsdba/calendar.py | 38 +++++- src/xsdba/locales.py | 2 +- src/xsdba/nbutils.py | 16 +-- src/xsdba/units.py | 1 + src/xsdba/utils.py | 256 +++++++++++++-------------------------- tests/test_adjustment.py | 215 +++++++++++++++++++------------- 7 files changed, 266 insertions(+), 263 deletions(-) diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index c1c626e..81088dc 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -36,6 +36,7 @@ from .adjustment import * from .base import Grouper from .options import set_options +from .processing import stack_variables, unstack_variables # from .processing import stack_variables, unstack_variables diff --git a/src/xsdba/calendar.py b/src/xsdba/calendar.py index e32cdcd..c3909d5 100644 --- a/src/xsdba/calendar.py +++ b/src/xsdba/calendar.py @@ -16,6 +16,7 @@ import numpy as np import pandas as pd import xarray as xr +from boltons.funcutils import wraps from xarray.coding.cftime_offsets import to_cftime_datetime from xarray.coding.cftimeindex import CFTimeIndex from xarray.core import dtypes @@ -43,6 +44,7 @@ "doy_from_string", "doy_to_days_since", "ensure_cftime_array", + "ensure_longest_doy", "get_calendar", "interp_calendar", "is_offset_divisor", @@ -554,7 +556,9 @@ def compare_offsets(freqA: str, op: str, freqB: str) -> bool: bool freqA op freqB """ - from ..indices.generic import get_op # pylint: disable=import-outside-toplevel + from .xclim_submodules.generic import ( # pylint: disable=import-outside-toplevel + get_op, + ) # Get multiplier and base frequency t_a, b_a, _, _ = parse_offset(freqA) @@ -704,6 +708,38 @@ def is_offset_divisor(divisor: str, offset: str): return all(offAs.is_on_offset(d) for d in tB) +def ensure_longest_doy(func: Callable) -> Callable: + """Ensure that selected day is the longest day of year for x and y dims.""" + + @wraps(func) + def _ensure_longest_doy(x, y, *args, **kwargs): + if ( + hasattr(x, "dims") + and hasattr(y, "dims") + and "dayofyear" in x.dims + and "dayofyear" in y.dims + and x.dayofyear.max() != y.dayofyear.max() + ): + warn( + ( + "get_correction received inputs defined on different dayofyear ranges. " + "Interpolating to the longest range. Results could be strange." + ), + stacklevel=4, + ) + if x.dayofyear.max() < y.dayofyear.max(): + x = _interpolate_doy_calendar( + x, int(y.dayofyear.max()), int(y.dayofyear.min()) + ) + else: + y = _interpolate_doy_calendar( + y, int(x.dayofyear.max()), int(x.dayofyear.min()) + ) + return func(x, y, *args, **kwargs) + + return _ensure_longest_doy + + def _interpolate_doy_calendar( source: xr.DataArray, doy_max: int, doy_min: int = 1 ) -> xr.DataArray: diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index 8ff876e..e3947b1 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -288,7 +288,7 @@ def generate_local_dict(locale: str, init_english: bool = False) -> dict: If True, fills the initial dictionary with the english versions of the attributes. Defaults to False. """ - from ..core.indicator import registry # pylint: disable=import-outside-toplevel + from .indicator import registry # pylint: disable=import-outside-toplevel if locale in _LOCALES: _, attrs = get_local_dict(locale) diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index d5b2864..88fc3d4 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -26,11 +26,10 @@ nogil=True, cache=False, ) -def _get_indexes( # noqa: PR07 +def _get_indexes( arr: np.array, virtual_indexes: np.array, valid_values_count: np.array ) -> tuple[np.array, np.array]: - """ - Get the valid indexes of arr neighbouring virtual_indexes. + """Get the valid indexes of arr neighbouring virtual_indexes. Parameters ---------- @@ -41,7 +40,7 @@ def _get_indexes( # noqa: PR07 Returns ------- array-like, array-like - A tuple of virtual_indexes neighbouring indexes (previous and next). + A tuple of virtual_indexes neighbouring indexes (previous and next) Notes ----- @@ -210,7 +209,8 @@ def _wrapper_quantile1d(arr, q): return out -def _quantile(arr, q, nreduce): +def _quantile(arr, q, nreduce=None): + nreduce = nreduce or arr.ndim if arr.ndim == nreduce: out = _nan_quantile_1d(arr.flatten(), q) else: @@ -277,7 +277,7 @@ def quantile(da: DataArray, q: np.ndarray, dim: str | Sequence[Hashable]) -> Dat nogil=True, cache=False, ) -def remove_NaNs(x): # noqa: N802 +def remove_NaNs(x): # noqa """Remove NaN values from series.""" remove = np.zeros_like(x[0, :], dtype=boolean) for i in range(x.shape[0]): @@ -386,7 +386,9 @@ def _first_and_last_nonnull(arr): nogil=True, cache=False, ) -def _extrapolate_on_quantiles(interp, oldx, oldg, oldy, newx, newg, method="constant"): +def _extrapolate_on_quantiles( + interp, oldx, oldg, oldy, newx, newg, method="constant" +): # noqa """Apply extrapolation to the output of interpolation on quantiles with a given grouping. Arguments are the same as _interp_on_quantiles_2D. diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 2342ad4..1a0bac4 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -6,6 +6,7 @@ import inspect from copy import deepcopy from functools import wraps +from typing import Any import pint diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 34dcdfb..5c6264c 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -9,15 +9,16 @@ from typing import Callable from warnings import warn +import bottleneck as bn import numpy as np import xarray as xr -from boltons.funcutils import wraps from dask import array as dsk from scipy.interpolate import griddata, interp1d from scipy.stats import spearmanr from xarray.core.utils import get_temp_dimname from .base import Grouper, parse_group, uses_dask +from .calendar import ensure_longest_doy from .nbutils import _extrapolate_on_quantiles MULTIPLICATIVE = "*" @@ -49,18 +50,17 @@ def map_cdf( Parameters ---------- ds : xr.Dataset - Variables: - x : Values from which to pick. - y : Reference values giving the ranking. + Variables: x, Values from which to pick, + y, Reference values giving the ranking y_value : float, array - Value within the support of `y`. + Value within the support of `y`. dim : str - Dimension along which to compute quantile. + Dimension along which to compute quantile. Returns ------- array - Quantile of `x` with the same CDF as `y_value` in `y`. + Quantile of `x` with the same CDF as `y_value` in `y`. """ return xr.apply_ufunc( map_cdf_1d, @@ -95,135 +95,6 @@ def ecdf(x: xr.DataArray, value: float, dim: str = "time") -> xr.DataArray: return (x <= value).sum(dim) / x.notnull().sum(dim) -# XC -def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: - r"""Ensure that the input DataArray has chunks of at least the given size. - - If only one chunk is too small, it is merged with an adjacent chunk. - If many chunks are too small, they are grouped together by merging adjacent chunks. - - Parameters - ---------- - da : xr.DataArray - The input DataArray, with or without the dask backend. Does nothing when passed a non-dask array. - \*\*minchunks : dict[str, int] - A kwarg mapping from dimension name to minimum chunk size. - Pass -1 to force a single chunk along that dimension. - - Returns - ------- - xr.DataArray - """ - if not uses_dask(da): - return da - - all_chunks = dict(zip(da.dims, da.chunks)) - chunking = {} - for dim, minchunk in minchunks.items(): - chunks = all_chunks[dim] - if minchunk == -1 and len(chunks) > 1: - # Rechunk to single chunk only if it's not already one - chunking[dim] = -1 - - toosmall = np.array(chunks) < minchunk # Chunks that are too small - if toosmall.sum() > 1: - # Many chunks are too small, merge them by groups - fac = np.ceil(minchunk / min(chunks)).astype(int) - chunking[dim] = tuple( - sum(chunks[i : i + fac]) for i in range(0, len(chunks), fac) - ) - # Reset counter is case the last chunks are still too small - chunks = chunking[dim] - toosmall = np.array(chunks) < minchunk - if toosmall.sum() == 1: - # Only one, merge it with adjacent chunk - ind = np.where(toosmall)[0][0] - new_chunks = list(chunks) - sml = new_chunks.pop(ind) - new_chunks[max(ind - 1, 0)] += sml - chunking[dim] = tuple(new_chunks) - - if chunking: - return da.chunk(chunks=chunking) - return da - - -# XC -def _interpolate_doy_calendar( - source: xr.DataArray, doy_max: int, doy_min: int = 1 -) -> xr.DataArray: - """Interpolate from one set of dayofyear range to another. - - Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 - to 365). - - Parameters - ---------- - source : xr.DataArray - Array with `dayofyear` coordinates. - doy_max : int - The largest day of the year allowed by calendar. - doy_min : int - The smallest day of the year in the output. - This parameter is necessary when the target time series does not span over a full year (e.g. JJA season). - Default is 1. - - Returns - ------- - xr.DataArray - Interpolated source array over coordinates spanning the target `dayofyear` range. - """ - if "dayofyear" not in source.coords.keys(): - raise AttributeError("Source should have `dayofyear` coordinates.") - - # Interpolate to fill na values - da = source - if uses_dask(source): - # interpolate_na cannot run on chunked dayofyear. - da = source.chunk(dict(dayofyear=-1)) - filled_na = da.interpolate_na(dim="dayofyear") - - # Interpolate to target dayofyear range - filled_na.coords["dayofyear"] = np.linspace( - start=doy_min, stop=doy_max, num=len(filled_na.coords["dayofyear"]) - ) - - return filled_na.interp(dayofyear=range(doy_min, doy_max + 1)) - - -# XC -def ensure_longest_doy(func: Callable) -> Callable: - """Ensure that selected day is the longest day of year for x and y dims.""" - - @wraps(func) - def _ensure_longest_doy(x, y, *args, **kwargs): - if ( - hasattr(x, "dims") - and hasattr(y, "dims") - and "dayofyear" in x.dims - and "dayofyear" in y.dims - and x.dayofyear.max() != y.dayofyear.max() - ): - warn( - ( - "get_correction received inputs defined on different dayofyear ranges. " - "Interpolating to the longest range. Results could be strange." - ), - stacklevel=4, - ) - if x.dayofyear.max() < y.dayofyear.max(): - x = _interpolate_doy_calendar( - x, int(y.dayofyear.max()), int(y.dayofyear.min()) - ) - else: - y = _interpolate_doy_calendar( - y, int(x.dayofyear.max()), int(x.dayofyear.min()) - ) - return func(x, y, *args, **kwargs) - - return _ensure_longest_doy - - @ensure_longest_doy def get_correction(x: xr.DataArray, y: xr.DataArray, kind: str) -> xr.DataArray: """Return the additive or multiplicative correction/adjustment factors.""" @@ -405,6 +276,39 @@ def add_cyclic_bounds( return ensure_chunk_size(qmf, **{att: -1}) +def _interp_on_quantiles_1D_multi(newxs, oldx, oldy, method, extrap): # noqa: N802 + # Perform multiple interpolations with a single call of interp1d. + # This should be used when `oldx` is common for many data arrays (`newxs`) + # that we want to interpolate on. For instance, with QuantileDeltaMapping, we simply + # interpolate on quantiles that always remain the same. + if len(newxs.shape) == 1: + return _interp_on_quantiles_1D(newxs, oldx, oldy, method, extrap) + mask_old = np.isnan(oldy) | np.isnan(oldx) + if extrap == "constant": + fill_value = ( + oldy[~np.isnan(oldy)][0], + oldy[~np.isnan(oldy)][-1], + ) + else: # extrap == 'nan' + fill_value = np.NaN + + finterp1d = interp1d( + oldx[~mask_old], + oldy[~mask_old], + kind=method, + bounds_error=False, + fill_value=fill_value, + ) + + out = np.zeros_like(newxs) + for ii in range(newxs.shape[0]): + mask_new = np.isnan(newxs[ii, :]) + y1 = newxs[ii, :].copy() * np.NaN + y1[~mask_new] = finterp1d(newxs[ii, ~mask_new]) + out[ii, :] = y1.flatten() + return out + + def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 mask_new = np.isnan(newx) mask_old = np.isnan(oldy) | np.isnan(oldx) @@ -627,6 +531,14 @@ def rank( return rnk +def _rank_bn(arr, axis=None): + """Ranking on a specific axis""" + rnk = bn.nanrankdata(arr, axis=axis) + rnk = rnk / np.nanmax(rnk, axis=axis, keepdims=True) + mx, mn = 1, np.nanmin(rnk, axis=axis, keepdims=True) + return mx * (rnk - mn) / (mx - mn) + + def pc_matrix(arr: np.ndarray | dsk.Array) -> np.ndarray | dsk.Array: """Construct a Principal Component matrix. @@ -678,17 +590,17 @@ def best_pc_orientation_simple( Parameters ---------- R : np.ndarray - MxM Matrix defining the final transformation. + MxM Matrix defining the final transformation. Hinv : np.ndarray - MxM Matrix defining the (inverse) first transformation. + MxM Matrix defining the (inverse) first transformation. val : float - The coordinate of the test point (same for all axes). It should be much - greater than the largest furthest point in the array used to define B. + The coordinate of the test point (same for all axes). It should be much + greater than the largest furthest point in the array used to define B. Returns ------- np.ndarray - Mx1 vector of orientation correction (1 or -1). + Mx1 vector of orientation correction (1 or -1). See Also -------- @@ -728,20 +640,20 @@ def best_pc_orientation_full( Parameters ---------- R : np.ndarray - MxM Matrix defining the final transformation. + MxM Matrix defining the final transformation. Hinv : np.ndarray - MxM Matrix defining the (inverse) first transformation. + MxM Matrix defining the (inverse) first transformation. Rmean : np.ndarray - M vector defining the target distribution center point. + M vector defining the target distribution center point. Hmean : np.ndarray - M vector defining the original distribution center point. + M vector defining the original distribution center point. hist : np.ndarray - MxN matrix of all training observations of the M variables/sites. + MxN matrix of all training observations of the M variables/sites. Returns ------- np.ndarray - M vector of orientation correction (1 or -1). + M vector of orientation correction (1 or -1). References ---------- @@ -830,27 +742,27 @@ def get_clusters(data: xr.DataArray, u1, u2, dim: str = "time") -> xr.Dataset: Parameters ---------- - data : 1D ndarray - Values to get clusters from. + data: 1D ndarray + Values to get clusters from. u1 : float - Extreme value threshold, at least one value in the cluster must exceed this. + Extreme value threshold, at least one value in the cluster must exceed this. u2 : float - Cluster threshold, values above this can be part of a cluster. + Cluster threshold, values above this can be part of a cluster. dim : str - Dimension name. + Dimension name. Returns ------- xr.Dataset - With variables, - - `nclusters` : Number of clusters for each point (with `dim` reduced), int - - `start` : First index in the cluster (`dim` reduced, new `cluster`), int - - `end` : Last index in the cluster, inclusive (`dim` reduced, new `cluster`), int - - `maxpos` : Index of the maximal value within the cluster (`dim` reduced, new `cluster`), int - - `maximum` : Maximal value within the cluster (`dim` reduced, new `cluster`), same dtype as data. - - For `start`, `end` and `maxpos`, -1 means NaN and should always correspond to a `NaN` in `maximum`. - The length along `cluster` is half the size of "dim", the maximal theoretical number of clusters. + With variables, + - `nclusters` : Number of clusters for each point (with `dim` reduced), int + - `start` : First index in the cluster (`dim` reduced, new `cluster`), int + - `end` : Last index in the cluster, inclusive (`dim` reduced, new `cluster`), int + - `maxpos` : Index of the maximal value within the cluster (`dim` reduced, new `cluster`), int + - `maximum` : Maximal value within the cluster (`dim` reduced, new `cluster`), same dtype as data. + + For `start`, `end` and `maxpos`, -1 means NaN and should always correspond to a `NaN` in `maximum`. + The length along `cluster` is half the size of "dim", the maximal theoretical number of clusters. """ def _get_clusters(arr, u1, u2, N): @@ -914,19 +826,19 @@ def rand_rot_matrix( Parameters ---------- - crd : xr.DataArray - 1D coordinate DataArray along which the rotation occurs. - The output will be square with the same coordinate replicated, - the second renamed to `new_dim`. + crd: xr.DataArray + 1D coordinate DataArray along which the rotation occurs. + The output will be square with the same coordinate replicated, + the second renamed to `new_dim`. num : int - If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. + If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. new_dim : str - Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". + Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". Returns ------- xr.DataArray - Data of type float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. + float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. References ---------- @@ -950,9 +862,11 @@ def rand_rot_matrix( num = np.diag(R) denum = np.abs(num) lam = np.diag(num / denum) # "lambda" - return xr.DataArray( - Q @ lam, dims=(dim, new_dim), coords={dim: crd, new_dim: crd2} - ).astype("float32") + return ( + xr.DataArray(Q @ lam, dims=(dim, new_dim), coords={dim: crd, new_dim: crd2}) + .astype("float32") + .assign_attrs({"crd_dim": dim, "new_dim": new_dim}) + ) def _pairwise_spearman(da, dims): diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index b2aaf1e..cf4e5ab 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -12,11 +12,13 @@ DetrendedQuantileMapping, EmpiricalQuantileMapping, ExtremeValues, + MBCn, PrincipalComponents, QuantileDeltaMapping, Scaling, ) from xsdba.base import Grouper +from xsdba.calendar import stack_periods from xsdba.options import set_options from xsdba.processing import ( jitter_under_thresh, @@ -582,44 +584,44 @@ def test_mon_u( # Test predict np.testing.assert_array_almost_equal(p, ref, 2) - # @pytest.mark.parametrize("use_dask", [True, False]) - # @pytest.mark.filterwarnings("ignore::RuntimeWarning") - # def test_add_dims(self, use_dask, open_dataset): - # with set_options(sdba_encode_cf=use_dask): - # if use_dask: - # chunks = {"location": -1} - # else: - # chunks = None - # ref = ( - # open_dataset( - # "sdba/ahccd_1950-2013.nc", - # chunks=chunks, - # drop_variables=["lat", "lon"], - # ) - # .sel(time=slice("1981", "2010")) - # .tasmax - # ) - # ref = convert_units_to(ref, "K") - # ref = ref.isel(location=1, drop=True).expand_dims(location=["Amos"]) - - # dsim = open_dataset( - # "sdba/CanESM2_1950-2100.nc", - # chunks=chunks, - # drop_variables=["lat", "lon"], - # ).tasmax - # hist = dsim.sel(time=slice("1981", "2010")) - # sim = dsim.sel(time=slice("2041", "2070")) - - # # With add_dims, "does it run" test - # group = Grouper("time.dayofyear", window=5, add_dims=["location"]) - # EQM = EmpiricalQuantileMapping.train(ref, hist, group=group) - # EQM.adjust(sim).load() - - # # Without, sanity test. - # group = Grouper("time.dayofyear", window=5) - # EQM2 = EmpiricalQuantileMapping.train(ref, hist, group=group) - # scen2 = EQM2.adjust(sim).load() - # assert scen2.sel(location=["Kugluktuk", "Vancouver"]).isnull().all() + @pytest.mark.parametrize("use_dask", [True, False]) + @pytest.mark.filterwarnings("ignore::RuntimeWarning") + def test_add_dims(self, use_dask, open_dataset): + with set_options(sdba_encode_cf=use_dask): + if use_dask: + chunks = {"location": -1} + else: + chunks = None + ref = ( + open_dataset( + "sdba/ahccd_1950-2013.nc", + chunks=chunks, + drop_variables=["lat", "lon"], + ) + .sel(time=slice("1981", "2010")) + .tasmax + ) + ref = convert_units_to(ref, "K") + ref = ref.isel(location=1, drop=True).expand_dims(location=["Amos"]) + + dsim = open_dataset( + "sdba/CanESM2_1950-2100.nc", + chunks=chunks, + drop_variables=["lat", "lon"], + ).tasmax + hist = dsim.sel(time=slice("1981", "2010")) + sim = dsim.sel(time=slice("2041", "2070")) + + # With add_dims, "does it run" test + group = Grouper("time.dayofyear", window=5, add_dims=["location"]) + EQM = EmpiricalQuantileMapping.train(ref, hist, group=group) + EQM.adjust(sim).load() + + # Without, sanity test. + group = Grouper("time.dayofyear", window=5) + EQM2 = EmpiricalQuantileMapping.train(ref, hist, group=group) + scen2 = EQM2.adjust(sim).load() + assert scen2.sel(location=["Kugluktuk", "Vancouver"]).isnull().all() class TestPrincipalComponents: @@ -666,49 +668,49 @@ def _group_assert(ds, dim): group.apply(_group_assert, {"ref": ref, "sim": sim, "scen": scen}) - # @pytest.mark.parametrize("use_dask", [True, False]) - # @pytest.mark.parametrize("pcorient", ["full", "simple"]) - # def test_real_data(self, atmosds, use_dask, pcorient): - # ref = stack_variables( - # xr.Dataset( - # {"tasmax": atmosds.tasmax, "tasmin": atmosds.tasmin, "tas": atmosds.tas} - # ) - # ).isel(location=3) - # hist = stack_variables( - # xr.Dataset( - # { - # "tasmax": 1.001 * atmosds.tasmax, - # "tasmin": atmosds.tasmin - 0.25, - # "tas": atmosds.tas + 1, - # } - # ) - # ).isel(location=3) - # with xr.set_options(keep_attrs=True): - # sim = hist + 5 - # sim["time"] = sim.time + np.timedelta64(10, "Y").astype("<m8[ns]") - - # if use_dask: - # ref = ref.chunk() - # hist = hist.chunk() - # sim = sim.chunk() - - # PCA = PrincipalComponents.train( - # ref, hist, crd_dim="multivar", best_orientation=pcorient - # ) - # scen = PCA.adjust(sim) - - # def dist(ref, sim): - # """Pointwise distance between ref and sim in the PC space.""" - # sim["time"] = ref.time - # return np.sqrt(((ref - sim) ** 2).sum("multivar")) - - # # Most points are closer after transform. - # assert (dist(ref, sim) < dist(ref, scen)).mean() < 0.01 - - # ref = unstack_variables(ref) - # scen = unstack_variables(scen) - # # "Error" is very small - # assert (ref - scen).mean().tasmin < 5e-3 + @pytest.mark.parametrize("use_dask", [True, False]) + @pytest.mark.parametrize("pcorient", ["full", "simple"]) + def test_real_data(self, atmosds, use_dask, pcorient): + ref = stack_variables( + xr.Dataset( + {"tasmax": atmosds.tasmax, "tasmin": atmosds.tasmin, "tas": atmosds.tas} + ) + ).isel(location=3) + hist = stack_variables( + xr.Dataset( + { + "tasmax": 1.001 * atmosds.tasmax, + "tasmin": atmosds.tasmin - 0.25, + "tas": atmosds.tas + 1, + } + ) + ).isel(location=3) + with xr.set_options(keep_attrs=True): + sim = hist + 5 + sim["time"] = sim.time + np.timedelta64(10, "Y").astype("<m8[ns]") + + if use_dask: + ref = ref.chunk() + hist = hist.chunk() + sim = sim.chunk() + + PCA = PrincipalComponents.train( + ref, hist, crd_dim="multivar", best_orientation=pcorient + ) + scen = PCA.adjust(sim) + + def dist(ref, sim): + """Pointwise distance between ref and sim in the PC space.""" + sim["time"] = ref.time + return np.sqrt(((ref - sim) ** 2).sum("multivar")) + + # Most points are closer after transform. + assert (dist(ref, sim) < dist(ref, scen)).mean() < 0.01 + + ref = unstack_variables(ref) + scen = unstack_variables(scen) + # "Error" is very small + assert (ref - scen).mean().tasmin < 5e-3 class TestExtremeValues: @@ -797,16 +799,63 @@ def test_raise_on_multiple_chunks(timelonlatseries): EmpiricalQuantileMapping.train(ref, ref, group=Grouper("time.month")) -def test_default_grouper_understood(timelonlatseries): +def test_default_grouper_understood(timeseries): attrs = {"units": "K", "kind": ADDITIVE} - ref = timelonlatseries(np.arange(730).astype(float), attrs={"units": "K"}) + ref = timeseries(np.arange(730).astype(float), units="K") EQM = EmpiricalQuantileMapping.train(ref, ref) EQM.adjust(ref) assert EQM.group.dim == "time" +@pytest.mark.slow +class TestMBCn: + @pytest.mark.parametrize("use_dask", [True, False]) + @pytest.mark.parametrize("group, window", [["time", 1], ["time.dayofyear", 31]]) + @pytest.mark.parametrize("period_dim", [None, "period"]) + # TODO: Add test_simple ? + def test_real_data(self, open_dataset, use_dask, group, window, period_dim): + group, window, period_dim, use_dask = "time", 1, None, False + with set_options(sdba_encode_cf=use_dask): + if use_dask: + chunks = {"location": -1} + else: + chunks = None + ref, dsim = ( + open_dataset( + f"sdba/{file}", + chunks=chunks, + drop_variables=["lat", "lon"], + ) + .isel(location=1, drop=True) + .expand_dims(location=["Amos"]) + for file in ["ahccd_1950-2013.nc", "CanESM2_1950-2100.nc"] + ) + ref, hist = ( + ds.sel(time=slice("1981", "2010")).isel(time=slice(365 * 4)) + for ds in [ref, dsim] + ) + # mm d-1 -> kg m-2 d-1 + ref["pr"] = pint_multiply(ref["pr"], "1000 kg/m^3") + dsim = dsim.sel(time=slice("1981", None)) + sim = (stack_periods(dsim).isel(period=slice(1, 2))).isel( + time=slice(365 * 4) + ) + + ref, hist, sim = (stack_variables(ds) for ds in [ref, hist, sim]) + + MBCN = MBCn.train( + ref, + hist, + base_kws=dict(nquantiles=50, group=Grouper(group, window)), + adj_kws=dict(interp="linear"), + ) + p = MBCN.adjust(sim=sim, ref=ref, hist=hist, period_dim=period_dim) + # 'does it run' test + p.load() + + # class TestSBCKutils: # @pytest.mark.slow # @pytest.mark.parametrize( From 47cd132d9b223b62e7bd1e0adb0ba1a686a9ec6a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 1 Aug 2024 18:09:24 -0400 Subject: [PATCH 040/105] SBCK added & tests --- src/xsdba/__init__.py | 11 +-- tests/test_adjustment.py | 150 +++++++++++++++++++-------------------- 2 files changed, 78 insertions(+), 83 deletions(-) diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 81088dc..f98670c 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -30,23 +30,18 @@ units, utils, ) - -# , adjustment -# from . import adjustment, base, detrending, measures, processing, properties, utils from .adjustment import * from .base import Grouper from .options import set_options from .processing import stack_variables, unstack_variables -# from .processing import stack_variables, unstack_variables - # TODO: ISIMIP ? Used for precip freq adjustment in biasCorrection.R # Hempel, S., Frieler, K., Warszawski, L., Schewe, J., & Piontek, F. (2013). A trend-preserving bias correction – # The ISI-MIP approach. Earth System Dynamics, 4(2), 219–236. https://doi.org/10.5194/esd-4-219-2013 # If SBCK is installed, create adjustment classes wrapping SBCK's algorithms. -# if hasattr(adjustment, "_generate_SBCK_classes"): -# for cls in adjustment._generate_SBCK_classes(): -# adjustment.__dict__[cls.__name__] = cls +if hasattr(adjustment, "_generate_SBCK_classes"): + for cls in adjustment._generate_SBCK_classes(): + adjustment.__dict__[cls.__name__] = cls __author__ = """Trevor James Smith""" __email__ = "smith.trevorj@ouranos.ca" diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index cf4e5ab..fae07d3 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -856,78 +856,78 @@ def test_real_data(self, open_dataset, use_dask, group, window, period_dim): p.load() -# class TestSBCKutils: -# @pytest.mark.slow -# @pytest.mark.parametrize( -# "method", -# [m for m in dir(adjustment) if m.startswith("SBCK_")], -# ) -# @pytest.mark.parametrize("use_dask", [True]) # do we gain testing both? -# def test_sbck(self, method, use_dask, random): -# SBCK = pytest.importorskip("SBCK", minversion="0.4.0") - -# n = 10 * 365 -# m = 2 # A dummy dimension to test vectorization. -# ref_y = norm.rvs(loc=10, scale=1, size=(m, n), random_state=random) -# ref_x = norm.rvs(loc=3, scale=2, size=(m, n), random_state=random) -# hist_x = norm.rvs(loc=11, scale=1.2, size=(m, n), random_state=random) -# hist_y = norm.rvs(loc=4, scale=2.2, size=(m, n), random_state=random) -# sim_x = norm.rvs(loc=12, scale=2, size=(m, n), random_state=random) -# sim_y = norm.rvs(loc=3, scale=1.8, size=(m, n), random_state=random) - -# ref = xr.Dataset( -# { -# "tasmin": xr.DataArray( -# ref_x, dims=("lon", "time"), attrs={"units": "degC"} -# ), -# "tasmax": xr.DataArray( -# ref_y, dims=("lon", "time"), attrs={"units": "degC"} -# ), -# } -# ) -# ref["time"] = xr.cftime_range("1990-01-01", periods=n, calendar="noleap") - -# hist = xr.Dataset( -# { -# "tasmin": xr.DataArray( -# hist_x, dims=("lon", "time"), attrs={"units": "degC"} -# ), -# "tasmax": xr.DataArray( -# hist_y, dims=("lon", "time"), attrs={"units": "degC"} -# ), -# } -# ) -# hist["time"] = ref["time"] - -# sim = xr.Dataset( -# { -# "tasmin": xr.DataArray( -# sim_x, dims=("lon", "time"), attrs={"units": "degC"} -# ), -# "tasmax": xr.DataArray( -# sim_y, dims=("lon", "time"), attrs={"units": "degC"} -# ), -# } -# ) -# sim["time"] = xr.cftime_range("2090-01-01", periods=n, calendar="noleap") - -# if use_dask: -# ref = ref.chunk({"lon": 1}) -# hist = hist.chunk({"lon": 1}) -# sim = sim.chunk({"lon": 1}) - -# if "TSMBC" in method: -# kws = {"lag": 1} -# elif "MBCn" in method: -# kws = {"metric": SBCK.metrics.energy} -# else: -# kws = {} - -# scen = getattr(adjustment, method).adjust( -# stack_variables(ref), -# stack_variables(hist), -# stack_variables(sim), -# multi_dim="multivar", -# **kws, -# ) -# unstack_variables(scen).load() +class TestSBCKutils: + @pytest.mark.slow + @pytest.mark.parametrize( + "method", + [m for m in dir(adjustment) if m.startswith("SBCK_")], + ) + @pytest.mark.parametrize("use_dask", [True]) # do we gain testing both? + def test_sbck(self, method, use_dask, random): + SBCK = pytest.importorskip("SBCK", minversion="0.4.0") + + n = 10 * 365 + m = 2 # A dummy dimension to test vectorization. + ref_y = norm.rvs(loc=10, scale=1, size=(m, n), random_state=random) + ref_x = norm.rvs(loc=3, scale=2, size=(m, n), random_state=random) + hist_x = norm.rvs(loc=11, scale=1.2, size=(m, n), random_state=random) + hist_y = norm.rvs(loc=4, scale=2.2, size=(m, n), random_state=random) + sim_x = norm.rvs(loc=12, scale=2, size=(m, n), random_state=random) + sim_y = norm.rvs(loc=3, scale=1.8, size=(m, n), random_state=random) + + ref = xr.Dataset( + { + "tasmin": xr.DataArray( + ref_x, dims=("lon", "time"), attrs={"units": "degC"} + ), + "tasmax": xr.DataArray( + ref_y, dims=("lon", "time"), attrs={"units": "degC"} + ), + } + ) + ref["time"] = xr.cftime_range("1990-01-01", periods=n, calendar="noleap") + + hist = xr.Dataset( + { + "tasmin": xr.DataArray( + hist_x, dims=("lon", "time"), attrs={"units": "degC"} + ), + "tasmax": xr.DataArray( + hist_y, dims=("lon", "time"), attrs={"units": "degC"} + ), + } + ) + hist["time"] = ref["time"] + + sim = xr.Dataset( + { + "tasmin": xr.DataArray( + sim_x, dims=("lon", "time"), attrs={"units": "degC"} + ), + "tasmax": xr.DataArray( + sim_y, dims=("lon", "time"), attrs={"units": "degC"} + ), + } + ) + sim["time"] = xr.cftime_range("2090-01-01", periods=n, calendar="noleap") + + if use_dask: + ref = ref.chunk({"lon": 1}) + hist = hist.chunk({"lon": 1}) + sim = sim.chunk({"lon": 1}) + + if "TSMBC" in method: + kws = {"lag": 1} + elif "MBCn" in method: + kws = {"metric": SBCK.metrics.energy} + else: + kws = {} + + scen = getattr(adjustment, method).adjust( + stack_variables(ref), + stack_variables(hist), + stack_variables(sim), + multi_dim="multivar", + **kws, + ) + unstack_variables(scen).load() From 0a93b8a2b9e62970f3d8e5c56f65a080ddc9d1be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 1 Aug 2024 18:28:24 -0400 Subject: [PATCH 041/105] what a beaut! (add logos) --- docs/logos/xsdba-logo-dark.png | Bin 0 -> 30117 bytes docs/logos/xsdba-logo-light.png | Bin 0 -> 8032 bytes docs/logos/xsdba-logo-small-dark.png | Bin 0 -> 2288 bytes docs/logos/xsdba-logo-small-light.png | Bin 0 -> 2306 bytes 4 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/logos/xsdba-logo-dark.png create mode 100644 docs/logos/xsdba-logo-light.png create mode 100644 docs/logos/xsdba-logo-small-dark.png create mode 100644 docs/logos/xsdba-logo-small-light.png diff --git a/docs/logos/xsdba-logo-dark.png b/docs/logos/xsdba-logo-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..235f994e542ae8fe2d1d66364ec832ebc35ad130 GIT binary patch literal 30117 zcmagFbyQqIw>^jkX@Yw~kl-%C-GU}~)401k1cv}YLU5Ph*0=?CCqQtwAi<r+nalU) z&3bSBX4d>cvevy_b?R2tIj7FvyTX+}%e+P>MTdifdo3p`r3wcJ4+Z|lP+tL0dM||^ zf&b7PWwl)3;NEq={K4B#xQPG{NnE8Nu4)eEt{z6tW^f)J9;{aOHZCScj%KV5&KBv% zLZonT6mW7<;_99mhbvw_x--7KPvg7GB;~8@EgXi3{Ykw^z0B2SYP|VYUU7AD5lhUk zKlr{|G*Deswbcr}9{OO{Swj}ruZ8|8o%Yk@><7DeAsU)=V;$TWdTf(A;&hg;WG1av z=}o&A_a+~cS`}uajx$qF?)yMCJ7XF5ZCtSB@n!GhWy;a71=>1gtDPC8Y5R|fB<eJJ z&redhg=vV00l2Fu&U+LkUBjA~mqn{rNqzwl&E_Vfy|xKKGL5z!w61<QfeLWCV#cAc zVz+4D7=73}+rNkL?S<=0(2wWK_U)0L;saLmsOA9U#5mn&tgJL`z08UunH0Fvm~{$C z8S~Ikh=xY^XpG6fS0otxxwxoP)SNj=)KlI}J;E(&BS~ht`j{r8H~9jM**xt394;sB zQ8QizQoscU(8p54e?yS{*7WI!)$2il_}ceYZG^C$@JJP(4g`&#n4aY!;Im`I4OGCy zWXI!+=B~nx#^9HtDZD{qGU&J{b<wA@`!SO8OTo=e<FcbmG~gx-t`rUjX@C@hARA7B zB{r{|>2>?=enLQm5Hi4VAF5+PizmYG<Nfi9p-by(_qSnZ1iCsLfgF;NEI+O+l_O=F zi+YL?C)&-#pOzSOIk*@P3|T5PI5|EU^H=v_K~pP#VJrr#<TK8sCebI+*T)xJ-9_*- z@S{f@nXZN$u&?EkMmI7Z2Htxve^~X-syYRt&HR0p?!Ab{%E{e`eq2Y$33MF{N<Ncb z{cCeL+<5YR?C_TRTQjS~CNL*4l9Hmeu<90aaYOaCNYc0+L1AI{<ebu8yRq&m_8U<x zJ#{WC#aQ9z^fdm1)&(wf{vX4o*8V?F7&Jpxb}Ky%4_pq`oNfap#>R=c+&|eZ5vo22 zigDxFjllD5&UZMbxh(#&R)fiCSCp>_{qaf=AaaAJrNiUnEx&6e&}p3gs29QU>Q`Ia z0XpZ6P{6)V-R=)=@nVgimF36(yevd^)P|X>qI+WF@9x+Y1+VDF8YehuwV9S$Do!`o z#8VR5W!d+HkF{oIF9L^B461871wwTMv&vrKC|>)JOwzE_MTL)+vivYO?qx%W#|NW~ z<ATL*TGAU`{arbCbfSR1sjf1|(!?s2zFR+G>;?IT^Al?KD^|>;x9lVP>31g3@2~|> ziLOr1J|?S-iXJmpVb*R2me&VQ>0OF%WPq+`M&;bxKYLcq5xW?FN^h9)3iFozoIZN{ z?ugkWs1a&?VlP)<y7W)wu#cE#W|3Q(K*Ni~@ORimSl5K%Z)Ct0{_KAA03mzqji9k} z4?3~0>?wP<%-!njV_&+UV7yGGekgO5b6We1pj%bH#z(z@4T+QBoGy}=ma=L(Cq9+E z!q|l}dLtXM?GF8hzcp3Ml{BUG6y8D%<!r4FGD)XPsrFT)X)cW>MAe;)N-vN>EGFm0 zCFLIN@f|3trbceLAS~>g`oOKu{=$aU!Ty=Qxllv}-1NmpCAk*%>y~AGarT4-x7d&* zj@#-l3gdkV&w?C&-rz92x|E4V@bk~z>0+C3)rD7J#zbeEMu+Up59%K@?@w2eA0I2n zYkPwG6-S3Ztz5MB5UC&;aZ6}^O?-L+ENQ7|;wIK$K-J~#=QKJ*3OYKRCp#>-RrFcs zmki8u%tqy`{i-aYU2cSa2I;%oLHloQUK7RNWhWjju`)x%Il%6LKwwyNtDJc?lPKMC zDBcYi)VQ!e@?_<)_&}<Lk*4FlLq9DHXY68m)JrrjvWd1UfV9@u)^;C<kch7%-SS6- zgx7YN__E%i((HLP*T9}imilth2biD!od&?mVta{j@~YATxH$D;m8+9(Zqp%(g}G~v zKW08MSn{>yG}GcFj4G8XhfCF8Yg>}IAT-u{WM@;f)34VR+YAxKO$ncs7e*gBL^dZ4 zsS*YzTHAecZE&dEQ%L#@d3|9;Q#K>|JR6M(*o!vS(3$fJJVpLijZqf<xXEWze7cq< z(Cp9TPtd11gaR(D=Z4QvnKWp=P_Dt9BAU-i;t0FD__Q>ZxJ!hV`Ob}HU~xX$8{^>H zD`oMs>@;4Fl@B@Y5n^&cOO5bHE{p!-eS(nnKvOq!gG^u{wfx(ymYTw)PLVm^g~9*0 z^@iM1AXD%{_y0XjNsQ52)4YN3u1%%(P7|4UUqwh@Cqgk`b4wfIYRBNG`~zq{NJN41 zT)1qAD&Vx)MZ+6rAfu;{lVEDNvb>O*!40bJ_##c|$(TAgT3l=MBh|USrv8ALx0fw| zk7-}~V|wrRqwLDX$*WY=)=BRnmWkh)nL~>?T#-A#7{$UO0(-@RLy{PH8$~atQ(5;! zP}UENZTNM?vC!T{w>F(LXZbVNGqokF8?H<N*6L5Db6Ws&5X)3&mwU;jF$}KYY$ElB zWLDDeohKQb%J-E8AEcBy1KnIKEYACU@0p<=W5?Ao)v-S0YwNJoDaz^mX}^eKKN3Od zcNpK7qIK84N7FOdu<*H0x+hP&T)Sob8ixvf@x{bSMYeFWAzm-_LYuMnUWt)}Qi3DF zany(PR{_<lwT$ytM|2JO=8JVGU<beae@bEu!)%jdPp9R(>R;3m#g3*IDa83g(C(yU zDbSGN<3*_B2*i+MP!SnX(csWdikFW}Ini!oWNBkhqh%4$$$}~JGl0ZVH!AeEjw{rF zc9WP%^Y~qIOU|E4Cis8zl`j4U{x$y3fgNcaCU+xL3^K3aq-1Vm!ja&p*Y`+b66oMN z!|{Eu-Lc`i27TeyWrw|~P}gP6@22*o*4sVS29i#)*GC)_ZK12Je_fj{U$OnBmF1Jb z<)1`B3;c=NtZSftEfTiTp4x_m`ISBZAtf^-ofRiKK+5o!7tULIa+IYcSx!McI5a2E z7O`-ORNu6Zi(~Ew!ER9x!p(Nd3;j-x?J|0wqqQq^GZ#b~=yXrtWb1x-z8&&(K+mB^ zJa}YzZr}TT<-osZV@XCLAhbmeH{WK#+mgN7;BrQwFyN!H74OAi;Pt3s=WDg(va9F0 z;WaowS8h^Q<vn*`g>xcmaczcW`^#^2{p+rYVlOb~Tdw1!<3TBzuNgp4JS0L&AxUaK z-`{bO*=bQQ`n8C2+vXB(wXiW!@6X~L*t%+3!4?Ldj9j~i{K${2n(J|X_p5YVMOkhi z#drVGbXc5Zm0C@8D>yXy5Ac9k)JD@9g}ftnpIXo|)CS>y4vDFzK{HW|qlurYyhcnM zbZWP1azW*rZ($5$r6yg$Gxbv_Y`_U2aVEL+(;no}alB+Ra2%aabYD9n?t>1i({pyc z2x;UR;+r42OP5OBaArezx>xO*c*#1Jsm3lgGINS%msW7QKqzmQs`-S+S}LpV<2AV} zDBed1c_^bI^N4)2>+@-?;*y}`JE3+V-v<Y;!vy)0<Bw<|8VR!PElqa!CsKL?p7<Ju z1*#07G9hOS>pOG0iYj3iJP-fbyMGu>>uT=A>>Wt{njBZpx#-OC{;ZeWzAd<#%TpzB z&0ixK$X<RHRT?p@B%blcjfEzRufw5nmE4WQL_;Xh%tSNfuljvt&N1)8hBzK?S^FA) z8<k3veq4w~Am6VaQhGfQ0wu%LAoLK1`|<vC`6J`hLeB#2mcpNfJFGQzFeti@RUuwn zmFLwCnY0rD28h`u2Cs0GIL$i8jB0LrR<NEeM+yEH-@dl|yNzB~lWDW45acBO<!QD1 zvNhWrv)s7-{WOU?!XT6O;iy#N*yN9ZMTlYQd(;d8lb<^*gxcmc<(`H%N1gT_L|?sB z=2XG?3o6O%goKbCNa5#&WFLi64Qa1iRy7}y#YJu!6`ksj6A#5U41&Fv#R|kAU_6R} zE>n|3Ss@KYX6P(43tC(>8zN|nDH>9txvYlF%vGaKAzO87Q&X!M)^_#6ENa*#V`FJg zPy2#$EZ>@woTbmMif#VWk%az6RQpyc2#7cBD~o5kZqJ5C28dNv5ivzs(aoXNRh^tB zR6`OYTN<TTd!?r4Ck86TKY$*HVz6ZX>#I0i#(w`($ZB%T!<W*FWUy~^cU8wyzxGFv zQpxzNH;me<!r$}Eyf4t-jW7}g%25+o@~&9^^+#ePBSZaQN`qh{DnW>q|LOh6Uu)ag zXH(p>?2^z|f_qezRP8?DBsg$f<ibTTMnNIV{)41@5A|zJjE4fx+$zp^8jQ1B;48{D z(U{@LpKk_O>WsU?(iW11TsB?<^V0wC<>#}CBM$~*$ufG8L$U3(_EwMYRgyWt(gY9{ z1M11Q5xpfu<NHnLq2J%I)Qvh7G&eI^7ZyHucQbzc>L*bCtvTw9zO)k|0N*f2Lpjw+ zcu_Em$77a;P<toE{`gSw`s8D608>9~^!(p`tS@$vy-sbhkp=aIh@3PLgaVn|4X42N zp+^;8N%T1bS+gL2Qzu(d94JiiiY}G3kPVHd>r?(*79{nDdgoRcx7s3_oOd(uwN<ta zNQ}I71+qeosMqXKennI>A(uoaZ}yj*0~3`wC(elT);}JPGn(xJ_fal8ViXiXVRrA) zPGi)hu?$9+>y}q=F`GWYJt86!jJH2TUP{-pL4S*wt9uKz_Ng>F|M<I+jl6uiCAqY) z)F^s8(#Cd}?X^Ez`d&fU7RR+W=<UVh8)0#{`@6fKiHi$0Ya3WZ?pCUBD3KVF91hjS zTl#Dk1FCh3xbrM=Y_ZiTWcV#{q=1WDsh})O%;3GJl{P^Sf0Nx%Q4%4rUE$@+*FFx_ zrXl&)2M4b+#8RW0-|IG{M?_=B(aFZWJ%0byc}13bJ^WBjECQGQ8|GK%BW!Bj>)X6$ z%LcNY2E3l7s9?MIf^4R9ZW8!nlr0)K&Qmnq9CLJ`>6-3V33`Pa4YebwnXCa{zv*VG zH#C}M7sfWEF4=DF6W@BfE;VhBwqd-lCvVSqTd&(BAd~c0r={#()bXS{WUspt`BpQb zh{k{SFR!2H&B>empE)gp^H;XWO65;9f&BAosq2?|Y<L#q-A`L(8RuVue1`(yl;ct7 zJI0;ZtCP9RM>{*8eBWXqfUo$C8QG_IAvkXhKVeTi<HHO%Pilg){O<Q{DsMDjxeE&) z1Oc)9D0`){ou|$N_Qv0R40$(8XYjW5x_jg?vQpqN5le3EQ>^=G1IEjgAtqXsf1T4% znKS-~{cs%UJA}2;lAlB0gHAu$NqQv0X=`am!!CFd{8XQ)A!+ejh-vNjJF0lhSg5RN zVYaip_%7E6_F~s(!>-+_j*|c^;*8afCRkd+WlRXzYk?m5hwJ4strmogwQ+#(^<E(2 zecTAIu4rZP51)iyPf6>An$dL^Z`&T?_pSmir*v(aODW*nd7xR{6*R`t%}<-TycX$4 zeIVn5R?waPT6@Hs2w`XdF5rj1U|2+jXZvM@+8nvc7FYE!-9-5Ud2?YdndG?T_eaA1 zR9j5Y04g$L@<s%Mw7vV8y|mo5T2ip;o4D!oZAs7iaS0|cU)f3XHla2RGfh*wErk1{ zUL*<SCd$lS>2`^k3rcPUje)%V`#9}Y_7A>yhwS?Tqo^`jQywelWmFx5MMEtKTX#!e z>?wf)0wKPsn&zzM!y0`_6@ol_6&%G(XHIIDE2y0BEUj&SBU4kyGBFzXy<oHGs{w?N z#P3F#81SN`TW>~0+bmW5MV7t?$6+wT-NYa4z8=f)YX|{neBC%);<an(mngd_p!WEg zcW-hE(f-wxFkl_G_SEU#A^O--KnxZ`Lm`BF7!tz#oXYcCg6ShZQmw<uzxoMA<GA@} z!|~_c^&}uz@=Fc0*R8fZktLIVYmSj%*aJe%^l}rTHzN#U+4n73)Wb~Xgu7~jQ6SFK zTV|Y`z<s>*1A(&%(|VWV;wa3=NUP@wVT{(9h8zNSx+fiZw>ICl23Vud^cV<M(zVLb zkfP?Phdl&-wV|^Ljps_2Q|;t{hFO39<2`5K2Oc`sdd(CG*z{hjpO9cOmmnY0`!nmC z7y`x_44sid)g^LcC@>ES8z8Uve9%@BI=Kq06i*<s7_8mK==n+57g%LnK5fgstoh~H z$NOp1u*7m)y3_dmy485bvz~ywL^VVBfZ2|}HSH5~(I=YdpTu#RJ2A2P6X)v+?rHff zyuoMZcwKFc8Qtjg9i0eb<<Iq8_o2#0IRx)1A41BOnva4?s;PJyJ=Rc9k8pmArY(G~ zIg2*JdAMDlSU<1-4!R~NE&RpU12o+Sb*KWhf9FrKcTqS>9vcxXdS0!BnfzYHKq(qV zBZUv%Ht{imEDOZE^BlKGYTNtXt$}Z_O#*=vvp(9qy%)AqV*32n>5nz2{9Ab0lDEhf zwi{#tXY-G&$W9EyQWe55e^o$mPNEZ`w$o;a*C)F+P+mozE_dS<Gpw^xS}%-5-1&{q zov=-kZiC>ycCPwrATnIOi1(HBeJgX_=GR^XQ29_}X}L|)Pmhm!GD+W!-~$2%Q1;ez zj*XBZhVX+G>^2oGhLu>%b;cp>$C#jUxmst1x!3q6xM12MrcZ6KsYp`&AI&j*Rh`3> zCEN~8h7Oh%SpD)J+n*Z9Mg7dC-4dF2uCrkL{VdR76O4m-I=$kh*Av~=_#mi?taX23 z<skvy%YsoWJ9uk{)Yd$n!Nff^r`=LizL8NfIs7_kZq`#t#-$^Kgvk}Cw(o~MSJTx^ zL=a$cLoBxqE|QL6%B+P(8d)X~B=@hf?G}%lk^14l^aIF7ggWDPk$>gWYswB$s5vcd zK5I1|$9Yjn-hHD~n;_tz^jn{k2V2Lx_x}O724!MyvZ(=c^qY`m9*6xeYSU);EgDC9 z9daByMjHAi5Zo+`pwl)FeV4rvl{tLP?dp#i`5t}`+3lPMQMDGaiUBfcu#GO&W)%;! zlfPZb?l&BrgOBfnq4)Q9@qz~4{h99lqiK?hv_GC!-?{}PVPm#EpQ2pBu#hArgAu2S z#*2v=K82~fZQ=dkCKjq`rKb2UbkG@ySdlAmTbVdyn&O)hoJY^r%`Yo*FCVd>`I}!h z*QLq5h7Bw5@Nralwae^BrYv>mqc`l(bG=CPMsV39+qamwNW)IA1OB`b9`_tyHd!Z( zUKw9JhzeOL+%-C8{Ie4r5;paQ@Wxw;aa->uSPTUcdTwx!qoApKGZOAkYJr_uP#ksG zy>dhOax=o#B8qr~z&uZmt{@Uxvag8D?3V7QreS0R(i!&(?Qa2yl;}U%t@+_4sNTBx zn*Z{0^5n1OtvxbL<`UFfAPO0rkz;7dc<-Ck#FKqa(&n&I6Pirx8$wS-2r-F?TdrUc zRLYESrTY7J%07U*_~Rl!Eec8s+S@=zYQDjV*wh?Ku!aT|*A{WJ_$$fiVx;a5sg9<D zln9BaZ%GQn<{t-5V86>-e&xiBoGvm|VzgaPGO@AzI*hwO=g&^g_AeR#TOxe1=Ci*L zk}=MfHDBA2cGcl@a&Bf9lA%<hHS^~J^Q#~KTcf}bx!2H*ZDG!;)4GtEc>v4%Nt`d6 z9q0bqe!+_ooAzSGuZA<WBvm#2#2ibdtx`KNTnch}tFFoT7g5ygi?q?MTD&q<aqH&w zHQn`E)6Hf!k*hh4v6=UHW!FJy@d2@5PJ)P<_uHlq2w5rxtBv;IAv2J9;#uMX*^Y|> z83UO6wIS5gjIhG?q?u}8V6&p6{QgLtBZNR%-pEb8myOHlM)07brizpa1a<o5aC?5b zuuHzMt!D@XC)VjiLhXUs)`EM1IB7yK%}Mf};?2^3a84B>RYm5i{=FBNn8?p*$i`U? zR8H*VsJUvN<My>Mx}p&c^3ILSe7Ya(sed}c0_`71IG|o`%-A64NV!kT0KymE$%;lp z5qEA=8%#6D7_)5hjx--d?A%M4x9$Va1J(YQh*;!VIqmk0jYQ2cFO9mMV5iNmWeyG} z?bQ1MxecXu-tYfKKCl~FeK*4K6rXSgmBm{Ga>I`dRZ;oeYII33edbg(;SZZFZK(Jt z<16+=ytd7SvkoHJ^k9b4_9NH?sR9_a^(0$6)qDy#<A(Efd15-b0mduxnAQ*tpVpKd zKbTtNLH76N7-NgTM3jXI0a)Ut@?u3Z_It`IQ)!Zr+0y7N>3pV~D#maQsHX5E3JdhS z2Z2dRbtI*v%Z%;yYcn9o^?EV0gbA0=90@yw%%KdblHM@fNqha~Z}VT-RLG8Mj!`uV zOq3}x8$GNf^BKCX+w4PB(5y?cx8$yOGl)OCGqeiPaC(21hIJOm9ZBl`QBQ%Px^uYJ zn}}5rmK{ViwFhLhk3mQkEPXw}W#os=q!TDw2rchvOf{*BZ`PY_4m_mvWJ{_$83SIL zoK)=lbJ&HUn9!X5a(5fJMpl`NWn<#?=+IjA4WOT?g^zT`ut|=)>0Hxw$qCVbhZqtJ zwt<KWVV_RCff*H%;=D{fkf*Fm6Kr1H`i3RBdgrK!?XxoEYq`SRV4*?ZP(w8F^815A z{WG6_2__y{_RFW{C4qNLixbUlkKs)Cn;&CnR{bNb2hQBEo>uh~_OpN^fhu^D$>;LP zk#b7SoGwcVDKG@A81qx@^m?Yek4U@h-Kw7#vAMm_K2}89H%F}eA5c5pD&c*3`ONam zc#4?`_JkB%5%OPOfmYatDX4x&4OHmm8afRI(XO8F75v7nArAvp^vADD(zQw7H0M?n zyiFL2Aa7Hb?3oDk1!6x=kZX9aVA|rBT>!=nUv6)LaSA+pH&_t7-_n;^sq=Gs{Hv0z z%4)lvE%l}%oA;Lmmfs$*w82O;&j(JJ<pk-CdOL`|5LIk9mUyOi69_dd=w>jJ5F9^@ zU=wHe0+0kwF=f?GL}20OKUDI1xa#4%v4q)tan#9l=?WWWgBsfz(DpvtYpFM~>`M%P zM+PJDjHdH?uDc3bgrWQm{(3>uela_H^A$j<k3cDC_Ea%Ib!*uRtd+sP9#Ke#YnKV& zkkQOlR5eDctzA+bfGwOj*3>P*=Um@`5S2M+odXjP^$JoE=j*Z?%3q?gNYCDnlL{<Q zD&s(coave-M8vM+U5ftmJktdyxO@uJn+gEtr2>@$IPtA`_X<*iH>A%RqiijbyzPQ? zsWu`G8Qd!ZoE<x08_Ga##fb|N>uSlHpVDqC*fpkVMKeqd(|}$^c9B=u=}wTiQEsz> z$&H3*;+|VJ$cx5P{0c!q*024CLIYeAU^1lq)mocfZ$_V#a08de5NiB`F&`fh!yg@5 z!8%;^4Y;HAE?;96iud^rUe#jpZ7!}Ov9t4S#SuvEk#I3ZFR$;gdKF3TWVT%J+2rQ; zw0lY&t|gmyXI`|Ks<O5)W5Q8d=d;G*{?oP38Vj5(4#AJLNqy^87#vI;H(AEkHoI^g z{$u649I>+2tujo={PO;*f_&B(KWY|s_(m?;WPC2&x|k<=UNRnjjRK7+xr|b`+1zV$ zP26rAI5e~D6ERe(kYy%u<$R#*8^bwYU|47nkNFDw>JlJSd$c_Z3c?2Jy@l<V7qAWi zO&OPrj9Mv%8mppbp+WcB7s>f3cmcL=xb#vHhOz9P4pU+GB!ZAWlpg8UD<5Cshy1Ce zd^Nb9XG1vtY?ZU-?_x{{;fUKmgf7f!3Kwzy1j&Vxa2ke+;jWqyV`Fep$BD&I3Uj%V z;0{p>abZZXoASUR#EHaH#-Z`WiD29w#*5ya2Za<7T;>NEh%_~xTqWPZbQ^9)YeD?k z7T#;~9lHfncjE@^CzldqyF`N7i-Py9TordqYnIIaG%&#S`&mTPj(J3ksFMgb>X|sm zge*|w0ZhSOS?i7NcJ*D*IL7r+Rxr|qAE^t~hL4$>(Rg%4v8z0_*6A%ZQ-&^;va}hH z)Z!H>w1lr#ewPcw%C*2SMarG(&5hM2`$2z*SPk|OQKhV?64u~>2@9}CH+%c5jA`o~ z!3Ji(8OA%k$=z6Xej?#M`Ths)KM74IKTQ2Q`2>T<=kfZ@XW6OX-|BAFqm*0G`*s+C zDO43?aTS8XIZgq1Iu>o5en;l`gth%qY94k6mNuj>>{X`Y$Q{jV0Otwk2e!3hx&Od6 zN}<>|1uEd<5>lLKPuFB#sO3wGE#sQ(p~7V~elWV*rFXr`sLSrjAsV(?hJ6rgtsXxw zkzfjy+4OQgoY>3F*LVw4+B36m`fw{B3V}AqIq`g<(ir@=OS9ZOwyCYDX=jWF$I2M9 zJgoC{*?u1ziU{5y#K{@m0@>=K|9<(<W%&~}BS<BkL^Q}Mfa$oVDnb|prK)Oh>Jmxr znyL{lpT|!4x_c5$R|l?l%al3&*xAj<^VRiVb&Z+R<4&;x2c3DK2K7t#b9AseAl+i& z$n7ql3ko!3yW|e=)L)Io-FUC_^^`)_j=H0bRAjxYtyU(RKOtwv4!r>^)oi4BdD|e0 z5Xie9b*02WNX)yj-m=x%pB##$Pkag}9S{x%J}Tr*4^>QPw>hY6Q+0MFhq$03wb3K3 z%yaT3SE!qFZlE|E-Q42jxZUp@*FFZ=BPdZp6?07Ccq+A=_kQHD_D20c2II)<aXD1J zIeZCP{OaJ)a4c?Mc%<zP+e*!2=wuE^mPQ2RBoV)DlBOT|_9aGdv<wMKk{a2T<B_t^ zfi;perP&jm2JlK7Gn+Xr@ibn96bNL282m0hp6<*E7@Aq2M(-?hldZ?vPrwFVb;KpP zy!vTRoHgxo*42a$+IEoOEOW)Z{&Yx6yv0h+pzqz>8-1)I4bhh<FKJls^RBz}aQi49 zgte<`L-hOEsGan~pQ=tqcpKJd-JY2L)&dCn!zga^r%Vk-`cpjd*2R5u%~Vzp0c?YI z453WQ=Zi|uf#0C8RTzpw)OVv#TYIbguy6nrJJ~6EhsO<q;yTZ{xwR;7xNBP`Vjtwt zg<Tq+^4bux+++i*d26zg)4S~E##3jjID+31Pu7#`F-fOGy1SI65e{T`aSuJc#*sN{ z;6#CGLi+}}%jQw<`xWd34-^HucAHDzZ6l?97%M(t$1^p7n0%CVwSQbJxO&$38Kl_D zTqQq$*O%OZ%LvrcqtLKuG<f)jX}!oD9Y`Yk0Va+8OA$ml1)$uh-|a9W15j7n%;g^a z34c-Gae$zlj=S8+?T1rU6PyLI?;fH;G`xVx!8=IeZrvil{0P*HbZ>eD3YW8H)++3v z_dnzq2c?*C+~Cd6TTc&H!%#54j<d^thDVinKcM^Jp>gEhH>Vz$*>n6y@@$gZcp=YV zI7dT&f%!(8f75dYU!E3%u>>|vV&BXRZ-n`NoN*mo3nL{(rz8)(haKN<<KXcxmqtTV z!$g#uwng@%P_N1U^|U|US2{_=uw({}vvfPA!~|jSKQw+j{DzLXwiUg64j1$XHc_&{ zk_>yN5-gaD6MVQ3pntQh2gIIXxeY(c-@UVBWJ}{D!#9x#=BU)`asr{3l;5NfSTXj{ z7%@nwak0h8zq}HMyN$ujhfyGO#$Hm=e|d$vPU5`#S2(-vXNCQ!D49Q}zUN)4uP+Mb zrGcwl56Mf};4acMXTh1u4<ej~lLyJGDF(}WQ~v!~7x3X{)cZ-?Nk`V#l^C5E0UwGn zIzRMcV4LGpB}n#rnfnCP;fJ>Uc<@;*&@^cJgn*`c?m8xZ`c*b+OK?x_57+%hw;Bb_ zMAIP(2!3=&_uA=_T9+pyRWKDZ8cvq}-Umejo8f=eZ9``C;<&4LWANvr4Pl2e#Q!5_ z3Abbbg`0qE7KPlq2kcltR<N)=UXK-oPqVr-34wi=Xou1I*<zJp_&Wc2*iF}N#6|N^ zp<JYc+eN?E`i3N1x_&YA+s0Ew!d)k0<)<WO9Gp0=EIhVcpuX5O4=ViUQ|y08-6MYl zu}%=apskvb+w_ZVwXsA3Qy=@?D6yn|g!Q>VX%SYZ=!El-tWBr|Ndzht&W7u>5r6(I zE_dlDzS?+JOseJNSsorA;ap=y42WT3Q%hyrB|jAq@n1r3SO(X{4;xY<2qdwo<`|Q< zte|>>D9%@Dq&Gg_-&$+=v>tGaKee5la5Xsuuj(c^tEtwRY?7y+U4WyFCqNCL_*y$X z*0OF*smvLDWH{hp_HjEh1~G8~Q2$%w7k&#}&oYOAXnRp|=sSzTeg~-=39bHcy<o~; zNaM{UUEh`(&~O;v%V1=)x#LGO2A(KDffUcOWWh|=0XjHUx0ja%I$8~ICnnmpP$P?! zSRi1ll6*J%bCzyHIJ5G`jf}Sah3zPBY48j4AONyOBIjNX#<D*Il8VO=e{4u=yuwX% zEDNAcY2DZl{#uaK|4<svb8*ddtzl&EK6puQc4!mM=|ECBssXN}0Z1g*Q3JJfe)$|G zVt$Q4(r9ZcTYlprK?pI|6{)YwS&}5wjxUf>YNogqWr-y88S5U73PVmJX#_%61$&)v zxtvOzZ~_*zx{8x7hq@)0q4jEHpB&35$E;uO<|$1YBq9T1a=`^gEvM7*>&eLhc%isv zFa?2W0nclI=U?lXOP2^4O>#8oX*fe^Hc?o<U%g?5j!FUZfTq)NIXOTth?7Sl|1(Vf zPGy7&m~SVV2{OgEb<9?timaZj`vQu~Rprgqz{s`$VrmG_`nL|-o!7c$ju{->xuySI z$iT_xSQ=-;DXHHGBU@M{f|VuS)1bX#1qKr7=8~d`vrB~^Yrbpe+b;~oWbC(QI5lJ0 zwwq-C`^T=QCw(HMdN}xRD0GMcox$XZQqhXU?Mg_f?DrkP@wG~{a2VIGe?8t~Wi(mL z9lZB;706FqzQAho^{ftiI-!3RHu*DOud<bg;)F&lKuSFKZ7=$XFS0C_#OXV1YOip7 z>X_42(CKLq1skQ{rvM?id@iFJc+ZD#2yX+Z1XF0&yNdLysyJ^wpnle)y|S%;>6X^w zJ|76lOoU~jBJh!`A_)(|1)zR8AwdF&i7pG?NAZA-4(V~YuC4(A(<0G@nfoEoKC4Js zOyt=io*?XwJw8=OQxlP%h5i%!Yfcu*qn9X?k1+`RJM>|T3yuqJ@+W72LeG1|I}9OC z=TW{NQ3!<v?1xW7?}>PI+fL7H+hgO3Trh(ySf|6{(=YS?q48m7Aut4v!Q;{gEM$y` zL}z_{PaO+KiSz#(V~}JKu!OCQ%+Px=(bBppu7=8Xo=5*Iq<~W?PAAfd=78NB1Z>g} zN$cOak%EYz@;I5(4PLg27H|HSR{aPg_=F`}u&09fb2ceGc@@T>cve}V^Di1}7R<o$ zLJQzL6#!_j`6?YNwq}B~@)t~b<IfxuCbYw2Lqd>i8eexA*snMx>cg5HZe5ZIA>biw zzxI|w|ICoYRA#^dCi7(tn({Zq;Rv;*m2^Bb$$+H*in$TRQvAI#qB##Z0Jos!c-w<} zIe*N!RLdDZ4!mo|-?Jf_Ys3o-nGNqP4?|xnRSNvBl`7j?E||g@OXa)08M$N>h7uW8 zS8iT7TR=(*aF~4wbRcHDRQ$c{FYOh2S!_VQ<`)^dy3W))V*oMX(Eu+??vuD$t*stu z2PF=QjoCw`YZ?Xgs@;29y@G+G#c(=uQuwknr%#*nGvSx{S7(kmFlB+`^3R&(pIFib zvF&L3rB=zJhSK=?uF(0_0Z8^xsx^$J(#ltS?Ni*L!~(4|A%xbs@$u%2N!(v$+O1dh z?HBr{IslY02eIJQ^SPp^^#heLQ8OGNm_ufBap&3|c+T)L>KztghnyoV0<1Gl<~qd$ z<|;*Mu*m$QxiTS`4mY?KNe1tit((rtb6`kPcmQ%zs_SnuJqL+z01>Q$zd0{iVqoVt zAu*!Z&gYJz)@|=_(k!vsT{=H>VD|}Nj^lt;l&dYx+f{Wi(%_`m1^8%RH6R?H8wHxt z_8lFqB+F)y17WcPRd;Q9)#X303<J&3?WMh8G^xs<+=@K<zQg>;Je<>xw51mNh-OT+ zJ79?7<$jhjz6cE#Zj%xDVe+09YC7ZJf#@u+6AOH56xiXo6pM>wsg@D%>*`7!zzE|< zXKt9BA8V#}cn(DEP3=;b#c|PKV-9A0N_zC64mUiuHy!76apl_rl>pidhWpM9C2-I9 zr?8ysBk#O+My*uhR4%NFKRwT~d9zMgmLcR>&x5<ao^r%x^=A?jV~E5&J-gI!DNxVP zRoy>|B%o{|!y~jM6Vc1XtQRN`u5KXT>b{v&PLX@scWAqKmZK2=ziU%3$5_<=u1)ii z1W;su!kHT^9sd0%2WUvpuyHp~1HRUbdr%<7BJ>^FD8??(&}6>fs#UA83#LFjLEDA% zGG9W(SqGBBjKAC4vM3IdIKDH<D3WXiR_kBYXAv~W!f#Hi=^BogL`@8yb4N(W>9>6R z7B8mSQWXVUu4o*};S;WvNyQc=t-6Yk3)*6?(YbObgC;3slDZY?v*BYfV>1bdEjZ6f zPJC&D*%5CQL*<K7(HccAPy0f2qvf{Gbjk#pfpl^H8;Am})__z_sb&Am6MmN*kqk|1 zQB(Q7M=onm0wIVwo)_3TM6o&FwYJrO?G1loU<EWQ{?-y49-nw5$eNF}pI6b-3(CQQ zS|4Zwuw&te|D=$G_9F@FVoD%S2;m$D6Kd0vzhoUir?H8!i}wOo^$CQ!<zs1CriRya za?;uL6|Od6NPx;D7<1k+p25-@U01My&O8&9J=o)|Ufzm#0}0d#$IC>`d(J^dFO1<c z5G|I|fC3b6qI)>wZ4fWFUBd+DUyDGq{_SyIJHg}}0Bls)i!ve$isl6%y%(B5(di`v zU+<<jWTs;*(*W)OmahvlXCv<uwOup?(qx5HOYl%*;cR(rS!t>5`0&<uxXFzlV2{gI zu6=DqC*VLr=PEOB?E=yIv)(honq+$}54U}#0%GBMkyiXV{x|RU`JZkuR$GV$zPu~O zfpWgYb9JH)bKU3};8i9sQ%y7Q<rX-os}JXgnGe)GkXKrtJQ)D-WV1}MIhdsKMIIQ? z*b`uW9^<;s0x(pSKbrCJlz`q*8%67m6zL4ufOI^BG=b>92q-hJi)}d0Oajd?&x)|@ z1i84jSkLMV@}fg(h<gMO(4dyqOXfLdn1JVEYQJc`_SqNKWkF@X=-1xu7aN)ZoXbHj zYj3a2tvia#H-aObaaq$>Y-faET9J%zh5ses!^XoRguE)_J>hGU5DzAM^`TmlFVx6I zO(r=c2`GO&%6LVczoezU0-&jq^S3?2D%a$b9KHKH*A)ie8~#&XaVG6A`)R+Lx#BS= zFfm(^<iAs*+lbz|)(4eyf`QsKV`cFVcdb7=6zh=vCj+T#9JtbYX_eTGhL)5NV)kz~ zx*`=V+wv#Y(IamkEqrJRz=IHKn+=NSCC7#^9Y6iH;wpUjA}xKcE`W<$TNZ#=A~}n^ zeck#NZbF<it6~|xH#R+v?=DYi?bugyv^X=1#BcDQdP3)Wa7*yG=%JtSv=3G$C;JD~ z;SjYl>!2Pw^IeYpE))lj7E>9nFR7t62#$t7u@dVwlxEcDP;=JN#N)=JE59X3sKiis z23+dD3lI~hr0)#=Dj}!rUM=Aj5YvhxS1`4=wH;ac)P#hazqOYk=^nk+wfR4zMzY@Z zp;<H><vrgQ+~^o7^Ids9a|4q90=1AMsAT`&K`qLb9qiFIB-cUKFsZnOy@hQgnm>QU z&ynQfdQNU-GpPb~?<r(e#QOPRXDzGEKOc)viWua=i$U!17IzHXb8M{*XFC$(7B&Nt z-n(pHF6t!4{@xa4t$JviYyYo6BhYyMBo#AiUy+F@{LyZZY|Gakj|~Bn>Yp>rOp>N0 zCt1_ICmV!-jzlIE`$SCsPWaGd`wyxdd1yAI>Gtfo#eNTvu$XmYq9uk;=P8ZLg2BIm z@|f#0u=+o;rxD@;K_b<qc@}@D2~4S8wt#NFc6QdEwT_Ob(;mNmd{LT>Gu|>DyV?mx zL_!FSy~b|*6bjR;{q@YYxxzt9=nsYNvv`0*UDcj&R@}0E5AL@2`j=zHO2!(H*EZf) z3hm$%az}{Qe~SMv8nq8U+HO!@9Uy9_8TLxt^fz!U{-jc=&I-F`$W-;otFrvo`Le2- z@<nlaxLGiv6!5_kxdDNbwva>yUX3ij%n-0uO(!D<(3u)pQ|CzcFn&vQv=LdfM(!-Y z@4o}e{K@IrBoLDz287cV<G@rST)X4E>zG$Y@7oYL@HW=^C@rqn>VgF-uc!r^K=TLX z4Tn5T5C10AF35$pNS54K+RP;cT3Z;IjpC@2#drWnbsNLJ{Ae!#xHP?J#m9;_``m-1 zeb~Lxx&T2!#M%&Ge>I}CZJ-ET=V1_+{OXe_b5#VSw6>P^?Bk~K2_mR0g@Q!>xSieg znUS4q<CPr-6C0|c)4ByqT|_!EI9A@bsCK8*@TxE75TW0R(hKvouZ!K^prZpot)2ro zeK}CR-L}OM2QmcyGSbk|l+=I26JH1nwz|3gZ`1x0iQ2BpYBwV-HR_iCYW-o&>c;)7 zo=yj1&b>#ByC=IyA>2bo2-pdjH_k?PAx*Mhh!?0p<iVzpd9+Y4k(}F@n$`Dq!jkkS ze_`X*82tRMb}H_QK^%Wg0yU%nEpvsy;M*$UGU8b3lhg9NkeRBMBpz3VClT4d<gttg z9MFdhSEs0?BF1&1w0Aza6^2|KUKRlGW`FdrxT5nZ(srCtgqq=Jd)o_%K=;KKut`Mr z%yM7b`&W5ZxUQ-r^u1x}h-tfJj)oAh>iCg5?uW%tS;Y<j&J#hRCplg6h^B;w)_>q} z<v0E-cVv|sgw65Y=;k&ty%~@uM)CvrOG=B`K=g20av1Bm6?I-kpDCJh(8HK#xAlBx z<N<luZokusRVu<H18Zm7OCFU5a83~rl(=R4i7Zh~|7|n2{Ct*%qB5?;18nH)OjVN2 zL4()r_n(4JmWggq0(*=D`U?T+)s=f9Ak}8{rltY28BwBhyr!b1R|XO?^9FO^N?_IL z>NMKr9zhMh?3t_{qznB4H$lBEjRvZsjm<yqv1wWMX=-_d{c8S?QS+OoEMV0>B5eB4 zve@5vwJ+)bmmP3W*YZE4w&3pEm>2rqDKITH0<B_@!K3+rUafHSU-p5K5do9_S_{_? zBW~N@an0FiPw8pPe+_m#zp3p7`&+J_&m*fO8)KRU61*>|sEBA^>Cy$nf>3&{n_%ua z9wF`G>p33%#XSj7`FrUbXY8V&@RvpaZxp3?CvNPLzh<Ki<1Nyd$p|zxX8d*-Vw)L^ z6zvy`szQO~JLk+>yiCsOp_bqb<IiQwM00<QF_xkdD|B#L^v;ZX-DwVkOhlt;K=9In z({naV{CC1)p233n`o97J$X}ycQP<RHsH3ChH?Gn`hq4OjFw3dqP+n3x>%C(1a<*^P z$SR96F}FW%4BrDsG~D&!0_@ViDEmoNwgBDlPSWN6nn{xUso{Ml5XOVo(PD}H(Eeu} z2Tp&^3atO(CUD|p0~X9o0dc->J0j&beEJ9q@z|guDFK;5iz3sdSN{*rldR)`N(H+U zFin=E8aljOZqD>o`bXgvL_M_OMzxfLSTmAsLypAoKd6Z%`u~HP$kCTmS6{sxDr5ap zF>%tt&v8#pj+i_ybkw|-F8aI=ME2M@_tzp%{ReD5H@RLe0Lc)YY#?&F?fU%2&7pa- z6(AX2Vn6Ruom#t~-C`8Hml6{EKk+|5Y;9$ScX_tn;mhstTn3HX-Gt@w2<nLt;h$e- ziQe^3-pQahz0E7v5_&FTYH;NjfQf`$8*#q#G&iSzRPuN*EeZi+%u{xKdy&MOc56uK zh4ClAQpwBHd#gwr{N#FiFnS!~#sHO0=-4m@rr&=~YrOmN!<oq7uP>s<v1Lu)b}?`A z&GmJ0(MGS8$q_nXXy{6P{)SPff23(@7#K?U3^k=XQ~Fe{V<Dp_%U}E2OiHy}UXdIs zG%hIkh8_Hs<v*m&v>8BX*L7ViZ9n#H{Q9#XOWSUpLqG<CqULKS63f~OvUQ<@fC%HW zv{>+3G`u<5$b)-q4Pn4RT2IDxlQ&9c-If;5pe@hjo*&TA0xTb`*2|>=?jM;40Qb@- zSU<o3L<r`JwL@S2Fz{O^aR0r3!$g`7Atc^14<F;FM}tDo=bCSLmC^N)n?&HAS(fsp z-k)zJnZPEHu=K>UjbsOZ%cWF+LHrE#J@k>m^F~IvHnplMf`G`i*J*s;(PmW}X42*R zB5|P{!|GYj)~q`bdJj;QA;`1T^S@NO#sPA~i4a_!OX2BwlzUr^Rc2)KhN!LvD#7Gu z0+HdMQ@*nS;G`aevQGQ?;&qE6*KA1(z?pj``|yDQG3%ecXEXSiqk-{(SM1J)X|Yk; zk{|^c48KyP($!=kA~J%B*dK}2BeN-F?nY&k%=0i2{EX*D7D5C>;2ul+pXi`+gxXHV zm^VE37&}>w7l%Oj1nU;d%(ArQ3-1fiTI-oSK4Mm2NR*}g3lbZuEC(d_m&HsB8iWvJ z$DaQ0U46A|q9X-nMg;HAeJ(3-QOjP|phGmlpJHDCy@<ZQ3NsHRJhcXB)G$C$Aq6@6 zW9Z13si6@8o&MAAK@ux{DzK~UhYFstXvnntWI97u3pyrSw-?j^ws{(2xUC}Z?0d8{ ze!gL724GD%uJ$$zZ(j)|CDA1Npy(57S9c?K2UhYrc#TRh{a~&-r%sG}vpDHeSSwrx ziCvy;S=IgmT=>!Pw(Ds`_GQ}_I4?{2+{}lbJH};{lPE(7@rscjBKvin%0)bnM(DID z`3zxr_tJge>$Nx;v=A@{kf(E2-`|9Wfc+qbpOk@{LMRnSB0V%fi4gVekafE!V4%j` z>d~J+QPq+_6!*$_^WZ<)b3l#lP6)w^kuO+Q{(Jw~Lk>7#<9W?Z)%@}Uz)>l)-*I=( z&W`0k0gd@bITrd58Zz4pG0dcvTYkRA%KQi_gPe&R>NVEc0|mO2q6ZJ_FD!l0=;oMk zhI0<+dp*@u=tF<$7+n$IKQDL3(Bf`1MZGuG1-q#9w}MvP6j)i7gv)x0&8${B!jA`3 zh@8*mjWG@=P~avDNQrN(U(Qm+2MiwxA%CgEnf$JMOZF(|OAe}Yk60pi?8FzIp%0eR z&C;MJ0_JPs@=5lGzkiU{Hh)(7*45j{=OYtPf}m$Hp7%;$Ebemr03SR%RRTcC+A0CY z(t_$I18RfgFuA`wEK_ke%^|Zl5X0|@y)&YRnIwf)z)qpcf;4VT{w4$uNS50{pI?;# zeEFoG0y1kxT<@G3p|**6AU7ed=ylI(Dzu8Dj86^=Q`pKIY$6T#>a)OCD$>79UBLFm zZgr;UoYNGls&}6RF-jEFf81KAe7K^UQ%sE&5=7Mv>FtDvBcuKUpEuiiI6@x|hvoZ; zOe`G5A)sl%%%Kp)*ZCw;$mVW(QCsY-)zo*PV~Tg%l^GiYoPv9&GMM>O_IFQ@YP++a zOGw9U96$7M3Gl_MxV7`Je=D*sdv0m2!F3Ffdgn7bc)+ci=X@pLamvv&#{q+&P|TtB zZAc%Ukk9MgPBw_%9f!US#?#AkrV1}x^cImY#u1aqLf8Y?@BdvWU<SYiQMb}%Aa2zj zv^(2Sh@;|5p@eO?4<5RrQH#mBy2c2J#|h1g*4UBx+`AkFQ%IB9rYl#F1$`Y6@t;Od zC}YrU5);c?9Mb^dI8sQ#<9}qaXqdu{ZgTVe|B!$+&D|R=ZS`yfUZTu({5?mEZ&$^S zm6}HGT}a)XZM}*p*kxwf64LkG2sqiFhz^yW8)f_FqwiyNnn9QKW#h-e0q6_C-hZ-E z=HArPZq$Osi8!36l0cBir4)AOZ4A{v@mGWHUMIrA6ahl?o|D0-2pG>S0KtPPLO9LE zEqVj{RPy@G0~&}kjG{zc-ay1r4~wjte*ep;xMs_KFRyB5=7|!E?mUqjhm%<t(vR=d zEE9ieM?*9i&5YdQR2l9T$)_LR2cYCtY~Kw3m1T1YtK0K*^Y_1cxk{*XLoZwMa;s9* z#@AI~{V>KVgHK59!UR<2BU|vVtfOO{oSx`nf|09tGB6^rQrnU&6M0qzdgr%$DHT$S z$80RsU8{lhumn)F4{|^QzhCPL0q-K3lk%8;j7Nt3&`|i*&|$n@)_6D%Ncze95f0cJ zmpe?-%Ic~j@Q9Gc!H<rCfDkBO^^#k(xI=Tg2LK5^;`kNpB<27~Mj!!smj0z6VJbZ; zJ#dmZCDOoRp3ji~(_Jc76NYkd43ASQTz*d4BM|fpy0cw(WcA%RFmVdtYPn?>VF0t= zCH%Y<xzqrG5a=^XKTlt{!O(BCfCwqsT7I2)scGNz><3~2bfa)0i!<Cb#6V8MLtqoS zeK1Ks)@c`t0&ZwHtvQD(wLxI~Cs(r5^`?ot#Irb4fd|$_zpE#LkO{%IE803u1AbK0 zpXotm#ef3M$nIwU6*>nR3nCoCs=lD_*xDL!L;$*?PjoXZ5HKi~J1hXAqUUBGoxuz5 zt_<kJ6*ca*Uz<+nXuJcsQ<{xTt~;BjoD9h_TSO+{R!Xqp1aO!|YQH(WAOt(bXg4sc z@n23_zzdPOu@oGq(CNKRT;+E8d96?~J6qFQEUxtmyf2u^?QjTUh5`by_RCAq1+NaI zPv*sv+g;*#fJz9UoF%(Dn`pU@w|J7|4+SqE&z6&oYrr%!RU2BSouoDk$k;~LeAb)+ z34`K`lKqXIZ#K^51%Si=!iI%x`i=?4vQGJW5k2me*APhGw_;73$x8d`s)$POXGf#v zFQFom>t{omwSXO>GabaC+Ts0E!v!Sp%l()3t)DM5P&sG)%3vV@_#Qk!a&e>j`n4p= zwQ%h_G0o}vgtRlDrTm2VJ=56T{Y&0G*HY6>ls5Fe2FeOT@R<bA8o<(wYc}o<Q0`&0 zbH<YrWp({k(e>42C&aTVq@HWYwXBamj0JIPS;-FwtIp4liItjIT97`}@Hy-5FQ782 zx{W)pV3cdxIRt=ja$-E(*1qg|I{4C|yq}{n2}<7IFD(|@&8XpT*TENZ*LXeS@R=nq zL?d?5@v*h5y)B$@VWZ14R%F^k&qMCSD)BI=fX7|q=QBR2j1R|M!wXcVTJ>V!(Smw5 z;2-O<?(pCI$Z!Cv`$KrT(SGnno~KUUImiB39e3st0KYdw=GKZA*UXJH1YXox^B(4X znH7dPW+o82;NGzN%7brPDcb+71$feB2nD}ft%SMK+JyPNqzjQt2SqOuI~c2ON^~<} zyuq8D-*4V_CUC>KOX(>re>zseJS}W*gxQK^^{`vh5C9iIU6h<>`-+nK_A>jrV;!b5 zB3MecUrPcGi2ipfa_p$GV*lA@7|=P=`{b9H-0#XW)XCFUsg{?AYY`dP0v5-bcuTXe zmQ-I8f(uyd9gPe$uA-DWuL0%tqzs_on@g0pOq4RTO9;|?tbLK$*eLZ)SFKz_hh?lc zpzT#`k7)3M7gM>JuCZ9S&%a8_z4a(}IkY1Dpu50DqTu7>V>skHIi?fPvK2MlSM{6s z%YxU(e|WQfcM3MdS9?UuW$B2wcX0fpgm^u6$ArBTQu*zaW~_i}nzQcZE&$}LbG8HB znn^Wa=M%I(Zk~Z}aN{2ibGV^Va^e<C+2WV!Nl0VOPcFu)T;2DC&)aJi=>m3lUW4s_ zgf81?DYlQD;joqn++`NnndXpcdEqEB$J7s3TD<!Kn7)XtS@0<Oj?OWv)|VPr=&qfa zY*KR1aR1Fc=4h%wfxsKx0dJ*`wES=aJ`2?EZf#Kz=953SAQEMESRaQFbsUmRhM9I^ z1R@E^4aA5b#maVuPzsBOPzFmOQ2mnxq(KzqlYy7-q~HKe6%xR@!Q)#x%zRigGSXND z1BslcSk6bHR~i!&sJr3}8zO^{=)-}VK;u_tn6UQ}hW65Q|L0Ahw|mSB?({*J*x#Nz z+PJW4^B6ClVQr0qD`<gmMg#=dR9XSw!qMd*K@`JOzoe06GF428Gs(R>U%ye2MWBzs z{FWCT9gLcr$44K@RUANZ-;Pe)O)5K>b=(f~^YhQJwiL*8&1}|aENvd&^*WxC^O)gZ zbJ+*Cxs7?P!M^#Kjm*%Dt}qeDQEHhQQn92k9xqH5Np{!2nk#It(Gy%*iyi&SFlpsG z&YX%}ne;e}_pLol`tsz-Oy(%6c|+p}amng&kzg-s(P;Aa!u(TK`XevJ8+rcjMcc?T zhg8m^auidof%5{k0|(fO|A~(ISVo+gumVxX^!(-OJ-M(|<BG>nO_rd(Ps#n7O}%1K z03~r*z~ANI!iu}ObaG)6SBG(+mzc(^0K~l;H3!csk0+>{!KjV`ZfGAVn8Kg5FtMz` z>Ry2z94Nv%@6zq8)3W25-$BPj2{kf9bWv*A2vq(2I%(Xn-mu-n^e_3G&1A%}S)P5X zVfWW#3?yXv(FepLHnrViHiZUu2bRDm$Jt$nFQ*f&8aJu}!800@ZjI;b!V0a%GZ76P zx{i*3ovu_--y*Y>wiN?}taCvZ)8&0Di{}5UyQ_YSs*Bbz2uO+29m0Tg4Bd(XLn=MA z#L(RhqM)=xhk!7Ygy4`;gER~^bdQ8|NrS+h@8197{&=2eowIhVz1O?mwbwo$4N6fA z3BBan?Z*dICg%R2)IqBa&$oEHrPd8z8|ki+gf`T4u_yM2$6ixAmQ?(MrWyt03xzLk zW=;%$E0>c_)7$4hAvJt1j4)tc8eO6&!Nv2;YP>kmP@U<`<>JvKr+EMhU9HPGSdn&T z_T)+GBrd90eO+ttrGC@xAX`4zby*j%QRsZ0D3m18&UxyyYyyDU8ZeyCwHkC6%MtLs ze#nq;y_0w_V*0L@n6ucqHx)Sb<~$HQ>T=nS0nR@C6S5_${+Z_)U8RzX=9GAS!|>g_ zcyOOpB|yvbT$Za%f43?Rs?1QOL^A6a<I0ko-S|=JK@|1JSH;#9vOgExuKvVJRt}hI zSOs`2@0nXvj)i7V1_-(fa4>`Rvl^rSlcj@2*ERG>w2Q}A0vx^172M5T65e<ZpSmoY zsEAQ7r#8O-PimG;#ZF7h=AJ>tFtSoAIG-radD@eA>#DUrUY~S9#+}UbApu{F1%vhe z{9xt+wllWF%^?4<NCt0UFgsQs1tPH(*v(E?i7Y7CnWr8K#){O%dqZ^stMy#D!S6pC zRzz+DYJ5}{HjeZyo7t{5=w0+Xemh~bSp^jSv6bC?LQ;04kD}SEvU~XkCf;pT1Nh#_ zu(Ry2m%Y%{&znq30&P2^f6JY--Ggls+rg-*64Sd*;#L6J*`%aJu>H)b@DJkkp?46< z{Bpy2ZBhK9DdKsjGsctY$1&J%!8l)!s@O=j+%A^u8EsSnA1A}VkIrsv=b7A6Wm#aY zB7Hq?a=~YF=3;3WloF<p+Gn+q-)=kmLRtRIpkB76q(cxpd>>XBZw}5=9dcdJu-1A~ zBZs54R`LIx=VT)NsjjAjmJ#`9Sh*hCyGm>c@>wsDX!MyHAMKdNkDa8y=}$6r=_{+N ztAz*EpM2XX|Gw2MtBFStJAzfZ&r_kVO<*x%I#lz^=MT0QM(Y9`g2kf73_RO8rb_r{ z(~?e$%-Fg4A?*GgtRumYMhV0(N&|2${k@!^ycck1R!AMTDj%x++!&3vF)VVri2iI) z;F8;N*v-B3EuYgky)nJ6-zNA;O8VqZo2t1&-%eF^3%$C14JY`0q@i`CZqeI|bVmlZ z$6KS)Ape`3DW6pjQ4@h4mox*uLs|coa-DU7o{WZ8e9o^H?)pK&L84Vf)24cD&&6+o zg7lsH4NuRZCZpLw-#@9e6_su-SI_AgLQNoS$s#9M8`w+DVU>C#9;%0KYCRLfv-)8e z*s$<JeJN2Y_)oWPw>cR+bzwwD{`a1Lg07ux<=Zr;dfl&Ybq&&pxeQ)%#5$K5zJL3x z(p?x*t_CQ2XK<5PWoVJ`0a>Z*NhkroNLsK>IgaWBlm1H^DEuKAKzAE%v$MbLW^?s7 z-*sH%XH4uIpN$17V(Y$|IV~0*ExY2e;_-1rq!R6pbb%5iY`H@dET)1R7gyg|GT+=K zn~4d#NNpsMYnIi`Nji#2h-Z~s15g%iCz}1XO^j4o?{Casg<cfheBl*+s}^0j02yED z)UVyTJK$qUIm3dgK>`ry!k-iLRy!J%>nZBb@I8IsZPUo7^%}c@4|#mpO$#D)Ej@EK zg6oN<2vnP{jd?@0n=62{+<5AaH5PcY7j7MG`|Y&72E9oZw&+JD)8o)Ji=gGY{oT4B zp|uI-XlTVk1sB+6{#yg|RnO0b^o5cfw{P`)M#ld2PG2hcN)n3mrl=VW%<bByzRCOb z;oY|lvFKe4>fWJygv9eg{vCIfwz*!fCB#;`L5n!2hAS;V6(+-QKXG31ifrtIUW<NJ zmUtyJEjw#|VX7wEVD}&d{4E<&WC*Hn{6s)j?iHR%KuW5r-F)Rv$=l}K0i0`k%E%u_ zs?9<`Qd_3Jfk9m4ovJxkt4pMMlT|1}nLw^4`^{<cZ{IpU-Z@i|r>j7E{K=K~52`at zThr<pk!n|PuSI<k)J&?Ik%eX~8H2kzt-vt)jL|G~QB?ym%lq3heTK7G1J;MVyuyoD zy~`;qj>h`|;NqKV`|NC@gX+nJm8-K*f5BHf#b4=I2>1$}2UA%DESTfdImH<g63<1* z39zn!hd)#N?CrSJ0Q_+^JJFg-m3ipc+>IukglRn~Ulb5*?p<;k&)C?iUyENpQ7}HP zu+v#B&rKB+%lTL>=L%7>Xes`M?M+i_ra<WIuPK}K%D_XcBO~XVxqoY419yPeLw&Go zv3aaO1Ugw3gWUt;^+&R$uM`Y;`)G$9>Yd1jP=b~+LBqM#Z<}y;Ys8FUjE;_{=qGk{ zWmr%3P!0W$KINcF;v4sC;UaN5p6_pO3r?~>-TNG$ZqE_;{pqd||L+Zf!~J22zm3nt z7!pQC5@Vuji61c8?}Lt6iuNC*5Z4C#O_Q5~LT&C)1AV@}WGkn>UGr98bk9WTg<H#U z_Cc$!t$NY8@x=6%8rH8OowGVF1pSM4JfZ0~YJ3$uozJXxPXiHL`3j2{WK8D-8nDDH zg|>^0ku>L%>CZ${Dn*F4{c#d(=N=H)-7U8)n$z}GuyIsHib(^F-I2#wJaPwhdPj`< zDEwbz6ShMek}YT9laclH*DJsJc^}UTZ=!O&Xs4xm#%i)$pYPPFtWA)d=jmpX(dF26 z)A56MvgKP!#N!N;4qQ{iX3YraRoqW!uMigxgYobIBF4ftgO*weDanH!)nv|`%+l`p z=HL5G)%ob(5NLR*?B1oxe%~pZ(r~WZQL@wQTlu52;%MAs`~U#)K3~>z`|MLlY+FZB z`BtEGc)8JPdfgfHMBhp!w-W{*+BCjBE>8MBIjg0<sij9auj;G75^unk9FLFSS}`l1 z{ZvS&GUQG+L}SF5)<v@?ef4LLiaO(oV-4r_Uuo~1`M{I3%6*=M@oyaSlEl5dj~&tx z_S)BRynecG;te%v#>d$Io2I<h59>W2u`@YoH%%A1=57?vP+xLXp36&C=HsLA<UfUv zPV6;*mOtO%gb>Bk1jRR;M~%+;|1ApC7)W{ITEkghQBfh{K3}&%ra~>jr$RlpHLim- z?}zXq=^M?~THW&8%+hfNCo+;I`_ru*c9Qelnlgjz*ujsI#;}`TC`F9ckgNlrnM{gP zFk{gUGs%Az^yBwl8`rV}+7T9ei4Ho+Zg`{WqqVZp)B1rb(yHcKxX5{wh%abbpBN<n z+SS=!U$yU7^_(oh%$X9K@}J?{za3%>rPfuFCcC~rm1fTLCGK9U5g+k(TD8##N(KD- z8)T<>01^4NzwhI3l(#d_L06$vK+QjEKge47RWEXJrcUJ6X?tsm^&X38NGog!hbc&> z*|4kCvu9Ro!D~p~(AC}kY;dRW1d9e9JMf&G=Y@Ph{rUDm#W`8LGC#iAZ?(2dd@Ts{ zAgZ3_XNe|+Xm{8si+<|d?^}hT0`q@kN=^dRYH!djN4ZX^?TYKYo5eq|*UpvA1yxI8 zQ3+$glpbDM!yBLPCRaX2YK>G6*9Tj(QmWt7d-0Y5M{!b=&g-v&b?)XpMw^yNJFTcc ziaQ%BP<r7J0D7$M;=x8n-_rEn$f!7nV%J`UO<FTn+qE{s8L9pJUz*ppLA&+mQ+!5t zCVlf$6?SA>bmC6qbHUm~%Sw?-k(rV<tA{#mzr#Rta`1ELppzOyH*-x3d!nhZ_o{m~ zPcS_B&ortl(fq#HS*5=1XW+{H!u&T^8;RurmoA2>Z=41d-^3UQpt=Us3?=Gf+~(zK znQx87gBk&qCRN1Fnfh;fP(e;-*IcG;cSc4m-o_sh4<8T@E;6!YTZoK&=$(dT1^ZZw zW+gY@|7@e`M4@h(2Q)KnUx?zRWHnC&RIBV~o}4e=p6BKmF}&;i3&&dD-+!_zif$)P zeVNPZJ@YLyCRHXP<$A8uu4l23s?t6gSy}zva^p6%>r`HBx$?J*?0N&#&a{ng%)AWa z(2A%ln#3FB<zGbh0KkYXUn`ZcG`AFKv}Q`=O`o)Sby%B`<mN8Rv1hlbDr`)2g>r4I zPx|g&2exx{jZf;_*-8#_N;9wtl1=v+UKY6s_^!l;>7#WEv6>-Znov5di>(i&tNi(C z#fag01iQNjvK{)RezvN~URTaAH~jKrBXyi_a(Zs=YvNDwc|wNDH{Yg%=C`Z)cg;Zi z5t3D;9N&}*{)OEAB<z!vVI(BVdH$-!aLn)HU<HAO(i#M`#9`o8=4)6jEd)1qinXdi z6IAYA?^dA0vRm^nlPA?`o|{^|2ZX4hTQg(w9iSZ}uZJRGg0X>@S<rJ<h$9c4`TfO9 zd!5jYrXc%bJOgJT|7tU)cj0)E$Qt}hs^cr;UX#S5F)y=p696tx_gj2Gq*4JV7NS3V z0EpCmOlrvX_~8Tf=U5!A#P;|Zey7#{3Q+z35UAS_U>lP|mcS%3#7uNc;ab2mbrYat zF`NY~lr{Hv@g)tNRXki$jiJKm#v=h<4@*}Mnn(RS(WBcUA7gi91e>buB#WsWw6s6H z=9feiU-9s>D&@ed&UQ|U4iy3*x*XS6uq=TgE%>`mUTUNv>>MVhjD7%?RS!ymYgy-Y zn4#BTc^|`;*|!NmrkS5G0Knc;$8d14+Ppbh&`Wab^`^YgwgUJ<?I#$0pEajJuTG{0 zXh^P0f<s__DPphC4I(3^g4<!u&VKoD#jH7VdUXMOrB`U%X8V3q;6CRCX<(7{Y*d+L zKI}Ae@nlT`+?YMLS}Ar>N_LqC$CDe8o<>y<sK2hj8A(1BNzx0mhT7W}+Y3j0TO5{A zMY}Y|ID=fCZVQZ;hRers-a^o6urM1a7POTL<8V2az{xdaUZ8g=Y3hAX154qQoZ=Ct zKy%)0QBW`!elso@=?7DIx{U`rPqihAoqKt(;r2ajLooH!6nrnRO%9!Quy8&8bbay= z9Mez#%~Ol2@zbJ47Zo_B!vw!k<GLQ(;5@Fu6=CEw64bpJi1E!La>7LhNBmUHIgBew zFe!E?K5`x1h0*XuYD6e|xZ4yzn5DZk!i>|LLdZRMjuNSS!Uu~i@@cC%|IfyW&-RJT zXwK}X<sO6((0x&{q$aas#BgG`{^j{P9vNXMmFx`@7Rbv2AO2*yIJcCE*pHx<oBs*O zoP6qfgL{uBCU<H#aEt7VJU6UUB#RJ1IwE1Y*L#h~Nv_i*sVIESp3uV+Od!Tq{gl~~ zRf$@P>XN!j<XZVy?g;W@%M_!LXWgFu^J6^je1u|9!$}#<);#{DrH*;kIuWM7^5!cf zLK-=7<wuQKcIY5;$t@t`=(WOS#NEVgV>z?!i9$YyoZ3udEYNqXM;9S29&K`@Ou2qV ze8?%5r#r|NUFy#w$Qe1=>(%%(9~?{E>7bp#IOm8jh`kg}oCSc<pGC>2+Q+k_2my{? zR=5)ps&a$w)ERg=_EV*ffOx$22*!cb$he3E^j?HO<SQ0{IwB9B>Envo!53R`!rfCB z{Kc)WrOzsH?<@^(S4ljC!}MCKN(e%zHzk-#<*}F#mmv3{PjKpz)7>K!>W6y{u0vl! znFXpbhvHaxL{IX`cZhzH8D&zceq7+4Axx0{&u}I!vH^CdcZ^q@p^<F^bq1jk6>!sa zIln=bQn)*=BD->w0#y^CWk&AIOnTt<$L9v<4B##6QEzL{I+5G@UsLcVm>~_3OLnXR zp271zp%HzI@sO6hbq6!#BXT)gA?O6o5O(9fvCO&rhzZ~qYD9b}&=-8IOMwfC@_uwx zo~z+ymMDQx#VXE$EApu9>5y8a#)(6oZPPci&19Pu9MMT%OlgA`26{~QQgz#4r{pj$ zyqL_n6P`5sxc=97F}W2%kWAoqVp)gVfT?B$u7%L{h1bEDU4a%l1VaW(99qC<2}t2w zdCbY0-j7cxlvZb=+Xx?CzkX}l+zB>`&+uVB!UeSqZg!s~#Qz!Uxo?$)O6L>axj>C> z^p~HubJ9Lz$T-ZLvx7YR<ThWCy67Osv+V?)QU5uI%F`}*YYGll&A;7v_b^3N3tf-A zgPvPcZgdk!65csC2b9%qeGYcsClND;8zHz(2hG2G!WuG2r1E$#O16dqz~MLwSdXFe z+@A-BYmmNTpE9>y6TJjGNINZn(-y7>WK0TXY+GwI$Lt7t%|O2`#+fjLXrlu#DbVQ@ z-K^SA7EMVhJ|&A94h(Y7X#E3I;4z%?PEd{Lv2h+p`{v-geb}S)I%P@*8KC(iCI_gb z_?r<vKqF4x-^?8T#UL7CMn(TyQ%^_BA7i34O?}E5tb7sfpI^j}2Knq0=W2PgsQ6>h z%67yf6?@TKKIfZum_8&S_|I^oyx_?0{SmqH)?0at3{r$RKgJblo#cg+*BwZHp!#lu zz)H+*__~E?$Aa}<D^58uf;rMucgzB>8ZWWeZV0TgqQ8jP-r%YeV6UoSx1tFXEDeXV z?LwqV3G$H(Kx88Q&Q)FvjmK>}PDVDDw}(X`>w~-1a>_-(wP|#9F;D0|@{q!Tv46!A zH?0;8>6w&x()5_thdD#$h&(D)+=Y}zm?&VND4sEbJh|{KGSoe>yG>twsH3=;ujE`H z(oSnDl$6%y4}uBya?=>&vpD2SaR98sal`134tC_J_Y6Cp`;NQgsM?m<6NI_{CI?I) z(3HxD?MQQ$ARV{J64u}?`gmGTjzSdRr6+=dB*H*M+!qf)m@2|gN+YPGcu;n$z&6aY z+&OQJRP`uogh~l$e2Ln+vj!w|5H4%Qfu?Z2b6ja`_)k#0y?pg`W<VN;{5~$kqBp4e zV$6%929h3R?c|21jgwCP^}<B7UBrW<5H1!$Vlr3SR3}ACArx=TBiy{wTr6qabXm}1 zlZzmhN~9SX#Hiq{00Skm2t15Q&Jx+fg#Q^J^QzDdEN#(@Q&%NXPQsXtD*7jDp3jp# z193AvYBz9#*CZ1HDd*aKb^eZdF$$m{bc9y+i^-wFG%3eFfp@#fw}Fp7?n<S8IEOTi z|9vg@T<lC^fQ-h?Z*88gZza;Zw;vx9%9-yL{A5#pmbXfk{OhI=(n2|7QpRJ5q@C!= z0cTZ)<zijBPT05f@Akh-Y(oI~mYi#|beP3Vlk`<HBND=cs?)!?L5#>?P_;kkA5-}C z39YV~m0KYhbCZ~svS*-A$Q+qr?p#7#e}D4;B9!ve#S0O-@RC=fl8Y{Vcu@`k#8SkK z9M6B_EGOL${ZTCD!Pt%tnl|KpV2ric_*(UR{;FzvN}oN9CR)h8yckk=*H)9i?DHpA z(rgpRGJ{aO*E&}DrYdqeKds7B+X*<g?m{s7V&MGZHvpG+Cj}b6Xiduy_w{AJTc1s6 zc&9#Tif2-gQ;#j;?-H^%9hyc&H0LpU`;mzCe0gMsPo?0*?0+lND*&_qDS+oTE=82_ zdhE-C2>Dr$<;IL7jTh#eQNA*6PTrxX0M<cWcU?6W!P;z6`8dMyKs>jgyZx$fATp1+ zwNNR};X%nhAt?9B89%X%`KJX+u16h1CK@Ifl>~_8sCKSKwNOV9X5l5K<g0|(@b(&m z8D~^I`;vIU7zFH*__Q&ot})57@%0*G<kQkR2C7Bfgi$}mZGx#a2@}5ek;s*Z27V;{ zW&%}=P~8h12r_(!9^<Dj{OV~N#p9i|?mC57+nQ<BsOPK0u@6U@`9Ce(1pl43@bMr@ zTGQp&ztq#g#qso}ymk=ANU|{OAR`@jXCvC3t#=0b2`XK1a#m?wh)2%CUM$at;&5?0 zY$^>})o73E+RWpCj#u)XyEmdw@i#+GD^>HuL|t*CO&1e2zNDJRdwRZ5$o&kx6*;{X zFR2bSDX-|qG0&T!5)JdP$9Llm_I-EW0ACVwuMzxOz~aIPxb%A0knZG;ltUga-x<&V zBy74!s_?+B@+1MWVZl3Qs=MBiJxc{{7lu2$yiIK2l|^@>KUFRC5jJuQ3;9nOD+!-v zmO{-uOowk|-u@GDUwTE@NI)xTbp!knFxR=_@$VDY48mhVB`J9Fij;nH!X#;=NpQbe zrIZ#QgJ7AVT7<$r#G9YsUVgA|xq0@j(*#d*Sl4tKXX1D?`gpq4mzLSg>wQxtq9t(R z?f`mj1TGEA{m}^j&Q(Qj?;Fm>Q!VRgj{aP=jNo~Cz#>yT3v0m-={>phM(rJIrq-nw zZ8Qwi35JZLuo;Dypv*Z}SlB_}JU1v=bn)mI2h|(O+L(8yK|YifAWxEkoQzqNJNl>y zyu4}^qrtbz-t-O4qH%FV^QuXR8+SjMcBK+~G(wBfx*TR{QzKd$F(vXSQw^`C<jYZi zS)0YaozE%%<Rmo~o{wqH!`DplN$lh4$PgPXO-zN*oHSv4*sl~qI&7dq_Jy3Rcjj&> zzeM#ieB!gFPH12R<6E~eET!=olRvtffEyA?HZ$Oy43qTzt>4FQo2$~+YKr0cPrT(x z8pFp&H~i=lx}JjXld;!s==91RD6tK=RdxXu#SU-ew71hwtK!$!Uz{e7hC1hQU4714 z%4__X+N?yu($}HL$KLgR6IhiPxF<8(t>5@T7-0(hvg#Q-8Z><Y+^0I3wE(j^PBrW^ zVyZLy41m6NWkp+i>>c|P;jYj)1Vsu*M=CaJ^OWL;p;o09Ej1`u3C${}E$z^x`3d@5 zjImMp&+lE^Zk<q84p55{nwq6FckuBp1X&CF6Oej^4{8}-yR2;LTAS4YsM?jlXPGd8 z|Hwt(d<H?M`6R`SRqmEhd4r}eRYDflW{+XZpVN}x{?ZUhVw60hg}Am}@PNbP0$pCA z!vWt}_mY~bW;%Yqxk!VFE+vmg?E(cZr0)8VBJ_?tq6&<S^4!}$E8kN^{7^V$9Wqsl zHUkdWzsz4?aRIU)q+(=<8bBh(&<4%0U5Kee@)^ICO|x&sNah9>oKTL}fc#M|3I9}b z48XLwiro8VCiwV`X-Lf^z3Rb0b5Y@6AE#-*|CO>+F*J!La<*oXbSlv5cX2*(IG(aU z%z?m0n2uWFINPNET*<=}T%a2AJ1+RN1McI7UK9CAfKpx9`)V!W=jdLRz6=?}tAe_J z(`&Pislq@5lH)*@c4!SOs}sfvx~YZ_$!lk6q#BW5mccpXN92LT)`C=@OEf5Re`1l} zogNZkmEn^{9W5`HST*F1EB9C}&UxJ;cCDry?)yXR0mU&x*GjBFo}$3T>sW7GJ{S$o z&EROy1#vh>0XYs1^`rm(5db=Y(7B42f`c*^-&G3b3<O%_0Twy7MZp<4a~wQ7Ln#9+ zeG0ZvK2bf2hn0jN(?^Ttmyf93(@q_tVcA?JegSQZ&!ClX5wEw(t}rLB-NQDoW4QeI z=q8H4`nUEM6q%vV*G+8rcRXE)jS`Jw^MkfUq`8xRSwl%8yEbz1SF8KTdJo1oosmmk zZevE-b6<G+Q6%|h5slE2r;q8fZ>U$SddNBla{Ir!3Q6y~r`JU-p7^@_SPjq~k#=}< zdcxD(-rR)})e@PGeUgsa)5bgi)Aq^%5278Mfy1A2<%koqmgwjY@|_<aW<1bLP_V}# z*_ieV<Ji8ITZy2+*wn1{*5d;p9{GK>yS9!F)SnUa!5cr^P-ASznp#${h6IJ(^=rJm zbRYZEW@R*)V{cbOH<oM9GN;ly3+3#w)_FFu^$S(~06IjUUZu-_od8o{3{A(I=?@e) zPt!wNvWB#>ua(?k8AD{BRlS%u*%<q_hxFmz#j`INtDG*hp^p;oR&WlIed-s{T6&|q z>GYK!NBf8Od(ZwYJXQoD;&h*t7H7^0AbpxKGyHyv%P-M{MLKv*=IDE@J;$y7T_I;B z@8m{MJbBp7=H^nqJ{>JeIID?P)VMZkexoy9rk2eT+Wt_kkSpG?#Nr*^CmPgdzt)C$ zSJ&T_*h1l#^tg{;K9z9(r6WGrGFQg=wjp>FM-gY4eEp0-;xTKK!F1iL$lsBp=%~?) zc}6QHk36&NB80xCjX0gVA*Eib0G64h+E4Kgp?p=DHbmJZ3IsP>L0@uo?{Bm|H2r<s zkYHwb%g5RFz>I*2psumt!1tq9_0^s_quc|$z}1v`F2quLWY@arO@5heB4u&$29`lb z?FGXG!2#DDnR7Le5J?0zRKjv(|DFm=URSm=4pZQ4%xieqgp)bG8qrtF@Yuc<cL(Ur zMMMfJG)wZFATDM(B6lJBr+tv8HSyV+ZD?KhjX+vBI!e>=jKMHmJ2}|ux^-y<3RN6b z)2V)WP_U^kLmLnS4^Q=e4dKSMC2#>^|CO*wgyDv@yF(#5omY#Ko)aNhBl)3wtfJ%D z_&gTBrUh;})C`yGA_g}O2|SVGrKLHoGix!-o|7r+cet{uGgCU1YR=dtx>aybUl4S< zq^K(9{9P32>`skzz}O%SklF8V(^4%kv@f$%MV(guumm|lwx3ZTOXaTNYO;@5Gm6s- zaroorSjz<<I5Bv9a@9Rb2Y_}!D|1E*$Tz|@k{qzP=J(~m^@V%5s5wdeLX(cfcmy>P z-nua66j6&Lj9^`BSaky${a!voyXnQ0CPLp;Yv5v;ScU=`grY7HH|{doX@FUbf+6k- zd(@3Y$w4hL64@A0O0jjwVHt(LN8<|xEsh@P5Vu%F@YV=<2p&14gwkioc)XdvO<c*D z{o^=o{_-I~MGcOP-1XWq)lRT%4Z27>!VSYzAgt%3gx{!eM`rcaKG?#h#$?Cmi9uL% z_C-M!|90>&A1^o5P!fT?OL71@Et&Lh)GL(H-&@R*7nb<hhr34meK6%^z+IbQPY@oi zWylXBF>&C-J+=(?<xTu!9hjdaLNB(CqcKYywZ{dL#l~dUJ8--Dd5xnR7<y19jOu8V zC(XbKwI>3)$;%r4>|Kz_<ygH)%W<#_^2}n}CSa?I2P!bqT*EzyAE0|TZ!%`z6464v z%2#DY#W+JDXlxMbfetc#p4!Cb$>cUfN^>OLT*vO{r6B11lI>|w4tBp85kdG56)VV? z9oYSzOa11UacT)i$o?3e1TVhtk5r<$q~p)8q{EZ8I8NE~)3`3n3Kf`l@G_pDh{A8x z8nKfV^enxR;WUrd(4nAv05Wxjc8DNG`!_Cwau!vxE+im6uh1Wq5JKz<1kR0IyTlK& z-)8sKej=r*sfSP4uq-E^dV*T`!RB_H-ci)_DMM6>g1?EIQ(rZ9%Y~_e6}k3~q&eUC zB`l!!d_W84=$FlPT3}TRu5Cgk5C>~MWAG@~4$*^byXd}J@E1Ys0Ov}>;?q)VJ7eSf zlc*JEU9;dRMS&xuJa>=sW56;~rkIC)C>99>XuW!rJC(nAPX(4eCpTfAQ~_4v1C--M z&O8oW(mImrk>!&XbXnWVj9CG8Xt~AULy~I#4AQ4GF}Xr@)L~gmTp2b(g7&KoLPP=9 zP<iM%rS#ztXrrO<;`bQWG{vFrKOaeI@C~q%`>{jx#j`Mm+7HkM;pfaT1N*`(F?vP% zZ#ZI6*bq_q*NmL@RdtrR0>*!HXk$25IR~y0=_<EFdfJ7W&Yau!lH8;iouHJqdMUZ& z%2L{@2$qjjN@*Qkn`NY!K3>l3Te5@Ba8?#g+NPD*ID-}S{+WI7SCetX2o;rg>Zo4_ zqr4hEpMuy%nLZWwp{mmsDu%da&)Bu}x4olS)wSm~@Hi;VYW}szX@i|=&XWQci;0GW z<jWcP7t^2I7hgWl8v=&Tq6oCyux!G{;_tOb;TI`6)5KztSxf8#+$p~rl+aS;eDaA) zX2bM-g=+{r@6U823ua8kmjjQI7xow89H7q*Kp;<y>)e3#`!j0r;i=S}F(}wYnGov= zU<!wC{*)u1u=EiUbfT(LeX9C+6fE>_n_q?Dc5`!9mXdZSbnq}J2(H+zAz1pBU7()! z@2?ShsI{P}p8_9=RlgCCNU5P|<+ZOQL2)fY(~?x-@<W`r!s_l64v8f4iCU>WoY~h2 z!LC5Z{NHrKELy(MbY?}H^QT3cm_Ps%+W>c@i>~BJQ=n)*^T5ro;&XgFEN_IZG+Hiy zK3z4fdiwfCwa0RFUK72c^z8;6uXI;%IZ->zS$ftszD8h_{>dLpa5a8>@514D*!s#A zX(W#=KHNCbe6bkZXK&tI#yNt_i|veECJnE?JUJW!4vT=k=juWmUb^XZHIa{P!`ip? zR5A508Gp*tpB#15tD^RFyaW$CrAaft)V06+o7IXhHlVmJz@}Ab_n{4IDz20{dA;Js zQ|~uuiSh#)W|F5LI_LeH7D{AsT5<}_oE!dYIx0gWB?>l=H2Rox6_~=cE4_k^BVvZc zsE%l^diZHRC*dw^2s|Y#%*sN@>o{{oC>$it7i%jMYJNVAhHpxSBJd7VR-Rsd;DJ+K zMgNl<YA4im`!Vuab5THv!v1YylYW?E;qtfNYY`%r$9Q^i>M?Mkb%Ccq?F<cbnv5IZ ztvlse8`DYCacVHfMAD`qsD|?BM<3M8A3inLv_Ex!@aEzc>EYKlOp1xl4E<L`wIegW zmJO)<x-P_le3R#TP^88vb^eB9=@xDBNSN$iU|Dg>_6uR~q`}}Feghyq@Z4F3QEHWR z)DE`#$8R^T(dk^kOt<i?@=4paO-lEdKVX}a{zLVkUu&1z;CrHY?XL&vQ75*pP~LI} z{SAtz8D6R$X4QilREpb?obsF*pnCd{Uox=hr1jx#r?5FT`lfw!s9La4r2;c|@Q#!O z33Jqz3}1yrBZZYs!4rhLo+ks2!cL$TZkYOj=s8|d<N{?~ebUp!n(NCzqVKBsms;-{ zB$!W#>ToM;ru}Ug_FaL<<)-mQp-=L}H%50Nqw1m7fg$yD9>p=~^|nl1c$yD_Jjkzg z?LYS&eoa&V`+F;UdG(DutHJ=x8{dI@uB%q@m4q?Q31TusqA5euQWwO6)Dqcs!STdP z@Ft`ql*=k`{|doU-UNn0`T^YZLKLeVd1nvCG*M%(gTfRG+7I8L|3xE#A~$t0V$0DM zRsNC%3v1c$T0Y+c1;`+g!8wTw-x&+H2uLvT{Ng3}9wzS^eDU=3COz_0msWHtmiaqF zXTGbCHHLDAm*CiVj*xgl9&w&GUraX89(<+G;2W?S1Oyxg?X={<n*RY7f={<uL1p(E zSVkp@z$0Yd1Pz#dc$v>We`JPgpy{!a2X(J>#0`m<s70h$H+ZvIYD4<+SbQ&VWJ@98 z^BAalSZ0m;jl-bT?Ihwy5`6Yf>N;cw5whC6I=O-?*ARJafwP<f{Q?1){T|Qo29<Su zS$CG()UAo(JmShN-HR^6^|o%PeMYc5fh=TCY$krDZ*5sX93l&4B=lnB8O_G993=%i zT!Qd#5-*;d?c)>OG$;;`(s;z%zoIQ(B=i)!uC_k|+!Pz%Z`w@G;f#F6Sh)TNW@;H5 zi#2IvxNtP&>rOXK3LaxGq9E^e=?huxmw5C_#F!Olxo2!dIu0kldo~L<p8HCF%F9Yu z<!Ad&`34_k%Yk4~Gk4TGK>3o9A5+y7kkMq@?pBXmwHEn-#UvlULF?=CegrkknF7J( zUhRZv#091?EOq-%4#}>xq^uL3N3iM^pYh>*Kf<ziGKkVmzd01OrkGWGK1;wSqj11@ zCKSPpm{fS#@~CU+0$i5z`-14=pUJ`3Qrr+3KKXVWy~q}ut-DvK^DDb^90|Lw2{Sy% zqgLsnyN?xt1lZVdW@7z_<uX<^^!AEg(9?q*N8wX`?GCW0aTxb!du~nm&4u@BsxZ-M zVoxadYI`^T&V*`6)CL0d0w!_EP&wXBE@~NdGUyBuRy<PqmmyB@x0q&2ZbDCwOiISt zT-o8^qfcMp!3ZI=$7R7y;VJ25n*C;|SXbC5GLP8OgFvn6nde@T8}&^ew$tTb6OMNP zk5V4YcT7ADB{2I>xiMa@j><&F=Mm4Q^50E~lsFm@<~M1zp{SFvbOYI^%of-|u=mE` zCN(G~1&`VNNq*oGX*zM51!Rb4op?7ZYK17X43SQv3FcU{o>3r{W71pG@x1uEV9mn1 zLJkN&%u4@mT9s6$7q<Jg4Oc8Jgi7*@cb0wrSt;Yi>pXDWJ3&wKOrf<5>x!hli1b(0 zYi^0qwnU_SQy4KyyCOewyU8jjf14@70Exo2b7ehQoNBTy%u)hGQGdBmiT3+Nr-n^} z3G=<Wy}?wUnCJ*Z9kbSrb>ap{9^;+gc=IU~!Pc+mBgoe_#qUh5^nLCQL`JXpJR3g# zk{1gtnK~%60@EK`j+(qk@!pj>%w!FmY*x5S^d8B4?(=y9aACK=dU13C@!!>vly)in z2r>byyxUznY|3~q9T4B@L9g@(X<npCIlV;2B%?OB5S&^|-1xeK+$|?x>_+BuXY9yQ z+SjF}nZ7loWJJ_a06U<eQ@SyPwc{r2S(w_R767K*6ui|t%;}OJSt5yda%73uni*E4 zXy)~yX%UZ!M3eP&pJFpCs1)Ah%*V&6C5ceYK7{#nwzXM&zijSw%MhDDt(M$aTDIk< z_*9z_>_Q;|jS2tqIhQ!LMZn=8gn@{UK4%*kT@5Sgx0712M3-o7m21d|eyF_p^l|>w z7Ywm&Fn+rI7M!GJLLX|8zTo4=0haCG-$cY^FXT8h!!L5?SPAZM8%wrROskX3(XE7@ zJTYO^Yh&cubJS6}9c}Q6^}hjJ#e&;!ns<-ka09Q<#_~n+Ib*lrEASw6H{lA_ZUs#s z9b9H>qD|%lGN;yj%!cz7jvfy4A5@dvipQsmX`pe(?a8n9c_ZN1gfs+iaOn+ttvzVE zTq=mp4A`M9gGPyd(Qzj*i%-_c&WuA<Vhf0o3+ogQ4#!*|yT2jLgnLflp>?-E38y;= za)xL_FCy!SLiTMv?AZXG^sI-NHJG5Gj1WFH0SP_?AzBD;INV;gsoV{eli1Z1ib^C5 z&I$>b3s_gdb#msyH+TSa92atK68n%wxGd)q_cktAXNXM9u)huEP8Hg#F>is+*=R7D zgXp5^^Xy=WB8YtQf6AwA#@RKCGgLl5H(!50q960zg(%z6()GXLnQD_BQFfK8dB<el zO^7Gyd;79|X|>0o`y*Lb)vHU`H-AAbO`=E7?5RB12c~WRV!*_89|+y9uST(#D+(Eb z-c!;arMiDj!^Lma6T}ZOJNT?WD<&11Ne@$C?{G}lmk1R@0HNn^njM>NvIT@xS<-WO zZ?%?RT-!h;)w6lGV*;J&-xb5|z-V?TjXh&}$psA`F?5=8*qDiTySequ1&8yt1->-A z_dPIfn<INrR;lMcQNxY+HXqowfQk-Uz7zEnK<*xS7n?oWgEjqPLbfH`xS-B)czQo! za+wqHEdGuqON!@eczgwUt5JA78$i6UAD|8(C|#4&K0K=|P3EY?wR3y^uVCEp$KwG1 z?Ar`{<R&&^Tq6GI`Bl2Mi_&8mZt;~Ml)C{p{4Z62Ez}689HA$_5C|q<kN_xXcpd&Q z^b|izuUp6mDsc;EVC%=x>k`=y({TI<Xo4q=0;0qV_G1411W~5{Uj0LS|6-a@nCO1f z*YI?;^_jogZ2DR#@2;$4due~%L@Q3!d)r+|mJ1}(dt3pKaUwYI2MT%JSB2Qif0bj3 zF9?5&dle6L2Rza)XKtZfdDS9Dz{lG`mVpo@@2Uq}($v^xhfec)jMnO`=_YM->NRNs zwd~@P=AX!d-7GBx@_WWwc*Ym{tuQ6P5So9}t8#ZgChLG6Vs1hL`In7#0ZbRGXxP4$ z3BI8D7<WVt=%B-{N%LVjV~`c!qUql2D=H1Un(HaOPS>Fm#(yPyDIVlULUqE}WBVR@ zeX6Sf7X%bv@bQh3ZlXq4TN5e$f*mquowmc{OIF~`C@q<p*rf$ashl0OV@O>m+=GbK z9z3sy)&x&%m}yVg7Q=Hmm)N#>K`rtde@O^O=vX<ov3%O}@Hv*rGt&5}k3K}XxTb8l zKE`1Asb`zEe}8Vx$iwnJ*Quc!QF|Lyy9>{Ca~}-PWY1CZOf}cTyNX7ay?)aVkMV6| zQ`7xDPnYIw13%!;Dv#7|yl%EvL8ufP3ErKM!>Ut!;<C;pAb)~7fqAo*2g{4kbytFB zt)*j{?M-2K++$2l503}DaFMd-H!ggRl+9A`cI5OMuUcyH=F3Xj4Hk#E4L~AmyaIU+ zq^g*V=W&ydP|MKSE_@5|#ez(Yna?raEP2NSJUT@GA!cLM7<(Ymk_ESz<HJ_4q5)d0 zc~|WD0fVc+#g`S$5vvP)|L@5sFG60UmB%;zK&EqE$I^H%z!~?J!Lubn>?xTWH}|I( wm0P=r_R$y3hZj-fqcJEK-=QA&h<ozaz`j-Yq&n=4sW>>`SK2SDUs%2SA7X~>761SM literal 0 HcmV?d00001 diff --git a/docs/logos/xsdba-logo-light.png b/docs/logos/xsdba-logo-light.png new file mode 100644 index 0000000000000000000000000000000000000000..8b7aafb60b95735d96764286f4b7b57100306f62 GIT binary patch literal 8032 zcmeHMS5y;Nw??td=pc>=jEXQQAUy~oBM|tl5L)QHC`d5$79u6Y!9f%hG(bW?K%|Ez zgcd?m1SFvudI>0yga{-W2r-0^%iO2?e4qb^v(8%kti9LT-#+_0-(KgLt&N$)v9rg- z#Ka^(=C|y{#12UBucyBp*|&trL?idNU&GDaqQt}wU;1|)NZd&f-#4C#zU><A5C(~c z-;4AYgTvw4(9obLzkA{S+F_9ac`W0zVq)?epj+1+AHLq8#=iD~Aw)lTjMqj2rOcC7 z|M}e(t$Eig={V@02Wv_07B#lg5z8($lNT<aP6qb#EARhcbpF}Z<`jaw5m@E;vGhTz zo9EMtZl!yGq<aG<bNRG_5q3sY|NL)we-3ug>LE}e<G3C#kuk5g`Kg^gAJxh5jDp_| za%-u5*Fs;xm8EQF=Z^S{O6?tzD)ILU@`GP5=f+J={G~B7+y3Pff8mj;%$e*Kq~KCm zMP1NC=L=N>^HTVasleX+{vp+xVDGj@!1^<l?o?}!VGV-GgIX2LF%&Q>*Cd?#Ha1Ts zj{0aoNmo6FDH$fT3GwS8WW!~MsqiWN@%BI$*p$eV7=ABoJoCH_c`}TkdRc44@9lVL z61KF!UwbUx8Q>k>bF1#6j+@eTay>1Nou@tXhP-K|kDtYX;~4ZIr|To|Y0bq(?hD9H z_uUL^HR=9T?Q|>cZBK`H_kHQ#rHLzLK30|%z~rw-{F6%{&OTH%2Q^KyL1=8pJV4=| zYc2s9II}Zpd4g<lAalOxPOtmbusX}Nz&lNHQC0a1UZySn`A;N9@4rj%Tl2{g_!rBC zKATCw)OBt4EVtQrpAJ{Gt4G7u0>_&L8D!Pi0gF=9iFW^(ZYgwoXL;yc(m;D}L-5Tt z0=;?A|0-wo7zE=*h*&H4Sn_s0=rEiUGrrejfNWY_k)n&rNnMe`u2|%By|AD-FWt}y zHBVK73Of50s74)sdC*1#X7I))1gBDOc;~^Uy)~}*2Kj1ZK@jDrl7_kZr!11wJI)Dr zr}YXaI)9mybYEK3GE(bq95yP{>3$Vzg|rJgrVqV|ShkaZ@oPF0^1K(bhI34U`kpiK zkilTXHYjB5v$ZvMEU+plFu-wYQlHi`TlQ^sw(JHh1X2HvJCn&Q9pw~;#KM+hux$3q zAN=?_&o0=#LH7d=<eaxC|D*hdyAQ?;$0ixpPu_VFpmQ43Et8g;5~)f9#-C>nkPno- z{uQ}Vm}AYZUD(-uHs9Y6+=Ir%qB}-3HPMk%!xjDq90v9SDb+^_^v1TZ=Oso8pK75s z44OL~DW!%h7~|~q`bLYzG!J<l*mEZ4A>6Eg+l#0mx)IypvGi<Ed2WsXPsi?9=^E%^ zf_>^c>Was=b9BM?A*@gpxB9Aw3BGY5O9hYyr3lOItgEl58fxLaUvnv4zGIVkJZd2b z<Y_xNo=@oFev=&xusjU5NV#GyLgj_xuukwB6Y|{C-@XNnNzF16HY&=nb(M1XmJlAB zT^YB+6z^(|@)2xs$IcZx#rnWqrqXdwcBb^BN9J@E%#xjh=i|yO*(17jmmP4s2?dUv zB(g&$jrW4HnlV7JDj-~vt#Q-Ms5xy6Jx?*o9(f&Q!&}JhD6PnTr9|F=a2-S9Bgk#A z<!$>1y*rb#5EiD*_=S6!B@nW$l9Y6bcyqx{FmO996^J`Q#eHgzj*h=KO!+b0->@D~ z19+*7QPojJ#pwY$LMGnw4UT9_<)BVnQ)jV!T-)9h_Z=?^_%pAe{B%`I=atAb|CuL7 z!?rlyt<WNKbpi@r;}&V?q53H4gc@;0A@1uy2!wP2-GU^{tow2=1H3fOM;@x(nL#tK z%IvGATmD=<Jc_W;5%;4Vnc=RYGm-3F!epDmdmQ3(%YYqslHD=oP(^FrmUKo~j+5w~ z8X$*gr2=bgGPPeE{XV|OeOWSGJ3K5!XI0Ob7Ef4PG={;yww*~F_xA&;M^E%=m17## zPr2ETbvaDX4)2phr4IUh(=%*CXD8XY5N3G&fcify{Ll6HVc|_nOY+6@0fnY>nT^9) z(t$0e_NFz^zIyTg+__~5y<CXP0w#xz%SX%UhX=#WCSJ3GhsjeGrp7*o73X`%28{(O zcsOQ+_UpX{lx|l7*R5P+Hm>{k#oIrh&(i7i>aSf>Cg_rH>7KQhV&>~6!+?yt-p90v zG#1~UGramHM?llS3|><0{<F_NH!&(I%DL+y>*54X`;PY1O8;W>y}2rYt5Kw@whvs; zuB0V=L0&Es<@uw3>LwlhEo6RJ2t_yG@HTO+E*(WKuSW*Ke=(=E7$;=W(rYaR?iH17 zuJ*yUx;_zH>}Ho#v(=YhuGBJSuUO6;&M<9jDuU7_DwQkq@`#seKgQwn^?R2JoVg=R z1BXI*_H4{HP}?$VAd|Bm8#I?WWL~pj1-CrqutdS)0}Zsjs%~Q>=KCXiwLEM<QXO8k zxQemZL0awl#j5>R>G<J4uCIPBENZOwa9OQ3{8n<qePVQKE%}NyrDS`%>TJNbiR@*= zISb;q@>1}$onW;iiiN9;Csk(ixTn*4b8}}6Cbh95DukBOP`AsUl<F7(pxeElmD14= z4kv4;`cHiHZ)V6-ggWo0hwr(|e7%F|r&DN@qeGUM?Fk;M&A_fmBa#qm($e~4xGVS- zYM;rkDXx(h)GG}G`6}?FgL1EXVu0E7QcHn+)hs+C_S9J!HS82&Fa7v&%I$_vZ$9}S zI{cSw3ipEbl(y$IkyzwcrIvPrtT*KM80E%!mYrrJh}p06rL>+zT1$|u_Bz#W3|3CQ zITD)gs|_D3cLC%I!lXL1yB(ulW5!R=m%_aDTDB{eha0bi=x8X>3u0ifp$88h&i3-- z)VkV=i5o$4E#<YfiDd*25fO4a4OqI<_GGx^<@&bfTo64TZ_>o|N1PuExB|;SnALQ) z2k!Sy{!4{p;fHeG9k)U9t=Y3N1J*p_QP)Mp9cS}%6O3fmQmtRm+PRE#e>K+uf`Wo` z6Rl_nXc6AkN!1E4?l_RO)f!9G%{H8!?Mtxtqwi31l{fbmUAyGF5BdDu(PO-x_i~6! zh(aspOA+KzN@Fg+91CAn*$v#;M_J}vTosZgbw*}v%0(+zRP$?m;+J1^zuLVjp_g8g ziLZhS+gpeRTb@Oq!^aGMJ$5qS!@npbjZ_2opqmBtlbRsCSYOn@(Cplt09RF&zRh7k z%2*4&&gNq%Y!lWaFMhGJx}<p!!LGgrhAK>?yEEhHMPl_TPL4{I{+sk2mamXvGLnn> zNcouASlqGvp{;KR<CMPkZB^4*`WPZP7iVTQP#n6~s=KlNAZRT(XL8yowPM%k`hg|u zRE%kM?taaxnOu*-;!B@47!BusIi_Qx;<X<<mYEcjy*nA<_V8_dPRhaOg`hLp{^y#l z9o%7kt(wMT1LUc&*v(eWbKNUx7UZ_czHwo2OLb^_L623Pd-J_DkG>#&cjipVtX=$9 zeFM|Y^}{2=W`@f<0}x#$K7pOi!oILJ%TtaV7^H5;H2Ld8ozyH5KJ|6Pnj9E=ZJqTX zh{porAsMXI3^z_kb{ZWK^0q7Ni@EN-v8|&!-5H5fI#D*uOV}4?z<@7)r3D2<2)Hn+ zTX5M$S-*Go2CQ&G2|@i9q5+{&LrRC6JArd%i1#5FQEvmcra5jPsqRjKq?pP8xsZG{ z1g9}B<DFCH9QCu1>K#ve5+W<V$2gpBB_*GYhDnY)3!XEGGp!pp&pgv0hV%O-4XnpE z#m!K^zSvJ3)<lK!Zdl*7-TSmL^sg#=@YY2<=bK7!At|qp7?J2TG+2sWug-KseWI`m z3eFg9Z#*1TCIj+(BL`yOO<eT60-DHWS8u2`2XJ8$8w<ri>H^hHle-P8%*nDSy_`ZB zTxbgx%G7x4iq1tWs(oM4RWw7oyL(i@ji-Omo<Lt5ZC_bsX>N~?Pnmpec&TT!#*U-g zU6Kpe7dF>!FL`a>O~aPD(UU)t%;JnqKSZgzj9~(Nyqi`U>oPVo4*YfD{5Hl^tEOh6 zx5LodBsSexVg<r>?R@rYWVfr_WX0~{5H4^LJFEu|yog!j5bxKssnu3&_s$~jiz4!& zf<q@f9Ni}?zyHT)P3@UQ(e+oAup!h~XZCh>r@Xw(i~ucsjcw_E|CgrSz+zGO9EdJM zOh#olPwqX~gDdmRh7E;0`VQ`JO0RC$KUy+(xB3uf8~r9RR1h+5etjgMEXk4{iY_TL zBDM{F3uLTJd6DW+qK7V@MGQ4P2R%0v>%~E3d;z6-rpe57MI~x;+`p2?6~0fr%*N3n z=fjKEG^Rp;cF^q;;2M+F5U>L|OTEcSV`SxQbGLb)zPfC+)6Rzig^t~~PoRqmKc}f1 z=UWOX)8DH}f@WAFyY0uv<$~|tr2LSODT6E4UDq^X-=DI~wBk+88?y!Ck16cOEy3}3 z!W0D_QB@gFQ#}u7p2Bzy`Aa?e`eKe;czm+fI-{_O_7_0;9$QWo^i0s9Z~5dzsuJR7 zHG$^=`#Sptp{c?*)t(zAWhLJIWBF9JjM_C;Yk)%L>7|8KN0jFPLO+cmdgFHUXz3zJ z&xQa7&d3g-M&BtlNNO#6D&95!Y6pcvL57n}!#452E2=2q&+hF-;lnG}nJtmbr1<ta zo;!wjrzY7FLNfUvb6lr&6rmpWbGF>(^`s8tkTSHU-4NseuHr%ZJKAv2WYQQbd!(a< zO3gR2sm5WK(ThwJ&~aTm)c6OKc3lPF<4{`V>Pf8nIZB%<MDFD*AY*$0EVnNmKsF3N zdvm%R6_@CK^PBzq!9iVO0u4n7x|kT#{py0Q`u6*|J(`h(9&V(j9q$KTWXBs7Zf^bk zxR4;MpBvF|RCre$V+QA?BTZPVaFv1*<yb|KX49ZN0WR1r^hS1`U`kNyW?N}ns5Se6 zwWPPGT(U0SGFA_Mx9cUwRAq)U#IweDtdi9XLNb2YM>zWPu2I%>xwQ<>{u5At#Dth| zbM3Gl`A}Kg&Gbj0m|lr<XEW`=s{~_b%0-@OG^6e5n=KC*y?u^42DUhMJgvmBVZ?{f z$=&VtKj<*2XhxIDlgDjf7hc|}wlW=A|13~2+CbN{Zk`#&DVOg#D~tXy4o$nwafD1Y z^d6M+b<`#>%W@G^!HvhhXjTPTp85wNS$C9#mzhU@GF9e%VwfunPThN-N!_1oyu*hi zqB4LH!wrL)moo|Rz82NfO+j}Me$-$rD3l(#wzmGwsHLjSomTmiFHj^>r^Ytdm`?hV z_c`N3sE?XVZZJ<0g-P%=erylrYr!?`bG;QS-TkKRss=avX~<poO#je0A@25On6ccV zxX#RTHT5t7UDC&xai)J!_xoNtHQvBrFxcHS)(0Hl&&I&HCSO-aw1B{%tERAFYm}^U z)41MZeBTnk%g`s~lBy6L)*AH8t$C0dbm8p<H}$asRGetVFKut7zK7o-mia!%d+(uI z*R)@jz1p0^qF}Wq#Yh#^82F=d&9b28vfF$V5hC62A?O48sFk8rqP}n(1q8S@e3|@L zi>L&ipVajJu7^cfv5E_7j8KEYapMh-D(_p_)n9qg=jlEzSnrJr%X_Mo^|!Nju0YD5 z=9T6JO>FG;*dv<Q{-8)lZ*9Z2V&E}AO)_JeNWO0$A0Hn^-^;;beB`llZE>@3$X*4( z4f$c-->a0>Jj+T6HTAg!erUT><83VJcc~4t2G&bQz7STRp+mUda^cnRiAQRFgJWCP z4U#n;E*FQi*X_VXwVhWt=BYoLX8U%;x0O%-JE>1j?3T_Shbn>uaUHg{?$z2MVfmjh z#ytez9<+-x#ATo(uF)uv2Nq7rx&Yk636_}*Yuw*G4+aH}o}B&UiTWY*>m8n-ED-sb z*Y**E{Mcn*D$8#8T==^dC{pwhcl-DP*!KJVm<pr7j@YmDUK38R;<#VO%I#f>V?y!= zuQTEMD!20zf1<%|!!N=>%V(eHCDR3|2QocBepc|oKMajW$NY9K^%m3x5z$X|P*fE< zYq@{-(%_p7rBFGm<oQK>;OE_-6Lb46uAdbBF$vrc$$}?_N_lRu`ZD$_L7DwNOrE+T z)2wOH<QD)m?i3TbKlz-M{dk0Q13=lDTobL;eGB?#V@bJDV@bzS>?iSlaCVw$Vr$t# z-i$uVMjN@qV|Bt_UKXh`duiaQRzZfDJBuSx!!QqgwXTXerb3+ZbgA~#4U3v4iJLu& zAmk>dWj&yZPf)}WDe-F`2NSiJ1RB_9h1K=P{Xut7od$A82Cgt6P-$swc5Y!0(y`@U z5;Mg-aIY5NZu<+e;EaJK7G2<)Wh0l-3(lb*J|3qe)D{Kr{Zo5f$IbfZ6@-|X%-e&1 zp0+!1GPOeN7pIp>dhsbG0cf`1F%bzV0bIfJEaNQrW5ju(#^dK8B_W~YxKh3%w7KL6 z$VhqP<<?P<Y37z6sAWe71HXb-2Zd#B-2p`@>t}cEO`$rMSf+nK^UZ!HLO^Y<6d#b` zb;=fp6NZj{K@>r<$k&`GK}sFBC<j4imbmOjO9}!N`f3ZzN?a_e2IxSuCDjTQD?Rv! z0GO?-@F`mZ5WDt|Ic4U|<L6i{D5AIZRcM_YonN5HG`N@`G*FsQ%diq50CK*uK^lGS zZWLdTq$Gab8>DcS6=3hp@+#i-7APTH?R6=-gowPrmK)bJTXJWlQ6^5ILyW<7S=NG~ z&JD=697v(Abq&GVn>*lV4>CaeO|Z8)8xgdrfAY1M*HAWRf69rYVb3`=$pMb@9d48w z(&9mGEXw;&rZvrH@-g=}P$BxtO^Q6o6t(rV#80WCJpp;$9*@Nm4J7f^4kQr(G^+xw z;%MnQbaL_L_QfTR6jO5?sxjfWwco6~g)qB4Ns-a4Xlm;Oh?{*Fb;X(wuoUI29o5L@ zU``7C<WXBmMYu9!bp>=Z{bUA`=<7yQ>hOJeIY3SF@3n5N+Rwq2TN$D!B~bA`eKeb` z;Bht(NM3F+-|+x}&n*3bqMRjN7oslh0FE1kzG@LSeFd?Id$Xh<#2hi+14w63H7cQ_ z$rgoGfA9?ayst5DOOpqbI-+yxM_l%FOF90158f`J68}^??;C8N*p6J+>Z$Ij@E$gI zcc^a%fVWH!hR$CIJ1QrP;89TvZ-neG@OrG5DhLu&&&e-AjbCKeQ4w`V4Dd_K{V9Lw zot1S-*bRY;25iNtLKjr$)hCQ_5SyzQb1FU&wW2(Wyzw<{D0r0FXtEPDUpu~s2}H)6 zTsvkJ2mY&Mot3BL<rFa`JG9<}QqTBBD~jil;ucEtaA@xh9&}k0jiqLET~7TWGJeAN zSxO8$7y5{}s0<xDxdt00{YZSb%lrX}886b5%&~f6$YY4i-PM^+B%VeBajE`X7JFK5 z_ytN^3z<+*vY0!=P!@JmMFCedoJ~G@5Tat1RXf*RNG%PxJDYO;d3WSF{Sj#-1%O=W z-B<>vN*U-u8Ou^Akbe-<+mFv;0}ht8UoT!_g+jt!Mdy_)tINmP^1ssWfkR?=B3*nK zC=S7|4FK)DRl?2yNsPdGRb~on;qpgcbtH3k9?@^U_?!sOo9QuZ)jMNm<Wmwk|N8xr zoS9(S^~B<6TiM})n3H~ggF-&xv#5v^Y{<*4DQP%zfodj@<yw;%=!F09eU=h0VZy>N zj#uz&N;Tm;)8BsXkh)kK#R)c`K%=MiNAc?<+Es~!(ZO^ld2*%(YoTiQ!AvMErAmW$ zy~D;{L@pRL2oP7HytKQFH(++ZF{d2U6BsD;29I*mM<yWK5ugB#LN~!FnunIK>sAwL z;Q~`m&uC7v{f&M7(sJ(aU75l_N#FJN&+Fu-^gk^Zj_<vh*J84jsK(>N9(qQWg5ra6 zmyZB>{eyH1Ts!^SHb=By-T=r%G2$Sc9mUI|3hm*@W)8?d%+_R}dNCN}bM|{_w#O}N z$kinPGB)M=8-Vqb%ke9Ult(oAcTEt8UiQe)D-Oc2E}Ey15q@QL^>f_?9hkAAI?ZQc zEsOmon}bj|t_*bF+x-nx)wlBxYcGe0BvXA9nfcO^T37KTp@C$Oh@9-mml-xMsC*Ak zJ;5Mcl#Kn*YIHQV8d=50Tnrh=?gGC}x=6X}p<Za4IDUf^(9=0VZP73_D-!|OrI2mL zfe{gy#M9q0suw-x`0xu|jAIs5(Y)Eq)jfq+x1MluQbt$%QtjVnZ`B#J=MaUV!^NHk zcS+a&REKOEg4pUvcU1H}k)14D^opZKx9<e6R6(}49>G>Ce?I&IxKEqUf@5c1BB?{w zb^=L1h37{=m=`*9#B3LBJ02u{>8lg#5n?iYGm^B}BYl*J>dyLX+T_f)OaacCB6c5( zmoKU>eylUz{272c_V_u`nZifmQu2nY68eH^u|R!s`MT_AaBogwU^o97Edqwx!~4#^ zw;5x<+R9bz>%4Qc031E=rypds+u_iH-p7V?=gw@saG<Qs)_7p({M%4Il7oMObo-I9 z3z3MBPb(?c=#sY(O=q0YrB8DFjIu`}g+?@h!mzE$Ic^B5vu>B>D2l9=TjG1;5-j3H ztpeo^AHGMh=Bq95jjok$nez`nEI)WlQ7E?Jqd&)zM&eAsl&S2ndTs`_qG;szoo|n9 z6I}Qwn6lYjybM)SzZtS=A&IPXQaaRZP)h{vR45fG{Je-tKfj$;5~Y!3i`r^9kg<rn zw5Ko6+D<M?bR(0A=3ryD@Gl|6k}>_}wMtK5Ds1;fiCa(gvK1{LCZq8+QR#f$E^hZ$ z^4#xm%fa>AH1m0v&W@SQ^Z1*QynW*EA%OXALs}5$YZ_Y!5;%9Rq^K^!-agTlFU{Hu zRiNX-SbGvQ<PVWY+=sj}S!H2W34<UwPs%vUMFMV1us)|=4q<iP;IA(l9XUg++U<DF zWErKn^;1dZKae($NBm+v`JU)~m&YV{60hzi&z5|+EH@%nuU@>MyV{1&2lT5JN>QqI z|LHMGSXJBU(PBeUbT!lH-KQl+RD{o$or1T!s*aC2WY7Yg)zOpqSqfuUzN@o&nIyjX zuEZJ680ruIc#c;g_Av5m;Evdh-=)Qho*sK-d+YFjRR51$xa}zR&jt1W9{(4X|5cCw ky$=8FlK($Dh!nO~s=|+cZ)WcQj*EeA+uW+XaX0CI0O()5sQ>@~ literal 0 HcmV?d00001 diff --git a/docs/logos/xsdba-logo-small-dark.png b/docs/logos/xsdba-logo-small-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..44e7ecd8d2985b5f1cbc18c6d00293f889c56798 GIT binary patch literal 2288 zcmd^>_dDAQ8^#j}idR(~PVFkHc5APQkreHrimy?vQAKeiDj^h=C|bM5(W<>Gm(fbC zkR~lXIAXmz?9rGxv1%lu>eavF{o#H-*LDARKhO1CcZ#Efjj*7UAP58!wzEYzozU|{ zgj0McvnluQkrN1n*?M3=An==C0{gzWbo#`U#3J3X&gcLv&Ntj2gu~&qf>0qCKi@Ea zEp&Kb;f9$M2y`mW4q@pMRkS`C_b0F?N!#AU3{gTiLp?;HmWVS19fV!|H6HRO0$H+F zgH%B7F`mJa?Psosc3!a~8Lb)Q4t}&BzpnQV@f59~;lSXtRyDcj%va4@*VUJn_}pos zmA!6u$e6twq}|F~*S;NPZkM}Xgo%f(OwGYoc4yUz*R=MU+Fbe1-j)$gk}rY#eLFNZ zl)_JbEu=0*hX=jf)sEN4Oy=J(9qOkIw1kb``fx4mv4wr0iSf~f;oOhuTFEXHup`T( ze~ENN^K@l%Yt~9baYBW=B@=0L-%LbN#xH_J{`;Z5I0ZHZQK%@kLAhV9{XSyB-+1Tq zcY8}}R&d=@1fYtvRhwPPAgSHjd8EW!Hca1#sX>?X53Pr!7DO6c7Oa$C*z1{47S<cA z`E~B!8T(rrN@*DuET0xD&VO>GWgB<5H`nap`3R0#8GytkZi}cj3+>jq*JFaZnajTN zhCVaWn%<Tj#$Qd4r5XjsOG#$yG4I#J4yAQh+x@OiTs@PGUnt?+6irSroOXt3N<!WA z>VxF|3VBWbtm!5yqw;p^Ta2mUw7z^otURK;FPZ?|Jz$q~E)}~^<vC=;yt;ZbgR{VS z)~su2E~bT!A=d;A^p%LbLI?l6K$y)7xonw_%$1++s3MybvlTC$?@b%bVKT8s<8M3@ zg%j#`(lXy3ls7_%v-|f<iuP0HoJn_Q^zetS`rb8td&c}uaUDh-E3*dxP-kh9oG`kA zs%k@q2%!CD4y=<~8iBpGl&ao{$aGYOyqp(-Nm6UJeWos|iBv@@r3R}yrUpANRXeW$ z-Kwz4PFY+4u9K3p`0D#=@_FEgm5KNP+U;<4`Ml)1qdzItZ9^3UK-P9F{QZ?$*eeoT z#iJn>N?5%$AB!ZTzT{~^ZxIB=C(@Y#E{3Tpqm{bSaVj|+A40K7rvCgmD5A-rR8y1* zoNMTFaq*M$@+`BQ8XdR&_kE5c)yv(ZK&IzpSw|&TAKtng$cz-&j<MWN(-GLN0N;wm zLPkLeDw<eS>HUCX-@zxkPp<V>IAq{{vm5nzkkJ-@u4i&ziA_BmrC%)gqgGmu`{AwZ z<F=`!AewIHueckrtcur(!|K`Je3hN_T6@&BR4XpU(vvSNAr+1ZlR!h@avWM{8XvHK z<9J5L%y#YK$k97)r46SxR94nJ?!!++uX^X=<Gp?tlW;n(Q_FAJ-NbM-qdxV{>CDRW zyQU=XhY!{}a<j05&+v)zXQ~9ws@hcpYiCDc{d)0GbJmW<XI(P^i7$=rxGz4eC<X5L zxPDW;da+gt)q7_4;F}1$C5szuQx84Ys{Q%VD!jN5HP`9KhMgRJWRi<SN?1Fa0Z1w@ zj4*aw8|6*!+c;WeN_Up;b)+R1Qy5&~>V;703ZyjItm&f&R{OPU_OkV;;`J4`8}=Zx zu!$8M|Mp_{OGTr9R`XWiy6C}tXY;6`abb1W#MJIjb`Mx@mi&KKJs-HR@)z`d-q@IB z$7WDyj2&xZwhfm7{NANa%os6jKjr6?!ok#Xk)&bX=E#U0<(zzVYh~HoIJgmxOQ?v_ zd)D^?K~`2^c}Y+>KMw#IHoTiFJ}9Q&^Z02xw4%4mnbAMw@}Y32kl267cSv(U#Ld;+ zth3@Ei5Od?nE`gWYG{61NTgT2R7NVgiaG)kakY<g`&jyfnf)##B1isOym5S|w>!7T zLCNVlY*Au3HzT2bLgw^QbWBfE#zi(|#(Nd@>rIFTTln=hW&@TQ2eFSLDO-zO!zhsU z?5AcUM~aug9ZCC*+dqT6T(}b<4Zl}W=CyegPen0k<>L)PO?Bye$9=hD502{&w*T4l zvo;Sz^yW2`!XL%D!5Kdw?c(EnU4pUF<ARP<a`c5D<6{e@R+dZr;G!7C;QJK=up4AE zC;DJd$_Hc4XI_wqSMxF3a*y;7zkE7M<^^b)Hyzvxq4GvT{AoAv7<_Gbx+#Iq(&Ci^ z8w5Nb=4<3l28ZBn2ne~XmBeK*8r(tyXzueVEFFCHy?}qMC;a^<magN+`g+I$t8vG% z@U642^XaNJhYS%0$<LhUHjhT%&UVqbi#Sl+NSp%p>;Z~q=YN2iN+Jf(|KvBpVSV55 z_a{zP6U9jIHX^eH)*5dGP^TCxf<SQt(U8cjksG+dZQAgp;_%1dO3o^lCroh*qEnlx zf?v4jpgJ|b8anUmgKnbwdNytL@>nfPZkx`B`v`_Td{py??`me8*yS90-CeJ&y@CFs zK$To$>Kuf{GsO3UWl&9f>cuD-`}dID52ZpmPW!kYn%?|3FImx)%ChN658wqtU#a-d z7O*Xy5xW4_W3i|#I;l)F>Ls1`ExWd8V<1x>+|I)hJ)?pdqGr-{%Y8>OnNV>aEj|>4 z3^zTBn0K1jFN3t_(p7z~Y<*=Jcte=@P4F;}Cha|o3<uj==$`>EgJznN=)CW&FUG<O zJbRq4zS|%Tf?_LhUk3yI-pDqOpZ56kiAJln#FRqX`m>LbeRoao{eRjc$Kc1_(`h5j SQR$Pm0<uFoAR4WF68;C1uWVNU literal 0 HcmV?d00001 diff --git a/docs/logos/xsdba-logo-small-light.png b/docs/logos/xsdba-logo-small-light.png new file mode 100644 index 0000000000000000000000000000000000000000..0ecf126497d73c1601726474c5767634ff91f5ea GIT binary patch literal 2306 zcmd^>`9Bj51IIUGuE-U0mxyvES1fDH6(h&woXBlht_@%3SC_9jl17dphS654hg_pl zi!^F-GmU%+L&#Mg&)@O<@cz7CulHZ@xp&pkMnp(X2mk<x*x4dnj_iFzh5-0zX@&0w zk0gk-^^64ofY1I1(7#wi^eD>4S$V{{MhC~?{9}RuI2=wVEGi=QhCen)CpspibQLNG z00`vSA>eNKvX${<Owqhz_d1uG!VF7x?C-M@<K-3Cuzc{AqFQOMSYLXxPrtOvzAV<U zZi3|-K0&a1)N9vLg3*b3tuutbC#IYA)P&$jc8Oz<1#0iu&#TA?5?y9rENuVTwsAT! z?y50pKFi=18Z0Kx{4`G_MU%R?ix*Fz)QICP0Yw?SL~F}go9{^ZL+4NGTNYd1gqd~d zE2!o75qgPv(9aLKKNH#W<E>ajf3@P%SBD?kAv+h!aa~ybzek!vJ6tP;g2>AF{_yE> zy)BlbG2L#YsPkXnD6!eEpv8wLPv?vkOm=FEsf;J!KOK0^^Cz2Ox3bC6!h4o(|5&L~ zuAH~HvQBLxIZOZeSu&Rqr8)6SL$cU+={UrYrR+g{-Fro^Ff=ZFD%l&n9X$Bx_Es!! z=aUK1DwbsVXa0q9Vq33c4IY!WH^_I{!K&rX`f-hB$<0N4M`YMk-@Bgoa!<dnkZDzu z_ajKvPA8D0%>d={<mpA}eeW-!ov~gYlEezqPgU$Vi-R+b-?}P35Xx*^ayJxZ8hQ-$ zks}0>1hlnwvG3d37vO^<g$$XC(fR3JYqLLFx|E|USY*ND!x|KESQ+GM%%{DOH?;#y zH$#k4!W{6W2*K~nU}>z#8AfyH5~p4IntSlxU*N==x=}4^)5om8SK1LC>I^wL8~a>2 ze1^6ZX&>}jmh`q0)j#3@Y)!M`oXDOmjy*X{6n1UrmR@r%SgpG_M~I?Xw|TWbT66#E zV{#pfc}bz8R4<U9#3QtBhT6(fm<<dIIMw<Eq!v=3LFv7Go+2_&bgJ+c4B5<HWpVme z<7_TA%+?OY!`s$+9ZWaq+YiMF@N?soKI;=SmTPb$`18u;d4g>cQ&)R4B)7fUY*>57 zg{2fmxBAisxC;zA*DO9vsHe&}Rg<Wg&EK{goZW;)6EE5g5UXPxPes(D{IgUFoe9bK zfei2f>78`|f41mh0z5I1qRceYRs5wNQ?vX0Omv}Gnp7Z3LsCpvuJRVi9Bz=#J}X>4 zA^2n&_GB+`@A6r%QS!a7JZB+AgNS~0ct;{Ge1^<)H)?P@<N9ljNXBsKUp_f?qQ_7o zrFUM2d?RM5{RJ<O64kk%Ib?<QcLws!KCaMk@e<omZbFNj)iIey%&qXC!vh%7GV?_g zU}~We7Elih?Z3O`$=O!(_8U8^OheXQD0m!|PwBm@;8L`|6!KstPA{(mJ6ZJm^Znrk zC+MU(lIMQv<@{5&WVLeVT3-aNPX9o5r)DC95|S*TRgdlpc1tV6o0|qNQ?7lLaw?jG z(IUgVH#nWzZ|Ku<x;$VmvPIz_dg8X(HfAP1`gcxq`Kh8?Dhf+U9p~PtDI^7~%17Az znmD#$oA>NT0Mk!@XL7}uswo=nE2Hf(vYLoYtxQfI&NfiWQ9_&2VqzrNJ(^vunzl7c zLkd04)-{(7$6hrWk=A=+-%-80pl%SdwGbzdj{fF^f2A4&cNTLn)s%d&SK;0w)yrMn z+n{!RtIk8bRBGdw@eedD!T)ifhb6Sb-D#K(2mP4%`ug~4F8_kllwbZ`u!L;MM+3E6 zzWvoib3Iz7(xHBn@3aZp5}L)(JDJ2%H>_B;RqynqHx{?H(A5)6m;TrhuJFC4eU1e6 zNvvmlQGda=;P;n?^B-0><MDf8k+rM6bI5aleB6%XW*Q|Au6}P!!R_tVdM^j+cd{&_ zwxFK63<_a((67bnU@0`5oBUpQsv*_d^H`OTLF%TGr}$e}-OYi91yUL9`HyaU0|RX# zw`ezuYc{TCXjqAHQR;f|a&?Z(0rI*AFq#X4&?9@|=hr#PySprovLP(x#>&6>%(0;Y zwTK0R;za64I06ldavgr6vT+XEPKg56`;M7Z<oLA0B>WP{^pF?}E@9K;E(6T=LQScv zoM)S&rtp2Bv`<-x8Xia^B@Yy+oaa2OjtEr18tX}nf)CIr+&x>twF_)0dr^UtD_Jm+ z5x{mv`H~cq&tNa<K|J`NWXgxsvYD`6&@>;#YEDjERs>oy1%4_u$_p)<a=$;-1%dEF z!IQ`0Qhpx*)+C<F;gJZ_!{7dxgpW2E{pq_Yu-Y#k+xq%NxkdY;Yrd$J$u9X~k*wTN zBct|94^n)1UVu2y^KNu+*+38N*!wn69Z)cjF;L#Lg(T>QHrm<m=I_R`*H5QP8v|iH z3HKO<D*9Qu_I>UsWJum6-sQ!O3z*f7-=T|7Av++fnx3G^k3ebLt_=WUF8De`k(m9e z+zho9k17{*;I-)P>~>`Ph_63?FAcJ6&q+oTxiB7U5V2wDnp?ciT3%|&P?(mgie!3H zCC?~-lSDxpNHfEW9aJd-;W@BJ!K4a~rzeRg-p-W|9XX6?^FwR{Iq8k*B!FNg0ufco zF|MN0)p2ctK;q|{<<rMbs?6}}@K5u4WwZl;(!eyP(l3!p@D6ZIVUSmWvAQoj2yo*O zzy6T2I*@xwen&}hHX`H49xkblXr5RenY55)?rU84F2F4CnPT&(s3+!*)_*LeCr<sd ilHZ%a`2WmRhoGL|uk)<}XrH710<g1kL{KfRXZ{zy{#gkC literal 0 HcmV?d00001 From c5e5f6bb73b246c62e2485892f4ca72575e4c8b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 1 Aug 2024 18:52:39 -0400 Subject: [PATCH 042/105] correct size of logo --- docs/logos/xsdba-logo-dark.png | Bin 30117 -> 17368 bytes docs/logos/xsdba-logo-light.png | Bin 8032 -> 17476 bytes docs/logos/xsdba-logo-small-dark.png | Bin 2288 -> 5620 bytes docs/logos/xsdba-logo-small-light.png | Bin 2306 -> 5578 bytes 4 files changed, 0 insertions(+), 0 deletions(-) diff --git a/docs/logos/xsdba-logo-dark.png b/docs/logos/xsdba-logo-dark.png index 235f994e542ae8fe2d1d66364ec832ebc35ad130..05afb6614791156127bc905259e92ee4975e6ec8 100644 GIT binary patch literal 17368 zcmbSzWmjBHu=Sw95(Wl`;4Z;JaCe8`?hrh<ySuv+WC*Uo-5Df!@E}9*;0|~4yzl)3 z_rt(ir%z9xQ(axPYwubUrJ^ML7L5oE006v|m67-i0KnnGK13+Uuq(o?1KhBGs9$At zTmXP~J^wy%JV<KPu#1GQlG?6nj+U+-Ce9WB4-bzI)(*BVW+q=PJ~%pC<(vu-0RZFx zSqV{f&)kzdA77k>^;h9d&W;?Pe#t#bMl><(#P5+PaM?EYl?yAxH!oK=O;5)|Et;pz zCS5@I=*7jw3A2J0WqTIwN<X_3v*t4As3t{?UJ)P=sZAW)`PcC&<o@M_hZu!@Z0dAs z3UWI2xYtSDVKsHj-`H3nxbHJ{Piktpi^eV7!C4EYR$rd%eky(noIYD>T3pmbL<=QN z>#k|waGh7zl*+xCqq=M>Ewa|mrw|$))CyvMCqV@lN_fGO<SB`5$c&cpT3SZbKG&`L zb}twVv9-HOkdplsH6;^d1S$a~83FGRRkah);t&agNAYPm#ERk<O)f^o)yk#vZdR!- zQ5Ki>Bbt(oLbg~#R59S;$OBOT?AkyP3}B#NqP7lq$2LR6dP`~*ZrYLm)iOe<g~dJj z9SRNrD+pjp8`x`%P2J0kDh2>Viei*a#otWDuohgt+LXl~I^S^!a75k{a~G73^(u?B zq5y()FlZSiBoGr*FFcBpf@p3N$jIF9u$d`rCHI(YUvGwWzDdU^L)Qi#Z_b2#<|B_N zvjdC_76#ob{Vqp^{AcQRj=?5R$$>w~X~-=l!?KV>h|!BL<hd5o-oG=F8%HUBFGH3) z+e}C;lQPWPr<fyGeKAVKuhZ_ZN}qQvjVi!+AeUL$?t8VH9AHQ0P-GjQm{#2IRon%& zLdaH529Dz@*~MX_X%2*!;IE^y`EeHLnJQvcu8WUVMu2sH)&F+#TlL>bh6XwH$Vdl& zcdH88X5Y%gkC9+D5<b>Hs4>!Hc=OzG^YB+j<gxYNl_;GkM1>kXpNa9cHOkk`<G?_X z2}A#H)GFi%noIUTRp}C+DmrFTL1sUbBNP^qgg~dM3N1AUlG}OCaE6ESd*UC8EnqRd zF+9~GN5>T%Y})mL4+un9d6D7MMpwROI_-9z=E(9d^?t4Sbfo4`m+cHCJU%tEhn@cL zvWYn>DnauQu*%oDDeQvSyIFe~kVHdWFDRXac6sJwtlK>h#ccDrW`U|gUn)6YzqRIo zF@{NriI9b{k9-jJrbFvL6D>0o<3x0I4(_>qzKQWl*TFn6awr6YZ&Ru<tR!la*>3qp zmDs*aVmMk32sAiz{7~%M^SosIhq3^D*oQrR&E)*yM?^S=018wT9;`W}{?JQ89#z1) zR`(opz;4V!$iOHnQrKNlH&b4EpcacsDCR0Hj_*A%`D=RnS}$Dg@QHAA5l_zOBV2bt z--G?8)65$+^IY&+t9$igy_bt<#wM>QZxpat<Sc)yS-T-)tI{VN(ESD_q*=vV=Iq!N zSq6Bj-)XXXV$GFGNl3%UU1LzG*lw(8xa3rD89W;TEbibJ_z6lsrn)=Kr&!Nh7dH9J zQ|@>07U2i;M(atp@l4*Pkrv+q8Fx+CCrb#%#D1YRoHcbjWs<X_I=v6d;u#_KA;$Bv zeei5dty@>X>hwO>r!spY$p-UK*i+)IlyKg*o<j4&$tf<-$Gh<4p^Y$KlO0`Z&JIFE z8rneq2v<Nv#Q3z%^7buK3sHQ?k>uWRvu$(I5I-nCgpww*RN}LAa<?2q^9MoQgJx}x z3}ZhvcI^%H8HsW~_OWI--rWQTBDSyghaoxsH~m!Kq+&nNmCfxMJ@?ID;-@@tyVxc1 z27*rPO*emc1r>=;L(ZzR1ucTqyfnNu(4wu6e=bt36Obm}BS}grJHhw*9{RF@q73Pn z5D?*&np%!Yh3|`5y{$nUF*)4!j4ZL~Ya_jg@K~ToC3zE|ytN3UL6G-vb>4JlQ&yV% z2NA)Zayzib&HNG1i6bSDQz>6sgvxF1dZLz57z$bEmt3(bqMZP9O66%e84gvMPYKRC z^XR7<`F_2)8{4OGd8wSN?OYI27cQ@B;;Bf_{TTZp&hrB1iF$%2V;E4!4SjXv)GGMj z{U0&6OOTL1?D+ayzPRLU_8cOp@#S3&rLB|oS7=HP_s@=eF8Ft-qvmQnF_h}ME0&jj z>nRpq%-c9W6?H+hwgP&s>GT;GC-nawXop;3{So9AK2kjJV7laX{D5{}&k<ruAJPwR zq}^1+P=VL2(fV1v0oC+?iTV9uv$p=|(_~JJ@B5cDfCkS=OmiesyspQrXMlE6{iHqH zvNAR6dFYTJ;?eEyBOihXn@c(>8sP6j43P)_C-?(C)iI&@mJf)(&H6Iht^crUp)Q_{ zVcxf&nnD>C7mwpnSP{G$n4Ig?ZUj~9v4a2Z$v-C>tEtt`b?-9%`1ldW^-+96)V#j1 z6&?F|&!_&4vbtS3^_zC($cf<V{JQ1INq!IL{Z+#%;pphcxTvjN#E;7AxgwM^drM_r z{ibAn4}$k$Zzw&`lGa&LQ-EYn<4tso*5$AFVbnY`?`J;ThSEH*JsnSVCiYa)wzwD* zIgJq@h!d4?^I2?waOo%z+YwgwF1g7VombNAXqM-3=ouGm0p1C7-OEUDIhvEX&dUss zH6UDfd6ae9OonNX?K=#|)?eOGu1^mg31+Chyj1jn-dGK#6^}eHptm6xgtsf3KDY0< zaonuUOxfDPz*bWE_Y-Y9#M<aM?4{e;eP~X}drMB$B+x}(69B&#<NgY{pZ4lcX6$?L zHd>O=Md_zedNid&Br%@Z&vQ8Ga8J8P+L3Mr|E=DkGx`HUIC|c<W<V9;S#gJavF5MI zAZ4`XJt>(R&-=dD)ZXh_auP|J+|b28ztH32l+N$&?oNGOgstXZI4bM{b1iPZuGx=j zSxd`*$PUTcGPMndTiz%UDk0gTx~3ut>2sTH`%9Dj34`S>I#z+NEb$7(gc<4&@=_U5 z4gG+y%V+iE{clrWWN?su)wh=D59eg&2E=ZyQ_HPOB9M?SknZ`L_Njh<xhnapVsw7+ zTU`k^e$V<Gwcz8`2ZN=z{u#$t6+!2xeEj@;;qQe!|6u;fYb-VT_N<Ol*t~bQx$ii< zucde%N`n=Aecf&1MdfI*E$>oUDqkJGd!(tUVdu00>K!WXw_UuVmYLn>>KAVJOIS?b z|JD#F6|t%(QE&83tU!vQfE>*&x~@#Mo0fi-hQ1J$@uwX6Z~|d~CP&NL3XglVl?d7# z<<gTs=Q~!hB)kGyE^y>)?{6NJ?kuMR94`54hfL#*{km!=0v3Hu-M{9jJnAt>d_me7 zV6xJBT6Nz+*c#82Ga}87rk^5W%DWjb1ovtsbFaqK4_dJlx;;wy7KqH{-V7PGDoVv2 z*;u9Vf1)cD<`7c{6qaFQJwr}&vGEw%RG7vKc2FmJtB{(8<5s(;5%KNJ9gGTM2<Zq` z+}svYUM+G|Q_N#wE|tJaLMH0NQyv;7gZDY<wJX1_Gl!g<h&a0kNxDNI{%bHrO>JfN zA3jky4h8khzKQQ6;n(ph@u)HM^U==>`E|LJD3LXBikt8*X)vc&;7{u8s}6=Y&jbT( z-c1ZFDZa&pW)PjrTVX*Y)prBVSl&MBH;=@C5aE8d)g0su?sACA`V_Y0$#fLCLrVh6 zR#g~b`3fMXov!#EmywZvjKu^_4t~ww;sd%o8w!?g&j~HI11R;XA7b!%oY>Y%>1%T# zfRK?f5IbG3JoXRcsHn-9^oT|qJ#!zq#GgZ`7l1_ZSb)tMecm0*<aGR3%BPZvz%=tJ z@ZeVVI4A$*GZHTiGe+tzaU0FQ8Mlu)J?|_t(BxK7;GQaQHPVjq+y|MnJ}?4$x#mWG zyn!!*nOBznT3T5@kE&m+=$6~>?bnV%ZDKVFa_YW<DQZ!;261&jAbP%6nc)0Fo?5?H z=;xl}&J}xNS3Oj$FJli-R=8bf(Ru<XQ1lTp{(am{sUw;G7bPROq9RHB<>d;shc#EN zA3ogzj`SwT&aNI9gjcosLWXfK1WRBMT<o~W9^y0m=~{}TJg~K7)B!Zi_pJK!i|e>B zQzbP(Sov$;!O$uHNwfxRYR&2ml4<wszu?dj<y&CH-ndOuE-0H`g^ddUR|GLX8e1@7 z?alLP1V)5Ee-rw8IhE(7<de)OQ5Z&?E&N85a8|4y*;0bwZW@=96{0N)r{5{Zi)#b8 zpA30)KWg6?uP-5z0A#9DpOmCxXJ-Am+GTd#8V#!1d2tt<Nv0E3=$g1`5%=TD$`T2k zQql5!)$`dzoZtLz$9&y?Fs7%pXV6>0wi(s(>EvX6l}-dq1fZ0`!=NleMUgS3HT{GL zN(uyo0<co*)mUG9Qv&X<UC_JtJPqT_RSfc>)9_i#VzNRi6I=9=-MU&D=UV9RokOc| zZ~>lMM+;h;Fwo;}_-pWYG5z#DzC_U%i90S)KCFABB;~+<Z}l(Kqd<vndR2*pXmM%X zDIzB*7$03eI@xASvj2CURUE08e?zzQ6~g-7++IYoV8BRa>7MXL+hv&}41p`PyrUzB zXVLF@<|OZ)<;ps+5A0K=7+SK~PqpeS1n4j`0_rSJ^><*{Bq45*aq2HVGIqOW!StJg z&4N?|3Pd`e4*(SGW6UpO1+2bdkC;-mU4;Cvz5(GV=vZG~+LwgiMq=0%T_t)#xsj#e z9=uyn&=SMg)4Hp&_?MOgd@p{=Xiryfv6y)NO#0KDg>9zO>Hjzq$)Tf?9Ee3T(`onT z;)?c25(%&f31dHz*~5~}K5b%k?^m$GfuVkn%f?f@^r534ezB-zt}6-ivf#90(C^oU zDdvC=1{*w*N|9&)NFKUbq|+Z1Dp-oErS`V}YOmI7ZS-LFyWO75qL>+&Dq)<5xSkpp z48NNQ28bxSH5(ELe&t!xWe)a~So-3%J`g7(G?RjyZujK{MdDMFig%=NOppjN!loYk zx2IRTucKJba{s*7;x}ppWzt%7J<yu!#?`TBgQdUW%k#|<O)}Z<afwJ{wm&{@8fgKp zD;ciIF2(Qwu7w%?=>9j~RH<MwD@yt_+M#FTpk^lcdbQT<s}d?23NpK2PmPVKCOTT; zH`x7{ig`r#W0>y~dGX9BpsMRsL)Vu?#P6-^nSa&o=&~>cH$49gC`=bYCf{eBh7*Nz z*8cZYCte1RqLi=|D5NnD7+d=sOmvz|M!4D*_uxj2i;<WtHTl|m>hpG+{>7?`+wtdI zvwrygKfiyQu7+BiKR_|DtU3yFNx?LfAvCPI>@KELC}>+zXn;aX2aA$BmYqC(Vu$q4 z`3885cVF7WEPjVWZ=GtIRU)ZT4fX$(kL3pS#LDWX^N{M;UCfx%i8ccCpT7n=VrnoK zm&z^1hPN|*Xr*i&&8hx)j2u$WB#gC~u-eTp1muHrr4%hJBruU~f?aG|v-<Ykkfk<^ zo9mdrEWa40k79|c0(+Bz`l?(`adX`~VRVdst*_bVzqviS>!+=SkHbqyR&jZbzG<RP z6vwSXfg^}CRxSQ!mO=cm1o<>&t(+U0>B5|mggW(laT~6$$@Q4@^b{;WDOxYU$jFKg zprsWVd{L=wlxr0u-x~ZmpliYqr`e39v}X>N>0{x@d(Ft+I36P=0&e8w@NGf~1U}a8 z>t8!MU7Y1VF>j|b07fvQxzW+2NYrcD*&`9@p&rbB7$F1-7>Pi53?O@o$)Ay%vo(*A z&9kTB4fC_j;J1p6NQ2U*zsylE;2X(-*PXOkNLY~z@D`NOUC2Oh=TQJ+g`wI$*3fAq zj}A9hP$`d&;d)Zay%oJ?&3@<dUIF6-Gmy!n!6E(^-+^$<oG&GC#P>wwU3h9Ula=Cw zeZwt_-ss`{o3RUMz~(BNu|u7|vVX=O9wY20A}m?a5-b^Dk^_MlFo~LS5<n;+5l%sk z6*ll@Gr-C1XM_2PqwTRx{@3$F^c2AWmk!K*{jYr*WBIkxSLw~Y$!#M2>%Ef1*_K$& zRTBfowDUE&TnA3&eohF6w^l%#?<4N`<J;U^NqU@)&;FaE0o)(`d|47zK4%~u8P-x3 zA8lMqX$o6FfK8@D5Hw{KQ}gQ)dnB#}vkt0a+aE>y>2-kz!NYGA3)q;L(U-UkYVMmb zZyzmhhSdqg<`<^ur|&-~I|`_>_Z<>)ib-wM83a4aYZDOMp2gJ$d?eWC)p@#ID!0yV z4Jw6XktCK_wpU*u?yY+kn<g)C4u|T-OS&JlLs(2qvX{G@9!HR|)5C~c43T?UgLpj< zkpP+JJFxuO<Ftawy&WY7FW|a9{~>hugW?xh!o}9#D5zuh^I9z(bQRw;K;Do{7qmcp za9Xb#e|2BM{E=)y=JB9&9mJ4V^wf|i770tb$XcOGTz;L>+IUr~?hM4f2qDf@Vf~o% zQ_QbnbN;P_%Ie9+3#nLn_a>ci42|4~zc8`E$18Qu-(r>=3%+9o3^o;-j~SSb7I?Cx z-gy=$Q~zT??%Nl0ZCUW@I#CjrZhzsi98nC1xM`&LA2g9=1=2AxsHhqIqHtTGp#NdY z+=eWF|MjG5ynz2ix@;>-E_z-=(JldgGQSQ(3|ZKMdXUP^g;w|wHd6vQVC}RB7J@p= zH}YK!C>qTj6!w0u5Q4h!<bq-5!*bIAt%`e>WVtYV=2Wx&)i%%wTN0CnS5{}<-8hWV zbNkc+mtSYjf%sy-UKL%y2U~ADDtc&5&(F!$LrZ#U&x|lt!FxQD%!u7~7D1^aY0R?% zb5=y!$7&!w{F_^lNMDu$wYPI=ojEqVF{LRoYV@8~)N@FdEO5pj!^+;U{E%|+q6`2q z_0sp=D9T^^z;jQ;uBN9~-tF^vv)*N-RUYE4%tDc7B-u5jK&fff#LwphOWe~Y=@=;D z9P*S5VWOWS%!AoPn4>7N`p5|&$N++*)5zDgsGXY!Kd-DM-4yK|RJlV>+3eX-mbZ!n z@T%F6>>0!$YAn(30?c$N?_{sDsVU*oDlMjK@?56hd-Uz6G<O_bpLC2UGWL-Fy4?JA zxfs+qlCOnUNGw4S*g-h2m^`2`ub60p>;?iNt7S$GkfViI>~3|343!Ryub`pD6lbND zpvKZ^Lcae+9D?VlFv)hR%2)O3?48!r`3ilu*~iW=)Q*M~Z)KKJdrn69EtDByLzBvc zb7z90^?2L?YdQlLmE#Gj^SA9+57{-r1OXRPUR5I?+#GEopC>HxP7MxcWo`XsDXOh$ zrtgfWJKd{j-X*bgjGr28ps54Eph?4+AsrOYMHo2!9Th!UmCbuvH*IA%HHH_1PQJz3 zoL^XitE^74RdbMnNkPfY>0C0jom?Ip`BK~ReOt&gI9XHw!fBtBsgem(&gjL~P-~PF z<*t&B{$?vGI;1N1(@kN)o~_O%uCtKJV<+q~Y>|OAu8wVh^|r?EX6@OKLHT<PT;X6k z`WDy_I=C{sRd{^ZvdH2f<ZMPwD%Pz7)1j+;_^o{@Nk0fT<Lh+pn2+TAYxYbhUJMOe z^`_s~BSBl})HSx%FW6gs*q-9uxj78?jia9k9fG>UCoONGM!R?xZ*yp>YjnRy3&Z^9 zmtxePPFH?-HPg{g{oYe^qF{Lw|NL}4HSB>VA3eemlo=TsI{t&Q5br9a7Xyw0MtVXd z!~!$JilkXremqVZ7T7ae$sLo0s(Go;T-F+PV6-&1Na~D#``pkMo{BwdEFzNOm0Vaq zk6vOPQkn`WK?paIAz;Ixnty+zEVPrXW#6IGMPAqk!r4E+sA$a`Vs#`#kE+0y7z|G& z$7Z}osYeu*>thcy`FtiScRsb@XGG+8%G;RIZ0jY23*RT>2>WZ_-t^t{TE7>B6LH=y z{Gse7`a)2M?0MB%crBie{`8-zTt@alo8|`H&?Yj5q+t;jPD9@OO}7HrXdfsI!+0+@ zni~;adK<?fysx$e>ap=WGhd-v?sxt#yAt+a=<M;M{Dk17Hwjog>Du~_f^hI*0TEeM zi>owCr*pfBOlbg;BPi;`nh!Q7fQ5z}R6<(j#bNc9COq%pZA$^wF%k1#4?tr3oIeko z{JpZW%32)ki-%!64-F2g5o#nPtM$vC8tq^Pepi!yd>EIvHf#e4|1pv@60O*UzOaOX z29FZF&$2v|dbKN*a0OdFyzU=|8+Z%X07G@y!xvtR)R6~eH2HO{*vjf0f&W-Db}biL zG`V(il(DO~wL{xN0;*2DeGg^ZDuEm5<Hn-0OKMU;#D_9E=6^=Qznp{()opS|P;h9e z%wk}n_TAkSzvZ{&J&B2+bddr&#~PcNnIzR3<E1e3WR>+&|NNrv+Tuao^(25DuVUr% z21NlmMJiFq@{U4B&UBHQJPT!ps}5==BaHaOX5Li!t-8)tTW8f8w~SvFBpP^q#=J5U z`maEnvzw%Pmk(}DWPSaUbq^X&517EL$n#!!Jq@m6XpXXe$B8ndGGEl3K+nPt5#;@> z1Xb|*!RN#}ba*fAQNrRZ<)NDMv81N4NFEAKm6}gPKC(-6AP};A|5?tY_b*}98_IB1 z@?SHnt1Fk%1u@U*YmpM<*pR0@nxmZJ2`deUhV||dS(t4Ie|$V<q9^=R<@=O*zE7(s zt!E|wWt$fyMeXBHPr|3-@8DIDx;8mTf$(`aRFYf9{b&}2IB^|$tgg?SXWU!cii$+? zW5eyqkLbK{4n>J<#A%}o=eh5DTAuyeIED&Cl54YdwdB)ZYAMBFTgE&zRURvo@)=^Z zT({#)T<v}J-=UTl7Y{NLW>1m9;X9Fs4hV5vNnS2-D|)P?=nuj+>FdNwI6RB)Cn{T{ zp{$ogWk3w<@IS*2HQPU;>!neymOQC6c$<Egs)ALgwPp;2M|>_ZB>IoIH<SteFzqes zbj3hb0MtH2jq!s`1NN1bi5#%;zRlL$ZDRd}c^?Xt$9G&~pR`tXhJyt=av0-<QZQ3S zm>iRLGlZvKm%<+M%zV9y*E8=LHP>y<pATMEsH<QA+JiD=r?5nw@Zs=KKCCah*3ZS8 zbHWB?U}XpS8e<s|hO$a-Fuk%|yIBw&v-JQhEPJ+Mz5L~Uk&o54D{4JvFcZr+Zl43C zUu`uc@bhOap}ejpy>DZnKc!JNYo7q&9i2<iO#TykFb{0T?M0nL3tNQMV~{5Bt2fU{ z%l*b^1yp6JU>w<Ioyt!f6vyS|p<T`cCcNr^br4<*IkaTX!4m_3^^;~(_tSUNm7%nt zr)^VNiQvdgk&;H0S6Xbu<mAXqq>m!N$VhtE!snH!Z*=M*8+qx4XJl)1d2sA=r_cPW zQU&Z~$4&jN7ol^8#)p305Bo`rR3~OqxhGa%2NS~`WC$%rBPmL28f!RR)Ul=A#JQ<s z!5`kP2Qn_LtbFEa@qIe&>@TJVMFQZ1jO)k;PvJz8b$~$x<Zi#}m%PVAPynLem*%}B zFo2mu741>IpL3aOYa+;XzE&B+E9Jk5PCH_lV4kN7uL1X6p5+_-N*%X4`&}v|gTAn7 zpy@u<#FQ-`fg#IirYCPWQ6J*PGO&|zEbOILSXk!*$ubM4F(U?S9Ps^BSjuwFc}NDa z-_PSO8yBgPMlELukhy*)@$PP=Iv`1gn2PML$tNjqozfg-I~bgz%FDrE54$bgN&i73 zQ**ySb!(M+Ou%r5wXNXPSUx)7_f9*B<|l!J%dBNx(XZADdj>#U+2l$`gC*CPB~w{a z)-qEH*z7%gqXH6o$fYTL7Mf~OLY?<-c|E3FcN#UAlTt3i>zWPR$W87m+D*6;(9<e* zILZ#hJHxhCLO``Xka$V#ab(yYH}Vk1e{RchoHLl=5QjVUz`j0L;i=U?5(wOp{-lVr zG5;7emI`CwP=-pZg)elOqkc!pp~2{?>x;!Gau|3#E|nm9@QXRh8RkEc`3D4({|(MA zMj0om1&fLBCwb0U3)@-JKOO`j5&wvHSxHjp1*K7=z!%#NK+(ezoWD<q$0~L8-d1-0 z=^G(fHhCDV@*MXB8=qLAe>%MirFo}w?zAe)hEn9X^6A}ZJs#S(6#A#ij&da)T{VO1 zAKj$72;1vQj~1NbNYVk&W^LpVP#Pi%GDW-ajBC&?NlX!tPxc|8%lC#x+S}0k&ym`< zkxQ`zcA$|q2bapK@W97KQvFW<2_z-{ZA}>Zmt`Zs$<uNaBpYQH#hR};SWjRn5PXr@ z{6U({$F-sfd>{*lRN$e5!exsDJ7LOPe%)0F9V3+dIa|3P!`6V*@({cImAgxi-p}jH z;rtg{|2r*_c(*Wu0UZglb6w`MVNe<mP$b4^!{6{@aR%Q>OdcC}V&rA>YDw&1;-8|L zu<!ATP5pqMZs#{nFhKE?012qL_boSY0{wb$(u0R<a@}chx&9K5il(MLcd?j>l}h^W z(RBaDKhZ>PurU9^RpWgR<@~59^c0fOlE2f$<j^-!K8u;+h=FXGj`{3K-s9PtUW+S( zASMD33yg}4iZVfggR`WBgQKOTlvR+RbB+3{`m%p{VdfKhJs#aZ=z1}ouTLMUoexXz zyRaQ#=>gC1>?MtR7dw{&BYmnVPoEn_zE6n^ZaV)4qtEk~9BMdLW@MV_sGDBrLMn=} zb4Rs29ChxlstaD!IBq|{qTnB!J}nf}wXs~fs*Chifr9ahc3#V)l2>M>%P0|&%WHGq zVTwt%Zs&a%Dobf|{1r;a`26)$3qRf;`n~cto|#$hJI(EJx1XavrzIq8Y^CS2w;S5e zkU~f6^Ri*!_;R}Dv@bke&q`A1`1abDx9HZFVF6$4%6E(q%i8#4{BS&EYy}yX*8TiF zHb!4lW9xaT7y<Qt5#N}5T$SU|W0sx|5a3+TOEcnKS1?yiLaTu|FoLk=bP99-6<@>= zVKlEi_DhM;<+G{DGn75hcI$t80oau~wyE1LoN|Hz4~7HrKm7}Y%Pq%)ftCo$+7$GH z^XdsFA7Xa}F``lBYkCFHUV3Zs7SA9$Ca`df4A*2Veo2q@ZhyXx9jjj|w4mv;iZ{4| zbkzVj<r8U9gA#*A17wSSdZ_)UW7|c%cSeM9B9K?BITV(WmY?L<CI|b%CF1{Y&U;)* z%)Dc?y?5W<G6dws^lwL@1(xP)kig0EE{MTVnIguPYbwbX6kgSN4`-@KFuf24GUKPu zsXcOB{%SXQay}^Imgd<_q}uHS``(6CQ<Y%sr4|B#aZ=x2Z6p5wEN!M2h7cE9^U$yP zSSS8=2k3e(QrgbC>gk;gmk<$A2MaqY74=KWSC8woGp`Yc)k>>aRNNL<!Cna+MrH(s zY4TVuw5D9F^jzFD<DGcUCNL~yz*8E8+|A{29^<Ey+SKH%XaL#$(Tsc4gm~cR?i+e< zbN+P$>@_hR(9%inEk3-ra+S7lKt=OLv<Nl}o)uSgvyd*D5{8FW`)oVDecdDbj%#TP z{V=MmVV7(*g35SzzFPoe){pw-7+Lh7sI0vqMD{6?=Ka?d{3Eu;H^c^oPIu=tNACGq z?j9tR<q|ORibdQ)9hzJCN6cqY5w^m=W&&(iR_AIaL?Sv#SH%`I`Kd^`I{)d!NJw>V z1IFyL*yDr^KAIfnzq+==xBC%bE*dlR#K(s`EL$Y(E-$V&>tooFmJ3XijO&;v_DagN zDFUJnoZSkZ4a2nR(*mIviE^l3Too`Kkz5^7TOi-QKl!@2;m`dr$7wt?wNOM3&wumM zLy0(pUHr$bGFd>dn89rzhmJP(=2Cv3Tu%@etjH(KMvfq%uvH^l``g&DkDq~?hDPxO zsnYCqVJ?jXl3SXx1x4}Pv<Cu0D!RCKiLr#tlzR6$3$e4V#v{cdSqk3tmcI($XxZ9E zw6<53EQRtpF?z@bD3j*#WubUhH|~t~VOgCZgz9S7CKt?%=`&LoYVOKAarDU5KGD;y zC_OzLIQkzt#W<8!GaL3;(5JKjsHMo~K9k9SG0R4V$1aufCL#@#&s=dJ@DRn&?Y8E| zDSM~G4L!-l=<y$~H-Bmxr&$#l1O9a9**l^?3!0(H$E4Vdz4tX+B4&!fQ06Nb2Ss4M zT08EAO4DGW!pj1&h{eR76(t6-5gCvQASq%J5RB~y7$PPVeDD8n6Di=)2?Zz{B_tQp za>0QjP0fY$0S=QxW_o!Yj}<9t>jnQn{<XQr1a4+2E9+m=GITV+{8T%bMqyZv_EX*z z2me-#m_ZR8M;BA7TQSFL+oYrki^^6LSxZ0jvsciALUhrf*>&vrjxPQJyR(9J<_FW? zdXHTXS`j=aat-EbU_@d}9A|RjABbVv4;Pm&`7metug11EQOybI=b)L+c)f!aDTHk^ zT(%Mx8=P@rCf``f5yJ?XKh{$aBb7$%X{C|Pxf!v@len#9+-WcG(00dWE?E}WnTLVb zW@l7XK6a9C!br<d0_Kus6(7la7?6|Y_Rv!1u_0J7z!<N_LqGp$YDiq=I1ZN0A!LPV zpn~^aQcg;!(Z-gFyY^MpQ~sg{zfTWQrMZk;k$OLnIx7yyFrM#GkmZk3n~Z%?y+4Nu zB1PC)`%Pr-Vi@VchTSgEdq-GJv%bdVcR@k8$B)VbW7b>5J__!ZZ%%Le(o@koSyqAn z(}Z_M64in!dokiZ?TKYrk!xydk$$|mdk6SnS6||WH-M}AcuvPDs?G6PJy=mODEKoK z%(k#q78!oP-aT!O5%YoC;mv4Rf3l{fd2k&}786)QdHp>w${>nm9RA_O>lPB7dvt*@ zXwb;?j_r@TyGG1V`mY1d=9?YmsQ`yY+c27M5;WSFn{Xt5`A;J9fFWFedz=~QZPVMo zM?Lo8?5^3?tKUaICv48nY>hME5K{f85$kPq=VIdkjN`k#%a_Cm6aU@(ET)GHjWuLV zLDYKi8qGF-CS8j2wfwJRgNSYMpK++3ujEduV%%X1t+u%ghk9r)*^2De)h&0d#S)xh z-is@@Dr)Pq{?||v$Gnl{6g-O;MeQe1iqjqF>9znXuw5VcIKtWw86JJN$k~-(jRMuJ zD%$!v4_oa%Wa#Pd7>LpP;DO{<ySQ+@3e*6$BsmXwc=qcr=G61mZs99a48)%grKfEy zu$b_7O0uyFFRF6CKT60)2*o^k-DfM`wER+gQfE0NBav@}2NEcpg|@#VV`X^``$!(C zt_%N#$n*d;lpI(XB!exVHWj!a=K1;T=LBZJf%vP!fc>O5UQeeVvwSx~@&pI#wJ0mG zvD2)wTkZ`vRwN<aG*$6F->PpxCyYopp*!_))L(@s;4@v0ZJZ|dapTx;`OzG%+=N3S z;B&lunaumT)$Os-z1W+X6ecO#ylcqg3bvmpLG5s}Mu~fJ<zPj_5+xD?=8a=gF4!hV zB8uz|;5jbyc-hp_Z#Ek5ELy;Cy8}v<9?kF}PksFy&-jSG>Gnk7L@2lJ0i#_trRd5k zRVI6ou?`vOw}J0`Som}MBkohs7ajGst3V%c(+cIE<><08^<cDD{L0~Y9(;GHaT7lb zmH~f9pmTpzcAbsLeY|ML3i+l8W6YFKs?a^qRo+JO!3sDjUwG&Gly|L4>Z9kMO1gk* zm*08SI#u&O*86JSzf07Ir_AXPo9gQwfweF2eJY=DD^B+NgU}=CwQ6f+@Mlt7mb00Y z(W9Ye2{4~#D1S;IYf)(arQ}QYzvc}m6pkitn_7a75o=-Ruy)>*ANAAPXkSNR(q$lZ z!A`0@teosEpCdLzAM!t}$?TkrJQOBZSwu$%@qWrZg%NHjiyrIjBRLF5IF;Ya?JP!V zBo0o|c;E839CX20zy0|qF~Ys|4PDZG9aW9{_L`sefcEO@UxH>B*u(DSc0R?Xp!Rrf zEiV?Fr8=93!AWx6+){%g7A7mDjlEQ-rKspRwb;3!k98v;oZEU+se3%}?N31dZo}cv znPhIWoktQ#0GkFGZH%I`Ys8_hs$7F}$7EB6z+)hul#8wCA1kGHSXYK<dStZJ@{u{` z`~XRF<2W%*OsTO%?hTFPitNSyKTvyE0;(}6h47`+5X<J-5@63J$`(wAOAG?q<ET$K z)#hhzy*Mp6BVcFpRd>10j6t>wPsTk1IXt9q#X;sl;UqU&E7!U3%@S12YuY1Sd20F+ zlO`Zv86D-K?+tCpM?C7jVA<s9eFS+*R1`dk>~S-=w<4<6=MBje1M1Gk{Rj6dcj^v! z$RksH3t#wu&d#z6m{z457g-0I<3V7q86D`Y2*g6Cq!69?*vp0pq90$rKXME><b6C% zkI-PY`_fK=tO=xN4Y{ar#o8HO(ZQYOcUe*zX)d14@rwJK;IR3vdG8*~T=?_%4W8=p z5_qOub(AhrERV9vI<*!x+7%V;OYpn*zP58&-=qr)V!QrzHInjr&tHEI{74y15Iz$r zgGL!A5*+C&z9*R^Q9?)_5;@8i3g^{pTV(!8evw--qYzhNR9->d)X3LIvNR2qtg`aE z=dYxk1x$yyiriswHLRhe4={fJ{4XL6zqU}NGYEu-aQwxNk`#j^xCFCRRwWPv3nq?d z=@Bw8@h9mg4j@aUzVi-F7M$16=wy~<-VO~N8rBpx!Ax;li00kXJLa^BkNr2JqAIq~ zc%FR1KTkAe#l+Dl|JZB+a)HdTOPP2i71kopP~(0yYAOX20q4~zi^DdY6&uy1uBkS3 z^N%fta>s}XpTv>dwnt(kiNXqmw6(Z?);9~DkMgL(1wPic(dzTefAw!jo{9G~$UiQx zv6+qO-y$=f+2s*giAX_Z-NQ^;V(IC8()NB^DkT+-20TJblVCOkT9OtWNO$2RwuztQ zj`!5>k_CDuwi*(dF~$nxOT6=IC~KI#COn35x-iX?rM35l=9t>4>LxnocG-SuK<Cg> zt6L;F9X<p#<{EgO4gWlYZ}YwK{UerQXe=JC$XjkQ)=1Y~T;i6{4c<Vrjg8?p`ID;X z{VZ#SK>tvhx9eoXRQCbZofT#6E4b|MIn6s^4JZFfzRLuI`FyL<CbSr15+nBJixbzC zzh8yjG;jkflI1fWL3m6>WYw7(^>t;)H3i=ma;kv;>>D2c_cw^6mW_oh@PmZydX=mX zO#YOH);mLY_X)Jew+yFqEPAXlqE<E4(>5J6!rYU&{?m&W9=iR^R)9ZQaPbr)7kw-> zJ14X1%K8RAX-<8ALPwbZG#q<T^(Mxi)npp{{_+s4KFSC)I+u&du|Rj}!uN+!vM(?v zTFZ$W`zG+&Y6vo3p5;kM?`C2m6&lsk;;eb^_+N{wk~+Y6a;*(H<n!s7)LXCZ8ta`K zui$NV0yj>^e0Wd76d6%%a7<QrovGzeLDeOMP(MeRMngBA<b<~0<m<H386$^sJwPzz z4aUNc<|YZLIMVe7@2TC8{6cDo7F;g-=%X~?X$_vA41tY8DN7?zP;_dA5H~>k?sEzp zg@bhPy*7bwBvOFa9%Ni=Za2T$T;ec9z0GTGYW6dOyx7mkzqY}ylo#lfu>PeZ)uJSF zao~Ni#P6>JK>|)C?u(KvN{@L(c1Ud2iMQMco(V|q{+L@kPUDDx<@OS@b9u!K848;y zwnc?Q1UAFjZ`=I;!L0Iv18SxYVZXM3hda>A-xqNb>^zba;mAsMNvd|9?%TU~gZx5I zYI&IRX`x+T9HA5=7cL>AY`cU0NLmvV7^-T#wAo?fkW1?_`k~g?qcz1bEJ)$s4-q?_ znZ=6DA9UvHNGSbKe{i;aj^}*B5iEdTK@oS>W_y2TcWd7T%ePat2J#?Y21ZirAy66# z9bLOHDJkhcZ6qQhq7=qZ{{C&kkPr6s^!%s&z=qOcO4|Q@$lRW9>|+reJrWy^i0ttw z!VDTYd?82#rPt)D<5wyZ;kzw6fFuB|sHXINF9pE<-NPPE7(fbvKIFmI4e%cDZa7|{ z^p;Z(zL4Osy%-RWu#DN8OakNmF=EMjnE@^Ug*R+iy<RH)*a`H39)M0<{%n99{9jfu z=B(@o#J^YoGQd{`<Y~GN{N5wL3))r!z`bmp|B;utHv-NVr56XVZ?=W!OB~1o$Vd1~ z2Y786=tCq#D@5xx2jBu2i}Kg8LHnek;}Mr=f!BciH;H#G{SXYx50+4SyZD5Wsrnsl zo7r-!EFEq0OAbr_)U1S@raTlrPDe}VW2RSnm{1OHjRkZ+OQ&q>71^?zB7ReEXZ}1} za_Q0s^z!hAH{czo@Ib|SLIC?^KwVdX+2*&<EaCCPEbp+aIGmbtRtn1(1kM2ZB-`WX z5lP6JMZXF<XMy9Q2-*mVWqkJE{r8qabMQX+oR_azbyhTIY%bME-I(qQrZlvg4N+O; z7{=2l#m*l%U&rP(viCJKrz;J_KKDWj%%OD4YaWYehE~v{$-AZ7u-dGTbx~OemKfAt zxqXmFg}Wk77q{q^kCrtiF7WB^ZidcT)67WA&x&H$E}#7E+I7^S9G9pmOBwXYoSRb+ zp%&-^GGF&J<ixrine!=W=PB~`gkK207jpU~0|BhqT5ItR{x1`_+d;tLjY>gqH6=h9 zPCNWKniUm*3Gf7ph-TZ}!BxfnVgp$@XX^n3-nrC=nF9e12!G#{oaH0*4ylN0mba4j z+Nzwl`X8{8b7A(r1EmG9TK3vN5n6{O+IrwxIg$9`z;CwNaSp#y!S}ub?!pyspm2Bf ziY>`|#DLQvK{fgsgul%5^q*Te&<-E97B+L9*LU3k1@JTP%T3|`q67BJw)BlG`*T%D z;Q#WLv^=iK0kq1$cI)XNZ8d&c?L_UZ{<QjWq8V`d;}_Hi?uqD^AZ8Ut?;K$G+Rv<z z_O()Fa;RXq!jnMV<Dg4r=e}Y_Ekjs|7j+9=#(oOstlV@eLWsui1M%TLiodNs4Ix@O zBXnjuaf=Nkn$5xBQt-l3*J4`t#XWS957jDc4?F_cja2Y{f&<?Zr2zC%w^9h6-jv`S zE=?%rqFxVhYu_HD%)66Ki`$bmU>;r~2R0UlZ&``G9hjEuy%_<lAsIV~k?M(~*nGKL zSgyyn;pybMd36Vfn~t!7P4=x-)aX7a^iF*RC=XA?<@&nS1)_7-vJ-adV3p^4zG1(d zqqSepDrRB3l&7^nF@ZX=yO>1ZTxh?YcuvjQJT)8mE^;DadCKNx0D&B3wJ`=ga9MUI zWqG{)yl)HXq>4A-M`%{YxY(f33_5;7v{N$S!m!5+$*NVjfO*P`6+o}Hp6F|9=7Lq4 z-E&4`_UE5jy>5$FHB|XQ9F`l_#h+of%KjGXwwk@q;JN<ufRobVKLL?sSRwk8Ie8eg z^ovN9!qNe@I+o>&(s8c2-5%#96|MbsL|!om@O1(ru2%QV`-yeSv9Wnt)lv1=1SBTQ zD>v-=mIR;eGKRL6eGu}^dx}f#UfuHalj^yNr4T>rKC2b9F6tqH?J|@4@XQBx+7^k> zk286vte`Y_^Os1VrNJtpCtH>azk1mmKPO#vQd3*nN`pQ~HLd-I!%wb|G_ai&wDzla zxm(}@<}{|F;ZB#}epdC<DlO9sKi%RLQ9q<Zah~Z{JL|wOPfPsBliYrU#a`0LA^rqJ z@F{et<w#-qBqpV}Aw0#g=-NZQ(dK^WTTGU;p1BL<s&I%$R+OzkUp-sUuRmAHrf^xF zkf7{Kll0eMU0bXKAHWlDkoOxi=iJ+XH@Gw7I6`lXW22mJMUbeg%~99zbKgf=0*sK2 z_n^P8+3+J-0DtXc>^@O7t4^D1hu>W;$pK+<T@{#ZezZS_cKid}Uw_bEH_{e}cD#$E zat>`u<Y`QqRmXhd10?q5qqriZfe4{DK&*Pooiq08-itL58MFuO%g5?<JvSKa2`E6s zCYE+Y`fGhf%6CWx$0a4~oXC*@-?|z)nVvZbCVZo)Vp9y^$NSX~GEo@ryHihazW<(P zA_w4~TGn2@jSANIaUcSJ*B#|74(AJ_sh9gqz_Mu}=Y{~?;uMz`IOC)!XDWa|_={vE z&i9xk{PK6me{sR{aGEBTd|tg`J_pb_+Ht#}?1*Hg)9?;GrXS^PFUWvbtK!`C6zpo~ z0nZsG+*c<K&X?1W@oKCDCb*}<f+aF!wvEAi;qYsta5LI*b!|J&yfx!uNJ!nM_!%-5 zwjY)d)J0K6M0svuPF1K4Plp4Y#vzt)&$v%A7H&A2XP15PF(#b)?Sl{LJa(YxM|kbT zI;(SQ$){Mmf(YH<E%zx=U#G<)-7t4xt@SZZ!Y}iEWfj7C<ZpE6T4l3wcbku6V>OCA zu+aDJ?V-3Jx=s6oAMK$-2sWww=hbUbO8=XNiK4}Z*1X#+`bI3Mu9apTT(4@5T~-*J zfLRL5d#DtB<=nA!J1@@uvr`4LrwyQPUZU-%O3*47;6gF=l`qhM;SLv*Q@l_(Jleg( zOLUnAW+R0T{BpL!&z9{`Ka3r>{6eBQ5Xvw{f$@W00qWm*B~HUXZ`kgna&{2iiPE3T z!U}hPc?prXxc+c9MQd|)4v6E7kl2ULba&Pb`?G;ht0Wk7HNvFlP+6Tg%wBD9jkC@% zeHhWkhwwJ6pBsaZ?8I5$!EAx7V%4r(oN%^mh9ToWlO0}AjJX5R6;iu!dUe6LKW&Q! z_h?$hjUkAs+~w;rbM=q%B$yq~zu*^!NUOs5(QHzw4M5BhqBQ5HvdcoK=UOj%vh}!= zkKa_pEh<Wc{sgv>e9$aJ(9YlDr7E(N5W-w|dNcw*QOuc~y;%$i@7sriJ2cFeZLy$n z0O58>HX}gWPc0jWXvF}BkC$5Dd+G$yx6%3-j|J1dm8Qr?fccWIFN!LSLMPijNl#6$ z9N=Ta%0kP>7SU$I!@}&B139hb98N6Z=RJy&{2f}=n^ikjQl&eyVJLl!owW*Q*k+(y z+Pyzd!3yW}xX3OV_*n&eucrvU&7HDHS8J6STnXs415^C9DwG;F438dyNO*^rPk&S` z6MXBw^Apa)zSzCL^wXrT|2cgG8ip{uZ6j-0blqolZ;l3<i=!FDX5>-SmBPWTTD+yB zkV8C{;D?z_08qk|uzB0W5@!-s)g<EhT_~tK^Vb6V!c#L@c=o!G;E?xh@Pc?59WY?D zg8LP7>^RW!{YYW5-7D}Q$5QBnCM;3(1g)@q(AZ{i0_5JOxz9QT@K7*X)@(u&`bB(6 zY<hd+9o#=_cd-nu12$4b?)8fByi0wE?u`imr-3$78^{aNiX#tXa9f-J2gJWF;Dw<v zhael;J4@-A4q>tLnB{QLZ7<}Sj#!|Jgb^i2Va*(0-6O#0cp050@V&~WaN{@CiJ}(B zdmxkK9thB#wZ%&Y_xF8fj&+X1JF)v$aj@q^fJilb3(?!&rNT1X>9Cbb9@Xt?oHx08 zX4_@WERuCbyO1XG<SZ6LL|mVbtK+<A%@R9~D(ineIZY<99T|cx)(b9+us_g<zn{I_ zQ%pBg;j}3iRU~-eQ#W7#j#(Ok1||eIrtmC5SnJd#cQ_)BZ={Ps9mfq>u`_;{&~0aX z72$ca!tFHW{uL{3ho#l%bUDDGJU4aNWxyM*pAdz_2_^TTcxlrBEs?lCknk0mF^J7k zAAN9kEce^<CF<*81(NY7)>LE<8cJs|?a8%Ui5(9bwv0v#V)fXWaaRgILcH2QT$VIl zaJM0&J|GRd@5Bz_FMS}Z=(A01c(&^m2&~gS#)jC-nzTIAm?fBy`yke49rgp%Z&Oy9 z{wH6<1?yG%5jgLh>57I{n5_6#?t8KG`>Gt>0IK;fDzr`jo9fvgMN(e0;w%jcB@1xi z#e}T+Y{4dSfBY}h$D7`Bkl8o<PW@z@pD?Ml%d=c5e)Q%KrC8fn<RUab>UA2G0o6qo z6<qHP!8oW{<3}n#&rtzFC|d=nxjBD)^E|y+J}&oovLq!5^Vh8wGy(%!s)7c)pZvjO zd3~Oso83uN5eqkxRCCFpH(dLstx*k|LAp$r8X$|yB8T`KDPVF?ktMzn+=4SZr@3L+ zU~sM??fCL@sdEl^`5D0i`rtuTFJjNT9YB^JEXbL~WMaxAprhLM9?GFD7_TNeMOS2s zc~1Z4uSl|g+gsEH=e7X}9Wn@w;bEUb^q@XIZpU-mvP71InqD>`h9_4aUrOn?LXo+| z9s&R_oBjvLrqtZgAxtg>nD81XSCPoFhU8MIHA!uF_?wJ&oSO1;#b=CLMPgxun-<NQ zkE+9v{Y7F<rfksLC)$ZOlQ?qf>QbV6lyM%01dQwEn+y{s;KG!wgE>s{#$**tDMTo? zI9<ccG0mXkg(l^-iDRQLN`<1ZGCo=Tm=Yl*>MjO#(Ux}E;hN<83qd#!r?roagu3^B zPTUAQcz5CX92pXKfg|cxfTrNJ?+>x#Ns9zG!QEv<IUC6pPO0BDD7s_s#nf44J~l=Q zvsd9F1h69aLz1!hyQz#q+qkSyqsB3fm7)rQvy=D;dV;dguo4(lsKkEtnt&`6{JwN~ z_Df{dQa)p@hpDjOa&wT<=A1B)1AGT0+BT`qNw_V8+b#Y7s8L`-X*c26SQ!`Ce%M3x zREPt!2v1rGp^IIa>x%;?nOTu(f4;A9MF!MLQ$Ak?r1!1M_J_zg+U`kZ5_c<GI+oyp zEXrtA9VyqM5gQh=yns`|ZD~oWV2xHw2l&FW>;N=qS*|b!R~vH*J7`tL_0#Su;Kj6f z%|5cgpF_t|-0#!@>RiJ5*9gAZpM{h^(Nh2kaFa<7Vm<d|R0wV};8cROWg*VvT>PXx zY<~;gM(*-@Z}Z7UK(1(;siKVfE61C#EEc(xU$SSUAd7G@)W(JCC=RegRZbZcb5Ia4 zB`@A}+piC8_9-eOpdPmzbc{1ZPW!WBBUgmoO*iisf1Ah>*w%evROsA7J1}kHfZsL& zs8X1f!W0gbGkm64ew1t_I_FL@1+Y@9-lDV7L6;C(Iinul6kAbLq!FIXj<JDvr8H}b zy9uGRZl_@nPD<h5*fM(VNwss{fKhCgh6bgLv%Ct;XgQ^Mh0fS6vqI+0p!6nCOHd0n z=VoGXo<`T9cU)FaFXRQsFTq2>92!DfQ!Ru<JZE-0jN!q?S?Z}626>WBxp}zIjc)OY z-=wn+0C8ge=zaOI{3Q5l7u}+n*>q{E^xTNVSuhEC<*>dqz)(M6v-F=ByyxT8())^K z42{X+HSdSATMBW@5?4M{oY8X%Lm*n5jg~)~uSm$Opm;D)40(#eu@|(NeaCsJ1`(i? z<;Q2ggo+-%8>zQ12V?9`=s^VNWIHT!m%D2A=X?I7*%|icn?pI1o5UecyqcR)L4P9m zdqr@C?JwYMl3o1^cXDV?9E>fEu&;0F7`u2O5KNBC@=PxQx?4636X-PCrLck_I_KpB zwf(h_T&9;6{3pGv`v{1@tod^q<Oztm;cYMg(c4*WR#Q)ZdyyY|&%a*MMFDvd{Iqm< zTojfyEx*0;z>jTBNNNndhX~A@uZL9)mar>zv9evBZ4=T#J%$3i(Oq1`4MU@GwYw4z zP&4Hb>fn2~5swU!xCAWIKY=ZfYDME9B;j)9OO4_taPzSv>?%wtbfStH%GCE7Z`6~^ zPEd0>fw0<F+BAskJtJ-7yYFZIJU6;R^B9MY6YA3d0D|Jb-vy9WnVV*fR+~=J{)Nwe zmtK`)GMSybDNYka8Y>1S89l#Y-9T!t?8gH?RU4?B4|5ioN^t@@@uMcGl2ybfdz80w z`{*OQ-+`iXLJM1BegT^8pq|HEWb@$DFqLTq+-<rgzIWGc)nc8Z5kk>iaXZ{bSy`Cu zmtRsCGa;<c4j>@{m?VOD6u<PjK8L>YLvq^f8K~+sE-&<6oqJi41y`8UsP{XP4fl_R z>&-Z%7Q;RUG2ibUcdMRZJ_#?WeQR~qp+uL;OQ(+2Dwm|&CtA#aCp2hy$GQxn&F|e5 zyroAU@ZgHO{o#-bKX884oK@8wp%w0iwznI>#tOAk2g&E6>`E%)L8#mOCUm3t0tI4G zt&8LWs`+dJg1FgF1&_0xUTG#oIRkBC#?39Yvw!caD4w~VRp221<poQYIh4U2`jg2w zzDHmLZDY=<3yVJkpD7ftZ%dJE9){GSa_6ZSxkdN-Vn?Jhb7~xsDvO54cFu*sZnBok z==(PVaOzBF_$urXZq_Z=)aq51^4W(0=r#*B?V&$yK8fuC<o+kU0Yd)QCi43LT!r*+ zHxmKyNvJ$M>1>T|f=V)$@Z2c@l~`uAiL%FGu3KUi47I{`pNX=!A^zkt0JtA2$Hqqh zJc#rs3GP9M>XuvrwVF5X-YFK*1SKpBVcpJw5vXKa7a@Tru}jzvbw7TH<TrBbO9X1- z*<=8Jx2Vo|NT{jvb6{?zdLkT#S{ykOYH2~j5HsHiHF6P;UjX=XGDcEl7Sznec<hHt z{+sAj=yE7Uo*w)EWLUFxi2<edPeHB9wj(L=U<`+v{W%ZGC4_zlYUcC(82no9fy!Sz z5N`pPpM?Fs+=}?SID7^J|C$elx))zTa<hUDL3J}9f_*<u{XtL(=x>4=jZNm+)uBd+ z{tIea{$QJ(eHU?Z=Jq$Foa+=qbx+1aEn*xWJIbJj-G)GAIWwSs{ZBv*J-0$F{%QvB zZ>S7kZrZH8Hy1&5T`q+Z)zMJvq6(p|qa7;l(-b?Nhe}zPtq)62qVma5iLK6t`kYIk zTITIgBC;K-JNX<`3&E~nxLJlm3Cnb-&-fguMAgMmy^@}7PLDygLf(K%&i*%8_^kea XbK1NSzc9-c00000NkvXXu0mjf6kQ_X literal 30117 zcmagFbyQqIw>^jkX@Yw~kl-%C-GU}~)401k1cv}YLU5Ph*0=?CCqQtwAi<r+nalU) z&3bSBX4d>cvevy_b?R2tIj7FvyTX+}%e+P>MTdifdo3p`r3wcJ4+Z|lP+tL0dM||^ zf&b7PWwl)3;NEq={K4B#xQPG{NnE8Nu4)eEt{z6tW^f)J9;{aOHZCScj%KV5&KBv% zLZonT6mW7<;_99mhbvw_x--7KPvg7GB;~8@EgXi3{Ykw^z0B2SYP|VYUU7AD5lhUk zKlr{|G*Deswbcr}9{OO{Swj}ruZ8|8o%Yk@><7DeAsU)=V;$TWdTf(A;&hg;WG1av z=}o&A_a+~cS`}uajx$qF?)yMCJ7XF5ZCtSB@n!GhWy;a71=>1gtDPC8Y5R|fB<eJJ z&redhg=vV00l2Fu&U+LkUBjA~mqn{rNqzwl&E_Vfy|xKKGL5z!w61<QfeLWCV#cAc zVz+4D7=73}+rNkL?S<=0(2wWK_U)0L;saLmsOA9U#5mn&tgJL`z08UunH0Fvm~{$C z8S~Ikh=xY^XpG6fS0otxxwxoP)SNj=)KlI}J;E(&BS~ht`j{r8H~9jM**xt394;sB zQ8QizQoscU(8p54e?yS{*7WI!)$2il_}ceYZG^C$@JJP(4g`&#n4aY!;Im`I4OGCy zWXI!+=B~nx#^9HtDZD{qGU&J{b<wA@`!SO8OTo=e<FcbmG~gx-t`rUjX@C@hARA7B zB{r{|>2>?=enLQm5Hi4VAF5+PizmYG<Nfi9p-by(_qSnZ1iCsLfgF;NEI+O+l_O=F zi+YL?C)&-#pOzSOIk*@P3|T5PI5|EU^H=v_K~pP#VJrr#<TK8sCebI+*T)xJ-9_*- z@S{f@nXZN$u&?EkMmI7Z2Htxve^~X-syYRt&HR0p?!Ab{%E{e`eq2Y$33MF{N<Ncb z{cCeL+<5YR?C_TRTQjS~CNL*4l9Hmeu<90aaYOaCNYc0+L1AI{<ebu8yRq&m_8U<x zJ#{WC#aQ9z^fdm1)&(wf{vX4o*8V?F7&Jpxb}Ky%4_pq`oNfap#>R=c+&|eZ5vo22 zigDxFjllD5&UZMbxh(#&R)fiCSCp>_{qaf=AaaAJrNiUnEx&6e&}p3gs29QU>Q`Ia z0XpZ6P{6)V-R=)=@nVgimF36(yevd^)P|X>qI+WF@9x+Y1+VDF8YehuwV9S$Do!`o z#8VR5W!d+HkF{oIF9L^B461871wwTMv&vrKC|>)JOwzE_MTL)+vivYO?qx%W#|NW~ z<ATL*TGAU`{arbCbfSR1sjf1|(!?s2zFR+G>;?IT^Al?KD^|>;x9lVP>31g3@2~|> ziLOr1J|?S-iXJmpVb*R2me&VQ>0OF%WPq+`M&;bxKYLcq5xW?FN^h9)3iFozoIZN{ z?ugkWs1a&?VlP)<y7W)wu#cE#W|3Q(K*Ni~@ORimSl5K%Z)Ct0{_KAA03mzqji9k} z4?3~0>?wP<%-!njV_&+UV7yGGekgO5b6We1pj%bH#z(z@4T+QBoGy}=ma=L(Cq9+E z!q|l}dLtXM?GF8hzcp3Ml{BUG6y8D%<!r4FGD)XPsrFT)X)cW>MAe;)N-vN>EGFm0 zCFLIN@f|3trbceLAS~>g`oOKu{=$aU!Ty=Qxllv}-1NmpCAk*%>y~AGarT4-x7d&* zj@#-l3gdkV&w?C&-rz92x|E4V@bk~z>0+C3)rD7J#zbeEMu+Up59%K@?@w2eA0I2n zYkPwG6-S3Ztz5MB5UC&;aZ6}^O?-L+ENQ7|;wIK$K-J~#=QKJ*3OYKRCp#>-RrFcs zmki8u%tqy`{i-aYU2cSa2I;%oLHloQUK7RNWhWjju`)x%Il%6LKwwyNtDJc?lPKMC zDBcYi)VQ!e@?_<)_&}<Lk*4FlLq9DHXY68m)JrrjvWd1UfV9@u)^;C<kch7%-SS6- zgx7YN__E%i((HLP*T9}imilth2biD!od&?mVta{j@~YATxH$D;m8+9(Zqp%(g}G~v zKW08MSn{>yG}GcFj4G8XhfCF8Yg>}IAT-u{WM@;f)34VR+YAxKO$ncs7e*gBL^dZ4 zsS*YzTHAecZE&dEQ%L#@d3|9;Q#K>|JR6M(*o!vS(3$fJJVpLijZqf<xXEWze7cq< z(Cp9TPtd11gaR(D=Z4QvnKWp=P_Dt9BAU-i;t0FD__Q>ZxJ!hV`Ob}HU~xX$8{^>H zD`oMs>@;4Fl@B@Y5n^&cOO5bHE{p!-eS(nnKvOq!gG^u{wfx(ymYTw)PLVm^g~9*0 z^@iM1AXD%{_y0XjNsQ52)4YN3u1%%(P7|4UUqwh@Cqgk`b4wfIYRBNG`~zq{NJN41 zT)1qAD&Vx)MZ+6rAfu;{lVEDNvb>O*!40bJ_##c|$(TAgT3l=MBh|USrv8ALx0fw| zk7-}~V|wrRqwLDX$*WY=)=BRnmWkh)nL~>?T#-A#7{$UO0(-@RLy{PH8$~atQ(5;! zP}UENZTNM?vC!T{w>F(LXZbVNGqokF8?H<N*6L5Db6Ws&5X)3&mwU;jF$}KYY$ElB zWLDDeohKQb%J-E8AEcBy1KnIKEYACU@0p<=W5?Ao)v-S0YwNJoDaz^mX}^eKKN3Od zcNpK7qIK84N7FOdu<*H0x+hP&T)Sob8ixvf@x{bSMYeFWAzm-_LYuMnUWt)}Qi3DF zany(PR{_<lwT$ytM|2JO=8JVGU<beae@bEu!)%jdPp9R(>R;3m#g3*IDa83g(C(yU zDbSGN<3*_B2*i+MP!SnX(csWdikFW}Ini!oWNBkhqh%4$$$}~JGl0ZVH!AeEjw{rF zc9WP%^Y~qIOU|E4Cis8zl`j4U{x$y3fgNcaCU+xL3^K3aq-1Vm!ja&p*Y`+b66oMN z!|{Eu-Lc`i27TeyWrw|~P}gP6@22*o*4sVS29i#)*GC)_ZK12Je_fj{U$OnBmF1Jb z<)1`B3;c=NtZSftEfTiTp4x_m`ISBZAtf^-ofRiKK+5o!7tULIa+IYcSx!McI5a2E z7O`-ORNu6Zi(~Ew!ER9x!p(Nd3;j-x?J|0wqqQq^GZ#b~=yXrtWb1x-z8&&(K+mB^ zJa}YzZr}TT<-osZV@XCLAhbmeH{WK#+mgN7;BrQwFyN!H74OAi;Pt3s=WDg(va9F0 z;WaowS8h^Q<vn*`g>xcmaczcW`^#^2{p+rYVlOb~Tdw1!<3TBzuNgp4JS0L&AxUaK z-`{bO*=bQQ`n8C2+vXB(wXiW!@6X~L*t%+3!4?Ldj9j~i{K${2n(J|X_p5YVMOkhi z#drVGbXc5Zm0C@8D>yXy5Ac9k)JD@9g}ftnpIXo|)CS>y4vDFzK{HW|qlurYyhcnM zbZWP1azW*rZ($5$r6yg$Gxbv_Y`_U2aVEL+(;no}alB+Ra2%aabYD9n?t>1i({pyc z2x;UR;+r42OP5OBaArezx>xO*c*#1Jsm3lgGINS%msW7QKqzmQs`-S+S}LpV<2AV} zDBed1c_^bI^N4)2>+@-?;*y}`JE3+V-v<Y;!vy)0<Bw<|8VR!PElqa!CsKL?p7<Ju z1*#07G9hOS>pOG0iYj3iJP-fbyMGu>>uT=A>>Wt{njBZpx#-OC{;ZeWzAd<#%TpzB z&0ixK$X<RHRT?p@B%blcjfEzRufw5nmE4WQL_;Xh%tSNfuljvt&N1)8hBzK?S^FA) z8<k3veq4w~Am6VaQhGfQ0wu%LAoLK1`|<vC`6J`hLeB#2mcpNfJFGQzFeti@RUuwn zmFLwCnY0rD28h`u2Cs0GIL$i8jB0LrR<NEeM+yEH-@dl|yNzB~lWDW45acBO<!QD1 zvNhWrv)s7-{WOU?!XT6O;iy#N*yN9ZMTlYQd(;d8lb<^*gxcmc<(`H%N1gT_L|?sB z=2XG?3o6O%goKbCNa5#&WFLi64Qa1iRy7}y#YJu!6`ksj6A#5U41&Fv#R|kAU_6R} zE>n|3Ss@KYX6P(43tC(>8zN|nDH>9txvYlF%vGaKAzO87Q&X!M)^_#6ENa*#V`FJg zPy2#$EZ>@woTbmMif#VWk%az6RQpyc2#7cBD~o5kZqJ5C28dNv5ivzs(aoXNRh^tB zR6`OYTN<TTd!?r4Ck86TKY$*HVz6ZX>#I0i#(w`($ZB%T!<W*FWUy~^cU8wyzxGFv zQpxzNH;me<!r$}Eyf4t-jW7}g%25+o@~&9^^+#ePBSZaQN`qh{DnW>q|LOh6Uu)ag zXH(p>?2^z|f_qezRP8?DBsg$f<ibTTMnNIV{)41@5A|zJjE4fx+$zp^8jQ1B;48{D z(U{@LpKk_O>WsU?(iW11TsB?<^V0wC<>#}CBM$~*$ufG8L$U3(_EwMYRgyWt(gY9{ z1M11Q5xpfu<NHnLq2J%I)Qvh7G&eI^7ZyHucQbzc>L*bCtvTw9zO)k|0N*f2Lpjw+ zcu_Em$77a;P<toE{`gSw`s8D608>9~^!(p`tS@$vy-sbhkp=aIh@3PLgaVn|4X42N zp+^;8N%T1bS+gL2Qzu(d94JiiiY}G3kPVHd>r?(*79{nDdgoRcx7s3_oOd(uwN<ta zNQ}I71+qeosMqXKennI>A(uoaZ}yj*0~3`wC(elT);}JPGn(xJ_fal8ViXiXVRrA) zPGi)hu?$9+>y}q=F`GWYJt86!jJH2TUP{-pL4S*wt9uKz_Ng>F|M<I+jl6uiCAqY) z)F^s8(#Cd}?X^Ez`d&fU7RR+W=<UVh8)0#{`@6fKiHi$0Ya3WZ?pCUBD3KVF91hjS zTl#Dk1FCh3xbrM=Y_ZiTWcV#{q=1WDsh})O%;3GJl{P^Sf0Nx%Q4%4rUE$@+*FFx_ zrXl&)2M4b+#8RW0-|IG{M?_=B(aFZWJ%0byc}13bJ^WBjECQGQ8|GK%BW!Bj>)X6$ z%LcNY2E3l7s9?MIf^4R9ZW8!nlr0)K&Qmnq9CLJ`>6-3V33`Pa4YebwnXCa{zv*VG zH#C}M7sfWEF4=DF6W@BfE;VhBwqd-lCvVSqTd&(BAd~c0r={#()bXS{WUspt`BpQb zh{k{SFR!2H&B>empE)gp^H;XWO65;9f&BAosq2?|Y<L#q-A`L(8RuVue1`(yl;ct7 zJI0;ZtCP9RM>{*8eBWXqfUo$C8QG_IAvkXhKVeTi<HHO%Pilg){O<Q{DsMDjxeE&) z1Oc)9D0`){ou|$N_Qv0R40$(8XYjW5x_jg?vQpqN5le3EQ>^=G1IEjgAtqXsf1T4% znKS-~{cs%UJA}2;lAlB0gHAu$NqQv0X=`am!!CFd{8XQ)A!+ejh-vNjJF0lhSg5RN zVYaip_%7E6_F~s(!>-+_j*|c^;*8afCRkd+WlRXzYk?m5hwJ4strmogwQ+#(^<E(2 zecTAIu4rZP51)iyPf6>An$dL^Z`&T?_pSmir*v(aODW*nd7xR{6*R`t%}<-TycX$4 zeIVn5R?waPT6@Hs2w`XdF5rj1U|2+jXZvM@+8nvc7FYE!-9-5Ud2?YdndG?T_eaA1 zR9j5Y04g$L@<s%Mw7vV8y|mo5T2ip;o4D!oZAs7iaS0|cU)f3XHla2RGfh*wErk1{ zUL*<SCd$lS>2`^k3rcPUje)%V`#9}Y_7A>yhwS?Tqo^`jQywelWmFx5MMEtKTX#!e z>?wf)0wKPsn&zzM!y0`_6@ol_6&%G(XHIIDE2y0BEUj&SBU4kyGBFzXy<oHGs{w?N z#P3F#81SN`TW>~0+bmW5MV7t?$6+wT-NYa4z8=f)YX|{neBC%);<an(mngd_p!WEg zcW-hE(f-wxFkl_G_SEU#A^O--KnxZ`Lm`BF7!tz#oXYcCg6ShZQmw<uzxoMA<GA@} z!|~_c^&}uz@=Fc0*R8fZktLIVYmSj%*aJe%^l}rTHzN#U+4n73)Wb~Xgu7~jQ6SFK zTV|Y`z<s>*1A(&%(|VWV;wa3=NUP@wVT{(9h8zNSx+fiZw>ICl23Vud^cV<M(zVLb zkfP?Phdl&-wV|^Ljps_2Q|;t{hFO39<2`5K2Oc`sdd(CG*z{hjpO9cOmmnY0`!nmC z7y`x_44sid)g^LcC@>ES8z8Uve9%@BI=Kq06i*<s7_8mK==n+57g%LnK5fgstoh~H z$NOp1u*7m)y3_dmy485bvz~ywL^VVBfZ2|}HSH5~(I=YdpTu#RJ2A2P6X)v+?rHff zyuoMZcwKFc8Qtjg9i0eb<<Iq8_o2#0IRx)1A41BOnva4?s;PJyJ=Rc9k8pmArY(G~ zIg2*JdAMDlSU<1-4!R~NE&RpU12o+Sb*KWhf9FrKcTqS>9vcxXdS0!BnfzYHKq(qV zBZUv%Ht{imEDOZE^BlKGYTNtXt$}Z_O#*=vvp(9qy%)AqV*32n>5nz2{9Ab0lDEhf zwi{#tXY-G&$W9EyQWe55e^o$mPNEZ`w$o;a*C)F+P+mozE_dS<Gpw^xS}%-5-1&{q zov=-kZiC>ycCPwrATnIOi1(HBeJgX_=GR^XQ29_}X}L|)Pmhm!GD+W!-~$2%Q1;ez zj*XBZhVX+G>^2oGhLu>%b;cp>$C#jUxmst1x!3q6xM12MrcZ6KsYp`&AI&j*Rh`3> zCEN~8h7Oh%SpD)J+n*Z9Mg7dC-4dF2uCrkL{VdR76O4m-I=$kh*Av~=_#mi?taX23 z<skvy%YsoWJ9uk{)Yd$n!Nff^r`=LizL8NfIs7_kZq`#t#-$^Kgvk}Cw(o~MSJTx^ zL=a$cLoBxqE|QL6%B+P(8d)X~B=@hf?G}%lk^14l^aIF7ggWDPk$>gWYswB$s5vcd zK5I1|$9Yjn-hHD~n;_tz^jn{k2V2Lx_x}O724!MyvZ(=c^qY`m9*6xeYSU);EgDC9 z9daByMjHAi5Zo+`pwl)FeV4rvl{tLP?dp#i`5t}`+3lPMQMDGaiUBfcu#GO&W)%;! zlfPZb?l&BrgOBfnq4)Q9@qz~4{h99lqiK?hv_GC!-?{}PVPm#EpQ2pBu#hArgAu2S z#*2v=K82~fZQ=dkCKjq`rKb2UbkG@ySdlAmTbVdyn&O)hoJY^r%`Yo*FCVd>`I}!h z*QLq5h7Bw5@Nralwae^BrYv>mqc`l(bG=CPMsV39+qamwNW)IA1OB`b9`_tyHd!Z( zUKw9JhzeOL+%-C8{Ie4r5;paQ@Wxw;aa->uSPTUcdTwx!qoApKGZOAkYJr_uP#ksG zy>dhOax=o#B8qr~z&uZmt{@Uxvag8D?3V7QreS0R(i!&(?Qa2yl;}U%t@+_4sNTBx zn*Z{0^5n1OtvxbL<`UFfAPO0rkz;7dc<-Ck#FKqa(&n&I6Pirx8$wS-2r-F?TdrUc zRLYESrTY7J%07U*_~Rl!Eec8s+S@=zYQDjV*wh?Ku!aT|*A{WJ_$$fiVx;a5sg9<D zln9BaZ%GQn<{t-5V86>-e&xiBoGvm|VzgaPGO@AzI*hwO=g&^g_AeR#TOxe1=Ci*L zk}=MfHDBA2cGcl@a&Bf9lA%<hHS^~J^Q#~KTcf}bx!2H*ZDG!;)4GtEc>v4%Nt`d6 z9q0bqe!+_ooAzSGuZA<WBvm#2#2ibdtx`KNTnch}tFFoT7g5ygi?q?MTD&q<aqH&w zHQn`E)6Hf!k*hh4v6=UHW!FJy@d2@5PJ)P<_uHlq2w5rxtBv;IAv2J9;#uMX*^Y|> z83UO6wIS5gjIhG?q?u}8V6&p6{QgLtBZNR%-pEb8myOHlM)07brizpa1a<o5aC?5b zuuHzMt!D@XC)VjiLhXUs)`EM1IB7yK%}Mf};?2^3a84B>RYm5i{=FBNn8?p*$i`U? zR8H*VsJUvN<My>Mx}p&c^3ILSe7Ya(sed}c0_`71IG|o`%-A64NV!kT0KymE$%;lp z5qEA=8%#6D7_)5hjx--d?A%M4x9$Va1J(YQh*;!VIqmk0jYQ2cFO9mMV5iNmWeyG} z?bQ1MxecXu-tYfKKCl~FeK*4K6rXSgmBm{Ga>I`dRZ;oeYII33edbg(;SZZFZK(Jt z<16+=ytd7SvkoHJ^k9b4_9NH?sR9_a^(0$6)qDy#<A(Efd15-b0mduxnAQ*tpVpKd zKbTtNLH76N7-NgTM3jXI0a)Ut@?u3Z_It`IQ)!Zr+0y7N>3pV~D#maQsHX5E3JdhS z2Z2dRbtI*v%Z%;yYcn9o^?EV0gbA0=90@yw%%KdblHM@fNqha~Z}VT-RLG8Mj!`uV zOq3}x8$GNf^BKCX+w4PB(5y?cx8$yOGl)OCGqeiPaC(21hIJOm9ZBl`QBQ%Px^uYJ zn}}5rmK{ViwFhLhk3mQkEPXw}W#os=q!TDw2rchvOf{*BZ`PY_4m_mvWJ{_$83SIL zoK)=lbJ&HUn9!X5a(5fJMpl`NWn<#?=+IjA4WOT?g^zT`ut|=)>0Hxw$qCVbhZqtJ zwt<KWVV_RCff*H%;=D{fkf*Fm6Kr1H`i3RBdgrK!?XxoEYq`SRV4*?ZP(w8F^815A z{WG6_2__y{_RFW{C4qNLixbUlkKs)Cn;&CnR{bNb2hQBEo>uh~_OpN^fhu^D$>;LP zk#b7SoGwcVDKG@A81qx@^m?Yek4U@h-Kw7#vAMm_K2}89H%F}eA5c5pD&c*3`ONam zc#4?`_JkB%5%OPOfmYatDX4x&4OHmm8afRI(XO8F75v7nArAvp^vADD(zQw7H0M?n zyiFL2Aa7Hb?3oDk1!6x=kZX9aVA|rBT>!=nUv6)LaSA+pH&_t7-_n;^sq=Gs{Hv0z z%4)lvE%l}%oA;Lmmfs$*w82O;&j(JJ<pk-CdOL`|5LIk9mUyOi69_dd=w>jJ5F9^@ zU=wHe0+0kwF=f?GL}20OKUDI1xa#4%v4q)tan#9l=?WWWgBsfz(DpvtYpFM~>`M%P zM+PJDjHdH?uDc3bgrWQm{(3>uela_H^A$j<k3cDC_Ea%Ib!*uRtd+sP9#Ke#YnKV& zkkQOlR5eDctzA+bfGwOj*3>P*=Um@`5S2M+odXjP^$JoE=j*Z?%3q?gNYCDnlL{<Q zD&s(coave-M8vM+U5ftmJktdyxO@uJn+gEtr2>@$IPtA`_X<*iH>A%RqiijbyzPQ? zsWu`G8Qd!ZoE<x08_Ga##fb|N>uSlHpVDqC*fpkVMKeqd(|}$^c9B=u=}wTiQEsz> z$&H3*;+|VJ$cx5P{0c!q*024CLIYeAU^1lq)mocfZ$_V#a08de5NiB`F&`fh!yg@5 z!8%;^4Y;HAE?;96iud^rUe#jpZ7!}Ov9t4S#SuvEk#I3ZFR$;gdKF3TWVT%J+2rQ; zw0lY&t|gmyXI`|Ks<O5)W5Q8d=d;G*{?oP38Vj5(4#AJLNqy^87#vI;H(AEkHoI^g z{$u649I>+2tujo={PO;*f_&B(KWY|s_(m?;WPC2&x|k<=UNRnjjRK7+xr|b`+1zV$ zP26rAI5e~D6ERe(kYy%u<$R#*8^bwYU|47nkNFDw>JlJSd$c_Z3c?2Jy@l<V7qAWi zO&OPrj9Mv%8mppbp+WcB7s>f3cmcL=xb#vHhOz9P4pU+GB!ZAWlpg8UD<5Cshy1Ce zd^Nb9XG1vtY?ZU-?_x{{;fUKmgf7f!3Kwzy1j&Vxa2ke+;jWqyV`Fep$BD&I3Uj%V z;0{p>abZZXoASUR#EHaH#-Z`WiD29w#*5ya2Za<7T;>NEh%_~xTqWPZbQ^9)YeD?k z7T#;~9lHfncjE@^CzldqyF`N7i-Py9TordqYnIIaG%&#S`&mTPj(J3ksFMgb>X|sm zge*|w0ZhSOS?i7NcJ*D*IL7r+Rxr|qAE^t~hL4$>(Rg%4v8z0_*6A%ZQ-&^;va}hH z)Z!H>w1lr#ewPcw%C*2SMarG(&5hM2`$2z*SPk|OQKhV?64u~>2@9}CH+%c5jA`o~ z!3Ji(8OA%k$=z6Xej?#M`Ths)KM74IKTQ2Q`2>T<=kfZ@XW6OX-|BAFqm*0G`*s+C zDO43?aTS8XIZgq1Iu>o5en;l`gth%qY94k6mNuj>>{X`Y$Q{jV0Otwk2e!3hx&Od6 zN}<>|1uEd<5>lLKPuFB#sO3wGE#sQ(p~7V~elWV*rFXr`sLSrjAsV(?hJ6rgtsXxw zkzfjy+4OQgoY>3F*LVw4+B36m`fw{B3V}AqIq`g<(ir@=OS9ZOwyCYDX=jWF$I2M9 zJgoC{*?u1ziU{5y#K{@m0@>=K|9<(<W%&~}BS<BkL^Q}Mfa$oVDnb|prK)Oh>Jmxr znyL{lpT|!4x_c5$R|l?l%al3&*xAj<^VRiVb&Z+R<4&;x2c3DK2K7t#b9AseAl+i& z$n7ql3ko!3yW|e=)L)Io-FUC_^^`)_j=H0bRAjxYtyU(RKOtwv4!r>^)oi4BdD|e0 z5Xie9b*02WNX)yj-m=x%pB##$Pkag}9S{x%J}Tr*4^>QPw>hY6Q+0MFhq$03wb3K3 z%yaT3SE!qFZlE|E-Q42jxZUp@*FFZ=BPdZp6?07Ccq+A=_kQHD_D20c2II)<aXD1J zIeZCP{OaJ)a4c?Mc%<zP+e*!2=wuE^mPQ2RBoV)DlBOT|_9aGdv<wMKk{a2T<B_t^ zfi;perP&jm2JlK7Gn+Xr@ibn96bNL282m0hp6<*E7@Aq2M(-?hldZ?vPrwFVb;KpP zy!vTRoHgxo*42a$+IEoOEOW)Z{&Yx6yv0h+pzqz>8-1)I4bhh<FKJls^RBz}aQi49 zgte<`L-hOEsGan~pQ=tqcpKJd-JY2L)&dCn!zga^r%Vk-`cpjd*2R5u%~Vzp0c?YI z453WQ=Zi|uf#0C8RTzpw)OVv#TYIbguy6nrJJ~6EhsO<q;yTZ{xwR;7xNBP`Vjtwt zg<Tq+^4bux+++i*d26zg)4S~E##3jjID+31Pu7#`F-fOGy1SI65e{T`aSuJc#*sN{ z;6#CGLi+}}%jQw<`xWd34-^HucAHDzZ6l?97%M(t$1^p7n0%CVwSQbJxO&$38Kl_D zTqQq$*O%OZ%LvrcqtLKuG<f)jX}!oD9Y`Yk0Va+8OA$ml1)$uh-|a9W15j7n%;g^a z34c-Gae$zlj=S8+?T1rU6PyLI?;fH;G`xVx!8=IeZrvil{0P*HbZ>eD3YW8H)++3v z_dnzq2c?*C+~Cd6TTc&H!%#54j<d^thDVinKcM^Jp>gEhH>Vz$*>n6y@@$gZcp=YV zI7dT&f%!(8f75dYU!E3%u>>|vV&BXRZ-n`NoN*mo3nL{(rz8)(haKN<<KXcxmqtTV z!$g#uwng@%P_N1U^|U|US2{_=uw({}vvfPA!~|jSKQw+j{DzLXwiUg64j1$XHc_&{ zk_>yN5-gaD6MVQ3pntQh2gIIXxeY(c-@UVBWJ}{D!#9x#=BU)`asr{3l;5NfSTXj{ z7%@nwak0h8zq}HMyN$ujhfyGO#$Hm=e|d$vPU5`#S2(-vXNCQ!D49Q}zUN)4uP+Mb zrGcwl56Mf};4acMXTh1u4<ej~lLyJGDF(}WQ~v!~7x3X{)cZ-?Nk`V#l^C5E0UwGn zIzRMcV4LGpB}n#rnfnCP;fJ>Uc<@;*&@^cJgn*`c?m8xZ`c*b+OK?x_57+%hw;Bb_ zMAIP(2!3=&_uA=_T9+pyRWKDZ8cvq}-Umejo8f=eZ9``C;<&4LWANvr4Pl2e#Q!5_ z3Abbbg`0qE7KPlq2kcltR<N)=UXK-oPqVr-34wi=Xou1I*<zJp_&Wc2*iF}N#6|N^ zp<JYc+eN?E`i3N1x_&YA+s0Ew!d)k0<)<WO9Gp0=EIhVcpuX5O4=ViUQ|y08-6MYl zu}%=apskvb+w_ZVwXsA3Qy=@?D6yn|g!Q>VX%SYZ=!El-tWBr|Ndzht&W7u>5r6(I zE_dlDzS?+JOseJNSsorA;ap=y42WT3Q%hyrB|jAq@n1r3SO(X{4;xY<2qdwo<`|Q< zte|>>D9%@Dq&Gg_-&$+=v>tGaKee5la5Xsuuj(c^tEtwRY?7y+U4WyFCqNCL_*y$X z*0OF*smvLDWH{hp_HjEh1~G8~Q2$%w7k&#}&oYOAXnRp|=sSzTeg~-=39bHcy<o~; zNaM{UUEh`(&~O;v%V1=)x#LGO2A(KDffUcOWWh|=0XjHUx0ja%I$8~ICnnmpP$P?! zSRi1ll6*J%bCzyHIJ5G`jf}Sah3zPBY48j4AONyOBIjNX#<D*Il8VO=e{4u=yuwX% zEDNAcY2DZl{#uaK|4<svb8*ddtzl&EK6puQc4!mM=|ECBssXN}0Z1g*Q3JJfe)$|G zVt$Q4(r9ZcTYlprK?pI|6{)YwS&}5wjxUf>YNogqWr-y88S5U73PVmJX#_%61$&)v zxtvOzZ~_*zx{8x7hq@)0q4jEHpB&35$E;uO<|$1YBq9T1a=`^gEvM7*>&eLhc%isv zFa?2W0nclI=U?lXOP2^4O>#8oX*fe^Hc?o<U%g?5j!FUZfTq)NIXOTth?7Sl|1(Vf zPGy7&m~SVV2{OgEb<9?timaZj`vQu~Rprgqz{s`$VrmG_`nL|-o!7c$ju{->xuySI z$iT_xSQ=-;DXHHGBU@M{f|VuS)1bX#1qKr7=8~d`vrB~^Yrbpe+b;~oWbC(QI5lJ0 zwwq-C`^T=QCw(HMdN}xRD0GMcox$XZQqhXU?Mg_f?DrkP@wG~{a2VIGe?8t~Wi(mL z9lZB;706FqzQAho^{ftiI-!3RHu*DOud<bg;)F&lKuSFKZ7=$XFS0C_#OXV1YOip7 z>X_42(CKLq1skQ{rvM?id@iFJc+ZD#2yX+Z1XF0&yNdLysyJ^wpnle)y|S%;>6X^w zJ|76lOoU~jBJh!`A_)(|1)zR8AwdF&i7pG?NAZA-4(V~YuC4(A(<0G@nfoEoKC4Js zOyt=io*?XwJw8=OQxlP%h5i%!Yfcu*qn9X?k1+`RJM>|T3yuqJ@+W72LeG1|I}9OC z=TW{NQ3!<v?1xW7?}>PI+fL7H+hgO3Trh(ySf|6{(=YS?q48m7Aut4v!Q;{gEM$y` zL}z_{PaO+KiSz#(V~}JKu!OCQ%+Px=(bBppu7=8Xo=5*Iq<~W?PAAfd=78NB1Z>g} zN$cOak%EYz@;I5(4PLg27H|HSR{aPg_=F`}u&09fb2ceGc@@T>cve}V^Di1}7R<o$ zLJQzL6#!_j`6?YNwq}B~@)t~b<IfxuCbYw2Lqd>i8eexA*snMx>cg5HZe5ZIA>biw zzxI|w|ICoYRA#^dCi7(tn({Zq;Rv;*m2^Bb$$+H*in$TRQvAI#qB##Z0Jos!c-w<} zIe*N!RLdDZ4!mo|-?Jf_Ys3o-nGNqP4?|xnRSNvBl`7j?E||g@OXa)08M$N>h7uW8 zS8iT7TR=(*aF~4wbRcHDRQ$c{FYOh2S!_VQ<`)^dy3W))V*oMX(Eu+??vuD$t*stu z2PF=QjoCw`YZ?Xgs@;29y@G+G#c(=uQuwknr%#*nGvSx{S7(kmFlB+`^3R&(pIFib zvF&L3rB=zJhSK=?uF(0_0Z8^xsx^$J(#ltS?Ni*L!~(4|A%xbs@$u%2N!(v$+O1dh z?HBr{IslY02eIJQ^SPp^^#heLQ8OGNm_ufBap&3|c+T)L>KztghnyoV0<1Gl<~qd$ z<|;*Mu*m$QxiTS`4mY?KNe1tit((rtb6`kPcmQ%zs_SnuJqL+z01>Q$zd0{iVqoVt zAu*!Z&gYJz)@|=_(k!vsT{=H>VD|}Nj^lt;l&dYx+f{Wi(%_`m1^8%RH6R?H8wHxt z_8lFqB+F)y17WcPRd;Q9)#X303<J&3?WMh8G^xs<+=@K<zQg>;Je<>xw51mNh-OT+ zJ79?7<$jhjz6cE#Zj%xDVe+09YC7ZJf#@u+6AOH56xiXo6pM>wsg@D%>*`7!zzE|< zXKt9BA8V#}cn(DEP3=;b#c|PKV-9A0N_zC64mUiuHy!76apl_rl>pidhWpM9C2-I9 zr?8ysBk#O+My*uhR4%NFKRwT~d9zMgmLcR>&x5<ao^r%x^=A?jV~E5&J-gI!DNxVP zRoy>|B%o{|!y~jM6Vc1XtQRN`u5KXT>b{v&PLX@scWAqKmZK2=ziU%3$5_<=u1)ii z1W;su!kHT^9sd0%2WUvpuyHp~1HRUbdr%<7BJ>^FD8??(&}6>fs#UA83#LFjLEDA% zGG9W(SqGBBjKAC4vM3IdIKDH<D3WXiR_kBYXAv~W!f#Hi=^BogL`@8yb4N(W>9>6R z7B8mSQWXVUu4o*};S;WvNyQc=t-6Yk3)*6?(YbObgC;3slDZY?v*BYfV>1bdEjZ6f zPJC&D*%5CQL*<K7(HccAPy0f2qvf{Gbjk#pfpl^H8;Am})__z_sb&Am6MmN*kqk|1 zQB(Q7M=onm0wIVwo)_3TM6o&FwYJrO?G1loU<EWQ{?-y49-nw5$eNF}pI6b-3(CQQ zS|4Zwuw&te|D=$G_9F@FVoD%S2;m$D6Kd0vzhoUir?H8!i}wOo^$CQ!<zs1CriRya za?;uL6|Od6NPx;D7<1k+p25-@U01My&O8&9J=o)|Ufzm#0}0d#$IC>`d(J^dFO1<c z5G|I|fC3b6qI)>wZ4fWFUBd+DUyDGq{_SyIJHg}}0Bls)i!ve$isl6%y%(B5(di`v zU+<<jWTs;*(*W)OmahvlXCv<uwOup?(qx5HOYl%*;cR(rS!t>5`0&<uxXFzlV2{gI zu6=DqC*VLr=PEOB?E=yIv)(honq+$}54U}#0%GBMkyiXV{x|RU`JZkuR$GV$zPu~O zfpWgYb9JH)bKU3};8i9sQ%y7Q<rX-os}JXgnGe)GkXKrtJQ)D-WV1}MIhdsKMIIQ? z*b`uW9^<;s0x(pSKbrCJlz`q*8%67m6zL4ufOI^BG=b>92q-hJi)}d0Oajd?&x)|@ z1i84jSkLMV@}fg(h<gMO(4dyqOXfLdn1JVEYQJc`_SqNKWkF@X=-1xu7aN)ZoXbHj zYj3a2tvia#H-aObaaq$>Y-faET9J%zh5ses!^XoRguE)_J>hGU5DzAM^`TmlFVx6I zO(r=c2`GO&%6LVczoezU0-&jq^S3?2D%a$b9KHKH*A)ie8~#&XaVG6A`)R+Lx#BS= zFfm(^<iAs*+lbz|)(4eyf`QsKV`cFVcdb7=6zh=vCj+T#9JtbYX_eTGhL)5NV)kz~ zx*`=V+wv#Y(IamkEqrJRz=IHKn+=NSCC7#^9Y6iH;wpUjA}xKcE`W<$TNZ#=A~}n^ zeck#NZbF<it6~|xH#R+v?=DYi?bugyv^X=1#BcDQdP3)Wa7*yG=%JtSv=3G$C;JD~ z;SjYl>!2Pw^IeYpE))lj7E>9nFR7t62#$t7u@dVwlxEcDP;=JN#N)=JE59X3sKiis z23+dD3lI~hr0)#=Dj}!rUM=Aj5YvhxS1`4=wH;ac)P#hazqOYk=^nk+wfR4zMzY@Z zp;<H><vrgQ+~^o7^Ids9a|4q90=1AMsAT`&K`qLb9qiFIB-cUKFsZnOy@hQgnm>QU z&ynQfdQNU-GpPb~?<r(e#QOPRXDzGEKOc)viWua=i$U!17IzHXb8M{*XFC$(7B&Nt z-n(pHF6t!4{@xa4t$JviYyYo6BhYyMBo#AiUy+F@{LyZZY|Gakj|~Bn>Yp>rOp>N0 zCt1_ICmV!-jzlIE`$SCsPWaGd`wyxdd1yAI>Gtfo#eNTvu$XmYq9uk;=P8ZLg2BIm z@|f#0u=+o;rxD@;K_b<qc@}@D2~4S8wt#NFc6QdEwT_Ob(;mNmd{LT>Gu|>DyV?mx zL_!FSy~b|*6bjR;{q@YYxxzt9=nsYNvv`0*UDcj&R@}0E5AL@2`j=zHO2!(H*EZf) z3hm$%az}{Qe~SMv8nq8U+HO!@9Uy9_8TLxt^fz!U{-jc=&I-F`$W-;otFrvo`Le2- z@<nlaxLGiv6!5_kxdDNbwva>yUX3ij%n-0uO(!D<(3u)pQ|CzcFn&vQv=LdfM(!-Y z@4o}e{K@IrBoLDz287cV<G@rST)X4E>zG$Y@7oYL@HW=^C@rqn>VgF-uc!r^K=TLX z4Tn5T5C10AF35$pNS54K+RP;cT3Z;IjpC@2#drWnbsNLJ{Ae!#xHP?J#m9;_``m-1 zeb~Lxx&T2!#M%&Ge>I}CZJ-ET=V1_+{OXe_b5#VSw6>P^?Bk~K2_mR0g@Q!>xSieg znUS4q<CPr-6C0|c)4ByqT|_!EI9A@bsCK8*@TxE75TW0R(hKvouZ!K^prZpot)2ro zeK}CR-L}OM2QmcyGSbk|l+=I26JH1nwz|3gZ`1x0iQ2BpYBwV-HR_iCYW-o&>c;)7 zo=yj1&b>#ByC=IyA>2bo2-pdjH_k?PAx*Mhh!?0p<iVzpd9+Y4k(}F@n$`Dq!jkkS ze_`X*82tRMb}H_QK^%Wg0yU%nEpvsy;M*$UGU8b3lhg9NkeRBMBpz3VClT4d<gttg z9MFdhSEs0?BF1&1w0Aza6^2|KUKRlGW`FdrxT5nZ(srCtgqq=Jd)o_%K=;KKut`Mr z%yM7b`&W5ZxUQ-r^u1x}h-tfJj)oAh>iCg5?uW%tS;Y<j&J#hRCplg6h^B;w)_>q} z<v0E-cVv|sgw65Y=;k&ty%~@uM)CvrOG=B`K=g20av1Bm6?I-kpDCJh(8HK#xAlBx z<N<luZokusRVu<H18Zm7OCFU5a83~rl(=R4i7Zh~|7|n2{Ct*%qB5?;18nH)OjVN2 zL4()r_n(4JmWggq0(*=D`U?T+)s=f9Ak}8{rltY28BwBhyr!b1R|XO?^9FO^N?_IL z>NMKr9zhMh?3t_{qznB4H$lBEjRvZsjm<yqv1wWMX=-_d{c8S?QS+OoEMV0>B5eB4 zve@5vwJ+)bmmP3W*YZE4w&3pEm>2rqDKITH0<B_@!K3+rUafHSU-p5K5do9_S_{_? zBW~N@an0FiPw8pPe+_m#zp3p7`&+J_&m*fO8)KRU61*>|sEBA^>Cy$nf>3&{n_%ua z9wF`G>p33%#XSj7`FrUbXY8V&@RvpaZxp3?CvNPLzh<Ki<1Nyd$p|zxX8d*-Vw)L^ z6zvy`szQO~JLk+>yiCsOp_bqb<IiQwM00<QF_xkdD|B#L^v;ZX-DwVkOhlt;K=9In z({naV{CC1)p233n`o97J$X}ycQP<RHsH3ChH?Gn`hq4OjFw3dqP+n3x>%C(1a<*^P z$SR96F}FW%4BrDsG~D&!0_@ViDEmoNwgBDlPSWN6nn{xUso{Ml5XOVo(PD}H(Eeu} z2Tp&^3atO(CUD|p0~X9o0dc->J0j&beEJ9q@z|guDFK;5iz3sdSN{*rldR)`N(H+U zFin=E8aljOZqD>o`bXgvL_M_OMzxfLSTmAsLypAoKd6Z%`u~HP$kCTmS6{sxDr5ap zF>%tt&v8#pj+i_ybkw|-F8aI=ME2M@_tzp%{ReD5H@RLe0Lc)YY#?&F?fU%2&7pa- z6(AX2Vn6Ruom#t~-C`8Hml6{EKk+|5Y;9$ScX_tn;mhstTn3HX-Gt@w2<nLt;h$e- ziQe^3-pQahz0E7v5_&FTYH;NjfQf`$8*#q#G&iSzRPuN*EeZi+%u{xKdy&MOc56uK zh4ClAQpwBHd#gwr{N#FiFnS!~#sHO0=-4m@rr&=~YrOmN!<oq7uP>s<v1Lu)b}?`A z&GmJ0(MGS8$q_nXXy{6P{)SPff23(@7#K?U3^k=XQ~Fe{V<Dp_%U}E2OiHy}UXdIs zG%hIkh8_Hs<v*m&v>8BX*L7ViZ9n#H{Q9#XOWSUpLqG<CqULKS63f~OvUQ<@fC%HW zv{>+3G`u<5$b)-q4Pn4RT2IDxlQ&9c-If;5pe@hjo*&TA0xTb`*2|>=?jM;40Qb@- zSU<o3L<r`JwL@S2Fz{O^aR0r3!$g`7Atc^14<F;FM}tDo=bCSLmC^N)n?&HAS(fsp z-k)zJnZPEHu=K>UjbsOZ%cWF+LHrE#J@k>m^F~IvHnplMf`G`i*J*s;(PmW}X42*R zB5|P{!|GYj)~q`bdJj;QA;`1T^S@NO#sPA~i4a_!OX2BwlzUr^Rc2)KhN!LvD#7Gu z0+HdMQ@*nS;G`aevQGQ?;&qE6*KA1(z?pj``|yDQG3%ecXEXSiqk-{(SM1J)X|Yk; zk{|^c48KyP($!=kA~J%B*dK}2BeN-F?nY&k%=0i2{EX*D7D5C>;2ul+pXi`+gxXHV zm^VE37&}>w7l%Oj1nU;d%(ArQ3-1fiTI-oSK4Mm2NR*}g3lbZuEC(d_m&HsB8iWvJ z$DaQ0U46A|q9X-nMg;HAeJ(3-QOjP|phGmlpJHDCy@<ZQ3NsHRJhcXB)G$C$Aq6@6 zW9Z13si6@8o&MAAK@ux{DzK~UhYFstXvnntWI97u3pyrSw-?j^ws{(2xUC}Z?0d8{ ze!gL724GD%uJ$$zZ(j)|CDA1Npy(57S9c?K2UhYrc#TRh{a~&-r%sG}vpDHeSSwrx ziCvy;S=IgmT=>!Pw(Ds`_GQ}_I4?{2+{}lbJH};{lPE(7@rscjBKvin%0)bnM(DID z`3zxr_tJge>$Nx;v=A@{kf(E2-`|9Wfc+qbpOk@{LMRnSB0V%fi4gVekafE!V4%j` z>d~J+QPq+_6!*$_^WZ<)b3l#lP6)w^kuO+Q{(Jw~Lk>7#<9W?Z)%@}Uz)>l)-*I=( z&W`0k0gd@bITrd58Zz4pG0dcvTYkRA%KQi_gPe&R>NVEc0|mO2q6ZJ_FD!l0=;oMk zhI0<+dp*@u=tF<$7+n$IKQDL3(Bf`1MZGuG1-q#9w}MvP6j)i7gv)x0&8${B!jA`3 zh@8*mjWG@=P~avDNQrN(U(Qm+2MiwxA%CgEnf$JMOZF(|OAe}Yk60pi?8FzIp%0eR z&C;MJ0_JPs@=5lGzkiU{Hh)(7*45j{=OYtPf}m$Hp7%;$Ebemr03SR%RRTcC+A0CY z(t_$I18RfgFuA`wEK_ke%^|Zl5X0|@y)&YRnIwf)z)qpcf;4VT{w4$uNS50{pI?;# zeEFoG0y1kxT<@G3p|**6AU7ed=ylI(Dzu8Dj86^=Q`pKIY$6T#>a)OCD$>79UBLFm zZgr;UoYNGls&}6RF-jEFf81KAe7K^UQ%sE&5=7Mv>FtDvBcuKUpEuiiI6@x|hvoZ; zOe`G5A)sl%%%Kp)*ZCw;$mVW(QCsY-)zo*PV~Tg%l^GiYoPv9&GMM>O_IFQ@YP++a zOGw9U96$7M3Gl_MxV7`Je=D*sdv0m2!F3Ffdgn7bc)+ci=X@pLamvv&#{q+&P|TtB zZAc%Ukk9MgPBw_%9f!US#?#AkrV1}x^cImY#u1aqLf8Y?@BdvWU<SYiQMb}%Aa2zj zv^(2Sh@;|5p@eO?4<5RrQH#mBy2c2J#|h1g*4UBx+`AkFQ%IB9rYl#F1$`Y6@t;Od zC}YrU5);c?9Mb^dI8sQ#<9}qaXqdu{ZgTVe|B!$+&D|R=ZS`yfUZTu({5?mEZ&$^S zm6}HGT}a)XZM}*p*kxwf64LkG2sqiFhz^yW8)f_FqwiyNnn9QKW#h-e0q6_C-hZ-E z=HArPZq$Osi8!36l0cBir4)AOZ4A{v@mGWHUMIrA6ahl?o|D0-2pG>S0KtPPLO9LE zEqVj{RPy@G0~&}kjG{zc-ay1r4~wjte*ep;xMs_KFRyB5=7|!E?mUqjhm%<t(vR=d zEE9ieM?*9i&5YdQR2l9T$)_LR2cYCtY~Kw3m1T1YtK0K*^Y_1cxk{*XLoZwMa;s9* z#@AI~{V>KVgHK59!UR<2BU|vVtfOO{oSx`nf|09tGB6^rQrnU&6M0qzdgr%$DHT$S z$80RsU8{lhumn)F4{|^QzhCPL0q-K3lk%8;j7Nt3&`|i*&|$n@)_6D%Ncze95f0cJ zmpe?-%Ic~j@Q9Gc!H<rCfDkBO^^#k(xI=Tg2LK5^;`kNpB<27~Mj!!smj0z6VJbZ; zJ#dmZCDOoRp3ji~(_Jc76NYkd43ASQTz*d4BM|fpy0cw(WcA%RFmVdtYPn?>VF0t= zCH%Y<xzqrG5a=^XKTlt{!O(BCfCwqsT7I2)scGNz><3~2bfa)0i!<Cb#6V8MLtqoS zeK1Ks)@c`t0&ZwHtvQD(wLxI~Cs(r5^`?ot#Irb4fd|$_zpE#LkO{%IE803u1AbK0 zpXotm#ef3M$nIwU6*>nR3nCoCs=lD_*xDL!L;$*?PjoXZ5HKi~J1hXAqUUBGoxuz5 zt_<kJ6*ca*Uz<+nXuJcsQ<{xTt~;BjoD9h_TSO+{R!Xqp1aO!|YQH(WAOt(bXg4sc z@n23_zzdPOu@oGq(CNKRT;+E8d96?~J6qFQEUxtmyf2u^?QjTUh5`by_RCAq1+NaI zPv*sv+g;*#fJz9UoF%(Dn`pU@w|J7|4+SqE&z6&oYrr%!RU2BSouoDk$k;~LeAb)+ z34`K`lKqXIZ#K^51%Si=!iI%x`i=?4vQGJW5k2me*APhGw_;73$x8d`s)$POXGf#v zFQFom>t{omwSXO>GabaC+Ts0E!v!Sp%l()3t)DM5P&sG)%3vV@_#Qk!a&e>j`n4p= zwQ%h_G0o}vgtRlDrTm2VJ=56T{Y&0G*HY6>ls5Fe2FeOT@R<bA8o<(wYc}o<Q0`&0 zbH<YrWp({k(e>42C&aTVq@HWYwXBamj0JIPS;-FwtIp4liItjIT97`}@Hy-5FQ782 zx{W)pV3cdxIRt=ja$-E(*1qg|I{4C|yq}{n2}<7IFD(|@&8XpT*TENZ*LXeS@R=nq zL?d?5@v*h5y)B$@VWZ14R%F^k&qMCSD)BI=fX7|q=QBR2j1R|M!wXcVTJ>V!(Smw5 z;2-O<?(pCI$Z!Cv`$KrT(SGnno~KUUImiB39e3st0KYdw=GKZA*UXJH1YXox^B(4X znH7dPW+o82;NGzN%7brPDcb+71$feB2nD}ft%SMK+JyPNqzjQt2SqOuI~c2ON^~<} zyuq8D-*4V_CUC>KOX(>re>zseJS}W*gxQK^^{`vh5C9iIU6h<>`-+nK_A>jrV;!b5 zB3MecUrPcGi2ipfa_p$GV*lA@7|=P=`{b9H-0#XW)XCFUsg{?AYY`dP0v5-bcuTXe zmQ-I8f(uyd9gPe$uA-DWuL0%tqzs_on@g0pOq4RTO9;|?tbLK$*eLZ)SFKz_hh?lc zpzT#`k7)3M7gM>JuCZ9S&%a8_z4a(}IkY1Dpu50DqTu7>V>skHIi?fPvK2MlSM{6s z%YxU(e|WQfcM3MdS9?UuW$B2wcX0fpgm^u6$ArBTQu*zaW~_i}nzQcZE&$}LbG8HB znn^Wa=M%I(Zk~Z}aN{2ibGV^Va^e<C+2WV!Nl0VOPcFu)T;2DC&)aJi=>m3lUW4s_ zgf81?DYlQD;joqn++`NnndXpcdEqEB$J7s3TD<!Kn7)XtS@0<Oj?OWv)|VPr=&qfa zY*KR1aR1Fc=4h%wfxsKx0dJ*`wES=aJ`2?EZf#Kz=953SAQEMESRaQFbsUmRhM9I^ z1R@E^4aA5b#maVuPzsBOPzFmOQ2mnxq(KzqlYy7-q~HKe6%xR@!Q)#x%zRigGSXND z1BslcSk6bHR~i!&sJr3}8zO^{=)-}VK;u_tn6UQ}hW65Q|L0Ahw|mSB?({*J*x#Nz z+PJW4^B6ClVQr0qD`<gmMg#=dR9XSw!qMd*K@`JOzoe06GF428Gs(R>U%ye2MWBzs z{FWCT9gLcr$44K@RUANZ-;Pe)O)5K>b=(f~^YhQJwiL*8&1}|aENvd&^*WxC^O)gZ zbJ+*Cxs7?P!M^#Kjm*%Dt}qeDQEHhQQn92k9xqH5Np{!2nk#It(Gy%*iyi&SFlpsG z&YX%}ne;e}_pLol`tsz-Oy(%6c|+p}amng&kzg-s(P;Aa!u(TK`XevJ8+rcjMcc?T zhg8m^auidof%5{k0|(fO|A~(ISVo+gumVxX^!(-OJ-M(|<BG>nO_rd(Ps#n7O}%1K z03~r*z~ANI!iu}ObaG)6SBG(+mzc(^0K~l;H3!csk0+>{!KjV`ZfGAVn8Kg5FtMz` z>Ry2z94Nv%@6zq8)3W25-$BPj2{kf9bWv*A2vq(2I%(Xn-mu-n^e_3G&1A%}S)P5X zVfWW#3?yXv(FepLHnrViHiZUu2bRDm$Jt$nFQ*f&8aJu}!800@ZjI;b!V0a%GZ76P zx{i*3ovu_--y*Y>wiN?}taCvZ)8&0Di{}5UyQ_YSs*Bbz2uO+29m0Tg4Bd(XLn=MA z#L(RhqM)=xhk!7Ygy4`;gER~^bdQ8|NrS+h@8197{&=2eowIhVz1O?mwbwo$4N6fA z3BBan?Z*dICg%R2)IqBa&$oEHrPd8z8|ki+gf`T4u_yM2$6ixAmQ?(MrWyt03xzLk zW=;%$E0>c_)7$4hAvJt1j4)tc8eO6&!Nv2;YP>kmP@U<`<>JvKr+EMhU9HPGSdn&T z_T)+GBrd90eO+ttrGC@xAX`4zby*j%QRsZ0D3m18&UxyyYyyDU8ZeyCwHkC6%MtLs ze#nq;y_0w_V*0L@n6ucqHx)Sb<~$HQ>T=nS0nR@C6S5_${+Z_)U8RzX=9GAS!|>g_ zcyOOpB|yvbT$Za%f43?Rs?1QOL^A6a<I0ko-S|=JK@|1JSH;#9vOgExuKvVJRt}hI zSOs`2@0nXvj)i7V1_-(fa4>`Rvl^rSlcj@2*ERG>w2Q}A0vx^172M5T65e<ZpSmoY zsEAQ7r#8O-PimG;#ZF7h=AJ>tFtSoAIG-radD@eA>#DUrUY~S9#+}UbApu{F1%vhe z{9xt+wllWF%^?4<NCt0UFgsQs1tPH(*v(E?i7Y7CnWr8K#){O%dqZ^stMy#D!S6pC zRzz+DYJ5}{HjeZyo7t{5=w0+Xemh~bSp^jSv6bC?LQ;04kD}SEvU~XkCf;pT1Nh#_ zu(Ry2m%Y%{&znq30&P2^f6JY--Ggls+rg-*64Sd*;#L6J*`%aJu>H)b@DJkkp?46< z{Bpy2ZBhK9DdKsjGsctY$1&J%!8l)!s@O=j+%A^u8EsSnA1A}VkIrsv=b7A6Wm#aY zB7Hq?a=~YF=3;3WloF<p+Gn+q-)=kmLRtRIpkB76q(cxpd>>XBZw}5=9dcdJu-1A~ zBZs54R`LIx=VT)NsjjAjmJ#`9Sh*hCyGm>c@>wsDX!MyHAMKdNkDa8y=}$6r=_{+N ztAz*EpM2XX|Gw2MtBFStJAzfZ&r_kVO<*x%I#lz^=MT0QM(Y9`g2kf73_RO8rb_r{ z(~?e$%-Fg4A?*GgtRumYMhV0(N&|2${k@!^ycck1R!AMTDj%x++!&3vF)VVri2iI) z;F8;N*v-B3EuYgky)nJ6-zNA;O8VqZo2t1&-%eF^3%$C14JY`0q@i`CZqeI|bVmlZ z$6KS)Ape`3DW6pjQ4@h4mox*uLs|coa-DU7o{WZ8e9o^H?)pK&L84Vf)24cD&&6+o zg7lsH4NuRZCZpLw-#@9e6_su-SI_AgLQNoS$s#9M8`w+DVU>C#9;%0KYCRLfv-)8e z*s$<JeJN2Y_)oWPw>cR+bzwwD{`a1Lg07ux<=Zr;dfl&Ybq&&pxeQ)%#5$K5zJL3x z(p?x*t_CQ2XK<5PWoVJ`0a>Z*NhkroNLsK>IgaWBlm1H^DEuKAKzAE%v$MbLW^?s7 z-*sH%XH4uIpN$17V(Y$|IV~0*ExY2e;_-1rq!R6pbb%5iY`H@dET)1R7gyg|GT+=K zn~4d#NNpsMYnIi`Nji#2h-Z~s15g%iCz}1XO^j4o?{Casg<cfheBl*+s}^0j02yED z)UVyTJK$qUIm3dgK>`ry!k-iLRy!J%>nZBb@I8IsZPUo7^%}c@4|#mpO$#D)Ej@EK zg6oN<2vnP{jd?@0n=62{+<5AaH5PcY7j7MG`|Y&72E9oZw&+JD)8o)Ji=gGY{oT4B zp|uI-XlTVk1sB+6{#yg|RnO0b^o5cfw{P`)M#ld2PG2hcN)n3mrl=VW%<bByzRCOb z;oY|lvFKe4>fWJygv9eg{vCIfwz*!fCB#;`L5n!2hAS;V6(+-QKXG31ifrtIUW<NJ zmUtyJEjw#|VX7wEVD}&d{4E<&WC*Hn{6s)j?iHR%KuW5r-F)Rv$=l}K0i0`k%E%u_ zs?9<`Qd_3Jfk9m4ovJxkt4pMMlT|1}nLw^4`^{<cZ{IpU-Z@i|r>j7E{K=K~52`at zThr<pk!n|PuSI<k)J&?Ik%eX~8H2kzt-vt)jL|G~QB?ym%lq3heTK7G1J;MVyuyoD zy~`;qj>h`|;NqKV`|NC@gX+nJm8-K*f5BHf#b4=I2>1$}2UA%DESTfdImH<g63<1* z39zn!hd)#N?CrSJ0Q_+^JJFg-m3ipc+>IukglRn~Ulb5*?p<;k&)C?iUyENpQ7}HP zu+v#B&rKB+%lTL>=L%7>Xes`M?M+i_ra<WIuPK}K%D_XcBO~XVxqoY419yPeLw&Go zv3aaO1Ugw3gWUt;^+&R$uM`Y;`)G$9>Yd1jP=b~+LBqM#Z<}y;Ys8FUjE;_{=qGk{ zWmr%3P!0W$KINcF;v4sC;UaN5p6_pO3r?~>-TNG$ZqE_;{pqd||L+Zf!~J22zm3nt z7!pQC5@Vuji61c8?}Lt6iuNC*5Z4C#O_Q5~LT&C)1AV@}WGkn>UGr98bk9WTg<H#U z_Cc$!t$NY8@x=6%8rH8OowGVF1pSM4JfZ0~YJ3$uozJXxPXiHL`3j2{WK8D-8nDDH zg|>^0ku>L%>CZ${Dn*F4{c#d(=N=H)-7U8)n$z}GuyIsHib(^F-I2#wJaPwhdPj`< zDEwbz6ShMek}YT9laclH*DJsJc^}UTZ=!O&Xs4xm#%i)$pYPPFtWA)d=jmpX(dF26 z)A56MvgKP!#N!N;4qQ{iX3YraRoqW!uMigxgYobIBF4ftgO*weDanH!)nv|`%+l`p z=HL5G)%ob(5NLR*?B1oxe%~pZ(r~WZQL@wQTlu52;%MAs`~U#)K3~>z`|MLlY+FZB z`BtEGc)8JPdfgfHMBhp!w-W{*+BCjBE>8MBIjg0<sij9auj;G75^unk9FLFSS}`l1 z{ZvS&GUQG+L}SF5)<v@?ef4LLiaO(oV-4r_Uuo~1`M{I3%6*=M@oyaSlEl5dj~&tx z_S)BRynecG;te%v#>d$Io2I<h59>W2u`@YoH%%A1=57?vP+xLXp36&C=HsLA<UfUv zPV6;*mOtO%gb>Bk1jRR;M~%+;|1ApC7)W{ITEkghQBfh{K3}&%ra~>jr$RlpHLim- z?}zXq=^M?~THW&8%+hfNCo+;I`_ru*c9Qelnlgjz*ujsI#;}`TC`F9ckgNlrnM{gP zFk{gUGs%Az^yBwl8`rV}+7T9ei4Ho+Zg`{WqqVZp)B1rb(yHcKxX5{wh%abbpBN<n z+SS=!U$yU7^_(oh%$X9K@}J?{za3%>rPfuFCcC~rm1fTLCGK9U5g+k(TD8##N(KD- z8)T<>01^4NzwhI3l(#d_L06$vK+QjEKge47RWEXJrcUJ6X?tsm^&X38NGog!hbc&> z*|4kCvu9Ro!D~p~(AC}kY;dRW1d9e9JMf&G=Y@Ph{rUDm#W`8LGC#iAZ?(2dd@Ts{ zAgZ3_XNe|+Xm{8si+<|d?^}hT0`q@kN=^dRYH!djN4ZX^?TYKYo5eq|*UpvA1yxI8 zQ3+$glpbDM!yBLPCRaX2YK>G6*9Tj(QmWt7d-0Y5M{!b=&g-v&b?)XpMw^yNJFTcc ziaQ%BP<r7J0D7$M;=x8n-_rEn$f!7nV%J`UO<FTn+qE{s8L9pJUz*ppLA&+mQ+!5t zCVlf$6?SA>bmC6qbHUm~%Sw?-k(rV<tA{#mzr#Rta`1ELppzOyH*-x3d!nhZ_o{m~ zPcS_B&ortl(fq#HS*5=1XW+{H!u&T^8;RurmoA2>Z=41d-^3UQpt=Us3?=Gf+~(zK znQx87gBk&qCRN1Fnfh;fP(e;-*IcG;cSc4m-o_sh4<8T@E;6!YTZoK&=$(dT1^ZZw zW+gY@|7@e`M4@h(2Q)KnUx?zRWHnC&RIBV~o}4e=p6BKmF}&;i3&&dD-+!_zif$)P zeVNPZJ@YLyCRHXP<$A8uu4l23s?t6gSy}zva^p6%>r`HBx$?J*?0N&#&a{ng%)AWa z(2A%ln#3FB<zGbh0KkYXUn`ZcG`AFKv}Q`=O`o)Sby%B`<mN8Rv1hlbDr`)2g>r4I zPx|g&2exx{jZf;_*-8#_N;9wtl1=v+UKY6s_^!l;>7#WEv6>-Znov5di>(i&tNi(C z#fag01iQNjvK{)RezvN~URTaAH~jKrBXyi_a(Zs=YvNDwc|wNDH{Yg%=C`Z)cg;Zi z5t3D;9N&}*{)OEAB<z!vVI(BVdH$-!aLn)HU<HAO(i#M`#9`o8=4)6jEd)1qinXdi z6IAYA?^dA0vRm^nlPA?`o|{^|2ZX4hTQg(w9iSZ}uZJRGg0X>@S<rJ<h$9c4`TfO9 zd!5jYrXc%bJOgJT|7tU)cj0)E$Qt}hs^cr;UX#S5F)y=p696tx_gj2Gq*4JV7NS3V z0EpCmOlrvX_~8Tf=U5!A#P;|Zey7#{3Q+z35UAS_U>lP|mcS%3#7uNc;ab2mbrYat zF`NY~lr{Hv@g)tNRXki$jiJKm#v=h<4@*}Mnn(RS(WBcUA7gi91e>buB#WsWw6s6H z=9feiU-9s>D&@ed&UQ|U4iy3*x*XS6uq=TgE%>`mUTUNv>>MVhjD7%?RS!ymYgy-Y zn4#BTc^|`;*|!NmrkS5G0Knc;$8d14+Ppbh&`Wab^`^YgwgUJ<?I#$0pEajJuTG{0 zXh^P0f<s__DPphC4I(3^g4<!u&VKoD#jH7VdUXMOrB`U%X8V3q;6CRCX<(7{Y*d+L zKI}Ae@nlT`+?YMLS}Ar>N_LqC$CDe8o<>y<sK2hj8A(1BNzx0mhT7W}+Y3j0TO5{A zMY}Y|ID=fCZVQZ;hRers-a^o6urM1a7POTL<8V2az{xdaUZ8g=Y3hAX154qQoZ=Ct zKy%)0QBW`!elso@=?7DIx{U`rPqihAoqKt(;r2ajLooH!6nrnRO%9!Quy8&8bbay= z9Mez#%~Ol2@zbJ47Zo_B!vw!k<GLQ(;5@Fu6=CEw64bpJi1E!La>7LhNBmUHIgBew zFe!E?K5`x1h0*XuYD6e|xZ4yzn5DZk!i>|LLdZRMjuNSS!Uu~i@@cC%|IfyW&-RJT zXwK}X<sO6((0x&{q$aas#BgG`{^j{P9vNXMmFx`@7Rbv2AO2*yIJcCE*pHx<oBs*O zoP6qfgL{uBCU<H#aEt7VJU6UUB#RJ1IwE1Y*L#h~Nv_i*sVIESp3uV+Od!Tq{gl~~ zRf$@P>XN!j<XZVy?g;W@%M_!LXWgFu^J6^je1u|9!$}#<);#{DrH*;kIuWM7^5!cf zLK-=7<wuQKcIY5;$t@t`=(WOS#NEVgV>z?!i9$YyoZ3udEYNqXM;9S29&K`@Ou2qV ze8?%5r#r|NUFy#w$Qe1=>(%%(9~?{E>7bp#IOm8jh`kg}oCSc<pGC>2+Q+k_2my{? zR=5)ps&a$w)ERg=_EV*ffOx$22*!cb$he3E^j?HO<SQ0{IwB9B>Envo!53R`!rfCB z{Kc)WrOzsH?<@^(S4ljC!}MCKN(e%zHzk-#<*}F#mmv3{PjKpz)7>K!>W6y{u0vl! znFXpbhvHaxL{IX`cZhzH8D&zceq7+4Axx0{&u}I!vH^CdcZ^q@p^<F^bq1jk6>!sa zIln=bQn)*=BD->w0#y^CWk&AIOnTt<$L9v<4B##6QEzL{I+5G@UsLcVm>~_3OLnXR zp271zp%HzI@sO6hbq6!#BXT)gA?O6o5O(9fvCO&rhzZ~qYD9b}&=-8IOMwfC@_uwx zo~z+ymMDQx#VXE$EApu9>5y8a#)(6oZPPci&19Pu9MMT%OlgA`26{~QQgz#4r{pj$ zyqL_n6P`5sxc=97F}W2%kWAoqVp)gVfT?B$u7%L{h1bEDU4a%l1VaW(99qC<2}t2w zdCbY0-j7cxlvZb=+Xx?CzkX}l+zB>`&+uVB!UeSqZg!s~#Qz!Uxo?$)O6L>axj>C> z^p~HubJ9Lz$T-ZLvx7YR<ThWCy67Osv+V?)QU5uI%F`}*YYGll&A;7v_b^3N3tf-A zgPvPcZgdk!65csC2b9%qeGYcsClND;8zHz(2hG2G!WuG2r1E$#O16dqz~MLwSdXFe z+@A-BYmmNTpE9>y6TJjGNINZn(-y7>WK0TXY+GwI$Lt7t%|O2`#+fjLXrlu#DbVQ@ z-K^SA7EMVhJ|&A94h(Y7X#E3I;4z%?PEd{Lv2h+p`{v-geb}S)I%P@*8KC(iCI_gb z_?r<vKqF4x-^?8T#UL7CMn(TyQ%^_BA7i34O?}E5tb7sfpI^j}2Knq0=W2PgsQ6>h z%67yf6?@TKKIfZum_8&S_|I^oyx_?0{SmqH)?0at3{r$RKgJblo#cg+*BwZHp!#lu zz)H+*__~E?$Aa}<D^58uf;rMucgzB>8ZWWeZV0TgqQ8jP-r%YeV6UoSx1tFXEDeXV z?LwqV3G$H(Kx88Q&Q)FvjmK>}PDVDDw}(X`>w~-1a>_-(wP|#9F;D0|@{q!Tv46!A zH?0;8>6w&x()5_thdD#$h&(D)+=Y}zm?&VND4sEbJh|{KGSoe>yG>twsH3=;ujE`H z(oSnDl$6%y4}uBya?=>&vpD2SaR98sal`134tC_J_Y6Cp`;NQgsM?m<6NI_{CI?I) z(3HxD?MQQ$ARV{J64u}?`gmGTjzSdRr6+=dB*H*M+!qf)m@2|gN+YPGcu;n$z&6aY z+&OQJRP`uogh~l$e2Ln+vj!w|5H4%Qfu?Z2b6ja`_)k#0y?pg`W<VN;{5~$kqBp4e zV$6%929h3R?c|21jgwCP^}<B7UBrW<5H1!$Vlr3SR3}ACArx=TBiy{wTr6qabXm}1 zlZzmhN~9SX#Hiq{00Skm2t15Q&Jx+fg#Q^J^QzDdEN#(@Q&%NXPQsXtD*7jDp3jp# z193AvYBz9#*CZ1HDd*aKb^eZdF$$m{bc9y+i^-wFG%3eFfp@#fw}Fp7?n<S8IEOTi z|9vg@T<lC^fQ-h?Z*88gZza;Zw;vx9%9-yL{A5#pmbXfk{OhI=(n2|7QpRJ5q@C!= z0cTZ)<zijBPT05f@Akh-Y(oI~mYi#|beP3Vlk`<HBND=cs?)!?L5#>?P_;kkA5-}C z39YV~m0KYhbCZ~svS*-A$Q+qr?p#7#e}D4;B9!ve#S0O-@RC=fl8Y{Vcu@`k#8SkK z9M6B_EGOL${ZTCD!Pt%tnl|KpV2ric_*(UR{;FzvN}oN9CR)h8yckk=*H)9i?DHpA z(rgpRGJ{aO*E&}DrYdqeKds7B+X*<g?m{s7V&MGZHvpG+Cj}b6Xiduy_w{AJTc1s6 zc&9#Tif2-gQ;#j;?-H^%9hyc&H0LpU`;mzCe0gMsPo?0*?0+lND*&_qDS+oTE=82_ zdhE-C2>Dr$<;IL7jTh#eQNA*6PTrxX0M<cWcU?6W!P;z6`8dMyKs>jgyZx$fATp1+ zwNNR};X%nhAt?9B89%X%`KJX+u16h1CK@Ifl>~_8sCKSKwNOV9X5l5K<g0|(@b(&m z8D~^I`;vIU7zFH*__Q&ot})57@%0*G<kQkR2C7Bfgi$}mZGx#a2@}5ek;s*Z27V;{ zW&%}=P~8h12r_(!9^<Dj{OV~N#p9i|?mC57+nQ<BsOPK0u@6U@`9Ce(1pl43@bMr@ zTGQp&ztq#g#qso}ymk=ANU|{OAR`@jXCvC3t#=0b2`XK1a#m?wh)2%CUM$at;&5?0 zY$^>})o73E+RWpCj#u)XyEmdw@i#+GD^>HuL|t*CO&1e2zNDJRdwRZ5$o&kx6*;{X zFR2bSDX-|qG0&T!5)JdP$9Llm_I-EW0ACVwuMzxOz~aIPxb%A0knZG;ltUga-x<&V zBy74!s_?+B@+1MWVZl3Qs=MBiJxc{{7lu2$yiIK2l|^@>KUFRC5jJuQ3;9nOD+!-v zmO{-uOowk|-u@GDUwTE@NI)xTbp!knFxR=_@$VDY48mhVB`J9Fij;nH!X#;=NpQbe zrIZ#QgJ7AVT7<$r#G9YsUVgA|xq0@j(*#d*Sl4tKXX1D?`gpq4mzLSg>wQxtq9t(R z?f`mj1TGEA{m}^j&Q(Qj?;Fm>Q!VRgj{aP=jNo~Cz#>yT3v0m-={>phM(rJIrq-nw zZ8Qwi35JZLuo;Dypv*Z}SlB_}JU1v=bn)mI2h|(O+L(8yK|YifAWxEkoQzqNJNl>y zyu4}^qrtbz-t-O4qH%FV^QuXR8+SjMcBK+~G(wBfx*TR{QzKd$F(vXSQw^`C<jYZi zS)0YaozE%%<Rmo~o{wqH!`DplN$lh4$PgPXO-zN*oHSv4*sl~qI&7dq_Jy3Rcjj&> zzeM#ieB!gFPH12R<6E~eET!=olRvtffEyA?HZ$Oy43qTzt>4FQo2$~+YKr0cPrT(x z8pFp&H~i=lx}JjXld;!s==91RD6tK=RdxXu#SU-ew71hwtK!$!Uz{e7hC1hQU4714 z%4__X+N?yu($}HL$KLgR6IhiPxF<8(t>5@T7-0(hvg#Q-8Z><Y+^0I3wE(j^PBrW^ zVyZLy41m6NWkp+i>>c|P;jYj)1Vsu*M=CaJ^OWL;p;o09Ej1`u3C${}E$z^x`3d@5 zjImMp&+lE^Zk<q84p55{nwq6FckuBp1X&CF6Oej^4{8}-yR2;LTAS4YsM?jlXPGd8 z|Hwt(d<H?M`6R`SRqmEhd4r}eRYDflW{+XZpVN}x{?ZUhVw60hg}Am}@PNbP0$pCA z!vWt}_mY~bW;%Yqxk!VFE+vmg?E(cZr0)8VBJ_?tq6&<S^4!}$E8kN^{7^V$9Wqsl zHUkdWzsz4?aRIU)q+(=<8bBh(&<4%0U5Kee@)^ICO|x&sNah9>oKTL}fc#M|3I9}b z48XLwiro8VCiwV`X-Lf^z3Rb0b5Y@6AE#-*|CO>+F*J!La<*oXbSlv5cX2*(IG(aU z%z?m0n2uWFINPNET*<=}T%a2AJ1+RN1McI7UK9CAfKpx9`)V!W=jdLRz6=?}tAe_J z(`&Pislq@5lH)*@c4!SOs}sfvx~YZ_$!lk6q#BW5mccpXN92LT)`C=@OEf5Re`1l} zogNZkmEn^{9W5`HST*F1EB9C}&UxJ;cCDry?)yXR0mU&x*GjBFo}$3T>sW7GJ{S$o z&EROy1#vh>0XYs1^`rm(5db=Y(7B42f`c*^-&G3b3<O%_0Twy7MZp<4a~wQ7Ln#9+ zeG0ZvK2bf2hn0jN(?^Ttmyf93(@q_tVcA?JegSQZ&!ClX5wEw(t}rLB-NQDoW4QeI z=q8H4`nUEM6q%vV*G+8rcRXE)jS`Jw^MkfUq`8xRSwl%8yEbz1SF8KTdJo1oosmmk zZevE-b6<G+Q6%|h5slE2r;q8fZ>U$SddNBla{Ir!3Q6y~r`JU-p7^@_SPjq~k#=}< zdcxD(-rR)})e@PGeUgsa)5bgi)Aq^%5278Mfy1A2<%koqmgwjY@|_<aW<1bLP_V}# z*_ieV<Ji8ITZy2+*wn1{*5d;p9{GK>yS9!F)SnUa!5cr^P-ASznp#${h6IJ(^=rJm zbRYZEW@R*)V{cbOH<oM9GN;ly3+3#w)_FFu^$S(~06IjUUZu-_od8o{3{A(I=?@e) zPt!wNvWB#>ua(?k8AD{BRlS%u*%<q_hxFmz#j`INtDG*hp^p;oR&WlIed-s{T6&|q z>GYK!NBf8Od(ZwYJXQoD;&h*t7H7^0AbpxKGyHyv%P-M{MLKv*=IDE@J;$y7T_I;B z@8m{MJbBp7=H^nqJ{>JeIID?P)VMZkexoy9rk2eT+Wt_kkSpG?#Nr*^CmPgdzt)C$ zSJ&T_*h1l#^tg{;K9z9(r6WGrGFQg=wjp>FM-gY4eEp0-;xTKK!F1iL$lsBp=%~?) zc}6QHk36&NB80xCjX0gVA*Eib0G64h+E4Kgp?p=DHbmJZ3IsP>L0@uo?{Bm|H2r<s zkYHwb%g5RFz>I*2psumt!1tq9_0^s_quc|$z}1v`F2quLWY@arO@5heB4u&$29`lb z?FGXG!2#DDnR7Le5J?0zRKjv(|DFm=URSm=4pZQ4%xieqgp)bG8qrtF@Yuc<cL(Ur zMMMfJG)wZFATDM(B6lJBr+tv8HSyV+ZD?KhjX+vBI!e>=jKMHmJ2}|ux^-y<3RN6b z)2V)WP_U^kLmLnS4^Q=e4dKSMC2#>^|CO*wgyDv@yF(#5omY#Ko)aNhBl)3wtfJ%D z_&gTBrUh;})C`yGA_g}O2|SVGrKLHoGix!-o|7r+cet{uGgCU1YR=dtx>aybUl4S< zq^K(9{9P32>`skzz}O%SklF8V(^4%kv@f$%MV(guumm|lwx3ZTOXaTNYO;@5Gm6s- zaroorSjz<<I5Bv9a@9Rb2Y_}!D|1E*$Tz|@k{qzP=J(~m^@V%5s5wdeLX(cfcmy>P z-nua66j6&Lj9^`BSaky${a!voyXnQ0CPLp;Yv5v;ScU=`grY7HH|{doX@FUbf+6k- zd(@3Y$w4hL64@A0O0jjwVHt(LN8<|xEsh@P5Vu%F@YV=<2p&14gwkioc)XdvO<c*D z{o^=o{_-I~MGcOP-1XWq)lRT%4Z27>!VSYzAgt%3gx{!eM`rcaKG?#h#$?Cmi9uL% z_C-M!|90>&A1^o5P!fT?OL71@Et&Lh)GL(H-&@R*7nb<hhr34meK6%^z+IbQPY@oi zWylXBF>&C-J+=(?<xTu!9hjdaLNB(CqcKYywZ{dL#l~dUJ8--Dd5xnR7<y19jOu8V zC(XbKwI>3)$;%r4>|Kz_<ygH)%W<#_^2}n}CSa?I2P!bqT*EzyAE0|TZ!%`z6464v z%2#DY#W+JDXlxMbfetc#p4!Cb$>cUfN^>OLT*vO{r6B11lI>|w4tBp85kdG56)VV? z9oYSzOa11UacT)i$o?3e1TVhtk5r<$q~p)8q{EZ8I8NE~)3`3n3Kf`l@G_pDh{A8x z8nKfV^enxR;WUrd(4nAv05Wxjc8DNG`!_Cwau!vxE+im6uh1Wq5JKz<1kR0IyTlK& z-)8sKej=r*sfSP4uq-E^dV*T`!RB_H-ci)_DMM6>g1?EIQ(rZ9%Y~_e6}k3~q&eUC zB`l!!d_W84=$FlPT3}TRu5Cgk5C>~MWAG@~4$*^byXd}J@E1Ys0Ov}>;?q)VJ7eSf zlc*JEU9;dRMS&xuJa>=sW56;~rkIC)C>99>XuW!rJC(nAPX(4eCpTfAQ~_4v1C--M z&O8oW(mImrk>!&XbXnWVj9CG8Xt~AULy~I#4AQ4GF}Xr@)L~gmTp2b(g7&KoLPP=9 zP<iM%rS#ztXrrO<;`bQWG{vFrKOaeI@C~q%`>{jx#j`Mm+7HkM;pfaT1N*`(F?vP% zZ#ZI6*bq_q*NmL@RdtrR0>*!HXk$25IR~y0=_<EFdfJ7W&Yau!lH8;iouHJqdMUZ& z%2L{@2$qjjN@*Qkn`NY!K3>l3Te5@Ba8?#g+NPD*ID-}S{+WI7SCetX2o;rg>Zo4_ zqr4hEpMuy%nLZWwp{mmsDu%da&)Bu}x4olS)wSm~@Hi;VYW}szX@i|=&XWQci;0GW z<jWcP7t^2I7hgWl8v=&Tq6oCyux!G{;_tOb;TI`6)5KztSxf8#+$p~rl+aS;eDaA) zX2bM-g=+{r@6U823ua8kmjjQI7xow89H7q*Kp;<y>)e3#`!j0r;i=S}F(}wYnGov= zU<!wC{*)u1u=EiUbfT(LeX9C+6fE>_n_q?Dc5`!9mXdZSbnq}J2(H+zAz1pBU7()! z@2?ShsI{P}p8_9=RlgCCNU5P|<+ZOQL2)fY(~?x-@<W`r!s_l64v8f4iCU>WoY~h2 z!LC5Z{NHrKELy(MbY?}H^QT3cm_Ps%+W>c@i>~BJQ=n)*^T5ro;&XgFEN_IZG+Hiy zK3z4fdiwfCwa0RFUK72c^z8;6uXI;%IZ->zS$ftszD8h_{>dLpa5a8>@514D*!s#A zX(W#=KHNCbe6bkZXK&tI#yNt_i|veECJnE?JUJW!4vT=k=juWmUb^XZHIa{P!`ip? zR5A508Gp*tpB#15tD^RFyaW$CrAaft)V06+o7IXhHlVmJz@}Ab_n{4IDz20{dA;Js zQ|~uuiSh#)W|F5LI_LeH7D{AsT5<}_oE!dYIx0gWB?>l=H2Rox6_~=cE4_k^BVvZc zsE%l^diZHRC*dw^2s|Y#%*sN@>o{{oC>$it7i%jMYJNVAhHpxSBJd7VR-Rsd;DJ+K zMgNl<YA4im`!Vuab5THv!v1YylYW?E;qtfNYY`%r$9Q^i>M?Mkb%Ccq?F<cbnv5IZ ztvlse8`DYCacVHfMAD`qsD|?BM<3M8A3inLv_Ex!@aEzc>EYKlOp1xl4E<L`wIegW zmJO)<x-P_le3R#TP^88vb^eB9=@xDBNSN$iU|Dg>_6uR~q`}}Feghyq@Z4F3QEHWR z)DE`#$8R^T(dk^kOt<i?@=4paO-lEdKVX}a{zLVkUu&1z;CrHY?XL&vQ75*pP~LI} z{SAtz8D6R$X4QilREpb?obsF*pnCd{Uox=hr1jx#r?5FT`lfw!s9La4r2;c|@Q#!O z33Jqz3}1yrBZZYs!4rhLo+ks2!cL$TZkYOj=s8|d<N{?~ebUp!n(NCzqVKBsms;-{ zB$!W#>ToM;ru}Ug_FaL<<)-mQp-=L}H%50Nqw1m7fg$yD9>p=~^|nl1c$yD_Jjkzg z?LYS&eoa&V`+F;UdG(DutHJ=x8{dI@uB%q@m4q?Q31TusqA5euQWwO6)Dqcs!STdP z@Ft`ql*=k`{|doU-UNn0`T^YZLKLeVd1nvCG*M%(gTfRG+7I8L|3xE#A~$t0V$0DM zRsNC%3v1c$T0Y+c1;`+g!8wTw-x&+H2uLvT{Ng3}9wzS^eDU=3COz_0msWHtmiaqF zXTGbCHHLDAm*CiVj*xgl9&w&GUraX89(<+G;2W?S1Oyxg?X={<n*RY7f={<uL1p(E zSVkp@z$0Yd1Pz#dc$v>We`JPgpy{!a2X(J>#0`m<s70h$H+ZvIYD4<+SbQ&VWJ@98 z^BAalSZ0m;jl-bT?Ihwy5`6Yf>N;cw5whC6I=O-?*ARJafwP<f{Q?1){T|Qo29<Su zS$CG()UAo(JmShN-HR^6^|o%PeMYc5fh=TCY$krDZ*5sX93l&4B=lnB8O_G993=%i zT!Qd#5-*;d?c)>OG$;;`(s;z%zoIQ(B=i)!uC_k|+!Pz%Z`w@G;f#F6Sh)TNW@;H5 zi#2IvxNtP&>rOXK3LaxGq9E^e=?huxmw5C_#F!Olxo2!dIu0kldo~L<p8HCF%F9Yu z<!Ad&`34_k%Yk4~Gk4TGK>3o9A5+y7kkMq@?pBXmwHEn-#UvlULF?=CegrkknF7J( zUhRZv#091?EOq-%4#}>xq^uL3N3iM^pYh>*Kf<ziGKkVmzd01OrkGWGK1;wSqj11@ zCKSPpm{fS#@~CU+0$i5z`-14=pUJ`3Qrr+3KKXVWy~q}ut-DvK^DDb^90|Lw2{Sy% zqgLsnyN?xt1lZVdW@7z_<uX<^^!AEg(9?q*N8wX`?GCW0aTxb!du~nm&4u@BsxZ-M zVoxadYI`^T&V*`6)CL0d0w!_EP&wXBE@~NdGUyBuRy<PqmmyB@x0q&2ZbDCwOiISt zT-o8^qfcMp!3ZI=$7R7y;VJ25n*C;|SXbC5GLP8OgFvn6nde@T8}&^ew$tTb6OMNP zk5V4YcT7ADB{2I>xiMa@j><&F=Mm4Q^50E~lsFm@<~M1zp{SFvbOYI^%of-|u=mE` zCN(G~1&`VNNq*oGX*zM51!Rb4op?7ZYK17X43SQv3FcU{o>3r{W71pG@x1uEV9mn1 zLJkN&%u4@mT9s6$7q<Jg4Oc8Jgi7*@cb0wrSt;Yi>pXDWJ3&wKOrf<5>x!hli1b(0 zYi^0qwnU_SQy4KyyCOewyU8jjf14@70Exo2b7ehQoNBTy%u)hGQGdBmiT3+Nr-n^} z3G=<Wy}?wUnCJ*Z9kbSrb>ap{9^;+gc=IU~!Pc+mBgoe_#qUh5^nLCQL`JXpJR3g# zk{1gtnK~%60@EK`j+(qk@!pj>%w!FmY*x5S^d8B4?(=y9aACK=dU13C@!!>vly)in z2r>byyxUznY|3~q9T4B@L9g@(X<npCIlV;2B%?OB5S&^|-1xeK+$|?x>_+BuXY9yQ z+SjF}nZ7loWJJ_a06U<eQ@SyPwc{r2S(w_R767K*6ui|t%;}OJSt5yda%73uni*E4 zXy)~yX%UZ!M3eP&pJFpCs1)Ah%*V&6C5ceYK7{#nwzXM&zijSw%MhDDt(M$aTDIk< z_*9z_>_Q;|jS2tqIhQ!LMZn=8gn@{UK4%*kT@5Sgx0712M3-o7m21d|eyF_p^l|>w z7Ywm&Fn+rI7M!GJLLX|8zTo4=0haCG-$cY^FXT8h!!L5?SPAZM8%wrROskX3(XE7@ zJTYO^Yh&cubJS6}9c}Q6^}hjJ#e&;!ns<-ka09Q<#_~n+Ib*lrEASw6H{lA_ZUs#s z9b9H>qD|%lGN;yj%!cz7jvfy4A5@dvipQsmX`pe(?a8n9c_ZN1gfs+iaOn+ttvzVE zTq=mp4A`M9gGPyd(Qzj*i%-_c&WuA<Vhf0o3+ogQ4#!*|yT2jLgnLflp>?-E38y;= za)xL_FCy!SLiTMv?AZXG^sI-NHJG5Gj1WFH0SP_?AzBD;INV;gsoV{eli1Z1ib^C5 z&I$>b3s_gdb#msyH+TSa92atK68n%wxGd)q_cktAXNXM9u)huEP8Hg#F>is+*=R7D zgXp5^^Xy=WB8YtQf6AwA#@RKCGgLl5H(!50q960zg(%z6()GXLnQD_BQFfK8dB<el zO^7Gyd;79|X|>0o`y*Lb)vHU`H-AAbO`=E7?5RB12c~WRV!*_89|+y9uST(#D+(Eb z-c!;arMiDj!^Lma6T}ZOJNT?WD<&11Ne@$C?{G}lmk1R@0HNn^njM>NvIT@xS<-WO zZ?%?RT-!h;)w6lGV*;J&-xb5|z-V?TjXh&}$psA`F?5=8*qDiTySequ1&8yt1->-A z_dPIfn<INrR;lMcQNxY+HXqowfQk-Uz7zEnK<*xS7n?oWgEjqPLbfH`xS-B)czQo! za+wqHEdGuqON!@eczgwUt5JA78$i6UAD|8(C|#4&K0K=|P3EY?wR3y^uVCEp$KwG1 z?Ar`{<R&&^Tq6GI`Bl2Mi_&8mZt;~Ml)C{p{4Z62Ez}689HA$_5C|q<kN_xXcpd&Q z^b|izuUp6mDsc;EVC%=x>k`=y({TI<Xo4q=0;0qV_G1411W~5{Uj0LS|6-a@nCO1f z*YI?;^_jogZ2DR#@2;$4due~%L@Q3!d)r+|mJ1}(dt3pKaUwYI2MT%JSB2Qif0bj3 zF9?5&dle6L2Rza)XKtZfdDS9Dz{lG`mVpo@@2Uq}($v^xhfec)jMnO`=_YM->NRNs zwd~@P=AX!d-7GBx@_WWwc*Ym{tuQ6P5So9}t8#ZgChLG6Vs1hL`In7#0ZbRGXxP4$ z3BI8D7<WVt=%B-{N%LVjV~`c!qUql2D=H1Un(HaOPS>Fm#(yPyDIVlULUqE}WBVR@ zeX6Sf7X%bv@bQh3ZlXq4TN5e$f*mquowmc{OIF~`C@q<p*rf$ashl0OV@O>m+=GbK z9z3sy)&x&%m}yVg7Q=Hmm)N#>K`rtde@O^O=vX<ov3%O}@Hv*rGt&5}k3K}XxTb8l zKE`1Asb`zEe}8Vx$iwnJ*Quc!QF|Lyy9>{Ca~}-PWY1CZOf}cTyNX7ay?)aVkMV6| zQ`7xDPnYIw13%!;Dv#7|yl%EvL8ufP3ErKM!>Ut!;<C;pAb)~7fqAo*2g{4kbytFB zt)*j{?M-2K++$2l503}DaFMd-H!ggRl+9A`cI5OMuUcyH=F3Xj4Hk#E4L~AmyaIU+ zq^g*V=W&ydP|MKSE_@5|#ez(Yna?raEP2NSJUT@GA!cLM7<(Ymk_ESz<HJ_4q5)d0 zc~|WD0fVc+#g`S$5vvP)|L@5sFG60UmB%;zK&EqE$I^H%z!~?J!Lubn>?xTWH}|I( wm0P=r_R$y3hZj-fqcJEK-=QA&h<ozaz`j-Yq&n=4sW>>`SK2SDUs%2SA7X~>761SM diff --git a/docs/logos/xsdba-logo-light.png b/docs/logos/xsdba-logo-light.png index 8b7aafb60b95735d96764286f4b7b57100306f62..0575ae2c2b5fb661fc35755df8f97e2804b7329a 100644 GIT binary patch literal 17476 zcmbq*Wm{X%7wy3vf?KiRZpDg2@B*Pw+>5)rYk=bJQmmAs#hv0%q_|6w;spxDx%vI? zb3eg-k>tslnKN@{_Uzevt(C+;)f8|rDKG&5z)@0!yaNCPV)%;!9Tk2>vh}+V`~$;9 zQO_L!aC`oHAqb;rGQcmAd&uc}XgXVYc$>Ld0^Z)<T((a3?jOutEV-QBtaH!AC;)&K zP=ZKn`Q)AE`vz$3b-hS#9!$KwiIB6zCq|~jP<#)G1b)n~RL!sKl^8j<tor${t}L+o zuL^TTgcvj}R4r~ax9DRnd|5x4vdhIpu+6Q4nc;&_^cb<|vL_})rvCjKb|*k&%I4>{ zo)qDC-{3xA%=VqUdMdD#xC(4Om!0?+usvk$O_Y`<7waz!)qO{Xi5#A@u(6Q<O`iV6 zH*KU5`oVL4p10-c?`V+I$~0d|FNnr`XS_EHy<`R`!CqEoFwThRNrSMz=;~mtJDQwE zT}o>?**M`Q$mtEv)aYtJ2}=nzpdb`v4Xs41cx3W077#NZIQhdV{qA<O)dZ~Lv_<^} z-^qdFqs^xt#6A<`PejOwQUE?+UPl{3Mhp1U)i;<q&ChamII@edv+2BS)uWBEvtdf3 zgIJKkhzJ93fzUn%#SlG$2mk<ulf5+>e$z48VY3lD_k(Qq^wRd$0v~I^`HgC7F-@2Y z7l7DErmO{nq0_SN)q+3Cs+{M(W<9!OU6PrM9m`yJyo;Y5O2|$dtB<}pTlKup($E?H zwzUzJ!<z5)u%GH5;Qjq(_E*#eKjKhWT8J(&u@wpMl{<Evdv0Ev#{Ev~r+n+F)c)4D z$se@RIj<+to!4}oG8H7+MjM(8hJIH|DsS<!>hv4VQWaHXJUbpMQX08O<`JdKsjiMG zHtEgEU?vr3=DYqHqUx@@#UAM&%9x4j{e=8Re7zmUvkn`zCJ}I?w2yXnO4clqfq49C z6de=zOuX{GLK-qSGooi^q8p%QZuVi^h7<CF(=Xg{#6WNW+C9&x_W$M3apaMchfj?7 zJ0o+01&eqzY2A|&;=!@Nzd=e;Xq?ei=bJ`SqR=b+>$bxdZMf_D<A>OnpuT&~S%<1= z4L3Qh-?^0DX>v+<R%0RZ5QSee7;%NpH6v*_g(s$mo6QMxSObaKcOM7JG$YmKvw|9J zWXI*Q8<WZ1q_tQ&T^01Ch7hv_OEJKDhPzlQ)Px(;d|{q<AoO3G51-fRKO0J?6zG3z z-s8(<pJdVFWZUK$C@FU=6Tg7%r>VwE>C4?kP(EoCchYwjTS6iR6UkrqNjDCb#tf4> zE?sJ%IhM;U#43}4)@hcsWg?{yruwGk=txyBA9OFH8IL!psd@i=;K7>-wbLmaQ{stM z++mK(X%3R$M?GO=mt(|6f89((iuMhAeQ+R&4x%pRmLR#7_rRg|Z^cE)2rukaJXB4d zaO;7jX7!SjG_Ve`5Hsd!zhE;g=*V`2+s@1qh)x&#w_r4AAf+S1WLX>=T}+CMP3DlX zv2m81R=PD%X*R=v-;PDKL0PNDpiw^8?<OzoY$4<!>}MRPq=Na)AZf-L{o~k~nYfX- zq{SadOW+|Mk`Sj}&)$a1QtqaS`Wpez;@40?r!|h%gQ6t_TZZ-z^~%9oEZ*osXVfHz zv1{i7(uc!3?UHqS%tEh)tQ{!isw^Ta4O>uG<}|(i&vx=dXz4KH*q&gF4|;RozH$)! z?#>NmKp9*Hazc)y6=H)uXQOcB5-8L{4&?UQ1?<1gl!>Mkgo7DjWf0|BqQLZbcI$qf zD~Y-dnJynxSamm$rioet>qp+xiJS--Q}Fz8I0~;7zwM|0ARqsgp`38n<f(7&fi(4A zsIhJ2RqxCsZvDUMg6Tio6(l!0KQ<bAFFM(t*if=59-JPwsXt<m_LmTRY7s^-l?W2c zih=Zmrz0RDD6Fn}spfc{9Xx%*SRRb06v`kS9zU}*<qL&jK$uH;cr+=Jly!<WgpCsz zv97-EYSL65{A<N&8Y{T(QoGGXANbh)3*Dxiy4~u|GF@S<&2M=0mSawf+<h#ov1+m^ zCl$WSS8?T3Fjes0=Dt3y)=CJrTpf4z#9f?X;o??hO-YTK`HHV@F!#-|k(*<=FHAL8 zIrd}2d)mCzZRxy^y}gl!BRvLx*2?j!@3;PP2?btQTt&Nx9gXPgqUs*ak_tGoyRQ-# z7GnrCr=cdGoH0Qy{RG;cr;W*2FeSE{2@8nQ4a8i$Poz=N|8`RrURV6}Pe;iWOoxQ& zX3GV#$o3-^8m!Hwyo+!qg;zBU(?yLPkAA?9L({9X)l}Njbzzix@AP2KZC?CkVg0oP z$jidviUJ##VDu``>;iXtXgxBtX4-Kg??V_O5OBA%Z&VX6<)^0QhS&5JOBz}C4~j9x z{kTqld<PbN=$UAiZ+n-3|EK88P{d^_(J9V{?n+^FX=Kc@prF>WvN=bS%k*492bLoY z`Hb)pE9nao2Gp^CJJ|4A*h;w9uZT&bC<D!0b11z}SkQkHx9}yU+ft<V{lKv4u51m3 zREk#q_!~JW@?URp|Aw7N!7cP@5-_|D%N5e}kNkfgWe8p!Vc3%1^{4nc1$Ze)Gb|Zd zpS{YG7ULW0O+r2V;gtPPZcr7yxFE@ECQKDgWzCCG2czX%g!0(+n~;rzW^Og<-l6x6 z6*O++-3O4!uAh--pb0II@XDKU8mHz$%ADMA@vpj=E*t2W0MCc?+#7LbHo!$?0|N__ zVLXo1VP#i=LlED1mVjcx=uw=hecI6^FY>wF&1s(B$!|+Z!z|=VMH@gQj-A{(L79RN zlWTiuNa~-BK63w^)58t}@`?4d^?JgMc!%<x%dr_3YtWab^Z3;J-uo9{8D&J!#;LIR zH_vZJduZb;YQn!G+=lH%in(~G&V;KKN>5H=Jn&8o!}b!4jE3K}e;&{xW5bv<hMU&4 zQ|;>?+W#G>xOfT1G926%!=h^BPM!+{zl}(4UA|YdJ{Y<d(G(D;({%soeJ?DQZk2CB z#X)I6#}+F~#EJb*PdcQ12VdhACR79Z$w!J_H4#(1NF%g7nVOi0jfhCBT%0Cu=vQFB zG;^Ff_pp0aU3LW{E#lAV4o@SYTk!_>cQ_yaEi8MUEWu>aaGz=J4;;v+e*?sbHqQ1> z$6>0sCsl{tbqunt^}IYKrhk9D4Ui6!YoBvc?Dn%%ows-LNA%Iv^0_|RKvufP`GKBr zy7twR2)PnmI#WC;s6jDTDO{w%KnnvKfvaq_DluX`u`q4J#=c#aDE(r}&xm!DJz5Vf zncV)ouX*Ux(sZ3R^GTuHjRS!Am-O|{^sb>yIqDxPa4et;38J=#S8&o=k+xuXN+{FG zh?3D5i?kdSCQ#BKtKWRin~>!P4cq=ITMZJ%B1Rd*+`kXxh|xo`5f9aPkt@oEFCoVo z-LIkfYj-xI+*Cf09vvG1)rrpvvQsz4h)Xl9PA8hYinMfD0Q9f!IbQ~m@f<A940Gei z706fSahhhIx3e_jEaEGH-lv1NvBms3I{h*Xai1A(gG_WcRLDR-D4PS3Y6N`^w^?Kj zXQBLq?qP@)*_Axu&Y!7h<`d;E-|9l@wJEBvBlm>Oq&#Y!?@+Vs*KP*Q-o)%S850xH zjzdtO?z+_7e)6TQb!&=-Z=y}Pic_{8oLA}=HT^qVrO7}>_6FT*Z>b5>K6=l25!fy+ zOcmV!drPStT}?<Vg)z>_KLk;Z9lKP~4QT**8|O^*6X421798&=FlsTBt<3hFSob`y z8=3v}p&=Z^|F!rrtKdnxS6oN5vt)V4!m-T**}ZfW0$c>@ueL0zKQ-r~U+GNducWae zd8IU!nD=|mS9lSl#$77wlCiMAhIiC&1}ngGcwoyCXJa9!NBncmZdbL~b_#pnV59|v z9CH=Skz>lit1}dfkxBab7NBFvNlaf7_a29tI~QUi;A1>n2x4F+QI;SAhJQOYJ>}c| z;k98<>NKNFf5&hqQ949Uqn1-Fz}FD!5G5irEz#6a?)P=IhC!tUhIw>!v|HCB;r^No zwx3=XVkrkx2;d>5Cjn3Qdm6mN)4dEjnpB&q7h;C{)Bffkw`a1>F9Jju*g^<0`bj5G ze;+37W!5R`;ln$NrliDL_ZsAaNyRNV-M!*9Icnyf>=%cGPSs=?U6-sDlq##mU;=aV z(%J!)?fI}vyL`6Z@1Od3X*ykp6A)X(l}N$U@Q|i3w1^`HdJ;;`i~1Zmc;eom4F&LO z->F5vkqUb1-7speX=%*X3P%T0kCcv6-y!l7=4a(a-q37pu2Y=M$vUDC49xX71dDn! zF!2+@ril*|&iw7CazpM7(gifR^Rhbkd^S*Co$rgT%oKNZ*&kb=zekcn9u1Rbc#VLd zGy$22G6fTWLO`_Ud|toPX#$QCdwiU>g$$>@Bx6>MHlEH(3Cgp4_MYPt#x3C%n$vn3 zm5(;0W0pe!sBi5~_ZGkEeae5&Ygx*|ijIt;!9YzYt(v3;k(MR`6;)D`Qef~QYtX6@ z&Hmci+HRhe&wsPeJ!r|uD(6;j<1uXeK|x({{$EyiPsOFVuUyrzb8uPb<ujFN_stKb z)RNB&+o+Htx#Q*_%z;clCjKrY9$~K1Tji(Dv1(Ex+GzL~w5JN44O^^!B-iWDv-a&k z-yKk(BZJUUH5=F?wzLva0O_!BI?n4~az#Fyp||ga%!g^t#tF>eMxy(0&y0{9iLcB( zY8~{!<yBGbek^>gmnz)&z8p*m-88BB3z5uUeYwiuY1nmnta3Q~px5AZJPd2lgT4#F zXP(Aso8CQCpNzu<stfQw>~9}^Pk9Z`ck&{#)mTM{y6%UpyEr*i;G2nzP-3^4<}g(& zt%Pt}^2l08B9qm54a^Ne0rsb&c_)N@vXX=Q-$6-w*gDG@cbmD9>TOOl68SW6(Utk? z)WW(m;=&MjlPdu!Bge1CuQr2OHo+v)Vpaato%h>Tr5iJ;2pNKo59kms2ul}3!Jrgv zc<6a`*897cS1u#Om&#fIBM0%!DB6em$D<E)Kjlx)mi^*&A}lZ3zb-14O7y44gZfOT zy(#Rff`2u0XEU6`2X<svOv4^S4I7T{Bp_j;?&9yhrfA8P!CG|e%IWiEWT7P+_-leA zpy>wp3}VE@fRD}4M;`+-i=K%_2@-SaS$=&(cUkvFcKq?5<)=EfA~UR_ASCZOf)QXh zY|odLMT$BOvnZmhvB;lBaW}n=XLreLU2gFWCr4avvq`qIDs>1plYXnYSJRgVN>L@_ z|5bKLTpRXf;-LLVMb7E@RyU)1)eFV725T&astICIw>!vgr9Mh2jS!%L0L=ZUO-S#y z>`Zn3{^Q-)EIU|^=Et`>4!e~b?mTCF%w&c>6^ear@zZ8@wO?_uO6!kDy4$eZjn3l_ zbZ-JJ)JFy2NBKvNW!=l43;F~Bs!T^W)K-O<{Nb+SmwI>1EFs)%%upR8s#*GC@vTP+ zC#yetM#VFWE1VoyLJonFD!Va7Ea;|6=(UyE4J(c&YyG6@sjcT@N;5*<o%M^3l6g_3 zuQsXPoPP4c7~i=z*vHQeOA#{Y;ce`7WVf#h+G}QZl9}+$7#~3-?7q!6BVCvXEUl}n z3{gzVR*>7XMCctrM!&+lmiQ9Ej*OVl?XSqrRZ(9h*ng470l4>^a1L)WT50=gpu;>o z2jvrp=|B@Neu?j2NCJcZ?OWpyt0LHl({6CEQFuyq4G+)~(9SyZ2V%oBW$YvnA~uLO z)$F&z&FPZ=s)_T<l=x@ko=8<rca#Bz2?su8)KEPT%x^PwA`E@NE|d>H`y3%+;}stu zUG;Cy6|(P166i^YuN&Kac@+D1uaK_M@Z5F(kcNAl!!+agORlOx;B%vJA2VY8p?!}V zPieJ@i1iV-W|vc&j9P_+V!F`FL4g-=^&K7)b_~{Iq=4pNikRSdsW6zwcTgCN0pAvN zgci()O&7yLA^s=y%1*^eY5qB5|I9IUiqcCB?m&*Pw>~ybb#u)By3X2YM%8^oqu5T~ z+WOfNmu@OY4BJZPX-q`3&}EgBdrK%ds;I^*K)s$LP?PXZ;7X7T`{VOLR7PSgLW=TH zgUji$0L0_kUt;92;v;#Oc6FA~9#*W9+NP6e<rk_=Lc;Y9Z1J85l(*JGLQMhvRdpQt zt8U38(-LA^(QT_0{h*TKAZ^PHA>VtriJ_bo2(X(IeOzK?>4}I8jd?MAxmWm(QIN_Q z92i($9%HXJ);WrxWLLh*W&+)a<7Oji^IvFHTuok5Gs?VU<an#;x8VG=WZK_QX?qok z9&4X{r2qv&$p6(=ehyl5l<b6Yvnl<Vp674JPZkv@-b=4jblH>YZ#XIABn8bjF`x7O zp>{iArJsJnaj$wAhBr`7SU;O+JPM!f07nvwMu2=7Ik0PDYaH)<YU?-*JN6I-Z}n04 z^dkE4=B8>MKd%P)keg_|GoAmdVHBy+iNNaKg5?G<K-bs5U4Mdmx%^`M;DLss-I4d^ zBQ*E;%H{zYO3CdjM;{{Fn>peBs!ohFX)*5`r~ahuM;f8Iw@=xtK^92em8H@~j@P`O zXT7BF=7&?9>(cNRr#?T&zzeb9g-WtN(k6xLevoF+jqFr>jPNNn+xVuienX!-va@<h zMPXO&p}haqcaf+;`R3-cn7*WaEKM;(3^$wL43xi&zht=CwZL;@pAB1V0jjyDz{0u} z7aPB(>2KUIIYiP+n&A-D+vAX>c}?H)G@>1#QJ?K^H)Vf*D3RfPryIqPTfn!^tUZx^ zAF}FX!5?%Kj_p$2X#d@wa>EflGFHtJJd?{F$(RZP2=V#hThnCl5sg2Uw&)67ZS|Y> zyd2L}IRH$Eadj0!ot;Skb}3BE&CHaYue5vWy!@NrE_&8fQQXtfpy5sBIsW)>pyC96 zZj(=>AebpyDKV7sC>|xf1);(ic^UZ0ki(Y&fPR4xt3bqZr@*v`_Mt=|X1=?qG_kOh zHGJ(G90Ordo7E-Ep-o}{E2c-6aUUjWohyL}pl$kI=WDz#6EW7og6}&-O*Y%@cjm?# zHN~Iv*PTx#10VJF06!@rgw|+jaR!kwh&VF2B@_=qgGVk#7_)>$cL?`H9I7u-Qu3*? zm7zdYDW})RZ7>gRqz<&Xh_ltd&h+NL%1Libgf*V)h!*}q8H7*cD351jl>yTF(#HT2 z5^hP$w>>u~gT|c!9qv(kneVBKeYQLgTLi>Wc!SOpFP9Rz*>LLv&Pu;ac{Ez=7S{Rj z$kT7(!NbC{z0?-sze<!QTCXhTPY$DLWpW>3gGT5+3#4fi+i|hqt8>IJptPnAW8<(v zB+#E>KNBclEH@jM%kbbVE|^J(_maW<VnkCO@>1Jfeq?+bmZBl%)^U}X-ZYP9QS|41 z59=;A^5ZBek@X+BK{@ToSHZL+m-Bhfm~ERH51rgBlkiT)*LYj(ByD$yw-q?DrFRDV zbE;^1Nr{HxEs$Q%y<H}?{*XHD_P5Xbkd=OD#RyGs^Zh}jE^8vZoPJHfd4(Duubb_) zq<K9`xn~EiL%03)<6Y1WNA!i<pzNB2^A7cTQZ2z=R-N!GW>5^133Tl{DRE+bN%{S$ zB7<MAqhtdyxIXA$L)H5sY==5Xf*9{-^UH|3@wr`4MQgQ(7$Gc1QL!?B9nnr&5`6*$ zLYzqHeanCh(<AeHT<hxCIPrG=k;l3(i9UQ)S@h53$&38N<{Z|TcCI{%O8HJ%F&qKG zh(s}L=pA=T3Qop5zEoVYC_1xVo{x&^uZ2(3u1s7{%&)^kaJq|H6ARS`zjOH79{VUx zB+-HeBaoA!qY5xa^mmwo#8FCtsH}sc{x?BpC)w5$s`E9ccUtJk^o{WMZx>-XRUHRN z@OymRe7xYf&eS@?MgCm~2YNgM;IKh=rBB`}SI#BV@#XuLC&f5yuQ|S7dkg(%{(;gL zxZRZ&2<!*%yXbUVf2wa=l07Q>n=R(!{m8=iUL`I3bz73c$Wf@-mJgazGaDVz9I9<5 zm51Mz7TyjYM_{&vH!gGi=DTB-Zz?y-#vo}r$ERYeF+rIOjJU2qw%R6A_`F)eO;*N& zrH&@4eKn{RLFLZd1lk$T&89a5kIyZM;*2q2C)uqw2bxR+q@+EqmId(w_e&q)<^MsF zmXKDWBAJ#zS1d&IFlXJRxs=OYiNcAUIOUAGN?QZ+kYEIh<kfD5_|q#bMbPYG#(n>e z61+pi{&>!^0mJcS7MAQVT87!+d;GY6aI5(hL1~~&Pv<Ae5{JU5sZK5p`hDD8=YwUU zB{s1LFZ$HiD;70kEIrBtVL<+s3y+tkTvthH<ZeFF?viis@9(5Y&AejLo69Wk1z-3W zdU#T+_}=+)P<*PH{6Nb?{+2=-H48t&f;C1jHN*lewb-j4LKhA~?@zio`#?3gN6+>~ zt&(R}DF+>~I@sP-6H9wet9HCjpb+`CWJkLDHhhyaORW2nQd;r!wxjPKiG}Lt_|GB} zv{JI8ykFh5d<W^yekA|Q<lpN$8h9f5@{dNmK4FPfoRR8hQu|~SSN5-W6t1!q)s52a zX2@BdimZ_c^rm&xvE=f}7P99jzd2s{Gu<q^(WQhc@?5oK)Y!*x7ixCRxIRb(!u#iS zTB&QPbQpk*{RakQ+fh*&IVQ7Ozokw;x=6OM2;R$1-+SkVN2q|UXp0%=lyovvhA%+t zkDa0ser=O?T{$WLI>E<bYSlTtJ>4<~_8P;u?r&Mf`*H4z$U)9W_~vq*jp~v^k+;Ud zmx1GG>}nF0keoF0z7m{OZnx<wb;$sY3v?mJB`DEc;v^HnpwmOjlS>G8;6<1xCuzs2 zlEhA2ELyAWk0>ywF)zC{%3%HtR0@cDf(`lxXt-v({5tF3vfax}8qtt;CB{se%jD8u z-NA|rhd&xvNTTBtEf`F?*ICqhpQa&&&T$1t$KcIkTvSvl10wP;RM}luGuNUKWnh*n z3(kdy&CGZ3K$HvQWQ!q}XvdE;S_a1~(5aV3v-+en?*C<UF1dBDcJID{19ER$%NU8y zL8Qu)gzybVM}p36u<2H?ny||UFI4nVRbg4-vLeHVyPvR1Ddl#@Vr~v{xFd@8X(jLb zP2P7EAMg<>c9X_iEXA{ahNWWlXX$iO)yYQw&*{?5BN5U0yCUB8ZLGK__--`&A2fCB zH0msUA*FCCRS82GC#_w5mS_naWrW*3Ej+aDg(;4Dpa(B4eJA2OWGAWhUneEWrQJ`P zb-Kky#Gkp_Y_)tlKXFwh8(CJC0z<~<4OO%*epY2bXJEwV#j**Z1>tL01RuQD98#-6 z=@R1X8x8)WbchYh_Bvgi;k`+7C1xfn??zJd3IF_Zaa0(+iszj`>FJl$$16+GPG^}% z_aQ2+eX@OW!d2<jBF=ge&rbVm52PwXe}99E+cBjM%vhD3x3q}p$YFh9rp8Di42`si zyi!Nse*E(rhiBsdH`c`lWer}m$MnAYo33*po5ZnHof*>oOUkNkqhUg3o!4U+$Jpgy z?I^?JtShnbo|b+t=piGP-^#e*Yrs-n8eel0@i!_F=(Hf8>u6}IP-JXu$58$oCkR_J z!dCv-Q_r!)dnXMOH*k5#Jt8H?Yc^W5piwO8z@6!bK`K@2Bny)8HwQ+_h=|@?MyqaD zZYH`v`$>s&;rP{op;(JPJJ+-_`&iR}LT6^ejkemgE&yvja)S(xq$OIL`=j)I3S>JE zt%Rg>KI}Jf3f<wW9Nh-82{xck8{dx~&&mv<1korr%V-hMu66w${PEtYBjxLDi8-M? z@YVPGf*t3Uy2H2^84IIohxcLBX*zr##KVh`;FQEo%e6rjXmK14RHa({(i~zD!2Ts6 zX|7b@(79d!#)c_<GAKt6K6=`+P$?W61t}}d25l*DjBdv%Q$!%lJpJ5frM<;hK6}T6 z^R&Sj&zZXB#bEG9j!~{Z<adzk6;a&?yEI)<s$%D1GYu|(UijbM{_9-k_ESZ{tvF>& z_#M{29lpXZ>a@EAeNy4ZeC(tR+TulRHjv<9F5si)()D-QzK2t347AKnEvXUTLH9$P zgrQ<_P%<OPOyQ=;hszGnrY66K<K%hTjlE_QTz*5BM`=lOatafz6xvr&zwb=Pms75) z@gk??_-^C&+@~bh9u{Ox^6{NHVPZp4=4PV{2`i!G#q~G87>|ubR~;2P;SmW5M)dcR z<I5j}A!39?(ndKOS4)>|sknuYGqU_v1ER6um+>TD;(8vl2%?qmDhplPSmOYEK5>55 zKJMz>E$o_=I~AkRoYNHl2U=PUtYUqVM7ykJ9UvP8Kf`G1J4sEn2&4c`_}Q#?k!5@a zhrauZ&HywT8WtIm?Eg5`7LuDsYz9=448y=NGJ3kOL=GR<Rpb_<3xYPk4#!YHzd2|; z+fQr?Ig+)?7Uj!VbY<@UPFQX~g=cKYIdR6?k){a#zUFIHiN|$Pp~CHEcH_RO3O-=A z1}oZ12lvINvd*JayOLN5Nk$5g35kKl#F(KYAXtGB5SW<2N^c<wo-sB`+tyf^Kg9d* zE#=J2j~*I@NHO~++)GkIUrGEdC(a<E92S44r>=EIgy`Dye&8vXL~))x7G-sk+`aie zLaXcO!!=1`w%lNK1$RZPvJ2Q``Ff?q+Ua@sT(iw<J0k<?P1y|r5k9yT)QuVJTm-NU zA6w087rt<){fUusxL?spaE0=J<X)F>UMYaHZd}`OV?f^Bp4^9E@8vyzdD6^MqEYb< z?{i9>1WIqUsvGCc9&dw-zqXq1#Dk_Lg@Qfz2Qa1@?;<~3e=XkNX8yauU3M=6+u#<V zXTqu0(=!O9eZLBT;Joz-E7{X|3a^AS1cg@c7Miz5dN$^6c9AQ|EDhv)_n~}($0M#} z8luSm!7TRvn4cnFaHdy*%L7(=3aU9oNu#+|+XGXO;s4VD<gM1UDs`_pseq(5m+Jx@ zct8_hvKwe2%e|>y@P+bh`sE+{0R=Dot=TAP)-WyE{awirl`lI-cV!kx3M;oc9)HHh z7>AOO&TinARTQNxvwh`4Ty7>TT6aILuCfLhaR>^1x$_oskX*NnHtZuMPDKfJCNJAt z7NmfH*}@-#vq5RbM|Q*i2INL%167M3&8q44xGyzy;YdrJ!>`;=w5+vYA|7-35g)(3 zi3tp4Ztp1y(iqz^Jj4-KGZEe<ZvMg=%Au(Y#{l;<72GzNjkvKElO-|bF-2nxOoR&` zv1bEj<g&~T>-acG(@z>+;U0N;bZhd9f?+rbE#e%(SSx3FI4-J&L%gRmB#1cJB=y+h zZF1l3o!1=rui7<vr}+#mi$x*QGU<>!;zB+-L#RKcrG&s~BPf<c=u#OfRca6F=?ToZ z3j3+D4o{Ke%!d+z6Zdg69n&1zIK)J5-JZkOEk>iSeOcLrgq$SHn7OW0pwsLusYZnV zJ^7bJ;^Rjommmx*ekOEWv3k>|$vl#bPQvuE;MF$-bo8}1duB=0v=?aH|67jv;j95X z-Jd~lIuwuHziwukLZMK%-D~(Wx%V(59FBvN?~bh>$2$p$jBKX-l%RgLmDxX)!p@|- z1tO&g%V4#W@6ARjH8B2Ta#QcpH8Z6Bpf<sstKsnB|CbM+No^SeBA|L*6NTYk2<zWr zxC|rZvS87eksD&^dQ}taBh3L{5U?3?c<4bF8Qf_ElB&O1DMLAvS3_4J09DCw6pRR% zjrwZnJqEa={2RDZhSD;|nQq;!TB}Xu6t6yT6?mk9*S$j<^mJ1;7Yjm;ibCh%Zb?uK z3BG!h<r1woeWIjk+G%N6bYT<K+P#h0?;z+Pe%`EJh(k9wZLjH(Ln5-goO(7XCNg#< zgz1T|1T?XC1>6q2<OVmj&=6+oq+RDinG+7U$bXN1`h`Y_Q0qk{8elqS>yJ=OvhZb> zc`h?95_v8*fc5_J%ir-tw{O3Gs~6neU#l;9uu@r$wl7BU+hR$Z6E$#NheovXb_w1m zhz4<d7b|=|WXVFwGC(i8IzGr--d|{HiOVBScYeN`$*)jnQD+VQy+K9gjP(@wD|TE( zGj<oZv;HbR{kwd5p8DRXY;;ghh2P~Tc+e5b0E6Ms6+bh9%`w8#!X7S5LHPXPt*&ya zp4#fsCJkpz+n{1OZ0dBQl9D53RV^vn6+^9e!aZl57pG@NaCOY+zItnYS(;yC)gIOa z9~5-2(u@V?1Exe;IF*N#nVRz^`GmII>DQB)8@pK3+)Em^+Ef`eIJMwdaY8>wI7;!5 z!;!4gz&bpYZgR3S-OaA!$sY&T?Tg0OV!N-VYmKtPP2`+=A8Hnafmx4DMDi$*3ExHk zW!N(%B@%d%mVVMje`4TDk_NY8`$^asPLDlT0tFQuy`3;Ejwv@JN;A$d(e{NbB3*M_ z)WB1ep&=5Xi^zdaCdx=gX2@PS4rQ#eJPC38X>=+mJd#NDzr@XJHS?{z_35rRj%-J` z^c`_MXo_JU4wq(B=X}e)hHttxBVE(9{q!Pqs|85k{r$=sX`1m_b^c=w39J@a`Yu~T zPNu}z%|g(dy3D`<7k2zRU(x`vrlP>JL52ZS*575T*6Kdva2$O<A+CZd&9yr}L>r!6 z5tYQzOW$9^iQYzY0_%m?vG}Po78~)fP68qXE1Pe;G&y47^$pGUAsW3c2!BimQfBn9 zGi~y}s#}KFS(H^q80gE$?a7b8vDXN)YRw=lWo~wBZ5njNHOwTmNXAbSW2k1MZ!~=2 z@vdxil1>=77u)FZX>$3!@8T}`N6~%lQ|sxkC!b-1$;*e0O_K{1Bw{V2jr}R_;ZF=P zmApZN`*bB(AH^-r-5jfZI$R#~&`Y%c7^iE8Sk}i3Ph0v@HCY<uwff`ZLleTf;A;T% zz6##+l9VA&`>%4COb5z@UY9Ww3K!00-8`JCFQB}ez|?4S!g*~P0LKCH<WUdz?nMsH z+*a{w-5;t)&+BRyLq{ylT)o=Jc_ly?@&$i$>U@m<rzfE_YNtO&E~6(=xg*Yehb*&` z{+?9TclPvZgoMJb;v6UB`+zW<u1eUEHoJi9G`^hsau`Zfn~Nc1Nrg=3>L3IB$v`iJ zZ5;!BVD3wDy<*}5@uBc1b6sCh*O&B2y~$E_RSc-FcEV!dx6>?%=rEK>eW{z4WrIf_ z&LbL!ay<le>~e4LdbIxdcrY6dIygN8$U)^74+SA3z6L3ofBs2cr;o0F#P4^w&24z` z58H4d&w5nFV7PI2m9`E1@Q&thBLYcaP}L$vFkxucjQ1;i@x^)k+r@{PJR;9u?f-@w z@q7Ph&|BpPE!>W4iZnNV68HP|^>^>#ui?V<u?w`D?yH;ks6+8wTuQ7d{@Yu935(@w z8)Yi8HbkY}oh%S!TXbm;F-h3}ATmG$sJ;6>^jR}lY40rZSZEVW>x2S5YnD{&o1kH< znGRO&tynHLtL*#ZbQRrstX~cXxu~@#3z}0s<`9JUt1UA%Z+Tvh;RIqv`*DPV9OH>b z4_^#Puayb(<WqOEU$m4dIa&UHiU7#%GaN9`T>DFR-rZ?Du;mlS&2pnDd5~v>sD)O- z1-J5~kPyS2a-;%6VmI+94-)g0X1fiK;5260{~!)3hRm>$?eZjlo<H?)^@36E?4F3m zsQBML$&#?I*Y1-S2gMdy_j>c9x{Jra(PTBF^T$#?sGyiO-|T<djaFpx70T<(kDI5> zG<P!JJ8cbwO*xQ+ci_>YRLYdgc=La`<n$qqq>O7pluEfH@6Nq9M%q<>Kcohy;-O@R zC+s@E<;RuvSo>hr%3&_K8>>cnu8h<78b`nLIOQP`i5}>XZ)Q)%a3CBq=&7;)D-MX? zES%)?qGEjbV$d9@;fiiFocrYweUQJp-Divm#5p=sK5fr#t-gAg;W`x)yQ=w-KlF9o zDk;%<y}9<Debm4|sgrv@as#uVIn^upoB);MbY{E}-NW!24R9TXq*AOU;3lg}wz?7r z#%n(egR_z%U^WV~#9Xt=M1i9NEkPBM@m^TlsY;GV%I=id>ksm4s?1^?%GsVwMndo2 zEbuUt(rHQ*;KXDh{3T;uu`X{dKEJjev%-T@ThH}2-)}4#uKj4|jVQ>tycTYxepVd8 zk*Jdlq%I%9!m)?$rT~32X%}G>EJS@pD1g92URqC!LGm^QF%-}xP?D;n{i#KbWdkUW zsW`Jz3d%5|G3909MJ66tnbrBuT@;<#7_8PO^Zs(eAjv^hwCZ~s=&OM|=N|^s1z})> zl_NyaWl6aXC71+U-5=z2=u3Fj|EHnjsSA@r(MwY=%OzW!pZe^#k^jXD43~R6uT6j4 zTAEzfSC9^2lcAtGav&^|j*ms6kV6b(`N>$4BOjSlq}x)I#PoYBv_-Jsjn_$p)(O>0 zhx6j^`VTe9h^6=%6Fd>}kar+kWCBPjB^!4v1Na9(4uM3`VUIioMWn2A7%jThBY!oO zk#;LF54y-FPWNI8s4gx)V$|VU0DPL%_mHV`LWOa?Rp3Bg1UE}t-=)YrWp*91sm=ov zL0_-5;(bvjGRg>n20}>t-F$s)?5EG3Zo(n3Sp*ZPTXa-TRVG8sU|w3CFxfSs7e9IC z*DRg89C!Jz$pUb~|3BR+Q9QZ%a;>P%JJH?q@l^ln9HX{S>^8F9HjU!1?_$Th-ZW&r z|6f&@ZE}kkVa8Z%(2~h`YDaaJkfV5b&lIitV-~(fBl^#1IC;?8+{}!x_n+)%GhIhM zE}HU8U7KLVtY<X!0gmlH#qr#BknxG&CS7b>^v6Yh-<==lt`bYplRZpMFG0*wEpEvA zfz@A4|N6;D62;;fDp`9!#c|g`OI>2Z9UjQ`QIcp7_u1aav+00;$?|I@psc&%()>$h zNohy%iSgjnYo#W!<MqVXpil-*q$mQC2fCekx%<AU`T2$R8~Pk<_~95r;pD^_OU2G2 z@aoX-0F-d+PkF$7?Os)2U2X}Wf-<mQ2a_cdJ%7Hpho`Ltzh~=Z7T|pJe|FyaXQVA3 zC2FFw4qg5@mVDmX`e#()KikUB_k^j2V`52lOBhe4gLzeQo}PamUwwVvjrfmW=JbHz zQKh2{lD8qWgHCbW%g;t3>k`YuW6QGzA56)^AH<!TpUQa|x?4)hFSR?^JW}8SQlRq7 z*ZF^EREwcmPG9P5WWH?*bR0QOMhW0ZB-Fd9UDHUnqR_4u2q9vR-rmHvy{{?fR*cRg zAO>{BX@(LO7FSNI62poUqH>PJ+p@&Qm;<#ZYJ#F-oDs^nIVNDd7dqOLpC8Mpy4&O? z;ev|l0?AEN=*sDOD_!CSultU%2{a(8#7ujB7TD}(_z5C8vMQhY3YTE`KZv=bP3>zc zWj235zX5H7TD>d0=lRvG(8R;hPOHvs?Bn9eMVn90d}ndt)W9pqUrV3@TVt1p|78GG zlm>}MM7sX{#EBxa^;31#i@{&>I0QN;xs*FyvVbI%VAs8qBOSiof=?E5N8uiAuD=p4 z-B`!L7g^|bVIE*i%#sk=*dy2CWLjAe$_`}4hNu|PwKZt6&C%&0KOQt=1!zXIG{j_Y zT8HPGAl>?enbTQW>rim}*6#(dLd5Zh43q+ap*TOofaA%P(epQl)=cn#a%yzV`=azy z-|z15SNKM+Xj%z%KEw`t%(Pc{KB&Rx;aypf@%8wi-`+g32HNzOaF3lE&~NUaJQ8j2 z<>GH+V38_-urU+DHEl;^IyLc}7_mYd8{=f*t*gG`?vVkBT59|IL#GwUtP-IzD=e~Z zT0Bi&o~VMG-g^xH7HceFokYZi|1mG>#;=0|0s`{j5Frf>jRBm?7#<#m6F(Oh7xly@ zTJR!=!T+D4(PfX6>=4*%U=N5wV&OMI0ag$O01pHhAUtq#!sYc@211XJhg*a!#XHyL zfhasOLFIJ6j|$PkHsuJxtbF)_B#gQR@YA@=ws_E%JWn~0hrFx2ibb+PsY}du9KG0y z8>0njfO=m6SAZe5DP~9`U_*kNNH`-3Z19<I0)mLQX#5@Rq+Iy<NL%!P1o{>tcCvZ~ z>;~|m>MaBwqq4n)cS^%SGlzf#_7)~Ei}1FW7GDhC6Y#<5bq9i`CSE+o)W2lyXdszV zgs=hg&?%?v$PakH684rQa14k|O^iCTJ22U@q12(Ujk=dC4ri0AbpjlXzh@hP2vtFD z<UcHFeg^gV6DnwR7`<K4Fw3|plBr`hU<xV8_I49_Yo+*6kY=p-$Y;L%>aGbTI9&FX zBwp|N&ra$W;E%J~#xTO<C+uE@AJ#{fm8ZI=e#Z2`GoG>wXW@t7gGrQW$37@!2nMcU zwJ)?-4;;LK;8KNiGl}%)#i5f<+xQ%)ociOLhsns~b>D^G`&atJS6>Ur!`S*KXp*P{ zOt?c8V}VEZ5N5MeQTyRzPhgROk*&PZL}{lO)ACPAKB8$Yilhh7WV`YcnCr_4vD|4A z3SYd4!j|yh1+W^Fw15dTm)Ek3-vJl)5UD7Xy`G}`&NUxx@?PhpErkHu3Yr$(J0tRT z8{{oKlEB-boMvU<abb{hU?ikc>Ka3AE9pfNwa6E)7+XX3&qWRI3c@O42`{<q;gYPy zHl+!{O2JR(16Db-ILvroDPNXwe)BQsrj2jr2mxtD=dKEkXlsNLqz%84h^Fz?(*hnV zzAt{lmvY68!<3CDSkNUPp1rs#dSgrQJ^;BlThO>}8EWPU?mz=Rs?9ERQMdA9KgjKI zWlsLG;*Q1CLTftfzxKf-|J@tu4T(hP#4_C(mB1A)otUTv&8PxFucr^5$Pl(NA%BCc z76{X*2*4EZZ&18`s3K7K>-9c1Xyz3l#N?`o+^Y`+hsN%BNnPJTmS4Him$+4maO?r{ z(m02z;S}X!q*b5OH6}O}oRu%@G7-dZJcA6(ChO@+Kyv}{p8>AOBQh~}nBP&%@2OG$ zd<`{}KbqL$I9ohvQsQ_5d@Y&T^netk0znw<X!wjCO7Eq8M;0Oqa44-D|BaD~d0^kS z#|y!&{9S@nrEZmVM}Z)4B1UL;G$5k1M2@k=3eFjwsPFbBtlY8F)vPAAt>Q-T87ld@ z>Ii)x<y=|8*`ieBPm9c<^+rik><LW4F#r=+wxJJm6p+gPkR{^@pehZ*>GcG>a5WCT z0L{#G#}=iRyP!g<h@%m%xBdGbm1Z_y7MB2*&r}DiQ_+3kbe&?<SCg_m5;a6eJ?M7I zaykSDdfqZr7}#1;PizKlK04*D;LZBqk8z5P-s=H8)l2t`Aq1i{upo&E0U94FK^SHl zi!(eU;srLt+L8@1n=ui@QU;I?$}6#N?m0uYZI_<0tFdlZy(AQbHMDM|<Ydlm!<I}B z94bfF#zf?SkB6cQGJE{MU){=EP{^#N%QG0zz`CYE<(Z6%^NdC@_;T8<6n@Kx(EE<^ z=+2Np=!Gpez$B%t<PzlY`xtP+&~opO{bAr3VD(H|m3_}>;i4aH8wUhz?ucy6dgl#} z_1M<$^nhcgv8q&C#$~#G4sn0KM{d?fz#iZI(Qr3JD)nTp*A`V+x9laG5i@32N>+@s zBg<Kh!{LEMW}o_l)x`&uJH&t^@0Ui_I<hu<8H3Y~qmr<wR&L9SeR@18%gk;CT7IXQ zVBS<_UU$@!gFRICVVRcAAUSlOW6t6=`wjma_m$9tiLu9~DLw-t;>LGhG$IkUkVuXm zq6Ty85oD{k6)*eq%=<Pf*1AKL3N%aT);74)_HaiTPSvH{s0N&1vB*5kvIpEr!uOVy z=)&}Y9=PJx6?&~x>imt@0c;a%xLc{v?F}e8&_i1?6HZK9f(5ME_Bl|7sPnn6RTW~e zv_SW%avdyRf!jfLBSQEpS#8XO5<FMAKu}UlyW_5sm2qZFY_^_^9D58IZqpxbcC&q1 z=#z--MG*LBit^8aiD0C<C7BrwfSSJK-<<R0!7Z_tNpI3V5CA`0m4}9rb(IW24Kv2& zccqbhwbDOiM;W|jaHRdx4fyp$_?<)aKjy&Ht$*U7`7rezd<XI}mG@ixi%EzXcisV; zR9jEc2yYu)9-k&0{$*~%BKh76u1+v4>a$#Z5d5|Hwr|1_D*MOSf|K9bt9LS-WXw<v zQbzud!Tq(2=Nr7ihZGXxD}*QT+^s*jTOHEW6%3le0cu)Y4Eg6MXgh49kFLmLrwH&Z zdz-(4X2=yeCf{gj{YH+F`OxAsK_}W1eI!I4yD?y*7qc9p_P47r<6VNjl~W{U7vZ(1 z4fIFREX?MOR$3|y7g%gm{d{`=p*fh)lDh-Fck!e-AK`gWCi{BAf$>daI8$X4t#Mef zRj<`Xl79Im8kU?r|A}(BNY>U>3@dZD;A-+X2N4z47Ae#n8Iv>Zg^mCG?L0S@u3n*= zBz~ZOkpvx{Yj-5yG5=X4#+STK%KQfF<d&@E(S(0YSe9HPt)$s|E@4x{rMaJO)L8bq z*reOWIT!wYurkiiP>AuRj-kg#*rEms=}Y{8sU=}VOHyt5K;s{+q~}fl%%UA}BPkCG zVYcM|N@yTN01tK5XG62@v0{?ejQ$mvO)$YzR=k>uR#tY*?<**~(Quh2=^W0TT8^jg zwh;8nak3eDg9z9IuV_mIpk15Xeh|}Y4;JUKR#N7jznQ}LY7bWwb9q_C;5A;z>xsM) zGtqs!7j_phvj;5(<2z^OGTZ2X6OUYTP`x*w@e-u3KUr9C$pud|pI<WIQQ|adZTkYz zF~3_N9{l)54p!^lMDAabqz@3X|4Mx&^CGB?iTzYEW><mCuKI8G^qUHV4%}V<dq!?T zJ?E_?UOMR0lST-UF}TOh^5vXsIM%wO;CF8PP8#=!SM6Da13?M-f>4e4hadzO?3WCq zfc^dsNpoRGrW7WQY0(iGvE6S~3Jt_vRf(W{)~y#Af@`x&@n?FFe2{tx0SUm~y`E1g zG@mM&z33-D)A$R|6}Q7*db)j<>5AfJMx{(}r4}kyu{?!-%x^|;6?4flIYoiQyiE2a z_LAxVF9UUhcgiQ~CfmJd91Q&TGM?CyVa2J|BJp*qS`*wy2T5zSvRH6C9X4xv*f6Y& zZ#ZE9<}-}2J!dy*OX}KUGL3Y}<=hRmCPdyk!In*1x8u@{sN!aMr64q@e}pOzCft|A zE&PaLqVw*rX!6EzZ3N9Gw_6F=tRdy)+3K&4H<cmqfQyLo=<T-w1eXJy71a);?Wjs! zkzjU7Oe7fyO*93MOG$P<ftRztA9Kh*MvZ4Huzu#D?XIlZWNm9aj2hvOIPj7%QT>7s zNT6)J0pDYU<O*MNLce;zm7lZzATZZ56}nJOX!@1<=c_arSJ+X6YT2d*vzB{s?cE9z zV@MZ!;@1Ru&gd0BZ>R$yG58)iq?XxtNulT+rGB<;u7)n-&*wMzfizV;dz(egQcaXN zcC*bQkk^ITChElr5cWX?0kl4x&Tq|S$dhq->FD6Y<sFC?qCm`?UD_4b96`J!l8yO3 zgx~DzeX<Q}nD`GGa1OB5qbb(eXV`y^k#&d8zd1F*U(AFZNL*#To{{@Akqw}Xv2ns2 z*1tpXVi&7%89kF?5Un3)&HaqN?rq9B8;CZCcP(u7jLI)*nOT&@;NVw5^*PHxL=2(n zM1)ud2$F-4X608D^ciy15mrT0L9|esjJ_KJ0(H$Rek|}PYG`eTb|$CvS@$s7?Gejz zvT*cPn?Y$Ss!qS{OzC<vdzPqr*I^kkJ!E6jgN~UWtbrg3PWP*n^Eq@8)KW%P|2|=m zb*EwVjL2Vz)Kqim2S`Tbl;vW62Oc>_i>=xHsoSn2FMnb>3xSE*ll2??wSOq=(42+? zTvK&L0Ne6hQYj-F#6#dDS3j5v|0!D4Qv{L!+<Je0;!)MA0KKW^135u$ghci-Adwug zF38}77|&GlEs9ICckCw`v+H*ncENwldKKv&bV4HEeE8gxW3#7zRVY4=6NMfnHT~=e zNX!P)!4HYWY+sR(Q9uHD>s;wo!AU?q#Fz86aHkK>X#Ar{=%?o_Q3|FUPJ7yzw6cA^ zq-BiQE)2BG{VXG@PXy^IN?H@?iHWj~{#h_*-YaK>fMuCwnaXEk?s!@T9QK0n6-q1e zxg;a79gHPgZIT4bGVeLXUsWsbIkds;xnpTfdmfywC{}XwO+)}ZtM$F##iuHH>}y>{ z-w}pY5HgT;$6DDP4L1}YTDcxE6n+(cx3(WL7eF<m@zJ1i>_7l1amAC!luWjTrhz^= zwh!az8_lvI<>FGgNSFk=X>w$VXpy$^&4E?rYmAs%A^tL%8W*(cuf|O&KA$st^jK0q zDwai(8~Hh|+_K^dRd6>!hsFYr6Vr)*jCwtmk40A#DZ_v8YJ;uC^%F8ISKPcHY&O=A z4Zif#&6Rix5sApX=5fbfAdqEloIa6bFz(b*g&gAg8|-10@;-@$2Ml1)Tg}eL!d@6h ztG;?PuZl+>iD&uhN98H4##w6c9?*)RHhqSIN%-8aq-c1qD1qvamuY}c7%aB>{<o{3 zF3Sf!xYH1Sse}H-(msBh%KgTISx@2|3cgaOzZj_Vsw_PlHMJat5pE_=eP79GECr{Z z_va8u;%q$^WAa@60;rpyiyoEV654v{uq-*&zXgfe7EfgIb587Ip0M-T(&I4onJ*Qv zS#kY(`3C*F$hzBF|MRo`UbKWItP)sY+C->hVcQp^+-!vY<*dZ%t^Vk>hTc2Yo=FKC z858bWtmngLUw+^8CE3Tq_I0&f)S(O3iOGc%^ES2u`(oe9pFlQ$`X)UVe)>qi)NLz< z<gZ-Y;id^)272V=(JRqQV{#$cms{|;bbIE(SN-;`HoE?2OY)q9qE!%OFAXQr(*|^P zx;(ti>rgYha#fxy40F?QI8SENwD`9d!)75O(7~Cel;#5;tPNZBY0k`WQi*w#r(}3e zLILbNd(}&K$guc96-#cs_+ICyveFi`YPheiLC%&<^l;s>c*2FntXUw3N0gZ+vZZ_< zZ^#JZp^bXfg|@&~yZ(WRPbEWD@m0LBBIN2_rN80?XY3;FvP3SjXcxEq&iV;?ZzBL< z>ln@T3No9S?E1XIb6OpyY#fLJC|A@loEqb%TLxCTrvmb2x-Wili_UHF2Sj}59mE|^ zCbcUTFN>^8K`2s@@rzsXabBCK(6p$0P7;SlDyfkncXot2!AN^Ci?YVzoYygIzG%Il zZ40ExLmWvQlz_!@Gwb&+(UfdYmeVzqys#gv&?|I;e1i`Zf?V?EGe?2zQLj;m?Xs?f zSjAn=VlibMeFT4^K5Q!P<OIJ_HDKphxsz-ExA4vT&D@AN+oJchvVv68IpO;vq{^m4 zIuX383en^r^uXlXnV~9#BY#r6$iI8QYthNF!mdPF&u@Bd<b{f}3!jwMZYz@gv^=;H zqIZ$HN-!KmS=qwxE=fXsSyxUSFZH?>;uTE>zL**H79hGP$9kdnT2Gu0m|oMU{Qgc$ zEcxLA`N-j!AZWd0oe2mfI-*h3y6?e7xaHMCyDZhBMy+H#Dh$gJvAymyu>KydgDPOZ zSoOoJa;@!Cs!ttF|MbkUU1bnmEo_WaHh@Vrm|Jb9I|yx|WODH)z7GJ9+Wz}rfDIkW zkVc0$n-<{jPXGx(=2U-X&cbV}20h1uVv$CFQ@1J$1kJRVIXaD)6kQ4}wI{{E3L=_b z1MFG8N-3VTVHDJj%4l;9VLHV@>$nIugBS6KaYare!j<Wxn#DQbQHGv3sHRN(&Z;|E z2)yoDg5b6U0V+H54gE@{-*i`9GL^(Fn#JXXg}Frq->sH=On-Cg3GuqG*t@}gFG7>I zphU75UL{X)-ZH0Ee<-w`7n~}kKWY{?eEos=Cx}5PQ4z5<Av-vKfH&OSY4n0EWxViJ z=t^!ChTZbpFL%a(ozu7ol>UQ&VxHj_Vmr=xHU<h0VWoO2u<Pv@bT({wg}4~|Ph8!2 z7#?Z}9;2RjiQ?d)&a2*G$L^p)p4#}-1N_Kk?5GxSI;~bvsw~&qYA*kub=}`T-6=ws z4I^^w`91D}aCLh1ZykVEFk#rwsm!?I6jA0&MpoDG76>DzKrJ)j;<*ZRCW`QY4k4hX z&`~`mR?mw>>+kklSC@e7zx1MaEpP7fh7bb272+wuv$8mO?f(-s0?PelQc(K&^IsPI z`7<nbu);f{vLC?Q3}3&GL*+uv<azYqBw>UHMa3*X8$)+M+VRo>d^^MUH3Zce>%?=~ z3gEJn>{}BR0AI6cqzM@wg6-!#L2V;y#jiSxb>0YTBTSik8BqH;k8tQ3R%7Uqnsi>f zF~A54JSr;YF_lnrRWfls_5gUlL-$ocrPIh{H2M;N$phF<EGlqdC^wCZcZzwl68UC% zXd9|S>KXtKnqQ1e-IV^XIMm|5=}ulh^Lz`S+TtBHol6vI!D!ha_B<;p=5ax&b!?qB zUXMFr<D|MIuEA`mNpE&Os|TTii~%RJ!h)y}fZL%)E)wxmX8wbPa<)Q5bD$!OMC^k~ z{+rZPXtP)S5~zNhOQ05p*|Eu*0X5O;X#kJ2Gf9aDg@{H%rS!Z3sU?Jd2Wk!2eM6lK z5#0sgj3MfIi<uXsVE<%0HzV;b4xi#dMkk4AIMlWH60Gf~b20}3`~<*5ocRp)gJLd} zyc$XfE=Ow5t`5}-`ELMgSmiw$%-*+=AZPA-hLrOiGXwopsCg<A&Hqn=>c}pE8l5VI z5{;wgs{?A@$8M-$*?$7~8#8-pv+_QO=v=6TI~PDT3C2Rrb18;8k4~uh7%k@Oc>u3) zjy^0z)SIY$8dQ_<bg27W1{Gy?LW#&$sA1>l0Q_Sx!Ey^zC@+Wlfjk#V+($t@uL8%n nIXwck!0`>JNaxRXKCAy9F{DvD&P<q600000NkvXXu0mjf%n{;# literal 8032 zcmeHMS5y;Nw??td=pc>=jEXQQAUy~oBM|tl5L)QHC`d5$79u6Y!9f%hG(bW?K%|Ez zgcd?m1SFvudI>0yga{-W2r-0^%iO2?e4qb^v(8%kti9LT-#+_0-(KgLt&N$)v9rg- z#Ka^(=C|y{#12UBucyBp*|&trL?idNU&GDaqQt}wU;1|)NZd&f-#4C#zU><A5C(~c z-;4AYgTvw4(9obLzkA{S+F_9ac`W0zVq)?epj+1+AHLq8#=iD~Aw)lTjMqj2rOcC7 z|M}e(t$Eig={V@02Wv_07B#lg5z8($lNT<aP6qb#EARhcbpF}Z<`jaw5m@E;vGhTz zo9EMtZl!yGq<aG<bNRG_5q3sY|NL)we-3ug>LE}e<G3C#kuk5g`Kg^gAJxh5jDp_| za%-u5*Fs;xm8EQF=Z^S{O6?tzD)ILU@`GP5=f+J={G~B7+y3Pff8mj;%$e*Kq~KCm zMP1NC=L=N>^HTVasleX+{vp+xVDGj@!1^<l?o?}!VGV-GgIX2LF%&Q>*Cd?#Ha1Ts zj{0aoNmo6FDH$fT3GwS8WW!~MsqiWN@%BI$*p$eV7=ABoJoCH_c`}TkdRc44@9lVL z61KF!UwbUx8Q>k>bF1#6j+@eTay>1Nou@tXhP-K|kDtYX;~4ZIr|To|Y0bq(?hD9H z_uUL^HR=9T?Q|>cZBK`H_kHQ#rHLzLK30|%z~rw-{F6%{&OTH%2Q^KyL1=8pJV4=| zYc2s9II}Zpd4g<lAalOxPOtmbusX}Nz&lNHQC0a1UZySn`A;N9@4rj%Tl2{g_!rBC zKATCw)OBt4EVtQrpAJ{Gt4G7u0>_&L8D!Pi0gF=9iFW^(ZYgwoXL;yc(m;D}L-5Tt z0=;?A|0-wo7zE=*h*&H4Sn_s0=rEiUGrrejfNWY_k)n&rNnMe`u2|%By|AD-FWt}y zHBVK73Of50s74)sdC*1#X7I))1gBDOc;~^Uy)~}*2Kj1ZK@jDrl7_kZr!11wJI)Dr zr}YXaI)9mybYEK3GE(bq95yP{>3$Vzg|rJgrVqV|ShkaZ@oPF0^1K(bhI34U`kpiK zkilTXHYjB5v$ZvMEU+plFu-wYQlHi`TlQ^sw(JHh1X2HvJCn&Q9pw~;#KM+hux$3q zAN=?_&o0=#LH7d=<eaxC|D*hdyAQ?;$0ixpPu_VFpmQ43Et8g;5~)f9#-C>nkPno- z{uQ}Vm}AYZUD(-uHs9Y6+=Ir%qB}-3HPMk%!xjDq90v9SDb+^_^v1TZ=Oso8pK75s z44OL~DW!%h7~|~q`bLYzG!J<l*mEZ4A>6Eg+l#0mx)IypvGi<Ed2WsXPsi?9=^E%^ zf_>^c>Was=b9BM?A*@gpxB9Aw3BGY5O9hYyr3lOItgEl58fxLaUvnv4zGIVkJZd2b z<Y_xNo=@oFev=&xusjU5NV#GyLgj_xuukwB6Y|{C-@XNnNzF16HY&=nb(M1XmJlAB zT^YB+6z^(|@)2xs$IcZx#rnWqrqXdwcBb^BN9J@E%#xjh=i|yO*(17jmmP4s2?dUv zB(g&$jrW4HnlV7JDj-~vt#Q-Ms5xy6Jx?*o9(f&Q!&}JhD6PnTr9|F=a2-S9Bgk#A z<!$>1y*rb#5EiD*_=S6!B@nW$l9Y6bcyqx{FmO996^J`Q#eHgzj*h=KO!+b0->@D~ z19+*7QPojJ#pwY$LMGnw4UT9_<)BVnQ)jV!T-)9h_Z=?^_%pAe{B%`I=atAb|CuL7 z!?rlyt<WNKbpi@r;}&V?q53H4gc@;0A@1uy2!wP2-GU^{tow2=1H3fOM;@x(nL#tK z%IvGATmD=<Jc_W;5%;4Vnc=RYGm-3F!epDmdmQ3(%YYqslHD=oP(^FrmUKo~j+5w~ z8X$*gr2=bgGPPeE{XV|OeOWSGJ3K5!XI0Ob7Ef4PG={;yww*~F_xA&;M^E%=m17## zPr2ETbvaDX4)2phr4IUh(=%*CXD8XY5N3G&fcify{Ll6HVc|_nOY+6@0fnY>nT^9) z(t$0e_NFz^zIyTg+__~5y<CXP0w#xz%SX%UhX=#WCSJ3GhsjeGrp7*o73X`%28{(O zcsOQ+_UpX{lx|l7*R5P+Hm>{k#oIrh&(i7i>aSf>Cg_rH>7KQhV&>~6!+?yt-p90v zG#1~UGramHM?llS3|><0{<F_NH!&(I%DL+y>*54X`;PY1O8;W>y}2rYt5Kw@whvs; zuB0V=L0&Es<@uw3>LwlhEo6RJ2t_yG@HTO+E*(WKuSW*Ke=(=E7$;=W(rYaR?iH17 zuJ*yUx;_zH>}Ho#v(=YhuGBJSuUO6;&M<9jDuU7_DwQkq@`#seKgQwn^?R2JoVg=R z1BXI*_H4{HP}?$VAd|Bm8#I?WWL~pj1-CrqutdS)0}Zsjs%~Q>=KCXiwLEM<QXO8k zxQemZL0awl#j5>R>G<J4uCIPBENZOwa9OQ3{8n<qePVQKE%}NyrDS`%>TJNbiR@*= zISb;q@>1}$onW;iiiN9;Csk(ixTn*4b8}}6Cbh95DukBOP`AsUl<F7(pxeElmD14= z4kv4;`cHiHZ)V6-ggWo0hwr(|e7%F|r&DN@qeGUM?Fk;M&A_fmBa#qm($e~4xGVS- zYM;rkDXx(h)GG}G`6}?FgL1EXVu0E7QcHn+)hs+C_S9J!HS82&Fa7v&%I$_vZ$9}S zI{cSw3ipEbl(y$IkyzwcrIvPrtT*KM80E%!mYrrJh}p06rL>+zT1$|u_Bz#W3|3CQ zITD)gs|_D3cLC%I!lXL1yB(ulW5!R=m%_aDTDB{eha0bi=x8X>3u0ifp$88h&i3-- z)VkV=i5o$4E#<YfiDd*25fO4a4OqI<_GGx^<@&bfTo64TZ_>o|N1PuExB|;SnALQ) z2k!Sy{!4{p;fHeG9k)U9t=Y3N1J*p_QP)Mp9cS}%6O3fmQmtRm+PRE#e>K+uf`Wo` z6Rl_nXc6AkN!1E4?l_RO)f!9G%{H8!?Mtxtqwi31l{fbmUAyGF5BdDu(PO-x_i~6! zh(aspOA+KzN@Fg+91CAn*$v#;M_J}vTosZgbw*}v%0(+zRP$?m;+J1^zuLVjp_g8g ziLZhS+gpeRTb@Oq!^aGMJ$5qS!@npbjZ_2opqmBtlbRsCSYOn@(Cplt09RF&zRh7k z%2*4&&gNq%Y!lWaFMhGJx}<p!!LGgrhAK>?yEEhHMPl_TPL4{I{+sk2mamXvGLnn> zNcouASlqGvp{;KR<CMPkZB^4*`WPZP7iVTQP#n6~s=KlNAZRT(XL8yowPM%k`hg|u zRE%kM?taaxnOu*-;!B@47!BusIi_Qx;<X<<mYEcjy*nA<_V8_dPRhaOg`hLp{^y#l z9o%7kt(wMT1LUc&*v(eWbKNUx7UZ_czHwo2OLb^_L623Pd-J_DkG>#&cjipVtX=$9 zeFM|Y^}{2=W`@f<0}x#$K7pOi!oILJ%TtaV7^H5;H2Ld8ozyH5KJ|6Pnj9E=ZJqTX zh{porAsMXI3^z_kb{ZWK^0q7Ni@EN-v8|&!-5H5fI#D*uOV}4?z<@7)r3D2<2)Hn+ zTX5M$S-*Go2CQ&G2|@i9q5+{&LrRC6JArd%i1#5FQEvmcra5jPsqRjKq?pP8xsZG{ z1g9}B<DFCH9QCu1>K#ve5+W<V$2gpBB_*GYhDnY)3!XEGGp!pp&pgv0hV%O-4XnpE z#m!K^zSvJ3)<lK!Zdl*7-TSmL^sg#=@YY2<=bK7!At|qp7?J2TG+2sWug-KseWI`m z3eFg9Z#*1TCIj+(BL`yOO<eT60-DHWS8u2`2XJ8$8w<ri>H^hHle-P8%*nDSy_`ZB zTxbgx%G7x4iq1tWs(oM4RWw7oyL(i@ji-Omo<Lt5ZC_bsX>N~?Pnmpec&TT!#*U-g zU6Kpe7dF>!FL`a>O~aPD(UU)t%;JnqKSZgzj9~(Nyqi`U>oPVo4*YfD{5Hl^tEOh6 zx5LodBsSexVg<r>?R@rYWVfr_WX0~{5H4^LJFEu|yog!j5bxKssnu3&_s$~jiz4!& zf<q@f9Ni}?zyHT)P3@UQ(e+oAup!h~XZCh>r@Xw(i~ucsjcw_E|CgrSz+zGO9EdJM zOh#olPwqX~gDdmRh7E;0`VQ`JO0RC$KUy+(xB3uf8~r9RR1h+5etjgMEXk4{iY_TL zBDM{F3uLTJd6DW+qK7V@MGQ4P2R%0v>%~E3d;z6-rpe57MI~x;+`p2?6~0fr%*N3n z=fjKEG^Rp;cF^q;;2M+F5U>L|OTEcSV`SxQbGLb)zPfC+)6Rzig^t~~PoRqmKc}f1 z=UWOX)8DH}f@WAFyY0uv<$~|tr2LSODT6E4UDq^X-=DI~wBk+88?y!Ck16cOEy3}3 z!W0D_QB@gFQ#}u7p2Bzy`Aa?e`eKe;czm+fI-{_O_7_0;9$QWo^i0s9Z~5dzsuJR7 zHG$^=`#Sptp{c?*)t(zAWhLJIWBF9JjM_C;Yk)%L>7|8KN0jFPLO+cmdgFHUXz3zJ z&xQa7&d3g-M&BtlNNO#6D&95!Y6pcvL57n}!#452E2=2q&+hF-;lnG}nJtmbr1<ta zo;!wjrzY7FLNfUvb6lr&6rmpWbGF>(^`s8tkTSHU-4NseuHr%ZJKAv2WYQQbd!(a< zO3gR2sm5WK(ThwJ&~aTm)c6OKc3lPF<4{`V>Pf8nIZB%<MDFD*AY*$0EVnNmKsF3N zdvm%R6_@CK^PBzq!9iVO0u4n7x|kT#{py0Q`u6*|J(`h(9&V(j9q$KTWXBs7Zf^bk zxR4;MpBvF|RCre$V+QA?BTZPVaFv1*<yb|KX49ZN0WR1r^hS1`U`kNyW?N}ns5Se6 zwWPPGT(U0SGFA_Mx9cUwRAq)U#IweDtdi9XLNb2YM>zWPu2I%>xwQ<>{u5At#Dth| zbM3Gl`A}Kg&Gbj0m|lr<XEW`=s{~_b%0-@OG^6e5n=KC*y?u^42DUhMJgvmBVZ?{f z$=&VtKj<*2XhxIDlgDjf7hc|}wlW=A|13~2+CbN{Zk`#&DVOg#D~tXy4o$nwafD1Y z^d6M+b<`#>%W@G^!HvhhXjTPTp85wNS$C9#mzhU@GF9e%VwfunPThN-N!_1oyu*hi zqB4LH!wrL)moo|Rz82NfO+j}Me$-$rD3l(#wzmGwsHLjSomTmiFHj^>r^Ytdm`?hV z_c`N3sE?XVZZJ<0g-P%=erylrYr!?`bG;QS-TkKRss=avX~<poO#je0A@25On6ccV zxX#RTHT5t7UDC&xai)J!_xoNtHQvBrFxcHS)(0Hl&&I&HCSO-aw1B{%tERAFYm}^U z)41MZeBTnk%g`s~lBy6L)*AH8t$C0dbm8p<H}$asRGetVFKut7zK7o-mia!%d+(uI z*R)@jz1p0^qF}Wq#Yh#^82F=d&9b28vfF$V5hC62A?O48sFk8rqP}n(1q8S@e3|@L zi>L&ipVajJu7^cfv5E_7j8KEYapMh-D(_p_)n9qg=jlEzSnrJr%X_Mo^|!Nju0YD5 z=9T6JO>FG;*dv<Q{-8)lZ*9Z2V&E}AO)_JeNWO0$A0Hn^-^;;beB`llZE>@3$X*4( z4f$c-->a0>Jj+T6HTAg!erUT><83VJcc~4t2G&bQz7STRp+mUda^cnRiAQRFgJWCP z4U#n;E*FQi*X_VXwVhWt=BYoLX8U%;x0O%-JE>1j?3T_Shbn>uaUHg{?$z2MVfmjh z#ytez9<+-x#ATo(uF)uv2Nq7rx&Yk636_}*Yuw*G4+aH}o}B&UiTWY*>m8n-ED-sb z*Y**E{Mcn*D$8#8T==^dC{pwhcl-DP*!KJVm<pr7j@YmDUK38R;<#VO%I#f>V?y!= zuQTEMD!20zf1<%|!!N=>%V(eHCDR3|2QocBepc|oKMajW$NY9K^%m3x5z$X|P*fE< zYq@{-(%_p7rBFGm<oQK>;OE_-6Lb46uAdbBF$vrc$$}?_N_lRu`ZD$_L7DwNOrE+T z)2wOH<QD)m?i3TbKlz-M{dk0Q13=lDTobL;eGB?#V@bJDV@bzS>?iSlaCVw$Vr$t# z-i$uVMjN@qV|Bt_UKXh`duiaQRzZfDJBuSx!!QqgwXTXerb3+ZbgA~#4U3v4iJLu& zAmk>dWj&yZPf)}WDe-F`2NSiJ1RB_9h1K=P{Xut7od$A82Cgt6P-$swc5Y!0(y`@U z5;Mg-aIY5NZu<+e;EaJK7G2<)Wh0l-3(lb*J|3qe)D{Kr{Zo5f$IbfZ6@-|X%-e&1 zp0+!1GPOeN7pIp>dhsbG0cf`1F%bzV0bIfJEaNQrW5ju(#^dK8B_W~YxKh3%w7KL6 z$VhqP<<?P<Y37z6sAWe71HXb-2Zd#B-2p`@>t}cEO`$rMSf+nK^UZ!HLO^Y<6d#b` zb;=fp6NZj{K@>r<$k&`GK}sFBC<j4imbmOjO9}!N`f3ZzN?a_e2IxSuCDjTQD?Rv! z0GO?-@F`mZ5WDt|Ic4U|<L6i{D5AIZRcM_YonN5HG`N@`G*FsQ%diq50CK*uK^lGS zZWLdTq$Gab8>DcS6=3hp@+#i-7APTH?R6=-gowPrmK)bJTXJWlQ6^5ILyW<7S=NG~ z&JD=697v(Abq&GVn>*lV4>CaeO|Z8)8xgdrfAY1M*HAWRf69rYVb3`=$pMb@9d48w z(&9mGEXw;&rZvrH@-g=}P$BxtO^Q6o6t(rV#80WCJpp;$9*@Nm4J7f^4kQr(G^+xw z;%MnQbaL_L_QfTR6jO5?sxjfWwco6~g)qB4Ns-a4Xlm;Oh?{*Fb;X(wuoUI29o5L@ zU``7C<WXBmMYu9!bp>=Z{bUA`=<7yQ>hOJeIY3SF@3n5N+Rwq2TN$D!B~bA`eKeb` z;Bht(NM3F+-|+x}&n*3bqMRjN7oslh0FE1kzG@LSeFd?Id$Xh<#2hi+14w63H7cQ_ z$rgoGfA9?ayst5DOOpqbI-+yxM_l%FOF90158f`J68}^??;C8N*p6J+>Z$Ij@E$gI zcc^a%fVWH!hR$CIJ1QrP;89TvZ-neG@OrG5DhLu&&&e-AjbCKeQ4w`V4Dd_K{V9Lw zot1S-*bRY;25iNtLKjr$)hCQ_5SyzQb1FU&wW2(Wyzw<{D0r0FXtEPDUpu~s2}H)6 zTsvkJ2mY&Mot3BL<rFa`JG9<}QqTBBD~jil;ucEtaA@xh9&}k0jiqLET~7TWGJeAN zSxO8$7y5{}s0<xDxdt00{YZSb%lrX}886b5%&~f6$YY4i-PM^+B%VeBajE`X7JFK5 z_ytN^3z<+*vY0!=P!@JmMFCedoJ~G@5Tat1RXf*RNG%PxJDYO;d3WSF{Sj#-1%O=W z-B<>vN*U-u8Ou^Akbe-<+mFv;0}ht8UoT!_g+jt!Mdy_)tINmP^1ssWfkR?=B3*nK zC=S7|4FK)DRl?2yNsPdGRb~on;qpgcbtH3k9?@^U_?!sOo9QuZ)jMNm<Wmwk|N8xr zoS9(S^~B<6TiM})n3H~ggF-&xv#5v^Y{<*4DQP%zfodj@<yw;%=!F09eU=h0VZy>N zj#uz&N;Tm;)8BsXkh)kK#R)c`K%=MiNAc?<+Es~!(ZO^ld2*%(YoTiQ!AvMErAmW$ zy~D;{L@pRL2oP7HytKQFH(++ZF{d2U6BsD;29I*mM<yWK5ugB#LN~!FnunIK>sAwL z;Q~`m&uC7v{f&M7(sJ(aU75l_N#FJN&+Fu-^gk^Zj_<vh*J84jsK(>N9(qQWg5ra6 zmyZB>{eyH1Ts!^SHb=By-T=r%G2$Sc9mUI|3hm*@W)8?d%+_R}dNCN}bM|{_w#O}N z$kinPGB)M=8-Vqb%ke9Ult(oAcTEt8UiQe)D-Oc2E}Ey15q@QL^>f_?9hkAAI?ZQc zEsOmon}bj|t_*bF+x-nx)wlBxYcGe0BvXA9nfcO^T37KTp@C$Oh@9-mml-xMsC*Ak zJ;5Mcl#Kn*YIHQV8d=50Tnrh=?gGC}x=6X}p<Za4IDUf^(9=0VZP73_D-!|OrI2mL zfe{gy#M9q0suw-x`0xu|jAIs5(Y)Eq)jfq+x1MluQbt$%QtjVnZ`B#J=MaUV!^NHk zcS+a&REKOEg4pUvcU1H}k)14D^opZKx9<e6R6(}49>G>Ce?I&IxKEqUf@5c1BB?{w zb^=L1h37{=m=`*9#B3LBJ02u{>8lg#5n?iYGm^B}BYl*J>dyLX+T_f)OaacCB6c5( zmoKU>eylUz{272c_V_u`nZifmQu2nY68eH^u|R!s`MT_AaBogwU^o97Edqwx!~4#^ zw;5x<+R9bz>%4Qc031E=rypds+u_iH-p7V?=gw@saG<Qs)_7p({M%4Il7oMObo-I9 z3z3MBPb(?c=#sY(O=q0YrB8DFjIu`}g+?@h!mzE$Ic^B5vu>B>D2l9=TjG1;5-j3H ztpeo^AHGMh=Bq95jjok$nez`nEI)WlQ7E?Jqd&)zM&eAsl&S2ndTs`_qG;szoo|n9 z6I}Qwn6lYjybM)SzZtS=A&IPXQaaRZP)h{vR45fG{Je-tKfj$;5~Y!3i`r^9kg<rn zw5Ko6+D<M?bR(0A=3ryD@Gl|6k}>_}wMtK5Ds1;fiCa(gvK1{LCZq8+QR#f$E^hZ$ z^4#xm%fa>AH1m0v&W@SQ^Z1*QynW*EA%OXALs}5$YZ_Y!5;%9Rq^K^!-agTlFU{Hu zRiNX-SbGvQ<PVWY+=sj}S!H2W34<UwPs%vUMFMV1us)|=4q<iP;IA(l9XUg++U<DF zWErKn^;1dZKae($NBm+v`JU)~m&YV{60hzi&z5|+EH@%nuU@>MyV{1&2lT5JN>QqI z|LHMGSXJBU(PBeUbT!lH-KQl+RD{o$or1T!s*aC2WY7Yg)zOpqSqfuUzN@o&nIyjX zuEZJ680ruIc#c;g_Av5m;Evdh-=)Qho*sK-d+YFjRR51$xa}zR&jt1W9{(4X|5cCw ky$=8FlK($Dh!nO~s=|+cZ)WcQj*EeA+uW+XaX0CI0O()5sQ>@~ diff --git a/docs/logos/xsdba-logo-small-dark.png b/docs/logos/xsdba-logo-small-dark.png index 44e7ecd8d2985b5f1cbc18c6d00293f889c56798..6271e51f7708d709412294da8c6a7f907fd26d24 100644 GIT binary patch delta 5612 zcmV<I6%*?45%epN7av^+1^@s6%5NHk00009a7bBm000Eo000Eo0j{r0K9M#je-(jA zL_t(|ob6qEbXC=z{(k$MdvhO2c!sA`kyjEaKG0$aTAZq_<1Dog7{_sSYDa5*w6!Qt zt(mk62~=9^SVwKEwbM=utu0l2p_U>c^$`_;5GW#5AfiGb$$j5*zWL+aOHQu$=Dto6 zW=+4f&dR;}{LXLh^JSm?d+dGoe-)A_7V{r^eu&4*GsLaRG^Kfzh!|!x@aX)Do+eOy z1p|!RHtrs&>E;q8m}`<T0oHrH!PRv$X9kPWD^8I8@4wo3Va3U#H`vP};YgQ9!wk=# z*S%X;S7#Po$pGQ@mYrjbFdhSB0zjRBE`SbThjPhP%Rg0lxKQ1y*v8dwe}pc&R+{b{ zU2cE)GhaBRzP`TbdIkcEUTqy?hWRr9<I<d-!8o5-+_Wp*xtvfG3H2MHW9Yt8C8lJO zAyir5g3BkJ=!7rY*g8gwtA_x|NG6FX0`r+gTeeRsq>h3KsNc9zKkVJ(3wNuGL?@vs ztvq<)l~Ybs!f$zD`)JYee*nqx*<?vhP}H7X(%kmReCsLb=Ia54vNE^5EMh}65{X2^ z;b`xgWJvI{S4}(72w(Qno{EwZ^`9chO0*55V3^M?+|pK)PhEK%$nQV(-hz?kBkoRq zCn14Qcbnf=S_uHjZr&L<+Wj^TmT9_{s6YS#x{h>S_3)R@|2<9se=p^>mfa)ukZ~Uc zCkv=UL=!?MpaY_%7)T9(PEr>U>oXVvwAqcd({|-jpPp|6J>pV+ug_yIiy2X^)axs; zm&N1Js9Q?hnx0aH(uOVEvh%c6v#WMs5D8!QO4|rMX8u4##uw3uG67csxGWdpL3yMV zRmGC#w&~LIAPgv$e{SA3%!rz+06D2>WrDME6&<wklP1S3-n?VRKoefSao<oVSA&R5 za7g9bxeDe@wo=NuM_**zlIGSk28!_dm-m#1T%qM4KH-Eu0Z38b%~d|{G5g@5_Fo_A z_@D(|O^-n|1!~biXj**KgzHF%Sgnv?Boym3x;&avfCvZ?e*vI$el;2nmXRVN6aw<K z_012<r8W2VXK26htwVmzh}Qv55lxzuZ#ULVeIeIt@+SMPFQ0w@z=3Z*{d5V2Pbu-o z+?p3CsTfvKWtR&CySomV$I4O-WF#1Jmv}tA9^rT_cIu+0?K7ozdP{#0zVNxX{L1gD z15i*fk`5%kf73Xp>c{z9Q}CGmqf0J{MD%0vLa+ZAOm)hlms-zpdPu2nY4>S9?GAyQ z>Xc3a>Kf)$ug>?nq73ANGiL@p@$OhLI(jum$;3rXZ_RQ_--71--caPoQiyXzE0OQ6 zsIB@zLDv>rdEMOVZp6j09<HEIT9#*ImJSP=_j}!DfA>Pr(H_0LP@;hX#_V)B7K^{x z-qC&sNw+8^2B?LD0Too;7Yh{xA{2^<ARG)Du~@vrGUZT81fo8is(JTMf(fORz=Wt< zH}BeX&z#He&R+Y+QNMAY$EAlBK%5(+l|tk4nyMcbqr;JWHedzgx3=sa;fk51psByV z|AW$zf1^gck!m2jI*#ox8#bhOFyU(3IkY0)%fKG{$o;&;rro)Gc4c!u?Wk{Ubq5d2 zw?soF2pymfKnIkT{45ZS$3H_e0llwqou+y3%JWVuxJM`9SWrWN_spDn*a(|p$8-ul zx#*=`wYkdIuWfY)JLE<YOmV6W0{Jf|hz1;ve;^5P<=pB+8e$=*bc&d#FKOC6C!1XT z+E#aHyt-b1sZP}m$WIz-D;u2B)*s<I@2WZdpcyiXny>4nknyvYY}$E#rt=TAz!e@Z z*8&dqXpu*pBpPtYK&Amdd~My|%18a{AE9(zNF|~`fe=TAN1~laNh$~+qQr<tLvjSW ze*_Q_2r1HijJg=zvq)+pqG)o~O@G{S&i$9ozQ<nC^(`%~;ZgrJB&Im!p_6#5p>|rM zGunFKn1M`(`g*AFr&~{jZVWNC5=~(0CH}3CdCOEUFX8B6W9QHjS}z0n!8^ltyGzFR z8WJL*(B2ZS=ieG?t2YC{{I$>~j%&MGe}L&o7&wqR2ptMqAqEn_ZyIJ-t?Umz`ZeoU zR|oU$4|lvH8Ujw~Byir6mv_&ZzZTlWu{*C4pwcPb0zBS0yK0qF`cl#FDb_Xf<{5kT zxBXSjxMPIFFy>Ag*LnkhX^!a>`EA4Os^$He3>%Pq_L_O~jJ*e|+YBY$jwvNZe>$cM z@`QK8n(z1bf};L1kRQXEc`)iXwzmdN^B{ySB9V>-B-U+)JL32N#PK{-C>%3PBlHmx zIa`ntiv%OFXndq7Q)q}lX%HpiFZCCmpAoG0ZTQWqfmle?uLd$5>NjrGgRZe>0Ol|O zb)}RR2m}^*y}k?Va)GYEZhx7-f0u#mI@;M@HniMLk#;e82*ihhK%moKR@zyJfu!Jh z--a~<LNqW4(_(dV=f;nEy0@C*;E+-PDA?$mT{U1t1A{aN`QXf%vC;!(3xKY{s2{+l zcMfcCr~?Lc4dS3p_}0y<j(UgT6%07xvia?U+g7fbH_sT@dIyng0H~|3e~xw^)&D}$ zu?dL2K%#l?!ELJsgJ@t73}iZ7`sms*<A;p?j7!&th?u%*D%}8Uy*}TCJyIf}Kv##? zSE?C?afGp0he39P!lCXl<HxsWGmwP5c6M#m>UqGR5Dg5V>(>|7e`VhL3!3*o?q=6N z2szY*(j(p7F^|_%ZkLNie<Ix;pT|uR5tA_xAwA&E8Z3$6m6@}vemIy!1A{z_*s;3i zq>#5{=$`=Rrq}>LAa8r3AKW|GL<1)f*#HoY9j#0}_KtzVi6PghbDh*#C{7r%7j0=h z!!(@BM;`~FK;D$g1Vn%1gfNibf9~Ct{u2LO0fYhpp*{+BM2C9Ie@BrN00I$obRUhB zdVPqP(avxz+!ct$j&+6(2S-d8cQ9)NNhPM3_pPk0erd4obI=XsvgX~DCzT98dt~W| zbL{0t+}u67tYTs>;W*nXhKzJa5sya9@Ubp49G0WVEfN(dq1>{#X=kjlw(2j=-9hdc z)L~@V=C-MTIeDP!e-nWw;F85nI|pS9A2hO;Zfu=wis{(8j@%)-65Ku*gbxbY3peeW zXu4!#cFBGMMF&{t#LBCDFyIFArYD+jQ@X2Ki6{saC`ym0PgMAajSvAq2nmUX!qMUW z;T{4aLIELN;jWP8b-fo8BN&av!V!su1Ce0NKdijFz&S_~f4Fm?#_$0pdqMNo@n(1Y zNsrHWhP}MIt7}hbSy`{K+ZS~0t{OhMS3dhluw(CD)&3I^(Zr-~LXN*oRK$dD+=N=% zSUc^t{=WYK8%DnU($2ANl$<<J_2q#Qz*xDsY1i5PUD1G$eftaBN4s^+sdrc)3h&3w z_|HjkXd#eze*k0k(wEz2I-@T=`km}$FTGJ=mazD@vJxP1D8i$^Ty_48cVgfpqMRXI z01x80cX8A9e(T}=HfBqGy;^&6&HRYRJ;H>cK{N${wq2LY;PZ`vKtKu!=?n&gn#b!0 zXxT`C_zc&P$>pb(01(28BD<sA?;b2wSFEl%>G)d0f5lC^#tC>mz;Y)R=?ED!q21gc zV|c%jJ^#_C#@tg@-d>_<y~_7?b?-m5th858zpq5?jFp%7S`iftgr4`8`PP~S6NE`e zOe_1Xo#-U)Xx=^Eq<NzWlod}lbPB>S&961gIc=+xob<~uQvdRva=+g<#yO4BVFqK5 zrz08wf9|T8dVmTKQ|QccWug?K{bb4J9j7~@F9FBNu5WEE4V%$XPU#cjQJ;6{?^azr zqt8i#73Ws&Gd1-9AWp3hFN3H@og~~*vKK!0mOtF7oLi}6@|f2%><@J_$L3@NSAA;Q zJEp|%7c$~d3(6?!7q`E>Ylaib92v7^{(SA~f7zFf(k6@_?sA!$ii;lT>h^v^_pEn| zMnFKJ0KkDj@W@z?Z=`K`ul&yM+7~V>|AfG{A}SJmam?sbuF92YJC-)LPNpdf0QjAF z%>!gmcWGDNJ!{%qMe*bW**84%$Y&=^@jqiP3kTy}!Nb$bv=jq*!Mlg{pXK-VGLRe1 zf9QQJ6&0J5vThKRpvOD(*+Pg;;?~V=Q(cO;f%KzDvJ+ci9HpkuYdm+#&O+N%{2ozj zTitHW>r+Z#KSUCTQoW9B5K{u3ac(GvXaKlpPUUWp_d*cOE}aubh!Ow&;=la0D!XWU z6h-#+EiJC_*iwHnI_x0LU~I_n4foHje|BVPT0?F14v1PUfK%&IMj#$vw|LX`f(S2| z?6rVa5+C9%^!ikg5;V$<7gx;~?c6$U01Y*j+eof*ZXpmWL{m=|LU_S@M76fGlw_C8 z4Pqe1p|L-&n$fp=S120hoVHb&TnUOpgiD3e)YHqFcjxuiL*54Rx^;iPrnI#Df0o3x zB1$0?==#9p@t#6ZB;im*!;$D$yCWVQ%JM`+fuyVphkp?C``eX94S+60OdShsSbohV zALiAN0<ds%>nu&MRG>-<Fp%l?h&rU}=DByzntmvk`tzRfbweLf;_>wIJI%PU-Q)B1 zdPiJD?;0IpS!%fMCpyDpM;!u8e;rV9BM^C|;S1;YOOH;)syWp!FWb`ANMM;2$`_6C zMqF<Ia7`}4gEj{#f`}Q2ypk<4bQ;TNS2mNX5h9MPkP^WK*`+KD3fa^UHA;uK3^dV6 zG}KPrj5wD=STx}TKFC!zf3ii2ih@KK^SjF5aN6t07Y*lEZK8n{U~voLe@Wb*t8Cum zR(CA4A$~-@E-*9^O+kqYb_Pb%G=m_7fCwp3BWi4oMV~UFRGOy55K%Bqc;f2Cg+&G| zPNDI<>KB%7Y13eucNX+^u*mAh*_A)fS-jA2-M&ZE;r4gt4j(t_ar^m5IMP+(ao2#< z1*UH3UeZ^#Yp{ECIxK41fBBCJxDx_b&fbXN-iFy#-^r(*qV|Z=O;1jKtDy{ooxu~5 zXaHDQTlJJlxeJi2Ly7<du{2+zfg%m$>Y9^69<Qs<bf%`1;V&7zd$5dQu2?yz@=3tF zi;{T^7l8rdn+<cSavrDcD1MKqnPY=7nrR7FN;lj`f_sZiDh(7Ge`Z&&6Tx>WAMfD= zV<K{G!+F*JU8sIXR<TBmz}`St*H1;1TPTX4ipAoQq1w=Wb^kQev7L1?U^;-S6QBPC z;Mp`X*8)f`0%`=%kxAK#nyTL~ZfZ3EbtizKiQ@gD)Pm(Tm0OBwsG}3U^VhD`PCNC~ zl4H>*SJ%{pF)+Ibe}56cZxf&I25?6jnGFDvFGEcPurHg^rJJ`6gQ=Zq2qSU5^Yzs= zHAU|Z<mmeB#4B(ACx(n{STX059ROZ*Qs)Wtn#cbK{GIFp#NWvtKn%n?H5CBH!-~L; z0Qd;`zpw5Ca0;yUwgYe~_pJbo0WdnzroW-EDYP;GCj%&fe`T}U0US+N*~tK!0lWs_ zRRGx*rBnlWB_aPZ(r=SI1eRy84^~#}jfDJO0G+VN`Za)m&QjMT0BZmo2CxIbR-3-7 z`?xL}TmWtd@D6|j0A2_1R{-w=xHr-MzTk%C-TV;1E?D=p4c0xjCffT3fEyFC7D$5R zLiV7IWND&2fA#Q@+-8%#BaO@?lKYq&wr8jZBrhb{o#pz6Nq*7x{jLnUHrQlNBiWQi z?>>?f`)J!$S+2LEiR1{9$H^9w>umzR$WY0{Hks#1sx&g2Z8BR)-a_&Ml4p>dNsF8n zBzG_~+0)pY=oXS+PF!D0@=lUR6X#yA$>l=!i;2H`e@Nay@*I-qCfa$xCbyeb=jw~> zw-WdAC6aRz?YoTD1oIJ_uJyE$4U!{CzGoA-CZ&RZv7LLL<d`&#sI<v6lhiXbHhIj* zQ2r;Ip0yeDOeWdR-pGaQWZTj`y(3As+T>Pb(02yOSy}FFJjtClUFW9?oJTU2I2j;W zohY9|f3h=CZjih<Lj{-FlrPKDm`ul+HXZFG%leSLJcYzu$PTgZA>ypWJ(6SxGxzRX zjybk^A53-qUIOqRiO)U&zX32T@wY5d-U#5i42Hv=z$x_onR&L)520_*WgUP$dFp>0 zmSN0<*J0&Y04q0gai03^XoBT|0l=(uuHOm(e{*43+v%{ZZ1Q)vngHCHrJ)8aH}6_l zUdMd^a+>N-Hp=!nT~a9(&j7eN5B<65d>X)KZ0-3&AF?{E%^at~@?zX6=aa7FgiPIk zG(SEb9ws><hezkZl<N$Vuaaye`8krFEZ4tnyLMO(_1$2T&t(`nI|rSY*yMkmL1q-m zfBQ&&#M}_i6hR&Wkh($lQULGe&?~+H%U4Zq(xL#I4PX(h9`g~bEM2CzYm+`MVfnAw zkTG4F0mt&xIV{cj(_uaFHv<@9EANCA7`+LgC2=HE%vvV0C%_`dj<3Utkg_2P;1*aB z-;J;yTl+#uKdiK96M!XYu1_v65agClf6%gv<SlO>UQ>7Wal;C<l5bb61Mq189#|da z6aZ(!>R@NX)<M(Vj1J&e==qN&d)Ju&^4Wp+0DuPod=6IcI1j-066JtJ=88nQ9riGH z1hS(dk2dA1)Bg6vk(6_nplA2_CjeXlU=x5$(}TyKjC5qz14!;V^BRD&V1=K6fA!d0 zkwars5eKjtmT{c~V7={JYS?XGY@W;O75TpNl8d}uCUx<<eK&_kv*;NI+dnRq?2FLz zXm<j*64tN6eHGRiDgb_l;(nhi0>Hkzd+P2C_FwPF_K$S|xHQlDFV8{d^R~~aQ(^Wo zJli_*FWJA?$sPmX7q+tN(ev|re}4q<BU@$vgW@uV_8;#|HG;oF&$#^+^zE<Ti2R3< zivY~-<NOuq>Dl{W4H0(Ojb~rK1vwIyQ_+Kj8>3R(qlePCI&PA$*<_Zdk@+Uc`$<mk z!>uZ(6)q=na~heS+Rnd8a$Fjj%SeV(+^bx}_5JLLj_t=R_ReWsmqzANf7|&ES}BTD znF+MqU6M4D!pW1j+Z1eL<`8u<$zut*bYc4vo1Qk3KTDK-jpSlliL4Hr%+3sT4QFqE z`zXl=NPdIlZ6u#g+=P)RPa+qx?@#;<k$jBgw`e7y*03j4!9*RBMwdn_!IngX<f9~S zP3U=yJxR336FiXYiQnz{e~{BMG&p%&X{#tTA$1#bM>DNtO{RKIp_LiTgfPi#nSY9P zBFP_RY1<R*J0~)k<lZbg*3ruA98X3G$(vyL)qv$OJlXe<2f!LDlSXn2tT8=_YFOd^ zr(t;>V`2HEL0HN8S7G_7PaykJhZ0!+{gtpnVh=38^+f<bh80*8Lb`6`A^_LH3dhI5 za`D~-@JOP4*)RlF0QY%VuArW{zt;i$5<v17xNk+muKX{IB2n6weC-MV0000<MNUMn GLSTXja^nL4 literal 2288 zcmd^>_dDAQ8^#j}idR(~PVFkHc5APQkreHrimy?vQAKeiDj^h=C|bM5(W<>Gm(fbC zkR~lXIAXmz?9rGxv1%lu>eavF{o#H-*LDARKhO1CcZ#Efjj*7UAP58!wzEYzozU|{ zgj0McvnluQkrN1n*?M3=An==C0{gzWbo#`U#3J3X&gcLv&Ntj2gu~&qf>0qCKi@Ea zEp&Kb;f9$M2y`mW4q@pMRkS`C_b0F?N!#AU3{gTiLp?;HmWVS19fV!|H6HRO0$H+F zgH%B7F`mJa?Psosc3!a~8Lb)Q4t}&BzpnQV@f59~;lSXtRyDcj%va4@*VUJn_}pos zmA!6u$e6twq}|F~*S;NPZkM}Xgo%f(OwGYoc4yUz*R=MU+Fbe1-j)$gk}rY#eLFNZ zl)_JbEu=0*hX=jf)sEN4Oy=J(9qOkIw1kb``fx4mv4wr0iSf~f;oOhuTFEXHup`T( ze~ENN^K@l%Yt~9baYBW=B@=0L-%LbN#xH_J{`;Z5I0ZHZQK%@kLAhV9{XSyB-+1Tq zcY8}}R&d=@1fYtvRhwPPAgSHjd8EW!Hca1#sX>?X53Pr!7DO6c7Oa$C*z1{47S<cA z`E~B!8T(rrN@*DuET0xD&VO>GWgB<5H`nap`3R0#8GytkZi}cj3+>jq*JFaZnajTN zhCVaWn%<Tj#$Qd4r5XjsOG#$yG4I#J4yAQh+x@OiTs@PGUnt?+6irSroOXt3N<!WA z>VxF|3VBWbtm!5yqw;p^Ta2mUw7z^otURK;FPZ?|Jz$q~E)}~^<vC=;yt;ZbgR{VS z)~su2E~bT!A=d;A^p%LbLI?l6K$y)7xonw_%$1++s3MybvlTC$?@b%bVKT8s<8M3@ zg%j#`(lXy3ls7_%v-|f<iuP0HoJn_Q^zetS`rb8td&c}uaUDh-E3*dxP-kh9oG`kA zs%k@q2%!CD4y=<~8iBpGl&ao{$aGYOyqp(-Nm6UJeWos|iBv@@r3R}yrUpANRXeW$ z-Kwz4PFY+4u9K3p`0D#=@_FEgm5KNP+U;<4`Ml)1qdzItZ9^3UK-P9F{QZ?$*eeoT z#iJn>N?5%$AB!ZTzT{~^ZxIB=C(@Y#E{3Tpqm{bSaVj|+A40K7rvCgmD5A-rR8y1* zoNMTFaq*M$@+`BQ8XdR&_kE5c)yv(ZK&IzpSw|&TAKtng$cz-&j<MWN(-GLN0N;wm zLPkLeDw<eS>HUCX-@zxkPp<V>IAq{{vm5nzkkJ-@u4i&ziA_BmrC%)gqgGmu`{AwZ z<F=`!AewIHueckrtcur(!|K`Je3hN_T6@&BR4XpU(vvSNAr+1ZlR!h@avWM{8XvHK z<9J5L%y#YK$k97)r46SxR94nJ?!!++uX^X=<Gp?tlW;n(Q_FAJ-NbM-qdxV{>CDRW zyQU=XhY!{}a<j05&+v)zXQ~9ws@hcpYiCDc{d)0GbJmW<XI(P^i7$=rxGz4eC<X5L zxPDW;da+gt)q7_4;F}1$C5szuQx84Ys{Q%VD!jN5HP`9KhMgRJWRi<SN?1Fa0Z1w@ zj4*aw8|6*!+c;WeN_Up;b)+R1Qy5&~>V;703ZyjItm&f&R{OPU_OkV;;`J4`8}=Zx zu!$8M|Mp_{OGTr9R`XWiy6C}tXY;6`abb1W#MJIjb`Mx@mi&KKJs-HR@)z`d-q@IB z$7WDyj2&xZwhfm7{NANa%os6jKjr6?!ok#Xk)&bX=E#U0<(zzVYh~HoIJgmxOQ?v_ zd)D^?K~`2^c}Y+>KMw#IHoTiFJ}9Q&^Z02xw4%4mnbAMw@}Y32kl267cSv(U#Ld;+ zth3@Ei5Od?nE`gWYG{61NTgT2R7NVgiaG)kakY<g`&jyfnf)##B1isOym5S|w>!7T zLCNVlY*Au3HzT2bLgw^QbWBfE#zi(|#(Nd@>rIFTTln=hW&@TQ2eFSLDO-zO!zhsU z?5AcUM~aug9ZCC*+dqT6T(}b<4Zl}W=CyegPen0k<>L)PO?Bye$9=hD502{&w*T4l zvo;Sz^yW2`!XL%D!5Kdw?c(EnU4pUF<ARP<a`c5D<6{e@R+dZr;G!7C;QJK=up4AE zC;DJd$_Hc4XI_wqSMxF3a*y;7zkE7M<^^b)Hyzvxq4GvT{AoAv7<_Gbx+#Iq(&Ci^ z8w5Nb=4<3l28ZBn2ne~XmBeK*8r(tyXzueVEFFCHy?}qMC;a^<magN+`g+I$t8vG% z@U642^XaNJhYS%0$<LhUHjhT%&UVqbi#Sl+NSp%p>;Z~q=YN2iN+Jf(|KvBpVSV55 z_a{zP6U9jIHX^eH)*5dGP^TCxf<SQt(U8cjksG+dZQAgp;_%1dO3o^lCroh*qEnlx zf?v4jpgJ|b8anUmgKnbwdNytL@>nfPZkx`B`v`_Td{py??`me8*yS90-CeJ&y@CFs zK$To$>Kuf{GsO3UWl&9f>cuD-`}dID52ZpmPW!kYn%?|3FImx)%ChN658wqtU#a-d z7O*Xy5xW4_W3i|#I;l)F>Ls1`ExWd8V<1x>+|I)hJ)?pdqGr-{%Y8>OnNV>aEj|>4 z3^zTBn0K1jFN3t_(p7z~Y<*=Jcte=@P4F;}Cha|o3<uj==$`>EgJznN=)CW&FUG<O zJbRq4zS|%Tf?_LhUk3yI-pDqOpZ56kiAJln#FRqX`m>LbeRoao{eRjc$Kc1_(`h5j SQR$Pm0<uFoAR4WF68;C1uWVNU diff --git a/docs/logos/xsdba-logo-small-light.png b/docs/logos/xsdba-logo-small-light.png index 0ecf126497d73c1601726474c5767634ff91f5ea..97ce2a37f19d437e6ab5e0e413f7f98a23692e73 100644 GIT binary patch delta 5570 zcmV;z6+P;L63Q!(7av^+1^@s6%5NHk00009a7bBm000Eo000Eo0j{r0K9M#je-&3r zL_t(|ob6qEbXDb*|LyOb`_2ssArOd^mp~FIQlrH@q&T&<j<e7{U>xh}j2$2K(bl3o zwPey!NJynp$2vZ$)=s-BSS?k2p*Dqt6g64|l92MM1tK6xNbdXIbN2jkPT<_jy}7TG zgjv(yT6g8#^X+f%@BHp}_TJy)f1D6ABU>zf;;m732hSy|a7#k63nEg~koVceUwVy! z><tVv?rrQGBgyItL0F(NhY8r?aQN2Ol$ZOm(Mx8K{qMhSys~i8xUI%>!9cLzE@6)S zkDEWPsi{%3HZn}OueE)=62Nl+O$1nGKqf#2uvb{<hBcorIhCnyk!|B@e;Xl_Eak*2 zV~f=l_~O?l*Vfi%ZD%;J?7g-kHNZ~;m=LFU4oCRq<<0xzm8FENNT_XujJ(4+f>cT* z!w_!o71vHX-w9vV*j6M(#1jA|B$FA_3F_<1cI=s!iH(d2sBLVNPdWBG10Io(=mAJV z%Jp4&{q*yd@VnpMGmd0Df5yzk$z+*%qG0Kb6)hc~P1jCF7hekqxZPIcxu5}|U@#a8 z1VYi4Xq4~EH_SZW2w$~*f1%AL{)-4ni8f#?6!ndzJ31=Tv6Xg!{PC-QTQVlM;K70K z%pkAd)8TUFlmNg$H}CWIdJf>2TaqQ+009K_clX`!<TvKOg!3Rvf4R4{bByd)9$~^H z0?Qzhh#@l|10=-+NC|+<%rX&a$6!AoRn}L{+?R?yIo$@@$s$}1r`>oitc0W-htp;} z7m0*IR<c<oImU#L@|W&tpVd%Vx)&oz_^Nk13goc*6Cx_kq7iNaHvm|eitvcs(t<_d zik6PqboNFVR;+B=f1R&{)CPbq$XXfU;#5UP%zv`VMa!G^&KYjPYa0*eL0IaDXrf6f z52PxXHrYZ5^KN~j2`gIK<_;I(wLACc`Yrx7V0^|5eFQL*_))6zY5VMB$Gd*h-E*Q9 z4oMD!BmtH}UjNL<*on6=gGg%y`GWp%pVDuagaC-ZAR+)lf97w80zNl05fKvubnBLu zC+V7s4MRD!U;5E;m!w2$0JDf@R+)ZKUoqqDRO_To_5<I#=qP}r-+S#f8%9sJxx!Y- z0oV%j3rmf1UZ1D`xO&<h8z6%|ztv{9N8Q4aaCqvn<~`+9HM?~v2w(c<M=s&A)Bwn6 zFcJ^U_+fo@f9cQCsgtqK{^`|M2ZQqINT&7Afhs01+unAm*)FBFwaY0vrTYmq)hwL^ z)YMg%txvaJRsr(y@^YU&;t6M?BdRfirYvjzXr5X6mb4sk_=DXmLFN%Hh<>!Ts`Mur z)y>v;&4MxyB4k<*7m%l|N^@iu4@+8(IIOB?DcIB=f4wGCqJa#2c08O8NB-Q^({(>H zTS*8~z*4~H6+Yp)idcX^#Kc5I2>5(TI2`HGLOFyW0*R9|B*&3yP$7gMs337q)4pvF zRbTsHa_i@!w(+ptBKwzs%=6Jgpngq7>BHIRFl9a)&<5l8w00I)!fFm!l|MOhB4^Cl zf)8T@e`J5p=_Bs^QPG15OGkTNVI(TRp8nMO7KLZ7UQ=1pl1@8n+uE$YQ}lh3Py&Vw zuna&3gfwtWAc@Z$Ls9{Gu;DtZ>V|cf&&s$*55TlR4Fmj8`HWLaKn<9tlknMP+xJza zDqp*)&Fbr+JBTpdtTqtnzs(>TFnI*Y0Iyq6e|B6#*l(6jBK4vb&7IZB<Z3syS^dT0 zHUegtWgDQU>Z(fW%+fX#!*zb3;-X`!U&(5{E=nOsE?%*%eSV_yCt6_%6w}Rsi9MR= z88e9nObU>3z$f3|{MX#E-~2s<EEBUJ5?}%`x<>~?eZ9;qKmd^-B@*&eH}(-gL?C7& zf6r-_N%72MW{HRdt32<{-|x8e(S?-{84cam+G-gca^1v?>1Ji<%y_P@YG%DT+RnnX z02vRpwGe?Xv`vMqj8Y|=L{Md$Yu9rQw}{FTdQU0sc?D8bfIM+1ztd_fj&cb>zyF}k zVgJ{<s<I{kSiA|+lnEU-5-=NjfCIA(e})VJDU$#R;Q6}B(se_@$B@qY)zm;eaB}Y< zlHfH<Cj*zS*x6aVcoU>4<J)f_pu{ZQ1iV;ZS=wNhzE}+T6zj%Ci<JFGI{rdx#5BU8 zC<~@dXuBQ2Ow)7{y--(Kx@IUR!-i!(d*h--%E4o09f}~2X-XMmOw$E=*|Bxwe~*WH zL(xzL$aAo95tQ1-t~Q^l9s{w3p-;yG6!xfro(N8Wab_OM9|$X|;{O!-oGq9s9P|al zp~x5#DzQQYA%O&uE60`j{0w1>bL;aB!?BTQNCRX%)HXKCKFj#IfSONWSqLF{z1}4b zhw}=foVVZG>2kZG0%U)0Uza;Cf7i-HU8M4HFiv{C-aeN*r!SKL$%MC@TQ?31(ZC2S zi`6Vx5b3phcBy2dOUVFCXmnPV4ja+H2(3XrUS1x~IjXh-=pPCD0Ja@Ex~HxN7}h<A zBevjMv#2cO$j7@FcEYLYz_H!yHZEGE46of0BpU!~%F05XUinYVY}x|Ee_&un%fVy2 z8%Ba?U<3kWJY4harlR6e<GyH-<xxbctg1p*z*P>X^UAYQM1F67kHeWGDT>m~;c$<_ z+~W`UJw?UEUC9C@gWkWSs&xG#U_^)phB5UU3|szf(I-n<j=X5){(m6mJQYF?dOTsf z!=7uD3kQQ9yVGuEA|jQ;e_;4!uQlmli3snOSC&3Jl0*X|>_&`OUvYuoVaxjiVBQiN z01)VaJ#=EjND~d5M`Qy)DBN43-}a_~iKqB2V=psPXQnuB$X>RiZLX@AHy?cl3<2gl zQ(1r*YMd7V^2cv}yv}8FEg*oHKwyYZeLbN(NA6f=CIAE?^muxMe>n~(f@-KQ5DxTv z!{O6?{!_k!i4%?`9YL}nmDESpRh4ZYsp}l^0J*BAv*ZHX=u5`r6kKXNuSC?&aqhw? zQNj`KDjYS&8bTx#R0F5`)j)uHk=jU<Ac*Pi<<0Hk`l`}DnRf-LV?^D^s-}(^fO_F@ z*&~8P;1$c8+egHQe~%d1D;wJ`R7o{$Uq|X7SrG0U3BpH&?4{fGO;Ig0CAs7ffk_6q z#*Cd;>0sCc<ee|K+$&^DnIIA%7GM%`P<*D)m0v&vfI-ZlkUtO_?HX-ofQXpDp#DI= zUvgOf7AD0P3Wozh3J1JFU)YtO>&b8pk{MV%Tt0kQ$zIa3f2&yaL|(BwopX)nJ^lUr zbKLGI-|h5SI!i}i7&V{W?dv&sP;@;-L=veitDrLv6J@dB8&M%v)>qAZf2gm2*xbku zwzrSB!ZvBR?4<!4psZWoyzi2sHZ&|`-}m;OaaLI}>lqf1z$Xzk@(X4%X(JHX0cHKl zogL-o=!=gbe<yp@_74kH8)yGimJVhd4|4CX8s^VA6b3&-!W_a0up@#E%bWKMSq~pF zpG~#3V$-CG#X-BZK!qZKBmsi7N2Y~vI*ULcFcUMV&*$?=c83dKEk+W^saU!%%$;fj zKn!gZ=?Qs0K9(b{TVHX(nZ1O|oA*s1@NEF+nz2cTf0)B6q`QW~hYuOqi=Tb9=plD* zmratQ&L8ae9GU9QiR$T(*hG6cH#cfWl+Wvb%jI@%QWe$-qn@zje!)oe0Pb(;ELK^) zLj~N~lMR^(0jTP&b=9+WnaRnJxRKhO`*U3`XOVdtsYmsNUyMgI06b7J<0uO}$;9St zS7zjZf25~YH0`~}6n#2OC%d+-EhnIc#+s#%h<lxmyx%rlHD}O8g0+{G99AXq7(iz2 z4|jvavt|-*D%nfl{KysP6XxwyQu(yQp8va=^6@DJ!G_PzJfu?OQDP37)B-n?_~m^& z_suawnJGS-7B7}=tXw!&npiyAVo@a#A=%sSe{p<Qwr{bL!~lVb2>_0Iecj{j&M}7V zz4Tj`<#52A`x$~^M^w=FPSLo@H>66m5i48TE@YLK0C1V{m<O1BvPHW7!Fe-3%8Dm5 z$iDscXTCgfy6bi0xqvUy?>jZyEyV=LD?UDc<YJd2DnK@>p+{N^3%3cOT_Bizc1PYD zf0+<HfP0!cW>^H@3uYIxBwK$4MlVb9qWa6Gw`ba>?B5Z!sm*GY98Mt!#t)JH5hCi7 z45X5`FTz{1AsPT4sxIjS^9B$?$)!_50V$D}mjCH5rO8F(BP+6RYi+dz#^<=Q(P0F$ z>I;t=z4g%rWu|ORtE(#83li%IFl%2*e*q$q&C9p#$%ycb$=(D=w#X<)ruAdNOg<%7 zd8c8{IP>;#1E{Mg+0D!i=4}MxLXyNQnGl}wJEGcJTW!fDQv)dob6)t54RZ!h?=nSQ z^{ib&<#k{(iEt_ul6Y-ZOJ`b7J)|8VZ`u6En{sk;@7C)Q2?4*i|AgJ{n9N`ze?6fH z1%jb(dxCZuLd!%*fSGA?An+5P%he?$mH^1a2#eF+t!r+&`ea%S$pA~6+U7}wl>}kS zAV9`@N7QjyRxf*S-t6P4*iU=G*9y77X17P>ooYncV|O~Eo)IUK`^N>@9XniiG5P}I z#~ue%84wZ08+^C!Yx9SsN5`U}f4XevsvRBm46M?I@>!!;iO6*TZc0UX#MU5*5LCUv zcax0_&BmI_k``uB4<b``ND<+R<Wd?&glv`&QgTMO4mZ&QsH>XMgb1$zan^)0a3WRN z^vNd5Y7|7oVV5QML$kAvbWu0IbQ>#J3(jssJTo3mRW@zE<q7+@M!M-ce*{G$k^}?^ zU!QjztEvwSVt|O5LP|*46%M_sgjh(DAcaUkRbh{aca~;3U@;5zmzTZ0az}>*Rb8FY z)4@dR>nlrsk+OKE!*%03qE2-kS}=OT*cXlE!9cLzX17*=Sth8mB0HF!?tLTOqvK&& zbNfFEU^NJql(P}ShPukqe;=k}C#!cv$*Mi2yj2m3!hOE;l4t-}S5^9|%Jcw0NnHv7 z493cIi3YL^kn1Zh@Y@}hL8mh%ArzNwT<1sy!&I@Zy5to=eSj&k4<~{G#`o%~OH=mK zMr8kvsPgf?FspG17eZF7-M)j_PAUx->MF}N6X8cp=k{<0hl%Lsf4a-d{wGuYrtD%3 zD&B+M{{Ej62`e!P28(bw63mnG4%hrsxoL0Ki3cK@4d6!o>mQi;jW{wl0~pu@RL{&k ziS(_lD1B*pbDIK))d2GJ(?>{%C2J~5c4XC7GZ%apZ`vfynmW~XIuzpd6%_#t!&`)j z=<5Jp(7!&&%=gEUf7uFP;9;mK%zQYR-jz+e^Px(gQ;35Rx$lGZ6&2aP9f+C#Pk#V> z9omn|03Jvnv(+Fod8FEU-aO{<{{ep|dl>O|vWF2v{!9%K6#^)RHUjGg@F_E=^}IR} zIRQ+D*4{2=Hf8Rchy;Kl0OO!NL;u%IR&<ES4PX)g8vvi)f5zT;vXcO`0C*q3djKv< z5|GLOysOLa1TZa*%qRd40yvDbfywwe3E(#X{yB-QX#h3?@W<5u5WtO@21o!F0QUj- zYmDAg05$*^m84x(XxYuf0QSYXK1FZi9RRFn>gko28U#B4<RmcS1hCs6dw&9g5|JGH z*)zxmT?xRGf297C8IU~-KywnkhoPm2iQ0BUir2@wtpX$21YnCn;Fk%EJZX@53xJ3t z(`1m@1>kM~R{)p`pj;<sEr7j=$cFZ!EhEvb0KTQyuL7_dK(Ai*cA8|rqyOCx;C29) z0=P_X=TU=PCje&>vOm(V<r@I1_4X|U&;ZS44(Qr)e}-&b!59F4GYH%iW8hy5WuE{j ziqnV^gG>vwS+c=y$2kek|G}VVQ#?J;Muc54y(ks32ikVd-K%rZW{_K(K;K*d^O9U! zF@Sc1uKBS7mqXiQ!2rAf%JlQo0rcUlKe{S`frSR;s|IV#AdUQ-K}Qz=_aL&@W<a(d zgS&`}fAwo*06mF%cZ%0iZLs@zRO-jf+X4KC{?!TKc_PXO@H_ywe!iZW-$Z;ECvYYu zkV%F`hT|uAkj#adH$!s=>EK0XJ~W8V51`#yfHpUBRhs&ZXolua0AOCc)Nd_-1<(T2 zY-j;-;QwwlL-Uu3@By@5Apy9Vh)x1{gqc%Xf9fA-l;QZCNu@Y=9l%{_=ubuGYXH7z zXwUBw2@;VEEym1%mW5ekL<UmHiHW-ZIGpPbPXU;i!maaoOg#l!N?8x!D*)_C>K`!F z%}>GJ?MTm!T#|y$s}1tMNgy*8z#{-Yjk(@LpU7Yam&FL*nxdbwLd!qH35<H6&C*pQ zf2cpucol$@g1zh0Bzt-aIxjQGzY(YWA^^wZT-#}AY2$~`#v$*+I7UcdY+{^W>;nL{ zG=f91-s@h6Had%Km<nJ;oO;HKu%uw;n`x3=l7dcSVA~R>GZ_amzXLEo5jW6MNCv>? z%#G+i=+^)W^izHM-_JqIA5#J|A7$ppf0+3z0P>+_I{yhRmj$%kek~DQ9#hpg%q>82 z6sFpyG;|uDp6HG#yBcTTKL0W^U&qYbIPudC`2z>>CZcMg{jz{|8(a*{Ujx8hM08yW zjg0~`N0_;ZnO8#_VQw)L-xwoq+-#o8;}z*X^OB0ZQ6_ftyYX!f&km-9h$g`Bf5VBG z!Y=_>p?~cIa6L000Pt;Sw*mopnus#~|6F<xFuvVA_U#PD|K2g^4@*QA0N141glkif z`KsYKb}201aGY!(`8T4z8GK6-w2|R}FS<U)_dIMUYetgMVH(l?g*fpdqL=vqOd3Sb z_YoZjQt{a;fXYF1UT2U!gqSG_e`u-kK>0Z_#~?Qbu^F9SAYvNyM4ZZ2Xl`XdW=$NK z?*Vue!0bU9kqfQ&4(Pcnj?B*u<$ne+A&$&K00E>=HUl^UeRLcnHxJQs8n?uexyDf5 zgE#?K?=bHfe%vUs?=vXajl>f$7eY&K7;%Q}&|J`fo(=#{>*sC-upHV%e^!q{rahi5 z0HYC|Z}$Rt48V5*+zV~cq3UgTEKRZ>#o1x|bI|UNyP-|x8q?L+pf8BW=#rpKunous zq51B6bUn}E>?GQYIu8S~s7CaB$gCtTz?j!YO-SiP#HM(OJ}m%>2eC65+RR|0`T+np zBmF7XDFA+&q-`%J>Trfme|Ip6j?K`fIL=H)5r8|Pb$bA4V&+$n1VnTP&i)h29nAcD zLs=QL;r<t(Wgg?9jkbLHkMkb1Ui32SEg!^=4ZwGx{lGH;*rCl#z60QA%)C3(eIt4@ za0@ioQ3TC>{29PA%)BuL4n{${)4mEV6_oYs`vAbN0KCM^OhorU7*9|C7lUTZ<ca0F QWB>pF07*qoM6N<$g1fhN5C8xG literal 2306 zcmd^>`9Bj51IIUGuE-U0mxyvES1fDH6(h&woXBlht_@%3SC_9jl17dphS654hg_pl zi!^F-GmU%+L&#Mg&)@O<@cz7CulHZ@xp&pkMnp(X2mk<x*x4dnj_iFzh5-0zX@&0w zk0gk-^^64ofY1I1(7#wi^eD>4S$V{{MhC~?{9}RuI2=wVEGi=QhCen)CpspibQLNG z00`vSA>eNKvX${<Owqhz_d1uG!VF7x?C-M@<K-3Cuzc{AqFQOMSYLXxPrtOvzAV<U zZi3|-K0&a1)N9vLg3*b3tuutbC#IYA)P&$jc8Oz<1#0iu&#TA?5?y9rENuVTwsAT! z?y50pKFi=18Z0Kx{4`G_MU%R?ix*Fz)QICP0Yw?SL~F}go9{^ZL+4NGTNYd1gqd~d zE2!o75qgPv(9aLKKNH#W<E>ajf3@P%SBD?kAv+h!aa~ybzek!vJ6tP;g2>AF{_yE> zy)BlbG2L#YsPkXnD6!eEpv8wLPv?vkOm=FEsf;J!KOK0^^Cz2Ox3bC6!h4o(|5&L~ zuAH~HvQBLxIZOZeSu&Rqr8)6SL$cU+={UrYrR+g{-Fro^Ff=ZFD%l&n9X$Bx_Es!! z=aUK1DwbsVXa0q9Vq33c4IY!WH^_I{!K&rX`f-hB$<0N4M`YMk-@Bgoa!<dnkZDzu z_ajKvPA8D0%>d={<mpA}eeW-!ov~gYlEezqPgU$Vi-R+b-?}P35Xx*^ayJxZ8hQ-$ zks}0>1hlnwvG3d37vO^<g$$XC(fR3JYqLLFx|E|USY*ND!x|KESQ+GM%%{DOH?;#y zH$#k4!W{6W2*K~nU}>z#8AfyH5~p4IntSlxU*N==x=}4^)5om8SK1LC>I^wL8~a>2 ze1^6ZX&>}jmh`q0)j#3@Y)!M`oXDOmjy*X{6n1UrmR@r%SgpG_M~I?Xw|TWbT66#E zV{#pfc}bz8R4<U9#3QtBhT6(fm<<dIIMw<Eq!v=3LFv7Go+2_&bgJ+c4B5<HWpVme z<7_TA%+?OY!`s$+9ZWaq+YiMF@N?soKI;=SmTPb$`18u;d4g>cQ&)R4B)7fUY*>57 zg{2fmxBAisxC;zA*DO9vsHe&}Rg<Wg&EK{goZW;)6EE5g5UXPxPes(D{IgUFoe9bK zfei2f>78`|f41mh0z5I1qRceYRs5wNQ?vX0Omv}Gnp7Z3LsCpvuJRVi9Bz=#J}X>4 zA^2n&_GB+`@A6r%QS!a7JZB+AgNS~0ct;{Ge1^<)H)?P@<N9ljNXBsKUp_f?qQ_7o zrFUM2d?RM5{RJ<O64kk%Ib?<QcLws!KCaMk@e<omZbFNj)iIey%&qXC!vh%7GV?_g zU}~We7Elih?Z3O`$=O!(_8U8^OheXQD0m!|PwBm@;8L`|6!KstPA{(mJ6ZJm^Znrk zC+MU(lIMQv<@{5&WVLeVT3-aNPX9o5r)DC95|S*TRgdlpc1tV6o0|qNQ?7lLaw?jG z(IUgVH#nWzZ|Ku<x;$VmvPIz_dg8X(HfAP1`gcxq`Kh8?Dhf+U9p~PtDI^7~%17Az znmD#$oA>NT0Mk!@XL7}uswo=nE2Hf(vYLoYtxQfI&NfiWQ9_&2VqzrNJ(^vunzl7c zLkd04)-{(7$6hrWk=A=+-%-80pl%SdwGbzdj{fF^f2A4&cNTLn)s%d&SK;0w)yrMn z+n{!RtIk8bRBGdw@eedD!T)ifhb6Sb-D#K(2mP4%`ug~4F8_kllwbZ`u!L;MM+3E6 zzWvoib3Iz7(xHBn@3aZp5}L)(JDJ2%H>_B;RqynqHx{?H(A5)6m;TrhuJFC4eU1e6 zNvvmlQGda=;P;n?^B-0><MDf8k+rM6bI5aleB6%XW*Q|Au6}P!!R_tVdM^j+cd{&_ zwxFK63<_a((67bnU@0`5oBUpQsv*_d^H`OTLF%TGr}$e}-OYi91yUL9`HyaU0|RX# zw`ezuYc{TCXjqAHQR;f|a&?Z(0rI*AFq#X4&?9@|=hr#PySprovLP(x#>&6>%(0;Y zwTK0R;za64I06ldavgr6vT+XEPKg56`;M7Z<oLA0B>WP{^pF?}E@9K;E(6T=LQScv zoM)S&rtp2Bv`<-x8Xia^B@Yy+oaa2OjtEr18tX}nf)CIr+&x>twF_)0dr^UtD_Jm+ z5x{mv`H~cq&tNa<K|J`NWXgxsvYD`6&@>;#YEDjERs>oy1%4_u$_p)<a=$;-1%dEF z!IQ`0Qhpx*)+C<F;gJZ_!{7dxgpW2E{pq_Yu-Y#k+xq%NxkdY;Yrd$J$u9X~k*wTN zBct|94^n)1UVu2y^KNu+*+38N*!wn69Z)cjF;L#Lg(T>QHrm<m=I_R`*H5QP8v|iH z3HKO<D*9Qu_I>UsWJum6-sQ!O3z*f7-=T|7Av++fnx3G^k3ebLt_=WUF8De`k(m9e z+zho9k17{*;I-)P>~>`Ph_63?FAcJ6&q+oTxiB7U5V2wDnp?ciT3%|&P?(mgie!3H zCC?~-lSDxpNHfEW9aJd-;W@BJ!K4a~rzeRg-p-W|9XX6?^FwR{Iq8k*B!FNg0ufco zF|MN0)p2ctK;q|{<<rMbs?6}}@K5u4WwZl;(!eyP(l3!p@D6ZIVUSmWvAQoj2yo*O zzy6T2I*@xwen&}hHX`H49xkblXr5RenY55)?rU84F2F4CnPT&(s3+!*)_*LeCr<sd ilHZ%a`2WmRhoGL|uk)<}XrH710<g1kL{KfRXZ{zy{#gkC From 9b55d7d6256d895b8f776b8b571f536a6b287011 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 12:37:29 -0400 Subject: [PATCH 043/105] notebooks added --- docs/notebooks/advanced_example.ipynb | 4051 +++++++++++++++++++++++++ docs/notebooks/example.ipynb | 1801 +++++++++++ docs/xsdba.rst | 144 + environment-dev.yml | 4 +- src/xsdba/__init__.py | 1 + src/xsdba/_adjustment.py | 4 +- src/xsdba/_processing.py | 4 +- src/xsdba/adjustment.py | 79 +- src/xsdba/base.py | 55 +- src/xsdba/calendar.py | 3 +- src/xsdba/measures.py | 1 - src/xsdba/options.py | 12 +- src/xsdba/processing.py | 3 +- src/xsdba/properties.py | 16 +- src/xsdba/units.py | 30 +- src/xsdba/utils.py | 2 +- tests/test_adjustment.py | 2 +- 17 files changed, 6144 insertions(+), 68 deletions(-) create mode 100644 docs/notebooks/advanced_example.ipynb create mode 100644 docs/notebooks/example.ipynb create mode 100644 docs/xsdba.rst diff --git a/docs/notebooks/advanced_example.ipynb b/docs/notebooks/advanced_example.ipynb new file mode 100644 index 0000000..763e88c --- /dev/null +++ b/docs/notebooks/advanced_example.ipynb @@ -0,0 +1,4051 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "title: Statistical Downscaling and Bias-Adjustment - Advanced tools\n", + "---\n", + "\n", + "\n", + "The previous notebook covered the most common utilities of `xsdba` for conventional cases. Here, we explore more advanced usage of `xsdba` tools.\n", + "\n", + "## Optimization with dask\n", + "\n", + "Adjustment processes can be very heavy when we need to compute them over large regions and long timeseries. Using small groupings (like `time.dayofyear`) adds precision and robustness, but also decouples the load and computing complexity. Fortunately, unlike the heroic pioneers of scientific computing who managed to write parallelized FORTRAN, we now have [dask](https://dask.org/). With only a few parameters, we can magically distribute the computing load to multiple workers and threads.\n", + "\n", + "A good first read on the use of dask within xarray are the latter's [Optimization tips](https://xarray.pydata.org/en/stable/user-guide/dask.html#optimization-tips).\n", + "\n", + "Some `xsdba`-specific tips:\n", + "\n", + "* Most adjustment method will need to perform operation on the whole `time` coordinate, so it is best to optimize chunking along the other dimensions. This is often different from how public data is shared, where more universal 3D chunks are used.\n", + "\n", + " Chunking of outputs can be controlled in xarray's [to_netcdf](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.to_netcdf.html?highlight=to_netcdf#xarray.Dataset.to_netcdf). We also suggest using [Zarr](https://zarr.readthedocs.io/en/stable/) files. According to [its creators](https://ui.adsabs.harvard.edu/abs/2018AGUFMIN33A..06A/abstract), `zarr` stores should give better performances, especially because of their better ability for parallel I/O. See [Dataset.to_zarr](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.to_zarr.html?highlight=to_zarr#xarray.Dataset.to_zarr) and this useful [rechunking package](https://rechunker.readthedocs.io).\n", + "\n", + "\n", + "<!-- FIXME : Do we leave the mention of xclim-0.27 as-is, give more context? -->\n", + "* One of the main bottleneck for adjustments with small groups is that dask needs to build and optimize an enormous task graph. This issue has been greatly reduced with `xclim` 0.27 and the use of `map_blocks` in the adjustment methods. However, not all adjustment methods use this optimized syntax.\n", + "\n", + " In order to help dask, one can split the processing in parts. For splitting training and adjustment, see [the section below](#Initializing-an-Adjustment-object-from-a-training-dataset).\n", + "\n", + "\n", + "* Another massive bottleneck of parallelization of `xarray` is the thread-locking behaviour of some methods. It is quite difficult to isolate and avoid these locking instances, so one of the best workarounds is to use `dask` configurations with many _processes_ and few _threads_. The former do not share memory and thus are not impacted when a lock is activated from a thread in another worker. However, this adds many memory transfer operations and, by experience, reduces dask's ability to parallelize some pipelines. Such a dask Client is usually created with a large `n_workers` and a small `threads_per_worker`.\n", + "\n", + "\n", + "* Sometimes, datasets have auxiliary coordinates (for example : lat / lon in a rotated pole dataset). Xarray handles these variables as data variables and will **not** load them if dask is used. However, in some operations, `xsdba` or `xarray` will trigger access to those variables, triggering computations each time, since they are `dask`-based. To avoid this behaviour, one can load the coordinates, or simply remove them from the inputs.\n", + "\n", + "\n", + "## LOESS smoothing and detrending\n", + "\n", + "As described in Cleveland (1979), locally weighted linear regressions are multiple regression methods using a nearest-neighbour approach. Instead of using all data points to compute a linear or polynomial regression, LOESS algorithms compute a local regression for each point in the dataset, using only the k-nearest neighbours as selected by a weighting function. This weighting function must fulfill some strict requirements, see the doc of `xsdba.loess.loess_smoothing` for more details.\n", + "\n", + "In `xsdba`'s implementation, the user can choose between local _constancy_ ($d=0$, local estimates are weighted averages) and local _linearity_ ($d=1$, local estimates are taken from linear regressions). Two weighting functions are currently implemented : \"tricube\" ($w(x) = (1 - x^3)^3$) and \"gaussian\" ($w(x) = e^{-x^2 / 2\\sigma^2}$). Finally, the number of Cleveland's _robustifying iterations_ is controllable through `niter`. After computing an estimate of $y(x)$, the weights are modulated by a function of the distance between the estimate and the points and the procedure is started over. These iterations are made to weaken the effect of outliers on the estimate.\n", + "\n", + "The next example shows the application of the LOESS to daily temperature data. The black line and dot are the estimated $y$, outputs of the `xsdba.loess.loess_smoothing` function, using local linear regression (passing $d = 1$), a window spanning 20% ($f = 0.2$) of the domain, the \"tricube\" weighting function and only one iteration. The red curve illustrates the weighting function on January 1st 2014, where the red circles are the nearest-neighbours used in the estimation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import nc_time_axis\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "from xsdba import loess\n", + "\n", + "%matplotlib inline\n", + "plt.style.use(\"seaborn-v0_8\")\n", + "plt.rcParams[\"figure.figsize\"] = (11, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Daily temperature data from xarray's tutorials\n", + "ds = xr.tutorial.open_dataset(\"air_temperature\").resample(time=\"D\").mean()\n", + "tas = ds.isel(lat=0, lon=0).air\n", + "\n", + "# Compute the smoothed series\n", + "f = 0.2\n", + "ys = loess.loess_smoothing(tas, d=1, weights=\"tricube\", f=f, niter=1)\n", + "\n", + "# Plot data points and smoothed series\n", + "fig, ax = plt.subplots()\n", + "ax.plot(tas.time, tas, \"o\", fillstyle=\"none\")\n", + "ax.plot(tas.time, ys, \"k\")\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Temperature [K]\")\n", + "\n", + "## The code below calls internal functions to demonstrate how the weights are computed.\n", + "\n", + "# LOESS algorithms as implemented here use scaled coordinates.\n", + "x = tas.time\n", + "x = (x - x[0]) / (x[-1] - x[0])\n", + "xi = x[366]\n", + "ti = tas.time[366]\n", + "\n", + "# Weighting function take the distance with all neighbors scaled by the r parameter as input\n", + "r = int(f * tas.time.size)\n", + "h = np.sort(np.abs(x - xi))[r]\n", + "weights = loess._tricube_weighting(np.abs(x - xi).values / h)\n", + "\n", + "# Plot nearest neighbors and weighing function\n", + "wax = ax.twinx()\n", + "wax.plot(tas.time, weights, color=\"indianred\")\n", + "ax.plot(\n", + " tas.time, tas.where(tas * weights > 0), \"o\", color=\"lightcoral\", alpha=0.5\n", + ")\n", + "\n", + "ax.plot(ti, ys[366], \"ko\")\n", + "wax.set_ylabel(\"Weights\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "LOESS smoothing can suffer from heavy boundary effects. On the previous graph, we can associate the strange bend on the left end of the line to them. The next example shows a stronger case. Usually, $\\frac{f}{2}N$ points on each side should be discarded. On the other hand, LOESS has the advantage of always staying within the bounds of the data.\n", + "\n", + "\n", + "### LOESS Detrending\n", + "\n", + "In climate science, it can be used in the detrending process. `xsdba` provides `xsdba.detrending.LoessDetrend` in order to compute trend with the LOESS smoothing and remove them from timeseries.\n", + "\n", + "First we create some toy data with a sinusoidal annual cycle, random noise and a linear temperature increase." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x7fb64fd07f50>]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "time = xr.cftime_range(\"1990-01-01\", \"2049-12-31\", calendar=\"noleap\")\n", + "tas = xr.DataArray(\n", + " (\n", + " 10 * np.sin(time.dayofyear * 2 * np.pi / 365)\n", + " + 5 * (np.random.random_sample(time.size) - 0.5) # Annual variability\n", + " + np.linspace(0, 1.5, num=time.size) # Random noise\n", + " ), # 1.5 degC increase in 60 years\n", + " dims=(\"time\",),\n", + " coords={\"time\": time},\n", + " attrs={\"units\": \"degC\"},\n", + " name=\"temperature\",\n", + ")\n", + "tas.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we compute the trend on the data. Here, we compute on the whole timeseries (`group='time'`) with the parameters suggested above." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from xsdba.detrending import LoessDetrend\n", + "\n", + "# Create the detrending object\n", + "det = LoessDetrend(group=\"time\", d=0, niter=2, f=0.2)\n", + "# Fitting returns a new object and computes the trend.\n", + "fit = det.fit(tas)\n", + "# Get the detrended series\n", + "tas_det = fit.detrend(tas)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fb65048e310>" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "fit.ds.trend.plot(ax=ax, label=\"Computed trend\")\n", + "ax.plot(time, np.linspace(0, 1.5, num=time.size), label=\"Expected tred\")\n", + "ax.plot([time[0], time[int(0.1 * time.size)]], [0.4, 0.4], linewidth=6, color=\"gray\")\n", + "ax.plot([time[-int(0.1 * time.size)], time[-1]], [1.1, 1.1], linewidth=6, color=\"gray\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As said earlier, this example shows how the Loess has strong boundary effects. It is recommended to remove the $\\frac{f}{2}\\cdot N$ outermost points on each side, as shown by the gray bars in the graph above.\n", + "\n", + "## Initializing an Adjustment object from a training dataset\n", + "\n", + "For large scale uses, when the training step deserves its own computation and write to disk, or simply when there are multiples `sim` to be adjusted with the same training, it is helpful to be able to instantiate the Adjustment objects from the training dataset itself. This trick relies on a global attribute \"adj_params\" set on the training dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "# Create toy data for the example, here fake temperature timeseries\n", + "t = xr.cftime_range(\"2000-01-01\", \"2030-12-31\", freq=\"D\", calendar=\"noleap\")\n", + "ref = xr.DataArray(\n", + " (\n", + " -20 * np.cos(2 * np.pi * t.dayofyear / 365)\n", + " + 2 * np.random.random_sample((t.size,))\n", + " + 273.15\n", + " + 0.1 * (t - t[0]).days / 365\n", + " ), # \"warming\" of 1K per decade,\n", + " dims=(\"time\",),\n", + " coords={\"time\": t},\n", + " attrs={\"units\": \"K\"},\n", + ")\n", + "sim = xr.DataArray(\n", + " (\n", + " -18 * np.cos(2 * np.pi * t.dayofyear / 365)\n", + " + 2 * np.random.random_sample((t.size,))\n", + " + 273.15\n", + " + 0.11 * (t - t[0]).days / 365\n", + " ), # \"warming\" of 1.1K per decade\n", + " dims=(\"time\",),\n", + " coords={\"time\": t},\n", + " attrs={\"units\": \"K\"},\n", + ")\n", + "\n", + "ref = ref.sel(time=slice(None, \"2015-01-01\"))\n", + "hist = sim.sel(time=slice(None, \"2015-01-01\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from xsdba.adjustment import QuantileDeltaMapping\n", + "\n", + "QDM = QuantileDeltaMapping.train(\n", + " ref, hist, nquantiles=15, kind=\"+\", group=\"time.dayofyear\"\n", + ")\n", + "QDM" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The trained `QDM` exposes the training data in the `ds` attribute, Here, we will write it to disk, read it back and initialize a new object from it. Notice the `adj_params` in the dataset, that has the same value as the repr string printed just above. Also, notice the `_xsdba_adjustment` attribute that contains a JSON string, so we can rebuild the adjustment object later." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.Dataset> Size: 91kB\n", + "Dimensions: (dayofyear: 365, quantiles: 15)\n", + "Coordinates:\n", + " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", + " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", + "Data variables:\n", + " af (dayofyear, quantiles) float64 44kB -1.268 -1.415 ... -2.264\n", + " hist_q (dayofyear, quantiles) float64 44kB 255.7 255.9 ... 258.0 258.5\n", + "Attributes:\n", + " group: time.dayofyear\n", + " group_compute_dims: ['time']\n", + " group_window: 1\n", + " _xsdba_adjustment: {"py/object": "xsdba.adjustment.QuantileDeltaMapping...\n", + " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-95c4f86f-361b-436e-9d81-0203d0f586dd' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-95c4f86f-361b-436e-9d81-0203d0f586dd' class='xr-section-summary' title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>dayofyear</span>: 365</li><li><span class='xr-has-index'>quantiles</span>: 15</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-fd589716-69c9-444b-8dc9-7f3e982d2761' class='xr-section-summary-in' type='checkbox' checked><label for='section-fd589716-69c9-444b-8dc9-7f3e982d2761' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>quantiles</span></div><div class='xr-var-dims'>(quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.03333 0.1 0.1667 ... 0.9 0.9667</div><input id='attrs-4aa06cfa-23ac-42e1-b6ed-95e12a0b2dd9' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-4aa06cfa-23ac-42e1-b6ed-95e12a0b2dd9' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-9885f047-4210-419f-b306-4d0bfa1dbe7e' class='xr-var-data-in' type='checkbox'><label for='data-9885f047-4210-419f-b306-4d0bfa1dbe7e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0.033333, 0.1 , 0.166667, 0.233333, 0.3 , 0.366667, 0.433333,\n", + " 0.5 , 0.566667, 0.633333, 0.7 , 0.766667, 0.833333, 0.9 ,\n", + " 0.966667])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>dayofyear</span></div><div class='xr-var-dims'>(dayofyear)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>1 2 3 4 5 6 ... 361 362 363 364 365</div><input id='attrs-b2689114-2efa-494c-a607-787bd2433284' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-b2689114-2efa-494c-a607-787bd2433284' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-3bb6ccd4-5a39-4fd2-8f53-7b8f9e3f9a6f' class='xr-var-data-in' type='checkbox'><label for='data-3bb6ccd4-5a39-4fd2-8f53-7b8f9e3f9a6f' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([ 1, 2, 3, ..., 363, 364, 365])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-8aa69c1e-a642-423a-b3b9-4872b068ab2e' class='xr-section-summary-in' type='checkbox' checked><label for='section-8aa69c1e-a642-423a-b3b9-4872b068ab2e' class='xr-section-summary' >Data variables: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>af</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>-1.268 -1.415 ... -2.124 -2.264</div><input id='attrs-3e92b834-9e2e-46c0-856b-bc788938fb5b' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-3e92b834-9e2e-46c0-856b-bc788938fb5b' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5fb147d5-7822-49be-bf45-ab9d6e93201d' class='xr-var-data-in' type='checkbox'><label for='data-5fb147d5-7822-49be-bf45-ab9d6e93201d' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>kind :</span></dt><dd>+</dd><dt><span>standard_name :</span></dt><dd>Adjustment factors</dd><dt><span>long_name :</span></dt><dd>Quantile mapping adjustment factors</dd></dl></div><div class='xr-var-data'><pre>array([[-1.26832691, -1.41518655, -1.44204209, ..., -1.90328231,\n", + " -1.97066107, -1.85047499],\n", + " [-2.13704007, -2.01513061, -1.89020114, ..., -1.9872316 ,\n", + " -1.84895748, -2.04778983],\n", + " [-2.05817452, -1.81650395, -1.75835219, ..., -2.32130962,\n", + " -2.05641772, -1.81242664],\n", + " ...,\n", + " [-1.95317141, -1.72661366, -1.67899876, ..., -1.69008412,\n", + " -1.7302959 , -1.9684894 ],\n", + " [-2.019817 , -1.72668539, -1.83673473, ..., -1.91127378,\n", + " -1.94020205, -1.75210557],\n", + " [-2.08251803, -2.44522864, -2.54127462, ..., -2.24160337,\n", + " -2.12437576, -2.2639624 ]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>hist_q</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>255.7 255.9 256.0 ... 258.0 258.5</div><input id='attrs-bf0e2c67-522f-44b2-bbdb-b6e7269bfe89' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-bf0e2c67-522f-44b2-bbdb-b6e7269bfe89' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-6637d6c7-777b-4718-96c0-90eccfa33e9d' class='xr-var-data-in' type='checkbox'><label for='data-6637d6c7-777b-4718-96c0-90eccfa33e9d' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>standard_name :</span></dt><dd>Model quantiles</dd><dt><span>long_name :</span></dt><dd>Quantiles of model on the reference period</dd></dl></div><div class='xr-var-data'><pre>array([[255.67497958, 255.86005355, 256.02935583, ..., 257.71220364,\n", + " 258.01227461, 258.28494627],\n", + " [255.85419559, 255.90780006, 256.03424744, ..., 257.32803683,\n", + " 257.45219506, 257.78927464],\n", + " [255.89059763, 256.25185479, 256.3157335 , ..., 258.06054282,\n", + " 258.1273541 , 258.1657027 ],\n", + " ...,\n", + " [255.56861177, 255.77899691, 256.02006814, ..., 257.48606473,\n", + " 257.60476301, 258.00044466],\n", + " [255.72623318, 255.80485509, 256.03708454, ..., 257.74902934,\n", + " 257.94442519, 257.98805055],\n", + " [255.67890484, 256.38863543, 256.77258908, ..., 257.73262335,\n", + " 257.99645326, 258.4576744 ]])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-d68164e7-fa25-4d84-83c8-022533396393' class='xr-section-summary-in' type='checkbox' ><label for='section-d68164e7-fa25-4d84-83c8-022533396393' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>quantiles</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-b560b2f1-7fb8-4749-956f-246bd3314d5e' class='xr-index-data-in' type='checkbox'/><label for='index-b560b2f1-7fb8-4749-956f-246bd3314d5e' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0.03333333333333333, 0.1, 0.16666666666666666,\n", + " 0.23333333333333334, 0.3, 0.36666666666666664,\n", + " 0.43333333333333335, 0.5, 0.5666666666666667,\n", + " 0.6333333333333333, 0.7, 0.7666666666666666,\n", + " 0.8333333333333334, 0.9, 0.9666666666666667],\n", + " dtype='float64', name='quantiles'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>dayofyear</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-8c6e8635-5349-48cd-81c6-c07b3d815fc0' class='xr-index-data-in' type='checkbox'/><label for='index-8c6e8635-5349-48cd-81c6-c07b3d815fc0' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\n", + " ...\n", + " 356, 357, 358, 359, 360, 361, 362, 363, 364, 365],\n", + " dtype='int64', name='dayofyear', length=365))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-1dd0d572-1bea-4f49-96c0-ca27b0cbe9fd' class='xr-section-summary-in' type='checkbox' checked><label for='section-1dd0d572-1bea-4f49-96c0-ca27b0cbe9fd' class='xr-section-summary' >Attributes: <span>(5)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>group :</span></dt><dd>time.dayofyear</dd><dt><span>group_compute_dims :</span></dt><dd>['time']</dd><dt><span>group_window :</span></dt><dd>1</dd><dt><span>_xsdba_adjustment :</span></dt><dd>{"py/object": "xsdba.adjustment.QuantileDeltaMapping", "py/state": {"hist_calendar": "noleap", "train_units": "K", "group": {"py/object": "xsdba.base.Grouper", "py/state": {"dim": "time", "add_dims": [], "prop": "dayofyear", "name": "time.dayofyear", "window": 1}}, "kind": "+"}}</dd><dt><span>adj_params :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.Dataset> Size: 91kB\n", + "Dimensions: (dayofyear: 365, quantiles: 15)\n", + "Coordinates:\n", + " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", + " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", + "Data variables:\n", + " af (dayofyear, quantiles) float64 44kB -1.268 -1.415 ... -2.264\n", + " hist_q (dayofyear, quantiles) float64 44kB 255.7 255.9 ... 258.0 258.5\n", + "Attributes:\n", + " group: time.dayofyear\n", + " group_compute_dims: ['time']\n", + " group_window: 1\n", + " _xsdba_adjustment: {\"py/object\": \"xsdba.adjustment.QuantileDeltaMapping...\n", + " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy..." + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "QDM.ds" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The engine keyword is only needed if netCDF4 is not available\n", + "# FIXME: Error when using h5netcdf\n", + "# QDM.ds.to_netcdf(\"QDM_training.nc\", engine=\"h5netcdf\")\n", + "! rm \"QDM_training.nc\"\n", + "QDM.ds.to_netcdf(\"QDM_training.nc\")\n", + "ds = xr.open_dataset(\"QDM_training.nc\")\n", + "QDM2 = QuantileDeltaMapping.from_dataset(ds)\n", + "QDM2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the case above, creating a full object from the dataset doesn't make the most sense since we are in the same python session, with the \"old\" object still available. This method effective when we reload the training data in a different python session, say on another computer. **However, take note that there is no retro-compatibility insurance.** If the `QuantileDeltaMapping` class was to change in a new `xsdba` version, one would not be able to create the new object from a dataset saved with the old one.\n", + "\n", + "For the case where we stay in the same python session, it is still useful to trigger the dask computations. For small datasets, that could mean a simple `QDM.ds.load()`, but sometimes even the training data is too large to be full loaded in memory. In that case, we could also do:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.Dataset> Size: 91kB\n", + "Dimensions: (dayofyear: 365, quantiles: 15)\n", + "Coordinates:\n", + " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", + " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", + "Data variables:\n", + " af (dayofyear, quantiles) float64 44kB ...\n", + " hist_q (dayofyear, quantiles) float64 44kB ...\n", + "Attributes:\n", + " group: time.dayofyear\n", + " group_compute_dims: time\n", + " group_window: 1\n", + " _xsdba_adjustment: {"py/object": "xsdba.adjustment.QuantileDeltaMapping...\n", + " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy...\n", + " title: This is the dataset, but read from disk.</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-bcddec80-a100-4cb3-9daa-37f0d3c4ab85' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-bcddec80-a100-4cb3-9daa-37f0d3c4ab85' class='xr-section-summary' title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>dayofyear</span>: 365</li><li><span class='xr-has-index'>quantiles</span>: 15</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-d3ab478b-ace6-40d2-b382-01bfae7f6d82' class='xr-section-summary-in' type='checkbox' checked><label for='section-d3ab478b-ace6-40d2-b382-01bfae7f6d82' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>quantiles</span></div><div class='xr-var-dims'>(quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.03333 0.1 0.1667 ... 0.9 0.9667</div><input id='attrs-5062dbfe-74af-4bbf-b50c-ea247855a579' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-5062dbfe-74af-4bbf-b50c-ea247855a579' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5637ca09-2f50-409d-9cb9-073ba9aaee69' class='xr-var-data-in' type='checkbox'><label for='data-5637ca09-2f50-409d-9cb9-073ba9aaee69' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0.033333, 0.1 , 0.166667, 0.233333, 0.3 , 0.366667, 0.433333,\n", + " 0.5 , 0.566667, 0.633333, 0.7 , 0.766667, 0.833333, 0.9 ,\n", + " 0.966667])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>dayofyear</span></div><div class='xr-var-dims'>(dayofyear)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>1 2 3 4 5 6 ... 361 362 363 364 365</div><input id='attrs-826abb8d-59b1-4eab-a3d4-746880075ca0' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-826abb8d-59b1-4eab-a3d4-746880075ca0' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d6e891f5-7994-44a6-bbe3-1c0b4d7685a7' class='xr-var-data-in' type='checkbox'><label for='data-d6e891f5-7994-44a6-bbe3-1c0b4d7685a7' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([ 1, 2, 3, ..., 363, 364, 365])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-d3960897-2f86-4b25-9f6c-5f1da9d6c26a' class='xr-section-summary-in' type='checkbox' checked><label for='section-d3960897-2f86-4b25-9f6c-5f1da9d6c26a' class='xr-section-summary' >Data variables: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>af</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-b8c2f7da-fc20-4dc4-85e2-8523309e2de2' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-b8c2f7da-fc20-4dc4-85e2-8523309e2de2' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d815973f-95ae-4b62-9bda-1610c99bdb15' class='xr-var-data-in' type='checkbox'><label for='data-d815973f-95ae-4b62-9bda-1610c99bdb15' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>kind :</span></dt><dd>+</dd><dt><span>standard_name :</span></dt><dd>Adjustment factors</dd><dt><span>long_name :</span></dt><dd>Quantile mapping adjustment factors</dd></dl></div><div class='xr-var-data'><pre>[5475 values with dtype=float64]</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>hist_q</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-1cfaf071-8d5b-4e00-a54e-a7db1523d00c' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-1cfaf071-8d5b-4e00-a54e-a7db1523d00c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-db7371e2-6edd-4104-a706-3f3adc5161bd' class='xr-var-data-in' type='checkbox'><label for='data-db7371e2-6edd-4104-a706-3f3adc5161bd' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>standard_name :</span></dt><dd>Model quantiles</dd><dt><span>long_name :</span></dt><dd>Quantiles of model on the reference period</dd></dl></div><div class='xr-var-data'><pre>[5475 values with dtype=float64]</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-5e2808c1-e15b-4314-b3b7-abba7365af88' class='xr-section-summary-in' type='checkbox' ><label for='section-5e2808c1-e15b-4314-b3b7-abba7365af88' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>quantiles</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-19117bc4-00d8-45a5-a22e-7ac17ab4380d' class='xr-index-data-in' type='checkbox'/><label for='index-19117bc4-00d8-45a5-a22e-7ac17ab4380d' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0.03333333333333333, 0.1, 0.16666666666666666,\n", + " 0.23333333333333334, 0.3, 0.36666666666666664,\n", + " 0.43333333333333335, 0.5, 0.5666666666666667,\n", + " 0.6333333333333333, 0.7, 0.7666666666666666,\n", + " 0.8333333333333334, 0.9, 0.9666666666666667],\n", + " dtype='float64', name='quantiles'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>dayofyear</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-aa44839a-c5cb-435f-9df9-e6ffabcccf07' class='xr-index-data-in' type='checkbox'/><label for='index-aa44839a-c5cb-435f-9df9-e6ffabcccf07' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\n", + " ...\n", + " 356, 357, 358, 359, 360, 361, 362, 363, 364, 365],\n", + " dtype='int64', name='dayofyear', length=365))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-9c281e26-ae8d-4ccc-b5c9-292ba6a3ffd2' class='xr-section-summary-in' type='checkbox' checked><label for='section-9c281e26-ae8d-4ccc-b5c9-292ba6a3ffd2' class='xr-section-summary' >Attributes: <span>(6)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>group :</span></dt><dd>time.dayofyear</dd><dt><span>group_compute_dims :</span></dt><dd>time</dd><dt><span>group_window :</span></dt><dd>1</dd><dt><span>_xsdba_adjustment :</span></dt><dd>{"py/object": "xsdba.adjustment.QuantileDeltaMapping", "py/state": {"hist_calendar": "noleap", "train_units": "K", "group": {"py/object": "xsdba.base.Grouper", "py/state": {"dim": "time", "add_dims": [], "prop": "dayofyear", "name": "time.dayofyear", "window": 1}}, "kind": "+"}}</dd><dt><span>adj_params :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')</dd><dt><span>title :</span></dt><dd>This is the dataset, but read from disk.</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.Dataset> Size: 91kB\n", + "Dimensions: (dayofyear: 365, quantiles: 15)\n", + "Coordinates:\n", + " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", + " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", + "Data variables:\n", + " af (dayofyear, quantiles) float64 44kB ...\n", + " hist_q (dayofyear, quantiles) float64 44kB ...\n", + "Attributes:\n", + " group: time.dayofyear\n", + " group_compute_dims: time\n", + " group_window: 1\n", + " _xsdba_adjustment: {\"py/object\": \"xsdba.adjustment.QuantileDeltaMapping...\n", + " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy...\n", + " title: This is the dataset, but read from disk." + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# FIXME: Error when using h5netcdf\n", + "# QDM.ds.to_netcdf(\"QDM_training2.nc\", engine=\"h5netcdf\")\n", + "! rm \"QDM_training2.nc\"\n", + "QDM.ds.to_netcdf(\"QDM_training2.nc\")\n", + "ds = xr.open_dataset(\"QDM_training2.nc\")\n", + "ds.attrs[\"title\"] = \"This is the dataset, but read from disk.\"\n", + "QDM.set_dataset(ds)\n", + "QDM.ds" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'scen' (time: 11315)> Size: 91kB\n", + "array([255.23206044, 254.31691855, 254.849451 , ..., 257.95004657,\n", + " 257.05566815, 256.34753035])\n", + "Coordinates:\n", + " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", + "Attributes:\n", + " units: K\n", + " history: [2024-08-02 12:24:44] : Bias-adjusted with QuantileDelt...\n", + " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'scen'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>time</span>: 11315</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-257c25bd-02bf-456c-9e07-d7f2f31f2764' class='xr-array-in' type='checkbox' checked><label for='section-257c25bd-02bf-456c-9e07-d7f2f31f2764' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>255.2 254.3 254.8 253.2 253.6 253.6 ... 256.4 257.7 258.0 257.1 256.3</span></div><div class='xr-array-data'><pre>array([255.23206044, 254.31691855, 254.849451 , ..., 257.95004657,\n", + " 257.05566815, 256.34753035])</pre></div></div></li><li class='xr-section-item'><input id='section-7de38e0b-d3d9-4219-a7d4-255b71915bec' class='xr-section-summary-in' type='checkbox' checked><label for='section-7de38e0b-d3d9-4219-a7d4-255b71915bec' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2030-12-...</div><input id='attrs-e5e83996-22ff-42ce-88c7-dcc17467d093' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-e5e83996-22ff-42ce-88c7-dcc17467d093' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-7f964837-b78d-404a-9830-c02a8cb73d15' class='xr-var-data-in' type='checkbox'><label for='data-7f964837-b78d-404a-9830-c02a8cb73d15' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", + " cftime.DatetimeNoLeap(2030, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2030, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2030, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", + " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-fb69ddc9-322f-4c58-adb2-1844a509851c' class='xr-section-summary-in' type='checkbox' ><label for='section-fb69ddc9-322f-4c58-adb2-1844a509851c' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-1e13fb99-8ef7-47dc-9c42-983a80157c87' class='xr-index-data-in' type='checkbox'/><label for='index-1e13fb99-8ef7-47dc-9c42-983a80157c87' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00,\n", + " 2000-01-04 00:00:00, 2000-01-05 00:00:00, 2000-01-06 00:00:00,\n", + " 2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,\n", + " 2000-01-10 00:00:00,\n", + " ...\n", + " 2030-12-22 00:00:00, 2030-12-23 00:00:00, 2030-12-24 00:00:00,\n", + " 2030-12-25 00:00:00, 2030-12-26 00:00:00, 2030-12-27 00:00:00,\n", + " 2030-12-28 00:00:00, 2030-12-29 00:00:00, 2030-12-30 00:00:00,\n", + " 2030-12-31 00:00:00],\n", + " dtype='object', length=11315, calendar='noleap', freq='D'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-67ad167a-bba1-4e70-bb15-942b0aa831dd' class='xr-section-summary-in' type='checkbox' checked><label for='section-67ad167a-bba1-4e70-bb15-942b0aa831dd' class='xr-section-summary' >Attributes: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>history :</span></dt><dd>[2024-08-02 12:24:44] : Bias-adjusted with QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, ) - xsdba version: 0.1.0</dd><dt><span>bias_adjustment :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, )</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.DataArray 'scen' (time: 11315)> Size: 91kB\n", + "array([255.23206044, 254.31691855, 254.849451 , ..., 257.95004657,\n", + " 257.05566815, 256.34753035])\n", + "Coordinates:\n", + " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", + "Attributes:\n", + " units: K\n", + " history: [2024-08-02 12:24:44] : Bias-adjusted with QuantileDelt...\n", + " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear..." + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "QDM2.adjust(sim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retrieving extra output diagnostics\n", + "\n", + "<!-- TODO : check xsdba_extra_output works -->\n", + "\n", + "To fully understand what is happening during the bias-adjustment process, `xsdba` can output _diagnostic_ variables, giving more visibility to what the adjustment is doing behind the scene. This behaviour, a `verbose` option, is controlled by the `xsdba_extra_output` option, set with `xsdba.set_options`. When `True`, `train` calls are instructed to include additional variables to the training datasets. In addition, the `adjust` calls will always output a dataset, with `scen` and, depending on the algorithm, other diagnostics variables. See the documentation of each `Adjustment` objects to see what extra variables are available.\n", + "\n", + "For the moment, this feature is still under construction and only a few `Adjustment` actually provide these extra outputs. Please open issues on the GitHub repo if you have needs or ideas of interesting diagnostic variables.\n", + "\n", + "For example, `QDM.adjust` adds `sim_q`, which gives the quantile of each element of `sim` within its group." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'sim_q' (time: 11315)> Size: 91kB\n", + "array([0.23333333, 0.13333333, 0.2 , ..., 1. , 0.8 ,\n", + " 0.7 ])\n", + "Coordinates:\n", + " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", + "Attributes:\n", + " group: time.dayofyear\n", + " group_compute_dims: time\n", + " group_window: 1\n", + " long_name: Group-wise quantiles of `sim`.</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'sim_q'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>time</span>: 11315</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-8ba6a71c-a7cc-42b6-be53-1a53d8eb890c' class='xr-array-in' type='checkbox' checked><label for='section-8ba6a71c-a7cc-42b6-be53-1a53d8eb890c' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>0.2333 0.1333 0.2 0.0 0.0 0.0 0.1 ... 1.0 0.9 0.9667 1.0 0.8 0.7</span></div><div class='xr-array-data'><pre>array([0.23333333, 0.13333333, 0.2 , ..., 1. , 0.8 ,\n", + " 0.7 ])</pre></div></div></li><li class='xr-section-item'><input id='section-6268f56e-8449-45c6-99a4-a700e01ba7dc' class='xr-section-summary-in' type='checkbox' checked><label for='section-6268f56e-8449-45c6-99a4-a700e01ba7dc' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2030-12-...</div><input id='attrs-478eb1ef-6ee4-40ce-b767-f085a44618ba' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-478eb1ef-6ee4-40ce-b767-f085a44618ba' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5907e25c-12b3-4be0-9e70-5fc9ce6cc889' class='xr-var-data-in' type='checkbox'><label for='data-5907e25c-12b3-4be0-9e70-5fc9ce6cc889' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", + " cftime.DatetimeNoLeap(2030, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2030, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2030, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", + " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-a3bf9ede-e1b0-4b9d-b538-de930de0c387' class='xr-section-summary-in' type='checkbox' ><label for='section-a3bf9ede-e1b0-4b9d-b538-de930de0c387' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-f30eadce-ae29-4e25-a212-aeca92a62fd0' class='xr-index-data-in' type='checkbox'/><label for='index-f30eadce-ae29-4e25-a212-aeca92a62fd0' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00,\n", + " 2000-01-04 00:00:00, 2000-01-05 00:00:00, 2000-01-06 00:00:00,\n", + " 2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,\n", + " 2000-01-10 00:00:00,\n", + " ...\n", + " 2030-12-22 00:00:00, 2030-12-23 00:00:00, 2030-12-24 00:00:00,\n", + " 2030-12-25 00:00:00, 2030-12-26 00:00:00, 2030-12-27 00:00:00,\n", + " 2030-12-28 00:00:00, 2030-12-29 00:00:00, 2030-12-30 00:00:00,\n", + " 2030-12-31 00:00:00],\n", + " dtype='object', length=11315, calendar='noleap', freq='D'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-23969be4-bfa0-4730-bdff-5049731839f8' class='xr-section-summary-in' type='checkbox' checked><label for='section-23969be4-bfa0-4730-bdff-5049731839f8' class='xr-section-summary' >Attributes: <span>(4)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>group :</span></dt><dd>time.dayofyear</dd><dt><span>group_compute_dims :</span></dt><dd>time</dd><dt><span>group_window :</span></dt><dd>1</dd><dt><span>long_name :</span></dt><dd>Group-wise quantiles of `sim`.</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.DataArray 'sim_q' (time: 11315)> Size: 91kB\n", + "array([0.23333333, 0.13333333, 0.2 , ..., 1. , 0.8 ,\n", + " 0.7 ])\n", + "Coordinates:\n", + " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", + "Attributes:\n", + " group: time.dayofyear\n", + " group_compute_dims: time\n", + " group_window: 1\n", + " long_name: Group-wise quantiles of `sim`." + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from xsdba import set_options\n", + "\n", + "with set_options(xsdba_extra_output=True):\n", + " QDM = QuantileDeltaMapping.train(\n", + " ref, hist, nquantiles=15, kind=\"+\", group=\"time.dayofyear\"\n", + " )\n", + " out = QDM.adjust(sim)\n", + "\n", + "out.sim_q" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Moving window for adjustments\n", + "\n", + "Some Adjustment methods require that the adjusted data (`sim`) be of the same length (same number of points) than the training data (`ref` and `hist`). These requirements often ensure conservation of statistical properties and a better representation of the climate change signal over the long adjusted timeseries.\n", + "\n", + "In opposition to a conventional \"rolling window\", here it is the _years_ that are the base units of the window, not the elements themselves. `xsdba` implements `xsdba.calendar.stack_periods` and `xsdba.calendar.unstack_periods` to manipulate data in that goal. The \"stack\" function cuts the data in overlapping windows of a certain length and stacks them along a new `\"period\"` dimension, alike to xarray's `da.rolling(time=win).construct('period')`, but with yearly steps. The stride (or step) between each window can also be controlled. This argument is an indicator of how many years overlap between each window. With a value of `1`, a window will have `window - 1` years overlapping with the previous one. The default (`None`) is to have `stride = window` will result in no overlap at all. The default units in which `window` and `stride` are given is a year (\"YS\"), but can be changed with argument `freq`.\n", + "\n", + "By chunking the result along this `'period'` dimension, it is expected to be more computationally efficient (when using `dask`) than looping over the windows with a for-loop (or a `GroupyBy`)\n", + "\n", + "Note that this results in two restrictions:\n", + "\n", + "1. The constructed array has the same \"time\" axis for all windows. This is a problem if the actual _year_ is of importance for the adjustment, but this is not the case for any of `xsdba`'s current adjustment methods.\n", + "2. The input timeseries must be in a calendar with uniform year lengths. For daily data, this means only the \"360_day\", \"noleap\" and \"all_leap\" calendars are supported.\n", + "\n", + "The \"unstack\" function does the opposite: it concatenates the windows together to recreate the original timeseries. It only works for the no-overlap case where `stride = window` and for the non-ambiguous one where `stride` divides `window` into an odd number (N) of parts. In that latter situation, the middle parts of each period are kept when reconstructing the timeseries, in addition to the first (last) parts of the first (last) period needed to get a full timeseries.\n", + "\n", + "Quantile Delta Mapping requires that the adjustment period should be of a length similar to the training one. As our `ref` and `hist` cover 15 years but `sim` covers 31 years, we will transform `sim` by stacking windows of 15 years. With a stride of five (5) years, this means the first window goes from 2000 to 2014 (inclusive). Then 2005-2019, 2010-2024 and 2015-2029. The last year will be dropped as it can't be included in any complete window.\n", + "\n", + "<div class=\"alert alert-warning\">\n", + "\n", + "In the following example, `QDM` is configured with `group=\"time.dayofyear\"` which will perform the adjustment for each day of year (doy) separately. When using `stack_periods` the extracted windows are all concatenated along the new `period` axis, and they all share the same time coordinate. As such, for the `doy` information to make sense, we must use a calendar with uniform year lengths. Otherwise, the `doy` values would shift one day at each leap year.\n", + "\n", + "</div>" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "QDM = QuantileDeltaMapping.train(\n", + " ref, hist, nquantiles=15, kind=\"+\", group=\"time.dayofyear\"\n", + ")\n", + "\n", + "scen_nowin = QDM.adjust(sim)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.DataArray (period: 4, time: 5475)> Size: 175kB\n", + "array([[256.56897873, 256.33204916, 256.6078032 , ..., 258.27778118,\n", + " 257.92444362, 258.72658245],\n", + " [256.34414151, 255.9003116 , 257.24846488, ..., 258.4266159 ,\n", + " 258.18310965, 259.22809524],\n", + " [257.29972639, 256.88057295, 258.17260583, ..., 258.73870093,\n", + " 258.79702384, 259.01007664],\n", + " [258.54563373, 257.32674304, 258.74673108, ..., 259.76399892,\n", + " 260.03250936, 259.81183198]])\n", + "Coordinates:\n", + " * time (time) object 44kB 1970-01-01 00:00:00 ... 1984-12-31 00:0...\n", + " period_length (period) int64 32B 5475 5475 5475 5475\n", + " * period (period) object 32B 2000-01-01 00:00:00 ... 2015-01-01 00:...\n", + "Attributes:\n", + " units: K</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'></div><ul class='xr-dim-list'><li><span class='xr-has-index'>period</span>: 4</li><li><span class='xr-has-index'>time</span>: 5475</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-8e8fe06f-9385-421d-9e2b-b9ff1e7ca49b' class='xr-array-in' type='checkbox' checked><label for='section-8e8fe06f-9385-421d-9e2b-b9ff1e7ca49b' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>256.6 256.3 256.6 255.4 255.5 255.5 ... 259.6 259.0 259.8 260.0 259.8</span></div><div class='xr-array-data'><pre>array([[256.56897873, 256.33204916, 256.6078032 , ..., 258.27778118,\n", + " 257.92444362, 258.72658245],\n", + " [256.34414151, 255.9003116 , 257.24846488, ..., 258.4266159 ,\n", + " 258.18310965, 259.22809524],\n", + " [257.29972639, 256.88057295, 258.17260583, ..., 258.73870093,\n", + " 258.79702384, 259.01007664],\n", + " [258.54563373, 257.32674304, 258.74673108, ..., 259.76399892,\n", + " 260.03250936, 259.81183198]])</pre></div></div></li><li class='xr-section-item'><input id='section-000e328c-456b-48ab-b208-0581acce198f' class='xr-section-summary-in' type='checkbox' checked><label for='section-000e328c-456b-48ab-b208-0581acce198f' class='xr-section-summary' >Coordinates: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>1970-01-01 00:00:00 ... 1984-12-...</div><input id='attrs-50251c4c-3774-48d1-b51d-89dc7e91484d' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-50251c4c-3774-48d1-b51d-89dc7e91484d' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-f3e1dba2-2866-4788-ba3c-00ba33a05349' class='xr-var-data-in' type='checkbox'><label for='data-f3e1dba2-2866-4788-ba3c-00ba33a05349' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd>Placeholder time axis</dd></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(1970, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(1970, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(1970, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", + " cftime.DatetimeNoLeap(1984, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(1984, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(1984, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", + " dtype=object)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>period_length</span></div><div class='xr-var-dims'>(period)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>5475 5475 5475 5475</div><input id='attrs-45953484-e935-4b84-9fe7-87b35d9612bd' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-45953484-e935-4b84-9fe7-87b35d9612bd' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d29e899d-9302-4695-bd90-b937dc0f96f4' class='xr-var-data-in' type='checkbox'><label for='data-d29e899d-9302-4695-bd90-b937dc0f96f4' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([5475, 5475, 5475, 5475])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>period</span></div><div class='xr-var-dims'>(period)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2015-01-...</div><input id='attrs-ab8b14f6-f23b-4608-94b3-91d3d1b70714' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-ab8b14f6-f23b-4608-94b3-91d3d1b70714' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-b99b0652-be37-408a-a9fa-2338a37fb563' class='xr-var-data-in' type='checkbox'><label for='data-b99b0652-be37-408a-a9fa-2338a37fb563' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd>Start of the period</dd><dt><span>window :</span></dt><dd>15</dd><dt><span>stride :</span></dt><dd>5</dd><dt><span>freq :</span></dt><dd>YS</dd><dt><span>unequal_lengths :</span></dt><dd>0</dd></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2005, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2010, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2015, 1, 1, 0, 0, 0, 0, has_year_zero=True)],\n", + " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-5d4cc573-7987-4d8d-b745-054c01d43861' class='xr-section-summary-in' type='checkbox' ><label for='section-5d4cc573-7987-4d8d-b745-054c01d43861' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-46ff406a-ee4a-4e96-8f13-da09a9d82172' class='xr-index-data-in' type='checkbox'/><label for='index-46ff406a-ee4a-4e96-8f13-da09a9d82172' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([1970-01-01 00:00:00, 1970-01-02 00:00:00, 1970-01-03 00:00:00,\n", + " 1970-01-04 00:00:00, 1970-01-05 00:00:00, 1970-01-06 00:00:00,\n", + " 1970-01-07 00:00:00, 1970-01-08 00:00:00, 1970-01-09 00:00:00,\n", + " 1970-01-10 00:00:00,\n", + " ...\n", + " 1984-12-22 00:00:00, 1984-12-23 00:00:00, 1984-12-24 00:00:00,\n", + " 1984-12-25 00:00:00, 1984-12-26 00:00:00, 1984-12-27 00:00:00,\n", + " 1984-12-28 00:00:00, 1984-12-29 00:00:00, 1984-12-30 00:00:00,\n", + " 1984-12-31 00:00:00],\n", + " dtype='object', length=5475, calendar='noleap', freq='D'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>period</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-685f83c2-bb64-4398-afc3-2fb2e5c45689' class='xr-index-data-in' type='checkbox'/><label for='index-685f83c2-bb64-4398-afc3-2fb2e5c45689' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2005-01-01 00:00:00, 2010-01-01 00:00:00,\n", + " 2015-01-01 00:00:00],\n", + " dtype='object', length=4, calendar='noleap', freq='5YS-JAN'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-1c637b0f-34b3-4e63-8fdf-e1bdb7a057e4' class='xr-section-summary-in' type='checkbox' checked><label for='section-1c637b0f-34b3-4e63-8fdf-e1bdb7a057e4' class='xr-section-summary' >Attributes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.DataArray (period: 4, time: 5475)> Size: 175kB\n", + "array([[256.56897873, 256.33204916, 256.6078032 , ..., 258.27778118,\n", + " 257.92444362, 258.72658245],\n", + " [256.34414151, 255.9003116 , 257.24846488, ..., 258.4266159 ,\n", + " 258.18310965, 259.22809524],\n", + " [257.29972639, 256.88057295, 258.17260583, ..., 258.73870093,\n", + " 258.79702384, 259.01007664],\n", + " [258.54563373, 257.32674304, 258.74673108, ..., 259.76399892,\n", + " 260.03250936, 259.81183198]])\n", + "Coordinates:\n", + " * time (time) object 44kB 1970-01-01 00:00:00 ... 1984-12-31 00:0...\n", + " period_length (period) int64 32B 5475 5475 5475 5475\n", + " * period (period) object 32B 2000-01-01 00:00:00 ... 2015-01-01 00:...\n", + "Attributes:\n", + " units: K" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from xsdba.calendar import stack_periods, unstack_periods\n", + "\n", + "sim_win = stack_periods(sim, window=15, stride=5)\n", + "sim_win" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we retrieve the full timeseries (minus the lasy year that couldn't fit in any window)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'scen' (time: 10950)> Size: 88kB\n", + "array([255.22055623, 254.25554953, 255.03477622, ..., 257.79550951,\n", + " 258.28040379, 257.54786958])\n", + "Coordinates:\n", + " * time (time) object 88kB 2000-01-01 00:00:00 ... 2029-12-31 00:00:00\n", + "Attributes:\n", + " units: K\n", + " history: [2024-08-02 12:24:53] : Bias-adjusted with QuantileDelt...\n", + " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'scen'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>time</span>: 10950</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-60340295-862d-49da-b085-8b6f9d96e10c' class='xr-array-in' type='checkbox' checked><label for='section-60340295-862d-49da-b085-8b6f9d96e10c' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>255.2 254.3 255.0 253.2 253.6 253.6 ... 256.8 256.9 257.8 258.3 257.5</span></div><div class='xr-array-data'><pre>array([255.22055623, 254.25554953, 255.03477622, ..., 257.79550951,\n", + " 258.28040379, 257.54786958])</pre></div></div></li><li class='xr-section-item'><input id='section-9a5bc7d2-7334-43e5-beeb-3045d2258691' class='xr-section-summary-in' type='checkbox' checked><label for='section-9a5bc7d2-7334-43e5-beeb-3045d2258691' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2029-12-...</div><input id='attrs-fba25547-b512-4177-8f78-b20bc193533f' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-fba25547-b512-4177-8f78-b20bc193533f' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-fff99daa-b037-49b7-94a3-0e526983531d' class='xr-var-data-in' type='checkbox'><label for='data-fff99daa-b037-49b7-94a3-0e526983531d' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", + " cftime.DatetimeNoLeap(2029, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2029, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2029, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", + " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-5baf9182-6e92-4a65-82f0-70367d7d1313' class='xr-section-summary-in' type='checkbox' ><label for='section-5baf9182-6e92-4a65-82f0-70367d7d1313' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-6d063f77-8f21-4833-9626-e2376edd68bf' class='xr-index-data-in' type='checkbox'/><label for='index-6d063f77-8f21-4833-9626-e2376edd68bf' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00,\n", + " 2000-01-04 00:00:00, 2000-01-05 00:00:00, 2000-01-06 00:00:00,\n", + " 2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,\n", + " 2000-01-10 00:00:00,\n", + " ...\n", + " 2029-12-22 00:00:00, 2029-12-23 00:00:00, 2029-12-24 00:00:00,\n", + " 2029-12-25 00:00:00, 2029-12-26 00:00:00, 2029-12-27 00:00:00,\n", + " 2029-12-28 00:00:00, 2029-12-29 00:00:00, 2029-12-30 00:00:00,\n", + " 2029-12-31 00:00:00],\n", + " dtype='object', length=10950, calendar='noleap', freq='D'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-61079d01-7748-4bb2-850e-71a543a53653' class='xr-section-summary-in' type='checkbox' checked><label for='section-61079d01-7748-4bb2-850e-71a543a53653' class='xr-section-summary' >Attributes: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>history :</span></dt><dd>[2024-08-02 12:24:53] : Bias-adjusted with QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, ) - xsdba version: 0.1.0</dd><dt><span>bias_adjustment :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, )</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.DataArray 'scen' (time: 10950)> Size: 88kB\n", + "array([255.22055623, 254.25554953, 255.03477622, ..., 257.79550951,\n", + " 258.28040379, 257.54786958])\n", + "Coordinates:\n", + " * time (time) object 88kB 2000-01-01 00:00:00 ... 2029-12-31 00:00:00\n", + "Attributes:\n", + " units: K\n", + " history: [2024-08-02 12:24:53] : Bias-adjusted with QuantileDelt...\n", + " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear..." + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scen_win = unstack_periods(QDM.adjust(sim_win))\n", + "scen_win" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Full example: Multivariate adjustment in the additive space\n", + "\n", + "The following example shows a complete bias-adjustment workflow using the `PrincipalComponents` method in a multi-variate configuration. Moreover, it uses the trick showed by [Alavoine et Grenier (2022)](https://doi.org/10.31223/X5C34C) to transform \"multiplicative\" variable to the \"additive\" space using log and logit transformations. This way, we can perform multi-variate adjustment with variables that couldn't be used in the same _kind_ of adjustment, like \"tas\" and \"hurs\".\n", + "\n", + "We will transform the variables that need it to the additive space, adding some jitter in the process to avoid $log(0)$ situations. Then, we will stack the different variables into a single `DataArray`, allowing us to use `PrincipalComponents` in a multi-variate way. Following the PCA, a simple quantile-mapping method is used, both adjustment acting on the residuals, while the mean of the simulated trend is adjusted on its own. Each step will be explained.\n", + "\n", + "First, open the data, convert the calendar and the units. Because we will perform adjustments on \"dayofyear\" groups (with a window), keeping standard calendars results in an extra \"dayofyear\" with only a quarter of the data. It's usual to transform to a \"noleap\" calendar, which drops the 29th of February, as it only has a small impact on the data." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/eridup1/repos/xsdba/src/xsdba/calendar.py:93: FutureWarning: `xclim` function convert_calendar is deprecated in favour of xarray.coding.calendar_ops.convert_calendar or obj.convert_calendar and will be removed in v0.51.0. Please adjust your script.\n", + " warn(\n" + ] + } + ], + "source": [ + "import xsdba\n", + "from xsdba.calendar import convert_calendar\n", + "from xsdba.units import convert_units_to, pint_multiply\n", + "from xsdba.testing import open_dataset\n", + "\n", + "group = xsdba.Grouper(\"time.dayofyear\", window=31)\n", + "\n", + "dref = convert_calendar(open_dataset(\"sdba/ahccd_1950-2013.nc\"), \"noleap\").sel(\n", + " time=slice(\"1981\", \"2010\")\n", + ")\n", + "dsim = open_dataset(\"sdba/CanESM2_1950-2100.nc\")\n", + "\n", + "dref = dref.assign(\n", + " tasmax=convert_units_to(dref.tasmax, \"K\"),\n", + ")\n", + "inverse_water_density = \"1e-03 m^3/kg\"\n", + "dsim = dsim.assign(pr=convert_units_to(pint_multiply(dsim.pr, inverse_water_density) , \"mm/d\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Jitter, additive space transformation and variable stacking\n", + "Here, `tasmax` is already ready to be adjusted in an additive way, because all data points are far from the physical zero (0 K). This is not the case for `pr`, which is why we want to transform that variable to the additive space, to avoid splitting our workflow in two. For `pr` the \"log\" transformation is simply:\n", + "\n", + "$$ pr' = \\ln\\left(pr - b\\right) $$\n", + "\n", + "Where $b$ is the lower bound, here 0 mm/d. However, we could have exact zeros (0 mm/d) in the datasets, which will translate into $-\\infty$. To avoid this, we simply replace the smallest values by a random distribution of very small, but not problematic, values. In the following, all values below 0.1 mm/d are replaced by a uniform random distribution of values within the range (0, 0.1) mm/d (bounds excluded).\n", + "\n", + "Finally, the variables are stacked together into a single `DataArray`." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'multivariate' (multivar: 2, time: 55115, location: 3)> Size: 1MB\n", + "array([[[ 2.4951424e-01, -8.2575518e-01, 2.4951424e-01],\n", + " [ 2.6499709e-01, -4.1112199e-01, 2.6499709e-01],\n", + " [-1.9535354e-01, -2.7694762e+00, -1.9535354e-01],\n", + " ...,\n", + " [ 3.2132244e+00, -2.2834629e-01, 3.2132244e+00],\n", + " [ 1.6713389e+00, 1.7489431e+00, 1.6713389e+00],\n", + " [ 7.5195450e-01, 2.4332018e+00, 7.5195450e-01]],\n", + "\n", + " [[ 2.7815024e+02, 2.7754898e+02, 2.7815024e+02],\n", + " [ 2.8335815e+02, 2.7690921e+02, 2.8335815e+02],\n", + " [ 2.8153192e+02, 2.7668036e+02, 2.8153192e+02],\n", + " ...,\n", + " [ 2.8901334e+02, 2.8192789e+02, 2.8901334e+02],\n", + " [ 2.8510699e+02, 2.8142294e+02, 2.8510699e+02],\n", + " [ 2.8404471e+02, 2.8160156e+02, 2.8404471e+02]]], dtype=float32)\n", + "Coordinates:\n", + " * time (time) object 441kB 1950-01-01 00:00:00 ... 2100-12-31 00:00:00\n", + " lat (location) float64 24B 49.1 67.8 48.8\n", + " lon (location) float64 24B -123.1 -115.1 -78.2\n", + " * location (location) <U9 108B 'Vancouver' 'Kugluktuk' 'Amos'\n", + " * multivar (multivar) <U6 48B 'pr' 'tasmax'\n", + "Attributes: (12/34)\n", + " institution: CanESM2\n", + " institute_id: CCCma\n", + " experiment_id: rcp85\n", + " source: CanESM2 2010 atmosphere: CanAM4 (AGCM15i...\n", + " model_id: CanESM2\n", + " forcing: GHG,Oz,SA,BC,OC,LU,Sl (GHG includes CO2,...\n", + " ... ...\n", + " modeling_realm: atmos\n", + " realization: 1\n", + " cmor_version: 2.5.4\n", + " DODS_EXTRA.Unlimited_Dimension: time\n", + " description: Extracted from CMIP5 CanESM2 hist+rcp85 ...\n", + " units: </pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'multivariate'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>multivar</span>: 2</li><li><span class='xr-has-index'>time</span>: 55115</li><li><span class='xr-has-index'>location</span>: 3</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-5c32d9ed-262a-45bf-a4f8-ad6f6a5c4d5d' class='xr-array-in' type='checkbox' checked><label for='section-5c32d9ed-262a-45bf-a4f8-ad6f6a5c4d5d' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>0.2495 -0.8258 0.2495 0.265 -0.4111 ... 281.4 285.1 284.0 281.6 284.0</span></div><div class='xr-array-data'><pre>array([[[ 2.4951424e-01, -8.2575518e-01, 2.4951424e-01],\n", + " [ 2.6499709e-01, -4.1112199e-01, 2.6499709e-01],\n", + " [-1.9535354e-01, -2.7694762e+00, -1.9535354e-01],\n", + " ...,\n", + " [ 3.2132244e+00, -2.2834629e-01, 3.2132244e+00],\n", + " [ 1.6713389e+00, 1.7489431e+00, 1.6713389e+00],\n", + " [ 7.5195450e-01, 2.4332018e+00, 7.5195450e-01]],\n", + "\n", + " [[ 2.7815024e+02, 2.7754898e+02, 2.7815024e+02],\n", + " [ 2.8335815e+02, 2.7690921e+02, 2.8335815e+02],\n", + " [ 2.8153192e+02, 2.7668036e+02, 2.8153192e+02],\n", + " ...,\n", + " [ 2.8901334e+02, 2.8192789e+02, 2.8901334e+02],\n", + " [ 2.8510699e+02, 2.8142294e+02, 2.8510699e+02],\n", + " [ 2.8404471e+02, 2.8160156e+02, 2.8404471e+02]]], dtype=float32)</pre></div></div></li><li class='xr-section-item'><input id='section-d5607408-8741-4029-bdc2-935b2c7f21e3' class='xr-section-summary-in' type='checkbox' checked><label for='section-d5607408-8741-4029-bdc2-935b2c7f21e3' class='xr-section-summary' >Coordinates: <span>(5)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>1950-01-01 00:00:00 ... 2100-12-...</div><input id='attrs-d1c00394-5f6b-4567-9f22-cc9bbe6123b6' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-d1c00394-5f6b-4567-9f22-cc9bbe6123b6' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-f66c8f12-8666-4855-952d-78e664e47e1e' class='xr-var-data-in' type='checkbox'><label for='data-f66c8f12-8666-4855-952d-78e664e47e1e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>bounds :</span></dt><dd>time_bnds</dd><dt><span>axis :</span></dt><dd>T</dd><dt><span>long_name :</span></dt><dd>time</dd><dt><span>standard_name :</span></dt><dd>time</dd></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(1950, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(1950, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(1950, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", + " cftime.DatetimeNoLeap(2100, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2100, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2100, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", + " dtype=object)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lat</span></div><div class='xr-var-dims'>(location)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>49.1 67.8 48.8</div><input id='attrs-30626c05-e64c-4b93-a331-97010f241228' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-30626c05-e64c-4b93-a331-97010f241228' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-ce52db73-4f77-4e54-a2a9-5202d3b98401' class='xr-var-data-in' type='checkbox'><label for='data-ce52db73-4f77-4e54-a2a9-5202d3b98401' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>degrees_north</dd><dt><span>long_name :</span></dt><dd>latitude</dd><dt><span>axis :</span></dt><dd>Y</dd><dt><span>standard_name :</span></dt><dd>latitude</dd></dl></div><div class='xr-var-data'><pre>array([49.1, 67.8, 48.8])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lon</span></div><div class='xr-var-dims'>(location)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>-123.1 -115.1 -78.2</div><input id='attrs-2da13dd2-e35a-4a30-84fb-406de8f30bc8' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-2da13dd2-e35a-4a30-84fb-406de8f30bc8' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-acd1646e-dc5d-41e6-a14e-a2fedd1b00e0' class='xr-var-data-in' type='checkbox'><label for='data-acd1646e-dc5d-41e6-a14e-a2fedd1b00e0' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>degrees_east</dd><dt><span>long_name :</span></dt><dd>longitude</dd><dt><span>axis :</span></dt><dd>X</dd><dt><span>standard_name :</span></dt><dd>longitude</dd></dl></div><div class='xr-var-data'><pre>array([-123.1, -115.1, -78.2])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>location</span></div><div class='xr-var-dims'>(location)</div><div class='xr-var-dtype'><U9</div><div class='xr-var-preview xr-preview'>'Vancouver' 'Kugluktuk' 'Amos'</div><input id='attrs-8e7c09ce-6850-4022-9282-8e60b116e457' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-8e7c09ce-6850-4022-9282-8e60b116e457' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5c96e41c-9b7b-47e1-8769-7bf42a090536' class='xr-var-data-in' type='checkbox'><label for='data-5c96e41c-9b7b-47e1-8769-7bf42a090536' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array(['Vancouver', 'Kugluktuk', 'Amos'], dtype='<U9')</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>multivar</span></div><div class='xr-var-dims'>(multivar)</div><div class='xr-var-dtype'><U6</div><div class='xr-var-preview xr-preview'>'pr' 'tasmax'</div><input id='attrs-5e12675f-a4ff-4854-9116-25b3313d392b' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-5e12675f-a4ff-4854-9116-25b3313d392b' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-ee543cae-9f13-4745-9f8f-63296fa46688' class='xr-var-data-in' type='checkbox'><label for='data-ee543cae-9f13-4745-9f8f-63296fa46688' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>_history :</span></dt><dd>["[2024-08-02 12:24:54] pr: jitter(x=pr, lower='0.1 mm/d', minimum='0 mm/d') - xsdba version: 0.1.0\\n[2024-08-02 12:24:54] pr: to_additive_space(data=pr, lower_bound='0 mm/d', trans='log') - xsdba version: 0.1.0", "2011-04-14T00:21:01Z altered by CMOR: Treated scalar dimension: 'height'. 2011-04-14T00:21:01Z altered by CMOR: replaced missing value flag (1e+38) with standard missing value (1e+20)."]</dd><dt><span>_sdba_transform :</span></dt><dd>['log', None]</dd><dt><span>_sdba_transform_lower :</span></dt><dd>[array(0.), None]</dd><dt><span>_sdba_transform_units :</span></dt><dd>[<Unit('millimeter / day')>, None]</dd><dt><span>_units :</span></dt><dd>['', 'K']</dd><dt><span>_standard_name :</span></dt><dd>[None, 'air_temperature']</dd><dt><span>_long_name :</span></dt><dd>[None, 'Daily Maximum Near-Surface Air Temperature']</dd><dt><span>_original_name :</span></dt><dd>[None, 'STMX']</dd><dt><span>_cell_methods :</span></dt><dd>[None, 'time: maximum (interval: 15 minutes)']</dd><dt><span>_cell_measures :</span></dt><dd>[None, 'area: areacella']</dd><dt><span>_associated_files :</span></dt><dd>[None, 'baseURL: http://cmip-pcmdi.llnl.gov/CMIP5/dataLocation gridspecFile: gridspec_atmos_fx_CanESM2_historical_r0i0p0.nc areacella: areacella_fx_CanESM2_historical_r0i0p0.nc']</dd><dt><span>is_variables :</span></dt><dd>True</dd></dl></div><div class='xr-var-data'><pre>array(['pr', 'tasmax'], dtype='<U6')</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-709e0efc-4b96-4094-b023-d43c3a94246c' class='xr-section-summary-in' type='checkbox' ><label for='section-709e0efc-4b96-4094-b023-d43c3a94246c' class='xr-section-summary' >Indexes: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-f169ca18-0c79-49b8-a1ef-d36d452cbe61' class='xr-index-data-in' type='checkbox'/><label for='index-f169ca18-0c79-49b8-a1ef-d36d452cbe61' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([1950-01-01 00:00:00, 1950-01-02 00:00:00, 1950-01-03 00:00:00,\n", + " 1950-01-04 00:00:00, 1950-01-05 00:00:00, 1950-01-06 00:00:00,\n", + " 1950-01-07 00:00:00, 1950-01-08 00:00:00, 1950-01-09 00:00:00,\n", + " 1950-01-10 00:00:00,\n", + " ...\n", + " 2100-12-22 00:00:00, 2100-12-23 00:00:00, 2100-12-24 00:00:00,\n", + " 2100-12-25 00:00:00, 2100-12-26 00:00:00, 2100-12-27 00:00:00,\n", + " 2100-12-28 00:00:00, 2100-12-29 00:00:00, 2100-12-30 00:00:00,\n", + " 2100-12-31 00:00:00],\n", + " dtype='object', length=55115, calendar='noleap', freq='D'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>location</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-ae6d569a-7f14-49e9-a34a-5c18cbc791a3' class='xr-index-data-in' type='checkbox'/><label for='index-ae6d569a-7f14-49e9-a34a-5c18cbc791a3' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index(['Vancouver', 'Kugluktuk', 'Amos'], dtype='object', name='location'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>multivar</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-f989c82a-e23e-4bba-8249-8f0dfd03004a' class='xr-index-data-in' type='checkbox'/><label for='index-f989c82a-e23e-4bba-8249-8f0dfd03004a' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index(['pr', 'tasmax'], dtype='object', name='multivar'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-b810120c-688a-4634-a46a-1c5b2cac83a5' class='xr-section-summary-in' type='checkbox' ><label for='section-b810120c-688a-4634-a46a-1c5b2cac83a5' class='xr-section-summary' >Attributes: <span>(34)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>institution :</span></dt><dd>CanESM2</dd><dt><span>institute_id :</span></dt><dd>CCCma</dd><dt><span>experiment_id :</span></dt><dd>rcp85</dd><dt><span>source :</span></dt><dd>CanESM2 2010 atmosphere: CanAM4 (AGCM15i, T63L35) ocean: CanOM4 (OGCM4.0, 256x192L40) and CMOC1.2 sea ice: CanSIM1 (Cavitating Fluid, T63 Gaussian Grid) land: CLASS2.7 and CTEM1</dd><dt><span>model_id :</span></dt><dd>CanESM2</dd><dt><span>forcing :</span></dt><dd>GHG,Oz,SA,BC,OC,LU,Sl (GHG includes CO2,CH4,N2O,CFC11,effective CFC12. Sl is the repeat of the 23rd solar cycle, years 1997-2008, after year 2008.)</dd><dt><span>parent_experiment_id :</span></dt><dd>historical</dd><dt><span>parent_experiment_rip :</span></dt><dd>r1i1p1</dd><dt><span>branch_time :</span></dt><dd>56940.0</dd><dt><span>contact :</span></dt><dd>cccma_info@ec.gc.ca</dd><dt><span>references :</span></dt><dd>http://www.cccma.ec.gc.ca/models</dd><dt><span>initialization_method :</span></dt><dd>1</dd><dt><span>physics_version :</span></dt><dd>1</dd><dt><span>tracking_id :</span></dt><dd>17560481-e4c5-43c9-bc3f-950732f21588</dd><dt><span>branch_time_YMDH :</span></dt><dd>2006:01:01:00</dd><dt><span>CCCma_runid :</span></dt><dd>IDR</dd><dt><span>CCCma_parent_runid :</span></dt><dd>IGM</dd><dt><span>CCCma_data_licence :</span></dt><dd>1) GRANT OF LICENCE - The Government of Canada (Environment Canada) is the \n", + "owner of all intellectual property rights (including copyright) that may exist in this Data \n", + "product. You (as "The Licensee") are hereby granted a non-exclusive, non-assignable, \n", + "non-transferable unrestricted licence to use this data product for any purpose including \n", + "the right to share these data with others and to make value-added and derivative \n", + "products from it. This licence is not a sale of any or all of the owner's rights.\n", + "2) NO WARRANTY - This Data product is provided "as-is"; it has not been designed or \n", + "prepared to meet the Licensee's particular requirements. Environment Canada makes no \n", + "warranty, either express or implied, including but not limited to, warranties of \n", + "merchantability and fitness for a particular purpose. In no event will Environment Canada \n", + "be liable for any indirect, special, consequential or other damages attributed to the \n", + "Licensee's use of the Data product.</dd><dt><span>product :</span></dt><dd>output</dd><dt><span>experiment :</span></dt><dd>RCP8.5</dd><dt><span>frequency :</span></dt><dd>day</dd><dt><span>creation_date :</span></dt><dd>2011-04-10T11:24:15Z</dd><dt><span>history :</span></dt><dd>2021-04-23T12:00:00: Extraction of timeseries.2011-04-10T11:24:15Z CMOR rewrote data to comply with CF standards and CMIP5 requirements.</dd><dt><span>Conventions :</span></dt><dd>CF-1.4</dd><dt><span>project_id :</span></dt><dd>CMIP5</dd><dt><span>table_id :</span></dt><dd>Table day (28 March 2011) f9d6cfec5981bb8be1801b35a81002f0</dd><dt><span>title :</span></dt><dd>Test dataset for xclim.sdba - model data</dd><dt><span>parent_experiment :</span></dt><dd>historical</dd><dt><span>modeling_realm :</span></dt><dd>atmos</dd><dt><span>realization :</span></dt><dd>1</dd><dt><span>cmor_version :</span></dt><dd>2.5.4</dd><dt><span>DODS_EXTRA.Unlimited_Dimension :</span></dt><dd>time</dd><dt><span>description :</span></dt><dd>Extracted from CMIP5 CanESM2 hist+rcp85 r1i1p1 at a few locations. Projection starts in 2006.</dd><dt><span>units :</span></dt><dd></dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.DataArray 'multivariate' (multivar: 2, time: 55115, location: 3)> Size: 1MB\n", + "array([[[ 2.4951424e-01, -8.2575518e-01, 2.4951424e-01],\n", + " [ 2.6499709e-01, -4.1112199e-01, 2.6499709e-01],\n", + " [-1.9535354e-01, -2.7694762e+00, -1.9535354e-01],\n", + " ...,\n", + " [ 3.2132244e+00, -2.2834629e-01, 3.2132244e+00],\n", + " [ 1.6713389e+00, 1.7489431e+00, 1.6713389e+00],\n", + " [ 7.5195450e-01, 2.4332018e+00, 7.5195450e-01]],\n", + "\n", + " [[ 2.7815024e+02, 2.7754898e+02, 2.7815024e+02],\n", + " [ 2.8335815e+02, 2.7690921e+02, 2.8335815e+02],\n", + " [ 2.8153192e+02, 2.7668036e+02, 2.8153192e+02],\n", + " ...,\n", + " [ 2.8901334e+02, 2.8192789e+02, 2.8901334e+02],\n", + " [ 2.8510699e+02, 2.8142294e+02, 2.8510699e+02],\n", + " [ 2.8404471e+02, 2.8160156e+02, 2.8404471e+02]]], dtype=float32)\n", + "Coordinates:\n", + " * time (time) object 441kB 1950-01-01 00:00:00 ... 2100-12-31 00:00:00\n", + " lat (location) float64 24B 49.1 67.8 48.8\n", + " lon (location) float64 24B -123.1 -115.1 -78.2\n", + " * location (location) <U9 108B 'Vancouver' 'Kugluktuk' 'Amos'\n", + " * multivar (multivar) <U6 48B 'pr' 'tasmax'\n", + "Attributes: (12/34)\n", + " institution: CanESM2\n", + " institute_id: CCCma\n", + " experiment_id: rcp85\n", + " source: CanESM2 2010 atmosphere: CanAM4 (AGCM15i...\n", + " model_id: CanESM2\n", + " forcing: GHG,Oz,SA,BC,OC,LU,Sl (GHG includes CO2,...\n", + " ... ...\n", + " modeling_realm: atmos\n", + " realization: 1\n", + " cmor_version: 2.5.4\n", + " DODS_EXTRA.Unlimited_Dimension: time\n", + " description: Extracted from CMIP5 CanESM2 hist+rcp85 ...\n", + " units: " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dref_as = dref.assign(\n", + " pr=xsdba.processing.to_additive_space(\n", + " xsdba.processing.jitter(dref.pr, lower=\"0.1 mm/d\", minimum=\"0 mm/d\"),\n", + " lower_bound=\"0 mm/d\",\n", + " trans=\"log\",\n", + " )\n", + ")\n", + "ref = xsdba.stack_variables(dref_as)\n", + "\n", + "dsim_as = dsim.assign(\n", + " pr=xsdba.processing.to_additive_space(\n", + " xsdba.processing.jitter(dsim.pr, lower=\"0.1 mm/d\", minimum=\"0 mm/d\"),\n", + " lower_bound=\"0 mm/d\",\n", + " trans=\"log\",\n", + " )\n", + ")\n", + "sim = xsdba.stack_variables(dsim_as)\n", + "sim" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. Get residuals and trends\n", + "The adjustment will be performed on residuals only. The adjusted timeseries `sim` will be detrended with the LOESS routine described above. Because of the short length of `ref` and `hist` and the potential boundary effects of using LOESS with them, we compute the 30-year mean. In other words, instead of _detrending_ inputs, we are _normalizing_ those inputs.\n", + "\n", + "While the residuals are adjusted with `PrincipalComponents` and `EmpiricalQuantileMapping`, the trend of `sim` still needs to be offset according to the means of `ref` and `hist`. This is similar to what `DetrendedQuantileMapping` does. The offset step could have been done on the trend itself or at the end on `scen`, it doesn't really matter. We do it here because it keeps it close to where the `scaling` is computed." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "ref_res, ref_norm = xsdba.processing.normalize(ref, group=group, kind=\"+\")\n", + "hist_res, hist_norm = xsdba.processing.normalize(\n", + " sim.sel(time=slice(\"1981\", \"2010\")), group=group, kind=\"+\"\n", + ")\n", + "scaling = xsdba.utils.get_correction(hist_norm, ref_norm, kind=\"+\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "sim_scaled = xsdba.utils.apply_correction(\n", + " sim, xsdba.utils.broadcast(scaling, sim, group=group), kind=\"+\"\n", + ")\n", + "\n", + "loess = xsdba.detrending.LoessDetrend(group=group, f=0.2, d=0, kind=\"+\", niter=1)\n", + "simfit = loess.fit(sim_scaled)\n", + "sim_res = simfit.detrend(sim_scaled)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. Adjustments\n", + "Following, Alavoine et Grenier (2022), we decided to perform the multivariate Principal Components adjustment first and then re-adjust with the simple Quantile-Mapping." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "PCA = xsdba.adjustment.PrincipalComponents.train(\n", + " ref_res, hist_res, group=group, crd_dim=\"multivar\", best_orientation=\"simple\"\n", + ")\n", + "\n", + "scen1_res = PCA.adjust(sim_res)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "EQM = xsdba.adjustment.EmpiricalQuantileMapping.train(\n", + " ref_res,\n", + " scen1_res.sel(time=slice(\"1981\", \"2010\")),\n", + " group=group,\n", + " nquantiles=50,\n", + " kind=\"+\",\n", + ")\n", + "\n", + "scen2_res = EQM.adjust(scen1_res, interp=\"linear\", extrapolation=\"constant\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4. Re-trend and transform back to the physical space\n", + "Add back the trend (which includes the scaling), unstack the variables to a dataset and transform `pr` back to the physical space. All functions have conserved and handled the attributes, so we don't need to repeat the additive space bounds. The annual cycle of both variables on the reference period in Vancouver is plotted to confirm the adjustment adds a positive effect." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "scen = simfit.retrend(scen2_res)\n", + "dscen_as = xsdba.unstack_variables(scen)\n", + "dscen = dscen_as.assign(pr=xsdba.processing.from_additive_space(dscen_as.pr))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1200x400 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# gather data together for plotting\n", + "dsl = [ds.assign_coords({\"data_type\":lab}) for ds, lab in zip([dref,dsim,dscen], [\"obs\", \"raw\", \"scen\"])]\n", + "dsout = xr.concat(dsl, dim=\"data_type\")\n", + "\n", + "fig, axs = plt.subplots(1,2, figsize=(12,4))\n", + "fg = dsout.tasmax.sel(time=slice(\"1981\", \"2010\"), location=\"Vancouver\").groupby(\n", + " \"time.dayofyear\"\n", + ").mean().plot(hue=\"data_type\",ax=axs[0])\n", + "axs[0].get_legend().set_title('')\n", + "dsout.pr.sel(time=slice(\"1981\", \"2010\"), location=\"Vancouver\").groupby(\n", + " \"time.dayofyear\"\n", + ").mean().plot(hue=\"data_type\",ax=axs[1])\n", + "axs[1].get_legend().set_title('')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Frequency adaption with a rolling window\n", + "\n", + "In the previous example, we performed bias adjustment with a rolling window. Here we show how to include frequency adaptation (see `example.ipynb` for the simple case `group=\"time\"`). We first generate the same precipitation dataset used in `example.ipynb`" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "t = xr.cftime_range(\"2000-01-01\", \"2030-12-31\", freq=\"D\", calendar=\"noleap\")\n", + "\n", + "vals = np.random.randint(0, 1000, size=(t.size,)) / 100\n", + "vals_ref = (4 ** np.where(vals < 9, vals / 100, vals)) / 3e6\n", + "vals_sim = (\n", + " (1 + 0.1 * np.random.random_sample((t.size,)))\n", + " * (4 ** np.where(vals < 9.5, vals / 100, vals))\n", + " / 3e6\n", + ")\n", + "\n", + "pr_ref = xr.DataArray(\n", + " vals_ref, coords={\"time\": t}, dims=(\"time\",), attrs={\"units\": \"mm/day\"}\n", + ")\n", + "pr_ref = pr_ref.sel(time=slice(\"2000\", \"2015\"))\n", + "pr_sim = xr.DataArray(\n", + " vals_sim, coords={\"time\": t}, dims=(\"time\",), attrs={\"units\": \"mm/day\"}\n", + ")\n", + "pr_hist = pr_sim.sel(time=slice(\"2000\", \"2015\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bias adjustment on a rolling window can be performed in the same way as shown in `example.ipynb`, but instead of being a single string precising the time grouping (e.g. `time.month`), the `group` argument is built with `sdba.Grouper` function" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fb6fa624250>" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# adapt_freq with a xsdba.Grouper\n", + "import xsdba\n", + "\n", + "group = xsdba.Grouper(\"time.dayofyear\", window=31)\n", + "hist_ad, pth, dP0 = xsdba.processing.adapt_freq(\n", + " pr_ref, pr_hist, thresh=\"0.05 mm d-1\", group=group\n", + ")\n", + "QM_ad = xsdba.EmpiricalQuantileMapping.train(\n", + " pr_ref, hist_ad, nquantiles=15, kind=\"*\", group=group\n", + ")\n", + "scen_ad = QM_ad.adjust(pr_sim)\n", + "\n", + "pr_ref.sel(time=\"2010\").plot(alpha=0.9, label=\"Reference\")\n", + "pr_sim.sel(time=\"2010\").plot(alpha=0.7, label=\"Model - biased\")\n", + "scen_ad.sel(time=\"2010\").plot(alpha=0.6, label=\"Model - adjusted\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the figure above, `scen` occasionally has small peaks where `sim` is 0, indicating that there are more \"dry days\" (days with almost no precipitation) in `hist` than in `ref`. The frequency-adaptation [Themeßl et al. (2010)](https://doi.org/10.1007/s10584-011-0224-4) performed in the step above only worked partially. \n", + "\n", + "The reason for this is the following. The first step above combines precipitations in 365 overlapping blocks of 31 days * Y years, one block for each day of the year. Each block is adapted, and the 16th day-of-year slice (at the center of the block) is assigned to the corresponding day-of-year in the adapted dataset `hist_ad`. As we proceed to the training, we re-form those 31 days * Y years blocks, but this step does not invert the last one: There can still be more zeroes in the simulation than in the reference. \n", + "\n", + "To alleviate this issue, another way of proceeding is to perform a frequency adaptation on the blocks, and then use the same blocks in the training step, as we show below." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fb6d998bed0>" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# adapt_freq directly in the training step\n", + "group = xsdba.Grouper(\"time.dayofyear\", window=31)\n", + "\n", + "QM_ad = xsdba.EmpiricalQuantileMapping.train(\n", + " pr_ref,\n", + " pr_hist,\n", + " nquantiles=15,\n", + " kind=\"*\",\n", + " group=group,\n", + " adapt_freq_thresh=\"0.05 mm d-1\",\n", + ")\n", + "scen_ad = QM_ad.adjust(pr_sim)\n", + "\n", + "pr_ref.sel(time=\"2010\").plot(alpha=0.9, label=\"Reference\")\n", + "pr_sim.sel(time=\"2010\").plot(alpha=0.7, label=\"Model - biased\")\n", + "scen_ad.sel(time=\"2010\").plot(alpha=0.6, label=\"Model - adjusted\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tests for sdba\n", + "\n", + "It can be useful to perform diagnostic tests on adjusted simulations to assess if the bias correction method is working properly, or to compare two different bias correction techniques.\n", + "\n", + "A diagnostic test includes calculations of a property (mean, 20-year return value, annual cycle amplitude, ...) on the simulation and on the scenario (adjusted simulation), then a measure (bias, relative bias, ratio, ...) of the difference. Usually, the property collapse the time dimension of the simulation/scenario and returns one value by grid point.\n", + "\n", + "You'll find those in ``xsdba.properties`` and ``xsdba.measures``, where they are implemented as classes similiar to of `xclim`'s ``Indicator``, which means they can be worked with the same way as conventional indicators (used in YAML modules for example)." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "import xsdba\n", + "from xsdba.testing import open_dataset\n", + "\n", + "# load test data\n", + "hist = open_dataset(\"sdba/CanESM2_1950-2100.nc\").sel(time=slice(\"1950\", \"1980\")).tasmax\n", + "ref = open_dataset(\"sdba/nrcan_1950-2013.nc\").sel(time=slice(\"1950\", \"1980\")).tasmax\n", + "sim = (\n", + " open_dataset(\"sdba/CanESM2_1950-2100.nc\").sel(time=slice(\"1980\", \"2010\")).tasmax\n", + ") # biased\n", + "\n", + "# learn the bias in historical simulation compared to reference\n", + "QM = xsdba.EmpiricalQuantileMapping.train(\n", + " ref, hist, nquantiles=50, group=\"time\", kind=\"+\"\n", + ")\n", + "\n", + "# correct the bias in the future\n", + "scen = QM.adjust(sim, extrapolation=\"constant\", interp=\"nearest\")\n", + "ref_future = (\n", + " open_dataset(\"sdba/nrcan_1950-2013.nc\").sel(time=slice(\"1980\", \"2010\")).tasmax\n", + ") # truth\n", + "\n", + "plt.figure(figsize=(15, 5))\n", + "lw = 0.3\n", + "sim.isel(location=1).plot(label=\"sim\", linewidth=lw)\n", + "scen.isel(location=1).plot(label=\"scen\", linewidth=lw)\n", + "hist.isel(location=1).plot(label=\"hist\", linewidth=lw)\n", + "ref.isel(location=1).plot(label=\"ref\", linewidth=lw)\n", + "ref_future.isel(location=1).plot(label=\"ref_future\", linewidth=lw)\n", + "leg = plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-2.5, 2.5)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 500x300 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# calculate the mean warm Spell Length Distribution\n", + "sim_prop = xsdba.properties.spell_length_distribution(\n", + " da=sim, thresh=\"28 degC\", op=\">\", stat=\"mean\", group=\"time\"\n", + ")\n", + "\n", + "\n", + "scen_prop = xsdba.properties.spell_length_distribution(\n", + " da=scen, thresh=\"28 degC\", op=\">\", stat=\"mean\", group=\"time\"\n", + ")\n", + "\n", + "ref_prop = xsdba.properties.spell_length_distribution(\n", + " da=ref_future, thresh=\"28 degC\", op=\">\", stat=\"mean\", group=\"time\"\n", + ")\n", + "# measure the difference between the prediction and the reference with an absolute bias of the properties\n", + "measure_sim = xsdba.measures.bias(sim_prop, ref_prop)\n", + "measure_scen = xsdba.measures.bias(scen_prop, ref_prop)\n", + "\n", + "plt.figure(figsize=(5, 3))\n", + "plt.plot(measure_sim.location, measure_sim.values, \".\", label=\"biased model (sim)\")\n", + "plt.plot(measure_scen.location, measure_scen.values, \".\", label=\"adjusted model (scen)\")\n", + "plt.title(\n", + " \"Bias of the mean of the warm spell \\n length distribution compared to observations\"\n", + ")\n", + "plt.legend()\n", + "plt.ylim(-2.5, 2.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is possible the change the 'group' of the property from 'time' to 'time.season' or 'time.month'.\n", + " This will return 4 or 12 values per grid point, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 875.125x600 with 4 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# calculate the mean warm Spell Length Distribution\n", + "sim_prop, scen_prop, ref_prop = [xsdba.properties.spell_length_distribution(\n", + " da=ds0, thresh=\"28 degC\", op=\">\", stat=\"mean\", group=\"time.season\"\n", + ") for ds0 in [sim, scen, ref_future]]\n", + "\n", + "# Properties are often associated with the same measures. This correspondence is implemented in xsdba:\n", + "measure = xsdba.properties.spell_length_distribution.get_measure()\n", + "measure_sim = measure(sim_prop, ref_prop)\n", + "measure_scen = measure(scen_prop, ref_prop)\n", + "\n", + "# Gather data together and plot\n", + "measl = [meas.assign_coords(data_type=lab) for meas,lab in zip([measure_sim, measure_scen],[\"biased model (sim)\", \"biased model (scen)\"])]\n", + "measure_all = xr.concat(measl, dim=\"data_type\")\n", + "fg = measure_all.plot(col=\"season\", col_wrap=2, hue=\"data_type\", marker=\"o\", ls=\"\")\n", + "fg.fig.subplots_adjust(top=0.9)\n", + "fg.fig.suptitle(\n", + "\"Bias of the mean of the warm spell length distribution compared to observations\"\n", + ")\n", + "fg.figlegend.set_title(\"\")\n", + "for ax in fg.fig.axes: \n", + " ax.set_ylim(-2.5,2.5)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3", + "path": "/bassin/eridup1/miniforge3/envs/xsdba/share/jupyter/kernels/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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/notebooks/example.ipynb b/docs/notebooks/example.ipynb new file mode 100644 index 0000000..4c6e12f --- /dev/null +++ b/docs/notebooks/example.ipynb @@ -0,0 +1,1801 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Statistical Downscaling and Bias-Adjustment\n", + "\n", + "`xsdba` provides tools and utilities to ease the bias-adjustment process. Almost all adjustment algorithms conform to the `train` - `adjust` scheme, formalized within `TrainAdjust` classes. Given a reference time series (`ref`), historical simulations (`hist`) and simulations to be adjusted (`sim`), any bias-adjustment method would be applied by first estimating the adjustment factors between the historical simulation and the observation series, and then applying these factors to `sim`, which could be a future simulation.\n", + "\n", + "This presents examples, while a bit more info and the API are given on [this page](../xsdba.rst).\n", + "\n", + "A very simple \"Quantile Mapping\" approach is available through the `EmpiricalQuantileMapping` object. The object is created through the `.train` method of the class, and the simulation is adjusted with `.adjust`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2c7230a10>" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from __future__ import annotations\n", + "\n", + "import cftime # noqa\n", + "import matplotlib.pyplot as plt\n", + "import nc_time_axis # noqa\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "%matplotlib inline\n", + "plt.style.use(\"seaborn-v0_8\")\n", + "plt.rcParams[\"figure.figsize\"] = (11, 5)\n", + "\n", + "# Create toy data to explore bias adjustment, here fake temperature timeseries\n", + "t = xr.cftime_range(\"2000-01-01\", \"2030-12-31\", freq=\"D\", calendar=\"noleap\")\n", + "\n", + "ref = xr.DataArray(\n", + " (\n", + " -20 * np.cos(2 * np.pi * t.dayofyear / 365)\n", + " + 2 * np.random.random_sample((t.size,))\n", + " + 273.15\n", + " + 0.1 * (t - t[0]).days / 365\n", + " ), # \"warming\" of 1K per decade,\n", + " dims=(\"time\",),\n", + " coords={\"time\": t},\n", + " attrs={\"units\": \"K\"},\n", + ")\n", + "sim = xr.DataArray(\n", + " (\n", + " -18 * np.cos(2 * np.pi * t.dayofyear / 365)\n", + " + 2 * np.random.random_sample((t.size,))\n", + " + 273.15\n", + " + 0.11 * (t - t[0]).days / 365\n", + " ), # \"warming\" of 1.1K per decade\n", + " dims=(\"time\",),\n", + " coords={\"time\": t},\n", + " attrs={\"units\": \"K\"},\n", + ")\n", + "\n", + "ref = ref.sel(time=slice(None, \"2015-01-01\"))\n", + "hist = sim.sel(time=slice(None, \"2015-01-01\"))\n", + "\n", + "ref.plot(label=\"Reference\")\n", + "sim.plot(label=\"Model\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2adeb1190>" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import xsdba \n", + "\n", + "QM = xsdba.EmpiricalQuantileMapping.train(\n", + " ref, hist, nquantiles=15, group=\"time\", kind=\"+\"\n", + ")\n", + "scen = QM.adjust(sim, extrapolation=\"constant\", interp=\"nearest\")\n", + "\n", + "ref.groupby(\"time.dayofyear\").mean().plot(label=\"Reference\")\n", + "hist.groupby(\"time.dayofyear\").mean().plot(label=\"Model - biased\")\n", + "scen.sel(time=slice(\"2000\", \"2015\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2000-15\", linestyle=\"--\"\n", + ")\n", + "scen.sel(time=slice(\"2015\", \"2030\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2015-30\", linestyle=\"--\"\n", + ")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the previous example, a simple Quantile Mapping algorithm was used with 15 quantiles and one group of values. The model performs well, but our toy data is also quite smooth and well-behaved so this is not surprising.\n", + "\n", + "A more complex example could have bias distribution varying strongly across months. To perform the adjustment with different factors for each month, one can pass `group='time.month'`. Moreover, to reduce the risk of drastic changes in the adjustments at the interface of months, `interp='linear'` can be passed to `.adjust` and the adjustment factors will be interpolated linearly (e.g.: the factors for the 1st of May will be the average of those for both April and May)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2acbdbd10>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "QM_mo = xsdba.EmpiricalQuantileMapping.train(\n", + " ref, hist, nquantiles=15, group=\"time.month\", kind=\"+\"\n", + ")\n", + "scen = QM_mo.adjust(sim, extrapolation=\"constant\", interp=\"linear\")\n", + "\n", + "ref.groupby(\"time.dayofyear\").mean().plot(label=\"Reference\")\n", + "hist.groupby(\"time.dayofyear\").mean().plot(label=\"Model - biased\")\n", + "scen.sel(time=slice(\"2000\", \"2015\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2000-15\", linestyle=\"--\"\n", + ")\n", + "scen.sel(time=slice(\"2015\", \"2030\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2015-30\", linestyle=\"--\"\n", + ")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The training data (here the adjustment factors) is available for inspection in the `ds` attribute of the adjustment object." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.Dataset> Size: 3kB\n", + "Dimensions: (month: 12, quantiles: 15)\n", + "Coordinates:\n", + " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", + " * month (month) int64 96B 1 2 3 4 5 6 7 8 9 10 11 12\n", + "Data variables:\n", + " af (month, quantiles) float64 1kB -1.996 -2.002 ... -1.88 -1.834\n", + " hist_q (month, quantiles) float64 1kB 256.0 256.4 256.7 ... 259.2 259.8\n", + "Attributes:\n", + " group: time.month\n", + " group_compute_dims: ['time']\n", + " group_window: 1\n", + " _xsdba_adjustment: {"py/object": "xsdba.adjustment.EmpiricalQuantileMap...\n", + " adj_params: EmpiricalQuantileMapping(group=Grouper(name='time.mo...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-1ce76d9a-baf1-423f-b457-37f5e24d70df' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-1ce76d9a-baf1-423f-b457-37f5e24d70df' class='xr-section-summary' title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>month</span>: 12</li><li><span class='xr-has-index'>quantiles</span>: 15</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-f6a70915-2944-4269-bf59-cc05038c06c9' class='xr-section-summary-in' type='checkbox' checked><label for='section-f6a70915-2944-4269-bf59-cc05038c06c9' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>quantiles</span></div><div class='xr-var-dims'>(quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.03333 0.1 0.1667 ... 0.9 0.9667</div><input id='attrs-9824507f-0dd0-44d3-bbf2-efbcc8ee5cfe' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-9824507f-0dd0-44d3-bbf2-efbcc8ee5cfe' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-f548a8ae-fe29-4d0b-a119-02a86f05dcdb' class='xr-var-data-in' type='checkbox'><label for='data-f548a8ae-fe29-4d0b-a119-02a86f05dcdb' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0.033333, 0.1 , 0.166667, 0.233333, 0.3 , 0.366667, 0.433333,\n", + " 0.5 , 0.566667, 0.633333, 0.7 , 0.766667, 0.833333, 0.9 ,\n", + " 0.966667])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>month</span></div><div class='xr-var-dims'>(month)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>1 2 3 4 5 6 7 8 9 10 11 12</div><input id='attrs-f6472c08-b79d-4b2d-a3c8-7ca0892daf0e' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-f6472c08-b79d-4b2d-a3c8-7ca0892daf0e' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-a1e2ce49-e06f-4653-9790-d06034295013' class='xr-var-data-in' type='checkbox'><label for='data-a1e2ce49-e06f-4653-9790-d06034295013' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-0dcb53df-c1a9-4a59-a0a3-f7853f3c971d' class='xr-section-summary-in' type='checkbox' checked><label for='section-0dcb53df-c1a9-4a59-a0a3-f7853f3c971d' class='xr-section-summary' >Data variables: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>af</span></div><div class='xr-var-dims'>(month, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>-1.996 -2.002 ... -1.88 -1.834</div><input id='attrs-45fde869-0bcf-426d-b121-8d60081ebf3d' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-45fde869-0bcf-426d-b121-8d60081ebf3d' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-a12f8980-3b88-4c95-b525-bb43bff8f485' class='xr-var-data-in' type='checkbox'><label for='data-a12f8980-3b88-4c95-b525-bb43bff8f485' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>kind :</span></dt><dd>+</dd><dt><span>standard_name :</span></dt><dd>Adjustment factors</dd><dt><span>long_name :</span></dt><dd>Quantile mapping adjustment factors</dd></dl></div><div class='xr-var-data'><pre>array([[-1.99618551, -2.0021663 , -2.03059259, -2.09842154, -2.10277329,\n", + " -2.04925981, -2.10045821, -2.04769897, -2.06992263, -1.97446436,\n", + " -2.04323076, -1.93528253, -1.83917834, -1.92110698, -2.04844952],\n", + " [-1.52943384, -1.82694965, -1.92962829, -1.80752908, -1.7373425 ,\n", + " -1.65663688, -1.53313705, -1.45447972, -1.4698499 , -1.46117992,\n", + " -1.50815524, -1.26504842, -1.28681936, -1.09281239, -1.18907294],\n", + " [-1.12899584, -1.08330473, -0.79272584, -1.00992381, -0.72755806,\n", + " -0.82682467, -0.73317671, -0.72866599, -0.58179646, -0.30412038,\n", + " -0.44762727, -0.26547131, -0.22393231, -0.11999948, -0.48243734],\n", + " [ 0.09983215, 0.08756574, 0.2128637 , 0.22728907, 0.26135008,\n", + " 0.33661191, 0.26885266, 0.37131827, 0.54571175, 0.61223851,\n", + " 0.60350382, 0.78898675, 0.7021569 , 0.80029986, 0.98309627],\n", + " [ 1.2338729 , 0.96079715, 1.07137709, 1.11015058, 1.12573426,\n", + " 1.28313221, 1.26445056, 1.2747203 , 1.31029963, 1.36890913,\n", + " 1.44400369, 1.54951951, 1.44954142, 1.67871412, 1.53551945],\n", + " [ 1.93397051, 1.7658039 , 1.7049751 , 1.82257539, 1.85496433,\n", + " 1.86199501, 1.90247109, 1.84026002, 1.88503272, 2.01188503,\n", + " 1.94099129, 1.91765119, 1.78781015, 1.80632097, 1.62971387],\n", + " [ 1.68434059, 1.83948278, 1.70180325, 1.80737253, 1.88836921,\n", + " 1.88640573, 1.85653498, 1.91824966, 1.90859862, 1.9757538 ,\n", + " 2.05299187, 1.97227392, 1.99549351, 2.00682613, 1.95144504],\n", + " [ 1.15213749, 1.17195961, 1.26800735, 1.1453641 , 1.32900331,\n", + " 1.30082974, 1.21446546, 1.3731542 , 1.3786736 , 1.47716329,\n", + " 1.56104876, 1.49046189, 1.4432084 , 1.43909205, 1.52423128],\n", + " [ 0.19453608, 0.18701838, 0.39799261, 0.17699079, 0.07250572,\n", + " 0.11513105, 0.38414408, 0.31052 , 0.35927724, 0.73753987,\n", + " 0.88011562, 0.74741399, 0.72150543, 0.77208879, 0.38661525],\n", + " [-1.02056128, -1.01769723, -0.78110887, -0.86315953, -0.95285293,\n", + " -0.65152767, -0.64259762, -0.44989437, -0.4318881 , -0.45823107,\n", + " -0.3688854 , -0.40348718, -0.44920454, -0.34928628, -0.02930245],\n", + " [-1.65364393, -1.67257236, -1.61472057, -1.65800937, -1.637498 ,\n", + " -1.45347986, -1.47455711, -1.54901273, -1.45558712, -1.44198224,\n", + " -1.27364993, -1.35705207, -0.89366918, -0.99295696, -1.18868365],\n", + " [-1.95705719, -1.98858932, -1.97365551, -1.95147502, -1.97409462,\n", + " -1.96687817, -1.95051748, -1.93209727, -1.8968306 , -1.84180558,\n", + " -1.89584486, -1.93687659, -1.95624154, -1.87971589, -1.83419253]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>hist_q</span></div><div class='xr-var-dims'>(month, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>256.0 256.4 256.7 ... 259.2 259.8</div><input id='attrs-18cbcb7d-9afc-4b21-a851-4f84a3ea68ad' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-18cbcb7d-9afc-4b21-a851-4f84a3ea68ad' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-f2cc71d5-2ef4-4158-a62c-5e676c23cf19' class='xr-var-data-in' type='checkbox'><label for='data-f2cc71d5-2ef4-4158-a62c-5e676c23cf19' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>standard_name :</span></dt><dd>Model quantiles</dd><dt><span>long_name :</span></dt><dd>Quantiles of model on the reference period</dd></dl></div><div class='xr-var-data'><pre>array([[255.95117248, 256.42781761, 256.7001553 , 257.02052317,\n", + " 257.20366486, 257.360436 , 257.56683939, 257.77631999,\n", + " 257.9645075 , 258.17173266, 258.44026381, 258.63249285,\n", + " 258.91430081, 259.23187213, 259.87132174],\n", + " [258.96713857, 259.91853148, 260.46843078, 260.81023676,\n", + " 261.10667669, 261.46407781, 261.78236589, 262.13886165,\n", + " 262.55748243, 262.97474826, 263.52478311, 263.88393293,\n", + " 264.40213718, 264.83447906, 265.45067771],\n", + " [265.78390653, 266.49616533, 267.03081992, 267.66814912,\n", + " 268.1087819 , 268.7792246 , 269.28863975, 270.00680762,\n", + " 270.56594218, 271.17426804, 271.92183785, 272.47375881,\n", + " 273.16371152, 273.73580772, 274.84124117],\n", + " [274.66022547, 275.51451647, 276.2067188 , 276.77817729,\n", + " 277.50129335, 278.0475197 , 278.78326241, 279.29902678,\n", + " 279.81048245, 280.46746973, 281.1098152 , 281.59576139,\n", + " 282.27946821, 282.82037787, 283.80627563],\n", + " [283.50832768, 284.50552568, 284.99128127, 285.46100551,\n", + " 286.0536072 , 286.4625847 , 287.02498629, 287.50876084,\n", + " 287.96322494, 288.36361851, 288.70448672, 289.09120647,\n", + " 289.64294479, 289.99186669, 290.77316341],\n", + "...\n", + " [283.74566305, 284.57262128, 285.14666896, 285.76141578,\n", + " 286.22259156, 286.77240918, 287.19000838, 287.67261837,\n", + " 288.06917624, 288.57661015, 288.92183789, 289.38617278,\n", + " 289.81368479, 290.37399229, 291.05365515],\n", + " [275.10182647, 275.97049306, 276.55907455, 277.33163729,\n", + " 277.93364227, 278.60857754, 279.05574972, 279.76695583,\n", + " 280.33208155, 280.80921153, 281.30149048, 281.99636366,\n", + " 282.66331506, 283.23191939, 284.26113667],\n", + " [265.83902208, 266.71866981, 267.23552495, 267.9012106 ,\n", + " 268.57572041, 269.03869994, 269.70918297, 270.25188039,\n", + " 270.91314782, 271.62575617, 272.30467927, 272.80942259,\n", + " 273.56307428, 274.29248342, 275.03626783],\n", + " [259.09219874, 259.7507774 , 260.17276182, 260.59675466,\n", + " 261.00679175, 261.31903697, 261.86324365, 262.33126451,\n", + " 262.78270124, 263.25194119, 263.63468765, 264.0424718 ,\n", + " 264.3495372 , 265.10977931, 265.91102047],\n", + " [256.15568618, 256.51746362, 256.82910412, 256.99452882,\n", + " 257.22547837, 257.40508962, 257.59423687, 257.79009697,\n", + " 257.95497742, 258.1014306 , 258.36500022, 258.60538039,\n", + " 258.88690153, 259.20653166, 259.81539254]])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-95cafd2d-3684-4cc2-ab0d-105a70cf209e' class='xr-section-summary-in' type='checkbox' ><label for='section-95cafd2d-3684-4cc2-ab0d-105a70cf209e' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>quantiles</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-46e6dcce-5d57-42d0-923a-90c45f4fbbe7' class='xr-index-data-in' type='checkbox'/><label for='index-46e6dcce-5d57-42d0-923a-90c45f4fbbe7' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0.03333333333333333, 0.1, 0.16666666666666666,\n", + " 0.23333333333333334, 0.3, 0.36666666666666664,\n", + " 0.43333333333333335, 0.5, 0.5666666666666667,\n", + " 0.6333333333333333, 0.7, 0.7666666666666666,\n", + " 0.8333333333333334, 0.9, 0.9666666666666667],\n", + " dtype='float64', name='quantiles'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>month</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-4be3aef1-bc7a-492d-b435-f67d7bd7837b' class='xr-index-data-in' type='checkbox'/><label for='index-4be3aef1-bc7a-492d-b435-f67d7bd7837b' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype='int64', name='month'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-978d0caa-95de-446d-903a-8d76b77f889d' class='xr-section-summary-in' type='checkbox' checked><label for='section-978d0caa-95de-446d-903a-8d76b77f889d' class='xr-section-summary' >Attributes: <span>(5)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>group :</span></dt><dd>time.month</dd><dt><span>group_compute_dims :</span></dt><dd>['time']</dd><dt><span>group_window :</span></dt><dd>1</dd><dt><span>_xsdba_adjustment :</span></dt><dd>{"py/object": "xsdba.adjustment.EmpiricalQuantileMapping", "py/state": {"hist_calendar": "noleap", "train_units": "K", "group": {"py/object": "xsdba.base.Grouper", "py/state": {"dim": "time", "add_dims": [], "prop": "month", "name": "time.month", "window": 1}}, "kind": "+"}}</dd><dt><span>adj_params :</span></dt><dd>EmpiricalQuantileMapping(group=Grouper(name='time.month'), kind='+')</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.Dataset> Size: 3kB\n", + "Dimensions: (month: 12, quantiles: 15)\n", + "Coordinates:\n", + " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", + " * month (month) int64 96B 1 2 3 4 5 6 7 8 9 10 11 12\n", + "Data variables:\n", + " af (month, quantiles) float64 1kB -1.996 -2.002 ... -1.88 -1.834\n", + " hist_q (month, quantiles) float64 1kB 256.0 256.4 256.7 ... 259.2 259.8\n", + "Attributes:\n", + " group: time.month\n", + " group_compute_dims: ['time']\n", + " group_window: 1\n", + " _xsdba_adjustment: {\"py/object\": \"xsdba.adjustment.EmpiricalQuantileMap...\n", + " adj_params: EmpiricalQuantileMapping(group=Grouper(name='time.mo..." + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "QM_mo.ds" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.collections.QuadMesh at 0x7fd2ac05a550>" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "QM_mo.ds.af.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Grouping\n", + "\n", + "For basic time period grouping (months, day of year, season), passing a string to the methods needing it is sufficient. Most methods acting on grouped data also accept a `window` int argument to pad the groups with data from adjacent ones. Units of `window` are the sampling frequency of the main grouping dimension (usually `time`). For more complex grouping, or simply for clarity, one can pass a `xsdba.base.Grouper` directly.\n", + "\n", + "Another example of a simpler, adjustment method is below; Here we want `sim` to be scaled so that its mean fits the one of `ref`. Scaling factors are to be computed separately for each day of the year, but including 15 days on either side of the day. This means that the factor for the 1st of May is computed including all values from the 16th of April to the 15th of May (of all years)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2ac051650>" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "group = xsdba.Grouper(\"time.dayofyear\", window=31)\n", + "QM_doy = xsdba.Scaling.train(ref, hist, group=group, kind=\"+\")\n", + "scen = QM_doy.adjust(sim)\n", + "\n", + "ref.groupby(\"time.dayofyear\").mean().plot(label=\"Reference\")\n", + "hist.groupby(\"time.dayofyear\").mean().plot(label=\"Model - biased\")\n", + "scen.sel(time=slice(\"2000\", \"2015\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2000-15\", linestyle=\"--\"\n", + ")\n", + "scen.sel(time=slice(\"2015\", \"2030\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2015-30\", linestyle=\"--\"\n", + ")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", + "<defs>\n", + "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", + "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", + "</symbol>\n", + "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", + "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", + "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", + "</symbol>\n", + "</defs>\n", + "</svg>\n", + "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", + " *\n", + " */\n", + "\n", + ":root {\n", + " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", + " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", + " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", + " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", + " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", + " --xr-background-color: var(--jp-layout-color0, white);\n", + " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", + " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", + "}\n", + "\n", + "html[theme=dark],\n", + "html[data-theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", + "\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", + "\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", + "\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "</style><pre class='xr-text-repr-fallback'><xarray.DataArray (time: 11315)> Size: 91kB\n", + "array([256.609732, 256.438077, 255.200139, ..., 258.855989, 258.750659,\n", + " 258.624197])\n", + "Coordinates:\n", + " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", + "Attributes:\n", + " units: K</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'></div><ul class='xr-dim-list'><li><span class='xr-has-index'>time</span>: 11315</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-3c0ff7c2-caa6-4c68-bac6-7de00a0ade7e' class='xr-array-in' type='checkbox' checked><label for='section-3c0ff7c2-caa6-4c68-bac6-7de00a0ade7e' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>256.6 256.4 255.2 257.0 256.7 256.9 ... 260.0 259.4 258.9 258.8 258.6</span></div><div class='xr-array-data'><pre>array([256.609732, 256.438077, 255.200139, ..., 258.855989, 258.750659,\n", + " 258.624197])</pre></div></div></li><li class='xr-section-item'><input id='section-40ba0939-2801-4b46-bd30-0c8224ac05ba' class='xr-section-summary-in' type='checkbox' checked><label for='section-40ba0939-2801-4b46-bd30-0c8224ac05ba' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2030-12-...</div><input id='attrs-24214987-c12e-43b4-a7b6-43edc734689e' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-24214987-c12e-43b4-a7b6-43edc734689e' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-3887ad47-422f-475d-a63e-bcda279afd29' class='xr-var-data-in' type='checkbox'><label for='data-3887ad47-422f-475d-a63e-bcda279afd29' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2000, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", + " cftime.DatetimeNoLeap(2030, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2030, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", + " cftime.DatetimeNoLeap(2030, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", + " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-abc757e5-f03b-407a-ac00-8724bddc0a6e' class='xr-section-summary-in' type='checkbox' ><label for='section-abc757e5-f03b-407a-ac00-8724bddc0a6e' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-f03e26fd-b1ad-4012-9be5-178208515e8c' class='xr-index-data-in' type='checkbox'/><label for='index-f03e26fd-b1ad-4012-9be5-178208515e8c' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00,\n", + " 2000-01-04 00:00:00, 2000-01-05 00:00:00, 2000-01-06 00:00:00,\n", + " 2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,\n", + " 2000-01-10 00:00:00,\n", + " ...\n", + " 2030-12-22 00:00:00, 2030-12-23 00:00:00, 2030-12-24 00:00:00,\n", + " 2030-12-25 00:00:00, 2030-12-26 00:00:00, 2030-12-27 00:00:00,\n", + " 2030-12-28 00:00:00, 2030-12-29 00:00:00, 2030-12-30 00:00:00,\n", + " 2030-12-31 00:00:00],\n", + " dtype='object', length=11315, calendar='noleap', freq='D'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-00e84528-cfa7-4803-a1b7-58e05c60d8f3' class='xr-section-summary-in' type='checkbox' checked><label for='section-00e84528-cfa7-4803-a1b7-58e05c60d8f3' class='xr-section-summary' >Attributes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd></dl></div></li></ul></div></div>" + ], + "text/plain": [ + "<xarray.DataArray (time: 11315)> Size: 91kB\n", + "array([256.609732, 256.438077, 255.200139, ..., 258.855989, 258.750659,\n", + " 258.624197])\n", + "Coordinates:\n", + " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", + "Attributes:\n", + " units: K" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x7fd2ac0b3c90>]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "QM_doy.ds.af.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modular approach\n", + "\n", + "The `xsdba` module adopts a modular approach instead of implementing published and named methods directly.\n", + "A generic bias adjustment process is laid out as follows:\n", + "\n", + "- preprocessing on `ref`, `hist` and `sim` (using methods in `xsdba.processing` or `xsdba.detrending`)\n", + "- creating and training the adjustment object `Adj = Adjustment.train(obs, hist, **kwargs)` (from `xsdba.adjustment`)\n", + "- adjustment `scen = Adj.adjust(sim, **kwargs)`\n", + "- post-processing on `scen` (for example: re-trending)\n", + "\n", + "The train-adjust approach allows us to inspect the trained adjustment object. The training information is stored in the underlying `Adj.ds` dataset and often has a `af` variable with the adjustment factors. Its layout and the other available variables vary between the different algorithm, refer to their part of the API docs.\n", + "\n", + "For heavy processing, this separation allows the computation and writing to disk of the training dataset before performing the adjustment(s). See the [advanced notebook](advanced_example.ipynb).\n", + "\n", + "Parameters needed by the training and the adjustment are saved to the `Adj.ds` dataset as a `adj_params` attribute. For other parameters, those only needed by the adjustment are passed in the `adjust` call and written to the history attribute in the output scenario DataArray.\n", + "\n", + "### First example : pr and frequency adaptation\n", + "\n", + "The next example generates fake precipitation data and adjusts the `sim` timeseries, but also adds a step where the dry-day frequency of `hist` is adapted so that it fits that of `ref`. This ensures well-behaved adjustment factors for the smaller quantiles. Note also that we are passing `kind='*'` to use the multiplicative mode. Adjustment factors will be multiplied/divided instead of being added/subtracted." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2ac0b2b10>" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vals = np.random.randint(0, 1000, size=(t.size,)) / 100\n", + "vals_ref = (4 ** np.where(vals < 9, vals / 100, vals)) / 3e6\n", + "vals_sim = (\n", + " (1 + 0.1 * np.random.random_sample((t.size,)))\n", + " * (4 ** np.where(vals < 9.5, vals / 100, vals))\n", + " / 3e6\n", + ")\n", + "\n", + "pr_ref = xr.DataArray(\n", + " vals_ref, coords={\"time\": t}, dims=(\"time\",), attrs={\"units\": \"mm/day\"}\n", + ")\n", + "pr_ref = pr_ref.sel(time=slice(\"2000\", \"2015\"))\n", + "pr_sim = xr.DataArray(\n", + " vals_sim, coords={\"time\": t}, dims=(\"time\",), attrs={\"units\": \"mm/day\"}\n", + ")\n", + "pr_hist = pr_sim.sel(time=slice(\"2000\", \"2015\"))\n", + "\n", + "pr_ref.plot(alpha=0.9, label=\"Reference\")\n", + "pr_sim.plot(alpha=0.7, label=\"Model\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2ac027b10>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 1st try without adapt_freq\n", + "QM = xsdba.EmpiricalQuantileMapping.train(\n", + " pr_ref, pr_hist, nquantiles=15, kind=\"*\", group=\"time\"\n", + ")\n", + "scen = QM.adjust(pr_sim)\n", + "\n", + "pr_ref.sel(time=\"2010\").plot(alpha=0.9, label=\"Reference\")\n", + "pr_hist.sel(time=\"2010\").plot(alpha=0.7, label=\"Model - biased\")\n", + "scen.sel(time=\"2010\").plot(alpha=0.6, label=\"Model - adjusted\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the figure above, `scen` has small peaks where `sim` is 0. This problem originates from the fact that there are more \"dry days\" (days with almost no precipitation) in `hist` than in `ref`. The next example works around the problem using frequency-adaptation, as described in [Themeßl et al. (2012)](https://doi.org/10.1007/s10584-011-0224-4)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2ac0ffb10>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6AAAAHACAYAAAC8rgXCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD8NElEQVR4nOydefwVVf3/XzP3fjaWD37YVUAFUwgVEeprhqG5pJaJpqm5oWmbkmmJoJZoKYKmllouSVlqpuhPS8nScq2swIRQIRZBlO2DfOCzf+6dmfP7496Ze84s987dZs7ceT8fD+V+7jJz5sw5Z97v894UxhgDQRAEQRAEQRAEQVQZNewGEARBEARBEARBEPGAFFCCIAiCIAiCIAgiEEgBJQiCIAiCIAiCIAKBFFCCIAiCIAiCIAgiEEgBJQiCIAiCIAiCIAKBFFCCIAiCIAiCIAgiEEgBJQiCIAiCIAiCIAKBFFCCIAiCIAiCIAgiEEgBJQiCIAiCIAiCIAIhGXYDZKG1tSPsJriiqgoGD+6PnTu7YBgs7OYQBBEgNP8JgrBD6wJBEIC8a8GwYQMLfocsoJKjqgoURYGqKmE3hSCIgKH5TxCEHVoXCIIAor0WkAJKEARBEARBEARBBAIpoARBEARBEARBEEQgkAJKEARBEARBEARBBAIpoARBEARBEARBEEQgkAJKEARBEARBEARBBAIpoARBEARBEARBEEQgkAJKEARBEARBEARBBAIpoARBEARBEARBEEQgkAJKEARBEARBEARBBAIpoARBEARBEARBEEQgkAJKEARBEARBEARBBAIpoARBEARBEARBEEQgkAJKEARBEARBEARBBAIpoARBEARBEARBEEQgkAJKEARBEARBEERNkdLTePx/z+C59X8GYyzs5hAcybAbQBAEQRAEQRAEUUm2dm3DRz078RGA9lQnBjUMDLtJRBaygBIEQRAEQRAEUVMYMKzXjHtNhA8poARBEARBEARB1BTkdSsvpIASBEEQRAEMZmBj+yZ0prvCbgpBEAThi5wGSjGgckEKKEEQBEEU4H9t67DkvRfx/Ht/CbspBEEQhA9I5ZQXUkAJgiAIogDtqQ7hX4IgCEJ2ciqoQRZQqSAFlCAIgiAIgiCImkJUOkkBlYlQFdC+vj5cc801mDp1KqZNm4ZFixZ5fvf3v/89Pve5z+GQQw7BWWedhRUrVgifT506FQceeKDwX1cXxeoQBEEQ5WPGDxkkxBAEQUQOWrnlItQ6oAsXLsTKlSvx0EMPYfPmzbj66qux11574YQTThC+t3TpUlx77bX40Y9+hMMOOwyPPvooLrnkEvz1r39F//79sW3bNnR0dODFF19EY2Oj9bt+/foFfUkEQRBEDcJM8YXcuAiCICIBIwuotISmgHZ3d+OJJ57AAw88gIkTJ2LixIlYs2YNHnnkEYcC2traim9961s45ZRTAACXXnopFi1ahHXr1uGQQw7BunXrMGzYMIwePTqMSyEIgiBiAokwBEEQ0YP2DuUiNAV01apV0DQNkydPtt6bMmUK7r33XhiGAVXNeQefeOKJ1uve3l786le/wpAhQzBu3DgAwNq1a7HffvsF13iCIIgapUfrwcb2D7DfoH3QkKgPuznSkNtJJymGIAgiCjC+DAuMEFtC2AlNAW1tbUVLSwvq63MCztChQ9HX14ddu3Zh8ODBjt/84x//wEUXXQTGGG677Tb0798fALBu3Tr09PTgvPPOw3vvvYcJEybgmmuuKUopVVUFqqqUf2EVJpFQhX8JgogPYcz/v2/6F9a0rceu1C5MG/V/gZ1XdtSEAkUBoADJJK3HRHiQXEAQ/kiY6zYy86XW1u4orwWhKaA9PT2C8gnA+juVSrn+5mMf+xieeuopvPTSS5gzZw5GjRqFQw89FOvXr8fu3btx5ZVXYsCAAXjggQcwc+ZMPPfccxgwYICv9gwe3B+KIp8CatLc3BR2EwiCCIkg57/2fgp19UloiRRaWvoHdl7Z6ddWj7r6JBKKSv1CSAHJBQSRnwGpBtTVZ1Sd5uZGtDTX5todxbUgNAW0oaHBoWiaf/OJhHiGDh2KoUOHYsKECVi+fDkee+wxHHrooXjwwQeRTqcti+htt92G6dOn46WXXsLJJ5/sqz07d3ZJawFtbm5Ce3sPdJ3cBwgiToQx/3t6UkinNHT39KGtjTKJm3R19SGd0qArKvULESokFxCEP9o7emF09IIlFOxu70GTXltrt6xrgZ9N2tAU0BEjRqCtrQ2apiGZzDSjtbUVjY2NaG5uFr67YsUKJBIJTJw40Xpv3LhxWLduHYCM5ZS3pjY0NGDUqFHYtm2b7/YYBoNhyBvbo+sGNE2ewUUQRHAEOf8Ng4ExQNcZrTkcum6AMcAArcWEHJBcQBD50Tu6MO7v70FPqkjvn4LWUJvzJYprQWhOwxMmTEAymcRbb71lvbds2TIcfPDBQgIiAFi8eDFuv/124b23334bY8eOBWMMxx57LJ566inrs+7ubmzcuBFjx46t6jUQBEHUGrmkDfJuyIWB2S+USZEgCCIasN3tMDQDap8Go7sn7OYQHKEpoE1NTZgxYwbmzZuHFStW4MUXX8SiRYtw/vnnA8hYQ3t7ewEAZ555Jt544w089NBD2LBhA376059ixYoVmDlzJhRFwVFHHYW77roL//znP7FmzRrMnj0bI0eOxPTp08O6PIIgiEjDSAEVEKrJkRZKEAQhPZ3dKezuSqG9K4V0Wgu7OQRHqGmT5s6di4kTJ+KCCy7ADTfcgFmzZuH4448HAEybNg1LliwBAEycOBF33303Fi9ejC9+8Yt45ZVX8OCDD2LEiBEAgKuuugqf+9zn8N3vfhdnnHEGNE3D/fffj0QiEdq1EQRBRBFTuSIVS4SUToIgiGjR3pXJLWMwoLPHPcEpEQ6hxYACGSvoggULsGDBAsdnq1evFv4++uijcfTRR7sep6GhAXPmzMGcOXOq0k6CIIi4YFk+SeESULp6MPo/H6Bj+ACwQxgUyJe0jiAIguBgfB1QQiZCVUAJgiAIuaAIUHfqPtyO/m3daOjqy1hDSf8kCIKQGsZyiXmYEa0kPbVO9CqXEgRBEFXEdMElFVTA0AEAisTZ0gmCIIgcFLsvL6SAEgRBEBb0jPYg2y8KSDknCIKIArzVk9HmoVSQAkoQBEFY5MqN0MOaJxcbS+7JBEEQUYB/jvHuuET4kAJKEARBWDBywXWHcdGxpJwTBEFID/8cM2jdlgpSQAmCIAgLZhhgXZSu3g7jXpAYQxAEEQF4pZNccKWCsuDGDN3QkVCpPipBEO6k//0eRmzYgs4JGjAu7NbIg5IVZDLJb0mQIQiCkB1e/yQXXLkgC2iMePWDv2PR24/gw84tYTeFIAhJqdvZCQBQWttDbolcMKonRxAEESmEMiwhtoNwQgpojHiv/X1oho5NHR+G3RSCIGSFmTGgBE8uCRGjnXSCIIgowG8ckguuVJACGiPMHXzKbkkQREFonRAh4YUgCCJSUBZceaEY0BiRy25JEASRH4VWCoG0ZqCrN41kMkEZggmCIKIAn4OI1m2pIAU0ltAkJAjCA3LBdWVnew9Y2kBaN8iLhCAIIhJwVk/yYpEKcsGNEZYLLomWBEF4ks32SkqWgK5nBRlGYQwEQRBRwDB4F1xat2WCFNAYQpOQIAgvLMWT1glPaA0lCIKIAnz2clq3ZYIU0BhBk48giEIw279EFs41mdZSgiAI+RHqgBqUhEgmSAGNEeSCSxBEIRTrX1oneIR1k2KJCIIg5EfIghtiOwgHpIDGCMuyQZOQIAgvLBfccJshHfxOOnUOQRCE9FAZFnkhBTRWkAWUIIhCUBZcN4S4T9rFIwiCkB9O6aTYfbkgBTRG0NQjCKIg2YVCod1iAYV7TTvpBEEQ8iPIvaSASgUpoHHCjAGlSUgQBFEUjHbSCYIgooXggkvrtkwkw24AERyJ7j4M2NUNNkgPuykEQUgK1f/0gEsPTBZQgiCICMAroJQ8TipIAY0Re729GY3tfajvtxXYN+zWEAQhNaSI2qDYWIIgiCjB5zyh/CdyQS64MSLZqwEAlN6+kFtCEIS8mFlw6WEtwFdh0cmLhCAIQnYYueBKCymgMYEyOBIEQZQDc3lFEPGirXcX3tiyFO2pjrCbQhAFEUVfCp2QCVJAY4QV20UKKEEQXtDy4A63bhoGCTJEPPnn1mX4z/b/Ytm25WE3hSAKImRzp2ebVJACGhPID54gCD8o5ILrCt8b5MpFxJVeLRPC06dTKA8hP8K6TbKvVJACGhMEgYkygREEQRSFIsQSkQWUiCemEE97MEQkoPAzaSEFNEYoVhkBmoQEQXiQXR+oHIsIE1xwqW+IeGIpoKBNGCICCLYXGrMyQQpoTGBg3EQk4YkgiPyQu5I3VE+OiC1M+IcgpIay4MoLKaAxQZyEITaEIAipUUi09ICzgNJOOhFTGMWIExFC2EilISsVpIDGBAbkHhj04CAIwgXGcp4S5IJrg7LgEoQFrQ5EJKAYUGkhBTQ2MCjca4IgCKIIaNkkCMubilz0iahByePkghTQmCCWEAitGQRBSIwQK04LhQ3eAqqH2A6CCA9ywSUiBdUBlRZSQGMCYwa54BIEkRfGeE8JQoA8uQgitz8VaisIwieUhEhaSAGNJTQJCYLwgMqweEBlWAjCnAfkgktEAcqCKy/JsBtABEPGtY7BYDQJCYJwh4TKPPBJiCiWiIgpJD8Q0YXGrkyEagHt6+vDNddcg6lTp2LatGlYtGiR53d///vf43Of+xwOOeQQnHXWWVixYoXw+bPPPotjjz0WkyZNwqWXXoqdO3dWu/mRwjAYuno07OpMob2zL+zmEAQhIQygZGV+IAsoEVPqdndj5LtbkejoDrspBFEYyl4uLaEqoAsXLsTKlSvx0EMP4frrr8fdd9+N559/3vG9pUuX4tprr8W3vvUtPPfcc5g8eTIuueQSdHV1AQBWrFiBa6+9Fpdddhl+97vfob29HXPnzg36ciSHQctOvp6+dMhtIWQkraexdtd76NF6wm4KERaMUYCjF7wrlyTKOWOMLFJEoDSv3YI9trSj//otYTeFIArCr46U30AuQlNAu7u78cQTT+Daa6/FxIkTcdxxx+Hiiy/GI4884vhua2srvvWtb+GUU07B6NGjcemll2LXrl1Yt24dAODhhx/GiSeeiBkzZmD8+PFYuHAhXnnlFWzatCnoy5IWQUgheYVw4c3tK/DCxpfx6gf/CLspREgwzz8IHibBTnqv1otHVz2J369/npRQIjBUPTP2FY0yQRMRgGJApSU0BXTVqlXQNA2TJ0+23psyZQqWL1/uMJOfeOKJ+OY3vwkA6O3txa9+9SsMGTIE48aNAwAsX74cU6dOtb6/5557Yq+99sLy5csDuJJowAyDyisQeelIdwr/EvGDt+wppIGKSBYDuqVrO9pTHdjcuRWd6a6wm0PEBWbAYIw2qIhoQAqotISWhKi1tRUtLS2or6+33hs6dCj6+vqwa9cuDB482PGbf/zjH7jooovAGMNtt92G/v37AwC2b9+O4cOHC98dMmQItm7d6rs9qqpAVeUz0CcSqvBvqSSzv1ey/0smKQEyIaIouf9ofMhBpea/XzQoUFjOVYnGgYjZL6qihN43aiIzV83XYbeHCI6g1wWe3Z0psM4U1M5eGnNEJFCsf1nNjdkw14JyCU0B7enpEZRPANbfqVTK9Tcf+9jH8NRTT+Gll17CnDlzMGrUKBx66KHo7e11PZbXcdwYPLg/FEU+BdSkubmprN8rdX3WLFRUoKWlfwVaRdQSjVvrUNeVRH1DksaHZJQ7//3Sk05kXiiZ5YLGQQ5VgbWGNvWrC71vBuqNqKvPPMIHDeqHlia6V3EjqHWBpy+to14BelNa6HOAIAqRSCjWup2sS9TsmA1jLSiX0BTQhoYGh4Jo/t3Y2Oj6m6FDh2Lo0KGYMGECli9fjsceewyHHnqo57GamvzfkJ07u6S1gDY3N6G9vQe6Xrrb1+7OrozLDAMMzUBbG7lsESI9PSmkUxp6E2kaH5JQqfnvlx6tFwrnqk/jIIdh5NwOOzt6Q++b9vYepFMaAKBtVxfQS1XV4kLQ6wIPy84DptP6QMiPrulQs+t2OqXV3JgNcy3Ihx9FP7Qn1ogRI9DW1gZN05BMZprR2tqKxsZGNDc3C99dsWIFEokEJk6caL03btw4KwnRiBEjsGPHDuE3O3bswLBhw3y3xzCY1MXFdd2AppU+uNKaYeqfYIyVdaxyWbnjXby5dSWO3+8zGNl/RGjtIER03QBjmbkQ5vggnJQ7//2SSqVzoV0MNA4EchGyRkD3Ix9adr4CgKbpobeHCJ6g1gURcx7Qc4KQH8a4dbuGZZtw1oLyCM1peMKECUgmk3jrrbes95YtW4aDDz4Yqio2a/Hixbj99tuF995++22MHTsWADBp0iQsW7bM+mzLli3YsmULJk2aVL0LiBpc0gwlZD37mRX/xL/WvY8XV1GSKJmwDF+UXSK2GDp/72kcCAhJiMLvG0qoQYSBkh13NP6IaMBXgKAxKxOhKaBNTU2YMWMG5s2bhxUrVuDFF1/EokWLcP755wPIWEN7e3sBAGeeeSbeeOMNPPTQQ9iwYQN++tOfYsWKFZg5cyYA4Oyzz8YzzzyDJ554AqtWrcLs2bNx1FFHYfTo0WFdnnTwSkXYCsburj4AQOtuKmQtE6ZAEfb4IMLDgLiDSkImB9cVchQ0l2dNJ+IDjTQiSggVCOl5JhWhpk2aO3cuJk6ciAsuuAA33HADZs2aheOPPx4AMG3aNCxZsgQAMHHiRNx9991YvHgxvvjFL+KVV17Bgw8+iBEjMu6bkydPxo033oh77rkHZ599NgYNGoT58+eHdl0yIkPdOpOcAw8tBnKRvR+0SMcWxoch0DCwIVc6fyZZe4iYkB1rVKaJiAIKI68eWQk1a0FTUxMWLFiABQsWOD5bvXq18PfRRx+No48+2vNYp512Gk477bSKt7EmCb2GHbnwyAhjDKm0DqOe7ktc4V1LFWSUHAXyJWcLA74XZFi7GO0VECFgzgMZ5gBBFIJRHVBpobR5McFgBh/kJwW0FsjFhm3tWLN9NzoGqsCEsFtDhIO4W8wYA+mfGQRBRgKPEgba2SdCwJwHNOSIKMCNU4WETqmIXuVSoiSYRBl+KdZQTnZ1paAaDJ09/uvnErWFkMadpqeAYAENrRU5+PVThqRIRLwgF1wiGnDrJI1ZqSALaGzgxJWQhZVcmUFaDGSiZccuHLBmM7bt6b98EVFbMEO3XpsuuEQWwZUrfAsodIbha7Yj3VAHfIzuExEUlCuAiBKUBVdWSAGNCWLWxrAnIVlAZaR5dwcUBrS011ahZsI/gqMEoxnqhQweJcaOjzB4067M6yN6gH7htoeICeEPfYLwD0UqSAu54MYExuTZBZIsFJUwod1Bwm7ZozHBIVkyi3Taesk0Pc8XCaKSUAwoER0YWUClhRTQmGBwrnXhPzjIhUdGlJxvdKjtIMLD0EVFhmygHMzzj3DgXYIhgUswEQtyiVwkmAMEUQCFG6a0SsoFKaAxgUkkPJlCLQWEywWjne3Yw3uWKoyGggC3iBoSuOCKFtkQm0HEExpzRATgN1EVGWL3CQuKAY0JhgRlA0yGtXVhxEe70D52cNhNIXiowHjssSfXkcLVVBLEajThr6f8vZIiKRIRD8gCSkQIRfAUIWSCFNCYICTNCFmoHL19N/r1pFDX2hZqOwgPSOmILUI5D2b9jwAgm8WRX9NlqEtKxAwJ5gBBFEJYq2VYuAkLcsGNCQaTJwZUzQpOVBRYMuh+xB67p4ROik0OPpZIgn6h2UqEgRlTR54yRDSQx/hCiJACGhPEkKVwJ6FCSYgkhe4HIUJJiDyQYe1iZAElwoCe30SUkCx7OWFBCmhMkEpAoWyrcsJIsIg7dsueoUu0boSOZIIMk6m2M0EQhIRIZHwhREgBjQsS1QHNue7QYiAj5FoVX5gtu6sMrqaywCchkiHpD68Ey9AeovZhjEuNTY8JIhLII/sSIqSAxgSdEyylib2UpR1EBssCGm4ziPCQwrInKbLlshDco6UoC0PEA9JAiQhhz6tHSAMpoDGBcUmIwp+EmRbIIMQRHHRDYo/dVd8gy5qFYkhmceTbI8GqTtQ+DIzzBKAxR0QMGrJSQWVYYoIoL4U8C5njBSETpIjGFrvCSTGgHkgwR1Kajt1dKaiqAoMsoEQAMMYsDyppPKkIIi/kgisrZAGNCYwrnK6EPAcpC66kUIFxwjYn4z5Fe7Qe6zVvZZShX9o6eqAbDGnNQGd3X9jNIWIAA6PHAxEtGHmKyAopoDFBcK0LW3oy64iF3Q7CRnZnO+RWEOFh2B7QhqF7fLP2+eeWZfjV24/hvzveASCuVzK44PJNMGgtJYKGxhwRBbhxSjKnXJACGhNk8dCiJCcSY20MhNsMIjzsWW/jPF83d23N/Nu5NeN6yH0mQ7/wSrBUZbaImkWGcU8QpULjVy5IAY0JTJKacQYzqAyLtGSTQ4HRQh1XHC648R0HjJsPLh+Gj2CRlaFBRK3DQBuURNSgASsrpIDGBKG+X4jCimHwdcRoYZARcsGNL7pOLrgWXKi6XQmVIZaI6oASQcOPe3JnJKKAuGFC66RMkAIaE2TZITfASMGRFa4OqAwCNhEGNkVLFt/9EMhZQI3M+snv4cng8sqt6RQDSgQGjTUiQgiyDA1dqSAFNCYI5RVCfIAIijA9yKRCIZe+2GO/73GuA5pTQN0/DRt+cyDOGwVEcAiWdhpyRBTgxynJNVJBCmhMkGLHHmYdMeuvMJtCOMjVdyMLaDxhNpfbOD+vLWU8Ox8UweIYUqM4xLIwcqzvRG1jCMm4qpcrgDGG1z58A6988HfaDCXKhDbWZYUU0BgSpguszhiE4CqCIKTBPiXjbQE1/3XZjpFgQ48XpgwZNGIiBuRc0RVUL1RjZ+8urNzxLt75aDVaez6qyjmImMA8XhOhQwpoTDAkqQNqGEZOAabFQC4YZwGlzYFY4ogljPU44FxwZewHvgyLjO0jag6xnnj1xp3GtNxrQ8vzTYLIj0KCprSQAhoTZIkRMjgDKGmgkkGx+oTN4qlLsm6EgSlcM8ay5SfkcnmlLLhE0PCP76oK9rShQlQIe/5yQh5IAY0JskxCwcJCa4FUWAIFZcGNLQ4DqASupmFhWj6ZIHZnP5NBQOabEN/bRASIUJapis8JIb6ZnkVEGQjlgmRYtwkLUkBjArM9OEKDGUISA0IiZCszQQSOPeZTCkUrJPp9sAP7/209Gra2SblS8VZPRhooEQB2Q3u15oWYuFTG2UdEBxo/spIMuwFEMIguuOFNSM1gtB5ISzYGFGRQiSt2YS/Orp39N7dBTemo2/wRGDOgcEuXDEKxuLEffnuI2kfXc/GYCkPVLEqCe3lVzkDEBirDIi1kAY0JvCCphDgHDaEdtBhICQN0WzkOIh7YY8XjbAlXrLWKWXGgJlIofEIW3PjeJyI8qmcB5RVQGttEZSB3brkgBTQm2KddWAKUKNDSYiAVQp1DujexxGbxjLPoZynjBnNagmWYH5SEiAgYMQa0evWixQRbEsw1IsLkxg8ZPeSCXHBjgixZcIV2yNEkIouQ1ZAsKrHEsE/KmCs2jK9bzL8vgWrO3ytZ1neitrFvTFZLOaTRTFQMOaLPCBdIAY0JvMCkZHcuFS4dUFCISU5oNZAVcumLJ3ZFxoixYtPe1QfWmUKio8/piizB9FB4t2Da2ScCwNBzFtCM9FAtBTQ3wcgbhygHRXDnprEkE6SAxgVb+RPGGELQP0XFhtYCueDuh04P/Xhid8GN8UZEX5+GOgDdvWmXEIbw+4WRyzwRMPb9KHvW7ErBDIa9V27OuL+PoXwEROnwQzYEkZfIAymgMUGWgvKiy44cbSKy8HE3lIQoljgVrVCaIQc586IUCqcDqm9HBA2zbSBXywV3924M3N6Zed22C2ipymmIGKAIyyStkzIRahKivr4+XHPNNZg6dSqmTZuGRYsWeX735ZdfximnnILJkyfj5JNPxl/+8hfh86lTp+LAAw8U/uvq6qr2JUQHbuIpqF7ygELostQjJfISY8NXrHHEEsb5gW1KLoxlTD+y6XuUhIgIGN7SntE/q6SAcnIC02lsE2UgxWJNuBGqBXThwoVYuXIlHnroIWzevBlXX3019tprL5xwwgnC91atWoXLLrsMs2fPxvTp0/H666/j8ssvx+LFizF+/Hhs27YNHR0dePHFF9HY2Gj9rl+/fkFfkrzYXXDDagb3MFFIA5UK/n7E2fUyztgVmVhbwoUl07ZlJ4HCR5lCiaDR9WBc9PmNMIrbIyoGrZNSEZoC2t3djSeeeAIPPPAAJk6ciIkTJ2LNmjV45JFHHAros88+i8MPPxznn38+AGCfffbBX//6V/zxj3/E+PHjsW7dOgwbNgyjR48O41IigSNGKKwyLKGclSgWsqjEE/t9d2TFjRMsZwG1JyGSQeFj4GKawm8OEQPsG1LVSlImbK7QZihRFhT2JSuhKaCrVq2CpmmYPHmy9d6UKVNw7733wjAMqGrOO/jUU09FOp12HKOjowMAsHbtWuy3337Vb3SU4V1wWXi7ivY6YoREkEUl9jj2qSSJHQ8HZv0rpSLObRbQhhERBPb1oVpJiMRYUxrbROlQ4iF5CU0BbW1tRUtLC+rr6633hg4dir6+PuzatQuDBw+23h83bpzw2zVr1uAf//gHzjrrLADAunXr0NPTg/POOw/vvfceJkyYgGuuuaYopVRVFaiqfEM1kVCFf0tFUZgwERMJBclk8CHAakK12qEAobSBcMJYZnzk7g2jeyMBlZr/frGvE4oa3zmqmInCmUu/SDA/FIhtCrs9RHAEvS6YqKpNjqjS+qByDyNVDUdWIWoExo1ZFv66XWnCWgsqQWgKaE9Pj6B8ArD+TqVSnr/buXMnZs2ahcMOOwzHHHMMAGD9+vXYvXs3rrzySgwYMAAPPPAAZs6cieeeew4DBgzw1Z7Bg/tDUeRTQE2am5vK+n1dfULw19pjj35orGvM95Oq0G97ndCOlpb+gbfBznttm/CnNS/jiDFTccjICWE3JxQYY5mcK9l7029AvRT3hshQ7vz3S0N9nbBl3NRYF9txoGQ1UEUBmgc2Cf2SSKih90tCVWFk21RXF357iOAJal0wadrRIMyDAQMaqzLumvrVWwaBpn7xXYOICmFuZihKzY6loNeCShCaAtrQ0OBQNM2/+URCPDt27MCFF14Ixhh++tOfWm66Dz74INLpNPr3zwys2267DdOnT8dLL72Ek08+2Vd7du7sktYC2tzchPb2HkcCgGLo60nnPMoUYGdbJ5rqgk8w0tHezXu2oa0t/EzF/97wX7R2tOGNDW9hdMOYsJsTCgbLOhlm7017e491bwxm4M8bXkZSTeKYMUdKvVFTa1Rq/vultzclhMl0dfdKMUfDgJmZbw0Du3Z1Cf2iaXro/aLpOtRsm1K96dDbQwRH0OuCSUd7jzAP2nZ1ol6tvEDf1dlrxZd2dcZ3DSIqQS7rpmGwmhtLYa0FhfCj6IemgI4YMQJtbW3QNA3JZKYZra2taGxsRHNzs+P727Zts5IQ/frXvxZcdOvr6wVrakNDA0aNGoVt27b5bo9hsKoF1FcCXTegaaUPLsPIRTEpDEinddQpwQ/WtMZFUzFW1jVVCk3XwVj5fRxldEOHwnKRwem0bvXF1q5tWLPzPQDApCEHoaVxj3AaKTGMMfTpfWhMVserIKixqetitKOmxXdOALlSh5qmC/1iGOH3CzNy89Vg4beHCJ6gn1n2eaCl9KqcP5VOo70rY5AYXqVzEDGBr/ogicxZDaIov4bmNDxhwgQkk0m89dZb1nvLli3DwQcfLCQgAjIZcy+++GKoqoqHH34YI0aMsD5jjOHYY4/FU089JXx/48aNGDt2bNWvIyo4VeuQsuBySYhkKcNiinFSJhoJCHtSKj7zoMbdM53FuCxHHl758O/41Tu/xfrdG8JuSnlQ8qkcVl8w6PZMnBJ0Ez9n450siggKe3K6aiUh2tXRB01n0HSGnR09VTkHEQ94OVMWmZPIEJoC2tTUhBkzZmDevHlYsWIFXnzxRSxatMiycra2tqK3txcAcN999+H999/HggULrM9aW1vR0dEBRVFw1FFH4a677sI///lPrFmzBrNnz8bIkSMxffr0sC5POuzp08NKbS6Wg5FjMWCcoBlXGACFuzdiwXH394kcH3ZsBmPAh51bw25KWdgFyjjXAbUScjEG2PVPCeaBIuFaStQ2zObiV615wG+oUE1qoiyY60tCAkJzwQWAuXPnYt68ebjgggswYMAAzJo1C8cffzwAYNq0aZg/fz5OO+00/OlPf0Jvby/OOOMM4fennnoqbrnlFlx11VVIJpP47ne/i87OThx++OG4//77kUgkwrgsKXGUVwinGWK5AElWA0v9lECoDA1Hfv3cfTKYgdZdPZnMhLLcNMnY3ZXC1vYujB3gLBcVKWzjIM5TIlcHNOOi7vpZiDCPDSOCqBZ2L6Fqlf8xeE8bsu4TlYLWSakIVQFtamrCggULLMsmz+rVq63Xzz//fN7jNDQ0YM6cOZgzZ07F21grCIWdEV7dOH5nU5ZUNmbfxNsFF+JOIaeAbmvrwfZdGTeoto4+DO8XbNuiwMZt7ejS+rBu825gXOHvS4t9o4oe2HDddJGhX/g2yNAeouaxe045XNMrdR7aXCEqBo0fWYle4RiiNJwVpENqBv/AkmNhYKZ/XYwfdPYYUF4Z701prq+JHFpWEEtr0XZZdbrgxtP9LVOWyLSAMocboH2+hAK/qRjjtYsIDnuixmolbhTmW0ib5URtoAiRCrROygQpoDHBkWQmJAFK2M2UZC3IRYBK0qAQYIYhWKR5AYDfNCBBNz+RH0OO+xvx6ykRWdZL39C8JALA7jlVtQ0q3gJKLrhEidjlFUpCJBekgMYFRxBoWFlwJcxIlu2LOMtwulnzMAu/UaALr2k32g3LjTvig8ihfkb8ekqFMSF3v1MIlqBfGFlAiYCxj7NqjTt+voUVLkTUCszlFSEDpIDGBHua/rAEZXsSIhky3KntnRi1/EM07mgPuymhYVcsmeFu9SRB14vsJkbEH3F2YU+G+RkW1gYZc8kiLsM8oHlJBIzDAlol5VDMWUFjmygNBia44Co0lKQi1CRERIDYXV9DS0JkE3DBQt8F6bdhG4yPuqCz7cCRITcmJJyuVZwAYBj42OZd0FUVxiRawd2omUzKThNoKM0IG8ZVL1eYnBZQAdnaQ9Qk9hhxvUrusULYR4w3wYjycD6PaZ2UCVJAYwKzuSGEZQHlz6sga2FRQy6XY9Y2i3HNQ0O3W3hyf6u7d2NUa1fm/Y7OQNsVHRgSuhF5BdRhAY349ZSKw9XQ+Y2gmuINxWYTAePYt66WBdTDA4cgioaSEEkLKaAxwRm7EdKuoox1BrONiLN7Rj4DD9M07nXE61xWiXEf7sTIHe3YMWFI2E0pD0lixcOGd91SGHNaYWToFxKsiIBxuuBW6TxiQoLqnISoeTLjiMaPrITt/UgEhe1JYeghWUA5QU5hTAoLC2MMDCzWyQ4Mm/VXyIIrvA7/fsnI4PYeKAwYsDvaccROy1887zcDnyTNZW2QolsoBpQIFvs4s3vOVAzuOWN3+yWI0qF1UibIAhoTZLGA8gKtAjkeLu1dfdA6U1CT9WE3JTQcgoXhLtzKcL9khE9YE2Uc60RMNxwYM4R7KaViLrgpSNAeouaxJyUzqjQPDAnrhRPRI1PPmX8jtKYQLpAFNCY4FIywYkB17sHCABnyC3T1pMAY0NunFf5yjcIcFnGPOqAxjpPNizmfakxBj6teI1w2Y85swNJ1jGztIWoSxwZV9euAxnUTjCgf+8iRpvQfAYAU0BghnwUUAAxIILBbD7v4Lk4Gs7vgugsANaZfVY4aGTpOV9N43nBnrFuhpEQhQGVYiIAJykNCyDpNY5soGQlzjhAWpIDGBPuDIrTU5lw7FEgiOOVqaITajDCxW8SZRyFwu6JKZLB2VmUw6ZdDQIXmZYfZYtXt/aBI0C+MXHCJgLGHYLCqbSBTFlyifAybC64SXlMIF3zFgP773/8u6eCf+MQnSvodUQ3k2AkSLAusenXEiiLbpjgvTrpht/jkFE2veFAiQy0VTXcmwY329ZQKY0xYMh2CtwT9wq9XMrSHiAEOT/TqjDtGSYiICpBJMCm8EVZTCBd8KaDnnXceFEUparFRVRXvvPNOyQ0jKov91tkVjqBwWNpkerjEeHFyWMiFP3kLqET3SyJMi5gMlrFycLrgRvt6SoUXXBQWosdIPgQLaHjNIOKDff03qrWBzITdn+qcg6h5pFy3CQvfWXAff/xxDB482Nd3P/roI3z5y18uuVFEFbDv4Ic1MYN6gBWDlUBGgraERL6YN0E5jW8XeWJwGVMjb4myNV+GMklhIJYlYi4bL+H3izBHaWOICIRgNpDFdTT8uUZEE/vzi5IQyYUvBfRTn/oU9t13XwwcONDXQQcOHIhPfepTZTWMqDCSWB7t8qy9/mQomNarkJsRJvYNCV7gFsqweNR9+6hnJ97+aDUOHjoBLY17VKWNsmIwxo2daD/gHLGOMiQJCwH7povDY0QCxVxYr8JvDhEDmB7MBrKYeT2eaxBRPo7s5YRU+EpC9Mtf/tJSPr/zne/gtddey7vT39zcjF/+8peVaSFREaQpw2JTOOWwsJAF1HEfDHcBwGve/3vbW3j7o1VYtn15VdonM4Ytrjna2NeJkJoRMnohjxEZ1gqyEhEBY49xr9pGtpBfi8Y2URqOnAw0lKTCtwuuiaqquOyyyzBo0CDMmDEDM2bMwNixY6vRNqKiyJndknlY1IJtRNgNCB9Hen2PEg9e46ZP78v+m6pC6+Qmk2mvNjYxHPc34tdTKmIWXDkFGQkLwxA1jt2iVK3lQbCA0tgmSsTQJdw4JCyKLsNy++23429/+xsuu+wyLF26FJ///Odx1lln4fHHH0dnZ2c12khUAIeBKzQXXLurZyjNEOESyMiimAeN0zLtYQH1cGkx+y2O/WcYRs244NqJ4/0EAJ3fGGPMKXhLcJ8VHxtDBFFNWJXKcglighRCAhFFmD3EK85xVhJSUh3QAQMG4Mtf/jIeffRRvPDCC5g2bRrmz5+PadOmYfbs2Vi5cmWl20mUi93CpYezqNuzrUoRA8oJkzIIlmFgj+0Rh0vhZCdmv8Wx/3SGXBdFXBFwZkOO9vWUCnPUKxbHvRxyjOCnGF4ziNjg9JSp1nmoDihRPg5phcaSVJSkgAJAKpXCH//4R9x00024//770dLSgpkzZyKRSOCcc87BL37xi0q2kygT54MjLAuoHO3gyZXQiO/DzrlQu5de8eofsoBmifz1211Nw5+fYeAoNyFhHVDhVsnQHqLmcXjAVCsJEf9EorFNlIjdAirHxiFhUnQM6NKlS/HMM8/gT3/6E3p7e3Hsscfi5z//OY444ggoSub2jh8/HnfddRcuvvjiijeYqAxhlT+RJRmSOyyWFjzAuVCLWUDJApoPgzFOGYj49Qdk4ZAdh8utlLFElISICBbn87tKG1QG/8yhsU2UhiNiiMaSVBStgJ577rn4+Mc/jssvvxwnn3wympubHd/52Mc+hunTp1ekgUSFkMXyaLck2AW7MLASyMT3YWffjxAzu3LCgMfGhaWAxrD/BDfyiF8+E0rKILYPbGEcM0nT+ddQplDGGP6y6VUwxnDMmM9AVUp2ziKqiCMLbtXKsJACSlSAmHrwRIWiFdCnn34a48ePz/udI444AkcccUTJjSIqj12wDGtRd+yghtIKO5wLbsgtCQuHBZSv/VmMC24Me1DnNlGUyAtL9tyqUb+e0rDX/WSwxapLcZ9rR0j/qHcn1rStBwBMGjYRw/sNC7lFhBuOGPFqrQ/CBlC0xzYRHk4POxpLMlG0Ajp+/Hjs3LkT7733nrUrzBhDKpXCf//7X3zzm9+seCOJ8lEc9f1Cmoj2B5gMSYgEY0c8FyiHSzb/J+8O5WEJUlJpNG9tB0a3VKF1csNbxyI/fqgMCwBA59YlBjdLT/j9otistFFG4/pbk+GZQLhi95yqlieVuKES8cFNhIYjeRwNJakoWgH9/e9/j+uuuw7pdBpA1rKWjf3ce++9SQGVFKdrXTi2x4IF3sOAyrDkFyx8uEMNWr0Zyfe3Qu9NAh+vShOlRef6JOoWUFk8JcLG4alhr1csQbfwTbBvMEaPqLc/JthDeaqWS6LwpidBFCKsXCeEP4oOtLj33nvx+c9/Hs8++ywGDhyIxYsX45577sHw4cMxa9asarSRqADO5AGhNcTWDhkWCO5hF1NByKFoeCQe8trxTvT0Zf9NVb5xsmOINSOjjT1WPOrXUxrMpnBKWdC8huLkUrqOdZt3Y+2Hu5HWyAIqK87HRJXGHSkORAVwSis0rmSiaAvopk2bcNddd2HcuHE48MADsXPnTnz2s5+Fpmm49957ccopp1SjnUTZyJGEyFGGRYbdTSHcRIL2hIA9yYo97rNgmRErkVP8Fnh7vGCkoayBAJwOIs5QgfD7RREXrvAaUgG27exGbyrTx1vburDPHuG2h3AnMBdcYWzX0PpKBIp9I9EstWd6bRLhUrQFtL6+HvX19QCAffbZB2vWrAEAHHTQQdi4cWNlW0dUDkfsZWgmUOEvGSygvNukFApxKOQrv8ElJPISvE0hIYbCguCeKcF4LgdHlksJFK0wKFQHVApq6NbwibzsYRqERDiy6Vc/CVHEl1QiRNzGZ1yfaTJStAJ60EEH4YknngAAHHDAAfj73/8OAFi7di3q6uoq2zqiaoSlaDlcgWVS+OJchsVh+eIsoPxmhcf9irEB1LaJUmMdEFNXOLvC6VgvZRjoNZQpNM1ZmCluS14cHkxVGneshsY2ER4OAwcNJako2gV31qxZuPjii7HHHnvg1FNPxT333IPPf/7z2LJlC0466aRqtJGoANJYNuyWBQkUUMECGteHHfMuwyLqV+SCa0dQTqJ+/XbFK6ZPbLvCaY8Bla5XIj7uNE7plMErhvAgqHriPkp/EUQhnIaWbKJJ8sCVgqIV0KlTp+JPf/oTUqkUWlpa8Mgjj+Cxxx7DnnvuifPOO68abSQqgcPyGM6i7nyWyPBwYdb/DV0LtykhYR8P4kOfK0nhMW4YY0jrBhIxtF4YNVQ2Qs75GTyO+WATZOTIdlw7ViJd0zBp/Q4oANj42plPtYYjBKNqFlAUzjtAEAWgzQu5KVoBBYARI0ZYr/fff39cd911FWsQUSUcz42QLI+BpXH3Dy9MxnX33eFyyPcDXwfUQyHZ3dELdKfBOnqq0j6Z4cdwMYrJP7csw87eXTh2zGdQl5AlfCFfLHB8cCZbkU8pqqVNfGV3OwZ3ZDJpY9fucBtDeGN7XlfteVnLYQ1EYNjHp8Li69UjI74U0PPPP9/3AX/961+X3Biispx++snYunWL8F5DMom9WwbhnMOP8nWMZ555Cg888DP09fXh/vsfwn77jS2rTUFl0SsGwdZnr/cXF/KWYSlsaUlrBuoAaFr49zNoSsmC26v14s3tKwAAmzo/xNhB+1a4VSVin48SbBCFgd3i6fhbBs28hoR0TeM8T2rIo6DWcDyvq7Q+MK/nD0EUg4t8SeNJHnwlIdp7772t/4YOHYp//etf6OjosEqxpNNpLFu2DGPHlqecEJXn29/+Lp555nlc9OVTcMln/g+fnzQBH3V24bePPurr9z//+U9x6qln4De/eRxjxuxTdnuc9UjDXQwYY6IFVIKY1DBwuuByMThCUXB34dAsCSGHa2Kw8MqJ3+vnM31qhjxu386cDfG7n4BzXbKvC4ps/RLxjQI+xpaSEMlLYHVAUTubK0R4yOBhR3jjywI6f/586/XcuXMxc+ZMzJkzR/jOnXfeiXXr1lW2dUTZDBgwAEOGDMWAxiYkGhswoLEBn9p/Hzz/39Xo7OzEgAED8v6+s7MTkydPwciRe1akPc4suHLtdsd1d8xZn9XdBddTFmBmHG38+k8Ywz7HD5PU7dvh1ilR24KkUAyoFMO8hu4N73kig1cM4UEIZVhqaZwTwWIfOQqTtKRWTCk6BvT555/H//t//8/x/owZMzBjxoxKtCkS9PRp2N5W/Xi3RELBR11pdLT3YEhzI5oaSgrbFRSDhJIxfKuqio6ODtx550K89tqraGpqwlFHfRbf+ta30dDQiGnTpgIAvv3tb+DQQw/D3Xffj/Xr1+KOO27F22+vxIgRI3DGGWfjtNPOAAA8+OB9WLv2f2hvb8f69etw8823YuLEg/Gzn/0UL7zwRwDAnnvuiaP3bEFjXR129/Tijku/jptuWoh77vkJduxoxdSpn8R1192A5uZBAIA33vg77r//HmzcuAGjRo3BrFlXYOrUTwIAXnnlJTzwwM+wZctmjB07Dt/61uWYPHlK8f3CrVK6ZApxYDiu230HmsFj8Ta/EkNhoRQFUlZF3SH8x/B+As6YT4cLbpCN8UARZHQZWlQ6vBu7bJuSRA7n5kAACihZsYgSsa8lDHKs3USGorWZ5uZmvPPOO9h3332F95cuXYohQ4YUday+vj7ccMMN+POf/4zGxkZcdNFFuOiii1y/+/LLL+OOO+7A+++/j1GjRuE73/kOjjnmGOvzZ599FnfeeSdaW1sxbdo0/PCHP8TgwYOLvTxf9PRp+OFDS9GTqr7rnAJAVRUYBkNjfRLfv2BqaUpodkHf1d2Df7+3CQcceAD69euHa6+9Cpqm4ec/fxB9fb24887bcPvtCzF37g/wzDPP45RTTsBNNy3E5MlT0NfXi+9973KceOIXMHv2tdi4cQMWLrwJ/fr1wwknfB4A8Nprr+B735uDiRMPxpgx++C+++7BqlXv4NZbf4KGhkbMmzcXzy5/F6dPPcRq2q9//UvMm3cTGAPmzLkSv/3tw/j61y/F+vXrcPXVV+DCCy/BMcccj5df/ivmzv0uHnvs/2Hnzp246aZ5+N735uLjH5+If/zjb/je976Nhx56DKNGjS6iW5jgTmcvtxAX7M94r7hPb5cWJvwTJ0qpA2owhu27etCX0pHaUx4XXEeysjjeUDhDh2TPgiudS3CR8Osuuc1Fh2rVE2ceG6AEUQxuyzTT9RLTrxKVpujbcOaZZ+IHP/gB1q1bh4MOOgiGYeDNN9/EI488gquuuqqoYy1cuBArV67EQw89hM2bN+Pqq6/GXnvthRNOOEH43qpVq3DZZZdh9uzZmD59Ol5//XVcfvnlWLx4McaPH48VK1bg2muvxQ033IDx48fjpptuwty5c3HfffcVe3k1x223zccddyyElk7BMAwkFBVjhw/BGWeehQ8//ACvvfYKliz5q+WKe/XV1+HCC7+CWbOuxJAhQwEAAwc2o7l5EJ599mnssUcLLrnkmwCA0aPHYOvWzXj88d9aCujgwUMwY8bpAIDe3l489dTj+MUvfoNx4/YHAHzuc8fjvnvvw46OLtQlEwCAr3716/j4xw8CABx//AlYteodAMBzzz2Dgw+ehJkzLwYAnHfeTPT29qCzsxOPPfYbnHzyDBx/fGasnHHGWXjrrWX4f/9vMWbNusJ3/9gtoHF1/8pn+fKsCcphCuRyCOYBU0IMaHdfGq27Mh4U72/vwCHDq9KyEgimzILsOJOl2fsh/Nh18e+QGlIheEtFtZQaonyc86JqJwrgJESt4+ZuS/tb8lC0Avqtb30LiUQCDz/8MO655x4AGbfK2bNn4ytf+Yrv43R3d+OJJ57AAw88gIkTJ2LixIlYs2YNHnnkEYcC+uyzz+Lwww+3svHus88++Otf/4o//vGPGD9+PB5++GGceOKJlgvwwoULcfTRR2PTpk0YPdq/NcwvTQ0ZS2RQLrgDm5tKdsH96le/junTP4unf30P/vXv/6C9pxfTPrYf+jc1YsOG92AYBk499UThN4Zh4IMPNmH8+AnC+xs2bMC6dWtw3HFHWu/puoFEImH9zceKbt78AdLpNL7xjQut9zRNAwPQ1t2N4c0DAUCwWPbr19/KiPj++xtx4IFiG0zld8OGDVi//kX8/vdPWZ+l02l88pOfKqp/MkmIcn/rMV2dnAKtuwCgeLrgWj64FW6Z/JTitp3mLD5pmTIHk7AHwC0GVJeu7IkivI72fdN1A+ZTJOruxDWNY3+qSmuX4b4BShBF4bKZRS7+8uBLm1mxYgUOOSTnMvn1r38dX//619HW1gZFUbDHHnsUfeJVq1ZB0zRMnjzZem/KlCm49957YRgGVDWXoPfUU09FOp12HKOjowMAsHz5clxyySXW+3vuuSf22msvLF++vCoKKJBRQvcZObAqx+ZJJlW0tPRHW1tdSSUuWloGY9So0Rg2eA98YdIEPPrGf/D7/7yNbx//BahMx4ABA/CLX/zG8bthw4Y53tN1HVOmfAJXXnm15/nq6+uF7wPAz372CzQ19QMALHl2MRIb/od+9XXoSWcUzbo6sQai+cBJJr2Hp67rOOecCyzLq0lDQ4Pnb9ywP9riujg5HvK8YOHLBdf8QgUbFRGEPvGbBVc3UJ/WUa8ZUidFiKvw56j7madMURgwMDDGKaERv0+6oVsKaFwzkUcB53Oiameq1oGJGOEmrtDIkgdfCujs2bPR3t6OadOmYfr06Zg2bRoGDRqElpaWkk/c2tqKlpYWQWEZOnQo+vr6sGvXLiF+c9y4ccJv16xZg3/84x8466yzAADbt2/H8OGiD9uQIUOwdetW3+1RVQWqKtseN5BIqMK/xaKqCpJJFWBAUlVx/MQD8Nt//gevv/43XHDBxejs7EQyqVpWyLVr1+CBB+7FddfNy/wue+5kUsW+++6L119/BaNHj7Ksnn/843N49913cOWVV0FVFSiKYv1uzJgxSCQS6Oxsx4QJGUtmQ0MD/rJqHaaPHwdVUYTjm+01jzFmzBisXr3a+gwALrlkJr785bOxzz77YOvWzdh3332sz+66606MGbMPTjnlVN/9o0N0m1QUCOeLDQpzWHhy/cB/xlz7R2GZ7ygen9c0Sk4R8H39TMMn/7cd9ZqBur07PX9T7vwvBcGyxuI5HxSI/cBYvvkRPLqRiV3n2xTp+8RKmEMxJox1AQAU+3NCqdK94uabwmg8EKWhqs51W60xGS+staAS+FJAn3/+eWzatAmvvPIKnn76aVx33XU48MAD8ZnPfAbTp0/HxIkTiz5xT0+PoHwCOetZKpXy/N3OnTsxa9YsHHbYYVYSot7eXtdj5TuOncGD+0NR5FNATZqbm4r+TSKhon//BrS09IeqAlCAkXsMxEGjRuKll/6Ka665BkceeSR++MMf4LrrrkMikcD8+Tdi0KBBGDNmpHWcgQMb0dLSH2eddToWLbofd9yxABdddBE++OAD3HnnbbjwwgvR0tIfTU31qKtLoKWlPwCgpaU/zjjjDPz4xwtw4403YsiQIXjhxRfR3tODQf0a0dHbBwAYNKjJ+g1/jJkzz8dJJ52Ep59+HJ/97Gfx/PPP47331mP69E/jgAPG4pxzzsGUKZNx1FFH4a9//Ssee+wRPPTQQ9ax/NCTTkABwLK3vn9TfVG/rxUa6hOCxG1a3gFkNgqynyUSinf/KBnhMW7919iQzPUdg6/r779DQb1uAArQmO4r+JtS5n8pqDbNK+/9rmEaGsX5YK6fJori7z5XC03XoDDFSoWrINz2lIvC9W9dnRrpawmSoNYFk0RChcHNg7pkde6VquaeOaoa7bFNhEdTU72jttiA5ga07FF74ynotaAS+A4oHD16NM4991yce+656OvrwxtvvIFXX30V3/nOd9DT04MjjzwSRx55JE466SRfx2toaHAoiObfjY2Nrr/ZsWMHLrzwQjDG8NOf/tRy0/U6VlOT/xuyc2eXtBbQ5uYmtLf3QC8yQ6uuG+jq6kNbWxcM3UAia+ibtv9+WPvRbtx003xce+08/PjHC3HBBTORTCZw+OFH4LvfnY22ti7rOB0dvdm/Ffz4xz/FnXfehhkzZmDQoEH40pe+jC9/+Vy0tXWhpyeFdFoXfvuNb8xCKqXjsstmQdM0DB82FKdOPggqFMsXYvfuHvTvn/kNf4yBA4dg/vxb8bOf3YXbb78d++03Frfeegfq6wdgn30+huuv/yF+8Yv7sHDhQuy99yjceOPN2H//jwvnL0R3uifTDLMtHd1F/b5W6OtNC74p6bRm9YOuG9ZnGve+CWMs4wLIMp67YfQfYww9Wi/61QW/CHd191r9ozDm6/p3t/dYv0n1pj1/U878LwXdMJDkxoGm67GcDz1dKbE8U1qz1k8AgOHvPleLtKEBXAI1xoxI36dUKo367LX09aYifS1BEPS6YKKlNWFepPqcz4NKYBg5eUXXw51rRHTp7Ox1+Nzu3tWNJHPXMaJIWGtBIfxsGpWUjLihoQHTp0/H9OnTAQDr16/Hq6++iieffNK3AjpixAi0tbVB0zQr1q+1tRWNjY1obm52fH/btm1WEqJf//rXgovuiBEjsGPHDuH7O3bscI1j9MIwmCPxhEzoulF0DOjixX8AgMzvuGSvjfV1uOaaOTj66Ez85PXX3+T4rXmu119fKvy9//4H4u67HxC+axiZB8aFF34NF14IoZ3JZAOuvPJqK270d4/8Asl174ABaG5qxE0Lfozhw0dav7Ef4/DDp+Hww6e5tu3oo4/D0Ucf5/qZX7RsHKrZN3paLynWNurouiGu0zrL9QPjPmPM0T+ZRE6ZxPkKnJ8Hwd82/xMrWt/B9FFH4ONDDgz03LqmC33n5/rT6bT1G03XCv6mlPlfEoatAIIRzv0MG00X76lhGBAcnFzmQZBoug4w7l6x4tc+meDnkG4ENNZrgMDWhSxMZ455UY3zM34dCnmuEdFFt63jQGazqxbHU9BrQSUo2Wl4x44d2Lx5MzZv3ozGxkYcf/zx+OEPf+j79xMmTEAymcRbb71lvbds2TIcfPDBQgIiIJMx9+KLL4aqqnj44YcxYsQI4fNJkyZh2bJl1t9btmzBli1bMGnSpNIurhaxZzkNKdGDva6gEXLyDMMwREuHPflITLDfBz67oViGxXm/DI+ERUGyuTMT772la1vg5xbnEvOVuMfQuXEmUwKZfNmQY4Qju6dkm5MM9tgmudpXLDo3h6gOqLzYn99VWx+oDAtRAVzz+9FwkoaiLaCvvPIK5s6di7a2NtfP3333XV/HaWpqwowZMzBv3jzcfPPN2L59OxYtWoT58+cDyFhDBw4ciMbGRtx33314//338Zvf/Mb6DMi46g4cOBBnn302zjvvPBx66KE4+OCDcdNNN+Goo46qWgbcKOJ4cITUDimzSXJ/G3pMVyd7fTfutVJAARV/EE7/mXcxjIyyvPKuMFM5yO/Oz2f6lEnJs7ck6uU9SsUxjCTLVGwwJt6sqN8mIdO2XH1NcARVD5cUUKISuNUBpfVFGopWQG+66SYccsgh+MpXvuIZq+mXuXPnYt68ebjgggswYMAAzJo1C8cffzwAYNq0aZg/fz5OO+00/OlPf0Jvby/OOOMM4fennnoqbrnlFkyePBk33ngjfvrTn2L37t349Kc/XZQ1NhY4nhshLeq284ZtAWW63Z00nouTU+DmBELkFwYMsJySyrIuuQEn9DKVOPtGSyDntj3QDMOAWiAjnSFYmOUZc3aFUyblOEjs98Rxj8JetyTbyCsXw+ZFQMiJUPoHQT2/aTwQpWG4jZ2Ir5W1RNEK6Pbt23Hvvfdi7NixZZ+8qakJCxYswIIFCxyfrV692nr9/PPPFzzWaaedhtNOO63sNtUqDsEyJDcnu+AUtvCt2+p+xnX33W455BU5pdBuNPP4boCYD5owFCZ+DCvMn1AmWEBlGnM1ptiUiuMeBmX58YtzxyiUZlQKQ5d0PhAitnlQtfWeLKBEBXCTc2Wuux03io4BPfzww/H2229Xoy1EFZFF8XO49IUc72N3x4jt4pQn5k0YOgUsoArC6cNQLaBiB/lUQOUUsORpScg4YubtgneQjXHCmG1vP+I3zivmnJALBmcCuuqciMYAUT7uOStobMlC0RbQefPm4fTTT8drr72G0aNHO1ztLrvssoo1jqgkdgU0pFZI5oJr6Hb3yXguTvld+vInGWLZouHM/eNAsBTQEBrAb2JkFHAfCiiX7EqqpCuOjaqQ2hEy9g06JY+HQBg470u0b5QYEx3TTcAoEFgoj5wbdES0cFtLwpY5iRxFK6A/+9nPsGPHDrz22muOOpuKopACKin2HfvQHvKOyR+yC65dsIyr+5d9fAhKp+fXAGQtntkPFMZggCFR8QbmhzEDiZTuHvNR7XMbYgf5SXLAxx4zmTIvOzYi4jkfZI+xdMakhtOOSmEIHhcRv5haJqiNGHLBJSqA2+auVBu+MadoBfTZZ5/F/Pnzceqpp1ajPUTVkEWgsru2hdQM6/wBuRRJTl6BVhAGfOQ1D6EP9/jfFuz93lYYhzUB+wV7biEGFCXEgMZzyEmNw43csFtEw7aA2toTfQ0095omhLQ4Q3noXhHy4rZBElsjg4QUHQPa1NSEww47rBptISrMtGlTMW3aVGzdutXx2dJlb2LatKl48MH7Sjr2m28uxbRpU319d8mSP+D0008G4JbjpLD15/TTT8aSJX9w/WzLls2YNm0qtmzZ7KstduzWKl33vzhNmzYVb765tKTzSofjxnj84RZTYeTsjqYFNGiadnYCAJI7dwd+bkEZYIDmYwwxaQVuyZLthIVjl1yyfmDw3iSKIGJSLok8Aoj8UBIiQmYoBlRqilZAv/KVr+Cuu+5CT09PNdpDVJhkMom//e0Vx0Rc/b//BV4qA0DFs2wOHz4CzzzzPIYPH1HS753ukvHcHbMvyqJSld8H11myIsREQCG419hdevy44Eob8ya562lgOFzz5eoHRxKiiMOvP2RVk5jALKC540beuk+EhrsLrkTP25hTtAvu0qVL8e9//xvPP/88hgwZgmRSPMRf/vKXijWOKJ9Jkw7D66+/iv8bM9R6r0/T8MGHm/Gxjx0YfIMqnIQokUhgyJChhb/oAWXBzZJPwPZKSGR+zCfhYeH0YVrTkerTUK8Fbz1xJNbysYkhZv2UaMyR/gmgcJKfsF1wa66YurAhE9NBFwHs96Z6ZVj4c1bnFETt4+aCG1sZT0KKVkCnTJmCKVOmVKMtRBU48sjP4J57foLD9jwKddn33mvdidGj9ka/fv2E7y5Z8gc88shD2LJlC/bbbyxmzboChx6acbfu6urEwoU34+9/fx1DhgzFF784Q/jttm1bcfvtC7B06b/Q0jIYJ510Mi644KtIJMR0NKUm91i/fh0uvPAr2LhxAw499DDMnn0dRo4ciS1bNuOMM76IJ574Pfbccy+899563HXX7fjvf1dA1zWMH/9xzJ59LfbdNxMYeN9992DJkt+jo6MTH//4RJz5la9Y5/igbTcev/0OXLf9GowaNQoXXfQ1HHXUMdbnv/zlA3jyycfBmIFvfnOWr3ZHBftCLcY1FpAGGLO5Awa/wHd09SGR0tG5O3jPDLsCaeiFlWBDWhdckbAVrbBwll2Rqx8c7Yu4lUiYQ5JZmwmegCygEtSWJqKPbJ4rhEjRCihluc3Qp6ewq3dX1c+TSKroSTRhd1cPBiab0ZCoL+r3Y8fuj6FDh2PjtlZMGNQMAFi7fQcOOHQytmz7yPrekiV/wB13LMSVV16NiRMPwnPP/QFXXXU5Hn30SQwbNhy33jof77+/AXfffT927WrDTTfNs37LGMO1187G/vt/DL/85SPYsWMHbr31ZqiqipkzLxYb5LCA+lNWnn56Ma6++jqMG7c/fvKTH+NHP/oB7r77fvFYhoGrr74Cn/jE/+G7352Dzs5O3H77Avz85z/FggV34JVXXsLvf/8Ubr75xxg6dCjuv/8e3H/vzzFj/73R1ZfCM/9ZiRM+/wV85eyZePvt/+Kmm25AS8tgTJo0Gc888xQef/y3uO66GzB8+HD8+McLirgLEcBRdsLd7dZNFjAM3foKQzgxFoaeybxbTAxvxc7tUECLdMGV6iEpV7mRsHAm5bL3S7jo9jjJCAvpjNlr55KFQloCKtNUcNOTIPzgmrOCYsxloWgFFABefvll/O9//0MqlRLeVxQFl156aUUaJjN9egqPvPsE+vRU4S+XiaIAdfVJpFMa6tV6nDPhjKKV0COP/AyW/+MVTBjUDM0w8P5HbThx3DhBAV28+DGcfvpZOPHELwAAvvnNWXjrrTfx5JOP49xzZ+Kll17ET396Lw48cDwAYObMi3H77RklbNmyf2Pr1i24//5fQVVVjBmzLy699Du4+eYbnAqoXXTzKWuceuoZOO64EwAAc+Z8H2ec8UVs3LgB9fW5vujr68OMGV/CqaeeYZUIOvHEL+DRR38NANi6dTOSyTqMGDESI0eOxHe+Mxt//+dr6P3Xy1i+aTPGDG7B4Z/6FEaNGo1Ro0bjf/9bjccffxSTJk3GH/7wNM488yv49KePBABcffV1OO+8L/trfATIl3KFFRAO7e6AYbiUWgJLGO41DjfuwgKTmIRIIoHbMRDiKfw5FG/JLKJOT5Jw2lEJdIMJCodcGzIEj9MzvTr3SjisvYYcQfjENRyGhpM0FK2A3njjjXj00UcxZMgQNDQ0CJ/FRQGNGtOmTcfvn14M48Bx2PTRLgwZ0B/9+ok1XDds2IALL7xEeO+ggw7Gxo3vYdOmjdB1HR/72AHWZxMmfNx6vXHje2hv343PfW669Z5hGOjr68Pu3bvExtgm/+9+9yh+cuePrb9feOE112uYMGGi9XrPPfdCc/MgbNjwHg44IBfH2tTUhBkzTsfzzz+HVavewfvvb8Dq1asxePBgAMCxx34OTz75OL785S9i4sSDceSRR2HCQR/HegAfdXZjfetHmPeDHyCRuAEAoGkaRo8ek+2f9YIyvd9+Yx11cKOMIzCfd4EqUAhUt7mcMh8uqBXHbG8IDxdHDKifOqCU5VFqnIkq5LpHUsUNl4mmG4JCX0vXVmvYN16q5SHh5YFDEMXg5iJOWXDloWgF9LnnnsO8efNw1llnVaM9kaAhkbFEBuWCO6i5CbvbS3PBBYBDDjkUYMCHu3Zj7fYd2H/4UIfQy1sSTXTdEFwa+cmcTNZx39MxZsy+uOWWH8NO//4DbO+I5z3xhJPwmc8cg0IkEmLCZsMwUFdXJ7zX3d2NSy45H4MG7YFp0z6DY4/9HN5/fwN++9uHAQBDhgzFo48+iX/96w38/e+v4be//Q3qG+pxxsRxYIxhwp7DcfxZ5+L/PjmNu05+iohtTyRKciCQlDyxuQWUJSaDsGApoMELr44suH5iQJn7vAodqvMHwClYK5JZ5XTJLLLloOlMsHJF90pqH8cwozIshMy4ySu1lsAtwhQtQSeTSfzf//1fNdoSKRoS9RjRf3jVz5NMqmhp7o8mvQuaVtrESSaT2GfkMKxv/QjrW3fik/uNdgiWY8bsg7ffXokjjzzKeu/tt/+LSZMmY8yYfZBMJvHuu+9g6tRPAgDWrFltfW/06H2wbdtW7LFHCwYMyCic//73G1iy5Flcd90NttaI5x0wcABGjRpd8BrWrVuL6dM/CwDYtOl9dHZ2YMyYfYTv/Oc/y7BjRyseeugxS3H897/fsK71739/Hdu2bcWpp56OI46YhgsvvASnnHICdowZiZb+Tdi8qx2DB7dY7fntbx9GOp3C+edfhP32G4d3330H06ZlrLxbtmxGZ2dHwXZHBbsS5W2hcy7ovAWUAdB1rcKtK4xVUCiUEjA2F1w/FlBps37WjmJTFgXqgIbdL7UkROkGE70sa+jaao/886JiKPzLmK5BRNm4PVvlet7Gm5LqgN57772O+E9CbsaOHIaVH2xF/4Y6DOrX5BDUzzzzHDz55O/w/PPP4f33N+LnP78L69atwcknz0D//gNwwgmfx5133oq3316JN99cikWLcgmAPvnJwzFy5EjceOP3sW7dWixf/h8sXHgzGhsbHVlwHYKdz8Xgd797BK+88lesWfM/3HzzDfj0p490KK6DBg1CT08PXnvtZWzZshl/+MPTePLJx5FOpzOnNgzcc8+deOWVl7Bly2YsWfIH1NfXo6V/EyaN3gvb2jvxwgt/xqZN7+PPf34e999/D0aO3BMAcPrpZ+KJJx7Dyy//BevXr8Utt/wQqlr09JEXn+n13d63J0QJJYYrxIeK3VrmJ7GWEZEYUBZCqWAZyOeSLgPOTQ652lcMmmbYlIzoXkvNE1TNZ8EluzqnIGofcsGVm6ItoCeeeCLOPvtsTJkyBcOGDYOiiBIK1QGVkzEjhkJnDOOGDQHgnJjHHHMcdu78CL/4xb3YufMj7L//Abj99ruxzz77AgCuuOIq3HHHrbjiiksxcOBAnH76WbjnnjsBZGpx3nLL7bjzzlvxta9dgKamfjj66GNx2WWXu7TEZmnzudt91lnn4oEHfo7Nmzfj8MOPwOzZ1zq+c9BBh2DmzIvx4x8vQCqVwrhx++PKK6/GLbf8EK2t2zFt2mfw1a9+A3fddTt27vwIY8bsi29ceikSby9DY10dTpk8Ef/43xqcf/6ZGDp0OC677Ds4/vgTAQCf+9xJ2LWrDXfccSv6+npx7rkzsXbt/3y1PQrYxwPzEAhdF3Rb1ldHhs4qwxjLKcZhuOCWUtuWH/dSuXfKZekLC4cLrtP3MDPulHA0dK+d/bDaUw6aYVDW06hQYhm1cs4T1zWIKB/XdZI8LKShaAX0qquuQnNzM770pS856kgScvH660ut1/WJBL59bC62kYE5ypicccZZOOMM99jehoZGzJnzfcyZ833rvbPPPtd6vffeo3DrrT9x/e1JJ52Mk046OXPeEh5gixf/AQAcSZKATEIi/jovuuhruOiirwnf+fznvyi0mW/38rffxNq3lwEA9hnSgoNPPg3HHXuyazvOPPMcnHnmOdbf5547s2DbI0OerJp8/JubO5SjDEnACpVw/jCEFbv7sg8FXFRS5RGw7AknyV0pg0MIDrlbHFb2CN8mXWcotMlFSEJAMaDR20YhZIRccOWmaAV0zZo1WLx4MQ444IDCXyakwaE4hGR1sT9YjJAlJxlKiMiAI5uh1yLt8ra9DwO3gIKLIZMiBrRwG8QYUHnGHD2aMzhdcF2+AwYlJFHZPsYUxkJtTzlksuByb5CFQl4CSlLGJN2gIyKGy7OVRpM8FB3ENm7cOLS3t1ejLUQ1cWzghzMNZatfZxfkJNIFAiWfCy4r4B5nz8gZdKFnBnBZcAM9dfactuvXfSQhEqy2lW5Q6Tg2quK6W1wgJlph4e6ku82xqO7sazqDgpC9GAhfMJuLRLW2OxTBBbdKJyFiiUwbvnGnaAvoJZdcgmuuuQZf/epXMWbMGFuZCuATn/hExRpHVJHQFvVgdlB949htD6GGpQQ4XQy9YnBcXFpsCpcfBaySZGJAM6/DyJjojAEtVgGVSMJyiXWMI7JtlNmxex0oCG9TsVw0vbzENgZjePHfmzBoQAP+7+MjKtk0wk4oLvrRHNdE+Lg5U1AMqDwUrYBeeeWVAIDrr7/e8ZmiKHj33XfLbxVReRwCVUiT0OHCE+5ioBvhxi/KQsZ9z88XXWJAbdYYPeB7mml7VvwO4f7Zx7CfGFAhU7BMCqgdiZtWVQplhc66vIaFWyx9VG+VrpeXBfe9ze3447/eh6oomLjfYAxoqiv8I6I0AtqgEpNSVeUURAxwky8pC648FK2AUpbbaGK3DIU2BwNKYuAXh+tpXBVQw6aAetUB9aGABr3DyJjBjasQ7p+tT+ybGq5IW4aFLKCAc13IWBi9/w4a13UqooKVZjCxM4u8jq7eTN1hgzH09mmkgFaVgFz0mecfBFEWcZXxZMRXDOjcuXPR2dkJANh7773z/gcAnZ2dmDt3bvVaTZRNaK6vASUx8AtjNuVJJmUgSPIoHoXcWu07ipmslsERdhZcxwPNhwIqjjOJHoikf2bwk607zNqztnVKYdHd2ddsFtBSXHDdXhNVwPH8rtqJrFdhx1sT0cXdG4nGkiz4UkCffvpppFIp3wft7e3F008/XWqbiGogjWUjmCQGfimlLEwtkjcLLvfSrSabI5NwwEmIxPOHoIDazuknszM/7uQWrmRuW/VwWEBduiFMZceRPA3RjQHVdSYooMXWfeQ3gOwJ0YgK4+jeICyg0R3bhHzI/byNF75ccBlj+PSnP13tthBBEtIctCucYVscHYJcTBenfEJfoXgcuwJq/7vaMCPnghtK0XL79ftIwiQoL1KNOXv5EZnaFhyMiS7prr0Q4trltm5GNbmG3QJabL8awmZOpVpFuFMgNroK51EYyzyXw96tJiKHax3QiK6TtYgvBXT+/PnVbgdRdSRJ/uOIuQx3MXDW+4unBOM0kHspSIUX9KDLsBiGHnIIaAlzi/tOKEqzB1TywMSHFTuAVnjhmiwtouEDad2wlX0qDr4ryAW3ujjXusr3N5/VPPNGxU9BxAWXdZKGkzz4UkBPPfXUareDqALTpk0FACxe/Kxj1i1/+13cMW0qLrzwEnz1q18v+thvvrkU3/72N/D660sLfnfJkj9g0aL7sXjxHwKxMD744H34z3+W4e677xfO7YbTeufevnQ6jT/+8Vl88YulzYVC7SiVt9buwCv/+RAzjhyLfUYOLP1Avl2RC7vgGgHHgOq8whuKAGp3QfahvBjhxq16kdcVO04UKsPCgnc1F8/vUgc0oqKVbtgVjuIUaf6ZEtcs5kHh3KAKpr+jOraJcHEbNWEbPYgcvmJAieiSTCbxt7+94vBeWffeBihK8D4tThfc6j5YjjnmODzwwK89P3eU0PAQfl588U/49a8XVbRtleDl/3yIDds68I+3t5Z1HOcD3iMmy9XwYlNA7W6cVYZ3eQ2lDqjtcv24IDNJXXDJyy2DY10IqR1euNe3k62V/rDHgBbb2XzcJ1lAq42tf6sw5hiY8MxRwGIbGkOUB3ORRWgsyQMpoDXOpEmH4fXXXxWE3D5Nw5Zt2/Gxjx0YQouCTYbU0NCIlpYW79Y4HqDu7ZF10UprhvBv6RSw+OT5wGDhuuDqetgW0BJccIVxJ9HYyueKHSMKzXcG57gPEse5Wfjx9KXiWLuKzYLLzaWYDtcAsSe/qo4Lrpj4jiygRIm4bJCEuW4TIqSA1jhHHvkZvPXWm+hLa9Z777XuxF4jR6Bfv37Cd5cs+QPOOed0fPazn8ZXv3oe3nrrTeuzrq5OXH/9NTjuuM/grLNOw6pV7wi/3bZtK66++gocc8yncfrpJ2PRovtFxcCkhLqbra3bcd11s3HCCUfj6KM/hYsuOgcrVryVu5731uOb3/wqjjnm0/j2t7+B3bt3Cdd0+uknA8i4DZtuySZPLn4Cf1q5GgDQm9bw9O+fxQknHIUTTjgaN974fXR1deLNN5fi5ptvwNatWzBt2lRs2bIZjDH86le/wCmnnIATTjgKs2dfga1bc1bIHTta8d3vfhvHHjsNF110Dj788IOC11kKpqBctoKcJxZWKWCtY7rdBTfYBV4P0xUSLtYyPxZQfmdWKtkq2A0iWfETlxumK5cjFi+kdlQC3bAlISryagxywQ2OALrXrmxmNnvovhLF47pxQUNJGkgBLREjlUK6tbXq/6VaW9G7bRtSra0wiiiFYzJ27P4YOnQYNu7Yab23dvsOjNt3jPC9JUv+gDvuWIhzz52JX/3qEUyd+klcddXlaG3dDgC49db5eP/9Dbj77vtxxRVX4bHHHrF+yxjDtdfORkvLYPzyl4/gmmuuxwsvPI/f/OaXzgaVUA7mxhu/D103cN99v8SiRY9g2LDh+PGPbwEApFIpzJ79Hey1195YtOgRHHXUMXjmmad89o549n+s24Curi787GcP4q677sWaNavx0EMP4uCDJ+Hb3/4uhg8fgWeeeR7Dh4/Ak0/+Dn/+8x9x/fU/wn33/QqDBw/GlVdeCk3LKPrXXXc1DEPH/fc/hHPOuQCPP/5b320qBtP9rPLlB9yP5+biat9RDNpaLLjgshDctWzn8yMEi8qLPDuylIQog58hlM/VesfuHvzj7a3oTWme3ykHtzFuuG34RQBdZwU3ufLBf50UlSoTQNmyTAZq+0Z1NMc2ETLuQaCBN4Nwx1cSIjsffvghli9f7lobdMaMGeW2SXqMVAo7nloMVoJCWCyKqqCjIYm+Pg1I1mHoaadDra8v6hjTpk3Hf//2Fxw4bCg0w8D7H7XhqDGj8NHba63vLF78GE4//SyceOIXAADf/OYsvPXWm3jyycdx7rkz8dJLL+KnP70XBx44HgAwc+bFuP32BQCAZcv+ja1bt+D++38FVVUxZsy+uPTS7+Dmm2/AzJkX521boecXYwxHHnkUjjrqsxg+fAQA4LTTvoyrrrocALB06b+we/dufO97c9HU1IR99tkX//nPMrS17cx3WNcGtPf0oa6pH/baa280NjbiRz9aCMYY6urqMGDAAKiqiiFDhgIAHn30N7jyyqtx2GEZi+pVV12DU045AW+88XfstdfeWLlyBRYvfhYjR47E2LHjsHr1u/jrX1/016YiMAWucgUvL6Ut8z5vDXX5jr2UTcCWId4CqrCMQpxQEsE1oIQsuEyUmivdojIQ2xJXhdTPJka+2/bYX9Zi3ebd6OxJ47ipoyvYsgxuYyyqylfaUYaldBdcsoAGTTViQE2322qehYgDruWqIrpO1iJFK6CPP/44brjhBlf3SkVRYqGARo1pR34Gf3j6CRgGw6aPdmHIgP7o19gofGfDhg248MJLhPcOOuhgbNz4HjZt2ghd1/Gxjx1gfTZhwset1xs3vof29t343OemW+8ZhoG+vj7BHTaDOPl/v2QJHvz1b6y/X3jhNeFzRVFw6qmn48UX/4SVK1dg48YNWL16lWV92LBhPUaNGo2mpiahbX//++uFOwbiYjR5zF74/YpV+MIXjsXUqZ/EUUcdg+OOO8Hxm+7ubmzfvg3XXz8XqppzIujr68OmTe8jlUqhuXkQRo4caX02fvzEqiigZvPLXlPzxP6JSojzRLptkbf/XW3sMaBBxwuVVJqgQGkbeZC5bdXEzz30HudtHX0AgF2dfZVqkIBbpumg6+9Wioz3RhkKKO+CG9fhGhQBWEANZjhnH1mtiAoR0WWyJilaAb333ntx1lln4YorrsCAAQOq0SbpUevrMfS006Hv3l31cyWSKgYNasLu3T1A/4FFWz8B4KCDDgEAfLhrN9Zu34H9hw91fKfe5bi6bkDn3Bt5wTqZrOO+p2PMmH1xyy0/dhyjf3/bGLE9WT575DSc8MUzPdtuGAauuOJSdHR04JhjjsOnP/0ZpNNpXHvtVZ4H5dvG45b1lxfaxgxpwSUzz0XL8H3w97+/joULb8a//vUGfvCDHwq/MRWeH/5wAcaM2Uf4rLm5GUuX/tuhhNTVleRsUBDT9bbsnX9HUpNsbCnsW9Eu57Gt6PaY0Gpjt/wEv8Npc8H1lYRI0hhQR1+G1I6w8WUB9f6O+Vm15GZ3C2g0JStNN4RNrmLr4pILbpBUv3+dtbnDjbcmoov7mkhjSRaKlopbW1tx4YUXxlb5NFHr66EOG1b18ySTKhpb+qOnvgtaiZlOk8kk9hs2GOtbP8L61p345H6jHQLWmDH74O23V+LII4+y3nv77f9i0qTJGDNmHySTSbz77juYOvWTAIA1a1Zb3xs9eh9s27YVe+zRYo2Lf//7DSxZ8iyuu+4GW2vE8w7o3x+jRnm7qG3YsB5vvfUm/vCHF6xstk899UTmSIxhv/3GYdOm99HZ2Wmdm28bT11dRjHt7u5Cv379AQBtbW1ozn7+5sYPMLSxGV+54FKceOIX8OKLf8LNN9+IH/zgh4LyOnDgQLS0DMbOnTtwxBHTAGTqhF5//TX4ylfOw9ix49DR0Y4PPthkXdv//ufepnIx3V/LFrw8fp5R0PMf2255CVpY4GPf7K5bwTSgeBdkJrg1yys0h1HWRgr8JCHKs9HCqhabnT2+m2tZRIV0zV6Gpcgxx/dxVEvRRAaHAbQa/c0cf5HbJFEKbiEktEklD0UnIZowYQLWrl1b+IuENDAwjBs+BCs/2Ir+DXUY1K/JsaCfeeY5ePLJ3+H555/D++9vxM9/fhfWrVuDk0+egf79B+CEEz6PO++8FW+/vRJvvrkUixbdb/32k588HCNHjsSNN34f69atxfLl/8HChTejsbERiUTC3hjb3/kXgwEDBkJVVfzlL3/C1q1b8NJLL2LRovsAZBIQfeIT/4cRI0billtuxIYN72HJkj/gL395wfVY++03Fg0NDXjooUXYvPlDPPror4XMtR29fXjp1dexcuV/sWnT+3j55b/ggAMypWoaGxvR0dGOTZveh6ZpOPPMr+D++3+O119/FZs2vY9bbvkh/vvf5RgzZl/su+9+mDLlk5g//0asXbsGr732Mp588vG811kqVgxomYKXw22Viy0tZJ1w1lINdoF3JCEK2QXX1wNOUhdch8IZ14e1HwtonjlnWUCr1H9uY0yPqAKq64ZYf7acGNC4jtfAqH6MuNvmSlTHNhEurusvrRHSULQF9OKLL8aNN96ITZs2YezYsQ7XzU984hMVaxxRGRiAfYcOhs4Yxg0b4vqdY445Djt3foRf/OJe7Nz5Efbf/wDcfvvd2GeffQEAV1xxFe6441ZcccWlGDhwIE4//Szcc8+dAIBEIoFbbrkdd955K772tQvQ1NQPRx99LC677HKP1vB/5V8Mhg8fge9+dw5+9atf4L777sHo0fvg8su/hx/96HqsWbMaBx10CBYuvBMLFvwIF110LsaN2x+nnXaGo0wMkHEHvvrq63Dfffdg8eLHMH36ZzF16hS0v78BAHDE/vsi9eEOzJlzJXp6unHooVMs99spUz6BvfcejQsuOAs/+9kvcPbZ56G7uxu33noTurq6MH78x3H77XehuTljT73xxpuxYMFN+MY3LsTIkXvijDPOwnPP/T7vtZaCKXuVv/HvfgA/8Zx2C2jQZVF0Q8w0ahg6EGAOIscDzY+wVEbWT6L6+NnEyOfyamWnrta9rSHBStMZEmXEgPL3ivSUgKlGFlzD6cYSdG1polaonXWyFilaAf32t78NALjpppscnymKgnfffdf3sfr6+nDDDTfgz3/+MxobG3HRRRfhoosuyvubpUuX4uqrr8Zf/vIX4f2pU6eio6NDeO/NN99E//79fben1nj99aUAgJSWQkMigW8fOy33IWO4++77he+fccZZOOOMs1yP1dDQiDlzvo85c75vvXf22edar/feexRuvfUnrr896aSTcdJJmVqcdguaHwvBKaechlNOOU14j08OtNdee+MnP/m56291XRdiQo8//kQcf/yJ1t9/fO5JdC/7GwCgLpHAsUcdidPP/YbjOM3Ng7Bo0cPCe1/72rfwta99y/W8gwbtgZtvvlV4z57kqRIYlYoBtf/esuDAhwU0XKuZPSGLnyy0FaUEC6joKijRA9HhoRBKK8LHzz3M0zlWcrBqueC6FViPqPal6QaSZXQTv/aRq2aVKaGMWvGncCYhiurYJsLFNWVFRGPla5GiFVC74lcOCxcuxMqVK/HQQw9h8+bNuPrqq7HXXnvhhBOcmUcBYPXq1bj88svR0NAgvL9t2zZ0dHTgxRdfRCOX3bVfv34Va2uUYXB7TEjyoK5izM6mTe9j+fL/YOhQZ9Ilk5IymEpExcqweGgemo/agnZhOGhhgTE+C24I53du1/v4Ee82XOEGlYNtHFEMqDd5XXArFZvtgWsd0IjGP5adBZe77mrF3BIZgohXd1u/jYAT2xHRJq3pqEsmXJ/FUZPxapmiFdC9994bQCb+7oMPPsCYMWOsWonF0N3djSeeeAIPPPAAJk6ciIkTJ2LNmjV45JFHXBXQxx57DAsWLMDo0aPR2dkpfLZu3ToMGzYMo0dXvt5aLSBXLaTgTCw/+tH12Lp1M+bOvd67NSHHL5ZLpQRdZ37g7PHtD35fMaBBl2HhMjUjhN1y+yaGrxIekrrg2gZC0PG00uDHAppnnOdisyvWIvH4Li6JUd3Z12x1QCkLrrw4ercK/e0WwkH3lfDLqo1tePC5d3D4xJHuG6g0lKShaAWUMYYf//jH+M1vfoN0Oo0//elPuOOOO9DU1IR58+b5VkRXrVoFTdMwefJk670pU6bg3nvvhWEYQn1FAHj11VexYMECdHZ24u677xY+W7t2Lfbbb79iLyU2uAdiB98O1/NW8cFy332/LPgduxCpREyIY5agW6YF1G75so4rCgNK9rt8VmB79s2gd6sdFlgfVtsKt0D8q8gsuDI9Ee3WWKmsswHiKwbURxKiIAXn6GbBNQSls9hND76PSU8JmGrFgDreoxhQwh+r3m+DZjD8d/1HOMTFCTJqRoZapmgF9De/+Q2eeeYZXH/99bjxxhsBAMceeyxuuOEGDB06FFdccYWv47S2tqKlpUVIYjR06FD09fVh165dGDx4sPD9n/3sZwCAp556ynGsdevWoaenB+eddx7ee+89TJgwAddcc01RSqmqKlBVLztQeCQSqvBvKSSzazd/dYrCkEyWfszSYWI7EFY7TJjD+hdue4rDYLn7Wk67FY9+UBOqLUMlkEgqUBWV+224Y0tRbG0Pemwze9/5OD/3G4V5f78S8784oj0fKoXCvL0CTBKq931jFZqXXtjnHJDJwRDFe2Uq8rn5UHyfWb9V4jFeg18XMij2ta4K/a0oLnMvomObCAdr/FjrsAJzozc82bc6hLUWVIKiFdDf/e53+MEPfoDjjjsOP/xhJkPoSSedhLq6OsyfP9+3AtrT0+PIoGv+nUqlimrT+vXrsXv3blx55ZUYMGAAHnjgAcycORPPPfec73qlgwf3F6w6stHc3FTyb+t7sjvj3OWpioKWluATNClMbIeihtMOk7pkAim+X0JuTzFkLJEZwVNR1bLardokWgUMLS390at3O94fNKgJyURu6airU4Xv1NUlA+3DhoaEcP4B/RsCPX/CJjHV1SUKnp/vbwUo+P1y5n8xKOb/uHkalflQSezzwYLrl379G137xjBy8zKRLDwWSqG+QXW0r1//umjeK0WBmpMUrbXHL/UNddbmcWNTfTT7oERKWRc03UCyRGFVcTwnKr8+9KTqHWN7wIBg13QiuljrgaIgmVSg2Z5n9fXByidBEZSMUEmKVkA/+OADTJgwwfH++PHj0dra6vs4DQ0NDkXT/JtPJOSHBx98EOl02sp4e9ttt2H69Ol46aWXcPLJJ/s6xs6dXdJaQJubm9De3iPEuhVDd3enw8tP13W0tXVVoIXFIqZYNzQjpHZkSKXSQnt0Lax+KR7dMCzrQSqlldVuQzdseUAY2tq6Mse0jZ2Pdnainsss3Nsn9mFfb1+gfdjZ2Sucv21XBxrrmgM7v67rtutPFbx+vr/NvnajEvO/KBg3P1nm76jMh0piGIZj3GdQLLfDjvZu177R9Ny87OtLV6X/errTjvZ5tUd2evs027grbsx196Ss/u7sDHbtCYtS14UX/r0Jf3xjI845/gBMOXB40edlTHx+M6Py60PbLuczZ/furljcV6J8zPUgndahabr4PAPQ6+P5HCUClxF84kfJLykJ0X//+1+MGjVKeP/VV18tKgnQiBEj0NbWBk3TkExmmtHa2orGxkarlqJf6uvrBWtqQ0MDRo0ahW3btvk+hmEwqbMI6roBTSttcKU13SV5AEo+Xlkw+7OFhdOOLIYhpnxnRun9HDSanmu7wcrrR0em5Ozx0mlNeF8B0JfWoHKFNg1dHF/ljNVS0HSxjZkHT3DnZ0yMWjN8jCG+1IDi494F2afC/S5zXEUV+z01yTlyAZrmPs749VbTq9N/9nUrc97orF08mSRE/Lgrrs80zeD6O5p9UCrFrgtvrdmBtG5g+dqPMGmcd3Z4T+zzogrrg5Z2GdtpLVb3lSgdcz0wDMbFE+dWGD/P5ygStNxVCYr2w/jqV7+KG264Ab/+9a/BGMM//vEP3HbbbVi4cCHOO+8838eZMGECkskk3nrrLeu9ZcuW4eCDD3YkIMoHYwzHHnusEBva3d2NjRs3YuzYsb6PU8u4JsKQJAtu2AHh1arTFwR8yYGyN08cSYiyx3XU+HQOHfs9DLwMiq0OqJ/SMZXEnmnPTzKYIMoZFEvGuiFfu0LBRz94lfzgb3+1NjVdM5tHdC3TdNv2V5GXIWTBjWgfBIW5NpfcT2472RXGbf2M6tgmgscc27rBLNmE8eF1NJSkoWgL6Je+9CVomoaf//zn6O3txQ9+8AMMHjwY3/nOd3D22Wf7Pk5TUxNmzJiBefPm4eabb8b27duxaNEizJ8/H0DGGjpw4MCC7riKouCoo47CXXfdhb333huDBw/GT37yE4wcORLTp08v9vJqEtcFPaRZ6HByDlsBtQtyERLADUEBLfNgHgXG3TLK2hU8x/gKuA/tafv1oLPgOsqw+PlJ7lsyKqMKlOwakb9tmm4grRloaij6USI3HveEcTvpXmVY+E2bYOuARjNTaCYLLhd6XEYdUCrXkR+zq0pVQIOoC+xahiWiY5sIHnMN8NpQDbxMG+FJSVLDmWeeiVNPPRWdnZ1gjEHTNIwYMaLo48ydOxfz5s3DBRdcgAEDBmDWrFk4/vjjAQDTpk3D/PnzcdpppxU8zlVXXYVkMonvfve76OzsxOGHH477778fiUSi4G/jgO424UIzgLorOqFhVx4iVIaFVVTQ9bLmFC4KbheGA+9DexmYwOuA2v70IywJfcYcpW3CwHVTKs+40g0DCx/9D9q7Urj6nMPQMrChiq2TA4bcJhrziLcJRAF1K1URUeVLN1hGsbF0+yIVUL6/yVKWF9NqX/q4dLi/lNcgF9zWbz2iY5sInlxt9GyiRiCTPSs7hOTL9BJfilZAd+7cie985zuYPHmylfH2iCOOwPjx43HHHXdg0KBBvo/V1NSEBQsWYMGCBY7PVq9e7fqb0047zaGUNjQ0YM6cOZgzZ04RVxIjXBfvkBZ0yfRPF3/ScNpRArysVbag67gvuXgJx3mN/BbQoAVhu9AZdh1Qf2OIt4BmlD8l5EcjY6youp+7O1No3d0DAHh/W0dtKaBeFlBFsfrIq6sq6hrvgdtmgRGhzTMT3TBgZIXEEvVP20ZcBRtXg4RRn7ZY3OuARm9sE+EgjvGcC65i+5wIn6JjQG+66Sb09PTg85//vPXeAw88gI6ODldFkggfdwuoHDGgYSt8DmUpQouTUcUY0NxxXRTQAjGgQQsLdotr4FYQx/X7OL/NBVc265WzGqiT2nZ9zOeCm33tofDxXVGtbnF1wY3gPdCy8dvMVoalGIJQ+GsFc20quZ9sQ74a4QNuGykUA0r4hV8PXMdNBDfqapWiFdDXX38dP/zhD3HAAQdY702cOBHXX389Xn755Uq2jagQrsJtSOu5U7gIWQG1LVBhxcaWglHRnX/xAKZg4cxHCBhMs/00bAuoXQENOQbUz/U74kaD67MPWjuxfVeP433Gpag2kzbkUwZE18fKtjF0PC6bT2bhdcm8cO+VqKhcFLcOj6CQrmcV0EwMaLZvi40B5b4v20aObOjlKqCOHPaVx23OUAwo4RdxAzBnAXX7nAiXohVQXdddF/m6ujr09DiFGiJ83C1SkrjghkytWECrtUPMXNxZDb2AwhWwIGwXTtySWFQThwXYUzURfsT/wN1LoQrs2NWDH//uLfz4sf+gp0/cSBDbYCoD3sfSa9kC6nk9nGXYY5wFYRl239iP3i6Alo2jVcCgWBbQ4hCy4NbaOKwwfIbQUrDfm2pYQN1i6N02QgnCDUEuclNAaSxJQ9EK6Cc+8Qncfvvt6OzstN7r7OzET37yE3ziE5+oaOOIyuD6sJHFAhqywKDYlYUIrU0VtbR4KOJuO+X2GEtHGZaAXVycLrhhl2Hx8SPeBRfBKaCm5TOlGWjvStmaxF2HDy1AiEGOoPUtPx7Xw1tAPb4iWOSq1S8144JrKqAcRbqkUxIi/xh51nV/VN+DyW3OUOZSwi+6iwIqbhzSGiELRSchmjt3Ls455xx85jOfwb777gsA2LBhA/bYYw/84he/qHT7iErAScR+yytUry32v0N2wWVitJsSofgAvqVl7+rZ70O2U9yUObuC6XBjDvie2s9vz9Jb/QbY//algQovg1LaeWHdvmnBC3lW0oY897KiMciy4VmGJYeXUBxEFlzDxcoepQzeJpo5bqws0GahG/9JuUSLc+XbWEtY3V3qAQKIoHEtG6fTjSX84VodQLCAErJQtAI6ZswYLFmyBM899xzWrFmDZDKJs88+GyeffHLBmp1EOLgKQdLslsulgEZpdWIVVACcrlXZ47qME6fbsk1giFsSIocyUHwMqK4ZQABJZPO5hwoKlRUD6u9Y1Yp1lA6hoLn7NQfSL27zMoL3QNeNrLLJjTXTAurTF7e2LfGVpVwX3CAekHqNZHgmwkEY2y4KKCUhkoeS6oAOHDgQZ511lvX3zp07SfmUGMGyYSW7D+tBbVdewmmFdfoQk8GUi+BqgoxCoZZYS9IrFtZPHdAwE+oAzt3x4JMQ2f70o4DbFdCA2pw/Yyj/t5J9J48FNABLX2h4XY+PZBZu8k+lcXVTjKBgpXFJiMyAIAWAzgwk4K+ON8uzqUKIWDUSK6WoBxQDGkXrPhEOrrkxeLGI1ghpKDoGtL29Hd///vexevVq6LqOCy+8EJ/+9Kdx4oknYtOmTdVoI1EmvGDCHC+CxakehbsYOJIoRGhxcsReVmP33+XBb1eWHApXwBZQg4ntCdwF1x4DWkIW3KBinPjTOC2g3IPbtIDmuZSaLn+Rpw6o9dpPEqKq9UttWEAzMaAsk4TIfJMVNx/ELLgVbV7NUW4W3GLqBJeKax1QUkAJn4gbgJk/eB+LKBkZap2iFdD58+fjjTfeQDKZxAsvvIClS5di4cKF2HfffbFw4cJqtJEoE+YiWIah+BmG4ZnsJiycykJ0Fie7G1U5sZfObIZZQcVFmSskHAZ+S+39ELAgXolNjKCSEOWNAeWSS/kqwxJHy5OQhKiwC261+qVWhHSzDAsYhCy4xUzhmo5FrjDmeNRLHpfi74qt2eoHt7WQ7ivhl0JlmahUkzwU7YL7yiuv4J577sG4cePwwAMP4NOf/jROPvlkHHjggTjnnHOq0UaiTIQJ6aO8QtXa4VbePuzFQDKFuBgc1U/KkD/tV23VAXUTBhx1Pw2bh0vAFlBbDKajTmmVcaruhceQXWm1ZxauFvmEdTEJrrlb7O9YtRYD6i1Y8y64HgpoAFlZ3eZYFAUrTTcAxXwu5J5NWhHzQYgBjWAfBAVjzOqfUsdKEB5DrmO7xtYXonq4lWGBoiD06DPCQdEW0O7ubuy5554AgL/97W844ogjAACNjY3QAxKiiCKxZbfMvgqhGYZ0k9+hLEjWvnw4XCjLEQY8hWk3YaBADGjAwoIjBjTgjImK/Xr9XL89BlQCBVRw1bdccL2vhbei1JqA6HXZzEcyiyBiY90UiChaiTTDyPQjE8MzinGjr+lY5Aoi1EstO2ld9Tay3RXQ6Fn3iXAwRB/czL8Kb3yhNUIWiraAjhs3Di+//DL23HNPtLa24jOf+QwA4PHHH8e4ceMq3kCifNxcWoKI5bDjesqwF4MIu+A6FYgyXHAdrlUZ3B78TsuZPZNw0FlwbTGgLOiNMFt/+LGA2r4TlAU0X9wmc8mCC2Tvr0tyKzHdfQUbKQGeirefOqBBuIS6ZjaPnpCu8ZtF3BArJikXueD6I5/7vR8YY47HYzVccN3uYRSt+0Q4uLvg8mVYaCzJQtEK6Le//W3MmjUL6XQaX/jCF7Dvvvti/vz5eOSRR3DPPfdUo41EmfCLNwsxENswXFxww8bhxxqdxSlfEpmicejhTHDZEj4KOemQHUcm47DvYSlJiAISsAQh1N5v/J8+simLLrjRU37yU1gB9XI1FyxNAQ7FKMrohsGgZHdDS3Xjr+WNkEoibj75/926zbvxYWsXPjVxBJybbZXHNcNzza0vRLUo5BFBmxnyULQCOn36dLzyyivYtm0bxo8fDwD4/Oc/jy9/+ctkAZUUQQFVlUzZwhDmoKsLbtiLQU1ZQMs5mstCDeZqAdUdMaB2RSZgYcFeBzTgUAC7tcxfGRbxz6BKx+R3wXVJQsSQrdPoVEhrOwuux/tK4RhQoV+yGzluFuRycJtjUSzDohssZ0Xj+kgvxgXXLeaLcFBKciyDMfxyySp09abRvymR84zJBtRVwwLqtn5GMcEWEQ78OBeezYqSjQGlNUIWSqoD2tLSgpaWFuvvQw45pGINIiqPuKCHGAPqOvHDVkDFB1s1HqjVwhF6WEElQGEZYc491swuDNi+E/ACb98xD15YKWUTwx4DGn4WXL4fFXuyHRf9SSzpUrk2yoB37CuXNsHLBdfFslxh/dNd0YqglcgwmLUG811UlAtuBWMba5lSkmMZBkNXbxoA0N6VssY8U5RMGE8VutvNO6uUNZ0xhsUvr0N3n4ZzjjsAyUTRKU+ICMIvg1YZFh8bh0Tw0IyMAcy+C5R5M/B2uFl5wohF5XFa70JqSAk4LFhlueC6/9a11mEhC2jQSYgKtKf6DbD96eP8DqtpQEqzrvNCqPiZYEFTCz8ayo0pk5vCLrheboH28V8V92q3jaEoLV5ZMi64bu+XmISo5sZh5SjFAip6OfD1xKu3ke2WgKqUob29rQd/f3sr3lq7Axu3dlSgZUQUEF1wsy+UXB3Q0I0ehAUpoDGAX85tCe+DbYdgYTEJWwO1/x2dxcmpPJfedlMh4rMbGsxwtWw5BARHav6ALTEORTxkC6iv22BrcxhJiBxxqLnX1o4x87ZGxdL1US2czKKisdkeuPZ3BO+BZhhQsk8oXhEtZj6IilXFmlZzlGIptrvsK4JAXx1c3ctLCFHozFpuASClRc87gCgNMQsun9k9+28E18lahRTQGCAs3mGWYZExINx2/mi54FbX0qLrhkcW3AJlWIJ2wXVYYMONAfWlgNvLsATUZpbHWuSVBdframq5DmieINDcNzw2Oux9UZW+sW8YIZoxoMwjJqtUC2jozxOJKdcCqum6NSv4GPFK4xoDWsIc6u3LralkGY8P/JjNbRLm1smwve6IHKSAxgF+8Q3RBVdUDMKzxPLYrRhRkl8qK+g6F2rdMFyFWsd7dgUwaCXenoQobGHDlwuu+HdQbc5bhsXNVT/zo6KPFXl8lGHxUnYc+xFV0T/dNvMqf55qo2ez4NqfA8UooGLW4Qh2QkDwmar9PiuETSaXvs1XJ7hU3I5YyjOlp0+zXtfeBhnhhbA2mkOeqwNKm1TyQApoDBBcWjjXuqDhhYOcq2e4i4H9AVqNB2q1qKig6/pb5prYxL5D7VjQw7aABp6Ft5Trt7tpBpQFN0/cpuFhAbVnPXY7Vq0poJ4bY0JsrIcLboAxoKLqFj0LaKavWKbDeRdcqgNacRxJ63yMS/47msZnyc7Mg2r0tpsHi6/M4jZ6UjkFlMZFfNBdXXAVbn2hsSALpIDGANfYrjDa4foQkc1aFZ3FqZJJiEzXY0NIssLcY0Bt99HpghqwAmpXiIOOAXVcvh8LqO3eBZUFN48bnuiCm3s0eF1PIetIpPG4HiE7sMd8CyYGNPsvP18DGkOVRDcYF3+eo+QkRDU2DCuJIzmWj87ik5YJmbpNF9xqJCFyNYGW4IKbyimyZAGND2Ld+yyUBVdKSAGNAcKOoiVYBj8JvSwsoeJQnsJpRilUNAbU8sAVs3y67kYXcrkNPAutXQEN9vwOIayE6w8qcVJeF1zuOvjZ6amA8g/6WhPwvC5HEGTcvxKIBRQuFtAIClZGtg6oPSCjGGWayrD4w+nxUKQF1C2XRFWM+z7yDvigl3PBJdfs+CAYXCSpAEG4QwpoDOCnWy55QBg+uHxGshDbwWFXnsJuTzFUNglR9re8gK3rrjGgDgtjvljCAHAaYEN2wfUhlTksoAG1WbQWeY8fxrmaeikD+TLqRh+P61F5y7BHduAALKDmmBM8FiJ4DwzGXLOCFBUDGsdszCVgHx9+rIL8d3Sdd8HNJTOsdJ+7bWaVcg7eAkobE/HAYMwW6mW+4DfqAm0SkQdSQGOAUGA+RMujkJ0sxFhUgZpywS3naFmLCud6qTMGxeWYTmFAMgtowAqoY0YVuH7XBDIBWUDzZa5luocLro96l7Xm4ua5SvqwgJZiaSoW96Qs0bsHum5kNmNsHV7MhoygJJEC6knepGM+fsO74+ZccEtLEJQXt03PEu5rj+CCGz33dKJ48q+1VAdUNkgBjQGiQJ7NBBZCOwwmRzkYgQivRU5DZOkXk6vvlnuPgXlkwc2vcAZtRbYLJ4HHwhUZA2sww9FHQQlI/GmcLri5D/lYRy+hXnR9rEz7pMHzFhZ2ebW/XZWuyXY4HwMaRTdog+Vc2HkdtJj5wCtAUeyDoMhX99fzN8ImkzOLPVjlrc6u1u9SLKCUBTd2eG+OK7k6oFEW+moMUkBjgPDgybqQheJqyvvmyxIDahcPI7SDXg1XP94CynTdtT8cFjFHFtqgLaD284erDRV6wDHGnEbjECygjiRE/J98tleP/uSVhCi6f+bHjwuuh2IehAXUzIKrRDsGNKMYGA6LczHzQRzTlWlXLWLv0mJdcDWNO4Baved3qR4iumFg2ert+HBHFwCxDAu54MYD+zAxN9Yznn8UAyobpIDGAM/6fgGjuyYxkMsCWo2sftXCqUCU0XZmrdTWW7phuJbgKFh2JXALqL2NwZ7fPmaUAsKODmfdw6CUZt6a6bCAeiQJ8xLe8rnzRh2vDTpFcMEtXJ4GqJbw63RZiOImQCYJEWD3wfWrgBpM3O4hRcObUjZGhLJNbllwWeUtSm7PMT9je+X6nXj4hf/hvmfehsEYxYDGEOc4MTfqwOmfNBZkgRTQOODighuGBdRNwA1d4QtZeSqHUtLqFzymPV25myDoyIzr5fYSEI4yLMGd39Wa6ZJUhUfTdOdv9IDqgObJgstbNP0pWrnXteT6mFdAKbI8DVAlxTB7SMZbokK2/JdCRgF1tlv3WQc0mIzDtUEpGyNiojH3OqAV73O32tM+HNnbOvoAAB09KfT0aUId0FrbICPc8b7PvAYaVGuIQpACGgOEB40a3i2XpR6pQMi6Uzk4C4tX4qi2MiwuwoVuV57CVuId7qzBKHNA5todmygFboSbwBaU4Jzfapn7W+Gz4Hq0Ta9hC6iVFNpmmVMEF1z3nzrmZRWz4PLzNYqxTZlxwxyOOX43NBzxtqSAeuJIjlV0EiJ3D4lKb565buwUqSx3dqfJAhpD7GPaii8X1hcaC7JACmgM4Bf0MLPgCmULTEtC6AJDuO6b5VDJ3X/LIs67XgLuGQltCp7Dmh60C26Icbw6M4oeMrqLwBZYDGi+Miz8eLLVg3WD5TlWlGFw2VTIIiqkHpbhAKxylrIZ8QLrZh1QAGJ+pyJccHki2AWBUcq4FMuw8N/nXb/LbpqAW7v8jG2+rbu7UuhLc1lwaWDEAu+NK8UyekRxnaxVSAGNA3x9vxAVP+Yh4IaKrRskaZUv7Dva5VmhTCGQr/+ouyofssWAOpIQBe2C63wz728MFwttYHVABRdc8TPe1Vbx4WoquOfVkIWBd6t2ROtyLq9e48zeX1WZDm5JiCJ4DzKKgdOa6xZ77obTjTx6fRAUpbjgihZQbt0SPCQq7XHiFvZRXFt37O7x/IyoXezz320jMUq13msdUkBjgGG4CZbBT0JRmQkvFlUkZOWpDOwud+Xs7LkVbGYeLrhOYSBkP+YQs+AajMER8lmoDqiLAhqUBTSv0igYOAq74NZqEiKhrIdto0xQzD1+X9mNIQ8sA2gutins7M+lYBjMegbwPe13PjiU/Roah5WmlCREopu9V4x4ZfvcPQmRvyy4Jjt29Yq/p3ERC5wl4rL/8utkoC0i8kEKaAzgBaowy2+KZR4ksTVGSOG04xQoSjtOxuKTtaioiuv7wnnswoD9KwE/7O1ZZ4N0sXFPlpL//LpLnVIvN9dKI2S1dIwfjzIL3PuC2y33+1pyazIMw9pUcMSqC5bhwq7JmeNVxQSaeyVJSeVSMAwGKG4xoD6TELH8fxM57MK5n40R0WPCI0u2Vtm1S5w//uUEvq3bd4kW0FraIIsLpTxT7LfZGqYRL1dVq5ACGgd4F1yzDmgoFlBnFr2whSZHCY0ILU7ViTXLLQm6oft0MQ3XAupIvhKgJchNmSx0+e4xoMH0Wf46oPxGler4ze7OPvzo10vxqz+uApC/pEuU4fshrwuuD9fkfN8rB+uYimKNt6DcuCuJbllAxX72O54cpYQitH4HTdkxoIZLDgdUYdzp/PzL/uvLAsq54JICGmm27ezGDb/8N554eW1Rv3N69XB/mzGgYQudhAUpoDGAn5S8YBk0bjGgYZdhcdOloiLEOEMvS2s3Q86NVBHKOrg/+B0CR75FPwhCdMNzVUALlAxws3aGEwPqLZAKLnbZObp60y7s7OjD8nU70NOnCf1cS0k+DGbkViWbaU7ls4h7uSbbrXLVzIKrKFxNxujdAyMbA2q3c/mdD6VY9eKK0+Oh8G+EpGV8EiKlcDboUsnd+9zYLjYJ0Uft5IIbZd7esBO7u1P45zvbivqd131WFMXa44riOlmrkAIaB5hL7EYIc9CAmwtPuIuB22IUlR2ySsWaCRYfe/ZTt/6xSS6OTYSwFdAALUHuFuL8vzHcyhYEFQOaJ3OtkISILzeSbZvGKduabojCafSMb54w7jrzxoB6jHOHC25VPHDNgyrOtyKEbjAo1u4X90GJdUCjsnkYBo4kRMWWYfEo5+a3ZmspWGcs0gKqUXKqSKNlNzt0gxU1p51lWDIwqgMqJaEqoH19fbjmmmswdepUTJs2DYsWLSr4m6VLl+KYY45xvP/ss8/i2GOPxaRJk3DppZdi586d1WhyJBEUqhBdcAVJTBIXXHsDFFbcghcmpWQ1dIPP+ilYyJl7EqLCWXBLakbphJiF1zA055sFzq+7ZRYOKgY0X+IgDxdcMyOpPYFRrWbBFay5eWJAvQZ6EGVYchZQRLq8gFcSIr/DqRSlKq44HFd8JSHK/YgPoRHKuVV47TI3wphSXOkM3V6gmqOW1qc4UGqCOy8XXCHBWfhCJ5ElVAV04cKFWLlyJR566CFcf/31uPvuu/H88897fn/16tW4/PLLHYvRihUrcO211+Kyyy7D7373O7S3t2Pu3LnVbn5k4F3lTMEyjCkouPipcrjgup0+KgtUpYQvoeSBzQJqCgNiHecCSYhCzoIbrALKjelcA/L+xs1iYBRw260U+VxweXgLqKkN6DahgJc7a0nwFxPgiI9I1UcZlkCy4JoF1sXimVU4T3Wx6oDakxC5eQm4/T4Id+cawemCW5xbq7BxVsUYUNckREVaa+3UUohAHODHWlEKqJcFlAtViKSrSI0SmgLa3d2NJ554Atdeey0mTpyI4447DhdffDEeeeQR1+8/9thjOOusszBkyBDHZw8//DBOPPFEzJgxA+PHj8fChQvxyiuvYNOmTdW+jGjATzjTAsqC3zEXXSPl8P7O7b6bCnF0hGmHHlhis3mXUNHyxThdyuaaK565Mg0pFUdHBJiEyM39rGAZFjcLaDB9li8JEX8tilDnL6uAchYGzWA2F9xozBk/8AI1s2frVgrHgFYqNjsf5hGZktvCK3fjbPOOLqzf3F7WMYrF8My07e9a7POmhoZhxXHM9yKVOoNzTa9mGRYrIzvA6Z/FWWsdh6SBESn4Z00+y7Yd5xDIyndK6KYOwoXQtIBVq1ZB0zRMnjzZem/KlClYvny5a5KOV199FQsWLMDMmTMdny1fvhxTp061/t5zzz2x1157Yfny5VVpe9TgHzyqYiqgwU9HscyDnC64YIhMQFulXHCFn9nqgBouFlC7MGAfS2Ev9UFurAhCmc/atm7rW2B1QPMojczVmgtLoResIbrhsIjWCkJiKVvSNiGbv18X3GomIeIbVca47+nTcOcTy3HXUyuwdWd3mY3zj64b4PKD5PCbBZdccH2Tb777+w0/5grXCS4VIcMz/Lvg5muHPSaUkBvNy/JeAPsYV/hXIeY/IdwJTQFtbW1FS0sL6uvrrfeGDh2Kvr4+7Nq1y/H9n/3sZzj++ONdj7V9+3YMHz5ceG/IkCHYunVrRdscVZiHi2XQrqbMLRmSJKuBwRUpjko5g0rFmrluDEC0TgjJWOzJa+wHDDkJUZDnL6VmnVsSoqASJwlus/lccBOJ3Pey12h332V5rKlRxsiXhIjrFy+h2KkUVbBxuZNnG1QZS1R7Vwrp7HXv2N1T4NuVw2CA4uJ+7j8Lrtt7tTMWK0lJSYg8ljc+W7p7JvAycLv3PpQQigGtHfyGijh+52fu0/ogDcmwTtzT0yMonwCsv1OpVFHH6u3tdT1WMcdRVUWI75GFREIV/i0FfodZUVXrdSKhIKEGtwfB5SEDy7ZDQUbnUQNshwDL5EczFAUqJ9Mlk3K4COfFbjkosd0J1X18ZKZDpn+YolilWgDxPApzllEIsv8UexkHxgI7v6Lkzm31UaHzq4qjvxS491kl5j8P4+4Vs52Tn5+qmsiNCSVzPYzvZ0WBwf1tGMH1ebVJJBXhOvl7pXLzw+uemZ9xh6h431j3KhvbZJ6v5PMIY1IJ7F4aLJOEyAzR4rdH/bTBzXqqqgqSFZovslLSuuB4XhS+z/yc59dZJZHg1ooKz30G65lTzNhm8N4CZCwiz3QCABzPGt/3zrEeZPPfqvxYqp1nFVB5GSFIQlNAGxoaHAqi+XdjY2NFjtXU1OT7GIMH9xczu0lGc7P/a7FTX5ewZmVdfR307OtBe/RDXSK4IdDQVGe1I5lMwFAysajNe/RDHWdZCBIVyEpzKoCMZWpgcyMGDegfSnuKIVmXFDZNGhrq0dJSfLsNpLj7kgTLvm5qqkMyoWbGizk3ssI0fx7OU8r8SkntKBXF+l8GVQ3u/K27GjitTQGMjKCW7/xNDUmHpJRIKHl/U87851G4jTY1Id7HhobcOtHQUI9eaxxkxlVdfZ312379G5BIJHLjT8nf/ijR1Zu7p0oiIdyrhoYk+hQFChjq6lTXa07WJYR5afZfJTHnnKqqlhaWSLi3xw+7ejSrzY1VaK8XiqJAUTP/Zq4l875X39rZ2ZV2bBwPGtQv88yLAcWsCw0N9UJf9etX+D7zv1EZE54TRvb1gP6NFR0vyaSClJIJaTCKGNtqQvU0IiSSpc8NInh42WbAQP/jq39rlzAGTNkgkUyAZdcXtcCzNqpUSkYIktAU0BEjRqCtrQ2apiGZzDSjtbUVjY2NaG5uLvpYO3bsEN7bsWMHhg0b5vsYO3d2SWsBbW5uQnt7T8muLr19actP0jCYtVXY1taJukRd5RpbgJ6uVK4dTLHa8dFHHWioC64dPGYJEpZVHgBgV1sHjLT8Akxvb1pwT+nu7kNbW1fRx9m1q8u6LzqDZQnu6uxFOq1BZVnrHgAwIJ1Ki+cxDNEP1zBKakepMNv5DS248+/enes7BiWb3At5z9/R2ePwW3b0aZZKzH+eVFq3xkxfnyacs6cnNz81PdennV2ZcdXZ1Wf9dteubvT1adbfhqFj585OqTfx/MLfUwDC67RmWO+lbP1n0mObl+0dvRUfjyx7fxhjGY8yBuhp9/b4oW1Xt9Xm9vaewOZPKq1DNQwwZtYdzrzf1+s+H+zsbu9xuOjt3NmFhnr51+9i0HRDsOqWsi50cfMXANrbC49Lfs7z5bp0g1keMbt3d1V0vKRTWmZsc64amqYXPEdvX9rTXbO3z994IuSgqztl3cudbV1o8Gnc293eK46B7JjV9WzICAMMH2MpSlRaRqgUfpT80BTQCRMmIJlM4q233rISCC1btgwHH3xw0e6YkyZNwrJly3DaaacBALZs2YItW7Zg0qRJvo9hGEzqOAFdN6BppQ0uQ89FeypQLVeVdEqDEuBOsa5pXFLVXEC4phlIKGFNHLNvcqlz+vp0aI3yTGQvNN0Q5GRNK22MpLXccfismpqmg2XPkesjBsPQhfPkPs/9XepYLQkmRjMbrPS5UixaWhfGNEPGJTnf+dP8PMhiGPnbXM78F4+T6yvNdkxdz10LgzgOzLFlvpdK647xl04bUm7iFUsqpbn2Q/YN62+vccb3MeDs50rAsuuW6abIkEkqU+p5+lK6eG8Dmj+6zoREFFbfGv7akE4bjrmUSutI1MA4NHnkhf9hxbod+OaMg7DvSHFzvph1Ia3p4nz18bzQbL/JrXWq9TqtVXa8WApv1uk3M7b9tNU7q4WmlT43iOARnjUp/+MrnRbHq4KcfGLKNoHLJwFRKRkhSEJzGm5qasKMGTMwb948rFixAi+++CIWLVqE888/H0DGGtrb2+vrWGeffTaeeeYZPPHEE1i1ahVmz56No446CqNHj67mJUQHPvlPiNlnhTqgfLkPt1IWQWEm2eEEFrcspTJi3zApNROpWGDcXt8tFxhr7kgXzIIbehKi4O6fwXJ9lxtD+a+fuexSBlaGxWcWXGET0MqCK9Zms4+DWkn+YnjUO8z8nfM397pnlcpOnZecJsC9V/p5Si38Xi6Gab7N0568v3f5Xq2MQ5MV63YgpRlY/f6uso5TStI6YSwo/PObi9at+Hjhz5N9p9i22qi1MVHrVKoOqInCB4vTUJCGUKNW586di4kTJ+KCCy7ADTfcgFmzZlmZbqdNm4YlS5b4Os7kyZNx44034p577sHZZ5+NQYMGYf78+dVseqQQdoSygiVDcJk3rXbw55NE4cu1glO8wlSIi8D+UC41C6ZQSkRQPBgn1HKBngXKgAa+wttPF2QWXG7sWracEsqwBCUg5csuyNsPVD7ba/Z7fJZJw2AlFbaPAkJJHFtiB9WukLrgFPQr0iwRs36xoliZesvJaq7ppQl85aIbpp1LhPlcg93mTa2MQxPzfpR7X+w/99NP/Dn5jUUlYd+orCBchmdzbCs+zpGvXEctlYmKA6WW+LIPgZz/Cr9RFw0DQxwIzQUXyFhBFyxYgAULFjg+W716tetvTjvtNMvV1s/7hKj48TuXQe8KChYWRYUpYoRqcMw2KYoWUPvCXLIFVBgfOdcqg+WsXEzJZXm1b1yYi7ySddEN2gLqqDsa4OkFIc5STopXQIN6KPJz3l6Int/AcFrCxfGl6cxZ2L5GhDzxOuwWUHB+XSFaQMGs/1srVxnzzl7jNSgyfcOy2SuLt+a6bbrVyDAEkBlLlgJa5n0ppT6tl4ygKglrH9JtI3tney8URUHLwIai22lm6jafKuZ7Bdvqcj1JVYEmeXgV4YTf7MxXXseOY7wK+mftuOXXCtHL20sUjVBgnrNwMS1YS5+wQ5+QxAXXcjGtXmHtauHY0S6x2YbH+DAMgxMu+AIJ+RW+wHsvTBdcru+sTYwCHeBqMQhg04Mx0WppP6WggHIbMubb9l3pfL+PMrz1TbHlI1A4e52XxbFS9XnzwllArblZjgLKCXlagMK6YbhvWPn1znFTLGplHALi9WlFCOKux7JvGBWt1Hm44NoO096VwvyHl2H+w8vQ1Zsuup1MGNvie/lw2wDr31jn+RkhL2JIgP9no3M9cFknCWkgBTQWeFg2AlYVeNc2RXFLPRE8imXhyy1Ouh4vF1zmIVgILrhmoT5A0FwYF8NlwHSXCtcCGuT5BVfB7Jh2WGRtGC7jqxz3Sb/Yu8XxsOa+oKpOl3QxLseoWAyybAiCui2rL6+Ye+34lGJpKh2F0z/LsYDyyaiCdME1ALOWLh+m5fNa3Lq2lqxdgtt7metaKeNScMHlnxO8i75ts2B7Ww80gyGtG9ixy18eDx7T3ZaBe+b4WB/drqdfY9LzM0JeSnbBtc+RXDFRbijRWJAFUkBjgGDZSIRo6fNy8Qs1CVH2XyGpQjRccCsl6ArXq+YEi4wFNP8xMy632ddKOAqo/YESpAVE54UvxZ8F1M26E8SYc7iG5nPBVZ3Zse3xo87jVaKV4cPckrbl3iio8Dn24KtiAM1tDLFKWEBLtDiUi8Gy64XNQuE3sU2tx4Dy90Ir0wXXLsj7GS5efWn3lBHPU148sTC2rU3Pwr8zLff9GnKRZWQBjSa67VnjF/t3rbxZ/FiiLETSQApoHBBcLKuZva5QMzxcPQPccefhrXeCC25UFdAKJCFylEDilEsr2YndAmpakcNycQlC4vc6taC8+4sBdZ13AbS5UNIgXqFK2JNRQXQB1HRnXFWtCP75suAqCj/O3a/XGZtd+fVEmGkVEKyEmKsAMzIbLFfoRuH+79eN3jULbmWaJwVaibFwbpQSsy2EZ/AWUD6Uxza+xXWihLvh5pJdhAV05OB+AICEqqCluUH4jIgG/LgpxvXcoYByWfwtaChIQ6hJiIhgEKqA8opWwK6momWBz7IZjsjAW++g8jGp0VihnFkNSz2Ou8Unc79cYkA5AYEhlzCCqSqgI3AXF2cSoiAVUKe7ZiELsHsSouq3uZDLrBgrLlrC7b/nk6Pkjlcbon9eBVSYB16/r75lWOGsRMW6rbqhheCCm+snbj1RFIA5S/x4HqPmLaCcMlfmddl1+mJdcD1DeWyHETIql6CA5hKvcy64RcSAjtt7ED4xfjgG9qvHe1vahc+IaFBqWah8ZViUIsYSEQykgMYAPpNpqFlwPZKchJX0RxByFH5HNxoxoIVcKv0iKB4Jm+JhfqbA1dLCC+vMljRCUQKyiDquO7jxpLvEgBbC1QU3CAW0kAsuvDYiMt+zZ0qtWRdcw70fAGTKRyn5rXSO2OwqdAyfqIXlNNCSj1dqzFU5mEKm5Xyb9bJQmP/SHm57HjWlgJapzAnHKuF54c8CKj4vyx5LnLxSTIIt81yqouDwiSMBAO9v6wAQncSCRIZSQwI8XXAzf5XZKqLSkAtuHPByfQ3YYsELdipvYQmpLpPBDM4CyiUhiooCWiEXSL7/VVuBcbdYM8ECyhgXR5tNwsOCSapj4rA4BilsuMytYiygitWn1Z8DBet2cu1OJgoooC6lDWpF8BcUSJsCqvKPTN8W0Cr2ixA7Wfp5Ss06WQ7meDKTzggbVj7HktvGTS1lwdUquDFQStIwQWkVpoWzTrBJqe6TudPkPLZQxOaKqaAnElx17+xznSyg0aLkGFDHV81NLsXxHhE+pIDGgZxPi80qFbQFNPdajAENR+ETN8ecMW+yU6ksuIaXazT3PvMQBhjL5VLmkxAFJQS6nifA+ydagEuxgAbnFmQXFB0WUMHz1Clg2gXLYOpdBo+RxwIqWPm9YkBLiLUrntzGkGmRLWcIVTLW0C9CTgBk+7bIeFZXF9zaGIYARKtnuUmI8sV8+/kNLzoIFlDbb8pOaMXJK8Wsj+ZYSKhOBTQqeR2IDHqFYkAteA+uiMh3cYAU0BjAP2h4C5cRYMHx7BmtV4rCKzoBNyOLoeu5h6dL2QnZqZilhbeACgI3sz7j62jxCpQYL1dYOK80DMwxgILMwusaP1vIAqrzSqv/Quvl4ozZFDcKeBdclZ+fZpmdAjGgteLmJoYK2CygiqiEuv8+/98Vwc21rIwTlRpzVQ6WBRTMEhCtzSyfCoNrEqIa0kBLtQS5UcqGkfgd9+eE/XkpxICW4YKLIjYk+BrHvAKasBTQ2hkTcYDfxCvmuWIfb7kqLCrIA1c+SAGNBSz3fz72MvA6oJwinAhf4RMsHXmSKshKpSwtTHcXuA0GMR7HZQdR17XccULIJMwYs8V5AIFa9vk+N11wC9dhyb1U/CmtlcBNCBM87Jj7/DQ3HISEKJrz/taKkOeVrRsw14n8mwYFXZ0rgLnJohTppuiFqDQENHd5BdSkyA0ZdwtobYxDwDbnQsiCK9QB5Zc6YX3w/k1ZWXAVWPHNhcYDf22qiwWUXHCjhZCVu4gx5Bwn2TWmyHhiIhhIAY0BfByfKiTbCTgG1CPbalgCgxB7KoFLcLFUytKiCw9vbkkwdOugCpwxgYDt3lnKVHBxWGYWXvHNAC2gHpsYfn9jKfUBzEX7hgUg3j+hDEuCHweZ93khLu0iFNSK4M8nVVEdj8jCCl8hV+dKYHkYqFWoAxqQC651TnONUXPKvf8yLC7v1cg4BCpgTeQoxWNG/A23Pqi5/JX2+HW9XHduPmQIPr1KuHYmuWeYaQFlqK1xUeuU6pHh+K71J29NJ2SBFNAYILiUcZPQTSCtckOsl6pHrGGQGJqHBTQiu6WVsrR4J4fKCbqMdz3kTiMo69kHf8ZwGsw9NQwjFw4HZ/uqfn6XTYxCLsBCbK0a3K6s2/gQxpDH/DQ9Jfid6FTaeX9rxcogKJAJmwWUS3DitckSRGyswr1ymZZFw1s9A8+Cy+dRKjKe1TUJUQ2F++nl1tTkKCVpGC8jiFlwveeBEL9X0ljKbZgz+3se8NZhIQkRH3JUI+tTHODXo2Is//axmFtWKpOsjagspIDGAcGNMvd20IH5Xq5tYSUI8LKAhqUQF0ulLC1CFlx7fVau3AP3gfVScI/hNzcCsiLrRi6OlzleVB/hHvgc04LngWIq7eEooN4WDmcSIl4YdbWA1oiAZ8B9PgDmJkc22ZbHPbN3Q1UsL3x26iIT97ghKDpBxYCa18BY1pWYLynjbw0uZNWPOpUsj+PcsPTxGw/hXxXKdeUpw1JSHdCcvOK3dqPggss9hxJCdvvaGRe1DGNMWIPKiQHlNzMU21tE+JACGgNyu0KK6CYYqgWUdwUOZ0Xgy62IMaDRWKGcgm5px/FMusJYbvOCd2ERYkB5C2jC/f0qwp/HjKcsGINZQZhbAieWP76aT/ZjuS0H4YLrpoB6uODyAqZ5v3lhNK0572/NKKBCTLRNAVVU54aH/fdBlKdhvGCVVYjLGEPlKg2lkKsDmruWQvG1dtyeHbUyDoHKxuaW4oLrdR/UPEkEyy3Dwod9uHnduMGvTW5ZcIHaGhe1jCNWuYj1yHNM8xt1EZHv4gApoDGAn26CC27AWXBFAdc7hiQoGHf9YtmJaMSAVsrVT1RAE+L71t6FuwLKvLLgBuWCyyugAbqzWudkTmVSQX4LKK/gBJkF1+3hzCseXhsRbllw0zWchAgeseqAqSPlj1N0zMsqdgtvkS3LBZcbk0HdRz4LbiZHCC8k+owBdWlqVDYQ/SDEwpWdhMj72F7wlih+Yy+R8A6hEUr6lKQ0M+v/is/xwK9jqksWXPt3CHkppV6tiX3q5xJn2UsQEjJACmgcMB8CSsh1QIWHRPgxl7zrkCJBe4qlUpYWvh9EwYIBQhSOKejyAoYzBhQAdBcLWTXgN1HM9jmz4lYPoU6eqbyz/IKXGANq9lkQLrgubfFQQBNClsusBZQ7gKsCGo1pUxAhVMAeA6rwSYg8fh+EBVRIQmS+VYYLLh9zFXAMqHktCucm5zsLbgGrftTh70XZSYgcGyM+LKAeLvr5PJjKTmjlEvZR6Cj8+BViQMkCGjnsVvOykhAJWXDF94jwIQU0DrDcP/yCHHgWXPAPifBdXnUPQTMqMaClCBSucD9T7YqH5eqnusbjCDFYnBuzHlgSIt4CGpwyxzXAeum3tJAw73zWDq0ExSQhEjYisvVCeWHYTQGtFQsD308JmwsuP8a94nbtylM11zcFCldaq/TzCIpOUC64lqtlFsECWtwxhPeisXz7QkjoU+EkREWXYeEV0ISzTrCJ4IJbys2wvG5yHiKFwiqEOUsxoJHGrV61X7w3GSgLroyQAhoDzAdEZn+ZUxKCdjUVEraE74Jr8C64Cp9UIRoSTCkxPe7H4TYGeBdcGJwCCi5BCOeup/NWZK4PA4sjc4mnDLIMi6CAczGw+S5f+I1ptQ3HBdfwsoDaxoH9t7Xsgqu4uFWLf+Z39XYke6nCvbXGC5/dsYzTlFr2oBxM65gClrkEwc3f3/rh1rU1ZQHVK3df7PPTT+4Fw0sBVZ0x4iblW0DNe58bD4Xayp+T39xORNCzKe44FNAixpD9HrtlwQ3iWUv4gxTQWJCZcExRhPTpQQdj8zuliRAtsSa8247i4nIoO/Z2lprMSYj945PPGAwQNi8KxIAKblnB3FMhCZFZBiWsJEQ+LaBmllUFuTYHkQW3mCREoiu288Fey3VA+U2NJBerDrjVBbX9ljnvZHWSEGX/5ZIQlWUBrWC9Sb9YMaCMQaivCvh+NrmNuais334QyuOUualnzxjsZ76Kv8m9Tia9N2z1MpMQWb/gQoaKsYDyXl68uBN42TmiJMoJYXCO6ewao6pciScaB7JACmgMsCacwtVKRAie8JzLlZjGPZwFQSg4r0bQAsry/+0XT8UDvAuuuwKq6+5xtEFZ1zU+224IFlCxxq5PBVzPbQhZFp8A5kBxdUD5DSLdIUjWsgWU31RwxIBygozbCuoek1jR5gnnVjjPhHIEq0omu/FLrr1mEqLihURz/CZrNNaPn59a1hW+VPLFanoh9CXvwGTPls4hxq0W/yw1LVSMz4pc4DeCBZSy4EYa+0ZLMWPI0wLK/UGOuPJACmgcyE5KxuzJdoJ1wfXMssnCyTor1iXlLX/yK6CMscplwRUSOOTJgqs6kxAJiZx4F9SAXHB1lyy8QSYhYkIMaM5alndu8QpOgMWxXV1wPU4rlGGBU1hNuSYhqg0BT6gp6MiCyyvmbtY35/GqW2Yqp7SVY/kvP3NpCecULKAoqVSC+UwRXC1rYxgCKC8hi51SsjOLMaA5ElwIjbNsBj+WSnHB5TY9fY4HLwU0IWyK1tDAqGHs96mYpGiOZ1D2T34zg5IQyQMpoLHA3C1XhDjswOVF3uVVCT82g1ceBMU8AkmIXEtqlBoDKtSy5JPPGLAWaw/3OF64DqMPDRcX3LDKsIgW4Hy/KV3gLgdXF1whBpSfn3xJHeYUCmq4DqhXuSgAmXuWZw+9oJW5UlhDiBfSSz8cv54EJaiba4d5CeK1+CzDkj0Gn/m0llzsKplR2RGbXKwFlNvZUxzZ0vnzlJs4iZdXylNAyQIaPUoZp7nv5l7zG+XiWCqreUQFIQU0RjAAKq/4BR4DmsVeDiasLLi8+ygfAxqBBxXfZab7WamCF3+9jvIb1jHdi4IbHnG0gSUh4l1wLeW5PFe1ohCUFd6NO08MaLbPGPwLWJXAbVyLCmj2haIIG0QwDIcQ4LYrXTMWBsECKlqCVaWAC25AMYm8tbPY0iVuCDGgAbngWuPFxc3fdxmW7NeSifA3NKuBXYErywJq2P8ufCzBAsqHaiTzJCEq0wLKPF7nwysGVMyCK//GMlFmFlzbWFRcX9fO+hB1SAGNA0buAc8nIWIBKQm5E2bawSBaWMJy3ROzfvIuRfI/qAwXpbHU5yu/UyhYfIQyLO7JToRSNqo/BaySCLGmWaVJYcEk9QHs7pr+sgDzMdl+XcwqQaEkRBAs4eLj2o9Ldc244HpsyADZMEXzD1eX5sp5JuTFjKcvEJPqFz0EF9xcGRYXl0uf12LOpWSCVzRqYxwCLu6IZTyziy3b5RbmYZLMk11WKzMJEV/6K7emF7CAcuf0toAW3xQieOzrTzHhPOJYZIKnSLElnojqQwpoDBAFXt51JtgV2eCUGaGQdUgKn5hsxNulSEZ4wSRpKaAlWkA9s5/y7ldwVZb4RE5hKKBuWXgVBHgP+RhQIQtwvhhQcyOmeIG7HFyVI/sDO9suVRHHQdEJSyIMH5OuJJx1QPMJMnwfWJ4JVegXRXhRfnmBSia78X1OvgwLUFTMn4nlgquG59lTTSprAS3OtdEroygAJBLeZdTEMiyl1AHNySv5NnuEc3okUEuQC27ksHtglGwBFeQX3uuOxoEskAIaAyxrELOH8gU8ETkLaBglO+zwO20JNc4uuO6WLzCWq4nIux5y5xFdn/hNhZKaUjS6iwIKBuhBxaDyLmqcW1o+qxeDM3FSWFlwXbNcKhDKX8ZNARUsoKqtDAsfG+vqgpt7bW0MVaVb+JtV/s6+3eoQhBLncJfja/X57DTzGEJZr9oYhgCqawEtNKcdGUU9Nirt8bqVK+njX2nglRb+Wa6SC27kKMsF1+O7Qhk5QhpIAY0B/A6zGuZOMVdgWpVAYBCSECXCswyXgiEIA5l7WnISIltyqNwjnxOxBRfcHF59yMfXVhNDd1pgme39asIrkwlHAieP3+i5+ViJDKZ+KZSESMgKLWighj8FtEYEf4Wb/wmbBVRV81vpBAtomZ4JeeFcy6zqSBVywXX7uxqY/aIwlg3/zPWt32sxp5mqKtbmQK1shADlWYPs2Pul0Ial/VwKnM+czHHE3/Hx4aUozKaiW0yCLXHTiCygUaYcBdTru/xYKsdThKgspIDGALFWIV9GICwXXEABH0MSjsInxnpx7qNRUEAFQbdMwcs2Pswsn4yxnDCQ+TD7fX6H28MFN6BFXlCeufMHVYeU17r4JET5z29albld2RAsToBXHVDFZunzZz2oldg7/jLUpM0Fl9+EKeCCa2ZmrWYMKD+Gyik/VI7QV/45y3DBzX4vo4CK79UCmiMergwFtGgLqO0NbugLZZryJSEqJwYUXNxeIQuoy7wDRI+FqsxDouJUIgZUVRQoii1DPZ/4kpACUkDjgOmBq9gtj8EuyPz0F1w9EZYCmlMShOQ7ERCkeWGiXFc/3oqnJrgsK3wZFtU99k0sWcEn4QnIAspvFvDWfZcyIdVATODEx8DmGdPZG8UUxWpzEHPR1QWXj+c1XeSV7Dgw3zcMX4JkzVgYuHuXtFlAlQJZcPn7WJeo3r01W6AoakVim8JQQC0LKDIucko5CigX41VLeoZ9TpV6X9zc6Asp6nZFgN/gSKjeG7a8wmBXoIuiiDIsQjI4TtGgMizRoxyrv/lNPimZBemf0kEKaAwQ3ZlUj/cDaAeXfEUoBxOSBZR5PFAj4YLr4upXauyqYPFRVMECyvngchuInNumED8afCInNxdcILh4H3OsKABXBqaAdwG3w2+6NQfhglu4RiVnCeefDH5jQGtE8hfd28UYULF8lPMe68Jvq+iCK7SnfCt6JZPd+MXsKyEJUZHF4pll8UBNuuA670tp65r4rDP7Kf9vnN3Ib7Z5b2SLSYhKt4AW44LLn4dXPsQyLLUzLmqZcmrfmvc4mVDFUlV8CFGNPKdqAVJA44A14VTRAhqw4mcpdkrWJcJ6P5wFgY9T5K1XLKA6eOUgWkAVx3tFHsx6yZfpUYDc2FEVWMuFkAXX3QIY1NgSkyCF7ILrM7GWaXFmCmD5DQYw5Nye48KmheCCmxDe9iO81Y6Ax88ttzqg3o9Nd9f4CreOK48kCOll4HDPDKBEV84Cal6Le6KzvMfgXXCzc6l2xqFbEqJSNxldPGYK9JNzDOQ2CvJtNvIxoKXdi5yHiLnhU2iDTvNIpEcW0OjhGPMlJCFKJlRbaJFKFlAJIQU0Tiiie0rg6zFv+REsCQG3wzytkGyEqwMagTTd/L2zLC2lZsHl+4FbqDPHM4VEd/c4LzfmoBRAsZQOZ1UPqMat5X6mKELinrzxRkauT4PclXUTBt1iQJniTEKUT3grNwuzbAhWfbsFVM0tV26X654Ft4ouuKpQq6KkY7m5ZxYj9JWKeU5rpCnw7XJpYiUhUhTOWFYb4xBwKpylbgzw87fO57h0ZMHN/us0jOZxwS2pDAt/Pp8uuPxGICdbkAU0ejhcxYtxwWWcAsq/rwBuSRSJcCEFNA5wCSt4y6ObC1l1m5ETcHlrUVjp0XmBOZn0TisvI8zV0lKiACpYQEUrhGINHcV1B1Eo4cIrgEGVQeFdcENQgPnSQuLUymMBteaBwv0oOBdccROKs2Zbr8RYcYOxvIKkOXdqx8LgbQFVlERO+XOLAXXLglthBVRUsJRcQrcST+O6MRGoBTQLb6Uo0gKqcBbQ2hmHzvtQ6saAW5Ke0uuAKkKpE/u4E1xwS2mvZd1XxY3qPJjnSaji5jZZQKOH/VlTzCZGzgVXgcIFLauUBVdKSAGNA7wrQqj1LjnLT4FYqiAQrXc+E8hIAv9gT5qJbFCasOtIQmS+z1lAxWybue/ziiZvLQpqbPGbF7wFVA8qCRGfjdRvXDNvNUVwD0WD5R7O1nuuLrjiOuH4no06M9trrQh4fH3gpNMCmq9UiF7BjSHv5tkSb5VpAXWL0ws6CRFgbnIVtyFjzj9VARJmDGiNDEPAJTlUiS64bsmxCich8v5cfE5wzwODCcctZSPD2thRi8+Cq9oUVrKARo9yYkANwQJq26ijLLjSQQpoHOAFS/DCZ8CKFsv9I2TBDWlHSrSA8oKm/A8qoe1eCoXvY+VeO5MQcQqWqZR4xIAmBAU0oLElxP7wFtBgz58Z07wC6q0Au1tAqw+foMH+Ht+ujGLMUSAJUTVdTcNASNiSFO+PWiB0gAnW0/KyU3vBmCG6KfpM1OKF21wJog6obimg/CZOcddiKR6c5Sv4jdXqYVfgSl3XxI0RfzGgzs+59UHhFVDv9mkGK9413y1Up5CynB2vCZvrJVlAo0c5GbnNe1yXVIVnmKLm5JooyHdxgRTQGGBNN0URkswE3g5OwBUSxoQkuPJxgglOeWEBxQ+Wg1usGVCiLm9P4JAdIgq3ZCt2pcRqR7hWZNECGkYZGH5M+/Qu4G9SgG5BZpvqBFdpdwuoaksSllcBTVY/22uQ8BYduwsuOBd1t3vmbgGt7Fzg/BJKKl1ix82tMxALqOVq6fSy8O+Cm/lXVRRrL6dWNkKAyllAhedFdr4Wusf2zy3xXbGvD3zMZyXGEq/o+tuQMGWLhE2+UbnnFtUBjQblKaCZfx1JiJDL91dOvWSispACGgc4i0tC2LkMKE7O1g7AXs4gpBWBL5lQxymgEXhQuZVhsb/vF95qoyCPBVTJbwHlrchBWUB54Ye3gOazQFYSYZdV8VDs7DA3ASs4i1PCc7zkLA/8P0D+GFDLpU/+fRtfiDUF7Vlwc0qSmwsuH02QqFK/MD7uuYhMoV64u+AGFwNqjkZFVYuOiWaWEsuVYYnA+u0X++ZAqRsDbkmICj3n7P2oeDy/+eO4rRNFK8253ZXcZk+Bn5j9ZFdA+fdqZYOs1rFb/Q3GfM9pMcxE3OhlihmqRONAFkJVQPv6+nDNNddg6tSpmDZtGhYtWuT53XfeeQdnnHEGJk2ahC996UtYuXKl8PnUqVNx4IEHCv91dXVV+xKiAVerMMzQS9710F7oPgx4JUVw3YmAACPWKnRPKuMXQYnziO0RSiQIP+YzCXsXJ68WzCNeTw/IAmr2EeMz2kLsO6/fCG7NQSQh4qwEbkKZOXRYLitM9ofeWXAV+E9qEhl4q7bdpQ9cMi6XyxXKXajVcU0WjpcJSvVsjx/Cd8HNwlmr/HoEGJzioVjZmCvYyJCx34eSssrCvTxQMRbQTKbr3AaV3UPC7Te594pts7mpwFn3CwxuazPDRQGtxfI8tYybpdrvs4UvwyJuDvMbdYQsJAt/pXosXLgQK1euxEMPPYTNmzfj6quvxl577YUTTjhB+F53dze+9rWv4eSTT8Ytt9yC3/72t/j617+OF154Af369cO2bdvQ0dGBF198EY2Njdbv+vXrF/QlyUnOB1dwU8wnJFe3IQpUbu8jrB0p/sGZr66ZjHhaQEtSQHOvVSELLicIZkwMmZdC0gnOXTFZlztmQA97If1+CC7AzGBWHF7C7/n5GKes3SqQJESckKYqCnQwW3yiexsYvIW3hKpYyV9qxsXN2lSAQwFV1ATyaaDCvEzmLHKMsYolwdBtFlC/Qrrn8cJywXXUAS0+CRGf2dm0gNaSouGMAS3VBdf5vGDZ9+2Je3Ln5sdyAujLvM644Lp7MLkpyEXXLuUsoH7LVJlKbtLVAqoCMALZVCHKx9UjQ2dIJly+bENIQqRwG+h5sjYT4RGaBbS7uxtPPPEErr32WkycOBHHHXccLr74YjzyyCOO7y5ZsgQNDQ2YPXs2xo0bh2uvvRb9+/fH888/DwBYt24dhg0bhtGjR2PYsGHWf5T1SoQpCvh9oaDVz5wyAzEWNawYUN6KqOYEORZ4zxSPKFCUm4SIW6hhj8PKCYemMMCfQVSEORfYgNy7maFZr4VaroG5AJtWfeSCTFDAqs8LWKoivldF+FIFrlYBfrMBEFyxvQRfRam98heM2yCwu+DyYYpu6C4W0Mwxq9G+CimgIbngOiygHrWG85GbSoo1/WplHAJuMaCVsID6C9mwZ85VuA1krxCaSmxm8BsSZlhDobg93YcFNAoby4T7mPQ7hnIWUGfOCqXMdZKoPKEpoKtWrYKmaZg8ebL13pQpU7B8+XKH8Lh8+XJMmTIlZ0JXFBx22GF46623AABr167FfvvtF1jbo0fOBZcXkoMO2hIEOyFjaFh1QMUdMkvgjkAwm5Cpk+/LEtZWwRKcUHMumIwJ1nPrlaCz8C6wnLAe0G6z7mkBDSq+2bz+IsY074JbpMWnHMxNC5WPl3PLgmvCjQMvwZdXZmtF8Ge5W+rwOlcVNa9VxjM7dQWFXz55WiV29sO2gFp1H1U193wq0gVX5VzsaknPsMeAVqIOaDLp7j6b7zd1SRdR0aUckbv1qsTnKed1U2hwW1lw88SA1pJlvJbRXJ6dbu+5IWR65263woUqkFlKHkJzwW1tbUVLSwvq6+ut94YOHYq+vj7s2rULgwcPFr67//77C78fMmQI1qxZAyBjAe3p6cF5552H9957DxMmTMA111xTlFKqqorr7lnYmLGJ9vTiRcFguQnW1yW5mBvxYRQEinlerh0Kgm9H5ry5LK/12SREpoEjjPYUBReK1lCfsF6rqlJ023mjDt8PRjbfpoKMYqqopv2cWecQftvQwI0tFkgf8vewrr6Oj8IM5h5yc6sumfA9t8zfqAk144Lr0d6KzH/beRMJFQlzh5hrp3UvFUV4D0rGwuu2OqqqgkQ23oYhAvPGDwrLXo+CBmFMAcm6RC5WkTnvGZ8tur7MeenZvETuXiRUFWp2Xpa8brnc2yDuZWbcZ3UMxXQNz/no+Dm/wczrVqy4LxbU3A8AXTcc9yaZVIteF1TOItRQl+tjJd+45MdyUs2ttdn1gSFjwRDGndtYKlbOyN7TjFVbtbb4Ch3DXNvs30uoSlFjiggXc13gURV/6yfLjp2GugQU5OZOMqFCTSgwUFvrA1B5GSFIQlNAe3p6BOUTgPV3KpXy9V3ze+vXr8fu3btx5ZVXYsCAAXjggQcwc+ZMPPfccxgwYICv9gwe3F9ql93m5qaSf2uW1lATKvYY1M+a3Y0NCbS09K9QCwuTyIZPKYqKIS39rXbU1wfbDpP6upwkt8ce/TOSkJFJqhJGe4qhf2uXtWEycGAj97oJLS3FjZW6pIqebD8MHjIg4xaqZB7cOgAoQF1dEtCS0LMChtk/dUnV6sOWlgHW67o6NZA+rKvLnX/AgH5oNcd2UzKQ8ycTSkY5UxQMHOhvbqlZqU1RVdTVZfuUIW97y5n/VlvrklBVBQ0NSdTXJdDTp6G+IddPiYQpPWbHv6JYCmp9fZ3rBl1dXQKNDcmsghXOPK40dQkFfRkJGIOHDBCkoUF79IOSUC2FyX69/fp1WP3UPCA3L5sH9UNTQ2Uetymty2pTQ0MdkskEDCWziVFK/29r73Pc26am+qrfy7r6ZFbpzPRlfWM9EsneTIxhgflgkkyqUFUFTU31aGhIQVUV1NUHM/eDgr839mvzuy7s6tGs4wzo35Abl8390L+pzvU3/FhuaqrL7VAp3PoAhmQit9bv6Ew5xlL/AY1F3Q8lq4HW1dVBTSbR52NsJ+oSUFUFjQ3Oe99Qn4SqplDn8hkhH3XZ5xRP/4GNaGnxkdMlu5YMGNCQDavKvN3YVI/6uiS07E5pLY6DSsgIQROaAtrQ0OBQNM2/+URC+b5rfu/BBx9EOp1G//6ZQXXbbbdh+vTpeOmll3DyySf7as/OnV3SWkCbm5vQ3t5TRvxHpnC5YTB0dPZZrgk9PWm0tQWXKVjXDKhZr87d7b1WO3p7U4G2w6SnJ2W1oaOrL/OSAem0Fkp7imF3e6/lfpbqTVuv23Z1IVlkDGuqL231w+7dPVbop67pmbhdlkkuoetGNnOFYfVPL/fb3h498Hvay93DtJZzGe5s7w3k/JqmI8Eyjrj8eOru7vM8v6Fn+okBMPTsC8Zcv1+J+W/S05OCYTAYugFmMBgGQ3dX7j5pmoEky+wQW21hQDqloaurz93FljHomg7DYOjtC3Y9qRaptGbdn/bduXUKADo7+jIJtljGVd9+ve0dPbl5mdKs1zt3dqFfY2Uet7t2dVltSqV16AaDwjLulKX0/65dPY57u7u9p+r3srs7Mx7BMlmW0+nMOFIYAObsWzf6sn2cSmnQzHHYWxvj0DCc5Y86uzLrSrHrQtuubusea9l+BoCdbV1I9boroLvbc+NCMUthZOeFsD5wz8u2tm7HWNrZ1oXmBh8ZZEy4Z46q6HnXR5OenrS1ttm/Z2SzePNrHSEv1rrA0dbWhbpCmZC5UJF0SrPGKwD09mlIa4ZlXq2lcVBJGaGS+NpADKAdrowYMQJtbW3QNM2qH9ja2orGxkY0Nzc7vrtjxw7hvR07dmD48OEAMtZQ3kLa0NCAUaNGYdu2bb7bY2QFMlnRdQOaVtrgYsyM0lDAWC6VgK7rJR+zpHYYzCqizocXGkbp11YOhmHkljTDdC4FWBl9HRSaplttV5VcX6bTxd9TnesHwwCgKNl7xKDwY4fzEDDPYei5digKN7a0YPrQ0HNtV9Wk9VrTtGDObxgwnVX5uaXluf7cPFCy/+V+40U5899Ey/aV6d7GAKS5djJzHCgKNM2w5ioMhhQ33nj4xFSVaKMMWPdHycQUMeEzWPeMMec9S6e58YjcvEylddRXyO1LT+fuhRCmjfxjyItUSnPc23S6+vfSHI/mQMuEI/qbDybm/TGNc7U0DtOa4bgvKdt98XutwrjknheplA6tzl055H+TSKgwuLGmaYb1nOCf36m0c51IpYq7H0r2PIoCMKZaYyTfMcz1Ss2uXcLxzLWuRsZFrZNyGfd9qcJyjcbLApnB4zgOQ2Z81eI4iOK6F5rT8IQJE5BMJq1EQgCwbNkyHHzwwUIyDwCYNGkS/vOf/+QyTjKGN998E5MmTQJjDMceeyyeeuop6/vd3d3YuHEjxo4dG8i1yI6ZfZYpYva64LPCWaqKkDwjqJIdjtbwCWxU1VKwopDEgo/JF8uwFH8s3u4vuqEz7n3VykjIwychqqvj3OSDqgPKWXv5JEhBFaMXMjsLc6twGRahNlm2VEc1McdMJt49+57rORXx3zxZcFWupmjNJPngkqXxpXWAbKIc6zY7r9et3IX9/XLhM9QqQlKkUo/n/GGpyW6KweyTXNx08UmIzDVcUWqv3qNbSZNSsxPzm+t1PtdJ/jMzBhQA+DJdwr9wL7lSfO3S3BaO37CofFlwrfWJyrBEArcEfn7mND+UM0mz+N+oCDLhH+GP0BTQpqYmzJgxA/PmzcOKFSvw4osvYtGiRTj//PMBZKyhvb29AIATTjgB7e3tuOmmm7B27VrcdNNN6OnpwYknnghFUXDUUUfhrrvuwj//+U+sWbMGs2fPxsiRIzF9+vSwLk9KTMuHRdCaFiesJ8JsRxaDz+CayGVJi1oZlkSZZVjMflCQrQNq9gNvXuHuF1+zklfiTU8GILiakIwTbpJ1OVcyQw+oDIy5uQMxC26+Mc3XVlWEDMbVHXdWFlyudqc4Xmxt5hQtU3irsyU6yCQudTtWdGHc/bELtJmwWG+Fz2teVnKTjT+HypWPKrWWrJuyGYQrlzmmrLIbKi8k+iOX2bn2suC6ZicuUYkqpWyXkDk3YRfoYWVLZ1zJLVeluUQFVOHKVBXaoDMVc37OmVhZumtlYNQ4bs8aP+NeLDUklmGx70tQSR45CDVt0ty5czFx4kRccMEFuOGGGzBr1iwcf/zxAIBp06ZhyZIlAIABAwbgvvvuw7Jly3Daaadh+fLluP/++9GvXyYo+aqrrsLnPvc5fPe738UZZ5wBTdNw//33O3av44ooUFVnV774diSc7weMUH6Eb08EBGnPum6l9GX2J5ZAIexwc8Khi3VCUEB5V67A6nByFthkCGVYTOVdEa1leh4FmHGeALk+rb7Qb1kJlOLrgJrjrd7mrpfg64DKP238Ya+zyZFQE5wFyHnB/B5CXZmeCZ7N4+eWzaulFNzrgAZoAeX7G8Up05ZVn68DWiPCZUUVUI8yLPkUUNFqKtYB5f/lu7siJX2sZUhxlEEq1NaEyw9MC2itbJDVOubmNf+s8TOnnd4n4jquKN4bh0Q4hBYDCmSsoAsWLMCCBQscn61evVr4+5BDDsH/+3//z/U4DQ0NmDNnDubMmVOVdkYerx39oBdkzrWN3/pweuoHxP9v79yj7KjqfP/du04/kg4hnYSEh8ggAmF4NE0ig2MzPC4EQ1CQhwNcMzDrCoyjsO7IgMY4gLiyZBHvCJMIE5h45S4iIKZBBO44wxhHAVEJkIgZGBK9ToQQguTZ3el0n1P3jzq1a+9dVefUqXNOnUd/P2tlnfR5VO2q2rVr//bv+/v9tNmi1Au6t8AExhhsZbIV7fiN+caSvUxYUDU/BQQEZDimwvAiZ7+oYMionewXEfzDdIslA7RPyv9IK7QOAPlCHkB0QpBa4J8TveSU8WBX3lzrd27gJbPrARrbaoH6uUlwXd/0Lt4PxXgi9f8Sk2J9sq2nxU8rnYyiYEtwVex1uj6vty0nBcYL8ZLrWqIS3KjT7Hm8vHWvZPv3xxmhScHbxdCIWpBK24/yxvMi2YKlYYBqfTlYqFTvqM+iPKBRstxECAkhvDFduJ5CxBHRTgW/v0Z6QEV7SbPbHb+/6M+aJDJuvS972fm1663P7+A9a3NOQ80fggZ7QEn2SGMAz3ZA1h8N+oOkZLxcHdH3K3KB9LQVlshMqV91HlBXvWoTbljXReqeFs0DWpQru0KgQ5Pgull7QC2venYeUG2VVZ+klZjs+N4dIaRhtNa7zWqSZhiN2rXUPA/F/6gPfKOnK8oA9SW4zX/bJKRozkUsmHseFt88jfCAxkgda7keo9/jXn316iS4ecPT5d1DWUhwgwyr3t+mBDfZsfiGldRisNulH9YyNtcMldAn4uUluFKIoG6wQXjBNtoDWllfEsZij5YcsKQE119ci6ql3F4LE+2Of526EnrqfYzFPykN+1MKM564XVQSrQ4N0AmB7nEJ3q13zFmoFTFS4EZ5HPXDd4TUYlqaf3Cy5VHB+yk2psXmGm9bnhZ/cmhMdK1ETsEmszmHfh92ITx5pPV+/Qm8+lLoBkeC/VvyyXqv0OvxckliQPVlBl/6Z0tw2zEJkT5OFf+jPhNOkPQn6mh9g0ggkP4BtZ38GqEDQl84S4cu6+zs8O7hLK6lvw8VA2ol5UpCQRkewf3XCiEUSdC9PsqLl9KbmI/xZpY6VQXNuPezigIwPEkArCRE6RLIqE0ZYTEwxtRSC3RqcS1CgksPaGvhL37pz5okCy+uYYAKAOYCuvnd9lDrtDo0QCcC6r40DT+R+XgcGDqyAXLNUGu0B5rUYrtawwAN/m9MdFO0PfSbCCmy1BJC6ATnyvw8swG+oPepBmRW9vcjzRjQknJUzWsr9LjR8fF6tDDYfmIJbtEI0PqBb1jZElwjBrRNJnih+1/o/w3CB6KMJF3mXK8Vd2MiLqKVCZWge6j865ulAaoQEojwYJUiWDsrl9m59dDPjz8ZT50FNy47cykPaN5XTEjPi6i6s6mQ0Bf7Ir22FXjTC3rYh5BG6a8k8aqlsuC2S79od6KeNRV7QB1hzIsEYCb8owHaFNAAnRAEk3ShZ8DLOturmuD6lRP9txvzYDCySTqN98hWgptiQhG/seKrb4BHSXBjvBMqC6wQcBrgAXVjPKDZrXDqcsiEfciIAa2PlywKlagj1mtpejhc9a6r4nKiPKCBBLf575tE6LHqxqt/auKTWQTrEaJuHlB98iQ1ZUK1ZVhyUqj4wCxKVqj4TV0Zk9ID6uj9sE0WQvRr4MsR0ychCv6fNAmRsWAlRPw10d7226fnJaikzcZzIxQjX7pOMlA6Cy49oK1BlNqm0hhQKQSkMW47iBKRk8ZCA3QioBkYErqR0Kh2eN4VN7BAM25IsRl6HKVWBzSrGpbVECf1S2P4heWiKp1k8I4+0Y35rTBidjKKAS0E3kQjFjbzGFBhxDWXlABr96Mxwapz6ZhClAdUb6bddYwY0OKqdKgMS/tJcP37P5xsxVduxHsc1Tm2Er7VNAtuaJJe3fZCni5kcy19WZ0y86WIHGNKoZcWEsrTVbMmNpRx3TNdlEZXXlPTw0jQkjBngN/PHOnHgAaLjR7h+8A3BHOOVONCJXGrhUI+qAIqpJm1v8T4mNfaatNuCo12xx97Oiv0gOpf8WTj+uKwrUhp/jneRIAG6ERAGStmopasSmVoO1Tt0GmGMixCSy7SAjmITKlf1Z4WS3oZ7ER9Qx/AzRjQIAmRvo3MJLCaB1YaEtisPLCa98bwgMbfW0HMm7RkQXWW4GqTtFIS3FAssKtPLIXh3dBLJbRL7F249q3lAS1h8NleI5+axoDqHlApjVqJadDb7KsYxjN4NgT9xX8+aYlCKs2C68cpon088YYHVElw03pATXli1Ps24zF9WcVAK/szLMF1NAO0koRWRlI0K+N0qbh63RNuk0vRDtI4fE+37gFN0u/1vmPPi4SAaYCOsy80AzRAJwBCk9YJY0DP+EFtK9uUwdfgLLihpArNP4HRpX5VV9ZRRlzxz4hJoO7d9D5yjde4bdYb1/BiN0CCq/qQGX9U0uDQY0C1a1dvr5M/4Rea1DFSghuysApBtlFpevZijdmWxjVfdA+ocEoaSa5aXDCHlZrGgNqx2RH3ZSX4E76ck20pE5WEyH886YtcSBanpcbBdpTgasdRSwO0wygPVMIDannzhb1AZUn1gcBDm9MXMyqQ4BYMRY2VJbzEdgIvftgAbTfPeLujak7nkvVT+3eAPx7YCq76xOST9NAAnQDot5qRqCXzezAwhAE0PuusXfcwKvaxSTGkflUOrHoiIWsn6r9SyGA/rjZRcO1r6p/DjAxQQ4LbiBhQH4nEmZ3VKTMVCfVuc1QZFt1r6VoGqKtdb0OmqR2n1GJ/20WCWyoLrneN412gUXG2+vs1aZ/WT1wp4D/G0yaV86+tLEotgfRSz0ooFFy4cLUFUk0R4JZPuOO6rpHZWf20TSaX+vErAzTlddHvzZwxByhh1Gm1NR0ZeCPdKIlE6DdS7aeSxEmF8UBmq5cYAoB8ieeyvkBmEyyqNP9znQTjUTV1QO2FeYH6JYUj6aEBOgEwkjwklAnWA+U1s5N7NMz+jJtwN//gpMc+VT3RjcuCq8VxCmlmqBwvxuOEJ+vFTWacBMi1DNCCm00MaJCECZYBXOo6aOdMO6eZxYAKRMdtWtLTQIrtmpNRRzfIggz3bWJ/GrJuAGYWXIGgr0eME/rCUN2y4NplWIxY08rvO19qqcftZeIBtc6JqCDpDGDVQ9UluG3SEceN8jjVeUCNpHUJPUumcS9gLyCr56a2bb/N+jhRSRIi85qaHtBSzxR9gcyGZVhaC/86VZoFNyTB1cdtacZOsAxLc0ADdAJhhVQ0bKXYLnTfKI+jbTyp2NQWMkBDsQ3VeECt62JYFMKM3fUNLHtRITKDbh3RPaBmHc5srqFQ18GKxS0VA+r/xvIm5uucOElftIiOlzMldq5611XGgCOFUWvPkOC2y0Ndi5lH8X8+UjrG/WajqgJl5AEVWoF1F6UTtcThX1uZUjaZlkLBBdyCpui0jOmyHtDg/3rSp3axM6JiQNNeFyNpXcLnhREbLETgYVehGsW/DQM0kODmfG96JR7QvKm6MftDfN8uFQOa5aIKqZ5AqSOD+N1ESYhMD6ier114K1Tqb/aE5oAG6ERAMxKM7LNZ34YxD7vGKXCjs126LTA8RWU09d5PsTFbilxEWPE4ImpyqMVAGq9ZXVQ9BjSX1ANZ0wZ4L0LAkbnIdoV/EkgO9ayfbp1lj/qDPbI0QYwnXLiWtFT3gOoT/3aZ4IWSMekGqNCSdcV7QB37vqzhqTEmWlZ2xzS70Utn+Nc2yxhQHy8GNHkmayOxjnYe2lGC29lRuZxVJ7ZflticHldpSluTSXCdFCV97Bq3Rgxoic2oBbJSZVjapF+0O/q1rKSEjt6XbQ+oXZbFzSpLPikJDdAJhL2in/WDWlietmDvDfKc2LGPrSTB9R/0NYgBVdgeUGOiK015nG+8x8XLZZaEKMjC6ziBAZjZA0brQ2aCr/J9WghTMpavs2w4SFwVI1e0JLhqnIAbOxk1Sro0/22TCFeTdXuvxQ+EmfU3UoJrKBO092tah8VaGIJuUKTxgAZGg+9xyCoGVIiCZudLYywrJ0nXJ6WeVz/8fiujG25+Qpa0HlC//wm7PFASCW7Rmx/KsiyC8SFos56EyO9LlUhwg/9Ly2tVsgyLJn23oQe0tTDj6JMvYoSTEAWfCelYSYhq1FhSFTRAJwIhiaX1fnYNgdGABht8SkaqTkvrGKDBJa0+s7FtLEWdBzs+qzA+HvpO8Yup25EKzWiSCZNr1Hb/wb0lHUe7tZJ5QA35dJ2figVDahk1KbPuT/W2axkpWhIiTZJb0JLCtDSFmHHKp6QEN1gY0hcXatkf80ZyMGF40dOc/3zUhC+DGVrBLfqSfU+7FFZZouQSXN2waos+CFO6GmTBrd4DakjDS5yrkNdUWPOIiBwO4/o4kSYJkV6KSlpZcGMW9bxkVlBttQnKwbRHv2hnXNc1Y9JVXeJKkxCZw7SwY/LpAW0KaIBOIILyAY3xgKq92QlrGiXBjc362fwPqrokIbIy2RoSXOkYNeL93fjxaHZx8sxiQNV+rAl/RvGImoluyttL9KEg5k14K7NFCnX2OkXJtkvJ0vT7QfcwGB7QCjwqrYMtwfXfjTFINYxzrH2tlgadLi8XtqQyRX0732uly6vrXhLI71Mhmb9edqOMBDc04fTHnho3tkHo95yfkCXt/RVVrqbc9vT9G4ZdqP/rHtCwoVtJX7I9oKbREGOAWpJ0m3ZbmGhnDFWD0BY3K0xC5PW/4DNvnU4PVWBfaAZy5b9CWp8ID6gLZH4PhiS4/gS3wRJcK9arFQanIEGE+dBNM3GMfS6X8oCGVhBNuWJmixuaASz8LFtudgawiKklWzIGVUtcJCvw+FSLMQn1S1ZExYBGLBDpcTl6nJUtyW2L+Lu47NgJlBJBTiw7KVUNDVDLaNMt5TRZcM24Pd9bVO++6N8DxhKOYXCUG8tsw8NpM0PDMOaKs+nxgpvqHjMSkMnw+5G/sTygtgQ3asE2qCkrVTsrkXMbzxVpLkjEjam6ZzMqBrTdykS1M4YR6VS2IJY3FqSEsYAohYTQ/G0uveFNAT2gE4BAOWOu4GdtaIVjSFBsR2NQEtwmkQRXQpwEN9XkyzKiVDF43QC1Y0D9SYU94VUZdDNaVLAylmaehdf/j+U9LhXXHMRCS0M2XE9ZkC6P1eOGI5MQ2f0Arinh0zqc7YFvh0meay/YBR8YRPlBozINA7W9HQzpqTRl3Gk8//4105MQ1TthizLU9aJcluQynx8P/1DD8ARrfbo9vPCaZ1pbGADS3WOGgiGhBzQUA+p/ELovIjygTmA0V+QBDWV4Ll+mKm94vqLKsPjbbo9+0c7kLS9mJUmI9PFASjMLrl0CohVqvU8EaIBOCExDS92mjS7D4o8IDXswRHiGgZYwQOOSEFXTdN0XYW/MTgjhJ/lRA7l68Ge7qmAnjFFeq4yeL6JgGytJ5O1Fo9ky6uspG7YTNCRJzOF/osfl6N4YIGpCW8NGNwrlABWRr0EoQ4QH1NXOU508w/pChV1eoCrjJMMyLKrfmYGc5hhTpglhuWb4/VZGXxjIObohlkLlEiOhL9Vf9Nhgow5oiQXb8SqTEJklhqxEXjGDuh4fGBkDmsIQJo3BNkArSkIUyg4efOYpUhqQI4KUhAboRMCSmipDNOtVIK0cjNeexnocQ8cfpLfMvC2Voq9OV736H5JWea+2B9TIUOl/Zr5oEtyM+paW3dEja1l39KSslDGp1w6VGdUBda2Hc6m4KGEfi17qRpreGLsMSFvIH+3s2IH21vu4RAyoP9EXsCfPtZTg6tfSStSSxgPqGw1OsoWJWpBX50nzgCb0ePmYiypBBtTsSjDVl3E9NtcwGtN7uUNlu0r0S+M3pfq8HgMalYSoIgmuvugprcXV6Lbai2s2ygPaDmNTm2N7syuJI9a/I4QwymS15XOqDaABOoEIJHUejboH9cLp3muDGhJbQqQhrakIZYAWm1zVQzaUJTm8MGDX6HP9yaEdA5m1Ea+VYfFe/bczXlxJk1jLypRaz4diImmTVRc3yptrx4BKATOmrB0m/zFZw31TqdRkvKbJweKap0+4jSIs6RZ+AkMjyDpZ7zIsQQxoQZ1fzziqoA6opdCoRK7XCgTGnHnPpfFOB/2y6C323y8lwS1E9+XgvvADySMM0JQJrfRFByElpJ6kLaY/6NvPRRmgWr+g56u50RcrzBjQBFlwta/YSYggpDlOtoVUp/WhATohMCdUSTJ11qcZpic29H7GuLano4ViQFVdN2nKAtNMdO1swEK96iuK0kyqYkvoKpKg1pCYDL5Z799eVClZ21Y1WRpZcOtZu9Qo0q17zKNOUwlJerkY0PZYWbYUAdaAFSRPCx+r7jWqJKFORa3TF4YccwUgVRIiQzZZXbbVxPv0xy8zoLUiRUDIAFULBe3QB3VjTpr1glNcGz3+29tm+edFXBIiYS/AaJsYU970oFxTJYsZRt+2EnnFJiEq5wFtu/GpfQmFilSSBdcOGdKQlgSX/aA5oAE6EVB2n+XpyzoJUZxcscEe0KDQfAsZoMUm+gNtIKlMsbEEHlBpxSv6E914Iz7bJERhL3ZjDOAkfci/D4Q0a5fWswyLHR+j+otumVoJnaJ+q3s2vL9l+5VhiUnGpBZoLCVJ1E9D5WnqlAVXWtL4auqA6osJmcWAGpHn0lASlLsf7MmqSGBUtRJ+3FvO8oCmyVCsezMBbcGyxKkyvfma+sWSpEcmIdI9oBX0JX0BRQphyN3j5OW2usPGVCIkbgppAOOWN1tlf07Qh8zQBHPhwTM+9cUMdoRmgAboBCBQ1NkPjmzbEdgq1kOiURMGe6LZqBOTAjWh8A3QGsSA6lNBwIoBFaYcSnknbA+kamA259CNMQDrXdJEa0Hx1ZKVx02W8nnDAyqRTWKEUH21qMm6tZYQJHTSJ3imN0YKc7W5XSb/AEJ9WsVGq0WG8E/MOqDahKeGp8W1MoUaHtAUxklU4fd6ewh8SZ2hspDCGGPKyYn1Juo1A120h4dj3C99JIUhLU3lAdXKAwHagmWpJER+DKrwSreokjnW+KDfCFHxxOMVjMWuVYbFEZoEN+aalvOAmt5jGh7NTK1iQKUQkJoKSVolnijFbg5ogE4ElGfDx5cpZjsYC5gPsGB1s8EGaCtKcLXVaf01zcCql3Qp/sd7sTygRhpzVYYl5hxmdk2jDcCSEth67F4lAS7tWbBjnJysyrBYk7RoCW6MQsGOAbWSEBkJUlrg3ilLbJ82347q40FsdnKpY+XNs2SK+sQqVRKisAe04Lp1XUxQyaPhBh5lS4JbbhFJb5+QpjS0HRZCgpIm5jgxnsoADTyTQNA/S03sjbrBQqsDaj0n9C3ktcWMIAlRBR7QgvnMMcM+osfHgmW02Eh6QFuG6mJALUWENh4Iuy+1w3OqDaABOpEoDs5BptKsXaDeiy7lLDYk23ao3ZqDmlvCs9Fs2JKqJBOKWGwPaIQNKSDMbJvWb0MS1KwmgGr/0th/VhKbIC7KLEMjYhZ39AefQHap4c1JmpkFN/wwjjdA7SyaoeyCbTDxh7VQFvzHfg0TKBP8b9beo6hvSQqzDmg6CW7gtcpVGWuYeJ9qoqkbkdK4H8pJTcNJiILP2mF+mdc9oFVKcPPWgqWTYMHSTChkZHQpvoQXbI1yTSmSQhl1QK1nTlxby5ZhoeHRMtj3dOoYUCkM48ZLvKV7QLkS0QzQACUZYk3s1AS3Ma0JYkD9FXj/g+YfnFzXnOiqBBypTmacFDlAOo6ZEEJ58uJWxbM2QG2jKZvdV9qnjRqOUsJxNFlzVjGgcbLZmCRhep/KWTGg9cz22jBCixowXoMY0CgPqPdqT/RrmwVXj5OzDNAUXvSozKVAfTPh6h5QhaisVEI4CVF7GRrjmgfUKIGVJtGc5ZlPkjHYN+w8Dyi0hGvm93SljJLtah7Q1EmIpPXMSRkDWu25I9mhx3rqHtAkMaBmCR8BIfW+ZI4t2ZVpI6XINboBpP6Es9f51kpj6oAGWVb99jRmMAhJT/31mBZ4RtkT3ZokIYqTHCIcn5V3o2NAs08CVIwls7LgZp4Eqdh3ykmAx8fiywzUs82h7IL6xM6+VrYxXyIG1BHJC9u3DKG+a3q3A89P+KehZC91keBqXiKrdEma2y5IHCMz8xbpSYjU6GvdD26ZOqBGDKhd37IN+qGSs0qhjDkg3cJA3u6XCRYsfXvPjxnXBI2wNhLaj+MIFAqVe0D1zMcy4YKELvEtmwW3DfpFO2MrdVRW7gRjUUhmrvVYKSx1BftBU0AP6ERA2RdKF+a93ahVYmFKgRvnAi1mcvX/bKEYUDWhqGBFOxbb8xVhgHoxoPpqdNF7HPfbzAxQa7/q/WyvoR0/GysXMzKYWl6bOsqG7UQdkUZjTBZc3dJyHDMhSugYWuDeKY+1YOd3acsDmiQG1D9VtZzvGHVAHQf6Y7xQxmiLQkk9HTPbaT0z4aoyUlapp0rqgJpJR0xPVzskGVHeRGlnwa382OyFkSTyWL1fmIadOT74WygUAjm/mQW3gnHN8IBaiysx46NhtDjhZ5cRo17n+rakOswYUC0JUYLrZlcGsBOc6bTD+NAO0AM6ERAxHtDMm2EaK6Xq6WVCnNSuBVyg/gAarv5RhQTXTq+vES4Sb2exNGMws/aA2sXRs4rxiK2NFzOxM4xM6RgS3HrGrcaVYfHa5L3aScJ8Q9SIARXhGNC2K3MQrEgVX2zNYfz4GcpOrcXa1qx5elIo63qkuf91z0G15T6SouqAoqCdZssALSfB1ZMQhbxlNWxsgwi8iaZnupo6oCpkI0G/ND2gUhsf7HmEW2xX0F9yjlSPgPGCC9d1w2Nk5D6tEkNGVuSYRb2CeT/YsA5o65CPGduS9Hl77NW7ghDSiCduBSfDRIAe0ImAPaFSE8tGNCbYf8MdjpZB7CeSES0wONlyk0qC9W1CHuCoh7hwzIQ5ygNq/TbjRYVwZsbiBxmXYfGlv+UyO+tZcKUw64DW02gOJSEq6bU0j8W1PAxmHdD2kz7GJtayQgdExKHa2amruS/jm6ev7MtgAQ1mHcWk2zLKsGR0Lc1tB3JlM561XBkWe1ElbvutiS5n1SW4aUqJxGXBLbUp5c20PaAhtYv3YsTv2dmxE16PUhme47z7hgHqhKe01RrvJDtiY0ArKMNiy8y9/4tg9QVciGgWaIBOAIQlKQukr1m7K6JXUBtm8IViH/33G9GYyqipp8WacEclIRLCyoKr6oAq95mxjaySENnGs5v1qoY6dUk9oLoBasZT1rfshe3FDD7Lxy0mqPmlPbEMfuxNEqP30/LYt0HotoiQ4PqePUuuWy8PqJd8R/+wsjE9rj4skK7cR1L88yFQ0JZF7aynycuwtKMU3I/1zFmxuVVJcIUpwS1ZB1T7jR4DKoIVW++1eJ302FS9DEslbS7pAY1b1DN+U8YDSgO0qYmNAU1w3Vxr8U8Ke5zUlCJtIdVpfWiATgRCXirr/YzbYSeMySxjanRzYiVFzYy6pGq1r/yKdvzGrOONiQGNlMcFDSm+xmyzTgiVhMhMFJNdjEe0t8yNSUJkSnAlpBNEQbh1rANqx4BGebpsibwILFCFLQe0jZa2mODFJW3TPHVx+IevPE11TkLkZadOn1xD/37OMcttZFGGxfAiSwmRCwyOsnVAtd9KtJ+hEdQBtZIQpZLgeq+h50VJCa6eBVdEJJyz2mv3JcPzmOzBFM6Cq7UnRhKub7pcGRZ6QJsbM6OxVPkGkixg2PH3ek+QjmOU/2MMaHNAA3RCYE2oysgE692OhmVMtbEfqLLB7amAuCREtfCAxhmg0XW0CuZP/EE+o3MY9tplu/9QDGiJDKmAKSMTQsDRVvgLdbwf7RT1kZN1W1qnJKfapMAyOKW0yhy0wL1TjlCsmz2pVVL98EQmVJ+32B3r5gG1ZKuVruzbGUSzStiiuqMwY0AdQ2VRoQS33TygWh1QWeV1CUlwEyyMGLHBehbcGKWM7gF1pLRK+iT0gNohCkKPAY0rw1K6Dmi79Yt2xr6W6WJAvb+NnmD7XliGpSmgATqRaHSmUFuumLG3LERsuYXmJyTBraHUL7IOqHSiMxIGbuTY39aT2BjQzLPg+mVYTFmajRED6jjG5KiecauJYkCtLLhuxKV0LM+GPTl228DD4Fp92o6JVQoOhI0k11qQ8M9zLbujGSdn1QGtcEd24pisvEVB5mXtLFsqi3InLZRYS+uv7WBnBOVxLGl0Ggmu5R1S2UVLnCg9ps67x82FKjuLve0BzaXwputqqFBcb9yinqXusDESa7XB+NTO5GNiQJN40EvFgDrCsRRctWgtqZbWmXGT1CjDz55QNcoDald2bxR27GPDsyIlJ4h38P5Wztt0hUC9FyWjjV5FFhFZcO1MwtnHF1ttR7Ye0HAfKr17owyLEJC58mUGakGpOqDqMzsmWv1lGq/6hC7kNWuDJ7vtAS21qGJ7rfPWKrw/4a/leTEkuFbm2Io9oHa/SBG3lwZ/QmmUSoBdHih5GRYR59VvYZQH0k4OlWJssyfnamEkLlbdDWYHTjFm3PaABmNu0QA1khDZcasJJbjGNbViQGP6dt5aXLMxFBp17NOkesKhIjL0fhx6CSDAHFsgzDwN9IA2BzRAJwTFG1GaK/mNMrRCNRMbFnNpTriFmnA2P7VNQmT9HWWAOhJSMzyCiYIt35TG23XH9ziFLfFMdq9i2EJJkGLilbSJmJDSKMNS3yREwf/tAu+hh3sJKbY3sQweG97CRJtJ3Cwvpu0JNiYy1sTangTVIwYUlpeomtgmfUKes2q8psm2mhRV+kdPFCIdiAQGh/rc6NOoyhPcjATZib371b8241VIcJPWjY5M8GTXCbY8oIYEN2Xcqp2ESCTwiJczQPX3GPvX3OihRXp+gSQLB8FacNgDKoU0/m4HpU47QAN0AhEamrMejOOSGDRMglt8tYMGWuAhpYouhya6KTamEvlEBU8U9+NIY6Lrl3sIYiCluY3M63D6b/iSx8ws4OJuba9+9P5dV4sBtSSH9VyVLZmEyDpXpeJZbTmg/Xc7eJ4UtqcnwjC3z11gWPmepujvVYNrXMvq+pARc9WILLiuviBjZlgu15dKZ8GtVUsbh+819M+J751O48Vz4xZGEhp1RrZrWxngRv8mVTyx1R/Ma1raA2ovrOlt8alnnybVEyovV8HCekiCq33mLdQ52jvsB81AQw3Q0dFRfOlLX8K8efMwMDCAb33rW7Hf3bhxIy677DL09fXhkksuwauvvmp8/uSTT+Kcc85BX18fPvvZz+K9996rd/NbAtd1tdw/vpHgf5ZtW2xvUcMLgaoHWrSkqJkpWF6a2pR7iJccSuGYJRJCElzTAIuqkVhXhD2UZW2AWkZKzO7NZEDSSEKUVR3QIKbL/Mw35gNdQFjKZMeACiu9fTtIcBFaVPE/sKT6CF+z8ES/KE2v4aU1JLhWcrBKFwDsGoq6BLeeiwmB4esaJWt0yWW5kxYuLRSl0Ghd/FjPnGNOxtPcY/5vhCUUiVuwjIqrDElwFWEJbs5Jl4TINGKdRBJc22ixabd+0c4Eiy5hAzTpgpQaew2liITQx7YWcDJMBBpqgN5555149dVX8cADD+DWW2/FihUr8M///M+h7w0PD+Paa6/FvHnzMDg4iP7+flx33XUYHh4GAGzYsAFLlizB5z73OTzyyCPYvXs3Fi9enPXhNCVGkgwleY3QyGeC5S0SDTJWLIQ9sWyBscnO+FaVp8U3PKwVbh3P0xIx8TZVzIHMO6uTGMpCm3UWXJj7ryAJUSjpSkZ1QGOTEPntiimzAISNVzsJUTs92IMjMc+HmQ3aPF410bc8oLXMDmyWqhDG2kvFHlA76YeR7Kb+CyL62C/sRCFly7DYBmjwWasvhLiuq4x0qSbj3gGmkuBaSYgq9YAC+l0QrZAwvOkpkxAZd500F0TiVC220WJDD2jrEIpVriC/QNDHvb/10BAhzWV11gFtDhpmgA4PD+PRRx/FkiVLcPzxx+Pcc8/Fpz/9aaxevTr03aeffhpdXV24+eabcdRRR2HJkiXo6elRxuqDDz6IBQsW4KKLLsKcOXNw55134t///d+xZcuWrA+r6dAf4qHYyyaZLDYsBtQ3vKT1QG0BCzRWqlJVEqKwh8dHOtKKz/L3Y3mLlAc0Ww9kSCaZ9f6lfW9Ff9uOcXIcJ7BZs/KAirjEQZY324qJ9uNy9IllbEKjFkb1Xfua+ufDON5oD6g9garpWGtJcIVRqqIKD6iVYKq+HlC/rxXUmCGlhHSSG6D67eIlydEWBlpgDC+FkQTIH+NVRtDKjy3kHSqTHCvaA+qP9cUPrOel7uXMWUmIkhrNumHgSWoTGKDWPWej36/0gDY3QdyzNF6B8jHpalErIgmRFNJQcLX48NA2NMwAfe211zA+Po7+/n713ty5c7F+/frQg2f9+vWYO3euITc85ZRT8Morr6jP582bp75/yCGH4NBDD8X69evrfyBNjp51MyStzLpUhS1XLBMvV3espAqqfzWJYV4KNX8LSXBTbMzflr2yreHJRbWHgVW6I5xBNysPpPnQaZSsO5SYIy4GVF8QktL6LBsPqJSIlOCGvNnW/WnHjwGBUerT6p4nnXDdZIT+LljSwiyy4JrX0rGkZZUtYozrZVjszKV1vJbKxtfeE3ZG3wokuOEsuDVpZsOw5azeq3d8aTygcZ6lUllwfUIe0FAMaFGCa5T0SecBtft2kv4QGNfR09lcRn2aVI9dR7mSxU3VD6KSSQpzGK90nCT1IdeoHW/fvh29vb3o7OxU782cOROjo6PYuXMnpk+fbnz3gx/8oPH7GTNm4I033gAAvPPOO5g1a1bo87fffjtxe2xpWbOw+p7/hY5tW1JP54Ub3IgiJ5DLSUB4j47Od97Emq9+vkYtLY/0Jx2O2Y6u97Zn2g6fLv+kSq89vmGcGxtrSHsqoa/4Kn/qYO0vcpg9Mobe8QKwA1jzq8q25Z8HIczzoNPZmUNHZ071pXfXPoE1P34CnfZvi1KXzqG9mZzDnNq/VG0XALp2vZfJ/v0+LRxZ7NPF/b/7duT+9fsx5zjI5SRcISBdF+MbX8Sar75Yt7YOFF+fv+cpFAouBob2AwA2/O9BbADQoRx/xXNZLL0wdXQIA/sHIQSw9q4fYCxfwMDwGADgje88id9IgYE9owCAd74PrPl+3Q4hE0LnoThOCQHkct5CjH8Nn7nrViNL7p8UX8d+lMPaZx0cPjyGg/MFYB2wZl1t2qf3oY6cRIcTtGfLU4/gv55+pKLt+f3itQefhNSu5ZbvAfXUEA2geBwHdAEAch0OOgvBMumu5/4Fa57/l7LbAICfLn8Kea1Pv7xqEC/Xo9EZ4h/brqc7sPZfJY4f2u8ZUD8BHvlJZds6sfjqPOtg7S9zOGhkHAPjee958evS+9/6WAf+kJPoGh+Fi/BY3zW0R411/m/W3f8UXAADe72+tPH/DGJjgnYafbvTQUenE/SH5/8Va372r7FtlTsF1t71WOgzF1B9+nePAr9L0A7SOIJrOYj94wUMjHjPmv+7bLDk73qKv83tllh718PI7c9jrPhZZ2cOTkfQl9764few5l++V6cjyI6xrkk459P/E729HzDk6q1CwwzQkZERw/gEoP7ev39/ou/639u3b1/Jz5MwfXpPydinRrB/bAzyD1sB2FFIFaD98JDDDkNvbw9yU6YCe3dVt90q2jJj9iHo7e1B14HTgJ3bs2+H1Z5J03rR29uD3tmzseM3v25ce1KQc7zYzJwjMTaeclWveLBdvd55mD57Nt7bHCT5Gs914LBDZ6K3dwp+7jiQxfp8QvvtAQcdhN7eHvTMmInRrb/TN1tfijvpnT0bvb096O6djkK190yK/c86xOvTnVOnArv+EL9/7c1jjjkSvb09yHdPhhwZiv9NDfHlt1JEpJoqvnFg8VpO7p2OsW2/Vx85RS9TBwKDx5ESUnor1e0gvwUQPg/Tp2Ns2xbIKVPR29uDQ99/OF7/ZejrBv596UiB8dLlLFO3b6yrGzNnTsXRRx+JX0sRqAFSbjbneKUKHCEyi+X1Y4hFRwcOOfRgjBeAfC4HJz8OINmx+AmIRFSfbgM6HO/4cjW4x4LnhcDYeNL9F38jJcbcAqaq8WEG9r/9XwDM6ySEJxd2Xc/DXVGLixsqSAdHHHEoOnM55DtycMbL94dcCSeCFC2R3J4Uyfl93qn8nvb7Qc7xVlDHO7swc8ZUQPwRNkhvsRdonTleKTpHR/CH7VuBYz+AqVMnNbo5FdMwA7SrqytkIPp/d3d3J/qu/724zydNSn5B3ntvqCk9oHMvvxabNq7H2Ph4VZkUD5x5EE7u/xPs2DGEcy+7Gi8892OMV2Cg14oDeqfjwwNneu24+L/jZz9di/379mXeDp+uSZMw8Gf/DTt2DOH0s87DT2UHhnbtbFh7KqG7y8Hs6ZMhhcB4Po+tfxjBeEojVD8PA2fOx09FDkO7dkII4KSTTsHQ0BgAB8dfchU2/4e5ZD75gAMw8GdnY8eOIZyz8GL8tGca9g3trcERJqPnwGkYOMPb/7kX/jme/8mPMDoyktn+p06fgVP/5HRv/5dehZ/9ZC3GRkv36cOO/CAOnDoTO3YM4SNXXIv1634GNyJTpJBAR87B2Hi+6kyqQgAzp3VjyiRvsa5z7yje2z1qfKdn6lScfobXD8654DI8N3Um9g0PQUhgdu9kTOryHhm53fsgpcC0KZ73avK+MbyzY6RtJnnGeVh4KX4+4xCc0HcKduwYwgnHn4ydO3ZhxzvbIn87qdvB7N7JEEJgWj6Pre+O1Dyhj5ACc/s/hB07htDV2YOjL1qE/3rj9dTbmz61CwcWr+Wkkf3YvnNf3a+lkMCsaZMwubsDB3/gOAwNe5Z635//D7zxq1cS7V8IYFavtw0guk+3Mj2TOnBQbzcEBA4Yy2Pbe0PI59ONC+bzooCtfxgu+7w4oKcDMw/05lEH7B/H7rGOYKz/2KV49oBe7BseUt+3x5ju4f14d2flz/ejjz8J+TGBkbE8+j5Zvj9ICRw8fTK6OqOntN0jXjvaZXxqZ7xr2YOuTi+2PbdzBHuGx8r8yiPnCBw8YzI6cg5cuOjYuQ9/NKcfu3fvQ2duEuZcfBX+3+v/Uc/mZ8r02Yfg+OM9Pdzu3SPJyx1lQG9vT9nvCLdBmWheeuklfOpTn8KGDRuQy3mDxgsvvIDrrrsOL7/8sqH9/7u/+zuMjY3hjjvuUO994QtfQFdXF26//Xacd955uO6663DxxRerz8866yzceOONuOCCCxK1Z/v2PTU6stqSy0n09vZgx46h1MYFIaQ14f1PCLHhuEAIAZp3LDjooAPKfqdhouHjjjsOuVxOJRICgHXr1uHEE080SxMA6Ovrw8svv6yyoLmui5deegl9fX3q83XrggCbrVu3YuvWrepzQgghhBBCCCGNp2EG6KRJk3DRRRfhtttuw4YNG/DMM8/gW9/6Fv7iL/4CgJd4aF9RmvnRj34Uu3fvxtKlS7Fp0yYsXboUIyMjWLBgAQDgiiuuwPe//308+uijeO2113DzzTfjzDPPxOGHH96owyOEEEIIIYQQYtHQtEmLFy/G8ccfj6uuugpf+cpXcP3112P+/PkAgIGBATz99NMAgClTpmDlypVYt24dLr74Yqxfvx733XcfJk+eDADo7+/H7bffjm9+85u44oorcOCBB+JrX/taw46LEEIIIYQQQkiYhsWANhuMASWENBu8/wkhNhwXCCFA844FTR0DSgghhBBCCCFkYkEDlBBCCCGEEEJIJtAAJYQQQgghhBCSCTRACSGEEEIIIYRkAg1QQgghhBBCCCGZQAOUEEIIIYQQQkgm0AAlhBBCCCGEEJIJNEAJIYQQQgghhGQCDVBCCCGEEEIIIZlAA5QQQgghhBBCSCbQACWEEEIIIYQQkgnCdV230Y0ghBBCCCGEENL+0ANKCCGEEEIIISQTaIASQgghhBBCCMkEGqCEEEIIIYQQQjKBBighhBBCCCGEkEygAUoIIYQQQgghJBNogBJCCCGEEEIIyQQaoIQQQgghhBBCMoEGKCGEEEIIIYSQTKABSgghhBBCCCEkE2iA1oBt27bhhhtuwKmnnorTTz8dX/va1zA6OgoA2LJlC66++mqcfPLJOP/88/Hss89GbuOJJ57AokWLQu9/+9vfxumnn47+/n586UtfwsjISMm2bNy4EZdddhn6+vpwySWX4NVXX4383r333osvfvGLFR4pIcSmle7/efPm4dhjjzX+DQ0NpTxyQkgUrTImuK6LVatW4eyzz8a8efOwePFijgeE1IF6jgkA8OUvfxnLly8v245mshFogFaJ67q44YYbMDIygtWrV+Mb3/gG1q5di7vuuguu6+Kzn/0sZs6ciTVr1uDCCy/E5z73Obz11lvGNl544QXccsstoW3/8Ic/xIoVK3D77bfjgQcewPr167Fs2bLYtgwPD+Paa6/FvHnzMDg4iP7+flx33XUYHh42vvfkk08m6qiEkNK00v2/bds27NmzB8888wyeffZZ9W/y5Mm1PSmETGBaaUx45JFHsGLFCnz+85/HQw89hG3btuHGG2+s7QkhZIJTzzEBAO6//348+uijZdvRdDaCS6pi06ZN7jHHHONu375dvfeDH/zAHRgYcJ9//nn35JNPdoeGhtRnV111lfsP//AP6u/ly5e7J5xwgnvBBRe4n/rUp4xtX3nllcZ3f/nLX7onnXSSOzw8HNmWRx991D377LPdQqHguq7rFgoF99xzz3XXrFnjuq7rjo2Nubfccot74oknuvPnz3e/8IUvVH8CCJnAtNL9/9xzz7kf+chHqj9oQkgsrTQmLFy40L377rvV97dt2+Yee+yx7ubNm6s4A4QQnXqNCXv27HGvv/5690Mf+pB7xhlnGL+JotlsBHpAq+Sggw7CP/3TP2HmzJnG+3v37sX69evxx3/8x4aHYe7cuXjllVfU38899xxWrVqF+fPnG7/P5/P41a9+hXnz5qn3Tj75ZIyNjeG1116LbMv69esxd+5cCCEAAEIInHLKKWp/w8PDeP311/Hd734X/f391Rw2IQStdf9v2rQJRx55ZDWHSwgpQyuNCVu2bEFfX5/6/qxZszB9+nSjPYSQ6qjXmPD73/8eo6OjGBwcxOGHH162Hc1mI9AArZKpU6fi9NNPV38XCgU8+OCDOO2007B9+3bMmjXL+P6MGTPw9ttvq78feughnHrqqaHt7t69G6Ojo8bvc7kcpk2bZvxep9z+pk6diocffhhz5syp/EAJISFa6f7fvHkzRkZGsGjRIgwMDOCaa67Bb3/728oPmhASSyuNCTNmzMC2bdvUZ8PDw9i1axd27NhRwRETQkpRrzFhzpw5WLlyJd73vvclakez2Qg0QGvMsmXLsHHjRvzN3/wNRkZG0NnZaXze2dmJ/fv3l93Ovn371PeT/r6a/RFCqqeZ7//f/OY32LVrFz7zmc/gnnvuQXd3N66++mrs3bs38fERQiqjmceE888/HytXrsTmzZsxOjqKO+64AwAwNjaW7OAIIRVTqzGhUprNRqABWkOWLVuGBx54AMuWLcMxxxyDrq6u0IXdv38/uru7y26rq6tLfd/+/aRJk/CP//iP6O/vV/9efPHFqvZHCKmOZr//V61ahccffxx/+qd/ipNOOglf//rXMTo6irVr11Zz2ISQGJp9TPjrv/5rnHDCCVi4cCHmzp2Lzs5OzJkzB1OmTKnmsAkhMdRyTChFK9gIuYbstQ356le/ioceegjLli3DeeedBwCYPXs2Nm3aZHzv3XffDbnAo5g2bRq6urrw7rvv4qijjgIAjI+PY+fOnTjooINw6qmnYsGCBer7s2fPxuzZs/Huu++m2h8hJD2tcP93dnYaq59dXV143/veZ0jwCCG1oRXGhMmTJ+Puu+/Gnj17IITAlClT8OEPfxiHHXZYVcdOCAlT6zGhFJdffnnT2wj0gNaAFStW4OGHH8bf//3fY+HCher9vr4+/PrXv1bSGQBYt26dEfQfh5QSJ554ItatW6fee+WVV5DL5TBnzhxMmzYNRxxxhPrX3d2Nvr4+vPzyy3BdF4CX+vmll15KtD9CSDpa4f53XRfnnHMOBgcH1faGh4fxu9/9Dh/4wAdqcRoIIUVaYUwAgDvvvBOPPfYYDjjgAEyZMgUbNmzAnj17mKSQkBpTjzGhFK1gI9AArZLNmzfjnnvuwTXXXIO5c+di+/bt6t+pp56KQw45BIsXL8Ybb7yB++67Dxs2bMCll16aaNtXXnklVq1ahWeeeQYbNmzAbbfdhk9+8pOYNGlS5Pc/+tGPYvfu3Vi6dCk2bdqEpUuXYmRkxFgFIYTUjla5/4UQOPPMM7F8+XL8/Oc/xxtvvIGbb74ZBx98MM4444xanhJCJjStMiYAXtbbFStWYMOGDXj11Vdx00034YorrsC0adNqdToImfDUc0yohGazESjBrZJ/+7d/Qz6fx7333ot7773X+Oz111/HPffcgyVLluDiiy/GEUccgW9+85s49NBDE2174cKFePPNN3HLLbdg//79mD9/Pm666abY70+ZMgUrV67Erbfeiu9+97s49thjcd9997HQPCF1opXu/5tuugm5XA433ngj9u7di9NOOw333XcfHMdJfwIIIQatNCYsWrQIb775Jq655hpIKXHhhRfib//2b9MfPCEkRD3HhEpoNhtBuL4vlhBCCCGEEEIIqSOU4BJCCCGEEEIIyQQaoIQQQgghhBBCMoEGKCGEEEIIIYSQTKABSgghhBBCCCEkE2iAEkIIIYQQQgjJBBqghBBCCCGEEEIygQYoIYQQQgghhJBMoAFKCCGENIC33noLTz31FADg7LPPxvLlyxvcIkIIIaT+CNd13UY3ghBCCJloLFq0CIcddhjuuOMOvPfee+jq6kJPT0+jm0UIIYTUlVyjG0AIIYRMdKZPn97oJhBCCCGZQA8oIYQQkjGLFi3CL37xCwDAYYcdBgD4xCc+geuvvx7Lly/HunXrMG/ePHznO9/ByMgIPvaxj+Ezn/kMbrvtNrzwwguYNWsWlixZgjPPPBMAsH//ftx999144oknsHfvXhx99NG44YYbMDAw0KhDJIQQQiJhDCghhBCSMcuXL0d/fz8WLFiA733ve6HPX3zxRfz2t7/F6tWr8eUvfxmPPPIILr30UixYsACDg4M46qij8MUvfhH+GvLixYvx3HPP4etf/zoee+wxLFiwAH/1V3+FH//4xxkfGSGEEFIaSnAJIYSQjJk2bRo6OjrQ3d0dKb8tFAr4yle+gilTpuDII4/EsmXLcNppp+Giiy4CAFxxxRVYu3Yttm/fjpGRETz55JN4/PHHcdxxxwEA/vIv/xKvvfYaVq1apbykhBBCSDNAA5QQQghpMmbMmIEpU6aovydPnoz3v//96u/u7m4AnvR248aNAIArr7zS2MbY2BimTp2aQWsJIYSQ5NAAJYQQQpqMjo6O0HtSRkfN+DLc1atXh7Loxv2GEEIIaRR8MhFCCCEtzNFHHw0A2L59O4444gj1b3BwEIODgw1uHSGEEGJCA5QQQghpAD09PXjzzTfx9ttvV7Wdo48+GmeddRZuvfVW/OhHP8KWLVtw//33Y+XKlYZslxBCCGkGaIASQgghDeDyyy/Hf/7nf+LjH/848vl8Vdv6xje+gfnz5+OWW27B+eefj8cffxxLly7FJz7xiRq1lhBCCKkNrANKCCGEEEIIISQT6AElhBBCCCGEEJIJNEAJIYQQQgghhGQCDVBCCCGEEEIIIZlAA5QQQgghhBBCSCbQACWEEEIIIYQQkgk0QAkhhBBCCCGEZAINUEIIIYQQQgghmUADlBBCCCGEEEJIJtAAJYQQQgghhBCSCTRACSGEEEIIIYRkAg1QQgghhBBCCCGZQAOUEEIIIYQQQkgm/H9Ek+oJXp2CIgAAAABJRU5ErkJggg==", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 2nd try with adapt_freq\n", + "hist_ad, pth, dP0 = xsdba.processing.adapt_freq(\n", + " pr_ref, pr_hist, thresh=\"0.05 mm d-1\", group=\"time\"\n", + ")\n", + "QM_ad = xsdba.EmpiricalQuantileMapping.train(\n", + " pr_ref, hist_ad, nquantiles=15, kind=\"*\", group=\"time\"\n", + ")\n", + "scen_ad = QM_ad.adjust(pr_sim)\n", + "\n", + "pr_ref.sel(time=\"2010\").plot(alpha=0.9, label=\"Reference\")\n", + "pr_sim.sel(time=\"2010\").plot(alpha=0.7, label=\"Model - biased\")\n", + "scen_ad.sel(time=\"2010\").plot(alpha=0.6, label=\"Model - adjusted\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Second example: tas and detrending\n", + "\n", + "The next example reuses the fake temperature timeseries generated at the beginning and applies the same QM adjustment method. However, for a better adjustment, we will scale sim to ref and then \"detrend\" the series, assuming the trend is linear. When `sim` (or `sim_scl`) is detrended, its values are now anomalies, so we need to normalize `ref` and `hist` so we can compare similar values.\n", + "\n", + "This process is detailed here to show how the `xsdba` module should be used in custom adjustment processes, but this specific method also exists as `xsdba.DetrendedQuantileMapping` and is based on [Cannon et al. 2015](https://doi.org/10.1175/JCLI-D-14-00754.1). However, `DetrendedQuantileMapping` normalizes over a `time.dayofyear` group, regardless of what is passed in the `group` argument. As done here, it is anyway recommended to use `dayofyear` groups when normalizing, especially for variables with strong seasonal variations." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2abfa4f50>" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "doy_win31 = xsdba.Grouper(\"time.dayofyear\", window=15)\n", + "Sca = xsdba.Scaling.train(ref, hist, group=doy_win31, kind=\"+\")\n", + "sim_scl = Sca.adjust(sim)\n", + "\n", + "detrender = xsdba.detrending.PolyDetrend(degree=1, group=\"time.dayofyear\", kind=\"+\")\n", + "sim_fit = detrender.fit(sim_scl)\n", + "sim_detrended = sim_fit.detrend(sim_scl)\n", + "\n", + "ref_n, _ = xsdba.processing.normalize(ref, group=doy_win31, kind=\"+\")\n", + "hist_n, _ = xsdba.processing.normalize(hist, group=doy_win31, kind=\"+\")\n", + "\n", + "QM = xsdba.EmpiricalQuantileMapping.train(\n", + " ref_n, hist_n, nquantiles=15, group=\"time.month\", kind=\"+\"\n", + ")\n", + "scen_detrended = QM.adjust(sim_detrended, extrapolation=\"constant\", interp=\"nearest\")\n", + "scen = sim_fit.retrend(scen_detrended)\n", + "\n", + "\n", + "ref.groupby(\"time.dayofyear\").mean().plot(label=\"Reference\")\n", + "sim.groupby(\"time.dayofyear\").mean().plot(label=\"Model - biased\")\n", + "scen.sel(time=slice(\"2000\", \"2015\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2000-15\", linestyle=\"--\"\n", + ")\n", + "scen.sel(time=slice(\"2015\", \"2030\")).groupby(\"time.dayofyear\").mean().plot(\n", + " label=\"Model - adjusted - 2015-30\", linestyle=\"--\"\n", + ")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Third example : Multi-method protocol - Hnilica et al. 2017\n", + "In [their paper of 2017](https://doi.org/10.1002/joc.4890), Hnilica, Hanel and Puš present a bias-adjustment method based on the principles of Principal Components Analysis.\n", + "\n", + "The idea is simple: use principal components to define coordinates on the reference and on the simulation, and then transform the simulation data from the latter to the former. Spatial correlation can thus be conserved by taking different points as the dimensions of the transform space. The method was demonstrated in the article by bias-adjusting precipitation over different drainage basins.\n", + "\n", + "The same method could be used for multivariate adjustment. The principle would be the same, concatenating the different variables into a single dataset along a new dimension. An example is given in the [advanced notebook](advanced_example.ipynb).\n", + "\n", + "Here we show how the modularity of `xsdba` can be used to construct a quite complex adjustment protocol involving two adjustment methods : quantile mapping and principal components. Evidently, as this example uses only 2 years of data, it is not complete. It is meant to show how the adjustment functions and how the API can be used." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# We are using xarray's \"air_temperature\" dataset\n", + "ds = xr.tutorial.load_dataset(\"air_temperature\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# To get an exaggerated example we select different points\n", + "# here \"lon\" will be our dimension of two \"spatially correlated\" points\n", + "reft = ds.air.isel(lat=21, lon=[40, 52]).drop_vars([\"lon\", \"lat\"])\n", + "simt = ds.air.isel(lat=18, lon=[17, 35]).drop_vars([\"lon\", \"lat\"])\n", + "\n", + "# Principal Components Adj, no grouping and use \"lon\" as the space dimensions\n", + "PCA = xsdba.PrincipalComponents.train(reft, simt, group=\"time\", crd_dim=\"lon\")\n", + "scen1 = PCA.adjust(simt)\n", + "\n", + "# QM, no grouping, 20 quantiles and additive adjustment\n", + "EQM = xsdba.EmpiricalQuantileMapping.train(\n", + " reft, scen1, group=\"time\", nquantiles=50, kind=\"+\"\n", + ")\n", + "scen2 = EQM.adjust(scen1)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Timeseries - Point 1')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1200x1600 with 4 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# some Analysis figures\n", + "fig = plt.figure(figsize=(12, 16))\n", + "gs = plt.matplotlib.gridspec.GridSpec(3, 2, fig)\n", + "\n", + "axPCA = plt.subplot(gs[0, :])\n", + "axPCA.scatter(reft.isel(lon=0), reft.isel(lon=1), s=20, label=\"Reference\")\n", + "axPCA.scatter(simt.isel(lon=0), simt.isel(lon=1), s=10, label=\"Simulation\")\n", + "axPCA.scatter(scen2.isel(lon=0), scen2.isel(lon=1), s=3, label=\"Adjusted - PCA+EQM\")\n", + "axPCA.set_xlabel(\"Point 1\")\n", + "axPCA.set_ylabel(\"Point 2\")\n", + "axPCA.set_title(\"PC-space\")\n", + "axPCA.legend()\n", + "\n", + "refQ = reft.quantile(EQM.ds.quantiles, dim=\"time\")\n", + "simQ = simt.quantile(EQM.ds.quantiles, dim=\"time\")\n", + "scen1Q = scen1.quantile(EQM.ds.quantiles, dim=\"time\")\n", + "scen2Q = scen2.quantile(EQM.ds.quantiles, dim=\"time\")\n", + "\n", + "axQM = None\n", + "for i in range(2):\n", + " if not axQM:\n", + " axQM = plt.subplot(gs[1, 0])\n", + " else:\n", + " axQM = plt.subplot(gs[1, 1], sharey=axQM)\n", + " axQM.plot(refQ.isel(lon=i), simQ.isel(lon=i), label=\"No adj\")\n", + " axQM.plot(refQ.isel(lon=i), scen1Q.isel(lon=i), label=\"PCA\")\n", + " axQM.plot(refQ.isel(lon=i), scen2Q.isel(lon=i), label=\"PCA+EQM\")\n", + " axQM.plot(\n", + " refQ.isel(lon=i), refQ.isel(lon=i), color=\"k\", linestyle=\":\", label=\"Ideal\"\n", + " )\n", + " axQM.set_title(f\"QQ plot - Point {i + 1}\")\n", + " axQM.set_xlabel(\"Reference\")\n", + " axQM.set_xlabel(\"Model\")\n", + " axQM.legend()\n", + "\n", + "axT = plt.subplot(gs[2, :])\n", + "reft.isel(lon=0).plot(ax=axT, label=\"Reference\")\n", + "simt.isel(lon=0).plot(ax=axT, label=\"Unadjusted sim\")\n", + "# scen1.isel(lon=0).plot(ax=axT, label='PCA only')\n", + "scen2.isel(lon=0).plot(ax=axT, label=\"PCA+EQM\")\n", + "axT.legend()\n", + "axT.set_title(\"Timeseries - Point 1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fourth example : Multivariate bias-adjustment (Cannon, 2018)\n", + "\n", + "This section replicates the \"MBCn\" algorithm described by [Cannon (2018)](https://doi.org/10.1007/s00382-017-3580-6). The method relies on some univariate algorithm, an adaption of the N-pdf transform of [Pitié et al. (2005)](https://ieeexplore.ieee.org/document/1544887/) and a final reordering step.\n", + "\n", + "In the following, we use the Adjusted and Homogenized Canadian Climate Dataset ([AHCCD](https://open.canada.ca/data/en/dataset/9c4ebc00-3ea4-4fe0-8bf2-66cfe1cddd1d)) and CanESM2 data as reference and simulation, respectively, and correct both `pr` and `tasmax` together." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "from xsdba.units import convert_units_to, pint_multiply\n", + "from xsdba.testing import open_dataset\n", + "\n", + "dref = open_dataset(\n", + " \"sdba/ahccd_1950-2013.nc\", chunks={\"location\": 1}, drop_variables=[\"lat\", \"lon\"]\n", + ").sel(time=slice(\"1981\", \"2010\"))\n", + "\n", + "# Fix the standard name of the `pr` variable.\n", + "# This allows the convert_units_to below to infer the correct CF transformation (precip rate to flux)\n", + "# see the \"Unit handling\" notebook\n", + "dref.pr.attrs[\"standard_name\"] = \"lwe_precipitation_rate\"\n", + "\n", + "# TODO : Do we change this example? Our datasets? Now it's a bit more complicated since `convert_units_to`\n", + "# doesn't have a `hydro` context.\n", + "dsim = open_dataset(\n", + " \"sdba/CanESM2_1950-2100.nc\", chunks={\"location\": 1}, drop_variables=[\"lat\", \"lon\"]\n", + ")\n", + "water_density_inverse = \"1e-03 m^3/kg\"\n", + "dsim = dsim.assign(\n", + " tasmax=convert_units_to(dsim.tasmax, \"K\"),\n", + " pr=convert_units_to(pint_multiply(dsim.pr, water_density_inverse), \"mm/d\")\n", + ")\n", + "\n", + "dhist = dsim.sel(time=slice(\"1981\", \"2010\"))\n", + "dsim = dsim.sel(time=slice(\"2041\", \"2070\"))\n", + "\n", + "# Stack variables : Dataset -> DataArray with `multivar` dimension\n", + "dref, dhist, dsim = (xsdba.stack_variables(da) for da in (dref, dhist, dsim))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Perform the multivariate adjustment (MBCn)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "ADJ = xsdba.MBCn.train(\n", + " dref,\n", + " dhist,\n", + " base_kws={\"nquantiles\": 20, \"group\": \"time\"},\n", + " adj_kws={\"interp\": \"nearest\", \"extrapolation\": \"constant\"},\n", + " n_iter=20, # perform 20 iteration\n", + " n_escore=1000, # only send 1000 points to the escore metric\n", + ")\n", + "\n", + "scenh, scens = (\n", + " ADJ.adjust(\n", + " sim=dsim,\n", + " ref=dref,\n", + " hist=dhist,\n", + " base=xsdba.QuantileDeltaMapping,\n", + " base_kws_vars={\n", + " \"pr\": {\n", + " \"kind\": \"*\",\n", + " \"jitter_under_thresh_value\": \"0.01 mm d-1\",\n", + " \"adapt_freq_thresh\": \"0.1 mm d-1\",\n", + " },\n", + " \"tasmax\": {\"kind\": \"+\"},\n", + " },\n", + " adj_kws={\"interp\": \"nearest\", \"extrapolation\": \"constant\"},\n", + " )\n", + " for ds in (dhist, dsim)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Let's trigger all the computations.\n", + "\n", + "The use of `dask.compute` allows the three DataArrays to be computed at the same time, avoiding repeating the common steps." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[########################################] | 100% Completed | 9.13 sms\n" + ] + } + ], + "source": [ + "from dask import compute\n", + "from dask.diagnostics import ProgressBar\n", + "\n", + "with ProgressBar():\n", + " scenh, scens, escores = compute(scenh, scens, ADJ.ds.escores)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's compare the series and look at the distance scores to see how well the N-pdf transform has converged." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd2a5f09190>" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1600x400 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(16, 4))\n", + "for da, label in zip((dref, scenh, dhist), (\"Reference\", \"Adjusted\", \"Simulated\")):\n", + " ds = xsdba.unstack_variables(da).isel(location=2)\n", + " # time series - tasmax\n", + " ds.tasmax.plot(ax=axs[0], label=label, alpha=0.65 if label == \"Adjusted\" else 1)\n", + " # scatter plot\n", + " ds.plot.scatter(x=\"pr\", y=\"tasmax\", ax=axs[1], label=label)\n", + "axs[0].legend()\n", + "axs[1].legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'E-score')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "escores.isel(location=2).plot()\n", + "plt.title(\"E-scores for each iteration.\")\n", + "plt.xlabel(\"iteration\")\n", + "plt.ylabel(\"E-score\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tutorial continues in the [advanced notebook](advanced_example.ipynb) with more on optimization with dask, other fancier detrending algorithms, and an example pipeline for heavy processing.\n" + ] + } + ], + "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.11.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/xsdba.rst b/docs/xsdba.rst new file mode 100644 index 0000000..10a9fca --- /dev/null +++ b/docs/xsdba.rst @@ -0,0 +1,144 @@ +========================================== +Bias Adjustment and Downscaling Algorithms +========================================== + +The `xsdba` submodule provides a collection of bias-adjustment methods meant to correct for systematic biases found in climate model simulations relative to observations. +Almost all adjustment algorithms conform to the `train` - `adjust` scheme, meaning that adjustment factors are first estimated on training data sets, then applied in a distinct step to the data to be adjusted. +Given a reference time series (`ref``), historical simulations (`hist``) and simulations to be adjusted (`sim``), +any bias-adjustment method would be applied by first estimating the adjustment factors between the historical simulation +and the observation series, and then applying these factors to `sim`, which could be a future simulation: + +.. code-block:: python + + # Create the adjustment object by training it with reference and model data, plus certain arguments + Adj = Adjustment.train(ref, hist, group="time.month") + # Get a scenario by applying the adjustment to a simulated timeseries. + scen = Adj.adjust(sim, interp="linear") + Adj.ds.af # adjustment factors. + +Most method support both additive and multiplicative correction factors. +Also, the `group` argument allows adjustment factors to be estimated independently for different periods: the full +time series, months, seasons or day of the year. For monthly groupings, the `interp` argument then allows for interpolation between +adjustment factors to avoid discontinuities in the bias-adjusted series. +See :ref:`Grouping` below. + +The same interpolation principle is also used for quantiles. Indeed, for methods extracting adjustment factors by +quantile, interpolation is also done between quantiles. This can help reduce discontinuities in the adjusted time +series, and possibly reduce the number of quantile bins that needs to be used. + +Modular Approach +================ +The module attempts to adopt a modular approach instead of implementing published and named methods directly. +A generic bias adjustment process is laid out as follows: + +- preprocessing on ``ref``, ``hist`` and ``sim`` (using methods in :py:mod:`xsdba.processing` or :py:mod:`xsdba.detrending`) +- creating and training the adjustment object ``Adj = Adjustment.train(obs, sim, **kwargs)`` (from :py:mod:`xsdba.adjustment`) +- adjustment ``scen = Adj.adjust(sim, **kwargs)`` +- post-processing on ``scen`` (for example: re-trending) + +.. + TODO : Find a way to link API below, and those later in the file. +The train-adjust approach allows to inspect the trained adjustment object. The training information is stored in +the underlying `Adj.ds` dataset and usually has a `af` variable with the adjustment factors. Its layout and the +other available variables vary between the different algorithm, refer to :ref:`Adjustment methods <sdba-user-api>`. + +Parameters needed by the training and the adjustment are saved to the ``Adj.ds`` dataset as a `adj_params` attribute. +Parameters passed to the `adjust` call are written to the history attribute in the output scenario DataArray. + +.. _grouping: + +Grouping +======== +For basic time period grouping (months, day of year, season), passing a string to the methods needing it is sufficient. +Most methods acting on grouped data also accept a `window` int argument to pad the groups with data from adjacent ones. +Units of `window` are the sampling frequency of the main grouping dimension (usually `time`). For more complex grouping, +one can pass an instance of :py:class:`xsdba.base.Grouper` directly. For example, if one wants to compute the factors +for each day of the year but across all realizations of an ensemble : ``group = Grouper("time.dayofyear", add_dims=['realization'])``. +In a conventional empirical quantile mapping (EQM), this will compute the quantiles for each day of year and all realizations together, yielding a single set of adjustment factors for all realizations. + +.. warning:: + If grouping according to the day of the year is needed, the :py:mod:`xsdba.calendar` submodule contains useful + tools to manage the different calendars that the input data can have. By default, if 2 different calendars are + passed, the adjustment factors will always be interpolated to the largest range of day of the years but this can + lead to strange values, so we recommend converting the data beforehand to a common calendar. + +Application in multivariate settings +==================================== +When applying univariate adjustment methods to multiple variables, some strategies are recommended to avoid introducing unrealistic artifacts in adjusted outputs. + +Minimum and maximum temperature +------------------------------- +When adjusting both minimum and maximum temperature, adjustment factors sometimes yield minimum temperatures larger than the maximum temperature on the same day, which of course, is nonsensical. +One way to avoid this is to first adjust maximum temperature using an additive adjustment, then adjust the diurnal temperature range (DTR) using a multiplicative adjustment, and then determine minimum temperature by subtracting DTR from the maximum temperature :cite:p:`thrasher_technical_2012,agbazo_characterizing_2020`. + +Relative and specific humidity +------------------------------ +When adjusting both relative and specific humidity, we want to preserve the relationship between both. +To do this, :cite:t:`grenier_two_2018` suggests to first adjust the relative humidity using a multiplicative factor, ensure values are within 0-100%, then apply an additive adjustment factor to the surface pressure before estimating the specific humidity from thermodynamic relationships. + +Radiation and precipitation +--------------------------- +In theory, short wave radiation should be capped when precipitation is not zero, but there is as of yet no mechanism proposed to do that, see :cite:t:`hoffmann_meteorologically_2012`. + +Usage examples +============== +The usage of this module is documented in two example notebooks: `Simple <notebooks/example.ipynb>`_ and `advanced <notebooks/advanced_example.ipynb>`_ examples. + +Discussion topics +================= +Some issues were also discussed on the Github repository. Most of these are still open questions, feel free to participate to the discussion! + +.. + TODO: Check/Update issues list. Can we keep this? Those will still be in xclim's repo + +* Number quantiles to use in quantile mapping methods: :issue:`1162` +* How to choose the quantiles: :issue:`1015` +* Bias-adjustment when the trend goes to zero: :issue:`1145` +* Spatial downscaling: :issue:`1150` + +Experimental wrap of SBCK +========================= +The `SBCK`_ python package implements various bias-adjustment methods, with an emphasis on multivariate methods and with +a care for performance. If the package is correctly installed alongside `xsdba`, the methods will be wrapped into +:py:class:`xsdba.adjustment.Adjust` classes (names beginning with `SBCK_`) with a minimal overhead so that they can +be parallelized with dask and accept xarray objects. For now, these experimental classes can't use the train-adjust +approach, instead they only provide one method, ``adjust(ref, hist, sim, multi_dim=None, **kwargs)`` which performs all +steps : initialization of the SBCK object, training (fit) and adjusting (predict). All SBCK wrappers accept a +``multi_dim`` argument for specifying the name of the "multivariate" dimension. This wrapping is still experimental and +some bugs or inconsistencies might exist. To see how one can install that package, see :ref:`extra-dependencies`. + +.. _SBCK: https://github.com/yrobink/SBCK + +Notes for Developers +==================== +To be scalable and performant, the sdba module makes use of the special decorators :py:func`xsdba.base.map_blocks` +and :py:func:`xsdba.base.map_groups`. However, they have the inconvenient that functions wrapped by them are unable +to manage xarray attributes (including units) correctly and their signatures are sometime wrong and often unclear. For +this reason, the module is often divided in two parts : the (decorated) compute functions in a "private" file +(ex: ``_adjustment.py``) and the user-facing functions or objects in corresponding public file (ex: ``adjustment.py``). +See the `advanced_example` notebook for more info on the reasons for this move. + +Other restrictions : ``map_blocks`` will remove any "auxiliary" coordinates before calling the wrapped function and will +add them back on exit. + +User API +======== + +See: :ref:`sdba-user-api` + +Developer API +============= + +See: :ref:`sdba-developer-api` + +.. only:: html or text + + .. _sdba-footnotes: + + SDBA Footnotes + ============== + + .. bibliography:: + :style: xcstyle + :labelprefix: SDBA- + :keyprefix: sdba- diff --git a/environment-dev.yml b/environment-dev.yml index 26b0eb9..87bde87 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -40,4 +40,6 @@ dependencies: - xdoctest - h5netcdf - netcdf4 - - cf_xarray # to accomodate numba + - cf_xarray + - nc_time_axis # for notebooks + - pooch # for notebooks diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index f98670c..6256a73 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -24,6 +24,7 @@ adjustment, base, detrending, + measures, processing, properties, testing, diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index 637c1c2..28d5346 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -388,7 +388,7 @@ def mbcn_adjust( adj_kws : Dict Options for univariate adjust for the scenario that is reordered with the output of npdf transform. period_dim : str, optional - Name of the period dimension used when stacking time periods of `sim` using :py:func:`xclim.core.calendar.stack_periods`. + Name of the period dimension used when stacking time periods of `sim` using :py:func:`xsdba.calendar.stack_periods`. If specified, the interpolation of the npdf transform is performed only once and applied on all periods simultaneously. This should be more performant, but also more memory intensive. Defaults to `None`: No optimization will be attempted. @@ -426,7 +426,7 @@ def mbcn_adjust( scen_block = xr.zeros_like(sim[{"time": ind_gw}]) for iv, v in enumerate(sim[pts_dims[0]].values): sl = {"time": ind_gw, pts_dims[0]: iv} - with set_options(sdba_extra_output=False): + with set_options(xsdba_extra_output=False): ADJ = base.train( ref[sl], hist[sl], **base_kws_vars[v], skip_input_checks=True ) diff --git a/src/xsdba/_processing.py b/src/xsdba/_processing.py index cd2566b..f40f63e 100644 --- a/src/xsdba/_processing.py +++ b/src/xsdba/_processing.py @@ -30,7 +30,7 @@ def _adapt_freq( r""" Adapt frequency of values under thresh of `sim`, in order to match ref. - This is the compute function, see :py:func:`xclim.sdba.processing.adapt_freq` for the user-facing function. + This is the compute function, see :py:func:`xsdba.processing.adapt_freq` for the user-facing function. Parameters ---------- @@ -116,7 +116,7 @@ def _normalize( The variable `data` is normalized. If a `norm` variable is present, is uses this one instead of computing the norm again. group : Union[str, Grouper] - Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Grouping information. See :py:class:`xsdba.base.Grouper` for details. dim : sequence of strings Dimension name(s). kind : {'+', '*'} diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 4dfb9a0..297d286 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -15,8 +15,8 @@ from xsdba.base import get_calendar from xsdba.formatting import gen_call_string, update_history -from xsdba.options import OPTIONS, SDBA_EXTRA_OUTPUT, set_options -from xsdba.units import convert_units_to +from xsdba.options import OPTIONS, XSDBA_EXTRA_OUTPUT, set_options +from xsdba.units import convert_units_to, pint2str, units2str from xsdba.utils import uses_dask from ._adjustment import ( @@ -60,6 +60,8 @@ "Scaling", ] +# FIXME: `xsdba.utils.extrapolate_qm` mentioned in docstrings, but doesn't exist in `xclim` or `xsdba` + class BaseAdjustment(ParametrizableWithDataset): """Base class for adjustment objects. @@ -71,7 +73,7 @@ class BaseAdjustment(ParametrizableWithDataset): """ _allow_diff_calendars = True - _attribute = "_xclim_adjustment" + _attribute = "_xsdba_adjustment" def __init__(self, *args, _trained=False, **kwargs): if _trained: @@ -138,9 +140,12 @@ def _harmonize_units_multivariate( ): def _convert_units_to(inda, dim, target): varss = inda[dim].values - input_units = { - v: inda[dim].attrs["_units"][iv] for iv, v in enumerate(varss) - } + input_units = {} + for iv, v in enumerate(varss): + # FIXME: I think we should already have strings at this point + # see what deeper code must be fixed + input_units[v] = units2str(inda[dim].attrs["_units"][iv]) + target[v] = units2str(target[v]) if input_units == target: return inda input_standard_names = { @@ -167,7 +172,7 @@ def _convert_units_to(inda, dim, target): raise ValueError(error_msg) target = { - v: inputs[0][dim].attrs["_units"][iv] + v: units2str(inputs[0][dim].attrs["_units"][iv]) for iv, v in enumerate(inputs[0][dim].values) } return ( @@ -204,7 +209,7 @@ class TrainAdjust(BaseAdjustment): """ _allow_diff_calendars = True - _attribute = "_xclim_adjustment" + _attribute = "_xsdba_adjustment" _repr_hide_params = ["hist_calendar", "train_units"] @classmethod @@ -287,7 +292,7 @@ def adjust(self, sim: DataArray, *args, **kwargs): if _is_multivariate is False: scen.attrs["units"] = self.train_units - if OPTIONS[SDBA_EXTRA_OUTPUT]: + if OPTIONS[XSDBA_EXTRA_OUTPUT]: return out return scen @@ -367,7 +372,7 @@ def adjust( if _is_multivariate is False: scen.attrs["units"] = ref.units - if OPTIONS[SDBA_EXTRA_OUTPUT]: + if OPTIONS[XSDBA_EXTRA_OUTPUT]: return out return scen @@ -394,10 +399,10 @@ class EmpiricalQuantileMapping(TrainAdjust): kind : {'+', '*'} The adjustment kind, either additive or multiplicative. Defaults to "+". group : Union[str, Grouper] - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. Default is "time", meaning an single adjustment group along dimension "time". adapt_freq_thresh : str | None - Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Threshold for frequency adaptation. See :py:class:`xsdba.processing.adapt_freq` for details. Default is None, meaning that frequency adaptation is not performed. Adjust step: @@ -405,7 +410,7 @@ class EmpiricalQuantileMapping(TrainAdjust): interp : {'nearest', 'linear', 'cubic'} The interpolation method to use when interpolating the adjustment factors. Defaults to "nearest". extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. See :py:func:`xsdba.utils.extrapolate_qm` for details. Defaults to "constant". References ---------- @@ -485,15 +490,15 @@ class DetrendedQuantileMapping(TrainAdjust): Train step: nquantiles : int or 1d array of floats - The number of quantiles to use. See :py:func:`~xclim.sdba.utils.equally_spaced_nodes`. + The number of quantiles to use. See :py:func:`~xsdba.utils.equally_spaced_nodes`. An array of quantiles [0, 1] can also be passed. Defaults to 20 quantiles. kind : {'+', '*'} The adjustment kind, either additive or multiplicative. Defaults to "+". group : Union[str, Grouper] - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. Default is "time", meaning a single adjustment group along dimension "time". adapt_freq_thresh : str | None - Threshold for frequency adaptation. See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Threshold for frequency adaptation. See :py:class:`xsdba.processing.adapt_freq` for details. Default is None, meaning that frequency adaptation is not performed. Adjust step: @@ -504,7 +509,7 @@ class DetrendedQuantileMapping(TrainAdjust): The method to use when detrending. If an int is passed, it is understood as a PolyDetrend (polynomial detrending) degree. Defaults to 1 (linear detrending). extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. See :py:func:`xsdba.utils.extrapolate_qm` for details. Defaults to "constant". References ---------- @@ -596,12 +601,12 @@ class QuantileDeltaMapping(EmpiricalQuantileMapping): Train step: nquantiles : int or 1d array of floats - The number of quantiles to use. See :py:func:`~xclim.sdba.utils.equally_spaced_nodes`. + The number of quantiles to use. See :py:func:`~xsdba.utils.equally_spaced_nodes`. An array of quantiles [0, 1] can also be passed. Defaults to 20 quantiles. kind : {'+', '*'} The adjustment kind, either additive or multiplicative. Defaults to "+". group : Union[str, Grouper] - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. Default is "time", meaning a single adjustment group along dimension "time". Adjust step: @@ -609,7 +614,7 @@ class QuantileDeltaMapping(EmpiricalQuantileMapping): interp : {'nearest', 'linear', 'cubic'} The interpolation method to use when interpolating the adjustment factors. Defaults to "nearest". extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. See :py:func:`xsdba.utils.extrapolate_qm` for details. Defaults to "constant". Extra diagnostics ----------------- @@ -630,7 +635,7 @@ def _adjust(self, sim, interp="nearest", extrapolation="constant"): extrapolation=extrapolation, kind=self.kind, ) - if OPTIONS[SDBA_EXTRA_OUTPUT]: + if OPTIONS[XSDBA_EXTRA_OUTPUT]: out.sim_q.attrs.update(long_name="Group-wise quantiles of `sim`.") return out return out.scen @@ -665,7 +670,7 @@ class ExtremeValues(TrainAdjust): interp : {'nearest', 'linear', 'cubic'} The interpolation method to use when interpolating the adjustment factors. Defaults to "linear". extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`~xclim.sdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. See :py:func:`~xsdba.utils.extrapolate_qm` for details. Defaults to "constant". frac : float Fraction where the cutoff happens between the original scen and the corrected one. See Notes, ]0, 1]. Defaults to 0.25. @@ -823,7 +828,7 @@ class LOCI(TrainAdjust): Train step: group : Union[str, Grouper] - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. Default is "time", meaning a single adjustment group along dimension "time". thresh : str The threshold in `ref` above which the values are scaled. @@ -879,7 +884,7 @@ class Scaling(TrainAdjust): Train step: group : Union[str, Grouper] - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. Default is "time", meaning an single adjustment group along dimension "time". kind : {'+', '*'} The adjustment kind, either additive or multiplicative. Defaults to "+". @@ -936,13 +941,13 @@ class PrincipalComponents(TrainAdjust): ---------- group : Union[str, Grouper] The main dimension and grouping information. See Notes. - See :py:class:`xclim.sdba.base.Grouper` for details. + See :py:class:`xsdba.base.Grouper` for details. The adjustment will be performed on each group independently. Default is "time", meaning a single adjustment group along dimension "time". best_orientation : {'simple', 'full'} Which method to use when searching for the best principal component orientation. - See :py:func:`~xclim.sdba.utils.best_pc_orientation_simple` and - :py:func:`~xclim.sdba.utils.best_pc_orientation_full`. + See :py:func:`~xsdba.utils.best_pc_orientation_simple` and + :py:func:`~xsdba.utils.best_pc_orientation_full`. "full" is more precise, but it is much slower. crd_dim : str The data dimension along which the multiple simulation space dimensions are taken. @@ -1108,7 +1113,7 @@ class NpdfTransform(Adjust): algorithm, based on a color-correction algorithm described by :cite:t:`sdba-pitie_n-dimensional_2005`. This algorithm in itself, when used with QuantileDeltaMapping, is NOT trend-preserving. - The full MBCn algorithm includes a reordering step provided here by :py:func:`xclim.sdba.processing.reordering`. + The full MBCn algorithm includes a reordering step provided here by :py:func:`xsdba.processing.reordering`. See notes for an explanation of the algorithm. @@ -1126,7 +1131,7 @@ class NpdfTransform(Adjust): The number of iterations to perform. Defaults to 20. pts_dim : str The name of the "multivariate" dimension. Defaults to "multivar", which is the - normal case when using :py:func:`xclim.sdba.base.stack_variables`. + normal case when using :py:func:`xsdba.base.stack_variables`. adj_kws : dict, optional Dictionary of arguments to pass to the adjust method of the univariate adjustment. rot_matrices : xr.DataArray, optional @@ -1169,7 +1174,7 @@ class NpdfTransform(Adjust): instead fix the number of iterations. As done by cite:t:`sdba-cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from - :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xclim.sdba.processing.escore`). + :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xsdba.processing.escore`). The random matrices are generated following a method laid out by :cite:t:`sdba-mezzadri_how_2007`. @@ -1251,7 +1256,7 @@ def _adjust( "adj_kws": adj_kws or {}, } - with set_options(sdba_extra_output=False): + with set_options(xsdba_extra_output=False): out = ds.map_blocks(npdf_transform, template=template, kwargs=kwargs) out = out.assign(rotation_matrices=rot_matrices) @@ -1266,7 +1271,7 @@ class MBCn(TrainAdjust): based on a color-correction algorithm described by :cite:t:`sdba-pitie_n-dimensional_2005`. This algorithm in itself, when used with QuantileDeltaMapping, is NOT trend-preserving. - The full MBCn algorithm includes a reordering step provided here by :py:func:`xclim.sdba.processing.reordering`. + The full MBCn algorithm includes a reordering step provided here by :py:func:`xsdba.processing.reordering`. See notes for an explanation of the algorithm. @@ -1290,7 +1295,7 @@ class MBCn(TrainAdjust): The number of iterations to perform. Defaults to 20. pts_dim : str The name of the "multivariate" dimension. Defaults to "multivar", which is the - normal case when using :py:func:`xclim.sdba.base.stack_variables`. + normal case when using :py:func:`xsdba.base.stack_variables`. rot_matrices: xr.DataArray, optional The rotation matrices as a 3D array ('iterations', <pts_dim>, <anything>), with shape (n_iter, <N>, <N>). If left empty, random rotation matrices will be automatically generated. @@ -1310,13 +1315,13 @@ class MBCn(TrainAdjust): adj_kws : dict, optional Arguments passed to the adjusting in the univariate bias correction period_dim : str, optional - Name of the period dimension used when stacking time periods of `sim` using :py:func:`xclim.core.calendar.stack_periods`. + Name of the period dimension used when stacking time periods of `sim` using :py:func:`xsdba.calendar.stack_periods`. If specified, the interpolation of the npdf transform is performed only once and applied on all periods simultaneously. This should be more performant, but also more memory intensive. Training (only npdf transform training) - 1. Standardize `ref` and `hist` (see ``xclim.sdba.processing.standardize``.) + 1. Standardize `ref` and `hist` (see ``xsdba.processing.standardize``.) 2. Rotate the datasets in the N-dimensional variable space with :math:`\mathbf{R}`, a random rotation NxN matrix. @@ -1357,7 +1362,7 @@ class MBCn(TrainAdjust): instead fix the number of iterations. As done by cite:t:`sdba-cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from - :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xclim.sdba.processing.escore`). + :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xsdba.processing.escore`). The random matrices are generated following a method laid out by :cite:t:`sdba-mezzadri_how_2007`. @@ -1611,7 +1616,7 @@ def _parse(s): "The adjust method accepts ref, hist, sim and all arguments listed " 'below in "Parameters". It also accepts a `multi_dim` argument ' "specifying the dimension across which to take the 'features' and " - "is valid for multivariate methods only. See :py:func:`xclim.sdba.stack_variables`." + "is valid for multivariate methods only. See :py:func:`xsdba.stack_variables`." "In the description below, `n_features` is the size of the `multi_dim` " "dimension. There is no way of specifying parameters across other " "dimensions for the moment." diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 293876f..2459ef9 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -106,6 +106,59 @@ def set_dataset(self, ds: xr.Dataset) -> None: self.ds.attrs[self._attribute] = jsonpickle.encode(self) +# XC : keep in the same file as `uses_dask` below +def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: + r"""Ensure that the input DataArray has chunks of at least the given size. + + If only one chunk is too small, it is merged with an adjacent chunk. + If many chunks are too small, they are grouped together by merging adjacent chunks. + + Parameters + ---------- + da : xr.DataArray + The input DataArray, with or without the dask backend. Does nothing when passed a non-dask array. + \*\*minchunks : dict[str, int] + A kwarg mapping from dimension name to minimum chunk size. + Pass -1 to force a single chunk along that dimension. + + Returns + ------- + xr.DataArray + """ + if not uses_dask(da): + return da + + all_chunks = dict(zip(da.dims, da.chunks)) + chunking = {} + for dim, minchunk in minchunks.items(): + chunks = all_chunks[dim] + if minchunk == -1 and len(chunks) > 1: + # Rechunk to single chunk only if it's not already one + chunking[dim] = -1 + + toosmall = np.array(chunks) < minchunk # Chunks that are too small + if toosmall.sum() > 1: + # Many chunks are too small, merge them by groups + fac = np.ceil(minchunk / min(chunks)).astype(int) + chunking[dim] = tuple( + sum(chunks[i : i + fac]) for i in range(0, len(chunks), fac) + ) + # Reset counter is case the last chunks are still too small + chunks = chunking[dim] + toosmall = np.array(chunks) < minchunk + if toosmall.sum() == 1: + # Only one, merge it with adjacent chunk + ind = np.where(toosmall)[0][0] + new_chunks = list(chunks) + sml = new_chunks.pop(ind) + new_chunks[max(ind - 1, 0)] += sml + chunking[dim] = tuple(new_chunks) + + if chunking: + return da.chunk(chunks=chunking) + return da + + # XC put here to avoid circular import def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: r"""Evaluate whether dask is installed and array is loaded as a dask array. @@ -915,7 +968,7 @@ def infer_kind_from_parameter(param) -> InputKind: Notes ----- - The correspondence between parameters and kinds is documented in :py:class:`xclim.core.utils.InputKind`. + The correspondence between parameters and kinds is documented in :py:class:`xsdba.typing.InputKind`. """ if param.annotation is not _empty: annot = set( diff --git a/src/xsdba/calendar.py b/src/xsdba/calendar.py index c3909d5..c88803f 100644 --- a/src/xsdba/calendar.py +++ b/src/xsdba/calendar.py @@ -73,7 +73,6 @@ "360_day": 360, } -# Some xclim.core.utils functions made accessible here for backwards compatibility reasons. datetime_classes = cftime._cftime.DATE_TYPES # Names of calendars that have the same number of days for all years @@ -1611,7 +1610,7 @@ def unstack_periods(da: xr.DataArray | xr.Dataset, dim: str = "period"): 0 o o o x x === === === === === === === === """ - from xclim.core.units import infer_sampling_units + from xsdba.units import infer_sampling_units try: starts = da[dim] diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py index b1b720a..62bd7f9 100644 --- a/src/xsdba/measures.py +++ b/src/xsdba/measures.py @@ -18,7 +18,6 @@ from xsdba.indicator import Indicator, base_registry # ADAPT -# from xclim.core.units import ensure_delta from .base import Grouper from .typing import InputKind from .units import convert_units_to, ensure_delta diff --git a/src/xsdba/options.py b/src/xsdba/options.py index cd34814..c01e49a 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -20,7 +20,7 @@ CHECK_MISSING = "check_missing" MISSING_OPTIONS = "missing_options" RUN_LENGTH_UFUNC = "run_length_ufunc" -SDBA_EXTRA_OUTPUT = "sdba_extra_output" +XSDBA_EXTRA_OUTPUT = "xsdba_extra_output" SDBA_ENCODE_CF = "sdba_encode_cf" KEEP_ATTRS = "keep_attrs" AS_DATASET = "as_dataset" @@ -34,7 +34,7 @@ CHECK_MISSING: "any", MISSING_OPTIONS: {}, RUN_LENGTH_UFUNC: "auto", - SDBA_EXTRA_OUTPUT: False, + XSDBA_EXTRA_OUTPUT: False, SDBA_ENCODE_CF: False, KEEP_ATTRS: "xarray", AS_DATASET: False, @@ -66,7 +66,7 @@ def _valid_missing_options(mopts): CHECK_MISSING: lambda meth: meth != "from_context" and meth in MISSING_METHODS, MISSING_OPTIONS: _valid_missing_options, RUN_LENGTH_UFUNC: _RUN_LENGTH_UFUNC_OPTIONS.__contains__, - SDBA_EXTRA_OUTPUT: lambda opt: isinstance(opt, bool), + XSDBA_EXTRA_OUTPUT: lambda opt: isinstance(opt, bool), SDBA_ENCODE_CF: lambda opt: isinstance(opt, bool), KEEP_ATTRS: _KEEP_ATTRS_OPTIONS.__contains__, AS_DATASET: lambda opt: isinstance(opt, bool), @@ -166,7 +166,7 @@ class set_options: run_length_ufunc : str Whether to use the 1D ufunc version of run length algorithms or the dask-ready broadcasting version. Default is ``"auto"``, which means the latter is used for dask-backed and large arrays. - sdba_extra_output : bool + xsdba_extra_output : bool Whether to add diagnostic variables to outputs of sdba's `train`, `adjust` and `processing` operations. Details about these additional variables are given in the object's docstring. When activated, `adjust` will return a Dataset with `scen` and those extra diagnostics @@ -199,9 +199,9 @@ class set_options: .. code-block:: python - import xclim + import xsdba - xclim.set_options(missing_options={"pct": {"tolerance": 0.04}}) + xsdba.set_options(missing_options={"pct": {"tolerance": 0.04}}) """ def __init__(self, **kwargs): diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index a708a75..1c92a6f 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -20,7 +20,7 @@ from ._processing import _adapt_freq, _normalize, _reordering from .base import Grouper from .nbutils import _escore -from .units import compare_units, convert_units_to, harmonize_units +from .units import compare_units, convert_units_to, harmonize_units, pint2str from .utils import ADDITIVE, copy_all_attrs # from xclim.core.units import convert_units_to, infer_context, units @@ -559,7 +559,6 @@ def to_additive_space( See Also -------- - Related functions from_additive_space : for the inverse transformation. jitter_under_thresh : Remove values exactly equal to the lower bound. jitter_over_thresh : Remove values exactly equal to the upper bound. diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 098a526..6efe525 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -53,7 +53,7 @@ class StatisticalProperty(Indicator): aspect = None """The aspect the statistical property studies: marginal, temporal, multivariate or spatial.""" - measure = "xclim.sdba.measures.BIAS" + measure = "xsdba.measures.BIAS" """The default measure to use when comparing the properties of two datasets. This gives the registry id. See :py:meth:`get_measure`.""" @@ -100,7 +100,7 @@ def _postprocess(self, outs, das, params): def get_measure(self): """Get the statistical measure indicator that is best used with this statistical property.""" - from xclim.core.indicator import registry + from xsdba.indicator import registry return registry[self.measure].get_instance() @@ -175,7 +175,7 @@ def _var(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: aspect="marginal", cell_methods="time: var", compute=_var, - measure="xclim.sdba.measures.RATIO", + measure="xsdba.measures.RATIO", ) @@ -211,7 +211,7 @@ def _std(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: aspect="marginal", cell_methods="time: std", compute=_std, - measure="xclim.sdba.measures.RATIO", + measure="xsdba.measures.RATIO", ) @@ -633,7 +633,7 @@ def _annual_cycle( parameters={"stat": "relamp"}, allowed_groups=["group"], cell_methods="time: mean time: range", - measure="xclim.sdba.measures.RATIO", + measure="xsdba.measures.RATIO", ) annual_cycle_phase = StatisticalProperty( @@ -644,7 +644,7 @@ def _annual_cycle( parameters={"stat": "phase"}, cell_methods="time: range", allowed_groups=["group"], - measure="xclim.sdba.measures.CIRCULAR_BIAS", + measure="xsdba.measures.CIRCULAR_BIAS", ) annual_cycle_asymmetry = StatisticalProperty( @@ -739,7 +739,7 @@ def _annual_statistic( parameters={"stat": "relamp"}, allowed_groups=["group"], units="%", - measure="xclim.sdba.measures.RATIO", + measure="xsdba.measures.RATIO", ) mean_annual_phase = StatisticalProperty( @@ -749,7 +749,7 @@ def _annual_statistic( parameters={"stat": "phase"}, allowed_groups=["group"], units="", - measure="xclim.sdba.measures.CIRCULAR_BIAS", + measure="xsdba.measures.CIRCULAR_BIAS", ) diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 1a0bac4..69a8cfb 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -6,7 +6,7 @@ import inspect from copy import deepcopy from functools import wraps -from typing import Any +from typing import Any, cast import pint @@ -91,12 +91,12 @@ def infer_sampling_units( # XC -def units2pint(value: xr.DataArray | str | units.Quantity) -> pint.Unit: +def units2pint(value: xr.DataArray | str | units.Quantity | units.Unit) -> pint.Unit: """Return the pint Unit for the DataArray units. Parameters ---------- - value : xr.DataArray or str or pint.Quantity + value : xr.DataArray or str or pint.Quantity or pint.Unit Input data array or string representing a unit (with no magnitude). Returns @@ -111,6 +111,12 @@ def units2pint(value: xr.DataArray | str | units.Quantity) -> pint.Unit: elif isinstance(value, units.Quantity): # This is a pint.PlainUnit, which is not the same as a pint.Unit return cast(pint.Unit, value.units) + elif isinstance(value, units.Quantity): + # This is a pint.PlainUnit, which is not the same as a pint.Unit + return cast(pint.Unit, value.units) + elif isinstance(value, units.Unit): + # This is a pint.PlainUnit, which is not the same as a pint.Unit + return cast(pint.Unit, value) else: raise NotImplementedError(f"Value of type `{type(value)}` not supported.") @@ -136,6 +142,22 @@ def units2pint(value: xr.DataArray | str | units.Quantity) -> pint.Unit: return units.parse_units(unit) +def units2str(value: xr.DataArray | str | units.Quantity | units.Unit) -> str: + """Return a str unit from various inputs. + + Parameters + ---------- + value : xr.DataArray or str or pint.Quantity or pint.Unit + Input data array or string representing a unit (with no magnitude). + + Returns + ------- + pint.Unit + Units of the data array. + """ + return value if isinstance(value, str) else pint2str(units2pint(value)) + + # XC def str2pint(val: str) -> pint.Quantity: """Convert a string to a pint.Quantity, splitting the magnitude and the units. @@ -206,7 +228,7 @@ def pint_multiply( xr.DataArray """ q = q if isinstance(q, pint.Quantity) else str2pint(q) - a = 1 * units2pint(da) # noqa + a = 1 * units2pint(da) f = a * q.to_base_units() if out_units: f = f.to(out_units) diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 5c6264c..392fe3d 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -17,7 +17,7 @@ from scipy.stats import spearmanr from xarray.core.utils import get_temp_dimname -from .base import Grouper, parse_group, uses_dask +from .base import Grouper, ensure_chunk_size, parse_group, uses_dask from .calendar import ensure_longest_doy from .nbutils import _extrapolate_on_quantiles diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index fae07d3..e5f82d4 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -466,7 +466,7 @@ def test_cannon_and_diagnostics(self, cannon_2015_dist, cannon_2015_rvs): ref, hist, sim = cannon_2015_rvs(15000, random=False) # Quantile mapping - with set_options(sdba_extra_output=True): + with set_options(xsdba_extra_output=True): QDM = QuantileDeltaMapping.train( ref, hist, kind="*", group="time", nquantiles=50 ) From 9c98e61428589e66b581fb5923df22dd367fecf6 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 2 Aug 2024 16:38:04 +0000 Subject: [PATCH 044/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/units.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 69a8cfb..8c646b5 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -228,7 +228,7 @@ def pint_multiply( xr.DataArray """ q = q if isinstance(q, pint.Quantity) else str2pint(q) - a = 1 * units2pint(da) + a = 1 * units2pint(da) f = a * q.to_base_units() if out_units: f = f.to(out_units) From 51bd9dc6f827e8548a22bccdf64e7e3720548135 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 13:36:06 -0400 Subject: [PATCH 045/105] Cleaning: remove many xclim mentions --- docs/notebooks/advanced_example.ipynb | 3287 +--------------------- src/xsdba/_adjustment.py | 1 - src/xsdba/adjustment.py | 13 +- src/xsdba/base.py | 6 +- src/xsdba/calendar.py | 29 +- src/xsdba/datachecks.py | 10 +- src/xsdba/detrending.py | 8 +- src/xsdba/formatting.py | 7 +- src/xsdba/indicator.py | 27 +- src/xsdba/locales.py | 13 +- src/xsdba/measures.py | 6 +- src/xsdba/options.py | 23 +- src/xsdba/processing.py | 7 +- src/xsdba/properties.py | 6 +- src/xsdba/typing.py | 13 +- src/xsdba/units.py | 6 +- src/xsdba/utils.py | 2 +- src/xsdba/xclim_submodules/generic.py | 6 +- src/xsdba/xclim_submodules/run_length.py | 4 +- 19 files changed, 130 insertions(+), 3344 deletions(-) diff --git a/docs/notebooks/advanced_example.ipynb b/docs/notebooks/advanced_example.ipynb index 763e88c..7b1b634 100644 --- a/docs/notebooks/advanced_example.ipynb +++ b/docs/notebooks/advanced_example.ipynb @@ -24,8 +24,7 @@ " Chunking of outputs can be controlled in xarray's [to_netcdf](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.to_netcdf.html?highlight=to_netcdf#xarray.Dataset.to_netcdf). We also suggest using [Zarr](https://zarr.readthedocs.io/en/stable/) files. According to [its creators](https://ui.adsabs.harvard.edu/abs/2018AGUFMIN33A..06A/abstract), `zarr` stores should give better performances, especially because of their better ability for parallel I/O. See [Dataset.to_zarr](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.to_zarr.html?highlight=to_zarr#xarray.Dataset.to_zarr) and this useful [rechunking package](https://rechunker.readthedocs.io).\n", "\n", "\n", - "<!-- FIXME : Do we leave the mention of xclim-0.27 as-is, give more context? -->\n", - "* One of the main bottleneck for adjustments with small groups is that dask needs to build and optimize an enormous task graph. This issue has been greatly reduced with `xclim` 0.27 and the use of `map_blocks` in the adjustment methods. However, not all adjustment methods use this optimized syntax.\n", + "* One of the main bottleneck for adjustments with small groups is that dask needs to build and optimize an enormous task graph. This issue is alleviated with the use of `map_blocks` in the adjustment methods. However, not all adjustment methods use this optimized syntax.\n", "\n", " In order to help dask, one can split the processing in parts. For splitting training and adjustment, see [the section below](#Initializing-an-Adjustment-object-from-a-training-dataset).\n", "\n", @@ -47,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -67,20 +66,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1100x500 with 2 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Daily temperature data from xarray's tutorials\n", "ds = xr.tutorial.open_dataset(\"air_temperature\").resample(time=\"D\").mean()\n", @@ -138,30 +126,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[<matplotlib.lines.Line2D at 0x7fb64fd07f50>]" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1100x500 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "time = xr.cftime_range(\"1990-01-01\", \"2049-12-31\", calendar=\"noleap\")\n", "tas = xr.DataArray(\n", @@ -187,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -203,30 +170,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7fb65048e310>" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1100x500 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots()\n", "fit.ds.trend.plot(ax=ax, label=\"Computed trend\")\n", @@ -249,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -287,20 +233,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from xsdba.adjustment import QuantileDeltaMapping\n", "\n", @@ -319,467 +254,18 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", - "<defs>\n", - "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", - "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "</symbol>\n", - "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", - "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "</symbol>\n", - "</defs>\n", - "</svg>\n", - "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", - " *\n", - " */\n", - "\n", - ":root {\n", - " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", - " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", - " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", - " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", - " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", - " --xr-background-color: var(--jp-layout-color0, white);\n", - " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", - " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", - "}\n", - "\n", - "html[theme=dark],\n", - "html[data-theme=dark],\n", - "body[data-theme=dark],\n", - "body.vscode-dark {\n", - " --xr-font-color0: rgba(255, 255, 255, 1);\n", - " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", - " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", - " --xr-border-color: #1F1F1F;\n", - " --xr-disabled-color: #515151;\n", - " --xr-background-color: #111111;\n", - " --xr-background-color-row-even: #111111;\n", - " --xr-background-color-row-odd: #313131;\n", - "}\n", - "\n", - ".xr-wrap {\n", - " display: block !important;\n", - " min-width: 300px;\n", - " max-width: 700px;\n", - "}\n", - "\n", - ".xr-text-repr-fallback {\n", - " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", - " display: none;\n", - "}\n", - "\n", - ".xr-header {\n", - " padding-top: 6px;\n", - " padding-bottom: 6px;\n", - " margin-bottom: 4px;\n", - " border-bottom: solid 1px var(--xr-border-color);\n", - "}\n", - "\n", - ".xr-header > div,\n", - ".xr-header > ul {\n", - " display: inline;\n", - " margin-top: 0;\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-obj-type,\n", - ".xr-array-name {\n", - " margin-left: 2px;\n", - " margin-right: 10px;\n", - "}\n", - "\n", - ".xr-obj-type {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-sections {\n", - " padding-left: 0 !important;\n", - " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", - "}\n", - "\n", - ".xr-section-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-section-item input {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-item input + label {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label {\n", - " cursor: pointer;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label:hover {\n", - " color: var(--xr-font-color0);\n", - "}\n", - "\n", - ".xr-section-summary {\n", - " grid-column: 1;\n", - " color: var(--xr-font-color2);\n", - " font-weight: 500;\n", - "}\n", - "\n", - ".xr-section-summary > span {\n", - " display: inline-block;\n", - " padding-left: 0.5em;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-summary-in + label:before {\n", - " display: inline-block;\n", - " content: '►';\n", - " font-size: 11px;\n", - " width: 15px;\n", - " text-align: center;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label:before {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label:before {\n", - " content: '▼';\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label > span {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-summary,\n", - ".xr-section-inline-details {\n", - " padding-top: 4px;\n", - " padding-bottom: 4px;\n", - "}\n", - "\n", - ".xr-section-inline-details {\n", - " grid-column: 2 / -1;\n", - "}\n", - "\n", - ".xr-section-details {\n", - " display: none;\n", - " grid-column: 1 / -1;\n", - " margin-bottom: 5px;\n", - "}\n", - "\n", - ".xr-section-summary-in:checked ~ .xr-section-details {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-array-wrap {\n", - " grid-column: 1 / -1;\n", - " display: grid;\n", - " grid-template-columns: 20px auto;\n", - "}\n", - "\n", - ".xr-array-wrap > label {\n", - " grid-column: 1;\n", - " vertical-align: top;\n", - "}\n", - "\n", - ".xr-preview {\n", - " color: var(--xr-font-color3);\n", - "}\n", - "\n", - ".xr-array-preview,\n", - ".xr-array-data {\n", - " padding: 0 5px !important;\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-array-data,\n", - ".xr-array-in:checked ~ .xr-array-preview {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-array-in:checked ~ .xr-array-data,\n", - ".xr-array-preview {\n", - " display: inline-block;\n", - "}\n", - "\n", - ".xr-dim-list {\n", - " display: inline-block !important;\n", - " list-style: none;\n", - " padding: 0 !important;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list li {\n", - " display: inline-block;\n", - " padding: 0;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list:before {\n", - " content: '(';\n", - "}\n", - "\n", - ".xr-dim-list:after {\n", - " content: ')';\n", - "}\n", - "\n", - ".xr-dim-list li:not(:last-child):after {\n", - " content: ',';\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-has-index {\n", - " font-weight: bold;\n", - "}\n", - "\n", - ".xr-var-list,\n", - ".xr-var-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-var-item > div,\n", - ".xr-var-item label,\n", - ".xr-var-item > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-even);\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-var-item > .xr-var-name:hover span {\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-var-list > li:nth-child(odd) > div,\n", - ".xr-var-list > li:nth-child(odd) > label,\n", - ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-odd);\n", - "}\n", - "\n", - ".xr-var-name {\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-var-dims {\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-var-dtype {\n", - " grid-column: 3;\n", - " text-align: right;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-preview {\n", - " grid-column: 4;\n", - "}\n", - "\n", - ".xr-index-preview {\n", - " grid-column: 2 / 5;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-name,\n", - ".xr-var-dims,\n", - ".xr-var-dtype,\n", - ".xr-preview,\n", - ".xr-attrs dt {\n", - " white-space: nowrap;\n", - " overflow: hidden;\n", - " text-overflow: ellipsis;\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-var-name:hover,\n", - ".xr-var-dims:hover,\n", - ".xr-var-dtype:hover,\n", - ".xr-attrs dt:hover {\n", - " overflow: visible;\n", - " width: auto;\n", - " z-index: 1;\n", - "}\n", - "\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " display: none;\n", - " background-color: var(--xr-background-color) !important;\n", - " padding-bottom: 5px !important;\n", - "}\n", - "\n", - ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data,\n", - ".xr-index-data-in:checked ~ .xr-index-data {\n", - " display: block;\n", - "}\n", - "\n", - ".xr-var-data > table {\n", - " float: right;\n", - "}\n", - "\n", - ".xr-var-name span,\n", - ".xr-var-data,\n", - ".xr-index-name div,\n", - ".xr-index-data,\n", - ".xr-attrs {\n", - " padding-left: 25px !important;\n", - "}\n", - "\n", - ".xr-attrs,\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " grid-column: 1 / -1;\n", - "}\n", - "\n", - "dl.xr-attrs {\n", - " padding: 0;\n", - " margin: 0;\n", - " display: grid;\n", - " grid-template-columns: 125px auto;\n", - "}\n", - "\n", - ".xr-attrs dt,\n", - ".xr-attrs dd {\n", - " padding: 0;\n", - " margin: 0;\n", - " float: left;\n", - " padding-right: 10px;\n", - " width: auto;\n", - "}\n", - "\n", - ".xr-attrs dt {\n", - " font-weight: normal;\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-attrs dt:hover span {\n", - " display: inline-block;\n", - " background: var(--xr-background-color);\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-attrs dd {\n", - " grid-column: 2;\n", - " white-space: pre-wrap;\n", - " word-break: break-all;\n", - "}\n", - "\n", - ".xr-icon-database,\n", - ".xr-icon-file-text2,\n", - ".xr-no-icon {\n", - " display: inline-block;\n", - " vertical-align: middle;\n", - " width: 1em;\n", - " height: 1.5em !important;\n", - " stroke-width: 0;\n", - " stroke: currentColor;\n", - " fill: currentColor;\n", - "}\n", - "</style><pre class='xr-text-repr-fallback'><xarray.Dataset> Size: 91kB\n", - "Dimensions: (dayofyear: 365, quantiles: 15)\n", - "Coordinates:\n", - " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", - " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", - "Data variables:\n", - " af (dayofyear, quantiles) float64 44kB -1.268 -1.415 ... -2.264\n", - " hist_q (dayofyear, quantiles) float64 44kB 255.7 255.9 ... 258.0 258.5\n", - "Attributes:\n", - " group: time.dayofyear\n", - " group_compute_dims: ['time']\n", - " group_window: 1\n", - " _xsdba_adjustment: {"py/object": "xsdba.adjustment.QuantileDeltaMapping...\n", - " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-95c4f86f-361b-436e-9d81-0203d0f586dd' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-95c4f86f-361b-436e-9d81-0203d0f586dd' class='xr-section-summary' title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>dayofyear</span>: 365</li><li><span class='xr-has-index'>quantiles</span>: 15</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-fd589716-69c9-444b-8dc9-7f3e982d2761' class='xr-section-summary-in' type='checkbox' checked><label for='section-fd589716-69c9-444b-8dc9-7f3e982d2761' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>quantiles</span></div><div class='xr-var-dims'>(quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.03333 0.1 0.1667 ... 0.9 0.9667</div><input id='attrs-4aa06cfa-23ac-42e1-b6ed-95e12a0b2dd9' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-4aa06cfa-23ac-42e1-b6ed-95e12a0b2dd9' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-9885f047-4210-419f-b306-4d0bfa1dbe7e' class='xr-var-data-in' type='checkbox'><label for='data-9885f047-4210-419f-b306-4d0bfa1dbe7e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0.033333, 0.1 , 0.166667, 0.233333, 0.3 , 0.366667, 0.433333,\n", - " 0.5 , 0.566667, 0.633333, 0.7 , 0.766667, 0.833333, 0.9 ,\n", - " 0.966667])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>dayofyear</span></div><div class='xr-var-dims'>(dayofyear)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>1 2 3 4 5 6 ... 361 362 363 364 365</div><input id='attrs-b2689114-2efa-494c-a607-787bd2433284' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-b2689114-2efa-494c-a607-787bd2433284' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-3bb6ccd4-5a39-4fd2-8f53-7b8f9e3f9a6f' class='xr-var-data-in' type='checkbox'><label for='data-3bb6ccd4-5a39-4fd2-8f53-7b8f9e3f9a6f' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([ 1, 2, 3, ..., 363, 364, 365])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-8aa69c1e-a642-423a-b3b9-4872b068ab2e' class='xr-section-summary-in' type='checkbox' checked><label for='section-8aa69c1e-a642-423a-b3b9-4872b068ab2e' class='xr-section-summary' >Data variables: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>af</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>-1.268 -1.415 ... -2.124 -2.264</div><input id='attrs-3e92b834-9e2e-46c0-856b-bc788938fb5b' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-3e92b834-9e2e-46c0-856b-bc788938fb5b' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5fb147d5-7822-49be-bf45-ab9d6e93201d' class='xr-var-data-in' type='checkbox'><label for='data-5fb147d5-7822-49be-bf45-ab9d6e93201d' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>kind :</span></dt><dd>+</dd><dt><span>standard_name :</span></dt><dd>Adjustment factors</dd><dt><span>long_name :</span></dt><dd>Quantile mapping adjustment factors</dd></dl></div><div class='xr-var-data'><pre>array([[-1.26832691, -1.41518655, -1.44204209, ..., -1.90328231,\n", - " -1.97066107, -1.85047499],\n", - " [-2.13704007, -2.01513061, -1.89020114, ..., -1.9872316 ,\n", - " -1.84895748, -2.04778983],\n", - " [-2.05817452, -1.81650395, -1.75835219, ..., -2.32130962,\n", - " -2.05641772, -1.81242664],\n", - " ...,\n", - " [-1.95317141, -1.72661366, -1.67899876, ..., -1.69008412,\n", - " -1.7302959 , -1.9684894 ],\n", - " [-2.019817 , -1.72668539, -1.83673473, ..., -1.91127378,\n", - " -1.94020205, -1.75210557],\n", - " [-2.08251803, -2.44522864, -2.54127462, ..., -2.24160337,\n", - " -2.12437576, -2.2639624 ]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>hist_q</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>255.7 255.9 256.0 ... 258.0 258.5</div><input id='attrs-bf0e2c67-522f-44b2-bbdb-b6e7269bfe89' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-bf0e2c67-522f-44b2-bbdb-b6e7269bfe89' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-6637d6c7-777b-4718-96c0-90eccfa33e9d' class='xr-var-data-in' type='checkbox'><label for='data-6637d6c7-777b-4718-96c0-90eccfa33e9d' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>standard_name :</span></dt><dd>Model quantiles</dd><dt><span>long_name :</span></dt><dd>Quantiles of model on the reference period</dd></dl></div><div class='xr-var-data'><pre>array([[255.67497958, 255.86005355, 256.02935583, ..., 257.71220364,\n", - " 258.01227461, 258.28494627],\n", - " [255.85419559, 255.90780006, 256.03424744, ..., 257.32803683,\n", - " 257.45219506, 257.78927464],\n", - " [255.89059763, 256.25185479, 256.3157335 , ..., 258.06054282,\n", - " 258.1273541 , 258.1657027 ],\n", - " ...,\n", - " [255.56861177, 255.77899691, 256.02006814, ..., 257.48606473,\n", - " 257.60476301, 258.00044466],\n", - " [255.72623318, 255.80485509, 256.03708454, ..., 257.74902934,\n", - " 257.94442519, 257.98805055],\n", - " [255.67890484, 256.38863543, 256.77258908, ..., 257.73262335,\n", - " 257.99645326, 258.4576744 ]])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-d68164e7-fa25-4d84-83c8-022533396393' class='xr-section-summary-in' type='checkbox' ><label for='section-d68164e7-fa25-4d84-83c8-022533396393' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>quantiles</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-b560b2f1-7fb8-4749-956f-246bd3314d5e' class='xr-index-data-in' type='checkbox'/><label for='index-b560b2f1-7fb8-4749-956f-246bd3314d5e' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0.03333333333333333, 0.1, 0.16666666666666666,\n", - " 0.23333333333333334, 0.3, 0.36666666666666664,\n", - " 0.43333333333333335, 0.5, 0.5666666666666667,\n", - " 0.6333333333333333, 0.7, 0.7666666666666666,\n", - " 0.8333333333333334, 0.9, 0.9666666666666667],\n", - " dtype='float64', name='quantiles'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>dayofyear</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-8c6e8635-5349-48cd-81c6-c07b3d815fc0' class='xr-index-data-in' type='checkbox'/><label for='index-8c6e8635-5349-48cd-81c6-c07b3d815fc0' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\n", - " ...\n", - " 356, 357, 358, 359, 360, 361, 362, 363, 364, 365],\n", - " dtype='int64', name='dayofyear', length=365))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-1dd0d572-1bea-4f49-96c0-ca27b0cbe9fd' class='xr-section-summary-in' type='checkbox' checked><label for='section-1dd0d572-1bea-4f49-96c0-ca27b0cbe9fd' class='xr-section-summary' >Attributes: <span>(5)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>group :</span></dt><dd>time.dayofyear</dd><dt><span>group_compute_dims :</span></dt><dd>['time']</dd><dt><span>group_window :</span></dt><dd>1</dd><dt><span>_xsdba_adjustment :</span></dt><dd>{"py/object": "xsdba.adjustment.QuantileDeltaMapping", "py/state": {"hist_calendar": "noleap", "train_units": "K", "group": {"py/object": "xsdba.base.Grouper", "py/state": {"dim": "time", "add_dims": [], "prop": "dayofyear", "name": "time.dayofyear", "window": 1}}, "kind": "+"}}</dd><dt><span>adj_params :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')</dd></dl></div></li></ul></div></div>" - ], - "text/plain": [ - "<xarray.Dataset> Size: 91kB\n", - "Dimensions: (dayofyear: 365, quantiles: 15)\n", - "Coordinates:\n", - " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", - " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", - "Data variables:\n", - " af (dayofyear, quantiles) float64 44kB -1.268 -1.415 ... -2.264\n", - " hist_q (dayofyear, quantiles) float64 44kB 255.7 255.9 ... 258.0 258.5\n", - "Attributes:\n", - " group: time.dayofyear\n", - " group_compute_dims: ['time']\n", - " group_window: 1\n", - " _xsdba_adjustment: {\"py/object\": \"xsdba.adjustment.QuantileDeltaMapping...\n", - " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy..." - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "QDM.ds" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# The engine keyword is only needed if netCDF4 is not available\n", "# FIXME: Error when using h5netcdf\n", @@ -802,425 +288,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", - "<defs>\n", - "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", - "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "</symbol>\n", - "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", - "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "</symbol>\n", - "</defs>\n", - "</svg>\n", - "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", - " *\n", - " */\n", - "\n", - ":root {\n", - " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", - " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", - " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", - " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", - " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", - " --xr-background-color: var(--jp-layout-color0, white);\n", - " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", - " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", - "}\n", - "\n", - "html[theme=dark],\n", - "html[data-theme=dark],\n", - "body[data-theme=dark],\n", - "body.vscode-dark {\n", - " --xr-font-color0: rgba(255, 255, 255, 1);\n", - " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", - " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", - " --xr-border-color: #1F1F1F;\n", - " --xr-disabled-color: #515151;\n", - " --xr-background-color: #111111;\n", - " --xr-background-color-row-even: #111111;\n", - " --xr-background-color-row-odd: #313131;\n", - "}\n", - "\n", - ".xr-wrap {\n", - " display: block !important;\n", - " min-width: 300px;\n", - " max-width: 700px;\n", - "}\n", - "\n", - ".xr-text-repr-fallback {\n", - " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", - " display: none;\n", - "}\n", - "\n", - ".xr-header {\n", - " padding-top: 6px;\n", - " padding-bottom: 6px;\n", - " margin-bottom: 4px;\n", - " border-bottom: solid 1px var(--xr-border-color);\n", - "}\n", - "\n", - ".xr-header > div,\n", - ".xr-header > ul {\n", - " display: inline;\n", - " margin-top: 0;\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-obj-type,\n", - ".xr-array-name {\n", - " margin-left: 2px;\n", - " margin-right: 10px;\n", - "}\n", - "\n", - ".xr-obj-type {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-sections {\n", - " padding-left: 0 !important;\n", - " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", - "}\n", - "\n", - ".xr-section-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-section-item input {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-item input + label {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label {\n", - " cursor: pointer;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label:hover {\n", - " color: var(--xr-font-color0);\n", - "}\n", - "\n", - ".xr-section-summary {\n", - " grid-column: 1;\n", - " color: var(--xr-font-color2);\n", - " font-weight: 500;\n", - "}\n", - "\n", - ".xr-section-summary > span {\n", - " display: inline-block;\n", - " padding-left: 0.5em;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-summary-in + label:before {\n", - " display: inline-block;\n", - " content: '►';\n", - " font-size: 11px;\n", - " width: 15px;\n", - " text-align: center;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label:before {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label:before {\n", - " content: '▼';\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label > span {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-summary,\n", - ".xr-section-inline-details {\n", - " padding-top: 4px;\n", - " padding-bottom: 4px;\n", - "}\n", - "\n", - ".xr-section-inline-details {\n", - " grid-column: 2 / -1;\n", - "}\n", - "\n", - ".xr-section-details {\n", - " display: none;\n", - " grid-column: 1 / -1;\n", - " margin-bottom: 5px;\n", - "}\n", - "\n", - ".xr-section-summary-in:checked ~ .xr-section-details {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-array-wrap {\n", - " grid-column: 1 / -1;\n", - " display: grid;\n", - " grid-template-columns: 20px auto;\n", - "}\n", - "\n", - ".xr-array-wrap > label {\n", - " grid-column: 1;\n", - " vertical-align: top;\n", - "}\n", - "\n", - ".xr-preview {\n", - " color: var(--xr-font-color3);\n", - "}\n", - "\n", - ".xr-array-preview,\n", - ".xr-array-data {\n", - " padding: 0 5px !important;\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-array-data,\n", - ".xr-array-in:checked ~ .xr-array-preview {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-array-in:checked ~ .xr-array-data,\n", - ".xr-array-preview {\n", - " display: inline-block;\n", - "}\n", - "\n", - ".xr-dim-list {\n", - " display: inline-block !important;\n", - " list-style: none;\n", - " padding: 0 !important;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list li {\n", - " display: inline-block;\n", - " padding: 0;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list:before {\n", - " content: '(';\n", - "}\n", - "\n", - ".xr-dim-list:after {\n", - " content: ')';\n", - "}\n", - "\n", - ".xr-dim-list li:not(:last-child):after {\n", - " content: ',';\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-has-index {\n", - " font-weight: bold;\n", - "}\n", - "\n", - ".xr-var-list,\n", - ".xr-var-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-var-item > div,\n", - ".xr-var-item label,\n", - ".xr-var-item > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-even);\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-var-item > .xr-var-name:hover span {\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-var-list > li:nth-child(odd) > div,\n", - ".xr-var-list > li:nth-child(odd) > label,\n", - ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-odd);\n", - "}\n", - "\n", - ".xr-var-name {\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-var-dims {\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-var-dtype {\n", - " grid-column: 3;\n", - " text-align: right;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-preview {\n", - " grid-column: 4;\n", - "}\n", - "\n", - ".xr-index-preview {\n", - " grid-column: 2 / 5;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-name,\n", - ".xr-var-dims,\n", - ".xr-var-dtype,\n", - ".xr-preview,\n", - ".xr-attrs dt {\n", - " white-space: nowrap;\n", - " overflow: hidden;\n", - " text-overflow: ellipsis;\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-var-name:hover,\n", - ".xr-var-dims:hover,\n", - ".xr-var-dtype:hover,\n", - ".xr-attrs dt:hover {\n", - " overflow: visible;\n", - " width: auto;\n", - " z-index: 1;\n", - "}\n", - "\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " display: none;\n", - " background-color: var(--xr-background-color) !important;\n", - " padding-bottom: 5px !important;\n", - "}\n", - "\n", - ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data,\n", - ".xr-index-data-in:checked ~ .xr-index-data {\n", - " display: block;\n", - "}\n", - "\n", - ".xr-var-data > table {\n", - " float: right;\n", - "}\n", - "\n", - ".xr-var-name span,\n", - ".xr-var-data,\n", - ".xr-index-name div,\n", - ".xr-index-data,\n", - ".xr-attrs {\n", - " padding-left: 25px !important;\n", - "}\n", - "\n", - ".xr-attrs,\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " grid-column: 1 / -1;\n", - "}\n", - "\n", - "dl.xr-attrs {\n", - " padding: 0;\n", - " margin: 0;\n", - " display: grid;\n", - " grid-template-columns: 125px auto;\n", - "}\n", - "\n", - ".xr-attrs dt,\n", - ".xr-attrs dd {\n", - " padding: 0;\n", - " margin: 0;\n", - " float: left;\n", - " padding-right: 10px;\n", - " width: auto;\n", - "}\n", - "\n", - ".xr-attrs dt {\n", - " font-weight: normal;\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-attrs dt:hover span {\n", - " display: inline-block;\n", - " background: var(--xr-background-color);\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-attrs dd {\n", - " grid-column: 2;\n", - " white-space: pre-wrap;\n", - " word-break: break-all;\n", - "}\n", - "\n", - ".xr-icon-database,\n", - ".xr-icon-file-text2,\n", - ".xr-no-icon {\n", - " display: inline-block;\n", - " vertical-align: middle;\n", - " width: 1em;\n", - " height: 1.5em !important;\n", - " stroke-width: 0;\n", - " stroke: currentColor;\n", - " fill: currentColor;\n", - "}\n", - "</style><pre class='xr-text-repr-fallback'><xarray.Dataset> Size: 91kB\n", - "Dimensions: (dayofyear: 365, quantiles: 15)\n", - "Coordinates:\n", - " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", - " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", - "Data variables:\n", - " af (dayofyear, quantiles) float64 44kB ...\n", - " hist_q (dayofyear, quantiles) float64 44kB ...\n", - "Attributes:\n", - " group: time.dayofyear\n", - " group_compute_dims: time\n", - " group_window: 1\n", - " _xsdba_adjustment: {"py/object": "xsdba.adjustment.QuantileDeltaMapping...\n", - " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy...\n", - " title: This is the dataset, but read from disk.</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-bcddec80-a100-4cb3-9daa-37f0d3c4ab85' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-bcddec80-a100-4cb3-9daa-37f0d3c4ab85' class='xr-section-summary' title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>dayofyear</span>: 365</li><li><span class='xr-has-index'>quantiles</span>: 15</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-d3ab478b-ace6-40d2-b382-01bfae7f6d82' class='xr-section-summary-in' type='checkbox' checked><label for='section-d3ab478b-ace6-40d2-b382-01bfae7f6d82' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>quantiles</span></div><div class='xr-var-dims'>(quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.03333 0.1 0.1667 ... 0.9 0.9667</div><input id='attrs-5062dbfe-74af-4bbf-b50c-ea247855a579' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-5062dbfe-74af-4bbf-b50c-ea247855a579' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5637ca09-2f50-409d-9cb9-073ba9aaee69' class='xr-var-data-in' type='checkbox'><label for='data-5637ca09-2f50-409d-9cb9-073ba9aaee69' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0.033333, 0.1 , 0.166667, 0.233333, 0.3 , 0.366667, 0.433333,\n", - " 0.5 , 0.566667, 0.633333, 0.7 , 0.766667, 0.833333, 0.9 ,\n", - " 0.966667])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>dayofyear</span></div><div class='xr-var-dims'>(dayofyear)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>1 2 3 4 5 6 ... 361 362 363 364 365</div><input id='attrs-826abb8d-59b1-4eab-a3d4-746880075ca0' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-826abb8d-59b1-4eab-a3d4-746880075ca0' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d6e891f5-7994-44a6-bbe3-1c0b4d7685a7' class='xr-var-data-in' type='checkbox'><label for='data-d6e891f5-7994-44a6-bbe3-1c0b4d7685a7' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([ 1, 2, 3, ..., 363, 364, 365])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-d3960897-2f86-4b25-9f6c-5f1da9d6c26a' class='xr-section-summary-in' type='checkbox' checked><label for='section-d3960897-2f86-4b25-9f6c-5f1da9d6c26a' class='xr-section-summary' >Data variables: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>af</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-b8c2f7da-fc20-4dc4-85e2-8523309e2de2' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-b8c2f7da-fc20-4dc4-85e2-8523309e2de2' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d815973f-95ae-4b62-9bda-1610c99bdb15' class='xr-var-data-in' type='checkbox'><label for='data-d815973f-95ae-4b62-9bda-1610c99bdb15' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>kind :</span></dt><dd>+</dd><dt><span>standard_name :</span></dt><dd>Adjustment factors</dd><dt><span>long_name :</span></dt><dd>Quantile mapping adjustment factors</dd></dl></div><div class='xr-var-data'><pre>[5475 values with dtype=float64]</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>hist_q</span></div><div class='xr-var-dims'>(dayofyear, quantiles)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-1cfaf071-8d5b-4e00-a54e-a7db1523d00c' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-1cfaf071-8d5b-4e00-a54e-a7db1523d00c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-db7371e2-6edd-4104-a706-3f3adc5161bd' class='xr-var-data-in' type='checkbox'><label for='data-db7371e2-6edd-4104-a706-3f3adc5161bd' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>standard_name :</span></dt><dd>Model quantiles</dd><dt><span>long_name :</span></dt><dd>Quantiles of model on the reference period</dd></dl></div><div class='xr-var-data'><pre>[5475 values with dtype=float64]</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-5e2808c1-e15b-4314-b3b7-abba7365af88' class='xr-section-summary-in' type='checkbox' ><label for='section-5e2808c1-e15b-4314-b3b7-abba7365af88' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>quantiles</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-19117bc4-00d8-45a5-a22e-7ac17ab4380d' class='xr-index-data-in' type='checkbox'/><label for='index-19117bc4-00d8-45a5-a22e-7ac17ab4380d' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0.03333333333333333, 0.1, 0.16666666666666666,\n", - " 0.23333333333333334, 0.3, 0.36666666666666664,\n", - " 0.43333333333333335, 0.5, 0.5666666666666667,\n", - " 0.6333333333333333, 0.7, 0.7666666666666666,\n", - " 0.8333333333333334, 0.9, 0.9666666666666667],\n", - " dtype='float64', name='quantiles'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>dayofyear</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-aa44839a-c5cb-435f-9df9-e6ffabcccf07' class='xr-index-data-in' type='checkbox'/><label for='index-aa44839a-c5cb-435f-9df9-e6ffabcccf07' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\n", - " ...\n", - " 356, 357, 358, 359, 360, 361, 362, 363, 364, 365],\n", - " dtype='int64', name='dayofyear', length=365))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-9c281e26-ae8d-4ccc-b5c9-292ba6a3ffd2' class='xr-section-summary-in' type='checkbox' checked><label for='section-9c281e26-ae8d-4ccc-b5c9-292ba6a3ffd2' class='xr-section-summary' >Attributes: <span>(6)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>group :</span></dt><dd>time.dayofyear</dd><dt><span>group_compute_dims :</span></dt><dd>time</dd><dt><span>group_window :</span></dt><dd>1</dd><dt><span>_xsdba_adjustment :</span></dt><dd>{"py/object": "xsdba.adjustment.QuantileDeltaMapping", "py/state": {"hist_calendar": "noleap", "train_units": "K", "group": {"py/object": "xsdba.base.Grouper", "py/state": {"dim": "time", "add_dims": [], "prop": "dayofyear", "name": "time.dayofyear", "window": 1}}, "kind": "+"}}</dd><dt><span>adj_params :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+')</dd><dt><span>title :</span></dt><dd>This is the dataset, but read from disk.</dd></dl></div></li></ul></div></div>" - ], - "text/plain": [ - "<xarray.Dataset> Size: 91kB\n", - "Dimensions: (dayofyear: 365, quantiles: 15)\n", - "Coordinates:\n", - " * quantiles (quantiles) float64 120B 0.03333 0.1 0.1667 ... 0.8333 0.9 0.9667\n", - " * dayofyear (dayofyear) int64 3kB 1 2 3 4 5 6 7 ... 360 361 362 363 364 365\n", - "Data variables:\n", - " af (dayofyear, quantiles) float64 44kB ...\n", - " hist_q (dayofyear, quantiles) float64 44kB ...\n", - "Attributes:\n", - " group: time.dayofyear\n", - " group_compute_dims: time\n", - " group_window: 1\n", - " _xsdba_adjustment: {\"py/object\": \"xsdba.adjustment.QuantileDeltaMapping...\n", - " adj_params: QuantileDeltaMapping(group=Grouper(name='time.dayofy...\n", - " title: This is the dataset, but read from disk." - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# FIXME: Error when using h5netcdf\n", "# QDM.ds.to_netcdf(\"QDM_training2.nc\", engine=\"h5netcdf\")\n", @@ -1234,419 +304,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", - "<defs>\n", - "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", - "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "</symbol>\n", - "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", - "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "</symbol>\n", - "</defs>\n", - "</svg>\n", - "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", - " *\n", - " */\n", - "\n", - ":root {\n", - " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", - " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", - " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", - " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", - " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", - " --xr-background-color: var(--jp-layout-color0, white);\n", - " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", - " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", - "}\n", - "\n", - "html[theme=dark],\n", - "html[data-theme=dark],\n", - "body[data-theme=dark],\n", - "body.vscode-dark {\n", - " --xr-font-color0: rgba(255, 255, 255, 1);\n", - " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", - " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", - " --xr-border-color: #1F1F1F;\n", - " --xr-disabled-color: #515151;\n", - " --xr-background-color: #111111;\n", - " --xr-background-color-row-even: #111111;\n", - " --xr-background-color-row-odd: #313131;\n", - "}\n", - "\n", - ".xr-wrap {\n", - " display: block !important;\n", - " min-width: 300px;\n", - " max-width: 700px;\n", - "}\n", - "\n", - ".xr-text-repr-fallback {\n", - " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", - " display: none;\n", - "}\n", - "\n", - ".xr-header {\n", - " padding-top: 6px;\n", - " padding-bottom: 6px;\n", - " margin-bottom: 4px;\n", - " border-bottom: solid 1px var(--xr-border-color);\n", - "}\n", - "\n", - ".xr-header > div,\n", - ".xr-header > ul {\n", - " display: inline;\n", - " margin-top: 0;\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-obj-type,\n", - ".xr-array-name {\n", - " margin-left: 2px;\n", - " margin-right: 10px;\n", - "}\n", - "\n", - ".xr-obj-type {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-sections {\n", - " padding-left: 0 !important;\n", - " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", - "}\n", - "\n", - ".xr-section-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-section-item input {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-item input + label {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label {\n", - " cursor: pointer;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label:hover {\n", - " color: var(--xr-font-color0);\n", - "}\n", - "\n", - ".xr-section-summary {\n", - " grid-column: 1;\n", - " color: var(--xr-font-color2);\n", - " font-weight: 500;\n", - "}\n", - "\n", - ".xr-section-summary > span {\n", - " display: inline-block;\n", - " padding-left: 0.5em;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-summary-in + label:before {\n", - " display: inline-block;\n", - " content: '►';\n", - " font-size: 11px;\n", - " width: 15px;\n", - " text-align: center;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label:before {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label:before {\n", - " content: '▼';\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label > span {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-summary,\n", - ".xr-section-inline-details {\n", - " padding-top: 4px;\n", - " padding-bottom: 4px;\n", - "}\n", - "\n", - ".xr-section-inline-details {\n", - " grid-column: 2 / -1;\n", - "}\n", - "\n", - ".xr-section-details {\n", - " display: none;\n", - " grid-column: 1 / -1;\n", - " margin-bottom: 5px;\n", - "}\n", - "\n", - ".xr-section-summary-in:checked ~ .xr-section-details {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-array-wrap {\n", - " grid-column: 1 / -1;\n", - " display: grid;\n", - " grid-template-columns: 20px auto;\n", - "}\n", - "\n", - ".xr-array-wrap > label {\n", - " grid-column: 1;\n", - " vertical-align: top;\n", - "}\n", - "\n", - ".xr-preview {\n", - " color: var(--xr-font-color3);\n", - "}\n", - "\n", - ".xr-array-preview,\n", - ".xr-array-data {\n", - " padding: 0 5px !important;\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-array-data,\n", - ".xr-array-in:checked ~ .xr-array-preview {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-array-in:checked ~ .xr-array-data,\n", - ".xr-array-preview {\n", - " display: inline-block;\n", - "}\n", - "\n", - ".xr-dim-list {\n", - " display: inline-block !important;\n", - " list-style: none;\n", - " padding: 0 !important;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list li {\n", - " display: inline-block;\n", - " padding: 0;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list:before {\n", - " content: '(';\n", - "}\n", - "\n", - ".xr-dim-list:after {\n", - " content: ')';\n", - "}\n", - "\n", - ".xr-dim-list li:not(:last-child):after {\n", - " content: ',';\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-has-index {\n", - " font-weight: bold;\n", - "}\n", - "\n", - ".xr-var-list,\n", - ".xr-var-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-var-item > div,\n", - ".xr-var-item label,\n", - ".xr-var-item > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-even);\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-var-item > .xr-var-name:hover span {\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-var-list > li:nth-child(odd) > div,\n", - ".xr-var-list > li:nth-child(odd) > label,\n", - ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-odd);\n", - "}\n", - "\n", - ".xr-var-name {\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-var-dims {\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-var-dtype {\n", - " grid-column: 3;\n", - " text-align: right;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-preview {\n", - " grid-column: 4;\n", - "}\n", - "\n", - ".xr-index-preview {\n", - " grid-column: 2 / 5;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-name,\n", - ".xr-var-dims,\n", - ".xr-var-dtype,\n", - ".xr-preview,\n", - ".xr-attrs dt {\n", - " white-space: nowrap;\n", - " overflow: hidden;\n", - " text-overflow: ellipsis;\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-var-name:hover,\n", - ".xr-var-dims:hover,\n", - ".xr-var-dtype:hover,\n", - ".xr-attrs dt:hover {\n", - " overflow: visible;\n", - " width: auto;\n", - " z-index: 1;\n", - "}\n", - "\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " display: none;\n", - " background-color: var(--xr-background-color) !important;\n", - " padding-bottom: 5px !important;\n", - "}\n", - "\n", - ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data,\n", - ".xr-index-data-in:checked ~ .xr-index-data {\n", - " display: block;\n", - "}\n", - "\n", - ".xr-var-data > table {\n", - " float: right;\n", - "}\n", - "\n", - ".xr-var-name span,\n", - ".xr-var-data,\n", - ".xr-index-name div,\n", - ".xr-index-data,\n", - ".xr-attrs {\n", - " padding-left: 25px !important;\n", - "}\n", - "\n", - ".xr-attrs,\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " grid-column: 1 / -1;\n", - "}\n", - "\n", - "dl.xr-attrs {\n", - " padding: 0;\n", - " margin: 0;\n", - " display: grid;\n", - " grid-template-columns: 125px auto;\n", - "}\n", - "\n", - ".xr-attrs dt,\n", - ".xr-attrs dd {\n", - " padding: 0;\n", - " margin: 0;\n", - " float: left;\n", - " padding-right: 10px;\n", - " width: auto;\n", - "}\n", - "\n", - ".xr-attrs dt {\n", - " font-weight: normal;\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-attrs dt:hover span {\n", - " display: inline-block;\n", - " background: var(--xr-background-color);\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-attrs dd {\n", - " grid-column: 2;\n", - " white-space: pre-wrap;\n", - " word-break: break-all;\n", - "}\n", - "\n", - ".xr-icon-database,\n", - ".xr-icon-file-text2,\n", - ".xr-no-icon {\n", - " display: inline-block;\n", - " vertical-align: middle;\n", - " width: 1em;\n", - " height: 1.5em !important;\n", - " stroke-width: 0;\n", - " stroke: currentColor;\n", - " fill: currentColor;\n", - "}\n", - "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'scen' (time: 11315)> Size: 91kB\n", - "array([255.23206044, 254.31691855, 254.849451 , ..., 257.95004657,\n", - " 257.05566815, 256.34753035])\n", - "Coordinates:\n", - " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", - "Attributes:\n", - " units: K\n", - " history: [2024-08-02 12:24:44] : Bias-adjusted with QuantileDelt...\n", - " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'scen'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>time</span>: 11315</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-257c25bd-02bf-456c-9e07-d7f2f31f2764' class='xr-array-in' type='checkbox' checked><label for='section-257c25bd-02bf-456c-9e07-d7f2f31f2764' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>255.2 254.3 254.8 253.2 253.6 253.6 ... 256.4 257.7 258.0 257.1 256.3</span></div><div class='xr-array-data'><pre>array([255.23206044, 254.31691855, 254.849451 , ..., 257.95004657,\n", - " 257.05566815, 256.34753035])</pre></div></div></li><li class='xr-section-item'><input id='section-7de38e0b-d3d9-4219-a7d4-255b71915bec' class='xr-section-summary-in' type='checkbox' checked><label for='section-7de38e0b-d3d9-4219-a7d4-255b71915bec' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2030-12-...</div><input id='attrs-e5e83996-22ff-42ce-88c7-dcc17467d093' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-e5e83996-22ff-42ce-88c7-dcc17467d093' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-7f964837-b78d-404a-9830-c02a8cb73d15' class='xr-var-data-in' type='checkbox'><label for='data-7f964837-b78d-404a-9830-c02a8cb73d15' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2000, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2000, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", - " cftime.DatetimeNoLeap(2030, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2030, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2030, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", - " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-fb69ddc9-322f-4c58-adb2-1844a509851c' class='xr-section-summary-in' type='checkbox' ><label for='section-fb69ddc9-322f-4c58-adb2-1844a509851c' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-1e13fb99-8ef7-47dc-9c42-983a80157c87' class='xr-index-data-in' type='checkbox'/><label for='index-1e13fb99-8ef7-47dc-9c42-983a80157c87' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00,\n", - " 2000-01-04 00:00:00, 2000-01-05 00:00:00, 2000-01-06 00:00:00,\n", - " 2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,\n", - " 2000-01-10 00:00:00,\n", - " ...\n", - " 2030-12-22 00:00:00, 2030-12-23 00:00:00, 2030-12-24 00:00:00,\n", - " 2030-12-25 00:00:00, 2030-12-26 00:00:00, 2030-12-27 00:00:00,\n", - " 2030-12-28 00:00:00, 2030-12-29 00:00:00, 2030-12-30 00:00:00,\n", - " 2030-12-31 00:00:00],\n", - " dtype='object', length=11315, calendar='noleap', freq='D'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-67ad167a-bba1-4e70-bb15-942b0aa831dd' class='xr-section-summary-in' type='checkbox' checked><label for='section-67ad167a-bba1-4e70-bb15-942b0aa831dd' class='xr-section-summary' >Attributes: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>history :</span></dt><dd>[2024-08-02 12:24:44] : Bias-adjusted with QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, ) - xsdba version: 0.1.0</dd><dt><span>bias_adjustment :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, )</dd></dl></div></li></ul></div></div>" - ], - "text/plain": [ - "<xarray.DataArray 'scen' (time: 11315)> Size: 91kB\n", - "array([255.23206044, 254.31691855, 254.849451 , ..., 257.95004657,\n", - " 257.05566815, 256.34753035])\n", - "Coordinates:\n", - " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", - "Attributes:\n", - " units: K\n", - " history: [2024-08-02 12:24:44] : Bias-adjusted with QuantileDelt...\n", - " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear..." - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "QDM2.adjust(sim)" ] @@ -1668,421 +328,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", - "<defs>\n", - "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", - "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "</symbol>\n", - "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", - "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "</symbol>\n", - "</defs>\n", - "</svg>\n", - "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", - " *\n", - " */\n", - "\n", - ":root {\n", - " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", - " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", - " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", - " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", - " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", - " --xr-background-color: var(--jp-layout-color0, white);\n", - " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", - " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", - "}\n", - "\n", - "html[theme=dark],\n", - "html[data-theme=dark],\n", - "body[data-theme=dark],\n", - "body.vscode-dark {\n", - " --xr-font-color0: rgba(255, 255, 255, 1);\n", - " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", - " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", - " --xr-border-color: #1F1F1F;\n", - " --xr-disabled-color: #515151;\n", - " --xr-background-color: #111111;\n", - " --xr-background-color-row-even: #111111;\n", - " --xr-background-color-row-odd: #313131;\n", - "}\n", - "\n", - ".xr-wrap {\n", - " display: block !important;\n", - " min-width: 300px;\n", - " max-width: 700px;\n", - "}\n", - "\n", - ".xr-text-repr-fallback {\n", - " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", - " display: none;\n", - "}\n", - "\n", - ".xr-header {\n", - " padding-top: 6px;\n", - " padding-bottom: 6px;\n", - " margin-bottom: 4px;\n", - " border-bottom: solid 1px var(--xr-border-color);\n", - "}\n", - "\n", - ".xr-header > div,\n", - ".xr-header > ul {\n", - " display: inline;\n", - " margin-top: 0;\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-obj-type,\n", - ".xr-array-name {\n", - " margin-left: 2px;\n", - " margin-right: 10px;\n", - "}\n", - "\n", - ".xr-obj-type {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-sections {\n", - " padding-left: 0 !important;\n", - " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", - "}\n", - "\n", - ".xr-section-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-section-item input {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-item input + label {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label {\n", - " cursor: pointer;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label:hover {\n", - " color: var(--xr-font-color0);\n", - "}\n", - "\n", - ".xr-section-summary {\n", - " grid-column: 1;\n", - " color: var(--xr-font-color2);\n", - " font-weight: 500;\n", - "}\n", - "\n", - ".xr-section-summary > span {\n", - " display: inline-block;\n", - " padding-left: 0.5em;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-summary-in + label:before {\n", - " display: inline-block;\n", - " content: '►';\n", - " font-size: 11px;\n", - " width: 15px;\n", - " text-align: center;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label:before {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label:before {\n", - " content: '▼';\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label > span {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-summary,\n", - ".xr-section-inline-details {\n", - " padding-top: 4px;\n", - " padding-bottom: 4px;\n", - "}\n", - "\n", - ".xr-section-inline-details {\n", - " grid-column: 2 / -1;\n", - "}\n", - "\n", - ".xr-section-details {\n", - " display: none;\n", - " grid-column: 1 / -1;\n", - " margin-bottom: 5px;\n", - "}\n", - "\n", - ".xr-section-summary-in:checked ~ .xr-section-details {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-array-wrap {\n", - " grid-column: 1 / -1;\n", - " display: grid;\n", - " grid-template-columns: 20px auto;\n", - "}\n", - "\n", - ".xr-array-wrap > label {\n", - " grid-column: 1;\n", - " vertical-align: top;\n", - "}\n", - "\n", - ".xr-preview {\n", - " color: var(--xr-font-color3);\n", - "}\n", - "\n", - ".xr-array-preview,\n", - ".xr-array-data {\n", - " padding: 0 5px !important;\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-array-data,\n", - ".xr-array-in:checked ~ .xr-array-preview {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-array-in:checked ~ .xr-array-data,\n", - ".xr-array-preview {\n", - " display: inline-block;\n", - "}\n", - "\n", - ".xr-dim-list {\n", - " display: inline-block !important;\n", - " list-style: none;\n", - " padding: 0 !important;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list li {\n", - " display: inline-block;\n", - " padding: 0;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list:before {\n", - " content: '(';\n", - "}\n", - "\n", - ".xr-dim-list:after {\n", - " content: ')';\n", - "}\n", - "\n", - ".xr-dim-list li:not(:last-child):after {\n", - " content: ',';\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-has-index {\n", - " font-weight: bold;\n", - "}\n", - "\n", - ".xr-var-list,\n", - ".xr-var-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-var-item > div,\n", - ".xr-var-item label,\n", - ".xr-var-item > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-even);\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-var-item > .xr-var-name:hover span {\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-var-list > li:nth-child(odd) > div,\n", - ".xr-var-list > li:nth-child(odd) > label,\n", - ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-odd);\n", - "}\n", - "\n", - ".xr-var-name {\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-var-dims {\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-var-dtype {\n", - " grid-column: 3;\n", - " text-align: right;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-preview {\n", - " grid-column: 4;\n", - "}\n", - "\n", - ".xr-index-preview {\n", - " grid-column: 2 / 5;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-name,\n", - ".xr-var-dims,\n", - ".xr-var-dtype,\n", - ".xr-preview,\n", - ".xr-attrs dt {\n", - " white-space: nowrap;\n", - " overflow: hidden;\n", - " text-overflow: ellipsis;\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-var-name:hover,\n", - ".xr-var-dims:hover,\n", - ".xr-var-dtype:hover,\n", - ".xr-attrs dt:hover {\n", - " overflow: visible;\n", - " width: auto;\n", - " z-index: 1;\n", - "}\n", - "\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " display: none;\n", - " background-color: var(--xr-background-color) !important;\n", - " padding-bottom: 5px !important;\n", - "}\n", - "\n", - ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data,\n", - ".xr-index-data-in:checked ~ .xr-index-data {\n", - " display: block;\n", - "}\n", - "\n", - ".xr-var-data > table {\n", - " float: right;\n", - "}\n", - "\n", - ".xr-var-name span,\n", - ".xr-var-data,\n", - ".xr-index-name div,\n", - ".xr-index-data,\n", - ".xr-attrs {\n", - " padding-left: 25px !important;\n", - "}\n", - "\n", - ".xr-attrs,\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " grid-column: 1 / -1;\n", - "}\n", - "\n", - "dl.xr-attrs {\n", - " padding: 0;\n", - " margin: 0;\n", - " display: grid;\n", - " grid-template-columns: 125px auto;\n", - "}\n", - "\n", - ".xr-attrs dt,\n", - ".xr-attrs dd {\n", - " padding: 0;\n", - " margin: 0;\n", - " float: left;\n", - " padding-right: 10px;\n", - " width: auto;\n", - "}\n", - "\n", - ".xr-attrs dt {\n", - " font-weight: normal;\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-attrs dt:hover span {\n", - " display: inline-block;\n", - " background: var(--xr-background-color);\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-attrs dd {\n", - " grid-column: 2;\n", - " white-space: pre-wrap;\n", - " word-break: break-all;\n", - "}\n", - "\n", - ".xr-icon-database,\n", - ".xr-icon-file-text2,\n", - ".xr-no-icon {\n", - " display: inline-block;\n", - " vertical-align: middle;\n", - " width: 1em;\n", - " height: 1.5em !important;\n", - " stroke-width: 0;\n", - " stroke: currentColor;\n", - " fill: currentColor;\n", - "}\n", - "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'sim_q' (time: 11315)> Size: 91kB\n", - "array([0.23333333, 0.13333333, 0.2 , ..., 1. , 0.8 ,\n", - " 0.7 ])\n", - "Coordinates:\n", - " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", - "Attributes:\n", - " group: time.dayofyear\n", - " group_compute_dims: time\n", - " group_window: 1\n", - " long_name: Group-wise quantiles of `sim`.</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'sim_q'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>time</span>: 11315</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-8ba6a71c-a7cc-42b6-be53-1a53d8eb890c' class='xr-array-in' type='checkbox' checked><label for='section-8ba6a71c-a7cc-42b6-be53-1a53d8eb890c' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>0.2333 0.1333 0.2 0.0 0.0 0.0 0.1 ... 1.0 0.9 0.9667 1.0 0.8 0.7</span></div><div class='xr-array-data'><pre>array([0.23333333, 0.13333333, 0.2 , ..., 1. , 0.8 ,\n", - " 0.7 ])</pre></div></div></li><li class='xr-section-item'><input id='section-6268f56e-8449-45c6-99a4-a700e01ba7dc' class='xr-section-summary-in' type='checkbox' checked><label for='section-6268f56e-8449-45c6-99a4-a700e01ba7dc' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2030-12-...</div><input id='attrs-478eb1ef-6ee4-40ce-b767-f085a44618ba' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-478eb1ef-6ee4-40ce-b767-f085a44618ba' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5907e25c-12b3-4be0-9e70-5fc9ce6cc889' class='xr-var-data-in' type='checkbox'><label for='data-5907e25c-12b3-4be0-9e70-5fc9ce6cc889' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2000, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2000, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", - " cftime.DatetimeNoLeap(2030, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2030, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2030, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", - " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-a3bf9ede-e1b0-4b9d-b538-de930de0c387' class='xr-section-summary-in' type='checkbox' ><label for='section-a3bf9ede-e1b0-4b9d-b538-de930de0c387' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-f30eadce-ae29-4e25-a212-aeca92a62fd0' class='xr-index-data-in' type='checkbox'/><label for='index-f30eadce-ae29-4e25-a212-aeca92a62fd0' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00,\n", - " 2000-01-04 00:00:00, 2000-01-05 00:00:00, 2000-01-06 00:00:00,\n", - " 2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,\n", - " 2000-01-10 00:00:00,\n", - " ...\n", - " 2030-12-22 00:00:00, 2030-12-23 00:00:00, 2030-12-24 00:00:00,\n", - " 2030-12-25 00:00:00, 2030-12-26 00:00:00, 2030-12-27 00:00:00,\n", - " 2030-12-28 00:00:00, 2030-12-29 00:00:00, 2030-12-30 00:00:00,\n", - " 2030-12-31 00:00:00],\n", - " dtype='object', length=11315, calendar='noleap', freq='D'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-23969be4-bfa0-4730-bdff-5049731839f8' class='xr-section-summary-in' type='checkbox' checked><label for='section-23969be4-bfa0-4730-bdff-5049731839f8' class='xr-section-summary' >Attributes: <span>(4)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>group :</span></dt><dd>time.dayofyear</dd><dt><span>group_compute_dims :</span></dt><dd>time</dd><dt><span>group_window :</span></dt><dd>1</dd><dt><span>long_name :</span></dt><dd>Group-wise quantiles of `sim`.</dd></dl></div></li></ul></div></div>" - ], - "text/plain": [ - "<xarray.DataArray 'sim_q' (time: 11315)> Size: 91kB\n", - "array([0.23333333, 0.13333333, 0.2 , ..., 1. , 0.8 ,\n", - " 0.7 ])\n", - "Coordinates:\n", - " * time (time) object 91kB 2000-01-01 00:00:00 ... 2030-12-31 00:00:00\n", - "Attributes:\n", - " group: time.dayofyear\n", - " group_compute_dims: time\n", - " group_window: 1\n", - " long_name: Group-wise quantiles of `sim`." - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from xsdba import set_options\n", "\n", @@ -2125,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2138,443 +386,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", - "<defs>\n", - "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", - "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "</symbol>\n", - "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", - "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "</symbol>\n", - "</defs>\n", - "</svg>\n", - "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", - " *\n", - " */\n", - "\n", - ":root {\n", - " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", - " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", - " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", - " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", - " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", - " --xr-background-color: var(--jp-layout-color0, white);\n", - " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", - " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", - "}\n", - "\n", - "html[theme=dark],\n", - "html[data-theme=dark],\n", - "body[data-theme=dark],\n", - "body.vscode-dark {\n", - " --xr-font-color0: rgba(255, 255, 255, 1);\n", - " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", - " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", - " --xr-border-color: #1F1F1F;\n", - " --xr-disabled-color: #515151;\n", - " --xr-background-color: #111111;\n", - " --xr-background-color-row-even: #111111;\n", - " --xr-background-color-row-odd: #313131;\n", - "}\n", - "\n", - ".xr-wrap {\n", - " display: block !important;\n", - " min-width: 300px;\n", - " max-width: 700px;\n", - "}\n", - "\n", - ".xr-text-repr-fallback {\n", - " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", - " display: none;\n", - "}\n", - "\n", - ".xr-header {\n", - " padding-top: 6px;\n", - " padding-bottom: 6px;\n", - " margin-bottom: 4px;\n", - " border-bottom: solid 1px var(--xr-border-color);\n", - "}\n", - "\n", - ".xr-header > div,\n", - ".xr-header > ul {\n", - " display: inline;\n", - " margin-top: 0;\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-obj-type,\n", - ".xr-array-name {\n", - " margin-left: 2px;\n", - " margin-right: 10px;\n", - "}\n", - "\n", - ".xr-obj-type {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-sections {\n", - " padding-left: 0 !important;\n", - " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", - "}\n", - "\n", - ".xr-section-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-section-item input {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-item input + label {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label {\n", - " cursor: pointer;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label:hover {\n", - " color: var(--xr-font-color0);\n", - "}\n", - "\n", - ".xr-section-summary {\n", - " grid-column: 1;\n", - " color: var(--xr-font-color2);\n", - " font-weight: 500;\n", - "}\n", - "\n", - ".xr-section-summary > span {\n", - " display: inline-block;\n", - " padding-left: 0.5em;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-summary-in + label:before {\n", - " display: inline-block;\n", - " content: '►';\n", - " font-size: 11px;\n", - " width: 15px;\n", - " text-align: center;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label:before {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label:before {\n", - " content: '▼';\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label > span {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-summary,\n", - ".xr-section-inline-details {\n", - " padding-top: 4px;\n", - " padding-bottom: 4px;\n", - "}\n", - "\n", - ".xr-section-inline-details {\n", - " grid-column: 2 / -1;\n", - "}\n", - "\n", - ".xr-section-details {\n", - " display: none;\n", - " grid-column: 1 / -1;\n", - " margin-bottom: 5px;\n", - "}\n", - "\n", - ".xr-section-summary-in:checked ~ .xr-section-details {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-array-wrap {\n", - " grid-column: 1 / -1;\n", - " display: grid;\n", - " grid-template-columns: 20px auto;\n", - "}\n", - "\n", - ".xr-array-wrap > label {\n", - " grid-column: 1;\n", - " vertical-align: top;\n", - "}\n", - "\n", - ".xr-preview {\n", - " color: var(--xr-font-color3);\n", - "}\n", - "\n", - ".xr-array-preview,\n", - ".xr-array-data {\n", - " padding: 0 5px !important;\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-array-data,\n", - ".xr-array-in:checked ~ .xr-array-preview {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-array-in:checked ~ .xr-array-data,\n", - ".xr-array-preview {\n", - " display: inline-block;\n", - "}\n", - "\n", - ".xr-dim-list {\n", - " display: inline-block !important;\n", - " list-style: none;\n", - " padding: 0 !important;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list li {\n", - " display: inline-block;\n", - " padding: 0;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list:before {\n", - " content: '(';\n", - "}\n", - "\n", - ".xr-dim-list:after {\n", - " content: ')';\n", - "}\n", - "\n", - ".xr-dim-list li:not(:last-child):after {\n", - " content: ',';\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-has-index {\n", - " font-weight: bold;\n", - "}\n", - "\n", - ".xr-var-list,\n", - ".xr-var-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-var-item > div,\n", - ".xr-var-item label,\n", - ".xr-var-item > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-even);\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-var-item > .xr-var-name:hover span {\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-var-list > li:nth-child(odd) > div,\n", - ".xr-var-list > li:nth-child(odd) > label,\n", - ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-odd);\n", - "}\n", - "\n", - ".xr-var-name {\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-var-dims {\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-var-dtype {\n", - " grid-column: 3;\n", - " text-align: right;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-preview {\n", - " grid-column: 4;\n", - "}\n", - "\n", - ".xr-index-preview {\n", - " grid-column: 2 / 5;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-name,\n", - ".xr-var-dims,\n", - ".xr-var-dtype,\n", - ".xr-preview,\n", - ".xr-attrs dt {\n", - " white-space: nowrap;\n", - " overflow: hidden;\n", - " text-overflow: ellipsis;\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-var-name:hover,\n", - ".xr-var-dims:hover,\n", - ".xr-var-dtype:hover,\n", - ".xr-attrs dt:hover {\n", - " overflow: visible;\n", - " width: auto;\n", - " z-index: 1;\n", - "}\n", - "\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " display: none;\n", - " background-color: var(--xr-background-color) !important;\n", - " padding-bottom: 5px !important;\n", - "}\n", - "\n", - ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data,\n", - ".xr-index-data-in:checked ~ .xr-index-data {\n", - " display: block;\n", - "}\n", - "\n", - ".xr-var-data > table {\n", - " float: right;\n", - "}\n", - "\n", - ".xr-var-name span,\n", - ".xr-var-data,\n", - ".xr-index-name div,\n", - ".xr-index-data,\n", - ".xr-attrs {\n", - " padding-left: 25px !important;\n", - "}\n", - "\n", - ".xr-attrs,\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " grid-column: 1 / -1;\n", - "}\n", - "\n", - "dl.xr-attrs {\n", - " padding: 0;\n", - " margin: 0;\n", - " display: grid;\n", - " grid-template-columns: 125px auto;\n", - "}\n", - "\n", - ".xr-attrs dt,\n", - ".xr-attrs dd {\n", - " padding: 0;\n", - " margin: 0;\n", - " float: left;\n", - " padding-right: 10px;\n", - " width: auto;\n", - "}\n", - "\n", - ".xr-attrs dt {\n", - " font-weight: normal;\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-attrs dt:hover span {\n", - " display: inline-block;\n", - " background: var(--xr-background-color);\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-attrs dd {\n", - " grid-column: 2;\n", - " white-space: pre-wrap;\n", - " word-break: break-all;\n", - "}\n", - "\n", - ".xr-icon-database,\n", - ".xr-icon-file-text2,\n", - ".xr-no-icon {\n", - " display: inline-block;\n", - " vertical-align: middle;\n", - " width: 1em;\n", - " height: 1.5em !important;\n", - " stroke-width: 0;\n", - " stroke: currentColor;\n", - " fill: currentColor;\n", - "}\n", - "</style><pre class='xr-text-repr-fallback'><xarray.DataArray (period: 4, time: 5475)> Size: 175kB\n", - "array([[256.56897873, 256.33204916, 256.6078032 , ..., 258.27778118,\n", - " 257.92444362, 258.72658245],\n", - " [256.34414151, 255.9003116 , 257.24846488, ..., 258.4266159 ,\n", - " 258.18310965, 259.22809524],\n", - " [257.29972639, 256.88057295, 258.17260583, ..., 258.73870093,\n", - " 258.79702384, 259.01007664],\n", - " [258.54563373, 257.32674304, 258.74673108, ..., 259.76399892,\n", - " 260.03250936, 259.81183198]])\n", - "Coordinates:\n", - " * time (time) object 44kB 1970-01-01 00:00:00 ... 1984-12-31 00:0...\n", - " period_length (period) int64 32B 5475 5475 5475 5475\n", - " * period (period) object 32B 2000-01-01 00:00:00 ... 2015-01-01 00:...\n", - "Attributes:\n", - " units: K</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'></div><ul class='xr-dim-list'><li><span class='xr-has-index'>period</span>: 4</li><li><span class='xr-has-index'>time</span>: 5475</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-8e8fe06f-9385-421d-9e2b-b9ff1e7ca49b' class='xr-array-in' type='checkbox' checked><label for='section-8e8fe06f-9385-421d-9e2b-b9ff1e7ca49b' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>256.6 256.3 256.6 255.4 255.5 255.5 ... 259.6 259.0 259.8 260.0 259.8</span></div><div class='xr-array-data'><pre>array([[256.56897873, 256.33204916, 256.6078032 , ..., 258.27778118,\n", - " 257.92444362, 258.72658245],\n", - " [256.34414151, 255.9003116 , 257.24846488, ..., 258.4266159 ,\n", - " 258.18310965, 259.22809524],\n", - " [257.29972639, 256.88057295, 258.17260583, ..., 258.73870093,\n", - " 258.79702384, 259.01007664],\n", - " [258.54563373, 257.32674304, 258.74673108, ..., 259.76399892,\n", - " 260.03250936, 259.81183198]])</pre></div></div></li><li class='xr-section-item'><input id='section-000e328c-456b-48ab-b208-0581acce198f' class='xr-section-summary-in' type='checkbox' checked><label for='section-000e328c-456b-48ab-b208-0581acce198f' class='xr-section-summary' >Coordinates: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>1970-01-01 00:00:00 ... 1984-12-...</div><input id='attrs-50251c4c-3774-48d1-b51d-89dc7e91484d' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-50251c4c-3774-48d1-b51d-89dc7e91484d' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-f3e1dba2-2866-4788-ba3c-00ba33a05349' class='xr-var-data-in' type='checkbox'><label for='data-f3e1dba2-2866-4788-ba3c-00ba33a05349' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd>Placeholder time axis</dd></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(1970, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(1970, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(1970, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", - " cftime.DatetimeNoLeap(1984, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(1984, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(1984, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", - " dtype=object)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>period_length</span></div><div class='xr-var-dims'>(period)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>5475 5475 5475 5475</div><input id='attrs-45953484-e935-4b84-9fe7-87b35d9612bd' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-45953484-e935-4b84-9fe7-87b35d9612bd' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d29e899d-9302-4695-bd90-b937dc0f96f4' class='xr-var-data-in' type='checkbox'><label for='data-d29e899d-9302-4695-bd90-b937dc0f96f4' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([5475, 5475, 5475, 5475])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>period</span></div><div class='xr-var-dims'>(period)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2015-01-...</div><input id='attrs-ab8b14f6-f23b-4608-94b3-91d3d1b70714' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-ab8b14f6-f23b-4608-94b3-91d3d1b70714' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-b99b0652-be37-408a-a9fa-2338a37fb563' class='xr-var-data-in' type='checkbox'><label for='data-b99b0652-be37-408a-a9fa-2338a37fb563' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd>Start of the period</dd><dt><span>window :</span></dt><dd>15</dd><dt><span>stride :</span></dt><dd>5</dd><dt><span>freq :</span></dt><dd>YS</dd><dt><span>unequal_lengths :</span></dt><dd>0</dd></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2005, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2010, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2015, 1, 1, 0, 0, 0, 0, has_year_zero=True)],\n", - " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-5d4cc573-7987-4d8d-b745-054c01d43861' class='xr-section-summary-in' type='checkbox' ><label for='section-5d4cc573-7987-4d8d-b745-054c01d43861' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-46ff406a-ee4a-4e96-8f13-da09a9d82172' class='xr-index-data-in' type='checkbox'/><label for='index-46ff406a-ee4a-4e96-8f13-da09a9d82172' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([1970-01-01 00:00:00, 1970-01-02 00:00:00, 1970-01-03 00:00:00,\n", - " 1970-01-04 00:00:00, 1970-01-05 00:00:00, 1970-01-06 00:00:00,\n", - " 1970-01-07 00:00:00, 1970-01-08 00:00:00, 1970-01-09 00:00:00,\n", - " 1970-01-10 00:00:00,\n", - " ...\n", - " 1984-12-22 00:00:00, 1984-12-23 00:00:00, 1984-12-24 00:00:00,\n", - " 1984-12-25 00:00:00, 1984-12-26 00:00:00, 1984-12-27 00:00:00,\n", - " 1984-12-28 00:00:00, 1984-12-29 00:00:00, 1984-12-30 00:00:00,\n", - " 1984-12-31 00:00:00],\n", - " dtype='object', length=5475, calendar='noleap', freq='D'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>period</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-685f83c2-bb64-4398-afc3-2fb2e5c45689' class='xr-index-data-in' type='checkbox'/><label for='index-685f83c2-bb64-4398-afc3-2fb2e5c45689' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2005-01-01 00:00:00, 2010-01-01 00:00:00,\n", - " 2015-01-01 00:00:00],\n", - " dtype='object', length=4, calendar='noleap', freq='5YS-JAN'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-1c637b0f-34b3-4e63-8fdf-e1bdb7a057e4' class='xr-section-summary-in' type='checkbox' checked><label for='section-1c637b0f-34b3-4e63-8fdf-e1bdb7a057e4' class='xr-section-summary' >Attributes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd></dl></div></li></ul></div></div>" - ], - "text/plain": [ - "<xarray.DataArray (period: 4, time: 5475)> Size: 175kB\n", - "array([[256.56897873, 256.33204916, 256.6078032 , ..., 258.27778118,\n", - " 257.92444362, 258.72658245],\n", - " [256.34414151, 255.9003116 , 257.24846488, ..., 258.4266159 ,\n", - " 258.18310965, 259.22809524],\n", - " [257.29972639, 256.88057295, 258.17260583, ..., 258.73870093,\n", - " 258.79702384, 259.01007664],\n", - " [258.54563373, 257.32674304, 258.74673108, ..., 259.76399892,\n", - " 260.03250936, 259.81183198]])\n", - "Coordinates:\n", - " * time (time) object 44kB 1970-01-01 00:00:00 ... 1984-12-31 00:0...\n", - " period_length (period) int64 32B 5475 5475 5475 5475\n", - " * period (period) object 32B 2000-01-01 00:00:00 ... 2015-01-01 00:...\n", - "Attributes:\n", - " units: K" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from xsdba.calendar import stack_periods, unstack_periods\n", "\n", @@ -2591,419 +405,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", - "<defs>\n", - "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", - "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "</symbol>\n", - "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", - "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "</symbol>\n", - "</defs>\n", - "</svg>\n", - "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", - " *\n", - " */\n", - "\n", - ":root {\n", - " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", - " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", - " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", - " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", - " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", - " --xr-background-color: var(--jp-layout-color0, white);\n", - " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", - " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", - "}\n", - "\n", - "html[theme=dark],\n", - "html[data-theme=dark],\n", - "body[data-theme=dark],\n", - "body.vscode-dark {\n", - " --xr-font-color0: rgba(255, 255, 255, 1);\n", - " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", - " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", - " --xr-border-color: #1F1F1F;\n", - " --xr-disabled-color: #515151;\n", - " --xr-background-color: #111111;\n", - " --xr-background-color-row-even: #111111;\n", - " --xr-background-color-row-odd: #313131;\n", - "}\n", - "\n", - ".xr-wrap {\n", - " display: block !important;\n", - " min-width: 300px;\n", - " max-width: 700px;\n", - "}\n", - "\n", - ".xr-text-repr-fallback {\n", - " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", - " display: none;\n", - "}\n", - "\n", - ".xr-header {\n", - " padding-top: 6px;\n", - " padding-bottom: 6px;\n", - " margin-bottom: 4px;\n", - " border-bottom: solid 1px var(--xr-border-color);\n", - "}\n", - "\n", - ".xr-header > div,\n", - ".xr-header > ul {\n", - " display: inline;\n", - " margin-top: 0;\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-obj-type,\n", - ".xr-array-name {\n", - " margin-left: 2px;\n", - " margin-right: 10px;\n", - "}\n", - "\n", - ".xr-obj-type {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-sections {\n", - " padding-left: 0 !important;\n", - " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", - "}\n", - "\n", - ".xr-section-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-section-item input {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-item input + label {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label {\n", - " cursor: pointer;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label:hover {\n", - " color: var(--xr-font-color0);\n", - "}\n", - "\n", - ".xr-section-summary {\n", - " grid-column: 1;\n", - " color: var(--xr-font-color2);\n", - " font-weight: 500;\n", - "}\n", - "\n", - ".xr-section-summary > span {\n", - " display: inline-block;\n", - " padding-left: 0.5em;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-summary-in + label:before {\n", - " display: inline-block;\n", - " content: '►';\n", - " font-size: 11px;\n", - " width: 15px;\n", - " text-align: center;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label:before {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label:before {\n", - " content: '▼';\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label > span {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-summary,\n", - ".xr-section-inline-details {\n", - " padding-top: 4px;\n", - " padding-bottom: 4px;\n", - "}\n", - "\n", - ".xr-section-inline-details {\n", - " grid-column: 2 / -1;\n", - "}\n", - "\n", - ".xr-section-details {\n", - " display: none;\n", - " grid-column: 1 / -1;\n", - " margin-bottom: 5px;\n", - "}\n", - "\n", - ".xr-section-summary-in:checked ~ .xr-section-details {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-array-wrap {\n", - " grid-column: 1 / -1;\n", - " display: grid;\n", - " grid-template-columns: 20px auto;\n", - "}\n", - "\n", - ".xr-array-wrap > label {\n", - " grid-column: 1;\n", - " vertical-align: top;\n", - "}\n", - "\n", - ".xr-preview {\n", - " color: var(--xr-font-color3);\n", - "}\n", - "\n", - ".xr-array-preview,\n", - ".xr-array-data {\n", - " padding: 0 5px !important;\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-array-data,\n", - ".xr-array-in:checked ~ .xr-array-preview {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-array-in:checked ~ .xr-array-data,\n", - ".xr-array-preview {\n", - " display: inline-block;\n", - "}\n", - "\n", - ".xr-dim-list {\n", - " display: inline-block !important;\n", - " list-style: none;\n", - " padding: 0 !important;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list li {\n", - " display: inline-block;\n", - " padding: 0;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list:before {\n", - " content: '(';\n", - "}\n", - "\n", - ".xr-dim-list:after {\n", - " content: ')';\n", - "}\n", - "\n", - ".xr-dim-list li:not(:last-child):after {\n", - " content: ',';\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-has-index {\n", - " font-weight: bold;\n", - "}\n", - "\n", - ".xr-var-list,\n", - ".xr-var-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-var-item > div,\n", - ".xr-var-item label,\n", - ".xr-var-item > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-even);\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-var-item > .xr-var-name:hover span {\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-var-list > li:nth-child(odd) > div,\n", - ".xr-var-list > li:nth-child(odd) > label,\n", - ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-odd);\n", - "}\n", - "\n", - ".xr-var-name {\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-var-dims {\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-var-dtype {\n", - " grid-column: 3;\n", - " text-align: right;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-preview {\n", - " grid-column: 4;\n", - "}\n", - "\n", - ".xr-index-preview {\n", - " grid-column: 2 / 5;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-name,\n", - ".xr-var-dims,\n", - ".xr-var-dtype,\n", - ".xr-preview,\n", - ".xr-attrs dt {\n", - " white-space: nowrap;\n", - " overflow: hidden;\n", - " text-overflow: ellipsis;\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-var-name:hover,\n", - ".xr-var-dims:hover,\n", - ".xr-var-dtype:hover,\n", - ".xr-attrs dt:hover {\n", - " overflow: visible;\n", - " width: auto;\n", - " z-index: 1;\n", - "}\n", - "\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " display: none;\n", - " background-color: var(--xr-background-color) !important;\n", - " padding-bottom: 5px !important;\n", - "}\n", - "\n", - ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data,\n", - ".xr-index-data-in:checked ~ .xr-index-data {\n", - " display: block;\n", - "}\n", - "\n", - ".xr-var-data > table {\n", - " float: right;\n", - "}\n", - "\n", - ".xr-var-name span,\n", - ".xr-var-data,\n", - ".xr-index-name div,\n", - ".xr-index-data,\n", - ".xr-attrs {\n", - " padding-left: 25px !important;\n", - "}\n", - "\n", - ".xr-attrs,\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " grid-column: 1 / -1;\n", - "}\n", - "\n", - "dl.xr-attrs {\n", - " padding: 0;\n", - " margin: 0;\n", - " display: grid;\n", - " grid-template-columns: 125px auto;\n", - "}\n", - "\n", - ".xr-attrs dt,\n", - ".xr-attrs dd {\n", - " padding: 0;\n", - " margin: 0;\n", - " float: left;\n", - " padding-right: 10px;\n", - " width: auto;\n", - "}\n", - "\n", - ".xr-attrs dt {\n", - " font-weight: normal;\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-attrs dt:hover span {\n", - " display: inline-block;\n", - " background: var(--xr-background-color);\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-attrs dd {\n", - " grid-column: 2;\n", - " white-space: pre-wrap;\n", - " word-break: break-all;\n", - "}\n", - "\n", - ".xr-icon-database,\n", - ".xr-icon-file-text2,\n", - ".xr-no-icon {\n", - " display: inline-block;\n", - " vertical-align: middle;\n", - " width: 1em;\n", - " height: 1.5em !important;\n", - " stroke-width: 0;\n", - " stroke: currentColor;\n", - " fill: currentColor;\n", - "}\n", - "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'scen' (time: 10950)> Size: 88kB\n", - "array([255.22055623, 254.25554953, 255.03477622, ..., 257.79550951,\n", - " 258.28040379, 257.54786958])\n", - "Coordinates:\n", - " * time (time) object 88kB 2000-01-01 00:00:00 ... 2029-12-31 00:00:00\n", - "Attributes:\n", - " units: K\n", - " history: [2024-08-02 12:24:53] : Bias-adjusted with QuantileDelt...\n", - " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'scen'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>time</span>: 10950</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-60340295-862d-49da-b085-8b6f9d96e10c' class='xr-array-in' type='checkbox' checked><label for='section-60340295-862d-49da-b085-8b6f9d96e10c' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>255.2 254.3 255.0 253.2 253.6 253.6 ... 256.8 256.9 257.8 258.3 257.5</span></div><div class='xr-array-data'><pre>array([255.22055623, 254.25554953, 255.03477622, ..., 257.79550951,\n", - " 258.28040379, 257.54786958])</pre></div></div></li><li class='xr-section-item'><input id='section-9a5bc7d2-7334-43e5-beeb-3045d2258691' class='xr-section-summary-in' type='checkbox' checked><label for='section-9a5bc7d2-7334-43e5-beeb-3045d2258691' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>2000-01-01 00:00:00 ... 2029-12-...</div><input id='attrs-fba25547-b512-4177-8f78-b20bc193533f' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-fba25547-b512-4177-8f78-b20bc193533f' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-fff99daa-b037-49b7-94a3-0e526983531d' class='xr-var-data-in' type='checkbox'><label for='data-fff99daa-b037-49b7-94a3-0e526983531d' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(2000, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2000, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2000, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", - " cftime.DatetimeNoLeap(2029, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2029, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2029, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", - " dtype=object)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-5baf9182-6e92-4a65-82f0-70367d7d1313' class='xr-section-summary-in' type='checkbox' ><label for='section-5baf9182-6e92-4a65-82f0-70367d7d1313' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-6d063f77-8f21-4833-9626-e2376edd68bf' class='xr-index-data-in' type='checkbox'/><label for='index-6d063f77-8f21-4833-9626-e2376edd68bf' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00,\n", - " 2000-01-04 00:00:00, 2000-01-05 00:00:00, 2000-01-06 00:00:00,\n", - " 2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,\n", - " 2000-01-10 00:00:00,\n", - " ...\n", - " 2029-12-22 00:00:00, 2029-12-23 00:00:00, 2029-12-24 00:00:00,\n", - " 2029-12-25 00:00:00, 2029-12-26 00:00:00, 2029-12-27 00:00:00,\n", - " 2029-12-28 00:00:00, 2029-12-29 00:00:00, 2029-12-30 00:00:00,\n", - " 2029-12-31 00:00:00],\n", - " dtype='object', length=10950, calendar='noleap', freq='D'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-61079d01-7748-4bb2-850e-71a543a53653' class='xr-section-summary-in' type='checkbox' checked><label for='section-61079d01-7748-4bb2-850e-71a543a53653' class='xr-section-summary' >Attributes: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>K</dd><dt><span>history :</span></dt><dd>[2024-08-02 12:24:53] : Bias-adjusted with QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, ) - xsdba version: 0.1.0</dd><dt><span>bias_adjustment :</span></dt><dd>QuantileDeltaMapping(group=Grouper(name='time.dayofyear'), kind='+').adjust(sim, )</dd></dl></div></li></ul></div></div>" - ], - "text/plain": [ - "<xarray.DataArray 'scen' (time: 10950)> Size: 88kB\n", - "array([255.22055623, 254.25554953, 255.03477622, ..., 257.79550951,\n", - " 258.28040379, 257.54786958])\n", - "Coordinates:\n", - " * time (time) object 88kB 2000-01-01 00:00:00 ... 2029-12-31 00:00:00\n", - "Attributes:\n", - " units: K\n", - " history: [2024-08-02 12:24:53] : Bias-adjusted with QuantileDelt...\n", - " bias_adjustment: QuantileDeltaMapping(group=Grouper(name='time.dayofyear..." - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "scen_win = unstack_periods(QDM.adjust(sim_win))\n", "scen_win" @@ -3024,18 +428,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/eridup1/repos/xsdba/src/xsdba/calendar.py:93: FutureWarning: `xclim` function convert_calendar is deprecated in favour of xarray.coding.calendar_ops.convert_calendar or obj.convert_calendar and will be removed in v0.51.0. Please adjust your script.\n", - " warn(\n" - ] - } - ], + "outputs": [], "source": [ "import xsdba\n", "from xsdba.calendar import convert_calendar\n", @@ -3072,497 +467,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n", - "<defs>\n", - "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n", - "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n", - "</symbol>\n", - "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n", - "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n", - "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n", - "</symbol>\n", - "</defs>\n", - "</svg>\n", - "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n", - " *\n", - " */\n", - "\n", - ":root {\n", - " --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n", - " --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n", - " --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n", - " --xr-border-color: var(--jp-border-color2, #e0e0e0);\n", - " --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n", - " --xr-background-color: var(--jp-layout-color0, white);\n", - " --xr-background-color-row-even: var(--jp-layout-color1, white);\n", - " --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n", - "}\n", - "\n", - "html[theme=dark],\n", - "html[data-theme=dark],\n", - "body[data-theme=dark],\n", - "body.vscode-dark {\n", - " --xr-font-color0: rgba(255, 255, 255, 1);\n", - " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", - " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", - " --xr-border-color: #1F1F1F;\n", - " --xr-disabled-color: #515151;\n", - " --xr-background-color: #111111;\n", - " --xr-background-color-row-even: #111111;\n", - " --xr-background-color-row-odd: #313131;\n", - "}\n", - "\n", - ".xr-wrap {\n", - " display: block !important;\n", - " min-width: 300px;\n", - " max-width: 700px;\n", - "}\n", - "\n", - ".xr-text-repr-fallback {\n", - " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", - " display: none;\n", - "}\n", - "\n", - ".xr-header {\n", - " padding-top: 6px;\n", - " padding-bottom: 6px;\n", - " margin-bottom: 4px;\n", - " border-bottom: solid 1px var(--xr-border-color);\n", - "}\n", - "\n", - ".xr-header > div,\n", - ".xr-header > ul {\n", - " display: inline;\n", - " margin-top: 0;\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-obj-type,\n", - ".xr-array-name {\n", - " margin-left: 2px;\n", - " margin-right: 10px;\n", - "}\n", - "\n", - ".xr-obj-type {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-sections {\n", - " padding-left: 0 !important;\n", - " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", - "}\n", - "\n", - ".xr-section-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-section-item input {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-item input + label {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label {\n", - " cursor: pointer;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-item input:enabled + label:hover {\n", - " color: var(--xr-font-color0);\n", - "}\n", - "\n", - ".xr-section-summary {\n", - " grid-column: 1;\n", - " color: var(--xr-font-color2);\n", - " font-weight: 500;\n", - "}\n", - "\n", - ".xr-section-summary > span {\n", - " display: inline-block;\n", - " padding-left: 0.5em;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label {\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-section-summary-in + label:before {\n", - " display: inline-block;\n", - " content: '►';\n", - " font-size: 11px;\n", - " width: 15px;\n", - " text-align: center;\n", - "}\n", - "\n", - ".xr-section-summary-in:disabled + label:before {\n", - " color: var(--xr-disabled-color);\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label:before {\n", - " content: '▼';\n", - "}\n", - "\n", - ".xr-section-summary-in:checked + label > span {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-section-summary,\n", - ".xr-section-inline-details {\n", - " padding-top: 4px;\n", - " padding-bottom: 4px;\n", - "}\n", - "\n", - ".xr-section-inline-details {\n", - " grid-column: 2 / -1;\n", - "}\n", - "\n", - ".xr-section-details {\n", - " display: none;\n", - " grid-column: 1 / -1;\n", - " margin-bottom: 5px;\n", - "}\n", - "\n", - ".xr-section-summary-in:checked ~ .xr-section-details {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-array-wrap {\n", - " grid-column: 1 / -1;\n", - " display: grid;\n", - " grid-template-columns: 20px auto;\n", - "}\n", - "\n", - ".xr-array-wrap > label {\n", - " grid-column: 1;\n", - " vertical-align: top;\n", - "}\n", - "\n", - ".xr-preview {\n", - " color: var(--xr-font-color3);\n", - "}\n", - "\n", - ".xr-array-preview,\n", - ".xr-array-data {\n", - " padding: 0 5px !important;\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-array-data,\n", - ".xr-array-in:checked ~ .xr-array-preview {\n", - " display: none;\n", - "}\n", - "\n", - ".xr-array-in:checked ~ .xr-array-data,\n", - ".xr-array-preview {\n", - " display: inline-block;\n", - "}\n", - "\n", - ".xr-dim-list {\n", - " display: inline-block !important;\n", - " list-style: none;\n", - " padding: 0 !important;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list li {\n", - " display: inline-block;\n", - " padding: 0;\n", - " margin: 0;\n", - "}\n", - "\n", - ".xr-dim-list:before {\n", - " content: '(';\n", - "}\n", - "\n", - ".xr-dim-list:after {\n", - " content: ')';\n", - "}\n", - "\n", - ".xr-dim-list li:not(:last-child):after {\n", - " content: ',';\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-has-index {\n", - " font-weight: bold;\n", - "}\n", - "\n", - ".xr-var-list,\n", - ".xr-var-item {\n", - " display: contents;\n", - "}\n", - "\n", - ".xr-var-item > div,\n", - ".xr-var-item label,\n", - ".xr-var-item > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-even);\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".xr-var-item > .xr-var-name:hover span {\n", - " padding-right: 5px;\n", - "}\n", - "\n", - ".xr-var-list > li:nth-child(odd) > div,\n", - ".xr-var-list > li:nth-child(odd) > label,\n", - ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", - " background-color: var(--xr-background-color-row-odd);\n", - "}\n", - "\n", - ".xr-var-name {\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-var-dims {\n", - " grid-column: 2;\n", - "}\n", - "\n", - ".xr-var-dtype {\n", - " grid-column: 3;\n", - " text-align: right;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-preview {\n", - " grid-column: 4;\n", - "}\n", - "\n", - ".xr-index-preview {\n", - " grid-column: 2 / 5;\n", - " color: var(--xr-font-color2);\n", - "}\n", - "\n", - ".xr-var-name,\n", - ".xr-var-dims,\n", - ".xr-var-dtype,\n", - ".xr-preview,\n", - ".xr-attrs dt {\n", - " white-space: nowrap;\n", - " overflow: hidden;\n", - " text-overflow: ellipsis;\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-var-name:hover,\n", - ".xr-var-dims:hover,\n", - ".xr-var-dtype:hover,\n", - ".xr-attrs dt:hover {\n", - " overflow: visible;\n", - " width: auto;\n", - " z-index: 1;\n", - "}\n", - "\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " display: none;\n", - " background-color: var(--xr-background-color) !important;\n", - " padding-bottom: 5px !important;\n", - "}\n", - "\n", - ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data,\n", - ".xr-index-data-in:checked ~ .xr-index-data {\n", - " display: block;\n", - "}\n", - "\n", - ".xr-var-data > table {\n", - " float: right;\n", - "}\n", - "\n", - ".xr-var-name span,\n", - ".xr-var-data,\n", - ".xr-index-name div,\n", - ".xr-index-data,\n", - ".xr-attrs {\n", - " padding-left: 25px !important;\n", - "}\n", - "\n", - ".xr-attrs,\n", - ".xr-var-attrs,\n", - ".xr-var-data,\n", - ".xr-index-data {\n", - " grid-column: 1 / -1;\n", - "}\n", - "\n", - "dl.xr-attrs {\n", - " padding: 0;\n", - " margin: 0;\n", - " display: grid;\n", - " grid-template-columns: 125px auto;\n", - "}\n", - "\n", - ".xr-attrs dt,\n", - ".xr-attrs dd {\n", - " padding: 0;\n", - " margin: 0;\n", - " float: left;\n", - " padding-right: 10px;\n", - " width: auto;\n", - "}\n", - "\n", - ".xr-attrs dt {\n", - " font-weight: normal;\n", - " grid-column: 1;\n", - "}\n", - "\n", - ".xr-attrs dt:hover span {\n", - " display: inline-block;\n", - " background: var(--xr-background-color);\n", - " padding-right: 10px;\n", - "}\n", - "\n", - ".xr-attrs dd {\n", - " grid-column: 2;\n", - " white-space: pre-wrap;\n", - " word-break: break-all;\n", - "}\n", - "\n", - ".xr-icon-database,\n", - ".xr-icon-file-text2,\n", - ".xr-no-icon {\n", - " display: inline-block;\n", - " vertical-align: middle;\n", - " width: 1em;\n", - " height: 1.5em !important;\n", - " stroke-width: 0;\n", - " stroke: currentColor;\n", - " fill: currentColor;\n", - "}\n", - "</style><pre class='xr-text-repr-fallback'><xarray.DataArray 'multivariate' (multivar: 2, time: 55115, location: 3)> Size: 1MB\n", - "array([[[ 2.4951424e-01, -8.2575518e-01, 2.4951424e-01],\n", - " [ 2.6499709e-01, -4.1112199e-01, 2.6499709e-01],\n", - " [-1.9535354e-01, -2.7694762e+00, -1.9535354e-01],\n", - " ...,\n", - " [ 3.2132244e+00, -2.2834629e-01, 3.2132244e+00],\n", - " [ 1.6713389e+00, 1.7489431e+00, 1.6713389e+00],\n", - " [ 7.5195450e-01, 2.4332018e+00, 7.5195450e-01]],\n", - "\n", - " [[ 2.7815024e+02, 2.7754898e+02, 2.7815024e+02],\n", - " [ 2.8335815e+02, 2.7690921e+02, 2.8335815e+02],\n", - " [ 2.8153192e+02, 2.7668036e+02, 2.8153192e+02],\n", - " ...,\n", - " [ 2.8901334e+02, 2.8192789e+02, 2.8901334e+02],\n", - " [ 2.8510699e+02, 2.8142294e+02, 2.8510699e+02],\n", - " [ 2.8404471e+02, 2.8160156e+02, 2.8404471e+02]]], dtype=float32)\n", - "Coordinates:\n", - " * time (time) object 441kB 1950-01-01 00:00:00 ... 2100-12-31 00:00:00\n", - " lat (location) float64 24B 49.1 67.8 48.8\n", - " lon (location) float64 24B -123.1 -115.1 -78.2\n", - " * location (location) <U9 108B 'Vancouver' 'Kugluktuk' 'Amos'\n", - " * multivar (multivar) <U6 48B 'pr' 'tasmax'\n", - "Attributes: (12/34)\n", - " institution: CanESM2\n", - " institute_id: CCCma\n", - " experiment_id: rcp85\n", - " source: CanESM2 2010 atmosphere: CanAM4 (AGCM15i...\n", - " model_id: CanESM2\n", - " forcing: GHG,Oz,SA,BC,OC,LU,Sl (GHG includes CO2,...\n", - " ... ...\n", - " modeling_realm: atmos\n", - " realization: 1\n", - " cmor_version: 2.5.4\n", - " DODS_EXTRA.Unlimited_Dimension: time\n", - " description: Extracted from CMIP5 CanESM2 hist+rcp85 ...\n", - " units: </pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'multivariate'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>multivar</span>: 2</li><li><span class='xr-has-index'>time</span>: 55115</li><li><span class='xr-has-index'>location</span>: 3</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-5c32d9ed-262a-45bf-a4f8-ad6f6a5c4d5d' class='xr-array-in' type='checkbox' checked><label for='section-5c32d9ed-262a-45bf-a4f8-ad6f6a5c4d5d' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>0.2495 -0.8258 0.2495 0.265 -0.4111 ... 281.4 285.1 284.0 281.6 284.0</span></div><div class='xr-array-data'><pre>array([[[ 2.4951424e-01, -8.2575518e-01, 2.4951424e-01],\n", - " [ 2.6499709e-01, -4.1112199e-01, 2.6499709e-01],\n", - " [-1.9535354e-01, -2.7694762e+00, -1.9535354e-01],\n", - " ...,\n", - " [ 3.2132244e+00, -2.2834629e-01, 3.2132244e+00],\n", - " [ 1.6713389e+00, 1.7489431e+00, 1.6713389e+00],\n", - " [ 7.5195450e-01, 2.4332018e+00, 7.5195450e-01]],\n", - "\n", - " [[ 2.7815024e+02, 2.7754898e+02, 2.7815024e+02],\n", - " [ 2.8335815e+02, 2.7690921e+02, 2.8335815e+02],\n", - " [ 2.8153192e+02, 2.7668036e+02, 2.8153192e+02],\n", - " ...,\n", - " [ 2.8901334e+02, 2.8192789e+02, 2.8901334e+02],\n", - " [ 2.8510699e+02, 2.8142294e+02, 2.8510699e+02],\n", - " [ 2.8404471e+02, 2.8160156e+02, 2.8404471e+02]]], dtype=float32)</pre></div></div></li><li class='xr-section-item'><input id='section-d5607408-8741-4029-bdc2-935b2c7f21e3' class='xr-section-summary-in' type='checkbox' checked><label for='section-d5607408-8741-4029-bdc2-935b2c7f21e3' class='xr-section-summary' >Coordinates: <span>(5)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>time</span></div><div class='xr-var-dims'>(time)</div><div class='xr-var-dtype'>object</div><div class='xr-var-preview xr-preview'>1950-01-01 00:00:00 ... 2100-12-...</div><input id='attrs-d1c00394-5f6b-4567-9f22-cc9bbe6123b6' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-d1c00394-5f6b-4567-9f22-cc9bbe6123b6' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-f66c8f12-8666-4855-952d-78e664e47e1e' class='xr-var-data-in' type='checkbox'><label for='data-f66c8f12-8666-4855-952d-78e664e47e1e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>bounds :</span></dt><dd>time_bnds</dd><dt><span>axis :</span></dt><dd>T</dd><dt><span>long_name :</span></dt><dd>time</dd><dt><span>standard_name :</span></dt><dd>time</dd></dl></div><div class='xr-var-data'><pre>array([cftime.DatetimeNoLeap(1950, 1, 1, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(1950, 1, 2, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(1950, 1, 3, 0, 0, 0, 0, has_year_zero=True), ...,\n", - " cftime.DatetimeNoLeap(2100, 12, 29, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2100, 12, 30, 0, 0, 0, 0, has_year_zero=True),\n", - " cftime.DatetimeNoLeap(2100, 12, 31, 0, 0, 0, 0, has_year_zero=True)],\n", - " dtype=object)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lat</span></div><div class='xr-var-dims'>(location)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>49.1 67.8 48.8</div><input id='attrs-30626c05-e64c-4b93-a331-97010f241228' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-30626c05-e64c-4b93-a331-97010f241228' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-ce52db73-4f77-4e54-a2a9-5202d3b98401' class='xr-var-data-in' type='checkbox'><label for='data-ce52db73-4f77-4e54-a2a9-5202d3b98401' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>degrees_north</dd><dt><span>long_name :</span></dt><dd>latitude</dd><dt><span>axis :</span></dt><dd>Y</dd><dt><span>standard_name :</span></dt><dd>latitude</dd></dl></div><div class='xr-var-data'><pre>array([49.1, 67.8, 48.8])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lon</span></div><div class='xr-var-dims'>(location)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>-123.1 -115.1 -78.2</div><input id='attrs-2da13dd2-e35a-4a30-84fb-406de8f30bc8' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-2da13dd2-e35a-4a30-84fb-406de8f30bc8' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-acd1646e-dc5d-41e6-a14e-a2fedd1b00e0' class='xr-var-data-in' type='checkbox'><label for='data-acd1646e-dc5d-41e6-a14e-a2fedd1b00e0' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>units :</span></dt><dd>degrees_east</dd><dt><span>long_name :</span></dt><dd>longitude</dd><dt><span>axis :</span></dt><dd>X</dd><dt><span>standard_name :</span></dt><dd>longitude</dd></dl></div><div class='xr-var-data'><pre>array([-123.1, -115.1, -78.2])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>location</span></div><div class='xr-var-dims'>(location)</div><div class='xr-var-dtype'><U9</div><div class='xr-var-preview xr-preview'>'Vancouver' 'Kugluktuk' 'Amos'</div><input id='attrs-8e7c09ce-6850-4022-9282-8e60b116e457' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-8e7c09ce-6850-4022-9282-8e60b116e457' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5c96e41c-9b7b-47e1-8769-7bf42a090536' class='xr-var-data-in' type='checkbox'><label for='data-5c96e41c-9b7b-47e1-8769-7bf42a090536' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array(['Vancouver', 'Kugluktuk', 'Amos'], dtype='<U9')</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>multivar</span></div><div class='xr-var-dims'>(multivar)</div><div class='xr-var-dtype'><U6</div><div class='xr-var-preview xr-preview'>'pr' 'tasmax'</div><input id='attrs-5e12675f-a4ff-4854-9116-25b3313d392b' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-5e12675f-a4ff-4854-9116-25b3313d392b' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-ee543cae-9f13-4745-9f8f-63296fa46688' class='xr-var-data-in' type='checkbox'><label for='data-ee543cae-9f13-4745-9f8f-63296fa46688' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>_history :</span></dt><dd>["[2024-08-02 12:24:54] pr: jitter(x=pr, lower='0.1 mm/d', minimum='0 mm/d') - xsdba version: 0.1.0\\n[2024-08-02 12:24:54] pr: to_additive_space(data=pr, lower_bound='0 mm/d', trans='log') - xsdba version: 0.1.0", "2011-04-14T00:21:01Z altered by CMOR: Treated scalar dimension: 'height'. 2011-04-14T00:21:01Z altered by CMOR: replaced missing value flag (1e+38) with standard missing value (1e+20)."]</dd><dt><span>_sdba_transform :</span></dt><dd>['log', None]</dd><dt><span>_sdba_transform_lower :</span></dt><dd>[array(0.), None]</dd><dt><span>_sdba_transform_units :</span></dt><dd>[<Unit('millimeter / day')>, None]</dd><dt><span>_units :</span></dt><dd>['', 'K']</dd><dt><span>_standard_name :</span></dt><dd>[None, 'air_temperature']</dd><dt><span>_long_name :</span></dt><dd>[None, 'Daily Maximum Near-Surface Air Temperature']</dd><dt><span>_original_name :</span></dt><dd>[None, 'STMX']</dd><dt><span>_cell_methods :</span></dt><dd>[None, 'time: maximum (interval: 15 minutes)']</dd><dt><span>_cell_measures :</span></dt><dd>[None, 'area: areacella']</dd><dt><span>_associated_files :</span></dt><dd>[None, 'baseURL: http://cmip-pcmdi.llnl.gov/CMIP5/dataLocation gridspecFile: gridspec_atmos_fx_CanESM2_historical_r0i0p0.nc areacella: areacella_fx_CanESM2_historical_r0i0p0.nc']</dd><dt><span>is_variables :</span></dt><dd>True</dd></dl></div><div class='xr-var-data'><pre>array(['pr', 'tasmax'], dtype='<U6')</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-709e0efc-4b96-4094-b023-d43c3a94246c' class='xr-section-summary-in' type='checkbox' ><label for='section-709e0efc-4b96-4094-b023-d43c3a94246c' class='xr-section-summary' >Indexes: <span>(3)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>time</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-f169ca18-0c79-49b8-a1ef-d36d452cbe61' class='xr-index-data-in' type='checkbox'/><label for='index-f169ca18-0c79-49b8-a1ef-d36d452cbe61' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(CFTimeIndex([1950-01-01 00:00:00, 1950-01-02 00:00:00, 1950-01-03 00:00:00,\n", - " 1950-01-04 00:00:00, 1950-01-05 00:00:00, 1950-01-06 00:00:00,\n", - " 1950-01-07 00:00:00, 1950-01-08 00:00:00, 1950-01-09 00:00:00,\n", - " 1950-01-10 00:00:00,\n", - " ...\n", - " 2100-12-22 00:00:00, 2100-12-23 00:00:00, 2100-12-24 00:00:00,\n", - " 2100-12-25 00:00:00, 2100-12-26 00:00:00, 2100-12-27 00:00:00,\n", - " 2100-12-28 00:00:00, 2100-12-29 00:00:00, 2100-12-30 00:00:00,\n", - " 2100-12-31 00:00:00],\n", - " dtype='object', length=55115, calendar='noleap', freq='D'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>location</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-ae6d569a-7f14-49e9-a34a-5c18cbc791a3' class='xr-index-data-in' type='checkbox'/><label for='index-ae6d569a-7f14-49e9-a34a-5c18cbc791a3' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index(['Vancouver', 'Kugluktuk', 'Amos'], dtype='object', name='location'))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>multivar</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-f989c82a-e23e-4bba-8249-8f0dfd03004a' class='xr-index-data-in' type='checkbox'/><label for='index-f989c82a-e23e-4bba-8249-8f0dfd03004a' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index(['pr', 'tasmax'], dtype='object', name='multivar'))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-b810120c-688a-4634-a46a-1c5b2cac83a5' class='xr-section-summary-in' type='checkbox' ><label for='section-b810120c-688a-4634-a46a-1c5b2cac83a5' class='xr-section-summary' >Attributes: <span>(34)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>institution :</span></dt><dd>CanESM2</dd><dt><span>institute_id :</span></dt><dd>CCCma</dd><dt><span>experiment_id :</span></dt><dd>rcp85</dd><dt><span>source :</span></dt><dd>CanESM2 2010 atmosphere: CanAM4 (AGCM15i, T63L35) ocean: CanOM4 (OGCM4.0, 256x192L40) and CMOC1.2 sea ice: CanSIM1 (Cavitating Fluid, T63 Gaussian Grid) land: CLASS2.7 and CTEM1</dd><dt><span>model_id :</span></dt><dd>CanESM2</dd><dt><span>forcing :</span></dt><dd>GHG,Oz,SA,BC,OC,LU,Sl (GHG includes CO2,CH4,N2O,CFC11,effective CFC12. Sl is the repeat of the 23rd solar cycle, years 1997-2008, after year 2008.)</dd><dt><span>parent_experiment_id :</span></dt><dd>historical</dd><dt><span>parent_experiment_rip :</span></dt><dd>r1i1p1</dd><dt><span>branch_time :</span></dt><dd>56940.0</dd><dt><span>contact :</span></dt><dd>cccma_info@ec.gc.ca</dd><dt><span>references :</span></dt><dd>http://www.cccma.ec.gc.ca/models</dd><dt><span>initialization_method :</span></dt><dd>1</dd><dt><span>physics_version :</span></dt><dd>1</dd><dt><span>tracking_id :</span></dt><dd>17560481-e4c5-43c9-bc3f-950732f21588</dd><dt><span>branch_time_YMDH :</span></dt><dd>2006:01:01:00</dd><dt><span>CCCma_runid :</span></dt><dd>IDR</dd><dt><span>CCCma_parent_runid :</span></dt><dd>IGM</dd><dt><span>CCCma_data_licence :</span></dt><dd>1) GRANT OF LICENCE - The Government of Canada (Environment Canada) is the \n", - "owner of all intellectual property rights (including copyright) that may exist in this Data \n", - "product. You (as "The Licensee") are hereby granted a non-exclusive, non-assignable, \n", - "non-transferable unrestricted licence to use this data product for any purpose including \n", - "the right to share these data with others and to make value-added and derivative \n", - "products from it. This licence is not a sale of any or all of the owner's rights.\n", - "2) NO WARRANTY - This Data product is provided "as-is"; it has not been designed or \n", - "prepared to meet the Licensee's particular requirements. Environment Canada makes no \n", - "warranty, either express or implied, including but not limited to, warranties of \n", - "merchantability and fitness for a particular purpose. In no event will Environment Canada \n", - "be liable for any indirect, special, consequential or other damages attributed to the \n", - "Licensee's use of the Data product.</dd><dt><span>product :</span></dt><dd>output</dd><dt><span>experiment :</span></dt><dd>RCP8.5</dd><dt><span>frequency :</span></dt><dd>day</dd><dt><span>creation_date :</span></dt><dd>2011-04-10T11:24:15Z</dd><dt><span>history :</span></dt><dd>2021-04-23T12:00:00: Extraction of timeseries.2011-04-10T11:24:15Z CMOR rewrote data to comply with CF standards and CMIP5 requirements.</dd><dt><span>Conventions :</span></dt><dd>CF-1.4</dd><dt><span>project_id :</span></dt><dd>CMIP5</dd><dt><span>table_id :</span></dt><dd>Table day (28 March 2011) f9d6cfec5981bb8be1801b35a81002f0</dd><dt><span>title :</span></dt><dd>Test dataset for xclim.sdba - model data</dd><dt><span>parent_experiment :</span></dt><dd>historical</dd><dt><span>modeling_realm :</span></dt><dd>atmos</dd><dt><span>realization :</span></dt><dd>1</dd><dt><span>cmor_version :</span></dt><dd>2.5.4</dd><dt><span>DODS_EXTRA.Unlimited_Dimension :</span></dt><dd>time</dd><dt><span>description :</span></dt><dd>Extracted from CMIP5 CanESM2 hist+rcp85 r1i1p1 at a few locations. Projection starts in 2006.</dd><dt><span>units :</span></dt><dd></dd></dl></div></li></ul></div></div>" - ], - "text/plain": [ - "<xarray.DataArray 'multivariate' (multivar: 2, time: 55115, location: 3)> Size: 1MB\n", - "array([[[ 2.4951424e-01, -8.2575518e-01, 2.4951424e-01],\n", - " [ 2.6499709e-01, -4.1112199e-01, 2.6499709e-01],\n", - " [-1.9535354e-01, -2.7694762e+00, -1.9535354e-01],\n", - " ...,\n", - " [ 3.2132244e+00, -2.2834629e-01, 3.2132244e+00],\n", - " [ 1.6713389e+00, 1.7489431e+00, 1.6713389e+00],\n", - " [ 7.5195450e-01, 2.4332018e+00, 7.5195450e-01]],\n", - "\n", - " [[ 2.7815024e+02, 2.7754898e+02, 2.7815024e+02],\n", - " [ 2.8335815e+02, 2.7690921e+02, 2.8335815e+02],\n", - " [ 2.8153192e+02, 2.7668036e+02, 2.8153192e+02],\n", - " ...,\n", - " [ 2.8901334e+02, 2.8192789e+02, 2.8901334e+02],\n", - " [ 2.8510699e+02, 2.8142294e+02, 2.8510699e+02],\n", - " [ 2.8404471e+02, 2.8160156e+02, 2.8404471e+02]]], dtype=float32)\n", - "Coordinates:\n", - " * time (time) object 441kB 1950-01-01 00:00:00 ... 2100-12-31 00:00:00\n", - " lat (location) float64 24B 49.1 67.8 48.8\n", - " lon (location) float64 24B -123.1 -115.1 -78.2\n", - " * location (location) <U9 108B 'Vancouver' 'Kugluktuk' 'Amos'\n", - " * multivar (multivar) <U6 48B 'pr' 'tasmax'\n", - "Attributes: (12/34)\n", - " institution: CanESM2\n", - " institute_id: CCCma\n", - " experiment_id: rcp85\n", - " source: CanESM2 2010 atmosphere: CanAM4 (AGCM15i...\n", - " model_id: CanESM2\n", - " forcing: GHG,Oz,SA,BC,OC,LU,Sl (GHG includes CO2,...\n", - " ... ...\n", - " modeling_realm: atmos\n", - " realization: 1\n", - " cmor_version: 2.5.4\n", - " DODS_EXTRA.Unlimited_Dimension: time\n", - " description: Extracted from CMIP5 CanESM2 hist+rcp85 ...\n", - " units: " - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "dref_as = dref.assign(\n", " pr=xsdba.processing.to_additive_space(\n", @@ -3596,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3609,7 +516,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3632,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3645,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3670,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3681,20 +588,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1200x400 with 2 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# gather data together for plotting\n", "dsl = [ds.assign_coords({\"data_type\":lab}) for ds, lab in zip([dref,dsim,dscen], [\"obs\", \"raw\", \"scen\"])]\n", @@ -3722,7 +618,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3758,30 +654,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7fb6fa624250>" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1100x500 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -3816,30 +691,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7fb6d998bed0>" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1100x500 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# adapt_freq directly in the training step\n", "group = xsdba.Grouper(\"time.dayofyear\", window=31)\n", @@ -3875,20 +729,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1500x500 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from matplotlib import pyplot as plt\n", "\n", @@ -3925,30 +768,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-2.5, 2.5)" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 500x300 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# calculate the mean warm Spell Length Distribution\n", "sim_prop = xsdba.properties.spell_length_distribution(\n", @@ -3987,20 +809,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 875.125x600 with 4 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# calculate the mean warm Spell Length Distribution\n", "sim_prop, scen_prop, ref_prop = [xsdba.properties.spell_length_distribution(\n", diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index 28d5346..393a680 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -773,7 +773,6 @@ def npdf_transform(ds: xr.Dataset, **kwargs) -> xr.Dataset: ) -# TODO: incorporate xclim.stats def _fit_on_cluster(data, thresh, dist, cluster_thresh): """Extract clusters on 1D data and fit "dist" on the maximums.""" _, _, _, maximums = u.get_clusters_1d(data, thresh, cluster_thresh) diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 297d286..a9a4787 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -60,8 +60,6 @@ "Scaling", ] -# FIXME: `xsdba.utils.extrapolate_qm` mentioned in docstrings, but doesn't exist in `xclim` or `xsdba` - class BaseAdjustment(ParametrizableWithDataset): """Base class for adjustment objects. @@ -80,7 +78,7 @@ def __init__(self, *args, _trained=False, **kwargs): super().__init__(*args, **kwargs) else: raise ValueError( - "As of xclim 0.29, Adjustment object should be initialized through their `train` or `adjust` methods." + "Adjustment object should be initialized through their `train` or `adjust` methods." ) @classmethod @@ -410,7 +408,7 @@ class EmpiricalQuantileMapping(TrainAdjust): interp : {'nearest', 'linear', 'cubic'} The interpolation method to use when interpolating the adjustment factors. Defaults to "nearest". extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`xsdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. Defaults to "constant". References ---------- @@ -509,7 +507,7 @@ class DetrendedQuantileMapping(TrainAdjust): The method to use when detrending. If an int is passed, it is understood as a PolyDetrend (polynomial detrending) degree. Defaults to 1 (linear detrending). extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`xsdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. Defaults to "constant". References ---------- @@ -614,7 +612,7 @@ class QuantileDeltaMapping(EmpiricalQuantileMapping): interp : {'nearest', 'linear', 'cubic'} The interpolation method to use when interpolating the adjustment factors. Defaults to "nearest". extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`xsdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. Defaults to "constant". Extra diagnostics ----------------- @@ -670,7 +668,7 @@ class ExtremeValues(TrainAdjust): interp : {'nearest', 'linear', 'cubic'} The interpolation method to use when interpolating the adjustment factors. Defaults to "linear". extrapolation : {'constant', 'nan'} - The type of extrapolation to use. See :py:func:`~xsdba.utils.extrapolate_qm` for details. Defaults to "constant". + The type of extrapolation to use. Defaults to "constant". frac : float Fraction where the cutoff happens between the original scen and the corrected one. See Notes, ]0, 1]. Defaults to 0.25. @@ -779,6 +777,7 @@ def _adjust( interp: str = "linear", extrapolation: str = "constant", ): + # TODO: `extrapolate_qm` doesn't exist anymore, is this cheat still relevant? # Quantiles coord : cheat and assign 0 - 1, so we can use `extrapolate_qm`. ds = self.ds.assign( quantiles=(np.arange(self.ds.quantiles.size) + 1) diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 2459ef9..9f4e5de 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -83,7 +83,7 @@ def __repr__(self) -> str: class ParametrizableWithDataset(Parametrizable): """Parametrizable class that also has a `ds` attribute storing a dataset.""" - _attribute = "_xclim_parameters" + _attribute = "_xsdba_parameters" @classmethod def from_dataset(cls, ds: xr.Dataset): @@ -220,11 +220,11 @@ def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: Base frequency. is_start_anchored : bool Whether coordinates of this frequency should correspond to the beginning of the period (`True`) - or its end (`False`). Can only be False when base is Y, Q or M; in other words, xclim assumes frequencies finer + or its end (`False`). Can only be False when base is Y, Q or M; in other words, xsdba assumes frequencies finer than monthly are all start-anchored. anchor : str, optional Anchor date for bases Y or Q. As xarray doesn't support "W", - neither does xclim (anchor information is lost when given). + neither does xsdba (anchor information is lost when given). """ # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) offset = pd.tseries.frequencies.to_offset(freq) diff --git a/src/xsdba/calendar.py b/src/xsdba/calendar.py index c88803f..985be14 100644 --- a/src/xsdba/calendar.py +++ b/src/xsdba/calendar.py @@ -91,7 +91,7 @@ def _get_usecf_and_warn(calendar: str, xcfunc: str, xrfunc: str): use_cftime = None msg = "" warn( - f"`xclim` function {xcfunc} is deprecated in favour of {xrfunc} and will be removed in v0.51.0. Please adjust your script{msg}.", + f"`xsdba` function {xcfunc} is deprecated in favour of {xrfunc} and will be removed in v0.51.0. Please adjust your script{msg}.", FutureWarning, ) return calendar, use_cftime @@ -325,10 +325,9 @@ def convert_doy( def convert_calendar( source: xr.DataArray | xr.Dataset, - target: xr.DataArray | str, + target: str, align_on: str | None = None, missing: Any | None = None, - doy: bool | str = False, dim: str = "time", ) -> DataType: """Deprecated : use :py:meth:`xarray.Dataset.convert_calendar` or :py:meth:`xarray.DataArray.convert_calendar` @@ -336,16 +335,6 @@ def convert_calendar( Convert a DataArray/Dataset to another calendar using the specified method. """ - if isinstance(target, xr.DataArray): - raise NotImplementedError( - "In `xclim` v0.50.0, `convert_calendar` is a direct copy of `xarray.coding.calendar_ops.convert_calendar`. " - "To retrieve the previous behaviour with target as a DataArray, convert the source first then reindex to the target." - ) - if doy is not False: - raise NotImplementedError( - "In `xclim` v0.50.0, `convert_calendar` is a direct copy of `xarray.coding.calendar_ops.convert_calendar`. " - "To retrieve the previous behaviour of doy=True, do convert_doy(obj, target_cal).convert_cal(target_cal)." - ) target, _usecf = _get_usecf_and_warn( target, "convert_calendar", @@ -356,6 +345,14 @@ def convert_calendar( ) +# TODO: Let's not keep this very contextual error message, but maybe put the suggestion in a tutorial somewhere +# if doy is not False: +# raise NotImplementedError( +# "In `xsdba` v0.50.0, `convert_calendar` is a direct copy of `xarray.coding.calendar_ops.convert_calendar`. " +# "To retrieve the previous behaviour of doy=True, do convert_doy(obj, target_cal).convert_cal(target_cal)." +# ) + + def interp_calendar( source: xr.DataArray | xr.Dataset, target: xr.DataArray, @@ -593,11 +590,11 @@ def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: Base frequency. is_start_anchored : bool Whether coordinates of this frequency should correspond to the beginning of the period (`True`) - or its end (`False`). Can only be False when base is Y, Q or M; in other words, xclim assumes frequencies finer + or its end (`False`). Can only be False when base is Y, Q or M; in other words, xsdba assumes frequencies finer than monthly are all start-anchored. anchor : str, optional Anchor date for bases Y or Q. As xarray doesn't support "W", - neither does xclim (anchor information is lost when given). + neither does xsdba (anchor information is lost when given). """ # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) @@ -887,7 +884,7 @@ def time_bnds( # noqa: C901 Notes ----- - xclim assumes that indexes for greater-than-day frequencies are "floored" down to a daily resolution. + xsdba assumes that indexes for greater-than-day frequencies are "floored" down to a daily resolution. For example, the coordinate "2000-01-31 00:00:00" with a "ME" frequency is assumed to mean a period going from "2000-01-01 00:00:00" to "2000-01-31 23:59:59.999999". diff --git a/src/xsdba/datachecks.py b/src/xsdba/datachecks.py index 9269046..0de675a 100644 --- a/src/xsdba/datachecks.py +++ b/src/xsdba/datachecks.py @@ -45,7 +45,7 @@ def check_freq(var: xr.DataArray, freq: str | Sequence[str], strict: bool = True if v_freq is None: raise ValidationError( "Unable to infer the frequency of the time series. " - "To mute this, set xclim's option data_validation='log'." + "To mute this, set xsdba's option data_validation='log'." ) v_base = parse_offset(v_freq)[1] if v_base not in exp_base or ( @@ -53,7 +53,7 @@ def check_freq(var: xr.DataArray, freq: str | Sequence[str], strict: bool = True ): raise ValidationError( f"Frequency of time series not {'strictly' if strict else ''} in {freq}. " - "To mute this, set xclim's option data_validation='log'." + "To mute this, set xsdba's option data_validation='log'." ) @@ -88,12 +88,12 @@ def check_common_time(inputs: Sequence[xr.DataArray]): if None in freqs: raise ValidationError( "Unable to infer the frequency of the time series. " - "To mute this, set xclim's option data_validation='log'." + "To mute this, set xsdba's option data_validation='log'." ) if len(set(freqs)) != 1: raise ValidationError( f"Inputs have different frequencies. Got : {freqs}." - "To mute this, set xclim's option data_validation='log'." + "To mute this, set xsdba's option data_validation='log'." ) # Check if anchor is the same @@ -106,7 +106,7 @@ def check_common_time(inputs: Sequence[xr.DataArray]): raise ValidationError( f"All inputs have the same frequency ({freq}), but they are not anchored on the same minutes (got {outs}). " f"xarray's alignment would silently fail. You can try to fix this with `da.resample('{freq}').mean()`." - "To mute this, set xclim's option data_validation='log'." + "To mute this, set xsdba's option data_validation='log'." ) diff --git a/src/xsdba/detrending.py b/src/xsdba/detrending.py index 426c3cd..9615903 100644 --- a/src/xsdba/detrending.py +++ b/src/xsdba/detrending.py @@ -39,7 +39,7 @@ def __init__(self, *, group: Grouper | str = "time", kind: str = "+", **kwargs): Parameters ---------- group : Union[str, Grouper] - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. The fit is performed along the group's main dim. kind : {'*', '+'} The way the trend is removed or added, either additive or multiplicative. @@ -154,7 +154,7 @@ class PolyDetrend(BaseDetrend): Attributes ---------- group : Union[str, Grouper] - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. The fit is performed along the group's main dim. kind : {'*', '+'} The way the trend is removed or added, either additive or multiplicative. @@ -203,7 +203,7 @@ class LoessDetrend(BaseDetrend): Attributes ---------- group : str or Grouper - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. The fit is performed along the group's main dim. kind : {'*', '+'} The way the trend is removed or added, either additive or multiplicative. @@ -284,7 +284,7 @@ class RollingMeanDetrend(BaseDetrend): Attributes ---------- group : str or Grouper - The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + The grouping information. See :py:class:`xsdba.base.Grouper` for details. The fit is performed along the group's main dim. kind : {'*', '+'} The way the trend is removed or added, either additive or multiplicative. diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 5d58610..46b35dd 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -195,7 +195,8 @@ def _match_value(self, value): def parse_doc(doc: str) -> dict[str, str]: """Crude regex parsing reading an indice docstring and extracting information needed in indicator construction. - The appropriate docstring syntax is detailed in :ref:`notebooks/extendxclim:Defining new indices`. + # TODO: Add such a notebook? The focus is not on the class Indicator here + The appropriate docstring syntax is detailed in :ref:`notebooks/extendxsdba:Defining new indices`. Parameters ---------- @@ -405,7 +406,7 @@ def update_history( ) -> str: r"""Return a history string with the timestamped message and the combination of the history of all inputs. - The new history entry is formatted as "[<timestamp>] <new_name>: <hist_str> - xclim version: <xclim.__version__>." + The new history entry is formatted as "[<timestamp>] <new_name>: <hist_str> - xsdba version: <xsdba.__version__>." Parameters ---------- @@ -470,7 +471,7 @@ def _call_and_add_history(*args, **kwargs): if not isinstance(out, (xr.DataArray, xr.Dataset)): raise TypeError( - f"Decorated `update_xclim_history` received a non-xarray output from {func.__name__}." + f"Decorated `update_xsdba_history` received a non-xarray output from {func.__name__}." ) da_list = [arg for arg in args if isinstance(arg, xr.DataArray)] diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py index dbca486..fd376ed 100644 --- a/src/xsdba/indicator.py +++ b/src/xsdba/indicator.py @@ -46,8 +46,8 @@ base: <base indicator class> # Defaults to module-wide base class # If the name startswith a '.', the base class is taken from the current module # (thus an indicator declared _above_). - # Available classes are listed in `xclim.core.indicator.registry` and - # `xclim.core.indicator.base_registry`. + # Available classes are listed in `xsdba.indicator.registry` and + # `xsdba.indicator.base_registry`. # General metadata, usually parsed from the `compute`'s docstring when possible. realm: <realm> # defaults to module-wide realm. One of "atmos", "land", "seaIce", "ocean". @@ -83,7 +83,6 @@ kind: <param kind> # Override the parameter kind. # This is mostly useful for transforming an optional variable into a required one by passing ``kind: 0``. ... - ... # and so on. All fields are optional. Other fields found in the yaml file will trigger errors in xclim. In the following, the section under `<identifier>` is referred to as `data`. When creating indicators from @@ -280,18 +279,18 @@ class Indicator(IndicatorRegistrar): the value of call arguments. Instantiating a new indicator returns an instance but also creates and registers a custom subclass - in :py:data:`xclim.core.indicator.registry`. + in :py:data:`xsdba.indicator.registry`. Attributes in `Indicator.cf_attrs` will be formatted and added to the output variable(s). This attribute is a list of dictionaries. For convenience and retro-compatibility, - standard CF attributes (names listed in :py:attr:`xclim.core.indicator.Indicator._cf_names`) + standard CF attributes (names listed in :py:attr:`xsdba.indicator.Indicator._cf_names`) can be passed as strings or list of strings directly to the indicator constructor. A lot of the Indicator's metadata is parsed from the underlying `compute` function's docstring and signature. Input variables and parameters are listed in - :py:attr:`xclim.core.indicator.Indicator.parameters`, while parameters that will be - injected in the compute function are in :py:attr:`xclim.core.indicator.Indicator.injected_parameters`. - Both are simply views of :py:attr:`xclim.core.indicator.Indicator._all_parameters`. + :py:attr:`xsdba.indicator.Indicator.parameters`, while parameters that will be + injected in the compute function are in :py:attr:`xsdba.indicator.Indicator.injected_parameters`. + Both are simply views of :py:attr:`xsdba.indicator.Indicator._all_parameters`. Compared to their base `compute` function, indicators add the possibility of using dataset as input, with the injected argument `ds` in the call signature. All arguments that were indicated @@ -308,7 +307,7 @@ class Indicator(IndicatorRegistrar): The function computing the indicators. It should return one or more DataArray. cf_attrs : list of dicts Attributes to be formatted and added to the computation's output. - See :py:attr:`xclim.core.indicator.Indicator.cf_attrs`. + See :py:attr:`xsdba.indicator.Indicator.cf_attrs`. title : str A succinct description of what is in the computed outputs. Parsed from `compute` docstring if None (first paragraph). abstract : str @@ -372,7 +371,7 @@ class Indicator(IndicatorRegistrar): Keys are the arguments of the "compute" function. All parameters are listed, even those "injected", absent from the indicator's call signature. All are instances of - :py:class:`xclim.core.indicator.Parameter`. + :py:class:`xsdba.indicator.Parameter`. """ # Note: typing and class types in this call signature will cause errors with sphinx-autodoc-typehints @@ -496,7 +495,7 @@ def __new__(cls, **kwds): # noqa: C901 new.__module__ = f"xclim.indicators.{kwds['module']}" else: # If the module was not forced, set the module to the base class' module. - # Otherwise, all indicators will have module `xclim.core.indicator`. + # Otherwise, all indicators will have module `xsdba.indicator`. new.__module__ = cls.__module__ # Add the created class to the registry @@ -691,8 +690,8 @@ def from_dict( Most parameters are passed directly as keyword arguments to the class constructor, except: - "base" : A subclass of Indicator or a name of one listed in - :py:data:`xclim.core.indicator.registry` or - :py:data:`xclim.core.indicator.base_registry`. When passed, it acts as if + :py:data:`xsdba.indicator.registry` or + :py:data:`xsdba.indicator.base_registry`. When passed, it acts as if `from_dict` was called on that class instead. - "compute" : A string function name translates to a :py:mod:`xclim.indices.generic` or :py:mod:`xclim.indices` function. @@ -1103,7 +1102,7 @@ def _check_identifier(identifier: str) -> None: def translate_attrs(cls, locale: str | Sequence[str], fill_missing: bool = True): """Return a dictionary of unformatted translated translatable attributes. - Translatable attributes are defined in :py:const:`xclim.core.locales.TRANSLATABLE_ATTRS`. + Translatable attributes are defined in :py:const:`xsdba.locales.TRANSLATABLE_ATTRS`. Parameters ---------- diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index e3947b1..dfb19c0 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -3,7 +3,7 @@ ==================== This module defines methods and object to help the internationalization of metadata for -climate indicators computed by xclim. Go to :ref:`notebooks/customize:Adding translated metadata` to see +climate indicators computed by xsdba. Go to :ref:`notebooks/customize:Adding translated metadata` to see how to use this feature. All the methods and objects in this module use localization data given in JSON files. @@ -28,7 +28,7 @@ # ... and so on for other indicators... } -Indicators are named by subclass identifier, the same as in the indicator registry (`xclim.core.indicators.registry`), +Indicators are named by subclass identifier, the same as in the indicator registry (`xsdba.indicators.registry`), but which can differ from the callable name. In this case, the indicator is called through `atmos.daily_temperature_range_variability`, but its identifier is `DTRVAR`. Use the `ind.__class__.__name__` accessor to get its registry name. @@ -36,13 +36,14 @@ Here, the usual parameter passed to the formatting of "description" is "freq" and is usually translated from "YS" to "annual". However, in French and in this sentence, the feminine form should be used, so the "f" modifier is added by the translator so that the formatting function knows which translation to use. Acceptable entries for the mappings -are limited to what is already defined in `xclim.core.indicators.utils.default_formatter`. +are limited to what is already defined in `xsdba.indicators.utils.default_formatter`. For user-provided internationalization dictionaries, only the "attrs_mapping" and its "modifiers" key are mandatory, all other entries (translations of frequent parameters and all indicator entries) are optional. -For xclim-provided translations (for now only French), all indicators must have en entry and the "attrs_mapping" +For xsdba-provided translations (for now only French), all indicators must have en entry and the "attrs_mapping" entries must match exactly the default formatter. -Those default translations are found in the `xclim/locales` folder. +# TODO : Add such folder +Those default translations are found in the `xsdba/locales` folder. """ from __future__ import annotations @@ -225,7 +226,7 @@ class UnavailableLocaleError(ValueError): def __init__(self, locale): super().__init__( - f"Locale {locale} not available. Use `xclim.core.locales.list_locales()` to see available languages." + f"Locale {locale} not available. Use `xsdba.locales.list_locales()` to see available languages." ) diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py index 62bd7f9..ad0b706 100644 --- a/src/xsdba/measures.py +++ b/src/xsdba/measures.py @@ -28,7 +28,7 @@ class StatisticalMeasure(Indicator): """Base indicator class for statistical measures used when validating bias-adjusted outputs. Statistical measures use input data where the time dimension was reduced, usually by the computation - of a :py:class:`xclim.sdba.properties.StatisticalProperty` instance. They usually take two arrays + of a :py:class:`xsdba.properties.StatisticalProperty` instance. They usually take two arrays as input: "sim" and "ref", "sim" being measured against "ref". The two arrays must have identical coordinates on their common dimensions. @@ -70,8 +70,8 @@ class StatisticalPropertyMeasure(Indicator): """Base indicator class for statistical properties that include the comparison measure, used when validating bias-adjusted outputs. StatisticalPropertyMeasure objects combine the functionalities of - :py:class:`xclim.sdba.properties.StatisticalProperty` and - :py:class:`xclim.sdba.properties.StatisticalMeasure`. + :py:class:`xsdba.properties.StatisticalProperty` and + :py:class:`xsdba.properties.StatisticalMeasure`. Statistical properties usually reduce the time dimension and sometimes more dimensions (for example in spatial properties), sometimes adding a grouping dimension according to diff --git a/src/xsdba/options.py b/src/xsdba/options.py index c01e49a..4773ea1 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -16,7 +16,6 @@ METADATA_LOCALES = "metadata_locales" DATA_VALIDATION = "data_validation" -CF_COMPLIANCE = "cf_compliance" CHECK_MISSING = "check_missing" MISSING_OPTIONS = "missing_options" RUN_LENGTH_UFUNC = "run_length_ufunc" @@ -30,7 +29,6 @@ OPTIONS = { METADATA_LOCALES: [], DATA_VALIDATION: "raise", - CF_COMPLIANCE: "warn", CHECK_MISSING: "any", MISSING_OPTIONS: {}, RUN_LENGTH_UFUNC: "auto", @@ -62,7 +60,6 @@ def _valid_missing_options(mopts): _VALIDATORS = { METADATA_LOCALES: _valid_locales, DATA_VALIDATION: _LOUDNESS_OPTIONS.__contains__, - CF_COMPLIANCE: _LOUDNESS_OPTIONS.__contains__, CHECK_MISSING: lambda meth: meth != "from_context" and meth in MISSING_METHODS, MISSING_OPTIONS: _valid_missing_options, RUN_LENGTH_UFUNC: _RUN_LENGTH_UFUNC_OPTIONS.__contains__, @@ -127,19 +124,6 @@ def run_check(*args, **kwargs): return run_check -def cfcheck(func: Callable) -> Callable: - """Decorate functions checking CF-compliance of DataArray attributes. - - Functions should raise ValidationError exceptions whenever attributes are non-conformant. - """ - - @wraps(func) - def run_check(*args, **kwargs): - return _run_check(func, CF_COMPLIANCE, *args, **kwargs) - - return run_check - - class set_options: """Set options for xclim in a controlled context. @@ -151,14 +135,11 @@ class set_options: Default: ``[]``. data_validation : {"log", "raise", "error"} Whether to "log", "raise" an error or 'warn' the user on inputs that fail the data checks in - :py:func:`xclim.core.datachecks`. Default: ``"raise"``. - cf_compliance : {"log", "raise", "error"} - Whether to "log", "raise" an error or "warn" the user on inputs that fail the CF compliance checks in - :py:func:`xclim.core.cfchecks`. Default: ``"warn"``. + :py:func:`xclim.datachecks`. Default: ``"raise"``. check_missing : {"any", "wmo", "pct", "at_least_n", "skip"} How to check for missing data and flag computed indicators. Available methods are "any", "wmo", "pct", "at_least_n" and "skip". - Missing method can be registered through the `xclim.core.options.register_missing_method` decorator. + Missing method can be registered through the `xsdba.options.register_missing_method` decorator. Default: ``"any"`` missing_options : dict Dictionary of options to pass to the missing method. Keys must the name of diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 1c92a6f..526d6c2 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -23,9 +23,6 @@ from .units import compare_units, convert_units_to, harmonize_units, pint2str from .utils import ADDITIVE, copy_all_attrs -# from xclim.core.units import convert_units_to, infer_context, units - - __all__ = [ "adapt_freq", "escore", @@ -267,7 +264,7 @@ def normalize( norm : xr.DataArray, optional If present, it is used instead of computing the norm again. group : str or Grouper - Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details.. + Grouping information. See :py:class:`xsdba.base.Grouper` for details.. kind : {'+', '*'} If `kind` is "+", the mean is subtracted from the mean and if it is '*', it is divided from the data. @@ -363,7 +360,7 @@ def reordering(ref: xr.DataArray, sim: xr.DataArray, group: str = "time") -> xr. sim : xr.DataArray Array to reorder. group : str - Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Grouping information. See :py:class:`xsdba.base.Grouper` for details. Returns ------- diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 6efe525..66ac462 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -461,7 +461,7 @@ def _threshold_count( Notes ----- - This corresponds to ``xclim.sdba.properties._spell_length_distribution`` with `window=1`. + This corresponds to ``xsdba.properties._spell_length_distribution`` with `window=1`. """ return _spell_length_distribution( da, @@ -1047,7 +1047,7 @@ def _bivariate_threshold_count( Notes ----- - This corresponds to ``xclim.sdba.properties._bivariate_spell_length_distribution`` with `window=1`. + This corresponds to ``xsdba.properties._bivariate_spell_length_distribution`` with `window=1`. """ return _bivariate_spell_length_distribution( da1, @@ -1427,7 +1427,7 @@ def _decorrelation_length( Distance from a grid cell where the correlation with its neighbours goes below the threshold. A correlogram is calculated for each grid cell following the method from - ``xclim.sdba.properties.spatial_correlogram``. Then, we find the first bin closest to the correlation threshold. + ``xsdba.properties.spatial_correlogram``. Then, we find the first bin closest to the correlation threshold. Parameters ---------- diff --git a/src/xsdba/typing.py b/src/xsdba/typing.py index ac96ad2..d81eeca 100644 --- a/src/xsdba/typing.py +++ b/src/xsdba/typing.py @@ -28,8 +28,8 @@ class InputKind(IntEnum): For use by external parses to determine what kind of data the indicator expects. On the creation of an indicator, the appropriate constant is stored in - :py:attr:`xclim.core.indicator.Indicator.parameters`. The integer value is what gets stored in the output - of :py:meth:`xclim.core.indicator.Indicator.json`. + :py:attr:`xsdba.indicator.Indicator.parameters`. The integer value is what gets stored in the output + of :py:meth:`xsdba.indicator.Indicator.json`. For developers : for each constant, the docstring specifies the annotation a parameter of an indice function should use in order to be picked up by the indicator constructor. Notice that we are using the annotation format @@ -50,7 +50,7 @@ class InputKind(IntEnum): QUANTIFIED = 2 """A quantity with units, either as a string (scalar), a pint.Quantity (scalar) or a DataArray (with units set). - Annotation : ``xclim.core.utils.Quantified`` and an entry in the :py:func:`xclim.core.units.declare_units` + Annotation : ``xsdba.typing.Quantified`` and an entry in the :py:func:`xsdba.units.declare_units` decorator. "Quantified" translates to ``str | xr.DataArray | pint.util.Quantity``. """ FREQ_STR = 3 @@ -70,17 +70,18 @@ class InputKind(IntEnum): Annotation : ``str`` or ``str | None``. In most cases, this kind of parameter makes sense with choices indicated in the docstring's version of the annotation with curly braces. + # TOOO : what about this notebook? See :ref:`notebooks/extendxclim:Defining new indices`. """ DAY_OF_YEAR = 6 """A date, but without a year, in the MM-DD format. - Annotation : :py:obj:`xclim.core.utils.DayOfYearStr` (may be optional). + Annotation : :py:obj:`xsdba.typing.DayOfYearStr` (may be optional). """ DATE = 7 """A date in the YYYY-MM-DD format, may include a time. - Annotation : :py:obj:`xclim.core.utils.DateStr` (may be optional). + Annotation : :py:obj:`xsdba.typing.DateStr` (may be optional). """ NUMBER_SEQUENCE = 8 """A sequence of numbers @@ -111,7 +112,7 @@ class InputKind(IntEnum): OTHER_PARAMETER = 99 """An object that fits None of the previous kinds. - Developers : This is the fallback kind, it will raise an error in xclim's unit tests if used. + Developers : This is the fallback kind, it will raise an error in xsdba's unit tests if used. """ diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 69a8cfb..7e6f631 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -38,7 +38,7 @@ "W": "week", } """ -Resampling frequency units for :py:func:`xclim.core.units.infer_sampling_units`. +Resampling frequency units for :py:func:`xsdba.units.infer_sampling_units`. Mapping from offset base to CF-compliant unit. Only constant-length frequencies are included. """ @@ -228,7 +228,7 @@ def pint_multiply( xr.DataArray """ q = q if isinstance(q, pint.Quantity) else str2pint(q) - a = 1 * units2pint(da) + a = 1 * units2pint(da) f = a * q.to_base_units() if out_units: f = f.to(out_units) @@ -351,7 +351,7 @@ def convert_units_to( # noqa: C901 """Convert a mathematical expression into a value with the same units as a DataArray. If the dimensionalities of source and target units differ, automatic CF conversions - will be applied when possible. See :py:func:`xclim.core.units.cf_conversion`. + will be applied when possible. Parameters ---------- diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 392fe3d..8c298f8 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -163,7 +163,7 @@ def broadcast( x : xr.DataArray The array to broadcast grouped to. group : str or Grouper - Grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Grouping information. See :py:class:`xsdba.base.Grouper` for details. interp : {'nearest', 'linear', 'cubic'} The interpolation method to use, sel : dict[str, xr.DataArray] diff --git a/src/xsdba/xclim_submodules/generic.py b/src/xsdba/xclim_submodules/generic.py index 91697d3..ac1be4b 100644 --- a/src/xsdba/xclim_submodules/generic.py +++ b/src/xsdba/xclim_submodules/generic.py @@ -75,7 +75,7 @@ def select_resample_op( freq : str Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. out_units : str, optional - Output units to assign. Only necessary if `op` is function not supported by :py:func:`xclim.core.units.to_agg_units`. + Output units to assign. Only necessary if `op` is function not supported by :py:func:`xsdba.units.to_agg_units`. indexer : {dim: indexer, }, optional Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are @@ -128,7 +128,7 @@ def select_rolling_resample_op( freq : str Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. Applied after the rolling window. out_units : str, optional - Output units to assign. Only necessary if `op` is function not supported by :py:func:`xclim.core.units.to_agg_units`. + Output units to assign. Only necessary if `op` is function not supported by :py:func:`xsdba.units.to_agg_units`. indexer : {dim: indexer, }, optional Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are @@ -186,7 +186,7 @@ def default_freq(**indexer) -> str: def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: """Get python's comparing function according to its name of representation and validate allowed usage. - Accepted op string are keys and values of xclim.indices.generic.binary_ops. + Accepted op string are keys and values of xsdba.xclim_submodules.generic.binary_ops. Parameters ---------- diff --git a/src/xsdba/xclim_submodules/run_length.py b/src/xsdba/xclim_submodules/run_length.py index e84704c..a46bf15 100644 --- a/src/xsdba/xclim_submodules/run_length.py +++ b/src/xsdba/xclim_submodules/run_length.py @@ -37,7 +37,7 @@ def use_ufunc( ) -> bool: """Return whether the ufunc version of run length algorithms should be used with this DataArray or not. - If ufunc_1dim is 'from_context', the parameter is read from xclim's global (or context) options. + If ufunc_1dim is 'from_context', the parameter is read from xsdba's global (or context) options. If it is 'auto', this returns False for dask-backed array and for arrays with more than :py:const:`npts_opt` points per slice along `dim`. @@ -1085,7 +1085,7 @@ def rle_1d( Examples -------- - >>> from xclim.indices.run_length import rle_1d + >>> from xsdba.xclim_submodules.run_length import rle_1d >>> a = [1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3] >>> rle_1d(a) (array([1, 2, 3]), array([2, 4, 6]), array([0, 2, 6])) From adfa2cbce1e6d3b89d010bd7a588eb16b989d572 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 14:46:25 -0400 Subject: [PATCH 046/105] link logo --- README.rst | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.rst b/README.rst index 827784a..aa2612b 100644 --- a/README.rst +++ b/README.rst @@ -37,6 +37,11 @@ This package was created with Cookiecutter_ and the `Ouranosinc/cookiecutter-pyp :target: https://github.com/psf/black :alt: Python Black +.. |logo| image:: https://raw.githubusercontent.com/Ouranosinc/xsdba/main/docs/logos/xclim-logo-small-light.png + :target: https://github.com/Ouranosinc/xsdba + :alt: Xsdba + :class: xsdba-logo-small no-theme + .. |build| image:: https://github.com/Ouranosinc/xsdba/actions/workflows/main.yml/badge.svg :target: https://github.com/Ouranosinc/xsdba/actions :alt: Build Status From 4647475fa69796b9d12fc0ce05d1a1686ecc2559 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 14:53:00 -0400 Subject: [PATCH 047/105] update CHANGELOG --- CHANGELOG.rst | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 8b415e8..44ee9fd 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -9,11 +9,10 @@ Contributors: Éric Dupuis (:user:`coxipi`), Trevor James Smith (:user:`Zeitsper Changes ^^^^^^^ -* No change. +* Split `sdba` from `xclim` and duplicate code where needed. (:pull:`8`) +* `xclim_submodules` represent submodules that are copy (or almost) of given modules in `xclim`. Elsewhere, more attention has been given for a cleaner integration of minimal and sufficient `xclim` functionnalities. (:pull:`8`) +* Class `Indicator` in ``indicator.py`` needs some reworking, many pieces are still artefact from `xclim` usage that won't be needed here. (:pull:`8`) -Fixes -^^^^^ -* No change. .. _changes_0.1.0: From 213d869e70fb03e9f6a5b4db1813b7226663d1b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 15:24:19 -0400 Subject: [PATCH 048/105] remove some dead code --- src/xsdba/properties.py | 39 ++++++++++++++++++--------------------- src/xsdba/units.py | 1 - tests/conftest.py | 17 ++--------------- tests/test_indicator.py | 5 +++-- tests/test_units.py | 5 ++--- 5 files changed, 25 insertions(+), 42 deletions(-) diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 66ac462..1d96398 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -34,6 +34,8 @@ from .nbutils import _pairwise_haversine_and_bins from .utils import _pairwise_spearman, copy_all_attrs +# TODO: Reduce redundancy between this submodule and generic + class StatisticalProperty(Indicator): """Base indicator class for statistical properties used for validating bias-adjusted outputs. @@ -345,8 +347,6 @@ def _spell_length_distribution( """ group = group if isinstance(group, Grouper) else Grouper(group) - ops = {">": np.greater, "<": np.less, ">=": np.greater_equal, "<=": np.less_equal} - @map_groups(out=[Grouper.PROP], main_only=True) def _spell_stats( ds, @@ -371,7 +371,7 @@ def _spell_stats( if method == "quantile": thresh = da.quantile(thresh, dim=dim).drop_vars("quantile") - cond = op(da, thresh) + cond = compare(da, op, thresh) out = rl.resample_and_rl( cond, resample_before_rl, @@ -399,7 +399,7 @@ def _spell_stats( method=method, thresh=thresh, window=window, - op=ops[op], + op=op, freq=group.freq, resample_before_rl=resample_before_rl, stat=stat, @@ -899,12 +899,11 @@ def _bivariate_spell_length_distribution( and the second variable is {op2} the {method2} {thresh2} for {window} consecutive day(s). """ group = group if isinstance(group, Grouper) else Grouper(group) - ops = { - ">": np.greater, - "<": np.less, - ">=": np.greater_equal, - "<=": np.less_equal, - } + allowed_ops = [">", "<", ">=", "<="] + if op1 not in allowed_ops or op2 not in allowed_ops: + raise ValueError( + f"`op1` and `op2` must be in {allowed_ops}, but {op1} and {op2} were given." + ) @map_groups(out=[Grouper.PROP], main_only=True) def _bivariate_spell_stats( @@ -913,7 +912,7 @@ def _bivariate_spell_stats( dim, methods, threshs, - opss, + ops, freq, window, resample_before_rl, @@ -925,13 +924,13 @@ def _bivariate_spell_stats( conds = [] masks = [] - for da, thresh, op, method in zip([ds.da1, ds.da2], threshs, opss, methods): + for da, thresh, op, method in zip([ds.da1, ds.da2], threshs, ops, methods): masks.append( ~(da.isel({dim: 0}).isnull()).drop_vars(dim) ) # mask of the ocean with NaNs if method == "quantile": thresh = da.quantile(thresh, dim=dim).drop_vars("quantile") - conds.append(op(da, thresh)) + conds.append(compare(da, op, thresh)) mask = masks[0] & masks[1] cond = conds[0] & conds[1] out = rl.resample_and_rl( @@ -964,7 +963,7 @@ def _bivariate_spell_stats( group=group, threshs=threshs, methods=methods, - opss=[ops[op1], ops[op2]], + opss=[op1, op2], window=window, freq=group.freq, resample_before_rl=resample_before_rl, @@ -1106,15 +1105,13 @@ def _relative_frequency( """ # mask of the ocean with NaNs mask = ~(da.isel({group.dim: 0}).isnull()).drop_vars(group.dim) - ops: dict[str, np.ufunc] = { - ">": np.greater, - "<": np.less, - ">=": np.greater_equal, - "<=": np.less_equal, - } + allowed_ops = [">", "<", ">=", "<="] + if op not in allowed_ops: + raise ValueError(f"`op` must be in {allowed_ops}, but {op} was given.") + t = convert_units_to(thresh, da) # , context="infer") length = da.sizes[group.dim] - cond = ops[op](da, t) + cond = compare(da, op, t) if group.prop != "group": # change the time resolution if necessary cond = cond.groupby(group.name) # length of the groupBy groups diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 7e6f631..a8c07e1 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -415,7 +415,6 @@ def _wrapper(*args, **kwargs): params_dict = args_dict | {k: v for k, v in kwargs.items()} params_dict = {k: v for k, v in params_dict.items() if k in params_to_check} params_dict = _add_default_kws(params_dict, params_to_check, func) - params_dict_keys = [k for k in params_dict.keys()] if set(params_dict.keys()) != set(params_to_check): raise TypeError( f"{params_to_check} were passed but only {params_dict.keys()} were found " diff --git a/tests/conftest.py b/tests/conftest.py index 2897a0a..716dff8 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -16,7 +16,8 @@ import pandas as pd import pytest import xarray as xr -from filelock import FileLock + +# from filelock import FileLock from packaging.version import Version from xsdba.testing import TESTDATA_BRANCH @@ -168,20 +169,6 @@ def timelonlatseries(): return test_timelonlatseries -@pytest.fixture -def lat_series(): - def _lat_series(values): - return xr.DataArray( - values, - dims=("lat",), - coords={"lat": values}, - attrs={"standard_name": "latitude", "units": "degrees_north"}, - name="lat", - ) - - return _lat_series - - # ADAPT # @pytest.fixture # def per_doy(): diff --git a/tests/test_indicator.py b/tests/test_indicator.py index 1c5d1af..fa0b33a 100644 --- a/tests/test_indicator.py +++ b/tests/test_indicator.py @@ -2,12 +2,12 @@ # Tests for the Indicator objects from __future__ import annotations -import gc +# import gc # test_registering +# import dask import json from inspect import signature from typing import Union -import dask import numpy as np import pytest import xarray as xr @@ -224,6 +224,7 @@ def test_opt_vars(timelonlatseries): assert MultiOptVar.parameters["tasmin"].kind == InputKind.OPTIONAL_VARIABLE +# FIXME # def test_registering(): # assert "test.TMIN" in registry diff --git a/tests/test_units.py b/tests/test_units.py index 06969a0..144ff82 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -11,7 +11,6 @@ from xsdba.logging import ValidationError from xsdba.typing import Quantified from xsdba.units import ( - compare_units, convert_units_to, harmonize_units, pint2str, @@ -24,7 +23,7 @@ class TestUnits: def test_temperature(self): assert 4 * units.d == 4 * units.day - Q_ = units.Quantity # noqa + Q_ = units.Quantity assert Q_(1, units.C) == Q_(1, units.degC) def test_lat_lon(self): @@ -73,7 +72,7 @@ def test_units2pint(self, timelonlatseries): assert pint2str(u) == "" def test_str2pint(self): - Q_ = units.Quantity # noqa + Q_ = units.Quantity assert str2pint("-0.78 m") == Q_(-0.78, units="meter") assert str2pint("m kg/s") == Q_(1, units="meter kilogram/second") assert str2pint("11.8 degC days") == Q_(11.8, units="delta_degree_Celsius days") From df76855c1af35a17772d0ff04e30554a8201c877 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 17:09:18 -0400 Subject: [PATCH 049/105] add back test (mainly checks with Cannon) --- src/xsdba/locales.py | 2 +- src/xsdba/processing.py | 2 +- src/xsdba/properties.py | 3 +- src/xsdba/units.py | 2 +- tests/conftest.py | 60 +++++++++++++++++++++------------------- tests/test_adjustment.py | 59 ++++++++++++++++++++------------------- tests/test_processing.py | 7 +++-- tests/test_properties.py | 40 +++++++++++++-------------- 8 files changed, 89 insertions(+), 86 deletions(-) diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index dfb19c0..ecde7e7 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -42,7 +42,7 @@ all other entries (translations of frequent parameters and all indicator entries) are optional. For xsdba-provided translations (for now only French), all indicators must have en entry and the "attrs_mapping" entries must match exactly the default formatter. -# TODO : Add such folder +# TODO : Add such folder ... or forget about locales ... ? Those default translations are found in the `xsdba/locales` folder. """ diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 526d6c2..feb2d66 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -20,7 +20,7 @@ from ._processing import _adapt_freq, _normalize, _reordering from .base import Grouper from .nbutils import _escore -from .units import compare_units, convert_units_to, harmonize_units, pint2str +from .units import convert_units_to, harmonize_units, pint2str from .utils import ADDITIVE, copy_all_attrs __all__ = [ diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 1d96398..2755520 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -34,9 +34,8 @@ from .nbutils import _pairwise_haversine_and_bins from .utils import _pairwise_spearman, copy_all_attrs -# TODO: Reduce redundancy between this submodule and generic - +# TODO: Reduce redundancy between this submodule and generic class StatisticalProperty(Indicator): """Base indicator class for statistical properties used for validating bias-adjusted outputs. diff --git a/src/xsdba/units.py b/src/xsdba/units.py index a8c07e1..7b572e4 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -300,7 +300,7 @@ def extract_units(arg): return ustr if ustr is None else pint.Quantity(1, ustr).units -# TODO: Think, is this really needed? +# TODO: Is this really needed? def compare_units(args_to_check): """Decorator to check that all arguments have the same units (or no units).""" diff --git a/tests/conftest.py b/tests/conftest.py index 716dff8..e67c721 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -81,37 +81,39 @@ def cannon_2015_dist(): return test_cannon_2015_dist -# @pytest.fixture +@pytest.fixture +# FIXME: can't find `socket_enable` fixture # def ref_hist_sim_tuto(socket_enabled): # noqa: F841 -# """Return ref, hist, sim time series of air temperature. - -# socket_enabled is a fixture that enables the use of the internet to download the tutorial dataset while the -# `--disable-socket` flag has been called. This fixture will crash if the `air_temperature` tutorial file is -# not on disk while the internet is unavailable. -# """ - -# def _ref_hist_sim_tuto(sim_offset=3, delta=0.1, smth_win=3, trend=True): -# ds = xr.tutorial.open_dataset("air_temperature") -# ref = ds.air.resample(time="D").mean(keep_attrs=True) -# hist = ref.rolling(time=smth_win, min_periods=1).mean(keep_attrs=True) + delta -# hist.attrs["units"] = ref.attrs["units"] -# sim_time = hist.time + np.timedelta64(730 + sim_offset * 365, "D").astype( -# "<m8[ns]" -# ) -# sim = hist + ( -# 0 -# if not trend -# else xr.DataArray( -# np.linspace(0, 2, num=hist.time.size), -# dims=("time",), -# coords={"time": hist.time}, -# attrs={"units": hist.attrs["units"]}, -# ) -# ) -# sim["time"] = sim_time -# return ref, hist, sim +def ref_hist_sim_tuto(): # noqa: F841 + """Return ref, hist, sim time series of air temperature. + + socket_enabled is a fixture that enables the use of the internet to download the tutorial dataset while the + `--disable-socket` flag has been called. This fixture will crash if the `air_temperature` tutorial file is + not on disk while the internet is unavailable. + """ + + def _ref_hist_sim_tuto(sim_offset=3, delta=0.1, smth_win=3, trend=True): + ds = xr.tutorial.open_dataset("air_temperature") + ref = ds.air.resample(time="D").mean(keep_attrs=True) + hist = ref.rolling(time=smth_win, min_periods=1).mean(keep_attrs=True) + delta + hist.attrs["units"] = ref.attrs["units"] + sim_time = hist.time + np.timedelta64(730 + sim_offset * 365, "D").astype( + "<m8[ns]" + ) + sim = hist + ( + 0 + if not trend + else xr.DataArray( + np.linspace(0, 2, num=hist.time.size), + dims=("time",), + coords={"time": hist.time}, + attrs={"units": hist.attrs["units"]}, + ) + ) + sim["time"] = sim_time + return ref, hist, sim -# return _ref_hist_sim_tuto + return _ref_hist_sim_tuto @pytest.fixture diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index e5f82d4..162b78a 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -32,6 +32,7 @@ ADDITIVE, MULTIPLICATIVE, apply_correction, + equally_spaced_nodes, get_correction, invert, ) @@ -77,12 +78,12 @@ def test_time_and_from_ds(self, timelonlatseries, group, dec, tmp_path, random): p2 = loci2.adjust(sim) np.testing.assert_array_equal(p, p2) - # @pytest.mark.requires_internet - # def test_reduce_dims(self, ref_hist_sim_tuto): - # ref, hist, _sim = ref_hist_sim_tuto() - # hist = hist.expand_dims(member=[0, 1]) - # ref = ref.expand_dims(member=hist.member) - # LOCI.train(ref, hist, group="time", thresh="283 K", add_dims=["member"]) + @pytest.mark.requires_internet + def test_reduce_dims(self, ref_hist_sim_tuto): + ref, hist, _sim = ref_hist_sim_tuto() + hist = hist.expand_dims(member=[0, 1]) + ref = ref.expand_dims(member=hist.member) + LOCI.train(ref, hist, group="time", thresh="283 K", add_dims=["member"]) @pytest.mark.slow @@ -290,25 +291,25 @@ def test_mon_u( np.testing.assert_array_almost_equal(mqm, int(kind == MULTIPLICATIVE), 1) np.testing.assert_allclose(p.transpose(..., "time"), ref_t, rtol=0.1, atol=0.5) - # def test_cannon_and_from_ds(self, cannon_2015_rvs, tmp_path, random): - # ref, hist, sim = cannon_2015_rvs(15000, random=random) + def test_cannon_and_from_ds(self, cannon_2015_rvs, tmp_path, random): + ref, hist, sim = cannon_2015_rvs(15000, random=random) - # DQM = DetrendedQuantileMapping.train(ref, hist, kind="*", group="time") - # p = DQM.adjust(sim) + DQM = DetrendedQuantileMapping.train(ref, hist, kind="*", group="time") + p = DQM.adjust(sim) - # np.testing.assert_almost_equal(p.mean(), 41.6, 0) - # np.testing.assert_almost_equal(p.std(), 15.0, 0) + np.testing.assert_almost_equal(p.mean(), 41.6, 0) + np.testing.assert_almost_equal(p.std(), 15.0, 0) - # file = tmp_path / "test_dqm.nc" - # DQM.ds.to_netcdf(file) + file = tmp_path / "test_dqm.nc" + DQM.ds.to_netcdf(file) - # ds = xr.open_dataset(file) - # DQM2 = DetrendedQuantileMapping.from_dataset(ds) + ds = xr.open_dataset(file) + DQM2 = DetrendedQuantileMapping.from_dataset(ds) - # xr.testing.assert_equal(DQM.ds, DQM2.ds) + xr.testing.assert_equal(DQM.ds, DQM2.ds) - # p2 = DQM2.adjust(sim) - # np.testing.assert_array_equal(p, p2) + p2 = DQM2.adjust(sim) + np.testing.assert_array_equal(p, p2) @pytest.mark.slow @@ -475,16 +476,16 @@ def test_cannon_and_diagnostics(self, cannon_2015_dist, cannon_2015_rvs): assert isinstance(scends, xr.Dataset) # Theoretical results - # ref, hist, sim = cannon_2015_dist - # u1 = equally_spaced_nodes(1001, None) - # u = np.convolve(u1, [0.5, 0.5], mode="valid") - # pu = ref.ppf(u) * sim.ppf(u) / hist.ppf(u) - # pu1 = ref.ppf(u1) * sim.ppf(u1) / hist.ppf(u1) - # pdf = np.diff(u1) / np.diff(pu1) - - # mean = np.trapz(pdf * pu, pu) - # mom2 = np.trapz(pdf * pu ** 2, pu) - # std = np.sqrt(mom2 - mean ** 2) + ref, hist, sim = cannon_2015_dist() + u1 = equally_spaced_nodes(1001, None) + u = np.convolve(u1, [0.5, 0.5], mode="valid") + pu = ref.ppf(u) * sim.ppf(u) / hist.ppf(u) + pu1 = ref.ppf(u1) * sim.ppf(u1) / hist.ppf(u1) + pdf = np.diff(u1) / np.diff(pu1) + + mean = np.trapz(pdf * pu, pu) + mom2 = np.trapz(pdf * pu**2, pu) + std = np.sqrt(mom2 - mean**2) bc_sim = scends.scen np.testing.assert_almost_equal(bc_sim.mean(), 41.5, 1) np.testing.assert_almost_equal(bc_sim.std(), 16.7, 0) diff --git a/tests/test_processing.py b/tests/test_processing.py index 85df267..351f2f7 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -22,7 +22,7 @@ unstack_variables, unstandardize, ) -from xsdba.units import units +from xsdba.units import convert_units_to, pint_multiply, units def test_jitter_both(): @@ -218,10 +218,11 @@ def test_to_additive(timelonlatseries): assert prlog.attrs["sdba_transform"] == "log" assert prlog.attrs["sdba_transform_units"] == "mm/d" + # FIXME # with xr.set_options(keep_attrs=True): # pr1 = pr + 1 - # with units.context("hydro"): - # prlog2 = to_additive_space(pr1, trans="log", lower_bound="1.0 kg m-2 s-1") + # lower_bound = "1e-03 mm/s" + # prlog2 = to_additive_space(pr1, trans="log", lower_bound=lower_bound) # np.testing.assert_allclose(prlog2, [-np.Inf, -11.512925, 0, 10]) # assert prlog2.attrs["sdba_transform_lower"] == 1.0 diff --git a/tests/test_properties.py b/tests/test_properties.py index 2e4403e..d362b8b 100644 --- a/tests/test_properties.py +++ b/tests/test_properties.py @@ -7,7 +7,7 @@ from xarray import set_options from xsdba import properties -from xsdba.units import convert_units_to +from xsdba.units import convert_units_to, pint_multiply class TestProperties: @@ -556,22 +556,22 @@ def test_decorrelation_length(self, open_dataset): ) # ADAPT? The plan was not to allow mm/d -> kg m-2 s-1 in xsdba - # def test_get_measure(self, open_dataset): - # sim = ( - # open_dataset("sdba/CanESM2_1950-2100.nc") - # .sel(time=slice("1981", "2010"), location="Vancouver") - # .pr - # ).load() - - # ref = ( - # open_dataset("sdba/ahccd_1950-2013.nc") - # .sel(time=slice("1981", "2010"), location="Vancouver") - # .pr - # ).load() - - # sim = convert_units_to(sim, ref) - # sim_var = properties.var(sim) - # ref_var = properties.var(ref) - - # meas = properties.var.get_measure()(sim_var, ref_var) - # np.testing.assert_allclose(meas, [0.408327], rtol=1e-3) + def test_get_measure(self, open_dataset): + sim = ( + open_dataset("sdba/CanESM2_1950-2100.nc") + .sel(time=slice("1981", "2010"), location="Vancouver") + .pr + ).load() + + ref = ( + open_dataset("sdba/ahccd_1950-2013.nc") + .sel(time=slice("1981", "2010"), location="Vancouver") + .pr + ).load() + water_density_inverse = "1e-03 m^3/kg" + sim = convert_units_to(pint_multiply(sim, water_density_inverse), ref) + sim_var = properties.var(sim) + ref_var = properties.var(ref) + + meas = properties.var.get_measure()(sim_var, ref_var) + np.testing.assert_allclose(meas, [0.408327], rtol=1e-3) From 71373a8c014e204ed7189d7e0d0926410db6ada4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 17:22:30 -0400 Subject: [PATCH 050/105] fixed test_to_additive --- tests/test_processing.py | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/tests/test_processing.py b/tests/test_processing.py index 351f2f7..0ed0adb 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -210,24 +210,23 @@ def test_reordering_with_window(): assert out.attrs == y.attrs -def test_to_additive(timelonlatseries): +def test_to_additive(timeseries): # log - pr = timelonlatseries(np.array([0, 1e-5, 1, np.e**10]), attrs={"units": "mm/d"}) - prlog = to_additive_space(pr, lower_bound="0 mm/d", trans="log") + pr = timeseries(np.array([0, 1e-5, 1, np.e**10]), units="kg m^-2 s^-1") + prlog = to_additive_space(pr, lower_bound="0 kg m^-2 s^-1", trans="log") np.testing.assert_allclose(prlog, [-np.Inf, -11.512925, 0, 10]) assert prlog.attrs["sdba_transform"] == "log" - assert prlog.attrs["sdba_transform_units"] == "mm/d" + assert prlog.attrs["sdba_transform_units"] == "kg m^-2 s^-1" - # FIXME - # with xr.set_options(keep_attrs=True): - # pr1 = pr + 1 - # lower_bound = "1e-03 mm/s" - # prlog2 = to_additive_space(pr1, trans="log", lower_bound=lower_bound) - # np.testing.assert_allclose(prlog2, [-np.Inf, -11.512925, 0, 10]) - # assert prlog2.attrs["sdba_transform_lower"] == 1.0 + with xr.set_options(keep_attrs=True): + pr1 = pr + 1 + lower_bound = "1 kg m^-2 s^-1" + prlog2 = to_additive_space(pr1, trans="log", lower_bound=lower_bound) + np.testing.assert_allclose(prlog2, [-np.Inf, -11.512925, 0, 10]) + assert prlog2.attrs["sdba_transform_lower"] == 1.0 # logit - hurs = timelonlatseries(np.array([0, 1e-3, 90, 100]), attrs={"units": "%"}) + hurs = timeseries(np.array([0, 1e-3, 90, 100]), units="%") hurslogit = to_additive_space( hurs, lower_bound="0 %", trans="logit", upper_bound="100 %" @@ -250,26 +249,26 @@ def test_to_additive(timelonlatseries): assert hurslogit2.attrs["sdba_transform_upper"] == 600.0 -def test_from_additive(timelonlatseries): +def test_from_additive(timeseries): # log - pr = timelonlatseries(np.array([0, 1e-5, 1, np.e**10]), attrs={"units": "mm/d"}) + pr = timeseries(np.array([0, 1e-5, 1, np.e**10]), units="mm/d") pr2 = from_additive_space(to_additive_space(pr, lower_bound="0 mm/d", trans="log")) np.testing.assert_allclose(pr[1:], pr2[1:]) pr2.attrs.pop("history") assert pr.attrs == pr2.attrs # logit - hurs = timelonlatseries(np.array([0, 1e-5, 0.9, 1]), attrs={"units": "%"}) + hurs = timeseries(np.array([0, 1e-5, 0.9, 1]), units="%") hurs2 = from_additive_space( to_additive_space(hurs, lower_bound="0 %", trans="logit", upper_bound="100 %") ) np.testing.assert_allclose(hurs[1:-1], hurs2[1:-1]) -def test_normalize(timelonlatseries, random): - tas = timelonlatseries( +def test_normalize(timeseries, random): + tas = timeseries( random.standard_normal((int(365.25 * 36),)) + 273.15, - attrs={"units": "K"}, + units="K", start="2000-01-01", ) From d6968aff3eb7f4a011df305cedacb2589ad9eeb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 2 Aug 2024 17:30:05 -0400 Subject: [PATCH 051/105] some formatting cleaning --- src/xsdba/indicator.py | 4 ++-- src/xsdba/locales.py | 2 +- src/xsdba/nbutils.py | 6 ++---- src/xsdba/processing.py | 8 ++++---- 4 files changed, 9 insertions(+), 11 deletions(-) diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py index fd376ed..4c01195 100644 --- a/src/xsdba/indicator.py +++ b/src/xsdba/indicator.py @@ -111,7 +111,7 @@ from functools import reduce from inspect import Parameter as _Parameter from inspect import Signature -from inspect import _empty as _empty_default # noqa +from inspect import _empty as _empty_default from inspect import signature from os import PathLike from pathlib import Path @@ -802,7 +802,7 @@ def __call__(self, *args, **kwds): # params : OrderedDict of parameters (var_kwargs as a single argument, if any) if self._version_deprecated: - self._show_deprecation_warning() # noqa + self._show_deprecation_warning() das, params, dsattrs = self._parse_variables_from_call(args, kwds) diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index ecde7e7..07bac51 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Internationalization ==================== diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index 88fc3d4..d676b1a 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -277,7 +277,7 @@ def quantile(da: DataArray, q: np.ndarray, dim: str | Sequence[Hashable]) -> Dat nogil=True, cache=False, ) -def remove_NaNs(x): # noqa +def remove_NaNs(x): """Remove NaN values from series.""" remove = np.zeros_like(x[0, :], dtype=boolean) for i in range(x.shape[0]): @@ -386,9 +386,7 @@ def _first_and_last_nonnull(arr): nogil=True, cache=False, ) -def _extrapolate_on_quantiles( - interp, oldx, oldg, oldy, newx, newg, method="constant" -): # noqa +def _extrapolate_on_quantiles(interp, oldx, oldg, oldy, newx, newg, method="constant"): """Apply extrapolation to the output of interpolation on quantiles with a given grouping. Arguments are the same as _interp_on_quantiles_2D. diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index feb2d66..b15fc53 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -581,12 +581,12 @@ def to_additive_space( raise NotImplementedError("`trans` must be one of 'log' or 'logit'.") # Attributes to remember all this. - out = out.assign_attrs(sdba_transform=trans) - out = out.assign_attrs(sdba_transform_lower=lower_bound_array) + out = out.assign_attrs(xsdba_transform=trans) + out = out.assign_attrs(xsdba_transform_lower=lower_bound_array) if upper_bound is not None: - out = out.assign_attrs(sdba_transform_upper=upper_bound_array) + out = out.assign_attrs(xsdba_transform_upper=upper_bound_array) if "units" in out.attrs: - out = out.assign_attrs(sdba_transform_units=out.attrs.pop("units")) + out = out.assign_attrs(xsdba_transform_units=out.attrs.pop("units")) out = out.assign_attrs(units="") return out From 1f4f6b69bd6b44a1a3f85de71c4ab31fc847ec79 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 5 Aug 2024 13:28:17 -0400 Subject: [PATCH 052/105] minor convention fixes --- docs/conf.py | 4 ++++ src/xsdba/indicator.py | 24 +++++++++++++----------- src/xsdba/nbutils.py | 2 +- src/xsdba/xclim_submodules/stats.py | 6 +++--- 4 files changed, 21 insertions(+), 15 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 12f11a1..8868c63 100755 --- a/docs/conf.py +++ b/docs/conf.py @@ -36,6 +36,7 @@ 'sphinx.ext.autodoc', 'sphinx.ext.autosectionlabel', 'sphinx.ext.extlinks', + "sphinx.ext.intersphinx", 'sphinx.ext.viewcode', 'sphinx.ext.todo', 'sphinx_codeautolink', @@ -53,6 +54,9 @@ "special-members": False, } +intersphinx_mapping = { + "scipy": ("https://docs.scipy.org/doc/scipy/", None), +} extlinks = { "issue": ("https://github.com/Ouranosinc/xsdba/issues/%s", "GH/%s"), "pull": ("https://github.com/Ouranosinc/xsdba/pull/%s", "PR/%s"), diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py index 4c01195..833a166 100644 --- a/src/xsdba/indicator.py +++ b/src/xsdba/indicator.py @@ -73,16 +73,19 @@ <var name in compute> : <variable official name> ... -Parameters ----------- - <param name>: <param data> # Simplest case, to inject parameters in the compute function. - <param name>: # To change parameters metadata or to declare units when "compute" is a generic function. - units: <param units> # Only valid if "compute" points to a generic function - default : <param default> - description: <param description> - kind: <param kind> # Override the parameter kind. - # This is mostly useful for transforming an optional variable into a required one by passing ``kind: 0``. - ... + +.. code-block:: restructuredtext + + Parameters # noqa: D214 + ---------- # noqa: D215 + <param name> : <param data> # Simplest case, to inject parameters in the compute function. + <param name> : # To change parameters metadata or to declare units when "compute" is a generic function. + units : <param units> # Only valid if "compute" points to a generic function + default : <param default> + description : <param description> + kind : <param kind> # Override the parameter kind. + # This is mostly useful for transforming an optional variable into a required one by passing ``kind: 0``. + ... All fields are optional. Other fields found in the yaml file will trigger errors in xclim. In the following, the section under `<identifier>` is referred to as `data`. When creating indicators from @@ -1147,7 +1150,6 @@ def _translate(cf_attrs, names, var_id=None): ) return attrs - @classmethod def json(self, args=None): """Return a serializable dictionary representation of the class. diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index d676b1a..4865a81 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -277,7 +277,7 @@ def quantile(da: DataArray, q: np.ndarray, dim: str | Sequence[Hashable]) -> Dat nogil=True, cache=False, ) -def remove_NaNs(x): +def remove_NaNs(x): # noqa: N802 """Remove NaN values from series.""" remove = np.zeros_like(x[0, :], dtype=boolean) for i in range(x.shape[0]): diff --git a/src/xsdba/xclim_submodules/stats.py b/src/xsdba/xclim_submodules/stats.py index 4a26152..18fdf80 100644 --- a/src/xsdba/xclim_submodules/stats.py +++ b/src/xsdba/xclim_submodules/stats.py @@ -542,7 +542,7 @@ def _dist_method_1D( # noqa: N802 ) -> xr.DataArray: r"""Statistical function for given argument on given distribution initialized with params. - See :py:ref:`scipy:scipy.stats.rv_continuous` for all available functions and their arguments. + See :py:ref:`scipy.stats.rv_continuous` for all available functions and their arguments. Every method where `"*args"` are the distribution parameters can be wrapped. Parameters @@ -587,7 +587,7 @@ def dist_method( The first argument for the requested function if different from `fit_params`. dist : str pr rv_continuous, optional The distribution name or instance. Defaults to the `scipy_dist` attribute or `fit_params`. - \*\*kwargs + \*\*kwargs : dict Other parameters to pass to the function call. Returns @@ -597,7 +597,7 @@ def dist_method( See Also -------- - scipy:scipy.stats.rv_continuous : for all available functions and their arguments. + scipy.stats.rv_continuous : for all available functions and their arguments. """ # Typically the data to be transformed arg = [arg] if arg is not None else [] From 8b7d8e942f934b8b6def7ab6a57e2c36bbf0270d Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 5 Aug 2024 13:40:05 -0400 Subject: [PATCH 053/105] ignore xclim submodules folder --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 7f5c90d..de2416f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -67,7 +67,7 @@ repos: rev: v1.7.0 hooks: - id: numpydoc-validation - exclude: ^docs/|^tests/ + exclude: ^docs/|^tests/|src/xsdba/xclim_submodules/ - repo: https://github.com/python-jsonschema/check-jsonschema rev: 0.28.6 hooks: From 69a576c0fdc3344235e4cbbf4a9aa4d7a2f3ae18 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 5 Aug 2024 13:58:23 -0400 Subject: [PATCH 054/105] docstring fixes --- src/xsdba/_adjustment.py | 17 ++++++++-------- src/xsdba/_processing.py | 19 +++++++++--------- src/xsdba/calendar.py | 43 +++++++++++++++++++--------------------- src/xsdba/datachecks.py | 2 +- src/xsdba/formatting.py | 4 ++-- src/xsdba/indicator.py | 12 ++++------- src/xsdba/locales.py | 6 +++--- src/xsdba/nbutils.py | 2 +- src/xsdba/processing.py | 7 +++---- src/xsdba/utils.py | 24 +++++++++++----------- 10 files changed, 63 insertions(+), 73 deletions(-) diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index 393a680..d6a5568 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -693,29 +693,28 @@ def npdf_transform(ds: xr.Dataset, **kwargs) -> xr.Dataset: ---------- ds : xr.Dataset Dataset variables: - ref : Reference multivariate timeseries - hist : simulated timeseries on the reference period + ref : Reference multivariate timeseries. + hist : simulated timeseries on the reference period. sim : Simulated timeseries on the projected period. rot_matrices : Random rotation matrices. \*\*kwargs - pts_dim : multivariate dimension name - base : Adjustment class - base_kws : Kwargs for initialising the adjustment object - adj_kws : Kwargs of the `adjust` call + pts_dim : multivariate dimension name. + base : Adjustment class. + base_kws : Kwargs for initialising the adjustment object. + adj_kws : Kwargs of the `adjust` call. n_escore : Number of elements to include in the e_score test (0 for all, < 0 to skip). Returns ------- xr.Dataset Dataset variables: - scenh : Scenario in the reference period (source `hist` transferred to target `ref` inside training) - scens : Scenario in the projected period (source `sim` transferred to target `ref` outside training) + scenh : Scenario in the reference period (source `hist` transferred to target `ref` inside training). + scens : Scenario in the projected period (source `sim` transferred to target `ref` outside training). escores : Index estimating the dissimilarity between `scenh` and `hist`. Notes ----- If `n_escore` is negative, `escores` will be filled with NaNs. - """ ref = ds.ref.rename(time_hist="time") hist = ds.hist.rename(time_hist="time") diff --git a/src/xsdba/_processing.py b/src/xsdba/_processing.py index f40f63e..2863ae0 100644 --- a/src/xsdba/_processing.py +++ b/src/xsdba/_processing.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Compute Functions Submodule =========================== @@ -35,24 +35,23 @@ def _adapt_freq( Parameters ---------- ds : xr.Dataset - With variables : "ref", Target/reference data, usually observed data and "sim", Simulated data. + With variables : "ref", Target/reference data, usually observed data and "sim", Simulated data. dim : str, or sequence of strings - Dimension name(s). If more than one, the probabilities and quantiles are computed within all the dimensions. - If `window` is in the names, it is removed before the correction - and the final timeseries is corrected along dim[0] only. + Dimension name(s). + If more than one, the probabilities and quantiles are computed within all the dimensions. + If `window` is in the names, it is removed before the correction and the final timeseries is corrected along dim[0] only. group : Union[str, Grouper] - Grouping information, see base.Grouper + Grouping information, see base.Grouper. thresh : float Threshold below which values are considered zero. Returns ------- xr.Dataset, with the following variables: - - `sim_adj`: Simulated data with the same frequency of values under threshold than ref. Adjustment is made group-wise. - - `pth` : For each group, the smallest value of sim that was not frequency-adjusted. All values smaller were - either left as zero values or given a random value between thresh and pth. + - `pth` : For each group, the smallest value of sim that was not frequency-adjusted. + All values smaller were either left as zero values or given a random value between thresh and pth. NaN where frequency adaptation wasn't needed. - `dP0` : For each group, the percentage of values that were corrected in sim. """ @@ -125,7 +124,7 @@ def _normalize( Returns ------- xr.Dataset - Group-wise anomaly of x + Group-wise anomaly of 'x'. Notes ----- diff --git a/src/xsdba/calendar.py b/src/xsdba/calendar.py index 985be14..c683b5d 100644 --- a/src/xsdba/calendar.py +++ b/src/xsdba/calendar.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Calendar Handling Utilities =========================== @@ -435,11 +435,11 @@ def percentile_doy( Parameters ---------- arr : xr.DataArray - Input data, a daily frequency (or coarser) is required. + Input data, a daily frequency (or coarser) is required. window : int - Number of time-steps around each day of the year to include in the calculation. + Number of time-steps around each day of the year to include in the calculation. per : float or sequence of floats - Percentile(s) between [0, 100] + Percentile(s) between [0, 100]. alpha : float Plotting position parameter. beta : float @@ -541,16 +541,16 @@ def compare_offsets(freqA: str, op: str, freqB: str) -> bool: Parameters ---------- freqA : str - RHS Date offset string ('YS', '1D', 'QS-DEC', ...) + RHS Date offset string ('YS', '1D', 'QS-DEC', ...). op : {'<', '<=', '==', '>', '>=', '!='} Operator to use. freqB : str - LHS Date offset string ('YS', '1D', 'QS-DEC', ...) + LHS Date offset string ('YS', '1D', 'QS-DEC', ...). Returns ------- bool - freqA op freqB + Either freqA op freqB. """ from .xclim_submodules.generic import ( # pylint: disable=import-outside-toplevel get_op, @@ -579,23 +579,20 @@ def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: Parameters ---------- freq : str - Frequency offset. + Frequency offset. Returns ------- multiplier : int - Multiplier of the base frequency. "[n]W" is always replaced with "[7n]D", - as xarray doesn't support "W" for cftime indexes. + Multiplier of the base frequency. + "[n]W" is always replaced with "[7n]D", as xarray doesn't support "W" for cftime indexes. offset_base : str Base frequency. is_start_anchored : bool - Whether coordinates of this frequency should correspond to the beginning of the period (`True`) - or its end (`False`). Can only be False when base is Y, Q or M; in other words, xsdba assumes frequencies finer - than monthly are all start-anchored. + Whether coordinates of this frequency should correspond to the beginning of the period (`True`) or its end (`False`). + Can only be False when base is Y, Q or M; in other words, xsdba assumes frequencies finer than monthly are all start-anchored. anchor : str, optional - Anchor date for bases Y or Q. As xarray doesn't support "W", - neither does xsdba (anchor information is lost when given). - + Anchor date for bases Y or Q. As xarray doesn't support "W", neither does xsdba (anchor information is lost when given). """ # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) offset = pd.tseries.frequencies.to_offset(freq) @@ -1236,17 +1233,17 @@ def select_time( Input data. drop : bool Whether to drop elements outside the period of interest or to simply mask them (default). - season : string or sequence of strings, optional + season : str or sequence of str, optional One or more of 'DJF', 'MAM', 'JJA' and 'SON'. - month : integer or sequence of integers, optional - Sequence of month numbers (January = 1 ... December = 12) - doy_bounds : 2-tuple of integers, optional + month : int or sequence of int, optional + Sequence of month numbers (January = 1 ... December = 12). + doy_bounds : 2-tuple of int, optional The bounds as (start, end) of the period of interest expressed in day-of-year, integers going from 1 (January 1st) to 365 or 366 (December 31st). If calendar awareness is needed, consider using ``date_bounds`` instead. - date_bounds : 2-tuple of strings, optional + date_bounds : 2-tuple of str, optional The bounds as (start, end) of the period of interest expressed as dates in the month-day (%m-%d) format. - include_bounds : bool or 2-tuple of booleans + include_bounds : bool or 2-tuple of bool Whether the bounds of `doy_bounds` or `date_bounds` should be inclusive or not. Either one value for both or a tuple. Default is True, meaning bounds are inclusive. @@ -1343,7 +1340,7 @@ def _get_doys(_start, _end, _inclusive): def _month_is_first_period_month(time, freq): - """Returns True if the given time is from the first month of freq.""" + """Return True if the given time is from the first month of freq.""" if isinstance(time, cftime.datetime): frq_monthly = xr.coding.cftime_offsets.to_offset("MS") frq = xr.coding.cftime_offsets.to_offset(freq) diff --git a/src/xsdba/datachecks.py b/src/xsdba/datachecks.py index 0de675a..f0c2bb0 100644 --- a/src/xsdba/datachecks.py +++ b/src/xsdba/datachecks.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Data Checks =========== diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 46b35dd..325f37d 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -627,8 +627,8 @@ def generate_indicator_docstring(ind) -> str: Parameters ---------- - ind - Indicator instance + ind : Indicator + An Indicator instance. Returns ------- diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py index 833a166..9fec173 100644 --- a/src/xsdba/indicator.py +++ b/src/xsdba/indicator.py @@ -1,4 +1,4 @@ -""" +"""# noqa: SS01 Indicator Utilities =================== @@ -9,8 +9,8 @@ There are many ways to construct indicators. A good place to start is `this notebook <notebooks/extendxclim.ipynb#Defining-new-indicators>`_. -Dictionary and YAML parser --------------------------- +Dictionary and YAML parser # noqa: GL06 +-------------------------- # noqa: GL06 To construct indicators dynamically, xclim can also use dictionaries and parse them from YAML files. This is especially useful for generating whole indicator "submodules" from files. @@ -73,7 +73,6 @@ <var name in compute> : <variable official name> ... - .. code-block:: restructuredtext Parameters # noqa: D214 @@ -99,7 +98,6 @@ As xclim has strict definitions of possible input variables (see :py:data:`xclim.core.utils.variables`), the mapping of `data.input` simply links an argument name from the function given in "compute" to one of those official variables. - """ from __future__ import annotations @@ -515,7 +513,6 @@ def _parse_indice(compute, passed_parameters): # noqa: F841 'passed_parameters' is only needed when compute is a generic function (not decorated by `declare_units`) and it takes a string parameter. In that case we need to check if that parameter has units (which have been passed explicitly). - """ docmeta = parse_doc(compute.__doc__) params_dict = docmeta.pop("parameters", {}) # override parent's parameters @@ -951,7 +948,7 @@ def _assign_named_args(self, ba): ) def _postprocess(self, outs, das, params): - """Actions to done after computing.""" + """Run post-computation actions.""" return outs def _bind_call(self, func, **das): @@ -1162,7 +1159,6 @@ def json(self, args=None): Notes ----- This is meant to be used by a third-party library wanting to wrap this class into another interface. - """ names = ["identifier", "title", "abstract", "keywords"] out = {key: getattr(self, key) for key in names} diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index 07bac51..18f738c 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -100,7 +100,7 @@ def get_local_dict(locale: str | Sequence[str] | tuple[str, dict]) -> tuple[str, Parameters ---------- - locale: str or sequence of str + locale : str or sequence of str IETF language tag or a tuple of the language tag and a translation dict, or a tuple of the language tag and a path to a json file defining translation of attributes. @@ -112,7 +112,7 @@ def get_local_dict(locale: str | Sequence[str] | tuple[str, dict]) -> tuple[str, Returns ------- str - The best fitting locale string + The best fitting locale string. dict The available translations in this locale. """ @@ -284,7 +284,7 @@ def generate_local_dict(locale: str, init_english: bool = False) -> dict: Parameters ---------- locale : str - Locale in the IETF format + Locale in the IETF format. init_english : bool If True, fills the initial dictionary with the english versions of the attributes. Defaults to False. diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index 4865a81..336cf14 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -40,7 +40,7 @@ def _get_indexes( Returns ------- array-like, array-like - A tuple of virtual_indexes neighbouring indexes (previous and next) + A tuple of virtual_indexes neighbouring indexes (previous and next). Notes ----- diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index b15fc53..f052801 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -1,5 +1,5 @@ # pylint: disable=missing-kwoa -""" +"""# noqa: SS01 Pre- and Post-Processing Submodule ================================== """ @@ -556,7 +556,7 @@ def to_additive_space( See Also -------- - from_additive_space : for the inverse transformation. + from_additive_space : For the inverse transformation. jitter_under_thresh : Remove values exactly equal to the lower bound. jitter_over_thresh : Remove values exactly equal to the upper bound. @@ -654,12 +654,11 @@ def from_additive_space( See Also -------- - to_additive_space : for the original transformation. + to_additive_space : For the original transformation. References ---------- :cite:cts:`sdba-alavoine_distinct_2022`. - """ if trans is None and lower_bound is None and units is None: try: diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 8c298f8..58f588c 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -50,17 +50,18 @@ def map_cdf( Parameters ---------- ds : xr.Dataset - Variables: x, Values from which to pick, - y, Reference values giving the ranking + Variables: + x, Values from which to pick, + y, Reference values giving the ranking. y_value : float, array - Value within the support of `y`. + Value within the support of `y`. dim : str - Dimension along which to compute quantile. + Dimension along which to compute quantile. Returns ------- array - Quantile of `x` with the same CDF as `y_value` in `y`. + Quantile of `x` with the same CDF as `y_value` in `y`. """ return xr.apply_ufunc( map_cdf_1d, @@ -826,19 +827,18 @@ def rand_rot_matrix( Parameters ---------- - crd: xr.DataArray - 1D coordinate DataArray along which the rotation occurs. - The output will be square with the same coordinate replicated, - the second renamed to `new_dim`. + crd : xr.DataArray + 1D coordinate DataArray along which the rotation occurs. + The output will be square with the same coordinate replicated, the second renamed to `new_dim`. num : int - If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. + If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. new_dim : str - Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". + Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". Returns ------- xr.DataArray - float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. + A float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. References ---------- From 6f38d4aa04dd0fda648fdfe481eb5f5390b5fa0f Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 5 Aug 2024 14:08:50 -0400 Subject: [PATCH 055/105] update environment --- environment-dev.yml | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/environment-dev.yml b/environment-dev.yml index 87bde87..69b2e76 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -4,42 +4,41 @@ channels: - defaults dependencies: - python >=3.9,<3.13 - # - xarray >=2022.05.0.dev0 - - xarray + - boltons + - bottleneck + - cf_xarray - cftime - dask # why was this not installed?? - jsonpickle - - boltons - - scipy - numba - numpy<2.0 # to accomodate numba - pint + - scipy - statsmodels + - xarray - yamale - - bottleneck - + # - xarray >=2022.05.0.dev0 # Dev tools and testing - pip >=24.0 + - black ==24.4.2 + - blackdoc ==0.3.9 - bump-my-version >=0.24.3 - - watchdog >=4.0.0 + - coverage >=7.5.0 + - coveralls >=4.0.0 - flake8 >=7.1.0 - flake8-rst-docstrings >=0.3.0 - flit >=3.9.0,<4.0 - - tox >=4.16.0 - - coverage >=7.5.0 - - coveralls >=4.0.0 - - typer >=0.12.3 - - pytest >=8.2.2 - - pytest-cov >=5.0.0 - - black ==24.4.2 - - blackdoc ==0.3.9 + - h5netcdf - isort ==5.13.2 + - nc-time-axis # for notebooks + - netcdf4 - numpydoc >=1.7.0 + - pooch # for notebooks - pre-commit >=3.5.0 + - pytest >=8.2.2 + - pytest-cov >=5.0.0 - ruff >=0.5.0 + - tox >=4.16.0 + - typer >=0.12.3 + - watchdog >=4.0.0 - xdoctest - - h5netcdf - - netcdf4 - - cf_xarray - - nc_time_axis # for notebooks - - pooch # for notebooks From 9be9d520a10a8e03847c13ae988d6bbd57483c52 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 5 Aug 2024 15:10:39 -0400 Subject: [PATCH 056/105] add annotation imports --- pyproject.toml | 1 + src/xsdba/units.py | 2 ++ 2 files changed, 3 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 455fdf2..ec9070d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -213,6 +213,7 @@ exclude = [ [tool.isort] profile = "black" py_version = 39 +add_imports = "from __future__ import annotations" [tool.mypy] files = "." diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 7b572e4..8c0de18 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -3,6 +3,8 @@ ======================== """ +from __future__ import annotations + import inspect from copy import deepcopy from functools import wraps From 1de32a3a484dbf7d38d7508c5d4335bd9108a77e Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 19:11:02 +0000 Subject: [PATCH 057/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/cli.py | 2 ++ src/xsdba/options.py | 3 ++- src/xsdba/xsdba.py | 2 ++ tests/__init__.py | 2 ++ tests/test_xsdba.py | 2 ++ 5 files changed, 10 insertions(+), 1 deletion(-) diff --git a/src/xsdba/cli.py b/src/xsdba/cli.py index 35bdd38..5d90e74 100644 --- a/src/xsdba/cli.py +++ b/src/xsdba/cli.py @@ -1,5 +1,7 @@ """Console script for xsdba.""" +from __future__ import annotations + import typer from rich.console import Console diff --git a/src/xsdba/options.py b/src/xsdba/options.py index 4773ea1..756bb7b 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -2,8 +2,9 @@ Global or contextual options for xsdba, similar to xarray.set_options. """ -# XC remove: metadata locales, do we need them? +from __future__ import annotations +# XC remove: metadata locales, do we need them? from __future__ import annotations from inspect import signature diff --git a/src/xsdba/xsdba.py b/src/xsdba/xsdba.py index dd0b80e..1c7c10a 100644 --- a/src/xsdba/xsdba.py +++ b/src/xsdba/xsdba.py @@ -1 +1,3 @@ """Main module.""" + +from __future__ import annotations diff --git a/tests/__init__.py b/tests/__init__.py index 62e3c58..792f1a2 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1 +1,3 @@ """Unit test package for xsdba.""" + +from __future__ import annotations diff --git a/tests/test_xsdba.py b/tests/test_xsdba.py index f093d61..cae4c6d 100644 --- a/tests/test_xsdba.py +++ b/tests/test_xsdba.py @@ -1,6 +1,8 @@ #!/usr/bin/env python """Tests for `xsdba` package.""" +from __future__ import annotations + import pathlib from importlib.util import find_spec From 8c1afaa3a11a33f2603b31111796bf5d21657c07 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 19:12:54 +0000 Subject: [PATCH 058/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/options.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/xsdba/options.py b/src/xsdba/options.py index 756bb7b..d69b914 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -2,8 +2,6 @@ Global or contextual options for xsdba, similar to xarray.set_options. """ -from __future__ import annotations - # XC remove: metadata locales, do we need them? from __future__ import annotations From 9164be9c1d0ea7a5560be0129e976a7b214758a3 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 5 Aug 2024 15:21:19 -0400 Subject: [PATCH 059/105] fix illegal pipe --- src/xsdba/units.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 8c0de18..da718cf 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -293,7 +293,7 @@ def extract_units(arg): ) elif isinstance(arg, xr.DataArray): ustr = None if "units" not in arg.attrs else arg.attrs["units"] - elif isinstance(arg, pint.Unit | units.Unit): + elif isinstance(arg, (pint.Unit, units.Unit)): ustr = pint2str(arg) # XC: from pint2str elif isinstance(arg, str): ustr = pint2str(str2pint(arg).units) From 75a159e2bca604e7f204cf6f0c34e1388c54f59a Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 5 Aug 2024 16:23:08 -0400 Subject: [PATCH 060/105] add needed functions for generate_atmos - WIP --- src/xsdba/testing.py | 41 ++++++++ src/xsdba/utils.py | 217 ++++++++++++++++++++++++++++++++++++++++++- tests/conftest.py | 24 ++--- tests/test_units.py | 1 + 4 files changed, 271 insertions(+), 12 deletions(-) diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 18fc108..2979cd2 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -19,6 +19,7 @@ from scipy.stats import gamma from xarray import open_dataset as _open_dataset +from xsdba.calendar import percentile_doy from xsdba.utils import equally_spaced_nodes __all__ = ["test_timelonlatseries", "test_timeseries"] @@ -343,3 +344,43 @@ def nancov(X): """Drop observations with NaNs from Numpy's cov.""" X_na = np.isnan(X).any(axis=0) return np.cov(X[:, ~X_na]) + + +# XC +def generate_atmos(cache_dir: Path) -> dict[str, xr.DataArray]: + """Create the `atmosds` synthetic testing dataset.""" + with open_dataset( + "ERA5/daily_surface_cancities_1990-1993.nc", + cache_dir=cache_dir, + branch=TESTDATA_BRANCH, + engine="h5netcdf", + ) as ds: + tn10 = percentile_doy(ds.tasmin, per=10) + t10 = percentile_doy(ds.tas, per=10) + t90 = percentile_doy(ds.tas, per=90) + tx90 = percentile_doy(ds.tasmax, per=90) + + # rsus = shortwave_upwelling_radiation_from_net_downwelling(ds.rss, ds.rsds) + # rlus = longwave_upwelling_radiation_from_net_downwelling(ds.rls, ds.rlds) + + ds = ds.assign( + # rsus=rsus, + # rlus=rlus, + tn10=tn10, + t10=t10, + t90=t90, + tx90=tx90, + ) + + # Create a file in session scoped temporary directory + atmos_file = cache_dir.joinpath("atmosds.nc") + ds.to_netcdf(atmos_file, engine="h5netcdf") + + # Give access to dataset variables by name in namespace + namespace = dict() + with open_dataset( + atmos_file, branch=TESTDATA_BRANCH, cache_dir=cache_dir, engine="h5netcdf" + ) as ds: + for variable in ds.data_vars: + namespace[f"{variable}_dataset"] = ds.get(variable) + return namespace diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 58f588c..bd5303a 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -19,7 +19,7 @@ from .base import Grouper, ensure_chunk_size, parse_group, uses_dask from .calendar import ensure_longest_doy -from .nbutils import _extrapolate_on_quantiles +from .nbutils import _extrapolate_on_quantiles, _linear_interpolation MULTIPLICATIVE = "*" ADDITIVE = "+" @@ -964,3 +964,218 @@ def load_module(path: os.PathLike, name: str | None = None): mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) # This executes code, effectively loading the module return mod + + +# calc_perc-needed functions needed for generate_atmos + + +# XC +def calc_perc( + arr: np.ndarray, + percentiles: Sequence[float] | None = None, + alpha: float = 1.0, + beta: float = 1.0, + copy: bool = True, +) -> np.ndarray: + """Compute percentiles using nan_calc_percentiles and move the percentiles' axis to the end.""" + if percentiles is None: + _percentiles = [50.0] + else: + _percentiles = percentiles + + return np.moveaxis( + nan_calc_percentiles( + arr=arr, + percentiles=_percentiles, + axis=-1, + alpha=alpha, + beta=beta, + copy=copy, + ), + source=0, + destination=-1, + ) + + +# XC +def nan_calc_percentiles( + arr: np.ndarray, + percentiles: Sequence[float] | None = None, + axis: int = -1, + alpha: float = 1.0, + beta: float = 1.0, + copy: bool = True, +) -> np.ndarray: + """Convert the percentiles to quantiles and compute them using _nan_quantile.""" + if percentiles is None: + _percentiles = [50.0] + else: + _percentiles = percentiles + + if copy: + # bootstrapping already works on a data's copy + # doing it again is extremely costly, especially with dask. + arr = arr.copy() + quantiles = np.array([per / 100.0 for per in _percentiles]) + return _nan_quantile(arr, quantiles, axis, alpha, beta) + + +# XC +def _nan_quantile( + arr: np.ndarray, + quantiles: np.ndarray, + axis: int = 0, + alpha: float = 1.0, + beta: float = 1.0, +) -> float | np.ndarray: + """Get the quantiles of the array for the given axis. + + A linear interpolation is performed using alpha and beta. + + Notes + ----- + By default, alpha == beta == 1 which performs the 7th method of :cite:t:`hyndman_sample_1996`. + with alpha == beta == 1/3 we get the 8th method. + """ + # --- Setup + data_axis_length = arr.shape[axis] + if data_axis_length == 0: + return np.nan + if data_axis_length == 1: + result = np.take(arr, 0, axis=axis) + return np.broadcast_to(result, (quantiles.size,) + result.shape) + # The dimensions of `q` are prepended to the output shape, so we need the + # axis being sampled from `arr` to be last. + DATA_AXIS = 0 + if axis != DATA_AXIS: # But moveaxis is slow, so only call it if axis!=0. + arr = np.moveaxis(arr, axis, destination=DATA_AXIS) + # nan_count is not a scalar + nan_count = np.isnan(arr).sum(axis=DATA_AXIS).astype(float) + valid_values_count = data_axis_length - nan_count + # We need at least two values to do an interpolation + too_few_values = valid_values_count < 2 + if too_few_values.any(): + # This will result in getting the only available value if it exists + valid_values_count[too_few_values] = np.nan + # --- Computation of indexes + # Add axis for quantiles + valid_values_count = valid_values_count[..., np.newaxis] + virtual_indexes = _compute_virtual_index(valid_values_count, quantiles, alpha, beta) + virtual_indexes = np.asanyarray(virtual_indexes) + previous_indexes, next_indexes = _get_indexes( + arr, virtual_indexes, valid_values_count + ) + # --- Sorting + arr.sort(axis=DATA_AXIS) + # --- Get values from indexes + arr = arr[..., np.newaxis] + previous = np.squeeze( + np.take_along_axis(arr, previous_indexes.astype(int)[np.newaxis, ...], axis=0), + axis=0, + ) + next_elements = np.squeeze( + np.take_along_axis(arr, next_indexes.astype(int)[np.newaxis, ...], axis=0), + axis=0, + ) + # --- Linear interpolation + gamma = _get_gamma(virtual_indexes, previous_indexes) + interpolation = _linear_interpolation(previous, next_elements, gamma) + # When an interpolation is in Nan range, (near the end of the sorted array) it means + # we can clip to the array max value. + result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation) + # Move quantile axis in front + result = np.moveaxis(result, axis, 0) + return result + + +# XC +def _get_gamma(virtual_indexes: np.ndarray, previous_indexes: np.ndarray): + """Compute gamma (AKA 'm' or 'weight') for the linear interpolation of quantiles. + + Parameters + ---------- + virtual_indexes: array_like + The indexes where the percentile is supposed to be found in the sorted sample. + previous_indexes: array_like + The floor values of virtual_indexes. + + Notes + ----- + `gamma` is usually the fractional part of virtual_indexes but can be modified by the interpolation method. + """ + gamma = np.asanyarray(virtual_indexes - previous_indexes) + return np.asanyarray(gamma) + + +# XC +def _compute_virtual_index( + n: np.ndarray, quantiles: np.ndarray, alpha: float, beta: float +): + """Compute the floating point indexes of an array for the linear interpolation of quantiles. + + Based on the approach used by :cite:t:`hyndman_sample_1996`. + + Parameters + ---------- + n : array_like + The sample sizes. + quantiles : array_like + The quantiles values. + alpha : float + A constant used to correct the index computed. + beta : float + A constant used to correct the index computed. + + Notes + ----- + `alpha` and `beta` values depend on the chosen method (see quantile documentation). + + References + ---------- + :cite:cts:`hyndman_sample_1996` + """ + return n * quantiles + (alpha + quantiles * (1 - alpha - beta)) - 1 + + +# XC +def _get_indexes( + arr: np.ndarray, virtual_indexes: np.ndarray, valid_values_count: np.ndarray +) -> tuple[np.ndarray, np.ndarray]: + """Get the valid indexes of arr neighbouring virtual_indexes. + + Notes + ----- + This is a companion function to linear interpolation of quantiles. + + Parameters + ---------- + arr : array-like + virtual_indexes : array-like + valid_values_count : array-like + + Returns + ------- + array-like, array-like + A tuple of virtual_indexes neighbouring indexes (previous and next). + """ + previous_indexes = np.asanyarray(np.floor(virtual_indexes)) + next_indexes = np.asanyarray(previous_indexes + 1) + indexes_above_bounds = virtual_indexes >= valid_values_count - 1 + # When indexes is above max index, take the max value of the array + if indexes_above_bounds.any(): + previous_indexes[indexes_above_bounds] = -1 + next_indexes[indexes_above_bounds] = -1 + # When indexes is below min index, take the min value of the array + indexes_below_bounds = virtual_indexes < 0 + if indexes_below_bounds.any(): + previous_indexes[indexes_below_bounds] = 0 + next_indexes[indexes_below_bounds] = 0 + if np.issubdtype(arr.dtype, np.inexact): + # After the sort, slices having NaNs will have for last element a NaN + virtual_indexes_nans = np.isnan(virtual_indexes) + if virtual_indexes_nans.any(): + previous_indexes[virtual_indexes_nans] = -1 + next_indexes[virtual_indexes_nans] = -1 + previous_indexes = previous_indexes.astype(np.intp) + next_indexes = next_indexes.astype(np.intp) + return previous_indexes, next_indexes diff --git a/tests/conftest.py b/tests/conftest.py index e67c721..28b9f3e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -20,7 +20,7 @@ # from filelock import FileLock from packaging.version import Version -from xsdba.testing import TESTDATA_BRANCH +from xsdba.testing import TESTDATA_BRANCH, generate_atmos from xsdba.testing import open_dataset as _open_dataset from xsdba.testing import ( test_cannon_2015_dist, @@ -317,17 +317,20 @@ def atmosds(threadsafe_data_dir) -> xr.Dataset: # ) -# @pytest.fixture(scope="session", autouse=True) -# def gather_session_data(threadsafe_data_dir, worker_id, xdoctest_namespace): -# """Gather testing data on pytest run. +@pytest.fixture(scope="session", autouse=True) +def gather_session_data(threadsafe_data_dir): + """Gather testing data on pytest run. + + When running pytest with multiple workers, one worker will copy data remotely to _default_cache_dir while + other workers wait using lockfile. Once the lock is released, all workers will then copy data to their local + threadsafe_data_dir.As this fixture is scoped to the session, it will only run once per pytest run. + + Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset as well as add the + example file paths to the xdoctest_namespace, used when running doctests. + """ + generate_atmos(threadsafe_data_dir) -# When running pytest with multiple workers, one worker will copy data remotely to _default_cache_dir while -# other workers wait using lockfile. Once the lock is released, all workers will then copy data to their local -# threadsafe_data_dir.As this fixture is scoped to the session, it will only run once per pytest run. -# Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset as well as add the -# example file paths to the xdoctest_namespace, used when running doctests. -# """ # if ( # not _default_cache_dir.joinpath(helpers.TESTDATA_BRANCH).exists() # or helpers.PREFETCH_TESTING_DATA @@ -353,7 +356,6 @@ def atmosds(threadsafe_data_dir) -> xr.Dataset: # if lockfile.exists(): # lockfile.unlink() # shutil.copytree(_default_cache_dir, threadsafe_data_dir) -# helpers.generate_atmos(threadsafe_data_dir) # xdoctest_namespace.update(helpers.add_example_file_paths(threadsafe_data_dir)) diff --git a/tests/test_units.py b/tests/test_units.py index 144ff82..271c7d4 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -7,6 +7,7 @@ import pytest import xarray as xr from dask import array as dsk +from packaging.version import Version from xsdba.logging import ValidationError from xsdba.typing import Quantified From e65adcc7288294bbafd29d0d90ba1232d371f749 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Mon, 19 Aug 2024 16:57:04 -0400 Subject: [PATCH 061/105] remove generate_atmos and dependencies --- src/xsdba/testing.py | 40 -------- src/xsdba/utils.py | 215 ------------------------------------------- 2 files changed, 255 deletions(-) diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 2979cd2..08fc591 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -344,43 +344,3 @@ def nancov(X): """Drop observations with NaNs from Numpy's cov.""" X_na = np.isnan(X).any(axis=0) return np.cov(X[:, ~X_na]) - - -# XC -def generate_atmos(cache_dir: Path) -> dict[str, xr.DataArray]: - """Create the `atmosds` synthetic testing dataset.""" - with open_dataset( - "ERA5/daily_surface_cancities_1990-1993.nc", - cache_dir=cache_dir, - branch=TESTDATA_BRANCH, - engine="h5netcdf", - ) as ds: - tn10 = percentile_doy(ds.tasmin, per=10) - t10 = percentile_doy(ds.tas, per=10) - t90 = percentile_doy(ds.tas, per=90) - tx90 = percentile_doy(ds.tasmax, per=90) - - # rsus = shortwave_upwelling_radiation_from_net_downwelling(ds.rss, ds.rsds) - # rlus = longwave_upwelling_radiation_from_net_downwelling(ds.rls, ds.rlds) - - ds = ds.assign( - # rsus=rsus, - # rlus=rlus, - tn10=tn10, - t10=t10, - t90=t90, - tx90=tx90, - ) - - # Create a file in session scoped temporary directory - atmos_file = cache_dir.joinpath("atmosds.nc") - ds.to_netcdf(atmos_file, engine="h5netcdf") - - # Give access to dataset variables by name in namespace - namespace = dict() - with open_dataset( - atmos_file, branch=TESTDATA_BRANCH, cache_dir=cache_dir, engine="h5netcdf" - ) as ds: - for variable in ds.data_vars: - namespace[f"{variable}_dataset"] = ds.get(variable) - return namespace diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index bd5303a..029e3a7 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -964,218 +964,3 @@ def load_module(path: os.PathLike, name: str | None = None): mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) # This executes code, effectively loading the module return mod - - -# calc_perc-needed functions needed for generate_atmos - - -# XC -def calc_perc( - arr: np.ndarray, - percentiles: Sequence[float] | None = None, - alpha: float = 1.0, - beta: float = 1.0, - copy: bool = True, -) -> np.ndarray: - """Compute percentiles using nan_calc_percentiles and move the percentiles' axis to the end.""" - if percentiles is None: - _percentiles = [50.0] - else: - _percentiles = percentiles - - return np.moveaxis( - nan_calc_percentiles( - arr=arr, - percentiles=_percentiles, - axis=-1, - alpha=alpha, - beta=beta, - copy=copy, - ), - source=0, - destination=-1, - ) - - -# XC -def nan_calc_percentiles( - arr: np.ndarray, - percentiles: Sequence[float] | None = None, - axis: int = -1, - alpha: float = 1.0, - beta: float = 1.0, - copy: bool = True, -) -> np.ndarray: - """Convert the percentiles to quantiles and compute them using _nan_quantile.""" - if percentiles is None: - _percentiles = [50.0] - else: - _percentiles = percentiles - - if copy: - # bootstrapping already works on a data's copy - # doing it again is extremely costly, especially with dask. - arr = arr.copy() - quantiles = np.array([per / 100.0 for per in _percentiles]) - return _nan_quantile(arr, quantiles, axis, alpha, beta) - - -# XC -def _nan_quantile( - arr: np.ndarray, - quantiles: np.ndarray, - axis: int = 0, - alpha: float = 1.0, - beta: float = 1.0, -) -> float | np.ndarray: - """Get the quantiles of the array for the given axis. - - A linear interpolation is performed using alpha and beta. - - Notes - ----- - By default, alpha == beta == 1 which performs the 7th method of :cite:t:`hyndman_sample_1996`. - with alpha == beta == 1/3 we get the 8th method. - """ - # --- Setup - data_axis_length = arr.shape[axis] - if data_axis_length == 0: - return np.nan - if data_axis_length == 1: - result = np.take(arr, 0, axis=axis) - return np.broadcast_to(result, (quantiles.size,) + result.shape) - # The dimensions of `q` are prepended to the output shape, so we need the - # axis being sampled from `arr` to be last. - DATA_AXIS = 0 - if axis != DATA_AXIS: # But moveaxis is slow, so only call it if axis!=0. - arr = np.moveaxis(arr, axis, destination=DATA_AXIS) - # nan_count is not a scalar - nan_count = np.isnan(arr).sum(axis=DATA_AXIS).astype(float) - valid_values_count = data_axis_length - nan_count - # We need at least two values to do an interpolation - too_few_values = valid_values_count < 2 - if too_few_values.any(): - # This will result in getting the only available value if it exists - valid_values_count[too_few_values] = np.nan - # --- Computation of indexes - # Add axis for quantiles - valid_values_count = valid_values_count[..., np.newaxis] - virtual_indexes = _compute_virtual_index(valid_values_count, quantiles, alpha, beta) - virtual_indexes = np.asanyarray(virtual_indexes) - previous_indexes, next_indexes = _get_indexes( - arr, virtual_indexes, valid_values_count - ) - # --- Sorting - arr.sort(axis=DATA_AXIS) - # --- Get values from indexes - arr = arr[..., np.newaxis] - previous = np.squeeze( - np.take_along_axis(arr, previous_indexes.astype(int)[np.newaxis, ...], axis=0), - axis=0, - ) - next_elements = np.squeeze( - np.take_along_axis(arr, next_indexes.astype(int)[np.newaxis, ...], axis=0), - axis=0, - ) - # --- Linear interpolation - gamma = _get_gamma(virtual_indexes, previous_indexes) - interpolation = _linear_interpolation(previous, next_elements, gamma) - # When an interpolation is in Nan range, (near the end of the sorted array) it means - # we can clip to the array max value. - result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation) - # Move quantile axis in front - result = np.moveaxis(result, axis, 0) - return result - - -# XC -def _get_gamma(virtual_indexes: np.ndarray, previous_indexes: np.ndarray): - """Compute gamma (AKA 'm' or 'weight') for the linear interpolation of quantiles. - - Parameters - ---------- - virtual_indexes: array_like - The indexes where the percentile is supposed to be found in the sorted sample. - previous_indexes: array_like - The floor values of virtual_indexes. - - Notes - ----- - `gamma` is usually the fractional part of virtual_indexes but can be modified by the interpolation method. - """ - gamma = np.asanyarray(virtual_indexes - previous_indexes) - return np.asanyarray(gamma) - - -# XC -def _compute_virtual_index( - n: np.ndarray, quantiles: np.ndarray, alpha: float, beta: float -): - """Compute the floating point indexes of an array for the linear interpolation of quantiles. - - Based on the approach used by :cite:t:`hyndman_sample_1996`. - - Parameters - ---------- - n : array_like - The sample sizes. - quantiles : array_like - The quantiles values. - alpha : float - A constant used to correct the index computed. - beta : float - A constant used to correct the index computed. - - Notes - ----- - `alpha` and `beta` values depend on the chosen method (see quantile documentation). - - References - ---------- - :cite:cts:`hyndman_sample_1996` - """ - return n * quantiles + (alpha + quantiles * (1 - alpha - beta)) - 1 - - -# XC -def _get_indexes( - arr: np.ndarray, virtual_indexes: np.ndarray, valid_values_count: np.ndarray -) -> tuple[np.ndarray, np.ndarray]: - """Get the valid indexes of arr neighbouring virtual_indexes. - - Notes - ----- - This is a companion function to linear interpolation of quantiles. - - Parameters - ---------- - arr : array-like - virtual_indexes : array-like - valid_values_count : array-like - - Returns - ------- - array-like, array-like - A tuple of virtual_indexes neighbouring indexes (previous and next). - """ - previous_indexes = np.asanyarray(np.floor(virtual_indexes)) - next_indexes = np.asanyarray(previous_indexes + 1) - indexes_above_bounds = virtual_indexes >= valid_values_count - 1 - # When indexes is above max index, take the max value of the array - if indexes_above_bounds.any(): - previous_indexes[indexes_above_bounds] = -1 - next_indexes[indexes_above_bounds] = -1 - # When indexes is below min index, take the min value of the array - indexes_below_bounds = virtual_indexes < 0 - if indexes_below_bounds.any(): - previous_indexes[indexes_below_bounds] = 0 - next_indexes[indexes_below_bounds] = 0 - if np.issubdtype(arr.dtype, np.inexact): - # After the sort, slices having NaNs will have for last element a NaN - virtual_indexes_nans = np.isnan(virtual_indexes) - if virtual_indexes_nans.any(): - previous_indexes[virtual_indexes_nans] = -1 - next_indexes[virtual_indexes_nans] = -1 - previous_indexes = previous_indexes.astype(np.intp) - next_indexes = next_indexes.astype(np.intp) - return previous_indexes, next_indexes From 9f46e401651937792fb281b8dd844f3bb75b9fab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 21 Aug 2024 15:39:08 -0400 Subject: [PATCH 062/105] new numpydoc API --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index c26f620..c9e26f3 100644 --- a/Makefile +++ b/Makefile @@ -57,7 +57,7 @@ clean-test: ## remove test and coverage artifacts lint/flake8: ## check style with flake8 python -m ruff check src/xsdba tests python -m flake8 --config=.flake8 src/xsdba tests - validate-docstrings src/xsdba/**.py + python -m numpydoc validate src/xsdba/**.py lint/black: ## check style with black python -m black --check src/xsdba tests From dee8a1b31ad39611c00ad1af2fbfb9e4a8fd8f74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 28 Aug 2024 13:15:41 -0400 Subject: [PATCH 063/105] update dependencies for github --- pyproject.toml | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index bbf6b18..8bfccb9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,7 @@ maintainers = [ {name = "Trevor James Smith", email = "smith.trevorj@ouranos.ca"} ] readme = {file = "README.rst", content-type = "text/x-rst"} -requires-python = ">=3.8.0" +requires-python = ">=3.9.0" keywords = ["xsdba"] license = {file = "LICENSE"} classifiers = [ @@ -34,7 +34,37 @@ classifiers = [ ] dynamic = ["description", "version"] dependencies = [ - "typer >=0.12.3" + "boltons", + "bottleneck", + "cf_xarray", + "cftime", + "dask", + "jsonpickle", + "numba", + "numpy<2.0", + "pint", + "scipy", + "statsmodels", + "xarray", + "yamale", + "pip >=24.2.0", + "bump-my-version >=0.25.1", + "watchdog >=4.0.0", + "flake8 >=7.1.1", + "flake8-rst-docstrings >=0.3.0", + "flit >=3.9.0,<4.0", + "tox >=4.17.1", + "coverage >=7.5.0", + "coveralls >=4.0.1", + "typer >=0.12.3", + "pytest >=8.3.2", + "pytest-cov >=5.0.0", + "black ==24.8.0", + "blackdoc ==0.3.9", + "isort ==5.13.2", + "numpydoc >=1.8.0", + "pre-commit >=3.5.0", + "ruff >=0.5.7" ] [project.optional-dependencies] From de7f9ab621ce6b899443c05d42ee70847e3247f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 28 Aug 2024 13:23:53 -0400 Subject: [PATCH 064/105] remove py3.8 from testing suite --- .github/workflows/main.yml | 1 - tox.ini | 1 - 2 files changed, 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 37a0b93..cae6f59 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -57,7 +57,6 @@ jobs: strategy: matrix: python-version: - - "3.8" - "3.9" - "3.10" - "3.11" diff --git a/tox.ini b/tox.ini index c39a4a2..30818ad 100644 --- a/tox.ini +++ b/tox.ini @@ -13,7 +13,6 @@ opts = [gh] python = - 3.8 = py38-coveralls 3.9 = py39-coveralls 3.10 = py310-coveralls 3.11 = py311-coveralls From 4c872a5f8d3828a939a0d6ed9073daddd0b77cde Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 28 Aug 2024 16:08:31 -0400 Subject: [PATCH 065/105] remove generate_atmos uses / imports --- tests/conftest.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 28b9f3e..8979844 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -20,7 +20,7 @@ # from filelock import FileLock from packaging.version import Version -from xsdba.testing import TESTDATA_BRANCH, generate_atmos +from xsdba.testing import TESTDATA_BRANCH # , generate_atmos from xsdba.testing import open_dataset as _open_dataset from xsdba.testing import ( test_cannon_2015_dist, @@ -316,19 +316,19 @@ def atmosds(threadsafe_data_dir) -> xr.Dataset: # df.set_index(["scenario", "model", "downscaling", "time"]) # ) +# ADAPT or REMOVE? +# @pytest.fixture(scope="session", autouse=True) +# def gather_session_data(threadsafe_data_dir): +# """Gather testing data on pytest run. -@pytest.fixture(scope="session", autouse=True) -def gather_session_data(threadsafe_data_dir): - """Gather testing data on pytest run. - - When running pytest with multiple workers, one worker will copy data remotely to _default_cache_dir while - other workers wait using lockfile. Once the lock is released, all workers will then copy data to their local - threadsafe_data_dir.As this fixture is scoped to the session, it will only run once per pytest run. +# When running pytest with multiple workers, one worker will copy data remotely to _default_cache_dir while +# other workers wait using lockfile. Once the lock is released, all workers will then copy data to their local +# threadsafe_data_dir.As this fixture is scoped to the session, it will only run once per pytest run. - Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset as well as add the - example file paths to the xdoctest_namespace, used when running doctests. - """ - generate_atmos(threadsafe_data_dir) +# Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset as well as add the +# example file paths to the xdoctest_namespace, used when running doctests. +# """ +# generate_atmos(threadsafe_data_dir) # if ( From 06b353f02a911726cbbadcbc8104f97356ca70b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 29 Aug 2024 13:25:37 -0400 Subject: [PATCH 066/105] pin pytest/xdoctest --- environment-dev.yml | 3 ++- pyproject.toml | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/environment-dev.yml b/environment-dev.yml index 9bb498d..ee9f991 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -29,7 +29,7 @@ dependencies: - coverage >=7.5.0 - coveralls >=4.0.1 - typer >=0.12.3 - - pytest >=8.3.2 + - pytest <8.0.0 - pytest-cov >=5.0.0 - black ==24.8.0 - blackdoc ==0.3.9 @@ -37,3 +37,4 @@ dependencies: - numpydoc >=1.8.0 - pre-commit >=3.5.0 - ruff >=0.5.7 + - xdoctest>=1.1.5 diff --git a/pyproject.toml b/pyproject.toml index 8bfccb9..93b30e4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,14 +57,15 @@ dependencies = [ "coverage >=7.5.0", "coveralls >=4.0.1", "typer >=0.12.3", - "pytest >=8.3.2", + "pytest <8.0.0", "pytest-cov >=5.0.0", "black ==24.8.0", "blackdoc ==0.3.9", "isort ==5.13.2", "numpydoc >=1.8.0", "pre-commit >=3.5.0", - "ruff >=0.5.7" + "ruff >=0.5.7", + "xdoctest>=1.1.5" ] [project.optional-dependencies] From 35442a4e79e0b20ecbd4b1a8cb9d69c1b00ae55a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 29 Aug 2024 13:34:45 -0400 Subject: [PATCH 067/105] remove extra pytest pin --- pyproject.toml | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 93b30e4..d361281 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,15 +57,13 @@ dependencies = [ "coverage >=7.5.0", "coveralls >=4.0.1", "typer >=0.12.3", - "pytest <8.0.0", "pytest-cov >=5.0.0", "black ==24.8.0", "blackdoc ==0.3.9", "isort ==5.13.2", "numpydoc >=1.8.0", "pre-commit >=3.5.0", - "ruff >=0.5.7", - "xdoctest>=1.1.5" + "ruff >=0.5.7" ] [project.optional-dependencies] @@ -82,13 +80,14 @@ dev = [ "coveralls >=4.0.1", "mypy", "numpydoc >=1.8.0; python_version >='3.9'", - "pytest >=8.3.2", + "pytest <8.0.0", "pytest-cov >=5.0.0", "black ==24.8.0", "blackdoc ==0.3.9", "isort ==5.13.2", "ruff >=0.5.7", - "pre-commit >=3.5.0" + "pre-commit >=3.5.0", + "xdoctest>=1.1.5" ] docs = [ # Documentation and examples From ce0935701ab211886649b4b7a28d1f21031bcf75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 29 Aug 2024 13:45:17 -0400 Subject: [PATCH 068/105] add pooch deps --- environment-dev.yml | 1 + pyproject.toml | 2 ++ 2 files changed, 3 insertions(+) diff --git a/environment-dev.yml b/environment-dev.yml index ee9f991..cc62dc6 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -35,6 +35,7 @@ dependencies: - blackdoc ==0.3.9 - isort ==5.13.2 - numpydoc >=1.8.0 + - pooch >=1.8.0 - pre-commit >=3.5.0 - ruff >=0.5.7 - xdoctest>=1.1.5 diff --git a/pyproject.toml b/pyproject.toml index d361281..52ae991 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -86,11 +86,13 @@ dev = [ "blackdoc ==0.3.9", "isort ==5.13.2", "ruff >=0.5.7", + "pooch >=1.8.0", "pre-commit >=3.5.0", "xdoctest>=1.1.5" ] docs = [ # Documentation and examples + "pooch >=1.8.0", "sphinx >=7.0.0", "sphinx-codeautolink", "sphinx-copybutton", From ac280cee16687c9caa1696f9744b72cf82520eb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 13 Sep 2024 12:59:12 -0400 Subject: [PATCH 069/105] xclim as opt dep for prop/meas --- environment-dev.yml | 1 + pyproject.toml | 1 + src/xsdba/_adjustment.py | 2 +- src/xsdba/adjustment.py | 6 +- src/xsdba/indicator.py | 1317 ------------------ src/xsdba/measures.py | 10 +- src/xsdba/properties.py | 10 +- src/xsdba/utils.py | 137 ++ src/xsdba/xclim_submodules/generic.py | 941 ------------- src/xsdba/xclim_submodules/run_length.py | 1538 ---------------------- 10 files changed, 152 insertions(+), 3811 deletions(-) delete mode 100644 src/xsdba/indicator.py delete mode 100644 src/xsdba/xclim_submodules/generic.py delete mode 100644 src/xsdba/xclim_submodules/run_length.py diff --git a/environment-dev.yml b/environment-dev.yml index cc62dc6..e46ae2f 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -39,3 +39,4 @@ dependencies: - pre-commit >=3.5.0 - ruff >=0.5.7 - xdoctest>=1.1.5 + - xclim>=0.52 diff --git a/pyproject.toml b/pyproject.toml index 52ae991..2431739 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -110,6 +110,7 @@ docs = [ "sphinxcontrib-bibtex", "sphinxcontrib-svg2pdfconverter[Cairosvg]" ] +extras = ["xclim>=0.52"] all = ["xsdba[dev]", "xsdba[docs]"] [project.scripts] diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index d6a5568..3fae1ed 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -22,7 +22,7 @@ from .options import set_options from .processing import escore, jitter_under_thresh, reordering, standardize from .units import convert_units_to, units -from .xclim_submodules.stats import _fitfunc_1d +from .utils import _fitfunc_1d def _adapt_freq_hist(ds: xr.Dataset, adapt_freq_thresh: str): diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index a9a4787..124d212 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -11,6 +11,7 @@ import numpy as np import xarray as xr +from scipy import stats from xarray.core.dataarray import DataArray from xsdba.base import get_calendar @@ -45,7 +46,6 @@ pc_matrix, rand_rot_matrix, ) -from .xclim_submodules import stats __all__ = [ "LOCI", @@ -747,7 +747,7 @@ def _train( ), q_thresh=q_thresh, cluster_thresh=cluster_thresh, - dist=stats.get_dist("genpareto"), + dist=stats.genpareto, quantiles=np.arange(int(N)), group="time", ) @@ -787,7 +787,7 @@ def _adjust( scen = extremes_adjust( ds.assign(sim=sim, scen=scen), cluster_thresh=self.cluster_thresh, - dist=stats.get_dist("genpareto"), + dist=stats.genpareto, frac=frac, power=power, interp=interp, diff --git a/src/xsdba/indicator.py b/src/xsdba/indicator.py deleted file mode 100644 index 9fec173..0000000 --- a/src/xsdba/indicator.py +++ /dev/null @@ -1,1317 +0,0 @@ -"""# noqa: SS01 -Indicator Utilities -=================== - -The `Indicator` class wraps indices computations with pre- and post-processing functionality. Prior to computations, -the class runs data and metadata health checks. After computations, the class masks values that should be considered -missing and adds metadata attributes to the object. - -There are many ways to construct indicators. A good place to start is -`this notebook <notebooks/extendxclim.ipynb#Defining-new-indicators>`_. - -Dictionary and YAML parser # noqa: GL06 --------------------------- # noqa: GL06 - -To construct indicators dynamically, xclim can also use dictionaries and parse them from YAML files. -This is especially useful for generating whole indicator "submodules" from files. -This functionality is inspired by the work of `clix-meta <https://github.com/clix-meta/clix-meta/>`_. - -YAML file structure -~~~~~~~~~~~~~~~~~~~ - -Indicator-defining yaml files are structured in the following way. -Most entries of the `indicators` section are mirroring attributes of -the :py:class:`Indicator`, please refer to its documentation for more -details on each. - -.. code-block:: yaml - - module: <module name> # Defaults to the file name - realm: <realm> # If given here, applies to all indicators that do not already provide it. - keywords: <keywords> # Merged with indicator-specific keywords (joined with a space) - references: <references> # Merged with indicator-specific references (joined with a new line) - base: <base indicator class> # Defaults to "Daily" and applies to all indicators that do not give it. - doc: <module docstring> # Defaults to a minimal header, only valid if the module doesn't already exist. - variables: # Optional section if indicators declared below rely on variables unknown to xclim - # (not in `xclim.core.utils.VARIABLES`) - # The variables are not module-dependent and will overwrite any already existing with the same name. - <varname>: - canonical_units: <units> # required - description: <description> # required - standard_name: <expected standard_name> # optional - cell_methods: <expected cell_methods> # optional - indicators: - <identifier>: - # From which Indicator to inherit - base: <base indicator class> # Defaults to module-wide base class - # If the name startswith a '.', the base class is taken from the current module - # (thus an indicator declared _above_). - # Available classes are listed in `xsdba.indicator.registry` and - # `xsdba.indicator.base_registry`. - - # General metadata, usually parsed from the `compute`'s docstring when possible. - realm: <realm> # defaults to module-wide realm. One of "atmos", "land", "seaIce", "ocean". - title: <title> - abstract: <abstract> - keywords: <keywords> # Space-separated, merged to module-wide keywords. - references: <references> # newline-seperated, merged to module-wide references. - notes: <notes> - - # Other options - missing: <missing method name> - missing_options: - # missing options mapping - allowed_periods: [<list>, <of>, <allowed>, <periods>] - - # Compute function - compute: <function name> # Referring to a function in `Indices` module (xclim.indices.generic or xclim.indices) - input: # When "compute" is a generic function, this is a mapping from argument name to the expected variable. - # This will allow the input units and CF metadata checks to run on the inputs. - # Can also be used to modify the expected variable, as long as it has the same dimensionality - # Ex: tas instead of tasmin. - # Can refer to a variable declared in the `variables` section above. - <var name in compute> : <variable official name> - ... - -.. code-block:: restructuredtext - - Parameters # noqa: D214 - ---------- # noqa: D215 - <param name> : <param data> # Simplest case, to inject parameters in the compute function. - <param name> : # To change parameters metadata or to declare units when "compute" is a generic function. - units : <param units> # Only valid if "compute" points to a generic function - default : <param default> - description : <param description> - kind : <param kind> # Override the parameter kind. - # This is mostly useful for transforming an optional variable into a required one by passing ``kind: 0``. - ... - -All fields are optional. Other fields found in the yaml file will trigger errors in xclim. -In the following, the section under `<identifier>` is referred to as `data`. When creating indicators from -a dictionary, with :py:meth:`Indicator.from_dict`, the input dict must follow the same structure of `data`. - -When a module is built from a yaml file, the yaml is first validated against the schema (see xclim/data/schema.yml) -using the YAMALE library (:cite:p:`lopker_yamale_2022`). See the "Extending xclim" notebook for more info. - -Inputs -~~~~~~ -As xclim has strict definitions of possible input variables (see :py:data:`xclim.core.utils.variables`), -the mapping of `data.input` simply links an argument name from the function given in "compute" -to one of those official variables. -""" - -from __future__ import annotations - -import re -import warnings -import weakref -from collections import OrderedDict, defaultdict -from collections.abc import Sequence -from copy import deepcopy -from dataclasses import asdict, dataclass -from functools import reduce -from inspect import Parameter as _Parameter -from inspect import Signature -from inspect import _empty as _empty_default -from inspect import signature -from os import PathLike -from pathlib import Path -from types import ModuleType -from typing import Any, Callable, Optional, Union - -import numpy as np -import xarray -import yamale -from xarray import DataArray, Dataset -from yaml import safe_load - -from .base import Grouper, infer_kind_from_parameter -from .calendar import parse_offset -from .datachecks import is_percentile_dataarray -from .formatting import ( - AttrFormatter, - default_formatter, - gen_call_string, - generate_indicator_docstring, - get_percentile_metadata, - merge_attributes, - parse_doc, - update_history, -) -from .locales import ( - TRANSLATABLE_ATTRS, - get_local_attrs, - get_local_formatter, - load_locale, - read_locale_file, -) -from .logging import MissingVariableError, ValidationError, raise_warn_or_log -from .options import ( - AS_DATASET, - CHECK_MISSING, - KEEP_ATTRS, - METADATA_LOCALES, - MISSING_METHODS, - MISSING_OPTIONS, - OPTIONS, -) -from .typing import InputKind -from .units import convert_units_to, units -from .utils import load_module - -# Indicators registry -registry = {} # Main class registry -base_registry = {} -_indicators_registry = defaultdict(list) # Private instance registry - - -class _empty: - pass - - -@dataclass -class Parameter: - """Class for storing an indicator's controllable parameter. - - For retrocompatibility, this class implements a "getitem" and a special "contains". - - Example - ------- - >>> p = Parameter(InputKind.NUMBER, default=2, description="A simple number") - >>> p.units is Parameter._empty # has not been set - True - >>> "units" in p # Easier/retrocompatible way to test if units are set - False - >>> p.description - 'A simple number' - """ - - _empty = _empty - - kind: InputKind - default: Any = _empty_default - description: str = "" - units: str = _empty - choices: set = _empty - value: Any = _empty - - def update(self, other: dict) -> None: - """Update a parameter's values from a dict.""" - for k, v in other.items(): - if hasattr(self, k): - setattr(self, k, v) - else: - raise AttributeError(f"Unexpected parameter field '{k}'.") - - @classmethod - def is_parameter_dict(cls, other: dict) -> bool: - """Return whether indicator has a parameter dictionary.""" - return set(other.keys()).issubset( - cls.__dataclass_fields__.keys() # pylint: disable=no-member - ) - - # def __getitem__(self, key) -> str: - # """Return an item in retro-compatible fashion.""" - # try: - # return str(getattr(self, key)) - # except AttributeError as err: - # raise KeyError(key) from err - - def __contains__(self, key) -> bool: - """Imitate previous behaviour where "units" and "choices" were missing, instead of being "_empty".""" - return getattr(self, key, _empty) is not _empty - - def asdict(self) -> dict: - """Format indicators as a dictionary.""" - return {k: v for k, v in asdict(self).items() if v is not _empty} - - @property - def injected(self) -> bool: - """Indicate whether values are injected.""" - return self.value is not _empty - - -class IndicatorRegistrar: - """Climate Indicator registering object.""" - - def __new__(cls): - """Add subclass to registry.""" - name = cls.__name__.upper() - module = cls.__module__ - # If the module is not one of xclim's default, prepend the submodule name. - if module.startswith("xclim.indicators"): - submodule = module.split(".")[2] - if submodule not in ["atmos", "generic", "land", "ocean", "seaIce"]: - name = f"{submodule}.{name}" - else: - name = f"{module}.{name}" - if name in registry: - warnings.warn( - f"Class {name} already exists and will be overwritten.", stacklevel=1 - ) - registry[name] = cls - cls._registry_id = name - return super().__new__(cls) - - def __init__(self): - _indicators_registry[self.__class__].append(weakref.ref(self)) - - @classmethod - def get_instance(cls): - """Return first found instance. - - Raises `ValueError` if no instance exists. - """ - for inst_ref in _indicators_registry[cls]: - inst = inst_ref() - if inst is not None: - return inst - raise ValueError( - f"There is no existing instance of {cls.__name__}. " - "Either none were created or they were all garbage-collected." - ) - - -class Indicator(IndicatorRegistrar): - r"""Climate indicator base class. - - Climate indicator object that, when called, computes an indicator and assigns its output a number of - CF-compliant attributes. Some of these attributes can be *templated*, allowing metadata to reflect - the value of call arguments. - - Instantiating a new indicator returns an instance but also creates and registers a custom subclass - in :py:data:`xsdba.indicator.registry`. - - Attributes in `Indicator.cf_attrs` will be formatted and added to the output variable(s). - This attribute is a list of dictionaries. For convenience and retro-compatibility, - standard CF attributes (names listed in :py:attr:`xsdba.indicator.Indicator._cf_names`) - can be passed as strings or list of strings directly to the indicator constructor. - - A lot of the Indicator's metadata is parsed from the underlying `compute` function's - docstring and signature. Input variables and parameters are listed in - :py:attr:`xsdba.indicator.Indicator.parameters`, while parameters that will be - injected in the compute function are in :py:attr:`xsdba.indicator.Indicator.injected_parameters`. - Both are simply views of :py:attr:`xsdba.indicator.Indicator._all_parameters`. - - Compared to their base `compute` function, indicators add the possibility of using dataset as input, - with the injected argument `ds` in the call signature. All arguments that were indicated - by the compute function to be variables (DataArrays) through annotations will be promoted - to also accept strings that correspond to variable names in the `ds` dataset. - - Parameters - ---------- - identifier : str - Unique ID for class registry, should be a valid slug. - realm : {'atmos', 'seaIce', 'land', 'ocean'} - General domain of validity of the indicator. Indicators created outside xclim.indicators must set this attribute. - compute : func - The function computing the indicators. It should return one or more DataArray. - cf_attrs : list of dicts - Attributes to be formatted and added to the computation's output. - See :py:attr:`xsdba.indicator.Indicator.cf_attrs`. - title : str - A succinct description of what is in the computed outputs. Parsed from `compute` docstring if None (first paragraph). - abstract : str - A long description of what is in the computed outputs. Parsed from `compute` docstring if None (second paragraph). - keywords : str - Comma separated list of keywords. Parsed from `compute` docstring if None (from a "Keywords" section). - references : str - Published or web-based references that describe the data or methods used to produce it. Parsed from - `compute` docstring if None (from the "References" section). - notes : str - Notes regarding computing function, for example the mathematical formulation. Parsed from `compute` - docstring if None (form the "Notes" section). - src_freq : str, sequence of strings, optional - The expected frequency of the input data. Can be a list for multiple frequencies, or None if irrelevant. - context : str - The `pint` unit context, for example use 'hydro' to allow conversion from kg m-2 s-1 to mm/day. - - Notes - ----- - All subclasses created are available in the `registry` attribute and can be used to define custom subclasses - or parse all available instances. - """ - - # Officially-supported metadata attributes on the output variables - _cf_names = [ - "var_name", - "standard_name", - "long_name", - "units", - "cell_methods", - "description", - "comment", - ] - - # metadata fields that are formatted as free text (first letter capitalized) - _text_fields = ["long_name", "description", "comment"] - # Class attributes that are function (so we know which to convert to static methods) - _funcs = ["compute"] - # Mapping from name in the compute function to official (CMIP6) variable name - _variable_mapping = {} - - # Will become the class's name - identifier = None - - context = "none" - src_freq = None - - # Global metadata (must be strings, not attributed to the output) - realm = None - title = "" - abstract = "" - keywords = "" - references = "" - notes = "" - _version_deprecated = "" - - # Note: typing and class types in this call signature will cause errors with sphinx-autodoc-typehints - # See: https://github.com/tox-dev/sphinx-autodoc-typehints/issues/186#issuecomment-1450739378 - _all_parameters: dict = {} - """A dictionary mapping metadata about the input parameters to the indicator. - - Keys are the arguments of the "compute" function. All parameters are listed, even - those "injected", absent from the indicator's call signature. All are instances of - :py:class:`xsdba.indicator.Parameter`. - """ - - # Note: typing and class types in this call signature will cause errors with sphinx-autodoc-typehints - # See: https://github.com/tox-dev/sphinx-autodoc-typehints/issues/186#issuecomment-1450739378 - cf_attrs: list[dict[str, str]] = None - """A list of metadata information for each output of the indicator. - - It minimally contains a "var_name" entry, and may contain : "standard_name", "long_name", - "units", "cell_methods", "description" and "comment" on official xclim indicators. Other - fields could also be present if the indicator was created from outside xclim. - - var_name: - Output variable(s) name(s). For derived single-output indicators, this field is not - inherited from the parent indicator and defaults to the identifier. - standard_name: - Variable name, must be in the CF standard names table (this is not checked). - long_name: - Descriptive variable name. Parsed from `compute` docstring if not given. - (first line after the output dtype, only works on single output function). - units: - Representative units of the physical quantity. - cell_methods: - List of blank-separated words of the form "name: method". Must respect the - CF-conventions and vocabulary (not checked). - description: - Sentence(s) meant to clarify the qualifiers of the fundamental quantities, such as which - surface a quantity is defined on or what the flux sign conventions are. - comment: - Miscellaneous information about the data or methods used to produce it. - """ - - def __new__(cls, **kwds): # noqa: C901 - """Create subclass from arguments.""" - identifier = kwds.get("identifier", cls.identifier) - if identifier is None: - raise AttributeError("`identifier` has not been set.") - - if "compute" in kwds: - # Parsed parameters and metadata override parent's params entirely. - parameters, docmeta = cls._parse_indice( - kwds["compute"], kwds.get("parameters", {}) - ) - for name, value in docmeta.items(): - # title, abstract, references, notes, long_name - kwds.setdefault(name, value) - - # Inject parameters (subclasses can override or extend this through _injected_parameters) - for name, param in cls._injected_parameters(): - if name in parameters: - raise ValueError( - f"Class {cls.__name__} can't wrap indices that have a `{name}`" - " argument as it conflicts with arguments it injects." - ) - parameters[name] = param - else: # inherit parameters from base class - parameters = deepcopy(cls._all_parameters) - - # Update parameters with passed parameters - cls._update_parameters(parameters, kwds.pop("parameters", {})) - - # Input variable mapping (to change variable names in signature and expected units/cf attrs). - cls._parse_var_mapping(kwds.pop("input", {}), parameters, kwds) - - # Raise on incorrect params, sort params, modify var defaults in-place if needed - parameters = cls._ensure_correct_parameters(parameters) - - # If needed, wrap compute with declare units - if "compute" in kwds: - if not hasattr(kwds["compute"], "in_units") and "_variable_mapping" in kwds: - # We actually need the inverse mapping (to get cmip6 name -> arg name) - inv_var_map = dict(map(reversed, kwds["_variable_mapping"].items())) - # parameters has already been update above. - # kwds["compute"] = declare_units( - # **{ - # inv_var_map[k]: m.units - # for k, m in parameters.items() - # if "units" in m and k in inv_var_map - # } - # )(kwds["compute"]) - - if hasattr(kwds["compute"], "in_units"): - varmap = kwds.get("_variable_mapping", {}) - for name, unit in kwds["compute"].in_units.items(): - parameters[varmap.get(name, name)].units = unit - - # All updates done. - kwds["_all_parameters"] = parameters - - # Parse kwds to organize `cf_attrs` - # And before converting callables to static methods - kwds["cf_attrs"] = cls._parse_output_attrs(kwds, identifier) - # Parse keywords - if "keywords" in kwds: - kwds["keywords"] = cls.keywords + " " + kwds.get("keywords") - - # Convert function objects to static methods. - for key in cls._funcs: - if key in kwds and callable(kwds[key]): - kwds[key] = staticmethod(kwds[key]) - - # ADAPT: Get rid of this - # Infer realm for built-in xclim instances - # if cls.__module__.startswith(__package__.split(".", maxsplit=1)[0]): - # xclim_realm = cls.__module__.split(".")[2] - # else: - xclim_realm = None - - # ADAPT: Get rid of this - # Priority given to passed realm -> parent's realm -> location of the class declaration (official inds only) - kwds.setdefault("realm", cls.realm or xclim_realm) - # if kwds["realm"] not in ["atmos", "seaIce", "land", "ocean", "generic"]: - # raise AttributeError( - # "Indicator's realm must be given as one of 'atmos', 'seaIce', 'land', 'ocean' or 'generic'" - # ) - - # Create new class object - new = type(identifier.upper(), (cls,), kwds) - - # Forcing the module is there so YAML-generated submodules are correctly seen by IndicatorRegistrar. - if kwds.get("module") is not None: - new.__module__ = f"xclim.indicators.{kwds['module']}" - else: - # If the module was not forced, set the module to the base class' module. - # Otherwise, all indicators will have module `xsdba.indicator`. - new.__module__ = cls.__module__ - - # Add the created class to the registry - # This will create an instance from the new class and call __init__. - return super().__new__(new) - - @staticmethod - def _parse_indice(compute, passed_parameters): # noqa: F841 - """Parse the compute function. - - - Metadata is extracted from the docstring - - Parameters are parsed from the docstring (description, choices), decorator (units), signature (kind, default) - - 'passed_parameters' is only needed when compute is a generic function - (not decorated by `declare_units`) and it takes a string parameter. In that case - we need to check if that parameter has units (which have been passed explicitly). - """ - docmeta = parse_doc(compute.__doc__) - params_dict = docmeta.pop("parameters", {}) # override parent's parameters - - compute_sig = signature(compute) - # Check that the `Parameters` section of the docstring does not include parameters - # that are not in the `compute` function signature. - if not set(params_dict.keys()).issubset(compute_sig.parameters.keys()): - raise ValueError( - f"Malformed docstring on {compute} : the parameters " - f"{set(params_dict.keys()) - set(compute_sig.parameters.keys())} " - "are absent from the signature." - ) - for name, param in compute_sig.parameters.items(): - meta = params_dict.setdefault(name, {}) - meta["default"] = param.default - meta["kind"] = infer_kind_from_parameter(param) - - parameters = {name: Parameter(**param) for name, param in params_dict.items()} - return parameters, docmeta - - @classmethod - def _injected_parameters(cls): - """Create a list of tuples for arguments to inject, (name, Parameter).""" - return [ - ( - "ds", - Parameter( - kind=InputKind.DATASET, - default=None, - description="A dataset with the variables given by name.", - ), - ) - ] - - @classmethod - def _update_parameters(cls, parameters, passed): - """Update parameters with the ones passed.""" - try: - for key, val in passed.items(): - if isinstance(val, dict) and Parameter.is_parameter_dict(val): - # modified meta - parameters[key].update(val) - elif key in parameters: - parameters[key].value = val - else: - raise KeyError(key) - except KeyError as err: - raise ValueError( - f"Parameter {err} was passed but it does not exist on the " - f"compute function (not one of {parameters.keys()})" - ) from err - - @classmethod - def _parse_var_mapping(cls, variable_mapping, parameters, kwds): - """Parse the variable mapping passed in `input` and update `parameters` in-place.""" - # Update parameters - for old_name, new_name in variable_mapping.items(): - meta = parameters[new_name] = parameters.pop(old_name) - # try: - # varmeta = VARIABLES[new_name] - # except KeyError as err: - # raise ValueError( - # f"Compute argument {old_name} was mapped to variable " - # f"{new_name} which is not understood by xclim or CMIP6. Please" - # " use names listed in `xclim.core.utils.VARIABLES`." - # ) from err - # if meta.units is not _empty: - # try: - # check_units(varmeta["canonical_units"], meta.units) - # except ValidationError as err: - # raise ValueError( - # "When changing the name of a variable by passing `input`, " - # "the units dimensionality must stay the same. Got: old = " - # f"{meta.units}, new = {varmeta['canonical_units']}" - # ) from err - # meta.units = varmeta.get("dimensions", varmeta["canonical_units"]) - # meta.description = varmeta["description"] - - if variable_mapping: - # Update mapping attribute - new_variable_mapping = deepcopy(cls._variable_mapping) - new_variable_mapping.update(variable_mapping) - kwds["_variable_mapping"] = new_variable_mapping - - @classmethod - def _ensure_correct_parameters(cls, parameters): - """Ensure the parameters are correctly set and ordered.""" - # Set default values, otherwise the signature binding chokes - # on missing arguments when passing only `ds`. - for name, meta in parameters.items(): - if not meta.injected: - if meta.kind == InputKind.OPTIONAL_VARIABLE: - meta.default = None - elif meta.kind in [InputKind.VARIABLE]: - meta.default = name - - # Sort parameters : Var, Opt Var, all params, ds, injected params. - def sortkey(kv): - if not kv[1].injected: - if kv[1].kind in [ - InputKind.VARIABLE, - InputKind.OPTIONAL_VARIABLE, - InputKind.KWARGS, - ]: - return kv[1].kind - return 2 - return 99 - - return dict(sorted(parameters.items(), key=sortkey)) - - @classmethod - def _parse_output_attrs( # noqa: C901 - cls, kwds: dict[str, Any], identifier: str - ) -> list[dict[str, str | Callable]]: - """CF-compliant metadata attributes for all output variables.""" - parent_cf_attrs = cls.cf_attrs - cf_attrs = kwds.get("cf_attrs") - if isinstance(cf_attrs, dict): - # Single output indicator, but we store as a list anyway. - cf_attrs = [cf_attrs] - elif cf_attrs is None: - # Attributes were passed the "old" way, with lists or strings directly (only _cf_names) - # We need to get the number of outputs first, defaulting to the length of parent's cf_attrs or 1 - n_outs = len(parent_cf_attrs) if parent_cf_attrs is not None else 1 - for name in cls._cf_names: - arg = kwds.get(name) - if isinstance(arg, (tuple, list)): - n_outs = len(arg) - - # Populate new cf_attrs from parsing cf_names passed directly. - cf_attrs = [{} for _ in range(n_outs)] - for name in cls._cf_names: - values = kwds.pop(name, None) - if values is None: # None passed, skip - continue - if not isinstance(values, (tuple, list)): - # a single string or callable, same for all outputs - values = [values] * n_outs - elif len(values) != n_outs: # A sequence of the wrong length. - raise ValueError( - f"Attribute {name} has {len(values)} elements but xclim expected {n_outs}." - ) - for attrs, value in zip(cf_attrs, values): - if value: # Skip the empty ones (None or "") - attrs[name] = value - # else we assume a list of dicts - - # For single output, var_name defaults to identifier. - if len(cf_attrs) == 1 and "var_name" not in cf_attrs[0]: - cf_attrs[0]["var_name"] = identifier - - # update from parent, if they have the same length. - if parent_cf_attrs is not None and len(parent_cf_attrs) == len(cf_attrs): - for old, new in zip(parent_cf_attrs, cf_attrs): - for attr, value in old.items(): - new.setdefault(attr, value) - - # check if we have var_names for everybody - for i, var in enumerate(cf_attrs, start=1): - if "var_name" not in var: - raise ValueError(f"Output #{i} is missing a var_name! Got: {var}.") - - return cf_attrs - - @classmethod - def from_dict( - cls, - data: dict, - identifier: str, - module: str | None = None, - ): - """Create an indicator subclass and instance from a dictionary of parameters. - - Most parameters are passed directly as keyword arguments to the class constructor, except: - - - "base" : A subclass of Indicator or a name of one listed in - :py:data:`xsdba.indicator.registry` or - :py:data:`xsdba.indicator.base_registry`. When passed, it acts as if - `from_dict` was called on that class instead. - - "compute" : A string function name translates to a - :py:mod:`xclim.indices.generic` or :py:mod:`xclim.indices` function. - - Parameters - ---------- - data: dict - The exact structure of this dictionary is detailed in the submodule documentation. - identifier : str - The name of the subclass and internal indicator name. - module : str - The module name of the indicator. This is meant to be used only if the indicator - is part of a dynamically generated submodule, to override the module of the base class. - """ - data = data.copy() - if "base" in data: - if isinstance(data["base"], str): - parts = data["base"].split(".") - registry_id = ".".join([*parts[:-1], parts[-1].upper()]) - cls = registry.get(registry_id, base_registry.get(data["base"])) - if cls is None: - raise ValueError( - f"Requested base class {data['base']} is neither in the " - "indicators registry nor in base classes registry." - ) - else: - cls = data["base"] - - compute = data.get("compute", None) - # data.compute refers to a function in xclim.indices.generic or xclim.indices (in this order of priority). - # It can also directly be a function (like if a module was passed to build_indicator_module_from_yaml) - if isinstance(compute, str): - compute_func = getattr( - indices.generic, compute, getattr(indices, compute, None) - ) - if compute_func is None: - raise ImportError( - f"Indice function {compute} not found in xclim.indices or " - "xclim.indices.generic." - ) - data["compute"] = compute_func - - return cls(identifier=identifier, module=module, **data) - - def __init__(self, **kwds): - """Run checks and organizes the metadata.""" - # keywords of kwds that are class attributes have already been set in __new__ - self._check_identifier(self.identifier) - - # Validation is done : register the instance. - super().__init__() - - self.__signature__ = self._gen_signature() - - # Generate docstring - self.__doc__ = generate_indicator_docstring(self) - - def _gen_signature(self): - """Generate the correct signature.""" - # Update call signature - variables = [] - parameters = [] - compute_sig = signature(self.compute) - for name, meta in self.parameters.items(): - if meta.kind in [ - InputKind.VARIABLE, - InputKind.OPTIONAL_VARIABLE, - ]: - annot = Union[DataArray, str] - if meta.kind == InputKind.OPTIONAL_VARIABLE: - annot = Optional[annot] - variables.append( - _Parameter( - name, - kind=_Parameter.POSITIONAL_OR_KEYWORD, - default=meta.default, - annotation=annot, - ) - ) - elif meta.kind == InputKind.KWARGS: - parameters.append(_Parameter(name, kind=_Parameter.VAR_KEYWORD)) - elif meta.kind == InputKind.DATASET: - parameters.append( - _Parameter( - name, - kind=_Parameter.KEYWORD_ONLY, - annotation=Dataset, - default=meta.default, - ) - ) - else: - parameters.append( - _Parameter( - name, - kind=_Parameter.KEYWORD_ONLY, - default=meta.default, - annotation=compute_sig.parameters[name].annotation, - ) - ) - - ret_ann = DataArray if self.n_outs == 1 else tuple[(DataArray,) * self.n_outs] - return Signature(variables + parameters, return_annotation=ret_ann) - - def __call__(self, *args, **kwds): - """Call function of Indicator class.""" - # Put the variables in `das`, parse them according to the following annotations: - # das : OrderedDict of variables (required + non-None optionals) - # params : OrderedDict of parameters (var_kwargs as a single argument, if any) - - if self._version_deprecated: - self._show_deprecation_warning() - - das, params, dsattrs = self._parse_variables_from_call(args, kwds) - - if OPTIONS[KEEP_ATTRS] is True or ( - OPTIONS[KEEP_ATTRS] == "xarray" - and xarray.core.options._get_keep_attrs(False) - ): - out_attrs = xarray.core.merge.merge_attrs( - [da.attrs for da in das.values()], "drop_conflicts" - ) - out_attrs.pop("units", None) - else: - out_attrs = {} - out_attrs = [out_attrs.copy() for i in range(self.n_outs)] - - # Get correct variable names for the compute function. - inv_var_map = dict(map(reversed, self._variable_mapping.items())) - compute_das = {inv_var_map.get(nm, nm): das[nm] for nm in das} - - # Compute the indicator values, ignoring NaNs and missing values. - # Filter the passed parameters to only keep the ones needed by compute. - kwargs = {} - var_kwargs = {} - for nm, pa in signature(self.compute).parameters.items(): - if pa.kind == _Parameter.VAR_KEYWORD: - var_kwargs = params[nm] - elif nm not in compute_das and nm in params: - kwargs[nm] = params[nm] - - with xarray.set_options(keep_attrs=False): - outs = self.compute(**compute_das, **kwargs, **var_kwargs) - - if isinstance(outs, DataArray): - outs = [outs] - - if len(outs) != self.n_outs: - raise ValueError( - f"Indicator {self.identifier} was wrongly defined. Expected " - f"{self.n_outs} outputs, got {len(outs)}." - ) - - # Metadata attributes from templates - var_id = None - for out, attrs, base_attrs in zip(outs, out_attrs, self.cf_attrs): - if self.n_outs > 1: - var_id = base_attrs["var_name"] - attrs.update(units=out.units) - attrs.update( - self._update_attrs( - params.copy(), - das, - base_attrs, - names=self._cf_names, - var_id=var_id, - ) - ) - - # Convert to output units - outs = [ - convert_units_to(out, attrs["units"]) for out, attrs in zip(outs, out_attrs) - ] - - outs = self._postprocess(outs, das, params) - - # Update variable attributes - for out, attrs in zip(outs, out_attrs): - var_name = attrs.pop("var_name") - out.attrs.update(attrs) - out.name = var_name - - if OPTIONS[AS_DATASET]: - out = Dataset({o.name: o for o in outs}) - if OPTIONS[KEEP_ATTRS] is True or ( - OPTIONS[KEEP_ATTRS] == "xarray" - and xarray.core.options._get_keep_attrs(False) - ): - out.attrs.update(dsattrs) - out.attrs["history"] = update_history( - self._history_string(das, params), - out, - new_name=self.identifier, - ) - return out - - # Return a single DataArray in case of single output, otherwise a tuple - if self.n_outs == 1: - return outs[0] - return tuple(outs) - - def _parse_variables_from_call(self, args, kwds) -> tuple[OrderedDict, dict]: - """Extract variable and optional variables from call arguments.""" - # Bind call arguments to `compute` arguments and set defaults. - ba = self.__signature__.bind(*args, **kwds) - ba.apply_defaults() - - # Assign inputs passed as strings from ds. - self._assign_named_args(ba) - - # Extract variables + inject injected - das = OrderedDict() - params = ba.arguments.copy() - for name, param in self._all_parameters.items(): - if not param.injected: - # If a variable pop the arg - if is_percentile_dataarray(params[name]): - # duplicate percentiles DA in both das and params - das[name] = params[name] - elif param.kind in [InputKind.VARIABLE, InputKind.OPTIONAL_VARIABLE]: - data = params.pop(name) - # If a non-optional variable OR None, store the arg - if param.kind == InputKind.VARIABLE or data is not None: - das[name] = data - else: - params[name] = param.value - - ds = ba.arguments.get("ds") - dsattrs = ds.attrs if ds is not None else {} - return das, params, dsattrs - - def _assign_named_args(self, ba): - """Assign inputs passed as strings from ds.""" - ds = ba.arguments.get("ds") - - for name, val in ba.arguments.items(): - kind = self.parameters[name].kind - - if kind <= InputKind.OPTIONAL_VARIABLE: - if isinstance(val, str) and ds is None: - raise ValueError( - "Passing variable names as string requires giving the `ds` " - f"dataset (got {name}='{val}')" - ) - if (isinstance(val, str) or val is None) and ds is not None: - # Set default name for DataArray - key = val or name - - if key in ds: - ba.arguments[name] = ds[key] - elif kind == InputKind.VARIABLE: - raise MissingVariableError( - f"For input '{name}', variable '{key}' " - "was not found in the input dataset." - ) - - def _postprocess(self, outs, das, params): - """Run post-computation actions.""" - return outs - - def _bind_call(self, func, **das): - """Call function using `__call__` `DataArray` arguments. - - This will try to bind keyword arguments to `func` arguments. If this fails, - `func` is called with positional arguments only. - - Notes - ----- - This method is used to support two main use cases. - - In use case #1, we have two compute functions with arguments in a different order: - `func1(tasmin, tasmax)` and `func2(tasmax, tasmin)` - - In use case #2, we have two compute functions with arguments that have different names: - `generic_func(da)` and `custom_func(tas)` - - Passing a dictionary of arguments will solve #1, but not #2. - """ - # First try to bind arguments to function. - try: - ba = signature(func).bind(**das) - except TypeError: - # If this fails, simply call the function using positional arguments - return func(*das.values()) - else: - # Call the func using bound arguments - return func(*ba.args, **ba.kwargs) - - @classmethod - def _get_translated_metadata( - cls, locale, var_id=None, names=None, append_locale_name=True - ): - """Get raw translated metadata for the current indicator and a given locale. - - All available translated metadata from the current indicator and those it is - based on are merged, with the highest priority set to the current one. - """ - var_id = var_id or "" - if var_id: - var_id = "." + var_id - - family_tree = [] - cl = cls - while hasattr(cl, "_registry_id"): - family_tree.append(cl._registry_id + var_id) - # The indicator mechanism always has single inheritance. - cl = cl.__bases__[0] - - return get_local_attrs( - family_tree, - locale, - names=names, - append_locale_name=append_locale_name, - ) - - def _update_attrs( - self, - args: dict[str, Any], - das: dict[str, DataArray], - attrs: dict[str, str], - var_id: str | None = None, - names: Sequence[str] | None = None, - ): - """Format attributes with the run-time values of `compute` call parameters. - - Cell methods and history attributes are updated, adding to existing values. - The language of the string is taken from the `OPTIONS` configuration dictionary. - - Parameters - ---------- - args : dict[str, Any] - Keyword arguments of the `compute` call. - das : dict[str, DataArray] - Input arrays. - attrs : dict[str, str] - The attributes to format and update. - var_id : str - The identifier to use when requesting the attributes translations. - Defaults to the class name (for the translations) or the `identifier` field of - the class (for the history attribute). - If given, the identifier will be converted to uppercase to get the translation - attributes. This is meant for multi-outputs indicators. - names : sequence of str, optional - List of attribute names for which to get a translation. - - Returns - ------- - dict - Attributes with {} expressions replaced by call argument values. With updated `cell_methods` and `history`. - `cell_methods` is not added if `names` is given and those not contain `cell_methods`. - """ - # FIXME: Some tests fail without this, the groups are not properly parsed before - # e.g. test_properties::TestProperties::test_return_value fails - if "group" in args and isinstance(args["group"], str): - args["group"] = Grouper(args["group"]) - - out = self._format(attrs, args) - for locale in OPTIONS[METADATA_LOCALES]: - out.update( - self._format( - self._get_translated_metadata( - locale, var_id=var_id, names=names or list(attrs.keys()) - ), - args=args, - formatter=get_local_formatter(locale), - ) - ) - - # Get history and cell method attributes from source data - attrs = defaultdict(str) - if names is None or "cell_methods" in names: - attrs["cell_methods"] = merge_attributes( - "cell_methods", new_line=" ", missing_str=None, **das - ) - if "cell_methods" in out: - attrs["cell_methods"] += " " + out.pop("cell_methods") - - attrs["history"] = update_history( - self._history_string(das, args), - new_name=out.get("var_name"), - **das, - ) - - attrs.update(out) - return attrs - - def _history_string(self, das, params): - kwargs = dict(**das) - for k, v in params.items(): - if self._all_parameters[k].injected: - continue - if self._all_parameters[k].kind == InputKind.KWARGS: - kwargs.update(**v) - elif self._all_parameters[k].kind != InputKind.DATASET: - kwargs[k] = v - return gen_call_string(self._registry_id, **kwargs) - - @staticmethod - def _check_identifier(identifier: str) -> None: - """Verify that the identifier is a proper slug.""" - if not re.match(r"^[-\w]+$", identifier): - warnings.warn( - "The identifier contains non-alphanumeric characters. It could make " - "life difficult for downstream software reusing this class.", - UserWarning, - ) - - @classmethod - def translate_attrs(cls, locale: str | Sequence[str], fill_missing: bool = True): - """Return a dictionary of unformatted translated translatable attributes. - - Translatable attributes are defined in :py:const:`xsdba.locales.TRANSLATABLE_ATTRS`. - - Parameters - ---------- - locale : str or sequence of str - The POSIX name of the locale or a tuple of a locale name and a path to a json file defining translations. - See `xclim.locale` for details. - fill_missing : bool - If True (default) fill the missing attributes by their english values. - """ - - def _translate(cf_attrs, names, var_id=None): - attrs = cls._get_translated_metadata( - locale, - var_id=var_id, - names=names, - append_locale_name=False, - ) - if fill_missing: - for name in names: - if name not in attrs and cf_attrs.get(name): - attrs[name] = cf_attrs.get(name) - return attrs - - # Translate global attrs - attrs = _translate( - cls.__dict__, - # Translate only translatable attrs that are not variable attrs - set(TRANSLATABLE_ATTRS).difference(set(cls._cf_names)), - ) - # Translate variable attrs - attrs["cf_attrs"] = [] - var_id = None - for cf_attrs in cls.cf_attrs: # Translate for each variable - if len(cls.cf_attrs) > 1: - var_id = cf_attrs["var_name"] - attrs["cf_attrs"].append( - _translate( - cf_attrs, - set(TRANSLATABLE_ATTRS).intersection(cls._cf_names), - var_id=var_id, - ) - ) - return attrs - - def json(self, args=None): - """Return a serializable dictionary representation of the class. - - Parameters - ---------- - args : mapping, optional - Arguments as passed to the call method of the indicator. - If not given, the default arguments will be used when formatting the attributes. - - Notes - ----- - This is meant to be used by a third-party library wanting to wrap this class into another interface. - """ - names = ["identifier", "title", "abstract", "keywords"] - out = {key: getattr(self, key) for key in names} - out = self._format(out, args) - - # Format attributes - out["outputs"] = [self._format(attrs, args) for attrs in self.cf_attrs] - out["notes"] = self.notes - - # We need to deepcopy, otherwise empty defaults get overwritten! - # All those tweaks are to ensure proper serialization of the returned dictionary. - out["parameters"] = { - k: p.asdict() if not p.injected else deepcopy(p.value) - for k, p in self._all_parameters.items() - } - for name, param in list(out["parameters"].items()): - if not self._all_parameters[name].injected: - param["kind"] = param["kind"].value # Get the int. - if "choices" in param: # A set is stored, convert to list - param["choices"] = list(param["choices"]) - if param["default"] is _empty_default: - del param["default"] - elif callable(param): # Rare special case (doy_qmax and doy_qmin). - out["parameters"][name] = f"{param.__module__}.{param.__name__}" - - return out - - @classmethod - def _format( - cls, - attrs: dict, - args: dict | None = None, - formatter: AttrFormatter = default_formatter, - ) -> dict: - """Format attributes including {} tags with arguments. - - Parameters - ---------- - attrs : dict - Attributes containing tags to replace with arguments' values. - args : dict, optional - Function call arguments. If not given, the default arguments will be used when formatting the attributes. - formatter : AttrFormatter - Plaintext mappings for indicator attributes. - - Returns - ------- - dict - """ - # Use defaults - if args is None: - args = { - k: p.default if not p.injected else p.value - for k, p in cls._all_parameters.items() - } - - # Prepare arguments - mba = {} - # Add formatting {} around values to be able to replace them with _attrs_mapping using format. - for k, v in args.items(): - if isinstance(v, units.Quantity): - mba[k] = f"{v:g~P}" - elif isinstance(v, (int, float)): - mba[k] = f"{v:g}" - # TODO: What about InputKind.NUMBER_SEQUENCE - elif k == "indexer": - if v and v not in [_empty, _empty_default]: - dk, dv = v.copy().popitem() - if dk == "month": - dv = f"m{dv}" - elif dk in ("doy_bounds", "date_bounds"): - dv = f"{dv[0]} to {dv[1]}" - mba["indexer"] = dv - else: - mba["indexer"] = args.get("freq") or "YS" - elif is_percentile_dataarray(v): - mba.update(get_percentile_metadata(v, k)) - elif ( - isinstance(v, DataArray) - and cls._all_parameters[k].kind == InputKind.QUANTIFIED - ): - mba[k] = "<an array>" - else: - mba[k] = v - out = {} - for key, val in attrs.items(): - if callable(val): - val = val(**mba) - - out[key] = formatter.format(val, **mba) - - if key in cls._text_fields: - out[key] = out[key].strip().capitalize() - - return out - - # The following static methods are meant to be replaced to define custom indicators. - @staticmethod - def compute(*args, **kwds): - """Compute the indicator. - - This would typically be a function from `xclim.indices`. - """ - raise NotImplementedError - - def __getattr__(self, attr): - """Return the attribute.""" - if attr in self._cf_names: - out = [meta.get(attr, "") for meta in self.cf_attrs] - if len(out) == 1: - return out[0] - return out - raise AttributeError(attr) - - @property - def n_outs(self): - """Return the length of all cf_attrs.""" - return len(self.cf_attrs) - - @property - def parameters(self): - """Create a dictionary of controllable parameters. - - Similar to :py:attr:`Indicator._all_parameters`, but doesn't include injected parameters. - """ - return { - name: param - for name, param in self._all_parameters.items() - if not param.injected - } - - @property - def injected_parameters(self): - """Return a dictionary of all injected parameters. - - Opposite of :py:meth:`Indicator.parameters`. - """ - return { - name: param.value - for name, param in self._all_parameters.items() - if param.injected - } - - @property - def is_generic(self): - """Return True if the indicator is "generic", meaning that it can accept variables with any units.""" - return not hasattr(self.compute, "in_units") - - def _show_deprecation_warning(self): - warnings.warn( - f"`{self.title}` is deprecated as of `xclim` v{self._version_deprecated} and will be removed " - "in a future release. See the `xclim` release notes for more information: " - f"https://xclim.readthedocs.io/en/stable/history.html", - FutureWarning, - stacklevel=3, - ) diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py index ad0b706..fc9eeeb 100644 --- a/src/xsdba/measures.py +++ b/src/xsdba/measures.py @@ -14,10 +14,8 @@ import numpy as np import xarray as xr +from xclim.core.indicator import Indicator, base_registry -from xsdba.indicator import Indicator, base_registry - -# ADAPT from .base import Grouper from .typing import InputKind from .units import convert_units_to, ensure_delta @@ -28,7 +26,7 @@ class StatisticalMeasure(Indicator): """Base indicator class for statistical measures used when validating bias-adjusted outputs. Statistical measures use input data where the time dimension was reduced, usually by the computation - of a :py:class:`xsdba.properties.StatisticalProperty` instance. They usually take two arrays + of a :py:class:`xclim.sdba.properties.StatisticalProperty` instance. They usually take two arrays as input: "sim" and "ref", "sim" being measured against "ref". The two arrays must have identical coordinates on their common dimensions. @@ -36,7 +34,7 @@ class StatisticalMeasure(Indicator): to match "ref". """ - # realm = "generic" + realm = "generic" @classmethod def _ensure_correct_parameters(cls, parameters): @@ -91,7 +89,7 @@ class StatisticalPropertyMeasure(Indicator): """A list of allowed groupings. A subset of dayofyear, week, month, season or group. The latter stands for no temporal grouping.""" - # realm = "generic" + realm = "generic" @classmethod def _ensure_correct_parameters(cls, parameters): diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 2755520..70dcde2 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -14,11 +14,13 @@ import numpy as np import xarray as xr +import xclim.indices.run_length as rl from scipy import stats from statsmodels.tsa import stattools +from xclim.core.indicator import Indicator, base_registry +from xclim.indices.generic import compare, select_resample_op +from xclim.indices.stats import fit, parametric_quantile -import xsdba.xclim_submodules.run_length as rl -from xsdba.indicator import Indicator, base_registry from xsdba.units import ( convert_units_to, ensure_delta, @@ -27,8 +29,6 @@ units2pint, ) from xsdba.utils import uses_dask -from xsdba.xclim_submodules.generic import compare, select_resample_op -from xsdba.xclim_submodules.stats import fit, parametric_quantile from .base import Grouper, map_groups, parse_group, parse_offset from .nbutils import _pairwise_haversine_and_bins @@ -101,7 +101,7 @@ def _postprocess(self, outs, das, params): def get_measure(self): """Get the statistical measure indicator that is best used with this statistical property.""" - from xsdba.indicator import registry + from xclim.core.indicator import registry return registry[self.measure].get_instance() diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 029e3a7..1cd9b85 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -964,3 +964,140 @@ def load_module(path: os.PathLike, name: str | None = None): mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) # This executes code, effectively loading the module return mod + + +# XC : redundancy +# Fit the parameters. +# This would also be the place to impose constraints on the series minimum length if needed. +def _fitfunc_1d(arr, *, dist, nparams, method, **fitkwargs): + """Fit distribution parameters.""" + x = np.ma.masked_invalid(arr).compressed() # pylint: disable=no-member + + # Return NaNs if array is empty. + if len(x) <= 1: + return np.asarray([np.nan] * nparams) + + # Estimate parameters + if method in ["ML", "MLE"]: + args, kwargs = _fit_start(x, dist.name, **fitkwargs) + params = dist.fit(x, *args, method="mle", **kwargs, **fitkwargs) + elif method == "MM": + params = dist.fit(x, method="mm", **fitkwargs) + elif method == "PWM": + params = list(dist.lmom_fit(x).values()) + elif method == "APP": + args, kwargs = _fit_start(x, dist.name, **fitkwargs) + kwargs.setdefault("loc", 0) + params = list(args) + [kwargs["loc"], kwargs["scale"]] + else: + raise NotImplementedError(f"Unknown method `{method}`.") + + params = np.asarray(params) + + # Fill with NaNs if one of the parameters is NaN + if np.isnan(params).any(): + params[:] = np.nan + + return params + + +# XC : redundancy +def _fit_start(x, dist: str, **fitkwargs: Any) -> tuple[tuple, dict]: + r"""Return initial values for distribution parameters. + + Providing the ML fit method initial values can help the optimizer find the global optimum. + + Parameters + ---------- + x : array-like + Input data. + dist : str + Name of the univariate distribution, e.g. `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm`. + (see :py:mod:scipy.stats). Only `genextreme` and `weibull_exp` distributions are supported. + \*\*fitkwargs + Kwargs passed to fit. + + Returns + ------- + tuple, dict + + References + ---------- + :cite:cts:`coles_introduction_2001,cohen_parameter_2019, thom_1958, cooke_1979, muralidhar_1992` + """ + x = np.asarray(x) + m = x.mean() + v = x.var() + + if dist == "genextreme": + s = np.sqrt(6 * v) / np.pi + return (0.1,), {"loc": m - 0.57722 * s, "scale": s} + + if dist == "genpareto" and "floc" in fitkwargs: + # Taken from julia' Extremes. Case for when "mu/loc" is known. + t = fitkwargs["floc"] + if not np.isclose(t, 0): + m = (x - t).mean() + v = (x - t).var() + + c = 0.5 * (1 - m**2 / v) + scale = (1 - c) * m + return (c,), {"scale": scale} + + if dist in "weibull_min": + s = x.std() + loc = x.min() - 0.01 * s + chat = np.pi / np.sqrt(6) / (np.log(x - loc)).std() + scale = ((x - loc) ** chat).mean() ** (1 / chat) + return (chat,), {"loc": loc, "scale": scale} + + if dist in ["gamma"]: + if "floc" in fitkwargs: + loc0 = fitkwargs["floc"] + else: + xs = sorted(x) + x1, x2, xn = xs[0], xs[1], xs[-1] + # muralidhar_1992 would suggest the following, but it seems more unstable + # using cooke_1979 for now + # n = len(x) + # cv = x.std() / x.mean() + # p = (0.48265 + 0.32967 * cv) * n ** (-0.2984 * cv) + # xp = xs[int(p/100*n)] + xp = x2 + loc0 = (x1 * xn - xp**2) / (x1 + xn - 2 * xp) + loc0 = loc0 if loc0 < x1 else (0.9999 * x1 if x1 > 0 else 1.0001 * x1) + x_pos = x - loc0 + x_pos = x_pos[x_pos > 0] + m = x_pos.mean() + log_of_mean = np.log(m) + mean_of_logs = np.log(x_pos).mean() + A = log_of_mean - mean_of_logs + a0 = (1 + np.sqrt(1 + 4 * A / 3)) / (4 * A) + scale0 = m / a0 + kwargs = {"scale": scale0, "loc": loc0} + return (a0,), kwargs + + if dist in ["fisk"]: + if "floc" in fitkwargs: + loc0 = fitkwargs["floc"] + else: + xs = sorted(x) + x1, x2, xn = xs[0], xs[1], xs[-1] + loc0 = (x1 * xn - x2**2) / (x1 + xn - 2 * x2) + loc0 = loc0 if loc0 < x1 else (0.9999 * x1 if x1 > 0 else 1.0001 * x1) + x_pos = x - loc0 + x_pos = x_pos[x_pos > 0] + # method of moments: + # LHS is computed analytically with the two-parameters log-logistic distribution + # and depends on alpha,beta + # RHS is from the sample + # <x> = m + # <x^2> / <x>^2 = m2/m**2 + # solving these equations yields + m = x_pos.mean() + m2 = (x_pos**2).mean() + scale0 = 2 * m**3 / (m2 + m**2) + c0 = np.pi * m / np.sqrt(3) / np.sqrt(m2 - m**2) + kwargs = {"scale": scale0, "loc": loc0} + return (c0,), kwargs + return (), {} diff --git a/src/xsdba/xclim_submodules/generic.py b/src/xsdba/xclim_submodules/generic.py deleted file mode 100644 index ac1be4b..0000000 --- a/src/xsdba/xclim_submodules/generic.py +++ /dev/null @@ -1,941 +0,0 @@ -""" -Generic Indices Submodule -========================= - -Helper functions for common generic actions done in the computation of indices. -""" - -from __future__ import annotations - -import warnings -from collections.abc import Sequence -from typing import Callable - -import cftime -import numpy as np -import xarray -import xarray as xr -from xarray.coding.cftime_offsets import _MONTH_ABBREVIATIONS - -from xsdba.calendar import doy_to_days_since, get_calendar, select_time -from xsdba.typing import DayOfYearStr, Quantified, Quantity -from xsdba.units import ( - convert_units_to, - harmonize_units, - pint2str, - str2pint, - to_agg_units, -) - -from . import run_length as rl - -__all__ = [ - "aggregate_between_dates", - "binary_ops", - "compare", - "count_level_crossings", - "count_occurrences", - "cumulative_difference", - "default_freq", - "detrend", - "diurnal_temperature_range", - "domain_count", - "doymax", - "doymin", - "extreme_temperature_range", - "first_day_threshold_reached", - "first_occurrence", - "get_daily_events", - "get_op", - "get_zones", - "interday_diurnal_temperature_range", - "last_occurrence", - "select_resample_op", - "spell_length", - "statistics", - "temperature_sum", - "threshold_count", - "thresholded_statistics", -] - -binary_ops = {">": "gt", "<": "lt", ">=": "ge", "<=": "le", "==": "eq", "!=": "ne"} - - -def select_resample_op( - da: xr.DataArray, op: str, freq: str = "YS", out_units=None, **indexer -) -> xr.DataArray: - """Apply operation over each period that is part of the index selection. - - Parameters - ---------- - da : xr.DataArray - Input data. - op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral', 'argmax', 'argmin'} or func - Reduce operation. Can either be a DataArray method or a function that can be applied to a DataArray. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - out_units : str, optional - Output units to assign. Only necessary if `op` is function not supported by :py:func:`xsdba.units.to_agg_units`. - indexer : {dim: indexer, }, optional - Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, - month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are - considered. - - Returns - ------- - xr.DataArray - The maximum value for each period. - """ - da = select_time(da, **indexer) - r = da.resample(time=freq) - if op in _xclim_ops: - op = _xclim_ops[op] - if isinstance(op, str): - out = getattr(r, op.replace("integral", "sum"))(dim="time", keep_attrs=True) - else: - with xr.set_options(keep_attrs=True): - out = r.map(op) - op = op.__name__ - if out_units is not None: - return out.assign_attrs(units=out_units) - return to_agg_units(out, da, op) - - -def select_rolling_resample_op( - da: xr.DataArray, - op: str, - window: int, - window_center: bool = True, - window_op: str = "mean", - freq: str = "YS", - out_units=None, - **indexer, -) -> xr.DataArray: - """Apply operation over each period that is part of the index selection, using a rolling window before the operation. - - Parameters - ---------- - da : xr.DataArray - Input data. - op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral', 'argmax', 'argmin'} or func - Reduce operation. Can either be a DataArray method or a function that can be applied to a DataArray. - window : int - Size of the rolling window (centered). - window_center : bool - If True, the window is centered on the date. If False, the window is right-aligned. - window_op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral'} - Operation to apply to the rolling window. Default: 'mean'. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. Applied after the rolling window. - out_units : str, optional - Output units to assign. Only necessary if `op` is function not supported by :py:func:`xsdba.units.to_agg_units`. - indexer : {dim: indexer, }, optional - Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, - month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are - considered. - - Returns - ------- - xr.DataArray - The array for which the operation has been applied over each period. - """ - rolled = getattr( - da.rolling(time=window, center=window_center), - window_op.replace("integral", "sum"), - )() - rolled = to_agg_units(rolled, da, window_op) - return select_resample_op(rolled, op=op, freq=freq, out_units=out_units, **indexer) - - -def doymax(da: xr.DataArray) -> xr.DataArray: - """Return the day of year of the maximum value.""" - i = da.argmax(dim="time") - out = da.time.dt.dayofyear.isel(time=i, drop=True) - return to_agg_units(out, da, "doymax") - - -def doymin(da: xr.DataArray) -> xr.DataArray: - """Return the day of year of the minimum value.""" - i = da.argmin(dim="time") - out = da.time.dt.dayofyear.isel(time=i, drop=True) - return to_agg_units(out, da, "doymin") - - -_xclim_ops = {"doymin": doymin, "doymax": doymax} - - -def default_freq(**indexer) -> str: - """Return the default frequency.""" - freq = "YS-JAN" - if indexer: - group, value = indexer.popitem() - if group == "season": - month = 12 # The "season" scheme is based on YS-DEC - elif group == "month": - month = np.take(value, 0) - elif group == "doy_bounds": - month = cftime.num2date(value[0] - 1, "days since 2004-01-01").month - elif group == "date_bounds": - month = int(value[0][:2]) - else: - raise ValueError(f"Unknown group `{group}`.") - freq = "YS-" + _MONTH_ABBREVIATIONS[month] - return freq - - -def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: - """Get python's comparing function according to its name of representation and validate allowed usage. - - Accepted op string are keys and values of xsdba.xclim_submodules.generic.binary_ops. - - Parameters - ---------- - op : str - Operator. - constrain : sequence of str, optional - A tuple of allowed operators. - """ - if op == "gteq": - warnings.warn(f"`{op}` is being renamed `ge` for compatibility.") - op = "ge" - if op == "lteq": - warnings.warn(f"`{op}` is being renamed `le` for compatibility.") - op = "le" - - if op in binary_ops.keys(): - binary_op = binary_ops[op] - elif op in binary_ops.values(): - binary_op = op - else: - raise ValueError(f"Operation `{op}` not recognized.") - - constraints = list() - if isinstance(constrain, (list, tuple, set)): - constraints.extend([binary_ops[c] for c in constrain]) - constraints.extend(constrain) - elif isinstance(constrain, str): - constraints.extend([binary_ops[constrain], constrain]) - - if constrain: - if op not in constraints: - raise ValueError(f"Operation `{op}` not permitted for indice.") - - return xr.core.ops.get_op(binary_op) - - -def compare( - left: xr.DataArray, - op: str, - right: float | int | np.ndarray | xr.DataArray, - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - """Compare a dataArray to a threshold using given operator. - - Parameters - ---------- - left : xr.DataArray - A DatArray being evaluated against `right`. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - right : float, int, np.ndarray, or xr.DataArray - A value or array-like being evaluated against left`. - constrain : sequence of str, optional - Optionally allowed conditions. - - Returns - ------- - xr.DataArray - Boolean mask of the comparison. - """ - return get_op(op, constrain)(left, right) - - -def threshold_count( - da: xr.DataArray, - op: str, - threshold: float | int | xr.DataArray, - freq: str, - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - """Count number of days where value is above or below threshold. - - Parameters - ---------- - da : xr.DataArray - Input data. - op : {">", "<", ">=", "<=", "gt", "lt", "ge", "le"} - Logical operator. e.g. arr > thresh. - threshold : Union[float, int] - Threshold value. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - constrain : sequence of str, optional - Optionally allowed conditions. - - Returns - ------- - xr.DataArray - The number of days meeting the constraints for each period. - """ - if constrain is None: - constrain = (">", "<", ">=", "<=") - - c = compare(da, op, threshold, constrain) * 1 - return c.resample(time=freq).sum(dim="time") - - -def domain_count( - da: xr.DataArray, - low: float | int | xr.DataArray, - high: float | int | xr.DataArray, - freq: str, -) -> xr.DataArray: - """Count number of days where value is within low and high thresholds. - - A value is counted if it is larger than `low`, and smaller or equal to `high`, i.e. in `]low, high]`. - - Parameters - ---------- - da : xr.DataArray - Input data. - low : scalar or DataArray - Minimum threshold value. - high : scalar or DataArray - Maximum threshold value. - freq : str - Resampling frequency defining the periods defined in :ref:`timeseries.resampling`. - - Returns - ------- - xr.DataArray - The number of days where value is within [low, high] for each period. - """ - c = compare(da, ">", low) * compare(da, "<=", high) * 1 - return c.resample(time=freq).sum(dim="time") - - -def get_daily_events( - da: xr.DataArray, - threshold: float | int | xr.DataArray, - op: str, - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - """Return a 0/1 mask when a condition is True or False. - - Parameters - ---------- - da : xr.DataArray - Input data. - threshold : float - Threshold value. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - constrain : sequence of str, optional - Optionally allowed conditions. - - Notes - ----- - The function returns: - - - ``1`` where operator(da, da_value) is ``True`` - - ``0`` where operator(da, da_value) is ``False`` - - ``nan`` where da is ``nan`` - - Returns - ------- - xr.DataArray - """ - events = compare(da, op, threshold, constrain) * 1 - events = events.where(~(np.isnan(da))) - events = events.rename("events") - return events - - -# CF-INDEX-META Indices - - -@harmonize_units(["low_data", "high_data", "threshold"]) -def count_level_crossings( - low_data: xr.DataArray, - high_data: xr.DataArray, - threshold: Quantified, - freq: str, - *, - op_low: str = "<", - op_high: str = ">=", -) -> xr.DataArray: - """Calculate the number of times low_data is below threshold while high_data is above threshold. - - First, the threshold is transformed to the same standard_name and units as the input data, - then the thresholding is performed, and finally, the number of occurrences is counted. - - Parameters - ---------- - low_data : xr.DataArray - Variable that must be under the threshold. - high_data : xr.DataArray - Variable that must be above the threshold. - threshold : Quantified - Threshold. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - op_low : {"<", "<=", "lt", "le"} - Comparison operator for low_data. Default: "<". - op_high : {">", ">=", "gt", "ge"} - Comparison operator for high_data. Default: ">=". - - Returns - ------- - xr.DataArray - """ - # Convert units to low_data - lower = compare(low_data, op_low, threshold, constrain=("<", "<=")) - higher = compare(high_data, op_high, threshold, constrain=(">", ">=")) - - out = (lower & higher).resample(time=freq).sum() - return to_agg_units(out, low_data, "count", dim="time") - - -@harmonize_units(["data", "threshold"]) -def count_occurrences( - data: xr.DataArray, - threshold: Quantified, - freq: str, - op: str, - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - """Calculate the number of times some condition is met. - - First, the threshold is transformed to the same standard_name and units as the input data. - Then the thresholding is performed as condition(data, threshold), - i.e. if condition is `<`, then this counts the number of times `data < threshold`. - Finally, count the number of occurrences when condition is met. - - Parameters - ---------- - data : xr.DataArray - An array. - threshold : Quantified - Threshold. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - constrain : sequence of str, optional - Optionally allowed conditions. - - Returns - ------- - xr.DataArray - """ - cond = compare(data, op, threshold, constrain) - - out = cond.resample(time=freq).sum() - return to_agg_units(out, data, "count", dim="time") - - -@harmonize_units(["data", "threshold"]) -def first_occurrence( - data: xr.DataArray, - threshold: Quantified, - freq: str, - op: str, - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - """Calculate the first time some condition is met. - - First, the threshold is transformed to the same standard_name and units as the input data. - Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. - Finally, locate the first occurrence when condition is met. - - Parameters - ---------- - data : xr.DataArray - Input data. - threshold : Quantified - Threshold. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - constrain : sequence of str, optional - Optionally allowed conditions. - - Returns - ------- - xr.DataArray - """ - cond = compare(data, op, threshold, constrain) - - out = cond.resample(time=freq).map( - rl.first_run, - window=1, - dim="time", - coord="dayofyear", - ) - out.attrs["units"] = "" - return out - - -@harmonize_units(["data", "threshold"]) -def last_occurrence( - data: xr.DataArray, - threshold: Quantified, - freq: str, - op: str, - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - """Calculate the last time some condition is met. - - First, the threshold is transformed to the same standard_name and units as the input data. - Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. - Finally, locate the last occurrence when condition is met. - - Parameters - ---------- - data : xr.DataArray - Input data. - threshold : Quantified - Threshold. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - constrain : sequence of str, optional - Optionally allowed conditions. - - Returns - ------- - xr.DataArray - """ - cond = compare(data, op, threshold, constrain) - - out = cond.resample(time=freq).map( - rl.last_run, - window=1, - dim="time", - coord="dayofyear", - ) - out.attrs["units"] = "" - return out - - -@harmonize_units(["data", "threshold"]) -def spell_length( - data: xr.DataArray, threshold: Quantified, reducer: str, freq: str, op: str -) -> xr.DataArray: - """Calculate statistics on lengths of spells. - - First, the threshold is transformed to the same standard_name and units as the input data. - Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. - Then the spells are determined, and finally the statistics according to the specified reducer are calculated. - - Parameters - ---------- - data : xr.DataArray - Input data. - threshold : Quantified - Threshold. - reducer : {'max', 'min', 'mean', 'sum'} - Reducer. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - - Returns - ------- - xr.DataArray - """ - cond = compare(data, op, threshold) - - out = cond.resample(time=freq).map( - rl.rle_statistics, - reducer=reducer, - window=1, - dim="time", - ) - return to_agg_units(out, data, "count") - - -def statistics(data: xr.DataArray, reducer: str, freq: str) -> xr.DataArray: - """Calculate a simple statistic of the data. - - Parameters - ---------- - data : xr.DataArray - Input data. - reducer : {'max', 'min', 'mean', 'sum'} - Reducer. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - - Returns - ------- - xr.DataArray - """ - out = getattr(data.resample(time=freq), reducer)() - out.attrs["units"] = data.attrs["units"] - return out - - -@harmonize_units(["data", "threshold"]) -def thresholded_statistics( - data: xr.DataArray, - op: str, - threshold: Quantified, - reducer: str, - freq: str, - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - """Calculate a simple statistic of the data for which some condition is met. - - First, the threshold is transformed to the same standard_name and units as the input data. - Then the thresholding is performed as condition(data, threshold), i.e. if condition is <, data < threshold. - Finally, the statistic is calculated for those data values that fulfill the condition. - - Parameters - ---------- - data : xr.DataArray - Input data. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - threshold : Quantified - Threshold. - reducer : {'max', 'min', 'mean', 'sum'} - Reducer. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - constrain : sequence of str, optional - Optionally allowed conditions. Default: None. - - Returns - ------- - xr.DataArray - """ - cond = compare(data, op, threshold, constrain) - - out = getattr(data.where(cond).resample(time=freq), reducer)() - out.attrs["units"] = data.attrs["units"] - return out - - -def aggregate_between_dates( - data: xr.DataArray, - start: xr.DataArray | DayOfYearStr, - end: xr.DataArray | DayOfYearStr, - op: str = "sum", - freq: str | None = None, -) -> xr.DataArray: - """Aggregate the data over a period between start and end dates and apply the operator on the aggregated data. - - Parameters - ---------- - data : xr.DataArray - Data to aggregate between start and end dates. - start : xr.DataArray or DayOfYearStr - Start dates (as day-of-year) for the aggregation periods. - end : xr.DataArray or DayOfYearStr - End (as day-of-year) dates for the aggregation periods. - op : {'min', 'max', 'sum', 'mean', 'std'} - Operator. - freq : str, optional - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. Default: `None`. - - Returns - ------- - xr.DataArray, [dimensionless] - Aggregated data between the start and end dates. If the end date is before the start date, returns np.nan. - If there is no start and/or end date, returns np.nan. - """ - - def _get_days(_bound, _group, _base_time): - """Get bound in number of days since base_time. Bound can be a days_since array or a DayOfYearStr.""" - if isinstance(_bound, str): - b_i = rl.index_of_date(_group.time, _bound, max_idxs=1) - if not b_i.size > 0: - return None - return (_group.time.isel(time=b_i[0]) - _group.time.isel(time=0)).dt.days - if _base_time in _bound.time: - return _bound.sel(time=_base_time) - return None - - if freq is None: - frequencies = [] - for bound in [start, end]: - try: - frequencies.append(xr.infer_freq(bound.time)) - except AttributeError: - frequencies.append(None) - - good_freq = set(frequencies) - {None} - - if len(good_freq) != 1: - raise ValueError( - f"Non-inferrable resampling frequency or inconsistent frequencies. Got start, end = {frequencies}." - " Please consider providing `freq` manually." - ) - freq = good_freq.pop() - - cal = get_calendar(data, dim="time") - - if not isinstance(start, str): - start = start.convert_calendar(cal) - start.attrs["calendar"] = cal - start = doy_to_days_since(start) - if not isinstance(end, str): - end = end.convert_calendar(cal) - end.attrs["calendar"] = cal - end = doy_to_days_since(end) - - out = [] - for base_time, indexes in data.resample(time=freq).groups.items(): - # get group slice - group = data.isel(time=indexes) - - start_d = _get_days(start, group, base_time) - end_d = _get_days(end, group, base_time) - - # convert bounds for this group - if start_d is not None and end_d is not None: - days = (group.time - base_time).dt.days - days[days < 0] = np.nan - - masked = group.where((days >= start_d) & (days <= end_d - 1)) - res = getattr(masked, op)(dim="time", skipna=True) - res = xr.where( - ((start_d > end_d) | (start_d.isnull()) | (end_d.isnull())), np.nan, res - ) - # Re-add the time dimension with the period's base time. - res = res.expand_dims(time=[base_time]) - out.append(res) - else: - # Get an array with the good shape, put nans and add the new time. - res = (group.isel(time=0) * np.nan).expand_dims(time=[base_time]) - out.append(res) - continue - - return xr.concat(out, dim="time") - - -@harmonize_units(["data", "threshold"]) -def cumulative_difference( - data: xr.DataArray, threshold: Quantified, op: str, freq: str | None = None -) -> xr.DataArray: - """Calculate the cumulative difference below/above a given value threshold. - - Parameters - ---------- - data : xr.DataArray - Data for which to determine the cumulative difference. - threshold : Quantified - The value threshold. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le"} - Logical operator. e.g. arr > thresh. - freq : str, optional - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - If `None`, no resampling is performed. Default: `None`. - - Returns - ------- - xr.DataArray - """ - if op in ["<", "<=", "lt", "le"]: - diff = (threshold - data).clip(0) - elif op in [">", ">=", "gt", "ge"]: - diff = (data - threshold).clip(0) - else: - raise NotImplementedError(f"Condition not supported: '{op}'.") - - if freq is not None: - diff = diff.resample(time=freq).sum(dim="time") - - return to_agg_units(diff, data, op="integral") - - -@harmonize_units(["data", "threshold"]) -def first_day_threshold_reached( - data: xr.DataArray, - *, - threshold: Quantified, - op: str, - after_date: DayOfYearStr, - window: int = 1, - freq: str = "YS", - constrain: Sequence[str] | None = None, -) -> xr.DataArray: - r"""First day of values exceeding threshold. - - Returns first day of period where values reach or exceed a threshold over a given number of days, - limited to a starting calendar date. - - Parameters - ---------- - data : xarray.DataArray - Dataset being evaluated. - threshold : str - Threshold on which to base evaluation. - op : {">", "gt", "<", "lt", ">=", "ge", "<=", "le", "==", "eq", "!=", "ne"} - Logical operator. e.g. arr > thresh. - after_date : str - Date of the year after which to look for the first event. Should have the format '%m-%d'. - window : int - Minimum number of days with values above threshold needed for evaluation. Default: 1. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - Default: "YS". - constrain : sequence of str, optional - Optionally allowed conditions. - - Returns - ------- - xarray.DataArray, [dimensionless] - Day of the year when value reaches or exceeds a threshold over a given number of days for the first time. - If there is no such day, returns np.nan. - """ - cond = compare(data, op, threshold, constrain=constrain) - - out: xarray.DataArray = cond.resample(time=freq).map( - rl.first_run_after_date, - window=window, - date=after_date, - dim="time", - coord="dayofyear", - ) - out.attrs.update(units="", is_dayofyear=np.int32(1), calendar=get_calendar(data)) - return out - - -def _get_zone_bins( - zone_min: Quantity, - zone_max: Quantity, - zone_step: Quantity, -): - """Bin boundary values as defined by zone parameters. - - Parameters - ---------- - zone_min : Quantity - Left boundary of the first zone - zone_max : Quantity - Right boundary of the last zone - zone_step: Quantity - Size of zones - - Returns - ------- - xarray.DataArray, [units of `zone_step`] - Array of values corresponding to each zone: [zone_min, zone_min+step, ..., zone_max] - """ - units = pint2str(str2pint(zone_step)) - mn, mx, step = ( - convert_units_to(str2pint(z), units) for z in [zone_min, zone_max, zone_step] - ) - bins = np.arange(mn, mx + step, step) - if (mx - mn) % step != 0: - warnings.warn( - "`zone_max` - `zone_min` is not an integer multiple of `zone_step`. Last zone will be smaller." - ) - bins[-1] = mx - return xr.DataArray(bins, attrs={"units": units}) - - -def get_zones( - da: xr.DataArray, - zone_min: Quantity | None = None, - zone_max: Quantity | None = None, - zone_step: Quantity | None = None, - bins: xr.DataArray | list[Quantity] | None = None, - exclude_boundary_zones: bool = True, - close_last_zone_right_boundary: bool = True, -) -> xr.DataArray: - r"""Divide data into zones and attribute a zone coordinate to each input value. - - Divide values into zones corresponding to bins of width zone_step beginning at zone_min and ending at zone_max. - Bins are inclusive on the left values and exclusive on the right values. - - Parameters - ---------- - da : xarray.DataArray - Input data - zone_min : Quantity | None - Left boundary of the first zone - zone_max : Quantity | None - Right boundary of the last zone - zone_step: Quantity | None - Size of zones - bins : xr.DataArray | list[Quantity] | None - Zones to be used, either as a DataArray with appropriate units or a list of Quantity - exclude_boundary_zones : Bool - Determines whether a zone value is attributed for values in ]`-np.inf`, `zone_min`[ and [`zone_max`, `np.inf`\ [. - close_last_zone_right_boundary : Bool - Determines if the right boundary of the last zone is closed. - - Returns - ------- - xarray.DataArray, [dimensionless] - Zone index for each value in `da`. Zones are returned as an integer range, starting from `0` - """ - # Check compatibility of arguments - zone_params = np.array([zone_min, zone_max, zone_step]) - if bins is None: - if (zone_params == [None] * len(zone_params)).any(): - raise ValueError( - "`bins` is `None` as well as some or all of [`zone_min`, `zone_max`, `zone_step`]. " - "Expected defined parameters in one of these cases." - ) - elif set(zone_params) != {None}: - warnings.warn( - "Expected either `bins` or [`zone_min`, `zone_max`, `zone_step`], got both. " - "`bins` will be used." - ) - - # Get zone bins (if necessary) - bins = bins if bins is not None else _get_zone_bins(zone_min, zone_max, zone_step) - if isinstance(bins, list): - bins = sorted([convert_units_to(b, da) for b in bins]) - else: - bins = convert_units_to(bins, da) - - def _get_zone(_da): - return np.digitize(_da, bins) - 1 - - zones = xr.apply_ufunc(_get_zone, da, dask="parallelized") - - if close_last_zone_right_boundary: - zones = zones.where(da != bins[-1], _get_zone(bins[-2])) - if exclude_boundary_zones: - zones = zones.where( - (zones != _get_zone(bins[0] - 1)) & (zones != _get_zone(bins[-1])) - ) - - return zones - - -def detrend( - ds: xr.DataArray | xr.Dataset, dim="time", deg=1 -) -> xr.DataArray | xr.Dataset: - """Detrend data along a given dimension computing a polynomial trend of a given order. - - Parameters - ---------- - ds : xr.Dataset or xr.DataArray - The data to detrend. If a Dataset, detrending is done on all data variables. - dim : str - Dimension along which to compute the trend. - deg : int - Degree of the polynomial to fit. - - Returns - ------- - xr.Dataset or xr.DataArray - Same as `ds`, but with its trend removed (subtracted). - """ - if isinstance(ds, xr.Dataset): - return ds.map(detrend, keep_attrs=False, dim=dim, deg=deg) - # is a DataArray - # detrend along a single dimension - coeff = ds.polyfit(dim=dim, deg=deg) - trend = xr.polyval(ds[dim], coeff.polyfit_coefficients) - with xr.set_options(keep_attrs=True): - return ds - trend diff --git a/src/xsdba/xclim_submodules/run_length.py b/src/xsdba/xclim_submodules/run_length.py deleted file mode 100644 index a46bf15..0000000 --- a/src/xsdba/xclim_submodules/run_length.py +++ /dev/null @@ -1,1538 +0,0 @@ -""" -Run-Length Algorithms Submodule -=============================== - -Computation of statistics on runs of True values in boolean arrays. -""" - -from __future__ import annotations - -from collections.abc import Sequence -from datetime import datetime -from warnings import warn - -import numpy as np -import xarray as xr -from numba import njit -from xarray.core.utils import get_temp_dimname - -from xsdba.base import uses_dask -from xsdba.options import OPTIONS, RUN_LENGTH_UFUNC -from xsdba.typing import DateStr, DayOfYearStr - -npts_opt = 9000 -""" -Arrays with less than this number of data points per slice will trigger -the use of the ufunc version of run lengths algorithms. -""" -# XC: all copied from xc - - -def use_ufunc( - ufunc_1dim: bool | str, - da: xr.DataArray, - dim: str = "time", - freq: str | None = None, - index: str = "first", -) -> bool: - """Return whether the ufunc version of run length algorithms should be used with this DataArray or not. - - If ufunc_1dim is 'from_context', the parameter is read from xsdba's global (or context) options. - If it is 'auto', this returns False for dask-backed array and for arrays with more than :py:const:`npts_opt` - points per slice along `dim`. - - Parameters - ---------- - ufunc_1dim : {'from_context', 'auto', True, False} - The method for handling the ufunc parameters. - da : xr.DataArray - Input array. - dim : str - The dimension along which to find runs. - freq : str - Resampling frequency. - index : {'first', 'last'} - If 'first' (default), the run length is indexed with the first element in the run. - If 'last', with the last element in the run. - - Returns - ------- - bool - If ufunc_1dim is "auto", returns True if the array is on dask or too large. - Otherwise, returns ufunc_1dim. - """ - if ufunc_1dim is True and freq is not None: - raise ValueError( - "Resampling after run length operations is not implemented for 1d method" - ) - - if ufunc_1dim == "from_context": - ufunc_1dim = OPTIONS[RUN_LENGTH_UFUNC] - - if ufunc_1dim == "auto": - ufunc_1dim = not uses_dask(da) and (da.size // da[dim].size) < npts_opt - # If resampling after run length is set up for the computation, the 1d method is not implemented - # Unless ufunc_1dim is specifically set to False (in which case we flag an error above), - # we simply forbid this possibility. - return (index == "first") and (ufunc_1dim) and (freq is None) - - -def resample_and_rl( - da: xr.DataArray, - resample_before_rl: bool, - compute, - *args, - freq: str, - dim: str = "time", - **kwargs, -) -> xr.DataArray: - """Wrap run length algorithms to control if resampling occurs before or after the algorithms. - - Parameters - ---------- - da: xr.DataArray - N-dimensional array (boolean). - resample_before_rl : bool - Determines whether if input arrays of runs `da` should be separated in period before - or after the run length algorithms are applied. - compute - Run length function to apply - args - Positional arguments needed in `compute`. - dim: str - The dimension along which to find runs. - freq : str - Resampling frequency. - kwargs - Keyword arguments needed in `compute`. - - Returns - ------- - xr.DataArray - Output of compute resampled according to frequency {freq}. - """ - if resample_before_rl: - out = da.resample({dim: freq}).map( - compute, args=args, freq=None, dim=dim, **kwargs - ) - else: - out = compute(da, *args, dim=dim, freq=freq, **kwargs) - return out - - -def _cumsum_reset_on_zero( - da: xr.DataArray, - dim: str = "time", - index: str = "last", -) -> xr.DataArray: - """Compute the cumulative sum for each series of numbers separated by zero. - - Parameters - ---------- - da : xr.DataArray - Input array. - dim : str - Dimension name along which the cumulative sum is taken. - index : {'first', 'last'} - If 'first', the largest value of the cumulative sum is indexed with the first element in the run. - If 'last'(default), with the last element in the run. - - Returns - ------- - xr.DataArray - An array with cumulative sums. - """ - if index == "first": - da = da[{dim: slice(None, None, -1)}] - - # Example: da == 100110111 -> cs_s == 100120123 - cs = da.cumsum(dim=dim) # cumulative sum e.g. 111233456 - cs2 = cs.where(da == 0) # keep only numbers at positions of zeroes e.g. N11NN3NNN - cs2[{dim: 0}] = 0 # put a zero in front e.g. 011NN3NNN - cs2 = cs2.ffill(dim=dim) # e.g. 011113333 - out = cs - cs2 - - if index == "first": - out = out[{dim: slice(None, None, -1)}] - - return out - - -# TODO: Check if rle would be more performant with ffill/bfill instead of two times [{dim: slice(None, None, -1)}] -def rle( - da: xr.DataArray, - dim: str = "time", - index: str = "first", -) -> xr.DataArray: - """Generate basic run length function. - - Parameters - ---------- - da : xr.DataArray - Input array. - dim : str - Dimension name. - index : {'first', 'last'} - If 'first' (default), the run length is indexed with the first element in the run. - If 'last', with the last element in the run. - - Returns - ------- - xr.DataArray - Values are 0 where da is False (out of runs). - """ - da = da.astype(int) - - # "first" case: Algorithm is applied on inverted array and output is inverted back - if index == "first": - da = da[{dim: slice(None, None, -1)}] - - # Get cumulative sum for each series of 1, e.g. da == 100110111 -> cs_s == 100120123 - cs_s = _cumsum_reset_on_zero(da, dim) - - # Keep total length of each series (and also keep 0's), e.g. 100120123 -> 100N20NN3 - # Keep numbers with a 0 to the right and also the last number - cs_s = cs_s.where(da.shift({dim: -1}, fill_value=0) == 0) - out = cs_s.where(da == 1, 0) # Reinsert 0's at their original place - - # Inverting back if needed e.g. 100N20NN3 -> 3NN02N001. This is the output of - # `rle` for 111011001 with index == "first" - if index == "first": - out = out[{dim: slice(None, None, -1)}] - - return out - - -def rle_statistics( - da: xr.DataArray, - reducer: str, - window: int, - dim: str = "time", - freq: str | None = None, - ufunc_1dim: str | bool = "from_context", - index: str = "first", -) -> xr.DataArray: - """Return the length of consecutive run of True values, according to a reducing operator. - - Parameters - ---------- - da : xr.DataArray - N-dimensional array (boolean). - reducer : str - Name of the reducing function. - window : int - Minimal length of consecutive runs to be included in the statistics. - dim : str - Dimension along which to calculate consecutive run; Default: 'time'. - freq : str - Resampling frequency. - ufunc_1dim : Union[str, bool] - Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal - usage based on number of data points. Using 1D_ufunc=True is typically more efficient - for DataArray with a small number of grid points. - It can be modified globally through the "run_length_ufunc" global option. - index : {'first', 'last'} - If 'first' (default), the run length is indexed with the first element in the run. - If 'last', with the last element in the run. - - Returns - ------- - xr.DataArray, [int] - Length of runs of True values along dimension, according to the reducing function (float) - If there are no runs (but the data is valid), returns 0. - """ - ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, index=index, freq=freq) - if ufunc_1dim: - rl_stat = statistics_run_ufunc(da, reducer, window, dim) - else: - d = rle(da, dim=dim, index=index) - - def get_rl_stat(d): - rl_stat = getattr(d.where(d >= window), reducer)(dim=dim) - rl_stat = xr.where((d.isnull() | (d < window)).all(dim=dim), 0, rl_stat) - return rl_stat - - if freq is None: - rl_stat = get_rl_stat(d) - else: - rl_stat = d.resample({dim: freq}).map(get_rl_stat) - - return rl_stat - - -def longest_run( - da: xr.DataArray, - dim: str = "time", - freq: str | None = None, - ufunc_1dim: str | bool = "from_context", - index: str = "first", -) -> xr.DataArray: - """Return the length of the longest consecutive run of True values. - - Parameters - ---------- - da : xr.DataArray - N-dimensional array (boolean). - dim : str - Dimension along which to calculate consecutive run; Default: 'time'. - freq : str - Resampling frequency. - ufunc_1dim : Union[str, bool] - Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal - usage based on number of data points. Using 1D_ufunc=True is typically more efficient - for DataArray with a small number of grid points. - It can be modified globally through the "run_length_ufunc" global option. - index : {'first', 'last'} - If 'first', the run length is indexed with the first element in the run. - If 'last', with the last element in the run. - - Returns - ------- - xr.DataArray, [int] - Length of the longest run of True values along dimension (int). - """ - return rle_statistics( - da, - reducer="max", - window=1, - dim=dim, - freq=freq, - ufunc_1dim=ufunc_1dim, - index=index, - ) - - -def windowed_run_events( - da: xr.DataArray, - window: int, - dim: str = "time", - freq: str | None = None, - ufunc_1dim: str | bool = "from_context", - index: str = "first", -) -> xr.DataArray: - """Return the number of runs of a minimum length. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum run length. - When equal to 1, an optimized version of the algorithm is used. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - freq : str - Resampling frequency. - ufunc_1dim : Union[str, bool] - Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal - usage based on number of data points. Using 1D_ufunc=True is typically more efficient - for DataArray with a small number of grid points. - Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. - index : {'first', 'last'} - If 'first', the run length is indexed with the first element in the run. - If 'last', with the last element in the run. - - Returns - ------- - xr.DataArray, [int] - Number of distinct runs of a minimum length (int). - """ - ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, index=index, freq=freq) - - if ufunc_1dim: - out = windowed_run_events_ufunc(da, window, dim) - - else: - if window == 1: - shift = 1 * (index == "first") + -1 * (index == "last") - d = xr.where(da.shift({dim: shift}, fill_value=0) == 0, 1, 0) - d = d.where(da == 1, 0) - else: - d = rle(da, dim=dim, index=index) - d = xr.where(d >= window, 1, 0) - if freq is not None: - d = d.resample({dim: freq}) - out = d.sum(dim=dim) - - return out - - -def windowed_run_count( - da: xr.DataArray, - window: int, - dim: str = "time", - freq: str | None = None, - ufunc_1dim: str | bool = "from_context", - index: str = "first", -) -> xr.DataArray: - """Return the number of consecutive true values in array for runs at least as long as given duration. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum run length. - When equal to 1, an optimized version of the algorithm is used. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - freq : str - Resampling frequency. - ufunc_1dim : Union[str, bool] - Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal - usage based on number of data points. Using 1D_ufunc=True is typically more efficient - for DataArray with a small number of grid points. - Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. - index : {'first', 'last'} - If 'first', the run length is indexed with the first element in the run. - If 'last', with the last element in the run. - - Returns - ------- - xr.DataArray, [int] - Total number of `True` values part of a consecutive runs of at least `window` long. - """ - ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, index=index, freq=freq) - - if ufunc_1dim: - out = windowed_run_count_ufunc(da, window, dim) - - elif window == 1 and freq is None: - out = da.sum(dim=dim) - - else: - d = rle(da, dim=dim, index=index) - d = d.where(d >= window, 0) - if freq is not None: - d = d.resample({dim: freq}) - out = d.sum(dim=dim) - - return out - - -def _boundary_run( - da: xr.DataArray, - window: int, - dim: str, - freq: str | None, - coord: str | bool | None, - ufunc_1dim: str | bool, - position: str, -) -> xr.DataArray: - """Return the index of the first item of the first or last run of at least a given length. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive run to accumulate values. - When equal to 1, an optimized version of the algorithm is used. - dim : str - Dimension along which to calculate consecutive run. - freq : str - Resampling frequency. - coord : Optional[str] - If not False, the function returns values along `dim` instead of indexes. - If `dim` has a datetime dtype, `coord` can also be a str of the name of the - DateTimeAccessor object to use (ex: 'dayofyear'). - ufunc_1dim : Union[str, bool] - Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal - usage based on number of data points. Using 1D_ufunc=True is typically more efficient - for DataArray with a small number of grid points. - Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. - position : {"first", "last"} - Determines if the algorithm finds the "first" or "last" run - - Returns - ------- - xr.DataArray - Index (or coordinate if `coord` is not False) of first item in first (last) valid run. - Returns np.nan if there are no valid runs. - """ - - def coord_transform(out, da): - """Transforms indexes to coordinates if needed, and drops obsolete dim.""" - if coord: - crd = da[dim] - if isinstance(coord, str): - crd = getattr(crd.dt, coord) - - out = lazy_indexing(crd, out) - - if dim in out.coords: - out = out.drop_vars(dim) - return out - - # general method to get indices (or coords) of first run - def find_boundary_run(runs, position): - if position == "last": - runs = runs[{dim: slice(None, None, -1)}] - dmax_ind = runs.argmax(dim=dim) - # If there are no runs, dmax_ind will be 0: We must replace this with NaN - out = dmax_ind.where(dmax_ind != runs.argmin(dim=dim)) - if position == "last": - out = runs[dim].size - out - 1 - runs = runs[{dim: slice(None, None, -1)}] - out = coord_transform(out, runs) - return out - - ufunc_1dim = use_ufunc(ufunc_1dim, da, dim=dim, freq=freq) - - da = da.fillna(0) # We expect a boolean array, but there could be NaNs nonetheless - if window == 1: - if freq is not None: - out = da.resample({dim: freq}).map(find_boundary_run, position=position) - else: - out = find_boundary_run(da, position) - - elif ufunc_1dim: - if position == "last": - da = da[{dim: slice(None, None, -1)}] - out = first_run_ufunc(x=da, window=window, dim=dim) - if position == "last" and not coord: - out = da[dim].size - out - 1 - da = da[{dim: slice(None, None, -1)}] - out = coord_transform(out, da) - - else: - # _cusum_reset_on_zero() is an intermediate step in rle, which is sufficient here - d = _cumsum_reset_on_zero(da, dim=dim, index=position) - d = xr.where(d >= window, 1, 0) - # for "first" run, return "first" element in the run (and conversely for "last" run) - if freq is not None: - out = d.resample({dim: freq}).map(find_boundary_run, position=position) - else: - out = find_boundary_run(d, position) - - return out - - -def first_run( - da: xr.DataArray, - window: int, - dim: str = "time", - freq: str | None = None, - coord: str | bool | None = False, - ufunc_1dim: str | bool = "from_context", -) -> xr.DataArray: - """Return the index of the first item of the first run of at least a given length. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive run to accumulate values. - When equal to 1, an optimized version of the algorithm is used. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - freq : str - Resampling frequency. - coord : Optional[str] - If not False, the function returns values along `dim` instead of indexes. - If `dim` has a datetime dtype, `coord` can also be a str of the name of the - DateTimeAccessor object to use (ex: 'dayofyear'). - ufunc_1dim : Union[str, bool] - Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal - usage based on number of data points. Using 1D_ufunc=True is typically more efficient - for DataArray with a small number of grid points. - Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. - - Returns - ------- - xr.DataArray - Index (or coordinate if `coord` is not False) of first item in first valid run. - Returns np.nan if there are no valid runs. - """ - out = _boundary_run( - da, - window=window, - dim=dim, - freq=freq, - coord=coord, - ufunc_1dim=ufunc_1dim, - position="first", - ) - return out - - -def last_run( - da: xr.DataArray, - window: int, - dim: str = "time", - freq: str | None = None, - coord: str | bool | None = False, - ufunc_1dim: str | bool = "from_context", -) -> xr.DataArray: - """Return the index of the last item of the last run of at least a given length. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive run to accumulate values. - When equal to 1, an optimized version of the algorithm is used. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - freq : str - Resampling frequency. - coord : Optional[str] - If not False, the function returns values along `dim` instead of indexes. - If `dim` has a datetime dtype, `coord` can also be a str of the name of the - DateTimeAccessor object to use (ex: 'dayofyear'). - ufunc_1dim : Union[str, bool] - Use the 1d 'ufunc' version of this function : default (auto) will attempt to select optimal - usage based on number of data points. Using `1D_ufunc=True` is typically more efficient - for a DataArray with a small number of grid points. - Ignored when `window=1`. It can be modified globally through the "run_length_ufunc" global option. - - Returns - ------- - xr.DataArray - Index (or coordinate if `coord` is not False) of last item in last valid run. - Returns np.nan if there are no valid runs. - """ - out = _boundary_run( - da, - window=window, - dim=dim, - freq=freq, - coord=coord, - ufunc_1dim=ufunc_1dim, - position="last", - ) - return out - - -# TODO: Add window arg -# TODO: Inverse window arg to tolerate holes? -def run_bounds(mask: xr.DataArray, dim: str = "time", coord: bool | str = True): - """Return the start and end dates of boolean runs along a dimension. - - Parameters - ---------- - mask : xr.DataArray - Boolean array. - dim : str - Dimension along which to look for runs. - coord : bool or str - If `True`, return values of the coordinate, if a string, returns values from `dim.dt.<coord>`. - If `False`, return indexes. - - Returns - ------- - xr.DataArray - With ``dim`` reduced to "events" and "bounds". The events dim is as long as needed, padded with NaN or NaT. - """ - if uses_dask(mask): - raise NotImplementedError( - "Dask arrays not supported as we can't know the final event number before computing." - ) - - diff = xr.concat( - (mask.isel({dim: [0]}).astype(int), mask.astype(int).diff(dim)), dim - ) - - nstarts = (diff == 1).sum(dim).max().item() - - def _get_indices(arr, *, N): - out = np.full((N,), np.nan, dtype=float) - inds = np.where(arr)[0] - out[: len(inds)] = inds - return out - - starts = xr.apply_ufunc( - _get_indices, - diff == 1, - input_core_dims=[[dim]], - output_core_dims=[["events"]], - kwargs={"N": nstarts}, - vectorize=True, - ) - - ends = xr.apply_ufunc( - _get_indices, - diff == -1, - input_core_dims=[[dim]], - output_core_dims=[["events"]], - kwargs={"N": nstarts}, - vectorize=True, - ) - - if coord: - crd = mask[dim] - if isinstance(coord, str): - crd = getattr(crd.dt, coord) - - starts = lazy_indexing(crd, starts) - ends = lazy_indexing(crd, ends) - return xr.concat((starts, ends), "bounds") - - -def keep_longest_run( - da: xr.DataArray, dim: str = "time", freq: str | None = None -) -> xr.DataArray: - """Keep the longest run along a dimension. - - Parameters - ---------- - da : xr.DataArray - Boolean array. - dim : str - Dimension along which to check for the longest run. - freq : str - Resampling frequency. - - Returns - ------- - xr.DataArray, [bool] - Boolean array similar to da but with only one run, the (first) longest. - """ - # Get run lengths - rls = rle(da, dim) - - def get_out(rls): - out = xr.where( - # Construct an integer array and find the max - rls[dim].copy(data=np.arange(rls[dim].size)) == rls.argmax(dim), - rls + 1, # Add one to the First longest run - rls, - ) - out = out.ffill(dim) == out.max(dim) - return out - - if freq is not None: - out = rls.resample({dim: freq}).map(get_out) - else: - out = get_out(rls) - - return da.copy(data=out.transpose(*da.dims).data) - - -def extract_events( - da_start: xr.DataArray, - window_start: int, - da_stop: xr.DataArray, - window_stop: int, - dim: str = "time", -) -> xr.DataArray: - """Extract events, i.e. runs whose starting and stopping points are defined through run length conditions. - - Parameters - ---------- - da_start : xr.DataArray - Input array where run sequences are searched to define the start points in the main runs - window_start: int, - Number of True (1) values needed to start a run in `da_start` - da_stop : xr.DataArray - Input array where run sequences are searched to define the stop points in the main runs - window_stop: int, - Number of True (1) values needed to start a run in `da_stop` - dim : str - Dimension name. - - Returns - ------- - xr.DataArray - Output array with 1's when in a run sequence and with 0's elsewhere. - - Notes - ----- - A season (as defined in ``season``) could be considered as an event with `window_stop == window_start` and `da_stop == 1 - da_start`, - although it has more constraints on when to start and stop a run through the `date` argument. - """ - da_start = da_start.astype(int).fillna(0) - da_stop = da_stop.astype(int).fillna(0) - - start_runs = _cumsum_reset_on_zero(da_start, dim=dim, index="first") - stop_runs = _cumsum_reset_on_zero(da_stop, dim=dim, index="first") - start_positions = xr.where(start_runs >= window_start, 1, np.NaN) - stop_positions = xr.where(stop_runs >= window_stop, 0, np.NaN) - - # start positions (1) are f-filled until a stop position (0) is met - runs = stop_positions.combine_first(start_positions).ffill(dim=dim).fillna(0) - - return runs - - -def season( - da: xr.DataArray, - window: int, - date: DayOfYearStr | None = None, - dim: str = "time", - coord: str | bool | None = False, -) -> xr.Dataset: - """Calculate the bounds of a season along a dimension. - - A "season" is a run of True values that may include breaks under a given length (`window`). - The start is computed as the first run of `window` True values, then end as the first subsequent run - of `window` False values. If a date is passed, it must be included in the season. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive values to start and end the season. - date : DayOfYearStr, optional - The date (in MM-DD format) that a run must include to be considered valid. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - coord : Optional[str] - If not False, the function returns values along `dim` instead of indexes. - If `dim` has a datetime dtype, `coord` can also be a str of the name of the - DateTimeAccessor object to use (ex: 'dayofyear'). - - Returns - ------- - xr.Dataset - "dim" is reduced to "season_bnds" with 2 elements : season start and season end, both indices of da[dim]. - - Notes - ----- - The run can include holes of False or NaN values, so long as they do not exceed the window size. - - If a date is given, the season start and end are forced to be on each side of this date. This means that - even if the "real" season has been over for a long time, this is the date used in the length calculation. - Example : Length of the "warm season", where T > 25°C, with date = 1st August. Let's say the temperature is over - 25 for all June, but July and august have very cold temperatures. Instead of returning 30 days (June), the function - will return 61 days (July + June). - """ - beg = first_run(da, window=window, dim=dim) - # Invert the condition and mask all values after beginning - # we fillna(0) as so to differentiate series with no runs and all-nan series - not_da = (~da).where(da[dim].copy(data=np.arange(da[dim].size)) >= beg.fillna(0)) - - # Mask also values after "date" - mid_idx = index_of_date(da[dim], date, max_idxs=1, default=0) - if mid_idx.size == 0: - # The date is not within the group. Happens at boundaries. - base = da.isel({dim: 0}) # To have the proper shape - beg = xr.full_like(base, np.nan, float).drop_vars(dim) - end = xr.full_like(base, np.nan, float).drop_vars(dim) - length = xr.full_like(base, np.nan, float).drop_vars(dim) - else: - if date is not None: - # If the beginning was after the mid date, both bounds are NaT. - valid_start = beg < mid_idx.squeeze() - else: - valid_start = True - - not_da = not_da.where(da[dim] >= da[dim][mid_idx][0]) - end = first_run( - not_da, - window=window, - dim=dim, - ) - # If there was a beginning but no end, season goes to the end of the array - no_end = beg.notnull() & end.isnull() - - # Length - length = end - beg - - # No end: length is actually until the end of the array, so it is missing 1 - length = xr.where(no_end, da[dim].size - beg, length) - # Where the beginning was before the mid-date, invalid. - length = length.where(valid_start) - # Where there were data points, but no season : put 0 length - length = xr.where(beg.isnull() & end.notnull(), 0, length) - - # No end: end defaults to the last element (this differs from length, but heh) - end = xr.where(no_end, da[dim].size - 1, end) - - # Where the beginning was before the mid-date - beg = beg.where(valid_start) - end = end.where(valid_start) - - if coord: - crd = da[dim] - if isinstance(coord, str): - crd = getattr(crd.dt, coord) - coordstr = coord - else: - coordstr = dim - beg = lazy_indexing(crd, beg) - end = lazy_indexing(crd, end) - else: - coordstr = "index" - - out = xr.Dataset({"start": beg, "end": end, "length": length}) - - out.start.attrs.update( - long_name="Start of the season.", - description=f"First {coordstr} of a run of at least {window} steps respecting the condition.", - ) - out.end.attrs.update( - long_name="End of the season.", - description=f"First {coordstr} of a run of at least {window} " - "steps breaking the condition, starting after `start`.", - ) - out.length.attrs.update( - long_name="Length of the season.", - description="Number of steps of the original series in the season, between 'start' and 'end'.", - ) - return out - - -def season_length( - da: xr.DataArray, - window: int, - date: DayOfYearStr | None = None, - dim: str = "time", -) -> xr.DataArray: - """Return the length of the longest semi-consecutive run of True values (optionally including a given date). - - A "season" is a run of True values that may include breaks under a given length (`window`). - The start is computed as the first run of `window` True values, then end as the first subsequent run - of `window` False values. If a date is passed, it must be included in the season. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive values to start and end the season. - date : DayOfYearStr, optional - The date (in MM-DD format) that a run must include to be considered valid. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - - Returns - ------- - xr.DataArray, [int] - Length of the longest run of True values along a given dimension (inclusive of a given date) - without breaks longer than a given length. - - Notes - ----- - The run can include holes of False or NaN values, so long as they do not exceed the window size. - - If a date is given, the season start and end are forced to be on each side of this date. This means that - even if the "real" season has been over for a long time, this is the date used in the length calculation. - Example : Length of the "warm season", where T > 25°C, with date = 1st August. Let's say the temperature is over - 25 for all June, but July and august have very cold temperatures. Instead of returning 30 days (June), the function - will return 61 days (July + June). - """ - seas = season(da, window, date, dim, coord=False) - return seas.length - - -def run_end_after_date( - da: xr.DataArray, - window: int, - date: DayOfYearStr = "07-01", - dim: str = "time", - coord: bool | str | None = "dayofyear", -) -> xr.DataArray: - """Return the index of the first item after the end of a run after a given date. - - The run must begin before the date. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive run to accumulate values. - date : str - The date after which to look for the end of a run. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - coord : Optional[Union[bool, str]] - If not False, the function returns values along `dim` instead of indexes. - If `dim` has a datetime dtype, `coord` can also be a str of the name of the - DateTimeAccessor object to use (ex: 'dayofyear'). - - Returns - ------- - xr.DataArray - Index (or coordinate if `coord` is not False) of last item in last valid run. - Returns np.nan if there are no valid runs. - """ - mid_idx = index_of_date(da[dim], date, max_idxs=1, default=0) - if mid_idx.size == 0: # The date is not within the group. Happens at boundaries. - return xr.full_like(da.isel({dim: 0}), np.nan, float).drop_vars(dim) - - end = first_run( - (~da).where(da[dim] >= da[dim][mid_idx][0]), - window=window, - dim=dim, - coord=coord, - ) - beg = first_run(da.where(da[dim] < da[dim][mid_idx][0]), window=window, dim=dim) - - if coord: - last = da[dim][-1] - if isinstance(coord, str): - last = getattr(last.dt, coord) - else: - last = da[dim].size - 1 - - end = xr.where(end.isnull() & beg.notnull(), last, end) - return end.where(beg.notnull()).drop_vars(dim, errors="ignore") - - -def first_run_after_date( - da: xr.DataArray, - window: int, - date: DayOfYearStr | None = "07-01", - dim: str = "time", - coord: bool | str | None = "dayofyear", -) -> xr.DataArray: - """Return the index of the first item of the first run after a given date. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive run to accumulate values. - date : DayOfYearStr - The date after which to look for the run. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - coord : Optional[Union[bool, str]] - If not False, the function returns values along `dim` instead of indexes. - If `dim` has a datetime dtype, `coord` can also be a str of the name of the - DateTimeAccessor object to use (ex: 'dayofyear'). - - Returns - ------- - xr.DataArray - Index (or coordinate if `coord` is not False) of first item in the first valid run. - Returns np.nan if there are no valid runs. - """ - mid_idx = index_of_date(da[dim], date, max_idxs=1, default=0) - if mid_idx.size == 0: # The date is not within the group. Happens at boundaries. - return xr.full_like(da.isel({dim: 0}), np.nan, float).drop_vars(dim) - - return first_run( - da.where(da[dim] >= da[dim][mid_idx][0]), - window=window, - dim=dim, - coord=coord, - ) - - -def last_run_before_date( - da: xr.DataArray, - window: int, - date: DayOfYearStr = "07-01", - dim: str = "time", - coord: bool | str | None = "dayofyear", -) -> xr.DataArray: - """Return the index of the last item of the last run before a given date. - - Parameters - ---------- - da : xr.DataArray - Input N-dimensional DataArray (boolean). - window : int - Minimum duration of consecutive run to accumulate values. - date : DayOfYearStr - The date before which to look for the last event. - dim : str - Dimension along which to calculate consecutive run (default: 'time'). - coord : Optional[Union[bool, str]] - If not False, the function returns values along `dim` instead of indexes. - If `dim` has a datetime dtype, `coord` can also be a str of the name of the - DateTimeAccessor object to use (ex: 'dayofyear'). - - Returns - ------- - xr.DataArray - Index (or coordinate if `coord` is not False) of last item in last valid run. - Returns np.nan if there are no valid runs. - """ - mid_idx = index_of_date(da[dim], date, default=-1) - - if mid_idx.size == 0: # The date is not within the group. Happens at boundaries. - return xr.full_like(da.isel({dim: 0}), np.nan, float).drop_vars(dim) - - run = da.where(da[dim] <= da[dim][mid_idx][0]) - return last_run(run, window=window, dim=dim, coord=coord) - - -@njit -def _rle_1d(ia): - y = ia[1:] != ia[:-1] # pairwise unequal (string safe) - i = np.append(np.nonzero(y)[0], ia.size - 1) # must include last element position - rl = np.diff(np.append(-1, i)) # run lengths - pos = np.cumsum(np.append(0, rl))[:-1] # positions - return ia[i], rl, pos - - -def rle_1d( - arr: int | float | bool | Sequence[int | float | bool], -) -> tuple[np.array, np.array, np.array]: - """Return the length, starting position and value of consecutive identical values. - - Parameters - ---------- - arr : Sequence[Union[int, float, bool]] - Array of values to be parsed. - - Returns - ------- - values : np.array - The values taken by arr over each run. - run lengths : np.array - The length of each run. - start position : np.array - The starting index of each run. - - Examples - -------- - >>> from xsdba.xclim_submodules.run_length import rle_1d - >>> a = [1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3] - >>> rle_1d(a) - (array([1, 2, 3]), array([2, 4, 6]), array([0, 2, 6])) - """ - ia = np.asarray(arr) - n = len(ia) - - if n == 0: - warn("run length array empty") - # Returning None makes some other 1d func below fail. - return np.array(np.nan), 0, np.array(np.nan) - return _rle_1d(ia) - - -def first_run_1d(arr: Sequence[int | float], window: int) -> int | np.nan: - """Return the index of the first item of a run of at least a given length. - - Parameters - ---------- - arr : Sequence[Union[int, float]] - Input array. - window : int - Minimum duration of consecutive run to accumulate values. - - Returns - ------- - int or np.nan - Index of first item in first valid run. - Returns np.nan if there are no valid runs. - """ - v, rl, pos = rle_1d(arr) - ind = np.where(v * rl >= window, pos, np.inf).min() - - if np.isinf(ind): - return np.nan - return ind - - -def statistics_run_1d(arr: Sequence[bool], reducer: str, window: int) -> int: - """Return statistics on lengths of run of identical values. - - Parameters - ---------- - arr : Sequence[bool] - Input array (bool) - reducer : {'mean', 'sum', 'min', 'max', 'std'} - Reducing function name. - window : int - Minimal length of runs to be included in the statistics - - Returns - ------- - int - Statistics on length of runs. - """ - v, rl = rle_1d(arr)[:2] - if not np.any(v) or np.all(v * rl < window): - return 0 - func = getattr(np, f"nan{reducer}") - return func(np.where(v * rl >= window, rl, np.NaN)) - - -def windowed_run_count_1d(arr: Sequence[bool], window: int) -> int: - """Return the number of consecutive true values in array for runs at least as long as given duration. - - Parameters - ---------- - arr : Sequence[bool] - Input array (bool). - window : int - Minimum duration of consecutive run to accumulate values. - - Returns - ------- - int - Total number of true values part of a consecutive run at least `window` long. - """ - v, rl = rle_1d(arr)[:2] - return np.where(v * rl >= window, rl, 0).sum() - - -def windowed_run_events_1d(arr: Sequence[bool], window: int) -> xr.DataArray: - """Return the number of runs of a minimum length. - - Parameters - ---------- - arr : Sequence[bool] - Input array (bool). - window : int - Minimum run length. - - Returns - ------- - xr.DataArray, [int] - Number of distinct runs of a minimum length. - """ - v, rl, _ = rle_1d(arr) - return (v * rl >= window).sum() - - -def windowed_run_count_ufunc( - x: xr.DataArray | Sequence[bool], window: int, dim: str -) -> xr.DataArray: - """Dask-parallel version of windowed_run_count_1d, ie: the number of consecutive true values in array for runs at least as long as given duration. - - Parameters - ---------- - x : Sequence[bool] - Input array (bool). - window : int - Minimum duration of consecutive run to accumulate values. - dim : str - Dimension along which to calculate windowed run. - - Returns - ------- - xr.DataArray - A function operating along the time dimension of a dask-array. - """ - return xr.apply_ufunc( - windowed_run_count_1d, - x, - input_core_dims=[[dim]], - vectorize=True, - dask="parallelized", - output_dtypes=[int], - keep_attrs=True, - kwargs={"window": window}, - ) - - -def windowed_run_events_ufunc( - x: xr.DataArray | Sequence[bool], window: int, dim: str -) -> xr.DataArray: - """Dask-parallel version of windowed_run_events_1d, ie: the number of runs at least as long as given duration. - - Parameters - ---------- - x : Sequence[bool] - Input array (bool). - window : int - Minimum run length. - dim : str - Dimension along which to calculate windowed run. - - Returns - ------- - xr.DataArray - A function operating along the time dimension of a dask-array. - """ - return xr.apply_ufunc( - windowed_run_events_1d, - x, - input_core_dims=[[dim]], - vectorize=True, - dask="parallelized", - output_dtypes=[int], - keep_attrs=True, - kwargs={"window": window}, - ) - - -def statistics_run_ufunc( - x: xr.DataArray | Sequence[bool], - reducer: str, - window: int, - dim: str = "time", -) -> xr.DataArray: - """Dask-parallel version of statistics_run_1d, ie: the {reducer} number of consecutive true values in array. - - Parameters - ---------- - x : Sequence[bool] - Input array (bool) - reducer: {'min', 'max', 'mean', 'sum', 'std'} - Reducing function name. - window : int - Minimal length of runs. - dim : str - The dimension along which the runs are found. - - Returns - ------- - xr.DataArray - A function operating along the time dimension of a dask-array. - """ - return xr.apply_ufunc( - statistics_run_1d, - x, - input_core_dims=[[dim]], - kwargs={"reducer": reducer, "window": window}, - vectorize=True, - dask="parallelized", - output_dtypes=[float], - keep_attrs=True, - ) - - -def first_run_ufunc( - x: xr.DataArray | Sequence[bool], - window: int, - dim: str, -) -> xr.DataArray: - """Dask-parallel version of first_run_1d, ie: the first entry in array of consecutive true values. - - Parameters - ---------- - x : Union[xr.DataArray, Sequence[bool]] - Input array (bool). - window : int - Minimum run length. - dim : str - The dimension along which the runs are found. - - Returns - ------- - xr.DataArray - A function operating along the time dimension of a dask-array. - """ - ind = xr.apply_ufunc( - first_run_1d, - x, - input_core_dims=[[dim]], - vectorize=True, - dask="parallelized", - output_dtypes=[float], - keep_attrs=True, - kwargs={"window": window}, - ) - - return ind - - -def lazy_indexing( - da: xr.DataArray, index: xr.DataArray, dim: str | None = None -) -> xr.DataArray: - """Get values of `da` at indices `index` in a NaN-aware and lazy manner. - - Parameters - ---------- - da : xr.DataArray - Input array. If not 1D, `dim` must be given and must not appear in index. - index : xr.DataArray - N-d integer indices, if da is not 1D, all dimensions of index must be in da - dim : str, optional - Dimension along which to index, unused if `da` is 1D, should not be present in `index`. - - Returns - ------- - xr.DataArray - Values of `da` at indices `index`. - """ - if da.ndim == 1: - # Case where da is 1D and index is N-D - # Slightly better performance using map_blocks, over an apply_ufunc - def _index_from_1d_array(indices, array): - return array[indices] - - idx_ndim = index.ndim - if idx_ndim == 0: - # The 0-D index case, we add a dummy dimension to help dask - dim = get_temp_dimname(da.dims, "x") - index = index.expand_dims(dim) - # Which indexes to mask. - invalid = index.isnull() - # NaN-indexing doesn't work, so fill with 0 and cast to int - index = index.fillna(0).astype(int) - - # No need for coords, we extract by integer index. - # Renaming with no name to fix bug in xr 2024.01.0 - tmpname = get_temp_dimname(da.dims, "temp") - da2 = xr.DataArray(da.data, dims=(tmpname,), name=None) - # for each chunk of index, take corresponding values from da - out = index.map_blocks(_index_from_1d_array, args=(da2,)).rename(da.name) - # mask where index was NaN. Drop any auxiliary coord, they are already on `out`. - # Chunked aux coord would have the same name on both sides and xarray will want to check if they are equal, which means loading them - # making lazy_indexing not lazy. - out = out.where( - ~invalid.drop_vars( - [crd for crd in invalid.coords if crd not in invalid.dims] - ) - ) - if idx_ndim == 0: - # 0-D case, drop useless coords and dummy dim - out = out.drop_vars(da.dims[0], errors="ignore").squeeze() - return out.drop_vars(dim or da.dims[0], errors="ignore") - - # Case where index.dims is a subset of da.dims. - if dim is None: - diff_dims = set(da.dims) - set(index.dims) - if len(diff_dims) == 0: - raise ValueError( - "da must have at least one dimension more than index for lazy_indexing." - ) - if len(diff_dims) > 1: - raise ValueError( - "If da has more than one dimension more than index, the indexing dim must be given through `dim`" - ) - dim = diff_dims.pop() - - def _index_from_nd_array(array, indices): - return np.take_along_axis(array, indices[..., np.newaxis], axis=-1)[..., 0] - - return xr.apply_ufunc( - _index_from_nd_array, - da, - index.astype(int), - input_core_dims=[[dim], []], - output_core_dims=[[]], - dask="parallelized", - output_dtypes=[da.dtype], - ) - - -def index_of_date( - time: xr.DataArray, - date: DateStr | DayOfYearStr | None, - max_idxs: int | None = None, - default: int = 0, -) -> np.ndarray: - """Get the index of a date in a time array. - - Parameters - ---------- - time : xr.DataArray - An array of datetime values, any calendar. - date : DayOfYearStr or DateStr, optional - A string in the "yyyy-mm-dd" or "mm-dd" format. - If None, returns default. - max_idxs : int, optional - Maximum number of returned indexes. - default : int - Index to return if date is None. - - Raises - ------ - ValueError - If there are most instances of `date` in `time` than `max_idxs`. - - Returns - ------- - numpy.ndarray - 1D array of integers, indexes of `date` in `time`. - """ - if date is None: - return np.array([default]) - try: - date = datetime.strptime(date, "%Y-%m-%d") - year_cond = time.dt.year == date.year - except ValueError: - date = datetime.strptime(date, "%m-%d") - year_cond = True - - idxs = np.where( - year_cond & (time.dt.month == date.month) & (time.dt.day == date.day) - )[0] - if max_idxs is not None and idxs.size > max_idxs: - raise ValueError( - f"More than {max_idxs} instance of date {date} found in the coordinate array." - ) - return idxs - - -def suspicious_run_1d( - arr: np.ndarray, - window: int = 10, - op: str = ">", - thresh: float | None = None, -) -> np.ndarray: - """Return True where the array contains a run of identical values. - - Parameters - ---------- - arr : numpy.ndarray - Array of values to be parsed. - window : int - Minimum run length. - op : {">", ">=", "==", "<", "<=", "eq", "gt", "lt", "gteq", "lteq", "ge", "le"} - Operator for threshold comparison. Defaults to ">". - thresh : float, optional - Threshold compared against which values are checked for identical values. - - Returns - ------- - numpy.ndarray - Whether or not the data points are part of a run of identical values. - """ - v, rl, pos = rle_1d(arr) - sus_runs = rl >= window - if thresh is not None: - if op in {">", "gt"}: - sus_runs = sus_runs & (v > thresh) - elif op in {"<", "lt"}: - sus_runs = sus_runs & (v < thresh) - elif op in {"==", "eq"}: - sus_runs = sus_runs & (v == thresh) - elif op in {"!=", "ne"}: - sus_runs = sus_runs & (v != thresh) - elif op in {">=", "gteq", "ge"}: - sus_runs = sus_runs & (v >= thresh) - elif op in {"<=", "lteq", "le"}: - sus_runs = sus_runs & (v <= thresh) - else: - raise NotImplementedError(f"{op}") - - out = np.zeros_like(arr, dtype=bool) - for st, l in zip(pos[sus_runs], rl[sus_runs]): # noqa: E741 - out[st : st + l] = True # noqa: E741 - return out - - -def suspicious_run( - arr: xr.DataArray, - dim: str = "time", - window: int = 10, - op: str = ">", - thresh: float | None = None, -) -> xr.DataArray: - """Return True where the array contains has runs of identical values, vectorized version. - - In opposition to other run length functions, here the output has the same shape as the input. - - Parameters - ---------- - arr : xr.DataArray - Array of values to be parsed. - dim : str - Dimension along which to check for runs (default: "time"). - window : int - Minimum run length. - op : {">", ">=", "==", "<", "<=", "eq", "gt", "lt", "gteq", "lteq"} - Operator for threshold comparison, defaults to ">". - thresh : float, optional - Threshold above which values are checked for identical values. - - Returns - ------- - xarray.DataArray - """ - return xr.apply_ufunc( - suspicious_run_1d, - arr, - input_core_dims=[[dim]], - output_core_dims=[[dim]], - vectorize=True, - dask="parallelized", - output_dtypes=[bool], - keep_attrs=True, - kwargs=dict(window=window, op=op, thresh=thresh), - ) From 3556b1cb3c2a6151f345a6c8404531df14672b91 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Fri, 13 Sep 2024 14:59:59 -0400 Subject: [PATCH 070/105] fix fixtures, add pytest-xdist --- environment-dev.yml | 1 + pyproject.toml | 8 +- tests/conftest.py | 277 ++++++++++++++++---------------------------- 3 files changed, 107 insertions(+), 179 deletions(-) diff --git a/environment-dev.yml b/environment-dev.yml index e46ae2f..73089d1 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -31,6 +31,7 @@ dependencies: - typer >=0.12.3 - pytest <8.0.0 - pytest-cov >=5.0.0 + - pytest-xdist >=3.2.0 - black ==24.8.0 - blackdoc ==0.3.9 - isort ==5.13.2 diff --git a/pyproject.toml b/pyproject.toml index 2431739..d1ad441 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -82,6 +82,7 @@ dev = [ "numpydoc >=1.8.0; python_version >='3.9'", "pytest <8.0.0", "pytest-cov >=5.0.0", + "pytest-xdist >=3.2.0", "black ==24.8.0", "blackdoc ==0.3.9", "isort ==5.13.2", @@ -300,10 +301,13 @@ override_SS05 = [ [tool.pytest.ini_options] addopts = [ - "--verbose", - "--color=yes" + "--color=yes", + "--numprocesses=0", + "--maxprocesses=8", + "--dist=worksteal" ] filterwarnings = ["ignore::UserWarning"] +strict_markers = true testpaths = "tests" usefixtures = "xdoctest_namespace" diff --git a/tests/conftest.py b/tests/conftest.py index 8979844..847a653 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -4,71 +4,64 @@ import os import re -import shutil -import sys import time import warnings from datetime import datetime as dt -from functools import partial from pathlib import Path import numpy as np -import pandas as pd import pytest import xarray as xr - -# from filelock import FileLock from packaging.version import Version +from xclim.testing import helpers +from xclim.testing.utils import ( + TESTDATA_BRANCH, + TESTDATA_CACHE_DIR, + TESTDATA_REPO_URL, + default_testdata_cache, + gather_testing_data, +) +from xclim.testing.utils import nimbus as _nimbus +from xclim.testing.utils import open_dataset as _open_dataset -from xsdba.testing import TESTDATA_BRANCH # , generate_atmos -from xsdba.testing import open_dataset as _open_dataset +import xsdba +from xsdba import __version__ as __xsdba_version__ from xsdba.testing import ( test_cannon_2015_dist, test_cannon_2015_rvs, test_timelonlatseries, test_timeseries, ) -from xsdba.utils import apply_correction, equally_spaced_nodes - -# import xclim -# from xclim import __version__ as __xclim_version__ -# from xclim.core.calendar import max_doy -# from xclim.testing import helpers -# from xclim.testing.utils import _default_cache_dir -# from xclim.testing.utils import get_file -# from xclim.testing.utils import open_dataset as _open_dataset +from xsdba.utils import apply_correction # ADAPT -# if ( -# re.match(r"^\d+\.\d+\.\d+$", __xclim_version__) -# and helpers.TESTDATA_BRANCH == "main" -# ): -# # This does not need to be emitted on GitHub Workflows and ReadTheDocs -# if not os.getenv("CI") and not os.getenv("READTHEDOCS"): -# warnings.warn( -# f'`xclim` {__xclim_version__} is running tests against the "main" branch of `Ouranosinc/xclim-testdata`. ' -# "It is possible that changes in xclim-testdata may be incompatible with test assertions in this version. " -# "Please be sure to check https://github.com/Ouranosinc/xclim-testdata for more information.", -# UserWarning, -# ) +if re.match(r"^\d+\.\d+\.\d+$", __xsdba_version__) and TESTDATA_BRANCH == "main": + # This does not need to be emitted on GitHub Workflows and ReadTheDocs + if not os.getenv("CI") and not os.getenv("READTHEDOCS"): + warnings.warn( + f'`xclim` {__xsdba_version__} is running tests against the "main" branch of `Ouranosinc/xclim-testdata`. ' + "It is possible that changes in xclim-testdata may be incompatible with test assertions in this version. " + "Please be sure to check https://github.com/Ouranosinc/xclim-testdata for more information.", + UserWarning, + ) -# if re.match(r"^v\d+\.\d+\.\d+", helpers.TESTDATA_BRANCH): -# # Find the date of last modification of xclim source files to generate a calendar version -# install_date = dt.strptime( -# time.ctime(os.path.getmtime(xclim.__file__)), -# "%a %b %d %H:%M:%S %Y", -# ) -# install_calendar_version = ( -# f"{install_date.year}.{install_date.month}.{install_date.day}" -# ) - -# if Version(helpers.TESTDATA_BRANCH) > Version(install_calendar_version): -# warnings.warn( -# f"Installation date of `xclim` ({install_date.ctime()}) " -# f"predates the last release of `xclim-testdata` ({helpers.TESTDATA_BRANCH}). " -# "It is very likely that the testing data is incompatible with this build of `xclim`.", -# UserWarning, -# ) +if re.match(r"^v\d+\.\d+\.\d+", TESTDATA_BRANCH): + # Find the date of last modification of xclim source files to generate a calendar version + install_date = dt.strptime( + time.ctime(Path(xsdba.__file__).stat().st_mtime), + "%a %b %d %H:%M:%S %Y", + ) + install_calendar_version = ( + f"{install_date.year}.{install_date.month}.{install_date.day}" + ) + + if Version(TESTDATA_BRANCH) > Version(install_calendar_version): + warnings.warn( + f"Installation date of `xsdba` ({install_date.ctime()}) " + f"predates the last release of `xclim-testdata` ({TESTDATA_BRANCH}). " + "It is very likely that the testing data is incompatible with this build of `xsdba`.", + UserWarning, + ) @pytest.fixture @@ -121,30 +114,6 @@ def random() -> np.random.Generator: return np.random.default_rng(seed=list(map(ord, "𝕽𝔞𝖓𝔡𝖔𝔪"))) -# ADAPT -# @pytest.fixture -# def tmp_netcdf_filename(tmpdir) -> Path: -# yield Path(tmpdir).joinpath("testfile.nc") - - -@pytest.fixture(autouse=True, scope="session") -def threadsafe_data_dir(tmp_path_factory) -> Path: - yield Path(tmp_path_factory.getbasetemp().joinpath("data")) - - -@pytest.fixture(scope="session") -def open_dataset(threadsafe_data_dir): - def _open_session_scoped_file( - file: str | os.PathLike, branch: str = TESTDATA_BRANCH, **xr_kwargs - ): - xr_kwargs.setdefault("engine", "h5netcdf") - return _open_dataset( - file, cache_dir=threadsafe_data_dir, branch=branch, **xr_kwargs - ) - - return _open_session_scoped_file - - # XC @pytest.fixture def mon_triangular(): @@ -216,20 +185,6 @@ def areacella() -> xr.DataArray: areacello = areacella -# ADAPT? -# @pytest.fixture(scope="session") -# def open_dataset(threadsafe_data_dir): -# def _open_session_scoped_file( -# file: str | os.PathLike, branch: str = helpers.TESTDATA_BRANCH, **xr_kwargs -# ): -# xr_kwargs.setdefault("engine", "h5netcdf") -# return _open_dataset( -# file, cache_dir=threadsafe_data_dir, branch=branch, **xr_kwargs -# ) - -# return _open_session_scoped_file - - # ADAPT? # @pytest.fixture(autouse=True, scope="session") # def add_imports(xdoctest_namespace, threadsafe_data_dir) -> None: @@ -277,103 +232,71 @@ def atmosds(threadsafe_data_dir) -> xr.Dataset: ).load() -# @pytest.fixture(scope="function") -# def ensemble_dataset_objects() -> dict: -# edo = dict() -# edo["nc_files_simple"] = [ -# "EnsembleStats/BCCAQv2+ANUSPLIN300_ACCESS1-0_historical+rcp45_r1i1p1_1950-2100_tg_mean_YS.nc", -# "EnsembleStats/BCCAQv2+ANUSPLIN300_BNU-ESM_historical+rcp45_r1i1p1_1950-2100_tg_mean_YS.nc", -# "EnsembleStats/BCCAQv2+ANUSPLIN300_CCSM4_historical+rcp45_r1i1p1_1950-2100_tg_mean_YS.nc", -# "EnsembleStats/BCCAQv2+ANUSPLIN300_CCSM4_historical+rcp45_r2i1p1_1950-2100_tg_mean_YS.nc", -# ] -# edo["nc_files_extra"] = [ -# "EnsembleStats/BCCAQv2+ANUSPLIN300_CNRM-CM5_historical+rcp45_r1i1p1_1970-2050_tg_mean_YS.nc" -# ] -# edo["nc_files"] = edo["nc_files_simple"] + edo["nc_files_extra"] -# return edo - - -# @pytest.fixture(scope="session") -# def lafferty_sriver_ds() -> xr.Dataset: -# """Get data from Lafferty & Sriver unit test. - -# Notes -# ----- -# https://github.com/david0811/lafferty-sriver_2023_npjCliAtm/tree/main/unit_test -# """ -# fn = get_file( -# "uncertainty_partitioning/seattle_avg_tas.csv", -# cache_dir=_default_cache_dir, -# branch=helpers.TESTDATA_BRANCH, -# ) - -# df = pd.read_csv(fn, parse_dates=["time"]).rename( -# columns={"ssp": "scenario", "ensemble": "downscaling"} -# ) +@pytest.fixture(scope="session") +def threadsafe_data_dir(tmp_path_factory): + return Path(tmp_path_factory.getbasetemp().joinpath("data")) -# # Make xarray dataset -# return xr.Dataset.from_dataframe( -# df.set_index(["scenario", "model", "downscaling", "time"]) -# ) -# ADAPT or REMOVE? -# @pytest.fixture(scope="session", autouse=True) -# def gather_session_data(threadsafe_data_dir): -# """Gather testing data on pytest run. - -# When running pytest with multiple workers, one worker will copy data remotely to _default_cache_dir while -# other workers wait using lockfile. Once the lock is released, all workers will then copy data to their local -# threadsafe_data_dir.As this fixture is scoped to the session, it will only run once per pytest run. - -# Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset as well as add the -# example file paths to the xdoctest_namespace, used when running doctests. -# """ -# generate_atmos(threadsafe_data_dir) - - -# if ( -# not _default_cache_dir.joinpath(helpers.TESTDATA_BRANCH).exists() -# or helpers.PREFETCH_TESTING_DATA -# ): -# if helpers.PREFETCH_TESTING_DATA: -# print("`XCLIM_PREFETCH_TESTING_DATA` set. Prefetching testing data...") -# if sys.platform == "win32": -# raise OSError( -# "UNIX-style file-locking is not supported on Windows. " -# "Consider running `$ xclim prefetch_testing_data` to download testing data." -# ) -# elif worker_id in ["master"]: -# helpers.populate_testing_data(branch=helpers.TESTDATA_BRANCH) -# else: -# _default_cache_dir.mkdir(exist_ok=True, parents=True) -# lockfile = _default_cache_dir.joinpath(".lock") -# test_data_being_written = FileLock(lockfile) -# with test_data_being_written: -# # This flag prevents multiple calls from re-attempting to download testing data in the same pytest run -# helpers.populate_testing_data(branch=helpers.TESTDATA_BRANCH) -# _default_cache_dir.joinpath(".data_written").touch() -# with test_data_being_written.acquire(): -# if lockfile.exists(): -# lockfile.unlink() -# shutil.copytree(_default_cache_dir, threadsafe_data_dir) -# xdoctest_namespace.update(helpers.add_example_file_paths(threadsafe_data_dir)) - - -# @pytest.fixture(scope="session", autouse=True) -# def cleanup(request): -# """Cleanup a testing file once we are finished. - -# This flag prevents remote data from being downloaded multiple times in the same pytest run. -# """ - -# def remove_data_written_flag(): -# flag = _default_cache_dir.joinpath(".data_written") -# if flag.exists(): -# flag.unlink() - -# request.addfinalizer(remove_data_written_flag) +@pytest.fixture(scope="session") +def nimbus(threadsafe_data_dir, worker_id): + return _nimbus( + repo=TESTDATA_REPO_URL, + branch=TESTDATA_BRANCH, + cache_dir=( + TESTDATA_CACHE_DIR if worker_id == "master" else threadsafe_data_dir + ), + ) @pytest.fixture +def tmp_netcdf_filename(tmpdir) -> Path: + yield Path(tmpdir).joinpath("testfile.nc") + + +@pytest.fixture(scope="session") +def open_dataset(threadsafe_data_dir): + def _open_session_scoped_file( + file: str | os.PathLike, branch: str = helpers.TESTDATA_BRANCH, **xr_kwargs + ): + xr_kwargs.setdefault("engine", "h5netcdf") + return _open_dataset( + file, cache_dir=threadsafe_data_dir, branch=branch, **xr_kwargs + ) + + return _open_session_scoped_file + + +@pytest.fixture(autouse=True, scope="session") +def gather_session_data(request, nimbus, worker_id): + """Gather testing data on pytest run. + + When running pytest with multiple workers, one worker will copy data remotely to default cache dir while + other workers wait using lockfile. Once the lock is released, all workers will then copy data to their local + threadsafe_data_dir. As this fixture is scoped to the session, it will only run once per pytest run. + + Due to the lack of UNIX sockets on Windows, the lockfile mechanism is not supported, requiring users on + Windows to run `$ xclim prefetch_testing_data` before running any tests for the first time to populate the + default cache dir. + + Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset. + """ + gather_testing_data(worker_cache_dir=nimbus.path, worker_id=worker_id) + + +@pytest.fixture(scope="session", autouse=True) +def cleanup(request): + """Cleanup a testing file once we are finished. + + This flag prevents remote data from being downloaded multiple times in the same pytest run. + """ + + def remove_data_written_flag(): + flag = default_testdata_cache.joinpath(".data_written") + if flag.exists(): + flag.unlink() + + request.addfinalizer(remove_data_written_flag) + + def timeseries(): return test_timeseries From fc4ed5c6ea676c6555e28f13e5cc56844e7b8022 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Fri, 13 Sep 2024 15:18:44 -0400 Subject: [PATCH 071/105] install development version of xclim --- .github/workflows/main.yml | 5 +++++ tox.ini | 2 ++ 2 files changed, 7 insertions(+) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 20d1247..9b27273 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -111,6 +111,11 @@ jobs: - name: Conda and Mamba versions run: | echo "micromamba $(micromamba --version)" + - name: Install xclim development version + run: | + echo "Installing xclim from main branch until version 0.53.0+ is released" + micromamba remove -y xclim + python -m pip install git+https://github.com/Ouranosinc/xclim.git@main - name: Install xsdba run: | python -m pip install --no-deps . diff --git a/tox.ini b/tox.ini index 30818ad..bc04724 100644 --- a/tox.ini +++ b/tox.ini @@ -60,6 +60,8 @@ commands_pre = pip list pip check commands = + ; Install the development version of xclim until v0.53.0 is released + pip install git+https://github.com/Ouranosinc/xclim.git@main pytest --cov ; Coveralls requires access to a repo token set in .coveralls.yml in order to report stats coveralls: - coveralls From e59282f233f800affd2fd6dce89141f820c6572c Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Tue, 17 Sep 2024 11:15:36 -0400 Subject: [PATCH 072/105] fix testdata fetching --- .github/workflows/main.yml | 3 --- tests/conftest.py | 4 ++-- tests/test_indicator.py | 3 +-- 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 9b27273..df553a6 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,8 +1,5 @@ name: xsdba Testing Suite -env: - XCLIM_TESTDATA_BRANCH: v2023.12.14 - on: push: branches: diff --git a/tests/conftest.py b/tests/conftest.py index 847a653..42800ae 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -13,7 +13,6 @@ import pytest import xarray as xr from packaging.version import Version -from xclim.testing import helpers from xclim.testing.utils import ( TESTDATA_BRANCH, TESTDATA_CACHE_DIR, @@ -256,7 +255,7 @@ def tmp_netcdf_filename(tmpdir) -> Path: @pytest.fixture(scope="session") def open_dataset(threadsafe_data_dir): def _open_session_scoped_file( - file: str | os.PathLike, branch: str = helpers.TESTDATA_BRANCH, **xr_kwargs + file: str | os.PathLike, branch: str = TESTDATA_BRANCH, **xr_kwargs ): xr_kwargs.setdefault("engine", "h5netcdf") return _open_dataset( @@ -298,5 +297,6 @@ def remove_data_written_flag(): request.addfinalizer(remove_data_written_flag) +@pytest.fixture def timeseries(): return test_timeseries diff --git a/tests/test_indicator.py b/tests/test_indicator.py index fa0b33a..f50f289 100644 --- a/tests/test_indicator.py +++ b/tests/test_indicator.py @@ -11,15 +11,14 @@ import numpy as np import pytest import xarray as xr +from xclim.core.indicator import Indicator from xsdba.formatting import ( AttrFormatter, default_formatter, merge_attributes, - parse_doc, update_history, ) -from xsdba.indicator import Indicator, registry from xsdba.logging import MissingVariableError from xsdba.options import set_options from xsdba.typing import InputKind, Quantified From 5b9ff8705977ff3f67ae6626715c60f275f88374 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 17 Sep 2024 11:20:24 -0400 Subject: [PATCH 073/105] remove more xclim duplicated code --- src/xsdba/__init__.py | 27 +++--- src/xsdba/testing.py | 215 ------------------------------------------ tests/conftest.py | 20 +--- 3 files changed, 19 insertions(+), 243 deletions(-) diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 6256a73..89705a4 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -20,17 +20,22 @@ from __future__ import annotations -from . import ( - adjustment, - base, - detrending, - measures, - processing, - properties, - testing, - units, - utils, -) +import importlib +import warnings + +from . import adjustment, base, detrending, processing, testing, units, utils + +xclim_installed = importlib.util.find_spec("xclim") is not None +if xclim_installed: + warnings.warn( + "Sub-modules `properties` and `measures` depend on `xclim`. Run `pip install xsdba['extras']` to install it." + ) +else: + from . import ( + measures, + properties, + ) + from .adjustment import * from .base import Grouper from .options import set_options diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 08fc591..cb0ae1c 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -124,221 +124,6 @@ def test_timeseries( return da -# XC -def file_md5_checksum(f_name): - hash_md5 = hashlib.md5() # noqa: S324 - with open(f_name, "rb") as f: - hash_md5.update(f.read()) - return hash_md5.hexdigest() - - -# XC -def audit_url(url: str, context: str | None = None) -> str: - """Check if the URL is well-formed. - - Raises - ------ - URLError - If the URL is not well-formed. - """ - msg = "" - result = urlparse(url) - if result.scheme == "http": - msg = f"{context if context else ''} URL is not using secure HTTP: '{url}'".strip() - if not all([result.scheme, result.netloc]): - msg = f"{context if context else ''} URL is not well-formed: '{url}'".strip() - - if msg: - logger.error(msg) - raise URLError(msg) - return url - - -# XC (oh dear) -def _get( - fullname: Path, - github_url: str, - branch: str, - suffix: str, - cache_dir: Path, -) -> Path: - cache_dir = cache_dir.absolute() - local_file = cache_dir / branch / fullname - md5_name = fullname.with_suffix(f"{suffix}.md5") - md5_file = cache_dir / branch / md5_name - - if not github_url.lower().startswith("http"): - raise ValueError(f"GitHub URL not safe: '{github_url}'.") - - if local_file.is_file(): - local_md5 = file_md5_checksum(local_file) - try: - url = "/".join((github_url, "raw", branch, md5_name.as_posix())) - msg = f"Attempting to fetch remote file md5: {md5_name.as_posix()}" - logger.info(msg) - urlretrieve(url, md5_file) # nosec - with open(md5_file) as f: - remote_md5 = f.read() - if local_md5.strip() != remote_md5.strip(): - local_file.unlink() - msg = ( - f"MD5 checksum for {local_file.as_posix()} does not match upstream md5. " - "Attempting new download." - ) - warnings.warn(msg) - except HTTPError: - msg = ( - f"{md5_name.as_posix()} not accessible in remote repository. " - "Unable to determine validity with upstream repo." - ) - warnings.warn(msg) - except URLError: - msg = ( - f"{md5_name.as_posix()} not found in remote repository. " - "Unable to determine validity with upstream repo." - ) - warnings.warn(msg) - except SocketBlockedError: - msg = f"Unable to access {md5_name.as_posix()} online. Testing suite is being run with `--disable-socket`." - warnings.warn(msg) - - if not local_file.is_file(): - # This will always leave this directory on disk. - # We may want to add an option to remove it. - local_file.parent.mkdir(exist_ok=True, parents=True) - - url = "/".join((github_url, "raw", branch, fullname.as_posix())) - msg = f"Fetching remote file: {fullname.as_posix()}" - logger.info(msg) - try: - urlretrieve(url, local_file) # nosec - except HTTPError as e: - msg = f"{fullname.as_posix()} not accessible in remote repository. Aborting file retrieval." - raise FileNotFoundError(msg) from e - except URLError as e: - msg = ( - f"{fullname.as_posix()} not found in remote repository. " - "Verify filename and repository address. Aborting file retrieval." - ) - raise FileNotFoundError(msg) from e - # gives TypeError: catching classes that do not inherit from BaseException is not allowed - except SocketBlockedError as e: - msg = ( - f"Unable to access {fullname.as_posix()} online. Testing suite is being run with `--disable-socket`. " - f"If you intend to run tests with this option enabled, please download the file beforehand with the " - f"following console command: `xclim prefetch_testing_data`." - ) - raise FileNotFoundError(msg) from e - try: - url = "/".join((github_url, "raw", branch, md5_name.as_posix())) - msg = f"Fetching remote file md5: {md5_name.as_posix()}" - logger.info(msg) - urlretrieve(url, md5_file) # nosec - except (HTTPError, URLError) as e: - msg = ( - f"{md5_name.as_posix()} not accessible online. " - "Unable to determine validity of file from upstream repo. " - "Aborting file retrieval." - ) - local_file.unlink() - raise FileNotFoundError(msg) from e - - local_md5 = file_md5_checksum(local_file) - try: - with open(md5_file) as f: - remote_md5 = f.read() - if local_md5.strip() != remote_md5.strip(): - local_file.unlink() - msg = ( - f"{local_file.as_posix()} and md5 checksum do not match. " - "There may be an issue with the upstream origin data." - ) - raise OSError(msg) - except OSError as e: - logger.error(e) - - return local_file - - -# XC -# idea copied from xclim that it borrowed from raven that it borrowed from xclim that borrowed it from xarray that was borrowed from Seaborn -def open_dataset( - name: str | os.PathLike[str], - suffix: str | None = None, - dap_url: str | None = None, - github_url: str = "https://github.com/Ouranosinc/xclim-testdata", - branch: str = "main", - cache: bool = True, - cache_dir: Path = _default_cache_dir, - **kwargs, -) -> xr.Dataset: - r"""Open a dataset from the online GitHub-like repository. - - If a local copy is found then always use that to avoid network traffic. - - Parameters - ---------- - name : str or os.PathLike - Name of the file containing the dataset. - suffix : str, optional - If no suffix is given, assumed to be netCDF ('.nc' is appended). For no suffix, set "". - dap_url : str, optional - URL to OPeNDAP folder where the data is stored. If supplied, supersedes github_url. - github_url : str - URL to GitHub repository where the data is stored. - branch : str, optional - For GitHub-hosted files, the branch to download from. - cache : bool - If True, then cache data locally for use on subsequent calls. - cache_dir : Path - The directory in which to search for and write cached data. - \*\*kwargs : dict - For NetCDF files, keywords passed to :py:func:`xarray.open_dataset`. - - Returns - ------- - Union[Dataset, Path] - - See Also - -------- - xarray.open_dataset - """ - if isinstance(name, (str, os.PathLike)): - name = Path(name) - if suffix is None: - suffix = ".nc" - fullname = name.with_suffix(suffix) - - if dap_url is not None: - dap_file_address = urljoin(dap_url, str(name)) - try: - ds = _open_dataset(audit_url(dap_file_address, context="OPeNDAP"), **kwargs) - return ds - except URLError: - raise - except OSError: - msg = f"OPeNDAP file not read. Verify that the service is available: '{dap_file_address}'" - logger.error(msg) - raise OSError(msg) - - local_file = _get( - fullname=fullname, - github_url=github_url, - branch=branch, - suffix=suffix, - cache_dir=cache_dir, - ) - - try: - ds = _open_dataset(local_file, **kwargs) - if not cache: - ds = ds.load() - local_file.unlink() - return ds - except OSError as err: - raise err - - # XC def nancov(X): """Drop observations with NaNs from Numpy's cov.""" diff --git a/tests/conftest.py b/tests/conftest.py index 847a653..b17b9a9 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -13,7 +13,6 @@ import pytest import xarray as xr from packaging.version import Version -from xclim.testing import helpers from xclim.testing.utils import ( TESTDATA_BRANCH, TESTDATA_CACHE_DIR, @@ -39,7 +38,7 @@ # This does not need to be emitted on GitHub Workflows and ReadTheDocs if not os.getenv("CI") and not os.getenv("READTHEDOCS"): warnings.warn( - f'`xclim` {__xsdba_version__} is running tests against the "main" branch of `Ouranosinc/xclim-testdata`. ' + f'`xsdba` {__xsdba_version__} is running tests against the "main" branch of `Ouranosinc/xclim-testdata`. ' "It is possible that changes in xclim-testdata may be incompatible with test assertions in this version. " "Please be sure to check https://github.com/Ouranosinc/xclim-testdata for more information.", UserWarning, @@ -184,21 +183,7 @@ def areacella() -> xr.DataArray: areacello = areacella - -# ADAPT? -# @pytest.fixture(autouse=True, scope="session") -# def add_imports(xdoctest_namespace, threadsafe_data_dir) -> None: -# """Add these imports into the doctests scope.""" -# ns = xdoctest_namespace -# ns["np"] = np -# ns["xr"] = xclim.testing # xr.open_dataset(...) -> xclim.testing.open_dataset(...) -# ns["xclim"] = xclim -# ns["open_dataset"] = partial( -# _open_dataset, -# cache_dir=threadsafe_data_dir, -# branch=helpers.TESTDATA_BRANCH, -# engine="h5netcdf", -# ) # Needed for modules where xarray is imported as `xr` +# TODO: Adapt add_imports for new open_dataset for doctests? @pytest.fixture(autouse=True, scope="function") @@ -298,5 +283,6 @@ def remove_data_written_flag(): request.addfinalizer(remove_data_written_flag) +@pytest.fixture def timeseries(): return test_timeseries From ca1672bfd36a3b5a821b421d1f593991b232f70b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 17 Sep 2024 17:12:44 -0400 Subject: [PATCH 074/105] ignore top import errors --- CHANGELOG.rst | 3 +-- pyproject.toml | 1 + 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 44ee9fd..4c58781 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -10,8 +10,7 @@ Contributors: Éric Dupuis (:user:`coxipi`), Trevor James Smith (:user:`Zeitsper Changes ^^^^^^^ * Split `sdba` from `xclim` and duplicate code where needed. (:pull:`8`) -* `xclim_submodules` represent submodules that are copy (or almost) of given modules in `xclim`. Elsewhere, more attention has been given for a cleaner integration of minimal and sufficient `xclim` functionnalities. (:pull:`8`) -* Class `Indicator` in ``indicator.py`` needs some reworking, many pieces are still artefact from `xclim` usage that won't be needed here. (:pull:`8`) +* `calendar` and `units` are copy (or almost) of given modules in `xclim`. Perhaps in the future some functionalities can be put in a common generic module (:pull:`8`) .. _changes_0.1.0: diff --git a/pyproject.toml b/pyproject.toml index d1ad441..2016593 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -337,6 +337,7 @@ ignore = [ "D205", # blank-line-after-summary "D400", # ends-in-period "D401", # non-imperative-mood + "E402", # top import module # WIP xsdba "D200", "FLY002", From 805e369260786c776f22d9024b3c6a1799b073ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 17 Sep 2024 17:13:12 -0400 Subject: [PATCH 075/105] position of exception --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 2016593..7cde3ed 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -337,8 +337,8 @@ ignore = [ "D205", # blank-line-after-summary "D400", # ends-in-period "D401", # non-imperative-mood - "E402", # top import module # WIP xsdba + "E402", # top import module "D200", "FLY002", "N801", From 2f31dc6dde1f6df2f877097d8a12464ee7d32626 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Wed, 2 Oct 2024 12:16:35 -0400 Subject: [PATCH 076/105] address several dependency issues, fix some broken tests, add requires_atmosds marker --- environment-dev.yml | 10 +-- pyproject.toml | 30 ++----- src/xsdba/processing.py | 1 + src/xsdba/properties.py | 2 +- src/xsdba/testing.py | 2 +- src/xsdba/xclim_submodules/__init__.py | 1 + src/xsdba/xclim_submodules/generic.py | 119 +++++++++++++++++++++++++ src/xsdba/xclim_submodules/stats.py | 19 ++-- tests/conftest.py | 1 + tests/test_adjustment.py | 1 + tests/test_units.py | 33 +++---- tox.ini | 2 +- 12 files changed, 165 insertions(+), 56 deletions(-) create mode 100644 src/xsdba/xclim_submodules/__init__.py create mode 100644 src/xsdba/xclim_submodules/generic.py diff --git a/environment-dev.yml b/environment-dev.yml index 73089d1..1d19293 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -8,14 +8,15 @@ dependencies: - bottleneck - cf_xarray - cftime - - dask # why was this not installed?? + - dask # why was this not installed? This is only pulled in by xclim, optional for xarray. + - h5netcdf >=1.3.0 - jsonpickle - numba - - numpy<2.0 # to accomodate numba + - numpy >=1.23.0,<2.0 # to accommodate numba - pint - - scipy + - scipy >=1.9.0 - statsmodels - - xarray + - xarray >=2023.11.0 - yamale # - xarray >=2022.05.0.dev0 # Dev tools and testing @@ -40,4 +41,3 @@ dependencies: - pre-commit >=3.5.0 - ruff >=0.5.7 - xdoctest>=1.1.5 - - xclim>=0.52 diff --git a/pyproject.toml b/pyproject.toml index 7cde3ed..9f80072 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -39,31 +39,15 @@ dependencies = [ "cf_xarray", "cftime", "dask", + "h5netcdf>=1.3.0", "jsonpickle", "numba", - "numpy<2.0", + "numpy >=1.23.0,<2.0", "pint", - "scipy", + "scipy >=1.9.0", "statsmodels", - "xarray", - "yamale", - "pip >=24.2.0", - "bump-my-version >=0.25.1", - "watchdog >=4.0.0", - "flake8 >=7.1.1", - "flake8-rst-docstrings >=0.3.0", - "flit >=3.9.0,<4.0", - "tox >=4.17.1", - "coverage >=7.5.0", - "coveralls >=4.0.1", - "typer >=0.12.3", - "pytest-cov >=5.0.0", - "black ==24.8.0", - "blackdoc ==0.3.9", - "isort ==5.13.2", - "numpydoc >=1.8.0", - "pre-commit >=3.5.0", - "ruff >=0.5.7" + "xarray >=2023.11.0", + "yamale" ] [project.optional-dependencies] @@ -310,6 +294,10 @@ filterwarnings = ["ignore::UserWarning"] strict_markers = true testpaths = "tests" usefixtures = "xdoctest_namespace" +markers = [ + "slow: mark test as slow", + "requires_atmosds: mark test as requiring access to the atmosds data" +] [tool.ruff] src = ["xsdba"] diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index f052801..0ba5fbf 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -36,6 +36,7 @@ "stack_variables", "standardize", "to_additive_space", + "uniform_noise_like", "unstack_variables", "unstandardize", ] diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 70dcde2..670e8ae 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -962,7 +962,7 @@ def _bivariate_spell_stats( group=group, threshs=threshs, methods=methods, - opss=[op1, op2], + ops=[op1, op2], window=window, freq=group.freq, resample_before_rl=resample_before_rl, diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index cb0ae1c..88a6a3b 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -22,7 +22,7 @@ from xsdba.calendar import percentile_doy from xsdba.utils import equally_spaced_nodes -__all__ = ["test_timelonlatseries", "test_timeseries"] +__all__ = ["nancov", "test_timelonlatseries", "test_timeseries"] # keeping xclim-testdata for now, since it's still this on gitHub _default_cache_dir = Path(user_cache_dir("xclim-testdata")) diff --git a/src/xsdba/xclim_submodules/__init__.py b/src/xsdba/xclim_submodules/__init__.py new file mode 100644 index 0000000..6e03199 --- /dev/null +++ b/src/xsdba/xclim_submodules/__init__.py @@ -0,0 +1 @@ +# noqa: D104 diff --git a/src/xsdba/xclim_submodules/generic.py b/src/xsdba/xclim_submodules/generic.py new file mode 100644 index 0000000..de0c753 --- /dev/null +++ b/src/xsdba/xclim_submodules/generic.py @@ -0,0 +1,119 @@ +"""Generic functions adapted from xclim.""" + +from __future__ import annotations + +from typing import Callable + +import xarray as xr + +__all__ = ["default_freq", "get_op", "select_resample_op"] + + +# XC +binary_ops = {">": "gt", "<": "lt", ">=": "ge", "<=": "le", "==": "eq", "!=": "ne"} + + +# XC +def default_freq(**indexer) -> str: + """Return the default frequency.""" + freq = "YS-JAN" + if indexer: + group, value = indexer.popitem() + if group == "season": + month = 12 # The "season" scheme is based on YS-DEC + elif group == "month": + month = np.take(value, 0) + elif group == "doy_bounds": + month = cftime.num2date(value[0] - 1, "days since 2004-01-01").month + elif group == "date_bounds": + month = int(value[0][:2]) + else: + raise ValueError(f"Unknown group `{group}`.") + freq = "YS-" + _MONTH_ABBREVIATIONS[month] + return freq + + +# XC +def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: + """Get python's comparing function according to its name of representation and validate allowed usage. + + Accepted op string are keys and values of xclim.indices.generic.binary_ops. + + Parameters + ---------- + op : str + Operator. + constrain : sequence of str, optional + A tuple of allowed operators. + """ + if op == "gteq": + warnings.warn(f"`{op}` is being renamed `ge` for compatibility.") + op = "ge" + if op == "lteq": + warnings.warn(f"`{op}` is being renamed `le` for compatibility.") + op = "le" + + if op in binary_ops: + binary_op = binary_ops[op] + elif op in binary_ops.values(): + binary_op = op + else: + raise ValueError(f"Operation `{op}` not recognized.") + + constraints = [] + if isinstance(constrain, list | tuple | set): + constraints.extend([binary_ops[c] for c in constrain]) + constraints.extend(constrain) + elif isinstance(constrain, str): + constraints.extend([binary_ops[constrain], constrain]) + + if constrain: + if op not in constraints: + raise ValueError(f"Operation `{op}` not permitted for indice.") + + return xr.core.ops.get_op(binary_op) + + +# XC +def select_resample_op( + da: xr.DataArray, + op: str | Callable, + freq: str = "YS", + out_units: str | None = None, + **indexer, +) -> xr.DataArray: + """Apply operation over each period that is part of the index selection. + + Parameters + ---------- + da : xr.DataArray + Input data. + op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral', 'argmax', 'argmin'} or func + Reduce operation. Can either be a DataArray method or a function that can be applied to a DataArray. + freq : str + Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. + out_units : str, optional + Output units to assign. Only necessary if `op` is function not supported by :py:func:`xclim.core.units.to_agg_units`. + indexer : {dim: indexer, }, optional + Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, + month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are + considered. + + Returns + ------- + xr.DataArray + The maximum value for each period. + """ + da = select_time(da, **indexer) + r = da.resample(time=freq) + if isinstance(op, str): + op = _xclim_ops.get(op, op) + if isinstance(op, str): + out = getattr(r, op.replace("integral", "sum"))(dim="time", keep_attrs=True) + else: + with xr.set_options(keep_attrs=True): + out = r.map(op) + op = op.__name__ + if out_units is not None: + return out.assign_attrs(units=out_units) + return to_agg_units(out, da, op) diff --git a/src/xsdba/xclim_submodules/stats.py b/src/xsdba/xclim_submodules/stats.py index 18fdf80..8ff5e89 100644 --- a/src/xsdba/xclim_submodules/stats.py +++ b/src/xsdba/xclim_submodules/stats.py @@ -366,7 +366,7 @@ def frequency_analysis( window: int = 1, freq: str | None = None, method: str = "ML", - **indexer: int | float | str, + **indexer: dict[str, int | float | str], ) -> xr.DataArray: r"""Return the value corresponding to a return period. @@ -391,7 +391,7 @@ def frequency_analysis( Fitting method, either maximum likelihood (ML or MLE), method of moments (MOM) or approximate method (APP). Also accepts probability weighted moments (PWM), also called L-Moments, if `dist` is an instance from the lmoments3 library. The PWM method is usually more robust to outliers. - \*\*indexer + \*\*indexer : dict Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, month=1 to select January, or month=[6,7,8] to select summer months. If indexer is not provided, all values are considered. @@ -435,7 +435,7 @@ def get_dist(dist: str | scipy.stats.rv_continuous): return dc -def _fit_start(x, dist: str, **fitkwargs: Any) -> tuple[tuple, dict]: +def _fit_start(x, dist: str, **fitkwargs: dict[str, Any]) -> tuple[tuple, dict]: r"""Return initial values for distribution parameters. Providing the ML fit method initial values can help the optimizer find the global optimum. @@ -447,7 +447,7 @@ def _fit_start(x, dist: str, **fitkwargs: Any) -> tuple[tuple, dict]: dist : str Name of the univariate distribution, e.g. `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm`. (see :py:mod:scipy.stats). Only `genextreme` and `weibull_exp` distributions are supported. - \*\*fitkwargs + \*\*fitkwargs : dict Kwargs passed to fit. Returns @@ -538,7 +538,10 @@ def _fit_start(x, dist: str, **fitkwargs: Any) -> tuple[tuple, dict]: def _dist_method_1D( # noqa: N802 - *args, dist: str | scipy.stats.rv_continuous, function: str, **kwargs: Any + *args: Sequence[str], + dist: str | scipy.stats.rv_continuous, + function: str, + **kwargs: dict[str, Any], ) -> xr.DataArray: r"""Statistical function for given argument on given distribution initialized with params. @@ -547,13 +550,13 @@ def _dist_method_1D( # noqa: N802 Parameters ---------- - \*args + \*args : str The arguments for the requested scipy function. dist : str The scipy name of the distribution. function : str The name of the function to call. - \*\*kwargs + \*\*kwargs L Other parameters to pass to the function call. Returns @@ -569,7 +572,7 @@ def dist_method( fit_params: xr.DataArray, arg: xr.DataArray | None = None, dist: str | scipy.stats.rv_continuous | None = None, - **kwargs: Any, + **kwargs: dict[str, Any], ) -> xr.DataArray: r"""Vectorized statistical function for given argument on given distribution initialized with params. diff --git a/tests/conftest.py b/tests/conftest.py index 873616e..7cdf41d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -207,6 +207,7 @@ def _is_matplotlib_installed(): # ADAPT or REMOVE? +@pytest.mark.requires_atmosds @pytest.fixture(scope="function") def atmosds(threadsafe_data_dir) -> xr.Dataset: return _open_dataset( diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index 162b78a..4877ffe 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -669,6 +669,7 @@ def _group_assert(ds, dim): group.apply(_group_assert, {"ref": ref, "sim": sim, "scen": scen}) + @pytest.mark.requires_atmosds @pytest.mark.parametrize("use_dask", [True, False]) @pytest.mark.parametrize("pcorient", ["full", "simple"]) def test_real_data(self, atmosds, use_dask, pcorient): diff --git a/tests/test_units.py b/tests/test_units.py index 271c7d4..20e2cac 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -1,23 +1,18 @@ from __future__ import annotations import numpy as np -import pandas as pd -import pint -import pint.errors import pytest import xarray as xr -from dask import array as dsk +from cf_xarray import __version__ as __cfxr_version__ from packaging.version import Version -from xsdba.logging import ValidationError -from xsdba.typing import Quantified from xsdba.units import ( - convert_units_to, harmonize_units, pint2str, str2pint, to_agg_units, units, + units2pint, ) @@ -125,9 +120,9 @@ def test_simple(self): da = xr.DataArray([1, 2], attrs={"units": "K"}) thr = "1 K" - @harmonize_units(["da", "thr"]) - def gt(da, thr): - return (da > thr).sum().values + @harmonize_units(["d", "t"]) + def gt(d, t): + return (d > t).sum().values assert gt(da, thr) == 1 @@ -135,9 +130,9 @@ def test_no_units(self): da = xr.DataArray([1, 2]) thr = 1 - @harmonize_units(["da", "thr"]) - def gt(da, thr): - return (da > thr).sum().values + @harmonize_units(["d", "t"]) + def gt(d, t): + return (d > t).sum().values assert gt(da, thr) == 1 @@ -145,9 +140,9 @@ def test_wrong_decorator(self): da = xr.DataArray([1, 2], attrs={"units": "K"}) thr = "1 K" - @harmonize_units(["da", "thrr"]) - def gt(da, thr): - return (da > thr).sum().values + @harmonize_units(["d", "this_is_clearly_wrong"]) + def gt(d, t): + return (d > t).sum().values with pytest.raises(TypeError, match="should be a subset of"): gt(da, thr) @@ -156,9 +151,9 @@ def test_wrong_input_catched_by_decorator(self): da = xr.DataArray([1, 2], attrs={"units": "K"}) thr = "1 K" - @harmonize_units(["da", "thr"]) - def gt(da, thr): - return (da > thr).sum().values + @harmonize_units(["d", "t"]) + def gt(d, t): + return (d > t).sum().values with pytest.raises(TypeError, match="were passed but only"): gt(da) diff --git a/tox.ini b/tox.ini index bc04724..4b8a5af 100644 --- a/tox.ini +++ b/tox.ini @@ -62,6 +62,6 @@ commands_pre = commands = ; Install the development version of xclim until v0.53.0 is released pip install git+https://github.com/Ouranosinc/xclim.git@main - pytest --cov + pytest --cov xsdba -m "not requires_atmosds" {posargs} ; Coveralls requires access to a repo token set in .coveralls.yml in order to report stats coveralls: - coveralls From bd60551c8e7f21a63b60902e01c3c86fd9c508bc Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Wed, 2 Oct 2024 12:27:21 -0400 Subject: [PATCH 077/105] drop Python3.9, stage Python3.13 --- .github/workflows/main.yml | 5 ++--- pyproject.toml | 9 ++++----- tox.ini | 4 ++-- 3 files changed, 8 insertions(+), 10 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index df553a6..b50c04b 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -54,7 +54,6 @@ jobs: strategy: matrix: python-version: - - "3.9" - "3.10" - "3.11" - "3.12" @@ -87,7 +86,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [ "3.9", "3.10", "3.11", "3.12" ] + python-version: [ "3.10", "3.11", "3.12" ] defaults: run: shell: bash -l {0} @@ -122,7 +121,7 @@ jobs: python -m pip check || true - name: Test with pytest run: | - python -m pytest --cov xsdba + python -m pytest --cov xsdba -m "not requires_atmosds" - name: Report Coverage run: | python -m coveralls diff --git a/pyproject.toml b/pyproject.toml index 9f80072..87e279e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,7 @@ maintainers = [ {name = "Trevor James Smith", email = "smith.trevorj@ouranos.ca"} ] readme = {file = "README.rst", content-type = "text/x-rst"} -requires-python = ">=3.9.0" +requires-python = ">=3.10.0" keywords = ["xsdba"] license = {file = "LICENSE"} classifiers = [ @@ -26,10 +26,10 @@ classifiers = [ "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", + # "Programming Language :: Python :: 3.13", "Programming Language :: Python :: Implementation :: CPython" ] dynamic = ["description", "version"] @@ -228,12 +228,12 @@ exclude = [ [tool.isort] profile = "black" -py_version = 39 +py_version = 310 add_imports = "from __future__ import annotations" [tool.mypy] files = "." -python_version = 3.9 +python_version = 3.10 show_error_codes = true strict = true warn_no_return = true @@ -302,7 +302,6 @@ markers = [ [tool.ruff] src = ["xsdba"] line-length = 150 -target-version = "py39" exclude = [ ".eggs", ".git", diff --git a/tox.ini b/tox.ini index 4b8a5af..9498e7c 100644 --- a/tox.ini +++ b/tox.ini @@ -2,7 +2,7 @@ min_version = 4.17.1 envlist = lint - py{38,39,310,311,312} + py{310,311,312,313} docs coveralls requires = @@ -13,10 +13,10 @@ opts = [gh] python = - 3.9 = py39-coveralls 3.10 = py310-coveralls 3.11 = py311-coveralls 3.12 = py312-coveralls + 3.13 = py313-coveralls [testenv:lint] skip_install = True From 6ebaf297c6489ade456d91c66694fe0ef0f02753 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 2 Oct 2024 16:27:43 +0000 Subject: [PATCH 078/105] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/xsdba/_adjustment.py | 2 +- src/xsdba/base.py | 3 ++- src/xsdba/formatting.py | 3 ++- src/xsdba/loess.py | 2 +- src/xsdba/options.py | 2 +- src/xsdba/utils.py | 2 +- src/xsdba/xclim_submodules/generic.py | 2 +- 7 files changed, 9 insertions(+), 7 deletions(-) diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index 3fae1ed..0626001 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -9,7 +9,7 @@ from __future__ import annotations from collections.abc import Sequence -from typing import Callable +from collections.abc import Callable import numpy as np import xarray as xr diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 9f4e5de..b08fd39 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -9,7 +9,8 @@ import itertools from collections.abc import Sequence from inspect import _empty, signature -from typing import Any, Callable, NewType, TypeVar +from typing import Any, NewType, TypeVar +from collections.abc import Callable import cftime import dask.array as dsk diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 325f37d..3407b2a 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -14,7 +14,8 @@ from collections.abc import Sequence from fnmatch import fnmatch from inspect import _empty, signature -from typing import Any, Callable +from typing import Any +from collections.abc import Callable import xarray as xr from boltons.funcutils import wraps diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py index 05ef85f..057d400 100644 --- a/src/xsdba/loess.py +++ b/src/xsdba/loess.py @@ -5,7 +5,7 @@ from __future__ import annotations -from typing import Callable +from collections.abc import Callable from warnings import warn import numba diff --git a/src/xsdba/options.py b/src/xsdba/options.py index d69b914..c6f6a38 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -6,7 +6,7 @@ from __future__ import annotations from inspect import signature -from typing import Callable +from collections.abc import Callable from boltons.funcutils import wraps diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 1cd9b85..05ce4ba 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -6,7 +6,7 @@ from __future__ import annotations import itertools -from typing import Callable +from collections.abc import Callable from warnings import warn import bottleneck as bn diff --git a/src/xsdba/xclim_submodules/generic.py b/src/xsdba/xclim_submodules/generic.py index de0c753..3ef0ac0 100644 --- a/src/xsdba/xclim_submodules/generic.py +++ b/src/xsdba/xclim_submodules/generic.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import Callable +from collections.abc import Callable import xarray as xr From 73cec4ac2b2fa7c6d5d8767caac72e7b030ecebd Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Wed, 2 Oct 2024 12:32:41 -0400 Subject: [PATCH 079/105] coding convention fixes --- src/xsdba/_adjustment.py | 3 +-- src/xsdba/base.py | 7 +++---- src/xsdba/calendar.py | 6 +++--- src/xsdba/formatting.py | 7 +++---- src/xsdba/locales.py | 2 +- src/xsdba/options.py | 2 +- src/xsdba/units.py | 7 ++++--- 7 files changed, 16 insertions(+), 18 deletions(-) diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index 0626001..ad3e214 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -8,8 +8,7 @@ from __future__ import annotations -from collections.abc import Sequence -from collections.abc import Callable +from collections.abc import Callable, Sequence import numpy as np import xarray as xr diff --git a/src/xsdba/base.py b/src/xsdba/base.py index b08fd39..40f8f1c 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -7,10 +7,9 @@ import datetime as pydt import itertools -from collections.abc import Sequence +from collections.abc import Callable, Sequence from inspect import _empty, signature from typing import Any, NewType, TypeVar -from collections.abc import Callable import cftime import dask.array as dsk @@ -268,7 +267,7 @@ def get_calendar(obj: Any, dim: str = "time") -> str: The Climate and Forecasting (CF) calendar name. Will always return "standard" instead of "gregorian", following CF conventions 1.9. """ - if isinstance(obj, (xr.DataArray, xr.Dataset)): + if isinstance(obj, (xr.DataArray | xr.Dataset)): return obj[dim].dt.calendar elif isinstance(obj, xr.CFTimeIndex): obj = obj.values[0] @@ -555,7 +554,7 @@ def apply( function may add a "_group_apply_reshape" attribute set to `True` on the variables that should be reduced and these will be re-grouped by calling `da.groupby(self.name).first()`. """ - if isinstance(da, (dict, xr.Dataset)): + if isinstance(da, (dict | xr.Dataset)): grpd = self.group(main_only=main_only, **da) dim_chunks = min( # Get smallest chunking to rechunk if the operation is non-grouping [ diff --git a/src/xsdba/calendar.py b/src/xsdba/calendar.py index c683b5d..4de1470 100644 --- a/src/xsdba/calendar.py +++ b/src/xsdba/calendar.py @@ -152,7 +152,7 @@ def get_calendar(obj: Any, dim: str = "time") -> str: The Climate and Forecasting (CF) calendar name. Will always return "standard" instead of "gregorian", following CF conventions 1.9. """ - if isinstance(obj, (xr.DataArray, xr.Dataset)): + if isinstance(obj, (xr.DataArray | xr.Dataset)): return obj[dim].dt.calendar elif isinstance(obj, xr.CFTimeIndex): obj = obj.values[0] @@ -889,9 +889,9 @@ def time_bnds( # noqa: C901 So "2000-01-31 00:00:00" with a "3h" frequency, means a period going from "2000-01-31 00:00:00" to "2000-01-31 02:59:59.999999". """ - if isinstance(time, (xr.DataArray, xr.Dataset)): + if isinstance(time, (xr.DataArray | xr.Dataset)): time = time.indexes[time.name] - elif isinstance(time, (DataArrayResample, DatasetResample)): + elif isinstance(time, (DataArrayResample | DatasetResample)): for grouper in time.groupers: if "time" in grouper.dims: datetime = grouper.unique_coord.data diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 3407b2a..17ed526 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -11,11 +11,10 @@ import string import warnings from ast import literal_eval -from collections.abc import Sequence +from collections.abc import Callable, Sequence from fnmatch import fnmatch from inspect import _empty, signature from typing import Any -from collections.abc import Callable import xarray as xr from boltons.funcutils import wraps @@ -470,7 +469,7 @@ def _call_and_add_history(*args, **kwargs): else: out = outs - if not isinstance(out, (xr.DataArray, xr.Dataset)): + if not isinstance(out, (xr.DataArray | xr.Dataset)): raise TypeError( f"Decorated `update_xsdba_history` received a non-xarray output from {func.__name__}." ) @@ -525,7 +524,7 @@ def gen_call_string( for name, val in chain: if isinstance(val, xr.DataArray): rep = val.name or "<array>" - elif isinstance(val, (int, float, str, bool)) or val is None: + elif isinstance(val, (int | float | str | bool)) or val is None: rep = repr(val) else: rep = repr(val) diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index 18f738c..e733ae4 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -268,7 +268,7 @@ def load_locale(locdata: str | Path | dict[str, dict], locale: str): locale : str The locale name (IETF tag). """ - if isinstance(locdata, (str, Path)): + if isinstance(locdata, (str | Path)): filename = Path(locdata) locdata = read_locale_file(filename) diff --git a/src/xsdba/options.py b/src/xsdba/options.py index c6f6a38..204a912 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -5,8 +5,8 @@ # XC remove: metadata locales, do we need them? from __future__ import annotations -from inspect import signature from collections.abc import Callable +from inspect import signature from boltons.funcutils import wraps diff --git a/src/xsdba/units.py b/src/xsdba/units.py index da718cf..5cce223 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -201,7 +201,7 @@ def pint2str(value: units.Quantity | units.Unit) -> str: ----- If cf-xarray is installed, the units will be converted to cf units. """ - if isinstance(value, (pint.Quantity, units.Quantity)): + if isinstance(value, (pint.Quantity | units.Quantity)): value = value.units # Issue originally introduced in https://github.com/hgrecco/pint/issues/1486 @@ -286,14 +286,15 @@ def ensure_delta(unit: str) -> str: def extract_units(arg): """Extract units from a string, DataArray, or scalar.""" if not ( - isinstance(arg, (str, xr.DataArray, pint.Unit, units.Unit)) or np.isscalar(arg) + isinstance(arg, (str | xr.DataArray | pint.Unit | units.Unit)) + or np.isscalar(arg) ): raise TypeError( f"Argument must be a str, DataArray, or scalar. Got {type(arg)}" ) elif isinstance(arg, xr.DataArray): ustr = None if "units" not in arg.attrs else arg.attrs["units"] - elif isinstance(arg, (pint.Unit, units.Unit)): + elif isinstance(arg, (pint.Unit | units.Unit)): ustr = pint2str(arg) # XC: from pint2str elif isinstance(arg, str): ustr = pint2str(str2pint(arg).units) From 80117d0e454e04998ec061f83c2a1d4ccc251068 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Wed, 2 Oct 2024 14:55:53 -0400 Subject: [PATCH 080/105] add xclim v0.53 workaround --- .github/workflows/main.yml | 2 +- .readthedocs.yml | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 1ea483f..43bab75 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -117,9 +117,9 @@ jobs: python=${{ matrix.python-version }} micromamba-version: "1.5.10-0" # pinned to avoid the breaking changes with mamba and micromamba (2.0.0). - name: Install xclim development version + # FIXME: This is a workaround to install xclim v0.53, which is not released. run: | echo "Installing xclim from main branch until version 0.53.0+ is released" - micromamba remove -y xclim python -m pip install git+https://github.com/Ouranosinc/xclim.git@main - name: Install xsdba run: | diff --git a/.readthedocs.yml b/.readthedocs.yml index c623e5e..a0ec23e 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -15,6 +15,10 @@ build: tools: python: "mambaforge-22.9" jobs: + pre_install: + # FIXME: This is a workaround to install xclim v0.53, which is not released. + - mamba install -y -n base -c conda-forge "xclim=0.52.2" + - pip install git+https://github.com/Ouranosinc/xclim.git@main pre_build: - sphinx-apidoc -o docs/apidoc --private --module-first src/xsdba - sphinx-build -M gettext docs docs/_build From 55606d931c245e0f052cda96a013f23985d1b9ec Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 7 Oct 2024 12:36:49 -0400 Subject: [PATCH 081/105] first try at configuring references --- .readthedocs.yml | 2 +- docs/conf.py | 32 +++- docs/index.rst | 1 + docs/references.bib | 432 ++++++++++++++++++++++++++++++++++++++++++ docs/xsdba.rst | 17 +- environment-docs.yml | 1 + src/xsdba/__init__.py | 4 +- 7 files changed, 477 insertions(+), 12 deletions(-) create mode 100644 docs/references.bib diff --git a/.readthedocs.yml b/.readthedocs.yml index a0ec23e..66b4c6a 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -18,7 +18,7 @@ build: pre_install: # FIXME: This is a workaround to install xclim v0.53, which is not released. - mamba install -y -n base -c conda-forge "xclim=0.52.2" - - pip install git+https://github.com/Ouranosinc/xclim.git@main + - python -m pip install git+https://github.com/Ouranosinc/xclim.git@main pre_build: - sphinx-apidoc -o docs/apidoc --private --module-first src/xsdba - sphinx-build -M gettext docs docs/_build diff --git a/docs/conf.py b/docs/conf.py index 2519eee..9699961 100755 --- a/docs/conf.py +++ b/docs/conf.py @@ -22,8 +22,18 @@ sys.path.insert(0, os.path.abspath('..')) +import xarray +from pybtex.plugin import register_plugin +from pybtex.style.formatting.alpha import Style as AlphaStyle +from pybtex.style.labels import BaseLabelStyle + +xarray.DataArray.__module__ = "xarray" +xarray.Dataset.__module__ = "xarray" +xarray.CFTimeIndex.__module__ = "xarray" + import xsdba + # -- General configuration --------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. @@ -37,8 +47,10 @@ 'sphinx.ext.autosectionlabel', 'sphinx.ext.extlinks', "sphinx.ext.intersphinx", - 'sphinx.ext.viewcode', + "sphinx.ext.napoleon", 'sphinx.ext.todo', + 'sphinx.ext.viewcode', + "sphinxcontrib.bibtex", 'sphinx_codeautolink', 'sphinx_copybutton', ] @@ -54,6 +66,24 @@ "special-members": False, } + +# Bibliography stuff +# a simple label style which uses the bibtex keys for labels +class XCLabelStyle(BaseLabelStyle): + def format_labels(self, sorted_entries): + for entry in sorted_entries: + yield entry.key + + +class XCStyle(AlphaStyle): + default_label_style = XCLabelStyle + + +register_plugin("pybtex.style.formatting", "xcstyle", XCStyle) +bibtex_bibfiles = ["references.bib"] +bibtex_default_style = "xcstyle" +bibtex_reference_style = "author_year" + intersphinx_mapping = { "scipy": ("https://docs.scipy.org/doc/scipy/", None), } diff --git a/docs/index.rst b/docs/index.rst index 14940e4..abda240 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -8,6 +8,7 @@ Welcome to xsdba's documentation! readme installation usage + xsdba contributing releasing authors diff --git a/docs/references.bib b/docs/references.bib new file mode 100644 index 0000000..735f687 --- /dev/null +++ b/docs/references.bib @@ -0,0 +1,432 @@ + +@article{deque_frequency_2007, + series = {Extreme {Climatic} {Events}}, + title = {Frequency of precipitation and temperature extremes over {France} in an anthropogenic scenario: {Model} results and statistical correction according to observed values}, + volume = {57}, + issn = {0921-8181}, + shorttitle = {Frequency of precipitation and temperature extremes over {France} in an anthropogenic scenario}, + url = {https://www.sciencedirect.com/science/article/pii/S0921818106002748}, + doi = {10.1016/j.gloplacha.2006.11.030}, + abstract = {Météo-France atmospheric model ARPEGE/Climate has been used to simulate present climate (1961–1990) and a possible future climate (2071–2100) through two ensembles of three 30-year numerical experiments. In the scenario experiment, the greenhouse gas and aerosol concentrations are prescribed by the so-called SRES-A2 hypotheses, whereas the sea surface temperature and sea ice extent come from an earlier ocean–atmosphere coupled simulation. The model covers the whole globe, with a variable resolution reaching 50 to 60 km over France. Model responses on daily minimum and maximum temperature and precipitation are analyzed over France. The distribution of daily values is compared with observed data from the French climatological network. The extreme cold temperatures and summer heavy precipitations are underestimated by the model. A correction technique is proposed in order to adjust the simulated values according to the observed ones. This process is applied to both reference and scenario simulation. Synthetic indices of extreme events are calculated with corrected simulations. The number of heavy rain ({\textgreater}10 mm) days increases by one quarter in winter. The maximum length of summer dry episodes increases by one half in summer. The number of heat wave days is multiplied by 10. The response in precipitation is less when only the change in the mean is considered. Such a corrected simulation is useful to feed impact models which are sensitive to threshold values, but the correction does not reduce, and may enhance in some cases, the uncertainty about the climate projections. Using several models and scenarios is the appropriate technique to deal with uncertainty.}, + language = {en}, + number = {1}, + urldate = {2022-07-29}, + journal = {Global and Planetary Change}, + author = {Déqué, Michel}, + month = may, + year = {2007}, + keywords = {extreme values, numerical simulation, regional climate, scenario}, + pages = {16--26}, +} + +@article{cannon_bias_2015, + title = {Bias {Correction} of {GCM} {Precipitation} by {Quantile} {Mapping}: {How} {Well} {Do} {Methods} {Preserve} {Changes} in {Quantiles} and {Extremes}?}, + volume = {28}, + issn = {0894-8755, 1520-0442}, + shorttitle = {Bias {Correction} of {GCM} {Precipitation} by {Quantile} {Mapping}}, + url = {https://journals.ametsoc.org/view/journals/clim/28/17/jcli-d-14-00754.1.xml}, + doi = {10.1175/JCLI-D-14-00754.1}, + abstract = {Abstract Quantile mapping bias correction algorithms are commonly used to correct systematic distributional biases in precipitation outputs from climate models. Although they are effective at removing historical biases relative to observations, it has been found that quantile mapping can artificially corrupt future model-projected trends. Previous studies on the modification of precipitation trends by quantile mapping have focused on mean quantities, with less attention paid to extremes. This article investigates the extent to which quantile mapping algorithms modify global climate model (GCM) trends in mean precipitation and precipitation extremes indices. First, a bias correction algorithm, quantile delta mapping (QDM), that explicitly preserves relative changes in precipitation quantiles is presented. QDM is compared on synthetic data with detrended quantile mapping (DQM), which is designed to preserve trends in the mean, and with standard quantile mapping (QM). Next, methods are applied to phase 5 of the Coupled Model Intercomparison Project (CMIP5) daily precipitation projections over Canada. Performance is assessed based on precipitation extremes indices and results from a generalized extreme value analysis applied to annual precipitation maxima. QM can inflate the magnitude of relative trends in precipitation extremes with respect to the raw GCM, often substantially, as compared to DQM and especially QDM. The degree of corruption in the GCM trends by QM is particularly large for changes in long period return values. By the 2080s, relative changes in excess of +500\% with respect to historical conditions are noted at some locations for 20-yr return values, with maximum changes by DQM and QDM nearing +240\% and +140\%, respectively, whereas raw GCM changes are never projected to exceed +120\%.}, + language = {EN}, + number = {17}, + urldate = {2022-07-29}, + journal = {Journal of Climate}, + author = {Cannon, Alex J. and Sobie, Stephen R. and Murdock, Trevor Q.}, + month = sep, + year = {2015}, + pages = {6938--6959}, +} + +@misc{cannon_mbc_2020, + title = {{MBC}: {Multivariate} {Bias} {Correction} of {Climate} {Model} {Outputs}}, + copyright = {GPL-2}, + shorttitle = {{MBC}}, + url = {https://CRAN.R-project.org/package=MBC}, + abstract = {Calibrate and apply multivariate bias correction algorithms for climate model simulations of multiple climate variables. Three methods described by Cannon (2016) {\textless}doi:10.1175/JCLI-D-15-0679.1{\textgreater} and Cannon (2018) {\textless}doi:10.1007/s00382-017-3580-6{\textgreater} are implemented — (i) MBC Pearson correlation (MBCp), (ii) MBC rank correlation (MBCr), and (iii) MBC N-dimensional PDF transform (MBCn) — as is the Rank Resampling for Distributions and Dependences (R2D2) method.}, + urldate = {2022-07-29}, + author = {Cannon, Alex J.}, + month = oct, + year = {2020}, + keywords = {Hydrology}, +} + + +@article{roy_extremeprecip_2023, + title = {Climate scenarios of extreme precipitation using a combination of parametric and non-parametric bias correction methods in the province of Québec}, + url = {https://www.tandfonline.com/doi/full/10.1080/07011784.2023.2220682}, + doi = {10.1080/07011784.2023.2220682}, + language = {English}, + journal = {Canadian Water Resources Journal}, + author = {Roy, Philippe and Rondeau-Genesse, Gabriel and Jalbert, Jonathan and Fournier, Élyse}, + month = {june}, + year = {2023}, +} + +@misc{roy_juliaclimateclimatetoolsjl_2021, + title = {{JuliaClimate}/{ClimateTools}.jl: v0.23.1}, + shorttitle = {{JuliaClimate}/{ClimateTools}.jl}, + url = {https://zenodo.org/record/5399172}, + abstract = {ClimateTools v0.23.1 Diff since v0.23.0 Closed issues: possible test failure in upcoming Julia version 1.5 (\#148) Merged pull requests: CompatHelper: bump compat for "DataFrames" to "1.0" (\#191) (@github-actions[bot]) CompatHelper: bump compat for "GeoStats" to "0.25" (\#193) (@github-actions[bot]) CompatHelper: bump compat for "Reexport" to "1" (\#194) (@github-actions[bot]) CompatHelper: bump compat for Reexport to 1, (keep existing compat) (\#196) (@github-actions[bot]) CompatHelper: bump compat for Interpolations to 0.13, (keep existing compat) (\#197) (@github-actions[bot]) CompatHelper: bump compat for NCDatasets to 0.11, (keep existing compat) (\#198) (@github-actions[bot]) CompatHelper: bump compat for GeoStats to 0.26, (keep existing compat) (\#199) (@github-actions[bot]) CompatHelper: bump compat for NetCDF to 0.11, (keep existing compat) (\#201) (@github-actions[bot]) CompatHelper: bump compat for ClimateBase to 0.13, (keep existing compat) (\#202) (@github-actions[bot]) CompatHelper: bump compat for Distances to 0.10, (keep existing compat) (\#204) (@github-actions[bot]) CompatHelper: bump compat for Shapefile to 0.7, (keep existing compat) (\#205) (@github-actions[bot]) fix for extreme bug (\#206) (@Balinus)}, + urldate = {2022-07-29}, + publisher = {Zenodo}, + author = {Roy, Philippe and Smith, Trevor James and Kelman, Tony and Nolet-Gravel, Éloïse and Saba, Elliot and Thomet, Fidel and TagBot, Julia and Forget, Gael}, + month = sep, + year = {2021}, + doi = {10.5281/zenodo.5399172}, +} + +@article{schmidli_downscaling_2006, + title = {Downscaling from {GCM} precipitation: a benchmark for dynamical and statistical downscaling methods}, + volume = {26}, + issn = {1097-0088}, + shorttitle = {Downscaling from {GCM} precipitation}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/joc.1287}, + doi = {10.1002/joc.1287}, + abstract = {A precipitation downscaling method is presented using precipitation from a general circulation model (GCM) as predictor. The method extends a previous method from monthly to daily temporal resolution. The simplest form of the method corrects for biases in wet-day frequency and intensity. A more sophisticated variant also takes account of flow-dependent biases in the GCM. The method is flexible and simple to implement. It is proposed here as a correction of GCM output for applications where sophisticated methods are not available, or as a benchmark for the evaluation of other downscaling methods. Applied to output from reanalyses (ECMWF, NCEP) in the region of the European Alps, the method is capable of reducing large biases in the precipitation frequency distribution, even for high quantiles. The two variants exhibit similar performances, but the ideal choice of method can depend on the GCM/reanalysis and it is recommended to test the methods in each case. Limitations of the method are found in small areas with unresolved topographic detail that influence higher-order statistics (e.g. high quantiles). When used as benchmark for three regional climate models (RCMs), the corrected reanalysis and the RCMs perform similarly in many regions, but the added value of the latter is evident for high quantiles in some small regions. Copyright © 2006 Royal Meteorological Society.}, + language = {en}, + number = {5}, + urldate = {2022-07-29}, + journal = {International Journal of Climatology}, + author = {Schmidli, Jürg and Frei, Christoph and Vidale, Pier Luigi}, + year = {2006}, + keywords = {European alps, precipitation statistics, reanalysis, regional climate model, statistical downscaling}, + pages = {679--689}, +} + +@article{hnilica_multisite_2017, + title = {Multisite bias correction of precipitation data from regional climate models}, + volume = {37}, + issn = {1097-0088}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/joc.4890}, + doi = {10.1002/joc.4890}, + abstract = {The characteristics of precipitation in regional climate model simulations deviate considerably from those of the observed data; therefore, bias correction is a standard part of most climate change impact assessment studies. The standard approach is that the corrections are calibrated and applied separately for individual spatial points and meteorological variables. For this reason, the correlation and covariance structures of the observed and corrected data differ, although the individual observed and corrected data sets correspond well in their statistical indicators. This inconsistency may affect impact studies using corrected simulations. This study presents a new approach to the bias correction utilizing principal components in combination with quantile mapping, which allows for the correction of multivariate data sets. The proposed procedure significantly reduces the bias in covariance and correlation structures, as well as that in the distribution of individual variables. This is in contrast to standard quantile mapping, which only corrects the individual distributions, and leaves the dependence structure biased.}, + language = {en}, + number = {6}, + urldate = {2022-07-29}, + journal = {International Journal of Climatology}, + author = {Hnilica, Jan and Hanel, Martin and Puš, Vladimír}, + year = {2017}, + keywords = {bias correction, correlation, covariance, multisite correction, multivariate data, precipitation, principal components, regional climate model}, + pages = {2934--2946}, +} + +@article{cannon_multivariate_2018, + title = {Multivariate quantile mapping bias correction: an {N}-dimensional probability density function transform for climate model simulations of multiple variables}, + volume = {50}, + issn = {1432-0894}, + shorttitle = {Multivariate quantile mapping bias correction}, + url = {https://doi.org/10.1007/s00382-017-3580-6}, + doi = {10.1007/s00382-017-3580-6}, + abstract = {Most bias correction algorithms used in climatology, for example quantile mapping, are applied to univariate time series. They neglect the dependence between different variables. Those that are multivariate often correct only limited measures of joint dependence, such as Pearson or Spearman rank correlation. Here, an image processing technique designed to transfer colour information from one image to another—the N-dimensional probability density function transform—is adapted for use as a multivariate bias correction algorithm (MBCn) for climate model projections/predictions of multiple climate variables. MBCn is a multivariate generalization of quantile mapping that transfers all aspects of an observed continuous multivariate distribution to the corresponding multivariate distribution of variables from a climate model. When applied to climate model projections, changes in quantiles of each variable between the historical and projection period are also preserved. The MBCn algorithm is demonstrated on three case studies. First, the method is applied to an image processing example with characteristics that mimic a climate projection problem. Second, MBCn is used to correct a suite of 3-hourly surface meteorological variables from the Canadian Centre for Climate Modelling and Analysis Regional Climate Model (CanRCM4) across a North American domain. Components of the Canadian Forest Fire Weather Index (FWI) System, a complicated set of multivariate indices that characterizes the risk of wildfire, are then calculated and verified against observed values. Third, MBCn is used to correct biases in the spatial dependence structure of CanRCM4 precipitation fields. Results are compared against a univariate quantile mapping algorithm, which neglects the dependence between variables, and two multivariate bias correction algorithms, each of which corrects a different form of inter-variable correlation structure. MBCn outperforms these alternatives, often by a large margin, particularly for annual maxima of the FWI distribution and spatiotemporal autocorrelation of precipitation fields.}, + language = {en}, + number = {1}, + urldate = {2022-07-29}, + journal = {Climate Dynamics}, + author = {Cannon, Alex J.}, + month = jan, + year = {2018}, + keywords = {Bias correction, Climate model, Fire weather, Model output statistics, Multivariate, Post-processing, Precipitation, Quantile mapping}, + pages = {31--49}, +} + +@inproceedings{pitie_n-dimensional_2005, + title = {N-dimensional probability density function transfer and its application to color transfer}, + volume = {2}, + doi = {10.1109/ICCV.2005.166}, + abstract = {This article proposes an original method to estimate a continuous transformation that maps one N-dimensional distribution to another. The method is iterative, non-linear, and is shown to converge. Only 1D marginal distribution is used in the estimation process, hence involving low computation costs. As an illustration this mapping is applied to color transfer between two images of different contents. The paper also serves as a central focal point for collecting together the research activity in this area and relating it to the important problem of automated color grading}, + language = {en}, + booktitle = {Tenth {IEEE} {International} {Conference} on {Computer} {Vision} ({ICCV}'05) {Volume} 1}, + author = {Pitie, F. and Kokaram, A.C. and Dahyot, R.}, + month = oct, + year = {2005}, + keywords = {Color, Computational efficiency, Density functional theory, Distributed computing, Educational institutions, Image converters, Iterative methods, Rendering (computer graphics), Statistical distributions, Statistics}, + pages = {1434--1439 Vol. 2}, +} + +@article{szekely_testing_2004, + title = {Testing for equal distributions in high dimension}, + volume = {5}, + abstract = {We propose a new nonparametric test for equality of two or more multivariate distributions based on Euclidean distance between sample elements. Several consistent tests for comparing multivariate distribu-tions can be developed from the underlying theoretical results. The test procedure for the multisample problem is developed and applied for testing the composite hypothesis of equal distributions, when dis-tributions are unspecified. The proposed test is universally consistent against all fixed alternatives (not necessarily continuous) with finite second moments. The test is implemented by conditioning on the pooled sample to obtain an approximate permutation test, which is distribution free. Our Monte Carlo power study suggests that the new test may be much more sensitive than tests based on nearest neighbors against several classes of alternatives, and performs particularly well in high dimension. Computational complexity of our test procedure is independent of dimension and number of populations sampled. The test is applied in a high dimensional problem, testing microarray data from cancer samples.}, + journal = {InterStat}, + author = {Szekely, Gabor and Rizzo, Maria}, + month = nov, + year = {2004}, +} + +@misc{mezzadri_how_2007, + title = {How to generate random matrices from the classical compact groups}, + url = {https://arxiv.org/abs/math-ph/0609050}, + doi = {10.48550/arXiv.math-ph/0609050}, + abstract = {We discuss how to generate random unitary matrices from the classical compact groups U(N), O(N) and USp(N) with probability distributions given by the respective invariant measures. The algorithm is straightforward to implement using standard linear algebra packages. This approach extends to the Dyson circular ensembles too. This article is based on a lecture given by the author at the summer school on Number Theory and Random Matrix Theory held at the University of Rochester in June 2006. The exposition is addressed to a general mathematical audience.}, + urldate = {2022-11-16}, + publisher = {arXiv}, + author = {Mezzadri, Francesco}, + month = feb, + year = {2007}, + keywords = {1502,15A52, 65F25, Mathematical Physics, Mathematics - Numerical Analysis}, +} + +@article{hyndman_sample_1996, + title = {Sample {Quantiles} in {Statistical} {Packages}}, + volume = {50}, + issn = {0003-1305}, + url = {https://www.tandfonline.com/doi/abs/10.1080/00031305.1996.10473566}, + doi = {10.1080/00031305.1996.10473566}, + abstract = {There are a large number of different definitions used for sample quantiles in statistical computer packages. Often within the same package one definition will be used to compute a quantile explicitly, while other definitions may be used when producing a boxplot, a probability plot, or a QQ plot. We compare the most commonly implemented sample quantile definitions by writing them in a common notation and investigating their motivation and some of their properties. We argue that there is a need to adopt a standard definition for sample quantiles so that the same answers are produced by different packages and within each package. We conclude by recommending that the median-unbiased estimator be used because it has most of the desirable properties of a quantile estimator and can be defined independently of the underlying distribution.}, + number = {4}, + urldate = {2022-08-03}, + journal = {The American Statistician}, + author = {Hyndman, Rob J. and Fan, Yanan}, + month = nov, + year = {1996}, + keywords = {Percentiles, Quartiles, Sample quantiles, Statistical computer packages}, + pages = {361--365}, +} + +@article{cleveland_robust_1979, + title = {Robust {Locally} {Weighted} {Regression} and {Smoothing} {Scatterplots}}, + volume = {74}, + issn = {0162-1459}, + url = {https://www.tandfonline.com/doi/abs/10.1080/01621459.1979.10481038}, + doi = {10.1080/01621459.1979.10481038}, + abstract = {The visual information on a scatterplot can be greatly enhanced, with little additional cost, by computing and plotting smoothed points. Robust locally weighted regression is a method for smoothing a scatterplot, (x i , y i ), i = 1, …, n, in which the fitted value at z k is the value of a polynomial fit to the data using weighted least squares, where the weight for (x i , y i ) is large if x i is close to x k and small if it is not. A robust fitting procedure is used that guards against deviant points distorting the smoothed points. Visual, computational, and statistical issues of robust locally weighted regression are discussed. Several examples, including data on lead intoxication, are used to illustrate the methodology.}, + number = {368}, + urldate = {2022-07-29}, + journal = {Journal of the American Statistical Association}, + author = {Cleveland, William S.}, + month = dec, + year = {1979}, + keywords = {Graphics, Nonparametric regression, Robust estimation, Scatterplots, Smoothing}, + pages = {829--836}, +} + +@misc{gramfort_lowess_2015, + title = {{LOWESS} : {Locally} weighted regression}, + copyright = {BSD 3-Clause}, + shorttitle = {{LOWESS}}, + url = {https://gist.github.com/agramfort/850437}, + abstract = {LOWESS : Locally weighted regression. GitHub Gist: instantly share code, notes, and snippets.}, + urldate = {2022-08-05}, + author = {Gramfort, Alexandre}, + month = oct, + year = {2015}, +} + + +@article{themesl_empirical-statistical_2012, + title = {Empirical-statistical downscaling and error correction of regional climate models and its impact on the climate change signal}, + volume = {112}, + issn = {1573-1480}, + url = {https://doi.org/10.1007/s10584-011-0224-4}, + doi = {10.1007/s10584-011-0224-4}, + abstract = {Realizing the error characteristics of regional climate models (RCMs) and the consequent limitations in their direct utilization in climate change impact research, this study analyzes a quantile-based empirical-statistical error correction method (quantile mapping, QM) for RCMs in the context of climate change. In particular the success of QM in mitigating systematic RCM errors, its ability to generate “new extremes” (values outside the calibration range), and its impact on the climate change signal (CCS) are investigated. In a cross-validation framework based on a RCM control simulation over Europe, QM reduces the bias of daily mean, minimum, and maximum temperature, precipitation amount, and derived indices of extremes by about one order of magnitude and strongly improves the shapes of the related frequency distributions. In addition, a simple extrapolation of the error correction function enables QM to reproduce “new extremes” without deterioration and mostly with improvement of the original RCM quality. QM only moderately modifies the CCS of the corrected parameters. The changes are related to trends in the scenarios and magnitude-dependent error characteristics. Additionally, QM has a large impact on CCSs of non-linearly derived indices of extremes, such as threshold indices.}, + language = {en}, + number = {2}, + urldate = {2022-07-29}, + journal = {Climatic Change}, + author = {Themeßl, Matthias Jakob and Gobiet, Andreas and Heinrich, Georg}, + month = may, + year = {2012}, + keywords = {Climate Change Signal, Pacific Decadal Oscillation, Precipitation Amount, Quantile Mapping, Regional Climate Model}, + pages = {449--468}, +} + + +@article{baringhaus_new_2004, + title = {On a new multivariate two-sample test}, + volume = {88}, + issn = {0047-259X}, + url = {https://www.sciencedirect.com/science/article/pii/S0047259X03000794}, + doi = {10.1016/S0047-259X(03)00079-4}, + abstract = {In this paper we propose a new test for the multivariate two-sample problem. The test statistic is the difference of the sum of all the Euclidean interpoint distances between the random variables from the two different samples and one-half of the two corresponding sums of distances of the variables within the same sample. The asymptotic null distribution of the test statistic is derived using the projection method and shown to be the limit of the bootstrap distribution. A simulation study includes the comparison of univariate and multivariate normal distributions for location and dispersion alternatives. For normal location alternatives the new test is shown to have power similar to that of the t- and T2-Test.}, + language = {en}, + number = {1}, + urldate = {2022-07-29}, + journal = {Journal of Multivariate Analysis}, + author = {Baringhaus, L. and Franz, C.}, + month = jan, + year = {2004}, + keywords = {Bootstrapping, Cramér test, Multivariate two-sample test, Orthogonal invariance, Projection method}, + pages = {190--206}, +} +@article{alavoine_distinct_2022, + title = {The distinct problems of physical inconsistency and of multivariate bias involved in the statistical adjustment of climate simulations}, + issn = {1097-0088}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/joc.7878}, + doi = {10.1002/joc.7878}, + abstract = {Bias adjustment of numerical climate model simulations involves several arguments wherein the notion of physical inconsistency is referred to, either for rejecting the legitimacy of bias adjustment in general or for justifying the necessity of sophisticated multivariate techniques. However, this notion is often mishandled, in part because the literature generally proceeds without defining it. In this context, the central objective of this study is to clarify and illustrate the distinction between physical inconsistency and multivariate bias, by investigating the effect of bias adjustment on two different kinds of intervariable relationships, namely a physical constraint expected to hold at every step of a time series and statistical properties that emerge with potential bias over a climatic timescale. To this end, 18 alternative bias adjustment techniques are applied on 10 climate simulations at 12 sites over North America. Adjusted variables are temperature, pressure, relative humidity and specific humidity, linked by a thermodynamic constraint. The analysis suggests on the one hand that a clear instance of potential physical inconsistency can be avoided with either a univariate or a multivariate technique, if and only if the bias adjustment strategy explicitly considers the physical constraint to be preserved. On the other hand, it also suggests that sophisticated multivariate techniques alone are not complete adjustment strategies in presence of a physical constraint, as they cannot replace its explicit consideration. By involving common bias adjustment procedures with likely effects on diverse basic statistical properties, this study may also help guide climate information users in the determination of adequate bias adjustment strategies for their research purposes.}, + language = {en}, + urldate = {2022-11-16}, + journal = {International Journal of Climatology}, + author = {Alavoine, Mégane and Grenier, Patrick}, + month = sep, + year = {2022}, + keywords = {bias adjustment techniques, climate simulations, multivariate biases, physical relationships}, + pages = {1--23}, +} + +@article{francois_multivariate_2020, + title = {Multivariate bias corrections of climate simulations: which benefits for which losses?}, + volume = {11}, + issn = {2190-4979}, + shorttitle = {Multivariate bias corrections of climate simulations}, + url = {https://esd.copernicus.org/articles/11/537/2020/}, + doi = {10.5194/esd-11-537-2020}, + language = {English}, + number = {2}, + urldate = {2022-04-27}, + journal = {Earth System Dynamics}, + author = {François, Bastien and Vrac, Mathieu and Cannon, Alex J. and Robin, Yoann and Allard, Denis}, + month = jun, + year = {2020}, + pages = {537--562}, +} + +@misc{jalbert_extreme_2022, + title = {Extreme value analysis package for {Julia}.}, + url = {https://github.com/jojal5/Extremes.jl}, + abstract = {Extreme value analysis package for Julia}, + urldate = {2022-07-29}, + author = {Jalbert, Jonathan}, + month = jun, + year = {2022}, +} + + +@book{coles_introduction_2001, + address = {London, UK}, + series = {Springer {Series} in {Statistics}}, + title = {An {Introduction} to {Statistical} {Modeling} of {Extreme} {Values}}, + isbn = {978-1-85233-459-8}, + url = {https://link.springer.com/book/10.1007/978-1-4471-3675-0}, + abstract = {Directly oriented towards real practical application, this book develops both the basic theoretical framework of extreme value models and the statistical inferential techniques for using these models in practice. Intended for statisticians and non-statisticians alike, the theoretical treatment is elementary, with heuristics often replacing detailed mathematical proof. Most aspects of extreme modeling techniques are covered, including historical techniques (still widely used) and contemporary techniques based on point process models. A wide range of worked examples, using genuine datasets, illustrate the various modeling procedures and a concluding chapter provides a brief introduction to a number of more advanced topics, including Bayesian inference and spatial extremes. All the computations are carried out using S-PLUS, and the corresponding datasets and functions are available via the Internet for readers to recreate examples for themselves. An essential reference for students and researchers in statistics and disciplines such as engineering, finance and environmental science, this book will also appeal to practitioners looking for practical help in solving real problems. Stuart Coles is Reader in Statistics at the University of Bristol, UK, having previously lectured at the universities of Nottingham and Lancaster. In 1992 he was the first recipient of the Royal Statistical Society's research prize. He has published widely in the statistical literature, principally in the area of extreme value modeling.}, + language = {en}, + urldate = {2022-07-29}, + publisher = {Springer-Verlag}, + author = {Coles, Stuart}, + month = aug, + year = {2001}, + keywords = {Mathematics / Probability \& Statistics / General, Mathematics / Probability \& Statistics / Stochastic Processes, Medical / Biostatistics}, +} + +@book{cohen_parameter_2019, + title = {Parameter {Estimation} in {Reliability} and {Life} {Span} {Models}}, + isbn = {978-0-367-40334-8}, + abstract = {Offers an applications-oriented treatment of parameter estimation from both complete and censored samples; contains notations, simplified formats for estimates, graphical techniques, and numerous tables and charts allowing users to calculate estimates and analyze sample data quickly and easily. Furnishing numerous practical examples, this resource serves as a handy reference for statisticians, biometricians, medical researchers, operations research and quality control practitioners, reliability and design engineers, and all others involved in the analysis of sample data from skewed distributions, as well as a text for senior undergraduate and graduate students in statistics, quality control, operations research, mathematics and biometry courses.}, + publisher = {CRC Press}, + author = {Cohen, A Clifford and Whitten, Betty Jones}, + month = sep, + year = {2019}, +} + +@article{thom_1958, + title = {A Note on the Gamma Distribution}, + author = {Thom, H. C. S.}, + year = {1958}, + journal = {Monthly Weather Review}, + volume = {86}, + number = {4}, + pages = {117--122}, + publisher = {{American Meteorological Society}}, + issn = {1520-0493, 0027-0644}, + doi = {10.1175/1520-0493(1958)086<0117:ANOTGD>2.0.CO;2}, + abstract = {Abstract The general properties of the gamma distribution, which has several applications in meteorology, are discussed. A short review of the general properties of good statistical estimators is given. This is applied to the gamma distribution to show that the maximum likelihood estimators are jointly sufficient. A new, simple approximation of the likelihood solutions is given, and the efficiency of the fitting procedure is computed.}, + chapter = {Monthly Weather Review}, +} + +@article{muralidhar_1992, + title = {A {{Simple Minimum}}-{{Bias Percentile Estimator}} of the {{Location Parameter}} for the {{Gamma}}, {{Weibull}}, and {{Log}}-{{Normal Distributions}}}, + author = {Muralidhar, Krishnamurty and Zanakis, Stelios H.}, + year = {1992}, + month = jul, + journal = {Decision Sciences}, + volume = {23}, + number = {4}, + pages = {862--879}, + issn = {0011-7315, 1540-5915}, + doi = {10.1111/j.1540-5915.1992.tb00423.x} +} + +@article{cooke_1979, + title = {Statistical Inference for Bounds of Random Variables}, + author = {Cooke, Peter}, + year = {1979}, + journal = {Biometrika}, + volume = {66}, + number = {2}, + pages = {367--374}, + issn = {0006-3444, 1464-3510}, + doi = {10.1093/biomet/66.2.367} +} + +@article{hoffmann_meteorologically_2012, + title = {Meteorologically consistent bias correction of climate time series for agricultural models}, + volume = {110}, + issn = {1434-4483}, + url = {https://doi.org/10.1007/s00704-012-0618-x}, + doi = {10.1007/s00704-012-0618-x}, + abstract = {Conventional bias correction of simulated climate time series for impact models is done separately for climate variables and hence leads to inconsistencies between them. However, agricultural models mostly use several variables, and meteorological consistency is essential. The present work points out meteorological inconsistency due to quantile mapping and describes a new method of consistent bias correction by an optimization approach. Time series of hourly precipitation and global radiation from the regional model REMO5.7 (Run UBA C20/A1B\_1) were corrected with site observations from the German Meteorological Service. The results urge to check conventionally corrected series for consistency before using them for multidimensional models. Here, quantile mapping resulted in underestimation of diffuse radiation at hours with precipitation. This deficit was minimized by the developed procedure.}, + language = {en}, + number = {1}, + urldate = {2022-08-03}, + journal = {Theoretical and Applied Climatology}, + author = {Hoffmann, Holger and Rath, Thomas}, + month = oct, + year = {2012}, + keywords = {Bias Correction, Diffuse Radiation, Global Radiation, Quantile Mapping, Simulated Time Series}, + pages = {129--141}, +} + +@article{thrasher_technical_2012, + title = {Technical {Note}: {Bias} correcting climate model simulated daily temperature extremes with quantile mapping}, + volume = {16}, + issn = {1027-5606}, + shorttitle = {Technical {Note}}, + url = {https://hess.copernicus.org/articles/16/3309/2012/}, + doi = {10.5194/hess-16-3309-2012}, + abstract = {{\textless}p{\textgreater}{\textless}strong class="journal-contentHeaderColor"{\textgreater}Abstract.{\textless}/strong{\textgreater} When applying a quantile mapping-based bias correction to daily temperature extremes simulated by a global climate model (GCM), the transformed values of maximum and minimum temperatures are changed, and the diurnal temperature range (DTR) can become physically unrealistic. While causes are not thoroughly explored, there is a strong relationship between GCM biases in snow albedo feedback during snowmelt and bias correction resulting in unrealistic DTR values. We propose a technique to bias correct DTR, based on comparing observations and GCM historic simulations, and combine that with either bias correcting daily maximum temperatures and calculating daily minimum temperatures or vice versa. By basing the bias correction on a base period of 1961–1980 and validating it during a test period of 1981–1999, we show that bias correcting DTR and maximum daily temperature can produce more accurate estimations of daily temperature extremes while avoiding the pathological cases of unrealistic DTR values.{\textless}/p{\textgreater}}, + language = {English}, + number = {9}, + urldate = {2022-08-03}, + journal = {Hydrology and Earth System Sciences}, + author = {Thrasher, B. and Maurer, E. P. and McKellar, C. and Duffy, P. B.}, + month = sep, + year = {2012}, + note = {Publisher: Copernicus GmbH}, + pages = {3309--3314}, +} + +@article{grenier_two_2018, + title = {Two {Types} of {Physical} {Inconsistency} to {Avoid} with {Univariate} {Quantile} {Mapping}: {A} {Case} {Study} over {North} {America} {Concerning} {Relative} {Humidity} and {Its} {Parent} {Variables}}, + volume = {57}, + issn = {1558-8424, 1558-8432}, + shorttitle = {Two {Types} of {Physical} {Inconsistency} to {Avoid} with {Univariate} {Quantile} {Mapping}}, + url = {https://journals.ametsoc.org/view/journals/apme/57/2/jamc-d-17-0177.1.xml}, + doi = {10.1175/JAMC-D-17-0177.1}, + abstract = {Abstract Univariate quantile mapping (QM), a technique often used to statistically postprocess climate simulations, may generate physical inconsistency. This issue is investigated here by classifying physical inconsistency into two types. Type I refers to the attribution of an impossible value to a single variable, and type II refers to the breaking of a fixed intervariable relationship. Here QM is applied to relative humidity (RH) and its parent variables, namely, temperature, pressure, and specific humidity. Twelve sites representing various climate types across North America are investigated. Time series from an ensemble of ten 3-hourly simulations are postprocessed, with the CFSR reanalysis used as the reference product. For type I, results indicate that direct postprocessing of RH generates supersaturation values ({\textgreater}100\%) at relatively small frequencies of occurrence. Generated supersaturation amplitudes exceed observed values in fog and clouds. Supersaturation values are generally more frequent and higher when RH is deduced from postprocessed parent variables. For type II, results show that univariate QM practically always breaks the intervariable thermodynamic relationship. Heuristic proxies are designed for comparing the initial bias with physical inconsistency of type II, and results suggest that QM generates a problem that is arguably lesser than the one it is intended to solve. When physical inconsistency is avoided by capping one humidity variable at its saturation level and deducing the other, statistical equivalence with the reference product remains much improved relative to the initial situation. A recommendation for climate services is to postprocess RH and deduce specific humidity rather than the opposite.}, + language = {EN}, + number = {2}, + urldate = {2022-08-03}, + journal = {Journal of Applied Meteorology and Climatology}, + author = {Grenier, Patrick}, + month = feb, + year = {2018}, + pages = {347--364}, +} + +@article{agbazo_characterizing_2020, + title = {Characterizing and avoiding physical inconsistency generated by the application of univariate quantile mapping on daily minimum and maximum temperatures over {Hudson} {Bay}}, + volume = {40}, + issn = {1097-0088}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/joc.6432}, + doi = {10.1002/joc.6432}, + abstract = {Quantile mapping (QM) is a technique often used for statistical post-processing (SPP) of climate model simulations, in order to adjust their biases relative to a selected reference product and/or to downscale their resolution. However, when QM is applied in univariate mode, there is a risk of generating other problems, like intervariable physical inconsistency (PI). Here, such a risk is investigated with daily temperature minimum (Tmin) and maximum (Tmax), for which the relationship Tmin {\textgreater} Tmax would be inconsistent with the definition of the variables. QM is applied to an ensemble of 78 daily CMIP5 simulations over Hudson Bay for the application period 1979–2100, with Climate Forecast System Reanalysis (CFSR) selected as the reference product during the calibration period 1979–2010. This study's specific objectives are as follows: to investigate the conditions under which PI situations are generated; to test whether PI may be prevented simply by tuning some of the QM technique's numerical choices; and to compare the suitability of alternative approaches that hinder PI by design. Primary results suggest that PI situations appear preferentially for small values of the initial (simulated) diurnal temperature range (DTR), but the differential between the respective biases of Tmin and Tmax also plays an important role; one cannot completely prevent the generation of PI simply by adjusting QM parameters and options, but forcing preservation of the simulated long-term trends generates fewer PI situations; for avoiding PI between Tmin and Tmax, the present study supports a previous recommendation to directly post-process Tmax and DTR before deducing Tmin.}, + language = {en}, + number = {8}, + urldate = {2022-08-03}, + journal = {International Journal of Climatology}, + author = {Agbazo, Médard Noukpo and Grenier, Patrick}, + year = {2020}, + keywords = {bias adjustment, climate simulations, physical inconsistency, univariate quantile mapping}, + pages = {3868--3884}, +} diff --git a/docs/xsdba.rst b/docs/xsdba.rst index 10a9fca..90ed6ad 100644 --- a/docs/xsdba.rst +++ b/docs/xsdba.rst @@ -4,9 +4,7 @@ Bias Adjustment and Downscaling Algorithms The `xsdba` submodule provides a collection of bias-adjustment methods meant to correct for systematic biases found in climate model simulations relative to observations. Almost all adjustment algorithms conform to the `train` - `adjust` scheme, meaning that adjustment factors are first estimated on training data sets, then applied in a distinct step to the data to be adjusted. -Given a reference time series (`ref``), historical simulations (`hist``) and simulations to be adjusted (`sim``), -any bias-adjustment method would be applied by first estimating the adjustment factors between the historical simulation -and the observation series, and then applying these factors to `sim`, which could be a future simulation: +Given a reference time series (`ref`), historical simulations (`hist`) and simulations to be adjusted (`sim`), any bias-adjustment method would be applied by first estimating the adjustment factors between the historical simulation and the observation series, and then applying these factors to `sim``, which could be a future simulation: .. code-block:: python @@ -31,16 +29,18 @@ Modular Approach The module attempts to adopt a modular approach instead of implementing published and named methods directly. A generic bias adjustment process is laid out as follows: -- preprocessing on ``ref``, ``hist`` and ``sim`` (using methods in :py:mod:`xsdba.processing` or :py:mod:`xsdba.detrending`) +- preprocessing on `ref`, `hist` and `sim` (using methods in :py:mod:`xsdba.processing` or :py:mod:`xsdba.detrending`) - creating and training the adjustment object ``Adj = Adjustment.train(obs, sim, **kwargs)`` (from :py:mod:`xsdba.adjustment`) - adjustment ``scen = Adj.adjust(sim, **kwargs)`` -- post-processing on ``scen`` (for example: re-trending) +- post-processing on `scen` (for example: re-trending) .. + TODO : Find a way to link API below, and those later in the file. -The train-adjust approach allows to inspect the trained adjustment object. The training information is stored in -the underlying `Adj.ds` dataset and usually has a `af` variable with the adjustment factors. Its layout and the -other available variables vary between the different algorithm, refer to :ref:`Adjustment methods <sdba-user-api>`. + +The train-adjust approach allows to inspect the trained adjustment object. +The training information is stored in the underlying `Adj.ds` dataset and usually has a `af` variable with the adjustment factors. +Its layout and the other available variables vary between the different algorithm, refer to :ref:`Adjustment methods <sdba-user-api>`. Parameters needed by the training and the adjustment are saved to the ``Adj.ds`` dataset as a `adj_params` attribute. Parameters passed to the `adjust` call are written to the history attribute in the output scenario DataArray. @@ -57,6 +57,7 @@ for each day of the year but across all realizations of an ensemble : ``group = In a conventional empirical quantile mapping (EQM), this will compute the quantiles for each day of year and all realizations together, yielding a single set of adjustment factors for all realizations. .. warning:: + If grouping according to the day of the year is needed, the :py:mod:`xsdba.calendar` submodule contains useful tools to manage the different calendars that the input data can have. By default, if 2 different calendars are passed, the adjustment factors will always be interpolated to the largest range of day of the years but this can diff --git a/environment-docs.yml b/environment-docs.yml index c1adada..5c88da2 100644 --- a/environment-docs.yml +++ b/environment-docs.yml @@ -11,5 +11,6 @@ dependencies: - sphinx-codeautolink - sphinx-copybutton - sphinx-intl + - sphinxcontrib-bibtex - sphinxcontrib-napoleon - typer >=0.12.3 diff --git a/src/xsdba/__init__.py b/src/xsdba/__init__.py index 5d8b5d3..d5848ac 100644 --- a/src/xsdba/__init__.py +++ b/src/xsdba/__init__.py @@ -20,13 +20,13 @@ from __future__ import annotations -import importlib +import importlib.util import warnings from . import adjustment, base, detrending, processing, testing, units, utils xclim_installed = importlib.util.find_spec("xclim") is not None -if xclim_installed: +if not xclim_installed: warnings.warn( "Sub-modules `properties` and `measures` depend on `xclim`. Run `pip install xsdba['extras']` to install it." ) From 923b0e9c85b5b94b4b74f178d55a9b4391ed37e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Mon, 7 Oct 2024 13:47:08 -0400 Subject: [PATCH 082/105] fix tests, remove xclim redundancies --- README.rst | 2 +- environment-dev.yml | 4 +- pyproject.toml | 2 +- src/xsdba/adjustment.py | 2 +- src/xsdba/base.py | 863 +++++++++++++++---- src/xsdba/calendar.py | 1692 -------------------------------------- src/xsdba/datachecks.py | 123 --- src/xsdba/nbutils.py | 2 +- src/xsdba/options.py | 7 +- src/xsdba/processing.py | 51 +- src/xsdba/testing.py | 1 - src/xsdba/units.py | 37 +- src/xsdba/utils.py | 243 +++++- tests/test_adjustment.py | 24 +- tests/test_indicator.py | 886 -------------------- tests/test_processing.py | 14 +- 16 files changed, 970 insertions(+), 2983 deletions(-) delete mode 100644 src/xsdba/calendar.py delete mode 100644 src/xsdba/datachecks.py delete mode 100644 tests/test_indicator.py diff --git a/README.rst b/README.rst index aa2612b..41006b3 100644 --- a/README.rst +++ b/README.rst @@ -37,7 +37,7 @@ This package was created with Cookiecutter_ and the `Ouranosinc/cookiecutter-pyp :target: https://github.com/psf/black :alt: Python Black -.. |logo| image:: https://raw.githubusercontent.com/Ouranosinc/xsdba/main/docs/logos/xclim-logo-small-light.png +.. |logo| image:: https://raw.githubusercontent.com/Ouranosinc/xsdba/main/docs/logos/xsdba-logo-small-light.png :target: https://github.com/Ouranosinc/xsdba :alt: Xsdba :class: xsdba-logo-small no-theme diff --git a/environment-dev.yml b/environment-dev.yml index 1d19293..7bba6d4 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -6,7 +6,7 @@ dependencies: - python >=3.9,<3.13 - boltons - bottleneck - - cf_xarray + - cf_xarray >=0.9.3 - cftime - dask # why was this not installed? This is only pulled in by xclim, optional for xarray. - h5netcdf >=1.3.0 @@ -18,8 +18,8 @@ dependencies: - statsmodels - xarray >=2023.11.0 - yamale - # - xarray >=2022.05.0.dev0 # Dev tools and testing + - netcdf4 - pip >=24.2.0 - bump-my-version >=0.25.1 - watchdog >=4.0.0 diff --git a/pyproject.toml b/pyproject.toml index 87e279e..03ecc11 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,7 +36,7 @@ dynamic = ["description", "version"] dependencies = [ "boltons", "bottleneck", - "cf_xarray", + "cf_xarray>=0.9.3", "cftime", "dask", "h5netcdf>=1.3.0", diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 124d212..4ecbb2b 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -1178,7 +1178,7 @@ class NpdfTransform(Adjust): The random matrices are generated following a method laid out by :cite:t:`sdba-mezzadri_how_2007`. This is only part of the full MBCn algorithm, see :ref:`notebooks/sdba:Statistical Downscaling and Bias-Adjustment` - for an example on how to replicate the full method with xclim. This includes a standardization of the simulated data + for an example on how to replicate the full method with xsdba. This includes a standardization of the simulated data beforehand, an initial univariate adjustment and the reordering of those adjusted series according to the rank structure of the output of this algorithm. diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 40f8f1c..b27d257 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -18,6 +18,7 @@ import pandas as pd import xarray as xr from boltons.funcutils import wraps +from xarray.core import dtypes from xsdba.options import OPTIONS, SDBA_ENCODE_CF @@ -106,184 +107,6 @@ def set_dataset(self, ds: xr.Dataset) -> None: self.ds.attrs[self._attribute] = jsonpickle.encode(self) -# XC : keep in the same file as `uses_dask` below -def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: - r"""Ensure that the input DataArray has chunks of at least the given size. - - If only one chunk is too small, it is merged with an adjacent chunk. - If many chunks are too small, they are grouped together by merging adjacent chunks. - - Parameters - ---------- - da : xr.DataArray - The input DataArray, with or without the dask backend. Does nothing when passed a non-dask array. - \*\*minchunks : dict[str, int] - A kwarg mapping from dimension name to minimum chunk size. - Pass -1 to force a single chunk along that dimension. - - Returns - ------- - xr.DataArray - """ - if not uses_dask(da): - return da - - all_chunks = dict(zip(da.dims, da.chunks)) - chunking = {} - for dim, minchunk in minchunks.items(): - chunks = all_chunks[dim] - if minchunk == -1 and len(chunks) > 1: - # Rechunk to single chunk only if it's not already one - chunking[dim] = -1 - - toosmall = np.array(chunks) < minchunk # Chunks that are too small - if toosmall.sum() > 1: - # Many chunks are too small, merge them by groups - fac = np.ceil(minchunk / min(chunks)).astype(int) - chunking[dim] = tuple( - sum(chunks[i : i + fac]) for i in range(0, len(chunks), fac) - ) - # Reset counter is case the last chunks are still too small - chunks = chunking[dim] - toosmall = np.array(chunks) < minchunk - if toosmall.sum() == 1: - # Only one, merge it with adjacent chunk - ind = np.where(toosmall)[0][0] - new_chunks = list(chunks) - sml = new_chunks.pop(ind) - new_chunks[max(ind - 1, 0)] += sml - chunking[dim] = tuple(new_chunks) - - if chunking: - return da.chunk(chunks=chunking) - return da - - -# XC put here to avoid circular import -def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: - r"""Evaluate whether dask is installed and array is loaded as a dask array. - - Parameters - ---------- - \*das : xr.DataArray or xr.Dataset - DataArrays or Datasets to check. - - Returns - ------- - bool - True if any of the passed objects is using dask. - """ - if len(das) > 1: - return any([uses_dask(da) for da in das]) - da = das[0] - if isinstance(da, xr.DataArray) and isinstance(da.data, dsk.Array): - return True - if isinstance(da, xr.Dataset) and any( - isinstance(var.data, dsk.Array) for var in da.variables.values() - ): - return True - return False - - -# XC -# Maximum day of year in each calendar. -max_doy = { - "standard": 366, - "gregorian": 366, - "proleptic_gregorian": 366, - "julian": 366, - "noleap": 365, - "365_day": 365, - "all_leap": 366, - "366_day": 366, - "360_day": 360, -} - - -# XC -def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: - """Parse an offset string. - - Parse a frequency offset and, if needed, convert to cftime-compatible components. - - Parameters - ---------- - freq : str - Frequency offset. - - Returns - ------- - multiplier : int - Multiplier of the base frequency. "[n]W" is always replaced with "[7n]D", - as xarray doesn't support "W" for cftime indexes. - offset_base : str - Base frequency. - is_start_anchored : bool - Whether coordinates of this frequency should correspond to the beginning of the period (`True`) - or its end (`False`). Can only be False when base is Y, Q or M; in other words, xsdba assumes frequencies finer - than monthly are all start-anchored. - anchor : str, optional - Anchor date for bases Y or Q. As xarray doesn't support "W", - neither does xsdba (anchor information is lost when given). - """ - # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) - offset = pd.tseries.frequencies.to_offset(freq) - base, *anchor = offset.name.split("-") - anchor = anchor[0] if len(anchor) > 0 else None - start = ("S" in base) or (base[0] not in "AYQM") - if base.endswith("S") or base.endswith("E"): - base = base[:-1] - mult = offset.n - if base == "W": - mult = 7 * mult - base = "D" - anchor = None - return mult, base, start, anchor - - -# XC put here to avoid circular import -def get_calendar(obj: Any, dim: str = "time") -> str: - """Return the calendar of an object. - - Parameters - ---------- - obj : Any - An object defining some date. - If `obj` is an array/dataset with a datetime coordinate, use `dim` to specify its name. - Values must have either a datetime64 dtype or a cftime dtype. - `obj` can also be a python datetime.datetime, a cftime object or a pandas Timestamp - or an iterable of those, in which case the calendar is inferred from the first value. - dim : str - Name of the coordinate to check (if `obj` is a DataArray or Dataset). - - Raises - ------ - ValueError - If no calendar could be inferred. - - Returns - ------- - str - The Climate and Forecasting (CF) calendar name. - Will always return "standard" instead of "gregorian", following CF conventions 1.9. - """ - if isinstance(obj, (xr.DataArray | xr.Dataset)): - return obj[dim].dt.calendar - elif isinstance(obj, xr.CFTimeIndex): - obj = obj.values[0] - else: - obj = np.take(obj, 0) - # Take zeroth element, overcome cases when arrays or lists are passed. - if isinstance(obj, pydt.datetime): # Also covers pandas Timestamp - return "standard" - if isinstance(obj, cftime.datetime): - if obj.calendar == "gregorian": - return "standard" - return obj.calendar - - raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") - - class Grouper(Parametrizable): """Grouper inherited class for parameterizable classes.""" @@ -408,7 +231,9 @@ def group( They are broadcast, merged to the grouping dataset and regrouped in the output. """ if das: - from .utils import broadcast # pylint: disable=cyclic-import + from .utils import ( # pylint: disable=cyclic-import,import-outside-toplevel + broadcast, + ) if da is not None: das[da.name] = da @@ -554,7 +379,7 @@ def apply( function may add a "_group_apply_reshape" attribute set to `True` on the variables that should be reduced and these will be re-grouped by calling `da.groupby(self.name).first()`. """ - if isinstance(da, (dict | xr.Dataset)): + if isinstance(da, dict | xr.Dataset): grpd = self.group(main_only=main_only, **da) dim_chunks = min( # Get smallest chunking to rechunk if the operation is non-grouping [ @@ -1019,3 +844,681 @@ def infer_kind_from_parameter(param) -> InputKind: return InputKind.DATASET return InputKind.OTHER_PARAMETER + + +# XC: core.utils +def ensure_chunk_size(da: xr.DataArray, **minchunks: int) -> xr.DataArray: + r"""Ensure that the input DataArray has chunks of at least the given size. + + If only one chunk is too small, it is merged with an adjacent chunk. + If many chunks are too small, they are grouped together by merging adjacent chunks. + + Parameters + ---------- + da : xr.DataArray + The input DataArray, with or without the dask backend. Does nothing when passed a non-dask array. + \*\*minchunks : dict[str, int] + A kwarg mapping from dimension name to minimum chunk size. + Pass -1 to force a single chunk along that dimension. + + Returns + ------- + xr.DataArray + """ + if not uses_dask(da): + return da + + all_chunks = dict(zip(da.dims, da.chunks)) + chunking = {} + for dim, minchunk in minchunks.items(): + chunks = all_chunks[dim] + if minchunk == -1 and len(chunks) > 1: + # Rechunk to single chunk only if it's not already one + chunking[dim] = -1 + + toosmall = np.array(chunks) < minchunk # Chunks that are too small + if toosmall.sum() > 1: + # Many chunks are too small, merge them by groups + fac = np.ceil(minchunk / min(chunks)).astype(int) + chunking[dim] = tuple( + sum(chunks[i : i + fac]) for i in range(0, len(chunks), fac) + ) + # Reset counter is case the last chunks are still too small + chunks = chunking[dim] + toosmall = np.array(chunks) < minchunk + if toosmall.sum() == 1: + # Only one, merge it with adjacent chunk + ind = np.where(toosmall)[0][0] + new_chunks = list(chunks) + sml = new_chunks.pop(ind) + new_chunks[max(ind - 1, 0)] += sml + chunking[dim] = tuple(new_chunks) + + if chunking: + return da.chunk(chunks=chunking) + return da + + +# XC: core.utils +def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: + r"""Evaluate whether dask is installed and array is loaded as a dask array. + + Parameters + ---------- + \*das : xr.DataArray or xr.Dataset + DataArrays or Datasets to check. + + Returns + ------- + bool + True if any of the passed objects is using dask. + """ + if len(das) > 1: + return any([uses_dask(da) for da in das]) + da = das[0] + if isinstance(da, xr.DataArray) and isinstance(da.data, dsk.Array): + return True + if isinstance(da, xr.Dataset) and any( + isinstance(var.data, dsk.Array) for var in da.variables.values() + ): + return True + return False + + +# XC: core +def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: + """Get python's comparing function according to its name of representation and validate allowed usage. + + Accepted op string are keys and values of xclim.indices.generic.binary_ops. + + Parameters + ---------- + op : str + Operator. + constrain : sequence of str, optional + A tuple of allowed operators. + """ + binary_ops = {">": "gt", "<": "lt", ">=": "ge", "<=": "le", "==": "eq", "!=": "ne"} + if op in binary_ops: + binary_op = binary_ops[op] + elif op in binary_ops.values(): + binary_op = op + else: + raise ValueError(f"Operation `{op}` not recognized.") + + constraints = [] + if isinstance(constrain, list | tuple | set): + constraints.extend([binary_ops[c] for c in constrain]) + constraints.extend(constrain) + elif isinstance(constrain, str): + constraints.extend([binary_ops[constrain], constrain]) + + if constrain: + if op not in constraints: + raise ValueError(f"Operation `{op}` not permitted for indice.") + + return xr.core.ops.get_op(binary_op) + + +# XC: calendar +def _interpolate_doy_calendar( + source: xr.DataArray, doy_max: int, doy_min: int = 1 +) -> xr.DataArray: + """Interpolate from one set of dayofyear range to another. + + Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 + to 365). + + Parameters + ---------- + source : xr.DataArray + Array with `dayofyear` coordinates. + doy_max : int + The largest day of the year allowed by calendar. + doy_min : int + The smallest day of the year in the output. + This parameter is necessary when the target time series does not span over a full year (e.g. JJA season). + Default is 1. + + Returns + ------- + xr.DataArray + Interpolated source array over coordinates spanning the target `dayofyear` range. + """ + if "dayofyear" not in source.coords.keys(): + raise AttributeError("Source should have `dayofyear` coordinates.") + + # Interpolate to fill na values + da = source + if uses_dask(source): + # interpolate_na cannot run on chunked dayofyear. + da = source.chunk({"dayofyear": -1}) + filled_na = da.interpolate_na(dim="dayofyear") + + # Interpolate to target dayofyear range + filled_na.coords["dayofyear"] = np.linspace( + start=doy_min, stop=doy_max, num=len(filled_na.coords["dayofyear"]) + ) + + return filled_na.interp(dayofyear=range(doy_min, doy_max + 1)) + + +# XC: calendar +def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: + """Parse an offset string. + + Parse a frequency offset and, if needed, convert to cftime-compatible components. + + Parameters + ---------- + freq : str + Frequency offset. + + Returns + ------- + multiplier : int + Multiplier of the base frequency. "[n]W" is always replaced with "[7n]D", + as xarray doesn't support "W" for cftime indexes. + offset_base : str + Base frequency. + is_start_anchored : bool + Whether coordinates of this frequency should correspond to the beginning of the period (`True`) + or its end (`False`). Can only be False when base is Y, Q or M; in other words, xsdba assumes frequencies finer + than monthly are all start-anchored. + anchor : str, optional + Anchor date for bases Y or Q. As xarray doesn't support "W", + neither does xsdba (anchor information is lost when given). + """ + # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) + offset = pd.tseries.frequencies.to_offset(freq) + base, *anchor = offset.name.split("-") + anchor = anchor[0] if len(anchor) > 0 else None + start = ("S" in base) or (base[0] not in "AYQM") + if base.endswith("S") or base.endswith("E"): + base = base[:-1] + mult = offset.n + if base == "W": + mult = 7 * mult + base = "D" + anchor = None + return mult, base, start, anchor + + +# XC : calendar +def compare_offsets(freqA: str, op: str, freqB: str) -> bool: + """Compare offsets string based on their approximate length, according to a given operator. + + Offset are compared based on their length approximated for a period starting + after 1970-01-01 00:00:00. If the offsets are from the same category (same first letter), + only the multiplier prefix is compared (QS-DEC == QS-JAN, MS < 2MS). + "Business" offsets are not implemented. + + Parameters + ---------- + freqA : str + RHS Date offset string ('YS', '1D', 'QS-DEC', ...). + op : {'<', '<=', '==', '>', '>=', '!='} + Operator to use. + freqB : str + LHS Date offset string ('YS', '1D', 'QS-DEC', ...). + + Returns + ------- + bool + Return freqA op freqB. + """ + # Get multiplier and base frequency + t_a, b_a, _, _ = parse_offset(freqA) + t_b, b_b, _, _ = parse_offset(freqB) + + if b_a != b_b: + # Different base freq, compare length of first period after beginning of time. + t = pd.date_range("1970-01-01T00:00:00.000", periods=2, freq=freqA) + t_a = (t[1] - t[0]).total_seconds() + t = pd.date_range("1970-01-01T00:00:00.000", periods=2, freq=freqB) + t_b = (t[1] - t[0]).total_seconds() + # else Same base freq, compare multiplier only. + + return get_op(op)(t_a, t_b) + + +# XC: calendar +def get_calendar(obj: Any, dim: str = "time") -> str: + """Return the calendar of an object. + + Parameters + ---------- + obj : Any + An object defining some date. + If `obj` is an array/dataset with a datetime coordinate, use `dim` to specify its name. + Values must have either a datetime64 dtype or a cftime dtype. + `obj` can also be a python datetime.datetime, a cftime object or a pandas Timestamp + or an iterable of those, in which case the calendar is inferred from the first value. + dim : str + Name of the coordinate to check (if `obj` is a DataArray or Dataset). + + Raises + ------ + ValueError + If no calendar could be inferred. + + Returns + ------- + str + The Climate and Forecasting (CF) calendar name. + Will always return "standard" instead of "gregorian", following CF conventions 1.9. + """ + if isinstance(obj, xr.DataArray | xr.Dataset): + return obj[dim].dt.calendar + if isinstance(obj, xr.CFTimeIndex): + obj = obj.values[0] + else: + obj = np.take(obj, 0) + # Take zeroth element, overcome cases when arrays or lists are passed. + if isinstance(obj, pydt.datetime): # Also covers pandas Timestamp + return "standard" + if isinstance(obj, cftime.datetime): + if obj.calendar == "gregorian": + return "standard" + return obj.calendar + + raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") + + +# XC: calendar +def construct_offset(mult: int, base: str, start_anchored: bool, anchor: str | None): + """Reconstruct an offset string from its parts. + + Parameters + ---------- + mult : int + The period multiplier (>= 1). + base : str + The base period string (one char). + start_anchored : bool + If True and base in [Y, Q, M], adds the "S" flag, False add "E". + anchor : str, optional + The month anchor of the offset. Defaults to JAN for bases YS and QS and to DEC for bases YE and QE. + + Returns + ------- + str + An offset string, conformant to pandas-like naming conventions. + + Notes + ----- + This provides the mirror opposite functionality of :py:func:`parse_offset`. + """ + start = ("S" if start_anchored else "E") if base in "YAQM" else "" + if anchor is None and base in "AQY": + anchor = "JAN" if start_anchored else "DEC" + return ( + f"{mult if mult > 1 else ''}{base}{start}{'-' if anchor else ''}{anchor or ''}" + ) + + +# XC: calendar +# Names of calendars that have the same number of days for all years +uniform_calendars = ("noleap", "all_leap", "365_day", "366_day", "360_day") + + +# XC: calendar +def _month_is_first_period_month(time, freq): + """Return True if the given time is from the first month of freq.""" + if isinstance(time, cftime.datetime): + frq_monthly = xr.coding.cftime_offsets.to_offset("MS") + frq = xr.coding.cftime_offsets.to_offset(freq) + if frq_monthly.onOffset(time): + return frq.onOffset(time) + return frq.onOffset(frq_monthly.rollback(time)) + # Pandas + time = pd.Timestamp(time) + frq_monthly = pd.tseries.frequencies.to_offset("MS") + frq = pd.tseries.frequencies.to_offset(freq) + if frq_monthly.is_on_offset(time): + return frq.is_on_offset(time) + return frq.is_on_offset(frq_monthly.rollback(time)) + + +# XC: calendar +def stack_periods( + da: xr.Dataset | xr.DataArray, + window: int = 30, + stride: int | None = None, + min_length: int | None = None, + freq: str = "YS", + dim: str = "period", + start: str = "1970-01-01", + align_days: bool = True, + pad_value=dtypes.NA, +): + """Construct a multi-period array. + + Stack different equal-length periods of `da` into a new 'period' dimension. + + This is similar to ``da.rolling(time=window).construct(dim, stride=stride)``, but adapted for arguments + in terms of a base temporal frequency that might be non-uniform (years, months, etc.). + It is reversible for some cases (see `stride`). + A rolling-construct method will be much more performant for uniform periods (days, weeks). + + Parameters + ---------- + da : xr.Dataset or xr.DataArray + An xarray object with a `time` dimension. + Must have a uniform timestep length. + Output might be strange if this does not use a uniform calendar (noleap, 360_day, all_leap). + window : int + The length of the moving window as a multiple of ``freq``. + stride : int, optional + At which interval to take the windows, as a multiple of ``freq``. + For the operation to be reversible with :py:func:`unstack_periods`, it must divide `window` into an odd number of parts. + Default is `window` (no overlap between periods). + min_length : int, optional + Windows shorter than this are not included in the output. + Given as a multiple of ``freq``. Default is ``window`` (every window must be complete). + Similar to the ``min_periods`` argument of ``da.rolling``. + If ``freq`` is annual or quarterly and ``min_length == ``window``, the first period is considered complete + if the first timestep is in the first month of the period. + freq : str + Units of ``window``, ``stride`` and ``min_length``, as a frequency string. + Must be larger or equal to the data's sampling frequency. + Note that this function offers an easier interface for non-uniform period (like years or months) + but is much slower than a rolling-construct method. + dim : str + The new dimension name. + start : str + The `start` argument passed to :py:func:`xarray.date_range` to generate the new placeholder + time coordinate. + align_days : bool + When True (default), an error is raised if the output would have unaligned days across periods. + If `freq = 'YS'`, day-of-year alignment is checked and if `freq` is "MS" or "QS", we check day-in-month. + Only uniform-calendar will pass the test for `freq='YS'`. + For other frequencies, only the `360_day` calendar will work. + This check is ignored if the sampling rate of the data is coarser than "D". + pad_value : Any + When some periods are shorter than others, this value is used to pad them at the end. + Passed directly as argument ``fill_value`` to :py:func:`xarray.concat`, + the default is the same as on that function. + + Return + ------ + xr.DataArray + A DataArray with a new `period` dimension and a `time` dimension with the length of the longest window. + The new time coordinate has the same frequency as the input data but is generated using + :py:func:`xarray.date_range` with the given `start` value. + That coordinate is the same for all periods, depending on the choice of ``window`` and ``freq``, it might make sense. + But for unequal periods or non-uniform calendars, it will certainly not. + If ``stride`` is a divisor of ``window``, the correct timeseries can be reconstructed with :py:func:`unstack_periods`. + The coordinate of `period` is the first timestep of each window. + """ + # Import in function to avoid cyclical imports + from xclim.core.units import ( # pylint: disable=import-outside-toplevel + ensure_cf_units, + infer_sampling_units, + ) + + stride = stride or window + min_length = min_length or window + if stride > window: + raise ValueError( + f"Stride must be less than or equal to window. Got {stride} > {window}." + ) + + srcfreq = xr.infer_freq(da.time) + cal = da.time.dt.calendar + use_cftime = da.time.dtype == "O" + + if ( + compare_offsets(srcfreq, "<=", "D") + and align_days + and ( + (freq.startswith(("Y", "A")) and cal not in uniform_calendars) + or (freq.startswith(("Q", "M")) and window > 1 and cal != "360_day") + ) + ): + if freq.startswith(("Y", "A")): + u = "year" + else: + u = "month" + raise ValueError( + f"Stacking {window}{freq} periods will result in unaligned day-of-{u}. " + f"Consider converting the calendar of your data to one with uniform {u} lengths, " + "or pass `align_days=False` to disable this check." + ) + + # Convert integer inputs to freq strings + mult, *args = parse_offset(freq) + win_frq = construct_offset(mult * window, *args) + strd_frq = construct_offset(mult * stride, *args) + minl_frq = construct_offset(mult * min_length, *args) + + # The same time coord as da, but with one extra element. + # This way, the last window's last index is not returned as None by xarray's grouper. + time2 = xr.DataArray( + xr.date_range( + da.time[0].item(), + freq=srcfreq, + calendar=cal, + periods=da.time.size + 1, + use_cftime=use_cftime, + ), + dims=("time",), + name="time", + ) + + periods = [] + # longest = 0 + # Iterate over strides, but recompute the full window for each stride start + for strd_slc in da.resample(time=strd_frq).groups.values(): + win_resamp = time2.isel(time=slice(strd_slc.start, None)).resample(time=win_frq) + # Get slice for first group + win_slc = list(win_resamp.groups.values())[0] + if min_length < window: + # If we ask for a min_length period instead is it complete ? + min_resamp = time2.isel(time=slice(strd_slc.start, None)).resample( + time=minl_frq + ) + min_slc = list(min_resamp.groups.values())[0] + open_ended = min_slc.stop is None + else: + # The end of the group slice is None if no outside-group value was found after the last element + # As we added an extra step to time2, we avoid the case where a group ends exactly on the last element of ds + open_ended = win_slc.stop is None + if open_ended: + # Too short, we got to the end + break + if ( + strd_slc.start == 0 + and parse_offset(freq)[1] in "YAQ" + and min_length == window + and not _month_is_first_period_month(da.time[0].item(), freq) + ): + # For annual or quarterly frequencies (which can be anchor-based), + # if the first time is not in the first month of the first period, + # then the first period is incomplete but by a fractional amount. + continue + periods.append( + slice( + strd_slc.start + win_slc.start, + ( + (strd_slc.start + win_slc.stop) + if win_slc.stop is not None + else da.time.size + ), + ) + ) + + # Make coordinates + lengths = xr.DataArray( + [slc.stop - slc.start for slc in periods], + dims=(dim,), + attrs={"long_name": "Length of each period"}, + ) + longest = lengths.max().item() + # Length as a pint-ready array : with proper units, but values are not usable as indexes anymore + m, u = infer_sampling_units(da) + lengths = lengths * m + lengths.attrs["units"] = ensure_cf_units(u) + # Start points for each period and remember parameters for unstacking + starts = xr.DataArray( + [da.time[slc.start].item() for slc in periods], + dims=(dim,), + attrs={ + "long_name": "Start of the period", + # Save parameters so that we can unstack. + "window": window, + "stride": stride, + "freq": freq, + "unequal_lengths": int(len(np.unique(lengths)) > 1), + }, + ) + # The "fake" axis that all periods share + fake_time = xr.date_range( + start, periods=longest, freq=srcfreq, calendar=cal, use_cftime=use_cftime + ) + # Slice and concat along new dim. We drop the index and add a new one so that xarray can concat them together. + out = xr.concat( + [ + da.isel(time=slc) + .drop_vars("time") + .assign_coords(time=np.arange(slc.stop - slc.start)) + for slc in periods + ], + dim, + join="outer", + fill_value=pad_value, + ) + out = out.assign_coords( + time=(("time",), fake_time, da.time.attrs.copy()), + **{f"{dim}_length": lengths, dim: starts}, + ) + out.time.attrs.update(long_name="Placeholder time axis") + return out + + +# XC: calendar +def unstack_periods(da: xr.DataArray | xr.Dataset, dim: str = "period"): + """Unstack an array constructed with :py:func:`stack_periods`. + + Can only work with periods stacked with a ``stride`` that divides ``window`` in an odd number of sections. + When ``stride`` is smaller than ``window``, only the center-most stride of each window is kept, + except for the beginning and end which are taken from the first and last windows. + + Parameters + ---------- + da : xr.DataArray + As constructed by :py:func:`stack_periods`, attributes of the period coordinates must have been preserved. + dim : str + The period dimension name. + + Notes + ----- + The following table shows which strides are included (``o``) in the unstacked output. + + In this example, ``stride`` was a fifth of ``window`` and ``min_length`` was four (4) times ``stride``. + The row index ``i`` the period index in the stacked dataset, + columns are the stride-long section of the original timeseries. + + .. table:: Unstacking example with ``stride < window``. + + === === === === === === === === + i 0 1 2 3 4 5 6 + === === === === === === === === + 3 x x o o + 2 x x o x x + 1 x x o x x + 0 o o o x x + === === === === === === === === + """ + from xclim.core.units import ( # pylint: disable=import-outside-toplevel + infer_sampling_units, + ) + + try: + starts = da[dim] + window = starts.attrs["window"] + stride = starts.attrs["stride"] + freq = starts.attrs["freq"] + unequal_lengths = bool(starts.attrs["unequal_lengths"]) + except (AttributeError, KeyError) as err: + raise ValueError( + f"`unstack_periods` can't find the window, stride and freq attributes on the {dim} coordinates." + ) from err + + if unequal_lengths: + try: + lengths = da[f"{dim}_length"] + except KeyError as err: + raise ValueError( + f"`unstack_periods` can't find the `{dim}_length` coordinate." + ) from err + # Get length as number of points + m, _ = infer_sampling_units(da.time) + lengths = lengths // m + else: + # It is acceptable to lose "{dim}_length" if they were all equal + lengths = xr.DataArray([da.time.size] * da[dim].size, dims=(dim,)) + + # Convert from the fake axis to the real one + time_as_delta = da.time - da.time[0] + if da.time.dtype == "O": + # cftime can't add with np.timedelta64 (restriction comes from numpy which refuses to add O with m8) + time_as_delta = pd.TimedeltaIndex( + time_as_delta + ).to_pytimedelta() # this array is O, numpy complies + else: + # Xarray will return int when iterating over datetime values, this returns timestamps + starts = pd.DatetimeIndex(starts) + + def _reconstruct_time(_time_as_delta, _start): + times = _time_as_delta + _start + return xr.DataArray(times, dims=("time",), coords={"time": times}, name="time") + + # Easy case: + if window == stride: + # just concat them all + periods = [] + for i, (start, length) in enumerate( + zip(starts.values, lengths.values, strict=False) + ): + real_time = _reconstruct_time(time_as_delta, start) + periods.append( + da.isel(**{dim: i}, drop=True) + .isel(time=slice(0, length)) + .assign_coords(time=real_time.isel(time=slice(0, length))) + ) + return xr.concat(periods, "time") + + # Difficult and ambiguous case + if (window / stride) % 2 != 1: + raise NotImplementedError( + "`unstack_periods` can't work with strides that do not divide the window into an odd number of parts." + f"Got {window} / {stride} which is not an odd integer." + ) + + # Non-ambiguous overlapping case + Nwin = window // stride + mid = (Nwin - 1) // 2 # index of the center window + + mult, *args = parse_offset(freq) + strd_frq = construct_offset(mult * stride, *args) + + periods = [] + for i, (start, length) in enumerate( + zip(starts.values, lengths.values, strict=False) + ): + real_time = _reconstruct_time(time_as_delta, start) + slices = list(real_time.resample(time=strd_frq).groups.values()) + if i == 0: + slc = slice(slices[0].start, min(slices[mid].stop, length)) + elif i == da.period.size - 1: + slc = slice(slices[mid].start, min(slices[Nwin - 1].stop or length, length)) + else: + slc = slice(slices[mid].start, min(slices[mid].stop, length)) + periods.append( + da.isel(**{dim: i}, drop=True) + .isel(time=slc) + .assign_coords(time=real_time.isel(time=slc)) + ) + + return xr.concat(periods, "time") diff --git a/src/xsdba/calendar.py b/src/xsdba/calendar.py deleted file mode 100644 index 4de1470..0000000 --- a/src/xsdba/calendar.py +++ /dev/null @@ -1,1692 +0,0 @@ -"""# noqa: SS01 -Calendar Handling Utilities -=========================== - -Helper function to handle dates, times and different calendars with xarray. -""" - -from __future__ import annotations - -import datetime as pydt -from collections.abc import Sequence -from typing import Any, TypeVar -from warnings import warn - -import cftime -import numpy as np -import pandas as pd -import xarray as xr -from boltons.funcutils import wraps -from xarray.coding.cftime_offsets import to_cftime_datetime -from xarray.coding.cftimeindex import CFTimeIndex -from xarray.core import dtypes -from xarray.core.resample import DataArrayResample, DatasetResample - -from .base import uses_dask -from .formatting import update_xsdba_history -from .typing import DayOfYearStr - -__all__ = [ - "DayOfYearStr", - "adjust_doy_calendar", - "build_climatology_bounds", - "climatological_mean_doy", - "common_calendar", - "compare_offsets", - "construct_offset", - "convert_calendar", - "convert_doy", - "date_range", - "date_range_like", - "datetime_to_decimal_year", - "days_in_year", - "days_since_to_doy", - "doy_from_string", - "doy_to_days_since", - "ensure_cftime_array", - "ensure_longest_doy", - "get_calendar", - "interp_calendar", - "is_offset_divisor", - "max_doy", - "parse_offset", - "percentile_doy", - "resample_doy", - "select_time", - "stack_periods", - "time_bnds", - "uniform_calendars", - "unstack_periods", - "within_bnds_doy", -] - -# Maximum day of year in each calendar. -max_doy = { - "standard": 366, - "gregorian": 366, - "proleptic_gregorian": 366, - "julian": 366, - "noleap": 365, - "365_day": 365, - "all_leap": 366, - "366_day": 366, - "360_day": 360, -} - -datetime_classes = cftime._cftime.DATE_TYPES - -# Names of calendars that have the same number of days for all years -uniform_calendars = ("noleap", "all_leap", "365_day", "366_day", "360_day") - - -DataType = TypeVar("DataType", xr.DataArray, xr.Dataset) - - -def _get_usecf_and_warn(calendar: str, xcfunc: str, xrfunc: str): - if calendar == "default": - calendar = "standard" - use_cftime = False - msg = " and use use_cftime=False instead of calendar='default' to get numpy objects." - else: - use_cftime = None - msg = "" - warn( - f"`xsdba` function {xcfunc} is deprecated in favour of {xrfunc} and will be removed in v0.51.0. Please adjust your script{msg}.", - FutureWarning, - ) - return calendar, use_cftime - - -def days_in_year(year: int, calendar: str = "proleptic_gregorian") -> int: - """Deprecated : use :py:func:`xarray.coding.calendar_ops._days_in_year` instead. Passing use_cftime=False instead of calendar='default'. - - Return the number of days in the input year according to the input calendar. - """ - calendar, usecf = _get_usecf_and_warn( - calendar, "days_in_year", "xarray.coding.calendar_ops._days_in_year" - ) - return xr.coding.calendar_ops._days_in_year(year, calendar, use_cftime=usecf) - - -def doy_from_string(doy: DayOfYearStr, year: int, calendar: str) -> int: - """Return the day-of-year corresponding to a "MM-DD" string for a given year and calendar.""" - MM, DD = doy.split("-") - return datetime_classes[calendar](year, int(MM), int(DD)).timetuple().tm_yday - - -def date_range(*args, **kwargs) -> pd.DatetimeIndex | CFTimeIndex: - """Deprecated : use :py:func:`xarray.date_range` instead. Passing use_cftime=False instead of calendar='default'. - - Wrap a Pandas date_range object. - - Uses pd.date_range (if calendar == 'default') or xr.cftime_range (otherwise). - """ - calendar, usecf = _get_usecf_and_warn( - kwargs.pop("calendar", "default"), "date_range", "xarray.date_range" - ) - return xr.date_range(*args, calendar=calendar, use_cftime=usecf, **kwargs) - - -def get_calendar(obj: Any, dim: str = "time") -> str: - """Return the calendar of an object. - - Parameters - ---------- - obj : Any - An object defining some date. - If `obj` is an array/dataset with a datetime coordinate, use `dim` to specify its name. - Values must have either a datetime64 dtype or a cftime dtype. - `obj` can also be a python datetime.datetime, a cftime object or a pandas Timestamp - or an iterable of those, in which case the calendar is inferred from the first value. - dim : str - Name of the coordinate to check (if `obj` is a DataArray or Dataset). - - Raises - ------ - ValueError - If no calendar could be inferred. - - Returns - ------- - str - The Climate and Forecasting (CF) calendar name. - Will always return "standard" instead of "gregorian", following CF conventions 1.9. - """ - if isinstance(obj, (xr.DataArray | xr.Dataset)): - return obj[dim].dt.calendar - elif isinstance(obj, xr.CFTimeIndex): - obj = obj.values[0] - else: - obj = np.take(obj, 0) - # Take zeroth element, overcome cases when arrays or lists are passed. - if isinstance(obj, pydt.datetime): # Also covers pandas Timestamp - return "standard" - if isinstance(obj, cftime.datetime): - if obj.calendar == "gregorian": - return "standard" - return obj.calendar - - raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") - - -def common_calendar(calendars: Sequence[str], join="outer") -> str: - """Return a calendar common to all calendars from a list. - - Uses the hierarchy: 360_day < noleap < standard < all_leap. - Returns "default" only if all calendars are "default." - - Parameters - ---------- - calendars: Sequence of string - List of calendar names. - join : {'inner', 'outer'} - The criterion for the common calendar. - - - 'outer': the common calendar is the smallest calendar (in number of days by year) that will include all the - dates of the other calendars. - When converting the data to this calendar, no timeseries will lose elements, but some - might be missing (gaps or NaNs in the series). - - 'inner': the common calendar is the smallest calendar of the list. - When converting the data to this calendar, no timeseries will have missing elements (no gaps or NaNs), - but some might be dropped. - - Examples - -------- - >>> common_calendar(["360_day", "noleap", "default"], join="outer") - 'standard' - >>> common_calendar(["360_day", "noleap", "default"], join="inner") - '360_day' - """ - if all(cal == "default" for cal in calendars): - return "default" - - trans = { - "proleptic_gregorian": "standard", - "gregorian": "standard", - "default": "standard", - "366_day": "all_leap", - "365_day": "noleap", - "julian": "standard", - } - ranks = {"360_day": 0, "noleap": 1, "standard": 2, "all_leap": 3} - calendars = sorted([trans.get(cal, cal) for cal in calendars], key=ranks.get) - - if join == "outer": - return calendars[-1] - if join == "inner": - return calendars[0] - raise NotImplementedError(f"Unknown join criterion `{join}`.") - - -def _convert_doy_date(doy: int, year: int, src, tgt): - fracpart = doy - int(doy) - date = src(year, 1, 1) + pydt.timedelta(days=int(doy - 1)) - try: - same_date = tgt(date.year, date.month, date.day) - except ValueError: - return np.nan - else: - if tgt is pydt.datetime: - return float(same_date.timetuple().tm_yday) + fracpart - return float(same_date.dayofyr) + fracpart - - -def convert_doy( - source: xr.DataArray | xr.Dataset, - target_cal: str, - source_cal: str | None = None, - align_on: str = "year", - missing: Any = np.nan, - dim: str = "time", -) -> xr.DataArray: - """Convert the calendar of day of year (doy) data. - - Parameters - ---------- - source : xr.DataArray or xr.Dataset - Day of year data (range [1, 366], max depending on the calendar). - If a Dataset, the function is mapped to each variables with attribute `is_day_of_year == 1`. - target_cal : str - Name of the calendar to convert to. - source_cal : str, optional - Calendar the doys are in. If not given, uses the "calendar" attribute of `source` or, - if absent, the calendar of its `dim` axis. - align_on : {'date', 'year'} - If 'year' (default), the doy is seen as a "percentage" of the year and is simply rescaled unto the new doy range. - This always result in floating point data, changing the decimal part of the value. - if 'date', the doy is seen as a specific date. See notes. This never changes the decimal part of the value. - missing : Any - If `align_on` is "date" and the new doy doesn't exist in the new calendar, this value is used. - dim : str - Name of the temporal dimension. - """ - if isinstance(source, xr.Dataset): - return source.map( - lambda da: ( - da - if da.attrs.get("is_dayofyear") != 1 - else convert_doy( - da, - target_cal, - source_cal=source_cal, - align_on=align_on, - missing=missing, - dim=dim, - ) - ) - ) - - source_cal = source_cal or source.attrs.get("calendar", get_calendar(source[dim])) - is_calyear = xr.infer_freq(source[dim]) in ("YS-JAN", "Y-DEC", "YE-DEC") - - if is_calyear: # Fast path - year_of_the_doy = source[dim].dt.year - else: # Doy might refer to a date from the year after the timestamp. - year_of_the_doy = source[dim].dt.year + 1 * (source < source[dim].dt.dayofyear) - - if align_on == "year": - if source_cal in ["noleap", "all_leap", "360_day"]: - max_doy_src = max_doy[source_cal] - else: - max_doy_src = xr.apply_ufunc( - xr.coding.calendar_ops._days_in_year, - year_of_the_doy, - vectorize=True, - dask="parallelized", - kwargs={"calendar": source_cal}, - ) - if target_cal in ["noleap", "all_leap", "360_day"]: - max_doy_tgt = max_doy[target_cal] - else: - max_doy_tgt = xr.apply_ufunc( - xr.coding.calendar_ops._days_in_year, - year_of_the_doy, - vectorize=True, - dask="parallelized", - kwargs={"calendar": target_cal}, - ) - new_doy = source.copy(data=source * max_doy_tgt / max_doy_src) - elif align_on == "date": - new_doy = xr.apply_ufunc( - _convert_doy_date, - source, - year_of_the_doy, - vectorize=True, - dask="parallelized", - kwargs={ - "src": datetime_classes[source_cal], - "tgt": datetime_classes[target_cal], - }, - ) - else: - raise NotImplementedError('"align_on" must be one of "date" or "year".') - return new_doy.assign_attrs(is_dayofyear=np.int32(1), calendar=target_cal) - - -def convert_calendar( - source: xr.DataArray | xr.Dataset, - target: str, - align_on: str | None = None, - missing: Any | None = None, - dim: str = "time", -) -> DataType: - """Deprecated : use :py:meth:`xarray.Dataset.convert_calendar` or :py:meth:`xarray.DataArray.convert_calendar` - or :py:func:`xarray.coding.calendar_ops.convert_calendar` instead. Passing use_cftime=False instead of calendar='default'. - - Convert a DataArray/Dataset to another calendar using the specified method. - """ - target, _usecf = _get_usecf_and_warn( - target, - "convert_calendar", - "xarray.coding.calendar_ops.convert_calendar or obj.convert_calendar", - ) - return xr.coding.calendar_ops.convert_calendar( - source, target, dim=dim, align_on=align_on, missing=missing - ) - - -# TODO: Let's not keep this very contextual error message, but maybe put the suggestion in a tutorial somewhere -# if doy is not False: -# raise NotImplementedError( -# "In `xsdba` v0.50.0, `convert_calendar` is a direct copy of `xarray.coding.calendar_ops.convert_calendar`. " -# "To retrieve the previous behaviour of doy=True, do convert_doy(obj, target_cal).convert_cal(target_cal)." -# ) - - -def interp_calendar( - source: xr.DataArray | xr.Dataset, - target: xr.DataArray, - dim: str = "time", -) -> xr.DataArray | xr.Dataset: - """Deprecated : use :py:func:`xarray.coding.calendar_ops.interp_calendar` instead. - - Interpolates a DataArray/Dataset to another calendar based on decimal year measure. - """ - _, _ = _get_usecf_and_warn( - "standard", "interp_calendar", "xarray.coding.calendar_ops.interp_calendar" - ) - return xr.coding.calendar_ops.interp_calendar(source, target, dim=dim) - - -def ensure_cftime_array(time: Sequence) -> np.ndarray | Sequence[cftime.datetime]: - """Convert an input 1D array to a numpy array of cftime objects. - - Python's datetime are converted to cftime.DatetimeGregorian ("standard" calendar). - - Parameters - ---------- - time : sequence - A 1D array of datetime-like objects. - - Returns - ------- - np.ndarray - - Raises - ------ - ValueError: When unable to cast the input. - """ - if isinstance(time, xr.DataArray): - time = time.indexes["time"] - elif isinstance(time, np.ndarray): - time = pd.DatetimeIndex(time) - if isinstance(time, xr.CFTimeIndex): - return time.values - if isinstance(time[0], cftime.datetime): - return time - if isinstance(time[0], pydt.datetime): - return np.array( - [cftime.DatetimeGregorian(*ele.timetuple()[:6]) for ele in time] - ) - raise ValueError("Unable to cast array to cftime dtype") - - -def datetime_to_decimal_year(times: xr.DataArray, calendar: str = "") -> xr.DataArray: - """Deprecated : use :py:func:`xarray.coding.calendar_ops_datetime_to_decimal_year` instead. - - Convert a datetime xr.DataArray to decimal years according to its calendar or the given one. - """ - _, _ = _get_usecf_and_warn( - "standard", - "datetime_to_decimal_year", - "xarray.coding.calendar_ops._datetime_to_decimal_year", - ) - return xr.coding.calendar_ops._datetime_to_decimal_year( - times, dim="time", calendar=calendar - ) - - -@update_xsdba_history -def percentile_doy( - arr: xr.DataArray, - window: int = 5, - per: float | Sequence[float] = 10.0, - alpha: float = 1.0 / 3.0, - beta: float = 1.0 / 3.0, - copy: bool = True, -) -> xr.DataArray: - """Percentile value for each day of the year. - - Return the climatological percentile over a moving window around each day of the year. Different quantile estimators - can be used by specifying `alpha` and `beta` according to specifications given by :cite:t:`hyndman_sample_1996`. - The default definition corresponds to method 8, which meets multiple desirable statistical properties for sample - quantiles. Note that `numpy.percentile` corresponds to method 7, with alpha and beta set to 1. - - Parameters - ---------- - arr : xr.DataArray - Input data, a daily frequency (or coarser) is required. - window : int - Number of time-steps around each day of the year to include in the calculation. - per : float or sequence of floats - Percentile(s) between [0, 100]. - alpha : float - Plotting position parameter. - beta : float - Plotting position parameter. - copy : bool - If True (default) the input array will be deep-copied. It's a necessary step - to keep the data integrity, but it can be costly. - If False, no copy is made of the input array. It will be mutated and rendered - unusable but performances may significantly improve. - Put this flag to False only if you understand the consequences. - - Returns - ------- - xr.DataArray - The percentiles indexed by the day of the year. - For calendars with 366 days, percentiles of doys 1-365 are interpolated to the 1-366 range. - - References - ---------- - :cite:cts:`hyndman_sample_1996` - """ - from .utils import calc_perc # pylint: disable=import-outside-toplevel - - # Ensure arr sampling frequency is daily or coarser - # but cowardly escape the non-inferrable case. - if compare_offsets(xr.infer_freq(arr.time) or "D", "<", "D"): - raise ValueError("input data should have daily or coarser frequency") - - rr = arr.rolling(min_periods=1, center=True, time=window).construct("window") - - crd = xr.Coordinates.from_pandas_multiindex( - pd.MultiIndex.from_arrays( - (rr.time.dt.year.values, rr.time.dt.dayofyear.values), - names=("year", "dayofyear"), - ), - "time", - ) - rr = rr.drop_vars("time").assign_coords(crd) - rrr = rr.unstack("time").stack(stack_dim=("year", "window")) - - if rrr.chunks is not None and len(rrr.chunks[rrr.get_axis_num("stack_dim")]) > 1: - # Preserve chunk size - time_chunks_count = len(arr.chunks[arr.get_axis_num("time")]) - doy_chunk_size = np.ceil(len(rrr.dayofyear) / (window * time_chunks_count)) - rrr = rrr.chunk(dict(stack_dim=-1, dayofyear=doy_chunk_size)) - - if np.isscalar(per): - per = [per] - - p = xr.apply_ufunc( - calc_perc, - rrr, - input_core_dims=[["stack_dim"]], - output_core_dims=[["percentiles"]], - keep_attrs=True, - kwargs=dict(percentiles=per, alpha=alpha, beta=beta, copy=copy), - dask="parallelized", - output_dtypes=[rrr.dtype], - dask_gufunc_kwargs=dict(output_sizes={"percentiles": len(per)}), - ) - p = p.assign_coords(percentiles=xr.DataArray(per, dims=("percentiles",))) - - # The percentile for the 366th day has a sample size of 1/4 of the other days. - # To have the same sample size, we interpolate the percentile from 1-365 doy range to 1-366 - if p.dayofyear.max() == 366: - p = adjust_doy_calendar(p.sel(dayofyear=(p.dayofyear < 366)), arr) - - p.attrs.update(arr.attrs.copy()) - - # Saving percentile attributes - p.attrs["climatology_bounds"] = build_climatology_bounds(arr) - p.attrs["window"] = window - p.attrs["alpha"] = alpha - p.attrs["beta"] = beta - return p.rename("per") - - -def build_climatology_bounds(da: xr.DataArray) -> list[str]: - """Build the climatology_bounds property with the start and end dates of input data. - - Parameters - ---------- - da : xr.DataArray - The input data. - Must have a time dimension. - """ - n = len(da.time) - return da.time[0 :: n - 1].dt.strftime("%Y-%m-%d").values.tolist() - - -def compare_offsets(freqA: str, op: str, freqB: str) -> bool: - """Compare offsets string based on their approximate length, according to a given operator. - - Offset are compared based on their length approximated for a period starting - after 1970-01-01 00:00:00. If the offsets are from the same category (same first letter), - only the multiplier prefix is compared (QS-DEC == QS-JAN, MS < 2MS). - "Business" offsets are not implemented. - - Parameters - ---------- - freqA : str - RHS Date offset string ('YS', '1D', 'QS-DEC', ...). - op : {'<', '<=', '==', '>', '>=', '!='} - Operator to use. - freqB : str - LHS Date offset string ('YS', '1D', 'QS-DEC', ...). - - Returns - ------- - bool - Either freqA op freqB. - """ - from .xclim_submodules.generic import ( # pylint: disable=import-outside-toplevel - get_op, - ) - - # Get multiplier and base frequency - t_a, b_a, _, _ = parse_offset(freqA) - t_b, b_b, _, _ = parse_offset(freqB) - - if b_a != b_b: - # Different base freq, compare length of first period after beginning of time. - t = pd.date_range("1970-01-01T00:00:00.000", periods=2, freq=freqA) - t_a = (t[1] - t[0]).total_seconds() - t = pd.date_range("1970-01-01T00:00:00.000", periods=2, freq=freqB) - t_b = (t[1] - t[0]).total_seconds() - # else Same base freq, compare multiplier only. - - return get_op(op)(t_a, t_b) - - -def parse_offset(freq: str) -> tuple[int, str, bool, str | None]: - """Parse an offset string. - - Parse a frequency offset and, if needed, convert to cftime-compatible components. - - Parameters - ---------- - freq : str - Frequency offset. - - Returns - ------- - multiplier : int - Multiplier of the base frequency. - "[n]W" is always replaced with "[7n]D", as xarray doesn't support "W" for cftime indexes. - offset_base : str - Base frequency. - is_start_anchored : bool - Whether coordinates of this frequency should correspond to the beginning of the period (`True`) or its end (`False`). - Can only be False when base is Y, Q or M; in other words, xsdba assumes frequencies finer than monthly are all start-anchored. - anchor : str, optional - Anchor date for bases Y or Q. As xarray doesn't support "W", neither does xsdba (anchor information is lost when given). - """ - # Useful to raise on invalid freqs, convert Y to A and get default anchor (A, Q) - offset = pd.tseries.frequencies.to_offset(freq) - base, *anchor = offset.name.split("-") - anchor = anchor[0] if len(anchor) > 0 else None - start = ("S" in base) or (base[0] not in "AYQM") - if base.endswith("S") or base.endswith("E"): - base = base[:-1] - mult = offset.n - if base == "W": - mult = 7 * mult - base = "D" - anchor = None - return mult, base, start, anchor - - -def construct_offset(mult: int, base: str, start_anchored: bool, anchor: str | None): - """Reconstruct an offset string from its parts. - - Parameters - ---------- - mult : int - The period multiplier (>= 1). - base : str - The base period string (one char). - start_anchored : bool - If True and base in [Y, Q, M], adds the "S" flag, False add "E". - anchor : str, optional - The month anchor of the offset. Defaults to JAN for bases YS and QS and to DEC for bases YE and QE. - - Returns - ------- - str - An offset string, conformant to pandas-like naming conventions. - - Notes - ----- - This provides the mirror opposite functionality of :py:func:`parse_offset`. - """ - start = ("S" if start_anchored else "E") if base in "YAQM" else "" - if anchor is None and base in "AQY": - anchor = "JAN" if start_anchored else "DEC" - return ( - f"{mult if mult > 1 else ''}{base}{start}{'-' if anchor else ''}{anchor or ''}" - ) - - -def is_offset_divisor(divisor: str, offset: str): - """Check that divisor is a divisor of offset. - - A frequency is a "divisor" of another if a whole number of periods of the - former fit within a single period of the latter. - - Parameters - ---------- - divisor : str - The divisor frequency. - offset: str - The large frequency. - - Returns - ------- - bool - - Examples - -------- - >>> is_offset_divisor("QS-Jan", "YS") - True - >>> is_offset_divisor("QS-DEC", "YS-JUL") - False - >>> is_offset_divisor("D", "M") - True - """ - if compare_offsets(divisor, ">", offset): - return False - # Reconstruct offsets anchored at the start of the period - # to have comparable quantities, also get "offset" objects - mA, bA, _sA, aA = parse_offset(divisor) - offAs = pd.tseries.frequencies.to_offset(construct_offset(mA, bA, True, aA)) - - mB, bB, _sB, aB = parse_offset(offset) - offBs = pd.tseries.frequencies.to_offset(construct_offset(mB, bB, True, aB)) - tB = pd.date_range("1970-01-01T00:00:00", freq=offBs, periods=13) - - if bA in ["W", "D", "h", "min", "s", "ms", "us", "ms"] or bB in [ - "W", - "D", - "h", - "min", - "s", - "ms", - "us", - "ms", - ]: - # Simple length comparison is sufficient for submonthly freqs - # In case one of bA or bB is > W, we test many to be sure. - tA = pd.date_range("1970-01-01T00:00:00", freq=offAs, periods=13) - return np.all( - (np.diff(tB)[:, np.newaxis] / np.diff(tA)[np.newaxis, :]) % 1 == 0 - ) - - # else, we test alignment with some real dates - # If both fall on offAs, then is means divisor is aligned with offset at those dates - # if N=13 is True, then it is always True - # As divisor <= offset, this means divisor is a "divisor" of offset. - return all(offAs.is_on_offset(d) for d in tB) - - -def ensure_longest_doy(func: Callable) -> Callable: - """Ensure that selected day is the longest day of year for x and y dims.""" - - @wraps(func) - def _ensure_longest_doy(x, y, *args, **kwargs): - if ( - hasattr(x, "dims") - and hasattr(y, "dims") - and "dayofyear" in x.dims - and "dayofyear" in y.dims - and x.dayofyear.max() != y.dayofyear.max() - ): - warn( - ( - "get_correction received inputs defined on different dayofyear ranges. " - "Interpolating to the longest range. Results could be strange." - ), - stacklevel=4, - ) - if x.dayofyear.max() < y.dayofyear.max(): - x = _interpolate_doy_calendar( - x, int(y.dayofyear.max()), int(y.dayofyear.min()) - ) - else: - y = _interpolate_doy_calendar( - y, int(x.dayofyear.max()), int(x.dayofyear.min()) - ) - return func(x, y, *args, **kwargs) - - return _ensure_longest_doy - - -def _interpolate_doy_calendar( - source: xr.DataArray, doy_max: int, doy_min: int = 1 -) -> xr.DataArray: - """Interpolate from one set of dayofyear range to another. - - Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 - to 365). - - Parameters - ---------- - source : xr.DataArray - Array with `dayofyear` coordinates. - doy_max : int - The largest day of the year allowed by calendar. - doy_min : int - The smallest day of the year in the output. - This parameter is necessary when the target time series does not span over a full year (e.g. JJA season). - Default is 1. - - Returns - ------- - xr.DataArray - Interpolated source array over coordinates spanning the target `dayofyear` range. - """ - if "dayofyear" not in source.coords.keys(): - raise AttributeError("Source should have `dayofyear` coordinates.") - - # Interpolate to fill na values - da = source - if uses_dask(source): - # interpolate_na cannot run on chunked dayofyear. - da = source.chunk(dict(dayofyear=-1)) - filled_na = da.interpolate_na(dim="dayofyear") - - # Interpolate to target dayofyear range - filled_na.coords["dayofyear"] = np.linspace( - start=doy_min, stop=doy_max, num=len(filled_na.coords["dayofyear"]) - ) - - return filled_na.interp(dayofyear=range(doy_min, doy_max + 1)) - - -def adjust_doy_calendar( - source: xr.DataArray, target: xr.DataArray | xr.Dataset -) -> xr.DataArray: - """Interpolate from one set of dayofyear range to another calendar. - - Interpolate an array defined over a `dayofyear` range (say 1 to 360) to another `dayofyear` range (say 1 to 365). - - Parameters - ---------- - source : xr.DataArray - Array with `dayofyear` coordinate. - target : xr.DataArray or xr.Dataset - Array with `time` coordinate. - - Returns - ------- - xr.DataArray - Interpolated source array over coordinates spanning the target `dayofyear` range. - """ - max_target_doy = int(target.time.dt.dayofyear.max()) - min_target_doy = int(target.time.dt.dayofyear.min()) - - def has_same_calendar(): - # case of full year (doys between 1 and 360|365|366) - return source.dayofyear.max() == max_doy[get_calendar(target)] - - def has_similar_doys(): - # case of partial year (e.g. JJA, doys between 152|153 and 243|244) - return ( - source.dayofyear.min == min_target_doy - and source.dayofyear.max == max_target_doy - ) - - if has_same_calendar() or has_similar_doys(): - return source - return _interpolate_doy_calendar(source, max_target_doy, min_target_doy) - - -def resample_doy(doy: xr.DataArray, arr: xr.DataArray | xr.Dataset) -> xr.DataArray: - """Create a temporal DataArray where each day takes the value defined by the day-of-year. - - Parameters - ---------- - doy : xr.DataArray - Array with `dayofyear` coordinate. - arr : xr.DataArray or xr.Dataset - Array with `time` coordinate. - - Returns - ------- - xr.DataArray - An array with the same dimensions as `doy`, except for `dayofyear`, which is - replaced by the `time` dimension of `arr`. Values are filled according to the - day of year value in `doy`. - """ - if "dayofyear" not in doy.coords: - raise AttributeError("Source should have `dayofyear` coordinates.") - - # Adjust calendar - adoy = adjust_doy_calendar(doy, arr) - - out = adoy.rename(dayofyear="time").reindex(time=arr.time.dt.dayofyear) - out["time"] = arr.time - - return out - - -def time_bnds( # noqa: C901 - time: ( - xr.DataArray - | xr.Dataset - | CFTimeIndex - | pd.DatetimeIndex - | DataArrayResample - | DatasetResample - ), - freq: str | None = None, - precision: str | None = None, -): - """Find the time bounds for a datetime index. - - As we are using datetime indices to stand in for period indices, assumptions regarding the period - are made based on the given freq. - - Parameters - ---------- - time : DataArray, Dataset, CFTimeIndex, DatetimeIndex, DataArrayResample or DatasetResample - Object which contains a time index as a proxy representation for a period index. - freq : str, optional - String specifying the frequency/offset such as 'MS', '2D', or '3min' - If not given, it is inferred from the time index, which means that index must - have at least three elements. - precision : str, optional - A timedelta representation that :py:class:`pandas.Timedelta` understands. - The time bounds will be correct up to that precision. If not given, - 1 ms ("1U") is used for CFtime indexes and 1 ns ("1N") for numpy datetime64 indexes. - - Returns - ------- - DataArray - The time bounds: start and end times of the periods inferred from the time index and a frequency. - It has the original time index along it's `time` coordinate and a new `bnds` coordinate. - The dtype and calendar of the array are the same as the index. - - Notes - ----- - xsdba assumes that indexes for greater-than-day frequencies are "floored" down to a daily resolution. - For example, the coordinate "2000-01-31 00:00:00" with a "ME" frequency is assumed to mean a period - going from "2000-01-01 00:00:00" to "2000-01-31 23:59:59.999999". - - Similarly, it assumes that daily and finer frequencies yield indexes pointing to the period's start. - So "2000-01-31 00:00:00" with a "3h" frequency, means a period going from "2000-01-31 00:00:00" to - "2000-01-31 02:59:59.999999". - """ - if isinstance(time, (xr.DataArray | xr.Dataset)): - time = time.indexes[time.name] - elif isinstance(time, (DataArrayResample | DatasetResample)): - for grouper in time.groupers: - if "time" in grouper.dims: - datetime = grouper.unique_coord.data - freq = freq or grouper.grouper.freq - if datetime.dtype == "O": - time = xr.CFTimeIndex(datetime) - else: - time = pd.DatetimeIndex(datetime) - break - - else: - raise ValueError( - 'Got object resampled along another dimension than "time".' - ) - - if freq is None and hasattr(time, "freq"): - freq = time.freq - if freq is None: - freq = xr.infer_freq(time) - elif hasattr(freq, "freqstr"): - # When freq is a Offset - freq = freq.freqstr - - freq_base, freq_is_start = parse_offset(freq)[1:3] - - # Normalizing without using `.normalize` because cftime doesn't have it - floor = {"hour": 0, "minute": 0, "second": 0, "microsecond": 0, "nanosecond": 0} - if freq_base in ["h", "min", "s", "ms", "us", "ns"]: - floor.pop("hour") - if freq_base in ["min", "s", "ms", "us", "ns"]: - floor.pop("minute") - if freq_base in ["s", "ms", "us", "ns"]: - floor.pop("second") - if freq_base in ["us", "ns"]: - floor.pop("microsecond") - if freq_base == "ns": - floor.pop("nanosecond") - - if isinstance(time, xr.CFTimeIndex): - period = xr.coding.cftime_offsets.to_offset(freq) - is_on_offset = period.onOffset - eps = pd.Timedelta(precision or "1us").to_pytimedelta() - day = pd.Timedelta("1D").to_pytimedelta() - floor.pop("nanosecond") # unsupported by cftime - else: - period = pd.tseries.frequencies.to_offset(freq) - is_on_offset = period.is_on_offset - eps = pd.Timedelta(precision or "1ns") - day = pd.Timedelta("1D") - - def shift_time(t): - if not is_on_offset(t): - if freq_is_start: - t = period.rollback(t) - else: - t = period.rollforward(t) - return t.replace(**floor) - - time_real = list(map(shift_time, time)) - - cls = time.__class__ - if freq_is_start: - tbnds = [cls(time_real), cls([t + period - eps for t in time_real])] - else: - tbnds = [ - cls([t - period + day for t in time_real]), - cls([t + day - eps for t in time_real]), - ] - return xr.DataArray( - tbnds, dims=("bnds", "time"), coords={"time": time}, name="time_bnds" - ).transpose() - - -def climatological_mean_doy( - arr: xr.DataArray, window: int = 5 -) -> tuple[xr.DataArray, xr.DataArray]: - """Calculate the climatological mean and standard deviation for each day of the year. - - Parameters - ---------- - arr : xarray.DataArray - Input array. - window : int - Window size in days. - - Returns - ------- - xarray.DataArray, xarray.DataArray - Mean and standard deviation. - """ - rr = arr.rolling(min_periods=1, center=True, time=window).construct("window") - - # Create empty percentile array - g = rr.groupby("time.dayofyear") - - m = g.mean(["time", "window"]) - s = g.std(["time", "window"]) - - return m, s - - -def within_bnds_doy( - arr: xr.DataArray, *, low: xr.DataArray, high: xr.DataArray -) -> xr.DataArray: - """Return whether array values are within bounds for each day of the year. - - Parameters - ---------- - arr : xarray.DataArray - Input array. - low : xarray.DataArray - Low bound with dayofyear coordinate. - high : xarray.DataArray - High bound with dayofyear coordinate. - - Returns - ------- - xarray.DataArray - """ - low = resample_doy(low, arr) - high = resample_doy(high, arr) - return (low < arr) * (arr < high) - - -def _doy_days_since_doys( - base: xr.DataArray, start: DayOfYearStr | None = None -) -> tuple[xr.DataArray, xr.DataArray, xr.DataArray]: - """Calculate dayofyear to days since, or the inverse. - - Parameters - ---------- - base : xr.DataArray - 1D time coordinate. - start : DayOfYearStr, optional - A date to compute the offset relative to. If note given, start_doy is the same as base_doy. - - Returns - ------- - base_doy : xr.DataArray - Day of year for each element in base. - start_doy : xr.DataArray - Day of year of the "start" date. - The year used is the one the start date would take as a doy for the corresponding base element. - doy_max : xr.DataArray - Number of days (maximum doy) for the year of each value in base. - """ - calendar = get_calendar(base) - - base_doy = base.dt.dayofyear - - doy_max = xr.apply_ufunc( - xr.coding.calendar_ops._days_in_year, - base.dt.year, - vectorize=True, - kwargs={"calendar": calendar}, - ) - - if start is not None: - mm, dd = map(int, start.split("-")) - starts = xr.apply_ufunc( - lambda y: datetime_classes[calendar](y, mm, dd), - base.dt.year, - vectorize=True, - ) - start_doy = starts.dt.dayofyear - start_doy = start_doy.where(start_doy >= base_doy, start_doy + doy_max) - else: - start_doy = base_doy - - return base_doy, start_doy, doy_max - - -def doy_to_days_since( - da: xr.DataArray, - start: DayOfYearStr | None = None, - calendar: str | None = None, -) -> xr.DataArray: - """Convert day-of-year data to days since a given date. - - This is useful for computing meaningful statistics on doy data. - - Parameters - ---------- - da : xr.DataArray - Array of "day-of-year", usually int dtype, must have a `time` dimension. - Sampling frequency should be finer or similar to yearly and coarser than daily. - start : date of year str, optional - A date in "MM-DD" format, the base day of the new array. If None (default), the `time` axis is used. - Passing `start` only makes sense if `da` has a yearly sampling frequency. - calendar : str, optional - The calendar to use when computing the new interval. - If None (default), the calendar attribute of the data or of its `time` axis is used. - All time coordinates of `da` must exist in this calendar. - No check is done to ensure doy values exist in this calendar. - - Returns - ------- - xr.DataArray - Same shape as `da`, int dtype, day-of-year data translated to a number of days since a given date. - If start is not None, there might be negative values. - - Notes - ----- - The time coordinates of `da` are considered as the START of the period. For example, a doy value of - 350 with a timestamp of '2020-12-31' is understood as '2021-12-16' (the 350th day of 2021). - Passing `start=None`, will use the time coordinate as the base, so in this case the converted value - will be 350 "days since time coordinate". - - Examples - -------- - >>> from xarray import DataArray - >>> time = date_range("2020-07-01", "2021-07-01", freq="AS-JUL") - >>> # July 8th 2020 and Jan 2nd 2022 - >>> da = DataArray([190, 2], dims=("time",), coords={"time": time}) - >>> # Convert to days since Oct. 2nd, of the data's year. - >>> doy_to_days_since(da, start="10-02").values - array([-86, 92]) - """ - base_calendar = get_calendar(da) - calendar = calendar or da.attrs.get("calendar", base_calendar) - dac = da.convert_calendar(calendar) - - base_doy, start_doy, doy_max = _doy_days_since_doys(dac.time, start) - - # 2cases: - # val is a day in the same year as its index : da - offset - # val is a day in the next year : da + doy_max - offset - out = xr.where(dac > base_doy, dac, dac + doy_max) - start_doy - out.attrs.update(da.attrs) - if start is not None: - out.attrs.update(units=f"days after {start}") - else: - starts = np.unique(out.time.dt.strftime("%m-%d")) - if len(starts) == 1: - out.attrs.update(units=f"days after {starts[0]}") - else: - out.attrs.update(units="days after time coordinate") - - out.attrs.pop("is_dayofyear", None) - out.attrs.update(calendar=calendar) - return out.convert_calendar(base_calendar).rename(da.name) - - -def days_since_to_doy( - da: xr.DataArray, - start: DayOfYearStr | None = None, - calendar: str | None = None, -) -> xr.DataArray: - """Reverse the conversion made by :py:func:`doy_to_days_since`. - - Converts data given in days since a specific date to day-of-year. - - Parameters - ---------- - da : xr.DataArray - The result of :py:func:`doy_to_days_since`. - start : DateOfYearStr, optional - `da` is considered as days since that start date (in the year of the time index). - If None (default), it is read from the attributes. - calendar : str, optional - Calendar the "days since" were computed in. - If None (default), it is read from the attributes. - - Returns - ------- - xr.DataArray - Same shape as `da`, values as `day of year`. - - Examples - -------- - >>> from xarray import DataArray - >>> time = date_range("2020-07-01", "2021-07-01", freq="AS-JUL") - >>> da = DataArray( - ... [-86, 92], - ... dims=("time",), - ... coords={"time": time}, - ... attrs={"units": "days since 10-02"}, - ... ) - >>> days_since_to_doy(da).values - array([190, 2]) - """ - if start is None: - unitstr = da.attrs.get("units", " time coordinate").split(" ", maxsplit=2)[-1] - if unitstr != "time coordinate": - start = unitstr - - base_calendar = get_calendar(da) - calendar = calendar or da.attrs.get("calendar", base_calendar) - - dac = da.convert_calendar(calendar) - - _, start_doy, doy_max = _doy_days_since_doys(dac.time, start) - - # 2cases: - # val is a day in the same year as its index : da + offset - # val is a day in the next year : da + offset - doy_max - out = dac + start_doy - out = xr.where(out > doy_max, out - doy_max, out) - - out.attrs.update( - {k: v for k, v in da.attrs.items() if k not in ["units", "calendar"]} - ) - out.attrs.update(calendar=calendar, is_dayofyear=1) - return out.convert_calendar(base_calendar).rename(da.name) - - -def date_range_like(source: xr.DataArray, calendar: str) -> xr.DataArray: - """Deprecated : use :py:func:`xarray.date_range_like` instead. Passing use_cftime=False instead of calendar='default'. - - Generate a datetime array with the same frequency, start and end as another one, but in a different calendar. - """ - calendar, usecf = _get_usecf_and_warn( - calendar, "date_range_like", "xarray.date_range_like" - ) - return xr.coding.calendar_ops.date_range_like( - source=source, calendar=calendar, use_cftime=usecf - ) - - -def select_time( - da: xr.DataArray | xr.Dataset, - drop: bool = False, - season: str | Sequence[str] | None = None, - month: int | Sequence[int] | None = None, - doy_bounds: tuple[int, int] | None = None, - date_bounds: tuple[str, str] | None = None, - include_bounds: bool | tuple[bool, bool] = True, -) -> DataType: - """Select entries according to a time period. - - This conveniently improves xarray's :py:meth:`xarray.DataArray.where` and - :py:meth:`xarray.DataArray.sel` with fancier ways of indexing over time elements. - In addition to the data `da` and argument `drop`, only one of `season`, `month`, - `doy_bounds` or `date_bounds` may be passed. - - Parameters - ---------- - da : xr.DataArray or xr.Dataset - Input data. - drop : bool - Whether to drop elements outside the period of interest or to simply mask them (default). - season : str or sequence of str, optional - One or more of 'DJF', 'MAM', 'JJA' and 'SON'. - month : int or sequence of int, optional - Sequence of month numbers (January = 1 ... December = 12). - doy_bounds : 2-tuple of int, optional - The bounds as (start, end) of the period of interest expressed in day-of-year, integers going from - 1 (January 1st) to 365 or 366 (December 31st). - If calendar awareness is needed, consider using ``date_bounds`` instead. - date_bounds : 2-tuple of str, optional - The bounds as (start, end) of the period of interest expressed as dates in the month-day (%m-%d) format. - include_bounds : bool or 2-tuple of bool - Whether the bounds of `doy_bounds` or `date_bounds` should be inclusive or not. - Either one value for both or a tuple. Default is True, meaning bounds are inclusive. - - Returns - ------- - xr.DataArray or xr.Dataset - Selected input values. If ``drop=False``, this has the same length as ``da`` (along dimension 'time'), - but with masked (NaN) values outside the period of interest. - - Examples - -------- - Keep only the values of fall and spring. - - >>> ds = open_dataset("ERA5/daily_surface_cancities_1990-1993.nc") - >>> ds.time.size - 1461 - >>> out = select_time(ds, drop=True, season=["MAM", "SON"]) - >>> out.time.size - 732 - - Or all values between two dates (included). - - >>> out = select_time(ds, drop=True, date_bounds=("02-29", "03-02")) - >>> out.time.values - array(['1990-03-01T00:00:00.000000000', '1990-03-02T00:00:00.000000000', - '1991-03-01T00:00:00.000000000', '1991-03-02T00:00:00.000000000', - '1992-02-29T00:00:00.000000000', '1992-03-01T00:00:00.000000000', - '1992-03-02T00:00:00.000000000', '1993-03-01T00:00:00.000000000', - '1993-03-02T00:00:00.000000000'], dtype='datetime64[ns]') - """ - N = sum(arg is not None for arg in [season, month, doy_bounds, date_bounds]) - if N > 1: - raise ValueError(f"Only one method of indexing may be given, got {N}.") - - if N == 0: - return da - - def _get_doys(_start, _end, _inclusive): - if _start <= _end: - _doys = np.arange(_start, _end + 1) - else: - _doys = np.concatenate((np.arange(_start, 367), np.arange(0, _end + 1))) - if not _inclusive[0]: - _doys = _doys[1:] - if not _inclusive[1]: - _doys = _doys[:-1] - return _doys - - if isinstance(include_bounds, bool): - include_bounds = (include_bounds, include_bounds) - - if season is not None: - if isinstance(season, str): - season = [season] - mask = da.time.dt.season.isin(season) - - elif month is not None: - if isinstance(month, int): - month = [month] - mask = da.time.dt.month.isin(month) - - elif doy_bounds is not None: - mask = da.time.dt.dayofyear.isin(_get_doys(*doy_bounds, include_bounds)) - - elif date_bounds is not None: - # This one is a bit trickier. - start, end = date_bounds - time = da.time - calendar = get_calendar(time) - if calendar not in uniform_calendars: - # For non-uniform calendars, we can't simply convert dates to doys - # conversion to all_leap is safe for all non-uniform calendar as it doesn't remove any date. - time = time.convert_calendar("all_leap") - # values of time are the _old_ calendar - # and the new calendar is in the coordinate - calendar = "all_leap" - - # Get doy of date, this is now safe because the calendar is uniform. - doys = _get_doys( - to_cftime_datetime(f"2000-{start}", calendar).dayofyr, - to_cftime_datetime(f"2000-{end}", calendar).dayofyr, - include_bounds, - ) - mask = time.time.dt.dayofyear.isin(doys) - # Needed if we converted calendar, this puts back the correct coord - mask["time"] = da.time - - else: - raise ValueError( - "Must provide either `season`, `month`, `doy_bounds` or `date_bounds`." - ) - - return da.where(mask, drop=drop) - - -def _month_is_first_period_month(time, freq): - """Return True if the given time is from the first month of freq.""" - if isinstance(time, cftime.datetime): - frq_monthly = xr.coding.cftime_offsets.to_offset("MS") - frq = xr.coding.cftime_offsets.to_offset(freq) - if frq_monthly.onOffset(time): - return frq.onOffset(time) - return frq.onOffset(frq_monthly.rollback(time)) - # Pandas - time = pd.Timestamp(time) - frq_monthly = pd.tseries.frequencies.to_offset("MS") - frq = pd.tseries.frequencies.to_offset(freq) - if frq_monthly.is_on_offset(time): - return frq.is_on_offset(time) - return frq.is_on_offset(frq_monthly.rollback(time)) - - -def stack_periods( - da: xr.Dataset | xr.DataArray, - window: int = 30, - stride: int | None = None, - min_length: int | None = None, - freq: str = "YS", - dim: str = "period", - start: str = "1970-01-01", - align_days: bool = True, - pad_value=dtypes.NA, -): - """Construct a multi-period array. - - Stack different equal-length periods of `da` into a new 'period' dimension. - - This is similar to ``da.rolling(time=window).construct(dim, stride=stride)``, but adapted for arguments - in terms of a base temporal frequency that might be non-uniform (years, months, etc.). - It is reversible for some cases (see `stride`). - A rolling-construct method will be much more performant for uniform periods (days, weeks). - - Parameters - ---------- - da : xr.Dataset or xr.DataArray - An xarray object with a `time` dimension. - Must have a uniform timestep length. - Output might be strange if this does not use a uniform calendar (noleap, 360_day, all_leap). - window : int - The length of the moving window as a multiple of ``freq``. - stride : int, optional - At which interval to take the windows, as a multiple of ``freq``. - For the operation to be reversible with :py:func:`unstack_periods`, it must divide `window` into an odd number of parts. - Default is `window` (no overlap between periods). - min_length : int, optional - Windows shorter than this are not included in the output. - Given as a multiple of ``freq``. Default is ``window`` (every window must be complete). - Similar to the ``min_periods`` argument of ``da.rolling``. - If ``freq`` is annual or quarterly and ``min_length == ``window``, the first period is considered complete - if the first timestep is in the first month of the period. - freq : str - Units of ``window``, ``stride`` and ``min_length``, as a frequency string. - Must be larger or equal to the data's sampling frequency. - Note that this function offers an easier interface for non-uniform period (like years or months) - but is much slower than a rolling-construct method. - dim : str - The new dimension name. - start : str - The `start` argument passed to :py:func:`xarray.date_range` to generate the new placeholder - time coordinate. - align_days : bool - When True (default), an error is raised if the output would have unaligned days across periods. - If `freq = 'YS'`, day-of-year alignment is checked and if `freq` is "MS" or "QS", we check day-in-month. - Only uniform-calendar will pass the test for `freq='YS'`. - For other frequencies, only the `360_day` calendar will work. - This check is ignored if the sampling rate of the data is coarser than "D". - pad_value : Any - When some periods are shorter than others, this value is used to pad them at the end. - Passed directly as argument ``fill_value`` to :py:func:`xarray.concat`, - the default is the same as on that function. - - Return - ------ - xr.DataArray - A DataArray with a new `period` dimension and a `time` dimension with the length of the longest window. - The new time coordinate has the same frequency as the input data but is generated using - :py:func:`xarray.date_range` with the given `start` value. - That coordinate is the same for all periods, depending on the choice of ``window`` and ``freq``, it might make sense. - But for unequal periods or non-uniform calendars, it will certainly not. - If ``stride`` is a divisor of ``window``, the correct timeseries can be reconstructed with :py:func:`unstack_periods`. - The coordinate of `period` is the first timestep of each window. - """ - from xsdba.units import ( # Import in function to avoid cyclical imports; ensure_cf_units, - infer_sampling_units, - ) - - stride = stride or window - min_length = min_length or window - if stride > window: - raise ValueError( - f"Stride must be less than or equal to window. Got {stride} > {window}." - ) - - srcfreq = xr.infer_freq(da.time) - cal = da.time.dt.calendar - use_cftime = da.time.dtype == "O" - - if ( - compare_offsets(srcfreq, "<=", "D") - and align_days - and ( - (freq.startswith(("Y", "A")) and cal not in uniform_calendars) - or (freq.startswith(("Q", "M")) and window > 1 and cal != "360_day") - ) - ): - if freq.startswith(("Y", "A")): - u = "year" - else: - u = "month" - raise ValueError( - f"Stacking {window}{freq} periods will result in unaligned day-of-{u}. " - f"Consider converting the calendar of your data to one with uniform {u} lengths, " - "or pass `align_days=False` to disable this check." - ) - - # Convert integer inputs to freq strings - mult, *args = parse_offset(freq) - win_frq = construct_offset(mult * window, *args) - strd_frq = construct_offset(mult * stride, *args) - minl_frq = construct_offset(mult * min_length, *args) - - # The same time coord as da, but with one extra element. - # This way, the last window's last index is not returned as None by xarray's grouper. - time2 = xr.DataArray( - xr.date_range( - da.time[0].item(), - freq=srcfreq, - calendar=cal, - periods=da.time.size + 1, - use_cftime=use_cftime, - ), - dims=("time",), - name="time", - ) - - periods = [] - # longest = 0 - # Iterate over strides, but recompute the full window for each stride start - for strd_slc in da.resample(time=strd_frq).groups.values(): - win_resamp = time2.isel(time=slice(strd_slc.start, None)).resample(time=win_frq) - # Get slice for first group - win_slc = win_resamp._group_indices[0] - if min_length < window: - # If we ask for a min_length period instead is it complete ? - min_resamp = time2.isel(time=slice(strd_slc.start, None)).resample( - time=minl_frq - ) - min_slc = min_resamp._group_indices[0] - open_ended = min_slc.stop is None - else: - # The end of the group slice is None if no outside-group value was found after the last element - # As we added an extra step to time2, we avoid the case where a group ends exactly on the last element of ds - open_ended = win_slc.stop is None - if open_ended: - # Too short, we got to the end - break - if ( - strd_slc.start == 0 - and parse_offset(freq)[1] in "YAQ" - and min_length == window - and not _month_is_first_period_month(da.time[0].item(), freq) - ): - # For annual or quarterly frequencies (which can be anchor-based), - # if the first time is not in the first month of the first period, - # then the first period is incomplete but by a fractional amount. - continue - periods.append( - slice( - strd_slc.start + win_slc.start, - ( - (strd_slc.start + win_slc.stop) - if win_slc.stop is not None - else da.time.size - ), - ) - ) - - # Make coordinates - lengths = xr.DataArray( - [slc.stop - slc.start for slc in periods], - dims=(dim,), - attrs={"long_name": "Length of each period"}, - ) - longest = lengths.max().item() - # Length as a pint-ready array : with proper units, but values are not usable as indexes anymore - m, u = infer_sampling_units(da) - lengths = lengths * m - # ADAPT: cf-agnostic - # lengths.attrs["units"] = ensure_cf_units(u) - - # Start points for each period and remember parameters for unstacking - starts = xr.DataArray( - [da.time[slc.start].item() for slc in periods], - dims=(dim,), - attrs={ - "long_name": "Start of the period", - # Save parameters so that we can unstack. - "window": window, - "stride": stride, - "freq": freq, - "unequal_lengths": int(len(np.unique(lengths)) > 1), - }, - ) - # The "fake" axis that all periods share - fake_time = xr.date_range( - start, periods=longest, freq=srcfreq, calendar=cal, use_cftime=use_cftime - ) - # Slice and concat along new dim. We drop the index and add a new one so that xarray can concat them together. - out = xr.concat( - [ - da.isel(time=slc) - .drop_vars("time") - .assign_coords(time=np.arange(slc.stop - slc.start)) - for slc in periods - ], - dim, - join="outer", - fill_value=pad_value, - ) - out = out.assign_coords( - time=(("time",), fake_time, da.time.attrs.copy()), - **{f"{dim}_length": lengths, dim: starts}, - ) - out.time.attrs.update(long_name="Placeholder time axis") - return out - - -def unstack_periods(da: xr.DataArray | xr.Dataset, dim: str = "period"): - """Unstack an array constructed with :py:func:`stack_periods`. - - Can only work with periods stacked with a ``stride`` that divides ``window`` in an odd number of sections. - When ``stride`` is smaller than ``window``, only the center-most stride of each window is kept, - except for the beginning and end which are taken from the first and last windows. - - Parameters - ---------- - da : xr.DataArray - As constructed by :py:func:`stack_periods`, attributes of the period coordinates must have been preserved. - dim : str - The period dimension name. - - Notes - ----- - The following table shows which strides are included (``o``) in the unstacked output. - - In this example, ``stride`` was a fifth of ``window`` and ``min_length`` was four (4) times ``stride``. - The row index ``i`` the period index in the stacked dataset, - columns are the stride-long section of the original timeseries. - - .. table:: Unstacking example with ``stride < window``. - - === === === === === === === === - i 0 1 2 3 4 5 6 - === === === === === === === === - 3 x x o o - 2 x x o x x - 1 x x o x x - 0 o o o x x - === === === === === === === === - """ - from xsdba.units import infer_sampling_units - - try: - starts = da[dim] - window = starts.attrs["window"] - stride = starts.attrs["stride"] - freq = starts.attrs["freq"] - unequal_lengths = bool(starts.attrs["unequal_lengths"]) - except (AttributeError, KeyError) as err: - raise ValueError( - f"`unstack_periods` can't find the window, stride and freq attributes on the {dim} coordinates." - ) from err - - if unequal_lengths: - try: - lengths = da[f"{dim}_length"] - except KeyError as err: - raise ValueError( - f"`unstack_periods` can't find the `{dim}_length` coordinate." - ) from err - # Get length as number of points - m, _ = infer_sampling_units(da.time) - lengths = lengths // m - else: - # It is acceptable to lose "{dim}_length" if they were all equal - lengths = xr.DataArray([da.time.size] * da[dim].size, dims=(dim,)) - - # Convert from the fake axis to the real one - time_as_delta = da.time - da.time[0] - if da.time.dtype == "O": - # cftime can't add with np.timedelta64 (restriction comes from numpy which refuses to add O with m8) - time_as_delta = pd.TimedeltaIndex( - time_as_delta - ).to_pytimedelta() # this array is O, numpy complies - else: - # Xarray will return int when iterating over datetime values, this returns timestamps - starts = pd.DatetimeIndex(starts) - - def _reconstruct_time(_time_as_delta, _start): - times = _time_as_delta + _start - return xr.DataArray(times, dims=("time",), coords={"time": times}, name="time") - - # Easy case: - if window == stride: - # just concat them all - periods = [] - for i, (start, length) in enumerate(zip(starts.values, lengths.values)): - real_time = _reconstruct_time(time_as_delta, start) - periods.append( - da.isel(**{dim: i}, drop=True) - .isel(time=slice(0, length)) - .assign_coords(time=real_time.isel(time=slice(0, length))) - ) - return xr.concat(periods, "time") - - # Difficult and ambiguous case - if (window / stride) % 2 != 1: - raise NotImplementedError( - "`unstack_periods` can't work with strides that do not divide the window into an odd number of parts." - f"Got {window} / {stride} which is not an odd integer." - ) - - # Non-ambiguous overlapping case - Nwin = window // stride - mid = (Nwin - 1) // 2 # index of the center window - - mult, *args = parse_offset(freq) - strd_frq = construct_offset(mult * stride, *args) - - periods = [] - for i, (start, length) in enumerate(zip(starts.values, lengths.values)): - real_time = _reconstruct_time(time_as_delta, start) - slices = real_time.resample(time=strd_frq)._group_indices - if i == 0: - slc = slice(slices[0].start, min(slices[mid].stop, length)) - elif i == da.period.size - 1: - slc = slice(slices[mid].start, min(slices[Nwin - 1].stop or length, length)) - else: - slc = slice(slices[mid].start, min(slices[mid].stop, length)) - periods.append( - da.isel(**{dim: i}, drop=True) - .isel(time=slc) - .assign_coords(time=real_time.isel(time=slc)) - ) - - return xr.concat(periods, "time") diff --git a/src/xsdba/datachecks.py b/src/xsdba/datachecks.py deleted file mode 100644 index f0c2bb0..0000000 --- a/src/xsdba/datachecks.py +++ /dev/null @@ -1,123 +0,0 @@ -"""# noqa: SS01 -Data Checks -=========== - -Utilities designed to check the validity of data inputs. -""" - -from __future__ import annotations - -from collections.abc import Sequence - -import xarray as xr - -from .calendar import compare_offsets, parse_offset -from .logging import ValidationError -from .options import datacheck - - -@datacheck -def check_freq(var: xr.DataArray, freq: str | Sequence[str], strict: bool = True): - """Raise an error if not series has not the expected temporal frequency or is not monotonically increasing. - - Parameters - ---------- - var : xr.DataArray - Input array. - freq : str or sequence of str - The expected temporal frequencies, using Pandas frequency terminology ({'Y', 'M', 'D', 'h', 'min', 's', 'ms', 'us'}) - and multiples thereof. To test strictly for 'W', pass '7D' with `strict=True`. - This ignores the start/end flag and the anchor (ex: 'YS-JUL' will validate against 'Y'). - strict : bool - Whether multiples of the frequencies are considered invalid or not. With `strict` set to False, a '3h' series - will not raise an error if freq is set to 'h'. - - Raises - ------ - ValidationError - - If the frequency of `var` is not inferrable. - - If the frequency of `var` does not match the requested `freq`. - """ - if isinstance(freq, str): - freq = [freq] - exp_base = [parse_offset(frq)[1] for frq in freq] - v_freq = xr.infer_freq(var.time) - if v_freq is None: - raise ValidationError( - "Unable to infer the frequency of the time series. " - "To mute this, set xsdba's option data_validation='log'." - ) - v_base = parse_offset(v_freq)[1] - if v_base not in exp_base or ( - strict and all(compare_offsets(v_freq, "!=", frq) for frq in freq) - ): - raise ValidationError( - f"Frequency of time series not {'strictly' if strict else ''} in {freq}. " - "To mute this, set xsdba's option data_validation='log'." - ) - - -def check_daily(var: xr.DataArray): - """Raise an error if not series has a frequency other that daily, or is not monotonically increasing. - - Notes - ----- - This does not check for gaps in series. - """ - return check_freq(var, "D") - - -@datacheck -def check_common_time(inputs: Sequence[xr.DataArray]): - """Raise an error if the list of inputs doesn't have a single common frequency. - - Raises - ------ - ValidationError - - if the frequency of any input can't be inferred - - if inputs have different frequencies - - if inputs have a daily or hourly frequency, but they are not given at the same time of day. - - Parameters - ---------- - inputs : Sequence of xr.DataArray - Input arrays. - """ - # Check all have the same freq - freqs = [xr.infer_freq(da.time) for da in inputs] - if None in freqs: - raise ValidationError( - "Unable to infer the frequency of the time series. " - "To mute this, set xsdba's option data_validation='log'." - ) - if len(set(freqs)) != 1: - raise ValidationError( - f"Inputs have different frequencies. Got : {freqs}." - "To mute this, set xsdba's option data_validation='log'." - ) - - # Check if anchor is the same - freq = freqs[0] - base = parse_offset(freq)[1] - fmt = {"h": ":%M", "D": "%H:%M"} - if base in fmt: - outs = {da.indexes["time"][0].strftime(fmt[base]) for da in inputs} - if len(outs) > 1: - raise ValidationError( - f"All inputs have the same frequency ({freq}), but they are not anchored on the same minutes (got {outs}). " - f"xarray's alignment would silently fail. You can try to fix this with `da.resample('{freq}').mean()`." - "To mute this, set xsdba's option data_validation='log'." - ) - - -def is_percentile_dataarray(source: xr.DataArray) -> bool: - """Evaluate whether a DataArray is a Percentile. - - A percentile dataarray must have climatology_bounds attributes and either a - quantile or percentiles coordinate, the window is not mandatory. - """ - return ( - isinstance(source, xr.DataArray) - and source.attrs.get("climatology_bounds", None) is not None - and ("quantile" in source.coords or "percentiles" in source.coords) - ) diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index 336cf14..adaa41c 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -389,7 +389,7 @@ def _first_and_last_nonnull(arr): def _extrapolate_on_quantiles(interp, oldx, oldg, oldy, newx, newg, method="constant"): """Apply extrapolation to the output of interpolation on quantiles with a given grouping. - Arguments are the same as _interp_on_quantiles_2D. + Arguments are the same as _interp_on_quantiles_2d. """ bnds = _first_and_last_nonnull(oldx) xp = np.arange(bnds.shape[0]) diff --git a/src/xsdba/options.py b/src/xsdba/options.py index 204a912..cc77b2e 100644 --- a/src/xsdba/options.py +++ b/src/xsdba/options.py @@ -124,7 +124,7 @@ def run_check(*args, **kwargs): class set_options: - """Set options for xclim in a controlled context. + """Set options for xsdba in a controlled context. Attributes ---------- @@ -188,9 +188,8 @@ def __init__(self, **kwargs): self.old = {} for k, v in kwargs.items(): if k not in OPTIONS: - raise ValueError( - f"argument name {k!r} is not in the set of valid options {set(OPTIONS)!r}" - ) + msg = f"Argument name {k!r} is not in the set of valid options {set(OPTIONS)!r}." + raise ValueError(msg) if k in _VALIDATORS and not _VALIDATORS[k](v): raise ValueError(f"option {k!r} given an invalid value: {v!r}") diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 0ba5fbf..2faaaa6 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -14,11 +14,10 @@ import xarray as xr from xarray.core.utils import get_temp_dimname -from xsdba.calendar import get_calendar, max_doy, parse_offset, uses_dask from xsdba.formatting import update_xsdba_history from ._processing import _adapt_freq, _normalize, _reordering -from .base import Grouper +from .base import Grouper, parse_offset, uses_dask from .nbutils import _escore from .units import convert_units_to, harmonize_units, pint2str from .utils import ADDITIVE, copy_all_attrs @@ -480,16 +479,8 @@ def _get_number_of_elements_by_year(time): Only calendar with uniform year lengths are supported : 360_day, noleap, all_leap. """ - cal = get_calendar(time) - - # Calendar check - if cal in ["standard", "gregorian", "default", "proleptic_gregorian"]: - raise ValueError( - "For moving window computations, the data must have a uniform calendar (360_day, no_leap or all_leap)" - ) - mult, freq, _, _ = parse_offset(xr.infer_freq(time)) - days_in_year = max_doy[cal] + days_in_year = time.dt.days_in_year.max() elements_in_year = {"Q": 4, "M": 12, "D": days_in_year, "h": days_in_year * 24} N_in_year = elements_in_year.get(freq, 1) / mult if N_in_year % 1 != 0: @@ -613,25 +604,25 @@ def from_additive_space( lower_bound : str, optional The smallest physical value of the variable, as a Quantity string. The final data will have no value smaller or equal to this bound. - If None (default), the `sdba_transform_lower` attribute is looked up on `data`. + If None (default), the `xsdba_transform_lower` attribute is looked up on `data`. upper_bound : str, optional The largest physical value of the variable, as a Quantity string. Only relevant for the logit transformation. The final data will have no value larger or equal to this bound. - If None (default), the `sdba_transform_upper` attribute is looked up on `data`. + If None (default), the `xsdba_transform_upper` attribute is looked up on `data`. trans : {'log', 'logit'}, optional The transformation to use. See notes. - If None (the default), the `sdba_transform` attribute is looked up on `data`. + If None (the default), the `xsdba_transform` attribute is looked up on `data`. units : str, optional The units of the data before transformation to the additive space. - If None (the default), the `sdba_transform_units` attribute is looked up on `data`. + If None (the default), the `xsdba_transform_units` attribute is looked up on `data`. Returns ------- xr.DataArray The physical variable. Attributes are conserved, even if some might be incorrect. - Except units which are taken from `sdba_transform_units` if available. - All `sdba_transform*` attributes are deleted. + Except units which are taken from `xsdba_transform_units` if available. + All `xsdba_transform*` attributes are deleted. Notes ----- @@ -663,15 +654,15 @@ def from_additive_space( """ if trans is None and lower_bound is None and units is None: try: - trans = data.attrs["sdba_transform"] - units = data.attrs["sdba_transform_units"] - lower_bound_array = np.array(data.attrs["sdba_transform_lower"]).astype( + trans = data.attrs["xsdba_transform"] + units = data.attrs["xsdba_transform_units"] + lower_bound_array = np.array(data.attrs["xsdba_transform_lower"]).astype( float ) if trans == "logit": - upper_bound_array = np.array(data.attrs["sdba_transform_upper"]).astype( - float - ) + upper_bound_array = np.array( + data.attrs["xsdba_transform_upper"] + ).astype(float) except KeyError as err: raise ValueError( f"Attribute {err!s} must be present on the input data " @@ -707,10 +698,10 @@ def from_additive_space( raise NotImplementedError("`trans` must be one of 'log' or 'logit'.") # Remove unneeded attributes, put correct units back. - out.attrs.pop("sdba_transform", None) - out.attrs.pop("sdba_transform_lower", None) - out.attrs.pop("sdba_transform_upper", None) - out.attrs.pop("sdba_transform_units", None) + out.attrs.pop("xsdba_transform", None) + out.attrs.pop("xsdba_transform_lower", None) + out.attrs.pop("xsdba_transform_upper", None) + out.attrs.pop("xsdba_transform_units", None) out = out.assign_attrs(units=units) return out @@ -735,9 +726,9 @@ def stack_variables(ds: xr.Dataset, rechunk: bool = True, dim: str = "multivar") ------- xr.DataArray The transformed variable. Attributes are conserved, even if some might be incorrect, except for units, - which are replaced with `""`. Old units are stored in `sdba_transformation_units`. - A `sdba_transform` attribute is added, set to the transformation method. `sdba_transform_lower` and - `sdba_transform_upper` are also set if the requested bounds are different from the defaults. + which are replaced with `""`. Old units are stored in `xsdba_transformation_units`. + A `xsdba_transform` attribute is added, set to the transformation method. `xsdba_transform_lower` and + `xsdba_transform_upper` are also set if the requested bounds are different from the defaults. Array with variables stacked along `dim` dimension. Units are set to "". """ diff --git a/src/xsdba/testing.py b/src/xsdba/testing.py index 88a6a3b..602df1b 100644 --- a/src/xsdba/testing.py +++ b/src/xsdba/testing.py @@ -19,7 +19,6 @@ from scipy.stats import gamma from xarray import open_dataset as _open_dataset -from xsdba.calendar import percentile_doy from xsdba.utils import equally_spaced_nodes __all__ = ["nancov", "test_timelonlatseries", "test_timeseries"] diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 5cce223..f77f034 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -15,6 +15,7 @@ # this dependency is "necessary" for convert_units_to # if we only do checks, we could get rid of it +# XC : units try: # allows to use cf units @@ -25,12 +26,30 @@ import warnings import numpy as np +import pandas as pd import xarray as xr -from .calendar import get_calendar, parse_offset +from .base import get_calendar, parse_offset from .typing import Quantified from .utils import copy_all_attrs +__all__ = [ + "compare_units", + "convert_units_to", + "ensure_absolute_temperature", + "ensure_cf_units", + "ensure_delta", + "harmonize_units", + "infer_context", + "infer_sampling_units", + "pint2cfunits", + "pint_multiply", + "str2pint", + "to_agg_units", + "units", + "units2pint", +] + units = pint.get_application_registry() # Another alias not included by cf_xarray units.define("@alias percent = pct") @@ -260,6 +279,14 @@ def ensure_absolute_temperature(units: str): return units +def ensure_cf_units(ustr: str) -> str: + """Ensure the passed unit string is CF-compliant. + + The string will be parsed to pint then recast to a string by xclim's `pint2cfunits`. + """ + return pint2cfunits(units2pint(ustr)) + + def ensure_delta(unit: str) -> str: """Return delta units for temperature. @@ -515,13 +542,13 @@ def to_agg_units( out.attrs["units"] = ensure_absolute_temperature(orig.attrs["units"]) elif op in ["var"]: - out.attrs["units"] = pint2str( + out.attrs["units"] = pint2cfunits( str2pint(ensure_absolute_temperature(orig.units)) ** 2 ) elif op in ["doymin", "doymax"]: out.attrs.update( - units="", is_dayofyear=np.int32(1), calendar=get_calendar(orig) + units="1", is_dayofyear=np.int32(1), calendar=get_calendar(orig) ) elif op in ["count", "integral"]: @@ -537,9 +564,9 @@ def to_agg_units( # We need to simplify units after multiplication out_units = (orig_u * freq_u).to_reduced_units() out = out * out_units.magnitude - out.attrs["units"] = pint2str(out_units) + out.attrs["units"] = pint2cfunits(out_units) else: - out.attrs["units"] = pint2str(orig_u * freq_u) + out.attrs["units"] = pint2cfunits(orig_u * freq_u) else: raise ValueError( f"Unknown aggregation op {op}. " diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 05ce4ba..e977fa6 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -12,13 +12,14 @@ import bottleneck as bn import numpy as np import xarray as xr +from boltons.funcutils import wraps from dask import array as dsk from scipy.interpolate import griddata, interp1d +from scipy.spatial import distance from scipy.stats import spearmanr from xarray.core.utils import get_temp_dimname from .base import Grouper, ensure_chunk_size, parse_group, uses_dask -from .calendar import ensure_longest_doy from .nbutils import _extrapolate_on_quantiles, _linear_interpolation MULTIPLICATIVE = "*" @@ -41,7 +42,7 @@ def map_cdf( ds: xr.Dataset, *, y_value: xr.DataArray, - dim, + dim: str, ): """Return the value in `x` with the same CDF as `y_value` in `y`. @@ -96,6 +97,38 @@ def ecdf(x: xr.DataArray, value: float, dim: str = "time") -> xr.DataArray: return (x <= value).sum(dim) / x.notnull().sum(dim) +def ensure_longest_doy(func: Callable) -> Callable: + """Ensure that selected day is the longest day of year for x and y dims.""" + + @wraps(func) + def _ensure_longest_doy(x, y, *args, **kwargs): + if ( + hasattr(x, "dims") + and hasattr(y, "dims") + and "dayofyear" in x.dims + and "dayofyear" in y.dims + and x.dayofyear.max() != y.dayofyear.max() + ): + warn( + ( + "get_correction received inputs defined on different dayofyear ranges. " + "Interpolating to the longest range. Results could be strange." + ), + stacklevel=4, + ) + if x.dayofyear.max() < y.dayofyear.max(): + x = _interpolate_doy_calendar( + x, int(y.dayofyear.max()), int(y.dayofyear.min()) + ) + else: + y = _interpolate_doy_calendar( + y, int(x.dayofyear.max()), int(x.dayofyear.min()) + ) + return func(x, y, *args, **kwargs) + + return _ensure_longest_doy + + @ensure_longest_doy def get_correction(x: xr.DataArray, y: xr.DataArray, kind: str) -> xr.DataArray: """Return the additive or multiplicative correction/adjustment factors.""" @@ -291,7 +324,7 @@ def _interp_on_quantiles_1D_multi(newxs, oldx, oldy, method, extrap): # noqa: N oldy[~np.isnan(oldy)][-1], ) else: # extrap == 'nan' - fill_value = np.NaN + fill_value = np.nan finterp1d = interp1d( oldx[~mask_old], @@ -304,7 +337,7 @@ def _interp_on_quantiles_1D_multi(newxs, oldx, oldy, method, extrap): # noqa: N out = np.zeros_like(newxs) for ii in range(newxs.shape[0]): mask_new = np.isnan(newxs[ii, :]) - y1 = newxs[ii, :].copy() * np.NaN + y1 = newxs[ii, :].copy() * np.nan y1[~mask_new] = finterp1d(newxs[ii, ~mask_new]) out[ii, :] = y1.flatten() return out @@ -316,7 +349,7 @@ def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 out = np.full_like(newx, np.nan, dtype=f"float{oldy.dtype.itemsize * 8}") if np.all(mask_new) or np.all(mask_old): warn( - "All-NaN slice encountered in interp_on_quantiles", + "All-nan slice encountered in interp_on_quantiles", category=RuntimeWarning, ) return out @@ -339,13 +372,13 @@ def _interp_on_quantiles_1D(newx, oldx, oldy, method, extrap): # noqa: N802 return out -def _interp_on_quantiles_2D(newx, newg, oldx, oldy, oldg, method, extrap): # noqa: N802 +def _interp_on_quantiles_2d(newx, newg, oldx, oldy, oldg, method, extrap): mask_new = np.isnan(newx) | np.isnan(newg) mask_old = np.isnan(oldy) | np.isnan(oldx) | np.isnan(oldg) out = np.full_like(newx, np.nan, dtype=f"float{oldy.dtype.itemsize * 8}") if np.all(mask_new) or np.all(mask_old): warn( - "All-NaN slice encountered in interp_on_quantiles", + "All-nan slice encountered in interp_on_quantiles", category=RuntimeWarning, ) return out @@ -380,8 +413,8 @@ def interp_on_quantiles( Interpolate in 2D with :py:func:`scipy.interpolate.griddata` if grouping is used, in 1D otherwise, with :py:class:`scipy.interpolate.interp1d`. - Any NaNs in `xq` or `yq` are removed from the input map. - Similarly, NaNs in newx are left NaNs. + Any nans in `xq` or `yq` are removed from the input map. + Similarly, nans in newx are left nans. Parameters ---------- @@ -406,7 +439,7 @@ def interp_on_quantiles( ----- Extrapolation methods: - - 'nan' : Any value of `newx` outside the range of `xq` is set to NaN. + - 'nan' : Any value of `newx` outside the range of `xq` is set to 'nan'. - 'constant' : Values of `newx` smaller than the minimum of `xq` are set to the first value of `yq` and those larger than the maximum, set to the last one (first and last non-nan values along the "quantiles" dimension). When the grouping is "time.month", @@ -452,7 +485,7 @@ def interp_on_quantiles( oldg = xq[prop].expand_dims(quantiles=xq.coords["quantiles"]) return xr.apply_ufunc( - _interp_on_quantiles_2D, + _interp_on_quantiles_2d, newx, newg, xq, @@ -487,23 +520,23 @@ def rank( Parameters ---------- - da : xr.DataArray - Source array. + da: xr.DataArray + Source array. dim : str | list[str], hashable - Dimension(s) over which to compute rank. + Dimension(s) over which to compute rank. pct : bool, optional - If True, compute percentage ranks, otherwise compute integer ranks. - Percentage ranks range from 0 to 1, in opposition to xarray's implementation, - where they range from 1/N to 1. + If True, compute percentage ranks, otherwise compute integer ranks. + Percentage ranks range from 0 to 1, in opposition to xarray's implementation, + where they range from 1/N to 1. Returns ------- - xr.DataArray + DataArray DataArray with the same coordinates and dtype 'float64'. Notes ----- - The `bottleneck` library is required. NaNs in the input array are returned as NaNs. + The `bottleneck` library is required. nans in the input array are returned as nans. See Also -------- @@ -513,7 +546,7 @@ def rank( dims = dim if isinstance(dim, list) else [dim] rnk_dim = dims[0] if len(dims) == 1 else get_temp_dimname(da_dims, "temp") - # multidimensional ranking through stacking + # multi-dimensional ranking through stacking if len(dims) > 1: da = da.stack(**{rnk_dim: dims}) rnk = da.rank(rnk_dim, pct=pct) @@ -544,18 +577,18 @@ def pc_matrix(arr: np.ndarray | dsk.Array) -> np.ndarray | dsk.Array: """Construct a Principal Component matrix. This matrix can be used to transform points in arr to principal components - coordinates. Note that this function does not manage NaNs; if a single observation is null, all elements - of the transformation matrix involving that variable will be NaN. + coordinates. Note that this function does not manage nans; if a single observation is null, all elements + of the transformation matrix involving that variable will be nan. Parameters ---------- arr : numpy.ndarray or dask.array.Array - 2D array (M, N) of the M coordinates of N points. + 2D array (M, N) of the M coordinates of N points. Returns ------- numpy.ndarray or dask.array.Array - MxM Array of the same type as arr. + MxM Array of the same type as arr. """ # Get appropriate math module mod = dsk if isinstance(arr, dsk.Array) else np @@ -690,11 +723,11 @@ def get_clusters_1d( Parameters ---------- data : 1D ndarray - Values to get clusters from. + Values to get clusters from. u1 : float - Extreme value threshold, at least one value in the cluster must exceed this. + Extreme value threshold, at least one value in the cluster must exceed this. u2 : float - Cluster threshold, values above this can be part of a cluster. + Cluster threshold, values above this can be part of a cluster. Returns ------- @@ -720,7 +753,7 @@ def get_clusters_1d( cl_maxval = [] cl_start = [] cl_end = [] - for start, end in zip(starts, ends): + for start, end in zip(starts, ends, strict=False): cluster_max = data[start:end].max() if cluster_max > u1: cl_maxval.append(cluster_max) @@ -762,7 +795,7 @@ def get_clusters(data: xr.DataArray, u1, u2, dim: str = "time") -> xr.Dataset: - `maxpos` : Index of the maximal value within the cluster (`dim` reduced, new `cluster`), int - `maximum` : Maximal value within the cluster (`dim` reduced, new `cluster`), same dtype as data. - For `start`, `end` and `maxpos`, -1 means NaN and should always correspond to a `NaN` in `maximum`. + For `start`, `end` and `maxpos`, -1 means nan and should always correspond to a `nan` in `maximum`. The length along `cluster` is half the size of "dim", the maximal theoretical number of clusters. """ @@ -827,18 +860,19 @@ def rand_rot_matrix( Parameters ---------- - crd : xr.DataArray - 1D coordinate DataArray along which the rotation occurs. - The output will be square with the same coordinate replicated, the second renamed to `new_dim`. + crd: xr.DataArray + 1D coordinate DataArray along which the rotation occurs. + The output will be square with the same coordinate replicated, + the second renamed to `new_dim`. num : int - If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. + If larger than 1 (default), the number of matrices to generate, stacked along a "matrices" dimension. new_dim : str - Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". + Name of the new "prime" dimension, defaults to the same name as `crd` + "_prime". Returns ------- xr.DataArray - A float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. + Float, NxN if num = 1, numxNxN otherwise, where N is the length of crd. References ---------- @@ -869,10 +903,20 @@ def rand_rot_matrix( ) +def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): + """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" + ds.attrs.update(ref.attrs) + extras = ds.variables if isinstance(ds, xr.Dataset) else ds.coords + others = ref.variables if isinstance(ref, xr.Dataset) else ref.coords + for name, var in extras.items(): + if name in others: + var.attrs.update(ref[name].attrs) + + def _pairwise_spearman(da, dims): """Area-averaged pairwise temporal correlation. - With skipna-shortcuts for cases where all times or all points are NaN. + With skipna-shortcuts for cases where all times or all points are nan. """ da = da - da.mean(dims) da = ( @@ -883,7 +927,7 @@ def _pairwise_spearman(da, dims): def _skipna_correlation(data): nv, _nt = data.shape - # Mask of which variable are all NaN + # Mask of which variable are all nan mask_omit = np.isnan(data).all(axis=1) # Remove useless variables data_noallnan = data[~mask_omit, :] @@ -892,7 +936,7 @@ def _skipna_correlation(data): # Remove those times (they'll be omitted anyway) data_nonan = data_noallnan[:, ~mask_skip] - # We still have a possibility that a NaN was unique to a variable and time. + # We still have a possibility that a nan was unique to a variable and time. # If this is the case, it will be a lot longer, but what can we do. coef = spearmanr(data_nonan, axis=1, nan_policy="omit").correlation @@ -922,6 +966,129 @@ def _skipna_correlation(data): ).rename("correlation") +def bin_width_estimator(X): + """Estimate the bin width of an histogram. + + References + ---------- + :cite:cts:`sdba-robin_2021` + """ + if isinstance(X, list): + return np.min([bin_width_estimator(x) for x in X], axis=0) + + if X.ndim == 1: + X = X.reshape(-1, 1) + + # Freedman-Diaconis + bin_width = ( + 2.0 + * (np.percentile(X, q=75, axis=0) - np.percentile(X, q=25, axis=0)) + / np.power(X.shape[0], 1.0 / 3.0) + ) + bin_width = np.where( + bin_width == 0, + # Scott + 3.49 * np.std(X, axis=0) / np.power(X.shape[0], 1.0 / 3.0), + bin_width, + ) + + return bin_width + + +def histogram(data, bin_width, bin_origin): + """Construct an histogram of the data. + + Returns the position of the center of bins, their corresponding frequency and the bin of every data point. + """ + # Find bin indices of data points + idx_bin = np.floor((data - bin_origin) / bin_width) + + # Associate unique values with frequencies + grid, mu = np.unique(idx_bin, return_counts=True, axis=0) + + # Normalise frequencies + mu = np.divide(mu, sum(mu)) + + grid = (grid + 0.5) * bin_width + bin_origin + + return grid, mu, idx_bin + + +def optimal_transport(gridX, gridY, muX, muY, num_iter_max, normalization): + """Compute the optimal transportation plan on (transformations of) X and Y. + + References + ---------- + :cite:cts:`sdba-robin_2021` + """ + try: + from ot import emd # pylint: disable=import-outside-toplevel + except ImportError as e: + raise ImportError( + "The optional dependency `POT` is required for optimal_transport. " + "You can install it with `pip install POT`, `conda install -c conda-forge pot` or `pip install 'xsdba[extras]'`." + ) from e + + if normalization == "standardize": + gridX = (gridX - gridX.mean(axis=0)) / gridX.std(axis=0) + gridY = (gridY - gridY.mean(axis=0)) / gridY.std(axis=0) + + elif normalization == "max_distance": + max1 = np.abs(gridX.max(axis=0) - gridY.min(axis=0)) + max2 = np.abs(gridY.max(axis=0) - gridX.min(axis=0)) + max_dist = np.maximum(max1, max2) + gridX = gridX / max_dist + gridY = gridY / max_dist + + elif normalization == "max_value": + max_value = np.maximum(gridX.max(axis=0), gridY.max(axis=0)) + gridX = gridX / max_value + gridY = gridY / max_value + + # Compute the distances from every X bin to every Y bin + C = distance.cdist(gridX, gridY, "sqeuclidean") + + # Compute the optimal transportation plan + gamma = emd(muX, muY, C, numItermax=num_iter_max) + plan = (gamma.T / gamma.sum(axis=1)).T + + return plan + + +def eps_cholesky(M, nit=26): + """Cholesky decomposition. + + References + ---------- + :cite:cts:`sdba-robin_2021,sdba-higham_1988,sdba-knol_1989` + """ + MC = None + try: + MC = np.linalg.cholesky(M) + except np.linalg.LinAlgError: + MC = None + + if MC is None: + # Introduce small perturbations until M is positive-definite + eps = min(1e-9, np.abs(np.diagonal(M)).min()) + if eps == 0: + eps = 1e-9 + it = 0 + while MC is None: + if it == nit: + raise ValueError( + "The vcov matrix is far from positive-definite. Please use `cov_factor = 'std'`" + ) + perturb = np.identity(M.shape[0]) * eps + try: + MC = np.linalg.cholesky(M + perturb) + except np.linalg.LinAlgError: + MC = None + eps = 2 * eps + it += 1 + return MC + + # ADAPT: Maybe this is not the best place def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index 4877ffe..7a1c920 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -17,8 +17,7 @@ QuantileDeltaMapping, Scaling, ) -from xsdba.base import Grouper -from xsdba.calendar import stack_periods +from xsdba.base import Grouper, stack_periods from xsdba.options import set_options from xsdba.processing import ( jitter_under_thresh, @@ -593,6 +592,15 @@ def test_add_dims(self, use_dask, open_dataset): chunks = {"location": -1} else: chunks = None + + dsim = open_dataset( + "sdba/CanESM2_1950-2100.nc", + chunks=chunks, + drop_variables=["lat", "lon"], + ).tasmax + hist = dsim.sel(time=slice("1981", "2010")) + sim = dsim.sel(time=slice("2041", "2070")) + ref = ( open_dataset( "sdba/ahccd_1950-2013.nc", @@ -603,15 +611,9 @@ def test_add_dims(self, use_dask, open_dataset): .tasmax ) ref = convert_units_to(ref, "K") - ref = ref.isel(location=1, drop=True).expand_dims(location=["Amos"]) - - dsim = open_dataset( - "sdba/CanESM2_1950-2100.nc", - chunks=chunks, - drop_variables=["lat", "lon"], - ).tasmax - hist = dsim.sel(time=slice("1981", "2010")) - sim = dsim.sel(time=slice("2041", "2070")) + # The idea is to have ref defined only over 1 location + # But sdba needs the same dimensions on ref and hist for Grouping with add_dims + ref = ref.where(ref.location == "Amos") # With add_dims, "does it run" test group = Grouper("time.dayofyear", window=5, add_dims=["location"]) diff --git a/tests/test_indicator.py b/tests/test_indicator.py deleted file mode 100644 index f50f289..0000000 --- a/tests/test_indicator.py +++ /dev/null @@ -1,886 +0,0 @@ -# pylint: disable=unsubscriptable-object,function-redefined -# Tests for the Indicator objects -from __future__ import annotations - -# import gc # test_registering -# import dask -import json -from inspect import signature -from typing import Union - -import numpy as np -import pytest -import xarray as xr -from xclim.core.indicator import Indicator - -from xsdba.formatting import ( - AttrFormatter, - default_formatter, - merge_attributes, - update_history, -) -from xsdba.logging import MissingVariableError -from xsdba.options import set_options -from xsdba.typing import InputKind, Quantified -from xsdba.units import convert_units_to, units - -# # @declare_units(da="[temperature]", thresh="[temperature]") -# def uniindtemp_compute( -# da: xr.DataArray, -# thresh: Quantified = "0.0 degC", -# freq: str = "YS", -# method: str = "injected", -# ): -# """Docstring""" -# out = da - convert_units_to(thresh, da) -# out = out.resample(time=freq).mean() -# out.attrs["units"] = da.units -# return out - - -# uniIndTemp = Daily( -# realm="atmos", -# identifier="tmin", -# module="test", -# cf_attrs=[ -# dict( -# var_name="tmin{thresh}", -# units="K", -# long_name="{freq} mean surface temperature with {thresh} threshold.", -# standard_name="{freq} mean temperature", -# cell_methods="time: mean within {freq:noun}", -# another_attr="With a value.", -# ) -# ], -# compute=uniindtemp_compute, -# parameters={"method": "injected"}, -# ) - - -# @declare_units(da="[precipitation]") -# def uniindpr_compute(da: xr.DataArray, freq: str): -# """Docstring""" -# return da.resample(time=freq).mean(keep_attrs=True) - - -# uniIndPr = Daily( -# realm="atmos", -# identifier="prmax", -# cf_attrs=[dict(units="mm/s")], -# context="hydro", -# module="test", -# compute=uniindpr_compute, -# ) - - -# @declare_units(da="[temperature]") -# def uniclim_compute(da: xr.DataArray, freq="YS", **indexer): -# select = select_time(da, **indexer) -# return select.mean(dim="time", keep_attrs=True).expand_dims("time") - - -# uniClim = ResamplingIndicator( -# src_freq="D", -# realm="atmos", -# identifier="clim", -# cf_attrs=[dict(units="K")], -# module="test", -# compute=uniclim_compute, -# ) - - -# @declare_units(tas="[temperature]") -# def multitemp_compute(tas: xr.DataArray, freq: str): -# return ( -# tas.resample(time=freq).min(keep_attrs=True), -# tas.resample(time=freq).max(keep_attrs=True), -# ) - - -# multiTemp = Daily( -# realm="atmos", -# identifier="minmaxtemp", -# cf_attrs=[ -# dict( -# var_name="tmin", -# units="K", -# standard_name="Min temp", -# description="Grouped computation of tmax and tmin", -# ), -# dict( -# var_name="tmax", -# units="K", -# description="Grouped computation of tmax and tmin", -# ), -# ], -# module="test", -# compute=multitemp_compute, -# ) - - -# @declare_units(tas="[temperature]", tasmin="[temperature]", tasmax="[temperature]") -def multioptvar_compute( - tas: xr.DataArray | None = None, - tasmax: xr.DataArray | None = None, - tasmin: xr.DataArray | None = None, -): - if tas is None: - tasmax = convert_units_to(tasmax, tasmin) - return ((tasmin + tasmax) / 2).assign_attrs(units=tasmin.units) - return tas - - -MultiOptVar = Indicator( - src_freq="D", - realm="atmos", - identifier="multiopt", - cf_attrs=[dict(units="K")], - module="test", - compute=multioptvar_compute, -) - - -# def test_attrs(tas_series): -# import datetime as dt - -# a = tas_series(np.arange(360.0)) -# txm = uniIndTemp(a, thresh="5 degC", freq="YS") -# assert txm.cell_methods == "time: mean time: mean within years" -# assert f"{dt.datetime.now():%Y-%m-%d %H}" in txm.attrs["history"] -# assert ( -# "TMIN(da=tas, thresh='5 degC', freq='YS') with options check_missing=any" -# in txm.attrs["history"] -# ) -# assert f"xclim version: {__version__}" in txm.attrs["history"] -# assert txm.name == "tmin5 degC" -# assert uniIndTemp.standard_name == "{freq} mean temperature" -# assert uniIndTemp.cf_attrs[0]["another_attr"] == "With a value." - -# thresh = xr.DataArray( -# [1], -# dims=("adim",), -# coords={"adim": [1]}, -# attrs={"long_name": "A thresh", "units": "degC"}, -# name="TT", -# ) -# txm = uniIndTemp(a, thresh=thresh, freq="YS") -# assert ( -# "TMIN(da=tas, thresh=TT, freq='YS') with options check_missing=any" -# in txm.attrs["history"] -# ) -# assert txm.attrs["long_name"].endswith("with <an array> threshold.") - - -@pytest.mark.parametrize( - "xcopt,xropt,exp", - [ - ("xarray", "default", False), - (True, False, True), - (False, True, False), - ("xarray", True, True), - ], -) -def test_keep_attrs(timelonlatseries, xcopt, xropt, exp): - tx = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) - tn = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) - tx.attrs.update(something="blabla", bing="bang", foo="bar") - tn.attrs.update(something="blabla", bing="bong") - with set_options(keep_attrs=xcopt): - with xr.set_options(keep_attrs=xropt): - tg = MultiOptVar(tasmin=tn, tasmax=tx) - assert (tg.attrs.get("something") == "blabla") is exp - assert (tg.attrs.get("foo") == "bar") is exp - assert "bing" not in tg.attrs - - -def test_as_dataset(timelonlatseries): - tx = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) - tn = timelonlatseries(np.arange(360.0), attrs={"units": "K"}) - tx.attrs.update(something="blabla", bing="bang", foo="bar") - tn.attrs.update(something="blabla", bing="bong") - dsin = xr.Dataset({"tasmax": tx, "tasmin": tn}, attrs={"fou": "barre"}) - with set_options(keep_attrs=True, as_dataset=True): - dsout = MultiOptVar(ds=dsin) - assert isinstance(dsout, xr.Dataset) - assert dsout.attrs["fou"] == "barre" - assert dsout.multiopt.attrs.get("something") == "blabla" - - -# def test_as_dataset_multi(tas_series): -# tg = tas_series(np.arange(360.0)) -# with set_options(as_dataset=True): -# dsout = multiTemp(tas=tg, freq="YS") -# assert isinstance(dsout, xr.Dataset) -# assert "tmin" in dsout.data_vars -# assert "tmax" in dsout.data_vars - - -def test_opt_vars(timelonlatseries): - tn = timelonlatseries(np.zeros(365), attrs={"units": "K"}) - tx = timelonlatseries(np.zeros(365), attrs={"units": "K"}) - - MultiOptVar(tasmin=tn, tasmax=tx) - assert MultiOptVar.parameters["tasmin"].kind == InputKind.OPTIONAL_VARIABLE - - -# FIXME -# def test_registering(): -# assert "test.TMIN" in registry - -# # Because this has not been instantiated, it's not in any registry. -# class Test123(registry["test.TMIN"]): -# identifier = "test123" - -# assert "test.TEST123" not in registry -# Test123(module="test") -# assert "test.TEST123" in registry - -# # Confirm registries live in subclasses. -# class IndicatorNew(Indicator): -# pass - -# # Identifier must be given -# with pytest.raises(AttributeError, match="has not been set."): -# IndicatorNew() - -# # Realm must be given -# with pytest.raises(AttributeError, match="realm must be given"): -# IndicatorNew(identifier="i2d") - -# indnew = IndicatorNew(identifier="i2d", realm="atmos", module="test") -# assert "test.I2D" in registry -# assert registry["test.I2D"].get_instance() is indnew - -# del indnew -# gc.collect() -# with pytest.raises(ValueError, match="There is no existing instance"): -# registry["test.I2D"].get_instance() - - -# def test_module(): -# """Translations are keyed according to the module where the indicators are defined.""" -# assert atmos.tg_mean.__module__.split(".")[2] == "atmos" -# # Virtual module also are stored under xclim.indicators -# assert xclim.indicators.cf.fg.__module__ == "xclim.indicators.cf" # noqa: F821 -# assert ( -# xclim.indicators.icclim.GD4.__module__ == "xclim.indicators.icclim" -# ) # noqa: F821 - - -# def test_temp_unit_conversion(tas_series): -# a = tas_series(np.arange(365), start="2001-01-01") -# txk = uniIndTemp(a, freq="YS") - -# # This is not supposed to work -# uniIndTemp.units = "degC" -# txc = uniIndTemp(a, freq="YS") -# with pytest.raises(AssertionError): -# np.testing.assert_array_almost_equal(txk, txc + 273.15) - -# uniIndTemp.cf_attrs[0]["units"] = "degC" -# txc = uniIndTemp(a, freq="YS") -# np.testing.assert_array_almost_equal(txk, txc + 273.15) - - -# def test_multiindicator(tas_series): -# tas = tas_series(np.arange(366), start="2000-01-01") -# tmin, tmax = multiTemp(tas, freq="YS") - -# assert tmin[0] == tas.min() -# assert tmax[0] == tas.max() -# assert tmin.attrs["standard_name"] == "Min temp" -# assert tmin.attrs["description"] == "Grouped computation of tmax and tmin" -# assert tmax.attrs["description"] == "Grouped computation of tmax and tmin" -# assert multiTemp.units == ["K", "K"] - -# # Attrs passed as keywords - together -# ind = Daily( -# realm="atmos", -# identifier="minmaxtemp2", -# cf_attrs=[ -# dict( -# var_name="tmin", -# units="K", -# standard_name="Min temp", -# description="Grouped computation of tmax and tmin", -# ), -# dict( -# var_name="tmax", -# units="K", -# description="Grouped computation of tmax and tmin", -# ), -# ], -# compute=multitemp_compute, -# ) -# tmin, tmax = ind(tas, freq="YS") -# assert tmin[0] == tas.min() -# assert tmax[0] == tas.max() -# assert tmin.attrs["standard_name"] == "Min temp" -# assert tmin.attrs["description"] == "Grouped computation of tmax and tmin" -# assert tmax.attrs["description"] == "Grouped computation of tmax and tmin" - -# with pytest.raises(ValueError, match="Output #2 is missing a var_name!"): -# ind = Daily( -# realm="atmos", -# identifier="minmaxtemp2", -# cf_attrs=[ -# dict( -# var_name="tmin", -# units="K", -# ), -# dict( -# units="K", -# ), -# ], -# compute=multitemp_compute, -# ) - -# # Attrs passed as keywords - individually -# ind = Daily( -# realm="atmos", -# identifier="minmaxtemp3", -# var_name=["tmin", "tmax"], -# units="K", -# standard_name=["Min temp", ""], -# description="Grouped computation of tmax and tmin", -# compute=multitemp_compute, -# ) -# tmin, tmax = ind(tas, freq="YS") -# assert tmin[0] == tas.min() -# assert tmax[0] == tas.max() -# assert tmin.attrs["standard_name"] == "Min temp" -# assert tmin.attrs["description"] == "Grouped computation of tmax and tmin" -# assert tmax.attrs["description"] == "Grouped computation of tmax and tmin" -# assert ind.units == ["K", "K"] - -# # All must be the same length -# with pytest.raises(ValueError, match="Attribute var_name has 2 elements"): -# ind = Daily( -# realm="atmos", -# identifier="minmaxtemp3", -# var_name=["tmin", "tmax"], -# units="K", -# standard_name=["Min temp"], -# description="Grouped computation of tmax and tmin", -# compute=uniindpr_compute, -# ) - -# ind = Daily( -# realm="atmos", -# identifier="minmaxtemp4", -# var_name=["tmin", "tmax"], -# units="K", -# standard_name=["Min temp", ""], -# description="Grouped computation of tmax and tmin", -# compute=uniindtemp_compute, -# ) -# with pytest.raises(ValueError, match="Indicator minmaxtemp4 was wrongly defined"): -# _tmin, _tmax = ind(tas, freq="YS") - - -# def test_missing(tas_series): -# a = tas_series(np.ones(365, float), start="1/1/2000") - -# # By default, missing is set to "from_context", and the default missing option is "any" -# # Cannot set missing_options with "from_context" -# with pytest.raises(ValueError, match="Cannot set `missing_options`"): -# uniClim.__class__(missing_options={"tolerance": 0.01}) - -# # Null value -# a[5] = np.nan - -# m = uniIndTemp(a, freq="MS") -# assert m[0].isnull() - -# with set_options( -# check_missing="pct", missing_options={"pct": {"tolerance": 0.05}} -# ): -# m = uniIndTemp(a, freq="MS") -# assert not m[0].isnull() -# assert "check_missing=pct, missing_options={'tolerance': 0.05}" in m.history - -# with set_options(check_missing="wmo"): -# m = uniIndTemp(a, freq="YS") -# assert m[0].isnull() - -# # With freq=None -# c = uniClim(a) -# assert c.isnull() - -# # With indexer -# ci = uniClim(a, month=[2]) -# assert not ci.isnull() - -# out = uniClim(a, month=[1]) -# assert out.isnull() - - -# def test_missing_from_context(tas_series): -# a = tas_series(np.ones(365, float), start="1/1/2000") -# # Null value -# a[5] = np.nan - -# ind = uniIndTemp.__class__(missing="from_context") - -# m = ind(a, freq="MS") -# assert m[0].isnull() - - -# def test_json(timeseries): -# meta = uniIndPr.json() - -# expected = { -# "identifier", -# "title", -# "keywords", -# "abstract", -# "parameters", -# "history", -# "references", -# "notes", -# "outputs", -# } - -# output_exp = { -# "var_name", -# "units", -# "long_name", -# "standard_name", -# "cell_methods", -# "description", -# "comment", -# } - -# assert set(meta.keys()).issubset(expected) -# for output in meta["outputs"]: -# assert set(output.keys()).issubset(output_exp) - - -# def test_all_jsonable(official_indicators): -# problems = [] -# err = None -# for identifier, ind in official_indicators.items(): -# indinst = ind.get_instance() -# json.dumps(indinst.json()) -# try: -# json.dumps(indinst.json()) -# except (KeyError, TypeError) as e: -# problems.append(identifier) -# err = e -# if problems: -# raise ValueError( -# f"Indicators {problems} provide problematic json serialization.: {err}" -# ) - - -# def test_all_parameters_understood(official_indicators): -# problems = set() -# for identifier, ind in official_indicators.items(): -# indinst = ind.get_instance() -# for name, param in indinst.parameters.items(): -# if param.kind == InputKind.OTHER_PARAMETER: -# problems.add((identifier, name)) -# # this one we are ok with. -# if problems - { -# ("COOL_NIGHT_INDEX", "lat"), -# ("DRYNESS_INDEX", "lat"), -# # TODO: How should we handle the case of Literal[str]? -# ("GROWING_SEASON_END", "op"), -# ("GROWING_SEASON_START", "op"), -# }: -# raise ValueError( -# f"The following indicator/parameter couple {problems} use types not listed in InputKind." -# ) - - -# def test_signature(): -# sig = signature(xclim.atmos.solid_precip_accumulation) -# assert list(sig.parameters.keys()) == [ -# "pr", -# "tas", -# "thresh", -# "freq", -# "ds", -# "indexer", -# ] -# assert sig.parameters["pr"].annotation == Union[xr.DataArray, str] -# assert sig.parameters["tas"].default == "tas" -# assert sig.parameters["tas"].kind == sig.parameters["tas"].POSITIONAL_OR_KEYWORD -# assert sig.parameters["thresh"].kind == sig.parameters["thresh"].KEYWORD_ONLY -# assert sig.return_annotation == xr.DataArray - -# sig = signature(xclim.atmos.wind_speed_from_vector) -# assert sig.return_annotation == tuple[xr.DataArray, xr.DataArray] - - -# def test_doc(): -# doc = xclim.atmos.cffwis_indices.__doc__ -# assert doc.startswith("Canadian Fire Weather Index System indices. (realm: atmos)") -# assert "This indicator will check for missing values according to the method" in doc -# assert ( -# "Based on indice :py:func:`~xclim.indices.fire._cffwis.cffwis_indices`." in doc -# ) -# assert "ffmc0 : str or DataArray, optional" in doc -# assert "Returns\n-------" in doc -# assert "See :cite:t:`code-natural_resources_canada_data_nodate`, " in doc -# assert "the :py:mod:`xclim.indices.fire` module documentation," in doc -# assert ( -# "and the docstring of :py:func:`fire_weather_ufunc` for more information." -# in doc -# ) - - -# def test_delayed(tasmax_series): -# tasmax = tasmax_series(np.arange(360.0)).chunk({"time": 5}) -# out = uniIndTemp(tasmax) -# assert isinstance(out.data, dask.array.Array) - - -# def test_identifier(): -# with pytest.warns(UserWarning): -# uniIndPr.__class__(identifier="t_{}") - - -# def test_formatting(pr_series): -# out = atmos.wetdays(pr_series(np.arange(366)), thresh=1.0 * units.mm / units.day) -# # pint 0.10 now pretty print day as d. -# assert ( -# out.attrs["long_name"] -# == "Number of days with daily precipitation at or above 1 mm/d" -# ) -# assert out.attrs["description"] in [ -# "Annual number of days with daily precipitation at or above 1 mm/d." -# ] -# out = atmos.wetdays(pr_series(np.arange(366)), thresh=1.5 * units.mm / units.day) -# assert ( -# out.attrs["long_name"] -# == "Number of days with daily precipitation at or above 1.5 mm/d" -# ) -# assert out.attrs["description"] in [ -# "Annual number of days with daily precipitation at or above 1.5 mm/d." -# ] - - -# def test_parse_doc(): -# doc = parse_doc(tg_mean.__doc__) -# assert doc["title"] == "Mean of daily average temperature." -# assert ( -# doc["abstract"] -# == "Resample the original daily mean temperature series by taking the mean over each period." -# ) -# assert doc["parameters"]["tas"]["description"] == "Mean daily temperature." -# assert doc["parameters"]["freq"]["description"] == "Resampling frequency." -# assert doc["notes"].startswith("Let") -# assert "math::" in doc["notes"] -# assert "references" not in doc -# assert doc["long_name"] == "The mean daily temperature at the given time frequency" - -# doc = parse_doc(xclim.indices.saturation_vapor_pressure.__doc__) -# assert ( -# doc["parameters"]["ice_thresh"]["description"] -# == "Threshold temperature under which to switch to equations in reference to ice instead of water. " -# "If None (default) everything is computed with reference to water." -# ) -# assert "goff_low-pressure_1946" in doc["references"] - - -# def test_parsed_doc(): -# assert "tas" in xclim.atmos.liquid_precip_accumulation.parameters - -# params = xclim.atmos.drought_code.parameters -# assert params["tas"].description == "Noon temperature." -# assert params["tas"].units == "[temperature]" -# assert params["tas"].kind is InputKind.VARIABLE -# assert params["tas"].default == "tas" -# assert params["snd"].default is None -# assert params["snd"].kind is InputKind.OPTIONAL_VARIABLE -# assert params["snd"].units == "[length]" -# assert params["season_method"].kind is InputKind.STRING -# assert params["season_method"].choices == {"GFWED", None, "WF93", "LA08"} - -# params = xclim.atmos.standardized_precipitation_evapotranspiration_index.parameters -# assert params["fitkwargs"].kind is InputKind.DICT - - -def test_default_formatter(): - assert default_formatter.format("{freq}", freq="YS") == "annual" - assert default_formatter.format("{freq:noun}", freq="MS") == "months" - assert default_formatter.format("{month}", month="m3") == "march" - - -def test_attr_formatter(): - fmt = AttrFormatter( - mapping={"evil": ["méchant", "méchante"], "nice": ["beau", "belle"]}, - modifiers=["m", "f"], - ) - # Normal cases - assert fmt.format("{adj:m}", adj="evil") == "méchant" - assert fmt.format("{adj:f}", adj="nice") == "belle" - # Missing mod: - assert fmt.format("{adj}", adj="evil") == "méchant" - # Mod with unknown value - with pytest.warns(match="Requested formatting `m` for unknown string `funny`."): - fmt.format("{adj:m}", adj="funny") - - -@pytest.mark.parametrize("new_line", ["<>", "\n"]) -@pytest.mark.parametrize("missing_str", ["<Missing>", None]) -def test_merge_attributes(missing_str, new_line): - a = xr.DataArray([0], attrs={"text": "Text1"}, name="a") - b = xr.DataArray([0], attrs={}) - c = xr.Dataset(attrs={"text": "Text3"}) - - merged = merge_attributes( - "text", a, missing_str=missing_str, new_line=new_line, b=b, c=c - ) - - assert merged.startswith("a: Text1") - - if missing_str is not None: - assert merged.count(new_line) == 2 - assert f"b: {missing_str}" in merged - else: - assert merged.count(new_line) == 1 - assert "b:" not in merged - - -def test_update_history(): - a = xr.DataArray([0], attrs={"history": "Text1"}, name="a") - b = xr.DataArray([0], attrs={"history": "Text2"}) - c = xr.Dataset(attrs={"history": "Text3"}) - - merged = update_history("text", a, new_name="d", b=b, c=c) - - assert "d: text" in merged.split("\n")[-1] - assert merged.startswith("a: Text1") - - -# def test_input_dataset(open_dataset): -# ds = open_dataset("ERA5/daily_surface_cancities_1990-1993.nc") - -# # Use defaults -# _ = xclim.atmos.daily_temperature_range(freq="YS", ds=ds) - -# # Use non-defaults (inverted on purpose) -# with set_options(cf_compliance="log"): -# _ = xclim.atmos.daily_temperature_range("tasmax", "tasmin", freq="YS", ds=ds) - -# # Use a mix -# _ = xclim.atmos.daily_temperature_range(tasmax=ds.tasmax, freq="YS", ds=ds) - -# # Inexistent variable: -# dsx = ds.drop_vars("tasmin") -# with pytest.raises(MissingVariableError): -# out = xclim.atmos.daily_temperature_range(freq="YS", ds=dsx) - -# # dataset not given -# with pytest.raises(ValueError): -# xclim.atmos.daily_temperature_range(tasmax="tmax") - - -# def test_indicator_from_dict(): -# d = dict( -# realm="atmos", -# cf_attrs=dict( -# var_name="tmean{threshold}", -# units="K", -# long_name="{freq} mean surface temperature", -# standard_name="{freq} mean temperature", -# cell_methods=[{"time": "mean within days"}], -# ), -# compute="thresholded_statistics", -# parameters=dict( -# threshold={"description": "A threshold temp"}, -# op="<", -# reducer="mean", -# ), -# input={"data": "tas"}, -# ) - -# ind = Daily.from_dict(d, identifier="tmean", module="test") - -# assert ind.realm == "atmos" -# # Parameters metadata modification -# assert ind.parameters["threshold"].description == "A threshold temp" -# # Injection of parameters -# assert ind.injected_parameters["op"] == "<" -# # Default value for input variable injected and meta injected -# assert ind._variable_mapping["data"] == "tas" -# assert signature(ind).parameters["tas"].default == "tas" -# assert ind.parameters["tas"].units == "[temperature]" - -# # Wrap a multi-output ind -# d = dict(base="wind_speed_from_vector") -# Indicator.from_dict(d, identifier="wsfv", module="test") - - -# def test_indicator_errors(): -# def func(data: xr.DataArray, thresh: str = "0 degC", freq: str = "YS"): -# return data - -# doc = [ -# "The title", -# "", -# " The abstract", -# "", -# " Parameters", -# " ----------", -# " data : xr.DataArray", -# " A variable.", -# " thresh : str", -# " A threshold", -# " freq : str", -# " The resampling frequency.", -# "", -# " Returns", -# " -------", -# " xr.DataArray, [K]", -# " An output", -# ] -# func.__doc__ = "\n".join(doc) - -# d = dict( -# realm="atmos", -# cf_attrs=dict( -# var_name="tmean{threshold}", -# units="K", -# long_name="{freq} mean surface temperature", -# standard_name="{freq} mean temperature", -# cell_methods=[{"time": "mean within days"}], -# ), -# compute=func, -# input={"data": "tas"}, -# ) -# ind = Daily(identifier="indi", module="test", **d) - -# with pytest.raises(AttributeError, match="`identifier` has not been set"): -# Daily(**d) - -# d["identifier"] = "bad_indi" -# d["module"] = "test" - -# bad_doc = doc[:12] + [" extra: bool", " Woupsi"] + doc[12:] -# func.__doc__ = "\n".join(bad_doc) -# with pytest.raises(ValueError, match="Malformed docstring"): -# Daily(**d) - -# func.__doc__ = "\n".join(doc) -# d["parameters"] = {} -# d["parameters"]["thresh"] = "1 degK" -# d["parameters"]["extra"] = "woopsi again" -# with pytest.raises(ValueError, match="Parameter 'extra' was passed but it does"): -# Daily(**d) - -# del d["parameters"]["extra"] -# d["input"]["data"] = "3nsd6sk72" -# with pytest.raises(ValueError, match="Compute argument data was mapped to"): -# Daily(**d) - -# d2 = dict(input={"tas": "sfcWind"}) -# with pytest.raises(ValueError, match="When changing the name of a variable by"): -# ind.__class__(**d2) - -# del d["input"] -# # with pytest.raises(ValueError, match="variable data is missing expected units"): -# # Daily(**d) - -# d["parameters"]["thresh"] = {"units": "K"} -# d["realm"] = "mercury" -# d["input"] = {"data": "tasmin"} -# with pytest.raises(AttributeError, match="Indicator's realm must be given as one"): -# Daily(**d) - -# def func(data: xr.DataArray, thresh: str = "0 degC"): -# return data - -# func.__doc__ = "\n".join(doc[:10] + doc[12:]) -# d = dict( -# realm="atmos", -# cf_attrs=dict( -# var_name="tmean{threshold}", -# units="K", -# long_name="{freq} mean surface temperature", -# standard_name="{freq} mean temperature", -# cell_methods=[{"time": "mean within days"}], -# ), -# compute=func, -# input={"data": "tas"}, -# ) -# with pytest.raises(ValueError, match="ResamplingIndicator require a 'freq'"): -# Daily(identifier="indi", module="test", **d) - - -# def test_indicator_call_errors(timeseries): -# tas = timeseries(np.arange(730), start="2001-01-01", units="K") -# uniIndTemp(da=tas, thresh="3 K") - -# with pytest.raises(TypeError, match="too many positional arguments"): -# uniIndTemp(tas, tas) - -# with pytest.raises(TypeError, match="got an unexpected keyword argument 'oups'"): -# uniIndTemp(tas, oups=3) - - -# def test_resamplingIndicator_new_error(): -# with pytest.raises(ValueError, match="ResamplingIndicator require a 'freq'"): -# Daily( -# realm="atmos", -# identifier="multiopt", -# cf_attrs=[dict(units="K")], -# module="test", -# compute=multioptvar_compute, -# ) - - -def test_resampling_indicator_with_indexing(timeseries): - tas = timeseries(np.ones(731) + 273.15, start="2003-01-01") - out = (tas > 273.15).resample(time="YS").sum() - # out = xclim.atmos.tx_days_above(tas, thresh="0 degC", freq="YS") - np.testing.assert_allclose(out, [365, 366]) - - # out = xclim.atmos.tx_days_above(tas, thresh="0 degC", freq="YS", month=2) - # np.testing.assert_allclose(out, [28, 29]) - - # out = xclim.atmos.tx_days_above( - # tas, thresh="0 degC", freq="YS-JUL", doy_bounds=(1, 50) - # ) - # np.testing.assert_allclose(out, [50, 50, np.NaN]) - - # out = xclim.atmos.tx_days_above( - # tas, thresh="0 degC", freq="YS", date_bounds=("02-29", "04-01") - # ) - # np.testing.assert_allclose(out, [32, 33]) - - -# def test_all_inputs_known(): -# var_and_inds = list_input_variables() -# known_vars = ( -# set(var_and_inds.keys()) -# - { -# "dc0", -# "season_mask", -# "ffmc0", -# "dmc0", -# "kbdi0", -# "drought_factor", -# } # FWI optional inputs -# - {var for var in var_and_inds.keys() if var.endswith("_per")} # percentiles -# - {"pr_annual", "pr_cal", "wb_cal"} # other optional or uncommon -# - {"q", "da"} # Generic inputs -# - {"mrt", "wb"} # TODO: add Mean Radiant Temperature and water budget -# ) -# # if not set(VARIABLES.keys()).issuperset(known_vars): -# # raise AssertionError( -# # "All input variables of xclim indicators must be registered in " -# # "data/variables.yml, or skipped explicitly in this test. " -# # f"The yaml file is missing: {known_vars - VARIABLES.keys()}." -# # ) - - -# def test_freq_doc(): -# from xclim import atmos - -# doc = atmos.latitude_temperature_index.__doc__ -# allowed_periods = ["A"] -# exp = f"Restricted to frequencies equivalent to one of {allowed_periods}" -# assert exp in doc diff --git a/tests/test_processing.py b/tests/test_processing.py index 0ed0adb..865d139 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -215,15 +215,15 @@ def test_to_additive(timeseries): pr = timeseries(np.array([0, 1e-5, 1, np.e**10]), units="kg m^-2 s^-1") prlog = to_additive_space(pr, lower_bound="0 kg m^-2 s^-1", trans="log") np.testing.assert_allclose(prlog, [-np.Inf, -11.512925, 0, 10]) - assert prlog.attrs["sdba_transform"] == "log" - assert prlog.attrs["sdba_transform_units"] == "kg m^-2 s^-1" + assert prlog.attrs["xsdba_transform"] == "log" + assert prlog.attrs["xsdba_transform_units"] == "kg m^-2 s^-1" with xr.set_options(keep_attrs=True): pr1 = pr + 1 lower_bound = "1 kg m^-2 s^-1" prlog2 = to_additive_space(pr1, trans="log", lower_bound=lower_bound) np.testing.assert_allclose(prlog2, [-np.Inf, -11.512925, 0, 10]) - assert prlog2.attrs["sdba_transform_lower"] == 1.0 + assert prlog2.attrs["xsdba_transform_lower"] == 1.0 # logit hurs = timeseries(np.array([0, 1e-3, 90, 100]), units="%") @@ -234,8 +234,8 @@ def test_to_additive(timeseries): np.testing.assert_allclose( hurslogit, [-np.Inf, -11.5129154649, 2.197224577, np.Inf] ) - assert hurslogit.attrs["sdba_transform"] == "logit" - assert hurslogit.attrs["sdba_transform_units"] == "%" + assert hurslogit.attrs["xsdba_transform"] == "logit" + assert hurslogit.attrs["xsdba_transform_units"] == "%" with xr.set_options(keep_attrs=True): hursscl = hurs * 4 + 200 @@ -245,8 +245,8 @@ def test_to_additive(timeseries): np.testing.assert_allclose( hurslogit2, [-np.Inf, -11.5129154649, 2.197224577, np.Inf] ) - assert hurslogit2.attrs["sdba_transform_lower"] == 200.0 - assert hurslogit2.attrs["sdba_transform_upper"] == 600.0 + assert hurslogit2.attrs["xsdba_transform_lower"] == 200.0 + assert hurslogit2.attrs["xsdba_transform_upper"] == 600.0 def test_from_additive(timeseries): From a69dd31a96fa5fcac91551abb89e637a347a77e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Mon, 7 Oct 2024 14:58:27 -0400 Subject: [PATCH 083/105] add pint2cfunits and netcdf4 dependency --- pyproject.toml | 1 + src/xsdba/units.py | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index b9f2092..ebfd8f7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -63,6 +63,7 @@ dev = [ "coverage >=7.5.0", "coveralls >=4.0.1", "mypy", + "netcdf4", "numpydoc >=1.8.0; python_version >='3.9'", "pytest <8.0.0", "pytest-cov >=5.0.0", diff --git a/src/xsdba/units.py b/src/xsdba/units.py index f77f034..7e79c10 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -287,6 +287,26 @@ def ensure_cf_units(ustr: str) -> str: return pint2cfunits(units2pint(ustr)) +def pint2cfunits(value: units.Quantity | units.Unit) -> str: + """Return a CF-compliant unit string from a `pint` unit. + + Parameters + ---------- + value : pint.Unit + Input unit. + + Returns + ------- + str + Units following CF-Convention, using symbols. + """ + if isinstance(value, pint.Quantity | units.Quantity): + value = value.units + + # Force "1" if the formatted string is "" (pint < 0.24) + return f"{value:~cf}" or "1" + + def ensure_delta(unit: str) -> str: """Return delta units for temperature. From 8e22153dc3076bfb78bff287e2e217de1eda0804 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Mon, 7 Oct 2024 17:52:43 -0400 Subject: [PATCH 084/105] remove `sdba-` in references --- src/xsdba/adjustment.py | 18 +++++++++--------- src/xsdba/loess.py | 8 ++++---- src/xsdba/processing.py | 10 +++++----- src/xsdba/utils.py | 14 +++++++------- 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 4ecbb2b..3e3bfec 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -412,7 +412,7 @@ class EmpiricalQuantileMapping(TrainAdjust): References ---------- - :cite:cts:`sdba-deque_frequency_2007` + :cite:cts:`deque_frequency_2007` """ _allow_diff_calendars = False @@ -511,7 +511,7 @@ class DetrendedQuantileMapping(TrainAdjust): References ---------- - :cite:cts:`sdba-cannon_bias_2015` + :cite:cts:`cannon_bias_2015` """ _allow_diff_calendars = False @@ -622,7 +622,7 @@ class QuantileDeltaMapping(EmpiricalQuantileMapping): References ---------- - :cite:cts:`sdba-cannon_bias_2015` + :cite:cts:`cannon_bias_2015` """ def _adjust(self, sim, interp="nearest", extrapolation="constant"): @@ -716,8 +716,8 @@ class ExtremeValues(TrainAdjust): References ---------- - :cite:cts:`sdba-roy_juliaclimateclimatetoolsjl_2021` - :cite:cts:`sdba-roy_extremeprecip_2023` + :cite:cts:`roy_juliaclimateclimatetoolsjl_2021` + :cite:cts:`roy_extremeprecip_2023` """ @classmethod @@ -839,7 +839,7 @@ class LOCI(TrainAdjust): References ---------- - :cite:cts:`sdba-schmidli_downscaling_2006` + :cite:cts:`schmidli_downscaling_2006` """ _allow_diff_calendars = False @@ -984,7 +984,7 @@ class PrincipalComponents(TrainAdjust): References ---------- - :cite:cts:`sdba-hnilica_multisite_2017,sdba-alavoine_distinct_2022` + :cite:cts:`hnilica_multisite_2017,sdba-alavoine_distinct_2022` """ @classmethod @@ -1184,7 +1184,7 @@ class NpdfTransform(Adjust): References ---------- - :cite:cts:`sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` + :cite:cts:`cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` """ @classmethod @@ -1367,7 +1367,7 @@ class MBCn(TrainAdjust): References ---------- - :cite:cts:`sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` + :cite:cts:`cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` Notes ----- diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py index 057d400..4cf1f53 100644 --- a/src/xsdba/loess.py +++ b/src/xsdba/loess.py @@ -86,9 +86,9 @@ def _loess_nb( References ---------- - :cite:cts:`sdba-cleveland_robust_1979` + :cite:cts:`cleveland_robust_1979` - Code adapted from: :cite:cts:`sdba-gramfort_lowess_2015` + Code adapted from: :cite:cts:`gramfort_lowess_2015` """ if skipna: nan = np.isnan(y) @@ -232,9 +232,9 @@ def loess_smoothing( References ---------- - :cite:cts:`sdba-cleveland_robust_1979` + :cite:cts:`cleveland_robust_1979` - Code adapted from: :cite:cts:`sdba-gramfort_lowess_2015` + Code adapted from: :cite:cts:`gramfort_lowess_2015` """ x = da[dim] x = ((x - x[0]) / (x[-1] - x[0])).astype(float) diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 2faaaa6..3ffdd6f 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -92,7 +92,7 @@ def adapt_freq( References ---------- - :cite:cts:`sdba-themesl_empirical-statistical_2012` + :cite:cts:`themesl_empirical-statistical_2012` """ out = _adapt_freq(xr.Dataset(dict(sim=sim, ref=ref)), group=group, thresh=thresh) @@ -369,7 +369,7 @@ def reordering(ref: xr.DataArray, sim: xr.DataArray, group: str = "time") -> xr. References ---------- - :cite:cts:`sdba-cannon_multivariate_2018`. + :cite:cts:`cannon_multivariate_2018`. """ ds = xr.Dataset({"sim": sim, "ref": ref}) out: xr.Dataset = _reordering(ds, group=group).reordered @@ -435,7 +435,7 @@ def escore( References ---------- - :cite:cts:`sdba-baringhaus_new_2004,sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-szekely_testing_2004`. + :cite:cts:`baringhaus_new_2004,sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-szekely_testing_2004`. """ pts_dim, obs_dim = dims @@ -554,7 +554,7 @@ def to_additive_space( References ---------- - :cite:cts:`sdba-alavoine_distinct_2022`. + :cite:cts:`alavoine_distinct_2022`. """ # with units.context(infer_context(data.attrs.get("standard_name"))): lower_bound_array = np.array(lower_bound).astype(float) @@ -650,7 +650,7 @@ def from_additive_space( References ---------- - :cite:cts:`sdba-alavoine_distinct_2022`. + :cite:cts:`alavoine_distinct_2022`. """ if trans is None and lower_bound is None and units is None: try: diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index e977fa6..2b23ea1 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -642,7 +642,7 @@ def best_pc_orientation_simple( References ---------- - :cite:cts:`sdba-hnilica_multisite_2017` + :cite:cts:`hnilica_multisite_2017` """ m = R.shape[0] P = np.diag(val * np.ones(m)) @@ -691,7 +691,7 @@ def best_pc_orientation_full( References ---------- - :cite:cts:`sdba-alavoine_distinct_2022` + :cite:cts:`alavoine_distinct_2022` See Also -------- @@ -735,7 +735,7 @@ def get_clusters_1d( References ---------- - `getcluster` of Extremes.jl (:cite:cts:`sdba-jalbert_extreme_2022`). + `getcluster` of Extremes.jl (:cite:cts:`jalbert_extreme_2022`). """ # Boolean array, True where data is over u2 # We pad with values under u2, so that clusters never start or end at boundaries. @@ -876,7 +876,7 @@ def rand_rot_matrix( References ---------- - :cite:cts:`sdba-mezzadri_how_2007` + :cite:cts:`mezzadri_how_2007` """ if num > 1: return xr.concat([rand_rot_matrix(crd, num=1) for i in range(num)], "matrices") @@ -971,7 +971,7 @@ def bin_width_estimator(X): References ---------- - :cite:cts:`sdba-robin_2021` + :cite:cts:`robin_2021` """ if isinstance(X, list): return np.min([bin_width_estimator(x) for x in X], axis=0) @@ -1019,7 +1019,7 @@ def optimal_transport(gridX, gridY, muX, muY, num_iter_max, normalization): References ---------- - :cite:cts:`sdba-robin_2021` + :cite:cts:`robin_2021` """ try: from ot import emd # pylint: disable=import-outside-toplevel @@ -1060,7 +1060,7 @@ def eps_cholesky(M, nit=26): References ---------- - :cite:cts:`sdba-robin_2021,sdba-higham_1988,sdba-knol_1989` + :cite:cts:`robin_2021,sdba-higham_1988,sdba-knol_1989` """ MC = None try: From 12e02d1c118474fe4a1c904817ccecf5b5f85bb7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Mon, 21 Oct 2024 14:25:34 -0400 Subject: [PATCH 085/105] solve some docs problems, remove unused functions --- docs/api.rst | 81 +++++++++++++ docs/index.rst | 10 ++ docs/references.bib | 50 +++++++- docs/references.rst | 10 ++ docs/xsdba.rst | 10 +- src/xsdba/adjustment.py | 48 ++++---- src/xsdba/formatting.py | 257 ---------------------------------------- src/xsdba/locales.py | 3 +- src/xsdba/loess.py | 6 +- src/xsdba/processing.py | 18 +-- src/xsdba/typing.py | 3 +- src/xsdba/utils.py | 8 +- 12 files changed, 192 insertions(+), 312 deletions(-) create mode 100644 docs/api.rst create mode 100644 docs/references.rst diff --git a/docs/api.rst b/docs/api.rst new file mode 100644 index 0000000..a1c0c11 --- /dev/null +++ b/docs/api.rst @@ -0,0 +1,81 @@ +=== +API +=== + +.. _xsdba-user-api: + +xsdba Module +=========== + +.. automodule:: xsdba.adjustment + :members: + :exclude-members: BaseAdjustment + :special-members: + :show-inheritance: + :noindex: + +.. automodule:: xsdba.processing + :members: + :noindex: + +.. automodule:: xsdba.detrending + :members: + :show-inheritance: + :exclude-members: BaseDetrend + :noindex: + +.. automodule:: xsdba.utils + :members: + :noindex: + +.. autoclass:: xsdba.base.Grouper + :members: + :class-doc-from: init + :noindex: + +.. automodule:: xsdba.nbutils + :members: + :noindex: + +.. automodule:: xsdba.loess + :members: + :noindex: + +.. automodule:: xsdba.properties + :members: + :exclude-members: StatisticalProperty + :noindex: + +.. automodule:: xsdba.measures + :members: + :exclude-members: StatisticalMeasure + :noindex: + +.. _`xsdba-developer-api`: + +xsdba Utilities +-------------- + +.. automodule:: xsdba.base + :members: + :show-inheritance: + :exclude-members: Grouper + :noindex: + +.. autoclass:: xsdba.detrending.BaseDetrend + :members: + :noindex: + +.. autoclass:: xsdba.adjustment.TrainAdjust + :members: + :noindex: + +.. autoclass:: xsdba.adjustment.Adjust + :members: + :noindex: + +.. autofunction:: xsdba.properties.StatisticalProperty + :noindex: + +.. autofunction:: xsdba.measures.StatisticalMeasure + :noindex: diff --git a/docs/index.rst b/docs/index.rst index abda240..c33c563 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -13,6 +13,9 @@ Welcome to xsdba's documentation! releasing authors changelog + references + notebooks/example + notebooks/advanced_example .. toctree:: :maxdepth: 1 @@ -20,6 +23,13 @@ Welcome to xsdba's documentation! apidoc/modules + +.. toctree:: + :maxdepth: 2 + :caption: User API + + api + Indices and tables ================== * :ref:`genindex` diff --git a/docs/references.bib b/docs/references.bib index 735f687..ff6372d 100644 --- a/docs/references.bib +++ b/docs/references.bib @@ -37,7 +37,7 @@ @article{cannon_bias_2015 pages = {6938--6959}, } -@misc{cannon_mbc_2020, +@article{cannon_mbc_2020, title = {{MBC}: {Multivariate} {Bias} {Correction} of {Climate} {Model} {Outputs}}, copyright = {GPL-2}, shorttitle = {{MBC}}, @@ -62,7 +62,7 @@ @article{roy_extremeprecip_2023 year = {2023}, } -@misc{roy_juliaclimateclimatetoolsjl_2021, +@article{roy_juliaclimateclimatetoolsjl_2021, title = {{JuliaClimate}/{ClimateTools}.jl: v0.23.1}, shorttitle = {{JuliaClimate}/{ClimateTools}.jl}, url = {https://zenodo.org/record/5399172}, @@ -153,7 +153,7 @@ @article{szekely_testing_2004 year = {2004}, } -@misc{mezzadri_how_2007, +@article{mezzadri_how_2007, title = {How to generate random matrices from the classical compact groups}, url = {https://arxiv.org/abs/math-ph/0609050}, doi = {10.48550/arXiv.math-ph/0609050}, @@ -200,7 +200,7 @@ @article{cleveland_robust_1979 pages = {829--836}, } -@misc{gramfort_lowess_2015, +@article{gramfort_lowess_2015, title = {{LOWESS} : {Locally} weighted regression}, copyright = {BSD 3-Clause}, shorttitle = {{LOWESS}}, @@ -282,7 +282,7 @@ @article{francois_multivariate_2020 pages = {537--562}, } -@misc{jalbert_extreme_2022, +@article{jalbert_extreme_2022, title = {Extreme value analysis package for {Julia}.}, url = {https://github.com/jojal5/Extremes.jl}, abstract = {Extreme value analysis package for Julia}, @@ -430,3 +430,43 @@ @article{agbazo_characterizing_2020 keywords = {bias adjustment, climate simulations, physical inconsistency, univariate quantile mapping}, pages = {3868--3884}, } + + +@misc{robin_2021, + title = {{SBCK}: {Statistical} {Bias} {Correction} {Kit}}, + copyright = {GPL-3}, + shorttitle = {{SBCK}}, + url = {https://github.com/yrobink/SBCK-python}, + urldate = {2024-07-03}, + author = {Robin, Yoann}, + year = {2021}, +} + +@article{higham_1988, + title = {Computing a nearest symmetric positive semidefinite matrix}, + journal = {Linear Algebra and its Applications}, + volume = {103}, + pages = {103-118}, + year = {1988}, + issn = {0024-3795}, + doi = {https://doi.org/10.1016/0024-3795(88)90223-6}, + url = {https://www.sciencedirect.com/science/article/pii/0024379588902236}, + author = {Nicholas J. Higham}, + abstract = {The nearest symmetric positive semidefinite matrix in the Frobenius norm to an arbitrary real matrix A is shown to be (B + H)/2, where H is the symmetric polar factor of B=(A + AT)/2. In the 2-norm a nearest symmetric positive semidefinite matrix, and its distance δ2(A) from A, are given by a computationally challenging formula due to Halmos. We show how the bisection method can be applied to this formula to compute upper and lower bounds for δ2(A) differing by no more than a given amount. A key ingredient is a stable and efficient test for positive definiteness, based on an attempted Choleski decomposition. For accurate computation of δ2(A) we formulate the problem as one of zero finding and apply a hybrid Newton-bisection algorithm. Some numerical difficulties are discussed and illustrated by example.} +} + +@article{knol_1989, + title = "Least-squares approximation of an improper correlation matrix by a proper one", + abstract = "An algorithm is presented for the best least-squares fitting correlation matrix approximating a given missing value or improper correlation matrix. The proposed algorithm is based upon a solution for Mosier's oblique Procrustes rotation problem offered by ten Berge and Nevels. A necessary and sufficient condition is given for a solution to yield the unique global minimum of the least-squares function. Empirical verification of the condition indicates that the occurrence of non-optimal solutions with the proposed algorithm is very unlikely. A possible drawback of the optimal solution is that it is a singular matrix of necessity. In cases where singularity is undesirable, one may impose the additional nonsingularity constraint that the smallest eigenvalue of the solution be δ, where δ is an arbitrary small positive constant. Finally, it may be desirable to weight the squared errors of estimation differentially. A generalized solution is derived which satisfies the additional nonsingularity constraint and also allows for weighting. The generalized solution can readily be obtained from the standard “unweighted singular” solution by transforming the observed improper correlation matrix in a suitable way.", + keywords = "Missing value correlation, indefinite correlation matrix, IR-85889, tetrachoric correlation, constrained least-squares approximation", + author = "Knol, {Dirk L.} and {ten Berge}, {Jos M.F.}", + year = "1989", + doi = "10.1007/BF02294448", + language = "Undefined", + volume = "54", + pages = "53--61", + journal = "Psychometrika", + issn = "0033-3123", + publisher = "Springer", + number = "1", +} diff --git a/docs/references.rst b/docs/references.rst new file mode 100644 index 0000000..08873c0 --- /dev/null +++ b/docs/references.rst @@ -0,0 +1,10 @@ +.. only:: html + + ============ + Bibliography + ============ + + General References + ------------------ + +.. bibliography:: diff --git a/docs/xsdba.rst b/docs/xsdba.rst index 90ed6ad..2c917de 100644 --- a/docs/xsdba.rst +++ b/docs/xsdba.rst @@ -40,7 +40,7 @@ A generic bias adjustment process is laid out as follows: The train-adjust approach allows to inspect the trained adjustment object. The training information is stored in the underlying `Adj.ds` dataset and usually has a `af` variable with the adjustment factors. -Its layout and the other available variables vary between the different algorithm, refer to :ref:`Adjustment methods <sdba-user-api>`. +Its layout and the other available variables vary between the different algorithm, refer to :ref:`Adjustment methods <xsdba-user-api>`. Parameters needed by the training and the adjustment are saved to the ``Adj.ds`` dataset as a `adj_params` attribute. Parameters passed to the `adjust` call are written to the history attribute in the output scenario DataArray. @@ -125,21 +125,19 @@ add them back on exit. User API ======== -See: :ref:`sdba-user-api` +See: :ref:`xsdba-user-api` Developer API ============= -See: :ref:`sdba-developer-api` +See: :ref:`xsdba-developer-api` .. only:: html or text - .. _sdba-footnotes: + _xsdba-footnotes: SDBA Footnotes ============== .. bibliography:: :style: xcstyle - :labelprefix: SDBA- - :keyprefix: sdba- diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 3e3bfec..7397927 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -481,7 +481,7 @@ class DetrendedQuantileMapping(TrainAdjust): F^{-1}_{ref}\left\{F_{hist}\left[\frac{\overline{hist}\cdot sim}{\overline{sim}}\right]\right\}\frac{\overline{sim}}{\overline{hist}} where :math:`F` is the cumulative distribution function (CDF) and :math:`\overline{xyz}` is the linear trend of the data. - This equation is valid for multiplicative adjustment. Based on the DQM method of :cite:p:`sdba-cannon_bias_2015`. + This equation is valid for multiplicative adjustment. Based on the DQM method of :cite:p:`cannon_bias_2015`. Parameters ---------- @@ -592,7 +592,7 @@ class QuantileDeltaMapping(EmpiricalQuantileMapping): sim\frac{F^{-1}_{ref}\left[F_{sim}(sim)\right]}{F^{-1}_{hist}\left[F_{sim}(sim)\right]} where :math:`F` is the cumulative distribution function (CDF). This equation is valid for multiplicative adjustment. - The algorithm is based on the "QDM" method of :cite:p:`sdba-cannon_bias_2015`. + The algorithm is based on the "QDM" method of :cite:p:`cannon_bias_2015`. Parameters ---------- @@ -643,7 +643,7 @@ class ExtremeValues(TrainAdjust): r"""Adjustment correction for extreme values. The tail of the distribution of adjusted data is corrected according to the bias between the parametric Generalized - Pareto distributions of the simulated and reference data :cite:p:`sdba-roy_extremeprecip_2023`. The distributions are composed of the + Pareto distributions of the simulated and reference data :cite:p:`roy_extremeprecip_2023`. The distributions are composed of the maximal values of clusters of "large" values. With "large" values being those above `cluster_thresh`. Only extreme values, whose quantile within the pool of large values are above `q_thresh`, are re-adjusted. See `Notes`. @@ -704,7 +704,7 @@ class ExtremeValues(TrainAdjust): \tau = \left(\frac{1}{f}\frac{S - min(S)}{max(S) - min(S)}\right)^p Code based on an internal Matlab source and partly ib the `biascorrect_extremes` function of the julia package - "ClimateTools.jl" :cite:p:`sdba-roy_juliaclimateclimatetoolsjl_2021`. + "ClimateTools.jl" :cite:p:`roy_juliaclimateclimatetoolsjl_2021`. Because of limitations imposed by the lazy computing nature of the dask backend, it is not possible to know the number of cluster extremes in `ref` and `hist` at the @@ -802,7 +802,7 @@ class LOCI(TrainAdjust): r"""Local Intensity Scaling (LOCI) bias-adjustment. This bias adjustment method is designed to correct daily precipitation time series by considering wet and dry days - separately :cite:p:`sdba-schmidli_downscaling_2006`. + separately :cite:p:`schmidli_downscaling_2006`. Multiplicative adjustment factors are computed such that the mean of `hist` matches the mean of `ref` for values above a threshold. @@ -924,7 +924,7 @@ class PrincipalComponents(TrainAdjust): r"""Principal component adjustment. This bias-correction method maps model simulation values to the observation space through principal components - :cite:p:`sdba-hnilica_multisite_2017`. Values in the simulation space (multiple variables, or multiple sites) can be + :cite:p:`hnilica_multisite_2017`. Values in the simulation space (multiple variables, or multiple sites) can be thought of as coordinate along axes, such as variable, temperature, etc. Principal components (PC) are a linear combinations of the original variables where the coefficients are the eigenvectors of the covariance matrix. Values can then be expressed as coordinates along the PC axes. The method makes the assumption that bias-corrected @@ -984,7 +984,7 @@ class PrincipalComponents(TrainAdjust): References ---------- - :cite:cts:`hnilica_multisite_2017,sdba-alavoine_distinct_2022` + :cite:cts:`hnilica_multisite_2017,alavoine_distinct_2022` """ @classmethod @@ -1108,8 +1108,8 @@ class NpdfTransform(Adjust): This adjustment object combines both training and adjust steps in the `adjust` class method. - A multivariate bias-adjustment algorithm described by :cite:t:`sdba-cannon_multivariate_2018`, as part of the MBCn - algorithm, based on a color-correction algorithm described by :cite:t:`sdba-pitie_n-dimensional_2005`. + A multivariate bias-adjustment algorithm described by :cite:t:`cannon_multivariate_2018`, as part of the MBCn + algorithm, based on a color-correction algorithm described by :cite:t:`pitie_n-dimensional_2005`. This algorithm in itself, when used with QuantileDeltaMapping, is NOT trend-preserving. The full MBCn algorithm includes a reordering step provided here by :py:func:`xsdba.processing.reordering`. @@ -1168,23 +1168,23 @@ class NpdfTransform(Adjust): These three steps are repeated a certain number of times, prescribed by argument ``n_iter``. At each iteration, a new random rotation matrix is generated. - The original algorithm :cite:p:`sdba-pitie_n-dimensional_2005`, stops the iteration when some distance score converges. - Following cite:t:`sdba-cannon_multivariate_2018` and the MBCn implementation in :cite:t:`sdba-cannon_mbc_2020`, we + The original algorithm :cite:p:`pitie_n-dimensional_2005`, stops the iteration when some distance score converges. + Following cite:t:`cannon_multivariate_2018` and the MBCn implementation in :cite:t:`cannon_mbc_2020`, we instead fix the number of iterations. - As done by cite:t:`sdba-cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from - :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xsdba.processing.escore`). + As done by cite:t:`cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from + :cite:t:`szekely_testing_2004`. (see: :py:func:`xsdba.processing.escore`). - The random matrices are generated following a method laid out by :cite:t:`sdba-mezzadri_how_2007`. + The random matrices are generated following a method laid out by :cite:t:`mezzadri_how_2007`. - This is only part of the full MBCn algorithm, see :ref:`notebooks/sdba:Statistical Downscaling and Bias-Adjustment` + This is only part of the full MBCn algorithm, see :ref:`notebooks/example:Statistical Downscaling and Bias-Adjustment` for an example on how to replicate the full method with xsdba. This includes a standardization of the simulated data beforehand, an initial univariate adjustment and the reordering of those adjusted series according to the rank structure of the output of this algorithm. References ---------- - :cite:cts:`cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` + :cite:cts:`cannon_multivariate_2018,cannon_mbc_2020,pitie_n-dimensional_2005,mezzadri_how_2007,szekely_testing_2004` """ @classmethod @@ -1266,8 +1266,8 @@ def _adjust( class MBCn(TrainAdjust): r"""Multivariate bias correction function using the N-dimensional probability density function transform. - A multivariate bias-adjustment algorithm described by :cite:t:`sdba-cannon_multivariate_2018` - based on a color-correction algorithm described by :cite:t:`sdba-pitie_n-dimensional_2005`. + A multivariate bias-adjustment algorithm described by :cite:t:`cannon_multivariate_2018` + based on a color-correction algorithm described by :cite:t:`pitie_n-dimensional_2005`. This algorithm in itself, when used with QuantileDeltaMapping, is NOT trend-preserving. The full MBCn algorithm includes a reordering step provided here by :py:func:`xsdba.processing.reordering`. @@ -1356,18 +1356,18 @@ class MBCn(TrainAdjust): 3. Reorder the dataset found in step 2. according to the ranks of the dataset found in step 1. - The original algorithm :cite:p:`sdba-pitie_n-dimensional_2005`, stops the iteration when some distance score converges. - Following cite:t:`sdba-cannon_multivariate_2018` and the MBCn implementation in :cite:t:`sdba-cannon_mbc_2020`, we + The original algorithm :cite:p:`pitie_n-dimensional_2005`, stops the iteration when some distance score converges. + Following cite:t:`cannon_multivariate_2018` and the MBCn implementation in :cite:t:`cannon_mbc_2020`, we instead fix the number of iterations. - As done by cite:t:`sdba-cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from - :cite:t:`sdba-szekely_testing_2004`. (see: :py:func:`xsdba.processing.escore`). + As done by cite:t:`cannon_multivariate_2018`, the distance score chosen is the "Energy distance" from + :cite:t:`szekely_testing_2004`. (see: :py:func:`xsdba.processing.escore`). - The random matrices are generated following a method laid out by :cite:t:`sdba-mezzadri_how_2007`. + The random matrices are generated following a method laid out by :cite:t:`mezzadri_how_2007`. References ---------- - :cite:cts:`cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-pitie_n-dimensional_2005,sdba-mezzadri_how_2007,sdba-szekely_testing_2004` + :cite:cts:`cannon_multivariate_2018,cannon_mbc_2020,pitie_n-dimensional_2005,mezzadri_how_2007,szekely_testing_2004` Notes ----- diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 17ed526..4543ecf 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -192,103 +192,6 @@ def _match_value(self, value): ) -def parse_doc(doc: str) -> dict[str, str]: - """Crude regex parsing reading an indice docstring and extracting information needed in indicator construction. - - # TODO: Add such a notebook? The focus is not on the class Indicator here - The appropriate docstring syntax is detailed in :ref:`notebooks/extendxsdba:Defining new indices`. - - Parameters - ---------- - doc : str - The docstring of an indice function. - - Returns - ------- - dict - A dictionary with all parsed sections. - """ - if doc is None: - return {} - - out = {} - - sections = re.split(r"(\w+\s?\w+)\n\s+-{3,50}", doc) # obj.__doc__.split('\n\n') - intro = sections.pop(0) - if intro: - intro_content = list(map(str.strip, intro.strip().split("\n\n"))) - if len(intro_content) == 1: - out["title"] = intro_content[0] - elif len(intro_content) >= 2: - out["title"], abstract = intro_content[:2] - out["abstract"] = " ".join(map(str.strip, abstract.splitlines())) - - for i in range(0, len(sections), 2): - header, content = sections[i : i + 2] - - if header in ["Notes", "References"]: - out[header.lower()] = content.replace("\n ", "\n").strip() - elif header == "Parameters": - out["parameters"] = _parse_parameters(content) - elif header == "Returns": - rets = _parse_returns(content) - if rets: - meta = list(rets.values())[0] - if "long_name" in meta: - out["long_name"] = meta["long_name"] - return out - - -def _parse_parameters(section): - """Parse the 'parameters' section of a docstring into a dictionary. - - Works by mapping the parameter name to its description and, potentially, to its set of choices. - The type annotation are not parsed, except for fixed sets of values (listed as "{'a', 'b', 'c'}"). - The annotation parsing only accepts strings, numbers, `None` and `nan` (to represent `numpy.nan`). - """ - curr_key = None - params = {} - for line in section.split("\n"): - if line.startswith(" " * 6): # description - s = " " if params[curr_key]["description"] else "" - params[curr_key]["description"] += s + line.strip() - elif line.startswith(" " * 4) and ":" in line: # param title - name, annot = line.split(":", maxsplit=1) - curr_key = name.strip() - params[curr_key] = {"description": ""} - match = re.search(r".*(\{.*\}).*", annot) - if match: - try: - choices = literal_eval(match.groups()[0]) - params[curr_key]["choices"] = choices - except ValueError: # noqa: S110 - # If the literal_eval fails, we just ignore the choices. - pass - return params - - -def _parse_returns(section): - """Parse the returns section of a docstring into a dictionary mapping the parameter name to its description.""" - curr_key = None - params = {} - for line in section.split("\n"): - if line.strip(): - if line.startswith(" " * 6): # long_name - s = " " if params[curr_key]["long_name"] else "" - params[curr_key]["long_name"] += s + line.strip() - elif line.startswith(" " * 4): # param title - annot, *name = reversed(line.split(":", maxsplit=1)) - if name: - curr_key = name[0].strip() - else: - curr_key = None - params[curr_key] = {"long_name": ""} - annot, *unit = annot.split(",", maxsplit=1) - if unit: - params[curr_key]["units"] = unit[0].strip() - return params - - # XC def prefix_attrs(source: dict, keys: Sequence, prefix: str) -> dict: """Rename some keys of a dictionary by adding a prefix. @@ -537,163 +440,3 @@ def gen_call_string( elements.append(rep) return f"{funcname}({', '.join(elements)})" - - -# XC -def _gen_parameters_section( - parameters: dict[str, dict[str, Any]], allowed_periods: list[str] | None = None -) -> str: - """Generate the "parameters" section of the indicator docstring. - - Parameters - ---------- - parameters : dict - Parameters dictionary (`Ind.parameters`). - allowed_periods : list of str, optional - Restrict parameters to specific periods. Default: None. - - Returns - ------- - str - """ - section = "Parameters\n----------\n" - for name, param in parameters.items(): - desc_str = param.description - if param.kind == InputKind.FREQ_STR: - desc_str += ( - " See https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset" - "-aliases for available options." - ) - if allowed_periods is not None: - desc_str += ( - f" Restricted to frequencies equivalent to one of {allowed_periods}" - ) - if param.kind == InputKind.VARIABLE: - defstr = f"Default : `ds.{param.default}`. " - elif param.kind == InputKind.OPTIONAL_VARIABLE: - defstr = "" - elif param.default is not _empty: - defstr = f"Default : {param.default}. " - else: - defstr = "Required. " - if "choices" in param: - annotstr = str(param.choices) - else: - annotstr = KIND_ANNOTATION[param.kind] - if "units" in param and param.units is not None: - unitstr = f"[Required units : {param.units}]" - else: - unitstr = "" - section += f"{name} {': ' if annotstr else ''}{annotstr}\n {desc_str}\n {defstr}{unitstr}\n" - return section - - -def _gen_returns_section(cf_attrs: Sequence[dict[str, Any]]) -> str: - """Generate the "Returns" section of an indicator's docstring. - - Parameters - ---------- - cf_attrs : Sequence[Dict[str, Any]] - The list of attributes, usually Indicator.cf_attrs. - - Returns - ------- - str - """ - section = "Returns\n-------\n" - for attrs in cf_attrs: - if not section.endswith("\n"): - section += "\n" - section += f"{attrs['var_name']} : DataArray\n" - section += f" {attrs.get('long_name', '')}" - if "standard_name" in attrs: - section += f" ({attrs['standard_name']})" - if "units" in attrs: - section += f" [{attrs['units']}]" - added_section = "" - for key, attr in attrs.items(): - if key not in ["long_name", "standard_name", "units", "var_name"]: - if callable(attr): - attr = "<Dynamically generated string>" - added_section += f" **{key}**: {attr};" - if added_section: - section = f"{section}, with additional attributes:{added_section[:-1]}" - section += "\n" - return section - - -def generate_indicator_docstring(ind) -> str: - """Generate an indicator's docstring from keywords. - - Parameters - ---------- - ind : Indicator - An Indicator instance. - - Returns - ------- - str - """ - header = f"{ind.title} (realm: {ind.realm})\n\n{ind.abstract}\n" - - special = "" - - if hasattr(ind, "missing"): # Only ResamplingIndicators - special += f'This indicator will check for missing values according to the method "{ind.missing}".\n' - if hasattr(ind.compute, "__module__"): - special += f"Based on indice :py:func:`~{ind.compute.__module__}.{ind.compute.__name__}`.\n" - if ind.injected_parameters: - special += "With injected parameters: " - special += ", ".join( - [f"{k}={v}" for k, v in ind.injected_parameters.items()] - ) - special += ".\n" - if ind.keywords: - special += f"Keywords : {ind.keywords}.\n" - - parameters = _gen_parameters_section( - ind.parameters, getattr(ind, "allowed_periods", None) - ) - - returns = _gen_returns_section(ind.cf_attrs) - - extras = "" - for section in ["notes", "references"]: - if getattr(ind, section): - extras += f"{section.capitalize()}\n{'-' * len(section)}\n{getattr(ind, section)}\n\n" - - doc = f"{header}\n{special}\n{parameters}\n{returns}\n{extras}" - return doc - - -def get_percentile_metadata(data: xr.DataArray, prefix: str) -> dict[str, str]: - """Get the metadata related to percentiles from the given DataArray as a dictionary. - - Parameters - ---------- - data : xr.DataArray - Must be a percentile DataArray, this means the necessary metadata - must be available in its attributes and coordinates. - prefix : str - The prefix to be used in the metadata key. - Usually this takes the form of "tasmin_per" or equivalent. - - Returns - ------- - dict - A mapping of the configuration used to compute these percentiles. - """ - # handle case where da was created with `quantile()` method - if "quantile" in data.coords: - percs = data.coords["quantile"].values * 100 - elif "percentiles" in data.coords: - percs = data.coords["percentiles"].values - else: - percs = "<unknown percentiles>" - clim_bounds = data.attrs.get("climatology_bounds", "<unknown bounds>") - - return { - f"{prefix}_thresh": percs, - f"{prefix}_window": data.attrs.get("window", "<unknown window>"), - f"{prefix}_period": clim_bounds, - } diff --git a/src/xsdba/locales.py b/src/xsdba/locales.py index e733ae4..8bb3cf4 100644 --- a/src/xsdba/locales.py +++ b/src/xsdba/locales.py @@ -3,8 +3,7 @@ ==================== This module defines methods and object to help the internationalization of metadata for -climate indicators computed by xsdba. Go to :ref:`notebooks/customize:Adding translated metadata` to see -how to use this feature. +climate indicators computed by xsdba. All the methods and objects in this module use localization data given in JSON files. These files are expected to be defined as in this example for French: diff --git a/src/xsdba/loess.py b/src/xsdba/loess.py index 4cf1f53..95506e9 100644 --- a/src/xsdba/loess.py +++ b/src/xsdba/loess.py @@ -61,7 +61,7 @@ def _loess_nb( The arrays x and y contain an equal number of elements; each pair (x[i], y[i]) defines a data point in the scatter plot. The function returns the estimated (smooth) values of y. - Originally proposed in :cite:t:`sdba-cleveland_robust_1979`. + Originally proposed in :cite:t:`cleveland_robust_1979`. Users should call `utils.loess_smoothing`. See that function for the main documentation. @@ -189,7 +189,7 @@ def loess_smoothing( Returns a smoothed curve along given dimension. The regression is computed for each point using a subset of neighbouring points as given from evaluating the weighting function locally. - Follows the procedure of :cite:t:`sdba-cleveland_robust_1979`. + Follows the procedure of :cite:t:`cleveland_robust_1979`. Parameters ---------- @@ -218,7 +218,7 @@ def loess_smoothing( Notes ----- - As stated in :cite:t:`sdba-cleveland_robust_1979`, the weighting function :math:`W(x)` should respect the following + As stated in :cite:t:`cleveland_robust_1979`, the weighting function :math:`W(x)` should respect the following conditions: - :math:`W(x) > 0` for :math:`|x| < 1` diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 3ffdd6f..0cff1b9 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -55,7 +55,7 @@ def adapt_freq( This is useful when the dry-day frequency in the simulations is higher than in the references. This function will create new non-null values for `sim`/`hist`, so that adjustment factors are less wet-biased. - Based on :cite:t:`sdba-themesl_empirical-statistical_2012`. + Based on :cite:t:`themesl_empirical-statistical_2012`. Parameters ---------- @@ -385,7 +385,7 @@ def escore( N: int = 0, scale: bool = False, ) -> xr.DataArray: - r"""Energy score, or energy dissimilarity metric, based on :cite:t:`sdba-szekely_testing_2004` and :cite:t:`sdba-cannon_multivariate_2018`. + r"""Energy score, or energy dissimilarity metric, based on :cite:t:`szekely_testing_2004` and :cite:t:`cannon_multivariate_2018`. Parameters ---------- @@ -414,7 +414,7 @@ def escore( ----- Explanation adapted from the "energy" R package documentation. The e-distance between two clusters :math:`C_i`, :math:`C_j` (tgt and sim) of size :math:`n_i,n_j` - proposed by :cite:t:`sdba-szekely_testing_2004` is defined by: + proposed by :cite:t:`szekely_testing_2004` is defined by: .. math:: @@ -429,13 +429,13 @@ def escore( :math:`\Vert\cdot\Vert` denotes Euclidean norm, :math:`X_{ip}` denotes the p-th observation in the i-th cluster. The input scaling and the factor :math:`\frac{1}{2}` in the first equation are additions of - :cite:t:`sdba-cannon_multivariate_2018` to the metric. With that factor, the test becomes identical to the one - defined by :cite:t:`sdba-baringhaus_new_2004`. - This version is tested against values taken from Alex Cannon's MBC R package :cite:p:`sdba-cannon_mbc_2020`. + :cite:t:`cannon_multivariate_2018` to the metric. With that factor, the test becomes identical to the one + defined by :cite:t:`baringhaus_new_2004`. + This version is tested against values taken from Alex Cannon's MBC R package :cite:p:`cannon_mbc_2020`. References ---------- - :cite:cts:`baringhaus_new_2004,sdba-cannon_multivariate_2018,sdba-cannon_mbc_2020,sdba-szekely_testing_2004`. + :cite:cts:`baringhaus_new_2004,cannon_multivariate_2018,cannon_mbc_2020,szekely_testing_2004`. """ pts_dim, obs_dim = dims @@ -501,7 +501,7 @@ def to_additive_space( ): r"""Transform a non-additive variable into an additive space by the means of a log or logit transformation. - Based on :cite:t:`sdba-alavoine_distinct_2022`. + Based on :cite:t:`alavoine_distinct_2022`. Parameters ---------- @@ -594,7 +594,7 @@ def from_additive_space( ): r"""Transform back to the physical space a variable that was transformed with `to_additive_space`. - Based on :cite:t:`sdba-alavoine_distinct_2022`. + Based on :cite:t:`alavoine_distinct_2022`. If parameters are not present on the attributes of the data, they must be all given are arguments. Parameters diff --git a/src/xsdba/typing.py b/src/xsdba/typing.py index d81eeca..759cbca 100644 --- a/src/xsdba/typing.py +++ b/src/xsdba/typing.py @@ -70,8 +70,7 @@ class InputKind(IntEnum): Annotation : ``str`` or ``str | None``. In most cases, this kind of parameter makes sense with choices indicated in the docstring's version of the annotation with curly braces. - # TOOO : what about this notebook? - See :ref:`notebooks/extendxclim:Defining new indices`. + # TOOO : what about this notebook? removed reference to extendxclim """ DAY_OF_YEAR = 6 """A date, but without a year, in the MM-DD format. diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 2b23ea1..858df5f 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -617,7 +617,7 @@ def best_pc_orientation_simple( Given an inverse transform `Hinv` and a transform `R`, this returns the orientation minimizing the projected distance for a test point far from the origin. - This trick is inspired by the one exposed in :cite:t:`sdba-hnilica_multisite_2017`. For each possible orientation vector, + This trick is inspired by the one exposed in :cite:t:`hnilica_multisite_2017`. For each possible orientation vector, the test point is reprojected and the distance from the original point is computed. The orientation minimizing that distance is chosen. @@ -660,7 +660,7 @@ def best_pc_orientation_full( Hmean: np.ndarray, hist: np.ndarray, ) -> np.ndarray: - """Return best orientation vector for `A` according to the method of :cite:t:`sdba-alavoine_distinct_2022`. + """Return best orientation vector for `A` according to the method of :cite:t:`alavoine_distinct_2022`. Eigenvectors returned by `pc_matrix` do not have a defined orientation. Given an inverse transform `Hinv`, a transform `R`, the actual and target origins `Hmean` and `Rmean` and the matrix @@ -668,7 +668,7 @@ def best_pc_orientation_full( that maximizes the Spearman correlation coefficient of all variables. The correlation is computed for each variable individually, then averaged. - This trick is explained in :cite:t:`sdba-alavoine_distinct_2022`. + This trick is explained in :cite:t:`alavoine_distinct_2022`. See docstring of :py:func:`sdba.adjustment.PrincipalComponentAdjustment`. Parameters @@ -1060,7 +1060,7 @@ def eps_cholesky(M, nit=26): References ---------- - :cite:cts:`robin_2021,sdba-higham_1988,sdba-knol_1989` + :cite:cts:`robin_2021,higham_1988,knol_1989` """ MC = None try: From 6196909c1296f2d4fc18b5bc0daa879759a701c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 23 Oct 2024 15:55:54 -0400 Subject: [PATCH 086/105] fix make docs errors --- docs/api.rst | 4 +- docs/conf.py | 18 +- docs/index.rst | 17 +- docs/installation.rst | 35 ++ docs/notebooks/advanced_example.ipynb | 13 +- docs/notebooks/example.ipynb | 4 +- docs/notebooks/index.rst | 9 + docs/references.bib | 10 +- pyproject.toml | 3 + src/xsdba/adjustment.py | 17 +- src/xsdba/base.py | 3 +- src/xsdba/xclim_submodules/__init__.py | 1 - src/xsdba/xclim_submodules/generic.py | 119 ----- src/xsdba/xclim_submodules/stats.py | 625 ------------------------- tests/conftest.py | 17 - 15 files changed, 93 insertions(+), 802 deletions(-) create mode 100644 docs/notebooks/index.rst delete mode 100644 src/xsdba/xclim_submodules/__init__.py delete mode 100644 src/xsdba/xclim_submodules/generic.py delete mode 100644 src/xsdba/xclim_submodules/stats.py diff --git a/docs/api.rst b/docs/api.rst index a1c0c11..de2fbcd 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -5,7 +5,7 @@ API .. _xsdba-user-api: xsdba Module -=========== +============ .. automodule:: xsdba.adjustment :members: @@ -54,7 +54,7 @@ xsdba Module .. _`xsdba-developer-api`: xsdba Utilities --------------- +--------------- .. automodule:: xsdba.base :members: diff --git a/docs/conf.py b/docs/conf.py index 9699961..ad36cd2 100755 --- a/docs/conf.py +++ b/docs/conf.py @@ -53,8 +53,14 @@ "sphinxcontrib.bibtex", 'sphinx_codeautolink', 'sphinx_copybutton', + "nbsphinx", + ] +# suppress "duplicate citation for key" warnings +suppress_warnings = ['bibtex.duplicate_citation'] + + autosectionlabel_prefix_document = True autosectionlabel_maxdepth = 2 @@ -86,7 +92,9 @@ class XCStyle(AlphaStyle): intersphinx_mapping = { "scipy": ("https://docs.scipy.org/doc/scipy/", None), + "pandas": ("https://pandas.pydata.org/docs/", None), } + extlinks = { "issue": ("https://github.com/Ouranosinc/xsdba/issues/%s", "GH/%s"), "pull": ("https://github.com/Ouranosinc/xsdba/pull/%s", "PR/%s"), @@ -101,7 +109,9 @@ class XCStyle(AlphaStyle): source_suffix = {'.rst': 'restructuredtext'} # The master toctree document. -master_doc = 'index' +# master_doc = 'index' +root_doc = "index" + # General information about the project. project = 'xsdba' @@ -191,7 +201,7 @@ class XCStyle(AlphaStyle): # (source start file, target name, title, author, documentclass # [howto, manual, or own class]). latex_documents = [ - (master_doc, 'xsdba.tex', + (root_doc, 'xsdba.tex', 'xsdba Documentation', 'Trevor James Smith', 'manual'), ] @@ -202,7 +212,7 @@ class XCStyle(AlphaStyle): # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ - (master_doc, 'xsdba', + (root_doc, 'xsdba', 'xsdba Documentation', [author], 1) ] @@ -214,7 +224,7 @@ class XCStyle(AlphaStyle): # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ - (master_doc, 'xsdba', + (root_doc, 'xsdba', 'xsdba Documentation', author, 'xsdba', diff --git a/docs/index.rst b/docs/index.rst index c33c563..64de5fa 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,9 +1,14 @@ Welcome to xsdba's documentation! ================================= +.. toctree:: + :hidden: + + self + .. toctree:: :maxdepth: 2 - :caption: Contents: + :caption: Table of Contents: readme installation @@ -11,11 +16,17 @@ Welcome to xsdba's documentation! xsdba contributing releasing + notebooks/index + notebooks/example + notebooks/advanced_example + + +.. toctree:: + :titlesonly: + authors changelog references - notebooks/example - notebooks/advanced_example .. toctree:: :maxdepth: 1 diff --git a/docs/installation.rst b/docs/installation.rst index 4b3706a..2bb3f5c 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -97,3 +97,38 @@ The sources for xsdba can be downloaded from the `Github repo`_. These commands should work most of the time, but if big changes are made to the repository, you might need to remove the environment and create it again. .. _Github repo: https://github.com/Ouranosinc/xsdba + + +.. _extra-dependencies: + +Extra Dependencies +------------------ + +Experimental SDBA Algorithms +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +`xsdba` also offers support for a handful of experimental adjustment methods to extend, available only if some additional libraries are installed. These libraries are completely optional. + +One experimental library is `SBCK`_. `SBCK` is available from PyPI but has one complex dependency: `Eigen3`_. +As `SBCK` is compiled at installation time, a **C++** compiler (`GCC`, `Clang`, `MSVC`, etc.) must also be available. + +On Debian/Ubuntu, `Eigen3` can be installed via `apt`: + +.. code-block:: shell + + $ sudo apt-get install libeigen3-dev + +Eigen3 is also available on conda-forge, so, if already using Anaconda, one can do: + +.. code-block:: shell + + $ conda install -c conda-forge eigen + +Afterwards, `SBCK` can be installed from PyPI using `pip`: + +.. code-block:: shell + + $ python -m pip install pybind11 sbck + +.. _SBCK: https://github.com/yrobink/SBCK +.. _Eigen3: https://eigen.tuxfamily.org/index.php diff --git a/docs/notebooks/advanced_example.ipynb b/docs/notebooks/advanced_example.ipynb index 7b1b634..c0fc9ef 100644 --- a/docs/notebooks/advanced_example.ipynb +++ b/docs/notebooks/advanced_example.ipynb @@ -351,7 +351,7 @@ "\n", "Some Adjustment methods require that the adjusted data (`sim`) be of the same length (same number of points) than the training data (`ref` and `hist`). These requirements often ensure conservation of statistical properties and a better representation of the climate change signal over the long adjusted timeseries.\n", "\n", - "In opposition to a conventional \"rolling window\", here it is the _years_ that are the base units of the window, not the elements themselves. `xsdba` implements `xsdba.calendar.stack_periods` and `xsdba.calendar.unstack_periods` to manipulate data in that goal. The \"stack\" function cuts the data in overlapping windows of a certain length and stacks them along a new `\"period\"` dimension, alike to xarray's `da.rolling(time=win).construct('period')`, but with yearly steps. The stride (or step) between each window can also be controlled. This argument is an indicator of how many years overlap between each window. With a value of `1`, a window will have `window - 1` years overlapping with the previous one. The default (`None`) is to have `stride = window` will result in no overlap at all. The default units in which `window` and `stride` are given is a year (\"YS\"), but can be changed with argument `freq`.\n", + "In opposition to a conventional \"rolling window\", here it is the _years_ that are the base units of the window, not the elements themselves. `xsdba` implements `xsdba.base.stack_periods` and `xsdba.base.unstack_periods` to manipulate data in that goal. The \"stack\" function cuts the data in overlapping windows of a certain length and stacks them along a new `\"period\"` dimension, alike to xarray's `da.rolling(time=win).construct('period')`, but with yearly steps. The stride (or step) between each window can also be controlled. This argument is an indicator of how many years overlap between each window. With a value of `1`, a window will have `window - 1` years overlapping with the previous one. The default (`None`) is to have `stride = window` will result in no overlap at all. The default units in which `window` and `stride` are given is a year (\"YS\"), but can be changed with argument `freq`.\n", "\n", "By chunking the result along this `'period'` dimension, it is expected to be more computationally efficient (when using `dask`) than looping over the windows with a for-loop (or a `GroupyBy`)\n", "\n", @@ -390,7 +390,7 @@ "metadata": {}, "outputs": [], "source": [ - "from xsdba.calendar import stack_periods, unstack_periods\n", + "from xsdba.base import stack_periods, unstack_periods\n", "\n", "sim_win = stack_periods(sim, window=15, stride=5)\n", "sim_win" @@ -433,13 +433,12 @@ "outputs": [], "source": [ "import xsdba\n", - "from xsdba.calendar import convert_calendar\n", "from xsdba.units import convert_units_to, pint_multiply\n", - "from xsdba.testing import open_dataset\n", + "from xclim.testing import open_dataset\n", "\n", "group = xsdba.Grouper(\"time.dayofyear\", window=31)\n", "\n", - "dref = convert_calendar(open_dataset(\"sdba/ahccd_1950-2013.nc\"), \"noleap\").sel(\n", + "dref = open_dataset(\"sdba/ahccd_1950-2013.nc\").convert_calendar(\"noleap\").sel(\n", " time=slice(\"1981\", \"2010\")\n", ")\n", "dsim = open_dataset(\"sdba/CanESM2_1950-2100.nc\")\n", @@ -736,7 +735,7 @@ "from matplotlib import pyplot as plt\n", "\n", "import xsdba\n", - "from xsdba.testing import open_dataset\n", + "from xclim.testing import open_dataset\n", "\n", "# load test data\n", "hist = open_dataset(\"sdba/CanESM2_1950-2100.nc\").sel(time=slice(\"1950\", \"1980\")).tasmax\n", @@ -854,7 +853,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/example.ipynb b/docs/notebooks/example.ipynb index 4c6e12f..337e983 100644 --- a/docs/notebooks/example.ipynb +++ b/docs/notebooks/example.ipynb @@ -1577,7 +1577,7 @@ "outputs": [], "source": [ "from xsdba.units import convert_units_to, pint_multiply\n", - "from xsdba.testing import open_dataset\n", + "from xclim.testing import open_dataset\n", "\n", "dref = open_dataset(\n", " \"sdba/ahccd_1950-2013.nc\", chunks={\"location\": 1}, drop_variables=[\"lat\", \"lon\"]\n", @@ -1780,7 +1780,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.6" }, "toc": { "base_numbering": 1, diff --git a/docs/notebooks/index.rst b/docs/notebooks/index.rst new file mode 100644 index 0000000..415d7bd --- /dev/null +++ b/docs/notebooks/index.rst @@ -0,0 +1,9 @@ +======== +Examples +======== + +.. toctree:: + :maxdepth: 1 + + example + advanced_example diff --git a/docs/references.bib b/docs/references.bib index ff6372d..386a3ef 100644 --- a/docs/references.bib +++ b/docs/references.bib @@ -37,7 +37,7 @@ @article{cannon_bias_2015 pages = {6938--6959}, } -@article{cannon_mbc_2020, +@misc{cannon_mbc_2020, title = {{MBC}: {Multivariate} {Bias} {Correction} of {Climate} {Model} {Outputs}}, copyright = {GPL-2}, shorttitle = {{MBC}}, @@ -62,7 +62,7 @@ @article{roy_extremeprecip_2023 year = {2023}, } -@article{roy_juliaclimateclimatetoolsjl_2021, +@misc{roy_juliaclimateclimatetoolsjl_2021, title = {{JuliaClimate}/{ClimateTools}.jl: v0.23.1}, shorttitle = {{JuliaClimate}/{ClimateTools}.jl}, url = {https://zenodo.org/record/5399172}, @@ -153,7 +153,7 @@ @article{szekely_testing_2004 year = {2004}, } -@article{mezzadri_how_2007, +@misc{mezzadri_how_2007, title = {How to generate random matrices from the classical compact groups}, url = {https://arxiv.org/abs/math-ph/0609050}, doi = {10.48550/arXiv.math-ph/0609050}, @@ -200,7 +200,7 @@ @article{cleveland_robust_1979 pages = {829--836}, } -@article{gramfort_lowess_2015, +@misc{gramfort_lowess_2015, title = {{LOWESS} : {Locally} weighted regression}, copyright = {BSD 3-Clause}, shorttitle = {{LOWESS}}, @@ -282,7 +282,7 @@ @article{francois_multivariate_2020 pages = {537--562}, } -@article{jalbert_extreme_2022, +@misc{jalbert_extreme_2022, title = {Extreme value analysis package for {Julia}.}, url = {https://github.com/jojal5/Extremes.jl}, abstract = {Extreme value analysis package for Julia}, diff --git a/pyproject.toml b/pyproject.toml index ebfd8f7..e0dfffa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -41,6 +41,8 @@ dependencies = [ "dask", "h5netcdf>=1.3.0", "jsonpickle", + # TODO : for notebooks ... does this fall in optional deps? + "nc_time_axis", "numba", "numpy >=1.23.0,<2.0", "pint", @@ -295,6 +297,7 @@ addopts = [ "--maxprocesses=8", "--dist=worksteal" ] +norecursedirs = ["docs/notebooks/*"] filterwarnings = ["ignore::UserWarning"] strict_markers = true testpaths = "tests" diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 7397927..12067a0 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -1177,7 +1177,7 @@ class NpdfTransform(Adjust): The random matrices are generated following a method laid out by :cite:t:`mezzadri_how_2007`. - This is only part of the full MBCn algorithm, see :ref:`notebooks/example:Statistical Downscaling and Bias-Adjustment` + This is only part of the full MBCn algorithm, see :`<notebooks/example.ipynb>` for an example on how to replicate the full method with xsdba. This includes a standardization of the simulated data beforehand, an initial univariate adjustment and the reordering of those adjusted series according to the rank structure of the output of this algorithm. @@ -1263,6 +1263,7 @@ def _adjust( return out +# TODO : Better document arguments of MBCn and its methods class MBCn(TrainAdjust): r"""Multivariate bias correction function using the N-dimensional probability density function transform. @@ -1278,10 +1279,6 @@ class MBCn(TrainAdjust): ---------- Train step - ref : xr.DataArray - Reference dataset. - hist : xr.DataArray - Historical dataset. base_kws : dict, optional Arguments passed to the training in the npdf transform. adj_kws : dict, optional @@ -1301,18 +1298,8 @@ class MBCn(TrainAdjust): Adjust step - ref : xr.DataArray - Target reference dataset also needed for univariate bias correction preceding npdf transform - hist: xr.DataArray - Source dataset also needed for univariate bias correction preceding npdf transform - sim : xr.DataArray - Source dataset to adjust. base : BaseAdjustment Bias-adjustment class used for the univariate bias correction. - base_kws : dict, optional - Arguments passed to the training in the univariate bias correction - adj_kws : dict, optional - Arguments passed to the adjusting in the univariate bias correction period_dim : str, optional Name of the period dimension used when stacking time periods of `sim` using :py:func:`xsdba.calendar.stack_periods`. If specified, the interpolation of the npdf transform is performed only once and applied on all periods simultaneously. diff --git a/src/xsdba/base.py b/src/xsdba/base.py index b27d257..9558f41 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -929,8 +929,6 @@ def uses_dask(*das: xr.DataArray | xr.Dataset) -> bool: def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: """Get python's comparing function according to its name of representation and validate allowed usage. - Accepted op string are keys and values of xclim.indices.generic.binary_ops. - Parameters ---------- op : str @@ -938,6 +936,7 @@ def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: constrain : sequence of str, optional A tuple of allowed operators. """ + # XC binary_ops = {">": "gt", "<": "lt", ">=": "ge", "<=": "le", "==": "eq", "!=": "ne"} if op in binary_ops: binary_op = binary_ops[op] diff --git a/src/xsdba/xclim_submodules/__init__.py b/src/xsdba/xclim_submodules/__init__.py deleted file mode 100644 index 6e03199..0000000 --- a/src/xsdba/xclim_submodules/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# noqa: D104 diff --git a/src/xsdba/xclim_submodules/generic.py b/src/xsdba/xclim_submodules/generic.py deleted file mode 100644 index 3ef0ac0..0000000 --- a/src/xsdba/xclim_submodules/generic.py +++ /dev/null @@ -1,119 +0,0 @@ -"""Generic functions adapted from xclim.""" - -from __future__ import annotations - -from collections.abc import Callable - -import xarray as xr - -__all__ = ["default_freq", "get_op", "select_resample_op"] - - -# XC -binary_ops = {">": "gt", "<": "lt", ">=": "ge", "<=": "le", "==": "eq", "!=": "ne"} - - -# XC -def default_freq(**indexer) -> str: - """Return the default frequency.""" - freq = "YS-JAN" - if indexer: - group, value = indexer.popitem() - if group == "season": - month = 12 # The "season" scheme is based on YS-DEC - elif group == "month": - month = np.take(value, 0) - elif group == "doy_bounds": - month = cftime.num2date(value[0] - 1, "days since 2004-01-01").month - elif group == "date_bounds": - month = int(value[0][:2]) - else: - raise ValueError(f"Unknown group `{group}`.") - freq = "YS-" + _MONTH_ABBREVIATIONS[month] - return freq - - -# XC -def get_op(op: str, constrain: Sequence[str] | None = None) -> Callable: - """Get python's comparing function according to its name of representation and validate allowed usage. - - Accepted op string are keys and values of xclim.indices.generic.binary_ops. - - Parameters - ---------- - op : str - Operator. - constrain : sequence of str, optional - A tuple of allowed operators. - """ - if op == "gteq": - warnings.warn(f"`{op}` is being renamed `ge` for compatibility.") - op = "ge" - if op == "lteq": - warnings.warn(f"`{op}` is being renamed `le` for compatibility.") - op = "le" - - if op in binary_ops: - binary_op = binary_ops[op] - elif op in binary_ops.values(): - binary_op = op - else: - raise ValueError(f"Operation `{op}` not recognized.") - - constraints = [] - if isinstance(constrain, list | tuple | set): - constraints.extend([binary_ops[c] for c in constrain]) - constraints.extend(constrain) - elif isinstance(constrain, str): - constraints.extend([binary_ops[constrain], constrain]) - - if constrain: - if op not in constraints: - raise ValueError(f"Operation `{op}` not permitted for indice.") - - return xr.core.ops.get_op(binary_op) - - -# XC -def select_resample_op( - da: xr.DataArray, - op: str | Callable, - freq: str = "YS", - out_units: str | None = None, - **indexer, -) -> xr.DataArray: - """Apply operation over each period that is part of the index selection. - - Parameters - ---------- - da : xr.DataArray - Input data. - op : str {'min', 'max', 'mean', 'std', 'var', 'count', 'sum', 'integral', 'argmax', 'argmin'} or func - Reduce operation. Can either be a DataArray method or a function that can be applied to a DataArray. - freq : str - Resampling frequency defining the periods as defined in :ref:`timeseries.resampling`. - out_units : str, optional - Output units to assign. Only necessary if `op` is function not supported by :py:func:`xclim.core.units.to_agg_units`. - indexer : {dim: indexer, }, optional - Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, - month=1 to select January, or month=[6,7,8] to select summer months. If not indexer is given, all values are - considered. - - Returns - ------- - xr.DataArray - The maximum value for each period. - """ - da = select_time(da, **indexer) - r = da.resample(time=freq) - if isinstance(op, str): - op = _xclim_ops.get(op, op) - if isinstance(op, str): - out = getattr(r, op.replace("integral", "sum"))(dim="time", keep_attrs=True) - else: - with xr.set_options(keep_attrs=True): - out = r.map(op) - op = op.__name__ - if out_units is not None: - return out.assign_attrs(units=out_units) - return to_agg_units(out, da, op) diff --git a/src/xsdba/xclim_submodules/stats.py b/src/xsdba/xclim_submodules/stats.py deleted file mode 100644 index 8ff5e89..0000000 --- a/src/xsdba/xclim_submodules/stats.py +++ /dev/null @@ -1,625 +0,0 @@ -"""Statistic-related functions. See the `frequency_analysis` notebook for examples.""" - -from __future__ import annotations - -import json -import warnings -from collections.abc import Sequence -from typing import Any - -import numpy as np -import scipy.stats -import xarray as xr - -from xsdba.base import uses_dask -from xsdba.formatting import prefix_attrs, unprefix_attrs, update_history -from xsdba.typing import DateStr, Quantified -from xsdba.units import convert_units_to - -from . import generic - -__all__ = [ - "_fit_start", - "dist_method", - "fa", - "fit", - "frequency_analysis", - "get_dist", - "parametric_cdf", - "parametric_quantile", -] - - -# Fit the parameters. -# This would also be the place to impose constraints on the series minimum length if needed. -def _fitfunc_1d(arr, *, dist, nparams, method, **fitkwargs): - """Fit distribution parameters.""" - x = np.ma.masked_invalid(arr).compressed() # pylint: disable=no-member - - # Return NaNs if array is empty. - if len(x) <= 1: - return np.asarray([np.nan] * nparams) - - # Estimate parameters - if method in ["ML", "MLE"]: - args, kwargs = _fit_start(x, dist.name, **fitkwargs) - params = dist.fit(x, *args, method="mle", **kwargs, **fitkwargs) - elif method == "MM": - params = dist.fit(x, method="mm", **fitkwargs) - elif method == "PWM": - params = list(dist.lmom_fit(x).values()) - elif method == "APP": - args, kwargs = _fit_start(x, dist.name, **fitkwargs) - kwargs.setdefault("loc", 0) - params = list(args) + [kwargs["loc"], kwargs["scale"]] - else: - raise NotImplementedError(f"Unknown method `{method}`.") - - params = np.asarray(params) - - # Fill with NaNs if one of the parameters is NaN - if np.isnan(params).any(): - params[:] = np.nan - - return params - - -def fit( - da: xr.DataArray, - dist: str | scipy.stats.rv_continuous = "norm", - method: str = "ML", - dim: str = "time", - **fitkwargs: Any, -) -> xr.DataArray: - r"""Fit an array to a univariate distribution along the time dimension. - - Parameters - ---------- - da : xr.DataArray - Time series to be fitted along the time dimension. - dist : str or rv_continuous distribution object - Name of the univariate distribution, such as beta, expon, genextreme, gamma, gumbel_r, lognorm, norm - (see :py:mod:scipy.stats for full list) or the distribution object itself. - method : {"ML" or "MLE", "MM", "PWM", "APP"} - Fitting method, either maximum likelihood (ML or MLE), method of moments (MM) or approximate method (APP). - Can also be the probability weighted moments (PWM), also called L-Moments, if a compatible `dist` object is passed. - The PWM method is usually more robust to outliers. - dim : str - The dimension upon which to perform the indexing (default: "time"). - \*\*fitkwargs - Other arguments passed directly to :py:func:`_fitstart` and to the distribution's `fit`. - - Returns - ------- - xr.DataArray - An array of fitted distribution parameters. - - Notes - ----- - Coordinates for which all values are NaNs will be dropped before fitting the distribution. If the array still - contains NaNs, the distribution parameters will be returned as NaNs. - """ - method = method.upper() - method_name = { - "ML": "maximum likelihood", - "MM": "method of moments", - "MLE": "maximum likelihood", - "PWM": "probability weighted moments", - "APP": "approximative method", - } - if method not in method_name: - raise ValueError(f"Fitting method not recognized: {method}") - - # Get the distribution - dist = get_dist(dist) - - if method == "PWM" and not hasattr(dist, "lmom_fit"): - raise ValueError( - f"The given distribution {dist} does not implement the PWM fitting method. Please pass an instance from the lmoments3 package." - ) - - shape_params = [] if dist.shapes is None else dist.shapes.split(",") - dist_params = shape_params + ["loc", "scale"] - - data = xr.apply_ufunc( - _fitfunc_1d, - da, - input_core_dims=[[dim]], - output_core_dims=[["dparams"]], - vectorize=True, - dask="parallelized", - output_dtypes=[float], - keep_attrs=True, - kwargs=dict( - # Don't know how APP should be included, this works for now - dist=dist, - nparams=len(dist_params), - method=method, - **fitkwargs, - ), - dask_gufunc_kwargs={"output_sizes": {"dparams": len(dist_params)}}, - ) - - # Add coordinates for the distribution parameters and transpose to original shape (with dim -> dparams) - dims = [d if d != dim else "dparams" for d in da.dims] - out = data.assign_coords(dparams=dist_params).transpose(*dims) - - out.attrs = prefix_attrs( - da.attrs, ["standard_name", "long_name", "units", "description"], "original_" - ) - attrs = dict( - long_name=f"{dist.name} parameters", - description=f"Parameters of the {dist.name} distribution", - method=method, - estimator=method_name[method].capitalize(), - scipy_dist=dist.name, - units="", - history=update_history( - f"Estimate distribution parameters by {method_name[method]} method along dimension {dim}.", - new_name="fit", - data=da, - ), - ) - out.attrs.update(attrs) - return out - - -def parametric_quantile( - p: xr.DataArray, - q: float | Sequence[float], - dist: str | scipy.stats.rv_continuous | None = None, -) -> xr.DataArray: - """Return the value corresponding to the given distribution parameters and quantile. - - Parameters - ---------- - p : xr.DataArray - Distribution parameters returned by the `fit` function. - The array should have dimension `dparams` storing the distribution parameters, - and attribute `scipy_dist`, storing the name of the distribution. - q : float or Sequence of float - Quantile to compute, which must be between `0` and `1`, inclusive. - dist: str, rv_continuous instance, optional - The distribution name or instance if the `scipy_dist` attribute is not available on `p`. - - Returns - ------- - xarray.DataArray - An array of parametric quantiles estimated from the distribution parameters. - - Notes - ----- - When all quantiles are above 0.5, the `isf` method is used instead of `ppf` because accuracy is sometimes better. - """ - q = np.atleast_1d(q) - - dist = get_dist(dist or p.attrs["scipy_dist"]) - - # Create a lambda function to facilitate passing arguments to dask. There is probably a better way to do this. - if np.all(q > 0.5): - - def func(x): - return dist.isf(1 - q, *x) - - else: - - def func(x): - return dist.ppf(q, *x) - - data = xr.apply_ufunc( - func, - p, - input_core_dims=[["dparams"]], - output_core_dims=[["quantile"]], - vectorize=True, - dask="parallelized", - output_dtypes=[float], - keep_attrs=True, - dask_gufunc_kwargs={"output_sizes": {"quantile": len(q)}}, - ) - - # Assign quantile coordinates and transpose to preserve original dimension order - dims = [d if d != "dparams" else "quantile" for d in p.dims] - out = data.assign_coords(quantile=q).transpose(*dims) - out.attrs = unprefix_attrs(p.attrs, ["units", "standard_name"], "original_") - - attrs = dict( - long_name=f"{dist.name} quantiles", - description=f"Quantiles estimated by the {dist.name} distribution", - cell_methods="dparams: ppf", - history=update_history( - "Compute parametric quantiles from distribution parameters", - new_name="parametric_quantile", - parameters=p, - ), - ) - out.attrs.update(attrs) - return out - - -def parametric_cdf( - p: xr.DataArray, - v: float | Sequence[float], - dist: str | scipy.stats.rv_continuous | None = None, -) -> xr.DataArray: - """Return the cumulative distribution function corresponding to the given distribution parameters and value. - - Parameters - ---------- - p : xr.DataArray - Distribution parameters returned by the `fit` function. - The array should have dimension `dparams` storing the distribution parameters, - and attribute `scipy_dist`, storing the name of the distribution. - v : float or Sequence of float - Value to compute the CDF. - dist: str, rv_continuous instance, optional - The distribution name or instance is the `scipy_dist` attribute is not available on `p`. - - Returns - ------- - xarray.DataArray - An array of parametric CDF values estimated from the distribution parameters. - """ - v = np.atleast_1d(v) - - dist = get_dist(dist or p.attrs["scipy_dist"]) - - # Create a lambda function to facilitate passing arguments to dask. There is probably a better way to do this. - def func(x): - return dist.cdf(v, *x) - - data = xr.apply_ufunc( - func, - p, - input_core_dims=[["dparams"]], - output_core_dims=[["cdf"]], - vectorize=True, - dask="parallelized", - output_dtypes=[float], - keep_attrs=True, - dask_gufunc_kwargs={"output_sizes": {"cdf": len(v)}}, - ) - - # Assign quantile coordinates and transpose to preserve original dimension order - dims = [d if d != "dparams" else "cdf" for d in p.dims] - out = data.assign_coords(cdf=v).transpose(*dims) - out.attrs = unprefix_attrs(p.attrs, ["units", "standard_name"], "original_") - - attrs = dict( - long_name=f"{dist.name} cdf", - description=f"CDF estimated by the {dist.name} distribution", - cell_methods="dparams: cdf", - history=update_history( - "Compute parametric cdf from distribution parameters", - new_name="parametric_cdf", - parameters=p, - ), - ) - out.attrs.update(attrs) - return out - - -def fa( - da: xr.DataArray, - t: int | Sequence, - dist: str | scipy.stats.rv_continuous = "norm", - mode: str = "max", - method: str = "ML", -) -> xr.DataArray: - """Return the value corresponding to the given return period. - - Parameters - ---------- - da : xr.DataArray - Maximized/minimized input data with a `time` dimension. - t : int or Sequence of int - Return period. The period depends on the resolution of the input data. If the input array's resolution is - yearly, then the return period is in years. - dist : str or rv_continuous instance - Name of the univariate distribution, such as: - `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm` - Or the distribution instance itself. - mode : {'min', 'max} - Whether we are looking for a probability of exceedance (max) or a probability of non-exceedance (min). - method : {"ML", "MLE", "MOM", "PWM", "APP"} - Fitting method, either maximum likelihood (ML or MLE), method of moments (MOM) or approximate method (APP). - Also accepts probability weighted moments (PWM), also called L-Moments, if `dist` is an instance from the lmoments3 library. - The PWM method is usually more robust to outliers. - - Returns - ------- - xarray.DataArray - An array of values with a 1/t probability of exceedance (if mode=='max'). - - See Also - -------- - scipy.stats : For descriptions of univariate distribution types. - """ - # Fit the parameters of the distribution - p = fit(da, dist, method=method) - t = np.atleast_1d(t) - - if mode in ["max", "high"]: - q = 1 - 1.0 / t - - elif mode in ["min", "low"]: - q = 1.0 / t - - else: - raise ValueError(f"Mode `{mode}` should be either 'max' or 'min'.") - - # Compute the quantiles - out = ( - parametric_quantile(p, q, dist) - .rename({"quantile": "return_period"}) - .assign_coords(return_period=t) - ) - out.attrs["mode"] = mode - return out - - -def frequency_analysis( - da: xr.DataArray, - mode: str, - t: int | Sequence[int], - dist: str | scipy.stats.rv_continuous, - window: int = 1, - freq: str | None = None, - method: str = "ML", - **indexer: dict[str, int | float | str], -) -> xr.DataArray: - r"""Return the value corresponding to a return period. - - Parameters - ---------- - da : xarray.DataArray - Input data. - mode : {'min', 'max'} - Whether we are looking for a probability of exceedance (high) or a probability of non-exceedance (low). - t : int or sequence - Return period. The period depends on the resolution of the input data. If the input array's resolution is - yearly, then the return period is in years. - dist : str or rv_continuous - Name of the univariate distribution, e.g. `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm`. - Or an instance of the distribution. - window : int - Averaging window length (days). - freq : str, optional - Resampling frequency. If None, the frequency is assumed to be 'YS' unless the indexer is season='DJF', - in which case `freq` would be set to `YS-DEC`. - method : {"ML" or "MLE", "MOM", "PWM", "APP"} - Fitting method, either maximum likelihood (ML or MLE), method of moments (MOM) or approximate method (APP). - Also accepts probability weighted moments (PWM), also called L-Moments, if `dist` is an instance from the lmoments3 library. - The PWM method is usually more robust to outliers. - \*\*indexer : dict - Time attribute and values over which to subset the array. For example, use season='DJF' to select winter values, - month=1 to select January, or month=[6,7,8] to select summer months. If indexer is not provided, all values are - considered. - - Returns - ------- - xarray.DataArray - An array of values with a 1/t probability of exceedance or non-exceedance when mode is high or low respectively. - - See Also - -------- - scipy.stats : For descriptions of univariate distribution types. - """ - # Apply rolling average - attrs = da.attrs.copy() - if window > 1: - da = da.rolling(time=window).mean(skipna=False) - da.attrs.update(attrs) - - # Assign default resampling frequency if not provided - freq = freq or generic.default_freq(**indexer) - - # Extract the time series of min or max over the period - sel = generic.select_resample_op(da, op=mode, freq=freq, **indexer) - - if uses_dask(sel): - sel = sel.chunk({"time": -1}) - # Frequency analysis - return fa(sel, t, dist=dist, mode=mode, method=method) - - -def get_dist(dist: str | scipy.stats.rv_continuous): - """Return a distribution object from `scipy.stats`.""" - if isinstance(dist, scipy.stats.rv_continuous): - return dist - - dc = getattr(scipy.stats, dist, None) - if dc is None: - e = f"Statistical distribution `{dist}` is not found in scipy.stats." - raise ValueError(e) - return dc - - -def _fit_start(x, dist: str, **fitkwargs: dict[str, Any]) -> tuple[tuple, dict]: - r"""Return initial values for distribution parameters. - - Providing the ML fit method initial values can help the optimizer find the global optimum. - - Parameters - ---------- - x : array-like - Input data. - dist : str - Name of the univariate distribution, e.g. `beta`, `expon`, `genextreme`, `gamma`, `gumbel_r`, `lognorm`, `norm`. - (see :py:mod:scipy.stats). Only `genextreme` and `weibull_exp` distributions are supported. - \*\*fitkwargs : dict - Kwargs passed to fit. - - Returns - ------- - tuple, dict - - References - ---------- - :cite:cts:`coles_introduction_2001,cohen_parameter_2019, thom_1958, cooke_1979, muralidhar_1992` - - """ - x = np.asarray(x) - m = x.mean() - v = x.var() - - if dist == "genextreme": - s = np.sqrt(6 * v) / np.pi - return (0.1,), {"loc": m - 0.57722 * s, "scale": s} - - if dist == "genpareto" and "floc" in fitkwargs: - # Taken from julia' Extremes. Case for when "mu/loc" is known. - t = fitkwargs["floc"] - if not np.isclose(t, 0): - m = (x - t).mean() - v = (x - t).var() - - c = 0.5 * (1 - m**2 / v) - scale = (1 - c) * m - return (c,), {"scale": scale} - - if dist in "weibull_min": - s = x.std() - loc = x.min() - 0.01 * s - chat = np.pi / np.sqrt(6) / (np.log(x - loc)).std() - scale = ((x - loc) ** chat).mean() ** (1 / chat) - return (chat,), {"loc": loc, "scale": scale} - - if dist in ["gamma"]: - if "floc" in fitkwargs: - loc0 = fitkwargs["floc"] - else: - xs = sorted(x) - x1, x2, xn = xs[0], xs[1], xs[-1] - # muralidhar_1992 would suggest the following, but it seems more unstable - # using cooke_1979 for now - # n = len(x) - # cv = x.std() / x.mean() - # p = (0.48265 + 0.32967 * cv) * n ** (-0.2984 * cv) - # xp = xs[int(p/100*n)] - xp = x2 - loc0 = (x1 * xn - xp**2) / (x1 + xn - 2 * xp) - loc0 = loc0 if loc0 < x1 else (0.9999 * x1 if x1 > 0 else 1.0001 * x1) - x_pos = x - loc0 - x_pos = x_pos[x_pos > 0] - m = x_pos.mean() - log_of_mean = np.log(m) - mean_of_logs = np.log(x_pos).mean() - A = log_of_mean - mean_of_logs - a0 = (1 + np.sqrt(1 + 4 * A / 3)) / (4 * A) - scale0 = m / a0 - kwargs = {"scale": scale0, "loc": loc0} - return (a0,), kwargs - - if dist in ["fisk"]: - if "floc" in fitkwargs: - loc0 = fitkwargs["floc"] - else: - xs = sorted(x) - x1, x2, xn = xs[0], xs[1], xs[-1] - loc0 = (x1 * xn - x2**2) / (x1 + xn - 2 * x2) - loc0 = loc0 if loc0 < x1 else (0.9999 * x1 if x1 > 0 else 1.0001 * x1) - x_pos = x - loc0 - x_pos = x_pos[x_pos > 0] - # method of moments: - # LHS is computed analytically with the two-parameters log-logistic distribution - # and depends on alpha,beta - # RHS is from the sample - # <x> = m - # <x^2> / <x>^2 = m2/m**2 - # solving these equations yields - m = x_pos.mean() - m2 = (x_pos**2).mean() - scale0 = 2 * m**3 / (m2 + m**2) - c0 = np.pi * m / np.sqrt(3) / np.sqrt(m2 - m**2) - kwargs = {"scale": scale0, "loc": loc0} - return (c0,), kwargs - return (), {} - - -def _dist_method_1D( # noqa: N802 - *args: Sequence[str], - dist: str | scipy.stats.rv_continuous, - function: str, - **kwargs: dict[str, Any], -) -> xr.DataArray: - r"""Statistical function for given argument on given distribution initialized with params. - - See :py:ref:`scipy.stats.rv_continuous` for all available functions and their arguments. - Every method where `"*args"` are the distribution parameters can be wrapped. - - Parameters - ---------- - \*args : str - The arguments for the requested scipy function. - dist : str - The scipy name of the distribution. - function : str - The name of the function to call. - \*\*kwargs L - Other parameters to pass to the function call. - - Returns - ------- - array_like - """ - dist = get_dist(dist) - return getattr(dist, function)(*args, **kwargs) - - -def dist_method( - function: str, - fit_params: xr.DataArray, - arg: xr.DataArray | None = None, - dist: str | scipy.stats.rv_continuous | None = None, - **kwargs: dict[str, Any], -) -> xr.DataArray: - r"""Vectorized statistical function for given argument on given distribution initialized with params. - - Methods where `"*args"` are the distribution parameters can be wrapped, except those that reduce dimensions ( - e.g. `nnlf`) or create new dimensions (eg: 'rvs' with size != 1, 'stats' with more than one moment, 'interval', - 'support'). - - Parameters - ---------- - function : str - The name of the function to call. - fit_params : xr.DataArray - Distribution parameters are along `dparams`, in the same order as given by :py:func:`fit`. - arg : array_like, optional - The first argument for the requested function if different from `fit_params`. - dist : str pr rv_continuous, optional - The distribution name or instance. Defaults to the `scipy_dist` attribute or `fit_params`. - \*\*kwargs : dict - Other parameters to pass to the function call. - - Returns - ------- - array_like - Same shape as arg. - - See Also - -------- - scipy.stats.rv_continuous : for all available functions and their arguments. - """ - # Typically the data to be transformed - arg = [arg] if arg is not None else [] - if function == "nnlf": - raise ValueError( - "This method is not supported because it reduces the dimensionality of the data." - ) - - # We don't need to set `input_core_dims` because we're explicitly splitting the parameters here. - args = arg + [fit_params.sel(dparams=dp) for dp in fit_params.dparams.values] - - return xr.apply_ufunc( - _dist_method_1D, - *args, - kwargs={ - "dist": dist or fit_params.attrs["scipy_dist"], - "function": function, - **kwargs, - }, - output_dtypes=[float], - dask="parallelized", - ) diff --git a/tests/conftest.py b/tests/conftest.py index 7cdf41d..a0cc3b6 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -139,23 +139,6 @@ def timelonlatseries(): return test_timelonlatseries -# ADAPT -# @pytest.fixture -# def per_doy(): -# def _per_doy(values, calendar="standard", units="kg m-2 s-1"): -# n = max_doy[calendar] -# if len(values) != n: -# raise ValueError( -# "Values must be same length as number of days in calendar." -# ) -# coords = xr.IndexVariable("dayofyear", np.arange(1, n + 1)) -# return xr.DataArray( -# values, coords=[coords], attrs={"calendar": calendar, "units": units} -# ) - -# return _per_doy - - @pytest.fixture def areacella() -> xr.DataArray: """Return a rectangular grid of grid cell area.""" From fc316ea3302ba50e8103209d24f0b0b562f9ffe8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 23 Oct 2024 17:39:43 -0400 Subject: [PATCH 087/105] add nbsphinx --- environment-docs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment-docs.yml b/environment-docs.yml index 5c88da2..c3c0aa7 100644 --- a/environment-docs.yml +++ b/environment-docs.yml @@ -14,3 +14,4 @@ dependencies: - sphinxcontrib-bibtex - sphinxcontrib-napoleon - typer >=0.12.3 + - nbsphinx From c0c8c2d7d6f6102f9c377f075fb4597d6598f15e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 24 Oct 2024 08:04:55 -0400 Subject: [PATCH 088/105] add ipython to dependencies --- environment-docs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment-docs.yml b/environment-docs.yml index c3c0aa7..e59ab7f 100644 --- a/environment-docs.yml +++ b/environment-docs.yml @@ -15,3 +15,4 @@ dependencies: - sphinxcontrib-napoleon - typer >=0.12.3 - nbsphinx + - ipython From 0599392c16554de82732f48b43eab4a57fba428f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 24 Oct 2024 08:35:49 -0400 Subject: [PATCH 089/105] add ipykernel to deps --- environment-docs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment-docs.yml b/environment-docs.yml index e59ab7f..f6dd18e 100644 --- a/environment-docs.yml +++ b/environment-docs.yml @@ -16,3 +16,4 @@ dependencies: - typer >=0.12.3 - nbsphinx - ipython + - ipykernel From 803e677b426ce784416e4145b2652becbe887261 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 25 Oct 2024 14:22:28 -0400 Subject: [PATCH 090/105] cleaning (dependencies, remove xclim53 hacks) --- .pre-commit-config.yaml | 2 +- .readthedocs.yml | 4 ---- CHANGELOG.rst | 2 +- environment-dev.yml | 1 + pyproject.toml | 7 +++---- tox.ini | 2 -- 6 files changed, 6 insertions(+), 12 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8d02763..9f00142 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -68,7 +68,7 @@ repos: rev: v1.8.0 hooks: - id: numpydoc-validation - exclude: ^docs/|^tests/|src/xsdba/xclim_submodules/ + exclude: ^docs/|^tests/ - repo: https://github.com/python-jsonschema/check-jsonschema rev: 0.29.2 hooks: diff --git a/.readthedocs.yml b/.readthedocs.yml index 66b4c6a..c623e5e 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -15,10 +15,6 @@ build: tools: python: "mambaforge-22.9" jobs: - pre_install: - # FIXME: This is a workaround to install xclim v0.53, which is not released. - - mamba install -y -n base -c conda-forge "xclim=0.52.2" - - python -m pip install git+https://github.com/Ouranosinc/xclim.git@main pre_build: - sphinx-apidoc -o docs/apidoc --private --module-first src/xsdba - sphinx-build -M gettext docs docs/_build diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 4c58781..63f054c 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -10,7 +10,7 @@ Contributors: Éric Dupuis (:user:`coxipi`), Trevor James Smith (:user:`Zeitsper Changes ^^^^^^^ * Split `sdba` from `xclim` and duplicate code where needed. (:pull:`8`) -* `calendar` and `units` are copy (or almost) of given modules in `xclim`. Perhaps in the future some functionalities can be put in a common generic module (:pull:`8`) +* `units` are a copy (or almost) of given modules in `xclim`. A lot of duplicated code from xclim's `calendar` is also in xsdba's `base`. (:pull:`8`) .. _changes_0.1.0: diff --git a/environment-dev.yml b/environment-dev.yml index 7bba6d4..4942235 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -17,6 +17,7 @@ dependencies: - scipy >=1.9.0 - statsmodels - xarray >=2023.11.0 + - xclim >= 0.53 - yamale # Dev tools and testing - netcdf4 diff --git a/pyproject.toml b/pyproject.toml index e0dfffa..0e761f9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,3 @@ -# SPLIT: many checks removed - [build-system] requires = ["flit_core >=3.9,<4"] build-backend = "flit_core.buildapi" @@ -76,7 +74,8 @@ dev = [ "ruff >=0.5.7", "pooch >=1.8.0", "pre-commit >=3.5.0", - "xdoctest>=1.1.5" + "xdoctest>=1.1.5", + "xclim >= 0.53" ] docs = [ # Documentation and examples @@ -98,7 +97,6 @@ docs = [ "sphinxcontrib-bibtex", "sphinxcontrib-svg2pdfconverter[Cairosvg]" ] -extras = ["xclim>=0.52"] all = ["xsdba[dev]", "xsdba[docs]"] [project.scripts] @@ -257,6 +255,7 @@ allow_untyped_defs = true disable_error_code = "attr-defined" ignore_missing_imports = true +# SPLIT: many checks removed [tool.numpydoc_validation] checks = [ "all", # report on all checks, except the below diff --git a/tox.ini b/tox.ini index 1996fe2..5b5ffe2 100644 --- a/tox.ini +++ b/tox.ini @@ -59,8 +59,6 @@ commands_pre = pip list pip check commands = - ; Install the development version of xclim until v0.53.0 is released - pip install git+https://github.com/Ouranosinc/xclim.git@main pytest --cov xsdba -m "not requires_atmosds" {posargs} ; Coveralls requires access to a repo token set in .coveralls.yml in order to report stats coveralls: - coveralls From 0eff02835558fd54416bb2a4dfe81472ff5622ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 29 Oct 2024 16:52:22 -0400 Subject: [PATCH 091/105] update sdba from xclim --- src/xsdba/_adjustment.py | 481 +++++++++++++++++++++++++++++++++++++-- src/xsdba/_processing.py | 19 +- src/xsdba/adjustment.py | 420 ++++++++++++++++++++++++++++++---- src/xsdba/base.py | 10 +- src/xsdba/detrending.py | 1 - src/xsdba/measures.py | 15 +- src/xsdba/nbutils.py | 38 ++-- src/xsdba/processing.py | 17 +- src/xsdba/properties.py | 20 +- src/xsdba/units.py | 182 ++++++++++----- src/xsdba/utils.py | 26 ++- tests/test_adjustment.py | 433 +++++++++++++++++++++++++++++------ tests/test_detrending.py | 2 +- tests/test_properties.py | 54 ++--- tests/test_units.py | 21 +- 15 files changed, 1444 insertions(+), 295 deletions(-) diff --git a/src/xsdba/_adjustment.py b/src/xsdba/_adjustment.py index ad3e214..4803231 100644 --- a/src/xsdba/_adjustment.py +++ b/src/xsdba/_adjustment.py @@ -31,7 +31,7 @@ def _adapt_freq_hist(ds: xr.Dataset, adapt_freq_thresh: str): thresh = convert_units_to(adapt_freq_thresh, ds.ref) dim = ["time"] + ["window"] * ("window" in ds.hist.dims) return _adapt_freq.func( - xr.Dataset(dict(sim=ds.hist, ref=ds.ref)), thresh=thresh, dim=dim + xr.Dataset({"sim": ds.hist, "ref": ds.ref}), thresh=thresh, dim=dim ).sim_ad @@ -95,7 +95,7 @@ def dqm_train( mu_hist = ds.hist.mean(dim) scaling = u.get_correction(mu_hist, mu_ref, kind=kind) - return xr.Dataset(data_vars=dict(af=af, hist_q=hist_q, scaling=scaling)) + return xr.Dataset(data_vars={"af": af, "hist_q": hist_q, "scaling": scaling}) @map_groups( @@ -150,7 +150,7 @@ def eqm_train( af = u.get_correction(hist_q, ref_q, kind) - return xr.Dataset(data_vars=dict(af=af, hist_q=hist_q)) + return xr.Dataset(data_vars={"af": af, "hist_q": hist_q}) def _npdft_train(ref, hist, rots, quantiles, method, extrap, n_escore, standardize): @@ -174,13 +174,13 @@ def _npdft_train(ref, hist, rots, quantiles, method, extrap, n_escore, standardi np.nanstd(hist, axis=-1, keepdims=True) ) af_q = np.zeros((len(rots), ref.shape[0], len(quantiles))) - escores = np.zeros(len(rots)) * np.NaN + escores = np.zeros(len(rots)) * np.nan if n_escore > 0: ref_step, hist_step = ( int(np.ceil(arr.shape[1] / n_escore)) for arr in [ref, hist] ) - for ii in range(len(rots)): - rot = rots[0] if ii == 0 else rots[ii] @ rots[ii - 1].T + for ii, _rot in enumerate(rots): + rot = _rot if ii == 0 else _rot @ rots[ii - 1].T ref, hist = rot @ ref, rot @ hist # loop over variables for iv in range(ref.shape[0]): @@ -292,7 +292,7 @@ def mbcn_train( escores_l.append(escores.expand_dims({gr_dim: [ib]})) af_q = xr.concat(af_q_l, dim=gr_dim) escores = xr.concat(escores_l, dim=gr_dim) - out = xr.Dataset(dict(af_q=af_q, escores=escores)).assign_coords( + out = xr.Dataset({"af_q": af_q, "escores": escores}).assign_coords( {"quantiles": quantiles, gr_dim: gw_idxs[gr_dim].values} ) return out @@ -316,8 +316,8 @@ def _npdft_adjust(sim, af_q, rots, quantiles, method, extrap): sim = sim[:, np.newaxis, :] # adjust npdft - for ii in range(len(rots)): - rot = rots[0] if ii == 0 else rots[ii] @ rots[ii - 1].T + for ii, _rot in enumerate(rots): + rot = _rot if ii == 0 else _rot @ rots[ii - 1].T sim = np.einsum("ij,j...->i...", rot, sim) # loop over variables for iv in range(sim.shape[0]): @@ -387,7 +387,7 @@ def mbcn_adjust( adj_kws : Dict Options for univariate adjust for the scenario that is reordered with the output of npdf transform. period_dim : str, optional - Name of the period dimension used when stacking time periods of `sim` using :py:func:`xsdba.calendar.stack_periods`. + Name of the period dimension used when stacking time periods of `sim` using :py:func:`xsdba.base.stack_periods`. If specified, the interpolation of the npdf transform is performed only once and applied on all periods simultaneously. This should be more performant, but also more memory intensive. Defaults to `None`: No optimization will be attempted. @@ -596,7 +596,7 @@ def qdm_adjust(ds: xr.Dataset, *, group, interp, extrapolation, kind) -> xr.Data extrapolation=extrapolation, ) scen = u.apply_correction(ds.sim, af, kind) - return xr.Dataset(dict(scen=scen, sim_q=sim_q)) + return xr.Dataset({"scen": scen, "sim_q": sim_q}) @map_blocks( @@ -757,10 +757,10 @@ def npdf_transform(ds: xr.Dataset, **kwargs) -> xr.Dataset: if kwargs["n_escore"] >= 0: escores = xr.concat(escores, "iterations") else: - # All NaN, but with the proper shape. + # All nan, but with the proper shape. escores = ( ref.isel({dim: 0, "time": 0}) * hist.isel({dim: 0, "time": 0}) - ).expand_dims(iterations=ds.iterations) * np.NaN + ).expand_dims(iterations=ds.iterations) * np.nan return xr.Dataset( data_vars={ @@ -814,8 +814,8 @@ def _extremes_train_1d(ref, hist, ref_params, *, q_thresh, cluster_thresh, dist, af = hist_in_ref / hist[Pcommon] # sort them in Px order, and pad to have N values. order = np.argsort(Px_hist) - px_hist = np.pad(Px_hist[order], ((0, N - af.size),), constant_values=np.NaN) - af = np.pad(af[order], ((0, N - af.size),), constant_values=np.NaN) + px_hist = np.pad(Px_hist[order], ((0, N - af.size),), constant_values=np.nan) + af = np.pad(af[order], ((0, N - af.size),), constant_values=np.nan) return px_hist, af, thresh @@ -858,7 +858,7 @@ def extremes_train( _extremes_train_1d, ds.ref, ds.hist, - ds.ref_params or np.NaN, + ds.ref_params or np.nan, input_core_dims=[("time",), ("time",), ()], output_core_dims=[("quantiles",), ("quantiles",), ()], vectorize=True, @@ -949,3 +949,452 @@ def extremes_adjust( adjusted: xr.DataArray = (transition * scen) + ((1 - transition) * ds.scen) out = adjusted.rename("scen").squeeze("group", drop=True).to_dataset() return out + + +def _otc_adjust( + X: np.ndarray, + Y: np.ndarray, + bin_width: dict | float | np.ndarray | None = None, + bin_origin: dict | float | np.ndarray | None = None, + num_iter_max: int | None = 100_000_000, + jitter_inside_bins: bool = True, + normalization: str | None = "max_distance", +): + """Optimal Transport Correction of the bias of X with respect to Y. + + Parameters + ---------- + X : np.ndarray + Historical data to be corrected. + Y : np.ndarray + Bias correction reference, target of optimal transport. + bin_width : dict or float or np.ndarray, optional + Bin widths for specified dimensions. + bin_origin : dict or float or np.ndarray, optional + Bin origins for specified dimensions. + num_iter_max : int, optional + Maximum number of iterations used in the earth mover distance algorithm. + jitter_inside_bins : bool + If `False`, output points are located at the center of their bin. + If `True`, a random location is picked uniformly inside their bin. Default is `True`. + normalization : {None, 'standardize', 'max_distance', 'max_value'} + Per-variable transformation applied before the distances are calculated + in the optimal transport. + + Returns + ------- + np.ndarray + Adjusted data. + + References + ---------- + :cite:cts:`sdba-robin_2021` + """ + # Initialize parameters + if bin_width is None: + bin_width = u.bin_width_estimator([Y, X]) + elif isinstance(bin_width, dict): + _bin_width = u.bin_width_estimator([Y, X]) + for k, v in bin_width.items(): + _bin_width[k] = v + bin_width = _bin_width + elif isinstance(bin_width, float | int): + bin_width = np.ones(X.shape[1]) * bin_width + + if bin_origin is None: + bin_origin = np.zeros(X.shape[1]) + elif isinstance(bin_origin, dict): + _bin_origin = np.zeros(X.shape[1]) + if bin_origin is not None: + for v, k in bin_origin.items(): + _bin_origin[v] = k + bin_origin = _bin_origin + elif isinstance(bin_origin, float | int): + bin_origin = np.ones(X.shape[1]) * bin_origin + + num_iter_max = 100_000_000 if num_iter_max is None else num_iter_max + + # Get the bin positions and frequencies of X and Y, and for all Xs the bin to which they belong + gridX, muX, binX = u.histogram(X, bin_width, bin_origin) + gridY, muY, _ = u.histogram(Y, bin_width, bin_origin) + + # Compute the optimal transportation plan + plan = u.optimal_transport(gridX, gridY, muX, muY, num_iter_max, normalization) + + gridX = np.floor((gridX - bin_origin) / bin_width) + gridY = np.floor((gridY - bin_origin) / bin_width) + + # regroup the indices of all the points belonging to a same bin + binX_sort = np.lexsort(binX[:, ::-1].T) + sorted_bins = binX[binX_sort] + _, binX_start, binX_count = np.unique( + sorted_bins, return_index=True, return_counts=True, axis=0 + ) + binX_start_sort = np.sort(binX_start) + binX_groups = np.split(binX_sort, binX_start_sort[1:]) + + out = np.empty(X.shape) + rng = np.random.default_rng() + # The plan row corresponding to a source bin indicates its probabilities to be transported to every target bin + for i, binX_group in enumerate(binX_groups): + # Pick as much target bins for this source bin as there are points in the source bin + choice = rng.choice(range(muY.size), p=plan[i, :], size=binX_count[i]) + out[binX_group] = (gridY[choice] + 1 / 2) * bin_width + bin_origin + + if jitter_inside_bins: + out += np.random.uniform(low=-bin_width / 2, high=bin_width / 2, size=out.shape) + + return out + + +@map_groups(scen=[Grouper.DIM]) +def otc_adjust( + ds: xr.Dataset, + dim: list, + pts_dim: str, + bin_width: dict | float | None = None, + bin_origin: dict | float | None = None, + num_iter_max: int | None = 100_000_000, + jitter_inside_bins: bool = True, + adapt_freq_thresh: dict | None = None, + normalization: str | None = "max_distance", +): + """Optimal Transport Correction of the bias of `hist` with respect to `ref`. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : training target + hist : training data + dim : list + The dimensions defining the distribution on which optimal transport is performed. + pts_dim : str + The dimension defining the multivariate components of the distribution. + bin_width : dict or float, optional + Bin widths for specified dimensions. + bin_origin : dict or float, optional + Bin origins for specified dimensions. + num_iter_max : int, optional + Maximum number of iterations used in the earth mover distance algorithm. + jitter_inside_bins : bool + If `False`, output points are located at the center of their bin. + If `True`, a random location is picked uniformly inside their bin. Default is `True`. + adapt_freq_thresh : dict, optional + Threshold for frequency adaptation per variable. + normalization : {None, 'standardize', 'max_distance', 'max_value'} + Per-variable transformation applied before the distances are calculated + in the optimal transport. + + Returns + ------- + xr.Dataset + Adjusted data. + """ + ref = ds.ref + hist = ds.hist + + if adapt_freq_thresh is not None: + for var, thresh in adapt_freq_thresh.items(): + hist.loc[var] = _adapt_freq_hist( + xr.Dataset( + {"ref": ref.sel({pts_dim: var}), "hist": hist.sel({pts_dim: var})} + ), + thresh, + ) + + ref_map = {d: f"ref_{d}" for d in dim} + ref = ref.rename(ref_map).stack(dim_ref=ref_map.values()).dropna(dim="dim_ref") + + hist = hist.stack(dim_hist=dim).dropna(dim="dim_hist") + + if isinstance(bin_width, dict): + bin_width = { + np.where(ref[pts_dim].values == var)[0][0]: op + for var, op in bin_width.items() + } + if isinstance(bin_origin, dict): + bin_origin = { + np.where(ref[pts_dim].values == var)[0][0]: op + for var, op in bin_origin.items() + } + + scen = xr.apply_ufunc( + _otc_adjust, + hist, + ref, + kwargs={ + "bin_width": bin_width, + "bin_origin": bin_origin, + "num_iter_max": num_iter_max, + "jitter_inside_bins": jitter_inside_bins, + "normalization": normalization, + }, + input_core_dims=[["dim_hist", pts_dim], ["dim_ref", pts_dim]], + output_core_dims=[["dim_hist", pts_dim]], + keep_attrs=True, + vectorize=True, + ) + + # Pad dim differences with NA to please map_blocks + ref = ref.unstack().rename({v: k for k, v in ref_map.items()}) + scen = scen.unstack().rename("scen") + for d in dim: + full_d = xr.concat([ref[d], scen[d]], dim=d).drop_duplicates(d) + scen = scen.reindex({d: full_d}) + + return scen.to_dataset() + + +def _dotc_adjust( + X1: np.ndarray, + Y0: np.ndarray, + X0: np.ndarray, + bin_width: dict | float | None = None, + bin_origin: dict | float | None = None, + num_iter_max: int | None = 100_000_000, + cov_factor: str | None = "std", + jitter_inside_bins: bool = True, + kind: dict | None = None, + normalization: str | None = "max_distance", +): + """Dynamical Optimal Transport Correction of the bias of X with respect to Y. + + Parameters + ---------- + X1 : np.ndarray + Simulation data to adjust. + Y0 : np.ndarray + Bias correction reference. + X0 : np.ndarray + Historical simulation data. + bin_width : dict or float, optional + Bin widths for specified dimensions. + bin_origin : dict or float, optional + Bin origins for specified dimensions. + num_iter_max : int, optional + Maximum number of iterations used in the earth mover distance algorithm. + cov_factor : str, optional + Rescaling factor. + jitter_inside_bins : bool + If `False`, output points are located at the center of their bin. + If `True`, a random location is picked uniformly inside their bin. Default is `True`. + kind : dict, optional + Keys are variable names and values are adjustment kinds, either additive or multiplicative. + Unspecified dimensions are treated as "+". + normalization : {None, 'standardize', 'max_distance', 'max_value'} + Per-variable transformation applied before the distances are calculated + in the optimal transport. + + Returns + ------- + np.ndarray + Adjusted data. + + References + ---------- + :cite:cts:`sdba-robin_2021` + """ + # Initialize parameters + if isinstance(bin_width, dict): + _bin_width = u.bin_width_estimator([Y0, X0, X1]) + for v, k in bin_width.items(): + _bin_width[v] = k + bin_width = _bin_width + elif isinstance(bin_width, float | int): + bin_width = np.ones(X0.shape[1]) * bin_width + + if isinstance(bin_origin, dict): + _bin_origin = np.zeros(X0.shape[1]) + for v, k in bin_origin.items(): + _bin_origin[v] = k + bin_origin = _bin_origin + elif isinstance(bin_origin, float | int): + bin_origin = np.ones(X0.shape[1]) * bin_origin + + # Map ref to hist + yX0 = _otc_adjust( + Y0, + X0, + bin_width=bin_width, + bin_origin=bin_origin, + num_iter_max=num_iter_max, + jitter_inside_bins=False, + normalization=normalization, + ) + + # Map hist to sim + yX1 = _otc_adjust( + yX0, + X1, + bin_width=bin_width, + bin_origin=bin_origin, + num_iter_max=num_iter_max, + jitter_inside_bins=False, + normalization=normalization, + ) + + # Temporal evolution + motion = np.empty(yX0.shape) + for j in range(yX0.shape[1]): + if kind is not None and j in kind.keys() and kind[j] == "*": + motion[:, j] = yX1[:, j] / yX0[:, j] + else: + motion[:, j] = yX1[:, j] - yX0[:, j] + + # Apply a variance dependent rescaling factor + if cov_factor == "cholesky": + fact0 = u.eps_cholesky(np.cov(Y0, rowvar=False)) + fact1 = u.eps_cholesky(np.cov(X0, rowvar=False)) + motion = (fact0 @ np.linalg.inv(fact1) @ motion.T).T + elif cov_factor == "std": + fact0 = np.std(Y0, axis=0) + fact1 = np.std(X0, axis=0) + motion = motion @ np.diag(fact0 / fact1) + + # Apply the evolution to ref + Y1 = np.empty(yX0.shape) + for j in range(yX0.shape[1]): + if kind is not None and j in kind.keys() and kind[j] == "*": + Y1[:, j] = Y0[:, j] * motion[:, j] + else: + Y1[:, j] = Y0[:, j] + motion[:, j] + + # Map sim to the evolution of ref + Z1 = _otc_adjust( + X1, + Y1, + bin_width=bin_width, + bin_origin=bin_origin, + num_iter_max=num_iter_max, + jitter_inside_bins=jitter_inside_bins, + normalization=normalization, + ) + + return Z1 + + +@map_groups(scen=[Grouper.DIM]) +def dotc_adjust( + ds: xr.Dataset, + dim: list, + pts_dim: str, + bin_width: dict | float | None = None, + bin_origin: dict | float | None = None, + num_iter_max: int | None = 100_000_000, + cov_factor: str | None = "std", + jitter_inside_bins: bool = True, + kind: dict | None = None, + adapt_freq_thresh: dict | None = None, + normalization: str | None = "max_distance", +): + """Dynamical Optimal Transport Correction of the bias of X with respect to Y. + + Parameters + ---------- + ds : xr.Dataset + Dataset variables: + ref : training target + hist : training data + sim : simulated data + dim : list + The dimensions defining the distribution on which optimal transport is performed. + pts_dim : str + The dimension defining the multivariate components of the distribution. + bin_width : dict or float, optional + Bin widths for specified dimensions. + bin_origin : dict or float, optional + Bin origins for specified dimensions. + num_iter_max : int, optional + Maximum number of iterations used in the earth mover distance algorithm. + cov_factor : str, optional + Rescaling factor. + jitter_inside_bins : bool + If `False`, output points are located at the center of their bin. + If `True`, a random location is picked uniformly inside their bin. Default is `True`. + kind : dict, optional + Keys are variable names and values are adjustment kinds, either additive or multiplicative. + Unspecified dimensions are treated as "+". + adapt_freq_thresh : dict, optional + Threshold for frequency adaptation per variable. + normalization : {None, 'standardize', 'max_distance', 'max_value'} + Per-variable transformation applied before the distances are calculated + in the optimal transport. + + Returns + ------- + xr.Dataset + Adjusted data. + """ + hist = ds.hist + sim = ds.sim + ref = ds.ref + + if adapt_freq_thresh is not None: + for var, thresh in adapt_freq_thresh.items(): + hist.loc[var] = _adapt_freq_hist( + xr.Dataset( + {"ref": ref.sel({pts_dim: var}), "hist": hist.sel({pts_dim: var})} + ), + thresh, + ) + + # Drop data added by map_blocks and prepare for apply_ufunc + hist_map = {d: f"hist_{d}" for d in dim} + hist = ( + hist.rename(hist_map).stack(dim_hist=hist_map.values()).dropna(dim="dim_hist") + ) + + ref_map = {d: f"ref_{d}" for d in dim} + ref = ref.rename(ref_map).stack(dim_ref=ref_map.values()).dropna(dim="dim_ref") + + sim = sim.stack(dim_sim=dim).dropna(dim="dim_sim") + + if kind is not None: + kind = { + np.where(ref[pts_dim].values == var)[0][0]: op for var, op in kind.items() + } + if isinstance(bin_width, dict): + bin_width = { + np.where(ref[pts_dim].values == var)[0][0]: op + for var, op in bin_width.items() + } + if isinstance(bin_origin, dict): + bin_origin = { + np.where(ref[pts_dim].values == var)[0][0]: op + for var, op in bin_origin.items() + } + + scen = xr.apply_ufunc( + _dotc_adjust, + sim, + ref, + hist, + kwargs={ + "bin_width": bin_width, + "bin_origin": bin_origin, + "num_iter_max": num_iter_max, + "cov_factor": cov_factor, + "jitter_inside_bins": jitter_inside_bins, + "kind": kind, + "normalization": normalization, + }, + input_core_dims=[ + ["dim_sim", pts_dim], + ["dim_ref", pts_dim], + ["dim_hist", pts_dim], + ], + output_core_dims=[["dim_sim", pts_dim]], + keep_attrs=True, + vectorize=True, + ) + + # Pad dim differences with NA to please map_blocks + hist = hist.unstack().rename({v: k for k, v in hist_map.items()}) + ref = ref.unstack().rename({v: k for k, v in ref_map.items()}) + scen = scen.unstack().rename("scen") + for d in dim: + full_d = xr.concat([hist[d], ref[d], scen[d]], dim=d).drop_duplicates(d) + scen = scen.reindex({d: full_d}) + + return scen.to_dataset() diff --git a/src/xsdba/_processing.py b/src/xsdba/_processing.py index 2863ae0..adaf0b3 100644 --- a/src/xsdba/_processing.py +++ b/src/xsdba/_processing.py @@ -124,7 +124,7 @@ def _normalize( Returns ------- xr.Dataset - Group-wise anomaly of 'x'. + Group-wise anomaly of x. Notes ----- @@ -137,7 +137,7 @@ def _normalize( norm.attrs["_group_apply_reshape"] = True return xr.Dataset( - dict(data=apply_correction(ds.data, invert(norm, kind), kind), norm=norm) + {"data": apply_correction(ds.data, invert(norm, kind), kind), "norm": norm} ) @@ -186,7 +186,8 @@ def _reordering_2d(data, ordr): .rename("reordered") .to_dataset() ) - elif len(dim) == 1: + + if len(dim) == 1: return ( xr.apply_ufunc( _reordering_1d, @@ -201,9 +202,9 @@ def _reordering_2d(data, ordr): .rename("reordered") .to_dataset() ) - else: - raise ValueError( - f"Reordering can only be done along one dimension." - f" If there is more than one, they should be `window` and `time`." - f" The dimensions are {dim}." - ) + + raise ValueError( + f"Reordering can only be done along one dimension. " + f"If there is more than one, they should be `window` and `time`. " + f"The dimensions are {dim}." + ) diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 12067a0..772efea 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -134,34 +134,29 @@ def _harmonize_units(cls, *inputs, target: dict[str] | str | None = None): """ def _harmonize_units_multivariate( - *inputs, dim, target: dict[str] | None = None + *_inputs, _dim, _target: dict[str] | None = None ): - def _convert_units_to(inda, dim, target): - varss = inda[dim].values - input_units = {} - for iv, v in enumerate(varss): - # FIXME: I think we should already have strings at this point - # see what deeper code must be fixed - input_units[v] = units2str(inda[dim].attrs["_units"][iv]) - target[v] = units2str(target[v]) - if input_units == target: - return inda - input_standard_names = { - v: inda[dim].attrs["_standard_name"][iv] + def __convert_units_to(_input_da, _internal_dim, _internal_target): + varss = _input_da[_internal_dim].values + input_units = { + v: _input_da[_internal_dim].attrs["_units"][iv] for iv, v in enumerate(varss) } + if input_units == _internal_target: + return _input_da for iv, v in enumerate(varss): - inda.attrs["units"] = input_units[v] - inda.attrs["standard_name"] = input_standard_names[v] - inda[{dim: iv}] = convert_units_to(inda[{dim: iv}], target[v]) - inda[dim].attrs["_units"][iv] = target[v] - inda.attrs["units"] = "" - inda.attrs.pop("standard_name") - return inda - - if target is None: - if "_units" not in inputs[0][dim].attrs or any( - [u is None for u in inputs[0][dim].attrs["_units"]] + _input_da.attrs["units"] = input_units[v] + _input_da[{_internal_dim: iv}] = convert_units_to( + _input_da[{_internal_dim: iv}], + _internal_target[v], + ) + _input_da[_internal_dim].attrs["_units"][iv] = _internal_target[v] + _input_da.attrs["units"] = "" + return _input_da + + if _target is None: + if "_units" not in _inputs[0][_dim].attrs or any( + u is None for u in _inputs[0][_dim].attrs["_units"] ): error_msg = ( "Units are missing in some or all of the stacked variables." @@ -169,17 +164,29 @@ def _convert_units_to(inda, dim, target): ) raise ValueError(error_msg) - target = { - v: units2str(inputs[0][dim].attrs["_units"][iv]) - for iv, v in enumerate(inputs[0][dim].values) + _target = { + v: _inputs[0][_dim].attrs["_units"][iv] + for iv, v in enumerate(_inputs[0][_dim].values) } - return ( - _convert_units_to(inda, dim=dim, target=target) for inda in inputs - ), target - for _dim, _crd in inputs[0].coords.items(): - if _crd.attrs.get("is_variables"): - return _harmonize_units_multivariate(*inputs, dim=_dim, target=target) + # `__convert_units_to`` was changing the units of the 3rd dataset during the 2nd loop + # This explicit loop is designed to avoid this + _outputs = [] + original_units = list( + [_inp[_dim].attrs["_units"].copy() for _inp in _inputs] + ) + for _inp, units in zip(_inputs, original_units, strict=False): + _inp[_dim].attrs["_units"] = units + _outputs.append( + __convert_units_to( + _inp, _internal_dim=_dim, _internal_target=_target + ) + ) + return _outputs, _target + + for dim, crd in inputs[0].coords.items(): + if crd.attrs.get("is_variables"): + return _harmonize_units_multivariate(*inputs, _dim=dim, _target=target) if target is None: target = inputs[0].units @@ -285,7 +292,7 @@ def adjust(self, sim: DataArray, *args, **kwargs): scen.attrs["bias_adjustment"] = infostr _is_multivariate = any( - [_crd.attrs.get("is_variables") for _crd in sim.coords.values()] + _crd.attrs.get("is_variables") for _crd in sim.coords.values() ) if _is_multivariate is False: scen.attrs["units"] = self.train_units @@ -322,7 +329,7 @@ def adjust( cls, ref: xr.DataArray, hist: xr.DataArray, - sim: xr.DataArray, + sim: xr.DataArray | None = None, **kwargs, ) -> xr.Dataset: r"""Return bias-adjusted data. Refer to the class documentation for the algorithm details. @@ -343,6 +350,10 @@ def adjust( xr.Dataset The bias-adjusted Dataset. """ + if sim is None: + sim = hist.copy() + sim.attrs["_is_hist"] = True + kwargs = parse_group(cls._adjust, kwargs) skip_checks = kwargs.pop("skip_input_checks", False) @@ -352,7 +363,7 @@ def adjust( (ref, hist, sim), _ = cls._harmonize_units(ref, hist, sim) - out: xr.Dataset | xr.DataArray = cls._adjust(ref, hist, sim, **kwargs) + out: xr.Dataset | xr.DataArray = cls._adjust(ref, hist, sim=sim, **kwargs) if isinstance(out, xr.DataArray): out = out.rename("scen").to_dataset() @@ -742,7 +753,7 @@ def _train( { "ref": ref, "hist": hist, - "ref_params": ref_params or np.float32(np.NaN), + "ref_params": ref_params or np.float32(np.nan), } ), q_thresh=q_thresh, @@ -1069,7 +1080,7 @@ def _compute_transform_matrices(ds, dim): hist_mean = group.apply("mean", hist) # Centroids of hist hist_mean.attrs.update(long_name="Centroid point of training.") - ds = xr.Dataset(dict(trans=trans, ref_mean=ref_mean, hist_mean=hist_mean)) + ds = xr.Dataset({"trans": trans, "ref_mean": ref_mean, "hist_mean": hist_mean}) ds.attrs["_reference_coord"] = lblR ds.attrs["_model_coord"] = lblM @@ -1230,8 +1241,8 @@ def _adjust( template = xr.Dataset( data_vars={ - "scenh": xr.full_like(hist, np.NaN).rename(time="time_hist"), - "scen": xr.full_like(sim, np.NaN), + "scenh": xr.full_like(hist, np.nan).rename(time="time_hist"), + "scen": xr.full_like(sim, np.nan), "escores": escores_tmpl, } ) @@ -1263,7 +1274,330 @@ def _adjust( return out -# TODO : Better document arguments of MBCn and its methods +class OTC(Adjust): + r"""Optimal Transport Correction. + + Following :cite:t:`sdba-robin_2019`, this multivariate bias correction method finds the optimal transport + mapping between simulated and observed data. The correction of every simulated data point is the observed + point it is mapped to. + + See notes for an explanation of the algorithm. + + Parameters + ---------- + bin_width : dict or float, optional + Bin widths for specified dimensions if is dict. + For all dimensions if float. + Will be estimated with Freedman-Diaconis rule by default. + bin_origin : dict or float, optional + Bin origins for specified dimensions if is dict. + For all dimensions if float. + Default is 0. + num_iter_max : int, optional + Maximum number of iterations used in the earth mover distance algorithm. + Default is 100_000_000. + jitter_inside_bins : bool + If `False`, output points are located at the center of their bin. + If `True`, a random location is picked uniformly inside their bin. Default is `True`. + adapt_freq_thresh : dict or str, optional + Threshold for frequency adaptation per variable. + See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Frequency adaptation is not applied to missing variables if is dict. + Applied to all variables if is string. + normalization : {None, 'standardize', 'max_distance', 'max_value'} + Per-variable transformation applied before the distances are calculated. + Default is "max_distance". + See notes for details. + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Default is "time", meaning a single adjustment group along dimension "time". + pts_dim : str + The name of the "multivariate" dimension. Defaults to "multivar", which is the + normal case when using :py:func:`xclim.sdba.base.stack_variables`. + + Notes + ----- + The simulated and observed data sets :math:`X` and :math:`Y` are discretized and standardized using histograms + whose bin length along dimension `v` is given by `bin_width[v]`. An optimal transport plan :math:`P^*` is found by solving + the linear program + + .. math:: + + \mathop{\arg\!\min}_{P} \langle P,C\rangle \\ + s.t. P\mathbf{1} = X \\ + P^T\mathbf{1} = Y \\ + P \geq 0 + + where :math:`C_{ij}` is the squared euclidean distance between the bin at position :math:`i` of :math:`X`'s histogram and + the bin at position :math:`j` of :math:`Y`'s. + + All data points belonging to input bin at position :math:`i` are then separately assigned to output bin at position :math:`j` + with probability :math:`P_{ij}`. A transformation of bin positions can be applied before computing the distances :math:`C_{ij}` + to make variables on different scales more evenly taken into consideration by the optimization step. Available transformations are + + - `normalization = 'standardize'` : + .. math:: + + i_v' = \frac{i_v - mean(i_v)}{std(i_v)} \quad\quad\quad j_v' = \frac{j_v - mean(j_v)}{std(j_v)} + + - `normalization = 'max_distance'` : + .. math:: + + i_v' = \frac{i_v}{max \{|i_v - j_v|\}} \quad\quad\quad j_v' = \frac{j_v}{max \{|i_v - j_v|\}} + + such that + .. math:: + + max \{|i_v' - j_v'|\} = max \{|i_w' - j_w'|\} = 1 + + - `normalization = 'max_value'` : + .. math:: + + i_v' = \frac{i_v}{max\{i_v\}} \quad\quad\quad j_v' = \frac{j_v}{max\{j_v\}} + + for variables :math:`v, w`. Default is `'max_distance'`. + + Note that `POT <https://pythonot.github.io/>`__ must be installed to use this method. + + This implementation is strongly inspired by :cite:t:`sdba-robin_2021`. + The differences from this implementation are : + + - `bin_width` and `bin_origin` are dictionaries or float + - Freedman-Diaconis rule is used to find the bin width when unspecified, and fallbacks to Scott's rule when 0 is obtained + - `jitter_inside_bins` argument + - `adapt_freq_thresh` argument + - `transform` argument + - `group` argument + - `pts_dim` argument + + References + ---------- + :cite:cts:`sdba-robin_2019,sdba-robin_2021` + """ + + @classmethod + def _adjust( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + *, + bin_width: dict | float | None = None, + bin_origin: dict | float | None = None, + num_iter_max: int | None = 100_000_000, + jitter_inside_bins: bool = True, + adapt_freq_thresh: dict | str | None = None, + normalization: str | None = "max_distance", + group: str | Grouper = "time", + pts_dim: str = "multivar", + **kwargs, + ) -> xr.DataArray: + if find_spec("ot") is None: + raise ImportError( + "POT is required for OTC and dOTC. Please install with `pip install POT`." + ) + + if normalization not in [None, "standardize", "max_distance", "max_value"]: + raise ValueError( + "`transform` should be in [None, 'standardize', 'max_distance', 'max_value']." + ) + + sim = kwargs.pop("sim") + if "_is_hist" not in sim.attrs: + raise ValueError("OTC does not take a `sim` argument.") + + if isinstance(adapt_freq_thresh, str): + adapt_freq_thresh = {v: adapt_freq_thresh for v in hist[pts_dim].values} + if adapt_freq_thresh is not None: + _, units = cls._harmonize_units(sim) + for var, thresh in adapt_freq_thresh.items(): + adapt_freq_thresh[var] = str(convert_units_to(thresh, units[var])) + + scen = otc_adjust( + xr.Dataset({"ref": ref, "hist": hist}), + bin_width=bin_width, + bin_origin=bin_origin, + num_iter_max=num_iter_max, + jitter_inside_bins=jitter_inside_bins, + adapt_freq_thresh=adapt_freq_thresh, + normalization=normalization, + group=group, + pts_dim=pts_dim, + ).scen + + if adapt_freq_thresh is not None: + for var in adapt_freq_thresh.keys(): + adapt_freq_thresh[var] = adapt_freq_thresh[var] + " " + units[var] + + for d in scen.dims: + if d != pts_dim: + scen = scen.dropna(dim=d) + + return scen + + +class dOTC(Adjust): + r"""Dynamical Optimal Transport Correction. + + This method is the dynamical version of :py:class:`~xclim.sdba.adjustment.OTC`, as presented by :cite:t:`sdba-robin_2019`. + The temporal evolution of the model is found for every point by mapping the historical to the future dataset with + optimal transport. A mapping between historical and reference data is found in the same way, and the temporal evolution + of model data is applied to their assigned reference. + + See notes for an explanation of the algorithm. + + This implementation is strongly inspired by :cite:t:`sdba-robin_2021`. + + Parameters + ---------- + bin_width : dict or float, optional + Bin widths for specified dimensions if is dict. + For all dimensions if float. + Will be estimated with Freedman-Diaconis rule by default. + bin_origin : dict or float, optional + Bin origins for specified dimensions if is dict. + For all dimensions if float. + Default is 0. + num_iter_max : int, optional + Maximum number of iterations used in the network simplex algorithm. + cov_factor : {None, 'std', 'cholesky'} + A rescaling of the temporal evolution before it is applied to the reference. + Note that "cholesky" cannot be used if some variables are multiplicative. + See notes for details. + jitter_inside_bins : bool + If `False`, output points are located at the center of their bin. + If `True`, a random location is picked uniformly inside their bin. Default is `True`. + kind : dict or str, optional + Keys are variable names and values are adjustment kinds, either additive or multiplicative. + Unspecified dimensions are treated as "+". + Applied to all variables if is string. + adapt_freq_thresh : dict or str, optional + Threshold for frequency adaptation per variable. + See :py:class:`xclim.sdba.processing.adapt_freq` for details. + Frequency adaptation is not applied to missing variables if is dict. + Applied to all variables if is string. + normalization : {None, 'standardize', 'max_distance', 'max_value'} + Per-variable transformation applied before the distances are calculated + in the optimal transport. Default is "max_distance". + See :py:class:`~xclim.sdba.adjustment.OTC` for details. + group : Union[str, Grouper] + The grouping information. See :py:class:`xclim.sdba.base.Grouper` for details. + Default is "time", meaning a single adjustment group along dimension "time". + pts_dim : str + The name of the "multivariate" dimension. Defaults to "multivar", which is the + normal case when using :py:func:`xclim.sdba.base.stack_variables`. + + Notes + ----- + The simulated historical, simulated future and observed data sets :math:`X0`, :math:`X1` and :math:`Y0` are + discretized and standardized using histograms whose bin length along dimension `k` is given by `bin_width[k]`. + Mappings between :math:`Y0` and :math:`X0` on the one hand and between :math:`X0` and :math:`X1` on the other + are found by optimal transport (see :py:class:`~xclim.sdba.adjustment.OTC`). The latter mapping is used to + compute the temporal evolution of model data. This evolution is computed additively or multiplicatively for + each variable depending on its `kind`, and is applied to observed data with + + .. math:: + + Y1_i & := Y0_i + D \cdot v_i \;\; or \\ + Y1_i & := Y0_i * D \cdot v_i + + where + - :math:`v_i` is the temporal evolution of historical simulated point :math:`i \in X0` to :math:`j \in X1` + - :math:`Y0_i` is the observed data mapped to :math:`i` + - :math:`D` is a correction factor given by + - :math:`I` if `cov_factor is None` + - :math:`diag(\frac{\sigma_{Y0}}{\sigma_{X0}})` if `cov_factor = "std"` + - :math:`\frac{Chol(Y0)}{Chol(X0)}` where :math:`Chol` is the Cholesky decomposition if `cov_factor = "cholesky"` + - :math:`Y1_i` is the correction of the future simulated data mapped to :math:`i`. + + Note that `POT <https://pythonot.github.io/>`__ must be installed to use this method. + + This implementation is strongly inspired by :cite:t:`sdba-robin_2021`. + The differences from this reference are : + + - `bin_width` and `bin_origin` are dictionaries or float. + - Freedman-Diaconis rule is used to find the bin width when unspecified, and fallbacks to Scott's rule when 0 is obtained. + - `jitter_inside_bins` argument + - `adapt_freq_thresh` argument + - `transform` argument + - `group` argument + - `pts_dim` argument + - `kind` argument + + References + ---------- + :cite:cts:`sdba-robin_2019,sdba-robin_2021` + """ + + @classmethod + def _adjust( + cls, + ref: xr.DataArray, + hist: xr.DataArray, + sim: xr.DataArray, + *, + bin_width: dict | float | None = None, + bin_origin: dict | float | None = None, + num_iter_max: int | None = 100_000_000, + cov_factor: str | None = "std", + jitter_inside_bins: bool = True, + kind: dict | str | None = None, + adapt_freq_thresh: dict | str | None = None, + normalization: str | None = "max_distance", + group: str | Grouper = "time", + pts_dim: str = "multivar", + ) -> xr.DataArray: + if find_spec("ot") is None: + raise ImportError( + "POT is required for OTC and dOTC. Please install with `pip install POT`." + ) + + if isinstance(kind, str): + kind = {v: kind for v in hist[pts_dim].values} + if kind is not None and "*" in kind.values() and cov_factor == "cholesky": + raise ValueError( + "Multiplicative correction is not supported with `cov_factor` = 'cholesky'." + ) + + if cov_factor not in [None, "std", "cholesky"]: + raise ValueError("`cov_factor` should be in [None, 'std', 'cholesky'].") + + if normalization not in [None, "standardize", "max_distance", "max_value"]: + raise ValueError( + "`normalization` should be in [None, 'standardize', 'max_distance', 'max_value']." + ) + + if isinstance(adapt_freq_thresh, str): + adapt_freq_thresh = {v: adapt_freq_thresh for v in hist[pts_dim].values} + if adapt_freq_thresh is not None: + _, units = cls._harmonize_units(sim) + for var, thresh in adapt_freq_thresh.items(): + adapt_freq_thresh[var] = str(convert_units_to(thresh, units[var])) + + scen = dotc_adjust( + xr.Dataset({"ref": ref, "hist": hist, "sim": sim}), + bin_width=bin_width, + bin_origin=bin_origin, + num_iter_max=num_iter_max, + cov_factor=cov_factor, + jitter_inside_bins=jitter_inside_bins, + kind=kind, + adapt_freq_thresh=adapt_freq_thresh, + normalization=normalization, + group=group, + pts_dim=pts_dim, + ).scen + + if adapt_freq_thresh is not None: + for var in adapt_freq_thresh.keys(): + adapt_freq_thresh[var] = adapt_freq_thresh[var] + " " + units[var] + + for d in scen.dims: + if d != pts_dim: + scen = scen.dropna(dim=d, how="all") + + return scen + + class MBCn(TrainAdjust): r"""Multivariate bias correction function using the N-dimensional probability density function transform. @@ -1389,7 +1723,7 @@ def _train( if isinstance(base_kws["group"], str): base_kws["group"] = Grouper(base_kws["group"], 1) if base_kws["group"].name == "time.month": - NotImplementedError( + raise NotImplementedError( "Received `group==time.month` in `base_kws`. Monthly grouping is not currently supported in the MBCn class." ) # stack variables and prepare rotations @@ -1412,7 +1746,7 @@ def _train( _, gw_idxs = grouped_time_indexes(ref.time, base_kws["group"]) # training, obtain adjustment factors of the npdf transform - ds = xr.Dataset(dict(ref=ref, hist=hist)) + ds = xr.Dataset({"ref": ref, "hist": hist}) params = { "quantiles": base_kws["nquantiles"], "interp": adj_kws["interp"], diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 9558f41..76a9c9a 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -58,7 +58,7 @@ def __getattr__(self, attr): @property def parameters(self) -> dict: """All parameters as a dictionary. Read-only.""" - return dict(**self) + return {**self} def __repr__(self) -> str: """Return a string representation.""" @@ -352,7 +352,7 @@ def apply( (if False, default) (including the window and dimensions given through `add_dims`). The dimensions used are also written in the "group_compute_dims" attribute. If all the input arrays are missing one of the 'add_dims', it is silently omitted. - \*\*kwargs : dict + \*\*kwargs Other keyword arguments to pass to the function. Returns @@ -529,7 +529,7 @@ def map_blocks( # noqa: C901 ---------- reduces : sequence of strings Name of the dimensions that are removed by the function. - \*\*out_vars : dict + \*\*out_vars Mapping from variable names in the output to their *new* dimensions. The placeholders ``Grouper.PROP``, ``Grouper.DIM`` and ``Grouper.ADD_DIMS`` can be used to signify ``group.prop``,``group.dim`` and ``group.add_dims`` respectively. @@ -605,7 +605,7 @@ def _map_blocks(ds, **kwargs): # noqa: C901 chunks = ( dict(ds.chunks) if isinstance(ds, xr.Dataset) - else dict(zip(ds.dims, ds.chunks)) + else dict(zip(ds.dims, ds.chunks, strict=False)) ) badchunks = {} if group is not None: @@ -750,7 +750,7 @@ def map_groups( if main_only is False, and [Grouper.DIM] if main_only is True. See :py:func:`map_blocks`. main_only : bool Same as for :py:meth:`Grouper.apply`. - \*\*out_vars : dict + \*\*out_vars Mapping from variable names in the output to their *new* dimensions. The placeholders ``Grouper.PROP``, ``Grouper.DIM`` and ``Grouper.ADD_DIMS`` can be used to signify ``group.prop``,``group.dim`` and ``group.add_dims``, respectively. diff --git a/src/xsdba/detrending.py b/src/xsdba/detrending.py index 9615903..e508750 100644 --- a/src/xsdba/detrending.py +++ b/src/xsdba/detrending.py @@ -61,7 +61,6 @@ def fit(self, da: xr.DataArray): new.set_dataset(new._get_trend(da).rename("trend").to_dataset()) if "units" in da.attrs: new.ds.trend.attrs["units"] = da.attrs["units"] - return new def _get_trend(self, da: xr.DataArray): diff --git a/src/xsdba/measures.py b/src/xsdba/measures.py index fc9eeeb..c261a42 100644 --- a/src/xsdba/measures.py +++ b/src/xsdba/measures.py @@ -18,7 +18,7 @@ from .base import Grouper from .typing import InputKind -from .units import convert_units_to, ensure_delta +from .units import convert_units_to, pint2cfattrs, units2pint from .utils import _pairwise_spearman @@ -128,9 +128,9 @@ def _postprocess(self, outs, das, params): """Squeeze `group` dim if needed.""" outs = super()._postprocess(outs, das, params) - for i in range(len(outs)): - if "group" in outs[i].dims: - outs[i] = outs[i].squeeze("group", drop=True) + for ii, out in enumerate(outs): + if "group" in out.dims: + outs[ii] = out.squeeze("group", drop=True) return outs @@ -157,8 +157,7 @@ def _bias(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray: Absolute bias. """ out = sim - ref - - out.attrs["units"] = ensure_delta(ref.attrs["units"]) + out.attrs.update(pint2cfattrs(units2pint(ref.attrs["units"]), is_difference=True)) return out @@ -281,7 +280,7 @@ def _rmse_internal(_sim: xr.DataArray, _ref: xr.DataArray) -> xr.DataArray: input_core_dims=[["time"], ["time"]], dask="parallelized", ) - out = out.assign_attrs(units=ensure_delta(ref.units)) + out = out.assign_attrs(pint2cfattrs(units2pint(ref.units), is_difference=True)) return out @@ -328,7 +327,7 @@ def _mae_internal(_sim: xr.DataArray, _ref: xr.DataArray) -> xr.DataArray: input_core_dims=[["time"], ["time"]], dask="parallelized", ) - out = out.assign_attrs(units=ensure_delta(ref.units)) + out = out.assign_attrs(pint2cfattrs(units2pint(ref.units), is_difference=True)) return out diff --git a/src/xsdba/nbutils.py b/src/xsdba/nbutils.py index adaa41c..8543b6b 100644 --- a/src/xsdba/nbutils.py +++ b/src/xsdba/nbutils.py @@ -246,26 +246,26 @@ def quantile(da: DataArray, q: np.ndarray, dim: str | Sequence[Hashable]) -> Dat """ if USE_FASTNANQUANTILE is True: return xr_apply_nanquantile(da, dim=dim, q=q).rename({"quantile": "quantiles"}) - else: - qc = np.array(q, dtype=da.dtype) - dims = [dim] if isinstance(dim, str) else dim - kwargs = dict(nreduce=len(dims), q=qc) - res = ( - apply_ufunc( - _quantile, - da, - input_core_dims=[dims], - exclude_dims=set(dims), - output_core_dims=[["quantiles"]], - output_dtypes=[da.dtype], - dask_gufunc_kwargs=dict(output_sizes={"quantiles": len(q)}), - dask="parallelized", - kwargs=kwargs, - ) - .assign_coords(quantiles=q) - .assign_attrs(da.attrs) + + qc = np.array(q, dtype=da.dtype) + dims = [dim] if isinstance(dim, str) else dim + kwargs = {"nreduce": len(dims), "q": qc} + res = ( + apply_ufunc( + _quantile, + da, + input_core_dims=[dims], + exclude_dims=set(dims), + output_core_dims=[["quantiles"]], + output_dtypes=[da.dtype], + dask_gufunc_kwargs={"output_sizes": {"quantiles": len(q)}}, + dask="parallelized", + kwargs=kwargs, ) - return res + .assign_coords(quantiles=q) + .assign_attrs(da.attrs) + ) + return res @njit( diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index 0cff1b9..ce4a226 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -275,7 +275,7 @@ def normalize( norm : xr.DataArray Mean over each group. """ - ds = xr.Dataset(dict(data=data)) + ds = xr.Dataset({"data": data}) if norm is not None: ds = ds.assign(norm=norm) @@ -465,11 +465,11 @@ def escore( out.name = "escores" out = out.assign_attrs( - dict( - long_name="Energy dissimilarity metric", - description=f"Escores computed from {N or 'all'} points.", - references="Székely, G. J. and Rizzo, M. L. (2004) Testing for Equal Distributions in High Dimension, InterStat, November (5)", - ) + { + "long_name": "Energy dissimilarity metric", + "description": f"Escores computed from {N or 'all'} points.", + "references": "Székely, G. J. and Rizzo, M. L. (2004) Testing for Equal Distributions in High Dimension, InterStat, November (5)", + } ) return out @@ -737,7 +737,7 @@ def stack_variables(ds: xr.Dataset, rechunk: bool = True, dim: str = "multivar") # sort to have coherent order with different datasets data_vars = sorted(ds.data_vars.items(), key=lambda e: e[0]) nvar = len(data_vars) - for i, (nm, var) in enumerate(data_vars): + for i, (_nm, var) in enumerate(data_vars): for name, attr in var.attrs.items(): attrs.setdefault(f"_{name}", [None] * nvar)[i] = attr @@ -790,7 +790,7 @@ def unstack_variables(da: xr.DataArray, dim: str | None = None) -> xr.Dataset: for name, attr_list in da[dim].attrs.items(): if not name.startswith("_"): continue - for attr, var in zip(attr_list, da[dim]): + for attr, var in zip(attr_list, da[dim], strict=False): if attr is not None: ds[var.item()].attrs[name[1:]] = attr @@ -824,6 +824,7 @@ def _get_group_complement(da, group): return da.time.dt.year if gr == "time.month": return da.time.dt.strftime("%Y-%d") + raise NotImplementedError(f"Grouping {gr} not implemented.") # does not work with group == "time.month" group = group if isinstance(group, Grouper) else Grouper(group) diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 670e8ae..12b97c7 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -23,7 +23,7 @@ from xsdba.units import ( convert_units_to, - ensure_delta, + pint2cfattrs, pint2str, to_agg_units, units2pint, @@ -74,7 +74,9 @@ def _ensure_correct_parameters(cls, parameters): return super()._ensure_correct_parameters(parameters) def _preprocess_and_checks(self, das, params): - """Check if group is allowed.""" + """Perform parent's checks and also check if group is allowed.""" + das, params = super()._preprocess_and_checks(das, params) + # Convert grouping and check if allowed: if isinstance(params["group"], str): params["group"] = Grouper(params["group"]) @@ -93,9 +95,9 @@ def _postprocess(self, outs, das, params): """Squeeze `group` dim if needed.""" outs = super()._postprocess(outs, das, params) - for i in range(len(outs)): - if "group" in outs[i].dims: - outs[i] = outs[i].squeeze("group", drop=True) + for ii, out in enumerate(outs): + if "group" in out.dims: + outs[ii] = out.squeeze("group", drop=True) return outs @@ -519,7 +521,7 @@ def acf_last(x, nlags): return out_last[-1] @map_groups(out=[Grouper.PROP], main_only=True) - def __acf(ds, *, dim, lag, freq): + def _acf(ds, *, dim, lag, freq): out = xr.apply_ufunc( acf_last, ds.data.resample({dim: freq}), @@ -530,7 +532,7 @@ def __acf(ds, *, dim, lag, freq): out = out.mean("__resample_dim__") return out.rename("out").to_dataset() - out = __acf( + out = _acf( da.rename("data").to_dataset(), group=group, lag=lag, freq=group.freq ).out out.attrs["units"] = "" @@ -594,7 +596,7 @@ def _annual_cycle( # TODO: In April 2024, use a match-case. if stat == "absamp": out = ac.max("dayofyear") - ac.min("dayofyear") - out.attrs["units"] = ensure_delta(units) + out.attrs.update(pint2cfattrs(units2pint(units), is_difference=True)) elif stat == "relamp": out = (ac.max("dayofyear") - ac.min("dayofyear")) * 100 / ac.mean("dayofyear") out.attrs["units"] = "%" @@ -711,7 +713,7 @@ def _annual_statistic( if stat == "absamp": out = yrs.max() - yrs.min() - out.attrs["units"] = ensure_delta(units) + out.attrs.update(pint2cfattrs(units2pint(units), is_difference=True)) elif stat == "relamp": out = (yrs.max() - yrs.min()) * 100 / yrs.mean() out.attrs["units"] = "%" diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 7e79c10..4dee1aa 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -38,10 +38,10 @@ "convert_units_to", "ensure_absolute_temperature", "ensure_cf_units", - "ensure_delta", "harmonize_units", "infer_context", "infer_sampling_units", + "pint2cfattrs", "pint2cfunits", "pint_multiply", "str2pint", @@ -50,10 +50,24 @@ "units2pint", ] -units = pint.get_application_registry() +# shamelessly adapted from `cf-xarray` (which adopted it from MetPy and xclim itself) +units = deepcopy(cf_xarray.units.units) +# Changing the default string format for units/quantities. +# CF is implemented by cf-xarray, g is the most versatile float format. +# The following try/except logic can be removed when xclim drops support numpy <2.0. +# try: +# units.formatter.default_format = "gcf" +# except UndefinedUnitError: +# units.default_format = "gcf" +# Switch this flag back to False. Not sure what that implies, but it breaks some tests. +units.force_ndarray_like = False # noqa: F841 # Another alias not included by cf_xarray units.define("@alias percent = pct") +# Default context. +null = pint.Context("none") +units.add_context(null) + FREQ_UNITS = { "D": "d", "W": "week", @@ -112,32 +126,44 @@ def infer_sampling_units( # XC -def units2pint(value: xr.DataArray | str | units.Quantity | units.Unit) -> pint.Unit: +def units2pint( + value: xr.DataArray | units.Unit | units.Quantity | dict | str, +) -> pint.Unit: """Return the pint Unit for the DataArray units. Parameters ---------- - value : xr.DataArray or str or pint.Quantity or pint.Unit + value : xr.DataArray or pint.Unit or pint.Quantity or dict or str Input data array or string representing a unit (with no magnitude). Returns ------- pint.Unit Units of the data array. + + Notes + ----- + To avoid ambiguity related to differences in temperature vs absolute temperatures, set the `units_metadata` + attribute to `"temperature: difference"` or `"temperature: on_scale"` on the DataArray. """ - if isinstance(value, str): - unit = value - elif isinstance(value, xr.DataArray): - unit = value.attrs["units"] - elif isinstance(value, units.Quantity): - # This is a pint.PlainUnit, which is not the same as a pint.Unit - return cast(pint.Unit, value.units) - elif isinstance(value, units.Quantity): + # Value is already a pint unit or a pint quantity + if isinstance(value, units.Unit): + return value + + if isinstance(value, units.Quantity): # This is a pint.PlainUnit, which is not the same as a pint.Unit return cast(pint.Unit, value.units) - elif isinstance(value, units.Unit): - # This is a pint.PlainUnit, which is not the same as a pint.Unit - return cast(pint.Unit, value) + + # We only need the attributes + if isinstance(value, xr.DataArray): + value = value.attrs + + if isinstance(value, str): + unit = value + metadata = None + elif isinstance(value, dict): + unit = value["units"] + metadata = value.get("units_metadata", None) else: raise NotImplementedError(f"Value of type `{type(value)}` not supported.") @@ -160,7 +186,10 @@ def units2pint(value: xr.DataArray | str | units.Quantity | units.Unit) -> pint. "Remove white space from temperature units, e.g. use `degC`." ) - return units.parse_units(unit) + pu = units.parse_units(unit) + if metadata == "temperature: difference": + return (1 * pu - 1 * pu).units + return pu def units2str(value: xr.DataArray | str | units.Quantity | units.Unit) -> str: @@ -279,6 +308,40 @@ def ensure_absolute_temperature(units: str): return units +def pint2cfattrs(value: units.Quantity | units.Unit, is_difference=None) -> dict: + """Return CF-compliant units attributes from a `pint` unit. + + Parameters + ---------- + value : pint.Unit + Input unit. + is_difference : bool + Whether the value represent a difference in temperature, which is ambiguous in the case of absolute + temperature scales like Kelvin or Rankine. It will automatically be set to True if units are "delta_*" + units. + + Returns + ------- + dict + Units following CF-Convention, using symbols. + """ + s = pint2cfunits(value) + if "delta_" in s: + is_difference = True + s = s.replace("delta_", "") + + attrs = {"units": s} + if "[temperature]" in value.dimensionality: + if is_difference: + attrs["units_metadata"] = "temperature: difference" + elif is_difference is False: + attrs["units_metadata"] = "temperature: on_scale" + else: + attrs["units_metadata"] = "temperature: unknown" + + return attrs + + def ensure_cf_units(ustr: str) -> str: """Ensure the passed unit string is CF-compliant. @@ -307,29 +370,6 @@ def pint2cfunits(value: units.Quantity | units.Unit) -> str: return f"{value:~cf}" or "1" -def ensure_delta(unit: str) -> str: - """Return delta units for temperature. - - For dimensions where delta exist in pint (Temperature), it replaces the temperature unit by delta_degC or - delta_degF based on the input unit. For other dimensionality, it just gives back the input units. - - Parameters - ---------- - unit : str - unit to transform in delta (or not). - """ - u = units2pint(unit) - d = 1 * u - # - delta_unit = pint2str(d - d) - # replace kelvin/rankine by delta_degC/F - if "kelvin" in u._units: - delta_unit = pint2str(u / units2pint("K") * units2pint("delta_degC")) - if "degree_Rankine" in u._units: - delta_unit = pint2str(u / units2pint("°R") * units2pint("delta_degF")) - return delta_unit - - def extract_units(arg): """Extract units from a string, DataArray, or scalar.""" if not ( @@ -418,9 +458,8 @@ def convert_units_to( # noqa: C901 Attributes are preserved unless an automatic CF conversion is performed, in which case only the new `standard_name` appears in the result. """ - # Target units - target_unit = extract_units(target) - source_unit = extract_units(source) + target_unit = pint2str(extract_units(target)) + source_unit = pint2str(extract_units(source)) if target_unit == source_unit: return source if isinstance(source, str) is False else str2pint(source).m else: # Convert units @@ -470,12 +509,20 @@ def _wrapper(*args, **kwargs): f"{params_to_check} were passed but only {params_dict.keys()} were found " f"in `{func.__name__}`'s arguments" ) - first_param = params_dict[params_to_check[0]] - for param_name in params_dict.keys(): - value = params_dict[param_name] - if value is None: # optional argument, should be ignored - continue - params_dict[param_name] = convert_units_to(value, first_param) + # Passing datasets or thresh as float (i.e. assign no units) is accepted + has_units = {extract_units(p) is not None for p in params_dict.values()} + if len(has_units) > 1: + raise ValueError( + "All arguments passed to `harmonize_units` must have units, or no units. Mixed cases " + "are not allowed." + ) + if has_units == {True}: + first_param = params_dict[params_to_check[0]] + for param_name in params_dict.keys(): + value = params_dict[param_name] + if value is None: # optional argument, should be ignored + continue + params_dict[param_name] = convert_units_to(value, first_param) # reassign keyword arguments for k in [k for k in params_dict.keys() if k not in args_dict.keys()]: kwargs[k] = params_dict[k] @@ -543,28 +590,27 @@ def to_agg_units( ... dims=("time",), ... coords={"time": time}, ... ) - >>> dt = (tas - 16).assign_attrs(units="delta_degC") + >>> dt = (tas - 16).assign_attrs( + ... units="degC", units_metadata="temperature: difference" + ... ) >>> degdays = dt.clip(0).sum("time") # Integral of temperature above a threshold >>> degdays = to_agg_units(degdays, dt, op="integral") >>> degdays.units - 'K week' + 'degC week' Which we can always convert to the more common "K days": >>> degdays = convert_units_to(degdays, "K days") >>> degdays.units - 'K d'. + 'd K' """ - if op in ["amin", "min", "amax", "max", "mean", "sum"]: - out.attrs["units"] = orig.attrs["units"] + is_difference = True if op in ["std", "var"] else None - elif op in ["std"]: - out.attrs["units"] = ensure_absolute_temperature(orig.attrs["units"]) + if op in ["amin", "min", "amax", "max", "mean", "sum", "std"]: + out.attrs["units"] = orig.attrs["units"] elif op in ["var"]: - out.attrs["units"] = pint2cfunits( - str2pint(ensure_absolute_temperature(orig.units)) ** 2 - ) + out.attrs["units"] = pint2cfunits(str2pint(orig.units) ** 2) elif op in ["doymin", "doymax"]: out.attrs.update( @@ -573,24 +619,34 @@ def to_agg_units( elif op in ["count", "integral"]: m, freq_u_raw = infer_sampling_units(orig[dim]) - orig_u = str2pint(ensure_absolute_temperature(orig.units)) + # TODO: Use delta here + orig_u = units2pint(orig) freq_u = str2pint(freq_u_raw) - out = out * m + # orig_u = xclim.core.units.units2pint(orig) + # freq_u = xclim.core.units.str2pint(freq_u_raw) + with xr.set_options(keep_attrs=True): + out = out * m if op == "count": out.attrs["units"] = freq_u_raw elif op == "integral": if "[time]" in orig_u.dimensionality: # We need to simplify units after multiplication + out_units = (orig_u * freq_u).to_reduced_units() - out = out * out_units.magnitude - out.attrs["units"] = pint2cfunits(out_units) + with xr.set_options(keep_attrs=True): + out = out * out_units.magnitude + out.attrs.update(pint2cfattrs(out_units, is_difference)) else: - out.attrs["units"] = pint2cfunits(orig_u * freq_u) + out.attrs.update(pint2cfattrs(orig_u * freq_u, is_difference)) else: raise ValueError( f"Unknown aggregation op {op}. " "Known ops are [min, max, mean, std, var, doymin, doymax, count, integral, sum]." ) + # Remove units_metadata where it doesn't make sense + if op in ["doymin", "doymax", "count"]: + out.attrs.pop("units_metadata", None) + return out diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index 858df5f..c36063d 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -83,16 +83,16 @@ def ecdf(x: xr.DataArray, value: float, dim: str = "time") -> xr.DataArray: Parameters ---------- x : array - Sample. + Sample. value : float - The value within the support of `x` for which to compute the CDF value. + The value within the support of `x` for which to compute the CDF value. dim : str - Dimension name. + Dimension name. Returns ------- xr.DataArray - Empirical CDF. + Empirical CDF. """ return (x <= value).sum(dim) / x.notnull().sum(dim) @@ -193,15 +193,15 @@ def broadcast( Parameters ---------- grouped : xr.DataArray - The grouped array to broadcast like `x`. + The grouped array to broadcast like `x`. x : xr.DataArray - The array to broadcast grouped to. + The array to broadcast grouped to. group : str or Grouper - Grouping information. See :py:class:`xsdba.base.Grouper` for details. + Grouping information. See :py:class:`xsdba.base.Grouper` for details. interp : {'nearest', 'linear', 'cubic'} - The interpolation method to use, + The interpolation method to use. sel : dict[str, xr.DataArray] - Mapping of grouped coordinates to x coordinates (other than the grouping one). + Mapping of grouped coordinates to x coordinates (other than the grouping one). Returns ------- @@ -250,14 +250,14 @@ def equally_spaced_nodes(n: int, eps: float | None = None) -> np.ndarray: Parameters ---------- n : int - Number of equally spaced nodes. + Number of equally spaced nodes. eps : float, optional - Distance from 0 and 1 of added end nodes. If None (default), do not add endpoints. + Distance from 0 and 1 of added end nodes. If None (default), do not add endpoints. Returns ------- np.array - Nodes between 0 and 1. Nodes can be seen as the middle points of `n` equal bins. + Nodes between 0 and 1. Nodes can be seen as the middle points of `n` equal bins. Warnings -------- @@ -1089,6 +1089,7 @@ def eps_cholesky(M, nit=26): return MC +# XC # ADAPT: Maybe this is not the best place def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray): """Copy all attributes of ds to ref, including attributes of shared coordinates, and variables in the case of Datasets.""" @@ -1100,6 +1101,7 @@ def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray var.attrs.update(ref[name].attrs) +# XC # ADAPT: Maybe this is not the best place def load_module(path: os.PathLike, name: str | None = None): """Load a python module from a python file, optionally changing its name. diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index 7a1c920..87eeff7 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -9,6 +9,7 @@ from xsdba import adjustment from xsdba.adjustment import ( LOCI, + BaseAdjustment, DetrendedQuantileMapping, EmpiricalQuantileMapping, ExtremeValues, @@ -37,6 +38,41 @@ ) +class TestBaseAdjustment: + def test_harmonize_units(self, timelonlatseries, random): + n = 10 + u = random.random(n) + attrs_tas = {"units": "K", "kind": ADDITIVE} + da = timelonlatseries(u, attrs=attrs_tas) + da2 = da.copy() + da2 = convert_units_to(da2, "degC") + (da, da2), _ = BaseAdjustment._harmonize_units(da, da2) + assert da.units == da2.units + + @pytest.mark.parametrize("use_dask", [True, False]) + def test_harmonize_units_multivariate(self, timelonlatseries, random, use_dask): + n = 10 + u = random.random(n) + attrs_tas = {"units": "K", "kind": ADDITIVE} + attrs_pr = {"units": "kg m-2 s-1", "kind": MULTIPLICATIVE} + ds = xr.merge( + [ + timelonlatseries(u, attrs=attrs_tas).to_dataset(name="tas"), + timelonlatseries(u * 100, attrs=attrs_pr).to_dataset(name="pr"), + ] + ) + ds2 = ds.copy() + ds2["tas"] = convert_units_to(ds2["tas"], "degC") + ds2["pr"] = convert_units_to(ds2["pr"], "kg mm-2 s-1") + da, da2 = stack_variables(ds), stack_variables(ds2) + if use_dask: + da, da2 = da.chunk({"multivar": 1}), da2.chunk({"multivar": 1}) + + (da, da2), _ = BaseAdjustment._harmonize_units(da, da2) + ds, ds2 = unstack_variables(da), unstack_variables(da2) + assert (ds.tas.units == ds2.tas.units) & (ds.pr.units == ds2.pr.units) + + class TestLoci: @pytest.mark.parametrize("group,dec", (["time", 2], ["time.month", 1])) def test_time_and_from_ds(self, timelonlatseries, group, dec, tmp_path, random): @@ -238,6 +274,11 @@ def test_quantiles(self, timelonlatseries, kind, units, random): p3 = DQM.adjust(sim3, interp="linear") np.testing.assert_array_almost_equal(p3[middle], ref3[middle], 1) + @pytest.mark.xfail( + raises=ValueError, + reason="This test sometimes fails due to a block/indexing error", + strict=False, + ) @pytest.mark.parametrize( "kind,units", [(ADDITIVE, "K"), (MULTIPLICATIVE, "kg m-2 s-1")] ) @@ -627,6 +668,54 @@ def test_add_dims(self, use_dask, open_dataset): assert scen2.sel(location=["Kugluktuk", "Vancouver"]).isnull().all() +@pytest.mark.slow +class TestMBCn: + @pytest.mark.parametrize("use_dask", [True, False]) + @pytest.mark.parametrize("group, window", [["time", 1], ["time.dayofyear", 31]]) + @pytest.mark.parametrize("period_dim", [None, "period"]) + def test_simple(self, open_dataset, use_dask, group, window, period_dim): + group, window, period_dim, use_dask = "time", 1, None, False + with set_options(sdba_encode_cf=use_dask): + if use_dask: + chunks = {"location": -1} + else: + chunks = None + ref, dsim = ( + open_dataset( + f"sdba/{file}", + chunks=chunks, + drop_variables=["lat", "lon"], + ) + .isel(location=1, drop=True) + .expand_dims(location=["Amos"]) + for file in ["ahccd_1950-2013.nc", "CanESM2_1950-2100.nc"] + ) + water_density_inverse = "1e-03 m^3/kg" + dsim["pr"] = convert_units_to( + pint_multiply(dsim.pr, water_density_inverse), ref.pr + ) + ref, hist = ( + ds.sel(time=slice("1981", "2010")).isel(time=slice(365 * 4)) + for ds in [ref, dsim] + ) + dsim = dsim.sel(time=slice("1981", None)) + sim = (stack_periods(dsim).isel(period=slice(1, 2))).isel( + time=slice(365 * 4) + ) + + ref, hist, sim = (stack_variables(ds) for ds in [ref, hist, sim]) + + MBCN = MBCn.train( + ref, + hist, + base_kws=dict(nquantiles=50, group=Grouper(group, window)), + adj_kws=dict(interp="linear"), + ) + p = MBCN.adjust(sim=sim, ref=ref, hist=hist, period_dim=period_dim) + # 'does it run' test + p.load() + + class TestPrincipalComponents: @pytest.mark.parametrize( "group", (Grouper("time.month"), Grouper("time", add_dims=["lon"])) @@ -675,20 +764,17 @@ def _group_assert(ds, dim): @pytest.mark.parametrize("use_dask", [True, False]) @pytest.mark.parametrize("pcorient", ["full", "simple"]) def test_real_data(self, atmosds, use_dask, pcorient): - ref = stack_variables( - xr.Dataset( - {"tasmax": atmosds.tasmax, "tasmin": atmosds.tasmin, "tas": atmosds.tas} - ) - ).isel(location=3) - hist = stack_variables( - xr.Dataset( - { - "tasmax": 1.001 * atmosds.tasmax, - "tasmin": atmosds.tasmin - 0.25, - "tas": atmosds.tas + 1, - } - ) - ).isel(location=3) + ds0 = xr.Dataset( + {"tasmax": atmosds.tasmax, "tasmin": atmosds.tasmin, "tas": atmosds.tas} + ) + ref = stack_variables(ds0).isel(location=3) + hist0 = ds0 + with xr.set_options(keep_attrs=True): + hist0["tasmax"] = 1.001 * hist0.tasmax + hist0["tasmin"] = hist0.tasmin - 0.25 + hist0["tas"] = hist0.tas + 1 + + hist = stack_variables(hist0).isel(location=3) with xr.set_options(keep_attrs=True): sim = hist + 5 sim["time"] = sim.time + np.timedelta64(10, "Y").astype("<m8[ns]") @@ -797,69 +883,284 @@ def test_real_data(self, open_dataset): new_scen.load() +class TestOTC: + def test_compare_sbck(self, random, timelonlatseries): + pytest.importorskip("ot") + pytest.importorskip("SBCK", minversion="0.4.0") + ns = 1000 + u = random.random(ns) + + ref_xd = uniform(loc=1000, scale=100) + ref_yd = norm(loc=0, scale=100) + hist_xd = norm(loc=-500, scale=100) + hist_yd = uniform(loc=-1000, scale=100) + + ref_x = ref_xd.ppf(u) + ref_y = ref_yd.ppf(u) + hist_x = hist_xd.ppf(u) + hist_y = hist_yd.ppf(u) + + # Constructing an histogram such that every bin contains + # at most 1 point should ensure that ot is deterministic + dx_ref = np.diff(np.sort(ref_x)).min() + dx_hist = np.diff(np.sort(hist_x)).min() + dx = min(dx_ref, dx_hist) * 9 / 10 + + dy_ref = np.diff(np.sort(ref_y)).min() + dy_hist = np.diff(np.sort(hist_y)).min() + dy = min(dy_ref, dy_hist) * 9 / 10 + + bin_width = [dx, dy] + + attrs_tas = {"units": "K", "kind": ADDITIVE} + attrs_pr = {"units": "kg m-2 s-1", "kind": MULTIPLICATIVE} + ref_tas = timelonlatseries(ref_x, attrs=attrs_tas) + ref_pr = timelonlatseries(ref_y, attrs=attrs_pr) + ref = xr.merge([ref_tas, ref_pr]) + ref = stack_variables(ref) + + hist_tas = timelonlatseries(hist_x, attrs=attrs_tas) + hist_pr = timelonlatseries(hist_y, attrs=attrs_pr) + hist = xr.merge([hist_tas, hist_pr]) + hist = stack_variables(hist) + + scen = OTC.adjust(ref, hist, bin_width=bin_width, jitter_inside_bins=False) + + otc_sbck = adjustment.SBCK_OTC + scen_sbck = otc_sbck.adjust( + ref, hist, hist, multi_dim="multivar", bin_width=bin_width + ) + + scen = scen.to_numpy().T + scen_sbck = scen_sbck.to_numpy() + assert np.allclose(scen, scen_sbck) + + def test_shape(self, random, timelonlatseries): + pytest.importorskip("ot") + pytest.importorskip("SBCK", minversion="0.4.0") + + attrs_tas = {"units": "K", "kind": ADDITIVE} + + ref_ns = 300 + hist_ns = 200 + ref_u = random.random(ref_ns) + hist_u = random.random(hist_ns) + + ref_xd = uniform(loc=1000, scale=100) + ref_yd = norm(loc=0, scale=100) + ref_zd = norm(loc=500, scale=100) + hist_xd = norm(loc=-500, scale=100) + hist_yd = uniform(loc=-1000, scale=100) + hist_zd = uniform(loc=-10, scale=100) + + ref_x = ref_xd.ppf(ref_u) + ref_y = ref_yd.ppf(ref_u) + ref_z = ref_zd.ppf(ref_u) + hist_x = hist_xd.ppf(hist_u) + hist_y = hist_yd.ppf(hist_u) + hist_z = hist_zd.ppf(hist_u) + + ref_na = 10 + hist_na = 15 + ref_idx = random.choice(range(ref_ns), size=ref_na, replace=False) + ref_x[ref_idx] = None + hist_idx = random.choice(range(hist_ns), size=hist_na, replace=False) + hist_x[hist_idx] = None + + ref_x = timelonlatseries(ref_x, attrs=attrs_tas).rename("x") + ref_y = timelonlatseries(ref_y, attrs=attrs_tas).rename("y") + ref_z = timelonlatseries(ref_z, attrs=attrs_tas).rename("z") + ref = xr.merge([ref_x, ref_y, ref_z]) + ref = stack_variables(ref) + + hist_x = timelonlatseries(hist_x, attrs=attrs_tas).rename("x") + hist_y = timelonlatseries(hist_y, attrs=attrs_tas).rename("y") + hist_z = timelonlatseries(hist_z, attrs=attrs_tas).rename("z") + hist = xr.merge([hist_x, hist_y, hist_z]) + hist = stack_variables(hist) + + scen = OTC.adjust(ref, hist) + + assert scen.shape == (3, hist_ns - hist_na) + hist = unstack_variables(hist) + assert not np.isin(hist.x[hist.x.isnull()].time.values, scen.time.values).any() + + +# TODO: Add tests for normalization methods +class TestdOTC: + @pytest.mark.parametrize("use_dask", [True, False]) + @pytest.mark.parametrize("cov_factor", ["std", "cholesky"]) + # FIXME: Should this comparison not fail if `standardization` != `None`? + def test_compare_sbck(self, random, timelonlatseries, use_dask, cov_factor): + pytest.importorskip("ot") + pytest.importorskip("SBCK", minversion="0.4.0") + ns = 1000 + u = random.random(ns) + + attrs_tas = {"units": "K", "kind": ADDITIVE} + attrs_pr = {"units": "kg m-2 s-1", "kind": MULTIPLICATIVE} + + ref_xd = uniform(loc=1000, scale=100) + ref_yd = norm(loc=0, scale=100) + hist_xd = norm(loc=-500, scale=100) + hist_yd = uniform(loc=-1000, scale=100) + sim_xd = norm(loc=0, scale=100) + sim_yd = uniform(loc=0, scale=100) + + ref_x = ref_xd.ppf(u) + ref_y = ref_yd.ppf(u) + hist_x = hist_xd.ppf(u) + hist_y = hist_yd.ppf(u) + sim_x = sim_xd.ppf(u) + sim_y = sim_yd.ppf(u) + + # Constructing an histogram such that every bin contains + # at most 1 point should ensure that ot is deterministic + dx_ref = np.diff(np.sort(ref_x)).min() + dx_hist = np.diff(np.sort(hist_x)).min() + dx_sim = np.diff(np.sort(sim_x)).min() + dx = min(dx_ref, dx_hist, dx_sim) * 9 / 10 + + dy_ref = np.diff(np.sort(ref_y)).min() + dy_hist = np.diff(np.sort(hist_y)).min() + dy_sim = np.diff(np.sort(sim_y)).min() + dy = min(dy_ref, dy_hist, dy_sim) * 9 / 10 + + bin_width = [dx, dy] + + ref_tas = timelonlatseries(ref_x, attrs=attrs_tas) + ref_pr = timelonlatseries(ref_y, attrs=attrs_pr) + hist_tas = timelonlatseries(hist_x, attrs=attrs_tas) + hist_pr = timelonlatseries(hist_y, attrs=attrs_pr) + sim_tas = timelonlatseries(sim_x, attrs=attrs_tas) + sim_pr = timelonlatseries(sim_y, attrs=attrs_pr) + + if use_dask: + ref_tas = ref_tas.chunk({"time": -1}) + ref_pr = ref_pr.chunk({"time": -1}) + hist_tas = hist_tas.chunk({"time": -1}) + hist_pr = hist_pr.chunk({"time": -1}) + sim_tas = sim_tas.chunk({"time": -1}) + sim_pr = sim_pr.chunk({"time": -1}) + + ref = xr.merge([ref_tas, ref_pr]) + hist = xr.merge([hist_tas, hist_pr]) + sim = xr.merge([sim_tas, sim_pr]) + + ref = stack_variables(ref) + hist = stack_variables(hist) + sim = stack_variables(sim) + + scen = dOTC.adjust( + ref, + hist, + sim, + bin_width=bin_width, + jitter_inside_bins=False, + cov_factor=cov_factor, + ) + + dotc_sbck = adjustment.SBCK_dOTC + scen_sbck = dotc_sbck.adjust( + ref, + hist, + sim, + multi_dim="multivar", + bin_width=bin_width, + cov_factor=cov_factor, + ) + + scen = scen.to_numpy().T + scen_sbck = scen_sbck.to_numpy() + assert np.allclose(scen, scen_sbck) + + def test_shape(self, random, timelonlatseries): + + pytest.importorskip("ot") + pytest.importorskip("SBCK", minversion="0.4.0") + + attrs_tas = {"units": "K", "kind": ADDITIVE} + + ref_ns = 300 + hist_ns = 200 + sim_ns = 400 + ref_u = random.random(ref_ns) + hist_u = random.random(hist_ns) + sim_u = random.random(sim_ns) + + ref_xd = uniform(loc=1000, scale=100) + ref_yd = norm(loc=0, scale=100) + ref_zd = norm(loc=500, scale=100) + hist_xd = norm(loc=-500, scale=100) + hist_yd = uniform(loc=-1000, scale=100) + hist_zd = uniform(loc=-10, scale=100) + sim_xd = norm(loc=0, scale=100) + sim_yd = uniform(loc=0, scale=100) + sim_zd = uniform(loc=10, scale=100) + + ref_x = ref_xd.ppf(ref_u) + ref_y = ref_yd.ppf(ref_u) + ref_z = ref_zd.ppf(ref_u) + hist_x = hist_xd.ppf(hist_u) + hist_y = hist_yd.ppf(hist_u) + hist_z = hist_zd.ppf(hist_u) + sim_x = sim_xd.ppf(sim_u) + sim_y = sim_yd.ppf(sim_u) + sim_z = sim_zd.ppf(sim_u) + + ref_na = 10 + hist_na = 15 + sim_na = 20 + ref_idx = random.choice(range(ref_ns), size=ref_na, replace=False) + ref_x[ref_idx] = None + hist_idx = random.choice(range(hist_ns), size=hist_na, replace=False) + hist_x[hist_idx] = None + sim_idx = random.choice(range(sim_ns), size=sim_na, replace=False) + sim_x[sim_idx] = None + + ref_x = timelonlatseries(ref_x, attrs=attrs_tas).rename("x") + ref_y = timelonlatseries(ref_y, attrs=attrs_tas).rename("y") + ref_z = timelonlatseries(ref_z, attrs=attrs_tas).rename("z") + ref = xr.merge([ref_x, ref_y, ref_z]) + ref = stack_variables(ref) + + hist_x = timelonlatseries(hist_x, attrs=attrs_tas).rename("x") + hist_y = timelonlatseries(hist_y, attrs=attrs_tas).rename("y") + hist_z = timelonlatseries(hist_z, attrs=attrs_tas).rename("z") + hist = xr.merge([hist_x, hist_y, hist_z]) + hist = stack_variables(hist) + + sim_x = timelonlatseries(sim_x, attrs=attrs_tas).rename("x") + sim_y = timelonlatseries(sim_y, attrs=attrs_tas).rename("y") + sim_z = timelonlatseries(sim_z, attrs=attrs_tas).rename("z") + sim = xr.merge([sim_x, sim_y, sim_z]) + sim = stack_variables(sim) + + scen = dOTC.adjust(ref, hist, sim) + + assert scen.shape == (3, sim_ns - sim_na) + sim = unstack_variables(sim) + assert not np.isin(sim.x[sim.x.isnull()].time.values, scen.time.values).any() + + def test_raise_on_multiple_chunks(timelonlatseries): - ref = timelonlatseries(np.arange(730).astype(float)).chunk({"time": 365}) + attrs_tas = {"units": "K", "kind": ADDITIVE} + ref = timelonlatseries(np.arange(730).astype(float), attrs=attrs_tas).chunk( + {"time": 365} + ) with pytest.raises(ValueError): EmpiricalQuantileMapping.train(ref, ref, group=Grouper("time.month")) -def test_default_grouper_understood(timeseries): - attrs = {"units": "K", "kind": ADDITIVE} - - ref = timeseries(np.arange(730).astype(float), units="K") +def test_default_grouper_understood(timelonlatseries): + attrs_tas = {"units": "K", "kind": ADDITIVE} + ref = timelonlatseries(np.arange(730).astype(float), attrs=attrs_tas) EQM = EmpiricalQuantileMapping.train(ref, ref) EQM.adjust(ref) assert EQM.group.dim == "time" -@pytest.mark.slow -class TestMBCn: - @pytest.mark.parametrize("use_dask", [True, False]) - @pytest.mark.parametrize("group, window", [["time", 1], ["time.dayofyear", 31]]) - @pytest.mark.parametrize("period_dim", [None, "period"]) - # TODO: Add test_simple ? - def test_real_data(self, open_dataset, use_dask, group, window, period_dim): - group, window, period_dim, use_dask = "time", 1, None, False - with set_options(sdba_encode_cf=use_dask): - if use_dask: - chunks = {"location": -1} - else: - chunks = None - ref, dsim = ( - open_dataset( - f"sdba/{file}", - chunks=chunks, - drop_variables=["lat", "lon"], - ) - .isel(location=1, drop=True) - .expand_dims(location=["Amos"]) - for file in ["ahccd_1950-2013.nc", "CanESM2_1950-2100.nc"] - ) - ref, hist = ( - ds.sel(time=slice("1981", "2010")).isel(time=slice(365 * 4)) - for ds in [ref, dsim] - ) - # mm d-1 -> kg m-2 d-1 - ref["pr"] = pint_multiply(ref["pr"], "1000 kg/m^3") - dsim = dsim.sel(time=slice("1981", None)) - sim = (stack_periods(dsim).isel(period=slice(1, 2))).isel( - time=slice(365 * 4) - ) - - ref, hist, sim = (stack_variables(ds) for ds in [ref, hist, sim]) - - MBCN = MBCn.train( - ref, - hist, - base_kws=dict(nquantiles=50, group=Grouper(group, window)), - adj_kws=dict(interp="linear"), - ) - p = MBCN.adjust(sim=sim, ref=ref, hist=hist, period_dim=period_dim) - # 'does it run' test - p.load() - - class TestSBCKutils: @pytest.mark.slow @pytest.mark.parametrize( diff --git a/tests/test_detrending.py b/tests/test_detrending.py index 06ad056..acbb4a1 100644 --- a/tests/test_detrending.py +++ b/tests/test_detrending.py @@ -30,7 +30,7 @@ def test_poly_detrend_and_from_ds(timeseries, tmp_path): np.testing.assert_array_almost_equal(xt, x) file = tmp_path / "test_polydetrend.nc" - fx.ds.to_netcdf(file) + fx.ds.to_netcdf(file, engine="h5netcdf") ds = xr.open_dataset(file) fx2 = PolyDetrend.from_dataset(ds) diff --git a/tests/test_properties.py b/tests/test_properties.py index d362b8b..01597c4 100644 --- a/tests/test_properties.py +++ b/tests/test_properties.py @@ -272,24 +272,24 @@ def test_annual_cycle(self, open_dataset): np.testing.assert_allclose( [amp.values, relamp.values, phase.values], [16.74645996, 5.802083, 167], - rtol=1e-6, + rtol=1e-5, ) - # FIXME - # with pytest.raises( - # ValueError, - # match="Grouping period season is not allowed for property", - # ): - # properties.annual_cycle_amplitude(simt, group="time.season") - - # with pytest.raises( - # ValueError, - # match="Grouping period month is not allowed for property", - # ): - # properties.annual_cycle_phase(simt, group="time.month") + with pytest.raises( + ValueError, + match="Grouping period season is not allowed for property", + ): + properties.annual_cycle_amplitude(simt, group="time.season") + + with pytest.raises( + ValueError, + match="Grouping period month is not allowed for property", + ): + properties.annual_cycle_phase(simt, group="time.month") assert amp.long_name.startswith("Absolute amplitude of the annual cycle") assert phase.long_name.startswith("Phase of the annual cycle") - assert amp.units == "delta_degC" + assert amp.units == "K" + assert amp.units_metadata == "temperature: difference" assert relamp.units == "%" assert phase.units == "" @@ -318,22 +318,22 @@ def test_annual_range(self, open_dataset): [amp.values, relamp.values, phase.values], [18.715261, 6.480101, 181.6666667], ) - # FIXME - # with pytest.raises( - # ValueError, - # match="Grouping period season is not allowed for property", - # ): - # properties.mean_annual_range(simt, group="time.season") - - # with pytest.raises( - # ValueError, - # match="Grouping period month is not allowed for property", - # ): - # properties.mean_annual_phase(simt, group="time.month") + with pytest.raises( + ValueError, + match="Grouping period season is not allowed for property", + ): + properties.mean_annual_range(simt, group="time.season") + + with pytest.raises( + ValueError, + match="Grouping period month is not allowed for property", + ): + properties.mean_annual_phase(simt, group="time.month") assert amp.long_name.startswith("Average annual absolute amplitude") assert phase.long_name.startswith("Average annual phase") - assert amp.units == "delta_degC" + assert amp.units == "K" + assert amp.units_metadata == "temperature: difference" assert relamp.units == "%" assert phase.units == "" diff --git a/tests/test_units.py b/tests/test_units.py index 20e2cac..4150290 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -84,15 +84,21 @@ def test_str2pint(self): ("", "sum", "count", 365, "d"), ("", "sum", "count", 365, "d"), ("kg m-2", "var", "var", 0, "kg2 m-4"), - ("°C", "argmax", "doymax", 0, ("", "1")), # dependent on numpy/pint version + ( + "°C", + "argmax", + "doymax", + 0, + "1", + ), ( "°C", "sum", "integral", 365, - ("K d", "d K"), + ("degC d", "d degC"), ), # dependent on numpy/pint version - ("°F", "sum", "integral", 365, "d °R"), # not sure why the order is different + ("°F", "sum", "integral", 365, "d degF"), # not sure why the order is different ], ) def test_to_agg_units(in_u, opfunc, op, exp, exp_u): @@ -102,15 +108,14 @@ def test_to_agg_units(in_u, opfunc, op, exp, exp_u): coords={"time": xr.cftime_range("1993-01-01", periods=365, freq="D")}, attrs={"units": in_u}, ) + if units(in_u).dimensionality == "[temperature]": + da.attrs["units_metadata"] = "temperature: difference" + # FIXME: This is emitting warnings from deprecated DataArray.argmax() usage. out = to_agg_units(getattr(da, opfunc)(), da, op) np.testing.assert_allclose(out, exp) - if isinstance(exp_u, tuple): - if Version(__cfxr_version__) < Version("0.9.3"): - assert out.attrs["units"] == exp_u[0] - else: - assert out.attrs["units"] == exp_u[1] + assert out.attrs["units"] in exp_u else: assert out.attrs["units"] == exp_u From 16e594cb2097805b551ef0a8be94e0d044ce3ca5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Wed, 30 Oct 2024 15:00:08 -0400 Subject: [PATCH 092/105] remove atmosds, not necessary --- .github/workflows/main.yml | 2 +- pyproject.toml | 3 +-- tests/conftest.py | 14 -------------- tests/test_adjustment.py | 5 +++-- tox.ini | 2 +- 5 files changed, 6 insertions(+), 20 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 43bab75..570badd 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -130,7 +130,7 @@ jobs: python -m pip check || true - name: Test with pytest run: | - python -m pytest --cov xsdba -m "not requires_atmosds" + python -m pytest --cov xsdba - name: Report Coverage run: | python -m coveralls diff --git a/pyproject.toml b/pyproject.toml index 0e761f9..96d28ba 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -302,8 +302,7 @@ strict_markers = true testpaths = "tests" usefixtures = "xdoctest_namespace" markers = [ - "slow: mark test as slow", - "requires_atmosds: mark test as requiring access to the atmosds data" + "slow: mark test as slow" ] [tool.ruff] diff --git a/tests/conftest.py b/tests/conftest.py index a0cc3b6..d300c26 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -189,18 +189,6 @@ def _is_matplotlib_installed(): ns["is_matplotlib_installed"] = _is_matplotlib_installed -# ADAPT or REMOVE? -@pytest.mark.requires_atmosds -@pytest.fixture(scope="function") -def atmosds(threadsafe_data_dir) -> xr.Dataset: - return _open_dataset( - threadsafe_data_dir.joinpath("atmosds.nc"), - cache_dir=threadsafe_data_dir, - branch=TESTDATA_BRANCH, - engine="h5netcdf", - ).load() - - @pytest.fixture(scope="session") def threadsafe_data_dir(tmp_path_factory): return Path(tmp_path_factory.getbasetemp().joinpath("data")) @@ -246,8 +234,6 @@ def gather_session_data(request, nimbus, worker_id): Due to the lack of UNIX sockets on Windows, the lockfile mechanism is not supported, requiring users on Windows to run `$ xclim prefetch_testing_data` before running any tests for the first time to populate the default cache dir. - - Additionally, this fixture is also used to generate the `atmosds` synthetic testing dataset. """ gather_testing_data(worker_cache_dir=nimbus.path, worker_id=worker_id) diff --git a/tests/test_adjustment.py b/tests/test_adjustment.py index 87eeff7..a220f8e 100644 --- a/tests/test_adjustment.py +++ b/tests/test_adjustment.py @@ -760,10 +760,11 @@ def _group_assert(ds, dim): group.apply(_group_assert, {"ref": ref, "sim": sim, "scen": scen}) - @pytest.mark.requires_atmosds @pytest.mark.parametrize("use_dask", [True, False]) @pytest.mark.parametrize("pcorient", ["full", "simple"]) - def test_real_data(self, atmosds, use_dask, pcorient): + def test_real_data(self, open_dataset, use_dask, pcorient): + atmosds = open_dataset("ERA5/daily_surface_cancities_1990-1993.nc") + ds0 = xr.Dataset( {"tasmax": atmosds.tasmax, "tasmin": atmosds.tasmin, "tas": atmosds.tas} ) diff --git a/tox.ini b/tox.ini index 5b5ffe2..7aa8b83 100644 --- a/tox.ini +++ b/tox.ini @@ -59,6 +59,6 @@ commands_pre = pip list pip check commands = - pytest --cov xsdba -m "not requires_atmosds" {posargs} + pytest --cov xsdba {posargs} ; Coveralls requires access to a repo token set in .coveralls.yml in order to report stats coveralls: - coveralls From 1e7dc68e088fd0fa78e674f14233b98ed4f50c33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 31 Oct 2024 14:46:54 -0400 Subject: [PATCH 093/105] remove unused functions (units, get_calendar) --- src/xsdba/adjustment.py | 7 +- src/xsdba/base.py | 53 +------ src/xsdba/processing.py | 2 +- src/xsdba/properties.py | 51 ++++--- src/xsdba/units.py | 312 ++++++---------------------------------- src/xsdba/utils.py | 34 ----- tests/test_units.py | 68 ++------- 7 files changed, 94 insertions(+), 433 deletions(-) diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 772efea..1f5039f 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -14,10 +14,9 @@ from scipy import stats from xarray.core.dataarray import DataArray -from xsdba.base import get_calendar from xsdba.formatting import gen_call_string, update_history from xsdba.options import OPTIONS, XSDBA_EXTRA_OUTPUT, set_options -from xsdba.units import convert_units_to, pint2str, units2str +from xsdba.units import convert_units_to from xsdba.utils import uses_dask from ._adjustment import ( @@ -94,7 +93,7 @@ def _check_inputs(cls, *inputs, group): ) # All calendars used by the inputs - calendars = {get_calendar(inda, group.dim) for inda in inputs} + calendars = {inda.time.dt.calendar for inda in inputs} if not cls._allow_diff_calendars and len(calendars) > 1: raise ValueError( "Inputs are defined on different calendars," @@ -246,7 +245,7 @@ def train(cls, ref: DataArray, hist: DataArray, **kwargs) -> TrainAdjust: ds, params = cls._train(ref, hist, **kwargs) obj = cls( _trained=True, - hist_calendar=get_calendar(hist), + hist_calendar=hist.time.dt.calendar, train_units=train_units, **params, ) diff --git a/src/xsdba/base.py b/src/xsdba/base.py index 76a9c9a..c6d2e16 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -200,7 +200,7 @@ def get_coordinate(self, ds: xr.Dataset | None = None) -> xr.DataArray: ) if self.prop == "dayofyear": if ds is not None: - cal = get_calendar(ds, dim=self.dim) + cal = ds.time.dt.calendar mdoy = max( xr.coding.calendar_ops._days_in_year(yr, cal) for yr in np.unique(ds[self.dim].dt.year) @@ -1081,49 +1081,6 @@ def compare_offsets(freqA: str, op: str, freqB: str) -> bool: return get_op(op)(t_a, t_b) -# XC: calendar -def get_calendar(obj: Any, dim: str = "time") -> str: - """Return the calendar of an object. - - Parameters - ---------- - obj : Any - An object defining some date. - If `obj` is an array/dataset with a datetime coordinate, use `dim` to specify its name. - Values must have either a datetime64 dtype or a cftime dtype. - `obj` can also be a python datetime.datetime, a cftime object or a pandas Timestamp - or an iterable of those, in which case the calendar is inferred from the first value. - dim : str - Name of the coordinate to check (if `obj` is a DataArray or Dataset). - - Raises - ------ - ValueError - If no calendar could be inferred. - - Returns - ------- - str - The Climate and Forecasting (CF) calendar name. - Will always return "standard" instead of "gregorian", following CF conventions 1.9. - """ - if isinstance(obj, xr.DataArray | xr.Dataset): - return obj[dim].dt.calendar - if isinstance(obj, xr.CFTimeIndex): - obj = obj.values[0] - else: - obj = np.take(obj, 0) - # Take zeroth element, overcome cases when arrays or lists are passed. - if isinstance(obj, pydt.datetime): # Also covers pandas Timestamp - return "standard" - if isinstance(obj, cftime.datetime): - if obj.calendar == "gregorian": - return "standard" - return obj.calendar - - raise ValueError(f"Calendar could not be inferred from object of type {type(obj)}.") - - # XC: calendar def construct_offset(mult: int, base: str, start_anchored: bool, anchor: str | None): """Reconstruct an offset string from its parts. @@ -1251,9 +1208,9 @@ def stack_periods( The coordinate of `period` is the first timestep of each window. """ # Import in function to avoid cyclical imports - from xclim.core.units import ( # pylint: disable=import-outside-toplevel - ensure_cf_units, + from xsdba.units import ( # pylint: disable=import-outside-toplevel infer_sampling_units, + units2str, ) stride = stride or window @@ -1357,7 +1314,7 @@ def stack_periods( # Length as a pint-ready array : with proper units, but values are not usable as indexes anymore m, u = infer_sampling_units(da) lengths = lengths * m - lengths.attrs["units"] = ensure_cf_units(u) + lengths.attrs["units"] = units2str(u) # Start points for each period and remember parameters for unstacking starts = xr.DataArray( [da.time[slc.start].item() for slc in periods], @@ -1429,7 +1386,7 @@ def unstack_periods(da: xr.DataArray | xr.Dataset, dim: str = "period"): 0 o o o x x === === === === === === === === """ - from xclim.core.units import ( # pylint: disable=import-outside-toplevel + from xsdba.units import ( # pylint: disable=import-outside-toplevel infer_sampling_units, ) diff --git a/src/xsdba/processing.py b/src/xsdba/processing.py index ce4a226..bef17f2 100644 --- a/src/xsdba/processing.py +++ b/src/xsdba/processing.py @@ -19,7 +19,7 @@ from ._processing import _adapt_freq, _normalize, _reordering from .base import Grouper, parse_offset, uses_dask from .nbutils import _escore -from .units import convert_units_to, harmonize_units, pint2str +from .units import convert_units_to, harmonize_units from .utils import ADDITIVE, copy_all_attrs __all__ = [ diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 12b97c7..0dc27a1 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -23,9 +23,9 @@ from xsdba.units import ( convert_units_to, + infer_sampling_units, pint2cfattrs, - pint2str, - to_agg_units, + units, units2pint, ) from xsdba.utils import uses_dask @@ -130,11 +130,11 @@ def _mean(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: xr.DataArray, [same as input] Mean of the variable. """ - units = da.units + u = da.units if group.prop != "group": da = da.groupby(group.name) out = da.mean(dim=group.dim) - return out.assign_attrs(units=units) + return out.assign_attrs(units=u) mean = StatisticalProperty( @@ -164,12 +164,11 @@ def _var(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: xr.DataArray, [square of the input units] Variance of the variable. """ - units = da.units + u = da.units if group.prop != "group": da = da.groupby(group.name) out = da.var(dim=group.dim) - u2 = units2pint(units) ** 2 - out.attrs["units"] = pint2str(u2) + out.attrs["units"] = str((units(u) ** 2).units) return out @@ -201,11 +200,11 @@ def _std(da: xr.DataArray, *, group: str | Grouper = "time") -> xr.DataArray: xr.DataArray, Standard deviation of the variable. """ - units = da.units + u = da.units if group.prop != "group": da = da.groupby(group.name) out = da.std(dim=group.dim) - out.attrs["units"] = units + out.attrs["units"] = u return out @@ -282,11 +281,11 @@ def _quantile( xr.DataArray, [same as input] Quantile {q} of the variable. """ - units = da.units + u = da.units if group.prop != "group": da = da.groupby(group.name) out = da.quantile(q, dim=group.dim, keep_attrs=True).drop_vars("quantile") - return out.assign_attrs(units=units) + return out.assign_attrs(units=u) quantile = StatisticalProperty( @@ -406,7 +405,12 @@ def _spell_stats( stat=stat, stat_resample=stat_resample or stat, ).out - return to_agg_units(out, da, op="count") + # in xclim this was managed by to_agg_units + # will hard-code this part for now + m, freq_u_raw = infer_sampling_units(da["time"]) + with xr.set_options(keep_attrs=True): + out = (out * m).assign_attrs({"units": freq_u_raw}) + return out spell_length_distribution = StatisticalProperty( @@ -581,7 +585,7 @@ def _annual_cycle( {stat} of the annual cycle. """ group = group if isinstance(group, Grouper) else Grouper(group) - units = da.units + u = da.units ac = da.groupby("time.dayofyear").mean() if window > 1: # smooth the cycle @@ -596,7 +600,7 @@ def _annual_cycle( # TODO: In April 2024, use a match-case. if stat == "absamp": out = ac.max("dayofyear") - ac.min("dayofyear") - out.attrs.update(pint2cfattrs(units2pint(units), is_difference=True)) + out.attrs.update(pint2cfattrs(units2pint(u), is_difference=True)) elif stat == "relamp": out = (ac.max("dayofyear") - ac.min("dayofyear")) * 100 / ac.mean("dayofyear") out.attrs["units"] = "%" @@ -605,10 +609,10 @@ def _annual_cycle( out.attrs.update(units="", is_dayofyear=np.int32(1)) elif stat == "min": out = ac.min("dayofyear") - out.attrs["units"] = units + out.attrs["units"] = u elif stat == "max": out = ac.max("dayofyear") - out.attrs["units"] = units + out.attrs["units"] = u elif stat == "asymmetry": out = (ac.idxmax("dayofyear") - ac.idxmin("dayofyear")) % 365 / 365 out.attrs["units"] = "yr" @@ -704,7 +708,7 @@ def _annual_statistic( xr.DataArray, [same units as input or dimensionless] Average annual {stat}. """ - units = da.units + u = da.units if window > 1: da = da.rolling(time=window, center=True).mean() @@ -713,7 +717,7 @@ def _annual_statistic( if stat == "absamp": out = yrs.max() - yrs.min() - out.attrs.update(pint2cfattrs(units2pint(units), is_difference=True)) + out.attrs.update(pint2cfattrs(units2pint(u), is_difference=True)) elif stat == "relamp": out = (yrs.max() - yrs.min()) * 100 / yrs.mean() out.attrs["units"] = "%" @@ -971,7 +975,12 @@ def _bivariate_spell_stats( stat=stat, stat_resample=stat_resample or stat, ).out - return to_agg_units(out, da1, op="count") + # in xclim this was managed by to_agg_units + # will hard-code this part for now + m, freq_u_raw = infer_sampling_units(da["time"]) + with xr.set_options(keep_attrs=True): + out = (out * m).assign_attrs({"units": freq_u_raw}) + return out bivariate_spell_length_distribution = StatisticalProperty( @@ -1229,7 +1238,7 @@ def _trend( numpy.polyfit """ - units = da.units + u = da.units da = da.resample({group.dim: group.freq}) # separate all the {group} da_mean = da.mean(dim=group.dim) # avg over all {group} @@ -1250,7 +1259,7 @@ def modified_lr( vectorize=True, dask="parallelized", ) - out.attrs["units"] = f"{units}/year" + out.attrs["units"] = f"{u}/year" return out diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 4dee1aa..75579b8 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -11,12 +11,11 @@ from typing import Any, cast import pint +from pint import UndefinedUnitError # this dependency is "necessary" for convert_units_to # if we only do checks, we could get rid of it -# XC : units - try: # allows to use cf units import cf_xarray.units @@ -29,25 +28,21 @@ import pandas as pd import xarray as xr -from .base import get_calendar, parse_offset +from .base import parse_offset from .typing import Quantified from .utils import copy_all_attrs __all__ = [ - "compare_units", "convert_units_to", - "ensure_absolute_temperature", - "ensure_cf_units", "harmonize_units", - "infer_context", "infer_sampling_units", "pint2cfattrs", - "pint2cfunits", "pint_multiply", "str2pint", "to_agg_units", "units", "units2pint", + "units2str", ] # shamelessly adapted from `cf-xarray` (which adopted it from MetPy and xclim itself) @@ -55,10 +50,10 @@ # Changing the default string format for units/quantities. # CF is implemented by cf-xarray, g is the most versatile float format. # The following try/except logic can be removed when xclim drops support numpy <2.0. -# try: -# units.formatter.default_format = "gcf" -# except UndefinedUnitError: -# units.default_format = "gcf" +try: + units.formatter.default_format = "gcf" +except UndefinedUnitError: + units.default_format = "gcf" # Switch this flag back to False. Not sure what that implies, but it breaks some tests. units.force_ndarray_like = False # noqa: F841 # Another alias not included by cf_xarray @@ -79,6 +74,7 @@ """ +# XC def infer_sampling_units( da: xr.DataArray, deffreq: str | None = "D", @@ -205,7 +201,7 @@ def units2str(value: xr.DataArray | str | units.Quantity | units.Unit) -> str: pint.Unit Units of the data array. """ - return value if isinstance(value, str) else pint2str(units2pint(value)) + return value if isinstance(value, str) else str(units2pint(value)) # XC @@ -232,33 +228,7 @@ def str2pint(val: str) -> pint.Quantity: return units.Quantity(1, units2pint(val)) -def pint2str(value: units.Quantity | units.Unit) -> str: - """A unit string from a `pint` unit. - - Parameters - ---------- - value : pint.Unit - Input unit. - - Returns - ------- - str - Units. - - Notes - ----- - If cf-xarray is installed, the units will be converted to cf units. - """ - if isinstance(value, (pint.Quantity | units.Quantity)): - value = value.units - - # Issue originally introduced in https://github.com/hgrecco/pint/issues/1486 - # Should be resolved in pint v0.24. See: https://github.com/hgrecco/pint/issues/1913 - with warnings.catch_warnings(): - warnings.simplefilter("ignore", category=DeprecationWarning) - return f"{value:cf}".replace("dimensionless", "") - - +# XC def pint_multiply( da: xr.DataArray, q: pint.Quantity | str, out_units: str | None = None ) -> xr.DataArray: @@ -285,7 +255,7 @@ def pint_multiply( else: f = f.to_reduced_units() out: xr.DataArray = da * f.magnitude - out = out.assign_attrs(units=pint2str(f.units)) + out = out.assign_attrs(units=str(f.units)) return out @@ -295,19 +265,7 @@ def pint_multiply( } -def ensure_absolute_temperature(units: str): - """Convert temperature units to their absolute counterpart, assuming they represented a difference (delta). - - Celsius becomes Kelvin, Fahrenheit becomes Rankine. Does nothing for other units. - """ - a = str2pint(units) - # ensure a delta pint unit - a = a - 0 * a - if a.units in DELTA_ABSOLUTE_TEMP: - return pint2str(DELTA_ABSOLUTE_TEMP[a.units]) - return units - - +# XC def pint2cfattrs(value: units.Quantity | units.Unit, is_difference=None) -> dict: """Return CF-compliant units attributes from a `pint` unit. @@ -325,7 +283,8 @@ def pint2cfattrs(value: units.Quantity | units.Unit, is_difference=None) -> dict dict Units following CF-Convention, using symbols. """ - s = pint2cfunits(value) + value = value if isinstance(value, pint.Unit | units.Unit) else value.units + s = str(value) if "delta_" in s: is_difference = True s = s.replace("delta_", "") @@ -342,97 +301,6 @@ def pint2cfattrs(value: units.Quantity | units.Unit, is_difference=None) -> dict return attrs -def ensure_cf_units(ustr: str) -> str: - """Ensure the passed unit string is CF-compliant. - - The string will be parsed to pint then recast to a string by xclim's `pint2cfunits`. - """ - return pint2cfunits(units2pint(ustr)) - - -def pint2cfunits(value: units.Quantity | units.Unit) -> str: - """Return a CF-compliant unit string from a `pint` unit. - - Parameters - ---------- - value : pint.Unit - Input unit. - - Returns - ------- - str - Units following CF-Convention, using symbols. - """ - if isinstance(value, pint.Quantity | units.Quantity): - value = value.units - - # Force "1" if the formatted string is "" (pint < 0.24) - return f"{value:~cf}" or "1" - - -def extract_units(arg): - """Extract units from a string, DataArray, or scalar.""" - if not ( - isinstance(arg, (str | xr.DataArray | pint.Unit | units.Unit)) - or np.isscalar(arg) - ): - raise TypeError( - f"Argument must be a str, DataArray, or scalar. Got {type(arg)}" - ) - elif isinstance(arg, xr.DataArray): - ustr = None if "units" not in arg.attrs else arg.attrs["units"] - elif isinstance(arg, (pint.Unit | units.Unit)): - ustr = pint2str(arg) # XC: from pint2str - elif isinstance(arg, str): - ustr = pint2str(str2pint(arg).units) - else: # (scalar case) - ustr = None - return ustr if ustr is None else pint.Quantity(1, ustr).units - - -# TODO: Is this really needed? -def compare_units(args_to_check): - """Decorator to check that all arguments have the same units (or no units).""" - - # if no units are present (DataArray without units attribute or float), then no check is performed - # if units are present, then check is performed - # in mixed cases, an error is raised - def _decorator(func): - @wraps(func) - def _wrapper(*args, **kwargs): - # dictionnary {arg_name:arg} for all args of func - arg_dict = dict(zip(inspect.getfullargspec(func).args, args)) - # Obtain units (or None if no units) of all args - units = [] - for arg_name in args_to_check: - if isinstance(arg_name, str): - value = arg_dict[arg_name] - key = arg_name - if isinstance( - arg_name, dict - ): # support for Dataset, or a dict of thresholds - key, val = list(arg_name.keys())[0], list(arg_name.values())[0] - value = arg_dict[key][val] - if value is None: # optional argument, should be ignored - args_to_check.remove(arg_name) - continue - if key not in arg_dict: - raise ValueError( - f"Argument '{arg_name}' not found in function arguments." - ) - units.append(extract_units(value)) - # Check that units are consistent - if len(set(units)) > 1: - raise ValueError( - f"{args_to_check} must have the same units (or no units). Got {units}" - ) - return func(*args, **kwargs) - - return _wrapper - - return _decorator - - # XC simplified def convert_units_to( # noqa: C901 source: Quantified, @@ -458,8 +326,8 @@ def convert_units_to( # noqa: C901 Attributes are preserved unless an automatic CF conversion is performed, in which case only the new `standard_name` appears in the result. """ - target_unit = pint2str(extract_units(target)) - source_unit = pint2str(extract_units(source)) + target_unit = units2str(target) + source_unit = units2str(source) if target_unit == source_unit: return source if isinstance(source, str) is False else str2pint(source).m else: # Convert units @@ -471,6 +339,30 @@ def convert_units_to( # noqa: C901 return out +def extract_units(arg): + """Extract units from a string, DataArray, or scalar. + + Wrapper that can also yield `None`. + """ + if not ( + isinstance(arg, (str | xr.DataArray | pint.Unit | units.Unit)) + or np.isscalar(arg) + ): + raise TypeError( + f"Argument must be a str, DataArray, or scalar. Got {type(arg)}" + ) + if isinstance(arg, xr.DataArray): + # arg becomes a str or None + arg = arg.attrs.get("units", None) + if isinstance(arg, (pint.Unit | units.Unit)): + ustr = units2str(arg) + elif isinstance(arg, str): + ustr = str(units(arg).units) + else: # (scalar case, or DataArray without units attribute) + ustr = None + return ustr + + def _add_default_kws(params_dict, params_to_check, func): """Combine args and kwargs into a dict.""" args_dict = {} @@ -483,7 +375,6 @@ def _add_default_kws(params_dict, params_to_check, func): # TODO: this changes the type of some variables (e.g. thresh : str -> float). This should probably not be allowed -# TODO: support for Datasets and dict like in compare_units? def harmonize_units(params_to_check): """Compare units and perform a conversion if possible, otherwise raise a `ValidationError`.""" @@ -509,12 +400,16 @@ def _wrapper(*args, **kwargs): f"{params_to_check} were passed but only {params_dict.keys()} were found " f"in `{func.__name__}`'s arguments" ) - # Passing datasets or thresh as float (i.e. assign no units) is accepted - has_units = {extract_units(p) is not None for p in params_dict.values()} + # # Passing datasets or thresh as float (i.e. assign no units) is accepted + has_units = { + extract_units(p) is not None + for p in params_dict.values() + if p is not None + } if len(has_units) > 1: raise ValueError( "All arguments passed to `harmonize_units` must have units, or no units. Mixed cases " - "are not allowed." + "are not allowed. `None` values are ignored." ) if has_units == {True}: first_param = params_dict[params_to_check[0]] @@ -537,116 +432,3 @@ def _wrapper(*args, **kwargs): return _wrapper return _decorator - - -def to_agg_units( - out: xr.DataArray, orig: xr.DataArray, op: str, dim: str = "time" -) -> xr.DataArray: - """Set and convert units of an array after an aggregation operation along the sampling dimension (time). - - Parameters - ---------- - out : xr.DataArray - The output array of the aggregation operation, no units operation done yet. - orig : xr.DataArray - The original array before the aggregation operation, - used to infer the sampling units and get the variable units. - op : {'min', 'max', 'mean', 'std', 'var', 'doymin', 'doymax', 'count', 'integral', 'sum'} - The type of aggregation operation performed. "integral" is mathematically equivalent to "sum", - but the units are multiplied by the timestep of the data (requires an inferrable frequency). - dim : str - The time dimension along which the aggregation was performed. - - Returns - ------- - xr.DataArray - - Examples - -------- - Take a daily array of temperature and count number of days above a threshold. - `to_agg_units` will infer the units from the sampling rate along "time", so - we ensure the final units are correct: - - >>> time = xr.cftime_range("2001-01-01", freq="D", periods=365) - >>> tas = xr.DataArray( - ... np.arange(365), - ... dims=("time",), - ... coords={"time": time}, - ... attrs={"units": "degC"}, - ... ) - >>> cond = tas > 100 # Which days are boiling - >>> Ndays = cond.sum("time") # Number of boiling days - >>> Ndays.attrs.get("units") - None - >>> Ndays = to_agg_units(Ndays, tas, op="count") - >>> Ndays.units - 'd' - - Similarly, here we compute the total heating degree-days, but we have weekly data: - - >>> time = xr.cftime_range("2001-01-01", freq="7D", periods=52) - >>> tas = xr.DataArray( - ... np.arange(52) + 10, - ... dims=("time",), - ... coords={"time": time}, - ... ) - >>> dt = (tas - 16).assign_attrs( - ... units="degC", units_metadata="temperature: difference" - ... ) - >>> degdays = dt.clip(0).sum("time") # Integral of temperature above a threshold - >>> degdays = to_agg_units(degdays, dt, op="integral") - >>> degdays.units - 'degC week' - - Which we can always convert to the more common "K days": - - >>> degdays = convert_units_to(degdays, "K days") - >>> degdays.units - 'd K' - """ - is_difference = True if op in ["std", "var"] else None - - if op in ["amin", "min", "amax", "max", "mean", "sum", "std"]: - out.attrs["units"] = orig.attrs["units"] - - elif op in ["var"]: - out.attrs["units"] = pint2cfunits(str2pint(orig.units) ** 2) - - elif op in ["doymin", "doymax"]: - out.attrs.update( - units="1", is_dayofyear=np.int32(1), calendar=get_calendar(orig) - ) - - elif op in ["count", "integral"]: - m, freq_u_raw = infer_sampling_units(orig[dim]) - # TODO: Use delta here - orig_u = units2pint(orig) - freq_u = str2pint(freq_u_raw) - # orig_u = xclim.core.units.units2pint(orig) - # freq_u = xclim.core.units.str2pint(freq_u_raw) - with xr.set_options(keep_attrs=True): - out = out * m - - if op == "count": - out.attrs["units"] = freq_u_raw - elif op == "integral": - if "[time]" in orig_u.dimensionality: - # We need to simplify units after multiplication - - out_units = (orig_u * freq_u).to_reduced_units() - with xr.set_options(keep_attrs=True): - out = out * out_units.magnitude - out.attrs.update(pint2cfattrs(out_units, is_difference)) - else: - out.attrs.update(pint2cfattrs(orig_u * freq_u, is_difference)) - else: - raise ValueError( - f"Unknown aggregation op {op}. " - "Known ops are [min, max, mean, std, var, doymin, doymax, count, integral, sum]." - ) - - # Remove units_metadata where it doesn't make sense - if op in ["doymin", "doymax", "count"]: - out.attrs.pop("units_metadata", None) - - return out diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index c36063d..b1ac278 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -1101,40 +1101,6 @@ def copy_all_attrs(ds: xr.Dataset | xr.DataArray, ref: xr.Dataset | xr.DataArray var.attrs.update(ref[name].attrs) -# XC -# ADAPT: Maybe this is not the best place -def load_module(path: os.PathLike, name: str | None = None): - """Load a python module from a python file, optionally changing its name. - - Examples - -------- - Given a path to a module file (.py): - - .. code-block:: python - - from pathlib import Path - import os - - path = Path("path/to/example.py") - - The two following imports are equivalent, the second uses this method. - - .. code-block:: python - - os.chdir(path.parent) - import example as mod1 - - os.chdir(previous_working_dir) - mod2 = load_module(path) - mod1 == mod2 - """ - path = Path(path) - spec = importlib.util.spec_from_file_location(name or path.stem, path) - mod = importlib.util.module_from_spec(spec) - spec.loader.exec_module(mod) # This executes code, effectively loading the module - return mod - - # XC : redundancy # Fit the parameters. # This would also be the place to impose constraints on the series minimum length if needed. diff --git a/tests/test_units.py b/tests/test_units.py index 4150290..fa63bae 100644 --- a/tests/test_units.py +++ b/tests/test_units.py @@ -6,14 +6,7 @@ from cf_xarray import __version__ as __cfxr_version__ from packaging.version import Version -from xsdba.units import ( - harmonize_units, - pint2str, - str2pint, - to_agg_units, - units, - units2pint, -) +from xsdba.units import harmonize_units, str2pint, units, units2pint class TestUnits: @@ -45,27 +38,27 @@ class TestUnitConversion: def test_pint2str(self): pytest.importorskip("cf-xarray") u = units("mm/d") - assert pint2str(u.units) == "mm d-1" + assert str(u.units) == "mm d-1" u = units("percent") - assert pint2str(u.units) == "%" + assert str(u.units) == "%" u = units("pct") - assert pint2str(u.units) == "%" + assert str(u.units) == "%" def test_units2pint(self, timelonlatseries): pytest.importorskip("cf-xarray") u = units2pint(timelonlatseries([1, 2], attrs={"units": "kg m-2 s-1"})) - assert pint2str(u) == "kg m-2 s-1" + assert str(u) == "kg m-2 s-1" u = units2pint("m^3 s-1") - assert pint2str(u) == "m3 s-1" + assert str(u) == "m3 s-1" u = units2pint("%") - assert pint2str(u) == "%" + assert str(u) == "%" u = units2pint("1") - assert pint2str(u) == "" + assert str(u) == "" def test_str2pint(self): Q_ = units.Quantity @@ -75,51 +68,6 @@ def test_str2pint(self): assert str2pint("nan m^2 K^-3").units == Q_(1, units="m²/K³").units -@pytest.mark.parametrize( - "in_u,opfunc,op,exp,exp_u", - [ - ("m/h", "sum", "integral", 8760, "m"), - ("m/h", "sum", "sum", 365, "m/h"), - ("K", "mean", "mean", 1, "K"), - ("", "sum", "count", 365, "d"), - ("", "sum", "count", 365, "d"), - ("kg m-2", "var", "var", 0, "kg2 m-4"), - ( - "°C", - "argmax", - "doymax", - 0, - "1", - ), - ( - "°C", - "sum", - "integral", - 365, - ("degC d", "d degC"), - ), # dependent on numpy/pint version - ("°F", "sum", "integral", 365, "d degF"), # not sure why the order is different - ], -) -def test_to_agg_units(in_u, opfunc, op, exp, exp_u): - da = xr.DataArray( - np.ones((365,)), - dims=("time",), - coords={"time": xr.cftime_range("1993-01-01", periods=365, freq="D")}, - attrs={"units": in_u}, - ) - if units(in_u).dimensionality == "[temperature]": - da.attrs["units_metadata"] = "temperature: difference" - - # FIXME: This is emitting warnings from deprecated DataArray.argmax() usage. - out = to_agg_units(getattr(da, opfunc)(), da, op) - np.testing.assert_allclose(out, exp) - if isinstance(exp_u, tuple): - assert out.attrs["units"] in exp_u - else: - assert out.attrs["units"] == exp_u - - class TestHarmonizeUnits: def test_simple(self): da = xr.DataArray([1, 2], attrs={"units": "K"}) From 7ef3264aa006082750728bd294c2b166d05c7ed6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 31 Oct 2024 14:51:17 -0400 Subject: [PATCH 094/105] pins: pint , cf-xr --- environment-dev.yml | 4 ++-- pyproject.toml | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/environment-dev.yml b/environment-dev.yml index 4942235..743e810 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -6,14 +6,14 @@ dependencies: - python >=3.9,<3.13 - boltons - bottleneck - - cf_xarray >=0.9.3 + - cf_xarray >=0.10.0 # not sure if we need to be that strict - cftime - dask # why was this not installed? This is only pulled in by xclim, optional for xarray. - h5netcdf >=1.3.0 - jsonpickle - numba - numpy >=1.23.0,<2.0 # to accommodate numba - - pint + - pint>=0.24.3 - scipy >=1.9.0 - statsmodels - xarray >=2023.11.0 diff --git a/pyproject.toml b/pyproject.toml index 96d28ba..2451c27 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,7 +34,7 @@ dynamic = ["description", "version"] dependencies = [ "boltons", "bottleneck", - "cf_xarray>=0.9.3", + "cf_xarray>=0.10.0", # not sure if we need to be that strict "cftime", "dask", "h5netcdf>=1.3.0", @@ -43,7 +43,7 @@ dependencies = [ "nc_time_axis", "numba", "numpy >=1.23.0,<2.0", - "pint", + "pint>=0.24.3", "scipy >=1.9.0", "statsmodels", "xarray >=2023.11.0", From b177320c8ec1dff9a5ff27f2a2e924ce6aed6683 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 31 Oct 2024 15:15:38 -0400 Subject: [PATCH 095/105] remove unused fcts/imports, add needed imports --- src/xsdba/formatting.py | 56 ----------------------------------------- src/xsdba/utils.py | 4 +-- 2 files changed, 2 insertions(+), 58 deletions(-) diff --git a/src/xsdba/formatting.py b/src/xsdba/formatting.py index 4543ecf..aa438e6 100644 --- a/src/xsdba/formatting.py +++ b/src/xsdba/formatting.py @@ -192,62 +192,6 @@ def _match_value(self, value): ) -# XC -def prefix_attrs(source: dict, keys: Sequence, prefix: str) -> dict: - """Rename some keys of a dictionary by adding a prefix. - - Parameters - ---------- - source : dict - Source dictionary, for example data attributes. - keys : sequence - Names of keys to prefix. - prefix : str - Prefix to prepend to keys. - - Returns - ------- - dict - Dictionary of attributes with some keys prefixed. - """ - out = {} - for key, val in source.items(): - if key in keys: - out[f"{prefix}{key}"] = val - else: - out[key] = val - return out - - -# XC -def unprefix_attrs(source: dict, keys: Sequence, prefix: str) -> dict: - """Remove prefix from keys in a dictionary. - - Parameters - ---------- - source : dict - Source dictionary, for example data attributes. - keys : sequence - Names of original keys for which prefix should be removed. - prefix : str - Prefix to remove from keys. - - Returns - ------- - dict - Dictionary of attributes whose keys were prefixed, with prefix removed. - """ - out = {} - n = len(prefix) - for key, val in source.items(): - k = key[n:] - if (k in keys) and key.startswith(prefix): - out[k] = val - elif key not in out: - out[key] = val - return out - - # XC def merge_attributes( attribute: str, diff --git a/src/xsdba/utils.py b/src/xsdba/utils.py index b1ac278..4f7cb93 100644 --- a/src/xsdba/utils.py +++ b/src/xsdba/utils.py @@ -19,8 +19,8 @@ from scipy.stats import spearmanr from xarray.core.utils import get_temp_dimname -from .base import Grouper, ensure_chunk_size, parse_group, uses_dask -from .nbutils import _extrapolate_on_quantiles, _linear_interpolation +from .base import Grouper, _interpolate_doy_calendar, ensure_chunk_size, parse_group +from .nbutils import _extrapolate_on_quantiles MULTIPLICATIVE = "*" ADDITIVE = "+" From c8b57b75d49a23de903853f15b0492b11c1ac8c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Thu, 31 Oct 2024 16:01:50 -0400 Subject: [PATCH 096/105] import uses_dask from base --- src/xsdba/adjustment.py | 3 +-- src/xsdba/properties.py | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/xsdba/adjustment.py b/src/xsdba/adjustment.py index 1f5039f..b72544e 100644 --- a/src/xsdba/adjustment.py +++ b/src/xsdba/adjustment.py @@ -17,7 +17,6 @@ from xsdba.formatting import gen_call_string, update_history from xsdba.options import OPTIONS, XSDBA_EXTRA_OUTPUT, set_options from xsdba.units import convert_units_to -from xsdba.utils import uses_dask from ._adjustment import ( dqm_adjust, @@ -35,7 +34,7 @@ scaling_adjust, scaling_train, ) -from .base import Grouper, ParametrizableWithDataset, parse_group +from .base import Grouper, ParametrizableWithDataset, parse_group, uses_dask from .processing import grouped_time_indexes from .utils import ( ADDITIVE, diff --git a/src/xsdba/properties.py b/src/xsdba/properties.py index 0dc27a1..fa7b801 100644 --- a/src/xsdba/properties.py +++ b/src/xsdba/properties.py @@ -28,9 +28,8 @@ units, units2pint, ) -from xsdba.utils import uses_dask -from .base import Grouper, map_groups, parse_group, parse_offset +from .base import Grouper, map_groups, parse_group, parse_offset, uses_dask from .nbutils import _pairwise_haversine_and_bins from .utils import _pairwise_spearman, copy_all_attrs From a7f9cc0578bedd68695c04bfafd9c56199f80df0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 1 Nov 2024 10:27:34 -0400 Subject: [PATCH 097/105] units2pint now accepts a str with magnitude --- src/xsdba/base.py | 2 ++ src/xsdba/units.py | 65 ++++++++++++++++++++++++++++------------------ 2 files changed, 42 insertions(+), 25 deletions(-) diff --git a/src/xsdba/base.py b/src/xsdba/base.py index c6d2e16..e8123a7 100644 --- a/src/xsdba/base.py +++ b/src/xsdba/base.py @@ -24,6 +24,8 @@ from .typing import InputKind +# TODO : Redistributes some functions in existing/new scripts + # ## Base class for the sdba module class Parametrizable(dict): diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 75579b8..6252aa0 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -121,6 +121,29 @@ def infer_sampling_units( return out +def parse_str(value: str) -> tuple[str, str]: + """Parse a str as a number and a unit. + + Parameters + ---------- + value : str + Input string representing a unit (may contain a magnitude or not). + + Returns + ------- + tuple[str, str] + Magntitude and unit strings. If no magntiude is found, "1" is used by default. + """ + mstr, *ustr = val.split(" ", maxsplit=1) + try: + mstr = str(float(mstr)) + except ValueError: + mstr = "1" + ustr = [val] + ustr = "dimensionless" if len(ustr) == 0 else ustr[0] + return mstr, ustr + + # XC def units2pint( value: xr.DataArray | units.Unit | units.Quantity | dict | str, @@ -130,7 +153,7 @@ def units2pint( Parameters ---------- value : xr.DataArray or pint.Unit or pint.Quantity or dict or str - Input data array or string representing a unit (with no magnitude). + Input data array or string representing a unit (may contain a magnitude). Returns ------- @@ -155,7 +178,7 @@ def units2pint( value = value.attrs if isinstance(value, str): - unit = value + _, unit = parse_str(value) metadata = None elif isinstance(value, dict): unit = value["units"] @@ -201,7 +224,7 @@ def units2str(value: xr.DataArray | str | units.Quantity | units.Unit) -> str: pint.Unit Units of the data array. """ - return value if isinstance(value, str) else str(units2pint(value)) + return str(units2pint(value)) # XC @@ -219,13 +242,8 @@ def str2pint(val: str) -> pint.Quantity: pint.Quantity Magnitude is 1 if no magnitude was present in the string. """ - mstr, *ustr = val.split(" ", maxsplit=1) - try: - if ustr: - return units.Quantity(float(mstr), units=units2pint(ustr[0])) - return units.Quantity(float(mstr)) - except ValueError: - return units.Quantity(1, units2pint(val)) + mstr, ustr = parse_str(val) + return units.Quantity(float(mstr), units=units2pint(ustr)) # XC @@ -344,23 +362,20 @@ def extract_units(arg): Wrapper that can also yield `None`. """ - if not ( - isinstance(arg, (str | xr.DataArray | pint.Unit | units.Unit)) - or np.isscalar(arg) - ): - raise TypeError( - f"Argument must be a str, DataArray, or scalar. Got {type(arg)}" - ) if isinstance(arg, xr.DataArray): - # arg becomes a str or None + # arg becomes str | None arg = arg.attrs.get("units", None) - if isinstance(arg, (pint.Unit | units.Unit)): - ustr = units2str(arg) - elif isinstance(arg, str): - ustr = str(units(arg).units) - else: # (scalar case, or DataArray without units attribute) - ustr = None - return ustr + # "2" is assumed to be "2 dimensionless", like a DataArray with units "" + if isinstance(arg, pint.Unit | units.Unit | str): + arg = units2str(arg) + # 2 is assumed to be 2, no dimension (None), like a DataArray without units attribute + elif np.isscalar(arg): + arg = None + if isinstance(arg, str | None): + return arg + raise TypeError( + f"Argument must be a str | DataArray | pint.Unit | units.Unit | scalar. Got {type(arg)}" + ) def _add_default_kws(params_dict, params_to_check, func): From c9e67d70d9dc5783ba0514f0bd705018c5800c82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 1 Nov 2024 10:28:49 -0400 Subject: [PATCH 098/105] make parse_string private --- src/xsdba/units.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/xsdba/units.py b/src/xsdba/units.py index 6252aa0..cb3c560 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -121,7 +121,7 @@ def infer_sampling_units( return out -def parse_str(value: str) -> tuple[str, str]: +def _parse_str(value: str) -> tuple[str, str]: """Parse a str as a number and a unit. Parameters @@ -178,7 +178,7 @@ def units2pint( value = value.attrs if isinstance(value, str): - _, unit = parse_str(value) + _, unit = _parse_str(value) metadata = None elif isinstance(value, dict): unit = value["units"] @@ -242,7 +242,7 @@ def str2pint(val: str) -> pint.Quantity: pint.Quantity Magnitude is 1 if no magnitude was present in the string. """ - mstr, ustr = parse_str(val) + mstr, ustr = _parse_str(val) return units.Quantity(float(mstr), units=units2pint(ustr)) From bd39c92346d819cf53aeb67472d5148520bf9a9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Fri, 1 Nov 2024 10:34:39 -0400 Subject: [PATCH 099/105] val -> value --- src/xsdba/units.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/xsdba/units.py b/src/xsdba/units.py index cb3c560..ce2a633 100644 --- a/src/xsdba/units.py +++ b/src/xsdba/units.py @@ -134,12 +134,12 @@ def _parse_str(value: str) -> tuple[str, str]: tuple[str, str] Magntitude and unit strings. If no magntiude is found, "1" is used by default. """ - mstr, *ustr = val.split(" ", maxsplit=1) + mstr, *ustr = value.split(" ", maxsplit=1) try: mstr = str(float(mstr)) except ValueError: mstr = "1" - ustr = [val] + ustr = [value] ustr = "dimensionless" if len(ustr) == 0 else ustr[0] return mstr, ustr From 11731fcf7fefc59668cab4f6dc022b7d229c44b1 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 4 Nov 2024 11:28:47 -0500 Subject: [PATCH 100/105] fast-forward cookiecutter --- .cruft.json | 2 +- .github/workflows/bump-version.yml | 2 +- .github/workflows/main.yml | 2 +- .github/workflows/publish-pypi.yml | 1 + .github/workflows/tag-testpypi.yml | 1 + CI/requirements_ci.in | 4 ++-- CI/requirements_ci.txt | 16 +++++++--------- environment-dev.yml | 10 +++++----- pyproject.toml | 13 ++++++------- tox.ini | 8 ++++---- 10 files changed, 29 insertions(+), 30 deletions(-) diff --git a/.cruft.json b/.cruft.json index 638e7fd..82505bf 100644 --- a/.cruft.json +++ b/.cruft.json @@ -1,6 +1,6 @@ { "template": "https://github.com/Ouranosinc/cookiecutter-pypackage", - "commit": "1d9ee5f08d3e8e4f78a4aabb75e2ce4eff8750bf", + "commit": "f750ad2185cbb56df6f7e98a269bdd8399283ea8", "checkout": null, "context": { "cookiecutter": { diff --git a/.github/workflows/bump-version.yml b/.github/workflows/bump-version.yml index 7e981bf..57938a2 100644 --- a/.github/workflows/bump-version.yml +++ b/.github/workflows/bump-version.yml @@ -46,7 +46,7 @@ jobs: actions: read steps: - name: Harden Runner - uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1 + uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1 with: disable-sudo: true egress-policy: block diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index e6a238e..88e87b9 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -59,7 +59,7 @@ jobs: - "3.10" - "3.11" - "3.12" - # - "3.13.0-rc.2" + # - "3.13" steps: - name: Harden Runner uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1 diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml index 0159dea..71bb6ac 100644 --- a/.github/workflows/publish-pypi.yml +++ b/.github/workflows/publish-pypi.yml @@ -26,6 +26,7 @@ jobs: files.pythonhosted.org:443 github.com:443 pypi.org:443 + ruf-repo-cdn.sigstore.dev:443 upload.pypi.org:443 - name: Checkout Repository uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 diff --git a/.github/workflows/tag-testpypi.yml b/.github/workflows/tag-testpypi.yml index 9a98c29..16106fb 100644 --- a/.github/workflows/tag-testpypi.yml +++ b/.github/workflows/tag-testpypi.yml @@ -50,6 +50,7 @@ jobs: files.pythonhosted.org:443 github.com:443 pypi.org:443 + ruf-repo-cdn.sigstore.dev:443 test.pypi.org:443 - name: Checkout Repository uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 diff --git a/CI/requirements_ci.in b/CI/requirements_ci.in index b60004f..291e299 100644 --- a/CI/requirements_ci.in +++ b/CI/requirements_ci.in @@ -1,6 +1,6 @@ bump-my-version==0.28.0 coveralls==4.0.1 pip==24.3.1 -flit==3.10.1 +flit==3.9.0 tox==4.23.2 -tox-gh==1.4.1 +tox-gh==1.4.4 diff --git a/CI/requirements_ci.txt b/CI/requirements_ci.txt index 2f2b595..28bc77a 100644 --- a/CI/requirements_ci.txt +++ b/CI/requirements_ci.txt @@ -1,5 +1,5 @@ # -# This file is autogenerated by pip-compile with Python 3.8 +# This file is autogenerated by pip-compile with Python 3.9 # by the following command: # # pip-compile --generate-hashes --output-file=CI/requirements_ci.txt CI/requirements_ci.in @@ -399,27 +399,25 @@ tox==4.23.2 \ # via # -r CI/requirements_ci.in # tox-gh -tox-gh==1.4.1 \ - --hash=sha256:005b33d16eef1bd1dae9f7d8b3cef53374af7d475f9c9c33ef098247741fb694 \ - --hash=sha256:da422beccbdc5ad5994fe8faf6c193f2d794e957628b052ba23e7fcf9e2e340f +tox-gh==1.4.4 \ + --hash=sha256:4ea585f66585b90f5826b1677cfc9453747792a0f9ff83d468603bc17556e07b \ + --hash=sha256:b962e0f8c4619e98d11c2a135939876691e148b843b7dac4cff7de1dc4f7c215 # via -r CI/requirements_ci.in typing-extensions==4.12.2 \ --hash=sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d \ --hash=sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8 # via - # annotated-types # pydantic # pydantic-core - # rich # rich-click # tox urllib3==2.2.2 \ --hash=sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472 \ --hash=sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168 # via requests -virtualenv==20.26.6 \ - --hash=sha256:280aede09a2a5c317e409a00102e7077c6432c5a38f0ef938e643805a7ad2c48 \ - --hash=sha256:7345cc5b25405607a624d8418154577459c3e0277f5466dd79c49d5e492995f2 +virtualenv==20.27.1 \ + --hash=sha256:142c6be10212543b32c6c45d3d3893dff89112cc588b7d0879ae5a1ec03a47ba \ + --hash=sha256:f11f1b8a29525562925f745563bfd48b189450f61fb34c4f9cc79dd5aa32a1f4 # via tox wcmatch==8.5.2 \ --hash=sha256:17d3ad3758f9d0b5b4dedc770b65420d4dac62e680229c287bf24c9db856a478 \ diff --git a/environment-dev.yml b/environment-dev.yml index 743e810..f7a2579 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -21,24 +21,24 @@ dependencies: - yamale # Dev tools and testing - netcdf4 - - pip >=24.2.0 - - bump-my-version >=0.25.1 + - pip >=24.3.1 + - bump-my-version >=0.28.0 - watchdog >=4.0.0 - flake8 >=7.1.1 - flake8-rst-docstrings >=0.3.0 - flit >=3.9.0,<4.0 - - tox >=4.17.1 + - tox >=4.23.2 - coverage >=7.5.0 - coveralls >=4.0.1 - typer >=0.12.3 - pytest <8.0.0 - pytest-cov >=5.0.0 - pytest-xdist >=3.2.0 - - black ==24.8.0 + - black ==24.10.0 - blackdoc ==0.3.9 - isort ==5.13.2 - numpydoc >=1.8.0 - pooch >=1.8.0 - pre-commit >=3.5.0 - - ruff >=0.5.7 + - ruff >=0.7.0 - xdoctest>=1.1.5 diff --git a/pyproject.toml b/pyproject.toml index 2451c27..245f791 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -53,13 +53,13 @@ dependencies = [ [project.optional-dependencies] dev = [ # Dev tools and testing - "pip >=24.2.0", - "bump-my-version >=0.26.0", + "pip >=24.3.1", + "bump-my-version >=0.28.0", "watchdog >=4.0.0", "flake8 >=7.1.1", "flake8-rst-docstrings >=0.3.0", "flit >=3.9.0,<4.0", - "tox >=4.18.0", + "tox >=4.23.2", "coverage >=7.5.0", "coveralls >=4.0.1", "mypy", @@ -68,14 +68,14 @@ dev = [ "pytest <8.0.0", "pytest-cov >=5.0.0", "pytest-xdist >=3.2.0", - "black ==24.8.0", + "black ==24.10.0", "blackdoc ==0.3.9", "isort ==5.13.2", - "ruff >=0.5.7", + "ruff >=0.7.0", "pooch >=1.8.0", "pre-commit >=3.5.0", "xdoctest>=1.1.5", - "xclim >= 0.53" + "xclim >= 0.53.2" ] docs = [ # Documentation and examples @@ -86,7 +86,6 @@ docs = [ "sphinx-intl", "sphinx-rtd-theme >=1.0", "nbsphinx", - "pandoc", "ipython", "ipykernel", "jupyter_client", diff --git a/tox.ini b/tox.ini index 7aa8b83..7a2237e 100644 --- a/tox.ini +++ b/tox.ini @@ -1,12 +1,12 @@ [tox] -min_version = 4.18.0 +min_version = 4.23.2 envlist = lint py{310,311,312,313} docs requires = flit >= 3.9.0,<4.0 - pip >= 24.2.0 + pip >= 24.3.1 opts = --verbose @@ -20,12 +20,12 @@ python = [testenv:lint] skip_install = True deps = - black ==24.8.0 + black ==24.10.0 blackdoc ==0.3.9 isort ==5.13.2 flake8 >=7.1.1 flake8-rst-docstrings >=0.3.0 - ruff >=0.5.7 + ruff >=0.7.0 numpydoc >=1.8.0 commands = make lint From bbd8ca9d22f0d6a728c06a230bde9023206d49f4 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 4 Nov 2024 12:06:10 -0500 Subject: [PATCH 101/105] try a different approach --- tox.ini | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tox.ini b/tox.ini index 7a2237e..2f76eef 100644 --- a/tox.ini +++ b/tox.ini @@ -2,7 +2,7 @@ min_version = 4.23.2 envlist = lint - py{310,311,312,313} + 3.{10,11,12,13} docs requires = flit >= 3.9.0,<4.0 @@ -12,10 +12,10 @@ opts = [gh] python = - 3.10 = py310-coveralls - 3.11 = py311-coveralls - 3.12 = py312-coveralls - 3.13 = py313-coveralls + 3.10 = py3.10-coveralls + 3.11 = py3.11-coveralls + 3.12 = py3.12-coveralls + 3.13 = py3.13-coveralls [testenv:lint] skip_install = True From a4ad584608ff25e884887db69878ce94697c2572 Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 4 Nov 2024 12:16:17 -0500 Subject: [PATCH 102/105] force Python in tox --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 88e87b9..05dd841 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -82,7 +82,7 @@ jobs: key: ${{ matrix.os }}-Python${{ matrix.python-version }}-${{ hashFiles('pyproject.toml', 'tox.ini') }} - name: Test with tox run: | - python -m tox + python -m tox -e ${{ matrix.python-version }}-coveralls env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} COVERALLS_FLAG_NAME: run-${{ matrix.python-version }} From 18ce70ee807b73acad587084af1a9951bf9c28be Mon Sep 17 00:00:00 2001 From: Trevor James Smith <10819524+Zeitsperre@users.noreply.github.com> Date: Mon, 4 Nov 2024 12:29:28 -0500 Subject: [PATCH 103/105] typo fix --- .github/workflows/bump-version.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/bump-version.yml b/.github/workflows/bump-version.yml index 57938a2..7e981bf 100644 --- a/.github/workflows/bump-version.yml +++ b/.github/workflows/bump-version.yml @@ -46,7 +46,7 @@ jobs: actions: read steps: - name: Harden Runner - uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1 + uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1 with: disable-sudo: true egress-policy: block From f031599b8ded7e72de44b4e1d3744d66c9ef5d00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 5 Nov 2024 14:19:09 -0500 Subject: [PATCH 104/105] simplify tox.int --- tests/test_properties.py | 1 - tox.ini | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/test_properties.py b/tests/test_properties.py index 01597c4..1f3bacf 100644 --- a/tests/test_properties.py +++ b/tests/test_properties.py @@ -110,7 +110,6 @@ def test_quantile(self, open_dataset): ) assert out_season.long_name.startswith("Quantile 0.2") - # TODO: test theshold_count? it's the same a test_spell_length_distribution def test_spell_length_distribution(self, open_dataset): ds = ( open_dataset("sdba/CanESM2_1950-2100.nc") diff --git a/tox.ini b/tox.ini index 7aa8b83..543dc75 100644 --- a/tox.ini +++ b/tox.ini @@ -42,7 +42,7 @@ allowlist_externals = [testenv] setenv = - PYTEST_ADDOPTS = "--color=yes" + PYTEST_ADDOPTS = "--color=yes --cov" PYTHONPATH = {toxinidir} passenv = COVERALLS_* @@ -59,6 +59,6 @@ commands_pre = pip list pip check commands = - pytest --cov xsdba {posargs} + pytest xsdba {posargs} ; Coveralls requires access to a repo token set in .coveralls.yml in order to report stats coveralls: - coveralls From f6e6efd0b43d288e517fb73e0a057fe964f3f445 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Dupuis?= <eric.dupuis.1@umontreal.ca> Date: Tue, 5 Nov 2024 14:26:30 -0500 Subject: [PATCH 105/105] try something else for tox.ini --- tox.ini | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 543dc75..96455d6 100644 --- a/tox.ini +++ b/tox.ini @@ -40,9 +40,11 @@ commands = allowlist_externals = make +[pytest] +addopts = --color=yes --cov + [testenv] setenv = - PYTEST_ADDOPTS = "--color=yes --cov" PYTHONPATH = {toxinidir} passenv = COVERALLS_*