Repository: jbusecke/xMIP (language: python)

Issue:
Adding detrending/drift removal functionality
I have developed quite a bit of logic to remove control run drift from CMIP6 models for my recent [OMZ paper](https://www.essoar.org/doi/10.1002/essoar.10507050.1), and would like to refactor this into cmip6_preprocessing.

The logic I use has these basic steps:

- Use the metadata of every historical member (see #95 for further explanation of nomenclature) to get the branch time in the parent `piControl` run `branch_time_parent`.
- Select a 250 year time period starting at `branch_time_parent`, and calculate a linear slope at every `x`, `y`, and `lev` position. Save that output
- Remove this trend from historical and forced runs by assuming an intercept of 0 at time `1850-01-01` (the time when the historical forcing starts). 

I will migrate this functionality here (and would then welcome feedback), but I wanted to discuss the API first.

First of all I was wondering about how to call the module (which I would create for this purpose): 
- `cmip6_preprocessing/drift_correction`
- `cmip6_preprocessing/time_tools` (this could more general time related functionality like #64, which is also needed for the above tools)
- `cmip6_preprocessing/detrending` (seems a bit ambiguous to me?)
Not super stoked about these yet. Any ideas?

For the API I would imagine something along the lines of:
```python
from cmip6_preprocessing.cool_modulename import sel_from_branch, detrend

ds = ...
ds_control ... # matching control run (can be inferred and matched from attributes similar as in #120)

matching_control = sel_from_branch(ds, ds_control, yrs=250)
slope = matching_control.polyfit(dim='time', deg=1)
# in a realistic workflow I would save these files out (they are relatively small) and load them back for analysis
ds_nodrift = detrend(ds, slope, start_date = '1850-01-01`)
```

Any thoughts?

cc @MackenzieBlanusa


Discussion / hints:
For a module name, I think `cmip6_preprocessing/drift_correction` is a good choice. The API is nice and straightforward. I'm a little confused on matching the control run. Do you match the control run with historical members? 
Thanks for the feedback @MackenzieBlanusa. Yes my approach is to find the time where the 'historical' run was split from 'piControl', the 250 year linear trend should then be applicable to any combination of 'historical' and scenarios. 
This makes sure that we only suptract a single linear trend. 

I am not sure if one can make an argument to detrend the scenarios separately, but in that case I would be worried that the different duration could lead to spurious signals due to interannual-decdal variability in the control.

What do you think?
Thanks for the clarification @jbusecke. I agree with your concern about detrending the scenarios separately. I think it would be best to just work with the single linear trend obtained from the historical and piControl. 
Ill try to start working on this today, and will ping you here once I have a working PR. 

Fix patch:
diff --git a/ci/environment-upstream-dev.yml b/ci/environment-upstream-dev.yml
index ca13e5dd..0744f04a 100644
--- a/ci/environment-upstream-dev.yml
+++ b/ci/environment-upstream-dev.yml
@@ -13,3 +13,4 @@ dependencies:
     - git+https://github.com/mathause/regionmask.git
     - git+https://github.com/pydata/xarray.git
     - git+https://github.com/xgcm/xgcm.git
+    - git+https://github.com/jbusecke/xarrayutils.git
diff --git a/ci/environment.yml b/ci/environment.yml
index 32f4b9d6..12305662 100644
--- a/ci/environment.yml
+++ b/ci/environment.yml
@@ -8,6 +8,7 @@ dependencies:
   - xgcm
   - cftime
   - regionmask
+  - xarrayutils
   - pytest-cov
   - pytest-xdist
   - codecov
diff --git a/cmip6_preprocessing/drift_removal.py b/cmip6_preprocessing/drift_removal.py
new file mode 100644
index 00000000..eaafb182
--- /dev/null
+++ b/cmip6_preprocessing/drift_removal.py
@@ -0,0 +1,364 @@
+import warnings
+
+import dask.array as dsa
+import numpy as np
+import xarray as xr
+
+from xarrayutils.utils import linear_trend
+
+from cmip6_preprocessing.utils import cmip6_dataset_id
+
+
+def _maybe_unpack_date(date):
+    """`Unpacks` cftime from xr.Dataarray if provided"""
+    # I should probably not do this here but instead in the higher level functions...
+    if isinstance(date, xr.DataArray):
+        date = date.data.tolist()
+        if isinstance(date, list):
+            if len(date) != 1:
+                raise RuntimeError(
+                    "The passed date has the wrong format. Got [{date}] after conversion to list."
+                )
+            else:
+                date = date[0]
+    return date
+
+
+def _construct_cfdate(data, units, calendar):
+    # This seems clunky. I feel there must be a more elegant way of doing this?
+    date = xr.DataArray(data, attrs={"units": units, "calendar": calendar})
+    return xr.decode_cf(date.to_dataset(name="time"), use_cftime=True).time
+
+
+def _datestr_to_cftime(date_str, calendar):
+    # Again I feel this should be more elegant? For now I guess it works
+    return _construct_cfdate([0], f"days since {date_str}", calendar)
+
+
+def replace_time(
+    ds, ref_date=None, ref_idx=0, freq="1MS", calendar=None, time_dim="time"
+):
+    """This function replaces the time encoding of a dataset acoording to `ref_date`.
+    The ref date can be any index of ds.time (default is 0; meaning the first timestep of ds will be replaced with `ref_date`).
+    """
+    #! I might be able to achieve some of this with time.shift
+    # !
+
+    if calendar is None:
+        calendar = ds.time.encoding.get("calendar", "standard")
+
+    if ref_date is None:
+        ref_date = _maybe_unpack_date(ds.time[0])
+
+    if isinstance(ref_date, str):
+        ref_date = _maybe_unpack_date(_datestr_to_cftime(ref_date, calendar))
+
+    # TODO: Check the frequency. Currently the logic only works on monthly intervals
+    if freq != "1MS":
+        raise ValueError("`replace_time` currently only works with monthly data.")
+
+    # determine the start date
+    # propagate the date back (this assumes stricly monthly data)
+
+    year = _maybe_unpack_date(ref_date).year - (ref_idx // 12)
+    month = _maybe_unpack_date(ref_date).month - (ref_idx % 12)
+
+    if month <= 0:
+        # move the year one more back
+        year -= 1
+        month = 12 + month
+
+    attrs = ds.time.attrs
+
+    start = f"{int(year):04d}-{int(month):02d}"
+
+    ds = ds.assign_coords(
+        time=xr.cftime_range(start, periods=len(ds.time), freq=freq, calendar=calendar)
+    )
+    ds.time.attrs = attrs
+    return ds
+
+
+def find_date_idx(time, date):
+    """Finds the index of `date` within an array of cftime dates. This strictly requires monthly data.
+    Might result in undesired behavior for other time frequencies.
+    """
+    # ! seems like I can refactor this with http://xarray.pydata.org/en/stable/generated/xarray.CFTimeIndex.get_loc.html#xarray.CFTimeIndex.get_loc
+
+    date = _maybe_unpack_date(date)
+
+    # easier approach: Find the difference in years and months
+    year_diff = date.year - _maybe_unpack_date(time[0]).year
+    month_diff = date.month - _maybe_unpack_date(time[0]).month
+
+    return (year_diff * 12) + month_diff
+
+
+def unify_time(parent, child, adjust_to="child"):
+    """Uses the CMIP6 specific metadata (augmented by cmip6_preprocessing....time_preprocessing!!!) to adjust parent time encoding to child experiment.
+    Similar to `switch_to_child_time`, but sets the time parameters (e.g. calendar) explicitly to the child conventions
+    """
+    branch_time_in_parent = child.attrs.get("branch_time_in_parent")
+    parent_time_units = child.attrs.get("parent_time_units")
+
+    # if branch time is not in attrs do nothing
+    if branch_time_in_parent is None:
+        child_source_id = child.attrs.get("source_id", "not found")
+        parent_source_id = parent.attrs.get("source_id", "not found")
+        msg = (
+            f"Could not unify time for [child:{child_source_id}|parent:{parent_source_id}]."
+            "`branch_time_in_parent` not found in attributes."
+        )
+        warnings.warn(msg, UserWarning)
+        return parent, child
+
+    else:
+        parent_calendar = parent.time.to_index().calendar
+        child_calendar = child.time.to_index().calendar
+        branch_time_parent = _construct_cfdate(
+            child.attrs.get("branch_time_in_parent"),
+            child.attrs.get("parent_time_units"),
+            parent_calendar,
+        )
+        branch_time_child = _construct_cfdate(
+            child.attrs.get("branch_time_in_child"),
+            child.time.encoding.get("units"),
+            child_calendar,
+        )
+
+        if adjust_to == "child":
+            branch_idx_parent = find_date_idx(parent.time, branch_time_parent)
+            return (
+                replace_time(
+                    parent,
+                    branch_time_child,
+                    ref_idx=branch_idx_parent,
+                    calendar=child_calendar,
+                ),
+                child,
+            )
+        elif adjust_to == "parent":
+            branch_idx_child = find_date_idx(child.time, branch_time_child)
+            return parent, replace_time(
+                child,
+                branch_time_parent,
+                ref_idx=branch_idx_child,
+                calendar=parent_calendar,
+            )
+        else:
+            raise ValueError(
+                f"Input for `adjust_to` not valid. Got {adjust_to}. Expected either `child` or `parent`."
+            )
+
+
+def calculate_drift(
+    reference, ds, variable, trend_years=250, compute_short_trends=False
+):
+    """Calculate the linear trend at every grid position for the given time (`trend_years`)
+    starting from the date when `ds` was branched of from `ds_parent`.
+    CMIP6 metadata must be present.
+
+    Parameters
+    ----------
+    ds_parent : xr.Dataset
+        The dataset from which the drift (trend) is calculated. Usually the preindustrial control run
+    ds : xr.Dataset
+        The dataset for which the drift is matched. This is usually the historical experiment.
+        !For many models, each historical member is branched
+    trend_years : int, optional
+        The duration of the trend to compute in years, by default 250 (This is the lenght of
+        historical+standard scenario, e.g. 1850-2100)
+    """
+
+    for attr in [
+        "parent_variant_label",
+        "parent_source_id",
+        "branch_time_in_parent",
+        "parent_time_units",
+        "source_id",
+        "variant_label",
+    ]:
+        if not attr in ds.attrs:
+            raise ValueError(f"Could not find {attr} in attributes of `ds`.")
+
+    # Check if the parent member id matches
+    match_attrs = ["source_id", "variant_label"]
+    for ma in match_attrs:
+        if not ds.attrs[f"parent_{ma}"] in reference.attrs[ma]:
+            raise ValueError(
+                f'`ds_parent` {ma} ({reference.attrs[ma]}) not compatible with `ds` parent_{ma} ({ds.attrs[f"parent_{ma}"]})'
+            )
+
+    # find the branch date in the control run
+    branch_time_reference = _construct_cfdate(
+        ds.attrs["branch_time_in_parent"],
+        ds.attrs["parent_time_units"],
+        reference.time.to_index().calendar,
+    )
+    branch_idx_reference = find_date_idx(reference.time, branch_time_reference)
+    # there might be some cases where this is not true. Figure out what to do when it happens.
+    assert branch_idx_reference >= 0
+
+    # cut the referenmce to the appropriate time frame
+    reference_cut = reference.isel(
+        time=slice(branch_idx_reference, branch_idx_reference + (12 * trend_years))
+    )
+
+    if len(reference_cut.time) == 0:
+        raise RuntimeError(
+            f"Selecting from `reference` according to the branch time resulted in empty dataset. Check the metadata."
+        )
+        return None
+    else:
+        if len(reference_cut.time) < trend_years * 12:
+            if compute_short_trends:
+                warnings.warn(
+                    f"reference dataset does not have the full {trend_years} years to calculate trend. Using {int(len(reference_cut.time)/12)} years only"
+                )
+            else:
+                raise RuntimeError(
+                    f"Reference dataset does not have the full {trend_years} years to calculate trend. Set `calculate_short_trend=True` to compute from a shorter timeseries"
+                )
+
+        time_range = xr.concat(
+            [
+                reference_cut.time[0].squeeze().drop_vars("time"),
+                reference_cut.time[-1].squeeze().drop_vars("time"),
+            ],
+            dim="bnds",
+        ).reset_coords(drop=True)
+
+        # there is some problem when encoding very large years. for now ill preserve these only as
+        # strings
+        time_range = time_range.astype(str)
+
+        # # The polyfit implementation actually respects the units.
+        # # For now my implementation requires the slope to be in units .../month
+        # # I might be able to change this later and accomodate other time frequencies?
+        # get rid of all the additional coords, which resets the time to an integer index
+
+        reference_cut = reference_cut[variable]
+
+        # TODO: This has pretty poor performance...need to find out why.
+        # Reset time dimension to integer index.
+        #         reference_cut = reference_cut.drop_vars("time")
+
+        # linear regression slope is all we need here.
+        #         reg = reference_cut.polyfit("time", 1).sel(degree=1).polyfit_coefficients
+
+        reg = (
+            linear_trend(reference_cut, "time")
+            .sel(parameter="slope")
+            .drop("parameter")
+            .squeeze()
+        )
+
+        # again drop all the coordinates
+        reg = reg.reset_coords(drop=True)
+
+        reg = reg.to_dataset(name=variable)
+
+        # add metadata about regression
+        reg = reg.assign_coords(trend_time_range=time_range)
+        reg.coords["trend_time_range"].attrs.update(
+            {
+                "standard_name": "regression_time_bounds",
+                "long_name": "regression_time_in_reference_run",
+            }
+        )
+        # reg should carry the attributes of `ds`
+        # ? Maybe I should convert to a dataset?
+        reg.attrs.update(ds.attrs)
+        return reg
+
+
+# TODO: I need a more generalized detrending? Based on indicies --> xarrayutils
+# Then refactor this one here just for cmip6
+
+
+def detrend_basic(da, da_slope, start_idx=0, dim="time", keep_attrs=True):
+    """Basic detrending just based on time index, not date"""
+    # now create a trend timeseries at each point
+    # and the time indicies by the ref index. This way the trend is correctly calculated from the reference year.
+    ## this adapts the chunk structure from the input if its a dask array
+    attrs = {k: v for k, v in da.attrs.items()}
+    idx_start = -start_idx
+    idx_stop = len(da.time) - start_idx
+    if isinstance(da.data, dsa.Array):
+        ref_time = da.isel({di: 0 for di in da.dims if di != dim})
+        chunks = ref_time.chunks
+        trend_time_idx_data = dsa.arange(
+            idx_start, idx_stop, chunks=chunks, dtype=da.dtype
+        )
+    else:
+        trend_time_idx_data = np.arange(idx_start, idx_stop, dtype=da.dtype)
+
+    trend_time_idx = xr.DataArray(
+        trend_time_idx_data,
+        dims=[dim],
+    )
+
+    # chunk like the time dimension
+    slope = da_slope.squeeze()
+
+    trend = trend_time_idx * slope
+
+    detrended = da - trend
+    if keep_attrs:
+        detrended.attrs.update(attrs)
+    return detrended
+
+
+def remove_trend(ds, ds_slope, variable, ref_date, check_mask=True):
+    """Detrending method for cmip6 data. Only works with monthly data!
+    This does not correct the time convention. Be careful with experiements that have
+    a non compatible time convention (often control runs.)
+    """
+
+    if not isinstance(ds, xr.Dataset):
+        raise ValueError("`ds` input needs to be a dataset")
+
+    if not isinstance(ds_slope, xr.Dataset):
+        raise ValueError("`ds_slope` input needs to be a dataset")
+
+    da = ds[variable]
+    da_slope = ds_slope[variable]
+
+    da, da_slope = xr.align(da, da_slope, join="override")
+
+    if check_mask:
+        nanmask_data = np.isnan(da.isel(time=[0, len(da.time) // 2, -1])).all("time")
+        nanmask_slope = np.isnan(da_slope)
+        # perform a quick test to see if the land is aligned properly
+        if np.logical_xor(nanmask_data, nanmask_slope).any():
+            raise ValueError(
+                "Nanmask between data and slope array not identical. Check input and disable `check_mask` to skip this test"
+            )
+
+    ref_calendar = da.time.to_index().calendar
+    ref_date = xr.cftime_range(ref_date, periods=1, calendar=ref_calendar)
+
+    # Find the index corresponding to the ref date (this can be outside the range of the actual data)
+    ref_idx = find_date_idx(da.time, ref_date)
+
+    detrended = detrend_basic(
+        da, da_slope, start_idx=ref_idx, dim="time", keep_attrs=True
+    )
+
+    # add information to track which data was used to remove trend
+    if "trend_time_range" in ds_slope.coords:
+        trend_start = ds_slope.trend_time_range.isel(bnds=0).data.tolist()
+        trend_stop = ds_slope.trend_time_range.isel(bnds=1).data.tolist()
+
+    else:
+        trend_start = "not-available"
+        trend_stop = "not-available"
+        warnings.warn(
+            "`ds_slope` did not have information about the time over which the slope was calculated. Check the input."
+        )
+
+    detrended.attrs[
+        "drift_removed"
+    ] = f"linear_trend_{cmip6_dataset_id(ds_slope)}_{trend_start}_{trend_stop}"
+
+    return detrended
diff --git a/cmip6_preprocessing/utils.py b/cmip6_preprocessing/utils.py
index 2ea633ae..3bdaae92 100644
--- a/cmip6_preprocessing/utils.py
+++ b/cmip6_preprocessing/utils.py
@@ -67,6 +67,7 @@ def cmip6_dataset_id(
         "institution_id",
         "source_id",
         "experiment_id",
+        "variant_label",
         "table_id",
         "grid_label",
         "version",
diff --git a/docs/drift_removal.ipynb b/docs/drift_removal.ipynb
new file mode 100644
index 00000000..b01552ab
--- /dev/null
+++ b/docs/drift_removal.ipynb
@@ -0,0 +1,3015 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9e0e9928",
+   "metadata": {},
+   "source": [
+    "# Time Based Utilities and Drift Removal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "10b03732",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import xarray as xr\n",
+    "import numpy as np\n",
+    "\n",
+    "from cmip6_preprocessing.utils import google_cmip_col\n",
+    "from cmip6_preprocessing.preprocessing import combined_preprocessing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4c9b2a2d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[]\n",
+      "[]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dask_gateway import Gateway\n",
+    "g = Gateway()\n",
+    "running_clusters = g.list_clusters()\n",
+    "print(running_clusters)\n",
+    "for c in running_clusters:\n",
+    "    # g.stop_cluster()\n",
+    "    cluster = g.connect(c.name)\n",
+    "    cluster.close()\n",
+    "print(running_clusters)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9f39a72c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5576118f47db470c843f2d36fa25d2be",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HTML(value='<h2>GatewayCluster</h2>'), HBox(children=(HTML(value='\\n<div>\\n<style scoped>\\n    …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from distributed import Client\n",
+    "from dask_gateway import GatewayCluster\n",
+    "cluster = GatewayCluster()\n",
+    "cluster.scale(30)\n",
+    "cluster"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3576d7b8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table style=\"border: 2px solid white;\">\n",
+       "<tr>\n",
+       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
+       "<h3 style=\"text-align: left;\">Client</h3>\n",
+       "<ul style=\"text-align: left; list-style: none; margin: 0; padding: 0;\">\n",
+       "  <li><b>Scheduler: </b>gateway://traefik-gcp-uscentral1b-staging-dask-gateway.staging:80/staging.f1abefca0c73428d92aaf87d3ccdc4ac</li>\n",
+       "  <li><b>Dashboard: </b><a href='/services/dask-gateway/clusters/staging.f1abefca0c73428d92aaf87d3ccdc4ac/status' target='_blank'>/services/dask-gateway/clusters/staging.f1abefca0c73428d92aaf87d3ccdc4ac/status</a></li>\n",
+       "</ul>\n",
+       "</td>\n",
+       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
+       "<h3 style=\"text-align: left;\">Cluster</h3>\n",
+       "<ul style=\"text-align: left; list-style:none; margin: 0; padding: 0;\">\n",
+       "  <li><b>Workers: </b>0</li>\n",
+       "  <li><b>Cores: </b>0</li>\n",
+       "  <li><b>Memory: </b>0 B</li>\n",
+       "</ul>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<Client: 'tls://10.39.58.9:8786' processes=0 threads=0, memory=0 B>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "client = Client(cluster)\n",
+    "client"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "196fba40",
+   "metadata": {},
+   "source": [
+    "## Loading example data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d6d8ce04",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--> The keys in the returned dictionary of datasets are constructed as follows:\n",
+      "\t'activity_id.institution_id.source_id.experiment_id.member_id.table_id.variable_id.grid_label.zstore.dcpp_init_year.version'\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "        <style>\n",
+       "            /* Turns off some styling */\n",
+       "            progress {\n",
+       "                /* gets rid of default border in Firefox and Opera. */\n",
+       "                border: none;\n",
+       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
+       "                background-size: auto;\n",
+       "            }\n",
+       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
+       "                background: #F44336;\n",
+       "            }\n",
+       "        </style>\n",
+       "      <progress value='3' class='' max='3' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      100.00% [3/3 00:04<00:00]\n",
+       "    </div>\n",
+       "    "
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--> The keys in the returned dictionary of datasets are constructed as follows:\n",
+      "\t'activity_id.institution_id.source_id.experiment_id.member_id.table_id.variable_id.grid_label.zstore.dcpp_init_year.version'\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "        <style>\n",
+       "            /* Turns off some styling */\n",
+       "            progress {\n",
+       "                /* gets rid of default border in Firefox and Opera. */\n",
+       "                border: none;\n",
+       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
+       "                background-size: auto;\n",
+       "            }\n",
+       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
+       "                background: #F44336;\n",
+       "            }\n",
+       "        </style>\n",
+       "      <progress value='3' class='' max='3' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      100.00% [3/3 00:04<00:00]\n",
+       "    </div>\n",
+       "    "
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--> The keys in the returned dictionary of datasets are constructed as follows:\n",
+      "\t'activity_id.institution_id.source_id.experiment_id.member_id.table_id.variable_id.grid_label.zstore.dcpp_init_year.version'\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "        <style>\n",
+       "            /* Turns off some styling */\n",
+       "            progress {\n",
+       "                /* gets rid of default border in Firefox and Opera. */\n",
+       "                border: none;\n",
+       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
+       "                background-size: auto;\n",
+       "            }\n",
+       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
+       "                background: #F44336;\n",
+       "            }\n",
+       "        </style>\n",
+       "      <progress value='1' class='' max='1' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      100.00% [1/1 00:00<00:00]\n",
+       "    </div>\n",
+       "    "
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "zkwargs = {'consolidated':True, 'use_cftime':True}\n",
+    "kwargs = {'zarr_kwargs':zkwargs, 'preprocess':combined_preprocessing, 'aggregate':False}\n",
+    "\n",
+    "col = google_cmip_col()\n",
+    "\n",
+    "\n",
+    "cat = col.search(source_id='CanESM5-CanOE', variable_id='thetao')\n",
+    "\n",
+    "\n",
+    "ddict_historical = cat.search(experiment_id='historical').to_dataset_dict(**kwargs)\n",
+    "ddict_ssp585 = cat.search(experiment_id='ssp585').to_dataset_dict(**kwargs)\n",
+    "ddict_picontrol = cat.search(experiment_id='piControl').to_dataset_dict(**kwargs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "138a525f",
+   "metadata": {},
+   "source": [
+    "## Pick some example data\n",
+    "\n",
+    "Lets pick a particular member and define a point in x/y/z space that we will use throughout this demonstration to extract timeseries at the same point. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "83d7a802",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds_control = ddict_picontrol['CMIP.CCCma.CanESM5-CanOE.piControl.r1i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/CMIP/CCCma/CanESM5-CanOE/piControl/r1i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429']\n",
+    "ds_historical = ddict_historical['CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/CMIP/CCCma/CanESM5-CanOE/historical/r1i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429']\n",
+    "ds_ssp585 = ddict_ssp585['ScenarioMIP.CCCma.CanESM5-CanOE.ssp585.r1i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/ScenarioMIP/CCCma/CanESM5-CanOE/ssp585/r1i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429']\n",
+    "\n",
+    "# Pick a random location in x/y/z space to use as an exmple\n",
+    "roi = {'x':100,'y':220, 'lev':30}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "088651ea",
+   "metadata": {},
+   "source": [
+    "## Visulalizing branching from the control run\n",
+    "\n",
+    "Lets first start by visualizing the example point of our data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a872e6b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98efd3cfa0>]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# ok lets just plot them together\n",
+    "ds_control.isel(**roi).thetao.plot(color='0.5')\n",
+    "ds_historical.isel(**roi).thetao.plot(color='C1')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "377b4b21",
+   "metadata": {},
+   "source": [
+    "Hmm well that doesnt look good. Its because the control run follows a different time convention. But we can check when the run was branched out exactly by looking at the metadata of the historical run:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "98170b1f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'CCCma_parent_runid': 'canoecpl-007',\n",
+       " 'YMDH_branch_time_in_parent': '5550:01:01:00',\n",
+       " 'branch_time_in_parent': 1350500.0,\n",
+       " 'parent_activity_id': 'CMIP',\n",
+       " 'parent_experiment_id': 'piControl',\n",
+       " 'parent_mip_era': 'CMIP6',\n",
+       " 'parent_source_id': 'CanESM5-CanOE',\n",
+       " 'parent_time_units': 'days since 1850-01-01 0:0:0.0',\n",
+       " 'parent_variant_label': 'r1i1p2f1'}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{k:v for k,v in ds_historical.attrs.items() if 'parent' in k}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddafcec2",
+   "metadata": {},
+   "source": [
+    "And of course there is a tool in here that makes translating these a bit easier. We can just convert time conventions from child to parent or vice versa."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "db3e0da1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cmip6_preprocessing.drift_removal import unify_time\n",
+    "\n",
+    "# the default will adjust the time convention from the first input (`parent`) to the second (`child`)\n",
+    "ds_control_adj, ds_historical_adj = unify_time(ds_control, ds_historical)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e9aa5566",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98ee01f490>]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# ok lets just plot them together\n",
+    "ds_control_adj.isel(**roi).thetao.plot(color='0.5')\n",
+    "ds_historical_adj.isel(**roi).thetao.plot(color='C1')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d56ab36",
+   "metadata": {},
+   "source": [
+    "That looks more sensible, but with all the wiggles its a bit tough to see. Since this run seems to be branched of at the first time step of the control ouput (the run is probably much longer, but not all data was provided to the archive), lets just cut to the first couple of timesteps to check in more detail. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "8fb0ba18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98bfc65910>]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# ok lets just plot them together\n",
+    "ds_control_adj.isel(**roi, time=slice(0,24)).thetao.plot()\n",
+    "ds_historical_adj.isel(**roi, time=slice(0,24)).thetao.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a9d55b4c",
+   "metadata": {},
+   "source": [
+    "That looks pretty good, but the values are slightly shifted. This is due to the fact that for the 'untouched' CMIP6 monthly data uses a timestamp in the 'middle' of the month, whereas our adustment uses the start of the month. We can quickly adjust that:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "795128c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cmip6_preprocessing.drift_removal import replace_time\n",
+    "# with the defaults it will just replace the dates with new ones which have time stamps at the beginning of the month.\n",
+    "ds_historical_adj = replace_time(ds_historical_adj) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "26317ac7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98bfce4b20>]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEWCAYAAAC0Q+rDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAABXMElEQVR4nO2dd3xUVfbAv2fSSSCQQi8JvXcQFFAUGyKWtSOuK4p917ar664u6rrFXXWtP3vvXSxgl14MRXqvoYaEVEhIOb8/7osOIZlMkpnMTHK/n8/7zMy79717Xpl33r3n3HNEVbFYLBaLxR+4Ai2AxWKxWBouVslYLBaLxW9YJWOxWCwWv2GVjMVisVj8hlUyFovFYvEbVslYLBaLxW9YJWNp8IhIioioiIQHWhaLxR0RuVJE5gZaDn9ilUyQISIPiMhKESkRkWmVlF8mIttFpEBEPhGRBLeyKBF5SURyRWSviNxWr8JXg4j8UURWiUieiGwVkT+6lbUUkbdFZLeI5IjIPBE5rsL2VR67D2U8SUTSfb1fZ9+viMgREcl3W8Lcyp8TkfUiUiYiV1azr4dEZKdzrbeLyF/cypKc85cpItkiskBETqiwfWcR+dy5FgdE5CG3sgQR+dg5z9tF5DK3skgR+UBEtjmK+6QK+51R4fiOiMjKCnX+4Fz/AhFZKyLd3co83d8JIvKuI+8BEXlTRJq5lYeJyN+deyhPRJaJSPNKzt337i8dzv/mRafd8u3OdKtf/pLiflz3uJVHicgzIrJPRLJE5DMRaefp+jUmrJIJPjYBfwK+qFggIn2AZ4HJQCvgEPC0W5VpQDegEzAW+JOInOFneWuCAFcALYAzgJtE5BKnLA74CRgCJACvAl+ISBx4deyhwkOqGue2lLqV/QzcACz1Yj8vAj1VtRlwPHCZiJzvlOUDVwHJmHP9b+Azt4dqJPAN8D3QGmgPvOG276eAI5jzPAn4P+f8lzMXuBzYW1EoVT3T/fiA+cD75eUicjUwBTgLc80nAAecsuqu8d+d4+kMdHHqTHMrv885FyOBZs5+Ct3lE5FJQMUebTiwEzgRiAfuAd4TkZQK9Zq7HdsDbuv/4LTZH2gLZANPVDw3jRZVtYsXC+amzgIGO7/bYv4cJ/mpvTeAaRXW/QN4q4JMR4Cmzu9dwGlu5Q8A73jRVmvMHzrRbd0QIAOI8OM5fRx4wkN5LjDEm2Ovpp0UQIFw5/fvgLVAHrAFuNZZHwscBsowD+p8oK0Pj/cV4O9e1JsLXFmD/bYDVgJ/qqTMBZztHH9LZ91UYE4V+4p1zmt3t3WvA/+qpG66p/vfOe+lQKqbLDuBU6qoX939PQO4wa38RuAr53sL53p18SBPPLABGOF+P1RRdwXwm8run0rq/h/m5aH891nAei+v3ZXAXLffPTEvAFnAeuAiZ/0IjFIPc6t7HrDCV/envxbbk/ESVd0M3Am8KSJNgJeBV1T1x8rqO0MR2VUsn9dSjD6Yt113mY4A3UWkBUbx/exW/2dnm+qObS/wI3CR2+rLMQqquGJ9Z0ijqmPLFpGO1bUpIgKMBlZXUT4QiMT07MDDsVfXViXsx7xBN8MonEdFZLCqFgBnArv11zfW3ZXIdpen46+m7RucIZUlIvKbWsheUY58zMM+FnirQvkKzJv8dOAFVd3vFI0AtjlDWwdE5EcR6eeUdQdKVXWD2668uo8q4QqMMtvq/G7vLH3FDPVtFZH7RKT8OVTdNX4KmCAiLZz7/TcYxQPQDygBLhAzVLxBRG6sIM8/MArhmB6YOyLSymmz4r25XUTSReRlEUlyW/8icIKItHWeDZPc5PIaEYnFKJi3gJbApcDTItJHVRcCBcDJbptcRoVrHoxYJVMDVPV5YCOwCGgD/MVD3Qmq2ryKZUItRYgDciqsywGaOmVUKC8v84ZXMYoFMXaCSzFvsMegqm95OLbmqrrDi/amYe6/lysWOOPsrwP3qWr58Xg69hqhql+o6mY1zAK+xig8b7f/l6fj97Dp45jhzJaYIZlXpIKtpIbH8S/M8Q/GnK+cCuX9MYr0MkzvqJz2wCWOPG0xQ7OfOsNoPjvPGCXzSoV2AU7DKIWxmPtsirO+uraXYl48Mp2llF+H09pjeirdgVTgAmCaiJwKICJDgROoZhhLRCKAN4FXVXWds/oAMAwzDD3EkedNt802ADswIwm5QC/gfk/tVMEEYJuqvqyqJaq6FPjQORaAtzHnCxFpCox31gU1VsnUnOeBvphhnqJ6bjsf89Bwpxlm2Cff7XfFMm/4FOgtIp2BU4EcVV1cB1mrRERuwjyAzqp4DkUkBvgMWKiq/3Qr8nTsNW3/TBFZ6PQosjF/1qRqNqszqrpUVTOdB8iXmAfV+dVtV80+VVWXYYb57qukvFBV3wbuEpEBzurDmCGaGap6BPgvkIh5OPrkPIvIKMww7Aduqw87nw+paraqbsPYYMY766tr+33MA72ps34zv9qSyvd9v6oeVtUVwDvAeKen9DTwB1Ut8SCzC6OsjwA3la9X1XxVTXOu2z6n7DQ3p4P/A6Ix5zAW+Iha9GQwSuy4Cr3iSZjzCKbXcr6IRGHum6Wqur0W7dQrVsnUAMcI/T9M93iaePBukmO9bNyX2tyAYLrv5Q8KHIUQBWxQ1YPAHvdy53ulw1EVUdVC4D3MTT2ZKnoxTruTPBxbvqfhMhG5CrgLMy6fXqEsCvgE80Z4bYVNqzx2b46vQhsfYh6srZyex5cYpwQwY+/V7eNuT8dfA3HUrd26Eo6xYVRFBMZgDsbeUNVxbgDCRaSb2zqv7yM3fgt8pKru52M95gFeVdvVXeMBwLOqWuDs9xl+VVArnM/K9t0MGAq8KyJ7MQ4mAOkiMtppSzD/61YYW8wxw8RulLdRfu0GYIbOs5yXpieA4RWG1LxhJzCrQs84TlWvB1DVNcB2zJBuSAyVAdbwX5MFcxO+53x/rvy7j9uIwLwVvYXxponGMfZhxqxzMUM7sZi3uHfctv0XMAtjBO2JUTpnuJVvw4NBGTOcsBnz5pjih2ObhBkP71XFcX+GUTLHGFi9OPZpwI9VtJuCY7jFvAWXYjyJBPOHPYRjkHfO22Eg3g/HfwFmSMiFGTLKw81wjhkKigbmAdc4312V7MeFUcItnGMY7lzr3zvlI4BRzv5iMLbEPBwnBqCHc8zjgDDgVue6Rzrl72CGYWKdeyIH6OPWfpQjW7pzHNGAuJXHYDysTq5E9teAz53r0B5YB0zx8hr/gHmAxzjL08A8t/LZmJ5RFKZXth84xTlHrd2WYc790M7tmJ8BFgJxlch8nHPOXJjeyrvAD27lL2NeXOIx9/HdwC638h+p4MTjVnYljuHfOSfbMS95Ec4yDLf/i3Mtv8fco0m+vkf9sQRcgFBZgHMwb9gJzu84jFF6ko/becX5A7gvV7qVX4YZ/y3ADHEluJVFAS85f9R9wG1uZZGYB03PatrfiHmb8sc53AoU86vnVj7wjFN2onOshyqUj/by2F8EHqyi3RSO9i670Tk/2Zge2zu4eX055zDTKfeld9kczAM7F2PgvqRC+Y+VXPuTnLJJwGrnuwuYifFAyse86d+N86B3zuXPzvXOwrx4jKnQ1vnO/ZvrtOuuRBIwyr7AOd+XVdh2WyVypriVX4p5WEol56CZc77zMG/u93K0gvJ0jVMxLyKZznHNBLq5lbdz1uXj5jXoxf3QyfldWOHem+R2PFsdmfZgFGVrt/0lYoY+9zv3zFxguFv5ZuDUKmS5kqO9y3pgbGQZznF+Dwx0K++I8X78opp77W5ghtvvGcDdbr+P+m/5cym/KS0NHGeM/EZVvbSaet9j3EhfqB/JfIOILMcMwWUGWhaLpRwRaQ+8r6ojAy1LoLBKxvILIjIM40LZQVVrbFC3WCyWiljDvwUAEXkV+Ba4xSoYi8XiK2xPxmKxWCx+w/ZkLBaLxeI3Gm3o86SkJE1JSQm0GBaLxRJSLFmy5ICqJntbv9EqmZSUFNLS0gIthsVisYQUIlKjKAN2uMxisVgsfsMqGYvFYrH4DatkLBaLxeI3rJKxWCwWi9+wSsZisVgsfsMqGYvFYrH4DatkLBaLxeI3rJJpQBSXlvHGwu1s2m9Dj1ksluAgaJSMiLwkIvtFZFUV5ZNEZIWzzHdLJYuINBeRD0RknYisFZFGGVb71fnb+Osnqzj10dlc9/oSVqRnB1oki8XSyAkaJYNJ1nWGh/KtwImq2h94AJOZspzHgJmq2hOTCnWtv4QMVvbnFfLYtxsZ3S2Jm8d2Zf7mA0x8ch6TX1zEwi2Z2ECoFoslEARNWBlVnS0iKR7K57v9XIhJ3YqINAPGYDLMoapHMHnEGxX/nrGeopIy7j+nL6lJsVwzpjNvLtrBC3O2cslzCxncsTk3ju3KyT1bYtKZWywWi/8Jpp5MTZiCSScK0BmTqvRlEVkmIi+ISGxlG4nIVBFJE5G0jIyM+pLV7yzZfpAPl6YzZXQqqUnm0JtGR3DdiV2Ye+dYHjinD/tyi5jyahpnPjaH6T/vprTM9mwsFov/Cap8Mk5P5nNV7euhzljgaWCUqmaKyFBMz+YEVV0kIo8Buap6j6e2hg4dqg0hQGZpmXLuU/PIyCviu9tPJDaq8s5pcWkZn/28m6d/3Mym/fmkJDbh2hO7cP7gdkSFh9WLrKpKYXEZMZH1057FYvE9IrJEVYd6Wz+kejIi0h94ATjHLZd7OpCuqouc3x8AgwMhXyB496edrNyVw5/H96xSwQBEhLk4f3B7vr5lDM9cPoRmMRH8+aOVjHnoB16Ys4XC4lK/yplVcITLnl/EiH9+Zx0SLJZGRMgoGRHpCHwETFbVDeXrVXUvsFNEejirTgHWBEDEeif70BH+89U6hqcmMHFAW6+2cbmEM/q25tMbT+D1KcPpnBTH379Yy7lPzWPT/ny/yLlhXx7nPDWXJTsOEhMRxuUvLGJleo5f2rJYLMFF0CgZEXkbWAD0EJF0EZkiIteJyHVOlXuBROBpEVkuIu5jXTcDb4rICmAg8I/6lD1QPPLNBnIOF3PfxD41NuaLCKO7JfP21BG8dOVQ9ucVcfYTc3k/badPPdG+XbOP856aR1FxGe9OHcEH14+kWUwEk15YyKpdVtFYLA2doLLJ1CehbpNZszuXCU/MYfKITtx3TpUmLK/Zm1PILe8uY+GWLM4d2Ja/n9ePOA/Db9WhqvzfrM3856v19GsXz3OTh9I6PhqAnVmHuOS5heQXlfDm1cfRt118neW3WCz1Q4O2yVgMqsq06atp3iSS207tUf0GXtA6Ppo3rx7Bbad2Z/rPu5nw+Jxa9zQKi0u55d3lPDRzPWf3b8t71478RcEAdEhowjtTRxAXFc6kFxbZHo3F0oCxSiYEmf7zbhZvy+JPp/cgvkmEz/Yb5hJ+f0o33r5mBIXFZZz39Dxemru1RsNne3MKufjZBXy6fDd/PL0Hj10ykOiIY73J3BXN5S8uYvVuq2gsloaIVTIhRn5RCf/4ci3928dz0dAOfmnjuM6JzPjDaE7snsz9n6/hmtfSOFhQ/fzW5TuzmfjkXDbtz+e5yUO4cWxXj7aickUTG2l6NFbRWCwND6tkQownvt/Ivtwi7pvYB5fLfzP3W8RG8vwVQ7l3Qm9mbcjgzMfmsHhrVpX1P1m2i4ueXUBkuIsPbzie0/q09qqdDglNePuaETSJCGPSC4tYszvXV4dgsViCAKtkQojNGfm8NHcrFwxpz6COLfzenohw1ahUPrr+BKIjXFzy3AIe/27jUdECSsuUf81Yxy3vLmdQh+ZMv2kUPVs3q1E7HROb8M7UkY6iWWgVjcXSgLBKJkRQVe77bA3R4WHceUbPem27X/t4Pv/9aCYOaMsj32zg8hcWsS+3kLzCYqa+lsYzszZz2XEdeX3KcSTERtaqjY6JTXh76giiHUWzdo9VNBZLQ8C6MIcIX6/ey9TXl3DPhN5MGZUaEBlUlQ+WpHPvp6uJiQyjRZMItmUeYtrZvZk8MsUnbWzPLODiZxdypLSMt645rsa9IovF4l+sC3MDpLC4lAe+WEO3lnFcMbJTwOQQES4c2oHPbh5Fy6ZRZBYc4fWrhvtMwQB0SozlnakjiAxzcdnzi1i31/ZoLJZQxiqZEOC52VvYmXWY+yb2ISIs8Jesa8s4vvj9aObfdTLHd03y+f5TkmJ5e+oIIsKEy55fxPq9NtOnxRKqBE0+GUvlpB88xNM/buKsfm388kCvLWEuoUmk/26f1KRY3pk6kkueW8Blzy9k4sC2hIkQ5hJcLsElECbme/mnS4QwF7jEfO/bLp7hqQl+k9FisVSPVTJBzoNfmCSfd5/VK8CS1D+pSbG8fc0Irn9jKR+kpVOqSmmZosov3z3hEvj61jF0bdm0niS2WCwVsUomiJm36QAzVu3l9lO70655TKDFCQidk+P46tYxVZaXlSllqpSqUlZmlE+ZKjmHihn/2Bz+PXM9z1/htY3SYrH4mMAP8Fsqpbi0jL9NX03HhCZcM6ZzoMUJWlwuITzMRVR4GDGRYcRFhdMsOoIOCU247qQufLNmH2nbqp5EarFY/ItVMkHK6wu2s2l/PvdO6F1p7C9L9Vx1QiqtmkXxjy/X+jR9gcVi8R6rZIKUL1buoX/7eE7p1TLQooQsMZFh3DquO0t3ZPPV6n2BFsdiaZRYJROElJSWsWZ3LkM6tahxMjLL0VwwpD1dW8bx0FfrKCktC7Q4FkujwyqZIGRzRgGHi0vpZ5N51ZnwMBd3ntGTLRkFvJu2M9DiWCyNDqtkgpCVThKv/u2tkvEF43q1ZFhKC/737UYOHSkJtDgWS6PCKpkgZGV6Nk0iw0hNigu0KA0CEeGuM3uSkVfEC3O2Bloci6VRYZVMELJyVw5928YT5sd8MY2NIZ0SOL1PK56dtZkD+UWBFsdiaTQEjZIRkZdEZL+IrKqifJKIrHCW+SIywK1sm4isFJHlIhI6oZUroaS0jDV7culnh8p8zp/O6ElhSRlPfr8p0KJYLI2GoFEywCvAGR7KtwInqmp/4AHguQrlY1V1YE1CUAcjmzLyKSwus0Z/P9AlOY6Lh3XgzUXb2Z5ZEGhxLJZGQdAoGVWdDVQ5NVtV56vqQefnQqB9vQhWz6xIN0b/RtmTUYUjhyB3N+xbDdvmwdrPYflbsOk7yN4JZXVzQ77llG6Eu1z856v1PhLaYrF4IlRjl00BZrj9VuBrEVHgWVWt2MsBQESmAlMBOnbs6Hcha8OqXTnERYWTmhgbaFF8z8HtsOI9OJwFhw/C4WzzWZj96+/SauwlEbGQ1BWSukNSD0jqZr4ndoHwqGpFaNksmmtGp/L495u4ZnQ2Azo098GBWSyWqgg5JSMiYzFKZpTb6hNUdbeItAS+EZF1Ts/oKBzl8xyYzJj1InANWZGeQ5+2zXA1NKP/4YPw2kQ4uA0im0JMC4iJh+jmRknENDfrop3PmOa/fo9qCnl7IGM9HNgIBzbAjoWw8v1f9y8uaJFytOJJGQUJx2YRnXpiF95ctIN/zVjHW9ccZye8Wix+JKSUjIj0B14AzlTVzPL1qrrb+dwvIh8Dw4FjlEywU1xaxto9uUweEbjsl36hrBQ+vAZydsGUb6DD8JrvI7GLURruHClwlI6jeA44Smjzd1B6xPR6bk6DZm2P2iwuKpzfn9KNv01fzY8bMhjbw4busVj8RcgoGRHpCHwETFbVDW7rYwGXquY5308D7g+QmHVi4758ikrKGp495sd/waZv4KxHaqdgqiIyFtoONIs7ZaWwZzm8dAZ8/yCc+9Qxm146vCMvzdvKv2esY0y3ZOsubrH4iaAx/IvI28ACoIeIpIvIFBG5TkSuc6rcCyQCT1dwVW4FzBWRn4HFwBeqOrPeD8AHrHJm+jcoz7J1X8Dsh2DQ5TD0qvpp0xUG7YbA8Kmw/E3Ye6xXfGS4iztO68G6vXl8vGxX/chlsTRCgqYno6qXVlN+NXB1Jeu3AAOO3SL0WLErm6ZR4aQ0FKP/gY3w0bXQdhCMfxjq2/Yx5g5Y9gZ8cw9M/viY4rP6teH5OVt45Ov1TOjfxqZUsFj8QND0ZCywMj2HPu0aiNG/KA/emQThkXDR6xARXf8yxLSAE/8Em7+HTd8eU+xymXAzu3MKeXX+tvqXz2JpBFglEyQcKSlj7d48+rdvHmhR6o4qfHIDZG6EC16G5h0CJ8uwq6F5J/j6XmOrqcDxXZI4qUcyT/2wiexDRwIgoMXSsLFKJkjYsC+PIyUNZKb/vP/B2ulw6v3Q+cTAyhIeBeOmwf7V8PPblVa584ye5BWV8PSPm+tXNoulEWCVTJDQYIz+m7+H7+6HPufDyJsCLY2hz3nQbih8/3fj9lyBXm2acf6g9rwyfxu7sg8HQECLpeFilUyQsGJXDk2jw+mU2CTQotSeg9vhg6sguSec82T9G/qrQgRO+7uZ0Lng6Uqr3HZadwAe+XpDpeUWi6V2WCUTJKzalUO/dvGhO/u8+DC8e7mJLXbxG2YOSzDRaST0nGCG8vL3H1PcrnkMk0d04uNl6eQcKq5/+SyWBopVMkHAkZIy1u3JC91JmKrw+a2wdwX85nkzOz8YGXcflBTCj/+stPiUXi0pU1i642Cl5RaLpeZYJRMEbNiXx5HSEDb6//SCMaqf9GfofnqgpamapK5mQuiSV00ctAoM7NCcMJeQtr3KYOAWi6WGWCUTBJSH9+/frnlgBakN2xfAzLug+xkw5k+BlqZ6TrzTDOV987djippEhtO3bTPSttmejMXiK6ySCQJW7sohPiaCDgkxgRalZuTugfd/a+ahnPcsuELgdopNglG3woYZsHXOMcVDOiWwfGc2R0rqlrfGYrEYQuCp0PBZuSs79Iz+JUfgvSugKN8Y+mOaB1oi7xlxPTRrD1//9ZgkaENTWlBUUsbq3TkBEs7SYCkuNE4nmZth11LY8iOsmQ7L3oSF/wcr3q90wnCoEzSxyxorRSWlrN+bx5RRnQMtSs348R+QvtjM6G/VO9DS1IyIGDjlHvj4Wlj1AfS/6JeioZ1aALBk+0EGdWwRKAktPqC41DjULNt5kGU7TO90bM+WnNKzJS1iI33fYFmZ+U+s/Qz2/AxFuVCYa0IsFeWa9BPVseAJE+evwzDfyxcgrJIJMOv35lFcqvQPJc+yQ1mw6FnodxH0PT/Q0tSOfhfBgqfMxNFeE3+JrdayWTQdE5rw07Ysrh4dYoq/kbMvt5BlO4xCWbrjICvScyhyhj2Tm0bhEvhi5R5cAsNSEjitT2tO692KDgl1mJtWWgLb5xrFsvZzyN8LYZHQZgDEtYLEbhDdDKKameR70fHme7Tz+5fvzWDLD/DVX+DFcSZq+bj7zPBuiGOVTIBZGYoz/Rf+HxQfgtG3B1qS2uNymQmar02ERc/AqFt+KRraqQWzN2agqqE1hNmIKCwuZfXuHJbtyHaWg+zOKQQgMsxF33bNuHxEJwZ1bM6gji1oG29eIlbuyuHr1fv4Zs0+Hvh8DQ98voaerZv+onD6tG1W/TUvKYIts2Dtp7DuS5NOPKIJdB0Hvc+BbqcZxVFT+v7GbDvrIVj4tFFcJ99jPCJdoRshvEolIyIJnjZU1aP8PEVkhRftZajqKV7K1ihYmZ5D8yYRtG8RIkb/wlxY/KyZ2NiyZ6ClqRudT4Rup8OcR2DQZIhNBGBoSgIfLdvF9sxDpCQF2aRSC498vZ7/m7WZ4lKTQb1DQgxDUxJ+USi92jQlKrzyh3L/9s3p3745d5zeg+2ZBXyzZh9fr97Hk99v5PHvNtI2PppTe7fitD6tGZ6aQESYY7Y+cshE8l47HTZ8ZYa/opoZr8peZxsFE+mDaB1RTeG0B2DgJJjxR/jyDlj2ekgPoXnqySwBFKhMrStQcSwhDBjvYX8CTK+RdI2AFekhNtM/7UUozAntXow7p94P/zfSJFY789+AMf4D/LQtyyqZIOOnbVk8/v0mTuvdiguGtGdgx+a0bFq7NBKdEmO5enRnrh7dmcz8Ir5bt5+vV+/jnZ928uqC7bSKLuGmthu5MHYZ0du+N733mAToPRF6nWNeUsKjfHyEDi17whXTYfVHIT+EVqWSUdXUGu7rWlXd7qmCiNxQw302aAqLS9mwL4+pPUJk7L/4sLFjdDkZ2g0OtDS+oWVPGHyFmVA6fCokdqFrchzNosNZsv0gFw4NYJoCy1EcKSnj7o9W0q55DI9ePJDYKN+N9ifGRXHR0A5cNCCJorUzObj4HRJ2/UDk7iKywxKJHnyZsd11OgHC6snKIFL5ENop98KQ34XMEJpXLswi0kJEhovImPKlkmrrReQYNyMR6SMiyQCqOreO8jYo1u3No6QshIz+y96AgoyG04sp56S7ISwKvp0GmGRmQ1MSSNtuJ2UGE8/O2szG/fn8/dy+PlUwlByBDV+bLK7/6UbUR1fS+uASIodewScDX2BQwWPM6naX6bnUl4Jxp3wI7bp5xqHgi9vh+bGw86f6l6UWVKtkRORqYDbwFXCf8zmtkqpPAMmVrG8PPFZ7ERsu5Ub/vqFg9C8thnmPQYcR5m2uIdG0FZzwBzPevmMRAEM6tWDT/nwOFthEZsHAlox8nvhhE2f1b8PYni3rvsOyUmO8n/57eLg7vHUhbJgJfc6FyZ/AbevgrP9y5oTz6ZQYx32frQ78BN3yIbQLXjLzbV4cB5/eZOykQYw3PZk/AMOA7ao6FhgEZFRSr5+qzqq4UlW/AvrXScoGysr0bBJiI2nXPASM/iveg5ydphcTKvajmnD8TRDX2kzQVD1qvowlsKgqf/l4FVHhLv52dh3mZJWVwY6F8OUf4eGexrNw1YdmOOqy9+COjSZFRZexv/RYosLDuPfs3mzJKAiOFN3lQ2g3/QTH/x6Wv2nsiUGMN32/QlUtFBFEJEpV14lIj0rqRXjYh6eyRsvKXbn0DQWjf1kpzH0UWveDbqcGWhr/EBlrws3MvBMObGBAh65EhAlp2w8yrnerQEtXrxQWm1nn0RHBMeb/wZJ0FmzJ5B/n9au1kZ+1n8GMuyA3HcKjTSDXcntHhOeXvJN7tuLkni157LuNnDOobe1l8CXlQ2hZW2D523DyvRDuhwmmPsCbnky6iDQHPgG+EZFPgd2V1NsoIsd4l4nImcCW6hoRkZdEZL+IrKqifJKIrHCW+SIyoEJ5mIgsE5HPvTimgFNu9O8fCkNla6dD5saG24spp9fZ5nPdF0RHhNG3XTxp2xpfROYb31zKhCfmklsY+Lw6mflFPPjlWoaltOCSYbV0wjiUZYaVouPh/Ofhj5vgotfMnJZqFEw590zoTVFJKQ/NPDZ6d0AZfAUcOmCG+oKUapWMqp6nqtmqOg24B3gROLeSqrcC/xORV0TkZmd5FWOP+YMXsrwCnOGhfCtwoqr2Bx4AnqtQ/gdgrRftBAVr9+RSWqbBb49RhTkPm5nLvSYGWhr/Et8O2gyE9TMAMylzxa4cikoaXjypqigqKWXupgNs2p/Pre8sp6xMAyrP379YS0FRCf88vx8uVy1fcGY9ZOa1/OZ5E0IoqmmNd5GaFMuUUZ35YEl6cOUb6nIKNG1j5tIEKVUqGRFp5nwmlC/ASmAuEFexvqpuAPoBs4AUZ5kF9HfKPKKqs4EqXxtVdb6qll/dhRiHgnJZ2wNnAS9U106wUG70D3rPso3fwN6VZigpRFwm60TPsyD9J8jfz9CUBI6UlLFqV+MJlrl8RzZFJWWM69WS79bt53/fBi4d9ZyNGXy8bBfXn9iFri1rrhgAOLARfnoeBv8WWvWpkzw3n9yVVs2imDZ9dcCV7y+EhcPAy8xE0ZxdgZamUjz1ZN5yPpcAaZV8HoOqFqnqy6p6u7O8pKqFPpXYMAWY4fb7f8CfAI/uHyIyVUTSRCQtI6My34X6Y2V6DklxkbSJD4Lx3apQhTn/hfgORwWRbND0OBNQ2DCTIZ3KJ2UG0Zurn1mwJRMRePjCgVw0tD2Pf7+Jmav21Lsch4+U8pePV9E5KZYbxnat/Y6+/qsJ+TL2L3WWKTYqnD+f2YsV6Tm8v2RnnffnMwZdDloGy9+qvm4AqFLJqOoE5zNVVTtX/KxqOxHJE5HcCstOEflYROo861BExmKUzJ3O7wnAflVdUt22qvqcqg5V1aHJyZV5W9cfK3flBL/Rf/t82LnIeLGENRLfjVZ9Ib4jrJ9BUlwUqUmxjSqJ2cItmfRu04z4JhE8cG5fBnVszm3v/cz6vXn1Ksdj321kR9YhHjyvX+0dEDZ/b2wVY+6AON/8388Z2JahnVrw0Mz15BwOvM0KgITOkDLaDJmVBdjNuhK8mSfznTfr3HgE+CPQDjOkdQfwPPAO8FLtxPyl3f6YIbFzVDXTWX0CMFFEtjltnCwib9SlHX9z+EgpG/fnB7/Rf85/ITYZBk8OtCT1h4jpzWz+AY4cYkinFizZnoVqkAyP+JHC4lKW7shmRGcTwy0qPIxnLh9CbFQ4U19PI+dQ/TxU1+7J5fk5W7hoaHtGdkms3U5KS0w4lhYpcNx1PpNNRJg2sQ9Zh47w2LcbfbbfOjP4CsjeDtuOTcQXaDzZZKIdO0ySM+O/3DaTArT1sM8zVPVZVc1T1VxVfQ4Yr6rvArVO0CEiHYGPgMnuNh5V/bOqtlfVFOAS4HtVvby27dQHa0LB6L9rqXkTHHmj1x44DYYeZ0LJYdjyI8NSWnDwUDGbMwoCLZXfKc+5MrLzrw/2Vs2ieebyIezOPszN7yyj1M+2iNIy5a6PVtI8JoK7x/eq/Y6Wvgr718CpD/g8vljfdvFcOrwjry7YxoZ99dvDq5JeZ0NUfFA6AHjqyVyLsb/0dD7Ll0+BpzxsVyYiF4mIy1ncB/OrvENF5G1gAdBDRNJFZIqIXCci5a8h9wKJwNMislxEKrULhQIr07MBExE2aJn7iHH5HDol0JLUPymjzB92/ZcM6WSCkS/Z3vBdmRduyTS5VlKPDsA+pFMLHjinL7M3ZPCfr/zrwvvGwu38vDObe8/uTfMmtZz3UZgDPzwInUb96pbuY+44rQdxUeHc99nq4OjlRsQYu+ma6XA4uIZ3PdlkHnOCZN7hZotJVdUBqvqkh31OAiYD+4F9zvfLRSQGuMlDe5eqahtVjXB6Ji+q6jOq+oxTfrWqtlDVgc4ytJJ9/FhuSwpmVu7KJSkuilbN/BTBta7sX2cmrw2/tnZ5MUKdsAjoNg42zKRLUgwtmkQ0CrvMgi2Z9GkbT3zMsfa3S4Z35PIRHXlm1mam/1zZNLm6syfnMA/NXMfobklMHOBpsKQaZv/HzI05/UG/zetKiI3k9tO6M29TJl+t3uuXNmrM4MlQWmTSOAcR3syTeUJEjheRy0TkivLFQ/0tqnq2qiaparLzfZOqHrYBMg0rd2XTv30QG/3nPmo8cnw4lh1y9BgPBRnIriUM6dTwg2UWFpeyfEc2IzpXnUbq3gl9GJbSgj998DOrd/verftvn66mVJUHz+1X+/9G5mZY+IzJx9J2oE/lq8hlwzvSs3VTHvh8LYePBMFcqjYDoHV/WPZaoCU5Cm8M/68D/wVGYWKYDQOO6UW41e8uIt+Vz9wXkf4i8lcfyRvyHDpSwqb9+cFrj8naCivfN6HEY2tpdG0IdB0HrnBY/yVDU1qw9UABB/KLAi2V31i6/SBHSst+MfpXRmS4i6cnDaF5TCRTX1tClg+Dh85ctZev1+zjlnHd6ZhYh+Rf39xr0h+fco/PZKuK8DAX0yb2YVf2YZ6dvdnv7XnF4CvMvLbdywMtyS94E1ZmKHCCqt6gqjc7y+891H8e+DNQDKCqKzAGeQuwZncuZUrwepbNf9xMujy+ypHNxkFMcxNtev2MRhEssyp7TEWSm0bx7OQhZOQXceObSykprbvLbF5hMdOmr6Zn66ZMGVXTNFZubJ0D6z6H0bdC09Z1lssbRnROZEL/Nvzfj5tJP3ioXtr0SL8LTNqKpcHTm/FGyawCanLFmqjq4grrSmqwfYOmfKZ/v2Cc6Z+31+SMGXgZNKvDmHhDocd4yFhHvyaZRIa7GnQcs4VbsujbLp5m0dXPhxrQoTn/PK+fCVr55bo6t/3fr9azL6+Qf/2m/6/pjmtKWSl89WczcXhk/b4g3T2+FyLw4BdBENUqpoWJybbyA5NkMAjw5oomAWtE5CsRmV6+eKh/QES64HiSicgFQP1PGQ5SVqbn0LJpFK2aBeFM//lPQFmJya1icWb/Q9Smr+jfLr7B2mUOHyll2c6DR7kuV8dvhrTndyek8NK8rXy4JL3WbS/dcZDXFm7ntyNTGNihea33w/K3zDDRuGn17nLftnkMN57UlRmr9jJv04F6bbtSBk+GohzjaRYEeBPqf1oN93kjJnhlTxHZhQlsGdTzVuqTlbtygjNe2aEsSHsZ+l5gZhBboEUnEwFg/QyGpJzCS3O3UlhcGjQh8H3F0h0HKS5Vj/aYyrh7fC/W7cnjzx+vpFurOK9d8otKStl24BCb9ufz2HcbaN0smjtOryx7iJcU5cF390P74SZ8fwC4Zkxn3luyk2nTV/PlH0bXvkfmCzqNMpNQl70OAy4OnBwO1SoZVZ0lIp2Abqr6rYg0Aar8l6nqFmCciMQCLlUNktlKgaegqIRNGfmc1b9NoEU5lkXPQnGBCYRp+ZUeZ8Kchzl+oPBsqfLzzmyOq+HDONhZsDmTMJcwNKVmc6Ujwlw8edkgJj45j2tfX8L0m0aR3PRXt/yCohI2Z+SzaX8+G/ebz83789medeiXSZ2R4S6evXwIcXVJpzz3USjYD5e+E7BUFNERYdxzVm+mvr6E1xds56q62Jbqistl4pl9/3fjbZfYJXCy4IWSEZFrgKlAAtAFEy7mGeCUCvVuq2J7AFT1kTrKGvKs2ZOLahBGXi7Kg0XPQI+zoFUdMg82RHqMh9n/YWhxGtCCtO0HG5ySWbglk77t4mnqhT2mIolxxhHggmfmc81raQzu2IJNGUaZ7Mr+1SYQ7hJSkmLp0bopZ/VvQ9eWcXRtGUfnpDhiIuvQMzy4HeY/Cf0vhvZDar8fH3Bq71aM7pbEo99uYOLAtiTFBXAe3MBJ8MM/jI113N8CJwfeDZfdCAwHFgGo6kYRqSzJdnks7h4YN+fyAcGzgdl1lLNBsCLdGP29cl/+5m+wexmcci+0r9Jj3DekvQSF2SYpmeVo2gyEpm2I3fY1XZKvanAeZoeOlPBzenad3rz7tovnoQsGcPt7y1m3N5cuyXEMS2nBpS07OMqkKZ0Sm/hnCOnbaSAuOCWwD1IwL9R/O7sPZ/xvNv/9aj3/+k0As843awtdTzW2qrF/+SWddCDwpuUiVT1S3iMRkXAqCQ+jqvc55V8Dg8uHyURkGhBcU1ADxKpdObRuFl19+taf34F5/4PwGHjhFOh3oTFoxrf3vF1t2DbPGPw7nxTwN8GgxOWC7mfAyvcZ0e33fLY6k7IyrX0CrSBjyXZjj6mJ0b8yJg5oy7heLYkOD6u/c7NjIaz+CE68yyScCwK6tozj4mEd+GBJOtMm9gms/W7wZHj3K5NrpoenfJD+xZtXi1kicjcQIyKnYhTGZx7qdwTcZ2kdwSQwa/SsSM+uvhezbw18fqsx3t2+DkbfYUK8PDEEvn8QivJ9I8zWOfDKBHhlPCBGiVkqp+dZcCSf02M3klto7GoNhYVbyu0xnufHeEOTyPD6UzBlZTDzzyYr5Amepu3VP6f2bkVRSRmLtwbY5b37GSaKeoCDZnqjZO4CMjBZMa8FvlRVTxmAXgcWi8g0EfkbZpjt1TpLGuLkF5Ww5UCBZ3tMUR68d4VJD3vBS2ZC4Cn3wE0/mQfd7IeMsln2Zu3yRqjCllnw8nh4dQIc2ACn/xP+8DO0HVTrY2vwpIyGiFgGHpoP0KDimC3YnEn/9vF1M7wHgpXvwe6l5uUoMjbQ0hzFcamJRIa5mLMxsIkRCYuAAZeanDp5+wImhjdK5mZVfV5VL1TVC1T1eRGpciKFqj4I/A44CGQDv1PVf/pG3NBl9a4cVKFfVT0ZVZh+M2RtNgqmaatfy5p3NOumfGOGzD69AZ4/yQx1eYOqCdv/8pnw2kTI2gJnPmSUy8gbILIOYTwaAxHR0PVkmm7/hqTYiAYzKbOgqIQV6Tk1dl0OOEcK4Nv7zItRv+DL2BoTGcaw1BbM2RgEc2YGTTZz335+O2AieKNkflvJuis9baCqS50ozo+p6rJaSdbAKJ/pX+Vw2eLnYfXHxtCfMqryOh2GG0Vz/gtQkGmGut693CiNylA147EvngavnwfZO2D8f+H3y+G4axtfnpi60OMsJG8P57U50GAmZS7ZfpCSsprPj6mS+gp5P/dRyNsNZ/zL2MyCkDHdklm3N499uf7IPl8DkrtDhxFmyCxAKQk8JS27VEQ+A1LdZ/qLyI9AZiX1l1bXmDd1Giord+XQJj76qHkEv5CeBl/dbcZQj69mtr3LBf0vNENoY/8Km76Hp46Dr+8xeTTA3Ewbv4EXxsEbv4Hc3XDWI/D7ZTD8GvNmbqkZ3U4DcXFm+FJ2ZB1if16AHx4+YMGWTMJd8ktstjqx8Vt4pBds8pQ01wdsmwdzHob+l0DHEf5tqw6M7mbSPQdFb2bwZMjcZBwlAoCngdj5mHAwScDDbuvzgBWV1O8lIpWtL0eAIJsgUj/szDrEnI0HGFbZZLdDWfDeb6FZGzj3/7x/M4tsAif+0Zl09YDxEFv+lumhrJ9hxqvjO8KE/xmf+fBaJoCyGGITocMIeubOBcayZNtBzuwXhJNqa8DCLcYeE1tXe8z+tfD+lXAkDz66Bq6b65/YdwUH4MMp0CIVzvqv7/fvQ3q2bkpSXBRzNmZwwRA/eIXWhN7nwoy7TG+m08h6b95T0rLtThKwkcA6zDyYpkC6qlYW8LInZk5MVcsE4Hjfih/87Mk5zGUvLKS0TLllXPejC8vKzJ+yYD9c+Co0qYWHT7M2cO7TMPVHSO5hMgIeyoSJT8DNS2Do76yC8RU9x9Mkay2p4Zn8FOLG/3zHHjOySx2HygoOwFsXm5eeyR9DcSF8MAVKfRwTt6wMPr7OvJRd+IpxjgliXC5hTLck5m48QJmfU1ZXS1Qc9D3fDMcX5tZ7897kk7kQWAxcCFwELHKCXh6Fo5SqW2ofSS8E2Z9XyKTnF5FdUMxrVw2nV5sKWSbnPGxsJmf8C9oNrltjbQfClV/ATWlGuQy+wioXX9NjPACTE9aEfDrmtG1ZlNbVHlNSZGyC+fvgkrehy8lw9v9gx3z48R8+kxWABU/Apm9Mtss2AZzkWANGd08is+AIa/bU/4P9GAZfAcWHYNWH9d60N2MzfwWGqepvVfUKzOx//2cECnGyCo5w+QuL2JtbyMu/G8aAihFmt/xoeh39LoKhV/mmURFI6mZcFy2+J7ELJHXnZFnC6t25HDoSuhksFm7JIiJMGFJbe4yqmc+1YwGc89SvE3n7X2QeaOUvUL5g52LjTdb7HBh2tW/2WQ+c0DUJgNmBdmUGaDcEknsFZM6MN0rGpar73X5nerldoyXnUDGXv7CI7ZmHePG3w46d6Ja7Gz682gxvTXg0YEH9LLWgx3g65i4lpqyA5TuzAy1NrVmwJZMB7ZvTJLKW9pj5j8PyN81s+34VBjbOfAha9oGPppp7vS4cyoIPrjKu+xOfCKn/Ssum0fRq04w5G4LA+C9ilP+uJWbCdz3ijbKY6eSSuVJErgS+AL70tIGIdBKRcc73GBGpdgBVRF4Skf3laZsrKZ8kIiucZb6IDHDWR4vIYhH5WURWi8h9XhyT38grLOaKlxezaX8+z10x9Ngx79Ji86c5cggues2Ml1pChx7jcWkJJ7mWs6S+7TKHsmD9zDq7ouYVFrNqVx3mx6z70sTW63MenHjnseURMcZuUlf7jCp8eqNJpnfhKxAden5DY7onkbY9i4KiIOj19r8YXBH13pupVsmo6h+BZ4H+wADgOVWt5M4yOFGbP3C2AWgPfOKFLK8AngLsbAVOVNX+wAOYnDUARcDJqjoAGAicISIB8W08dKSEq175idW7cnhq0mBO7J58bKXv7jNDDBMfNz0ZS2jRfig0SeL82BX1O18mZ5eZ7/T2xfDTC3XaVdq2g5SWae2M/ntXml5420GevSGTu9fdPrPoGVj/JZz2QN1tlgFiTLdkikuVRVuPmfVR/8QmmsghP79t7Gn1hKd5Mt1E5FOnZ3Eh8LCq3qqqH1ezzxuBE4BcMFGbgcqiNh+Fqs4GqrSmqup8VS3/Vy/EKC/UUB5MKsJZ6t2do7C4lKtfTWPJ9oM8dskgTu3d6thKaz8zrsbDrjl2iMESGrjCoMcZjChdyortGb/kRfErWVvg5TOMgb3DcSZm186far27hVsyiQgTBnesoT0mbx+8dYnpUVz6dvWTeftfBIN/a+wzG2ton9m1xMz96nEWHHddzbYNIoZ0akF0hIvZwTBkBmbOzOGDsO6LemvSU0/mJeBz4DfAEuAJL/dZpKq/BMisKmpzHZkCzHBrI0xElgP7gW9UdZGP2/NIUUkp172xhAVbMvnvhQMqT0qWtQU+uQHaDjYeMpbQpcd4Ysry6VW8ig37/JyTL2O9iTVXlAe/nQ6XvWvmoLz/W+M+XAsWbslkUIcWNcvjUlwI71wGh7PgsnegaWvvtjvz38Y+8/FU0xvzhsIceP93po1zngwpO0xFoiPCOC41MTiM/wCdx0LL3rW+d2qDJyXT1IlZtl5V/4v3kZRrGrW5RojIWIyS+WXITlVLVXUgpnczXET6VrHtVBFJE5G0jAzfXPTi0jJufmsZP67P4B/n9eP8wRUmXuXvN29yL59l8l5c9CqEBzCZkaXudB5LWVg0p7qW+HfIbM/PJt6clsGVX5ohqpgWcPHrZi7UB1dBWWmNdplbWMzKXTmM6FyDOVnltpFdaXDes9BmgPfbRsSYe7640EykrM4+Ux7DL3eXiddXm7ljQcaY7slsySgg/eChQItieuLXz4fjptZfkx7KokVkkIgMFpHBGKXh/rsq7qRC1GaMG3SdEZH+wAvAOap6zCCnqmYDP1KFbUdVn1PVoao6NDm5EntJDSktU259dzlfr9nHfRP7cOnwjqagrMy4KL/3WxNq47v7jfvrpPdNsEtLaBPZBOlyEqeHLyPNX2PtOxbBK2dDRBP43YyjM5a2GQBnPQxbZ5kUuzUgbVsWZUrNjP6z/wurPoCT74HeE2vUHmDc6s/+n7FF/lBNLz7tRVjzqYnh12F4zdsKQsZ0M67Mc4MhxAzUe8/Qk//iHsA9ZfJet98KnFxxAxFxAStUtS/wvK+EdPbdEfgImKyqG9zWJwPFqpotIjHAOODfvmy7MsrKlD9+8DOfr9jDn8/syW+PTzFd0OVvwpJXzPBYTAsznjzkSvNHszQYpMd42m6YycGtywEfG6W3zIK3LzXDRVd8Cs07HFtn0OVm/sjcR4wzQs+zvNr1gs2ZRIa5GOzt/JjVH8MPfzeeSXXJnNr/Itg218jb6QToNu7YOntWwMy7TUbHkTfXvq0go2vLOFo3i2bOxgNcMrzxvWRWqWRUdWxNd6aqZY4rcUdV3VGTbUXkbeAkIElE0oG/YYz4qOozwL1AIvC0k6WzRFWHAm2AV0UkDNMze09VP6+p7DVBVfnrp6v4aOkubj2lG9d22gMf/APWTofSI9BxpJk/0PscG4yyodLjTPQzoX/BfPbkXEqbeB9FtF4/0+QUSuwCkz85OuVDRc58yAypfXydCSuU2KXa3S/cksXAjs29y9i4ayl8fL1xNjj78bq/AZ/5bxMM9uOpcO2co7NZFuWZ+GdNEsyQXJBGV64NIsKY7kl8tXofpWVKWAPJquot/shU1AZYLSKLgYLylarqsZ+tqpdWU341cMx0X1VdAdRbxi1V5f7P1/DFojW82GMNJ6+fBvM2QFS8mbk/5Epo2au+xLEEiriWHGo5kHF7l5C27SBnD/CBkln1oZnA2LofXP5R9faIiGhjn3l2DLw7Ga7+xmMCr5zDxazencPNJ3vRq87dbQz9sUlw8Zu+eVkqt888e6Kxz/z2c5N7vjx6wMGtZl1siOW38YLR3ZJ5Ly2dFenZDKqpV1+I4w8lE9DJkP7my+++pe/i/3F3zGIith+B9sPgnKfNxDSb/KtREd1nAgP3P8B3GzfAgDpGHV72hjF4dzgOLnsPoptVvw0YG99vXoA3LjAP6vOerbLH8dNWL+0xRw7B25eY3sWUryGu7vbLXyi3z3x0jbHPjPubmRy48n04+a+QcoLv2goiTuiahIgJ/W+VjBtixqXaq+pOb3eoqrPqLFUQc0qrw7gilxE+6AoYeqV567Q0SsJ6TYAfHiBq69eYkd5asuhZmPEnE2Dy4jdqnk646zgYe7d5aLcfZnIGVcLCLZlEhrsY1LF51fvK3mFc7fesgEvfgVZ9aiaLN7jbZ5okGueFzmNhVB1sPkFOQmwk/drFM3tDBr8/pXHZZz0qGVVVEfkEGOLtDkUkj1/nxURi7CoFqurlq1lwE917PHTfYMPBWCC5B9nR7embO5f8ohLiapOXZc7Dxvuw5wTjsltb9/bRdxh7x8w/Q5uB0GHYMVUWbMlkcFX2mLJSWPwcfPeA+X3OU9DDUwCOOnLmv50Jl3+BuFZw/nMNyg5TGWO6JfN/szaTW1hMs+jGE8TWm6u6UESOvWOrQFWbqmozZ4nGTOZ8stYSBhth4VbBWAwi5Hc6lZGu1azY7OVEw3JUTWTh7+6Hfhea2Fx1mT/lcsH5z5qJmu9dAflHzwPLOVTMmj25lQ+V7VtjQtbMvAs6HQ83LoRBk2ovizdExJgcSu2HG+UaV21QkJBndLckSsuUBZuDIMRMPeLNq9dY4DoR2YYx5Aumk+NVUgdV/URE7qq9iBZL8JIw5Fyi1r9M7Dd3wK7egBoFomWmgpa5/dZff+fugg0zTdiVCY+aSXJ1pXyi5ounwYdXweUfm5ciYPG2LFRhpLuSKSkyc2DmPmJCxZz/ggl3VF/zKJK6GmeFRsKgji2IjQxjzsYMTu/jZcSEBoA3SubMmuxQRM53++kChhKAWGIWS33QpMso9kWn0DvrO8oW/IhLxER2EJd5WIsLEOe7229XGIy6zUw69OVDvXyi5qc3mvkt46YBZn5MVLiLgeX2mO0L4LPfw4ENZg7M6f9skF5dwURkuIuRXZKCJ45ZPVGtklHV7SIyCuimqi87kx89jRed7fa9BNgGnFMnKS2WYCUsnJhb0jjh4VkkN43i0xtPIDwswLaFQZdD+k8w91HjCNDzLBZuyWRIpxZElRTAzGlmZn18R7j8Q+M4YKkXxnRP4tu1+9ieWUCnxBo6eIQo3qRf/hsmVMyfnVURwBseNnlBVX/nLNeo6oNA43KnsDQqmkVHcN/EPqzencvL87YFWhzDGf82sc4+vo7c9LWs3ZvLpfGr4KnjIO0lGHED3LDAKph6ZnQ34w4+O1hCzNQD3rxynQdMxJlYqaq7AU9JyCqL1uxtBGeLJSQ5o29rxvVqySPfbGBnVhAEQoyINknxXGHI+1fwRPjjnL3mdohpDld/C2f80zqwBICUxCa0bxHD7A1BEpW5HvBGyRxRVcWxq4hIpX08ERkpIrcDySJym9syDfCBVdNiCV5EhPvP6YtL4K+frELrmL3SJzTvCL95kbicjZzmSqPkpL/A1Fkm1pklIJgQM8ks2JxJcWlZoMWpF7xRMu+JyLNAcyfr5beYSMgVicTYasIxPZ3yJRewGbosDZ62zWO4/bQezNqQwWcr9gRaHAC0y8n8KfZB7mr9HOEn/QnCIwMtUqNnTLck8otKWL4zO9Ci1AveGP7/6+SFyQV6APeq6jF+h85M/1ki8oqqbve9qBZL8PPb41P4ZPku7v9sNWO6JdG8SWAf6t+u3c/7mSk8MLrSFEuWADCySxIugdkbMhiWEvr5cqrDG8P/v1X1G1X9o6reoarfiIinUPqHROQ/IvKliHxfvvhQZoslaAlzCf88vx8HDxXzrxnrAipLUUkpD36xhq4t47hkWCXpAiwBIT4mgoEdmjca4783w2WnVrLO09yZN4F1QComWOY2oPYJyS2WEKNP23iuHpXKOz/tZNGWwM3ufnX+NrZlHuKvZ/UiItBu1ZajGNM9mRXp2WQfOlJ95RCnyjtPRK4XkZVADxFZ4bZsBVZ42Geiqr6ISSQ2S1WvAkb4WG6LJaj5w7hudEiI4c8fr6SopGYpkn3BgfwinvhuE2N7JHNSj4YfsiXUGN0tGVWYt6nhh5jx9HrzFmZi5XTns3wZoqqXe9iu2PncIyJnicggoL2H+hZLg6NJZDh/P7cfWzIKePqHzfXe/sNfr+dwcSl/ndC7+sqWemdA+3iaRoc3ClfmKpWMquao6jZVvdQx5B/GuDHHOamQq+LvIhIP3A7cgfFEu9WXQlssocCJ3ZM5Z2Bbnv5xE5v259Vbu6t35/DOTzu5YmQKXZLtXJhgJDzMxaiuSczZmBEc7u5+xBvD/9kishHYCszC2FhmVFE3DBN+JkdVV6nqWFUdoqrTfSm0xRIq3DOhN00iw7n7o1WUlfn/YaKq3P/ZGprHRPCHRpa3JNQY3S2Z3TmFbM4oqL5yCOONNfDvGJvKBlVNBU4B5lVWUVVLMdEBLBYLkBQXxV/G92LxtizeTfM691+t+Wr1XhZtzeK203oQ36Tx5CwJRUZ3SwJo8ENm3iiZYlXNBFwi4lLVH4CBHurPF5EnRWS0iAwuX3wircUSglw4tD0jOifwjy/Xsj+v0G/tFBaX8uCXa+nRqimXWpfloKdDQhNSk2KZs9EqmWwRiQNmA2+KyGOY6MpVcTzQB7gfeNhZ/ltXQS2WUEVEePC8fhQVl3H/Z2v81s5L87ayM+sw90zoHfhI0BavGNMtiYVbsgLigVhfeHJhbuF8PQc4hDHezwQ2c3Q4/6Nw7DAVl5OrE0REXhKR/SKyqorySW5u1PNFZICzvoOI/CAia0VktYj8obq2LJb6pktyHDed3JXPV+zh+3X7fL7//bmFPPX9Jsb1asUoZxjGEvyM7pbM4eJSlmw/GGhR/Ian1531IrIa+B9wBdBZVV9V1ced4bNKEZFWIvKiiMxwfvcWkSleyPIK4Cmp+FbgRCcj5wPAc876EuB2Ve2FsR3dKCLWb9MSdFx3Yhe6tozjnk9WU1DkaTCg5vznq/UcKS3jL2f18ul+Lf5lRJdEwl3SoBOZeXJhbokJ8z8PMwT2kYjsE5FPReRPHvb5CvAV0Nb5vQG4pTpBVHU2kOWhfL6qlqv7hThzb1R1j6oudb7nAWuBdtW1Z7HUN5HhLv55fj92ZR/m0W82+Gy/K9Nz+GBpOr87IZXUpMaRCKuhEBcVzpBOLRq0XcbjwK2qblDVV1R1KmbY7O8Ye8t9HjZLUtX3gDJnHyWArwccp1CJG7WIpACDgEWVbSQiU0UkTUTSMjIa7kW1BC/DUhK47LiOvDRvK8t21H2IRFW577PVJDSJ5KaTu/pAQkt9M6Z7Mqt353IgvyjQovgFTzaZ40XkDhH5UEQWAw9i8sJcDsR72GeBiCTya/6ZEUCOrwQWkbEYJXNnhfVxwIfALaqaW9m2qvqcqg5V1aHJycm+EsliqRF3ntGTlk2jufT5hbwyb2ud5s98vmIPadsPcvtpPWgWbV2WQ5FyV+a5DTRgpqeezFzgEsyD+yRVvURV/6eqC1XVU1S32zChaLqIyDzgNeBmXwgrIv0xEQTOcbcLiUiEI+ebqvqRL9qyWPxFfEwEn950AselJjLtszVc/uIidmUfrvF+CotL+deMdfRq04yLrctyyNKnbTwtmkQwu4EOmXlSMm2BfwCDgZmOR9eTjpdX56o2cuwjJ2LsONcCfVTVU0BNr3BC2XwETFbVDW7rBXgRWKuqj9S1HYulPmjVLJpXfjeMf5zXj+U7sznj0dm8n7azRiFGnp+9hV3Zh7l3Qm/CXOJHaS3+JMwljOqWzJyNBxpkiBlPhv+9qvqRk0NmDDAOE8L/PmBjVduJSDTwe4wH2H0Yb6/o6gQRkbeBBZioz+kiMkVErhOR65wq9wKJwNMislxE0pz1JwCTgZOd9ctFZHx17VksgUZEuOy4jsz8wxh6tWnGHz9YwTWvLSEjr/qx+b05hTz942bO6NOakV0S60Faiz8Z2TmRjLwith5oeCFmqsyM6QS5HInpkRyPMahvAj6jirAyDq8BecATzu9LgdeBCz0JoqqXVlN+NXB1JevnAvY1zhKydExswttTR/DS3K385+v1nP6/2Tx4bl/O7Nemym0emrmO0jLl7vHWZbkhMDzVZMhcvDWLzg0sqKmn9MubMK7C8zG9ksWq6s3AcQ9VHeD2+wcR+bkOMlosDZ4wl3DNmM6c2COZ295bzvVvLuW8Qe2YNrEP8TFHG/SX7TjIR8t2cf1JXeiY2CRAElt8SZfkWBJjI1m8NYtLhnsKch96VKlkVLW27lfLRGSEqi4EEJHj8NzzsVgsDt1bNeXjG07gye838eQPm1iwOZOHLujPmO7m76iq3P/5GpLiorhxrHVZbiiICMNTE1i0tcqpgiGLPwIcHYcJkrlNRLZh7CwnishKEamzA4DF0tCJCHNx66nd+fiG44mLDueKlxbz109WcuhICZ8u382yHdn86fQexEV5GoiwhBrHpSawK/sw6QcPBVoUn+KPu9RTaBiLxeIl/ds35/ObR/Gfr9bz0rytzNl4gMLiUvq2a8YFQ2yy2YbG8FTjwPHTtizat2g4w6A+78k4WTRzMRM2E8sXVd3ulFksFi+Jjgjjngm9efuaEZSWKftyi7h3Qh9c1mW5wdGjdVOaRYezuIENmVXbk3Hcj6dgwsn84oqsqldVUf8B4EpMtOZyp28Fqo3EbLFYKmdE50Rm3jKGbQcK6NvOU8ANS6gS5hKGpTQ8u4w3PZnXgdbA6Zj0y+0xLspVcRHQRVVPqkmof4vF4pm4qHCrYBo4w1MT2JJR4NVcqVDBGyXTVVXvAQpU9VXgLKCfh/qrgOY+kM1isVgaFeXzZX7a1nB6M94Y/oudz2wR6QvsBVI81P8nxo15FfCLOlbVibUV0mKxWBoDfdvFExMRxuKtWYz3MBk3lPBGyTznZMm8BxP4Mg4T4qUqXgX+DazECfdvsVgsluqJCHMxpFOLBmWXqVbJqOoLztdZQJWBMd04oKqP10kqi8ViaaQMT03g0W83kHOomPgmoZ++oVqbTC3SKS8RkX+KyEgRGVy++Exii8ViacAMT01AFdK2N4zejDfDZa8ALwN/cX5vAN7FhNevjEHO5wi3ddaF2WKxWLxgYIfmRIa5WLw1i1N6tQq0OHXGGyWTpKrvicifwaRTFpEq0ymr6lifSWexWCyNjOiIMAZ0iG8wdhlvXJhrlE65FsNrFovFYnFjeGoCq3blUFBUEmhR6ow3Sqam6ZRfAb7CZNYEM7x2S+1FtFgslsbF8NRESsqUZTuyAy1KnalWyXibTllEyofeklT1PRz3ZVUtAaocXrNYLBbL0Qzp1AKXwOKtmYEWpc5UqWREZJiItIZfFMUQ4EHgYRFJqGSTxc5njYbXLBaLxXI05SGEGoJdxlNP5lngCICIjAH+hRkqywGeq6R+eVjYmg6vWSwWi6UCw1MSWLYzm6KS0B4I8qRkwlS1XI1eDDynqh86ccwqS8mXLCK3AScBHwMPATOA54FxvhPZYrFYGj7DUxM4UlLGivTQHgjyqGTc7CynAN+7lVXm+hyGCTnTFIh16oQBTZx1FovFYvGSYSnGKhHq+WU8zZN5G5glIgeAw8AcABHpSuU2lj2qen9tBRGRl4AJwH5V7VtJ+STgTudnPnC9qv7szbYWi8USarSIjaRHq6Ys2prFjSE8+7DKnoyqPgjcjnFJHqWq6rZNZTaWuqbqewXPqZu3Aieqan/gAY62C1W3rcVisYQcw1MTWLIti5LS0I017NGFWVUXqurHqlrgtm6D49ZckVPqIoiqzgaq7Beq6nxVPej8XIhJnubVthaLxRKKDE9NoOBIKat35wZalFrjzWRMr3BzEqgPpmCcCmqEiEwVkTQRScvIyPCDWBaLxeI7ypOYhbJdxmdKpr4QkbEYJXNndXUroqrPqepQVR2anJzse+EsFovFh7RqFk1KYpOQni8TUkpGRPoDLwDnqGroT4W1WCyWahiemsBP27IoK9PqKwchIaNkRKQj8BEwWVU3BFoei8ViqQ+GpyaSc7iYDfvzAi1KrQgaJSMibwMLgB4iki4iU0TkOhG5zqlyL5AIPC0iy0UkzdO29X4AFovF4geOC3G7jDf5ZOoFVb20mvKrgatrs63FYrGEKu1bxNAmPppFW7O4YmRKoMWpMUHTk7FYLBbLsYgIw1MTWLw1i1+nK4YOVslYLBZLkDM8NYGMvCK2ZR4KtCg1xioZi8ViCXKOS00EQjO/jFUyFovFEuR0SY4lMTYyJOfLWCVjsVgsQY67XSbUsErGYrFYQoDhqQmkHzzMruzDgRalRlglY7FYLCFAeRyzn0KsN2OVjMVisYQAPVs3o2l0eMjZZaySsVgslhAgzCUMS0kIOQ8zq2QsFoslRBiemsDmjAIO5BcFWhSvsUrGYrFYQoRQtMtYJWOxWCwhQt+28cREhIWUXcYqGYvFYgkRIsNdDO7UPKTmy1glY7FYLCHE8JRE1u7NJedwcaBF8QqrZCwWiyWEGJ6agCos2R4avRmrZCwWiyWEGNSxORFhEjJ2GatkLBaLJYSIjghjQPvQsctYJWOxWCwhxvDUBFam53DoSEmgRakWq2QsFoslxBiemkBJmbJsR3agRakWq2QsFoslxBjSqQUuISTsMkGjZETkJRHZLyKrqiifJCIrnGW+iAxwKztDRNaLyCYRuav+pLZYLJb6p2l0BH3axodEHLOgUTLAK8AZHsq3Aieqan/gAeA5ABEJA54CzgR6A5eKSG//imqxWCyBZXhqAst2ZFNUUhpoUTwSNEpGVWcDVfb9VHW+qh50fi4E2jvfhwObVHWLqh4B3gHO8auwFovFEmCGpyZQVFLGivScQIvikaBRMjVkCjDD+d4O2OlWlu6ss1gslgbL8JQEwl3Cy/O2oqqBFqdKQk7JiMhYjJK5s3xVJdUqPeMiMlVE0kQkLSMjw18iWiwWi99pERvJ7af14MuVe3lj0Y5Ai1MlIaVkRKQ/8AJwjqqWW7zSgQ5u1doDuyvbXlWfU9Whqjo0OTnZv8JaLBaLn7l2TGdO6pHMA5+tYdWu4Bw2CxklIyIdgY+Ayaq6wa3oJ6CbiKSKSCRwCTA9EDJaLBZLfeJyCY9cNJCE2EhuemspeYXBFzQzaJSMiLwNLAB6iEi6iEwRketE5Dqnyr1AIvC0iCwXkTQAVS0BbgK+AtYC76nq6gAcgsVisdQ7CbGRPHHZIHYePMyfP1oZdPYZCTaB6ouhQ4dqWlpaoMWwWCwWn/DUD5v4z1frefC8vkw6rpPf2hGRJao61Nv6QdOTsVgsFkvtuf7ELozpnsx9n61h9e7gsc9YJWOxWCwNAJdLePSiAbRoEsFNby0jvyg4gmdaJWOxWCwNhMS4KB6/ZBDbMwu4O0jsM1bJWCwWSwPiuM6J3HZqd6b/vJt3ftpZ/QZ+xioZi8ViaWDccFJXRndLYtr01azdkxtQWaySsVgslgaGyyU8evFA4mMiuPHNpQG1z1glY7FYLA2QpLgoHrtkENsyC/jrx4Gzz1glY7FYLA2UkV0SuXVcdz5Zvpv30gJjn7FKxmKxWBowN4ztyqiuSdz76WrW7a1/+4xVMhaLxdKACXPsM80c+0xBPdtnrJKxWCyWBk5y0ygeu2QgWw8UcM8nq+rVPmOVjMVisTQCju+SxB9O6c5Hy3bx/pL0ems3vN5aslgsFktAuenkrmzYl0dibGS9tWmVjMVisTQSwlzCU5MG12ubdrjMYrFYLH7DKhmLxWKx+A2rZCwWi8XiN6ySsVgsFovfsErGYrFYLH7DKhmLxWKx+A2rZCwWi8XiN6ySsVgsFovfkGDIAR0IRCQD2A4kAQcCLI6leux1Cg3sdQoN6nKdOqlqsreVG62SKUdE0lR1aKDlsHjGXqfQwF6n0KA+r5MdLrNYLBaL37BKxmKxWCx+wyoZeC7QAli8wl6n0MBep9Cg3q5To7fJWCwWi8V/2J6MxWKxWPyGVTIWi8Vi8Rshp2RE5CUR2S8iq9zWDRSRhSKyXETSRGR4hW06iki+iNzhtu5iEVkhIqtF5CEP7T0oIjtFJL/C+ttEZI2zj+9EpJMvjzPUqcl1EpEUETnsrF8uIs+4bTNERFaKyCYReVxEpIr2Kq3nXPsfRGSZc63G+/vYQwkfXqdK/yeVtOfxeorIBSKiImLdoN0IwHXy3XNPVUNqAcYAg4FVbuu+Bs50vo8HfqywzYfA+8Adzu9EYAeQ7Px+FTilivZGAG2A/ArrxwJNnO/XA+8G+twE01KT6wSkuNersJ/FwEhAgBnl23tbD2PgvN753hvYFuhzE0yLD69Tpf+TmlxPoCkwG1gIDA30uQmmJQDXyWfPvZDryajqbCCr4mqgmfM9HthdXiAi5wJbgNVu9TsDG1Q1w/n9LfCbKtpbqKp7Kln/g6oecn4uBNrX7EgaNjW9TpUhIm2AZqq6QM1d/Rpwbg3r1ajNxoYvrpOzn0r/J+54cT0fAB4CCr2TvvFQn9fJU73aPPfCq6sQItwCfCUi/8UMAR4PICKxwJ3AqcAdbvU3AT1FJAVIx9zokXVofwrmrczimVuo5Do5pIrIMiAX+KuqzgHaYa5POenOuop4qjcN+FpEbgZigXF1P4wGzy3U7Dp5S5XXSUQGAR1U9XP3YW2LR27BP9fJW7x67oVcT6YKrgduVdUOwK3Ai876+4BHVfWocUVVPehs8y4wB9gGlNSmYRG5HBgK/KdWkjcuqrpOe4COqjoIuA14S0SaYYZUKlKZz72nepcCr6hqe8yQwusi0lDue39R0+vkLZVeJ+d6PArcXgeZGyP+uk7VUqPnXqDHGms5PpnC0WOTOfw650eAXOd7uQLZBmRjups3VbK/qZhuehiw3Fnur1DnmDFMzFvxWqBloM9JMC7eXqdKtvvRuYHbAOvc1l8KPFvxOlVVz/m+GvOGXF62xV4v316nCuvy3b57dZ0wQz0H3P6rhZihH2uXCcB1qqqe27oaPfcCfuJ8dLLXAic5308BllSyzTQcw7/zu6Xz2cI5ud2rabOiAWwQsBnoFujzEayLt9cJSAbCnO+dgV1AgvP7J4wRstxQPL6Ktiqt53y/0vney3l4SaDPTTAtvrhObttWZ1Cu9npW9lC0S/1ep6rq1ea5F/ATV4sT/TamO1iMGdOdAowClgA/A4uAIZVsV1HJvA2scZZLPLT3kNNOmfM5zVn/LbCPX98Apgf63ATTUpPrhHG6WO2sXwqc7bafocAq58Z+sioFUVU9jEfZPGffy4HTAn1ugmnx4XWq9H/i7XWqUMcqmcBfJ58992xYGYvFYrH4DWsAtVgsFovfsErGYrFYLH7DKhmLxWKx+A2rZCwWi8XiN6ySsVgsFovfsErGYqknRKS5iNzgfG8rIh8EWiaLxd9YF2aLpZ5wYuV9rqp9Ay2LxVJfNJQAmRZLKPAvoIuILAc2Ar1Uta+IXIkJ0hoG9AUexgRsnQwUYWbFZ4lIF+ApzIzuQ8A1qrquvg/CYqkJdrjMYqk/7gI2q+pA4I8VyvoClwHDgQeBQ2oCHC4ArnDqPAfcrKpDMFHFn64PoS2WumB7MhZLcPCDquYBeSKSA3zmrF8J9BeROEwo9/fdkklG1b+YFkvNsErGYgkOity+l7n9LsP8T11AttMLslhCBjtcZrHUH3mYFMM1RlVzga0iciGAGAb4UjiLxR9YJWOx1BOqmgnME5FV1C7J3SRgioj8jImye44v5bNY/IF1YbZYLBaL37A9GYvFYrH4DatkLBaLxeI3rJKxWCwWi9+wSsZisVgsfsMqGYvFYrH4DatkLBaLxeI3rJKxWCwWi9/4f9hE/W5dpYl6AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# ok lets just plot them together again\n",
+    "ds_control_adj.isel(**roi, time=slice(0,24)).thetao.plot()\n",
+    "ds_historical_adj.isel(**roi, time=slice(0,24)).thetao.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97d82456",
+   "metadata": {},
+   "source": [
+    "BINGO"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed3baa73",
+   "metadata": {},
+   "source": [
+    "OK now lets look at all the members: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d9808da6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CMIP.CCCma.CanESM5-CanOE.historical.r2i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/CMIP/CCCma/CanESM5-CanOE/historical/r2i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429 1368750.0\n",
+      "CMIP.CCCma.CanESM5-CanOE.historical.r3i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/CMIP/CCCma/CanESM5-CanOE/historical/r3i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429 1387000.0\n",
+      "CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/CMIP/CCCma/CanESM5-CanOE/historical/r1i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429 1350500.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "for name, ds in ddict_historical.items():\n",
+    "    print(name, ds.attrs['branch_time_in_parent'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a58f002d",
+   "metadata": {},
+   "source": [
+    "Hmmm, these were all branched out at a different time! This is actually quite common, but it means to visualize these we will have to convert the time into the conventions of the parent (control) run. Thats pretty easy though!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "95422f3b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# replace the timestamp with the first of the month for the control run and plot\n",
+    "# we will also average the data yearly to remove some of the visual noise\n",
+    "\n",
+    "plt.figure(figsize=[12,4])\n",
+    "replace_time(ds_control).isel(**roi).thetao.coarsen(time=3).mean().isel(time=slice(0,150*4)).plot(color='0.5')\n",
+    "\n",
+    "# now we loop through all the historical members, adjust the time and plot them in the same way, \n",
+    "# but only for the first 20 years\n",
+    "for name, ds in ddict_historical.items():\n",
+    "    _, ds_adj = unify_time(ds_control, ds, adjust_to='parent')\n",
+    "    ds_adj.isel(**roi).thetao.coarsen(time=3).mean().isel(time=slice(0,30*4)).plot(color='C1')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ebac669",
+   "metadata": {},
+   "source": [
+    "You can see that all the 'connection points' seem to match up!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a89b53b3",
+   "metadata": {},
+   "source": [
+    "## Removing control drift\n",
+    "\n",
+    "This was a neat exercise, but you might have noticed that the control run shows a pretty pronounced trend (decreasing temperature). Since this is an unforced control run, we have to assume that the model is not completely equilibrated and continues to `drift`. This drift can affect the runs which are branched off this run. \n",
+    "\n",
+    "It is often desirable to remove the drift, or more precisely subtract the linear trend of the control run over the time period of the branched off runs. `cmip6_preprocessing` makes this easy.\n",
+    "\n",
+    "In this context the words `trend` and `drift` are used as follows:\n",
+    "- `trend` general expression for a linear trend over a timeseries\n",
+    "- `drift` particularly the control run trend\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86b35189",
+   "metadata": {},
+   "source": [
+    "### Rechunking the control run\n",
+    "\n",
+    "Since most CMIP6 datasets are chunked into pretty small time chunks, applying any operation along the time axis is very difficult to do with dask. Lets use the [rechunker](https://rechunker.readthedocs.io/en/latest/) package to write a temporary dataset that is chunked in space, not time.\n",
+    "\n",
+    "We will save this (large) dataset in the [Pangeo scratch bucket](https://pangeo.io/cloud.html#scratch-bucket)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "c0022083",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setting up the scratch bucket\n",
+    "import os\n",
+    "import fsspec\n",
+    "PANGEO_SCRATCH = os.environ['PANGEO_SCRATCH']+'cmip6_pp_demo'\n",
+    "path = f'{PANGEO_SCRATCH}/test_rechunked.zarr'\n",
+    "temp_path = f'{PANGEO_SCRATCH}/test_rechunked_temp.zarr'\n",
+    "mapper = fsspec.get_mapper(path)\n",
+    "mapper_temp = fsspec.get_mapper(temp_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "28b2fb0a",
+   "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",
+       "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;\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-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",
+       "  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",
+       "  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-attrs {\n",
+       "  padding-left: 25px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs,\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-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",
+       "  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'>&lt;xarray.Dataset&gt;\n",
+       "Dimensions:  (lev: 45, time: 6012, x: 360, y: 291)\n",
+       "Coordinates:\n",
+       "    lat      (y, x) float64 dask.array&lt;chunksize=(291, 3), meta=np.ndarray&gt;\n",
+       "  * lev      (lev) float64 3.047 9.454 16.36 ... 5.126e+03 5.375e+03 5.625e+03\n",
+       "    lon      (y, x) float64 dask.array&lt;chunksize=(291, 3), meta=np.ndarray&gt;\n",
+       "  * time     (time) object 5550-01-16 12:00:00 ... 6050-12-16 12:00:00\n",
+       "  * x        (x) int32 0 1 2 3 4 5 6 7 8 ... 351 352 353 354 355 356 357 358 359\n",
+       "  * y        (y) int32 0 1 2 3 4 5 6 7 8 ... 282 283 284 285 286 287 288 289 290\n",
+       "Data variables:\n",
+       "    thetao   (time, lev, y, x) float32 dask.array&lt;chunksize=(6012, 1, 291, 3), meta=np.ndarray&gt;\n",
+       "Attributes: (12/58)\n",
+       "    CCCma_model_hash:            932b659de600c6a0e94f619abaf9cc79eabcd337\n",
+       "    CCCma_parent_runid:          canoecpl-007\n",
+       "    CCCma_pycmor_hash:           3ecdc18eb7c1f7fbce0346850f41adf815d9fb66\n",
+       "    CCCma_runid:                 c2-pictrl\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   5550:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5-CanOE output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/8b3a90ee-6bf3-496a-ba59-648dded...\n",
+       "    variable_id:                 thetao\n",
+       "    variant_label:               r1i1p2f1\n",
+       "    version:                     v20190429\n",
+       "    version_id:                  v20190429</pre><div class='xr-wrap' hidden><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-44b9a529-0dd5-491d-bcf1-a110c7037b70' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-44b9a529-0dd5-491d-bcf1-a110c7037b70' 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'>lev</span>: 45</li><li><span class='xr-has-index'>time</span>: 6012</li><li><span class='xr-has-index'>x</span>: 360</li><li><span class='xr-has-index'>y</span>: 291</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-ce785c9c-1548-4d3d-8661-743e7039e402' class='xr-section-summary-in' type='checkbox'  checked><label for='section-ce785c9c-1548-4d3d-8661-743e7039e402' class='xr-section-summary' >Coordinates: <span>(6)</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>lat</span></div><div class='xr-var-dims'>(y, x)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(291, 3), meta=np.ndarray&gt;</div><input id='attrs-4b894700-bf6f-48fc-88ec-9e947c82e7d7' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-4b894700-bf6f-48fc-88ec-9e947c82e7d7' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-7737e58f-6952-4ab9-8f55-742742127ac5' class='xr-var-data-in' type='checkbox'><label for='data-7737e58f-6952-4ab9-8f55-742742127ac5' 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>vertices_latitude</dd><dt><span>long_name :</span></dt><dd>latitude</dd><dt><span>standard_name :</span></dt><dd>latitude</dd><dt><span>units :</span></dt><dd>degrees_north</dd></dl></div><div class='xr-var-data'><table>\n",
+       "<tr>\n",
+       "<td>\n",
+       "<table>\n",
+       "  <thead>\n",
+       "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr><th> Bytes </th><td> 818.44 kiB </td> <td> 6.82 kiB </td></tr>\n",
+       "    <tr><th> Shape </th><td> (291, 360) </td> <td> (291, 3) </td></tr>\n",
+       "    <tr><th> Count </th><td> 121 Tasks </td><td> 120 Chunks </td></tr>\n",
+       "    <tr><th> Type </th><td> float64 </td><td> numpy.ndarray </td></tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</td>\n",
+       "<td>\n",
+       "<svg width=\"170\" height=\"147\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"0\" y1=\"97\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"6\" y1=\"0\" x2=\"6\" y2=\"97\" />\n",
+       "  <line x1=\"12\" y1=\"0\" x2=\"12\" y2=\"97\" />\n",
+       "  <line x1=\"18\" y1=\"0\" x2=\"18\" y2=\"97\" />\n",
+       "  <line x1=\"25\" y1=\"0\" x2=\"25\" y2=\"97\" />\n",
+       "  <line x1=\"31\" y1=\"0\" x2=\"31\" y2=\"97\" />\n",
+       "  <line x1=\"37\" y1=\"0\" x2=\"37\" y2=\"97\" />\n",
+       "  <line x1=\"44\" y1=\"0\" x2=\"44\" y2=\"97\" />\n",
+       "  <line x1=\"50\" y1=\"0\" x2=\"50\" y2=\"97\" />\n",
+       "  <line x1=\"56\" y1=\"0\" x2=\"56\" y2=\"97\" />\n",
+       "  <line x1=\"63\" y1=\"0\" x2=\"63\" y2=\"97\" />\n",
+       "  <line x1=\"69\" y1=\"0\" x2=\"69\" y2=\"97\" />\n",
+       "  <line x1=\"75\" y1=\"0\" x2=\"75\" y2=\"97\" />\n",
+       "  <line x1=\"82\" y1=\"0\" x2=\"82\" y2=\"97\" />\n",
+       "  <line x1=\"88\" y1=\"0\" x2=\"88\" y2=\"97\" />\n",
+       "  <line x1=\"94\" y1=\"0\" x2=\"94\" y2=\"97\" />\n",
+       "  <line x1=\"101\" y1=\"0\" x2=\"101\" y2=\"97\" />\n",
+       "  <line x1=\"107\" y1=\"0\" x2=\"107\" y2=\"97\" />\n",
+       "  <line x1=\"113\" y1=\"0\" x2=\"113\" y2=\"97\" />\n",
+       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,97.0 0.0,97.0\" style=\"fill:#8B4903A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"60.000000\" y=\"117.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >360</text>\n",
+       "  <text x=\"140.000000\" y=\"48.500000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,140.000000,48.500000)\">291</text>\n",
+       "</svg>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>lev</span></div><div class='xr-var-dims'>(lev)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>3.047 9.454 ... 5.375e+03 5.625e+03</div><input id='attrs-c1cd760f-01d2-48df-9bf4-6e95539745cf' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-c1cd760f-01d2-48df-9bf4-6e95539745cf' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d3e4e86a-e6e2-46aa-afad-9c065969653f' class='xr-var-data-in' type='checkbox'><label for='data-d3e4e86a-e6e2-46aa-afad-9c065969653f' 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>axis :</span></dt><dd>Z</dd><dt><span>bounds :</span></dt><dd>lev_bnds</dd><dt><span>long_name :</span></dt><dd>ocean depth coordinate</dd><dt><span>positive :</span></dt><dd>down</dd><dt><span>standard_name :</span></dt><dd>depth</dd><dt><span>units :</span></dt><dd>m</dd></dl></div><div class='xr-var-data'><pre>array([3.046773e+00, 9.454049e+00, 1.636397e+01, 2.389871e+01, 3.220929e+01,\n",
+       "       4.148185e+01, 5.194513e+01, 6.387905e+01, 7.762451e+01, 9.359412e+01,\n",
+       "       1.122835e+02, 1.342823e+02, 1.602840e+02, 1.910925e+02, 2.276233e+02,\n",
+       "       2.708962e+02, 3.220169e+02, 3.821444e+02, 4.524429e+02, 5.340197e+02,\n",
+       "       6.278525e+02, 7.347150e+02, 8.551112e+02, 9.892289e+02, 1.136922e+03,\n",
+       "       1.297724e+03, 1.470893e+03, 1.655472e+03, 1.850365e+03, 2.054414e+03,\n",
+       "       2.266454e+03, 2.485371e+03, 2.710133e+03, 2.939812e+03, 3.173588e+03,\n",
+       "       3.410756e+03, 3.650712e+03, 3.892950e+03, 4.137047e+03, 4.382654e+03,\n",
+       "       4.629485e+03, 4.877303e+03, 5.125919e+03, 5.375177e+03, 5.624952e+03])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lon</span></div><div class='xr-var-dims'>(y, x)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(291, 3), meta=np.ndarray&gt;</div><input id='attrs-66ed9d38-ad26-4054-95f0-eeea49ebd237' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-66ed9d38-ad26-4054-95f0-eeea49ebd237' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-7547a7d5-eb84-4f10-a86c-a818af63bf57' class='xr-var-data-in' type='checkbox'><label for='data-7547a7d5-eb84-4f10-a86c-a818af63bf57' 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>vertices_longitude</dd><dt><span>long_name :</span></dt><dd>longitude</dd><dt><span>standard_name :</span></dt><dd>longitude</dd><dt><span>units :</span></dt><dd>degrees_east</dd></dl></div><div class='xr-var-data'><table>\n",
+       "<tr>\n",
+       "<td>\n",
+       "<table>\n",
+       "  <thead>\n",
+       "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr><th> Bytes </th><td> 818.44 kiB </td> <td> 6.82 kiB </td></tr>\n",
+       "    <tr><th> Shape </th><td> (291, 360) </td> <td> (291, 3) </td></tr>\n",
+       "    <tr><th> Count </th><td> 121 Tasks </td><td> 120 Chunks </td></tr>\n",
+       "    <tr><th> Type </th><td> float64 </td><td> numpy.ndarray </td></tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</td>\n",
+       "<td>\n",
+       "<svg width=\"170\" height=\"147\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"0\" y1=\"97\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"6\" y1=\"0\" x2=\"6\" y2=\"97\" />\n",
+       "  <line x1=\"12\" y1=\"0\" x2=\"12\" y2=\"97\" />\n",
+       "  <line x1=\"18\" y1=\"0\" x2=\"18\" y2=\"97\" />\n",
+       "  <line x1=\"25\" y1=\"0\" x2=\"25\" y2=\"97\" />\n",
+       "  <line x1=\"31\" y1=\"0\" x2=\"31\" y2=\"97\" />\n",
+       "  <line x1=\"37\" y1=\"0\" x2=\"37\" y2=\"97\" />\n",
+       "  <line x1=\"44\" y1=\"0\" x2=\"44\" y2=\"97\" />\n",
+       "  <line x1=\"50\" y1=\"0\" x2=\"50\" y2=\"97\" />\n",
+       "  <line x1=\"56\" y1=\"0\" x2=\"56\" y2=\"97\" />\n",
+       "  <line x1=\"63\" y1=\"0\" x2=\"63\" y2=\"97\" />\n",
+       "  <line x1=\"69\" y1=\"0\" x2=\"69\" y2=\"97\" />\n",
+       "  <line x1=\"75\" y1=\"0\" x2=\"75\" y2=\"97\" />\n",
+       "  <line x1=\"82\" y1=\"0\" x2=\"82\" y2=\"97\" />\n",
+       "  <line x1=\"88\" y1=\"0\" x2=\"88\" y2=\"97\" />\n",
+       "  <line x1=\"94\" y1=\"0\" x2=\"94\" y2=\"97\" />\n",
+       "  <line x1=\"101\" y1=\"0\" x2=\"101\" y2=\"97\" />\n",
+       "  <line x1=\"107\" y1=\"0\" x2=\"107\" y2=\"97\" />\n",
+       "  <line x1=\"113\" y1=\"0\" x2=\"113\" y2=\"97\" />\n",
+       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,97.0 0.0,97.0\" style=\"fill:#8B4903A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"60.000000\" y=\"117.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >360</text>\n",
+       "  <text x=\"140.000000\" y=\"48.500000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,140.000000,48.500000)\">291</text>\n",
+       "</svg>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table></div></li><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'>5550-01-16 12:00:00 ... 6050-12-...</div><input id='attrs-3761e572-9e78-46ca-acc8-2918bc44c993' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-3761e572-9e78-46ca-acc8-2918bc44c993' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-cde1e2f7-5433-4eca-98a5-91115d570e7e' class='xr-var-data-in' type='checkbox'><label for='data-cde1e2f7-5433-4eca-98a5-91115d570e7e' 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>axis :</span></dt><dd>T</dd><dt><span>bounds :</span></dt><dd>time_bnds</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(5550, 1, 16, 12, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(5550, 2, 15, 0, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(5550, 3, 16, 12, 0, 0, 0), ...,\n",
+       "       cftime.DatetimeNoLeap(6050, 10, 16, 12, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(6050, 11, 16, 0, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(6050, 12, 16, 12, 0, 0, 0)], dtype=object)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>x</span></div><div class='xr-var-dims'>(x)</div><div class='xr-var-dtype'>int32</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 5 ... 355 356 357 358 359</div><input id='attrs-973f1c04-463e-436b-8997-dcbea8ca38df' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-973f1c04-463e-436b-8997-dcbea8ca38df' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-96d9ad2a-334d-40e0-a084-87313a7f8565' class='xr-var-data-in' type='checkbox'><label for='data-96d9ad2a-334d-40e0-a084-87313a7f8565' 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>cell index along first dimension</dd><dt><span>units :</span></dt><dd>1</dd></dl></div><div class='xr-var-data'><pre>array([  0,   1,   2, ..., 357, 358, 359], dtype=int32)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>y</span></div><div class='xr-var-dims'>(y)</div><div class='xr-var-dtype'>int32</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 5 ... 286 287 288 289 290</div><input id='attrs-8138a1a2-12cd-47f8-911e-bfc33454d79e' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-8138a1a2-12cd-47f8-911e-bfc33454d79e' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-0df12b5c-a4d3-4b53-8a2e-e575cf5afc5e' class='xr-var-data-in' type='checkbox'><label for='data-0df12b5c-a4d3-4b53-8a2e-e575cf5afc5e' 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>cell index along second dimension</dd><dt><span>units :</span></dt><dd>1</dd></dl></div><div class='xr-var-data'><pre>array([  0,   1,   2, ..., 288, 289, 290], dtype=int32)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-93552008-6003-4e21-b1a4-3ca86e3c6c37' class='xr-section-summary-in' type='checkbox'  checked><label for='section-93552008-6003-4e21-b1a4-3ca86e3c6c37' class='xr-section-summary' >Data variables: <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>thetao</span></div><div class='xr-var-dims'>(time, lev, y, x)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(6012, 1, 291, 3), meta=np.ndarray&gt;</div><input id='attrs-984c027a-89b6-40fc-a976-0a08c13b345d' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-984c027a-89b6-40fc-a976-0a08c13b345d' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-b194d51e-cddb-460e-9f0f-536ba877e575' class='xr-var-data-in' type='checkbox'><label for='data-b194d51e-cddb-460e-9f0f-536ba877e575' 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>cell_measures :</span></dt><dd>area: areacello volume: volcello</dd><dt><span>cell_methods :</span></dt><dd>area: mean where sea time: mean</dd><dt><span>comment :</span></dt><dd>Diagnostic should be contributed even for models using conservative temperature as prognostic field.</dd><dt><span>coordinates :</span></dt><dd>latitude longitude</dd><dt><span>long_name :</span></dt><dd>Sea Water Potential Temperature</dd><dt><span>original_name :</span></dt><dd>votemper</dd><dt><span>standard_name :</span></dt><dd>sea_water_potential_temperature</dd><dt><span>units :</span></dt><dd>degC</dd></dl></div><div class='xr-var-data'><table>\n",
+       "<tr>\n",
+       "<td>\n",
+       "<table>\n",
+       "  <thead>\n",
+       "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr><th> Bytes </th><td> 105.58 GiB </td> <td> 20.02 MiB </td></tr>\n",
+       "    <tr><th> Shape </th><td> (6012, 45, 291, 360) </td> <td> (6012, 1, 291, 3) </td></tr>\n",
+       "    <tr><th> Count </th><td> 5401 Tasks </td><td> 5400 Chunks </td></tr>\n",
+       "    <tr><th> Type </th><td> float32 </td><td> numpy.ndarray </td></tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</td>\n",
+       "<td>\n",
+       "<svg width=\"480\" height=\"99\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"0\" y1=\"25\" x2=\"120\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,25.412616514582485 0.0,25.412616514582485\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"60.000000\" y=\"45.412617\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >6012</text>\n",
+       "  <text x=\"140.000000\" y=\"12.706308\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,12.706308)\">1</text>\n",
+       "\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"204\" y2=\"14\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"190\" y1=\"34\" x2=\"204\" y2=\"49\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"190\" y2=\"34\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"190\" y2=\"34\" />\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"190\" y2=\"34\" />\n",
+       "  <line x1=\"191\" y1=\"1\" x2=\"191\" y2=\"35\" />\n",
+       "  <line x1=\"191\" y1=\"1\" x2=\"191\" y2=\"35\" />\n",
+       "  <line x1=\"192\" y1=\"2\" x2=\"192\" y2=\"36\" />\n",
+       "  <line x1=\"192\" y1=\"2\" x2=\"192\" y2=\"36\" />\n",
+       "  <line x1=\"192\" y1=\"2\" x2=\"192\" y2=\"37\" />\n",
+       "  <line x1=\"193\" y1=\"3\" x2=\"193\" y2=\"37\" />\n",
+       "  <line x1=\"193\" y1=\"3\" x2=\"193\" y2=\"38\" />\n",
+       "  <line x1=\"194\" y1=\"4\" x2=\"194\" y2=\"38\" />\n",
+       "  <line x1=\"194\" y1=\"4\" x2=\"194\" y2=\"39\" />\n",
+       "  <line x1=\"195\" y1=\"5\" x2=\"195\" y2=\"39\" />\n",
+       "  <line x1=\"195\" y1=\"5\" x2=\"195\" y2=\"40\" />\n",
+       "  <line x1=\"196\" y1=\"6\" x2=\"196\" y2=\"40\" />\n",
+       "  <line x1=\"196\" y1=\"6\" x2=\"196\" y2=\"41\" />\n",
+       "  <line x1=\"197\" y1=\"7\" x2=\"197\" y2=\"41\" />\n",
+       "  <line x1=\"197\" y1=\"7\" x2=\"197\" y2=\"41\" />\n",
+       "  <line x1=\"198\" y1=\"8\" x2=\"198\" y2=\"42\" />\n",
+       "  <line x1=\"198\" y1=\"8\" x2=\"198\" y2=\"42\" />\n",
+       "  <line x1=\"199\" y1=\"9\" x2=\"199\" y2=\"43\" />\n",
+       "  <line x1=\"199\" y1=\"9\" x2=\"199\" y2=\"43\" />\n",
+       "  <line x1=\"199\" y1=\"9\" x2=\"199\" y2=\"44\" />\n",
+       "  <line x1=\"200\" y1=\"10\" x2=\"200\" y2=\"44\" />\n",
+       "  <line x1=\"200\" y1=\"10\" x2=\"200\" y2=\"45\" />\n",
+       "  <line x1=\"201\" y1=\"11\" x2=\"201\" y2=\"45\" />\n",
+       "  <line x1=\"201\" y1=\"11\" x2=\"201\" y2=\"46\" />\n",
+       "  <line x1=\"202\" y1=\"12\" x2=\"202\" y2=\"46\" />\n",
+       "  <line x1=\"202\" y1=\"12\" x2=\"202\" y2=\"47\" />\n",
+       "  <line x1=\"203\" y1=\"13\" x2=\"203\" y2=\"47\" />\n",
+       "  <line x1=\"203\" y1=\"13\" x2=\"203\" y2=\"48\" />\n",
+       "  <line x1=\"204\" y1=\"14\" x2=\"204\" y2=\"48\" />\n",
+       "  <line x1=\"204\" y1=\"14\" x2=\"204\" y2=\"49\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"190.0,0.0 204.9485979497544,14.948597949754406 204.9485979497544,49.25079830746743 190.0,34.30220035771302\" style=\"fill:#8B4903A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"225\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"225\" y2=\"0\" />\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"226\" y2=\"0\" />\n",
+       "  <line x1=\"191\" y1=\"1\" x2=\"226\" y2=\"1\" />\n",
+       "  <line x1=\"191\" y1=\"1\" x2=\"227\" y2=\"1\" />\n",
+       "  <line x1=\"192\" y1=\"2\" x2=\"227\" y2=\"2\" />\n",
+       "  <line x1=\"192\" y1=\"2\" x2=\"228\" y2=\"2\" />\n",
+       "  <line x1=\"192\" y1=\"2\" x2=\"228\" y2=\"2\" />\n",
+       "  <line x1=\"193\" y1=\"3\" x2=\"229\" y2=\"3\" />\n",
+       "  <line x1=\"193\" y1=\"3\" x2=\"229\" y2=\"3\" />\n",
+       "  <line x1=\"194\" y1=\"4\" x2=\"230\" y2=\"4\" />\n",
+       "  <line x1=\"194\" y1=\"4\" x2=\"230\" y2=\"4\" />\n",
+       "  <line x1=\"195\" y1=\"5\" x2=\"230\" y2=\"5\" />\n",
+       "  <line x1=\"195\" y1=\"5\" x2=\"231\" y2=\"5\" />\n",
+       "  <line x1=\"196\" y1=\"6\" x2=\"231\" y2=\"6\" />\n",
+       "  <line x1=\"196\" y1=\"6\" x2=\"232\" y2=\"6\" />\n",
+       "  <line x1=\"197\" y1=\"7\" x2=\"232\" y2=\"7\" />\n",
+       "  <line x1=\"197\" y1=\"7\" x2=\"233\" y2=\"7\" />\n",
+       "  <line x1=\"198\" y1=\"8\" x2=\"233\" y2=\"8\" />\n",
+       "  <line x1=\"198\" y1=\"8\" x2=\"234\" y2=\"8\" />\n",
+       "  <line x1=\"199\" y1=\"9\" x2=\"234\" y2=\"9\" />\n",
+       "  <line x1=\"199\" y1=\"9\" x2=\"235\" y2=\"9\" />\n",
+       "  <line x1=\"199\" y1=\"9\" x2=\"235\" y2=\"9\" />\n",
+       "  <line x1=\"200\" y1=\"10\" x2=\"236\" y2=\"10\" />\n",
+       "  <line x1=\"200\" y1=\"10\" x2=\"236\" y2=\"10\" />\n",
+       "  <line x1=\"201\" y1=\"11\" x2=\"237\" y2=\"11\" />\n",
+       "  <line x1=\"201\" y1=\"11\" x2=\"237\" y2=\"11\" />\n",
+       "  <line x1=\"202\" y1=\"12\" x2=\"237\" y2=\"12\" />\n",
+       "  <line x1=\"202\" y1=\"12\" x2=\"238\" y2=\"12\" />\n",
+       "  <line x1=\"203\" y1=\"13\" x2=\"238\" y2=\"13\" />\n",
+       "  <line x1=\"203\" y1=\"13\" x2=\"239\" y2=\"13\" />\n",
+       "  <line x1=\"204\" y1=\"14\" x2=\"239\" y2=\"14\" />\n",
+       "  <line x1=\"204\" y1=\"14\" x2=\"240\" y2=\"14\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"204\" y2=\"14\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"205\" y2=\"14\" />\n",
+       "  <line x1=\"192\" y1=\"0\" x2=\"207\" y2=\"14\" />\n",
+       "  <line x1=\"193\" y1=\"0\" x2=\"208\" y2=\"14\" />\n",
+       "  <line x1=\"194\" y1=\"0\" x2=\"209\" y2=\"14\" />\n",
+       "  <line x1=\"195\" y1=\"0\" x2=\"210\" y2=\"14\" />\n",
+       "  <line x1=\"196\" y1=\"0\" x2=\"211\" y2=\"14\" />\n",
+       "  <line x1=\"197\" y1=\"0\" x2=\"212\" y2=\"14\" />\n",
+       "  <line x1=\"198\" y1=\"0\" x2=\"213\" y2=\"14\" />\n",
+       "  <line x1=\"199\" y1=\"0\" x2=\"214\" y2=\"14\" />\n",
+       "  <line x1=\"200\" y1=\"0\" x2=\"215\" y2=\"14\" />\n",
+       "  <line x1=\"202\" y1=\"0\" x2=\"217\" y2=\"14\" />\n",
+       "  <line x1=\"203\" y1=\"0\" x2=\"218\" y2=\"14\" />\n",
+       "  <line x1=\"204\" y1=\"0\" x2=\"219\" y2=\"14\" />\n",
+       "  <line x1=\"205\" y1=\"0\" x2=\"220\" y2=\"14\" />\n",
+       "  <line x1=\"206\" y1=\"0\" x2=\"221\" y2=\"14\" />\n",
+       "  <line x1=\"207\" y1=\"0\" x2=\"222\" y2=\"14\" />\n",
+       "  <line x1=\"208\" y1=\"0\" x2=\"223\" y2=\"14\" />\n",
+       "  <line x1=\"209\" y1=\"0\" x2=\"224\" y2=\"14\" />\n",
+       "  <line x1=\"211\" y1=\"0\" x2=\"226\" y2=\"14\" />\n",
+       "  <line x1=\"212\" y1=\"0\" x2=\"227\" y2=\"14\" />\n",
+       "  <line x1=\"213\" y1=\"0\" x2=\"228\" y2=\"14\" />\n",
+       "  <line x1=\"214\" y1=\"0\" x2=\"229\" y2=\"14\" />\n",
+       "  <line x1=\"215\" y1=\"0\" x2=\"230\" y2=\"14\" />\n",
+       "  <line x1=\"216\" y1=\"0\" x2=\"231\" y2=\"14\" />\n",
+       "  <line x1=\"217\" y1=\"0\" x2=\"232\" y2=\"14\" />\n",
+       "  <line x1=\"218\" y1=\"0\" x2=\"233\" y2=\"14\" />\n",
+       "  <line x1=\"219\" y1=\"0\" x2=\"234\" y2=\"14\" />\n",
+       "  <line x1=\"221\" y1=\"0\" x2=\"236\" y2=\"14\" />\n",
+       "  <line x1=\"222\" y1=\"0\" x2=\"236\" y2=\"14\" />\n",
+       "  <line x1=\"223\" y1=\"0\" x2=\"238\" y2=\"14\" />\n",
+       "  <line x1=\"224\" y1=\"0\" x2=\"239\" y2=\"14\" />\n",
+       "  <line x1=\"225\" y1=\"0\" x2=\"240\" y2=\"14\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"190.0,0.0 225.60051057044302,0.0 240.54910852019742,14.948597949754406 204.9485979497544,14.948597949754406\" style=\"fill:#8B4903A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"204\" y1=\"14\" x2=\"240\" y2=\"14\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"204\" y1=\"49\" x2=\"240\" y2=\"49\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"204\" y1=\"14\" x2=\"204\" y2=\"49\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"205\" y1=\"14\" x2=\"205\" y2=\"49\" />\n",
+       "  <line x1=\"207\" y1=\"14\" x2=\"207\" y2=\"49\" />\n",
+       "  <line x1=\"208\" y1=\"14\" x2=\"208\" y2=\"49\" />\n",
+       "  <line x1=\"209\" y1=\"14\" x2=\"209\" y2=\"49\" />\n",
+       "  <line x1=\"210\" y1=\"14\" x2=\"210\" y2=\"49\" />\n",
+       "  <line x1=\"211\" y1=\"14\" x2=\"211\" y2=\"49\" />\n",
+       "  <line x1=\"212\" y1=\"14\" x2=\"212\" y2=\"49\" />\n",
+       "  <line x1=\"213\" y1=\"14\" x2=\"213\" y2=\"49\" />\n",
+       "  <line x1=\"214\" y1=\"14\" x2=\"214\" y2=\"49\" />\n",
+       "  <line x1=\"215\" y1=\"14\" x2=\"215\" y2=\"49\" />\n",
+       "  <line x1=\"217\" y1=\"14\" x2=\"217\" y2=\"49\" />\n",
+       "  <line x1=\"218\" y1=\"14\" x2=\"218\" y2=\"49\" />\n",
+       "  <line x1=\"219\" y1=\"14\" x2=\"219\" y2=\"49\" />\n",
+       "  <line x1=\"220\" y1=\"14\" x2=\"220\" y2=\"49\" />\n",
+       "  <line x1=\"221\" y1=\"14\" x2=\"221\" y2=\"49\" />\n",
+       "  <line x1=\"222\" y1=\"14\" x2=\"222\" y2=\"49\" />\n",
+       "  <line x1=\"223\" y1=\"14\" x2=\"223\" y2=\"49\" />\n",
+       "  <line x1=\"224\" y1=\"14\" x2=\"224\" y2=\"49\" />\n",
+       "  <line x1=\"226\" y1=\"14\" x2=\"226\" y2=\"49\" />\n",
+       "  <line x1=\"227\" y1=\"14\" x2=\"227\" y2=\"49\" />\n",
+       "  <line x1=\"228\" y1=\"14\" x2=\"228\" y2=\"49\" />\n",
+       "  <line x1=\"229\" y1=\"14\" x2=\"229\" y2=\"49\" />\n",
+       "  <line x1=\"230\" y1=\"14\" x2=\"230\" y2=\"49\" />\n",
+       "  <line x1=\"231\" y1=\"14\" x2=\"231\" y2=\"49\" />\n",
+       "  <line x1=\"232\" y1=\"14\" x2=\"232\" y2=\"49\" />\n",
+       "  <line x1=\"233\" y1=\"14\" x2=\"233\" y2=\"49\" />\n",
+       "  <line x1=\"234\" y1=\"14\" x2=\"234\" y2=\"49\" />\n",
+       "  <line x1=\"236\" y1=\"14\" x2=\"236\" y2=\"49\" />\n",
+       "  <line x1=\"236\" y1=\"14\" x2=\"236\" y2=\"49\" />\n",
+       "  <line x1=\"238\" y1=\"14\" x2=\"238\" y2=\"49\" />\n",
+       "  <line x1=\"239\" y1=\"14\" x2=\"239\" y2=\"49\" />\n",
+       "  <line x1=\"240\" y1=\"14\" x2=\"240\" y2=\"49\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"204.9485979497544,14.948597949754406 240.54910852019742,14.948597949754406 240.54910852019742,49.25079830746743 204.9485979497544,49.25079830746743\" style=\"fill:#8B4903A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"222.748853\" y=\"69.250798\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >360</text>\n",
+       "  <text x=\"260.549109\" y=\"32.099698\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,260.549109,32.099698)\">291</text>\n",
+       "  <text x=\"187.474299\" y=\"61.776499\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(45,187.474299,61.776499)\">45</text>\n",
+       "</svg>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table></div></li></ul></div></li><li class='xr-section-item'><input id='section-02fabbfd-d4a3-4788-ac70-185cefec9ab5' class='xr-section-summary-in' type='checkbox'  ><label for='section-02fabbfd-d4a3-4788-ac70-185cefec9ab5' class='xr-section-summary' >Attributes: <span>(58)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>CCCma_model_hash :</span></dt><dd>932b659de600c6a0e94f619abaf9cc79eabcd337</dd><dt><span>CCCma_parent_runid :</span></dt><dd>canoecpl-007</dd><dt><span>CCCma_pycmor_hash :</span></dt><dd>3ecdc18eb7c1f7fbce0346850f41adf815d9fb66</dd><dt><span>CCCma_runid :</span></dt><dd>c2-pictrl</dd><dt><span>Conventions :</span></dt><dd>CF-1.7 CMIP-6.2</dd><dt><span>YMDH_branch_time_in_child :</span></dt><dd>5550:01:01:00</dd><dt><span>YMDH_branch_time_in_parent :</span></dt><dd>5550:01:01:00</dd><dt><span>activity_id :</span></dt><dd>CMIP</dd><dt><span>branch_method :</span></dt><dd>Spin-up documentation</dd><dt><span>branch_time_in_child :</span></dt><dd>1350500.0</dd><dt><span>branch_time_in_parent :</span></dt><dd>1350500.0</dd><dt><span>cmor_version :</span></dt><dd>3.5.0</dd><dt><span>contact :</span></dt><dd>ec.cccma.info-info.ccmac.ec@canada.ca</dd><dt><span>creation_date :</span></dt><dd>2019-12-11T20:58:53Z</dd><dt><span>data_specs_version :</span></dt><dd>01.00.31</dd><dt><span>experiment :</span></dt><dd>pre-industrial control</dd><dt><span>experiment_id :</span></dt><dd>piControl</dd><dt><span>external_variables :</span></dt><dd>areacello volcello</dd><dt><span>forcing_index :</span></dt><dd>1</dd><dt><span>frequency :</span></dt><dd>mon</dd><dt><span>further_info_url :</span></dt><dd>https://furtherinfo.es-doc.org/CMIP6.CCCma.CanESM5-CanOE.piControl.none.r1i1p2f1</dd><dt><span>grid :</span></dt><dd>ORCA1 tripolar grid, 1 deg with refinement to 1/3 deg within 20 degrees of the equator; 361 x 290 longitude/latitude; 45 vertical levels; top grid cell 0-6.19 m</dd><dt><span>grid_label :</span></dt><dd>gn</dd><dt><span>history :</span></dt><dd>2019-12-11T20:58:53Z ;rewrote data to be consistent with CMIP for variable thetao found in table Omon.</dd><dt><span>initialization_index :</span></dt><dd>1</dd><dt><span>institution :</span></dt><dd>Canadian Centre for Climate Modelling and Analysis, Environment and Climate Change Canada, Victoria, BC V8P 5C2, Canada</dd><dt><span>institution_id :</span></dt><dd>CCCma</dd><dt><span>intake_esm_dataset_key :</span></dt><dd>CMIP.CCCma.CanESM5-CanOE.piControl.r1i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/CMIP/CCCma/CanESM5-CanOE/piControl/r1i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429</dd><dt><span>intake_esm_varname :</span></dt><dd>None</dd><dt><span>license :</span></dt><dd>CMIP6 model data produced by The Government of Canada (Canadian Centre for Climate Modelling and Analysis, Environment and Climate Change Canada) is licensed under a Creative Commons Attribution ShareAlike 4.0 International License (https://creativecommons.org/licenses). Consult https://pcmdi.llnl.gov/CMIP6/TermsOfUse for terms of use governing CMIP6 output, including citation requirements and proper acknowledgment. Further information about this data, including some limitations, can be found via the further_info_url (recorded as a global attribute in this file) and at https:///pcmdi.llnl.gov/. The data producers and data providers make no warranty, either express or implied, including, but not limited to, warranties of merchantability and fitness for a particular purpose. All liabilities arising from the supply of the information (including any liability arising in negligence) are excluded to the fullest extent permitted by law.</dd><dt><span>mip_era :</span></dt><dd>CMIP6</dd><dt><span>netcdf_tracking_ids :</span></dt><dd>hdl:21.14100/8b3a90ee-6bf3-496a-ba59-648ddedb007c\n",
+       "hdl:21.14100/d73e30c1-ade5-4187-9276-a765675ba594\n",
+       "hdl:21.14100/e8ec6a5c-1b1e-4f38-bb6c-3cf749331a72\n",
+       "hdl:21.14100/f40c6071-ebbe-4c39-9552-fb9d44cf18c2\n",
+       "hdl:21.14100/8e9cdeca-d27d-4f5d-9294-ae2017eda51e\n",
+       "hdl:21.14100/6bfc80cc-b651-4749-add2-47230f00b4f7\n",
+       "hdl:21.14100/3838dd2c-9838-4cee-8057-420a285c16b7\n",
+       "hdl:21.14100/6a8df388-8eaf-42db-9a8c-fb785f00553a\n",
+       "hdl:21.14100/94d17f37-bc9c-4a71-b311-701afe5002db\n",
+       "hdl:21.14100/ce804047-111e-4140-b7e4-aaabe712baeb\n",
+       "hdl:21.14100/c46a5aff-afca-40e3-a41f-2b4837f8da7a\n",
+       "hdl:21.14100/f3c29ca2-63f3-4c66-970e-202a98287e76\n",
+       "hdl:21.14100/44a989f3-55e7-40ac-bcd6-a322ad98a8a4\n",
+       "hdl:21.14100/2fa7efbf-b263-47fa-b085-15024d22a9b2\n",
+       "hdl:21.14100/9189ae2c-157c-4b2e-a143-f00196de2b15\n",
+       "hdl:21.14100/881d762f-8479-4a2e-9b24-7d6724411d7a\n",
+       "hdl:21.14100/7d5a15c7-bd57-4d60-9377-6cb8ce5544d8\n",
+       "hdl:21.14100/c8b6c648-a238-4520-b8d0-984c18584737\n",
+       "hdl:21.14100/5fa556fb-d772-4d65-99fd-7ee524df4669\n",
+       "hdl:21.14100/5f5a48d9-8d6f-44f8-8854-7f7d168fa95b\n",
+       "hdl:21.14100/0e13a49d-446a-426e-af98-5d068921ac80\n",
+       "hdl:21.14100/50ac7e17-f501-409e-bb78-a3a844203c3d\n",
+       "hdl:21.14100/d9e74964-17d1-46b4-ae37-c85da9673408\n",
+       "hdl:21.14100/46e16c1b-edcc-4353-ae2a-a0a661cb68e5\n",
+       "hdl:21.14100/9ce4dc44-eaca-4b98-a999-347d28808a5b\n",
+       "hdl:21.14100/a38c0f47-4f5d-4541-8acf-882f7fef6c4e\n",
+       "hdl:21.14100/8198bd12-1e6a-4d8c-a0a6-03e085943d4d\n",
+       "hdl:21.14100/6f5b0e9a-b79d-4321-9a86-1d68c58559ae\n",
+       "hdl:21.14100/24e2daea-7556-46c8-9e08-c1109e212910\n",
+       "hdl:21.14100/ce7aafab-46b3-4ec2-9abb-4b107179a021\n",
+       "hdl:21.14100/40b76661-3806-40bf-9381-20a1918c2acd\n",
+       "hdl:21.14100/99cb0d3d-bc7d-4469-b232-c3529a9f45cc\n",
+       "hdl:21.14100/6c6f53e7-b15f-4382-b1e5-07354bae1aa9\n",
+       "hdl:21.14100/7c2657e6-ccf3-48ae-9f4b-a46a85b4ce9c\n",
+       "hdl:21.14100/f1b55d85-0633-44e9-b1cf-8f55241ddf44\n",
+       "hdl:21.14100/0c6fda9b-3959-49c4-af27-65340573c503\n",
+       "hdl:21.14100/8c5acf30-cc61-44ee-a496-c2f8e8258270\n",
+       "hdl:21.14100/f4b44462-d3d7-4932-90c4-34d9a8f726de\n",
+       "hdl:21.14100/d5425f68-8ad5-4fec-8309-3a79eb3195e5\n",
+       "hdl:21.14100/e0cb2937-21ce-4277-8927-361db0d7f96c\n",
+       "hdl:21.14100/682a5332-b6ef-4044-ae4f-e692cb30b61f\n",
+       "hdl:21.14100/2744f541-25e1-485f-8e7a-a54dbb9b35f6\n",
+       "hdl:21.14100/b3a492e0-ea86-49fb-98b3-5c20c5c09d5e\n",
+       "hdl:21.14100/6897611a-8205-4a6a-9e2b-d15153a3b238\n",
+       "hdl:21.14100/b92451d5-66e7-4477-9bbe-5b0938ff537c\n",
+       "hdl:21.14100/14c3e40f-46c0-4236-b632-c50b741c9865\n",
+       "hdl:21.14100/712e0694-fd3e-47de-95ec-f8758f4f427e\n",
+       "hdl:21.14100/09026096-df9c-44b5-a3be-38d7859ae189\n",
+       "hdl:21.14100/05345fcc-3261-47e4-81b4-24caeb0674bc\n",
+       "hdl:21.14100/9a3ea32e-84bb-4d7a-a11f-6c560915efa4</dd><dt><span>nominal_resolution :</span></dt><dd>100 km</dd><dt><span>parent_activity_id :</span></dt><dd>CMIP</dd><dt><span>parent_experiment_id :</span></dt><dd>piControl-spinup</dd><dt><span>parent_mip_era :</span></dt><dd>CMIP6</dd><dt><span>parent_source_id :</span></dt><dd>CanESM5-CanOE</dd><dt><span>parent_time_units :</span></dt><dd>days since 1850-01-01 0:0:0.0</dd><dt><span>parent_variant_label :</span></dt><dd>r1i1p2f1</dd><dt><span>physics_index :</span></dt><dd>2</dd><dt><span>product :</span></dt><dd>model-output</dd><dt><span>realization_index :</span></dt><dd>1</dd><dt><span>realm :</span></dt><dd>ocean</dd><dt><span>references :</span></dt><dd>Geoscientific Model Development Special issue on CanESM5 (https://www.geosci-model-dev.net/special_issue989.html)</dd><dt><span>source :</span></dt><dd>CanESM5-CanOE (2019): \n",
+       "aerosol: interactive\n",
+       "atmos: CanAM5 (T63L49 native atmosphere, T63 Linear Gaussian Grid; 128 x 64 longitude/latitude; 49 levels; top level 1 hPa)\n",
+       "atmosChem: specified oxidants for aerosols\n",
+       "land: CLASS3.6/CTEM1.2\n",
+       "landIce: specified ice sheets\n",
+       "ocean: NEMO3.4.1 (ORCA1 tripolar grid, 1 deg with refinement to 1/3 deg within 20 degrees of the equator; 361 x 290 longitude/latitude; 45 vertical levels; top grid cell 0-6.19 m)\n",
+       "ocnBgchem: Canadian Ocean Ecosystem (CanOE) with OMIP prescribed carbon chemistry\n",
+       "seaIce: LIM2</dd><dt><span>source_id :</span></dt><dd>CanESM5-CanOE</dd><dt><span>source_type :</span></dt><dd>AOGCM</dd><dt><span>status :</span></dt><dd>2020-12-31;created; by gcs.cmip6.ldeo@gmail.com</dd><dt><span>sub_experiment :</span></dt><dd>none</dd><dt><span>sub_experiment_id :</span></dt><dd>none</dd><dt><span>table_id :</span></dt><dd>Omon</dd><dt><span>table_info :</span></dt><dd>Creation Date:(24 July 2019) MD5:c93735846d66458966fc81f390b2d714</dd><dt><span>title :</span></dt><dd>CanESM5-CanOE output prepared for CMIP6</dd><dt><span>tracking_id :</span></dt><dd>hdl:21.14100/8b3a90ee-6bf3-496a-ba59-648ddedb007c\n",
+       "hdl:21.14100/d73e30c1-ade5-4187-9276-a765675ba594\n",
+       "hdl:21.14100/e8ec6a5c-1b1e-4f38-bb6c-3cf749331a72\n",
+       "hdl:21.14100/f40c6071-ebbe-4c39-9552-fb9d44cf18c2\n",
+       "hdl:21.14100/8e9cdeca-d27d-4f5d-9294-ae2017eda51e\n",
+       "hdl:21.14100/6bfc80cc-b651-4749-add2-47230f00b4f7\n",
+       "hdl:21.14100/3838dd2c-9838-4cee-8057-420a285c16b7\n",
+       "hdl:21.14100/6a8df388-8eaf-42db-9a8c-fb785f00553a\n",
+       "hdl:21.14100/94d17f37-bc9c-4a71-b311-701afe5002db\n",
+       "hdl:21.14100/ce804047-111e-4140-b7e4-aaabe712baeb\n",
+       "hdl:21.14100/c46a5aff-afca-40e3-a41f-2b4837f8da7a\n",
+       "hdl:21.14100/f3c29ca2-63f3-4c66-970e-202a98287e76\n",
+       "hdl:21.14100/44a989f3-55e7-40ac-bcd6-a322ad98a8a4\n",
+       "hdl:21.14100/2fa7efbf-b263-47fa-b085-15024d22a9b2\n",
+       "hdl:21.14100/9189ae2c-157c-4b2e-a143-f00196de2b15\n",
+       "hdl:21.14100/881d762f-8479-4a2e-9b24-7d6724411d7a\n",
+       "hdl:21.14100/7d5a15c7-bd57-4d60-9377-6cb8ce5544d8\n",
+       "hdl:21.14100/c8b6c648-a238-4520-b8d0-984c18584737\n",
+       "hdl:21.14100/5fa556fb-d772-4d65-99fd-7ee524df4669\n",
+       "hdl:21.14100/5f5a48d9-8d6f-44f8-8854-7f7d168fa95b\n",
+       "hdl:21.14100/0e13a49d-446a-426e-af98-5d068921ac80\n",
+       "hdl:21.14100/50ac7e17-f501-409e-bb78-a3a844203c3d\n",
+       "hdl:21.14100/d9e74964-17d1-46b4-ae37-c85da9673408\n",
+       "hdl:21.14100/46e16c1b-edcc-4353-ae2a-a0a661cb68e5\n",
+       "hdl:21.14100/9ce4dc44-eaca-4b98-a999-347d28808a5b\n",
+       "hdl:21.14100/a38c0f47-4f5d-4541-8acf-882f7fef6c4e\n",
+       "hdl:21.14100/8198bd12-1e6a-4d8c-a0a6-03e085943d4d\n",
+       "hdl:21.14100/6f5b0e9a-b79d-4321-9a86-1d68c58559ae\n",
+       "hdl:21.14100/24e2daea-7556-46c8-9e08-c1109e212910\n",
+       "hdl:21.14100/ce7aafab-46b3-4ec2-9abb-4b107179a021\n",
+       "hdl:21.14100/40b76661-3806-40bf-9381-20a1918c2acd\n",
+       "hdl:21.14100/99cb0d3d-bc7d-4469-b232-c3529a9f45cc\n",
+       "hdl:21.14100/6c6f53e7-b15f-4382-b1e5-07354bae1aa9\n",
+       "hdl:21.14100/7c2657e6-ccf3-48ae-9f4b-a46a85b4ce9c\n",
+       "hdl:21.14100/f1b55d85-0633-44e9-b1cf-8f55241ddf44\n",
+       "hdl:21.14100/0c6fda9b-3959-49c4-af27-65340573c503\n",
+       "hdl:21.14100/8c5acf30-cc61-44ee-a496-c2f8e8258270\n",
+       "hdl:21.14100/f4b44462-d3d7-4932-90c4-34d9a8f726de\n",
+       "hdl:21.14100/d5425f68-8ad5-4fec-8309-3a79eb3195e5\n",
+       "hdl:21.14100/e0cb2937-21ce-4277-8927-361db0d7f96c\n",
+       "hdl:21.14100/682a5332-b6ef-4044-ae4f-e692cb30b61f\n",
+       "hdl:21.14100/2744f541-25e1-485f-8e7a-a54dbb9b35f6\n",
+       "hdl:21.14100/b3a492e0-ea86-49fb-98b3-5c20c5c09d5e\n",
+       "hdl:21.14100/6897611a-8205-4a6a-9e2b-d15153a3b238\n",
+       "hdl:21.14100/b92451d5-66e7-4477-9bbe-5b0938ff537c\n",
+       "hdl:21.14100/14c3e40f-46c0-4236-b632-c50b741c9865\n",
+       "hdl:21.14100/712e0694-fd3e-47de-95ec-f8758f4f427e\n",
+       "hdl:21.14100/09026096-df9c-44b5-a3be-38d7859ae189\n",
+       "hdl:21.14100/05345fcc-3261-47e4-81b4-24caeb0674bc\n",
+       "hdl:21.14100/9a3ea32e-84bb-4d7a-a11f-6c560915efa4</dd><dt><span>variable_id :</span></dt><dd>thetao</dd><dt><span>variant_label :</span></dt><dd>r1i1p2f1</dd><dt><span>version :</span></dt><dd>v20190429</dd><dt><span>version_id :</span></dt><dd>v20190429</dd></dl></div></li></ul></div></div>"
+      ],
+      "text/plain": [
+       "<xarray.Dataset>\n",
+       "Dimensions:  (lev: 45, time: 6012, x: 360, y: 291)\n",
+       "Coordinates:\n",
+       "    lat      (y, x) float64 dask.array<chunksize=(291, 3), meta=np.ndarray>\n",
+       "  * lev      (lev) float64 3.047 9.454 16.36 ... 5.126e+03 5.375e+03 5.625e+03\n",
+       "    lon      (y, x) float64 dask.array<chunksize=(291, 3), meta=np.ndarray>\n",
+       "  * time     (time) object 5550-01-16 12:00:00 ... 6050-12-16 12:00:00\n",
+       "  * x        (x) int32 0 1 2 3 4 5 6 7 8 ... 351 352 353 354 355 356 357 358 359\n",
+       "  * y        (y) int32 0 1 2 3 4 5 6 7 8 ... 282 283 284 285 286 287 288 289 290\n",
+       "Data variables:\n",
+       "    thetao   (time, lev, y, x) float32 dask.array<chunksize=(6012, 1, 291, 3), meta=np.ndarray>\n",
+       "Attributes: (12/58)\n",
+       "    CCCma_model_hash:            932b659de600c6a0e94f619abaf9cc79eabcd337\n",
+       "    CCCma_parent_runid:          canoecpl-007\n",
+       "    CCCma_pycmor_hash:           3ecdc18eb7c1f7fbce0346850f41adf815d9fb66\n",
+       "    CCCma_runid:                 c2-pictrl\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   5550:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5-CanOE output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/8b3a90ee-6bf3-496a-ba59-648dded...\n",
+       "    variable_id:                 thetao\n",
+       "    variant_label:               r1i1p2f1\n",
+       "    version:                     v20190429\n",
+       "    version_id:                  v20190429"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "if not mapper.fs.exists(path):\n",
+    "    # recompute the rechunked data into the scratch bucket (is only triggered when the temporary store was erased)\n",
+    "    \n",
+    "    # Remove the temp store if for some reason that still exists\n",
+    "    if mapper.fs.exists(temp_path):\n",
+    "        mapper.fs.rm(temp_path, recursive=True)\n",
+    "    from rechunker import rechunk\n",
+    "    target_chunks = {\n",
+    "        'thetao': {'time':6012, 'lev':1, 'x':3, 'y':291},\n",
+    "        'x': {'x':3},\n",
+    "        'y': {'y':291},\n",
+    "        'lat': {'x':3, 'y':291},\n",
+    "        'lev': {'lev':1},\n",
+    "        'lon': {'x':3, 'y':291},\n",
+    "        'time': {'time':6012}, \n",
+    "    }\n",
+    "    max_mem = '1GB'\n",
+    "\n",
+    "    array_plan = rechunk(ds_control[['thetao']], target_chunks, max_mem, mapper, temp_store=mapper_temp)\n",
+    "    array_plan.execute(retries=10)\n",
+    "    \n",
+    "ds_control_rechunked = xr.open_zarr(mapper, use_cftime=True)\n",
+    "ds_control_rechunked    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e12291a5",
+   "metadata": {},
+   "source": [
+    "### Calculating the drift over the control run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "586a7b44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cmip6_preprocessing.drift_removal import calculate_drift, remove_trend"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "ea1ff6ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/srv/conda/envs/notebook/lib/python3.8/site-packages/xarrayutils/utils.py:85: FutureWarning: ``output_sizes`` should be given in the ``dask_gufunc_kwargs`` parameter. It will be removed as direct parameter in a future version.\n",
+      "  stats = xr.apply_ufunc(\n"
+     ]
+    },
+    {
+     "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",
+       "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;\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-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",
+       "  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",
+       "  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-attrs {\n",
+       "  padding-left: 25px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs,\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-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",
+       "  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'>&lt;xarray.Dataset&gt;\n",
+       "Dimensions:           (bnds: 2, lev: 45, x: 360, y: 291)\n",
+       "Coordinates:\n",
+       "  * lev               (lev) float64 3.047 9.454 16.36 ... 5.375e+03 5.625e+03\n",
+       "  * x                 (x) int32 0 1 2 3 4 5 6 7 ... 353 354 355 356 357 358 359\n",
+       "  * y                 (y) int32 0 1 2 3 4 5 6 7 ... 284 285 286 287 288 289 290\n",
+       "    trend_time_range  (bnds) &lt;U19 &#x27;5550-01-16 12:00:00&#x27; &#x27;5799-12-16 12:00:00&#x27;\n",
+       "Dimensions without coordinates: bnds\n",
+       "Data variables:\n",
+       "    thetao            (lev, y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "Attributes: (12/58)\n",
+       "    CCCma_model_hash:            932b659de600c6a0e94f619abaf9cc79eabcd337\n",
+       "    CCCma_parent_runid:          canoecpl-007\n",
+       "    CCCma_pycmor_hash:           3ecdc18eb7c1f7fbce0346850f41adf815d9fb66\n",
+       "    CCCma_runid:                 c2-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    variant_label:               r1i1p2f1\n",
+       "    version:                     v20190429\n",
+       "    netcdf_tracking_ids:         hdl:21.14100/05f0fb20-3395-4112-af53-d1b9241...\n",
+       "    version_id:                  v20190429\n",
+       "    intake_esm_varname:          None\n",
+       "    intake_esm_dataset_key:      CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1...</pre><div class='xr-wrap' hidden><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-87bde4a4-825c-467a-8fd2-442dc778a40a' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-87bde4a4-825c-467a-8fd2-442dc778a40a' class='xr-section-summary'  title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span>bnds</span>: 2</li><li><span class='xr-has-index'>lev</span>: 45</li><li><span class='xr-has-index'>x</span>: 360</li><li><span class='xr-has-index'>y</span>: 291</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-153bb0fa-0b6a-41e2-ad3b-a8fb80b6587e' class='xr-section-summary-in' type='checkbox'  checked><label for='section-153bb0fa-0b6a-41e2-ad3b-a8fb80b6587e' class='xr-section-summary' >Coordinates: <span>(4)</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'>lev</span></div><div class='xr-var-dims'>(lev)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>3.047 9.454 ... 5.375e+03 5.625e+03</div><input id='attrs-955c592d-5300-455c-93ab-bccd25ab8bb4' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-955c592d-5300-455c-93ab-bccd25ab8bb4' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-f5b537e9-c87e-4833-af7e-0fab5d49298b' class='xr-var-data-in' type='checkbox'><label for='data-f5b537e9-c87e-4833-af7e-0fab5d49298b' 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>axis :</span></dt><dd>Z</dd><dt><span>bounds :</span></dt><dd>lev_bnds</dd><dt><span>long_name :</span></dt><dd>ocean depth coordinate</dd><dt><span>positive :</span></dt><dd>down</dd><dt><span>standard_name :</span></dt><dd>depth</dd><dt><span>units :</span></dt><dd>m</dd></dl></div><div class='xr-var-data'><pre>array([3.046773e+00, 9.454049e+00, 1.636397e+01, 2.389871e+01, 3.220929e+01,\n",
+       "       4.148185e+01, 5.194513e+01, 6.387905e+01, 7.762451e+01, 9.359412e+01,\n",
+       "       1.122835e+02, 1.342823e+02, 1.602840e+02, 1.910925e+02, 2.276233e+02,\n",
+       "       2.708962e+02, 3.220169e+02, 3.821444e+02, 4.524429e+02, 5.340197e+02,\n",
+       "       6.278525e+02, 7.347150e+02, 8.551112e+02, 9.892289e+02, 1.136922e+03,\n",
+       "       1.297724e+03, 1.470893e+03, 1.655472e+03, 1.850365e+03, 2.054414e+03,\n",
+       "       2.266454e+03, 2.485371e+03, 2.710133e+03, 2.939812e+03, 3.173588e+03,\n",
+       "       3.410756e+03, 3.650712e+03, 3.892950e+03, 4.137047e+03, 4.382654e+03,\n",
+       "       4.629485e+03, 4.877303e+03, 5.125919e+03, 5.375177e+03, 5.624952e+03])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>x</span></div><div class='xr-var-dims'>(x)</div><div class='xr-var-dtype'>int32</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 5 ... 355 356 357 358 359</div><input id='attrs-7d9c7b6a-9fa4-4878-8215-b0c96aa5c920' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-7d9c7b6a-9fa4-4878-8215-b0c96aa5c920' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-e1e3ea50-b918-4900-922a-0b6df09cc730' class='xr-var-data-in' type='checkbox'><label for='data-e1e3ea50-b918-4900-922a-0b6df09cc730' 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>cell index along first dimension</dd><dt><span>units :</span></dt><dd>1</dd></dl></div><div class='xr-var-data'><pre>array([  0,   1,   2, ..., 357, 358, 359], dtype=int32)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>y</span></div><div class='xr-var-dims'>(y)</div><div class='xr-var-dtype'>int32</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 5 ... 286 287 288 289 290</div><input id='attrs-52c7d2c3-20fc-41a0-83fa-b1ff150516d4' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-52c7d2c3-20fc-41a0-83fa-b1ff150516d4' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-91bb3c34-b024-4c94-817a-c3d7a038a26a' class='xr-var-data-in' type='checkbox'><label for='data-91bb3c34-b024-4c94-817a-c3d7a038a26a' 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>cell index along second dimension</dd><dt><span>units :</span></dt><dd>1</dd></dl></div><div class='xr-var-data'><pre>array([  0,   1,   2, ..., 288, 289, 290], dtype=int32)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>trend_time_range</span></div><div class='xr-var-dims'>(bnds)</div><div class='xr-var-dtype'>&lt;U19</div><div class='xr-var-preview xr-preview'>&#x27;5550-01-16 12:00:00&#x27; &#x27;5799-12-1...</div><input id='attrs-6410a359-533b-45c9-a404-70d1407dec0f' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-6410a359-533b-45c9-a404-70d1407dec0f' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-9c1aeaf4-d573-4305-87b8-20ddcf1b38b3' class='xr-var-data-in' type='checkbox'><label for='data-9c1aeaf4-d573-4305-87b8-20ddcf1b38b3' 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>axis :</span></dt><dd>T</dd><dt><span>bounds :</span></dt><dd>time_bnds</dd><dt><span>long_name :</span></dt><dd>regression_time_in_reference_run</dd><dt><span>standard_name :</span></dt><dd>regression_time_bounds</dd></dl></div><div class='xr-var-data'><pre>array([&#x27;5550-01-16 12:00:00&#x27;, &#x27;5799-12-16 12:00:00&#x27;], dtype=&#x27;&lt;U19&#x27;)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-14bd0856-5d9e-44d7-825e-fd82c0c7d3f4' class='xr-section-summary-in' type='checkbox'  checked><label for='section-14bd0856-5d9e-44d7-825e-fd82c0c7d3f4' class='xr-section-summary' >Data variables: <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>thetao</span></div><div class='xr-var-dims'>(lev, y, x)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>nan nan nan nan ... nan nan nan nan</div><input id='attrs-0784e1af-ac0b-4ead-bd1d-72184027abd7' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-0784e1af-ac0b-4ead-bd1d-72184027abd7' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-e1ab27e0-d16e-4238-972a-c0e044231ac6' class='xr-var-data-in' type='checkbox'><label for='data-e1ab27e0-d16e-4238-972a-c0e044231ac6' 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([[[nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        ...,\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan]],\n",
+       "\n",
+       "       [[nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        ...,\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan]],\n",
+       "\n",
+       "       [[nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        ...,\n",
+       "...\n",
+       "        ...,\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan]],\n",
+       "\n",
+       "       [[nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        ...,\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan]],\n",
+       "\n",
+       "       [[nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        ...,\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan],\n",
+       "        [nan, nan, nan, ..., nan, nan, nan]]], dtype=float32)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-f53575a2-85d4-4d34-b2f6-0ac0e16b7149' class='xr-section-summary-in' type='checkbox'  ><label for='section-f53575a2-85d4-4d34-b2f6-0ac0e16b7149' class='xr-section-summary' >Attributes: <span>(58)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>CCCma_model_hash :</span></dt><dd>932b659de600c6a0e94f619abaf9cc79eabcd337</dd><dt><span>CCCma_parent_runid :</span></dt><dd>canoecpl-007</dd><dt><span>CCCma_pycmor_hash :</span></dt><dd>3ecdc18eb7c1f7fbce0346850f41adf815d9fb66</dd><dt><span>CCCma_runid :</span></dt><dd>c2-his01</dd><dt><span>Conventions :</span></dt><dd>CF-1.7 CMIP-6.2</dd><dt><span>YMDH_branch_time_in_child :</span></dt><dd>1850:01:01:00</dd><dt><span>YMDH_branch_time_in_parent :</span></dt><dd>5550:01:01:00</dd><dt><span>activity_id :</span></dt><dd>CMIP</dd><dt><span>branch_method :</span></dt><dd>Spin-up documentation</dd><dt><span>branch_time_in_child :</span></dt><dd>0.0</dd><dt><span>branch_time_in_parent :</span></dt><dd>1350500.0</dd><dt><span>cmor_version :</span></dt><dd>3.5.0</dd><dt><span>contact :</span></dt><dd>ec.cccma.info-info.ccmac.ec@canada.ca</dd><dt><span>creation_date :</span></dt><dd>2019-12-11T19:02:54Z</dd><dt><span>data_specs_version :</span></dt><dd>01.00.31</dd><dt><span>experiment :</span></dt><dd>all-forcing simulation of the recent past</dd><dt><span>experiment_id :</span></dt><dd>historical</dd><dt><span>external_variables :</span></dt><dd>areacello volcello</dd><dt><span>forcing_index :</span></dt><dd>1</dd><dt><span>frequency :</span></dt><dd>mon</dd><dt><span>further_info_url :</span></dt><dd>https://furtherinfo.es-doc.org/CMIP6.CCCma.CanESM5-CanOE.historical.none.r1i1p2f1</dd><dt><span>grid :</span></dt><dd>ORCA1 tripolar grid, 1 deg with refinement to 1/3 deg within 20 degrees of the equator; 361 x 290 longitude/latitude; 45 vertical levels; top grid cell 0-6.19 m</dd><dt><span>grid_label :</span></dt><dd>gn</dd><dt><span>history :</span></dt><dd>2019-12-11T19:02:54Z ;rewrote data to be consistent with CMIP for variable thetao found in table Omon.</dd><dt><span>initialization_index :</span></dt><dd>1</dd><dt><span>institution :</span></dt><dd>Canadian Centre for Climate Modelling and Analysis, Environment and Climate Change Canada, Victoria, BC V8P 5C2, Canada</dd><dt><span>institution_id :</span></dt><dd>CCCma</dd><dt><span>license :</span></dt><dd>CMIP6 model data produced by The Government of Canada (Canadian Centre for Climate Modelling and Analysis, Environment and Climate Change Canada) is licensed under a Creative Commons Attribution ShareAlike 4.0 International License (https://creativecommons.org/licenses). Consult https://pcmdi.llnl.gov/CMIP6/TermsOfUse for terms of use governing CMIP6 output, including citation requirements and proper acknowledgment. Further information about this data, including some limitations, can be found via the further_info_url (recorded as a global attribute in this file) and at https:///pcmdi.llnl.gov/. The data producers and data providers make no warranty, either express or implied, including, but not limited to, warranties of merchantability and fitness for a particular purpose. All liabilities arising from the supply of the information (including any liability arising in negligence) are excluded to the fullest extent permitted by law.</dd><dt><span>mip_era :</span></dt><dd>CMIP6</dd><dt><span>nominal_resolution :</span></dt><dd>100 km</dd><dt><span>parent_activity_id :</span></dt><dd>CMIP</dd><dt><span>parent_experiment_id :</span></dt><dd>piControl</dd><dt><span>parent_mip_era :</span></dt><dd>CMIP6</dd><dt><span>parent_source_id :</span></dt><dd>CanESM5-CanOE</dd><dt><span>parent_time_units :</span></dt><dd>days since 1850-01-01 0:0:0.0</dd><dt><span>parent_variant_label :</span></dt><dd>r1i1p2f1</dd><dt><span>physics_index :</span></dt><dd>2</dd><dt><span>product :</span></dt><dd>model-output</dd><dt><span>realization_index :</span></dt><dd>1</dd><dt><span>realm :</span></dt><dd>ocean</dd><dt><span>references :</span></dt><dd>Geoscientific Model Development Special issue on CanESM5 (https://www.geosci-model-dev.net/special_issue989.html)</dd><dt><span>source :</span></dt><dd>CanESM5-CanOE (2019): \n",
+       "aerosol: interactive\n",
+       "atmos: CanAM5 (T63L49 native atmosphere, T63 Linear Gaussian Grid; 128 x 64 longitude/latitude; 49 levels; top level 1 hPa)\n",
+       "atmosChem: specified oxidants for aerosols\n",
+       "land: CLASS3.6/CTEM1.2\n",
+       "landIce: specified ice sheets\n",
+       "ocean: NEMO3.4.1 (ORCA1 tripolar grid, 1 deg with refinement to 1/3 deg within 20 degrees of the equator; 361 x 290 longitude/latitude; 45 vertical levels; top grid cell 0-6.19 m)\n",
+       "ocnBgchem: Canadian Ocean Ecosystem (CanOE) with OMIP prescribed carbon chemistry\n",
+       "seaIce: LIM2</dd><dt><span>source_id :</span></dt><dd>CanESM5-CanOE</dd><dt><span>source_type :</span></dt><dd>AOGCM</dd><dt><span>status :</span></dt><dd>2020-01-27;created; by gcs.cmip6.ldeo@gmail.com</dd><dt><span>sub_experiment :</span></dt><dd>none</dd><dt><span>sub_experiment_id :</span></dt><dd>none</dd><dt><span>table_id :</span></dt><dd>Omon</dd><dt><span>table_info :</span></dt><dd>Creation Date:(24 July 2019) MD5:c93735846d66458966fc81f390b2d714</dd><dt><span>title :</span></dt><dd>CanESM5-CanOE output prepared for CMIP6</dd><dt><span>tracking_id :</span></dt><dd>hdl:21.14100/05f0fb20-3395-4112-af53-d1b9241b27d0\n",
+       "hdl:21.14100/85028acb-5582-4f18-b5dd-c99a3ccfea7e\n",
+       "hdl:21.14100/035167fc-8ff6-4cb0-b366-a396c92dbb30\n",
+       "hdl:21.14100/58a3046a-8bb5-4629-a54d-cf9468389e0a\n",
+       "hdl:21.14100/473e5246-8c26-4b98-8049-de0da8073616\n",
+       "hdl:21.14100/95841cde-a3b0-488b-a326-6adebb0a184d\n",
+       "hdl:21.14100/62e0855b-8359-4806-9f9d-bedfe270908e\n",
+       "hdl:21.14100/6803d3df-5bb6-417c-b62f-a9ae5e45c1b1\n",
+       "hdl:21.14100/7e3d4d83-4621-4b34-aa3b-29cb8b3b7aa5\n",
+       "hdl:21.14100/5a7b01b0-ae05-4dc3-9271-dcb77cbe5fdc\n",
+       "hdl:21.14100/651b784d-6f71-4b3d-b013-4bfb1b796d2b\n",
+       "hdl:21.14100/26930428-75ae-4ee2-9152-3fe01773eceb\n",
+       "hdl:21.14100/93831eb9-7bdd-4f37-8017-c753d8c6b16e\n",
+       "hdl:21.14100/252ad996-1374-47c0-a1d0-37387b4e89ed\n",
+       "hdl:21.14100/419a6d68-2e5a-42ae-b0dc-b1ab2de97c93\n",
+       "hdl:21.14100/b7ab6980-ce99-45cd-9ed2-3db50446c699\n",
+       "hdl:21.14100/55186b3d-f402-4c56-aec9-0c60d91a0c75</dd><dt><span>variable_id :</span></dt><dd>thetao</dd><dt><span>variant_label :</span></dt><dd>r1i1p2f1</dd><dt><span>version :</span></dt><dd>v20190429</dd><dt><span>netcdf_tracking_ids :</span></dt><dd>hdl:21.14100/05f0fb20-3395-4112-af53-d1b9241b27d0\n",
+       "hdl:21.14100/85028acb-5582-4f18-b5dd-c99a3ccfea7e\n",
+       "hdl:21.14100/035167fc-8ff6-4cb0-b366-a396c92dbb30\n",
+       "hdl:21.14100/58a3046a-8bb5-4629-a54d-cf9468389e0a\n",
+       "hdl:21.14100/473e5246-8c26-4b98-8049-de0da8073616\n",
+       "hdl:21.14100/95841cde-a3b0-488b-a326-6adebb0a184d\n",
+       "hdl:21.14100/62e0855b-8359-4806-9f9d-bedfe270908e\n",
+       "hdl:21.14100/6803d3df-5bb6-417c-b62f-a9ae5e45c1b1\n",
+       "hdl:21.14100/7e3d4d83-4621-4b34-aa3b-29cb8b3b7aa5\n",
+       "hdl:21.14100/5a7b01b0-ae05-4dc3-9271-dcb77cbe5fdc\n",
+       "hdl:21.14100/651b784d-6f71-4b3d-b013-4bfb1b796d2b\n",
+       "hdl:21.14100/26930428-75ae-4ee2-9152-3fe01773eceb\n",
+       "hdl:21.14100/93831eb9-7bdd-4f37-8017-c753d8c6b16e\n",
+       "hdl:21.14100/252ad996-1374-47c0-a1d0-37387b4e89ed\n",
+       "hdl:21.14100/419a6d68-2e5a-42ae-b0dc-b1ab2de97c93\n",
+       "hdl:21.14100/b7ab6980-ce99-45cd-9ed2-3db50446c699\n",
+       "hdl:21.14100/55186b3d-f402-4c56-aec9-0c60d91a0c75</dd><dt><span>version_id :</span></dt><dd>v20190429</dd><dt><span>intake_esm_varname :</span></dt><dd>None</dd><dt><span>intake_esm_dataset_key :</span></dt><dd>CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1.Omon.thetao.gn.gs://cmip6/CMIP6/CMIP/CCCma/CanESM5-CanOE/historical/r1i1p2f1/Omon/thetao/gn/v20190429/.nan.20190429</dd></dl></div></li></ul></div></div>"
+      ],
+      "text/plain": [
+       "<xarray.Dataset>\n",
+       "Dimensions:           (bnds: 2, lev: 45, x: 360, y: 291)\n",
+       "Coordinates:\n",
+       "  * lev               (lev) float64 3.047 9.454 16.36 ... 5.375e+03 5.625e+03\n",
+       "  * x                 (x) int32 0 1 2 3 4 5 6 7 ... 353 354 355 356 357 358 359\n",
+       "  * y                 (y) int32 0 1 2 3 4 5 6 7 ... 284 285 286 287 288 289 290\n",
+       "    trend_time_range  (bnds) <U19 '5550-01-16 12:00:00' '5799-12-16 12:00:00'\n",
+       "Dimensions without coordinates: bnds\n",
+       "Data variables:\n",
+       "    thetao            (lev, y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "Attributes: (12/58)\n",
+       "    CCCma_model_hash:            932b659de600c6a0e94f619abaf9cc79eabcd337\n",
+       "    CCCma_parent_runid:          canoecpl-007\n",
+       "    CCCma_pycmor_hash:           3ecdc18eb7c1f7fbce0346850f41adf815d9fb66\n",
+       "    CCCma_runid:                 c2-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    variant_label:               r1i1p2f1\n",
+       "    version:                     v20190429\n",
+       "    netcdf_tracking_ids:         hdl:21.14100/05f0fb20-3395-4112-af53-d1b9241...\n",
+       "    version_id:                  v20190429\n",
+       "    intake_esm_varname:          None\n",
+       "    intake_esm_dataset_key:      CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1..."
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "drift = calculate_drift(ds_control_rechunked, ds_historical, 'thetao') \n",
+    "drift = drift.load() # This takes a bit, but it is worth loading this small output to avoid repeated computation\n",
+    "drift"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "b0da8db1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x7f98eecf7190>"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "drift.thetao.isel(x=250).plot(yincrease=False, robust=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "912250cf",
+   "metadata": {},
+   "source": [
+    "`drift` represents the slope of a linear regression at every grid point of the model. For demonstration purposes we will stick with the one grid point that we defined above. Lets first check if the trend seems right..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "d90ad71f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start = drift.trend_time_range.isel(bnds=0).data.tolist()\n",
+    "stop = drift.trend_time_range.isel(bnds=1).data.tolist()\n",
+    "time = xr.cftime_range(start, stop, freq='1MS')\n",
+    "\n",
+    "# cut the control it to the time over which the trend was calculated\n",
+    "ds_control_cut = ds_control_rechunked.sel(time=slice(start, stop))\n",
+    "\n",
+    "# use the linear slope from the same point to construct a trendline\n",
+    "trendline = xr.DataArray((np.arange(len(time)) * drift.thetao.isel(**roi).data) + ds_control_cut.thetao.isel(**roi, time=0).data, dims=['time'], coords={'time':time})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "1ef8d9bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98bfa23460>]"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ds_control_cut.thetao.isel(**roi).plot()\n",
+    "trendline.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef0f642b",
+   "metadata": {},
+   "source": [
+    "### Removing the drift from various datasets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a60c2fdc",
+   "metadata": {},
+   "source": [
+    "We can remove this slope from either the control run "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "1b1bd93e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98b9de5490>]"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "control_detrended = remove_trend(ds_control, drift, 'thetao', ref_date=str(ds_control.time.data[0]))\n",
+    "control_detrended.isel(**roi).plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa138f58",
+   "metadata": {},
+   "source": [
+    "Sure thats nice, but that's not why we are here. Lets actually remove the trend from the control run from *another* run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "d17799fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98bf89d040>]"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ds_historical_dedrifted = remove_trend(ds_historical, drift, 'thetao', ref_date=str(ds_historical.time.data[0]))\n",
+    "ds_historical_dedrifted.isel(**roi).plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "06d6383e",
+   "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",
+       "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;\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-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",
+       "  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",
+       "  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-attrs {\n",
+       "  padding-left: 25px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs,\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-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",
+       "  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'>&lt;xarray.DataArray (time: 1980, lev: 45, y: 291, x: 360)&gt;\n",
+       "dask.array&lt;sub, shape=(1980, 45, 291, 360), dtype=float32, chunksize=(5, 45, 291, 360), chunktype=numpy.ndarray&gt;\n",
+       "Coordinates:\n",
+       "  * time     (time) object 1850-01-16 12:00:00 ... 2014-12-16 12:00:00\n",
+       "  * x        (x) int32 0 1 2 3 4 5 6 7 8 ... 351 352 353 354 355 356 357 358 359\n",
+       "  * y        (y) int32 0 1 2 3 4 5 6 7 8 ... 282 283 284 285 286 287 288 289 290\n",
+       "    lat      (y, x) float64 dask.array&lt;chunksize=(291, 360), meta=np.ndarray&gt;\n",
+       "  * lev      (lev) float64 3.047 9.454 16.36 ... 5.126e+03 5.375e+03 5.625e+03\n",
+       "    lon      (y, x) float64 dask.array&lt;chunksize=(291, 360), meta=np.ndarray&gt;\n",
+       "Attributes:\n",
+       "    cell_measures:  area: areacello volume: volcello\n",
+       "    cell_methods:   area: mean where sea time: mean\n",
+       "    comment:        Diagnostic should be contributed even for models using co...\n",
+       "    long_name:      Sea Water Potential Temperature\n",
+       "    original_name:  votemper\n",
+       "    standard_name:  sea_water_potential_temperature\n",
+       "    units:          degC\n",
+       "    drift_removed:  linear_trend_CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1...</pre><div class='xr-wrap' hidden><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>: 1980</li><li><span class='xr-has-index'>lev</span>: 45</li><li><span class='xr-has-index'>y</span>: 291</li><li><span class='xr-has-index'>x</span>: 360</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-0d838ad3-c7cd-4258-9cf2-26d3dcc5b6b4' class='xr-array-in' type='checkbox' checked><label for='section-0d838ad3-c7cd-4258-9cf2-26d3dcc5b6b4' 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>dask.array&lt;chunksize=(5, 45, 291, 360), meta=np.ndarray&gt;</span></div><div class='xr-array-data'><table>\n",
+       "<tr>\n",
+       "<td>\n",
+       "<table>\n",
+       "  <thead>\n",
+       "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr><th> Bytes </th><td> 34.77 GiB </td> <td> 89.92 MiB </td></tr>\n",
+       "    <tr><th> Shape </th><td> (1980, 45, 291, 360) </td> <td> (5, 45, 291, 360) </td></tr>\n",
+       "    <tr><th> Count </th><td> 2378 Tasks </td><td> 396 Chunks </td></tr>\n",
+       "    <tr><th> Type </th><td> float32 </td><td> numpy.ndarray </td></tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</td>\n",
+       "<td>\n",
+       "<svg width=\"489\" height=\"108\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"0\" y1=\"25\" x2=\"120\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"3\" y1=\"0\" x2=\"3\" y2=\"25\" />\n",
+       "  <line x1=\"7\" y1=\"0\" x2=\"7\" y2=\"25\" />\n",
+       "  <line x1=\"11\" y1=\"0\" x2=\"11\" y2=\"25\" />\n",
+       "  <line x1=\"14\" y1=\"0\" x2=\"14\" y2=\"25\" />\n",
+       "  <line x1=\"18\" y1=\"0\" x2=\"18\" y2=\"25\" />\n",
+       "  <line x1=\"22\" y1=\"0\" x2=\"22\" y2=\"25\" />\n",
+       "  <line x1=\"26\" y1=\"0\" x2=\"26\" y2=\"25\" />\n",
+       "  <line x1=\"30\" y1=\"0\" x2=\"30\" y2=\"25\" />\n",
+       "  <line x1=\"33\" y1=\"0\" x2=\"33\" y2=\"25\" />\n",
+       "  <line x1=\"37\" y1=\"0\" x2=\"37\" y2=\"25\" />\n",
+       "  <line x1=\"41\" y1=\"0\" x2=\"41\" y2=\"25\" />\n",
+       "  <line x1=\"44\" y1=\"0\" x2=\"44\" y2=\"25\" />\n",
+       "  <line x1=\"48\" y1=\"0\" x2=\"48\" y2=\"25\" />\n",
+       "  <line x1=\"52\" y1=\"0\" x2=\"52\" y2=\"25\" />\n",
+       "  <line x1=\"56\" y1=\"0\" x2=\"56\" y2=\"25\" />\n",
+       "  <line x1=\"60\" y1=\"0\" x2=\"60\" y2=\"25\" />\n",
+       "  <line x1=\"63\" y1=\"0\" x2=\"63\" y2=\"25\" />\n",
+       "  <line x1=\"67\" y1=\"0\" x2=\"67\" y2=\"25\" />\n",
+       "  <line x1=\"71\" y1=\"0\" x2=\"71\" y2=\"25\" />\n",
+       "  <line x1=\"74\" y1=\"0\" x2=\"74\" y2=\"25\" />\n",
+       "  <line x1=\"78\" y1=\"0\" x2=\"78\" y2=\"25\" />\n",
+       "  <line x1=\"82\" y1=\"0\" x2=\"82\" y2=\"25\" />\n",
+       "  <line x1=\"86\" y1=\"0\" x2=\"86\" y2=\"25\" />\n",
+       "  <line x1=\"90\" y1=\"0\" x2=\"90\" y2=\"25\" />\n",
+       "  <line x1=\"93\" y1=\"0\" x2=\"93\" y2=\"25\" />\n",
+       "  <line x1=\"97\" y1=\"0\" x2=\"97\" y2=\"25\" />\n",
+       "  <line x1=\"101\" y1=\"0\" x2=\"101\" y2=\"25\" />\n",
+       "  <line x1=\"104\" y1=\"0\" x2=\"104\" y2=\"25\" />\n",
+       "  <line x1=\"108\" y1=\"0\" x2=\"108\" y2=\"25\" />\n",
+       "  <line x1=\"112\" y1=\"0\" x2=\"112\" y2=\"25\" />\n",
+       "  <line x1=\"116\" y1=\"0\" x2=\"116\" y2=\"25\" />\n",
+       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,25.412616514582485 0.0,25.412616514582485\" style=\"fill:#8B4903A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"60.000000\" y=\"45.412617\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >1980</text>\n",
+       "  <text x=\"140.000000\" y=\"12.706308\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,12.706308)\">1</text>\n",
+       "\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"207\" y2=\"17\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"190\" y1=\"40\" x2=\"207\" y2=\"58\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"190\" y2=\"40\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"207\" y1=\"17\" x2=\"207\" y2=\"58\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"190.0,0.0 207.50496594506004,17.504965945060036 207.50496594506004,58.11238481092921 190.0,40.60741886586917\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"231\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"207\" y1=\"17\" x2=\"249\" y2=\"17\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"190\" y1=\"0\" x2=\"207\" y2=\"17\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"231\" y1=\"0\" x2=\"249\" y2=\"17\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"190.0,0.0 231.59732749150098,0.0 249.102293436561,17.504965945060036 207.50496594506004,17.504965945060036\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"207\" y1=\"17\" x2=\"249\" y2=\"17\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"207\" y1=\"58\" x2=\"249\" y2=\"58\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"207\" y1=\"17\" x2=\"207\" y2=\"58\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"249\" y1=\"17\" x2=\"249\" y2=\"58\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"207.50496594506004,17.504965945060036 249.102293436561,17.504965945060036 249.102293436561,58.11238481092921 207.50496594506004,58.11238481092921\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"228.303630\" y=\"78.112385\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >360</text>\n",
+       "  <text x=\"269.102293\" y=\"37.808675\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,269.102293,37.808675)\">291</text>\n",
+       "  <text x=\"188.752483\" y=\"69.359902\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(45,188.752483,69.359902)\">45</text>\n",
+       "</svg>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table></div></div></li><li class='xr-section-item'><input id='section-02e5e5f0-8486-4a5b-87f1-9ddc1122e9db' class='xr-section-summary-in' type='checkbox'  checked><label for='section-02e5e5f0-8486-4a5b-87f1-9ddc1122e9db' class='xr-section-summary' >Coordinates: <span>(6)</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'>1850-01-16 12:00:00 ... 2014-12-...</div><input id='attrs-c3215097-8118-4153-adcf-e6f02727449d' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-c3215097-8118-4153-adcf-e6f02727449d' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-98760037-647b-47ba-91c6-bcc2bd0ba7fd' class='xr-var-data-in' type='checkbox'><label for='data-98760037-647b-47ba-91c6-bcc2bd0ba7fd' 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>axis :</span></dt><dd>T</dd><dt><span>bounds :</span></dt><dd>time_bnds</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(1850, 1, 16, 12, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(1850, 2, 15, 0, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(1850, 3, 16, 12, 0, 0, 0), ...,\n",
+       "       cftime.DatetimeNoLeap(2014, 10, 16, 12, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(2014, 11, 16, 0, 0, 0, 0),\n",
+       "       cftime.DatetimeNoLeap(2014, 12, 16, 12, 0, 0, 0)], dtype=object)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>x</span></div><div class='xr-var-dims'>(x)</div><div class='xr-var-dtype'>int32</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 5 ... 355 356 357 358 359</div><input id='attrs-860d4bd0-0c2a-4bc7-8336-05a1f0dc3230' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-860d4bd0-0c2a-4bc7-8336-05a1f0dc3230' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-9906972c-9b35-4da4-9b93-2a83d04e7cba' class='xr-var-data-in' type='checkbox'><label for='data-9906972c-9b35-4da4-9b93-2a83d04e7cba' 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>cell index along first dimension</dd><dt><span>units :</span></dt><dd>1</dd></dl></div><div class='xr-var-data'><pre>array([  0,   1,   2, ..., 357, 358, 359], dtype=int32)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>y</span></div><div class='xr-var-dims'>(y)</div><div class='xr-var-dtype'>int32</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 5 ... 286 287 288 289 290</div><input id='attrs-bcda21e6-6108-47a2-9b28-51d60597bf75' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-bcda21e6-6108-47a2-9b28-51d60597bf75' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-da172325-5faf-492d-a0d7-c376e3fde56a' class='xr-var-data-in' type='checkbox'><label for='data-da172325-5faf-492d-a0d7-c376e3fde56a' 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>cell index along second dimension</dd><dt><span>units :</span></dt><dd>1</dd></dl></div><div class='xr-var-data'><pre>array([  0,   1,   2, ..., 288, 289, 290], dtype=int32)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lat</span></div><div class='xr-var-dims'>(y, x)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(291, 360), meta=np.ndarray&gt;</div><input id='attrs-0540e81f-629f-4159-85cf-5752b0297f37' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-0540e81f-629f-4159-85cf-5752b0297f37' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-8714ea77-2edc-4d9d-8350-1e965ae40842' class='xr-var-data-in' type='checkbox'><label for='data-8714ea77-2edc-4d9d-8350-1e965ae40842' 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>vertices_latitude</dd><dt><span>long_name :</span></dt><dd>latitude</dd><dt><span>standard_name :</span></dt><dd>latitude</dd><dt><span>units :</span></dt><dd>degrees_north</dd></dl></div><div class='xr-var-data'><table>\n",
+       "<tr>\n",
+       "<td>\n",
+       "<table>\n",
+       "  <thead>\n",
+       "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr><th> Bytes </th><td> 818.44 kiB </td> <td> 818.44 kiB </td></tr>\n",
+       "    <tr><th> Shape </th><td> (291, 360) </td> <td> (291, 360) </td></tr>\n",
+       "    <tr><th> Count </th><td> 7 Tasks </td><td> 1 Chunks </td></tr>\n",
+       "    <tr><th> Type </th><td> float64 </td><td> numpy.ndarray </td></tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</td>\n",
+       "<td>\n",
+       "<svg width=\"170\" height=\"147\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"0\" y1=\"97\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,97.0 0.0,97.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"60.000000\" y=\"117.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >360</text>\n",
+       "  <text x=\"140.000000\" y=\"48.500000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,140.000000,48.500000)\">291</text>\n",
+       "</svg>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>lev</span></div><div class='xr-var-dims'>(lev)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>3.047 9.454 ... 5.375e+03 5.625e+03</div><input id='attrs-ca46519c-9dba-4ec6-a00e-375168ec322e' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-ca46519c-9dba-4ec6-a00e-375168ec322e' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-01700e49-f614-49c2-ac30-98951b0b92e5' class='xr-var-data-in' type='checkbox'><label for='data-01700e49-f614-49c2-ac30-98951b0b92e5' 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>axis :</span></dt><dd>Z</dd><dt><span>bounds :</span></dt><dd>lev_bnds</dd><dt><span>long_name :</span></dt><dd>ocean depth coordinate</dd><dt><span>positive :</span></dt><dd>down</dd><dt><span>standard_name :</span></dt><dd>depth</dd><dt><span>units :</span></dt><dd>m</dd></dl></div><div class='xr-var-data'><pre>array([3.046773e+00, 9.454049e+00, 1.636397e+01, 2.389871e+01, 3.220929e+01,\n",
+       "       4.148185e+01, 5.194513e+01, 6.387905e+01, 7.762451e+01, 9.359412e+01,\n",
+       "       1.122835e+02, 1.342823e+02, 1.602840e+02, 1.910925e+02, 2.276233e+02,\n",
+       "       2.708962e+02, 3.220169e+02, 3.821444e+02, 4.524429e+02, 5.340197e+02,\n",
+       "       6.278525e+02, 7.347150e+02, 8.551112e+02, 9.892289e+02, 1.136922e+03,\n",
+       "       1.297724e+03, 1.470893e+03, 1.655472e+03, 1.850365e+03, 2.054414e+03,\n",
+       "       2.266454e+03, 2.485371e+03, 2.710133e+03, 2.939812e+03, 3.173588e+03,\n",
+       "       3.410756e+03, 3.650712e+03, 3.892950e+03, 4.137047e+03, 4.382654e+03,\n",
+       "       4.629485e+03, 4.877303e+03, 5.125919e+03, 5.375177e+03, 5.624952e+03])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lon</span></div><div class='xr-var-dims'>(y, x)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(291, 360), meta=np.ndarray&gt;</div><input id='attrs-f59716b8-5df9-4d9b-880b-c7b6078a8229' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-f59716b8-5df9-4d9b-880b-c7b6078a8229' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-2166fb29-ab2e-4c78-a06a-5c0788f27c5d' class='xr-var-data-in' type='checkbox'><label for='data-2166fb29-ab2e-4c78-a06a-5c0788f27c5d' 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>vertices_longitude</dd><dt><span>long_name :</span></dt><dd>longitude</dd><dt><span>standard_name :</span></dt><dd>longitude</dd><dt><span>units :</span></dt><dd>degrees_east</dd></dl></div><div class='xr-var-data'><table>\n",
+       "<tr>\n",
+       "<td>\n",
+       "<table>\n",
+       "  <thead>\n",
+       "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr><th> Bytes </th><td> 818.44 kiB </td> <td> 818.44 kiB </td></tr>\n",
+       "    <tr><th> Shape </th><td> (291, 360) </td> <td> (291, 360) </td></tr>\n",
+       "    <tr><th> Count </th><td> 10 Tasks </td><td> 1 Chunks </td></tr>\n",
+       "    <tr><th> Type </th><td> float64 </td><td> numpy.ndarray </td></tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</td>\n",
+       "<td>\n",
+       "<svg width=\"170\" height=\"147\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"0\" y1=\"97\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"97\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,97.0 0.0,97.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"60.000000\" y=\"117.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >360</text>\n",
+       "  <text x=\"140.000000\" y=\"48.500000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,140.000000,48.500000)\">291</text>\n",
+       "</svg>\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table></div></li></ul></div></li><li class='xr-section-item'><input id='section-75ef04ce-d352-45ed-97f5-ce48682ca730' class='xr-section-summary-in' type='checkbox'  checked><label for='section-75ef04ce-d352-45ed-97f5-ce48682ca730' class='xr-section-summary' >Attributes: <span>(8)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>cell_measures :</span></dt><dd>area: areacello volume: volcello</dd><dt><span>cell_methods :</span></dt><dd>area: mean where sea time: mean</dd><dt><span>comment :</span></dt><dd>Diagnostic should be contributed even for models using conservative temperature as prognostic field.</dd><dt><span>long_name :</span></dt><dd>Sea Water Potential Temperature</dd><dt><span>original_name :</span></dt><dd>votemper</dd><dt><span>standard_name :</span></dt><dd>sea_water_potential_temperature</dd><dt><span>units :</span></dt><dd>degC</dd><dt><span>drift_removed :</span></dt><dd>linear_trend_CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1.Omon.gn.v20190429_5550-01-16 12:00:00_5799-12-16 12:00:00</dd></dl></div></li></ul></div></div>"
+      ],
+      "text/plain": [
+       "<xarray.DataArray (time: 1980, lev: 45, y: 291, x: 360)>\n",
+       "dask.array<sub, shape=(1980, 45, 291, 360), dtype=float32, chunksize=(5, 45, 291, 360), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time     (time) object 1850-01-16 12:00:00 ... 2014-12-16 12:00:00\n",
+       "  * x        (x) int32 0 1 2 3 4 5 6 7 8 ... 351 352 353 354 355 356 357 358 359\n",
+       "  * y        (y) int32 0 1 2 3 4 5 6 7 8 ... 282 283 284 285 286 287 288 289 290\n",
+       "    lat      (y, x) float64 dask.array<chunksize=(291, 360), meta=np.ndarray>\n",
+       "  * lev      (lev) float64 3.047 9.454 16.36 ... 5.126e+03 5.375e+03 5.625e+03\n",
+       "    lon      (y, x) float64 dask.array<chunksize=(291, 360), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    cell_measures:  area: areacello volume: volcello\n",
+       "    cell_methods:   area: mean where sea time: mean\n",
+       "    comment:        Diagnostic should be contributed even for models using co...\n",
+       "    long_name:      Sea Water Potential Temperature\n",
+       "    original_name:  votemper\n",
+       "    standard_name:  sea_water_potential_temperature\n",
+       "    units:          degC\n",
+       "    drift_removed:  linear_trend_CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1..."
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ds_historical_dedrifted"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "038e53b0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'linear_trend_CMIP.CCCma.CanESM5-CanOE.historical.r1i1p2f1.Omon.gn.v20190429_5550-01-16 12:00:00_5799-12-16 12:00:00'"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ds_historical_dedrifted.attrs['drift_removed']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88c626e4",
+   "metadata": {},
+   "source": [
+    "Note that the attributes now contain informations about the dataset and time frame over which the removed trend was computed!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "2238356e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98eec61d60>]"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ds_historical.isel(**roi).thetao.coarsen(time=36).mean().plot()\n",
+    "ds_historical_dedrifted.isel(**roi).coarsen(time=36).mean().plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "826bd949",
+   "metadata": {},
+   "source": [
+    "You can also remove the trend from the ssp585 scenario in a way that is consistent with the historical run. The key here is the `ref_date` input. \n",
+    "This should be set to the 'branching' timestep of the historical run for both experiments (which is `1850-01-01` for most CMIP6 historical experiments). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "1e07906d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds_ssp585_dedrifted = remove_trend(\n",
+    "    ds_ssp585,\n",
+    "    drift,\n",
+    "    'thetao',\n",
+    "    ref_date=str(ds_historical.time.data[0]) \n",
+    "    # Note that the ref_date is still the first time point of the *historical*run. \n",
+    "    # This ensures that the scenario is treated as an extension of the historical \n",
+    "    # run and the offset is calculated appropriately\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "9bc30452",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f98ba0bd820>]"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ds_historical.isel(**roi).thetao.coarsen(time=36, boundary='trim').mean().plot(color='C0', label='raw data')\n",
+    "ds_ssp585.isel(**roi).thetao.coarsen(time=36, boundary='trim').mean().plot(color='C0')\n",
+    "ds_historical_dedrifted.isel(**roi).coarsen(time=36, boundary='trim').mean().plot(color='C1', label='control drift removed')\n",
+    "ds_ssp585_dedrifted.isel(**roi).coarsen(time=36, boundary='trim').mean().plot(color='C1')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f52d5cc7",
+   "metadata": {},
+   "source": [
+    "> We are working on calculating the linear trends for common variables and store them in the cloud. Then you only have to apply `remove_trend` and not the expensive `calculate_drift` anymore. Stay tuned!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c830d891",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/index.rst b/docs/index.rst
index 2067235b..05b56563 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -66,8 +66,12 @@ We aim to provide a flexible solution for many scientific workflows which might
 
 The `preprocessing` module deals with 'cleaning' single variable datasets (e.g. from a single zarr store in the `pangeo CMIP6 cloud data <https://pangeo-data.github.io/pangeo-cmip6-cloud/>`_ or a dataset loaded from mulitple netcdf files on a local server/HPC).
 
+It is often desired to remove control run drift from the data before running analyses. Check out the `drift_removal` module for utilities based on aligning/detrending branched runs.
+
 Depending on your science goal, you might need to combine several datasets into members (multi variable datasets) or even further. These combination tasks are facilitated by the `postprocessing` module. This provides the ability to 'match and combine' datasets based on their attributes. For more detailed examples please check out the `Postprocessing` section.
 
+The `regionmask` module enables you to create basin masks for each model (and any other data with longitude/latitude values)
+
 
 .. I need to check out how to link the API sections and from within notebooks properly. Look into https://myst-nb.readthedocs.io/en/latest/
 
@@ -80,6 +84,7 @@ Contents
 
    tutorial
    postprocessing
+   drift_removal
    regionmask
    contributor-guide
    api
diff --git a/pyproject.toml b/pyproject.toml
index d7296adf..58ee8369 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,7 +20,7 @@ quiet = false
 color = true
 
 [tool.isort]
-known_third_party = ["fsspec", "numpy", "pandas", "pkg_resources", "pytest", "setuptools", "xarray", "xgcm", "yaml"]
+known_third_party = ["cftime", "dask", "fsspec", "numpy", "pandas", "pkg_resources", "pytest", "setuptools", "xarray", "xarrayutils", "xgcm", "yaml"]
 
 [tool.pytest.ini_options]
 minversion = "6.0"
diff --git a/setup.cfg b/setup.cfg
index 716e5545..16847b0b 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -59,6 +59,7 @@ install_requires =
     xarray
     xgcm
     cftime
+    xarrayutils
 setup_requires=
     setuptools
     setuptools-scm


Test patch:
diff --git a/tests/test_drift_removal.py b/tests/test_drift_removal.py
new file mode 100644
index 00000000..8637d7ba
--- /dev/null
+++ b/tests/test_drift_removal.py
@@ -0,0 +1,529 @@
+import inspect
+
+import cftime
+import numpy as np
+import pytest
+import xarray as xr
+
+from cmip6_preprocessing.drift_removal import (
+    _construct_cfdate,
+    calculate_drift,
+    find_date_idx,
+    remove_trend,
+    replace_time,
+    unify_time,
+)
+
+
+# I copied this from a PR I made to parcels a while back.
+# Is there a more elegant way to parse these from cftime?
+def _get_cftime_datetimes():
+    cftime_calendars = tuple(
+        x[1].__name__ for x in inspect.getmembers(cftime._cftime, inspect.isclass)
+    )
+    cftime_datetime_names = [ca for ca in cftime_calendars if "Datetime" in ca]
+    return cftime_datetime_names
+
+
+all_cftime_calendars = [
+    getattr(cftime, cf_datetime)(1990, 1, 1).calendar
+    for cf_datetime in _get_cftime_datetimes()
+]
+
+
+@pytest.mark.parametrize("source_calendar", all_cftime_calendars)
+@pytest.mark.parametrize("target_calendar", all_cftime_calendars)
+@pytest.mark.parametrize(
+    "ref_idx, start_date",
+    [
+        (-12, "2001-01-01"),
+        (12, "1999-01-01"),
+        (1, "1999-12-01"),
+        (11, "1999-02-01"),
+        (13, "1998-12-01"),
+        (-13, "2001-02-01"),
+    ],
+)
+def test_replace_time(source_calendar, target_calendar, ref_idx, start_date):
+    nt = 10
+    timename = "time"
+    time = xr.cftime_range(
+        "2000-01-01", periods=nt, freq="1MS", calendar=source_calendar
+    )
+    ds = xr.DataArray(
+        np.random.rand(nt), dims=timename, coords={timename: time}
+    ).to_dataset(name="test")
+
+    # simply replace with a different calendar
+    time_replaced = xr.DataArray(
+        xr.cftime_range("2000-01-01", periods=nt, freq="1MS", calendar=target_calendar),
+        dims=["time"],
+    )
+    ds_replaced = replace_time(ds, calendar=target_calendar)
+    xr.testing.assert_allclose(time_replaced, ds_replaced.time)
+
+    # shift time with reference date before the actual data (e.g. for forced runs)
+    time_shifted = xr.DataArray(
+        xr.cftime_range(start_date, periods=nt, freq="1MS", calendar=target_calendar),
+        dims=["time"],
+    )
+    ds_shifted = replace_time(
+        ds, calendar=target_calendar, ref_idx=ref_idx, ref_date="2000-01-01"
+    )
+    xr.testing.assert_allclose(time_shifted, ds_shifted.time)
+
+
+def test_replace_time_error_other_freq():
+    # Check that a useful error is raised if the input frequency is not monthly
+    nt = 10
+    timename = "time"
+    time = xr.cftime_range("2000-01-01", periods=nt, freq="1MS")
+    ds = xr.DataArray(
+        np.random.rand(nt), dims=timename, coords={timename: time}
+    ).to_dataset(name="test")
+    with pytest.raises(ValueError) as einfo:
+        ds_new = replace_time(ds, freq="1DS")
+
+
+@pytest.mark.parametrize(
+    "expected_idx, strdate",
+    [(0, "2000-01-01"), (0, "2000-01-29"), (2, "2000-03-29"), (-12, "1999-01-01")],
+)
+@pytest.mark.parametrize("calendar", all_cftime_calendars)
+def test_find_date_idx(expected_idx, strdate, calendar):
+    time = xr.cftime_range("2000-01-01", periods=10, freq="1MS")
+    date = _construct_cfdate([0], f"days since {strdate}", calendar)
+    assert find_date_idx(time, date) == expected_idx
+
+
+@pytest.mark.parametrize("source_calendar", all_cftime_calendars)
+@pytest.mark.parametrize("target_calendar", all_cftime_calendars)
+def test_unify_time_simple(source_calendar, target_calendar):
+    nt = 24
+    # simplest case (same length, just different time convention)
+    time_child = xr.DataArray(
+        xr.cftime_range("2000-01-01", periods=nt, freq="1MS", calendar=source_calendar),
+        dims=["time"],
+    )
+    time_parent = xr.DataArray(
+        xr.cftime_range("1900-01-01", periods=nt, freq="1MS", calendar=target_calendar),
+        dims=["time"],
+    )
+
+    ds_child = xr.DataArray(
+        np.random.rand(12, nt),
+        dims=["x", "time"],
+        coords={"time": time_child},
+    ).to_dataset(name="test")
+
+    ds_child.attrs = {
+        "branch_time_in_parent": 0,
+        "branch_time_in_child": 0,
+        "parent_time_units": "days since 1900-01-01",
+    }
+    # this should be written when files are actually read from a file, but this is
+    # a bit dangerous. Why is the child time units not set?
+    ds_child.time.encoding["units"] = "days since 2000-01-01"
+
+    ds_parent = xr.DataArray(
+        np.random.rand(12, nt), dims=["x", "time"], coords={"time": time_parent}
+    ).to_dataset(name="test")
+
+    ds_parent_adjusted, ds_child_adjusted = unify_time(ds_parent, ds_child)
+
+    xr.testing.assert_allclose(ds_parent_adjusted.time, time_child)
+
+    ds_parent_adjusted, ds_child_adjusted = unify_time(
+        ds_parent, ds_child, adjust_to="parent"
+    )
+    xr.testing.assert_allclose(ds_child_adjusted.time, time_parent)
+
+
+@pytest.mark.parametrize("source_calendar", all_cftime_calendars)
+@pytest.mark.parametrize("target_calendar", all_cftime_calendars)
+def test_unify_time_complex(source_calendar, target_calendar):
+    nt = 24
+    nt_parent = 200
+    # more complex and common case (longer control, with starting from 0 convention)
+    time_child = xr.DataArray(
+        xr.cftime_range("2000-01-01", periods=nt, freq="1MS", calendar=source_calendar),
+        dims=["time"],
+    )
+    time_parent = xr.DataArray(
+        xr.cftime_range(
+            "0100-01-01", periods=nt_parent, freq="1MS", calendar=target_calendar
+        ),
+        dims=["time"],
+    )
+
+    ds_child = xr.DataArray(
+        np.random.rand(12, nt),
+        dims=["x", "time"],
+        coords={"time": time_child},
+    ).to_dataset(name="test")
+
+    ds_child.attrs = {
+        "branch_time_in_parent": 0,
+        "branch_time_in_child": 0,
+        "parent_time_units": "days since 0200-01-01",
+    }
+    # this should be written when files are actually read from a file, but this is
+    # a bit dangerous. Why is the child time units not set?
+    ds_child.time.encoding["units"] = "days since 2000-01-01"
+
+    ds_parent = xr.DataArray(
+        np.random.rand(12, nt_parent), dims=["x", "time"], coords={"time": time_parent}
+    ).to_dataset(name="test")
+
+    ds_parent_adjusted, ds_child_adjusted = unify_time(ds_parent, ds_child)
+
+    expected_time_parent_adjusted = xr.DataArray(
+        xr.cftime_range(
+            "1900-01-01", periods=nt_parent, freq="1MS", calendar=source_calendar
+        ),
+        dims=["time"],
+    )
+
+    xr.testing.assert_allclose(ds_parent_adjusted.time, expected_time_parent_adjusted)
+
+    ds_parent_adjusted, ds_child_adjusted = unify_time(
+        ds_parent, ds_child, adjust_to="parent"
+    )
+
+    expected_time_child_adjusted = xr.DataArray(
+        xr.cftime_range("0200-01-01", periods=nt, freq="1MS", calendar=target_calendar),
+        dims=["time"],
+    )
+    xr.testing.assert_allclose(ds_child_adjusted.time, expected_time_child_adjusted)
+
+
+def test_unify_time_missing_attr_warning():
+    nt = 24
+    # simplest case (same length, just different time convention)
+    time_child = xr.cftime_range("2000-01-01", periods=nt, freq="1MS")
+    time_parent = xr.cftime_range("1200-01-01", periods=nt, freq="1MS")
+
+    ds_child = xr.DataArray(
+        np.random.rand(12, nt), dims=["x", "time"], coords={"time": time_child}
+    )
+    ds_parent = xr.DataArray(
+        np.random.rand(12, nt), dims=["x", "time"], coords={"time": time_parent}
+    )
+    with pytest.warns(UserWarning):
+        ds_parent_adjusted, ds_child_adjusted = unify_time(ds_parent, ds_child)
+    xr.testing.assert_equal(ds_parent, ds_parent_adjusted)
+    xr.testing.assert_equal(ds_child, ds_child_adjusted)
+
+
+def test_unify_time_adjust_to_error():
+    nt = 24
+    # simplest case (same length, just different time convention)
+    time_child = xr.DataArray(
+        xr.cftime_range("2000-01-01", periods=nt, freq="1MS"),
+        dims=["time"],
+    )
+    time_parent = xr.DataArray(
+        xr.cftime_range("1900-01-01", periods=nt, freq="1MS"),
+        dims=["time"],
+    )
+
+    ds_child = xr.DataArray(
+        np.random.rand(12, nt),
+        dims=["x", "time"],
+        coords={"time": time_child},
+    ).to_dataset(name="test")
+
+    ds_child.attrs = {
+        "branch_time_in_parent": 0,
+        "branch_time_in_child": 0,
+        "parent_time_units": "days since 1900-01-01",
+    }
+    # this should be written when files are actually read from a file, but this is
+    # a bit dangerous. Why is the child time units not set?
+    ds_child.time.encoding["units"] = "days since 2000-01-01"
+
+    ds_parent = xr.DataArray(
+        np.random.rand(12, nt), dims=["x", "time"], coords={"time": time_parent}
+    ).to_dataset(name="test")
+    with pytest.raises(ValueError):
+        ds_parent_adjusted, ds_child_adjusted = unify_time(
+            ds_parent, ds_child, adjust_to="nonsense"
+        )
+
+
+@pytest.mark.parametrize("chunk", [False, {"time": 2}])
+def test_remove_trend(chunk):
+
+    # normal testing
+    time = xr.cftime_range("1850-01-01", periods=5, freq="1AS")
+    data = xr.DataArray(
+        np.random.rand(3, 4, len(time)),
+        dims=["x", "y", "time"],
+        coords={"time": time},
+        attrs={"just_some": "test"},
+    )
+    if chunk:
+        data = data.chunk(chunk)
+    slope = xr.DataArray(np.random.rand(3, 4), dims=["x", "y"])
+
+    ref_date = str(time[0])
+    dummy_time = xr.DataArray(np.arange(len(time)), dims=["time"])
+
+    sloped_data = data + (slope * dummy_time)
+    sloped_data.attrs = data.attrs
+
+    sloped_data = sloped_data.to_dataset(name="test")
+    slope = slope.to_dataset(name="test")
+    time_range = xr.DataArray(
+        [
+            "test_start",
+            "test_stop",
+        ],
+        dims="bnds",
+    )
+    slope = slope.assign_coords(trend_time_range=time_range)
+
+    detrended = remove_trend(sloped_data, slope, "test", ref_date)
+    xr.testing.assert_allclose(data, detrended)
+    for att in data.attrs.keys():
+        assert detrended.attrs[att] == data.attrs[att]
+
+    assert (
+        detrended.attrs["drift_removed"]
+        == "linear_trend_none.none.none.none.none.none.none.none_test_start_test_stop"
+    )
+
+    # test the additional output when the slope input does not have sufficient information
+
+    with pytest.warns(UserWarning) as winfo:
+        detrended = remove_trend(
+            sloped_data, slope.drop("trend_time_range"), "test", ref_date
+        )
+    assert (
+        detrended.attrs["drift_removed"]
+        == "linear_trend_none.none.none.none.none.none.none.none_not-available_not-available"
+    )
+
+
+@pytest.mark.parametrize("chunk", [False, {"time": 2}])
+def test_remove_trend_mask_check(chunk):
+
+    time = xr.cftime_range("1850-01-01", periods=5, freq="1AS")
+    data = xr.DataArray(
+        np.random.rand(3, 4, len(time)), dims=["x", "y", "time"], coords={"time": time}
+    )
+
+    slope = xr.DataArray(
+        np.random.rand(3, 4), dims=["x", "y"], attrs={"reference_year": str(time[0])}
+    )
+
+    slope[0, 0] = np.nan
+
+    ref_date = str(time[0])
+    with pytest.raises(ValueError):
+        remove_trend(data, slope, "test", ref_date)
+
+
+@pytest.mark.parametrize("chunk", [False, {"time": 2}])
+def test_remove_trend_exceptions(chunk):
+
+    # normal testing
+    time = xr.cftime_range("1850-01-01", periods=5, freq="1AS")
+    data = xr.DataArray(
+        np.random.rand(3, 4, len(time)),
+        dims=["x", "y", "time"],
+        coords={"time": time},
+        attrs={"just_some": "test"},
+    )
+    slope = xr.DataArray(np.random.rand(3, 4), dims=["x", "y"])
+
+    ref_date = str(time[0])
+    dummy_time = xr.DataArray(np.arange(len(time)), dims=["time"])
+    with pytest.raises(ValueError) as einfo:
+        remove_trend(data, slope.to_dataset(name="test"), "test", ref_date)
+    assert str(einfo.value) == "`ds` input needs to be a dataset"
+
+    with pytest.raises(ValueError) as einfo:
+        remove_trend(data.to_dataset(name="test"), slope, "test", ref_date)
+    assert str(einfo.value) == "`ds_slope` input needs to be a dataset"
+
+
+def test_calculate_drift_missing_attrs():
+    # error if no attr are given
+    ds_control = xr.DataArray([0]).to_dataset(name="test")
+    ds = xr.DataArray([0]).to_dataset(name="test")
+    with pytest.raises(ValueError) as einfo:
+        calculate_drift(ds_control, ds, "test", trend_years=250)
+    assert "in attributes of `ds`." in str(einfo.value)
+
+    # error for attrs mismatch
+    ds.attrs = {
+        "source_id": "a",
+        "variant_label": "b",
+        "branch_time_in_parent": 0,
+        "parent_time_units": "something",
+        "parent_variant_label": "a",
+        "parent_source_id": "a",
+    }
+
+    ds_control.attrs = {
+        "source_id": "a",
+        "variant_label": "b",
+    }
+
+    with pytest.raises(ValueError) as einfo:
+        calculate_drift(ds_control, ds, "test", trend_years=250)
+    assert (
+        str(einfo.value)
+        == "`ds_parent` variant_label (b) not compatible with `ds` parent_variant_label (a)"
+    )
+
+
+@pytest.mark.parametrize("trend_years", [1, 5, 10])
+def test_calculate_drift(trend_years):
+    # error if no attr are given
+    nx, ny = (10, 20)
+    nt_control = 3000
+    nt = 24
+    time_control = xr.cftime_range("0100-01-01", periods=nt_control, freq="1MS")
+    time_ds = xr.cftime_range("2000-01-01", periods=nt, freq="1MS")
+
+    ds_control = xr.DataArray(
+        np.random.rand(nx, ny, nt_control),
+        dims=["x", "y", "time"],
+        coords={"time": time_control},
+    ).to_dataset(name="test")
+
+    ds = xr.DataArray(
+        np.random.rand(nx, ny, nt),
+        dims=["x", "y", "time"],
+        coords={"time": time_ds},
+    ).to_dataset(name="test")
+
+    ds.attrs = {
+        "source_id": "a",
+        "variant_label": "a",
+        "branch_time_in_parent": 0,
+        "parent_time_units": "days since 0105-01-01",
+        "parent_variant_label": "a",
+        "parent_source_id": "a",
+    }
+
+    ds_control.attrs = {
+        "source_id": "a",
+        "variant_label": "a",
+    }
+
+    reg = calculate_drift(ds_control, ds, "test", trend_years=trend_years)
+
+    # use times from the output to cut control and manually calculate expected values
+    start = reg.trend_time_range.isel(bnds=0).data.tolist()
+    stop = reg.trend_time_range.isel(bnds=1).data.tolist()
+
+    # Need to replace the time with an index to ensure the units of the drift are in ../month.
+    ds_control_expected_normed = ds_control.sel(time=slice(start, stop))
+    ds_control_expected_normed = ds_control_expected_normed.assign_coords(
+        time=np.arange(len(ds_control_expected_normed.time))
+    )
+
+    reg_expected = (
+        (
+            ds_control_expected_normed.test.polyfit("time", 1)
+            .sel(degree=1)
+            .polyfit_coefficients
+        )
+        .drop(["x", "y", "degree"])
+        .squeeze()
+    )
+
+    xr.testing.assert_allclose(reg_expected, reg.test)
+    assert reg.attrs == ds.attrs
+
+    # TODO: Assert the correct time limits in the coords
+
+
+def test_calculate_drift_exceptions():
+    # error if no attr are given
+    nx, ny = (10, 20)
+    nt_control = 30
+    nt = 24
+    time_control = xr.cftime_range("0100-01-01", periods=nt_control, freq="1MS")
+    time_ds = xr.cftime_range("2000-01-01", periods=nt, freq="1MS")
+
+    ds_control = xr.DataArray(
+        np.random.rand(nx, ny, nt_control),
+        dims=["x", "y", "time"],
+        coords={"time": time_control},
+    ).to_dataset(name="test")
+
+    ds = xr.DataArray(
+        np.random.rand(nx, ny, nt),
+        dims=["x", "y", "time"],
+        coords={"time": time_ds},
+    ).to_dataset(name="test")
+
+    ds.attrs = {
+        "source_id": "a",
+        "variant_label": "a",
+        "branch_time_in_parent": 0,
+        "parent_time_units": "days since 0605-01-01",
+        "parent_variant_label": "a",
+        "parent_source_id": "a",
+    }
+
+    ds_control.attrs = {
+        "source_id": "a",
+        "variant_label": "a",
+    }
+    with pytest.raises(RuntimeError) as einfo:
+        reg = calculate_drift(ds_control, ds, "test")
+    assert (
+        str(einfo.value)
+        == "Selecting from `reference` according to the branch time resulted in empty dataset. Check the metadata."
+    )
+
+
+def test_calculate_drift_exceptions_partial():
+    # error if no attr are given
+    nx, ny = (10, 20)
+    nt_control = 24
+    nt = 24
+    time_control = xr.cftime_range("0100-01-01", periods=nt_control, freq="1MS")
+    time_ds = xr.cftime_range("2000-01-01", periods=nt, freq="1MS")
+
+    ds_control = xr.DataArray(
+        np.random.rand(nx, ny, nt_control),
+        dims=["x", "y", "time"],
+        coords={"time": time_control},
+    ).to_dataset(name="test")
+
+    ds = xr.DataArray(
+        np.random.rand(nx, ny, nt),
+        dims=["x", "y", "time"],
+        coords={"time": time_ds},
+    ).to_dataset(name="test")
+
+    ds.attrs = {
+        "source_id": "a",
+        "variant_label": "a",
+        "branch_time_in_parent": 0,
+        "parent_time_units": "days since 0101-01-01",
+        "parent_variant_label": "a",
+        "parent_source_id": "a",
+    }
+
+    ds_control.attrs = {
+        "source_id": "a",
+        "variant_label": "a",
+    }
+    with pytest.raises(RuntimeError) as einfo:
+        reg = calculate_drift(ds_control, ds, "test")
+    assert (
+        "Set `calculate_short_trend=True` to compute from a shorter timeseries"
+        in str(einfo.value)
+    )
+    # TODO: Assert the correct time limits in the attrs
+
+    with pytest.warns(UserWarning) as winfo:
+        reg = calculate_drift(ds_control, ds, "test", compute_short_trends=True)
+    assert "years to calculate trend. Using 1 years only" in winfo[0].message.args[0]
diff --git a/tests/test_postprocessing.py b/tests/test_postprocessing.py
index 922d928f..c0e3a98f 100644
--- a/tests/test_postprocessing.py
+++ b/tests/test_postprocessing.py
@@ -78,7 +78,7 @@ def test_parse_metric_exceptions_input_name():
         ds_parsed = _parse_metric(ds, da_metric_nameless)
     assert (
         warninfo[0].message.args[0]
-        == "a.none.none.none.none.none.none:`metric` has no name. This might lead to problems down the line."
+        == "a.none.none.none.none.none.none.none:`metric` has no name. This might lead to problems down the line."
     )
 
 
@@ -96,7 +96,7 @@ def test_parse_metric_exception_dim_length():
         ds_parsed = _parse_metric(
             ds, ds_metric.isel(x=slice(0, -1), y=slice(1, None))[metricname]
         )
-    msg = "a.none.none.none.none.g.none:`metric` dimensions ['x:2', 'y:1'] do not match `ds` ['x:3', 'y:2']."
+    msg = "a.none.none.none.none.none.g.none:`metric` dimensions ['x:2', 'y:1'] do not match `ds` ['x:3', 'y:2']."
     assert execinfo.value.args[0] == msg
 
 
@@ -123,7 +123,7 @@ def test_parse_metric_dim_alignment():
 
     xr.testing.assert_allclose(ds_parsed.time, ds_metric.time)
 
-    msg = "a.none.none.none.none.g.none:`metric` dimensions ['time:5'] do not match `ds` ['time:6']. Aligning the data on `inner`"
+    msg = "a.none.none.none.none.none.g.none:`metric` dimensions ['time:5'] do not match `ds` ['time:6']. Aligning the data on `inner`"
     assert warninfo[0].message.args[0] == msg
 
 
@@ -338,7 +338,7 @@ def test_match_metrics_align_dims():
             print_statistics=True,
             dim_length_conflict="align",
         )
-    msg = "none.none.a.a.a.a.a:`metric` dimensions ['time:5'] do not match `ds` ['time:6']. Aligning the data on `inner`"
+    msg = "none.none.a.a.a.a.a.a:`metric` dimensions ['time:5'] do not match `ds` ['time:6']. Aligning the data on `inner`"
     assert warninfo[0].message.args[0] == msg
 
     xr.testing.assert_allclose(ddict_matched["a"].time, ds_metric.time)
diff --git a/tests/test_utils.py b/tests/test_utils.py
index dc1e4672..44e0ad17 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -57,13 +57,14 @@ def test_cmip6_dataset_id():
         "activity_id": "ai",
         "institution_id": "ii",
         "source_id": "si",
+        "variant_label": "vl",
         "experiment_id": "ei",
         "table_id": "ti",
         "grid_label": "gl",
     }
 
-    assert cmip6_dataset_id(ds) == "ai.ii.si.ei.ti.gl.none"
-    assert cmip6_dataset_id(ds, sep="_") == "ai_ii_si_ei_ti_gl_none"
+    assert cmip6_dataset_id(ds) == "ai.ii.si.ei.vl.ti.gl.none"
+    assert cmip6_dataset_id(ds, sep="_") == "ai_ii_si_ei_vl_ti_gl_none"
     assert (
         cmip6_dataset_id(ds, id_attrs=["grid_label", "activity_id", "wrong_attrs"])
         == "gl.ai.none"