diff --git a/15-ENSO_diversity.ipynb b/15-ENSO_diversity.ipynb index e3b8d27..d8c8337 100644 --- a/15-ENSO_diversity.ipynb +++ b/15-ENSO_diversity.ipynb @@ -23,16 +23,358 @@ "- **NCEP2 (1979–2018)**: A second-generation reanalysis from NCEP that improves upon earlier reanalysis products and offers global atmospheric and surface data. " ] }, + { + "cell_type": "markdown", + "id": "0e694ef5-b014-4e98-a2c6-6d069cb669d3", + "metadata": {}, + "source": [ + "## Dask Cluster \n", + "\n", + "Start a cluster with multiple cores " + ] + }, { "cell_type": "code", "execution_count": 1, + "id": "dfdb2537-52da-47a8-8051-fee717c87adf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Client

\n", + "

Client-a89a9713-edb4-11ef-8802-00000183fe80

\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
Connection method: Cluster objectCluster type: distributed.LocalCluster
\n", + " Dashboard: /proxy/8787/status\n", + "
\n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "

Cluster Info

\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

LocalCluster

\n", + "

3a0aa1be

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + "
\n", + " Dashboard: /proxy/8787/status\n", + " \n", + " Workers: 4\n", + "
\n", + " Total threads: 12\n", + " \n", + " Total memory: 46.00 GiB\n", + "
Status: runningUsing processes: True
\n", + "\n", + "
\n", + " \n", + "

Scheduler Info

\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

Scheduler

\n", + "

Scheduler-9b7a6118-81d8-49f0-b288-00bda3581da7

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Comm: tcp://127.0.0.1:46173\n", + " \n", + " Workers: 4\n", + "
\n", + " Dashboard: /proxy/8787/status\n", + " \n", + " Total threads: 12\n", + "
\n", + " Started: Just now\n", + " \n", + " Total memory: 46.00 GiB\n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "

Workers

\n", + "
\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 0

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:41387\n", + " \n", + " Total threads: 3\n", + "
\n", + " Dashboard: /proxy/33427/status\n", + " \n", + " Memory: 11.50 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:34553\n", + "
\n", + " Local directory: /jobfs/135541908.gadi-pbs/dask-scratch-space/worker-op46eqwa\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 1

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:33117\n", + " \n", + " Total threads: 3\n", + "
\n", + " Dashboard: /proxy/35387/status\n", + " \n", + " Memory: 11.50 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:40337\n", + "
\n", + " Local directory: /jobfs/135541908.gadi-pbs/dask-scratch-space/worker-4jvxmsan\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 2

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:38293\n", + " \n", + " Total threads: 3\n", + "
\n", + " Dashboard: /proxy/36333/status\n", + " \n", + " Memory: 11.50 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:42425\n", + "
\n", + " Local directory: /jobfs/135541908.gadi-pbs/dask-scratch-space/worker-t_b8_lpv\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 3

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:34375\n", + " \n", + " Total threads: 3\n", + "
\n", + " Dashboard: /proxy/42859/status\n", + " \n", + " Memory: 11.50 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:41597\n", + "
\n", + " Local directory: /jobfs/135541908.gadi-pbs/dask-scratch-space/worker-eft2i9tr\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dask.distributed import Client, progress\n", + "client = Client()\n", + "client" + ] + }, + { + "cell_type": "markdown", + "id": "9adc99f1-de29-4e08-969f-23908ef4db1a", + "metadata": {}, + "source": [ + "## Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "03ca2b4d-aa80-4b22-86e1-bb668f4c832e", "metadata": { "scrolled": true }, "outputs": [], "source": [ - "from esmvalcore.config import CFG\n", "from esmvalcore.dataset import Dataset" ] }, @@ -46,102 +388,117 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "0d112937-acb8-40c7-8fda-24779cd4c46d", + "execution_count": 21, + "id": "0e0aefb0-234b-4d6a-98be-8564d468e635", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "obs = Dataset(\n", - " short_name='tos',\n", - " dataset='NOAA-ERSSTv5',\n", - " mip=\"Omon\",\n", - " project='OBS6',\n", + "model_datasets = {\n", + "\"ACCESS-CM2\": \n", + " Dataset(\n", + " short_name='ts',\n", + " project='CMIP6',\n", + " mip=\"Amon\",\n", + " exp=\"historical\",\n", + " ensemble=\"r1i1p1f1\",\n", + " timerange=\"19000101/20190101\",\n", + " dataset=\"ACCESS-CM2\",\n", + " grid=\"gn\"\n", + ")}\n", + "\n", + "obs_datasets = {\n", + "\"HadISST\": \n", + " Dataset(\n", + " short_name='ts',\n", + " dataset='HadISST',\n", + " mip=\"Amon\",\n", + " project='OBS',\n", " type='reanaly',\n", - " timerange=\"1900/2019\",\n", - " tier=2)\n", - "# list(obs.from_files())\n", - "len(obs.files)" + " tier=2),\n", + "# \"ERSSTv5\":\n", + "# Dataset(\n", + "# short_name='tos',\n", + "# dataset='NOAA-ERSSTv5',\n", + "# mip=\"Omon\",\n", + "# project='OBS6',\n", + "# type='reanaly',\n", + "# tier=2),\n", + "# \"ERA-Interim\": \n", + "# Dataset(\n", + "# short_name='tos',\n", + "# dataset='ERA-Interim',\n", + "# mip=\"Omon\",\n", + "# project='OBS6',\n", + "# type='reanaly',\n", + "# timerange=\"19790101/20190101\",\n", + "# tier=3)\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "a1adc46e-b9bb-4a5b-acf6-c3fdb0bed0ba", + "metadata": {}, + "source": [ + "## Add Ancillary files\n" ] }, { "cell_type": "code", - "execution_count": 4, - "id": "6c57f395-5f5a-47ec-a714-99d191ec22c6", - "metadata": { - "scrolled": true - }, + "execution_count": 22, + "id": "cce89e9d-72ee-401c-b4ed-ab745992b1a8", + "metadata": {}, + "outputs": [], + "source": [ + "for name, dataset in model_datasets.items():\n", + " dataset.add_supplementary(short_name='sftlf', mip=\"fx\")\n", + " dataset.add_supplementary(short_name=\"areacella\", mip=\"fx\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ba7e62d3-98f3-4fa9-b1f4-ff529d93617d", + "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "([LocalFile('/g/data/fs38/publications/CMIP6/CMIP/CSIRO-ARCCSS/ACCESS-CM2/historical/r1i1p1f1/Omon/tos/gn/v20191108/tos_Omon_ACCESS-CM2_historical_r1i1p1f1_gn_185001-201412.nc')],\n", - " [LocalFile('/g/data/fs38/publications/CMIP6/CMIP/CSIRO-ARCCSS/ACCESS-CM2/historical/r1i1p1f1/Ofx/areacello/gn/v20191108/areacello_Ofx_ACCESS-CM2_historical_r1i1p1f1_gn.nc')])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:esmvalcore.cmor._fixes.fix.genericfix:Long name changed from 'Percentage of the grid cell occupied by land (including lakes)' to 'Percentage of the Grid Cell Occupied by Land (Including Lakes)'\n", + "(for file /g/data/fs38/publications/CMIP6/CMIP/CSIRO-ARCCSS/ACCESS-CM2/historical/r1i1p1f1/fx/sftlf/gn/v20191108/sftlf_fx_ACCESS-CM2_historical_r1i1p1f1_gn.nc)\n" + ] } ], "source": [ - "## model\n", - "var = Dataset(\n", - " short_name='tos',\n", - " mip='Omon',\n", - " project='CMIP6',\n", - " activity='CMIP',\n", - " dataset='ACCESS-CM2',\n", - " ensemble='r1i1p1f1',\n", - " institute='*',\n", - " grid='*',\n", - " exp='historical',\n", - " # timerange='1979/2019',\n", - " # derive='true'\n", - ")\n", - "\n", - "var_noarea = var.copy()\n", - "\n", - "var.add_supplementary(short_name='areacello', mip='Ofx')\n", - "var.find_files()\n", - "# list(var.from_files())[0].files\n", - "var.files,var.supplementaries[0].files\n" + "model_datasets = {name: dataset.load() for name, dataset in model_datasets.items()}\n", + "obs_datasets = {name: dataset.load() for name, dataset in obs_datasets.items()}" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "300de51c", - "metadata": { - "scrolled": true - }, + "execution_count": 6, + "id": "b07c8086-b740-490f-96d9-e0521b464bbc", + "metadata": {}, "outputs": [], "source": [ - "import iris\n", - "from esmvalcore.preprocessor import (\n", - " detrend, # dimension, method, \n", - " meridional_statistics, # \n", - " zonal_statistics,\n", - " area_statistics,\n", - " regrid, #esmf bilinear\n", - " mask_landsea,\n", - " anomalies,\n", - " extract_month, \n", - " mask_inside_range, mask_above_threshold, mask_below_threshold,\n", - " extract_region, # equatorial pacific #1 - 150°E-90°W, zonal 5°S-5°N average\n", - " climate_statistics,# month mean, standard deviation\n", - " rolling_window_statistics) \n", + "from esmvalcore.preprocessor import detrend # Remove trends from the data\n", + "from esmvalcore.preprocessor import meridional_statistics # Calculate statistics along meridional direction\n", + "from esmvalcore.preprocessor import zonal_statistics # Calculate statistics along zonal direction\n", + "from esmvalcore.preprocessor import area_statistics # Compute area-based statistics\n", + "from esmvalcore.preprocessor import regrid # Regrid data using ESMF bilinear method\n", + "from esmvalcore.preprocessor import mask_landsea # Mask land or sea regions\n", + "from esmvalcore.preprocessor import anomalies # Compute anomalies in the data\n", + "from esmvalcore.preprocessor import extract_month # Extract specific month from the data\n", + "from esmvalcore.preprocessor import extract_time\n", + "from esmvalcore.preprocessor import mask_inside_range # Mask values inside a specified range\n", + "from esmvalcore.preprocessor import mask_above_threshold # Mask values above a specified threshold\n", + "from esmvalcore.preprocessor import mask_below_threshold # Mask values below a specified threshold\n", + "from esmvalcore.preprocessor import extract_region # Extract a specific geographical region (e.g., Equatorial Pacific)\n", + "from esmvalcore.preprocessor import climate_statistics # Compute month mean and standard deviation\n", + "from esmvalcore.preprocessor import rolling_window_statistics # Apply rolling window statistics\n", "\n", + "import iris\n", "import numpy as np\n", "import iris.quickplot as qplt\n", "import matplotlib.pyplot as plt\n", @@ -153,50 +510,45 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "784947b3-b662-479a-8a4f-56432f77d324", "metadata": { "scrolled": true }, "outputs": [], "source": [ - "## \n", "def nino3_4ssta(cube):\n", " cube = extract_region(cube, 190, 240, -5, 5) #\n", - " # cube = regrid(cube, target_grid=\"1x1\", scheme=\"linear\") \n", - " \n", + " cube = extract_time(cube, start_year=1900, start_month=1, start_day=1, end_year=2014, end_month=12, end_day=31) \n", + " cube = regrid(cube, target_grid=\"1x1\", scheme=\"linear\") \n", " # triangle weighted- double smoothed\n", " cube = rolling_window_statistics(cube, coordinate='time', operator='mean', window_length=5)\n", " cube = rolling_window_statistics(cube, coordinate='time', operator='mean', window_length=5)\n", - " \n", " cube = area_statistics(cube, 'mean')\n", " cube = extract_month(cube, 12)\n", " cube = anomalies(cube, period='monthly', standardize=True) #normalise\n", - " \n", " return cube\n", "\n", "def eq_ssta(cube):\n", " cube = extract_region(cube, 150, 270, -5, 5)\n", + " cube = extract_time(cube, start_year=1900, start_month=1, start_day=1, end_year=2014, end_month=12, end_day=31) \n", " # season cycle? detrend? #convert units\n", " cube = rolling_window_statistics(cube, coordinate='time', operator='mean', window_length=5)\n", " cube = rolling_window_statistics(cube, coordinate='time', operator='mean', window_length=5)\n", " cube = extract_month(cube, 12)\n", - " cube = anomalies(cube,period='monthly')\n", + " cube = anomalies(cube, period='monthly')\n", " cube = regrid(cube, target_grid=\"1x1\", scheme=\"linear\") \n", - " \n", " cube = meridional_statistics(cube, 'mean') #\n", " # weighted running average 5-degree\n", " cube = rolling_window_statistics(cube, coordinate='longitude', operator='mean', window_length=5)\n", " cube = rolling_window_statistics(cube, coordinate='longitude', operator='mean', window_length=5)\n", " return cube\n", "\n", - "\n", "def enso_events(cube):\n", - " # mean, std = cube.data.mean(), cube.data.std() #normalised, use 0.75\n", + " mean, std = cube.data.mean(), cube.data.std() #normalised, use 0.75\n", " # range1, range2 = mean-0.75*std, mean + 0.75*std \n", - " \n", - " a_events = mask_to_years(mask_above_threshold(cube.copy(), -0.75))\n", - " o_events = mask_to_years(mask_below_threshold(cube.copy(), 0.75))\n", + " a_events = mask_to_years(mask_above_threshold(cube.copy(), -0.75*std))\n", + " o_events = mask_to_years(mask_below_threshold(cube.copy(), 0.75*std))\n", " return {'nina':a_events, 'nino':o_events}\n", "\n", "def mask_to_years(events):\n", @@ -223,25 +575,31 @@ " loc_ls.append(cube.coord('longitude').points[indx])\n", "\n", " res_lon[enso] = loc_ls\n", - "\n", + " \n", + " res_lon['enso'] = res_lon['nino'] + res_lon['nina']\n", " return res_lon # return data to plot \n", "\n", "# IQR and abs((model-ref)/ref)*100\n", "def iqr(data):\n", " #calculate interquartile range \n", " q3, q1 = np.percentile(data, [75 ,25])\n", - " print(q3, q1)\n", " iqr = q3 - q1\n", " return iqr\n", " \n", "def compute(obs_iqr, mod_iqr):\n", - " return abs((mod_iqr-obs_iqr)/obs_iqr)*100" + " return abs((mod_iqr-obs_iqr)/obs_iqr)*100\n", + "\n", + "def preproc(dataset):\n", + " nino_res = nino3_4ssta(dataset)\n", + " events = enso_events(nino_res)\n", + " eq_res = eq_ssta(dataset)\n", + " return eq_res, events\n" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "2302a678-63e9-4fb2-8eb1-e702ff6213f2", + "execution_count": 24, + "id": "c4045a52-2fe8-405f-9f4d-3c7820557959", "metadata": {}, "outputs": [ { @@ -250,14 +608,6 @@ "text": [ "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/cube.py:4620: IrisIgnoringBoundsWarning: The bounds of coordinate 'time' were ignored in the rolling window operation.\n", " warnings.warn(\n", - "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/coords.py:2153: IrisVagueMetadataWarning: Cannot check if coordinate is contiguous: Invalid operation for 'cell index along second dimension', with 0 bound(s). Contiguous bounds are only defined for 1D coordinates with 2 bounds. Metadata may not be fully descriptive for 'cell index along second dimension'. Ignoring bounds.\n", - " warnings.warn(\n", - "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/coords.py:2153: IrisVagueMetadataWarning: Cannot check if coordinate is contiguous: Invalid operation for 'cell index along first dimension', with 0 bound(s). Contiguous bounds are only defined for 1D coordinates with 2 bounds. Metadata may not be fully descriptive for 'cell index along first dimension'. Ignoring bounds.\n", - " warnings.warn(\n", - "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/coords.py:2140: IrisVagueMetadataWarning: Collapsing a multi-dimensional coordinate. Metadata may not be fully descriptive for 'latitude'.\n", - " warnings.warn(\n", - "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/coords.py:2140: IrisVagueMetadataWarning: Collapsing a multi-dimensional coordinate. Metadata may not be fully descriptive for 'longitude'.\n", - " warnings.warn(\n", "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/numpy/ma/core.py:5417: RuntimeWarning: Degrees of freedom <= 0 for slice\n", " ret = super().var(axis=axis, dtype=dtype, out=out, ddof=ddof,\n", "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/numpy/core/_methods.py:195: RuntimeWarning: invalid value encountered in divide\n", @@ -269,16 +619,20 @@ "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/cube.py:4620: IrisIgnoringBoundsWarning: The bounds of coordinate 'longitude' were ignored in the rolling window operation.\n", " warnings.warn(\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "245.5 219.0\n", - "ACCESS-CM2 enso IQR: 26.5\n", - "245.5 219.0\n" - ] - }, + } + ], + "source": [ + "model_datasets_prep = {name: preproc(dataset) for name, dataset in model_datasets.items()}\n", + "\n", + "model_datasets_res = {name: diversity(*preprocs) for name, preprocs in model_datasets_prep.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "c07ece66-8d9c-41d8-bf84-789461a38985", + "metadata": {}, + "outputs": [ { "name": "stderr", "output_type": "stream", @@ -290,47 +644,37 @@ "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/numpy/core/_methods.py:195: RuntimeWarning: invalid value encountered in divide\n", " ret = um.true_divide(\n", "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/cube.py:4620: IrisIgnoringBoundsWarning: The bounds of coordinate 'time' were ignored in the rolling window operation.\n", + " warnings.warn(\n", + "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/cube.py:4067: IrisUserWarning: Collapsing spatial coordinate 'latitude' without weighting\n", + " warnings.warn(\n", + "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/cube.py:4620: IrisIgnoringBoundsWarning: The bounds of coordinate 'longitude' were ignored in the rolling window operation.\n", " warnings.warn(\n" ] - }, + } + ], + "source": [ + "obs_datasets_prep = {name: preproc(dataset) for name, dataset in obs_datasets.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "cd9c6341-575e-44d8-afcb-f461b18923ae", + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "235.5 194.5\n", - "NOAA-ERSSTv5 enso IQR: 41.0\n", - "235.5 194.5\n", - "metric: 35.36585365853659\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/cube.py:4067: IrisUserWarning: Collapsing spatial coordinate 'latitude' without weighting\n", - " warnings.warn(\n", - "/g/data/xp65/public/apps/med_conda/envs/esmvaltool-0.4/lib/python3.11/site-packages/iris/cube.py:4620: IrisIgnoringBoundsWarning: The bounds of coordinate 'longitude' were ignored in the rolling window operation.\n", - " warnings.warn(\n" + "metric: 58.69565217391305\n" ] } ], "source": [ - "datasets = [var, obs]\n", - "\n", - "#plot 1\n", - "process = {}\n", - "metric = []\n", - "for ds in datasets:\n", - " nino_res = nino3_4ssta(ds.load())\n", - " events = enso_events(nino_res)\n", - "\n", - " eq_res = eq_ssta(ds.load())\n", - " results_lon = diversity(eq_res, events)\n", - " results_lon['enso'] = results_lon['nino'] + results_lon['nina']\n", - " print(ds['dataset'], 'enso IQR:', iqr(results_lon['enso'])) \n", - " process[ds['dataset']] = results_lon\n", - " metric.append(iqr(results_lon['enso']))#plot with label\n", + "obs_datasets_res = {name: diversity(*preprocs) for name, preprocs in obs_datasets_prep.items()}\n", "\n", + "metric = [iqr(model_datasets_res[\"ACCESS-CM2\"]['enso']), \n", + " iqr(obs_datasets_res[\"HadISST\"]['enso'])]\n", "print('metric: ', compute(metric[1],metric[0]))" ] }, @@ -346,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 27, "id": "ae5d0b8e-bf8f-4440-bf0e-9457f5dbc7f4", "metadata": {}, "outputs": [ @@ -356,13 +700,13 @@ "Text(0.75, 0.8, '* observation')" ] }, - "execution_count": 9, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -410,13 +754,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 28, "id": "945b214c-b5b0-402e-b9a3-273eac8cefac", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -434,13 +778,14 @@ " else:\n", " return f'{int(x)}°E'\n", "\n", - "\n", + "ds_labels = ['ACCESS-CM2','HadISST']\n", "fig = plt.figure(figsize=(20, 7))\n", - "nina = [process[ds]['nina'] for ds in process.keys()] # subplots for nina and nino\n", - "nino = [process[ds]['nino'] for ds in process.keys()]\n", + "nina = [model_datasets_res[\"ACCESS-CM2\"]['nina'], obs_datasets_res[\"HadISST\"]['nina']] # subplots for nina and nino\n", + "nino = [model_datasets_res[\"ACCESS-CM2\"]['nino'], obs_datasets_res[\"HadISST\"]['nino']]\n", + "#another plot for enso = [process[ds]['enso'] for ds in process.keys()]\n", "\n", "ax1 = plt.subplot(121)\n", - "bplt = ax1.boxplot(nina, labels=process.keys(), showmeans=True)\n", + "bplt = ax1.boxplot(nina, labels=ds_labels, showmeans=True)\n", "#check whiskers to 10th 90th percentile,, whis=(5,95) box-25th to 75th, diamond mean\n", "\n", "for k in bplt.keys():\n", @@ -458,7 +803,7 @@ "plt.grid(linestyle='--', axis='y')\n", "\n", "ax1 = plt.subplot(122)\n", - "bplt = ax1.boxplot(nino, labels=process.keys(), showmeans=True) # whis=(10,90),\n", + "bplt = ax1.boxplot(nino, labels=ds_labels, showmeans=True) # whis=(10,90),\n", "for k in bplt.keys():\n", " plt.setp(bplt[k], linewidth=2)\n", "plt.title('El Nino diversity')\n", @@ -467,6 +812,36 @@ "plt.gca().yaxis.set_major_formatter(plt.FuncFormatter(format_longitude))" ] }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f7a5a5d4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAGxCAYAAACtEoj/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABRDElEQVR4nO3deVzU1f4/8NfMMAw7Asq+CGriLooL4E0x9wW1xbTrBtxMK5fcu7l13dBrWlIumWKaS5limV5ziZEMtFzI3BATU1lywVgUWWbO7w+/fH6OLM5HIQZ8PR+PedzmfM6ceR/nIi/P58znoxBCCBARERGR0ZTVXQARERFRTcMARURERCQTAxQRERGRTAxQRERERDIxQBERERHJxABFREREJBMDFBEREZFMDFBEREREMjFAEREREcnEAEVET23Dhg1QKBTlPrRardS3fv36UCgUGDNmTKlxtFotFAoFvv76a4P2Y8eOYdCgQfD29oZGo4GLiwuCgoIwefLkUmMUFRVh1apVCAoKgr29PSwtLdGkSRPMmDEDt2/ffqp5jho1CvXr1zdoUygUmDt37lONW5Xmzp0LhUJh0LZy5Ups2LChegoiqiXMqrsAIqo9YmJi4O/vX6q9adOmpdrWrVuHd955B40bN65wzD179iAsLAxdunTBkiVL4ObmhoyMDBw/fhzbtm3DBx98IPW9d+8e+vTpgyNHjmD06NGYNWsWLC0tkZiYiKVLl2LLli04cODAY99TjsTERHh6elbaeJXtX//6F3r16mXQtnLlStStWxejRo2qnqKIagEGKCKqNM2bN0dgYOBj+wUFBeHcuXP497//jR07dlTYd8mSJfD19cX3338PM7P//1fWkCFDsGTJEoO+77zzDg4fPoxt27bh1VdfldpDQ0Px8ssvo3379njppZfw66+/QqVSyZxd2Tp27Fgp48hRVFQEhUJh8OdRHk9PT5MOeEQ1FU/hEdHfztHRETNmzMDOnTtx9OjRCvvevn0bdevWLTMsKJX//6+wzMxMrF+/Hj179jQITyWee+45TJ8+HWfPnsWuXbseW+OGDRvQuHFjaDQaNGnSBBs3biyz38On8H799VcoFAqsW7euVL///e9/UCgU+Pbbb6W2lJQUvPbaa3B2dpbe55NPPjF4XclpzU2bNmHy5Mnw8PCARqPBpUuXcO/ePUyZMgW+vr6wsLCAo6MjAgMDsXXrVun1j57Cq1+/Ps6ePYvDhw9Lp1jr16+PvLw81KlTB2+88Uap2q9cuQKVSoX//ve/j/1zI3pWMEARUaXR6XQoLi42eOh0ujL7TpgwAR4eHpg2bVqFYwYFBeHYsWMYP348jh07hqKiojL7xcXFobi4GAMHDix3rJJjBw4cqPA9N2zYgPDwcDRp0gQ7duzAzJkzMW/ePPzwww8Vvq5Vq1YICAhATExMmWM6OzujT58+AIBz586hXbt2OHPmDD744AN899136Nu3L8aPH4/333+/1OvfffddXL16FatXr8bu3bvh7OyMSZMmYdWqVRg/fjz27duHTZs24ZVXXqlwr1dsbCz8/PwQEBCAxMREJCYmIjY2FjY2NoiIiMDmzZuRnZ1t8JqVK1fC3NwcERERFc6f6JkiiIieUkxMjABQ5kOlUhn09fHxEX379hVCCLF27VoBQOzevVsIIURcXJwAILZv3y71v3XrlujUqZM0nlqtFsHBwWLRokUiNzdX6hcVFSUAiH379pVbZ35+vgAgevfuXW4fnU4n3N3dRZs2bYRer5far1y5ItRqtfDx8THoD0DMmTNHer5ixQoBQCQnJ0ttWVlZQqPRiMmTJ0ttPXv2FJ6eniI7O9tgvLfffltYWFiIrKwsgz+T559/vlStzZs3FwMHDix3LkIIMWfOHPHoX/XNmjUTnTt3LtX3999/F0qlUixfvlxqy8/PF05OTiI8PLzC9yF61nAFiogqzcaNG/HLL78YPI4dO1Zu//DwcDRt2hQzZsyAXq8vs4+TkxN+/PFH/PLLL4iKisKAAQNw8eJFvPvuu2jRogVu3bolu85Hv5X2sOTkZKSnp+O1114z6Ofj44Pg4ODHjv3Pf/4TGo3G4FtuW7duRUFBAcLDwwEA9+/fx6FDhzBo0CBYWVkZrNj16dMH9+/fL3Vq86WXXir1Xu3bt8f//vc/zJgxA1qtFvn5+Y+tryJ+fn7o168fVq5cCSEEAGDLli24ffs23n777acam6i2YYAiokrTpEkTBAYGGjzatm1bbn+VSoWFCxfi7Nmz+PzzzyscOzAwENOnT8f27duRnp6Od955B1euXJE2knt7ewMAUlNTyx2j5JiXl1e5fUpOf7m6upY6VlbboxwdHREWFoaNGzdKpy83bNiA9u3bo1mzZtJ7FBcXIzo6Gmq12uBRcorv0WDo5uZW6r1WrFiB6dOnY9euXQgNDYWjoyMGDhyIlJSUx9ZZngkTJiAlJUU6zfnJJ58gKCgIbdq0eeIxiWojBigiqlYDBgxASEgI5syZg/v37xv1GrVajTlz5gAAzpw5A+DBN+3MzMwq3CBecqx79+7l9nFycgLwYFP6o8pqK0t4eDjS0tJw4MABnDt3Dr/88ou0+gQADg4OUKlUGDVqVKkVu5JHSZAqUdaqmbW1Nd5//31cuHABmZmZWLVqFY4ePYr+/fsbVWdZunbtiubNm+Pjjz9GQkICTp48ibfeeuuJxyOqrXgZAyKqdosXL0anTp2wYsWKUscyMjLKXH05f/48AMDd3R3Ag9WhiIgIfPrpp/jyyy9LfRPv4sWLWLx4MZo1a1bhRvPGjRvDzc0NW7duxaRJk6Tg8scffyAhIUF6v4r06NEDHh4eiImJgbe3NywsLDB06FDpuJWVFUJDQ3Hq1Cm0bNkS5ubmjx3zcVxcXDBq1Cj8+uuv+PDDD3Hv3j1YWVmV2Vej0VR4um/8+PEYM2YMsrOz4eLigldeeeWp6yOqbRigiKjSnDlzBsXFxaXaGzRogHr16pX7upCQEAwYMADffPNNqWM9e/aEp6cn+vfvD39/f+j1eiQlJeGDDz6AjY0NJkyYIPVdtmwZkpOTMWzYMMTHx6N///7QaDQ4evQoli5dCltbW+zYsaPCa0AplUrMmzcP//rXvzBo0CC8/vrr+OuvvzB37lyjTuEBD05NjhgxAsuWLYOdnR1efPFF2NvbG/T56KOP0KlTJ/zjH//A2LFjUb9+feTm5uLSpUvYvXv3Y7/xBwAdOnRAv3790LJlSzg4OOD8+fPYtGkTgoKCyg1PANCiRQts27YNX375Jfz8/GBhYYEWLVpIx4cNG4Z3330X8fHxmDlzZqUEPKJap7p3sRNRzVfRt/AAiLVr10p9H/4W3sPOnTsnVCpVqW/hffnll+K1114TjRo1EjY2NkKtVgtvb28xfPhwce7cuVLjFBYWik8++UR06NBB2NjYCI1GIxo3biymTZsmbt26ZfScPvvsM9GoUSNhbm4unnvuObF+/XoxcuTIx34Lr8TFixel+R84cKDM90hNTRURERHCw8NDqNVqUa9ePREcHCzmz58v9Snrm4klZsyYIQIDA4WDg4PQaDTCz89PvPPOOwbzLOtbeFeuXBE9evQQtra2AkCpOQkhxKhRo4SZmZm4fv16BX9KRM8uhRD/91ULIiIiAIWFhahfvz46deqEr776qrrLITJJPIVHREQAgJs3byI5ORkxMTH4888/MWPGjOouichkMUARERGABzduDg8Ph5ubG1auXMlLFxBVgKfwiIiIiGTidaCIiIiIZGKAIiIiIpKJAYqIiIhIJm4iryJ6vR7p6emwtbWt8MalREREZDqEEMjNzYW7uzuUyvLXmRigqkh6enqFNywlIiIi03Xt2jV4enqWe5wBqorY2toCePAB2NnZVXM1REREZIycnBx4eXlJv8fLwwBVRUpO29nZ2TFAERER1TCP237DTeREREREMjFAEREREcnEAEVEREQkEwMUERERkUwMUEREREQyMUARERERycQARURERCQTAxQRERGRTAxQRERERDIxQBERERHJxABFREREJBMDFBEREZFMvJkwERE9kwIDA5GZmfnYfjdu3IBOp4NKpYKzs3OFfV1dXXH8+PHKKpFMGAMUERE9kzIzM5GWlmZ0f71eL6s/1W4MUERE9ExydXU1ql9GRgb0ej2USiXc3NwqZUyq+RigiIjomWTsqTZPT0+kpaXBzc0N169fr+KqqKbgJnIiIiIimRigiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZGKCIiIiIZGKAIiIiIpKJAYqIiIhIJgYoIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZGKCIiIiIZGKAIiIiIpKJAYqIiIhIJgYoIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGSq1gAVHx+P/v37w93dHQqFArt27TI4LoTA3Llz4e7uDktLS3Tp0gVnz5416FNQUIBx48ahbt26sLa2RlhYGK5fv27QJzExEa1bt4aPjw/Wrl0rtXfs2BFjx4416Ltq1SooFAqsW7fOoD0yMhLBwcGVMGsiIiKq6ao1QN29exetWrXCxx9/XObxJUuWYNmyZfj444/xyy+/wNXVFd27d0dubq7UZ+LEiYiNjcW2bdtw5MgR5OXloV+/ftDpdFKfiIgIzJo1C1u3bsXixYtx9epVAEBoaCji4uIM3lOr1cLLy6vM9tDQ0MqaOhEREdVkwkQAELGxsdJzvV4vXF1dRVRUlNR2//59YW9vL1avXi2EEOKvv/4SarVabNu2TeqTlpYmlEql2Ldvn9Tm7e0tLl++LPLy8kRgYKA4e/asEEKI77//XgAQ6enpUl8XFxexcuVK4eHhIbVdvXpVABAHDhwwej7Z2dkCgMjOzjb+D4GIiEyOh4eHAGDwe4FqL2N/f5tVZ3irSGpqKjIzM9GjRw+pTaPRoHPnzkhISMAbb7yBEydOoKioyKCPu7s7mjdvjoSEBPTs2RMAMHv2bDRp0gTFxcUYO3YsmjZtCgAICQmBWq2GVqvF0KFDce7cOeTn5yMiIgLTp09HSkoKGjVqhLi4OJibm1d4Cq+goAAFBQXS85ycHABAUVERioqKAABKpRIqlQo6nQ56vV7qW9JeXFwMIYTUrlKpoFQqy20vGbeEmdmDj7O4uNiodrVaDb1eb7Bap1AoYGZmVm57ebVzTpwT58Q51dY5PayoqKhWzKk2fk6VOSdjmGyAyszMBAC4uLgYtLu4uOCPP/6Q+pibm8PBwaFUn5LXAw/2Lw0ZMgSFhYUGfa2trdGuXTspQGm1WnTq1AkajQYhISHQarVo1KgRtFotOnToACsrq3LrXbRoEd5///1S7fv375de5+3tjYCAAJw+fVo6jQgAjRs3hr+/P37++WfcvHlTai/ZtxUfH29w2jIoKAjOzs7Yv3+/wQcdGhoKS0tL7N2716CGPn36ID8/3+C0pJmZGfr27Ytbt24hMTFRare1tUXXrl1x7do1JCUlSe316tVDcHAwUlJSkJycLLVzTpwT58Q51fY5lbzf/fv3sXfv3loxp9r4OVXWnH766ScYQyEejl/VSKFQIDY2FgMHDgQAJCQkICQkBOnp6XBzc5P6vf7667h27Rr27duHLVu2IDw83GDlBwC6d++OBg0aYPXq1Y9935kzZ2L79u1ITk7G4MGD0a5dO0ydOhVRUVH47bffsHnzZvj5+WHEiBGYO3duueOUtQLl5eWFW7duwc7ODgATfk2cU/v27fHnn3/icW7cuAGdTgeVSgVnZ+cK+7q6uuKXX37h58Q5cU41ZE6enp5IS0uDh4cHUlNTa8WcauPnVFlzysrKgpOTE7Kzs6Xf32Ux2RUoV1dXAA9WmR4OUDdu3JBWpVxdXVFYWIg7d+4YrCzduHHD6G/MhYaGYsGCBUhLS8Phw4cxZcoUAEDnzp0RHR2Nq1evIjU19bEbyDUaDTQaTal2tVoNtVpt0KZSqaBSqUr1fXSp+HHtj477JO1KpRJKZenvEpTXXl7ttXVOf/75J9LS0sp877Lo9Xqj+isUCn5OnBPnhJoxp/LGq8lzqo2fU1XPqVQ/o3pVA19fX7i6uuLAgQMICAgAABQWFuLw4cNYvHgxAKBt27ZQq9U4cOAABg8eDADIyMjAmTNnsGTJEqPeJzg4GBqNBitXrkR+fj7atm0LAAgMDER2djbWrFkDCwsLdOzYsQpmSaauJMg/TkZGBvR6PZRKpUHgf5oxiYjIdFVrgMrLy8OlS5ek56mpqUhKSoKjoyO8vb0xceJELFy4EI0aNUKjRo2wcOFCWFlZ4bXXXgMA2NvbIzIyEpMnT4aTkxMcHR0xZcoUtGjRAt26dTOqBktLS3To0AHR0dEICQmRUqparUZQUBCio6OlkEXPnuPHjxvVr2SJ383NrdR1yIiIqPap1gB1/Phxg1NjkyZNAgCMHDkSGzZswLRp05Cfn48333wTd+7cQYcOHbB//37Y2tpKr1m+fDnMzMwwePBg5Ofn44UXXsCGDRvKXK4rT2hoKOLj49GlSxeD9s6dO+PgwYO8/hMREREZMJlN5LVNTk4O7O3tH7sJjWqHhzeZcgWKqHbhz/ezxdjf37wXHhEREZFMDFBEREREMjFAEREREcnEAEVEREQkEwMUERERkUwMUEREREQyMUARERERycQARURERCQTAxQRERGRTAxQRERERDIxQBERERHJxABFREREJBMDFBEREZFMDFBEREREMjFAEREREcnEAEVEREQkEwMUERERkUwMUEREREQyMUARERERycQARURERCQTAxQRERGRTAxQRERERDIxQBERERHJxABFREREJBMDFBEREZFMDFBEREREMjFAEREREcnEAEVEREQkEwMUERERkUwMUEREREQyMUARERERycQARURERCQTAxQRERGRTAxQRERERDIxQBERERHJxABFREREJFOlBajbt2/jww8/rKzhiIiIiEzWUwUoIQS+//57DB48GO7u7liwYEFl1UVERERksp4oQF25cgWzZ8+Gj48P+vTpAwsLC+zZsweZmZmVXR8RERGRyTE6QBUUFGDr1q144YUX0KRJE5w5cwbLli2DUqnEjBkz0K1bN6hUqqqslYiIiMgkmBnb0cPDA02bNsWwYcPw9ddfw8HBAQAwdOjQKiuOiIiIyBQZvQKl0+mgUCigUCi40kRERETPNKMDVEZGBkaPHo2tW7fC1dUVL730EmJjY6FQKKqyPiIiIiKToxBCCLkv+v333xETE4PPP/8caWlpGDp0KEaNGoWuXbtyder/5OTkwN7eHtnZ2bCzs6vucqgM27dvx+zZs5Gbm/vUY2VkZECv10OpVMLNze2pxrK1tcW8efPw8ssvP3VdRPT0PD09kZaWBg8PD1y/fr26y6EqZuzvb6MD1MaNG/Hqq69Co9FIbXq9Ht9//z3WrVuH3bt3w9bWFrdu3Xr66msBBijT16RJE1y4cKG6yyiTv78/zp8/X91lEBEYoJ41xv7+NnoTeXh4OHr16gVnZ2epTalUonfv3ujduzdu3ryJTZs2PV3VRH+jkpWnylg1unHjBnQ6HVQqlcHPiFwlK1mVsSpGRERVx+gA9biFqnr16mHSpElPXRDR383Nzc1k/lVZ8i9dIiIybbIupMkN40REREQyVqAAYNSoUQZ7oMqyc+fOpyqIiIiIyNTJClC2trawtLSsqlqIiIiIagRZAWrFihVPtUGWiIiIqDYweg8U9z8RERERPWB0gHqC620SERER1UpGB6i4uDg4OjpWZS1ERERENYLRAcrCwgIHDhwwaNu4cSN8fX3h7OyM0aNHo6CgoNILJCIiIjI1RgeouXPn4vTp09Lz3377DZGRkejWrRtmzJiB3bt3Y9GiRVVSJBEREZEpMTpAJSUl4YUXXpCeb9u2DR06dMDatWsxadIkrFixAl999VWVFElERERkSowOUHfu3IGLi4v0/PDhw+jVq5f0vF27drh27VrlVkdERERkgowOUC4uLkhNTQUAFBYW4uTJkwgKCpKO5+bmQq1WV36FRERERCbG6Atp9urVCzNmzMDixYuxa9cuWFlZ4R//+Id0/PTp02jQoEGVFElUVd7paI6pnfKAD5pUdykAgF+G5uG/R8zxFRdziZ7K9u3bMXv2bOTm5j71WBkZGdL/enp6PtVYtra2mDdvHl5++eWnrouql9EBav78+XjxxRfRuXNn2NjY4PPPP4e5ubl0fP369ejRo0eVFElUVew0CrhZCyA3vbpLAQC4WT+oiYiezuzZs3HhwoVKHVOv1yMtLe2px5k1axYDVC1gdICqV68efvzxR2RnZ8PGxgYqlcrg+Pbt22FjY1PpBRJVpZwCgYy7Cri5ulV3KQCAjMwM5BTworVET6tk5UmpVMLN7el+vm/cuAGdTgeVSvVUtzPLyMiAXq+vlFUxqn6y7oUHAPb29gbP//jjD9y9exf+/v5QKo3eUkVkEpYfLcRX1+rh+vXz1V0KAKCdpyfS0rLh4VHdlRDVDm5ubrh+/Xp1lwEA8PT0rJQVLDINRieezz//HB9++KFB2+jRo+Hn54cWLVqgefPm/BYeERERPROMDlCrV682WH3at28fYmJisHHjRvzyyy+oU6cO3n///SopkoiIiMiUGB2gLl68iMDAQOn5N998g7CwMPzzn/9EmzZtsHDhQhw6dEjWm8fHx6N///5wd3eHQqHArl27pGNFRUWYPn06WrRoAWtra7i7u2PEiBFITzfc7FtQUIBx48ahbt26sLa2RlhYWKnl2sTERLRu3Ro+Pj5Yu3at1N6xY0eMHTvWoO+qVaugUCiwbt06g/bIyEgEBwfLmh8RERHVTkYHqPz8fNjZ2UnPExIS8Pzzz0vP/fz8kJmZKevN7969i1atWuHjjz8udezevXs4efIkZs2ahZMnT2Lnzp24ePEiwsLCDPpNnDgRsbGx2LZtG44cOYK8vDz069cPOp1O6hMREYFZs2Zh69atWLx4Ma5evQoACA0NRVxcnMF4Wq0WXl5eZbaHhobKmh8RERHVTkZvIvfx8cGJEyfg4+ODW7du4ezZs+jUqZN0PDMzs9QG88fp3bs3evfuXeYxe3v7Ujcvjo6ORvv27XH16lV4e3sjOzsb69atw6ZNm9CtWzcAwBdffAEvLy8cPHgQPXv2BPAgjLVp0wbOzs5wcHBAXl4egAcBKioqChkZGdK3NA4fPow5c+ZgwYIF0vteu3YNly9fZoAiIiIiADIC1IgRI/DWW2/h7Nmz+OGHH+Dv74+2bdtKxxMSEtC8efMqKbJEdnY2FAoF6tSpAwA4ceIEioqKDK4/5e7ujubNmyMhIUEKULNnz0aTJk1QXFyMsWPHomnTpgCAkJAQqNVqaLVaDB06FOfOnUN+fj4iIiIwffp0pKSkoFGjRoiLi4O5uXmFp/AKCgpQUFAgPc/JyQHw4FRkUVERgAdfp1WpVNDpdNDr9VLfkvbi4mII8f+/wq5SqaBUKsttLxm3hJnZg4+zuLjYqHa1Wg29Xm+wWqdQKGBmZlZue3m118Q5Pezh963uOT1a07P+OXFOnNOTzOlhD7+mOuf0aE38nEx3TsYwOkBNnz4d9+7dw86dO+Hq6ort27cbHP/pp58wdOhQY4eT7f79+5gxYwZee+016VRiZmYmzM3N4eDgYNDXxcXF4HRiZGQkhgwZgsLCQoO+1tbWaNeunRSgtFotOnXqBI1Gg5CQEGi1WjRq1AharRYdOnSAlZVVufUtWrSozE30+/fvl17n7e2NgIAAnD59WjqNCACNGzeGv78/fv75Z9y8eVNqL9m3FR8fb3DdkKCgIDg7O2P//v0GH3RoaCgsLS2xd+9egxr69OmD/Px8g9OSZmZm6Nu3L27duoXExESp3dbWFl27dsW1a9eQlJQktderVw/BwcFISUlBcnKy1F6T51RYWAjgwQ/uw+NX55xKfpjv37+PvXv38nPinDinJ5xTiZKfJVOYU8k/sktq4udkmnP66aefYAyFeDh+VSOFQoHY2FgMHDiw1LGioiK88soruHr1KrRarRSgtmzZgvDwcIOVHwDo3r07GjRogNWrVz/2fWfOnInt27cjOTkZgwcPRrt27TB16lRERUXht99+w+bNm+Hn54cRI0Zg7ty55Y5T1gqUl5cXbt26JdXLhG9ac/L19UVaWho8PDyk+zxW95y8vLxK1fSsf06cE+f0JHMq7+e7OudUch2okpr4OZnmnLKysuDk5ITs7GyDvd+Pkn0hzb9bUVERBg8ejNTUVPzwww8Gk3F1dUVhYSHu3LljsLJ048YNo78xFxoaigULFiAtLQ2HDx/GlClTAACdO3dGdHQ0rl69itTU1Mfuf9JoNNBoNKXa1Wp1qZssq1SqUldyB0qfwnlce3k3b5bTrlQqy7wAannt5dVek+dU3jjVNaeyjvNz4pwAzqm8GitqL+tYdc2pvJr4OdWMOZWqw6he1aQkPKWkpODgwYNwcnIyON62bVuo1WqDzeYZGRk4c+aM0QEqODgYGo0GK1euRH5+vrSvKzAwENnZ2VizZg0sLCzQsWPHypsYERER1WjVugKVl5eHS5cuSc9TU1ORlJQER0dHuLu74+WXX8bJkyfx3XffQafTSfuaHB0dYW5uDnt7e0RGRmLy5MlwcnKCo6MjpkyZghYtWkjfynscS0tLdOjQAdHR0QgJCZFSqlqtRlBQEKKjo6WQRURERARU8wrU8ePHERAQgICAAADApEmTEBAQgNmzZ+P69ev49ttvcf36dbRu3Rpubm7SIyEhQRpj+fLlGDhwIAYPHoyQkBBYWVlh9+7dZS7XlSc0NBS5ubno0qWLQXvnzp2Rm5vLyxcQERGRAdmbyPPz82FpaVnmsYevp/Ssy8nJgb29/WM3oVH1eXhD59PebDQxPRFRP0dhRvsZCHIPMomaiJ5lpvizZIo1UWnG/v6WvQIVEBCAkydPlmr/+uuv0bJlS7nDEdV4Qgh8dPIjXM6+jI9OfgQT+WIrERFVIdkBqnv37ggODkZUVBSEEMjLy8OoUaMwcuRIzJ49uypqJDJpCekJOHv7LADg7O2zSEhPeMwriIioppO9iTw6Ohp9+/ZFeHg49uzZg/T0dNjZ2eGXX36RrvBN9KwQQiD6VDSUCiX0Qg+lQonoU9EIdg+GQqGo7vKIiKiKPNEm8h49euDFF1/ETz/9hGvXriEqKorhiZ5JJatPevHgIm16oecqFBHRM0B2gPr9998RFBSE7777Dt9//z2mTZuGAQMGYNq0aaWuPEpUmz28+vSwklUo7oUiIqq9ZAeo1q1bw9fXF7/++iu6d++O+fPn44cffsDOnTvRvn37qqiRyCQ9uvpUgqtQRES1n+wAtXLlSmzbtg116tSR2oKDg3Hq1Cm0adOmMmsjMlklq08KlL3PSQEFV6GIiGox2QFq+PDhZbbb2tpi3bp1T10QUU1QpC9C5t1MCJQdkAQEMu9mokjP09pERLXRE9/K5dy5c7h69SoKCwulNoVCgf79+1dKYUSmzFxljm39tiHrfla5fRwtHGGuMv8bqyIior+L7AB1+fJlDBo0CL/99hsUCoV0iqLkK9s6na5yKyQyUa7WrnC1dq3uMoiIqBrIPoU3YcIE+Pr64s8//4SVlRXOnj2L+Ph4BAYGQqvVVkGJRERERKZF9gpUYmIifvjhB9SrVw9KpRJKpRKdOnXCokWLMH78eJw6daoq6iQiIiIyGbJXoHQ6HWxsbAAAdevWRXp6OgDAx8cHycnJlVsdERERkQmSvQLVvHlznD59Gn5+fujQoQOWLFkCc3NzfPrpp/Dz86uKGomIiIhMiuwANXPmTNy9excAMH/+fPTr1w//+Mc/4OTkhC+//LLSCyQiIiIyNbIDVM+ePaX/9vPzw7lz55CVlQUHBwfePJWIiIieCU98HaiHOTo6VsYwRERERDWC7AB1//59REdHIy4uDjdu3IBeb3gfsJMnT1ZacURERESmSHaAioiIwIEDB/Dyyy+jffv2PG1HREREzxzZAWrPnj3Yu3cvQkJCqqIeIiIiIpMn+zpQHh4esLW1rYpaiIiIiGoE2QHqgw8+wPTp0/HHH39URT1EREREJk/2KbzAwEDcv38ffn5+sLKyglqtNjielVX+3emJiIiIagPZAWro0KFIS0vDwoUL4eLiwk3kRERE9MyRHaASEhKQmJiIVq1aVUU9RERERCZP9h4of39/5OfnV0UtRERERDWC7AAVFRWFyZMnQ6vV4vbt28jJyTF4EBEREdV2sk/h9erVCwDwwgsvGLQLIaBQKKDT6SqnMiIiIiITJTtA/fDDD9w4TkRERM80owPUp59+irCwMHTp0qUKyyEiIiIyfUbvgdq6dSvq16+PDh06YOHChTh79mxV1kVERERksowOUHFxccjIyMC4ceOQlJSE4OBgNGjQAJMmTYJWq4Ver6/KOomIiIhMhqxv4Tk4OGDYsGH46quvcPPmTXzyySe4f/8+hg8fjnr16mHEiBH4+uuvcffu3aqql4iIiKjayb6MQQlzc3P06tULK1euxLVr1/D999+jfv36mDdvHpYtW1aZNRIRERGZFNnfwitPYGAgAgMD8Z///AdFRUWVNSwRERGRyZEdoHQ6HTZs2IBDhw7hxo0bBnufFAoFDh06VOoGw0RERES1iewANWHCBGzYsAF9+/ZF8+bNeU0oIiIieubIDlDbtm3DV199hT59+lRFPUREREQmT/YmcnNzczRs2LAqaiEiIiKqEWQHqMmTJ+Ojjz6CEKIq6iEiIiIyebJP4R05cgRxcXH43//+h2bNmpXaML5z585KK46oKqWlpUn/6+np+VRj3bhxAzqdDiqVCs7Ozk88TkZGxlPVQUREfw/ZAapOnToYNGhQVdRCVG1KwtTT0uv1lTKWra1tJVRDRERVRXaAiomJqYo6iKqVh4fHU70+IyMDer0eSqUSbm5uTzWWra0t5s2b91RjEBFR1aq0C2kS1TSVuY/P09MTaWlpcHNzw/Xr1yttXCIiMk1GBag2bdrg0KFDcHBwQEBAQIXXfjp58mSlFUdERERkiowKUAMGDIBGowEADBw4sCrrISIiIjJ5RgWoOXPmlPnfRERERM+ip9oDlZeXZ3AvPACws7N7qoKIiIiITJ3sC2mmpqaib9++sLa2hr29PRwcHODg4IA6derAwcGhKmokIiIiMimyV6D++c9/AgDWr18PFxcX3kyYiIiInjmyA9Tp06dx4sQJNG7cuCrqISIiIjJ5sk/htWvXDteuXauKWoiIiIhqBNkrUJ999hnGjBmDtLQ0NG/evNS98Fq2bFlpxRERERGZItkB6ubNm/j9998RHh4utSkUCgghoFAooNPpKrVAIiIiIlMjO0BFREQgICAAW7du5SZyIiIieibJDlB//PEHvv32WzRs2LAq6iEiIiIyebI3kXft2hW//vprVdRCREREVCPIXoHq378/3nnnHfz2229o0aJFqU3kYWFhlVYcERERkSmSHaDGjBkDAPjPf/5T6hg3kRMREdGzQHaAevTed0RERETPGtl7oIiIiIiedQxQRERERDIxQBERERHJxABFREREJJNRAWrSpEm4e/cuACA+Ph7FxcVVWhQRERGRKTMqQEVHRyMvLw8AEBoaiqysrCotioiIiMiUGRWg6tevjxUrVuDw4cMQQiAxMRHx8fFlPuSIj49H//794e7uDoVCgV27dpXb94033oBCocCHH35o0F5QUIBx48ahbt26sLa2RlhYGK5fv27QJzExEa1bt4aPjw/Wrl0rtXfs2BFjx4416Ltq1SooFAqsW7fOoD0yMhLBwcGy5kdERES1k1HXgfrvf/+LMWPGYNGiRVAoFBg0aFCZ/eReSPPu3bto1aoVwsPD8dJLL5Xbb9euXTh27Bjc3d1LHZs4cSJ2796Nbdu2wcnJCZMnT0a/fv1w4sQJqFQqAA9ugDx//ny4ublhxIgR6NmzJ7y9vREaGorY2FiD8bRaLby8vBAXF4fIyEiD9iFDhhg9NyIiIqq9jFqBGjhwIDIzM5GTkwMhBJKTk3Hnzp1SD7mn9nr37o358+fjxRdfLLdPWloa3n77bWzevLnUbWOys7Oxbt06fPDBB+jWrRsCAgLwxRdf4LfffsPBgwelfvfu3UObNm3QqlUrODg4GJyOTE5ORkZGhtT38OHDePfdd6HVaqW2a9eu4fLlywgNDZU1PyIiIqqdZF2J3MbGBnFxcfD19YWZmeyLmMum1+sxfPhwTJ06Fc2aNSt1/MSJEygqKkKPHj2kNnd3dzRv3hwJCQno2bMnAGD27Nlo0qQJiouLMXbsWDRt2hQAEBISArVaDa1Wi6FDh+LcuXPIz89HREQEpk+fjpSUFDRq1AhxcXEwNzev8BReQUEBCgoKpOc5OTkAgKKiIhQVFQEAlEolVCoVdDqdwRXdS9qLi4shhJDaVSoVlEplue0l45Yo+Uwe3eRfXrtarYZerzdYNVQoFDAzMyu3vbzan/U5PaxkDjV9TrXxc+Kcnp05Pezh11TnnB6tiZ+T6c7JGLJTUOfOnaHT6bBjxw6cP38eCoUCTZo0wYABA0r9InlaixcvhpmZGcaPH1/m8czMTJibm8PBwcGg3cXFBZmZmdLzyMhIDBkyBIWFhQZ9ra2t0a5dOylAabVadOrUCRqNBiEhIdBqtWjUqBG0Wi06dOgAKyurcmtdtGgR3n///VLt+/fvl17n7e2NgIAAnD59GlevXpX6NG7cGP7+/vj5559x8+ZNqb1k31Z8fDxyc3Ol9qCgIDg7O2P//v0GH3RoaCgsLS2xd+9egxr69OmD/Px8xMXFSW1mZmbo27cvbt26hcTERKnd1tYWXbt2xbVr15CUlCS116tXD8HBwUhJSUFycrLUzjk9mFOJ+/fvS7XW9DnVxs+Jc3p25lTi4Z/J6p5TyT+yS2ri52Sac/rpp59gDIV4OH4Z4dKlS+jbty+uX7+Oxo0bQwiBixcvwsvLC3v27EGDBg3kDPf/C1EoEBsbi4EDBwJ4sLrUt29fnDx5Utr7VL9+fUycOBETJ04EAGzZsgXh4eEGKz8A0L17dzRo0ACrV69+7PvOnDkT27dvR3JyMgYPHox27dph6tSpiIqKwm+//YbNmzfDz88PI0aMwNy5c8sdp6wVKC8vL9y6dQt2dnYAmPBr85y8vb2RlpYGDw8PpKam1oo51cbPiXN6dubk6+tb6meyuufk6elpUBM/J9OcU1ZWFpycnJCdnS39/i6TkKl3796iV69e4vbt21LbrVu3RK9evUSfPn3kDicBIGJjY6Xny5cvFwqFQqhUKukBQCiVSuHj4yOEEOLQoUMCgMjKyjIYq2XLlmL27NlGve/BgwcFAHH9+nXh7Owsjh07JoQQIiEhQbi7u4s//vhDABBarVbWfLKzswUAkZ2dLet1VDN5eHgIAMLDw6O6SyEiYZo/k6ZYE5Vm7O9v2VciP3z4MJYsWQJHR0epzcnJCVFRUTh8+LDc4co1fPhwnD59GklJSdLD3d0dU6dOxffffw8AaNu2LdRqNQ4cOCC9LiMjA2fOnDH6kgPBwcHQaDRYuXIl8vPz0bZtWwBAYGAgsrOzsWbNGlhYWKBjx46VNjciIiKq2WTvgdJoNAbnO0vk5eXB3Nxc1lh5eXm4dOmS9Dw1NRVJSUlwdHSEt7c3nJycDPqr1Wq4urqicePGAAB7e3tERkZi8uTJcHJygqOjI6ZMmYIWLVqgW7duRtVgaWmJDh06IDo6GiEhIdI+LrVajaCgIERHR0shi4iIiAh4gnvh9evXD6NHj8axY8cghIAQAkePHsWYMWMQFhYma6zjx48jICAAAQEBAB7cMiYgIACzZ882eozly5dj4MCBGDx4MEJCQmBlZYXdu3fL2tAeGhqK3NxcdOnSxaC9c+fOyM3N5eULiIiIyIDsTeR//fUXRo4cid27d0vXZSouLkZYWBg2bNgAe3v7Kim0psnJyYG9vf3jN6FRrfDw5tBHr4RPRH8/U/yZNMWaqDRjf3/LPoVXp04dfPPNN7h06RLOnz8PIQSaNm2Khg0bPlXBRERERDXFE18Ns2HDhgxNRERE9EySvQeKiIiI6FnHAEVERFSBxPREDNg1AInpiY/vTM8MBigiIqJyCCHw0cmPcDn7Mj46+RFkfu+KajEGKCIionIkpCfg7O2zAICzt88iIT2hmisiU/FEAerHH3/EsGHDEBQUhLS0NADApk2bcOTIkUotjoiIqLoIIRB9KhpKxYNflUqFEtGnorkKRQCeIEDt2LEDPXv2hKWlJU6dOiXdQDc3NxcLFy6s9AKJiIiqQ8nqk148uBGtXui5CkUS2QFq/vz5WL16NdauXStdSBN4cE+5kydPVmpxRERE1eHR1acSXIWiErIDVHJyMp5//vlS7XZ2dvjrr78qoyYiIqJq9ejqUwmuQlEJ2QHKzc3N4AbAJY4cOQI/P79KKYqIiKi6lKw+KaAo87gCCq5CkfwA9cYbb2DChAk4duwYFAoF0tPTsXnzZkyZMgVvvvlmVdRIRET0tynSFyHzbiYEyg5IAgKZdzNRpC/6mysjUyL7Vi7Tpk1DdnY2QkNDcf/+fTz//PPQaDSYMmUK3n777aqokYiI6G9jrjLHtn7bkHU/q9w+jhaOMFeZ/41Vkal5onvhLViwAO+99x7OnTsHvV6Ppk2bwsbGprJrIyIiqhau1q5wtXat7jLIhD3xzYStrKwQGBhYmbUQERER1QhGBagXX3zR6AF37tz5xMUQERER1QRGbSK3t7eXHnZ2djh06BCOHz8uHT9x4gQOHToEe3v7KiuUiIiIyFQYtQIVExMj/ff06dMxePBgrF69GiqVCgCg0+nw5ptvws7OrmqqJCIiIjIhsi9jsH79ekyZMkUKTwCgUqkwadIkrF+/vlKLIyIiIjJFsgNUcXExzp8/X6r9/Pnz0Ov1ZbyCiIiIqHaR/S288PBwRERE4NKlS+jYsSMA4OjRo4iKikJ4eHilF0hERERkamQHqKVLl8LV1RXLly9HRkYGgAe3d5k2bRomT55c6QUSERERmRrZAUqpVGLatGmYNm0acnJyAICbx4mIiOiZ8sQX0gQYnIiIiOjZJDtA+fr6QqEo+w7VAHD58uWnKoiIiIjI1MkOUBMnTjR4XlRUhFOnTmHfvn2YOnVqZdVFREREZLJkB6gJEyaU2f7JJ58YXJ2ciIiIqLaSfR2o8vTu3Rs7duyorOGIiIiITFalBaivv/4ajo6OlTUcERERkcmSfQovICDAYBO5EAKZmZm4efMmVq5cWanFEREREZki2QFqwIABBgFKqVSiXr166NKlC/z9/Su1OCIiIiJTJDtAzZ07twrKICIiIqo5ZO+BUqlUuHHjRqn227dvQ6VSVUpRRERERKZMdoASQpTZXlBQAHNz86cuiIiIiMjUGX0Kb8WKFQAAhUKBzz77DDY2NtIxnU6H+Ph47oEiIiKiZ4LRAWr58uUAHqxArV692uB0nbm5OerXr4/Vq1dXfoVEREREJsboAJWamgoACA0Nxc6dO+Hg4FBlRRERERGZMtnfwouLi6uKOoiIiIhqDKMC1KRJkzBv3jxYW1tj0qRJFfZdtmxZpRRGREREZKqMClCnTp1CUVGR9N/lefgCm0RERES1lVEB6uHTdjyFR0RERM+6SruZMBEREdGzQvYm8kGDBpV5qk6hUMDCwgINGzbEa6+9hsaNG1dKgURERESmRnaAsre3x65du1CnTh20bdsWQgicOnUKf/31F3r06IEvv/wSixcvxqFDhxASElIVNRMRET3WOx3NMbVTHvBBk+ouBQDwy9A8/PeIOb66Vt2VUGWQHaBcXV3x2muv4eOPP4ZS+eAMoF6vx4QJE2Bra4tt27ZhzJgxmD59Oo4cOVLpBRMRERnDTqOAm7UActOruxQAgJv1g5qodpAdoNatW4effvpJCk8AoFQqMW7cOAQHB2PhwoV4++238Y9//KNSCyUiIpIjp0Ag464Cbq5u1V0KACAjMwM5BWXfT5ZqHtkBqri4GBcuXMBzzz1n0H7hwgXodDoAgIWFBS9pQERE1Wr50UJ8da0erl8/X92lAADaeXoiLS0bHh7VXQlVBtkBavjw4YiMjMS///1vtGvXDgqFAj///DMWLlyIESNGAAAOHz6MZs2aVXqxRERERKZAdoBavnw5XFxcsGTJEvz5558AABcXF7zzzjuYPn06AKBHjx7o1atX5VZKREREZCJkByiVSoX33nsP7733HnJycgAAdnZ2Bn28vb0rpzoiIiIiEyQ7QD3s0eBERERE9CyQfSXyP//8E8OHD4e7uzvMzMygUqkMHkRERES1newVqFGjRuHq1auYNWsW3Nzc+G07IiIieubIDlBHjhzBjz/+iNatW1dBOURERESmT/YpPC8vLwjBC4ERERHRs0t2gPrwww8xY8YMXLlypQrKISIiIjJ9sk/hvfrqq7h37x4aNGgAKysrqNVqg+NZWVmVVhwRERGRKZIdoD788MMqKIOIiIio5pAdoEaOHFkVdRCZpMDAQGRmZj62X0ZGhvS/np6eFfZ1dXXF8ePHK6U+IiKqHk90IU2dToddu3bh/PnzUCgUaNq0KcLCwngdKKp1MjMzkZaWZnR/vV4vqz8REdVMsgPUpUuX0KdPH6SlpaFx48YQQuDixYvw8vLCnj170KBBg6qok6hauLq6GtXvxo0b0Ol0UKlUcHZ2rpQxiYjIdMkOUOPHj0eDBg1w9OhRODo6AgBu376NYcOGYfz48dizZ0+lF0lUXXiqjYiIyiI7QB0+fNggPAGAk5MToqKiEBISUqnFEREREZki2deB0mg0yM3NLdWel5cHc3PzSimKiIiIyJTJDlD9+vXD6NGjcezYMQghIITA0aNHMWbMGISFhVVFjUREREQmRXaAWrFiBRo0aICgoCBYWFjAwsICISEhaNiwIT766CNZY8XHx6N///5wd3eHQqHArl27SvU5f/48wsLCYG9vD1tbW3Ts2BFXr16VjhcUFGDcuHGoW7curK2tERYWhuvXrxuMkZiYiNatW8PHxwdr166V2jt27IixY8ca9F21ahUUCgXWrVtn0B4ZGYng4GBZ8yMiIqLaSXaAqlOnDr755hskJyfj66+/xvbt25GcnIzY2FjY29vLGuvu3bto1aoVPv744zKP//777+jUqRP8/f2h1Wrx66+/YtasWbCwsJD6TJw4EbGxsdi2bRuOHDmCvLw89OvXDzqdTuoTERGBWbNmYevWrVi8eLEUwEJDQxEXF2fwnlqtFl5eXmW2h4aGypofERER1U5PdB0oAGjUqBEaNWr0VG/eu3dv9O7du9zj7733Hvr06YMlS5ZIbX5+ftJ/Z2dnY926ddi0aRO6desGAPjiiy/g5eWFgwcPomfPngCAe/fuoU2bNnB2doaDgwPy8vIAPAhQUVFRyMjIgJubG4AHm+TnzJmDBQsWSO9z7do1XL58mQGKiIiIABgZoCZNmmT0gMuWLXviYh6m1+uxZ88eTJs2DT179sSpU6fg6+uLd999FwMHDgQAnDhxAkVFRejRo4f0Ond3dzRv3hwJCQlSgJo9ezaaNGmC4uJijB07Fk2bNgUAhISEQK1WQ6vVYujQoTh37hzy8/MRERGB6dOnIyUlBY0aNUJcXBzMzc0rPIVXUFCAgoIC6XlOTg4AoKioCEVFRQAApVIJlUoFnU4HvV4v9S1pLy4uhhBCalepVFAqleW2l4xbwszswcdZXFxsVLtarYZerzdYrVMoFDAzMyu3vbzaOSfOiXPinExpTg97+DXVOadHa+LnZLpzMoZRAerUqVNGDaZQKIzqZ4wbN24gLy8PUVFRmD9/PhYvXox9+/bhxRdfRFxcHDp37ozMzEyYm5vDwcHB4LUuLi4Gt9+IjIzEkCFDUFhYaNDX2toa7dq1kwKUVqtFp06doNFoEBISAq1Wi0aNGkGr1aJDhw6wsrIqt95Fixbh/fffL9W+f/9+6XXe3t4ICAjA6dOnDfZxNW7cGP7+/vj5559x8+ZNqb1k31Z8fLzBNx+DgoLg7OyM/fv3G3zQoaGhsLS0xN69ew1q6NOnD/Lz8w1OS5qZmaFv3764desWEhMTpXZbW1t07doV165dQ1JSktRer149BAcHIyUlBcnJyVI758Q5cU6ckynOqcT9+/elY9U9p5J/ZJfUxM/JNOf0008/wRgK8XD8qkYKhQKxsbHS6lJ6ejo8PDwwdOhQbNmyReoXFhYGa2trbN26FVu2bEF4eLjByg8AdO/eHQ0aNMDq1asf+74zZ86U9nENHjwY7dq1w9SpUxEVFYXffvsNmzdvhp+fH0aMGIG5c+eWO05ZK1BeXl64desW7OzsADDhc06cE+fEOf1dc/L19UVaWho8PDyQmppqEnPy9PQ0qImfk2nOKSsrC05OTsjOzpZ+f5flifdAVbW6devCzMxMOt1WokmTJjhy5AiAB7fEKCwsxJ07dwxWlm7cuGH0N+ZCQ0OxYMECpKWl4fDhw5gyZQoAoHPnzoiOjsbVq1eRmpr62P1PGo0GGo2mVLtarYZarTZoU6lUZd43sOT/SMa2Pzruk7QrlcpSS8sVtZdXO+fEOclt55w4J6Dq51TWseqaU3k18XOqGXMqVYdRvaqBubk52rVrZ7AcBwAXL16Ej48PAKBt27ZQq9U4cOCAdDwjIwNnzpwxOkAFBwdDo9Fg5cqVyM/PR9u2bQEAgYGByM7Oxpo1a2BhYYGOHTtW0syIiIiopqvWFai8vDxcunRJep6amoqkpCQ4OjrC29sbU6dOxauvvornn38eoaGh2LdvH3bv3g2tVgsAsLe3R2RkJCZPngwnJyc4OjpiypQpaNGihfStvMextLREhw4dEB0djZCQECmlqtVqBAUFITo6WgpZREREREA1r0AdP34cAQEBCAgIAPDg234BAQGYPXs2AGDQoEFYvXo1lixZghYtWuCzzz7Djh070KlTJ2mM5cuXY+DAgRg8eDBCQkJgZWWF3bt3l7lcV57Q0FDk5uaiS5cuBu2dO3dGbm4uL19AREREBkxmE3ltk5OTA3t7+8duQiMiosr38IbtR+9OUV1MsSYqzdjf3ya7B4qIiIjIVDFAEREREcnEAEVEREQkEwMUERERkUwMUEREREQymeyVyImIiJ5UWlqa9L+enp5PNdaNGzeg0+mgUqng7Oz8xONkZGQ8VR1kWhigiIioVisJU09Lr9dXyli2traVUA1VNwYoIiKq1Tw8PJ7q9RkZGdDr9VAqlXBzc3uqsWxtbTFv3rynGoNMAwMUERHVOpV5jeiSC2C6ubnxApgk4SZyIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZGKCIiIiIZGKAIiIiIpKJAYqIiIhIJgYoIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZGKCIiIiIZGKAIiIiIpKJAYqIiIhIJgYoIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZGKCIiIiIZGKAIiIiIpKJAYqIiIhIJgYoIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZGKCIiIiIZGKAIiIiIpKJAYqIiIhIJgYoIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZamSAio+PR//+/eHu7g6FQoFdu3YZHM/Ly8Pbb78NT09PWFpaokmTJli1apVBn4KCAowbNw5169aFtbU1wsLCcP36dYM+iYmJaN26NXx8fLB27dqqnhYREf2NAgMD4enp+dhHRkYGACAjI+OxfQMDA6t5VvR3MavuAp7E3bt30apVK4SHh+Oll14qdfydd95BXFwcvvjiC9SvXx/79+/Hm2++CXd3dwwYMAAAMHHiROzevRvbtm2Dk5MTJk+ejH79+uHEiRNQqVQAgIiICMyfPx9ubm4YMWIEevbsCW9v7791rkREVDUyMzORlpZmdH+9Xi+rP9VuNTJA9e7dG7179y73eGJiIkaOHIkuXboAAEaPHo01a9bg+PHjGDBgALKzs7Fu3Tps2rQJ3bp1AwB88cUX8PLywsGDB9GzZ08AwL1799CmTRs4OzvDwcEBeXl55b5nQUEBCgoKpOc5OTkAgKKiIhQVFQEAlEolVCoVdDod9Hq91Lekvbi4GEIIqV2lUkGpVJbbXjJuCTOzBx9ncXGxUe1qtRp6vR46nU5qUygUMDMzK7e9vNo5J86Jc+KcatqcXFxcYIwbN25Ap9NBpVLB2dm5wr6urq78nGrBnIxRIwPU43Tq1AnffvstIiIi4O7uDq1Wi4sXL+Kjjz4CAJw4cQJFRUXo0aOH9Bp3d3c0b94cCQkJUoCaPXs2mjRpguLiYowdOxZNmzYt9z0XLVqE999/v1T7/v37YWVlBQDw9vZGQEAATp8+jatXr0p9GjduDH9/f/z888+4efOm1F5y+jA+Ph65ublSe1BQEJydnbF//36DDzo0NBSWlpbYu3evQQ19+vRBfn4+4uLipDYzMzP07dsXt27dQmJiotRua2uLrl274tq1a0hKSpLa69Wrh+DgYKSkpCA5OVlq55w4J86Jc6qpc5o9e7bBnP74448y53ThwoUy53Tq1Kky55SQkMDPqQbP6aeffoIxFOLh+FUDKRQKxMbGYuDAgVJbYWEhXn/9dWzcuBFmZmZQKpX47LPPMHz4cADAli1bEB4ebrBiBAA9evSAr68v1qxZI7XdvXsXhYWFcHBwqLCOslagvLy8cOvWLdjZ2QFgwuecOCfOiXPinDgnU59TVlYWnJyckJ2dLf3+LkutXIFasWIFjh49im+//VZKyG+++Sbc3NykU3ZlEUJAoVAYtFlbW8Pa2vqx76nRaKDRaEq1q9VqqNVqgzaVSiXts3pYyf+RjG1/dNwnaVcqlVAqS3+XoLz28mrnnDgnue2cE+cEcE7l1Si3nXOq+jmV6mdUrxokPz8f//73vxEbG4u+ffsCAFq2bImkpCQsXboU3bp1g6urKwoLC3Hnzh2DlaUbN24gODi4ukonIiKiGqJGXsagIiWbth9NpyqVSlrCa9u2LdRqNQ4cOCAdz8jIwJkzZxigiIiI6LFq5ApUXl4eLl26JD1PTU1FUlISHB0d4e3tjc6dO2Pq1KmwtLSEj48PDh8+jI0bN2LZsmUAAHt7e0RGRmLy5MlwcnKCo6MjpkyZghYtWlR4io+IiIgIqKGbyLVaLUJDQ0u1jxw5Ehs2bEBmZibeffdd7N+/H1lZWfDx8cHo0aPxzjvvSHuc7t+/j6lTp2LLli3Iz8/HCy+8gJUrV8LLy6tSaszJyYG9vf1jN6ERERGR6TD293eNDFA1AQMUERFRzWPs7+9atweKiIiIqKoxQBERERHJxABFREREJBMDFBEREZFMDFBEREREMjFAEREREclUIy+kWROUXB0iJyenmishIiIiY5X83n7cVZ4YoKpIbm4uAFTahTmJiIjo75Obmwt7e/tyj/NCmlVEr9cjPT0dtra20tXPqfbKycmBl5cXrl27xgunEtUy/Pl+tgghkJubC3d391L31X0YV6CqiFKphKenZ3WXQX8zOzs7/gVLVEvx5/vZUdHKUwluIiciIiKSiQGKiIiISCYGKKJKoNFoMGfOHGg0muouhYgqGX++qSzcRE5EREQkE1egiIiIiGRigCIiIiKSiQGKiIiISCYGKCIiIiKZGKCIiIge0qVLF0ycOLG6yyATxwBFJi8hIQEqlQq9evUqdaywsBBLlixBq1atYGVlhbp16yIkJAQxMTEoKiqS+mVmZmLcuHHw8/ODRqOBl5cX+vfvj0OHDkl96tevD4VCUeoRFRUl9dmxYwc6dOgAe3t72NraolmzZpg8ebJ0XKfTYdGiRfD394elpSUcHR3RsWNHxMTEPHaely5dQnh4ODw9PaHRaODr64uhQ4fi+PHjUp+Smo4ePWrw2oKCAjg5OUGhUECr1QIArly5gsjISPj6+sLS0hINGjTAnDlzUFhY+Pg/dCITN2rUKAwcOLBUu1arhUKhwF9//VVp7/VooLp8+TKGDh0Kd3d3WFhYwNPTEwMGDMDFixelPnFxcQgNDYWjoyOsrKzQqFEjjBw5EsXFxRg1alSZf9c8/CDTx1u5kMlbv349xo0bh88++wxXr16Ft7c3gAfhqWfPnvj1118xb948hISEwM7ODkePHsXSpUsREBCA1q1b48qVKwgJCUGdOnWwZMkStGzZEkVFRfj+++/x1ltv4cKFC9J7/ec//8Hrr79u8P62trYAgIMHD2LIkCFYuHAhwsLCoFAocO7cOYMQNnfuXHz66af4+OOPERgYiJycHBw/fhx37typcI7Hjx/HCy+8gObNm2PNmjXw9/dHbm4uvvnmG0yePBmHDx+W+np5eSEmJgYdO3aU2mJjY2FjY4OsrCyp7cKFC9Dr9VizZg0aNmyIM2fO4PXXX8fdu3exdOnSJ/gkiKiwsBDdu3eHv78/du7cCTc3N1y/fh179+5FdnY2AODs2bPo3bs3xo8fj+joaFhaWiIlJQVff/019Ho9PvroI4N/mLm5uSEmJqbMfySSCRNEJiwvL0/Y2tqKCxcuiFdffVW8//770rHFixcLpVIpTp48Wep1hYWFIi8vTwghRO/evYWHh4f0/GF37tyR/tvHx0csX7683FomTJggunTpUmG9rVq1EnPnzn3MrAzp9XrRrFkz0bZtW6HT6SqsEYCYOXOmsLOzE/fu3ZPau3fvLmbNmiUAiLi4uHLfa8mSJcLX11dWfUSmaOTIkWLAgAGl2uPi4gQAcefOHXHr1i0xZMgQ4eHhISwtLUXz5s3Fli1bDPrn5eWJ4cOHC2tra+Hq6iqWLl0qOnfuLCZMmCD1efj5qVOnBABx5cqVcmtbvny5qF+/vtFzASBiY2ON7k+mgafwyKR9+eWXaNy4MRo3boxhw4YhJiYG4v+u/bp582Z069YNAQEBpV6nVqthbW2NrKws7Nu3D2+99Rasra1L9atTp47Rtbi6uuLs2bM4c+ZMhX1++OEH3Lx50+hxk5KScPbsWUyePLnMO38/WmPbtm3h6+uLHTt2AACuXbuG+Ph4DB8+/LHvlZ2dDUdHR6NrI6rJ7t+/j7Zt2+K7777DmTNnMHr0aAwfPhzHjh2T+kydOhVxcXGIjY3F/v37odVqceLEiXLHrFevHpRKJb7++mvodLoy+7i6uiIjIwPx8fGVPicyHQxQZNLWrVuHYcOGAQB69eqFvLw86ZRZSkoK/P39K3z9pUuXIIR4bL8S06dPh42NjcGjZE/RuHHj0K5dO7Ro0QL169fHkCFDsH79ehQUFEivX7ZsGW7evAlXV1e0bNkSY8aMwf/+978K3zMlJQUAjK4RAMLDw7F+/XoAQExMDPr06YN69epV+Jrff/8d0dHRGDNmjNHvQ2TKvvvuu1I/r71795aOe3h4YMqUKWjdujX8/Pwwbtw49OzZE9u3bwcA5OXlYd26dVi6dCm6d++OFi1a4PPPPy83GJWMuWLFCsyePRsODg7o2rUr5s2bh8uXL0t9XnnlFQwdOhSdO3eGm5sbBg0ahI8//hg5OTlV94dBfzsGKDJZycnJ+PnnnzFkyBAAgJmZGV599VUpOAghHrvZsmS1ythNmVOnTkVSUpLBo0OHDgAAa2tr7NmzB5cuXcLMmTNhY2ODyZMno3379rh37x4AoGnTpjhz5gyOHj2K8PBw/Pnnn+jfvz/+9a9/AXiwavbwX/Y//vij7BoBYNiwYUhMTMTly5exYcMGREREVNg/PT0dvXr1wiuvvCLVQlTThYaGlvp5/eyzz6TjOp0OCxYsQMuWLeHk5AQbGxvs378fV69eBfDgHxWFhYUICgqSXuPo6IjGjRtX+L5vvfUWMjMz8cUXXyAoKAjbt29Hs2bNcODAAQCASqVCTEwMrl+/jiVLlsDd3R0LFixAs2bNkJGRUQV/ElQtqvUEIlEFpk6dKgAIlUolPZRKpdBoNCIrK0u0bNlS9OjRo8Ixbt++LRQKhVi4cOFj3+9xe6DKcvnyZWFmZibWr19fbp9NmzYJAOLy5csiJydHpKSkSI979+6JkydPCgCl9maUBQ/tlXj55ZdFly5dhJubmyguLhZ37twpcw9UWlqaeO6558Tw4cPL3GNFVBMZswdq8eLFwsnJSWzatEkkJSWJlJQU0bdvX+l1JfuZ/vjjD4MxWrduXe4eqLLo9XrRvXt38fzzz5fbJysrS9StW1fMnj271DFwD1SNxBUoMknFxcXYuHEjPvjgA4N/Xf7666/w8fHB5s2b8dprr+HgwYM4depUma+/e/cuHB0d0bNnT3zyySe4e/duqX5P+1Xn+vXrw8rKqsyxSzRt2hQAcPfuXdja2qJhw4bSw9LSEq1bt0bTpk3xwQcfQK/XG11jREQEtFotRowYAZVKVWaftLQ0dOnSBW3atEFMTEyZe6yIaqsff/wRAwYMwLBhw9CqVSv4+flJp8wBoGHDhlCr1QaXBblz547B5QiMoVAo4O/vX+HfAw4ODnBzc6uwD9UsvIwBmaTvvvsOd+7cQWRkJOzt7Q2Ovfzyy1i3bh2OHj2KPXv24IUXXsC8efPQqVMn2Nra4vjx41i8eDHWrVuH1q1bY+XKlQgODkb79u3xn//8By1btkRxcTEOHDiAVatW4fz589LYubm5yMzMNHg/Kysr2NnZYe7cubh37x769OkDHx8f/PXXX1ixYgWKiorQvXt3qbaQkBAEBwfD1dUVqampePfdd/Hcc8+Vu8dJoVAgJiYG3bp1w/PPP49///vf8Pf3R15eHnbv3o39+/cbXMagRK9evXDz5k3Y2dmVOW56ejq6dOkCb29vLF261GBju6urq3EfBFEN1rBhQ+zYsQMJCQlwcHDAsmXLkJmZiSZNmgAAbGxsEBkZialTp8LJyQkuLi547733KvyHRlJSEubMmYPhw4ejadOmMDc3x+HDh7F+/XpMnz4dALBmzRokJSVh0KBBaNCgAe7fv4+NGzfi7NmziI6O/lvmTn+D6l4CIypLv379RJ8+fco8duLECQFAnDhxQty/f18sWrRItGjRQlhYWAhHR0cREhIiNmzYIIqKiqTXpKeni7feekv4+PgIc3Nz4eHhIcLCwgxOd/n4+AgApR5vvPGGEEKIH374Qbz00kvCy8tLmJubCxcXF9GrVy/x448/SmN8+umnIjQ0VNSrV0+Ym5sLb29vMWrUqAq/8lwiOTlZjBgxQri7uwtzc3Ph4+Mjhg4danCZBlSw1P/oKbyYmJgy58Mfe6oNjDmFd/v2bTFgwABhY2MjnJ2dxcyZM8WIESMMXpebmyuGDRsmrKyshIuLi1iyZEmFlzG4efOmGD9+vGjevLmwsbERtra2okWLFmLp0qXSKfKTJ0+KYcOGCV9fX6HRaISTk5N4/vnnxbffflvmXCr6uSbTpRDi/3awEhEREZFRuCGCiIiISCYGKCIiIiKZGKCIiIiIZGKAIiIiIpKJAYqIiIhIJgYoIiIiIpkYoIiIiIhkYoAiIiIikokBioiIiEgmBigiIiIimRigiIiIiGT6f0FWaOU6uN0QAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot for \n", + "enso = [model_datasets_res[\"ACCESS-CM2\"]['enso'], obs_datasets_res[\"HadISST\"]['enso']]\n", + "\n", + "bplt = plt.boxplot(enso, labels=ds_labels, showmeans=True) # whis=(10,90),\n", + "for k in bplt.keys():\n", + " plt.setp(bplt[k], linewidth=2)\n", + "plt.title('ENSO diversity')\n", + "plt.ylabel('longitude of min/max SSTA')\n", + "plt.grid(linestyle='--', axis='y')\n", + "plt.gca().yaxis.set_major_formatter(plt.FuncFormatter(format_longitude))" + ] + }, { "cell_type": "markdown", "id": "b4b4dee0-0d9a-458f-b86b-2ccd9b785d2c",