ice_maps.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sea ice analyses (maps, timeseries, etc) for ACCESS-OM2 at multiple resolutions\n",
    "\n",
    "To get access to the rechunked ERA5 files in `uc0`, this notebook needs to be run with `gadi_jupyter -P v45 -t 15:00:00 -n 27 -q 'normalbw' -s 'gdata/uc0'` \n",
    "using this modified `gadi_jupyter` https://github.com/aekiss/nci_scripts/blob/append-storage/gadi_jupyter\n",
    "\n",
    "### TODO: \n",
    "- plot bias maps for runs forced by ERA5 `1deg_era5_iaf` and `025deg_era5_iaf` - see https://forum.access-hive.org.au/t/era-5-forced-access-om2-simulations/1103 (will I also need to use the JRA55 comparison runs?)\n",
    "- compare thickness with cryosat or ICESat data?\n",
    "- compare with SOSE ice data: http://sose.ucsd.edu/BSOSE6_iter133_solution.html\n",
    "- compare with MOM6 panantarctic `/scratch/x77/amh157/mom6/archive/mom6-panan`\n",
    "- compare with Pauthenet et al. SO climatology data: `/g/data/ik11/observations/Southern_Ocean_Climatology_PauthenetETAL2021/TS_Climato_Antarctic60S.nc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import cosima_cookbook as cc\n",
    "from dask.distributed import Client\n",
    "from glob import glob\n",
    "import os,sys\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as colors\n",
    "import matplotlib.ticker as mticker\n",
    "import dask.array as da\n",
    "import numpy as np\n",
    "import xarray as xr\n",
    "import netCDF4 as nc\n",
    "from tqdm import tqdm_notebook\n",
    "\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.feature as cft\n",
    "#from mpl_toolkits.basemap import Basemap\n",
    "from calendar import month_abbr\n",
    "import cmocean as cm\n",
    "import pandas as pd\n",
    "import calendar\n",
    "import cftime\n",
    "from datetime import timedelta\n",
    "from datetime import datetime\n",
    "import copy\n",
    "import xesmf\n",
    "import gzip\n",
    "import yaml\n",
    "from IPython.display import display, Markdown\n",
    "\n",
    "#import sys, os\n",
    "#sys.path.append(os.path.join(os.getcwd(), '..'))  # so we can import ../exptdata\n",
    "os.chdir('/g/data/v45/aek156/notebooks/github/aekiss/ice_analysis') # needed for ARE\n",
    "import exptdata\n",
    "#print('Available exptdata keys: ', [k for k in exptdata.exptdict.keys()])\n",
    "\n",
    "# set up time units and offset to suit CICE \n",
    "# see https://github.com/OceansAus/ACCESS-OM2-1-025-010deg-report/commit/ce3b6331bc4f304d2c5f957ccd2a0ae9ca5d6970#commitcomment-31646163\n",
    "# for e in exptdata.exptdict.keys():\n",
    "#     exptdata.exptdict[e]['time_units'] = None\n",
    "\n",
    "# Set up time_units to suit CICE \n",
    "# Only retain netcdf time_units for 0.1 deg.\n",
    "# We need to change time_units of 1deg and 0.25 deg \n",
    "# to shift the time so the last cycle starts in 1958.\n",
    "# But we don't need offset because CICE time starts at beginning of run, \n",
    "# unlike MOM which starts in year 0001.\n",
    "#exptdata.exptdict['01deg']['time_units'] = \"days since 1985-01-01\"  # don't use None - it leaves the time as cftime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exptdata.exptdict.keys()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# change to chio value 0.006 actually used - see chio bug: https://github.com/COSIMA/cice5/issues/55\n",
    "for ekey, ide in exptdata.exptdict.items():\n",
    "    if 'perturbed' in ide[0]:\n",
    "        if ide[0]['perturbed'] != 'chio':\n",
    "            if 'chio' in ide[0]['params']:\n",
    "                if ide[0]['params']['chio'] == 0.004:\n",
    "                    ide[0]['params']['chio'] = 0.006\n",
    "                    print('set chio=0.006 in', ekey)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "toc-hr-collapsed": true
   },
   "outputs": [],
   "source": [
    "import climtas.nci\n",
    "climtas.nci.GadiClient(malloc_trim_threshold='64kib')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# force memory cleanup - see https://distributed.dask.org/en/latest/worker.html#memtrim\n",
    "\n",
    "import ctypes\n",
    "\n",
    "def trim_memory() -> int:\n",
    "    libc = ctypes.CDLL(\"libc.so.6\")\n",
    "    return libc.malloc_trim(0)\n",
    "\n",
    "client.run(trim_memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "figdir = 'figs'\n",
    "dpi=200\n",
    "if not os.path.exists(figdir):\n",
    "    os.makedirs(figdir)\n",
    "\n",
    "def figname(fname, figdir=figdir):\n",
    "    return os.path.join(figdir, fname+'_'+str(dpi)+'dpi.png')\n",
    "\n",
    "def savefigure(fname, skip=False):\n",
    "    if not(os.path.exists(fname) and skip):\n",
    "        plt.savefig(fname, dpi=dpi, bbox_inches='tight')  # comment out to disable saving\n",
    "        pass\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specify date range"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# for comparison to fig 4 of WangIlicakGerdesDrangeAksenovBaileyBentsenBiastochBozec2016a\n",
    "tstart = pd.to_datetime('2007', format='%Y')\n",
    "tend = tstart + pd.DateOffset(years=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use common start and end dates for all runs\n",
    "tstart = exptdata.clim_tstart\n",
    "tend = exptdata.clim_tend"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# full JRA55-do v1.4.0 period\n",
    "tstart = pd.to_datetime('1958', format='%Y')\n",
    "tend = pd.to_datetime('2019', format='%Y')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# for movie\n",
    "tstart = pd.to_datetime('2016', format='%Y')\n",
    "tend = pd.to_datetime('2018', format='%Y')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# parameter ensemble\n",
    "tstart = pd.to_datetime('1968', format='%Y')\n",
    "tend = pd.to_datetime('2019', format='%Y')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# just the last bit for testing\n",
    "tstart = tend - pd.DateOffset(years=1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timerange=slice(tstart, tend)\n",
    "firstyear = pd.to_datetime(tstart).year  # assumes tstart is 1 January!\n",
    "lastyear = pd.to_datetime(tend).year-1  # assumes tend is 1 January!\n",
    "yearrange = str(firstyear)+'-'+str(lastyear)\n",
    "print('yearrange =', yearrange, 'complete years')\n",
    "print('tstart =', tstart)\n",
    "print('tend =', tend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Define data loaders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fixcicetime(da):\n",
    "    '''\n",
    "    Correct the time coordinate in DataArray from CICE netcdf file.\n",
    "    \n",
    "    CICE netcdf files unhelpfully have a time coordinate which is just after the end of the averaging period, \n",
    "    e.g. the time stamp for a January average is 1 February, which messes up groupby month etc.\n",
    "    \n",
    "    This function just subtracts 12 hours to put it in the correct month (and day, for daily means).\n",
    "    \n",
    "    PR 109 gives an option to fix this:\n",
    "    https://github.com/OceansAus/cosima-cookbook/pull/109\n",
    "    \n",
    "    '''\n",
    "    try:\n",
    "        da['time'] = da.time - np.timedelta64(12, 'h')\n",
    "    except:\n",
    "        da['time'] = da.time - timedelta(hours=12)  # for 01deg which for some reason uses cftime\n",
    "    return da\n",
    "\n",
    "# use this for DataSet: replaces the bad time dimension with the average of time_bounds.\n",
    "#     The time type is also changed to datetime64[ns]\n",
    "#     ds['time'] = ds.time_bounds.astype('int64').mean(axis=1).astype('datetime64[ns]')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loaddata(ide, varnames=['aice_m'], timerange=timerange, ncfiles=None, model='cice', **kwargs):\n",
    "# load model data\n",
    "#   NB: varnames must be t-grid variables!!\n",
    "\n",
    "    grids = [(p, xr.open_dataset(p)) for p in ide['gridpaths']]\n",
    "    for k in ['xt_ocean', 'yt_ocean', 'geolon_t', 'geolat_t', 'area_t']:\n",
    "        if k not in ide:\n",
    "            for (p, g) in grids:\n",
    "                try:\n",
    "                    ide[k] = g[k]\n",
    "                    print(k, 'loaded from', p)\n",
    "                    break\n",
    "                except:\n",
    "                    continue\n",
    "            try:\n",
    "                ide[k] = ide[k].rename({'grid_x_T': 'xt_ocean', 'grid_y_T': 'yt_ocean'}) # fix for 01deg\n",
    "            except:\n",
    "                pass\n",
    "\n",
    "    if not isinstance(ncfiles, list):\n",
    "        ncfiles = [ncfiles]*len(varnames)  # use the same ncfile for all variables\n",
    "\n",
    "    for varname, ncfile in zip(varnames, ncfiles):\n",
    "        if varname not in ide.keys():\n",
    "            if ncfile is None:\n",
    "                print('loading', varname)\n",
    "            else:\n",
    "                print('loading', varname, 'from', ncfile)                \n",
    "            var = cc.querying.getvar(ide['expt'], varname, ide['session'], ncfile=ncfile,\n",
    "                                                 start_time=str(timerange.start),\n",
    "                                                 end_time=str(timerange.stop+timedelta(hours=12)),  # tweak since fixcicetime hasn't been applied yet\n",
    "                                                 decode_coords=False, **kwargs)\n",
    "#             if ide['offset']:\n",
    "#                 var['time'] = var['time'] + ide['offset']  # BUG: already trimmed by start_time, end_time\n",
    "            if model.lower()=='cice':\n",
    "                try:\n",
    "                    var = fixcicetime(var).sel(time=timerange)\n",
    "                except:\n",
    "                    pass\n",
    "                # use physical coords instead of indices - ASSUMES VARIABLES ARE ON T GRID!\n",
    "#                 var.coords['ni'] = ide['xt_ocean'].data\n",
    "#                 var.coords['nj'] = ide['yt_ocean'].data\n",
    "                var = var.rename(({'ni': 'xt_ocean', 'nj': 'yt_ocean'}))\n",
    "#                 var = var.assign_coords({'latitude': ide['geolat_t'], 'longitude': ide['geolon_t']})\n",
    "            else:\n",
    "                try:\n",
    "                    var = var.sel(time=timerange)\n",
    "                except:\n",
    "                    pass\n",
    "            var.coords['xt_ocean'] = ide['xt_ocean'].data\n",
    "            var.coords['yt_ocean'] = ide['yt_ocean'].data\n",
    "            var = var.assign_coords({'latitude': ide['geolat_t'], 'longitude': ide['geolon_t']})\n",
    "            ide[varname] = var\n",
    "            try:\n",
    "                varmm = var.groupby('time.month').mean('time', skipna=True)\n",
    "                ide[varname+'_mm'] = varmm\n",
    "            except:\n",
    "                pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadJRA55do(ide, expt='MRI-JRA55-do-1-4-0', varnames=[], timerange=timerange): #, session=JRAsession):\n",
    "# load JRA55-do data\n",
    "    for varname in varnames:\n",
    "        if varname not in ide.keys():\n",
    "            print('loading', varname)\n",
    "            var = cc.querying.getvar(expt, varname, ide['session'],\n",
    "                                                 start_time=str(timerange.start),\n",
    "                                                 end_time=str(timerange.stop),\n",
    "                                                 decode_coords=False)\n",
    "            var = var.rename(({'lon': 'longitude', 'lat': 'latitude'}))\n",
    "            var = var.sel(time=timerange)\n",
    "\n",
    "            ide[varname] = var\n",
    "            \n",
    "            vard = var.resample(time='d').mean() # daily averages\n",
    "            vard.attrs = var.attrs\n",
    "            ide[varname+'_d'] = vard\n",
    "            \n",
    "            varm = var.resample(time='m').mean() # monthly averages\n",
    "            varm.attrs = var.attrs\n",
    "            ide[varname+'_m'] = varm\n",
    "\n",
    "            varmm = var.groupby('time.month').mean('time', skipna=True)\n",
    "            varmm.attrs = var.attrs\n",
    "            ide[varname+'_mm'] = varmm"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def get_sic_obs_daily(obsFileList, years=range(1978, 2020), months=range(1, 13), days=range(1, 32), variable='goddard_merged_seaice_conc'): \n",
    "    '''\n",
    "    Return a dataarray from the daily nc files in obsFileList.\n",
    "    '''\n",
    "    dataarrays = []\n",
    "    for year in tqdm_notebook(years, leave=False, desc='year'):\n",
    "        for month in tqdm_notebook(months, leave=False, desc='month'):\n",
    "            for day in days:\n",
    "                datestr = ''.join([str(year), str(month).zfill(2), str(day).zfill(2)])\n",
    "                obs_fname = [ IceFile for IceFile in obsFileList if os.path.basename(IceFile).split('_')[5]==datestr ]  # this is pretty inefficient!\n",
    "                \n",
    "                if len(obs_fname)>0:\n",
    "                    dataarray = xr.open_dataset(obs_fname[0],\n",
    "                                                decode_times=False,\n",
    "#                                                 autoclose=True\n",
    "                                               )[variable]\n",
    "                    dataarrays.append(dataarray)\n",
    "    dataarray = xr.concat(dataarrays, dim='time', coords='all')\n",
    "    if 'time' in dataarray.coords:\n",
    "        time_units = dataarray.time.units\n",
    "        decoded_time = xr.conventions.times.decode_cf_datetime(dataarray.time, time_units)\n",
    "        dataarray.coords['time'] = ('time', decoded_time,\n",
    "                                    {'long_name': 'time', 'decoded_using': time_units }\n",
    "                                   )\n",
    "\n",
    "#     dataarray.coords['longitude'] = dataarray.coords['longitude'].isel(time=0)\n",
    "#     dataarray.coords['latitude'] = dataarray.coords['latitude'].isel(time=0)\n",
    "\n",
    "#     dataarray.coords['longitude'] = dataarray.longitude.isel(time=0)\n",
    "#     dataarray.coords['latitude'] = dataarray.latitude.isel(time=0)\n",
    "\n",
    "\n",
    "    # replace values outside valid range with nan\n",
    "    dataarray = dataarray.where(xr.ufuncs.logical_and(dataarray>=0, dataarray<=1), np.nan)\n",
    "\n",
    "    return dataarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sic_obs(pattern, path='/g/data3/hh5/tmp/cosima/observations/NOAA/G02202_V3', # from http://nsidc.org/data/G02202\n",
    "                variable='goddard_merged_seaice_conc_monthly', timerange=timerange): \n",
    "    '''\n",
    "    Return a dataarray from the nc files in path/pattern.\n",
    "    '''\n",
    "    dataarrays = []\n",
    "    files = glob(os.path.join(path, pattern))\n",
    "    for f in tqdm_notebook(files, leave=False, desc='opening files'):\n",
    "        dataarrays.append(xr.open_dataset(f, decode_times=False)[variable])\n",
    "    dataarray = xr.concat(dataarrays, dim='time', coords='all')\n",
    "    if 'time' in dataarray.coords:\n",
    "        time_units = dataarray.time.units\n",
    "        decoded_time = xr.conventions.times.decode_cf_datetime(dataarray.time, time_units)\n",
    "        dataarray.coords['time'] = ('time', decoded_time,\n",
    "                                    {'long_name': 'time', 'decoded_using': time_units })\n",
    "\n",
    "    # replace values outside valid range with nan\n",
    "    dataarray = dataarray.where(np.logical_and(dataarray>=0, dataarray<=1)) #, np.nan)\n",
    "    \n",
    "    # use the same coord names as access-om2 t grid\n",
    "    dataarray = dataarray.rename(({'xgrid': 'xt_ocean', 'ygrid': 'yt_ocean'}))\n",
    "    \n",
    "    # sort by time and select timerange\n",
    "    dataarray = dataarray.sortby('time').sel(time=timerange)\n",
    "\n",
    "    return dataarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_giomas(path='/g/data/v45/aek156/giomas/Global_seaice', # from sftp anonymous@pscfiles.apl.uw.edu:/pscfiles/zhang/Global_seaice\n",
    "                variable='heff', timerange=timerange, varrange=[None, None], scale=1.0): \n",
    "    '''\n",
    "    Return a dataarray of GIOMAS data from the flat binary .gz files in path/variable.H????.gz\n",
    "    variable defaults to 'heff' but can be any of 'heff', 'area', 'iceprod', 'snow' (and maybe others)\n",
    "    GIOMAS info: http://psc.apl.washington.edu/zhang/Global_seaice/data.html\n",
    "    '''\n",
    "    # regridded giomas SIT, SIC is also here /g/data/v14/pas548/obs/seaice/giomas/ \n",
    "    grids = xr.open_dataset(os.path.join(path, 'heff.H1979.nc.gz'), decode_times=False)  # open this to get grid data\n",
    "    shape = grids.heff.shape\n",
    "    l = grids.lon_scaler\n",
    "    longitude = xr.where(np.logical_and(l>l.isel(i=-1, j=0), l.i<shape[-1]/2), l-360, l) # move discontinuity to i=0\n",
    "    xt_ocean = longitude.sel(j=0)  # nominal coordinate - incorrect in Arctic\n",
    "    yt_ocean = xr.DataArray(np.linspace(grids.lat_scaler.min(), grids.lat_scaler.max(), shape[1]))  # nominal coordinate - incorrect in Arctic and probably elsewhere\n",
    "    \n",
    "    dataarrays = []\n",
    "    for year in tqdm_notebook(range(timerange.start.year, timerange.stop.year+1), leave=False, desc='opening files'):\n",
    "        file = os.path.join(path, variable+'.H'+str(year)+'.gz')\n",
    "        with gzip.open(file, 'rb') as f:\n",
    "            data=np.frombuffer(f.read(), dtype=np.single).reshape(shape)\n",
    "            time = [ cftime.datetime(year, m, 15) for m in range(1,13) ]\n",
    "#             time = [ datetime(year, m, 15) for m in range(1,13) ]  # workaround for type error: https://arccss.slack.com/archives/C08KM5KS6/p1625538785048700\n",
    "            dataarrays.append(xr.DataArray(data, \n",
    "                                           dims=('time', 'yt_ocean', 'xt_ocean'),\n",
    "                                           coords={'time': time, 'yt_ocean': yt_ocean.data, 'xt_ocean': xt_ocean.data}))\n",
    "    dataarray = xr.concat(dataarrays, dim='time', coords='all')\n",
    "\n",
    "    # sort by time and select timerange\n",
    "    dataarray = dataarray.sortby('time').sel(time=timerange)\n",
    "    \n",
    "    dataarray = dataarray.assign_coords({ 'latitude': (['yt_ocean', 'xt_ocean'], grids.lat_scaler.data),\n",
    "                                          'longitude': (['yt_ocean', 'xt_ocean'], longitude) }) #grids.lon_scaler.data) })\n",
    "    \n",
    "    dataarray = dataarray * scale\n",
    "    \n",
    "    # truncate data to varrange\n",
    "    if varrange[0] != None:\n",
    "        dataarray = dataarray.where(dataarray > varrange[0], varrange[0])\n",
    "    if varrange[1] != None:\n",
    "        dataarray = dataarray.where(dataarray < varrange[1], varrange[1])\n",
    "\n",
    "    return dataarray"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def get_sit_obs(obsFileList, years, months, variable='SIT'):\n",
    "    '''\n",
    "    Return a dataarray from the nc files in obsFileList.\n",
    "    '''\n",
    "# TODO: rewrite like get_sic_obs\n",
    "# TODO: use /g/data/v14/pas548/obs/seaice/giomas/GIOMAS_sea-ice.nc instead so we can load SIC\n",
    "    dataarrays = []\n",
    "    for year in tqdm_notebook(years, leave=False, desc='year'):\n",
    "        for month in tqdm_notebook(months, leave=False, desc='month'):\n",
    "            obs_fname = [IceFile for IceFile in obsFileList if IceFile.split('_')[-2:]==[str(year),str(month).zfill(2)+'.nc']][0]\n",
    "            dataarray = xr.open_dataset(obs_fname,\n",
    "                                        decode_times=False,\n",
    "#                                         autoclose=True\n",
    "                                       )[variable]\n",
    "            dataarrays.append(dataarray)\n",
    "    dataarray = xr.concat(dataarrays, dim='time', coords='all')\n",
    "    \n",
    "    # need to fix time axis - it is integers YYYYMM (!)\n",
    "    if 'time' in dataarray.coords:\n",
    "        decoded_time = xr.DataArray([datetime.strptime(str(d)+'15', '%Y%m%d') for d in dataarray['time'].data])\n",
    "        dataarray.coords['time'] = ('time', decoded_time,\n",
    "                                    {'long_name': 'time'}\n",
    "                                   )\n",
    "\n",
    "    dataarray = dataarray.rename({'lat': 'latitude', 'lon': 'longitude'})\n",
    "\n",
    "    return dataarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def obs_mm(obs, groupby='time.month'):\n",
    "    cobs = obs.groupby(groupby).mean('time', skipna=True)\n",
    "    cobs = cobs.assign_coords({'latitude': obs.latitude.isel(time=0),\n",
    "                              'longitude': obs.longitude.isel(time=0)})\n",
    "    return cobs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def obs_mstd(obs, groupby='time.month'):\n",
    "    cobs = obs.groupby(groupby).std('time', skipna=True)\n",
    "    cobs = cobs.assign_coords({'latitude': obs.latitude.isel(time=0),\n",
    "                              'longitude': obs.longitude.isel(time=0)})\n",
    "    return cobs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### JRA55 (not -do) data loader\n",
    "JRA55 is available on NCI at `/g/data/ua8/synda/CREATE-IP/reanalysis/JMA/JRA-55/JRA-55/atmos/`: http://climate-cms.wikis.unsw.edu.au/JRA55"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55path = '/g/data/ua8/synda/CREATE-IP/reanalysis/JMA/JRA-55/JRA-55/atmos/mon/v20200612/' # monthly means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_JRA55(variable, path=JRA55path, timerange=timerange):\n",
    "    '''\n",
    "    Return a dataarray for an JRA55 variable.\n",
    "    timerange is a slice object.\n",
    "    '''\n",
    "    files = glob(os.path.join(path, variable+'_*.nc'))\n",
    "    files.sort()\n",
    "\n",
    "    dataarray = xr.open_mfdataset(\n",
    "                files,\n",
    "                parallel=True,\n",
    "                autoclose=True,\n",
    "                decode_times=False)[variable]\n",
    "    if 'time' in dataarray.coords:\n",
    "        time_units = dataarray.time.units\n",
    "        decoded_time = xr.conventions.times.decode_cf_datetime(dataarray.time, time_units)\n",
    "        dataarray.coords['time'] = ('time', decoded_time,\n",
    "                                    {'long_name': 'time', 'decoded_using': time_units })\n",
    "    dataarray = dataarray.rename(({'lon': 'longitude', 'lat': 'latitude'}))\n",
    "    \n",
    "    # sort by time and select timerange\n",
    "#     dataarray = dataarray.sortby('time').sel(time=timerange)\n",
    "    dataarray = dataarray.sel(time=timerange)\n",
    "\n",
    "    return dataarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadJRA55(ide, varnames=[], **kwargs):\n",
    "    for varname in varnames:\n",
    "        if varname not in ide.keys():\n",
    "            print('loading', varname)\n",
    "            var = get_JRA55(varname, **kwargs)\n",
    "\n",
    "            ide[varname] = var\n",
    "            \n",
    "            vard = var.resample(time='d').mean() # daily averages\n",
    "            vard.attrs = var.attrs\n",
    "            ide[varname+'_d'] = vard\n",
    "            \n",
    "            varm = var.resample(time='m').mean() # monthly averages\n",
    "            varm.attrs = var.attrs\n",
    "            ide[varname+'_m'] = varm\n",
    "\n",
    "            varmm = var.groupby('time.month').mean('time', skipna=True)\n",
    "            varmm.attrs = var.attrs\n",
    "            ide[varname+'_mm'] = varmm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### ERA5 data loader\n",
    "ERA5 is available on NCI at `/g/data/rt52`: https://opus.nci.org.au/display/ERA5/ERA5+Community+Home\n",
    "but some of that is badly chunked. Correctly chunked replacements are at `/g/data/uc0/era5_tmp/single-levels/reanalysis` (see https://github.com/COSIMA/access-om2/issues/242#issuecomment-939718446) and `get_ERA5` automatically uses these if present.\n",
    "\n",
    "To get access to the rechunked ERA5 files in `uc0`, this notebook needs to be run with `gadi_jupyter -P v45 -t 15:00:00 -n 27 -q 'normalbw' -s 'gdata/uc0'` \n",
    "using this modified `gadi_jupyter` https://github.com/aekiss/nci_scripts/blob/append-storage/gadi_jupyter\n",
    "\n",
    "Also see https://github.com/COSIMA/access-om2/issues/242\n",
    "\n",
    "and https://cds.climate.copernicus.eu/cdsapp#!/dataset/reanalysis-era5-single-levels?tab=form\n",
    "\n",
    "The hourly single-level data is probably what we want. This appears to be from the \"reanalysis\" or \"HRES\" dataset (as opposed to the lower-resolution \"ensemble\" or \"EDA\" dataset).\n",
    "\n",
    "It's 1-hourly 0.25° data (higher resolution than JRA55-do, which is 3-hourly 0.5625°), though this has been interpolated from the reanalysis grid, which is 0.28125° (31km) for HRES.\n",
    "\n",
    "It's currently only from 1979 onwards but data from 1950 will be available soon (cf. 1958 for JRA55-do)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ERA5path = '/g/data/rt52/era5/single-levels/reanalysis'\n",
    "ERA5rechunkedpath = '/g/data/uc0/era5_tmp/single-levels/reanalysis' # see https://github.com/COSIMA/access-om2/issues/242#issuecomment-939718446\n",
    "if len(glob(ERA5rechunkedpath))==0:\n",
    "    print(\"ERROR: can't access\", ERA5rechunkedpath, ' - try using -s option in gadi_jupyter')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# ERA5vars is needed for get_ERA5 and loadERA5\n",
    "ERA5vars = dict()  # keys are all ERA5 variables in ERA5path; values are dicts with keys 'fvar' and 'attrs'\n",
    "ERA5varsfn = 'ERA5vars.yaml'\n",
    "try:\n",
    "    with open(ERA5varsfn, 'r') as f:\n",
    "        ERA5vars = yaml.load(f)\n",
    "except: # create file - takes about 20 min\n",
    "    for p in tqdm_notebook(glob(os.path.join(ERA5path, '*')), leave=False, desc='scanning for ERA5 variable names'):\n",
    "        files = glob(os.path.join(p, '2017', '*.nc'))\n",
    "        files.sort()\n",
    "        if len(files) > 0:\n",
    "            file = files[0]\n",
    "            da = xr.open_mfdataset(\n",
    "                    file,\n",
    "                    parallel=True,\n",
    "                    autoclose=True,\n",
    "                    decode_times=False)\n",
    "            vname = [ v for v in da.variables if v not in list(da.coords) ][0]  # assumes only one data variable per file\n",
    "            var = nc.Dataset(file).variables[vname]\n",
    "            ERA5vars[vname] = {'fvar': os.path.basename(p),  # subdir of ERA5path containing this variable\n",
    "                               'attrs': da[vname].attrs,\n",
    "                               'dimensions': var.dimensions,\n",
    "                               'chunking': var.chunking()} # could use this instead: ds.encoding['chunksizes']\n",
    "    with open(ERA5varsfn, 'w') as f:\n",
    "        yaml.dump(ERA5vars, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "`ERA5vars` keys are all available variables. Potentially relevant ones include:\n",
    "- `alnid`: Near IR albedo for diffuse radiation [(0 - 1)]\n",
    "- `alnip`: Near IR albedo for direct radiation [(0 - 1)]\n",
    "- `aluvd`: UV visible albedo for diffuse radiation [(0 - 1)]\n",
    "- `aluvp`: UV visible albedo for direct radiation [(0 - 1)]\n",
    "- `asn`: Snow albedo [(0 - 1)]\n",
    "- `blh`: Boundary layer height [m]\n",
    "- `cdww`: Coefficient of drag with waves [dimensionless]\n",
    "- `chnk`: Charnock [~]\n",
    "- `crr`: Convective rain rate [kg m**-2 s**-1]\n",
    "- `csfr`: Convective snowfall rate water equivalent [kg m**-2 s**-1]\n",
    "- `d2m`: **2 metre dewpoint temperature** [K]\n",
    "- `dwi`: 10 metre wind direction [degrees]\n",
    "- `fal`: Forecast albedo [(0 - 1)]\n",
    "- `fg10`: 10 metre wind gust since previous post-processing [m s**-1]\n",
    "- `flsr`: Forecast logarithm of surface roughness for heat [~]\n",
    "- `fsr`: Forecast surface roughness [m]\n",
    "- `i10fg`: Instantaneous 10 metre wind gust [m s**-1]\n",
    "- `ie`: Instantaneous moisture flux [kg m**-2 s**-1]\n",
    "- `iews`: Instantaneous eastward turbulent surface stress [N m**-2]\n",
    "- `ilspf`: Instantaneous large-scale surface precipitation fraction [(0 - 1)]\n",
    "- `inss`: Instantaneous northward turbulent surface stress [N m**-2]\n",
    "- `ishf`: Instantaneous surface sensible heat flux [W m**-2]\n",
    "- `istl1`: Ice temperature layer 1 [K]\n",
    "- `istl2`: Ice temperature layer 2 [K]\n",
    "- `istl3`: Ice temperature layer 3 [K]\n",
    "- `istl4`: Ice temperature layer 4 [K]\n",
    "- `lsm`: Land-sea mask [(0 - 1)]\n",
    "- `lsrr`: Large scale rain rate [kg m**-2 s**-1]\n",
    "- `lssfr`: Large scale snowfall rate water equivalent [kg m**-2 s**-1]\n",
    "- `mbld`: Mean boundary layer dissipation [W m**-2]\n",
    "- `mcpr`: Mean convective precipitation rate [kg m**-2 s**-1]\n",
    "- `mcsr`: Mean convective snowfall rate [kg m**-2 s**-1]\n",
    "- `mer`: Mean evaporation rate [kg m**-2 s**-1]\n",
    "- `metss`: Mean eastward turbulent surface stress [N m**-2]\n",
    "- `mlspf`: Mean large-scale precipitation fraction [Proportion]\n",
    "- `mlspr`: Mean large-scale precipitation rate [kg m**-2 s**-1]\n",
    "- `mlssr`: Mean large-scale snowfall rate [kg m**-2 s**-1]\n",
    "- `mn2t`: Minimum temperature at 2 metres since previous post-processing [K]\n",
    "- `mntpr`: Minimum total precipitation rate since previous post-processing [kg m**-2 s**-1]\n",
    "- `mntss`: Mean northward turbulent surface stress [N m**-2]\n",
    "- `mper`: Mean potential evaporation rate [kg m**-2 s**-1]\n",
    "- `mror`: Mean runoff rate [kg m**-2 s**-1]\n",
    "- `msdrswrf`: Mean surface direct short-wave radiation flux [W m**-2]\n",
    "- `msdrswrfcs`: Mean surface direct short-wave radiation flux, clear sky [W m**-2]\n",
    "- `msdwlwrf`: Mean surface downward long-wave radiation flux [W m**-2]\n",
    "- `msdwlwrfcs`: Mean surface downward long-wave radiation flux, clear sky [W m**-2]\n",
    "- `msdwswrf`: Mean surface downward short-wave radiation flux [W m**-2]\n",
    "- `msdwswrfcs`: Mean surface downward short-wave radiation flux, clear sky [W m**-2]\n",
    "- `msdwuvrf`: Mean surface downward UV radiation flux [W m**-2]\n",
    "- `mser`: Mean snow evaporation rate [kg m**-2 s**-1]\n",
    "- `msl`: Mean sea level pressure [Pa]\n",
    "- `mslhf`: Mean surface latent heat flux [W m**-2]\n",
    "- `msmr`: Mean snowmelt rate [kg m**-2 s**-1]\n",
    "- `msnlwrf`: Mean surface net long-wave radiation flux [W m**-2]\n",
    "- `msnlwrfcs`: Mean surface net long-wave radiation flux, clear sky [W m**-2]\n",
    "- `msnswrf`: Mean surface net short-wave radiation flux [W m**-2]\n",
    "- `msnswrfcs`: Mean surface net short-wave radiation flux, clear sky [W m**-2]\n",
    "- `msr`: Mean snowfall rate [kg m**-2 s**-1]\n",
    "- `msror`: Mean surface runoff rate [kg m**-2 s**-1]\n",
    "- `msshf`: Mean surface sensible heat flux [W m**-2]\n",
    "- `mssror`: Mean sub-surface runoff rate [kg m**-2 s**-1]\n",
    "- `mtdwswrf`: Mean top downward short-wave radiation flux [W m**-2]\n",
    "- `mtnlwrf`: Mean top net long-wave radiation flux [W m**-2]\n",
    "- `mtnlwrfcs`: Mean top net long-wave radiation flux, clear sky [W m**-2]\n",
    "- `mtnswrf`: Mean top net short-wave radiation flux [W m**-2]\n",
    "- `mtnswrfcs`: Mean top net short-wave radiation flux, clear sky [W m**-2]\n",
    "- `mtpr`: Mean total precipitation rate [kg m**-2 s**-1]\n",
    "- `mx2t`: Maximum temperature at 2 metres since previous post-processing [K]\n",
    "- `mxtpr`: Maximum total precipitation rate since previous post-processing [kg m**-2 s**-1]\n",
    "- `p140209`: Air density over the oceans [kg m**-3]\n",
    "- `ptype`: Precipitation type [code table (4.201)]\n",
    "- `rsn`: Snow density [kg m**-3]\n",
    "- `sd`: Snow depth [m of water equivalent]\n",
    "- `siconc`: **Sea ice area fraction** [(0 - 1)]\n",
    "- `skt`: Skin temperature [K]\n",
    "- `sp`: Surface pressure [Pa]\n",
    "- `sst`: Sea surface temperature [K]\n",
    "- `t2m`: **2 metre temperature** [K]\n",
    "- `tauoc`: Normalized stress into ocean [dimensionless]\n",
    "- `tsn`: Temperature of snow layer [K]\n",
    "- `u10`: **10 metre U wind component** [m s**-1]\n",
    "- `u100`: 100 metre U wind component [m s**-1]\n",
    "- `u10n`: Neutral wind at 10 m u-component [m s**-1]\n",
    "- `v10`: **10 metre V wind component** [m s**-1]\n",
    "- `v100`: 100 metre V wind component [m s**-1]\n",
    "- `v10n`: Neutral wind at 10 m v-component [m s**-1]\n",
    "- `wind`: 10 metre wind speed [m s**-1]\n",
    "- `wmb`: Model bathymetry [m]\n",
    "- `z`: Geopotential [m**2 s**-2]\n",
    "- `zust`: Friction velocity [m s**-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# list all available ERA5 variables\n",
    "ERA5varskeys = list(ERA5vars.keys())\n",
    "ERA5varskeys.sort()\n",
    "md = '| name | longname [units] | dimensions | chunking | path |\\n'\n",
    "md += '| --- | --- | --- | --- | --- |\\n'\n",
    "for k in ERA5varskeys:\n",
    "    fvar = ERA5vars[k]['fvar']\n",
    "    md += '| '+' | '.join([ '`'+k+'`', \n",
    "                           ERA5vars[k]['attrs']['long_name']+' ['+ERA5vars[k]['attrs']['units']+']', \n",
    "                           repr(ERA5vars[k]['dimensions']),\n",
    "                           repr(ERA5vars[k]['chunking']),\n",
    "                           '`'+os.path.join(ERA5path, fvar, '*', fvar+'*.nc')+'`'])+' |\\n'\n",
    "display(Markdown(md))\n",
    "# print(md)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# find all ERA5 files in ERA5path with bad chunking\n",
    "# this is slow! and was only needed to send info to NCI\n",
    "ERA5varskeys = list(ERA5vars.keys())\n",
    "ERA5varskeys.sort()\n",
    "for vname in tqdm_notebook(ERA5varskeys, leave=False, desc='scanning ERA5 variables'):\n",
    "    fvar = ERA5vars[vname]['fvar']\n",
    "    filenames = os.path.join(ERA5path, fvar, '*', fvar+'*.nc')\n",
    "    files = glob(filenames)\n",
    "    files.sort()\n",
    "    allchunks = []\n",
    "    badchunks = []\n",
    "    for f in tqdm_notebook(files, leave=False, desc='scanning '+vname+' files'):\n",
    "#         print(vname, f)\n",
    "#         ds = xr.open_mfdataset(\n",
    "#                 f,\n",
    "#                 parallel=True,\n",
    "#                 autoclose=True,\n",
    "#                 decode_times=False)\n",
    "        var = nc.Dataset(f).variables[vname]\n",
    "        chunk = var.chunking()\n",
    "        allchunks.append(chunk)\n",
    "        if chunk[0] > 200:\n",
    "            badchunks.append(repr(chunk)+' '+f)\n",
    "#         break\n",
    "    unique_allchunks = [repr(list(x)) for x in set(tuple(x) for x in allchunks)]\n",
    "    unique_allchunks.sort()\n",
    "    print(vname, repr(ERA5vars[vname]['dimensions']), ERA5vars[vname]['attrs']['long_name'])\n",
    "    print(filenames)\n",
    "    print('all chunkings found in', vname, 'files:')\n",
    "    for ch in unique_allchunks:\n",
    "          print(ch)\n",
    "    print('bad chunking:')\n",
    "    for ch in badchunks:\n",
    "          print(ch)\n",
    "#     break\n",
    "    \n",
    "\n",
    "        \n",
    "#     md += '| '+' | '.join([ '`'+k+'`', \n",
    "#                            ERA5vars[k]['attrs']['long_name']+' ['+ERA5vars[k]['attrs']['units']+']', \n",
    "#                            repr(ERA5vars[k]['dimensions']),\n",
    "#                            repr(ERA5vars[k]['chunking']),\n",
    "#                            '`'+os.path.join(ERA5path, fvar, '*', fvar+'*.nc')+'`'])+' |\\n'\n",
    "# display(Markdown(md))\n",
    "# # print(md)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ERA5(variable, fvar=None, path=ERA5path, rechunkedpath=ERA5rechunkedpath,\n",
    "                timerange=timerange): #, time_units='days since 1900-01-01'): \n",
    "    '''\n",
    "    Return a dataarray for an ERA5 variable (e.g. ERA5vars keys).\n",
    "    fvar is the variable name in the filename and path. \n",
    "    If fvar is omitted, it is looked up in ERA5vars.\n",
    "    timerange is a slice object.\n",
    "    If files with the same basename exist in both ERA5path and ERA5rechunkedpath,\n",
    "    the version in ERA5rechunkedpath is used instead of that in ERA5path.\n",
    "    '''\n",
    "    if fvar is None:\n",
    "        try:\n",
    "            fvar = ERA5vars[variable]['fvar']\n",
    "        except KeyError:\n",
    "            fvar = variable  # wild guess, hope for the best...\n",
    "    files = []\n",
    "    for yr in range( timerange.start.year, \n",
    "                    (timerange.stop - pd.DateOffset(seconds=1)).year+1):\n",
    "        newfiles = glob(os.path.join(path, fvar, str(yr), fvar+'*.nc'))\n",
    "        rechunkedfiles = glob(os.path.join(rechunkedpath, fvar, str(yr), fvar+'*.nc'))\n",
    "        newfilebns = [os.path.basename(p) for p in newfiles]\n",
    "        rechunkedfilebns = [os.path.basename(p) for p in rechunkedfiles]\n",
    "        for rcf, rcfbn in zip(rechunkedfiles, rechunkedfilebns):\n",
    "            try:\n",
    "                i = newfilebns.index(rcfbn)\n",
    "                print('replacing', newfiles[i], 'with rechunked version', rcf)\n",
    "                newfiles[i] = rcf\n",
    "            except ValueError:\n",
    "                pass   \n",
    "        files.extend(newfiles)\n",
    "    files.sort(key=lambda p: os.path.basename(p))\n",
    "\n",
    "    dataarray = xr.open_mfdataset(\n",
    "                files,\n",
    "                # chunks=8,  \n",
    "                chunks={'time': 8, 'longitude': None, 'latitude': None},  # 8 1-hourly slices per chunk, matching chunking for most ERA5 NetCDF files\n",
    "                # chunks={'time': 24, 'longitude': 1, 'latitude': 1},  # 24 1-hourly slices per chunk\n",
    "                parallel=True,\n",
    "                autoclose=True,\n",
    "                decode_times=False)[variable]\n",
    "    if 'time' in dataarray.coords:\n",
    "        time_units = dataarray.time.units\n",
    "        decoded_time = xr.conventions.times.decode_cf_datetime(dataarray.time, time_units)\n",
    "        dataarray.coords['time'] = ('time', decoded_time,\n",
    "                                    {'long_name': 'time', 'decoded_using': time_units })\n",
    "#     # use the same coord names as access-om2 t grid\n",
    "#     dataarray = dataarray.rename(({'xgrid': 'xt_ocean', 'ygrid': 'yt_ocean'}))\n",
    "    \n",
    "    # sort by time and select timerange\n",
    "#     dataarray = dataarray.sortby('time').sel(time=timerange)\n",
    "    dataarray = dataarray.sel(time=timerange)\n",
    "\n",
    "    return dataarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadERA5(ide, varnames=[], **kwargs):\n",
    "    for varname in varnames:\n",
    "        if varname not in ide.keys():\n",
    "            print('loading', varname)\n",
    "            var = get_ERA5(varname, **kwargs)\n",
    "\n",
    "            ide[varname] = var\n",
    "            \n",
    "            vard = var.resample(time='d').mean() # daily averages\n",
    "            vard.attrs = var.attrs\n",
    "            ide[varname+'_d'] = vard\n",
    "            \n",
    "            varm = var.resample(time='m').mean() # monthly averages\n",
    "            varm.attrs = var.attrs\n",
    "            ide[varname+'_m'] = varm\n",
    "\n",
    "            varmm = var.groupby('time.month').mean('time', skipna=True)\n",
    "            varmm.attrs = var.attrs\n",
    "            ide[varname+'_mm'] = varmm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### List JRA55-do variable names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55dopath = '/g/data/ik11/inputs/JRA-55/MRI-JRA55-do/MRI-JRA55-do-1-4-0'\n",
    "JRA55dovars = dict()  # keys are all ERA5 variables in ERA5path; values are dicts with keys 'fvar' and 'attrs'\n",
    "for p in tqdm_notebook(glob(os.path.join(JRA55dopath, '*', '*')), leave=False, desc='scanning for JRA55do variable names'):\n",
    "    files = glob(os.path.join(p, '*.nc'))\n",
    "    if len(files) > 0:\n",
    "        file = files[0]\n",
    "#         print(file)\n",
    "        da = xr.open_mfdataset(\n",
    "                file,\n",
    "                parallel=True,\n",
    "                autoclose=True,\n",
    "                decode_times=False)\n",
    "        vname = [ v for v in da.variables if v not in list(da.coords) and not v.endswith('_bnds')][0]  # assumes only one data variable per file\n",
    "#         print(vname)\n",
    "        JRA55dovars[vname] = {'path': os.path.dirname(file),\n",
    "                           'attrs': da[vname].attrs}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# list all available JRA55-do variables\n",
    "JRA55dovarskeys = list(JRA55dovars.keys())\n",
    "JRA55dovarskeys.sort()\n",
    "md = '| name | longname [units] | path |\\n'\n",
    "md += '| --- | --- | --- |\\n'\n",
    "for k in JRA55dovarskeys:\n",
    "    md += '| '+' | '.join([ '`'+k+'`', \n",
    "                           JRA55dovars[k]['attrs']['long_name']+' ['+JRA55dovars[k]['attrs']['units']+']', \n",
    "                           '`'+os.path.join(JRA55dovars[k]['path'],'*.nc')+'`'])+' |\\n'\n",
    "display(Markdown(md))\n",
    "# print(md)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load ACCESS-OM2 model data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ice_data = exptdata.exptdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ensemble = [ k for k in ice_data.keys() if len(k.split('_')) > 1 ]\n",
    "# ensemble = [ k for k in ensemble if ice_data[k][0]['res'] in ['0.25°'] ]\n",
    "\n",
    "ensemble = [ k for k in ensemble if ice_data[k][0]['res'] in ['1°'] ]\n",
    "\n",
    "# ensemble = [ k for k in ensemble if ice_data[k][0]['perturbed'] not in ['turning_angle'] ]\n",
    "\n",
    "# ensemble = [ k for k in ensemble if ice_data[k][0]['perturbed'] in ['j09_bgmax', None] ]\n",
    "# ensemble = [ k for k in ensemble if ice_data[k][0]['perturbed'] in ['albicev', None] ]\n",
    "\n",
    "\n",
    "# ensemble = [ k for k in ensemble if ice_data[k][0]['perturbed'] in [None] ]  # control run only\n",
    "ensemble.sort()\n",
    "controlkeys = [ k for k in ensemble if ice_data[k][0]['perturbed']==None ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ensemble = ['1deg', '025deg', '01deg']\n",
    "# ensemble = ['025deg', '01deg']\n",
    "controlkeys = ensemble"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "ensemble = ['1deg_albicev_0.9', '1deg_control']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ensemble = ['1deg_albicev_0.9', '1deg_turning_angle_26', '1deg_control']\n",
    "controlkeys = ['1deg_control']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ensemble = ['1degERA5', '025degERA5']\n",
    "controlkeys = ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "controlkeys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# for ekey in ice_data.keys():\n",
    "for ekey in ensemble: # just the ensemble\n",
    "    print(ekey)\n",
    "    for ide in ice_data[ekey]:\n",
    "        loaddata(ide, varnames=['aice_m'])\n",
    "\n",
    "#         loaddata(ide, varnames=['daidtd_m', 'daidtt_m'])  # area tendency due to dynamics and thermo\n",
    "#         loaddata(ide, varnames=['dvidtd_m', 'dvidtt_m'])  # volume tendency due to dynamics and thermo\n",
    "#         loaddata(ide, varnames=['congel_m', 'frazil_m', 'meltt_m', 'meltb_m', 'meltl_m', 'snoice_m', 'evap_ai_m'])  # volume tendency due to dynamics and thermo\n",
    "\n",
    "        # loaddata(ide, varnames=['hi_m'])\n",
    "        # loaddata(ide, varnames=['hs_m'])\n",
    "#         loaddata(ide, varnames=['hi'])\n",
    "\n",
    "#         loaddata(ide, varnames=['mld'], model='mom', ncfiles=['ocean-2d-mld-1-daily-mean-ym_%'])\n",
    "\n",
    "\n",
    "#         loaddata(ide, varnames=['aice'])\n",
    "#         if ekey == '01deg':\n",
    "# #             loaddata(ide, varnames=['sea_level', 'surface_temp', 'surface_salt', 'mld'], \n",
    "# #                      ncfiles=['ocean-2d-sea_level-1-daily-mean-ym_%', 'ocean-2d-surface_temp-1-daily-mean-ym_%', 'ocean-2d-surface_salt-1-daily-mean-ym_%', 'ocean-2d-mld-1-daily-mean-ym_%'])\n",
    "\n",
    "#             loaddata(ide, model='mom', varnames=['surface_temp', 'surface_salt', 'mld'], \n",
    "#                      ncfiles=['ocean-2d-surface_temp-1-daily-mean-ym_%', 'ocean-2d-surface_salt-1-daily-mean-ym_%', 'ocean-2d-mld-1-daily-mean-ym_%'])\n",
    "#             ide['sst'] = ide['surface_temp'] # ensure consistent names\n",
    "#             ide['sss'] = ide['surface_salt'] # ensure consistent names\n",
    "\n",
    "#         else:\n",
    "#             loaddata(ide, model='mom', varnames=['sst', 'sss', 'mld'], ncfiles='ocean_daily.nc')\n",
    "# #             loaddata(ide, varnames=['sea_level', 'sst', 'sss', 'mld'], ncfiles='ocean_daily.nc')\n",
    "\n",
    "#         break  # only load cycle 1\n",
    "    \n",
    "#     break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load SIC obs data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_NH = get_sic_obs('north/monthly/*.nc')\n",
    "obs_NH_mm = obs_mm(obs_NH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_SH = get_sic_obs('south/monthly/*.nc')\n",
    "obs_SH_mm = obs_mm(obs_SH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_SH_mstd = obs_mstd(obs_SH)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# this is really slow and memory-intensive...\n",
    "obs_NH_daily = get_sic_obs('north/daily/*/*.nc', variable='goddard_merged_seaice_conc')\n",
    "obs_SH_daily = get_sic_obs('south/daily/*/*.nc', variable='goddard_merged_seaice_conc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Total ice area timeseries\n",
    "ObsDirExt = '/g/data3/hh5/tmp/cosima/observations/NOAA/G02135'  # from http://nsidc.org/data/g02135\n",
    "obsExtNHFileList = glob(os.path.join(ObsDirExt, 'north/monthly/data/*.csv'))\n",
    "obsExtSHFileList = glob(os.path.join(ObsDirExt, 'south/monthly/data/*.csv'))\n",
    "obsExtNHFileList.sort()\n",
    "obsExtSHFileList.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load GIOMAS data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GIOMAS = {}  # interannually varying monthly means\n",
    "# where possible, use the same names as for access-om2 \n",
    "for var, kwargs in \\\n",
    "           {'hi_m': {'variable': 'heff', 'varrange': [0, None]},\n",
    "            'hs_m': {'variable': 'snow', 'varrange': [0, None], 'scale': 1/.33},  # convert from water equivalent using CICE snow density / water density = .330\n",
    "            'aice_m': {'variable': 'area', 'varrange': [0, 1]},\n",
    "            'iceprod_m': {'variable': 'iceprod', 'varrange': [None, None]}\n",
    "           }.items():\n",
    "    print('loading', var)\n",
    "    GIOMAS[var] = get_giomas(**kwargs)\n",
    "GIOMAS_mm = {k: v.groupby('time.month').mean('time', skipna=True) for k, v in GIOMAS.items()}  # monthly climatologies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Load JRA55-do data\n",
    "JRA55-do has sea ice concentration `siconc`, `siconca` in\n",
    "\n",
    "`/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce`\n",
    "\n",
    "which is now indexed in the cookbook https://github.com/COSIMA/master_index/issues/11\n",
    "\n",
    "Presumably these are both from COBE-SST - see JMA2006a, MatsumotoIshiiFukudaHirahara2006a, IshiiShoujiSugimotoMatsumoto2005a\n",
    "- `siconc` is daily, on the ocean grid\n",
    "    - .nc metadata: :grid = \"1x1 degree latitude x longitude\" ;\n",
    "    - .nc metadata: :nominal_resolution = \"100 km\" ;\n",
    "    - continuous range of values\n",
    "    - presumably this is the original COBE-SST data before the 55% thresholding and regridding\n",
    "- `siconca` is 3-hourly, on the atmos grid, **assimilated into JRA55**\n",
    "    - .nc metadata: :grid = \"data regridded to the normal atmosphere TL319 gaussian grid (320x640 latxlon) from a reduced TL319 gaussian grid\" ;\n",
    "    - .nc metadata: :nominal_resolution = \"50 km\" ;\n",
    "    - almost all values are 0 or 100% (there are a few of 20, 40, 60, 80% at edges of 100% regions, presumably due to iterpolation onto atmos grid, and perhaps in time to get 3-hourly data from daily siconc)\n",
    "    - so presumably this is within the 55% contour as seen by the atmosphere model\n",
    "   \n",
    "so`siconc` is original ice data, `siconca` is thresholded - confirmed by comparing these:\n",
    "\n",
    "`/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/day/siconc/gn/v20190429/siconc_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gn_20180101-20181231.nc`\n",
    "\n",
    "`/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/3hrPt/siconca/gr/v20190429/siconca_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gr_201801010000-201812312100.nc`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55do_data = {'session': cc.database.create_session()}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "JRA55dovars=list(cc.querying.get_variables(JRA55do_data['session'], experiment='MRI-JRA55-do-1-4-0').name)\n",
    "JRA55dovars.sort()\n",
    "JRA55dovars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadJRA55do(JRA55do_data, varnames=['siconc'])  # COBE-SST sea ice concentration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadJRA55do(JRA55do_data, varnames=['siconca'])  # COBE-SST sea ice concentration, thresholded daily at 55% and interpolated to 3-hourly - used as input to JRA55 reanalysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "loadJRA55do(JRA55do_data, varnames=['uas', 'psl', 'tas', 'rlds', 'rsds']) # also 'vas', ts', 'huss', 'prra', 'prsn'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "loadJRA55do(JRA55do_data, varnames=['tas', 'huss']) # also 'vas', ts', 'huss', 'prra', 'prsn'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "loadJRA55do(JRA55do_data, varnames=['tas']) # also 'vas', ts', 'huss', 'prra', 'prsn'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "loadJRA55do(JRA55do_data, varnames=['uas', 'vas']) # also 'vas', ts', 'huss', 'prra', 'prsn'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load JRA55 (not -do) data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55_data = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadJRA55(JRA55_data, varnames=['tas'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadJRA55(JRA55_data, varnames=['hus'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load ERA5 data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ERA5_data = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadERA5(ERA5_data, varnames=['t2m'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadERA5(ERA5_data, varnames=['u10', 'v10'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Regridders\n",
    "see https://cosima-recipes.readthedocs.io/en/latest/documented_examples/Regridding.html\n",
    "and https://xesmf.readthedocs.io"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mom_regridder(grid_in, grid_out, method='bilinear', periodic=True, **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in and grid_out are paths to MOM grid NetCDF files.\n",
    "    The regridder maps tracer points to tracer points.\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    def opends(fn):\n",
    "        try: # for /g/data/ik11/grids/ocean_grid_10.nc and /g/data/ik11/grids/ocean_grid_025.nc\n",
    "            return xr.open_dataset(fn).rename({'xt_ocean': 'x', 'yt_ocean': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})         \n",
    "        except ValueError: # for /g/data/ik11/grids/ocean_grid_01.nc - see https://github.com/COSIMA/access-om2/issues/236\n",
    "            ds = xr.open_dataset(fn).rename({'grid_x_T': 'x', 'grid_y_T': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "            ds_fix = xr.open_dataset('/g/data/ik11/outputs/access-om2-01/01deg_jra55v140_iaf_cycle3/output488/ocean/ocean-3d-temp-1-daily-mean-ym_1958_01.nc')\\\n",
    "                        .rename({'xt_ocean': 'x', 'yt_ocean': 'y'})\n",
    "            return ds.assign_coords({'x': ds_fix['x'], 'y': ds_fix['y']})\n",
    "\n",
    "    ds_in = opends(grid_in)\n",
    "    ds_out = opends(grid_out)\n",
    "\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, periodic=periodic, reuse_weights=os.path.exists(weightfn), filename=weightfn, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da.chunk({'xt_ocean': None, 'yt_ocean': None}))\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def G02202_obs_regridder(grid_in, grid_out, method='bilinear', **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in -- path to a NSIDC G02202 NetCDF grid file\n",
    "    grid_out -- path to a MOM grid file (tracer points are used)\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    ds_in = xr.open_dataset(grid_in)\\\n",
    "             .rename({'xgrid': 'x', 'ygrid': 'y',\n",
    "                     'longitude': 'lon', 'latitude': 'lat'})\n",
    "    try: # for /g/data/ik11/grids/ocean_grid_10.nc and /g/data/ik11/grids/ocean_grid_025.nc\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'xt_ocean': 'x', 'yt_ocean': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "    except ValueError: # for /g/data/ik11/grids/ocean_grid_01.nc - see https://github.com/COSIMA/access-om2/issues/236\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'grid_x_T': 'x', 'grid_y_T': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "        ds_out_fix = xr.open_dataset('/g/data/ik11/outputs/access-om2-01/01deg_jra55v140_iaf_cycle3/output488/ocean/ocean-3d-temp-1-daily-mean-ym_1958_01.nc')\\\n",
    "                    .rename({'xt_ocean': 'x', 'yt_ocean': 'y'})\n",
    "        ds_out = ds_out.assign_coords({'x': ds_out_fix['x'], 'y': ds_out_fix['y']})\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, reuse_weights=os.path.exists(weightfn), filename=weightfn, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def giomas_regridder(grid_out, method='bilinear', periodic=True, **kwargs):\n",
    "    '''Return a function that takes one dataarray argument from get_giomas and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_out -- path to a MOM grid file (tracer points are used)\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', 'giomas',\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "\n",
    "    ds_in = get_giomas(timerange=slice(pd.to_datetime('2000', format='%Y'), pd.to_datetime('2001', format='%Y')))\\\n",
    "                .isel(time=0).rename({'xt_ocean': 'x', 'yt_ocean': 'y', 'longitude': 'lon', 'latitude': 'lat'})\n",
    "\n",
    "    try: # for /g/data/ik11/grids/ocean_grid_10.nc and /g/data/ik11/grids/ocean_grid_025.nc\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'xt_ocean': 'x', 'yt_ocean': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "    except ValueError: # for /g/data/ik11/grids/ocean_grid_01.nc - see https://github.com/COSIMA/access-om2/issues/236\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'grid_x_T': 'x', 'grid_y_T': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "        ds_out_fix = xr.open_dataset('/g/data/ik11/outputs/access-om2-01/01deg_jra55v140_iaf_cycle3/output488/ocean/ocean-3d-temp-1-daily-mean-ym_1958_01.nc')\\\n",
    "                    .rename({'xt_ocean': 'x', 'yt_ocean': 'y'})\n",
    "        ds_out = ds_out.assign_coords({'x': ds_out_fix['x'], 'y': ds_out_fix['y']})\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, periodic=periodic,\n",
    "                         reuse_weights=os.path.exists(weightfn), \n",
    "                         filename=weightfn, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def JRA55do_regridder(grid_in, grid_out, method='bilinear', periodic=True, **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in -- path to a JRA55-do or JRA55 NetCDF grid file\n",
    "    grid_out -- path to a MOM grid file (tracer points are used)\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    ds_in = xr.open_dataset(grid_in)\n",
    "    try: # for /g/data/ik11/grids/ocean_grid_10.nc and /g/data/ik11/grids/ocean_grid_025.nc\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'xt_ocean': 'x', 'yt_ocean': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "    except ValueError: # for /g/data/ik11/grids/ocean_grid_01.nc - see https://github.com/COSIMA/access-om2/issues/236\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'grid_x_T': 'x', 'grid_y_T': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "        ds_out_fix = xr.open_dataset('/g/data/ik11/outputs/access-om2-01/01deg_jra55v140_iaf_cycle3/output488/ocean/ocean-3d-temp-1-daily-mean-ym_1958_01.nc')\\\n",
    "                    .rename({'xt_ocean': 'x', 'yt_ocean': 'y'})\n",
    "        ds_out = ds_out.assign_coords({'x': ds_out_fix['x'], 'y': ds_out_fix['y']})\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, reuse_weights=os.path.exists(weightfn), periodic=periodic, filename=weightfn, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def JRA55do_to_G02202_obs_regridder(grid_in, grid_out, method='bilinear', **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in -- path to a JRA55-do or JRA55 NetCDF grid file\n",
    "    grid_out -- path to a NSIDC G02202 NetCDF grid file\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    ds_in = xr.open_dataset(grid_in)\n",
    "\n",
    "    ds_out = xr.open_dataset(grid_out)\\\n",
    "             .rename({'xgrid': 'x', 'ygrid': 'y',\n",
    "                     'longitude': 'lon', 'latitude': 'lat'})\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, reuse_weights=os.path.exists(weightfn), filename=weightfn, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def JRA55do_to_ERA5_regridder(grid_in, grid_out, method='bilinear', **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in -- path to a JRA55-do or JRA55 NetCDF grid file\n",
    "    grid_out -- path to an ERA5 NetCDF grid file\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    ds_in = xr.open_dataset(grid_in)\n",
    "\n",
    "    ds_out = xr.open_dataset(grid_out)\\\n",
    "             .rename({'longitude': 'lon', 'latitude': 'lat'})\n",
    "    ds_out.coords['x'] = ds_out['lon']\n",
    "    ds_out.coords['y'] = ds_out['lat']\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, reuse_weights=os.path.exists(weightfn), filename=weightfn, periodic=True, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ERA5_regridder(grid_in, grid_out, method='bilinear', periodic=True, **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in -- path to a ERA5 NetCDF grid file\n",
    "    grid_out -- path to a MOM grid file (tracer points are used)\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    ds_in = xr.open_dataset(grid_in)\\\n",
    "             .rename({'longitude': 'lon', 'latitude': 'lat'})\n",
    "    try: # for /g/data/ik11/grids/ocean_grid_10.nc and /g/data/ik11/grids/ocean_grid_025.nc\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'xt_ocean': 'x', 'yt_ocean': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "    except ValueError: # for /g/data/ik11/grids/ocean_grid_01.nc - see https://github.com/COSIMA/access-om2/issues/236\n",
    "        ds_out = xr.open_dataset(grid_out).rename({'grid_x_T': 'x', 'grid_y_T': 'y', 'geolon_t': 'lon', 'geolat_t': 'lat'})\n",
    "        ds_out_fix = xr.open_dataset('/g/data/ik11/outputs/access-om2-01/01deg_jra55v140_iaf_cycle3/output488/ocean/ocean-3d-temp-1-daily-mean-ym_1958_01.nc')\\\n",
    "                    .rename({'xt_ocean': 'x', 'yt_ocean': 'y'})\n",
    "        ds_out = ds_out.assign_coords({'x': ds_out_fix['x'], 'y': ds_out_fix['y']})\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, reuse_weights=os.path.exists(weightfn), periodic=periodic, filename=weightfn, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ERA5_to_JRA55do_regridder(grid_in, grid_out, method='bilinear', **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in -- path to an ERA5 NetCDF grid file\n",
    "    grid_out -- path to a JRA55-do or JRA55 NetCDF grid file\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    ds_in = xr.open_dataset(grid_in)\\\n",
    "             .rename({'longitude': 'lon', 'latitude': 'lat'})\n",
    "    # ds_in.coords['x'] = ds_in['lon']\n",
    "    # ds_in.coords['y'] = ds_in['lat']\n",
    "\n",
    "    ds_out = xr.open_dataset(grid_out)\n",
    "    ds_out.coords['x'] = ds_out['lon']\n",
    "    ds_out.coords['y'] = ds_out['lat']\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, reuse_weights=os.path.exists(weightfn), filename=weightfn, periodic=True, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def JRA55_to_JRA55do_regridder(grid_in, grid_out, method='bilinear', **kwargs):\n",
    "    '''Return a function that takes one dataarray argument on grid_in and returns that dataarray regridded onto grid_out.\n",
    "    \n",
    "    grid_in -- path to a JRA55 NetCDF grid file\n",
    "    grid_out -- path to a JRA55-do NetCDF grid file\n",
    "    '''\n",
    "    weightfn = '_'.join(['regrid', 'weights', os.path.splitext(os.path.basename(grid_in))[0],\n",
    "                         'to', os.path.splitext(os.path.basename(grid_out))[0], method])+'.nc'\n",
    "    ds_in = xr.open_dataset(grid_in)\n",
    "    # ds_in.coords['x'] = ds_in['lon']\n",
    "    # ds_in.coords['y'] = ds_in['lat']\n",
    "\n",
    "    ds_out = xr.open_dataset(grid_out)\n",
    "    ds_out.coords['x'] = ds_out['lon']\n",
    "    ds_out.coords['y'] = ds_out['lat']\n",
    "\n",
    "    # make regridder\n",
    "    rg = xesmf.Regridder(ds_in, ds_out, method=method, reuse_weights=os.path.exists(weightfn), filename=weightfn, periodic=True, **kwargs)\n",
    "\n",
    "    def outf(da): # define regridding function to output\n",
    "        outds = rg(da)\n",
    "        outds.coords['x'] = ds_out['x']\n",
    "        outds.coords['y'] = ds_out['y']\n",
    "        return outds.rename({'x': 'xt_ocean', 'y': 'yt_ocean', 'lon': 'longitude', 'lat': 'latitude'})\n",
    "\n",
    "    return outf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define regridder functions\n",
    "regrid_1_to_025 = mom_regridder('/g/data/ik11/grids/ocean_grid_10.nc', '/g/data/ik11/grids/ocean_grid_025.nc')#, method='conservative')\n",
    "regrid_1_to_01 = mom_regridder('/g/data/ik11/grids/ocean_grid_10.nc', '/g/data/ik11/grids/ocean_grid_01.nc')#, method='conservative')\n",
    "regrid_025_to_01 = mom_regridder('/g/data/ik11/grids/ocean_grid_025.nc', '/g/data/ik11/grids/ocean_grid_01.nc')#, method='conservative')\n",
    "regrid_025_to_1 = mom_regridder('/g/data/ik11/grids/ocean_grid_025.nc', '/g/data/ik11/grids/ocean_grid_10.nc')#, method='conservative')\n",
    "regrid_01_to_1 = mom_regridder('/g/data/ik11/grids/ocean_grid_01.nc', '/g/data/ik11/grids/ocean_grid_10.nc')#, method='conservative')\n",
    "regrid_01_to_025 = mom_regridder('/g/data/ik11/grids/ocean_grid_01.nc', '/g/data/ik11/grids/ocean_grid_025.nc')#, method='conservative')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obsfile_NH = '/g/data3/hh5/tmp/cosima/observations/NOAA/G02202_V3/north/monthly/seaice_conc_monthly_nh_f08_198708_v03r01.nc'\n",
    "regrid_NHobs_to_1 = G02202_obs_regridder(obsfile_NH, '/g/data/ik11/grids/ocean_grid_10.nc')\n",
    "regrid_NHobs_to_025 = G02202_obs_regridder(obsfile_NH, '/g/data/ik11/grids/ocean_grid_025.nc')\n",
    "regrid_NHobs_to_01 = G02202_obs_regridder(obsfile_NH, '/g/data/ik11/grids/ocean_grid_01.nc')\n",
    "\n",
    "obsfile_SH = '/g/data3/hh5/tmp/cosima/observations/NOAA/G02202_V3/south/monthly/seaice_conc_monthly_sh_f08_198708_v03r01.nc'\n",
    "regrid_SHobs_to_1 = G02202_obs_regridder(obsfile_SH, '/g/data/ik11/grids/ocean_grid_10.nc')\n",
    "regrid_SHobs_to_025 = G02202_obs_regridder(obsfile_SH, '/g/data/ik11/grids/ocean_grid_025.nc')\n",
    "regrid_SHobs_to_01 = G02202_obs_regridder(obsfile_SH, '/g/data/ik11/grids/ocean_grid_01.nc')\n",
    "\n",
    "obsregridders = {'NH': \n",
    "                 {\n",
    "                     '1°': regrid_NHobs_to_1,\n",
    "                     '0.25°': regrid_NHobs_to_025,\n",
    "                     '0.1°': regrid_NHobs_to_01\n",
    "                 },\n",
    "                'SH':\n",
    "                 {\n",
    "                     '1°': regrid_SHobs_to_1,\n",
    "                     '0.25°': regrid_SHobs_to_025,\n",
    "                     '0.1°': regrid_SHobs_to_01\n",
    "                 }\n",
    "                }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "regrid_giomas_to_1 = giomas_regridder('/g/data/ik11/grids/ocean_grid_10.nc')\n",
    "regrid_giomas_to_025 = giomas_regridder('/g/data/ik11/grids/ocean_grid_025.nc')\n",
    "regrid_giomas_to_01 = giomas_regridder('/g/data/ik11/grids/ocean_grid_01.nc')\n",
    "GIOMASregridders = {\n",
    "                     '1°': regrid_giomas_to_1,\n",
    "                     '0.25°': regrid_giomas_to_025,\n",
    "                     '0.1°': regrid_giomas_to_01\n",
    "                   }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/day/siconc/gn/v20190429/siconc_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gn_19580101-19581231.nc'\n",
    "JRA55do_data['siconc_mm_regridded_to_NHobs'] = JRA55do_to_G02202_obs_regridder(JRA55dofile, obsfile_NH)(JRA55do_data['siconc_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconc_mm_regridded_to_SHobs'] = JRA55do_to_G02202_obs_regridder(JRA55dofile, obsfile_SH)(JRA55do_data['siconc_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconc_mm_regridded_to_mom'] = dict()\n",
    "JRA55do_data['siconc_mm_regridded_to_mom']['1°'] = JRA55do_regridder(JRA55dofile, '/g/data/ik11/grids/ocean_grid_10.nc')(JRA55do_data['siconc_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconc_mm_regridded_to_mom']['0.25°'] = JRA55do_regridder(JRA55dofile, '/g/data/ik11/grids/ocean_grid_025.nc')(JRA55do_data['siconc_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconc_mm_regridded_to_mom']['0.1°'] = JRA55do_regridder(JRA55dofile, '/g/data/ik11/grids/ocean_grid_01.nc')(JRA55do_data['siconc_mm'])/100.0  # convert from percent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/3hrPt/siconca/gr/v20190429/siconca_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gr_201801010000-201812312100.nc'\n",
    "JRA55do_data['siconca_mm_regridded_to_NHobs'] = JRA55do_to_G02202_obs_regridder(JRA55dofile, obsfile_NH)(JRA55do_data['siconca_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconca_mm_regridded_to_SHobs'] = JRA55do_to_G02202_obs_regridder(JRA55dofile, obsfile_SH)(JRA55do_data['siconca_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconca_mm_regridded_to_mom'] = dict()\n",
    "JRA55do_data['siconca_mm_regridded_to_mom']['1°'] = JRA55do_regridder(JRA55dofile, '/g/data/ik11/grids/ocean_grid_10.nc')(JRA55do_data['siconca_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconca_mm_regridded_to_mom']['0.25°'] = JRA55do_regridder(JRA55dofile, '/g/data/ik11/grids/ocean_grid_025.nc')(JRA55do_data['siconca_mm'])/100.0  # convert from percent\n",
    "JRA55do_data['siconca_mm_regridded_to_mom']['0.1°'] = JRA55do_regridder(JRA55dofile, '/g/data/ik11/grids/ocean_grid_01.nc')(JRA55do_data['siconca_mm'])/100.0  # convert from percent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ERA5file = glob(os.path.join(ERA5path, ERA5vars['t2m']['fvar'], '2017', ERA5vars['t2m']['fvar']+'*.nc'))[0]\n",
    "def ERA5_to_025(**kwargs):\n",
    "    return ERA5_regridder(ERA5file, '/g/data/ik11/grids/ocean_grid_025.nc', **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/3hrPt/siconca/gr/v20190429/siconca_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gr_201801010000-201812312100.nc'\n",
    "def JRA55do_to_025(**kwargs):\n",
    "    return JRA55do_regridder(JRA55dofile, '/g/data/ik11/grids/ocean_grid_025.nc', **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/day/siconc/gn/v20190429/siconc_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gn_19580101-19581231.nc'\n",
    "JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/3hrPt/siconca/gr/v20190429/siconca_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gr_201801010000-201812312100.nc'\n",
    "ERA5file = glob(os.path.join(ERA5path, ERA5vars['t2m']['fvar'], '2017', ERA5vars['t2m']['fvar']+'*.nc'))[0]\n",
    "def JRA55do_to_ERA5(data_in):\n",
    "    return JRA55do_to_ERA5_regridder(JRA55dofile, ERA5file)(data_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/day/siconc/gn/v20190429/siconc_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gn_19580101-19581231.nc'\n",
    "JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/3hrPt/siconca/gr/v20190429/siconca_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gr_201801010000-201812312100.nc'\n",
    "ERA5file = glob(os.path.join(ERA5path, ERA5vars['t2m']['fvar'], '2017', ERA5vars['t2m']['fvar']+'*.nc'))[0]\n",
    "def ERA5_to_JRA55do(data_in):\n",
    "    return ERA5_to_JRA55do_regridder(ERA5file, JRA55dofile)(data_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55file = os.path.join(JRA55path, 'tas_Amon_reanalysis_JRA-55_195801-201912.nc')\n",
    "def JRA55_to_025(**kwargs):\n",
    "    return JRA55do_regridder(JRA55file, '/g/data/ik11/grids/ocean_grid_025.nc', **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55file = os.path.join(JRA55path, 'tas_Amon_reanalysis_JRA-55_195801-201912.nc')\n",
    "ERA5file = glob(os.path.join(ERA5path, ERA5vars['t2m']['fvar'], '2017', ERA5vars['t2m']['fvar']+'*.nc'))[0]\n",
    "def JRA55_to_ERA5(data_in):\n",
    "    return JRA55do_to_ERA5_regridder(JRA55file, ERA5file)(data_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55file = os.path.join(JRA55path, 'tas_Amon_reanalysis_JRA-55_195801-201912.nc')\n",
    "ERA5file = glob(os.path.join(ERA5path, ERA5vars['t2m']['fvar'], '2017', ERA5vars['t2m']['fvar']+'*.nc'))[0]\n",
    "def ERA5_to_JRA55(data_in):\n",
    "    return ERA5_to_JRA55do_regridder(ERA5file, JRA55file)(data_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55file = os.path.join(JRA55path, 'tas_Amon_reanalysis_JRA-55_195801-201912.nc')\n",
    "JRA55dofile = '/g/data/qv56/replicas/input4MIPs/CMIP6/OMIP/MRI/MRI-JRA55-do-1-4-0/seaIce/3hrPt/siconca/gr/v20190429/siconca_input4MIPs_atmosphericState_OMIP_MRI-JRA55-do-1-4-0_gr_201801010000-201812312100.nc'\n",
    "def JRA55_to_JRA55do(data_in):\n",
    "    return JRA55_to_JRA55do_regridder(JRA55file, JRA55dofile)(data_in)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Define map plotter and views"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# based on https://cosima-recipes.readthedocs.io/en/latest/tutorials/Making_Maps_with_Cartopy.html#gallery-tutorials-making-maps-with-cartopy-ipynb\n",
    "\n",
    "def plotSIC(var, legend=True, projection=ccrs.NorthPolarStereo(), extent=[-180, 180, 48, 90],\n",
    "           levels=np.arange(0,1.01,.1), cmp=plt.get_cmap('nipy_spectral'),\n",
    "           cmap_gamma=2., # NB: non-1 gamma only works for fields and ticklevels in range [0, 1]\n",
    "           cbar_ticklevels=[0,.3,.4,.5,.6,.7,.8,.85,.9,.95,1],  # for cmap_gamma = 2.\n",
    "#            cmap_gamma = 4., cbar_ticklevels = [0,.5,.6,.7,.8,.85,.9,.95,.98,1],  # for cmap_gamma = 4.\n",
    "           cbar_sigfigs=2, cbar_fontsize=12, cbar_label='Sea ice concentration', extend='neither', colorbar=True,\n",
    "           lon_grid=range(-360, 361, 30), lat_grid=range(-80, 81, 10), draw_gridline_labels=True,\n",
    "           x='longitude', y='latitude', xtransform=ccrs.PlateCarree(),\n",
    "           contourvars=[],  # list of (var, label, kwargs) for overlaid contours\n",
    "           feature=cft.NaturalEarthFeature('physical', 'land', '50m',\n",
    "                                   edgecolor='black', facecolor=[.6, .6, .6], \n",
    "                                   linewidth=0.25),\n",
    "           featureoverplot=False):\n",
    "    var = var**cmap_gamma\n",
    "    plt.figure(figsize=(12,7))\n",
    "    ax = plt.axes(projection=projection)\n",
    "#     ax.set_facecolor(cmp(0))\n",
    "    ax.set_facecolor([.4, .4, .4])\n",
    "#     ax.coastlines(resolution='50m', linewidth=0.5)\n",
    "    if not featureoverplot:\n",
    "        ax.add_feature(feature)\n",
    "#     ax.set_global()\n",
    "    gl = ax.gridlines(draw_labels=draw_gridline_labels,\n",
    "                      linewidth=0.5, color=[0.8, 0.8, 0.8], alpha=0.5)\n",
    "    gl.ylabels_top = None\n",
    "\n",
    "#     gl.ylabels_bottom = None # only needed for Weddell and Amundsen-Bellingshausen closeups\n",
    "#     gl.ylabels_left = None # only needed for Weddell and Amundsen-Bellingshausen closeups\n",
    "#     gl.ylabels_right = None # only needed for Weddell and Amundsen-Bellingshausen closeups\n",
    "\n",
    "#     gl.ylabels_right = None\n",
    "    gl.xlabels_top = None\n",
    "    gl.xlabels_bottom = None\n",
    "    gl.xlabels_left = None\n",
    "    gl.xlabels_right = None\n",
    "    gl.xlocator = mticker.FixedLocator(lon_grid)\n",
    "    gl.ylocator = mticker.FixedLocator(lat_grid)\n",
    "\n",
    "#     contourf is buggy near poles, so use pcolormesh instead\n",
    "#    p1 = var.plot.contourf(ax=ax,\n",
    "#                           x='longitude', y='latitude',\n",
    "#                           levels=levels, #vmin=0, vmax=1,\n",
    "#                           cmap=cmp,\n",
    "#                           transform=ccrs.PlateCarree(),\n",
    "#                           add_colorbar=False)\n",
    "\n",
    "#     p1 = exptdata.joinseams(var).plot.pcolormesh(ax=ax,\n",
    "    p1 = var.plot.pcolormesh(ax=ax,\n",
    "                           x=x, y=y,\n",
    "                           vmin=min(cbar_ticklevels), vmax=max(cbar_ticklevels),\n",
    "                           cmap=cmp,\n",
    "                           transform=xtransform,\n",
    "                           add_colorbar=False)\n",
    "\n",
    "    ax.set_extent(extent, ccrs.PlateCarree())\n",
    "#     p1.cmap.set_over(color=cmp(255), alpha=None)\n",
    "#     p1.cmap.set_under(color=cmp(0), alpha=None)\n",
    "    \n",
    "    for cv in contourvars:\n",
    "        cline = cv[0].plot.contour(#, #ax=ax,\n",
    "            x='longitude', y='latitude',\n",
    "            transform=ccrs.PlateCarree(),\n",
    "            add_colorbar=False,\n",
    "            **cv[2])\n",
    "        if cv[1] is not None:\n",
    "            cline.collections[0].set_label(cv[1]+' '+str(int(cv[2]['levels'][0]*100))+'%')\n",
    "\n",
    "#         SeasonSI.sel(season = season).plot.contour(x = 'xt_ocean', y = 'yt_ocean', ax = axes[i,j],\n",
    "#                                                    levels = [contIce], colors = 'white', linewidths = 1,\n",
    "#                                                    transform = ccrs.PlateCarree())\n",
    "\n",
    "    if featureoverplot:\n",
    "        ax.add_feature(feature)\n",
    "\n",
    "    if legend:\n",
    "        plt.legend(prop={'size':8},loc='center')\n",
    "\n",
    "    if colorbar:\n",
    "        ax_cb = plt.axes([0.3, 0.08, 0.422, 0.015])\n",
    "        cbar = plt.colorbar(p1, cax=ax_cb, orientation='horizontal', extend=extend)\n",
    "        cbar.set_label(cbar_label, size=cbar_fontsize)\n",
    "        cbar_ticks = [ f**cmap_gamma for f in cbar_ticklevels ]  \n",
    "        cbar_ticklabels = [str(round(f, cbar_sigfigs)) for f in cbar_ticklevels]\n",
    "        cbar.set_ticks(cbar_ticks)\n",
    "        cbar.set_ticklabels(cbar_ticklabels)\n",
    "        cbar_labels = plt.getp(cbar.ax.axes,'xticklabels')\n",
    "        plt.setp(cbar_labels, fontsize=cbar_fontsize)\n",
    "    \n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "views = {\n",
    "#     'NH': {'projection': ccrs.NorthPolarStereo(), 'extent': [-180, 180, 48, 90]},\n",
    "    'SH': {'projection': ccrs.SouthPolarStereo(), 'extent': [-180, 180, -90, -54]},\n",
    "\n",
    "# for some reason Stereographic doesn't work with JRA55-do data\n",
    "#     'Amundsen-Bellingshausen': {'projection': ccrs.Stereographic(central_longitude=-90, central_latitude=-70), 'extent': [-115, -60, -77, -63], 'lon_grid': [], 'lat_grid': [], 'draw_gridline_labels': False},\n",
    "\n",
    "# ... but SouthPolarStereo works with JRA55-do data and looks nearly identical\n",
    "#     'Amundsen-BellingshausenSP': {'projection': ccrs.SouthPolarStereo(central_longitude=-90), 'extent': [-115, -60, -77, -63], 'lon_grid': [], 'lat_grid': [], 'draw_gridline_labels': False},\n",
    "\n",
    "#     'Amundsen-Weddell': {'projection': ccrs.Stereographic(central_longitude=-70, central_latitude=-70), 'extent': [-115, -25, -82, -60], 'draw_gridline_labels': False},\n",
    "#     'Weddell': {'projection': ccrs.Stereographic(central_longitude=-60, central_latitude=-70), 'extent': [-62, -20, -76.5, -60], 'draw_gridline_labels': False},\n",
    "#     'Weddell-closeup': {'projection': ccrs.Stereographic(central_longitude=-60, central_latitude=-70), 'extent': [-60, -41, -75, -70], 'lon_grid': [], 'lat_grid': [], 'draw_gridline_labels': False}\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "extlevel = [0.15, 0.15+1e-15]  # SIC contour level defining extent "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Plot maps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ice monthly climatologies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model SIC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatologies from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #enumerate(ice_data.keys()): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['aice_m_mm']:\n",
    "                for m in range(1,13):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        print('doing', fname)\n",
    "                        v = ide[var].sel(month=m)\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                        try:\n",
    "                            idev1 = ice_data[ekey+'v1'][cycle-1]\n",
    "                            plotSIC(v, contourvars=[\n",
    "                                        (idev1[var].sel(month=m), idev1['desc'], {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "                                        (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "        # sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                        (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                        (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                                ],\n",
    "                                        **view).set_title(title);\n",
    "                        except KeyError:                        \n",
    "                            plotSIC(v, contourvars=[\n",
    "                                    # (idev1[var].sel(month=m), idev1['desc'], {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "                                    (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    # sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                    (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                    (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                            ],\n",
    "                                    **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "            break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatologies from each cycle of each model, with SIC set to 0 for hi < hithreshold\n",
    "hithreshold = .2  # thickness threshold (m)\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #enumerate(ice_data.keys()): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['aice_m']:\n",
    "                vthresh_m = ide[var].where(ide['hi_m'] > hithreshold, 0.0)\n",
    "                vthresh_m_mm = vthresh_m.groupby('time.month').mean('time', skipna=True)\n",
    "                for m in range(1,13):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean'])\n",
    "                    fname = figname('_'.join([viewname, var+'_mm', 'hithreshold', str(hithreshold), \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = vthresh_m_mm.sel(month=m)\n",
    "#                         idev1 = ice_data[ekey+'v1'][cycle-1]\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                        \n",
    "                        print('doing', fname)\n",
    "                        plotSIC(v, contourvars=[\n",
    "#                                 (idev1[var].sel(month=m), idev1['desc'], {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "                                (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                        ], cbar_label='Sea ice concentration for thickness > '+str(hithreshold)+'m',\n",
    "                                **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology for perturbations\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "control = ice_data[controlkey][0]\n",
    "for var in ['aice_m_mm']:\n",
    "    for m in range(1,13):\n",
    "        vcontrol = control[var].sel(month=m)\n",
    "        for ekey in ensemble: #ice_data.keys():\n",
    "            for viewname, view in views.items():\n",
    "                if viewname in ['NH']:\n",
    "                    hem = 'NH'\n",
    "                else:\n",
    "                    hem = 'SH'\n",
    "                ide = ice_data[ekey][0]\n",
    "                title = ' '.join([ide['desc'], yearrange, calendar.month_name[m], 'mean'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'], yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = ide[var].sel(month=m)\n",
    "                    obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (vcontrol, control['desc'], {'levels': extlevel, 'colors': 'green'}),\n",
    "                            (v, ide['desc'], {'levels': extlevel, 'colors': 'y'}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                            (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'silver'}),\n",
    "                            (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'silver'}),\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(v, contourvars=contourvars, **view).set_title(title);\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology for perturbations, with SIC set to 0 for hi < hithreshold\n",
    "hithreshold = .2  # thickness threshold (m)\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "control = ice_data[controlkey][0]\n",
    "for var in ['aice_m']:\n",
    "    vcontrolthresh_m = control[var].where(ide['hi_m'] > hithreshold, 0.0)\n",
    "    vcontrolthresh_m_mm = vcontrolthresh_m.groupby('time.month').mean('time', skipna=True)\n",
    "    for ekey in ensemble: #ice_data.keys():\n",
    "        ide = ice_data[ekey][0]\n",
    "        vthresh_m = ide[var].where(ide['hi_m'] > hithreshold, 0.0)\n",
    "        vthresh_m_mm = vthresh_m.groupby('time.month').mean('time', skipna=True)\n",
    "        for m in range(1,13):\n",
    "            vcontrol = vcontrolthresh_m_mm.sel(month=m)\n",
    "            for viewname, view in views.items():\n",
    "                if viewname in ['NH']:\n",
    "                    hem = 'NH'\n",
    "                else:\n",
    "                    hem = 'SH'\n",
    "                title = ' '.join([ide['desc'], yearrange, calendar.month_name[m], 'mean'])\n",
    "                fname = figname('_'.join([viewname, var+'_mm', 'hithreshold', str(hithreshold),\n",
    "                                          ide['expt'], yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = vthresh_m_mm.sel(month=m)\n",
    "                    obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (vcontrol, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (v, ide['desc'], {'levels': extlevel, 'colors': 'y'}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                            (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'silver'}),\n",
    "                            (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'silver'}),\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(v, contourvars=contourvars, \n",
    "                            cbar_label='Sea ice concentration for thickness > '+str(hithreshold)+'m',\n",
    "                            **view).set_title(title);\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model SIC differences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology difference between cycle n and cycle 1 for each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for ekey in ice_data.keys(): #['1deg']: #['01deg']: #['025deg']:\n",
    "        for var in ['aice_m_mm']:\n",
    "            for m in range(1,13):\n",
    "                vref = ice_data[ekey][0][var].sel(month=m)\n",
    "                for cycle, ide in enumerate(ice_data[ekey][1:], start=2):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean'])\n",
    "#                     title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean', 'minus cycle 1'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-cycle1', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                              yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                       print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(month=m) - vref\n",
    "                        print('doing', fname)\n",
    "                        plotSIC(v, cmp=plt.get_cmap('seismic'), cbar_label='Sea ice concentration minus cycle 1',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(-.15,.1501,.05), cbar_sigfigs=2, **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology difference between control and perturbation\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "control = ice_data[controlkey][0]\n",
    "for var in ['aice_m_mm']:\n",
    "    for m in range(1,13):\n",
    "        vcontrol = control[var].sel(month=m)\n",
    "        for ekey in ensemble[1:]: #ice_data.keys():\n",
    "            if ekey != controlkey:\n",
    "                for viewname, view in views.items():\n",
    "                    if viewname in ['NH']:\n",
    "                        hem = 'NH'\n",
    "                    else:\n",
    "                        hem = 'SH'\n",
    "                    ide = ice_data[ekey][0]\n",
    "                    title = ' '.join([ide['desc'], yearrange, calendar.month_name[m], 'mean'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'], '-control', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(month=m)\n",
    "                        vdiff = v - vcontrol\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "\n",
    "                        print('doing', fname)\n",
    "                        plotSIC(vdiff, cmp=plt.get_cmap('seismic'), cbar_label='Sea ice concentration minus control',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(-.15,.1501,.05), cbar_sigfigs=2, \n",
    "                                contourvars=[\n",
    "                                (vcontrol, control['desc'], {'levels': extlevel, 'colors': 'lime'}),\n",
    "                                (v, ide['desc'], {'levels': extlevel, 'colors': 'y'}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'silver'}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'silver'}),\n",
    "                                ], **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observed SIC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly climatologies from SIC obs\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for m in range(1,13):\n",
    "        title = ' '.join(['Passive microwave', yearrange, calendar.month_name[m], 'mean'])\n",
    "        fname = figname('_'.join([viewname, 'aice', 'obs', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "        if False: #os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            if viewname in ['NH']:\n",
    "                hem = 'NH'\n",
    "            else:\n",
    "                hem = 'SH'\n",
    "            v = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "            print('doing', fname)\n",
    "            plotSIC(v, #x='xt_ocean', y='ygrid', xtransform=ccrs.SouthPolarStereo(),\n",
    "                    contourvars=[\n",
    "                    (v.isel(xt_ocean=slice(0, 158)), 'passive microwave', {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (v.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'})], #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model SIC bias (model minus observed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology bias for each model\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        obsv = eval('_'.join(['obs', hem, 'mm']))\n",
    "        vrefs = obsregridders[hem][ice_data[ekey][0]['res']](obsv)\n",
    "        for var in ['aice_m_mm']:\n",
    "            for m in range(1,13):\n",
    "                vref = vrefs.sel(month=m)\n",
    "                for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'bias'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-obs', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                              yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        vcontrol = control[var].sel(month=m)\n",
    "                        v = ide[var].sel(month=m)\n",
    "                        bias = v - vref\n",
    "                        print('doing', fname)\n",
    "                        contourvars=[\n",
    "                                (vcontrol, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                                (v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                                (vref, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                                ]\n",
    "                        if ekey == controlkey:\n",
    "                            contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                        plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='Sea ice concentration minus passive microwave obs',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                                contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology bias for each model, with model SIC set to 0 for hi < hithreshold\n",
    "hithreshold = .2  # thickness threshold (m)\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        ide = ice_data[ekey][0]\n",
    "        obsv = eval('_'.join(['obs', hem, 'mm']))\n",
    "        vrefs = obsregridders[hem][ice_data[ekey][0]['res']](obsv)\n",
    "        for var in ['aice_m']:\n",
    "            vthresh_m = ide[var].where(ide['hi_m'] > hithreshold, 0.0)\n",
    "            vthresh_m_mm = vthresh_m.groupby('time.month').mean('time', skipna=True)\n",
    "            vcontrolthresh_m = control[var].where(ide['hi_m'] > hithreshold, 0.0)\n",
    "            vcontrolthresh_m_mm = vcontrolthresh_m.groupby('time.month').mean('time', skipna=True)\n",
    "            for m in range(1,13):\n",
    "                vref = vrefs.sel(month=m)\n",
    "#                 for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], # 'cycle', str(cycle), \n",
    "                                  yearrange, calendar.month_name[m], 'bias'])\n",
    "                fname = figname('_'.join([viewname, var+'_mm', 'hithreshold', str(hithreshold),\n",
    "                                          ide['expt'].split('_cycle')[0]+'-obs', #'cycle'+str(cycle)+'-obs', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                   print('   -- skipping', fname)\n",
    "                else:\n",
    "                    vcontrol = vcontrolthresh_m_mm.sel(month=m)\n",
    "                    v = vthresh_m_mm.sel(month=m)\n",
    "                    bias = v - vref\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (vcontrol, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (vref, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='SIC (for thickness > '+str(hithreshold)+'m) minus passive microwave obs',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                 break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology bias for each model relative to siconca (which was assimilated into JRA55) and siconc\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this betvter\n",
    "# # controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for JRA55dovar in ['siconca', 'siconc']:\n",
    "    for viewname, view in views.items():\n",
    "        print(viewname)\n",
    "        if viewname in ['NH']:\n",
    "            hem = 'NH'\n",
    "        else:\n",
    "            hem = 'SH'\n",
    "        for enum, ekey in enumerate(ensemble): #['1deg']: #['025deg']: #['01deg']: #\n",
    "            obss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "            vrefs = JRA55do_data[JRA55dovar+'_mm_regridded_to_mom'][ice_data[ekey][0]['res']]\n",
    "            for var in ['aice_m_mm']:\n",
    "                for m in range(1,13):\n",
    "                    vref = vrefs.sel(month=m)\n",
    "                    for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                        title = ' '.join([ide['desc'], #'cycle', str(cycle), \n",
    "                                          yearrange, calendar.month_name[m], 'minus JRA55', JRA55dovar])\n",
    "                        fname = figname('_'.join([viewname, var, \n",
    "                                                  ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-'+JRA55dovar, # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                                  yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                        if os.path.exists(fname):\n",
    "                           print('   -- skipping', fname)\n",
    "                        else:\n",
    "                            vcontrol = control[var].sel(month=m)\n",
    "                            v = ide[var].sel(month=m)\n",
    "                            bias = v - vref\n",
    "                            print('doing', fname)\n",
    "                            contourvars=[\n",
    "                                    (vcontrol, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                                    (v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                                    (vref, JRA55dovar,  {'levels': extlevel, 'colors': 'dimgray'}),\n",
    "                                    (obss.sel(month=m), 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                                    ]\n",
    "                            if ekey == controlkey:\n",
    "                                contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                            plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='Sea ice concentration minus JRA55 '+JRA55dovar,\n",
    "                                    cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                                    contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                            savefigure(fname)\n",
    "                            plt.close()\n",
    "#                         break\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model SIC standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot standard deviation of monthly SIC from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #enumerate(ice_data.keys()): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['aice_m']:\n",
    "                varstd = ide[var].groupby('time.month').std('time', skipna=True)\n",
    "                for m in range(1,13):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean standard deviation'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, 'std', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = varstd.sel(month=m)\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                        \n",
    "                        print('doing', fname)\n",
    "                        plotSIC(v, cbar_label='Standard deviation of monthly mean sea ice concentration',\n",
    "                                contourvars=[\n",
    "                                (ide[var+'_mm'].sel(month=m), ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                        ],\n",
    "                                **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observed SIC standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot standard deviation of monthly mean of SIC obs\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for m in range(1,13):\n",
    "        title = ' '.join(['Passive microwave', yearrange, calendar.month_name[m], 'mean standard deviation'])\n",
    "        fname = figname('_'.join([viewname, 'aice', 'obs', yearrange, 'std', 'month', str(m).zfill(2)]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            if viewname in ['NH']:\n",
    "                hem = 'NH'\n",
    "            else:\n",
    "                hem = 'SH'\n",
    "            vstd = eval('_'.join(['obs', hem, 'mstd'])).sel(month=m)\n",
    "            v = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "            print('doing', fname)\n",
    "            plotSIC(vstd, cbar_label='Standard deviation of monthly mean sea ice concentration',\n",
    "                    contourvars=[\n",
    "                    (v.isel(xt_ocean=slice(0, 158)), 'passive microwave', {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (v.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'})], #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SIC tendency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC tendency climatology from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #enumerate(ice_data.keys()): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['aice_m_mm']:\n",
    "                for m in range(1,13):\n",
    "                    prevm = (m-2)%12 + 1\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean tendency'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, 'mean', 'tendency', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(month=m) - ide[var].sel(month=prevm)\n",
    "#                         idev1 = ice_data[ekey+'v1'][0]\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                        \n",
    "                        print('doing', fname)\n",
    "                        plotSIC(v, cmp=plt.get_cmap('seismic'), cbar_label='SIC change from previous month',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                                contourvars=[\n",
    "#                                 (idev1[var].sel(month=m), idev1['desc'], {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "                                (ide[var].sel(month=m), ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'black'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'black'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                        ],\n",
    "                                **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#             break # cycle 1 only\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly tendency climatologies from SIC obs\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for m in range(1,13):\n",
    "        prevm = (m-2)%12 + 1\n",
    "        title = ' '.join(['Passive microwave', yearrange, calendar.month_name[m], 'mean tendency'])\n",
    "        fname = figname('_'.join([viewname, 'aice', 'obs', yearrange, 'mean', 'tendency', 'month', str(m).zfill(2)]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            if viewname in ['NH']:\n",
    "                hem = 'NH'\n",
    "            else:\n",
    "                hem = 'SH'\n",
    "            obs = eval('_'.join(['obs', hem, 'mm']))\n",
    "            v = obs.sel(month=m)\n",
    "            tendency = obs.sel(month=m) - obs.sel(month=prevm)\n",
    "            print('doing', fname)\n",
    "            plotSIC(tendency, cmp=plt.get_cmap('seismic'), cbar_label='SIC change from previous month',\n",
    "                    cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                    contourvars=[\n",
    "                    (v.isel(xt_ocean=slice(0, 158)), 'passive microwave', {'levels': extlevel, 'colors': 'black'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (v.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'black'})], #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC tendency climatology bias for each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #enumerate(ice_data.keys()): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        obs = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['aice_m_mm']:\n",
    "                for m in range(1,13):\n",
    "                    prevm = (m-2)%12 + 1\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'tendency bias'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, 'tendency', 'bias', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(month=m) - ide[var].sel(month=prevm)\n",
    "                        obsv = obs.sel(month=m)\n",
    "                        obstendency = obs.sel(month=m) - obs.sel(month=prevm)\n",
    "                        bias = v - obstendency\n",
    "                        print('doing', fname)\n",
    "                        plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='Bias (model-obs) in SIC change from previous month',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                                contourvars=[\n",
    "                                (ide[var].sel(month=m), ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'black'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'black'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                        ],\n",
    "                                **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#             break # cycle 1 only\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SIC tendency components\n",
    "\n",
    "- `daidtd` is %/day SIC change due to dynamics\n",
    "- `daidtt` is %/day SIC change due to thermodynamics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC tendency components from each cycle of each model\n",
    "cause = {'daidtd_m_mm':'dynamics', 'daidtt_m_mm': 'thermo'}\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble): #enumerate(ice_data.keys()): #['1deg']: #['025deg']: #['01deg']: #\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['daidtd_m_mm', 'daidtt_m_mm']:\n",
    "                for m in range(1,13):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], cause[var], 'tendency'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, cause[var], 'tendency', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(month=m)*calendar.monthrange(2021, m)[1]/100  # convert from %/day to SIC change over month (ignoring leap years)\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                        \n",
    "                        print('doing', fname)\n",
    "                        plotSIC(v, cmp=plt.get_cmap('seismic'), cbar_label='SIC change over month due to '+cause[var],\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                                contourvars=[\n",
    "                                (ide['aice_m_mm'].sel(month=m), ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'black'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'black'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                        ],\n",
    "                                **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#             break # cycle 1 only\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ice thickness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly ice thickness climatologies from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    if viewname == 'NH':\n",
    "        cbar_ticklevels=np.arange(0, 5.01, 1.0)\n",
    "    elif viewname == 'Amundsen-Bellingshausen':\n",
    "        cbar_ticklevels=np.arange(0, 3.501, 0.5)\n",
    "    else:\n",
    "        cbar_ticklevels=np.arange(0, 2.501, 0.5)\n",
    "    for enum, ekey in enumerate(ensemble):\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['hi_m_mm']:\n",
    "                for m in range(1,13):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(month=m)\n",
    "                        vsic = ide['aice_m_mm'].sel(month=m)\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "\n",
    "                        print('doing', fname)\n",
    "#                         plotSIC(v, cbar_label='Sea ice thickness (m)',\n",
    "#                                 cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='max', **view).set_title(title);\n",
    "                        plotSIC(v, cbar_label='Sea ice thickness (m)',\n",
    "                                cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='max',\n",
    "                                contourvars=[\n",
    "#                                 (idev1[var].sel(month=m), idev1['desc'], {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "                                (vsic, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                        ],\n",
    "                                **view).set_title(title);\n",
    "\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#             break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Snow thickness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly snow thickness climatologies from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for enum, ekey in enumerate(ensemble):\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['hs_m_mm']:\n",
    "                for m in range(1,13):\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean'])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(month=m)\n",
    "                        vsic = ide['aice_m_mm'].sel(month=m)\n",
    "                        obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "\n",
    "                        print('doing', fname)\n",
    "                        plotSIC(v, cbar_label='Snow thickness (m)',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(0, 0.701, 0.1), cbar_sigfigs=1, extend='max',\n",
    "#                                 cmap_gamma=1., cbar_ticklevels=np.arange(0, 0.601, 0.1), cbar_sigfigs=1, extend='max',\n",
    "                                contourvars=[\n",
    "#                                 (idev1[var].sel(month=m), idev1['desc'], {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "                                (vsic, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                        ],\n",
    "                                **view).set_title(title);\n",
    "\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#             break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GIOMAS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GIOMAS SIC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatologies from GIOMAS\n",
    "vname = 'aice_m'\n",
    "vdata = GIOMAS_mm[vname]\n",
    "vdata_regridded = regrid_giomas_to_025(vdata)\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for m in range(1,13):\n",
    "        title = ' '.join(['GIOMAS', yearrange, calendar.month_name[m], 'mean'])\n",
    "        fname = figname('_'.join([viewname, vname, 'GIOMAS', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            if viewname in ['NH']:\n",
    "                hem = 'NH'\n",
    "            else:\n",
    "                hem = 'SH'\n",
    "            v = vdata_regridded.sel(month=m)\n",
    "            obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "            print('doing', fname)\n",
    "            plotSIC(v,\n",
    "                    contourvars=[\n",
    "                    (v, 'GIOMAS', {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave', {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(158, None)), None, {'levels': extlevel, 'colors': 'white'})], #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "#     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GIOMAS SIT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIT climatologies from GIOMAS\n",
    "vname = 'hi_m'\n",
    "vdata = GIOMAS_mm[vname]\n",
    "vdata_regridded = regrid_giomas_to_025(vdata)\n",
    "sic_regridded = regrid_giomas_to_025(GIOMAS_mm['aice_m'])\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for m in range(1,13):\n",
    "        title = ' '.join(['GIOMAS', yearrange, calendar.month_name[m], 'mean'])\n",
    "        fname = figname('_'.join([viewname, vname, 'GIOMAS', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            if viewname in ['NH']:\n",
    "                hem = 'NH'\n",
    "            else:\n",
    "                hem = 'SH'\n",
    "            if viewname == 'NH':\n",
    "                cbar_ticklevels=np.arange(0, 5.01, 1.0)\n",
    "            elif viewname == 'Amundsen-Bellingshausen':\n",
    "                cbar_ticklevels=np.arange(0, 3.501, 0.5)\n",
    "            else:\n",
    "                cbar_ticklevels=np.arange(0, 2.501, 0.5)\n",
    "            v = vdata_regridded.sel(month=m)\n",
    "            sic = sic_regridded.sel(month=m)\n",
    "            obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "            print('doing', fname)\n",
    "            plotSIC(v, cbar_label='Sea ice thickness (m)',\n",
    "                                cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='max',\n",
    "                    contourvars=[\n",
    "                    (sic, 'GIOMAS', {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave', {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(158, None)), None, {'levels': extlevel, 'colors': 'white'})], #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "#     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GIOMAS snow thickness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly snow thickness climatologies from GIOMAS\n",
    "vname = 'hs_m'\n",
    "vdata = GIOMAS_mm[vname]\n",
    "vdata_regridded = regrid_giomas_to_025(vdata)\n",
    "sic_regridded = regrid_giomas_to_025(GIOMAS_mm['aice_m'])\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for m in range(1,13):\n",
    "        title = ' '.join(['GIOMAS', yearrange, calendar.month_name[m], 'mean'])\n",
    "        fname = figname('_'.join([viewname, vname, 'GIOMAS', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            v = vdata_regridded.sel(month=m)\n",
    "            sic = sic_regridded.sel(month=m)\n",
    "            obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "            print('doing', fname)\n",
    "            plotSIC(v, cbar_label='Snow thickness (m)',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(0, 0.701, 0.1), cbar_sigfigs=1, extend='max',\n",
    "                    contourvars=[\n",
    "                    (sic, 'GIOMAS', {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave', {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(158, None)), None, {'levels': extlevel, 'colors': 'white'})], #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "#     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GIOMAS SIC bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot bias in GIOMAS SIC monthly climatologies relative to NSIDC (GIOMAS - NSIDC)\n",
    "vname = 'aice_m'\n",
    "vdata = GIOMAS_mm[vname]\n",
    "vdata_regridded = regrid_giomas_to_025(vdata)\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for m in range(1,13):\n",
    "        title = ' '.join(['GIOMAS', vname, yearrange, calendar.month_name[m], 'bias'])\n",
    "        fname = figname('_'.join([viewname, vname, 'GIOMAS-obs', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            if viewname in ['NH']:\n",
    "                hem = 'NH'\n",
    "            else:\n",
    "                hem = 'SH'\n",
    "            v = vdata_regridded.sel(month=m)\n",
    "            obsv = eval('regrid_'+hem+'obs_to_025('+'_'.join(['obs', hem, 'mm'])+')').sel(month=m)\n",
    "            bias = v-obsv\n",
    "            print('doing', fname)\n",
    "            plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='GIOMAS SIC minus passive microwave obs',\n",
    "                                cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                    contourvars=[\n",
    "                    (v, 'GIOMAS', {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave', {'levels': extlevel, 'colors': 'k'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(158, None)), None, {'levels': extlevel, 'colors': 'k'})], #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIC bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC climatology bias for each model wrt GIOMAS\n",
    "vname = 'aice_m'\n",
    "var = vname+'_mm'\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.sel(month=m)\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean bias'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].sel(month=m)\n",
    "                    bias = v - vref\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'y'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='Sea ice concentration minus GIOMAS',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIT bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIT climatology bias for each model wrt GIOMAS\n",
    "vname = 'hi_m'\n",
    "var = vname+'_mm'\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.sel(month=m)\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean bias'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                if False: #os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].sel(month=m)\n",
    "                    bias = v - vref\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'y'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='Sea ice thickness minus GIOMAS (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-1, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, extend='both', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS snow bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly snow thickness climatology bias for each model wrt GIOMAS\n",
    "\n",
    "# TODO: check if CICE data is water-equivalent I've assumed it isn't - which is consistent with the CICE manual\n",
    "# CICE snow density = 330 kg/m^3, not sure what GIOMAS density is\n",
    "# correction was applied in get_giomas\n",
    "\n",
    "vname = 'hs_m'\n",
    "var = vname+'_mm'\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.sel(month=m)\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'mean bias'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].sel(month=m)\n",
    "                    bias = v - vref\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'y'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(bias, cmp=plt.get_cmap('seismic'), cbar_label='Snow thickness minus GIOMAS (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-0.3, 0.301, 0.1), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, extend='both', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIC MAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC MAD for each model wrt GIOMAS\n",
    "vname = 'aice_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'MAD'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'MAD', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    MAD = (np.abs(va - vrefa)).mean('time')\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'w'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(MAD, cmp=plt.get_cmap('inferno'), cbar_label='Sea ice concentration MAD vs. GIOMAS',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(0, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIC MAD diference from control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC MAD for each model wrt GIOMAS minus control MAD\n",
    "vname = 'aice_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'MAD - control'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'MAD-control', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    MAD = (np.abs(va - vrefa)).mean('time')\n",
    "                    vcontrol = control[vname].groupby('time.month')[m]\n",
    "                    MADcontrol = (np.abs(vcontrol - vrefa)).mean('time')\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(MAD-MADcontrol, cmp=plt.get_cmap('seismic'), cbar_label='Change in SIC MAD vs. GIOMAS due to perturbation',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-0.2, 0.201, 0.05), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIT MAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIT MAD for each model wrt GIOMAS\n",
    "vname = 'hi_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'MAD'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'MAD', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    MAD = (np.abs(va - vrefa)).mean('time')\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'w'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(MAD, cmp=plt.get_cmap('inferno'), cbar_label='Sea ice thickness MAD vs. GIOMAS (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(0, 2.01, 0.25), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, extend='max', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIT MAD difference from control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIT MAD for each model wrt GIOMAS minus control MAD\n",
    "vname = 'hi_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'MAD - control'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'MAD-control', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    MAD = (np.abs(va - vrefa)).mean('time')\n",
    "                    vcontrol = control[vname].groupby('time.month')[m]\n",
    "                    MADcontrol = (np.abs(vcontrol - vrefa)).mean('time')\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(MAD-MADcontrol, cmp=plt.get_cmap('seismic'), cbar_label='Change in SIT MAD vs. GIOMAS due to perturbation (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-0.5, 0.501, 0.1), cbar_sigfigs=1,\n",
    "                            contourvars=contourvars, extend='both', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS snow MAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# plot monthly snow MAD for each model wrt GIOMAS\n",
    "vname = 'hs_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'MAD'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'MAD', 'month', str(m).zfill(2)]))\n",
    "                if False: #os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    MAD = (np.abs(va - vrefa)).mean('time')\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'w'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(MAD, cmp=plt.get_cmap('inferno'), cbar_label='Snow thickness MAD vs. GIOMAS (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(0, 0.501, 0.1), cbar_sigfigs=1,\n",
    "                            contourvars=contourvars, extend='max', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS snow MAD difference from control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# plot monthly snow MAD for each model wrt GIOMAS minus control MAD\n",
    "vname = 'hs_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'MAD - control'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'MAD-control', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    MAD = (np.abs(va - vrefa)).mean('time')\n",
    "                    vcontrol = control[vname].groupby('time.month')[m]\n",
    "                    MADcontrol = (np.abs(vcontrol - vrefa)).mean('time')\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(MAD-MADcontrol, cmp=plt.get_cmap('seismic'), cbar_label='Change in snow thickness MAD vs. GIOMAS due to perturb (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-0.02, 0.0201, 0.005), cbar_sigfigs=3,\n",
    "                            contourvars=contourvars, extend='both', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIC RMSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIC RMSE for each model wrt GIOMAS\n",
    "vname = 'aice_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'RMSE'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'RMSE', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    RMSE = np.sqrt(((va - vrefa)**2).mean('time'))\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'w'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(RMSE, cmp=plt.get_cmap('inferno'), cbar_label='Sea ice concentration RMSE vs. GIOMAS',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(0, 1.01, 0.25), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIC RMSE difference from control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# plot monthly SIC RMSE for each model wrt GIOMAS minus control RMSE\n",
    "vname = 'aice_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'RMSE - control'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'RMSE-control', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    RMSE = np.sqrt(((va - vrefa)**2).mean('time'))\n",
    "                    vcontrol = control[vname].groupby('time.month')[m]\n",
    "                    RMSEcontrol = np.sqrt(((vcontrol - vrefa)**2).mean('time'))\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(RMSE-RMSEcontrol, cmp=plt.get_cmap('seismic'), cbar_label='Change in SIC RMSE vs. GIOMAS due to perturbation',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-0.2, 0.201, 0.05), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIT RMSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly SIT RMSE for each model wrt GIOMAS\n",
    "vname = 'hi_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'RMSE'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'RMSE', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    RMSE = np.sqrt(((va - vrefa)**2).mean('time'))\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'w'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(RMSE, cmp=plt.get_cmap('inferno'), cbar_label='Sea ice thickness RMSE vs. GIOMAS (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(0, 2.01, 0.25), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, extend='max', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS SIT RMSE difference from control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# plot monthly SIT RMSE for each model wrt GIOMAS minus control RMSE\n",
    "vname = 'hi_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'RMSE - control'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'RMSE-control', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    RMSE = np.sqrt(((va - vrefa)**2).mean('time'))\n",
    "                    vcontrol = control[vname].groupby('time.month')[m]\n",
    "                    RMSEcontrol = np.sqrt(((vcontrol - vrefa)**2).mean('time'))\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(RMSE-RMSEcontrol, cmp=plt.get_cmap('seismic'), cbar_label='Change in SIT RMSE vs. GIOMAS due to perturbation (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-0.2, 0.201, 0.05), cbar_sigfigs=2,\n",
    "                            contourvars=contourvars, extend='both', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS snow RMSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# plot monthly snow RMSE for each model wrt GIOMAS\n",
    "vname = 'hs_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'RMSE'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'RMSE', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    RMSE = np.sqrt(((va - vrefa)**2).mean('time'))\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'w'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(RMSE, cmp=plt.get_cmap('inferno'), cbar_label='Snow thickness RMSE vs. GIOMAS (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(0, 0.501, 0.1), cbar_sigfigs=1,\n",
    "                            contourvars=contourvars, extend='max', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model-GIOMAS snow RMSE difference from control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# plot monthly snow RMSE for each model wrt GIOMAS minus control RMSE\n",
    "vname = 'hs_m'\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        sic_vobss = obsregridders[hem][ice_data[ekey][0]['res']](eval('_'.join(['obs', hem, 'mm'])))\n",
    "        sic_vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS_mm['aice_m'])\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        for m in range(1,13):\n",
    "            sic_vobs = sic_vobss.sel(month=m)\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'RMSE - control'])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, 'RMSE-control', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    sic_control = control['aice_m_mm'].sel(month=m)\n",
    "                    sic_v = ide['aice_m_mm'].sel(month=m)\n",
    "                    sic_vref = sic_vrefs.sel(month=m)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "                    RMSE = np.sqrt(((va - vrefa)**2).mean('time'))\n",
    "                    vcontrol = control[vname].groupby('time.month')[m]\n",
    "                    RMSEcontrol = np.sqrt(((vcontrol - vrefa)**2).mean('time'))\n",
    "                    print('doing', fname)\n",
    "                    contourvars=[\n",
    "                            (sic_control, control['desc'], {'levels': extlevel, 'colors': 'g'}),\n",
    "                            (sic_v, ide['desc'], {'levels': extlevel, 'colors': 'm'}),\n",
    "                            (sic_vref, 'GIOMAS',  {'levels': extlevel, 'colors': 'c'}),\n",
    "                            (sic_vobs, 'passive microwave',  {'levels': extlevel, 'colors': 'k'})\n",
    "                            ]\n",
    "                    if ekey == controlkey:\n",
    "                        contourvars = contourvars[0:1]+contourvars[2:]\n",
    "                    plotSIC(RMSE-RMSEcontrol, cmp=plt.get_cmap('seismic'), cbar_label='Change in snow thickness RMSE vs. GIOMAS due to perturb (m)',\n",
    "                            cmap_gamma=1., cbar_ticklevels=np.arange(-0.02, 0.0201, 0.005), cbar_sigfigs=3,\n",
    "                            contourvars=contourvars, extend='both', **view).set_title(title);\n",
    "\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#                 break\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ice daily"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concentration"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "# plot daily SIC obs\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    indata = '_'.join(['obs', hem, 'daily'])\n",
    "    for date in eval(indata)['time'].data[213:578]:\n",
    "        datestr = np.datetime_as_string(date, unit='D')\n",
    "        title = ' '.join(['Passive microwave', datestr])\n",
    "        fname = figname('_'.join([viewname, 'aice', 'obs', datestr]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            v = eval(indata).sel(time=date)\n",
    "            print('doing', fname)\n",
    "            plotSIC(v, **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily SIC obs\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        indata = obs_NH_daily\n",
    "    else:\n",
    "        indata = obs_SH_daily\n",
    "    for date in indata['time'].data[213:578]:\n",
    "        datestr = np.datetime_as_string(date, unit='D')\n",
    "        title = ' '.join(['Passive microwave', datestr])\n",
    "        fname = figname('_'.join([viewname, 'aice', 'obs', datestr]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            v = indata.sel(time=date)\n",
    "            print('doing', fname)\n",
    "            plotSIC(v, **view).set_title(title);\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily SIC from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for ekey in ice_data.keys():\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['aice']:\n",
    "                for date in ide[var]['time'].data: #[213:578]:\n",
    "                    datestr = date.strftime('%Y-%m-%d')\n",
    "                    if datestr[0:7] == '2017-01':\n",
    "                        title = ' '.join([ide['desc'], 'cycle', str(cycle), datestr])\n",
    "                        fname = figname('_'.join([viewname, var, \n",
    "                                                  ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                                  datestr]))\n",
    "                        if os.path.exists(fname):\n",
    "                            print('   -- skipping', fname)\n",
    "                        else:\n",
    "                            v = ide[var].sel(time=date)\n",
    "                            print('doing', fname)\n",
    "                            plotSIC(v, **view).set_title(title);\n",
    "                            savefigure(fname)\n",
    "                            plt.close()\n",
    "    #                         break\n",
    "#             break  # only do cycle 1\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Thickness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily ice thickness from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname == 'NH':\n",
    "        cbar_ticklevels=np.arange(0, 5.01, 1.0)\n",
    "    elif viewname == 'Amundsen-Bellingshausen':\n",
    "        cbar_ticklevels=np.arange(0, 3.501, 0.5)\n",
    "    else:\n",
    "        cbar_ticklevels=np.arange(0, 2.501, 0.5)\n",
    "    for ekey in ['01deg']: #ice_data.keys():\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['hi']:\n",
    "                for date in ide[var]['time'].data: #[213:578]:\n",
    "                    datestr = date.strftime('%Y-%m-%d')\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), datestr])\n",
    "                    fname = figname('_'.join([viewname, var, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                              datestr]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "                        v = ide[var].sel(time=date)\n",
    "                        print('doing', fname)\n",
    "                        plotSIC(v, legend=False, cbar_label='Sea ice thickness (m)',\n",
    "                                cmp=cm.cm.ice,\n",
    "                                cmap_gamma=1.0, cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='max', **view).set_title(title);\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "            break  # only do cycle 1\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ocean daily"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily MLD from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for ekey in ['01deg']: #ice_data.keys():\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['mld']:\n",
    "                for date in ide[var]['time'].data:\n",
    "                    datestr = date.strftime('%Y-%m-%d')\n",
    "                    if True: #datestr[0:7] == '2017-01':\n",
    "                        title = ' '.join([ide['desc'], 'cycle', str(cycle), datestr])\n",
    "                        fname = figname('_'.join([viewname, var, \n",
    "                                                  ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                                  datestr]))\n",
    "                        if os.path.exists(fname):\n",
    "                            print('   -- skipping', fname)\n",
    "                        else:\n",
    "                            v = ide[var].sel(time=date)\n",
    "                            print('doing', fname)\n",
    "                            plotSIC(v, legend=False, cbar_label='Mixed layer depth (m)', cmp=cm.cm.thermal_r,\n",
    "                                cmap_gamma=1.0, cbar_ticklevels=np.arange(0, 50, 10), cbar_sigfigs=1, **view).set_title(title);\n",
    "                            savefigure(fname)\n",
    "                            plt.close()\n",
    "#                             break\n",
    "            break  # only do cycle 1\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily SSS from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for ekey in list(ice_data.keys())[2:]:\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['sss']:\n",
    "                for date in ide[var]['time'].data:\n",
    "                    datestr = date.strftime('%Y-%m-%d')\n",
    "                    if datestr[0:7] == '2017-01':\n",
    "                        title = ' '.join([ide['desc'], 'cycle', str(cycle), datestr])\n",
    "                        fname = figname('_'.join([viewname, var, \n",
    "                                                  ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                                  datestr]))\n",
    "                        if os.path.exists(fname):\n",
    "                            print('   -- skipping', fname)\n",
    "                        else:\n",
    "                            v = ide[var].sel(time=date)\n",
    "                            print('doing', fname)\n",
    "                            plotSIC(v, cbar_label='Sea surface salinity', cmp=cm.cm.haline,\n",
    "                                cmap_gamma=1.0, cbar_ticklevels=np.arange(31.5, 34.501, 0.5), cbar_sigfigs=2, extend='both', **view).set_title(title);\n",
    "                            savefigure(fname)\n",
    "                            plt.close()\n",
    "#                             break\n",
    "            break  # only do cycle 1\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily SST from each cycle of each model\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for ekey in list(ice_data.keys())[2:]:\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            for var in ['sst']:\n",
    "                for date in ide[var]['time'].data:\n",
    "                    datestr = date.strftime('%Y-%m-%d')\n",
    "                    if datestr[0:7] == '2017-01':\n",
    "                        title = ' '.join([ide['desc'], 'cycle', str(cycle), datestr])\n",
    "                        fname = figname('_'.join([viewname, var, \n",
    "                                                  ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                                  datestr]))\n",
    "                        if False: #os.path.exists(fname):\n",
    "                            print('   -- skipping', fname)\n",
    "                        else:\n",
    "                            v = ide[var].sel(time=date) - 273.15\n",
    "                            print('doing', fname)\n",
    "                            plotSIC(v, cbar_label='Sea surface temperature (°C)', cmp=cm.cm.thermal,\n",
    "                                cmap_gamma=1.0, cbar_ticklevels=np.arange(-2, 7, 1), cbar_sigfigs=1, extend='max', **view).set_title(title);\n",
    "                            savefigure(fname)\n",
    "                            plt.close()\n",
    "#                             break\n",
    "            break  # only do cycle 1\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JRA55-do monthly climatology"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly climatological JRA siconc and siconca\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for var in ['siconc_mm', 'siconca_mm']:\n",
    "        for m in range(1,13):\n",
    "            title = ' '.join(['JRA55-do', var, yearrange, calendar.month_name[m], 'mean'])\n",
    "            fname = figname('_'.join([viewname, var, \n",
    "                                      yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "            if os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "            else:\n",
    "                print('doing', fname)\n",
    "                v = JRA55do_data[var].sel(month=m)/100\n",
    "                siconc = JRA55do_data['siconc_mm'].sel(month=m)/100\n",
    "                siconca = JRA55do_data['siconca_mm'].sel(month=m)/100\n",
    "                obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                plotSIC(v, cbar_label='Sea ice concentration',\n",
    "                    contourvars=[\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                    (siconc.isel(longitude=slice(0, 158)), 'siconc', {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (siconc.isel(longitude=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    (siconca.isel(longitude=slice(0, 158)), 'siconca', {'levels': extlevel, 'colors': 'r'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (siconca.isel(longitude=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'r'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    (obsv.isel(xt_ocean=slice(0, 158)), 'NSIDC', {'levels': extlevel, 'colors': 'silver'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'silver'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    ], **view).set_title(title);\n",
    "                savefigure(fname)\n",
    "                plt.close()\n",
    "\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot monthly climatological JRA55-do siconc and siconca bias relative to NSIDC\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for var in ['siconc_mm', 'siconca_mm']: \n",
    "        for m in range(1,13):\n",
    "            title = ' '.join(['JRA55-do', var, yearrange, calendar.month_name[m], 'bias'])\n",
    "            fname = figname('_'.join([viewname, var+'-obs', \n",
    "                                      yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "            if os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "            else:\n",
    "                print('doing', fname)\n",
    "                siconc = JRA55do_data['siconc_mm'].sel(month=m)/100\n",
    "                siconca = JRA55do_data['siconca_mm'].sel(month=m)/100\n",
    "                obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                v = JRA55do_data[var + '_regridded_to_'+hem+'obs'].sel(month=m) - obsv\n",
    "                plotSIC(v, cmp=plt.get_cmap('seismic'), cbar_label='Sea ice concentration minus NSIDC',\n",
    "                    cmap_gamma=1., cbar_ticklevels=np.arange(-.15,.1501,.05), cbar_sigfigs=2,\n",
    "                    contourvars=[\n",
    "# sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                    (siconc.isel(longitude=slice(0, 158)), 'siconc', {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (siconc.isel(longitude=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'g'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    (siconca.isel(longitude=slice(0, 158)), 'siconca', {'levels': extlevel, 'colors': 'y'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (siconca.isel(longitude=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'y'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    (obsv.isel(xt_ocean=slice(0, 158)), 'NSIDC', {'levels': extlevel, 'colors': 'silver'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                    (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'silver'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                    ], \n",
    "                        **view).set_title(title);\n",
    "                savefigure(fname)\n",
    "                plt.close()\n",
    "\n",
    "#             break\n",
    "#         break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JRA55-do daily means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily JRA55-do siconc\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for var in ['siconc']:\n",
    "        for date in JRA55do_data[var]['time'].data:\n",
    "            datestr = np.datetime_as_string(date, unit='D')\n",
    "            if datestr[0:7] == '2017-01':\n",
    "                title = ' '.join(['JRA55-do', datestr])\n",
    "                fname = figname('_'.join([viewname, var, 'JRA55-do', datestr]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = JRA55do_data[var].sel(time=date)/100\n",
    "                    print('doing', fname)\n",
    "                    plotSIC(v, cbar_label=JRA55do_data[var].long_name.replace('Area Percentage', 'Concentration'), **view).set_title(title);\n",
    "#                     savefigure(fname)\n",
    "#                     plt.close()\n",
    "                    break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily JRA55-do uas, vas\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for var in ['uas_d']:\n",
    "        for date in JRA55do_data[var]['time'].data:\n",
    "            datestr = np.datetime_as_string(date, unit='D')\n",
    "            if datestr[0:7] == '2017-01':\n",
    "                title = ' '.join(['JRA55-do', datestr])\n",
    "                fname = figname('_'.join([viewname, var, 'JRA55-do', datestr]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = JRA55do_data[var].sel(time=date)\n",
    "                    print('doing', fname)\n",
    "                    plotSIC(v, cbar_label=JRA55do_data[var].long_name+' (m/s)', cmp=plt.get_cmap('seismic'),\n",
    "                        cmap_gamma=1.0, cbar_ticklevels=np.arange(-15, 15.001, 5), cbar_sigfigs=0, extend='both', **view).set_title(title);\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily JRA55-do 'psl'\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for var in ['psl_d']:\n",
    "        for date in JRA55do_data[var]['time'].data:\n",
    "            datestr = np.datetime_as_string(date, unit='D')\n",
    "            if datestr[0:7] == '2017-01':\n",
    "                title = ' '.join(['JRA55-do', datestr])\n",
    "                fname = figname('_'.join([viewname, var, 'JRA55-do', datestr]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = JRA55do_data[var].sel(time=date)/100 # convert to hPa\n",
    "                    print('doing', fname)\n",
    "                    plotSIC(v, cbar_label=JRA55do_data[var].long_name+' (hPa)', cmp=cm.cm.thermal,\n",
    "                        cmap_gamma=1.0, cbar_ticklevels=np.arange(960, 1021, 20), cbar_sigfigs=0, extend='both', **view).set_title(title);\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily JRA55-do 'tas'\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for var in ['tas_d']:\n",
    "        for date in JRA55do_data[var]['time'].data:\n",
    "            datestr = np.datetime_as_string(date, unit='D')\n",
    "            if datestr[0:7] == '2017-01':\n",
    "                title = ' '.join(['JRA55-do', datestr])\n",
    "                fname = figname('_'.join([viewname, var, 'JRA55-do', datestr]))\n",
    "                if False: #os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = JRA55do_data[var].sel(time=date) - 273.15  # convert to C\n",
    "                    print('doing', fname)\n",
    "                    plotSIC(v, cbar_label=JRA55do_data[var].long_name+' (°C)', cmp=cm.cm.thermal,\n",
    "                        cmap_gamma=1.0, cbar_ticklevels=np.arange(-8, 3.001, 1), cbar_sigfigs=0, extend='both', **view).set_title(title);\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily JRA55-do 'rlds'\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for var in ['rlds_d']:\n",
    "        for date in JRA55do_data[var]['time'].data:\n",
    "            datestr = np.datetime_as_string(date, unit='D')\n",
    "            if datestr[0:7] == '2017-01':\n",
    "                title = ' '.join(['JRA55-do', datestr])\n",
    "                fname = figname('_'.join([viewname, var, 'JRA55-do', datestr]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = JRA55do_data[var].sel(time=date)\n",
    "                    print('doing', fname)\n",
    "                    plotSIC(v, cbar_label=JRA55do_data[var].long_name+' ('+JRA55do_data[var].units+')', cmp=cm.cm.thermal,\n",
    "                        cmap_gamma=1.0, cbar_ticklevels=np.arange(150, 401, 50), cbar_sigfigs=0, extend='both', **view).set_title(title);\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot daily JRA55-do 'rsds'\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for var in ['rsds_d']:\n",
    "        for date in JRA55do_data[var]['time'].data:\n",
    "            datestr = np.datetime_as_string(date, unit='D')\n",
    "            if datestr[0:7] == '2017-01':\n",
    "                title = ' '.join(['JRA55-do', datestr])\n",
    "                fname = figname('_'.join([viewname, var, 'JRA55-do', datestr]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    v = JRA55do_data[var].sel(time=date)\n",
    "                    print('doing', fname)\n",
    "                    plotSIC(v, cbar_label=JRA55do_data[var].long_name+' ('+JRA55do_data[var].units+')', cmp=cm.cm.thermal,\n",
    "                        cmap_gamma=1.0, cbar_ticklevels=np.arange(0, 401, 50), cbar_sigfigs=0, extend='max', **view).set_title(title);\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Misc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotSIC(v, **SH);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotSIC(obs_NH.isel(time=-1), **NH).set_title('final obs');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotSIC(obs_NH_mm.sel(month=1), **NH).set_title('Obs monthly mean');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotSIC(obs_SH_mm.sel(month=1), **SH);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## JRA55-do minus ERA5 biases\n",
    "- TODO: mask out land\n",
    "- plot fields for forcing variables - see https://github.com/COSIMA/access-om2/issues/242#issuecomment-918795331 and https://github.com/COSIMA/01deg_jra55_iaf/blob/master/atmosphere/forcing.json and https://github.com/COSIMA/libaccessom2/blob/242-era5-support/tests/ERA5/forcing.json and https://arccss.slack.com/archives/D8BRL3VAS/p1631531254001600\n",
    "| Coupling name | JRA55-do | ERA5 | Note / TODO |\n",
    "| --- | --- | --- | --- |\n",
    "| `swfld_ai` | `rsds` Surface Downwelling Shortwave Radiation [W m-2] | `msdrswrf` Mean surface direct short-wave radiation flux [W m**-2] | should this be `msdwswrf` Mean surface downward short-wave radiation flux [W m**-2]? Does this include `msdwuvrf` Mean surface downward UV radiation flux [W m**-2]? I guess we don't want to use the \"net\" quantity `msnswrf` Mean surface net short-wave radiation flux [W m**-2]?|\n",
    "| `lwfld_ai` | `rlds` Surface Downwelling Longwave Radiation [W m-2] | `msdwlwrf` Mean surface downward long-wave radiation flux [W m**-2] | I guess we don't want to use the \"net\" quantity `msnlwrf` Mean surface net long-wave radiation flux [W m**-2]? |\n",
    "| `rain_ai` | `prra` Rainfall Flux [kg m-2 s-1] | `mcpr` Mean convective precipitation rate [kg m**-2 s**-1] **and** `mlspr` Mean large-scale precipitation rate [kg m**-2 s**-1] | does snowfall need to be subtracted? Or use `crr` Convective rain rate [kg m**-2 s**-1] and `lsrr` Large scale rain rate [kg m**-2 s**-1] instead? Or`mtpr` Mean total precipitation rate [kg m**-2 s**-1] and `ptype` Precipitation type [[code table (4.201)](https://apps.ecmwf.int/codes/grib/format/grib2/ctables/4/201)] instead? |\n",
    "| `snow_ai` | `prsn` Snowfall Flux [kg m-2 s-1] | `mlssr` Mean large-scale snowfall rate [kg m**-2 s**-1] | add `mcsr` Mean convective snowfall rate [kg m**-2 s**-1]? or just use `msr`\tMean snowfall rate [kg m**-2 s**-1]? what about `csfr` Convective snowfall rate water equivalent [kg m**-2 s**-1] and `lssfr` Large scale snowfall rate water equivalent [kg m**-2 s**-1] ?|\n",
    "| `press_ai` | `psl` Sea Level Pressure [Pa] | `msl` Mean sea level pressure [Pa] |  |\n",
    "| `runof_ai` | `friver` Water Flux into Sea Water from Rivers [kg m-2 s-1] | `msror` Mean surface runoff rate [kg m**-2 s**-1] **and** `mssror` Mean sub-surface runoff rate [kg m**-2 s**-1] | or just use `mror` Mean runoff rate [kg m**-2 s**-1]? |\n",
    "| `tair_ai` | `tas` Near-Surface (10m) Air Temperature [K] | `t2m` 2 metre temperature [K] | [Change to 10m height](https://github.com/COSIMA/access-om2/issues/242#issuecomment-1012817544)  - see appendix A2 in [Tsujino et al 2018](https://doi.org/10.1016/j.ocemod.2018.07.002)|\n",
    "| `qair_ai` | `huss` Near-Surface (10m) Specific Humidity [1]| `t2m` 2 metre temperature [K] **and** `d2m` 2 metre dewpoint temperature [K] | [Convert dew point to specific humidity](https://github.com/COSIMA/access-om2/issues/242#issuecomment-918783268) (also requires `msl` Mean sea level pressure [Pa]) and [change to 10m height](https://github.com/COSIMA/access-om2/issues/242#issuecomment-1012817544) - see appendix A2 in [Tsujino et al 2018](https://doi.org/10.1016/j.ocemod.2018.07.002) |\n",
    "| `uwnd_ai` | `uas` Eastward Near-Surface (10m) Wind [m s-1] | `u10` 10 metre U wind component [m s**-1] |  |\n",
    "| `vwnd_ai` | `vas` Northward Near-Surface (10m) Wind [m s-1] | `v10` 10 metre V wind component [m s**-1] |  |\n",
    "| `licalvf_ai` | `licalvf` Land Ice Calving Flux [kg m-2 s-1] |  | not available in ERA5 - use JRA55-do values? |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "varmapping = { # map variables JRA55-do: [ ERA5 ... ] based on table above\n",
    "    'rsds': ['msdrswrf'],\n",
    "    'rlds': ['msdwlwrf'],\n",
    "    'prra': ['mcpr', 'mlspr'],\n",
    "    'prsn': ['mcsr', 'mlssr'],\n",
    "    'psl': ['msl'],\n",
    "    'friver': ['msror', 'mssror'],\n",
    "    'tas': ['t2m'],\n",
    "    'huss': ['t2m', 'd2m', 'msl'],\n",
    "    'uas': ['u10'],\n",
    "    'vas': ['v10'] }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load JRA55do forcing variables and corresponding ERA5 variable(s)\n",
    "for JRA55dovname, ERA5vararray in varmapping.items():\n",
    "    loadJRA55do(JRA55do_data, varnames=[JRA55dovname])\n",
    "    loadERA5(ERA5_data, varnames=ERA5vararray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loaddata(ice_data['025deg'][0], varnames=['tmask'], n=1)\n",
    "landmask025 = ice_data['025deg'][0]['tmask'].fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mm025 = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# regrid JRA55do forcing variables and corresponding ERA5 variable(s) to model 0.25deg grid\n",
    "for JRA55dovname, ERA5vararray in varmapping.items():\n",
    "    print(JRA55dovname)\n",
    "    mm025[JRA55dovname] = dict()\n",
    "    mm025[JRA55dovname]['JRA55do'] = JRA55do_to_025(method='patch')(JRA55do_data[JRA55dovar+'_mm']).where(landmask025 != 0)  # use 'patch' method to match access-om2\n",
    "    mm025[JRA55dovname]['ERA5'] = {k: ERA5_to_025(method='patch')(ERA5_data[k+'_mm']).where(landmask025 != 0)  # use 'patch' method to match access-om2\n",
    "                                 for k in ERA5vararray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot JRA55do minus corresponding ERA5 variable(s)\n",
    "for JRA55dovname, ddict in mm025.items():\n",
    "    print(JRA55dovname)\n",
    "    JRA55dov = ddict['JRA55do']\n",
    "    for ERA5vname, ERA5v in ddict['ERA5'].items():\n",
    "        plt.figure()\n",
    "        (JRA55dov - ERA5v).sel(month=1).plot()\n",
    "        plt.title('JRA55-do '+JRA55dovname+' minus ERA5 '+ERA5vname)\n",
    "    #     break\n",
    "    # break\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mm025"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_tas_025 = JRA55do_to_025(method='patch')(JRA55do_data['tas'+'_mm']).where(landmask != 0)  # use 'patch' method to match access-om2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "landmasks = ['1deg', '025deg', '01deg']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# get model land masks\n",
    "# for ekey in ice_data.keys():\n",
    "# for ekey in ensemble: # just the ensemble\n",
    "for ekey in landmasks:\n",
    "    print(ekey)\n",
    "    for ide in ice_data[ekey]:\n",
    "        loaddata(ide, varnames=['tmask'], n=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temperature\n",
    "See https://github.com/COSIMA/access-om2/issues/242#issuecomment-914960099"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SATplot(dataname, dataset, vname):\n",
    "    for viewname, view in views.items():\n",
    "        print(viewname)\n",
    "        if viewname in ['NH']:\n",
    "            hem = 'NH'\n",
    "        else:\n",
    "            hem = 'SH'\n",
    "        for m in range(1, 13):\n",
    "            title = ' '.join([dataname, yearrange, calendar.month_name[m], 'mean'])\n",
    "            fname = figname('_'.join([viewname, vname, dataname, yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "            if os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "            else:\n",
    "                print('doing', fname)\n",
    "                plt.close()\n",
    "                cbar_ticklevels=np.arange(-40, 10, 5)\n",
    "                plotSIC(dataset[vname].sel(month=m)-273.15, cbar_label='Surface air temperature (°C)',\n",
    "                                    cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='both', cmp=cm.cm.thermal,\n",
    "                                    # contourvars=[], \n",
    "                                    legend=False,\n",
    "                                    feature=cft.NaturalEarthFeature('physical', 'land', '50m',\n",
    "                                                   edgecolor='black', facecolor='None', \n",
    "                                                   linewidth=0.5),\n",
    "                                    featureoverplot=True,\n",
    "                                    contourvars=[\n",
    "                                        (ice_data['1deg'][0]['tmask'], '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C0'}),\n",
    "                                        (ice_data['025deg'][0]['tmask'], '0.25° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C1'}),\n",
    "                                        (ice_data['01deg'][0]['tmask'], '0.1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(180, 360)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(0, 158)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(159, 360)), None, {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(yt_ocean=slice(-90, -50)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'})\n",
    "    #                                 (JRA55do_data['tas_mm'].sel(month=m), 'bla', {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "    #                                 (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    # # sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "    #                                 (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    #                                 (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                            ],\n",
    "                                    **view).set_title(title);\n",
    "                savefigure(fname)\n",
    "                # plt.close()\n",
    "            # break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "SATplot('JRA55-do', JRA55do_data, 'tas_mm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "SATplot('ERA5', ERA5_data, 't2m_mm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SATbiasplot():\n",
    "    for viewname, view in views.items():\n",
    "        print(viewname)\n",
    "        if viewname in ['NH']:\n",
    "            hem = 'NH'\n",
    "        else:\n",
    "            hem = 'SH'\n",
    "        for m in range(1, 13):\n",
    "            title = ' '.join(['JRA55-do 10m SAT - ERA5 2m SAT', yearrange, calendar.month_name[m], 'mean'])\n",
    "            fname = figname('_'.join([viewname, 'JRA55-do_tas_mm-ERA5_t2m_mm', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "            if os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "            else:\n",
    "                print('doing', fname)\n",
    "                plt.close()\n",
    "                cbar_ticklevels=np.arange(-5, 5.01, 1)\n",
    "                obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                plotSIC(bias[m-1], cbar_label='Surface air temperature difference (°C)',\n",
    "                                    cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='both', cmp=plt.get_cmap('seismic'),\n",
    "                                    # contourvars=[], \n",
    "                                    legend=False,\n",
    "                                    feature=cft.NaturalEarthFeature('physical', 'land', '50m',\n",
    "                                                   edgecolor='black', facecolor='None', \n",
    "                                                   linewidth=0.5),\n",
    "                                    featureoverplot=True,\n",
    "                                    contourvars=[\n",
    "                                        # (ice_data['1deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '1° ACCESS-OM2 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C0'}),\n",
    "                                        # (ice_data['025deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '0.25° ACCESS-OM2-025 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C1'}),\n",
    "                                        # (ice_data['01deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '0.1° ACCESS-OM2-01 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C2'}),\n",
    "                                        (ice_data['1deg'][2]['aice_m_mm'].sel(month=m), '1° ACCESS-OM2 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C0'}),\n",
    "                                        (ice_data['025deg'][2]['aice_m_mm'].sel(month=m), '0.25° ACCESS-OM2-025 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C1'}),\n",
    "                                        (ice_data['01deg'][2]['aice_m_mm'].sel(month=m), '0.1° ACCESS-OM2-01 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'], '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C0'}),\n",
    "                                        # (ice_data['025deg'][0]['tmask'], '0.25° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C1'}),\n",
    "                                        # (ice_data['01deg'][0]['tmask'], '0.1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(180, 360)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(0, 158)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(159, 360)), None, {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(yt_ocean=slice(-90, -50)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'})\n",
    "    #                                 (JRA55do_data['tas_mm'].sel(month=m), 'bla', {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "    #                                 (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    # # sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                        (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave SIC',     {'levels': extlevel, 'colors': 'dimgray'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                        (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'dimgray'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                                        (ice_data['1deg'][0]['tmask'], None, {'levels': [0, 1e-15], 'colors': 'k'}),\n",
    "                            ],\n",
    "                                    **view).set_title(title);\n",
    "                savefigure(fname)\n",
    "                plt.close()\n",
    "            # break"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "tags": []
   },
   "source": [
    "def SATbiasplot():\n",
    "    for viewname, view in views.items():\n",
    "        print(viewname)\n",
    "        if viewname in ['NH']:\n",
    "            hem = 'NH'\n",
    "        else:\n",
    "            hem = 'SH'\n",
    "        for m in [1,2,7]: #range(1, 13):\n",
    "            title = ' '.join(['JRA55-do 10m SAT - ERA5 2m SAT', yearrange, calendar.month_name[m], 'mean'])\n",
    "            fname = figname('_'.join([viewname, 'JRA55-do_tas_mm-ERA5_t2m_mm', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "            if False: #os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "            else:\n",
    "                print('doing', fname)\n",
    "                plt.close()\n",
    "                cbar_ticklevels=np.arange(-5, 5.01, 1)\n",
    "                plotSIC(bias[m-1], cbar_label='Surface air temperature difference (°C)',\n",
    "                                    cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='both', cmp=plt.get_cmap('seismic'),\n",
    "                                    # contourvars=[], \n",
    "                                    legend=False,\n",
    "                                    feature=cft.NaturalEarthFeature('physical', 'land', '50m',\n",
    "                                                   edgecolor='black', facecolor='None', \n",
    "                                                   linewidth=0.5),\n",
    "                                    featureoverplot=True,\n",
    "                                    contourvars=[\n",
    "                                        (ice_data['1deg'][0]['tmask'], '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'k'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'], '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C0'}),\n",
    "                                        # (ice_data['025deg'][0]['tmask'], '0.25° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C1'}),\n",
    "                                        # (ice_data['01deg'][0]['tmask'], '0.1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(180, 360)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(0, 158)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(159, 360)), None, {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(yt_ocean=slice(-90, -50)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'})\n",
    "    #                                 (JRA55do_data['tas_mm'].sel(month=m), 'bla', {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "    #                                 (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    # # sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "    #                                 (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave',     {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    #                                 (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'white'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                            ],\n",
    "                                    **view).set_title(title);\n",
    "                savefigure(fname)\n",
    "                plt.close()\n",
    "            # break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "bias = [None]*12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# month 5 doesn't work, presumably due to bad chunking in /g/data/rt52/era5/single-levels/reanalysis/2t/2014/2t_era5_oper_sfc_20140501-20140531.nc\n",
    "for m in [5]: #[6, 8, 9, 10, 11, 12]: # [5, 6, 8, 9]: #range(1, 13):\n",
    "    if bias[m-1] is None:\n",
    "        print('doing month', str(m))\n",
    "        bias[m-1] = (JRA55do_to_ERA5(JRA55do_data['tas_mm'].sel(month=m))\\\n",
    "                     - ERA5_data['t2m_mm'].sel(month=m)).load()\n",
    "#         break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SATbiasplot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bias[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_data['tas_mm'].sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_to_ERA5(JRA55do_data['tas_mm'].sel(month=1)).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ERA5_data['t2m_mm'].sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vrange in [40, 10, 5, 3]:\n",
    "    plt.figure(figsize=(20, 20))\n",
    "    for m in range(1, 13):\n",
    "        plt.subplot(4,3,m)\n",
    "        ax = bias[m-1].plot(vmin=-abs(vrange), vmax=abs(vrange), cmap=plt.get_cmap('seismic'))\n",
    "        plt.title(' '.join(['JRA55-do T_10 - ERA55 T_2', yearrange, calendar.month_name[m], 'mean']))\n",
    "    savefigure(figname('_'.join(['JRA55-do', 'T_10', 'minus', 'ERA55', 'T_2', yearrange, 'monthly', 'mean', 'vrange', str(vrange)])))\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zonal wind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "bias = [None]*12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for m in range(1, 13):\n",
    "    if bias[m-1] is None:\n",
    "        print('doing month', str(m))\n",
    "        bias[m-1] = (JRA55do_to_ERA5(JRA55do_data['uas_mm'].sel(month=m))\\\n",
    "                     - ERA5_data['u10_mm'].sel(month=m)).load()\n",
    "#         break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_data['uas_mm'].sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_to_ERA5(JRA55do_data['uas_mm'].sel(month=1)).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ERA5_data['u10_mm'].sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vrange in [8, 2]:\n",
    "    plt.figure(figsize=(20, 20))\n",
    "    for m in range(1, 13):\n",
    "        plt.subplot(4,3,m)\n",
    "#         ax = bias[m-1].plot(cmap=plt.get_cmap('seismic'))\n",
    "        ax = bias[m-1].plot(vmin=-abs(vrange), vmax=abs(vrange), cmap=plt.get_cmap('seismic'))\n",
    "        plt.title(' '.join(['JRA55-do u_10 - ERA55 u_10', yearrange, calendar.month_name[m], 'mean']))\n",
    "#         break\n",
    "#     break\n",
    "    savefigure(figname('_'.join(['JRA55-do', 'u_10', 'minus', 'ERA55', 'u_10', yearrange, 'monthly', 'mean', 'vrange', str(vrange)])))\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Meridional wind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "bias = [None]*12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for m in range(1, 13):\n",
    "    if bias[m-1] is None:\n",
    "        print('doing month', str(m))\n",
    "        bias[m-1] = (JRA55do_to_ERA5(JRA55do_data['vas_mm'].sel(month=m))\\\n",
    "                     - ERA5_data['v10_mm'].sel(month=m)).load()\n",
    "#         break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_data['vas_mm'].sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_to_ERA5(JRA55do_data['vas_mm'].sel(month=1)).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ERA5_data['v10_mm'].sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vrange in [8, 2]:\n",
    "    plt.figure(figsize=(20, 20))\n",
    "    for m in range(1, 13):\n",
    "        plt.subplot(4,3,m)\n",
    "#         ax = bias[m-1].plot(cmap=plt.get_cmap('seismic'))\n",
    "        ax = bias[m-1].plot(vmin=-abs(vrange), vmax=abs(vrange), cmap=plt.get_cmap('seismic'))\n",
    "        plt.title(' '.join(['JRA55-do v_10 - ERA55 v_10', yearrange, calendar.month_name[m], 'mean']))\n",
    "#         break\n",
    "#     break\n",
    "    savefigure(figname('_'.join(['JRA55-do', 'v_10', 'minus', 'ERA55', 'v_10', yearrange, 'monthly', 'mean', 'vrange', str(vrange)])))\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## JRA55-do minus JRA55 biases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SAT_JRA55do_JRA55_bias_plot():\n",
    "    for viewname, view in views.items():\n",
    "        print(viewname)\n",
    "        if viewname in ['NH']:\n",
    "            hem = 'NH'\n",
    "        else:\n",
    "            hem = 'SH'\n",
    "        for m in range(1, 13):\n",
    "            title = ' '.join(['JRA55-do 10m SAT - JRA55 2m SAT', yearrange, calendar.month_name[m], 'mean'])\n",
    "            fname = figname('_'.join([viewname, 'JRA55-do_tas_mm-JRA55_tas_mm', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "            if os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "            else:\n",
    "                print('doing', fname)\n",
    "                plt.close()\n",
    "                cbar_ticklevels=np.arange(-5, 5.01, 1)\n",
    "                obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                plotSIC(JRA55do_JRA55_bias[m-1], cbar_label='Surface air temperature difference (°C)',\n",
    "                                    cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='both', cmp=plt.get_cmap('seismic'),\n",
    "                                    # contourvars=[], \n",
    "                                    legend=False,\n",
    "                                    feature=cft.NaturalEarthFeature('physical', 'land', '50m',\n",
    "                                                   edgecolor='black', facecolor='None', \n",
    "                                                   linewidth=0.5),\n",
    "                                    featureoverplot=True,\n",
    "                                    contourvars=[\n",
    "                                        # (ice_data['1deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '1° ACCESS-OM2 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C0'}),\n",
    "                                        # (ice_data['025deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '0.25° ACCESS-OM2-025 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C1'}),\n",
    "                                        # (ice_data['01deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '0.1° ACCESS-OM2-01 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C2'}),\n",
    "                                        (ice_data['1deg'][2]['aice_m_mm'].sel(month=m), '1° ACCESS-OM2 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C0'}),\n",
    "                                        (ice_data['025deg'][2]['aice_m_mm'].sel(month=m), '0.25° ACCESS-OM2-025 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C1'}),\n",
    "                                        (ice_data['01deg'][2]['aice_m_mm'].sel(month=m), '0.1° ACCESS-OM2-01 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'], '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C0'}),\n",
    "                                        # (ice_data['025deg'][0]['tmask'], '0.25° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C1'}),\n",
    "                                        # (ice_data['01deg'][0]['tmask'], '0.1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(180, 360)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(0, 158)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(159, 360)), None, {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(yt_ocean=slice(-90, -50)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'})\n",
    "    #                                 (JRA55do_data['tas_mm'].sel(month=m), 'bla', {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "    #                                 (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    # # sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                        (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave SIC',     {'levels': extlevel, 'colors': 'dimgray'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                        (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'dimgray'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                                        (ice_data['1deg'][0]['tmask'], None, {'levels': [0, 1e-15], 'colors': 'k'}),\n",
    "                            ],\n",
    "                                    **view).set_title(title);\n",
    "                savefigure(fname)\n",
    "                plt.close()\n",
    "            # break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_JRA55_bias = [None]*12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for m in range(1, 13):\n",
    "    if JRA55do_JRA55_bias[m-1] is None:\n",
    "        print('doing month', str(m))\n",
    "        JRA55do_JRA55_bias[m-1] = (JRA55do_data['tas_mm'] - JRA55_to_JRA55do(JRA55_data['tas_mm'])).sel(month=m).load()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SAT_JRA55do_JRA55_bias_plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JRA55 minus ERA5 biases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SAT_JRA55_ERA5_bias_plot():\n",
    "    for viewname, view in views.items():\n",
    "        print(viewname)\n",
    "        if viewname in ['NH']:\n",
    "            hem = 'NH'\n",
    "        else:\n",
    "            hem = 'SH'\n",
    "        for m in range(1, 13):\n",
    "            title = ' '.join(['JRA55 2m SAT - ERA5 2m SAT', yearrange, calendar.month_name[m], 'mean'])\n",
    "            fname = figname('_'.join([viewname, 'JRA55_tas_mm-ERA5_t2m_mm', yearrange, 'mean', 'month', str(m).zfill(2)]))\n",
    "            if os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "            else:\n",
    "                print('doing', fname)\n",
    "                plt.close()\n",
    "                cbar_ticklevels=np.arange(-5, 5.01, 1)\n",
    "                obsv = eval('_'.join(['obs', hem, 'mm'])).sel(month=m)\n",
    "                plotSIC(JRA55_ERA5_bias[m-1], cbar_label='Surface air temperature difference (°C)',\n",
    "                                    cmap_gamma=1., cbar_ticklevels=cbar_ticklevels, cbar_sigfigs=1, extend='both', cmp=plt.get_cmap('seismic'),\n",
    "                                    # contourvars=[], \n",
    "                                    legend=False,\n",
    "                                    feature=cft.NaturalEarthFeature('physical', 'land', '50m',\n",
    "                                                   edgecolor='black', facecolor='None', \n",
    "                                                   linewidth=0.5),\n",
    "                                    featureoverplot=True,\n",
    "                                    contourvars=[\n",
    "                                        # (ice_data['1deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '1° ACCESS-OM2 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C0'}),\n",
    "                                        # (ice_data['025deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '0.25° ACCESS-OM2-025 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C1'}),\n",
    "                                        # (ice_data['01deg'][2]['aice_m_mm'].sel(month=m), None, {'label': '0.1° ACCESS-OM2-01 SIC', 'levels': [0.15, 0.15+1e-9], 'colors': 'C2'}),\n",
    "                                        (ice_data['1deg'][2]['aice_m_mm'].sel(month=m), '1° ACCESS-OM2 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C0'}),\n",
    "                                        (ice_data['025deg'][2]['aice_m_mm'].sel(month=m), '0.25° ACCESS-OM2-025 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C1'}),\n",
    "                                        (ice_data['01deg'][2]['aice_m_mm'].sel(month=m), '0.1° ACCESS-OM2-01 SIC', {'levels': [0.15, 0.15+1e-9], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'], '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C0'}),\n",
    "                                        # (ice_data['025deg'][0]['tmask'], '0.25° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C1'}),\n",
    "                                        # (ice_data['01deg'][0]['tmask'], '0.1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'C2'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(180, 360)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(0, 158)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(xt_ocean=slice(159, 360)), None, {'levels': [0, 1e-15], 'colors': 'r'}),\n",
    "                                        # (ice_data['1deg'][0]['tmask'].sel(yt_ocean=slice(-90, -50)), '1° ACCESS-OM2', {'levels': [0, 1e-15], 'colors': 'r'})\n",
    "    #                                 (JRA55do_data['tas_mm'].sel(month=m), 'bla', {'levels': extlevel, 'colors': 'C'+str(enum+3)}), # 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}), # old v1 config\n",
    "    #                                 (v, ide['desc'], {'levels': extlevel, 'colors': 'C'+str(enum)}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "    # # sliced to work around a cartopy bug https://stackoverflow.com/questions/55062406/cartopy-fails-to-correctly-contour-data-on-rotated-grid\n",
    "                                        (obsv.isel(xt_ocean=slice(0, 158)), 'passive microwave SIC',     {'levels': extlevel, 'colors': 'dimgray'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()}),\n",
    "                                        (obsv.isel(xt_ocean=slice(158, 100000)), None, {'levels': extlevel, 'colors': 'dimgray'}), #, 'x': 'longitude', 'y': 'latitude', 'transform': ccrs.PlateCarree()})],\n",
    "                                        (ice_data['1deg'][0]['tmask'], None, {'levels': [0, 1e-15], 'colors': 'k'}),\n",
    "                            ],\n",
    "                                    **view).set_title(title);\n",
    "                savefigure(fname)\n",
    "                plt.close()\n",
    "            # break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55_ERA5_bias = [None]*12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for m in range(1, 13):\n",
    "    if JRA55_ERA5_bias[m-1] is None:\n",
    "        print('doing month', str(m))\n",
    "        JRA55_ERA5_bias[m-1] = (JRA55_to_ERA5(JRA55_data['tas_mm'].sel(month=m))\\\n",
    "                     - ERA5_data['t2m_mm'].sel(month=m)).load()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SAT_JRA55_ERA5_bias_plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Histograms vs parameters - TODO: FINISH\n",
    "\n",
    "TODO: weight by area\n",
    "\n",
    "TODO: plot groups by perturbation variable as in \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcerr(v, vref, method='MAD', mean=[]):\n",
    "    va, vrefa = xr.align(v, vref, join='override', exclude=['xt_ocean', 'yt_ocean'])\n",
    "    if method == 'MAD':\n",
    "        e = (np.abs(va - vrefa)).mean(mean)\n",
    "    elif method == 'RMSE': \n",
    "        e = np.sqrt(((va - vrefa)**2).mean(mean))\n",
    "    elif method == 'bias':\n",
    "        e = (va - vrefa).mean(mean)\n",
    "    else:\n",
    "        return None\n",
    "    return e.where(xr.ufuncs.logical_not(np.logical_and(va==0, vrefa==0)))  # set to nan if both zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vname = 'hi_m'\n",
    "method = 'bias'\n",
    "mean = []\n",
    "var = vname\n",
    "controlkey = controlkeys[0]  # KLUDGE! do this better\n",
    "# controlkey = '025deg'\n",
    "control = ice_data[controlkey][0]\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    for ekey in ensemble:\n",
    "        vrefs = GIOMASregridders[ice_data[ekey][0]['res']](GIOMAS[vname])\n",
    "        if hem == 'NH':\n",
    "            vrefs = vrefs.where(vrefs.yt_ocean>0)\n",
    "        else:\n",
    "            vrefs = vrefs.where(vrefs.yt_ocean<0)\n",
    "        for m in range(1,13):\n",
    "            vref = vrefs.groupby('time.month')[m]\n",
    "# BUG: try something different from broadcast_to \n",
    "            area = xr.DataArray(np.broadcast_to(ide['area_t'], vref.shape[0:1]+ide['area_t'].shape).ravel())\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], method])\n",
    "                fname = figname('_'.join([viewname, var, \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle)+'-GIOMAS', # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          yearrange, method, 'histogram', 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "                    print('doing', fname)\n",
    "                    v = ide[var].groupby('time.month')[m]\n",
    "                    if hem == 'NH':\n",
    "                        v = v.where(v.yt_ocean>0)\n",
    "                    else:\n",
    "                        v = v.where(v.yt_ocean<0)\n",
    "        #                     err = calcerr(v, vref, method=method, mean=[])\n",
    "                    err = xr.DataArray(calcerr(v, vref, method=method, mean=[]).data.ravel())\n",
    "#                     err = np.abs(v-vref)\n",
    "#                     err = v-vref\n",
    "#                     histdata = \n",
    "                    xr.plot.hist(err, weights=area, bins=500, log=True, density=True, histtype='step')\n",
    "#                     plt.hist(err, weights=area, bins=500, log=True, density=True, histtype='step')\n",
    "                    plt.title(title)\n",
    "                    plt.xlabel('')\n",
    "                break\n",
    "            break\n",
    "        break\n",
    "    break\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "area.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "err.shape == area.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xr.DataArray(err).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "area.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vref"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.broadcast_to(ide['area_t'], err.shape[0:1]+ide['area_t'].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.broadcast_to(ide['area_t'], err.shape[0:1]+ide['area_t'].shape).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ide['area_t'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "err.shape[0:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2D Histograms\n",
    "TODO: \n",
    "- weight count by area?\n",
    "- normalise by obs count?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SIC histogram model vs. obs\n",
    "TODO: \n",
    "- weight count by area?\n",
    "- normalise by obs count?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    for ekey in ensemble:\n",
    "        if viewname in ['NH']:\n",
    "            hem = 'NH'\n",
    "        else:\n",
    "            hem = 'SH'\n",
    "        obsv = eval('_'.join(['obs', hem]))\n",
    "        vref = obsregridders[hem][ice_data[ekey][0]['res']](obsv)\n",
    "        vref = vref.isel(time=slice(0, -1))            \n",
    "#         vref.time.data = ice_data[ekey][0]['aice_m'].time.data\n",
    "        # obs dates are first day of month but cice dates are last day of month\n",
    "        # so align vref to use same dates as cice\n",
    "#         vref, _ = xr.align(vref, ice_data[ekey][0]['aice_m'], join='right')\n",
    "#         vref_m = vref.groupby('time.month')\n",
    "    #     break\n",
    "        for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "            v = ide['aice_m']\n",
    "            if hem == 'NH':\n",
    "                v = v.where(v.yt_ocean>0)\n",
    "            else:\n",
    "                v = v.where(v.yt_ocean<0)\n",
    "#             bias = v - vref\n",
    "#             bias_m = bias.groupby('time.month')\n",
    "            for m in range(1, 13):\n",
    "    #             v = ide[var]\n",
    "    #             vref = vrefs.sel(month=m)\n",
    "                title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'bias'])\n",
    "                fname = figname('_'.join([viewname, 'aice_m', \n",
    "                                          ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                          'hist_vs_obs',\n",
    "                                          yearrange, 'month', str(m).zfill(2)]))\n",
    "                if os.path.exists(fname):\n",
    "                    print('   -- skipping', fname)\n",
    "                else:\n",
    "    #                     v = ide[var].sel(month=m)\n",
    "    #                     bias = v - vref\n",
    "                    print('doing', fname)\n",
    "#                     plt.scatter(vref_m.sel(month=m), bias_m.sel(month=m))\n",
    "                    vrefm = vref.sel(time=(vref['time.month']==m)).data.ravel()\n",
    "                    vm = v.sel(time=(v['time.month']==m)).data.ravel()\n",
    "                    fig, ax = plt.subplots(nrows=1, ncols=1)\n",
    "                    ax.set_facecolor('k')\n",
    "#                     fig = plt.figure() #(figsize=(7,7))\n",
    "#                     fig.patch.set_facecolor('black')\n",
    "\n",
    "#                     plt.scatter(vrefm, vm-vrefm, s=.1)\n",
    "#                     plt.hist2d(vref.isel(time=8).data.ravel(), \n",
    "#                       v.where(v.yt_ocean<0).isel(time=8).data.ravel(),\n",
    "#                       bins=100, range=[[0, 1], [0, 1]], norm=colors.LogNorm(),\n",
    "#                       cmap=plt.cm.get_cmap('nipy_spectral_r'));\n",
    "                    plt.hist2d(vrefm, vm,\n",
    "                      bins=100, range=[[0, 1], [0, 1]], \n",
    "                      norm=colors.LogNorm(), \n",
    "                    # TODO: pick cmax value automatically\n",
    "                      cmax=1e5,  # cmax=1e5 for 1deg, 1e6 for 0.25deg, \n",
    "#                       cmap=cm.cm.ice)\n",
    "                      cmap=plt.cm.get_cmap('hot'))\n",
    "#                       cmap=plt.cm.get_cmap('nipy_spectral'))\n",
    "                    plt.plot([0, 1],[0, 1], 'g', linewidth=2)\n",
    "                    plt.colorbar()\n",
    "                    plt.title(title)\n",
    "                    plt.xlabel('NSIDC passive microwave SIC')\n",
    "                    plt.ylabel('Model SIC')\n",
    "                    savefigure(fname)\n",
    "                    plt.close()\n",
    "#                     break\n",
    "#             break\n",
    "#         break\n",
    "\n",
    "\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SIC histogram GIOMAS vs. obs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# histograms for GIOMAS SIC\n",
    "GIOMAS_aice_m_regridded = regrid_giomas_to_025(GIOMAS['aice_m'])\n",
    "for viewname, view in views.items():\n",
    "    print(viewname)\n",
    "    if viewname in ['NH']:\n",
    "        hem = 'NH'\n",
    "    else:\n",
    "        hem = 'SH'\n",
    "    obsv = eval('_'.join(['obs', hem]))\n",
    "    vref = eval('regrid_'+hem+'obs_to_025(obsv)')\n",
    "    vref = vref.isel(time=slice(0, -1))            \n",
    "    v = GIOMAS_aice_m_regridded\n",
    "    if hem == 'NH':\n",
    "        v = v.where(v.yt_ocean>0)\n",
    "    else:\n",
    "        v = v.where(v.yt_ocean<0)\n",
    "    for m in range(1, 13):\n",
    "        title = ' '.join(['GIOMAS', yearrange, calendar.month_name[m], 'bias'])\n",
    "        fname = figname('_'.join([viewname, 'aice_m', \n",
    "                                  'GIOMAS',\n",
    "                                  'hist_vs_obs',\n",
    "                                  yearrange, 'month', str(m).zfill(2)]))\n",
    "        if os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            print('doing', fname)\n",
    "            vrefm = vref.sel(time=(vref['time.month']==m)).data.ravel()\n",
    "            vm = v.sel(time=(v['time.month']==m)).data.ravel()\n",
    "            fig, ax = plt.subplots(nrows=1, ncols=1)\n",
    "            ax.set_facecolor('k')\n",
    "            plt.hist2d(vrefm, vm,\n",
    "              bins=100, range=[[0, 1], [0, 1]], \n",
    "              norm=colors.LogNorm(), \n",
    "            # TODO: pick cmax value automatically\n",
    "              cmax=1e5,  # cmax=1e5 for 1deg, 1e6 for 0.25deg, \n",
    "              cmap=plt.cm.get_cmap('hot'))\n",
    "            plt.plot([0, 1],[0, 1], 'g', linewidth=2)\n",
    "            plt.colorbar()\n",
    "            plt.title(title)\n",
    "            plt.xlabel('NSIDC passive microwave SIC')\n",
    "            plt.ylabel('GIOMAS SIC')\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "#             break\n",
    "#         break\n",
    "#     break\n",
    "\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histograms model vs. GIOMAS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hist_model_vs_GIOMAS(varname='aice_m', varrange=[0, 1], desc='sea ice concentration'):\n",
    "    for viewname, view in views.items():\n",
    "        print(viewname)\n",
    "        for ekey in ensemble:\n",
    "            if viewname in ['NH']:\n",
    "                hem = 'NH'\n",
    "            else:\n",
    "                hem = 'SH'\n",
    "            obsv = GIOMAS[varname]\n",
    "            vref = GIOMASregridders[ice_data[ekey][0]['res']](obsv)\n",
    "            if hem == 'NH':\n",
    "                vref = vref.where(vref.yt_ocean>0)\n",
    "            else:\n",
    "                vref = vref.where(vref.yt_ocean<0)\n",
    "            for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "                v = ide[varname]\n",
    "                if hem == 'NH':\n",
    "                    v = v.where(v.yt_ocean>0)\n",
    "                else:\n",
    "                    v = v.where(v.yt_ocean<0)\n",
    "    #             bias = v - vref\n",
    "    #             bias_m = bias.groupby('time.month')\n",
    "                for m in range(1, 13):\n",
    "        #             v = ide[var]\n",
    "        #             vref = vrefs.sel(month=m)\n",
    "                    title = ' '.join([ide['desc'], 'cycle', str(cycle), yearrange, calendar.month_name[m], 'bias'])\n",
    "                    fname = figname('_'.join([viewname, varname, \n",
    "                                              ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycm2+1\n",
    "                                              'hist_vs_GIOMAS',\n",
    "                                              yearrange, 'month', str(m).zfill(2)]))\n",
    "                    if os.path.exists(fname):\n",
    "                        print('   -- skipping', fname)\n",
    "                    else:\n",
    "        #                     v = ide[var].sel(month=m)\n",
    "        #                     bias = v - vref\n",
    "                        print('doing', fname)\n",
    "    #                     plt.scatter(vref_m.sel(month=m), bias_m.sel(month=m))\n",
    "                        vrefm = vref.sel(time=(vref['time.month']==m)).data.ravel()\n",
    "                        vm = v.sel(time=(v['time.month']==m)).data.ravel()\n",
    "                        fig, ax = plt.subplots(nrows=1, ncols=1)\n",
    "                        ax.set_facecolor('k')\n",
    "                        plt.hist2d(vrefm, vm,\n",
    "                          bins=100, range=[varrange, varrange], \n",
    "                          norm=colors.LogNorm(), \n",
    "                        # TODO: pick cmax value automatically\n",
    "                          cmax=1e5,  # cmax=1e5 for 1deg, 1e6 for 0.25deg, \n",
    "    #                       cmap=cm.cm.ice)\n",
    "                          cmap=plt.cm.get_cmap('hot'))\n",
    "    #                       cmap=plt.cm.get_cmap('nipy_spectral'))\n",
    "                        plt.plot([0, 2.5],[0, 2.5], 'g', linewidth=2)\n",
    "                        plt.colorbar()\n",
    "                        plt.title(title)\n",
    "                        plt.xlabel(' '.join(['GIOMAS', desc]))\n",
    "                        plt.ylabel(' '.join([ide['desc'], desc]))\n",
    "                        savefigure(fname)\n",
    "                        plt.close()\n",
    "#                         break\n",
    "#                 break\n",
    "#             break\n",
    "    print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hist_model_vs_GIOMAS()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hist_model_vs_GIOMAS(varname='hi_m', varrange=[0, 2.5], desc='sea ice thickness (m)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hist_model_vs_GIOMAS(varname='hs_m', varrange=[0, 0.7], desc='snow thickness (m)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histograms JRA55-do vs. ERA5\n",
    "\n",
    "Plot ERA5 vs JRA55-do to check that we're using the right ERA5 forcing fields and also see how much they differ. \n",
    "\n",
    "See https://github.com/COSIMA/access-om2/issues/242#issuecomment-918795331\n",
    "\n",
    "#### TODO\n",
    "- regrid JRA55-do, JRA55, ERA5 onto 0.25deg model T grid (since ERA5 is 0.25deg and JRA55-do is 0.5625deg)\n",
    "    - ideally use the same regridding as the model\n",
    "    /g/data/ik11/inputs/access-om2/input_20201022/common_025deg_jra55/rmp_jra55_cice_patch.nc\n",
    "    and the regridders Nic has defined?\n",
    "- ignore land data (use model land mask)\n",
    "- weight by 0.25 model grid cell area \n",
    "- density"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loaddata(ice_data['025deg'][0], varnames=['tmask'], n=1)\n",
    "landmask = ice_data['025deg'][0]['tmask'].fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "landmask.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_tas_025 = JRA55do_to_025(method='patch')(JRA55do_data['tas'+'_mm']).where(landmask != 0)  # use 'patch' method to match access-om2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55_tas_025 = JRA55_to_025(method='patch')(JRA55_data['tas'+'_mm']).where(landmask != 0)  # use 'patch' method to match access-om2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vrange in [3]:\n",
    "    fname = figname('_'.join(['JRA55-do', 'T_10', 'minus', 'JRA55', 'T_2', yearrange, 'monthly', 'mean', 'vrange', str(vrange)]))\n",
    "    if os.path.exists(fname):\n",
    "        print('-- skipped', fname)\n",
    "    else:\n",
    "        print('doing', fname)\n",
    "        plt.figure(figsize=(20, 20))\n",
    "        for m in range(1, 13):\n",
    "            plt.subplot(4,3,m)\n",
    "            ax = (JRA55do_tas_025 - JRA55_tas_025).sel(month=m).plot(vmin=-abs(vrange), vmax=abs(vrange), cmap=plt.get_cmap('seismic'), extend='both')\n",
    "            plt.title(' '.join(['JRA55-do T_10 - JRA55 T_2', yearrange, calendar.month_name[m], 'mean']))\n",
    "        savefigure(fname)\n",
    "        plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# humidity - SEE IF I CAN GET JRA55 SURFACE HUMIDITY! IS IT THE BOTTOM PRESSURE LEVEL?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_huss_025 = JRA55do_to_025(method='patch')(JRA55do_data['huss'+'_mm']).where(landmask != 0)  # use 'patch' method to match access-om2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55_hus_025 = JRA55_to_025(method='patch')(JRA55_data['hus'+'_mm']).isel(plev=0).where(landmask != 0)  # use bottom pressure level; use 'patch' method to match access-om2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55do_huss_025.sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JRA55_hus_025.isel(plev=0).sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for vrange in [5]:\n",
    "    plt.figure(figsize=(20, 20))\n",
    "    for m in range(1, 13):\n",
    "        plt.subplot(4,3,m)\n",
    "        # ax = (JRA55do_huss_025 - JRA55_hus_025).sel(month=m).plot(vmin=-abs(vrange), vmax=abs(vrange), cmap=plt.get_cmap('seismic'), extend='both')\n",
    "        ax = (JRA55do_huss_025 - JRA55_hus_025).sel(month=m).plot(cmap=plt.get_cmap('seismic'), extend='both')\n",
    "        plt.title(' '.join(['JRA55-do q_10 - JRA55 q_2', yearrange, calendar.month_name[m], 'mean']))\n",
    "        break\n",
    "    # savefigure(figname('_'.join(['JRA55-do', 'huss_10', 'minus', 'JRA55', 'hus_2', yearrange, 'monthly', 'mean', 'vrange', str(vrange)])))\n",
    "    # plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ERA5_data['t2m']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ERA5_to_JRA55do(ERA5_data['t2m'+'_mm'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(ERA5_to_JRA55do(ERA5_data['t2m'+'_mm'].sel(month=1)), \n",
    "                          JRA55do_data['tas'+'_mm'].sel(month=1), s=1, alpha=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hist_JRA55do_vs_ERA5(JRA55dovar, ERA5var, varrange):\n",
    "    vs = JRA55do_data[JRA55dovar+'_mm'] #.isel(time=0)).groupby('time.month').mean('time', skipna=True)\n",
    "    vrefs = ERA5_to_JRA55do(ERA5_data[ERA5var+'_mm']) #.isel(time=0)).groupby('time.month').mean('time', skipna=True)\n",
    "    for m in range(1, 13):\n",
    "        title = ' '.join(['JRA55-do', JRA55dovar, 'vs', 'ERA5', ERA5var, yearrange, calendar.month_name[m]])\n",
    "        fname = figname('_'.join(['JRA55', JRA55dovar, \n",
    "                                  'vs', 'ERA5', ERA5var,\n",
    "                                  yearrange, 'month', str(m).zfill(2)]))\n",
    "        if False: #os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            v = vs.sel(month=m)\n",
    "            vref = vrefs.sel(month=m)\n",
    "            print('doing', fname)\n",
    "#             vrefm = vref.sel(time=(vref['time.month']==m)).data.ravel()\n",
    "#             vm = v.sel(time=(v['time.month']==m)).data.ravel()\n",
    "            fig, ax = plt.subplots(nrows=1, ncols=1)\n",
    "            ax.set_facecolor('k')\n",
    "            ax.set_aspect('equal')\n",
    "#             plt.hist2d(vrefm, JRA55do_to_ERA5(vm),\n",
    "            # xdata = vref.data.ravel()-273.15\n",
    "            # ydata = JRA55do_to_ERA5(v).data.ravel()-273.15\n",
    "            # xdata = ERA5_to_JRA55do(vref).data.ravel()-273.15\n",
    "            xdata = vref.data.ravel()-273.15\n",
    "            ydata = v.data.ravel()-273.15\n",
    "            # xdata = ERA5_to_JRA55do(vref)-273.15\n",
    "            # xdata = vref.data-273.15\n",
    "            # ydata = v.data-273.15\n",
    "            # plt.hist2d(\n",
    "            h, xedges, yedges = da.histogram2d(\n",
    "                       ydata, xdata, # this order is deliberate! \n",
    "                       # JRA55do_to_ERA5(v).data.ravel().numpy()-273.15,\n",
    "                       bins=100,\n",
    "                       # bins=10,\n",
    "                       range=[varrange, varrange], \n",
    "#                        norm=colors.LogNorm(), \n",
    "#             # TODO: pick cmax value automatically\n",
    "# #               cmax=1e5,  # cmax=1e5 for 1deg, 1e6 for 0.25deg, \n",
    "            )\n",
    "            plt.pcolormesh(xedges, yedges, h, norm=matplotlib.colors.LogNorm(), cmap=plt.cm.get_cmap('hot'))\n",
    "            plt.plot(varrange, varrange, 'g', linewidth=1)\n",
    "            plt.colorbar()\n",
    "            plt.title(title)\n",
    "            plt.xlabel(' '.join(['ERA5', ERA5_data[ERA5var].attrs['long_name']]))\n",
    "            plt.ylabel(' '.join(['JRA55-do', JRA55do_data[JRA55dovar].attrs['long_name']]))\n",
    "            savefigure(fname)\n",
    "            plt.close()\n",
    "    print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "get_ERA5('t2m').data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "get_ERA5('t2m').groupby('time.month').mean('time', skipna=True).sel(month=1).data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "get_ERA5('t2m').groupby('time.month').mean('time', skipna=True).sel(month=1).data.ravel()-273.15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "get_ERA5('t2m').groupby('time.month').mean('time', skipna=True).sel(month=1).compute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "get_ERA5('t2m').groupby('time.month').mean('time', skipna=True).sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadERA5(ERA5_data, varnames=['t2m'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ERA5_data['t2m'].attrs['long_name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ERA5_to_JRA55do(ERA5_data['t2m_mm'].sel(month=1)).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ERA5_data['t2m_mm'].sel(month=1).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_to_ERA5(JRA55do_data['tas_mm'].sel(month=1)).data.ravel()-273.15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_to_ERA5(JRA55do_data['tas_mm'].sel(month=1)).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plt.scatter(get_ERA5('t2m').groupby('time.month').mean('time', skipna=True).sel(month=1).data.ravel()[1:10], \n",
    "           JRA55do_to_ERA5(JRA55do_data['tas_mm'].sel(month=1)).data.ravel()[1:10],\n",
    "           s=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "JRA55do_data['tas_mm']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hist_JRA55do_vs_ERA5('tas', 't2m', [-70, 45])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Timeseries plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Time series of sea ice volume (by category), area, extent and snow volume\n",
    "\n",
    "`vicen_m(time, nc, nj, ni)`\n",
    "\t\thas units = \"m\",\n",
    "so need to multiply by `area_t` to get volume.\n",
    "`nc` is number of ice categories.\n",
    "\n",
    "We use kcatbound=0, so lower bound of ice categories is 0, 0.64, 1.39, 2.47, 4.57m (HunkeLipscombTurnerJefferyElliott2015a-CICE5p1, table 2).\n",
    "\n",
    "Much of the Arctic ice volume (not area) is >4.57m thick, including in the summer minimum.\n",
    "\n",
    "<font color=\"FF0000\"><B>FIXME:<B> land mask area differs between the three configurations and differs from obs, especially in the Canadian Archipelago and River Ob - how to remove this bias in the total extent, area and volume? Can we at least quantify the area differences poleward of (say) 65N/S?\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_transient = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcvol(ide, timerange=timerange):\n",
    "# WARNING - this can take several minutes\n",
    "    loaddata(ide, varnames=['hi_m', 'area_t'], timerange=timerange)\n",
    "    if 'NH_ice_volume' not in ide.keys():\n",
    "        volume = ide['hi_m']*ide['area_t'] # hi_m(time, nc, nj, ni) has units = \"m\", so need to multiply by `area_t` to get volume.\n",
    "        volume_zonalsum = volume.sum('xt_ocean').compute()  # do this once for both NH & SH\n",
    "        ide['NH_ice_volume'] = volume_zonalsum.sel(yt_ocean=slice(0, 90)).sum('yt_ocean')\n",
    "        ide['SH_ice_volume'] = volume_zonalsum.sel(yt_ocean=slice(-90,0)).sum('yt_ocean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcvolcat(ide, timerange=timerange):\n",
    "# WARNING - this can take several minutes\n",
    "    loaddata(ide, varnames=['vicen_m', 'area_t'], timerange=timerange)\n",
    "    if 'NH_ice_volume_cat' not in ide.keys():\n",
    "        volume = ide['vicen_m']*ide['area_t'] # vicen_m(time, nc, nj, ni) has units = \"m\", so need to multiply by `area_t` to get volume.\n",
    "        volume_zonalsum = volume.sum('xt_ocean').compute()  # do this once for both NH & SH\n",
    "        ide['NH_ice_volume_cat'] = volume_zonalsum.sel(yt_ocean=slice(0, 90)).sum('yt_ocean')\n",
    "        ide['SH_ice_volume_cat'] = volume_zonalsum.sel(yt_ocean=slice(-90,0)).sum('yt_ocean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotvol(v):\n",
    "    if not initial_transient:\n",
    "        v = v.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    plt.plot(v['time'],v.isel(nc=c)/1e12, color='C'+str(c), linewidth=1, label='Category '+str(c+1))\n",
    "#         if not initial_transient:\n",
    "    plt.plot(v['time'],\n",
    "             v.rolling(time=12, center=True).mean().isel(nc=c)/1e12, # 12-month rolling mean\n",
    "             color='C'+str(c), linewidth=2)\n",
    "#     total\n",
    "#     plt.plot(v['time'],v.sum(axis=-1)/1e12, color='k', linewidth=1, label='Total')\n",
    "#     plt.plot(v['time'][6:-5],\n",
    "#              v.rolling(time=12, center=True).mean().sum(axis=-1)[6:-5]/1e12,  # 12-month rolling mean\n",
    "#              color='k', linewidth=2)\n",
    "    plt.ylim(ymin=0)\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Ice volume (10$^{12}$ m$^3$)')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def plotvolcat(v):\n",
    "    if not initial_transient:\n",
    "        v = v.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    for c in range(len(v['nc'])):\n",
    "        plt.plot(v['time'],v.isel(nc=c)/1e12, color='C'+str(c), linewidth=1, label='Category '+str(c+1))\n",
    "#         if not initial_transient:\n",
    "        plt.plot(v['time'],\n",
    "                 v.rolling(time=12, center=True).mean().isel(nc=c)/1e12, # 12-month rolling mean\n",
    "                 color='C'+str(c), linewidth=2)\n",
    "#     total\n",
    "#     plt.plot(v['time'],v.sum(axis=-1)/1e12, color='k', linewidth=1, label='Total')\n",
    "#     plt.plot(v['time'][6:-5],\n",
    "#              v.rolling(time=12, center=True).mean().sum(axis=-1)[6:-5]/1e12,  # 12-month rolling mean\n",
    "#              color='k', linewidth=2)\n",
    "    plt.ylim(ymin=0)\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Ice volume (10$^{12}$ m$^3$)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotvolcumul(v):\n",
    "    if not initial_transient:\n",
    "        v = v.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    plt.plot(v['time'],v/1e12, linewidth=1)\n",
    "#         if not initial_transient:\n",
    "    plt.plot(v['time'],\n",
    "             v.rolling(time=12, center=True).mean()/1e12, # 12-month rolling mean\n",
    "             linewidth=2)\n",
    "    plt.ylim(ymin=0)\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Ice volume (10$^{12}$ m$^3$)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotvolcatcumul(v):\n",
    "    if not initial_transient:\n",
    "        v = v.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    v = v.cumsum(axis=-1)\n",
    "    cats = list(range(len(v['nc'])))\n",
    "    cats.reverse()  # so legend is in same order as plotted data\n",
    "    for c in cats:\n",
    "        plt.plot(v['time'],v.isel(nc=c)/1e12, color='C'+str(c), linewidth=1, label='Category '+'+'.join([str(f+1) for f in range(c+1)]))\n",
    "#         if not initial_transient:\n",
    "        plt.plot(v['time'],\n",
    "                 v.rolling(time=12, center=True).mean().isel(nc=c)/1e12, # 12-month rolling mean\n",
    "                 color='C'+str(c), linewidth=2)\n",
    "    plt.ylim(ymin=0)\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Ice volume (10$^{12}$ m$^3$)')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def plotvolcatNHSH():\n",
    "    plt.figure(1,(12,5))\n",
    "    plt.clf()\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    plotvolcat(ice_data[ekey]['NH_ice_volume_cat'])\n",
    "    plt.title('Arctic ice volume, '+ice_data[ekey]['desc'],font)\n",
    "\n",
    "    plt.subplot(2,1,2)\n",
    "    plotvolcat(ice_data[ekey]['SH_ice_volume_cat'])\n",
    "    plt.title('Antarctic ice volume, '+ice_data[ekey]['desc'],font)\n",
    "    plt.legend(prop=font,loc='upper left', bbox_to_anchor=(1, 1))\n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "    savefigure('ice_volume_categories_'+ekey)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def plotvolcumulNHSH():\n",
    "    plt.figure(1,(12,5))\n",
    "    plt.clf()\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    plotvolcumul(ice_data[ekey]['NH_ice_volume'])\n",
    "    plt.title('Arctic ice volume, '+ice_data[ekey]['desc'],font)\n",
    "\n",
    "    plt.subplot(2,1,2)\n",
    "    plotvolcumul(ice_data[ekey]['SH_ice_volume'])\n",
    "    plt.title('Antarctic ice volume, '+ice_data[ekey]['desc'],font)\n",
    "    plt.legend(prop=font,loc='upper left', bbox_to_anchor=(1, 1))\n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "    savefigure('ice_volume_categories_cumulative'+ekey)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "plotvolcatcumul(ice_data['1deg'][0]['SH_ice_volume_cat'])\n",
    "plt.legend(loc='upper left', bbox_to_anchor=(1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seasonal cycle of sea ice extent and area\n",
    "We adopt the usual definition of sea ice extent as the area in which sea ice concentration exceeds 15\\%.\n",
    "\n",
    "- obs in `/g/data3/hh5/tmp/cosima/observations/NOAA/G02135/north/monthly/data/*.csv` and  `/g/data3/hh5/tmp/cosima/observations/NOAA/G02135/south/monthly/data/*.csv`\n",
    "- file names `N_mm_extent_v3.0.csv`, `S_mm_extent_v3.0.csv` where `mm` is month number\n",
    "- first full year: 1979\n",
    "- last full year: 2017\n",
    "- missing extent data (-9999): Dec 1987, Jan 1988\n",
    "\n",
    "CSV format:\n",
    "```\n",
    "year, mo,    data-type, region, extent,   area\n",
    "1978, 12,      Goddard,      N,  13.67,  10.90\n",
    "...\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadObsExt(fnlist):\n",
    "    \"\"\"\n",
    "    Return xarray DataSet of sea ice extent and area from NOAA/G02135 csv file list\n",
    "    \"\"\"\n",
    "    df = pd.concat([pd.read_csv(f) for f in fnlist])  # read all csv files into a pandas DataFrame\n",
    "    df.columns = df.columns.str.strip()  # remove leading/trailing whitespace from headers\n",
    "#     df['time'] = df.apply(lambda r: datetime(r['year'], r['mo'], 1), axis=1)  # make a date column (set day=1 to match cice output)\n",
    "    df['time'] = df.apply(lambda r: cftime.DatetimeGregorian(r['year'], r['mo'], 1), axis=1)  # make a date column (set day=1 to match cice output)\n",
    "#     print(df)\n",
    "    df = df.drop(columns=['year', 'mo', 'data-type', 'region'])  # remove redundant columns\n",
    "    num = df._get_numeric_data()\n",
    "    num[num < 0] = np.nan  # replace bad data with NaN\n",
    "    df = df.sort_values('time')\n",
    "    ds = df.to_xarray()  # convert to xarray DataSet\n",
    "    ds = ds.assign_coords(index=ds['time']).drop('time')  # set index values to time and remove time\n",
    "    ds['extent'] = ds.extent.rename({'index': 'time'})  # rename extent coord to time\n",
    "    ds['area'] = ds.area.rename({'index': 'time'})  # rename area coord to time\n",
    "    ds = ds.drop('index')  # remove index\n",
    "    ds = ds*1e12  # convert from M km^2 to m^2\n",
    "    return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_ext_NH = loadObsExt(obsExtNHFileList)\n",
    "obs_ext_NH_mm = obs_ext_NH.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "obs_ext_SH = loadObsExt(obsExtSHFileList)\n",
    "obs_ext_SH_mm = obs_ext_SH.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcarea(ide, timerange=timerange):\n",
    "    loaddata(ide, varnames=['aice_m', 'area_t'], timerange=timerange)\n",
    "    if 'NH_area' not in ide.keys():\n",
    "        area = ide['aice_m']*ide['area_t']\n",
    "        area_zonalsum = area.sum('xt_ocean').compute()  # do this once for both NH & SH\n",
    "        ide['NH_area'] = area_zonalsum.sel(yt_ocean=slice(0, 90)).sum('yt_ocean')\n",
    "        ide['SH_area'] = area_zonalsum.sel(yt_ocean=slice(-90,0)).sum('yt_ocean')\n",
    "        ide['NH_area_clim'] = ide['NH_area'].sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "        ide['SH_area_clim'] = ide['SH_area'].sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcextent(ide, timerange=timerange):\n",
    "    loaddata(ide, varnames=['aice_m', 'area_t'], timerange=timerange)\n",
    "    if 'NH_extent' not in ide.keys():\n",
    "        extent = xr.where(ide['aice_m'] > 0.15, ide['area_t'], 0)\n",
    "        extent_zonalsum = extent.sum('xt_ocean').compute()  # do this once for both NH & SH\n",
    "        ide['NH_extent'] = extent_zonalsum.sel(yt_ocean=slice(0, 90)).sum('yt_ocean')\n",
    "        ide['SH_extent'] = extent_zonalsum.sel(yt_ocean=slice(-90,0)).sum('yt_ocean')\n",
    "        ide['NH_extent_clim'] = ide['NH_extent'].sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "        ide['SH_extent_clim'] = ide['SH_extent'].sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotarea(v, obs):\n",
    "    v = v.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    plt.plot(v['time'],v/1e12, color='r', linewidth=1, label='Model')\n",
    "    plt.plot(v['time'],\n",
    "             v.rolling(time=12, center=True).mean()/1e12, # 12-month rolling mean\n",
    "             color='r', linewidth=2)\n",
    "\n",
    "    obs = obs.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    plt.plot(obs['time'],obs/1e12, color='k', linewidth=1, label='Obs')\n",
    "    plt.plot(obs['time'],\n",
    "             obs.rolling(time=12, center=True).mean()/1e12, # 12-month rolling mean\n",
    "             color='k', linewidth=2)\n",
    "\n",
    "    plt.ylim(ymin=0)\n",
    "    plt.xlabel('Year',font)\n",
    "    plt.ylabel(r'Ice area (10$^{12}$ m$^2$)',font)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotareaNHSH():\n",
    "    plt.figure(1,(12,5))\n",
    "    plt.clf()\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    plotarea(NH_area, obs_ext_NH.area)\n",
    "    plt.title('Arctic ice area, '+exptdata.exptdict[ekey]['desc'],font)\n",
    "\n",
    "    plt.subplot(2,1,2)\n",
    "    plotarea(SH_area, obs_ext_SH.area)\n",
    "    plt.title('Antarctic ice area, '+exptdata.exptdict[ekey]['desc'],font)\n",
    "    plt.legend(prop=font,loc='upper left', bbox_to_anchor=(1, 1))\n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "    savefigure('ice_area_'+ekey)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotextent(v, obs):\n",
    "    v = v.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    plt.plot(v['time'],v/1e12, color='r', linewidth=1, label='Model')\n",
    "    plt.plot(v['time'],\n",
    "             v.rolling(time=12, center=True).mean()/1e12, # 12-month rolling mean\n",
    "             color='r', linewidth=2)\n",
    "\n",
    "    obs = obs.sel(time=slice(pd.to_datetime('1985', format='%Y'),tend))  # common time range for all plots\n",
    "    plt.plot(obs['time'],obs/1e12, color='k', linewidth=1, label='Obs')\n",
    "    plt.plot(obs['time'],\n",
    "             obs.rolling(time=12, center=True).mean()/1e12, # 12-month rolling mean\n",
    "             color='k', linewidth=2)\n",
    "\n",
    "    plt.ylim(ymin=0)\n",
    "    plt.xlabel('Year',font)\n",
    "    plt.ylabel(r'Ice extent (10$^{12}$ m$^2$)',font)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotextentNHSH():\n",
    "    plt.figure(1,(12,5))\n",
    "    plt.clf()\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    plotextent(NH_extent, obs_ext_NH.extent)\n",
    "    plt.title('Arctic ice extent, '+exptdata.exptdict[ekey]['desc'],font)\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    plotextent(SH_extent, obs_ext_SH.extent)\n",
    "    plt.title('Antarctic ice extent, '+exptdata.exptdict[ekey]['desc'],font)\n",
    "    plt.legend(prop=font,loc='upper left', bbox_to_anchor=(1, 1))\n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "    savefigure('ice_extent_'+ekey)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for ekey in ice_data.keys():\n",
    "for ekey in ensemble:\n",
    "    print(ekey)\n",
    "    for ide in ice_data[ekey]:\n",
    "#         calcvol(ide)\n",
    "        calcarea(ide)\n",
    "#         calcextent(ide)\n",
    "#         break  # only load cycle 1\n",
    "#     break"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "# 12-mo running mean minimum, mean and maximum of volume for all models\n",
    "for cycle in range(1, 2):\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, e in enumerate(ice_data.values()):\n",
    "        try:\n",
    "            ide = e[cycle-1]\n",
    "            plt.subplot(1,2,1)\n",
    "            v = ide['NH_ice_volume']/1e12\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='C'+str(c), linewidth=.1, label=ide['desc'])\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "\n",
    "            plt.subplot(1,2,2)\n",
    "            v = ide['SH_ice_volume']/1e12\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='C'+str(c), linewidth=.1, label=ide['desc'])\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.ylim(ymin=0,ymax=40)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice volume (10$^{12}$ m$^3$)')\n",
    "    plt.title('Arctic ice volume min, mean and max, cycle ' + str(cycle))\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice volume (10$^{12}$ m$^3$)')\n",
    "    plt.title('Antarctic ice volume min, mean and max, cycle ' + str(cycle))\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1), ncol=-(-len(ice_data.values())//25))\n",
    "\n",
    "    plt.tight_layout()\n",
    "    \n",
    "#     fname = os.path.join('figs', 'ice_volume_min_mean_max_all_cycle'+str(cycle)+'.pdf')\n",
    "    fname = 'ice_volume_min_mean_max_param.pdf'\n",
    "\n",
    "    plt.savefig(fname, bbox_inches='tight')\n",
    "#     plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12-mo running mean min, mean and max"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# 12-mo running mean minimum, mean and maximum of area for all models\n",
    "\n",
    "# TODO: different colour for each perturbation variable, then different line pattern for perturbation values\n",
    "\n",
    "cols = plt.get_cmap('nipy_spectral')\n",
    "cols = plt.get_cmap('hsv')\n",
    "\n",
    "cols = plt.get_cmap('plasma')\n",
    "\n",
    "# cols = cm.cm.thermal\n",
    "colsteps = min(20, len(ensemble))\n",
    "linestyles = ['-', '--', ':', '-.']\n",
    "lsstep = colsteps\n",
    "lwidth = 1\n",
    "for cycle in range(1, 2):\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, k in enumerate(ensemble):\n",
    "        ide = ice_data[k][cycle-1]\n",
    "        cval = ((c)/colsteps)%1\n",
    "        linestyle = linestyles[(c//lsstep) % len(linestyles)]\n",
    "        plt.subplot(1,2,1)\n",
    "        v = ide['NH_area']/1e12\n",
    "        plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color=cols(cval), linewidth=lwidth, linestyle=linestyle, label=ide['desc'])\n",
    "        plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "        plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "\n",
    "        plt.subplot(1,2,2)\n",
    "        v = ide['SH_area']/1e12\n",
    "        plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color=cols(cval), linewidth=lwidth, linestyle=linestyle, label=ide['desc'])\n",
    "        plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "        plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    v = obs_ext_NH.area/1e12\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='k', linewidth=2*lwidth, label='Observations')\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='k', linewidth=2*lwidth)\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='k', linewidth=2*lwidth)\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    v = obs_ext_SH.area/1e12\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='k', linewidth=2*lwidth, label='Observations')\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='k', linewidth=2*lwidth)\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='k', linewidth=2*lwidth)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "    plt.title('Arctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "    plt.title('Antarctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1), ncol=-(-len(ensemble)//25))\n",
    "\n",
    "    plt.tight_layout()\n",
    "    \n",
    "#     fname = os.path.join('figs', 'ice_area_min_mean_max_all_cycle'+str(cycle)+'.pdf')\n",
    "    fname = 'ice_area_min_mean_max_param.pdf'\n",
    "\n",
    "#     plt.savefig(fname, bbox_inches='tight')\n",
    "#     plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ice_data[controlkeys[0]][0]['params']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_keys = set().union(*(ice_data[k][0]['params'].keys() for k in controlkeys))\n",
    "all_keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://stackoverflow.com/questions/65806135/overflowerror-fig-savefig-triggered-by-dpi\n",
    "matplotlib.use('Agg')\n",
    "matplotlib.rcParams['agg.path.chunksize'] = 200\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matplotlib.style.use('fast')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "allparams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### separated by perturbation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 12-mo running mean minimum, mean and maximum of area -- separate plots for each perturbed parameter\n",
    "\n",
    "def running(op, v):\n",
    "    return eval(\"v['time'][6:-5],v.rolling(time=12, center=True).\"+op+\"()[6:-5]\")\n",
    "\n",
    "# cols = plt.get_cmap('nipy_spectral')\n",
    "# cols = plt.get_cmap('hsv')\n",
    "cols = plt.get_cmap('plasma')\n",
    "# cols = cm.cm.thermal\n",
    "linestyles = ['-', '--', ':', '-.']\n",
    "lwidth = 0.5\n",
    "\n",
    "allparams = set().union(*(ice_data[k][0]['params'].keys() for k in controlkeys))\n",
    "allparams = ['albicev']\n",
    "\n",
    "for cycle in range(1, 2):\n",
    "    for param in allparams:  # NB: assumes the same params at both resolutions!\n",
    "        subensemble = [ k for k in ensemble if ice_data[k][0]['perturbed']==param or (ice_data[k][0]['perturbed']==None and param in ice_data[k][0]['params']) ]\n",
    "        print(subensemble)\n",
    "        vals = [ ice_data[k][0]['params'][param] for k in subensemble ] #if param in ice_data[k][0]['params'] ]\n",
    "        # sort vals and subensemble by value\n",
    "        vs = sorted(zip(vals, subensemble))\n",
    "        vals = [ v for v, _ in vs ]\n",
    "        subensemble = [ s for _, s in vs ]\n",
    "        labels = [ param+'='+str(v) for v in vals ]\n",
    "        for controlkey in controlkeys:\n",
    "            try:                                                                ## KLUDGE! shouldn't need this\n",
    "                labels[subensemble.index(controlkey)] += ' (control)'\n",
    "            except:\n",
    "                pass\n",
    "        if len(subensemble) > 1:\n",
    "            colsteps = min(20, len(subensemble))\n",
    "            lsstep = colsteps\n",
    "            plt.figure(1,(12,5))                                                                                               \n",
    "            for c, k in enumerate(subensemble):               \n",
    "                ide = ice_data[k][cycle-1]\n",
    "                cval = ((c)/colsteps)%1\n",
    "                if k.split('_')[0] == '1deg':\n",
    "                    label = labels[c]+', 1°'\n",
    "                    linestyle = '-'\n",
    "                else:\n",
    "                    label = labels[c]+', 0.25°'\n",
    "                    linestyle = '--'\n",
    "#                 linestyle = linestyles[(c//lsstep) % len(linestyles)]\n",
    "                lw = lwidth\n",
    "                if k in controlkeys:\n",
    "                    lw *= 3\n",
    "                plt.subplot(1,2,1)\n",
    "                v = ide['NH_area']/1e12\n",
    "                plt.plot(*running('max', v), color=cols(cval), linewidth=lw, linestyle=linestyle, label=label)\n",
    "                plt.plot(*running('mean', v), color=cols(cval), linewidth=lw, linestyle=linestyle)\n",
    "                plt.plot(*running('min', v), color=cols(cval), linewidth=lw, linestyle=linestyle)\n",
    "\n",
    "                plt.subplot(1,2,2)\n",
    "                v = ide['SH_area']/1e12\n",
    "                plt.plot(*running('max', v), color=cols(cval), linewidth=lw, linestyle=linestyle, label=label)\n",
    "                plt.plot(*running('mean', v), color=cols(cval), linewidth=lw, linestyle=linestyle)\n",
    "                plt.plot(*running('min', v), color=cols(cval), linewidth=lw, linestyle=linestyle)\n",
    "\n",
    "            plt.subplot(1,2,1)\n",
    "            v = obs_ext_NH.area/1e12\n",
    "            plt.plot(*running('max', v), color='k', linewidth=2*lwidth, label='Observations')\n",
    "            plt.plot(*running('mean', v), color='k', linewidth=2*lwidth)\n",
    "            plt.plot(*running('min', v), color='k', linewidth=2*lwidth)\n",
    "\n",
    "            plt.subplot(1,2,2)\n",
    "            v = obs_ext_SH.area/1e12\n",
    "            plt.plot(*running('max', v), color='k', linewidth=2*lwidth, label='Observations')\n",
    "            plt.plot(*running('mean', v), color='k', linewidth=2*lwidth)\n",
    "            plt.plot(*running('min', v), color='k', linewidth=2*lwidth)\n",
    "\n",
    "            plt.subplot(1,2,1)\n",
    "            plt.ylim(ymin=0,ymax=22)\n",
    "            plt.grid(axis='y')\n",
    "            plt.xlabel('Year')\n",
    "            plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "        #     plt.title('Arctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "            plt.title('Arctic ice area min, mean and max')\n",
    "            plt.subplot(1,2,2)\n",
    "            plt.ylim(ymin=0,ymax=22)\n",
    "            plt.grid(axis='y')\n",
    "            plt.xlabel('Year')\n",
    "        #     plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "        #     plt.title('Antarctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "            plt.title('Antarctic ice area min, mean and max')\n",
    "            plt.legend(loc='upper left', bbox_to_anchor=(1, 1), ncol=-(-len(subensemble)//25))\n",
    "\n",
    "#             plt.tight_layout()\n",
    "\n",
    "        #     fname = os.path.join('figs', 'ice_area_min_mean_max_all_cycle'+str(cycle)+'.pdf')\n",
    "            fname = os.path.join('figs', 'ice_area_min_mean_max_'+param+'.pdf')\n",
    "            fname = os.path.join('figs', 'ice_area_min_mean_max_'+param+'_new.pdf')\n",
    "\n",
    "            fname = os.path.join('figs', 'ice_area_min_mean_max_'+param+'_new.png')\n",
    "\n",
    "            if os.path.exists(fname):\n",
    "                print('   -- skipping', fname)\n",
    "#                 break\n",
    "            else:\n",
    "#                     v = ide[var].sel(month=m)\n",
    "#                     bias = v - vref\n",
    "                print('saving', fname)\n",
    "#                 plt.savefig(fname, bbox_inches='tight')\n",
    "#                 plt.close()\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 12-mo running mean minimum, mean and maximum of area for all models\n",
    "\n",
    "# TODO: different colour for each perturbation variable, then different line pattern for perturbation values\n",
    "\n",
    "\n",
    "def running(op, v):\n",
    "    return eval(\"v['time'][6:-5],v.rolling(time=12, center=True).\"+op+\"()[6:-5]\")\n",
    "\n",
    "\n",
    "cols = plt.get_cmap('nipy_spectral')\n",
    "cols = plt.get_cmap('hsv')\n",
    "\n",
    "cols = plt.get_cmap('plasma')\n",
    "\n",
    "# cols = cm.cm.thermal\n",
    "colsteps = min(20, len(ensemble))\n",
    "linestyles = ['-', '--', ':', '-.']\n",
    "lsstep = colsteps\n",
    "lwidth = 1\n",
    "for cycle in range(1, 2):\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, k in enumerate(ensemble):\n",
    "        ide = ice_data[k][cycle-1]\n",
    "        cval = ((c)/colsteps)%1\n",
    "        linestyle = linestyles[(c//lsstep) % len(linestyles)]\n",
    "        plt.subplot(1,2,1)\n",
    "        v = ide['NH_area']/1e12\n",
    "        plt.plot(*running('max', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle, label=ide['desc'])\n",
    "        plt.plot(*running('mean', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "        plt.plot(*running('min', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "\n",
    "        plt.subplot(1,2,2)\n",
    "        v = ide['SH_area']/1e12\n",
    "        plt.plot(*running('max', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle, label=ide['desc'])\n",
    "        plt.plot(*running('mean', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "        plt.plot(*running('min', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    v = obs_ext_NH.area/1e12\n",
    "    plt.plot(*running('max', v), color='k', linewidth=2*lwidth, label='Observations')\n",
    "    plt.plot(*running('mean', v), color='k', linewidth=2*lwidth)\n",
    "    plt.plot(*running('min', v), color='k', linewidth=2*lwidth)\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    v = obs_ext_SH.area/1e12\n",
    "    plt.plot(*running('max', v), color='k', linewidth=2*lwidth, label='Observations')\n",
    "    plt.plot(*running('mean', v), color='k', linewidth=2*lwidth)\n",
    "    plt.plot(*running('min', v), color='k', linewidth=2*lwidth)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "#     plt.title('Arctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "    plt.title('Arctic ice area min, mean and max')\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "#     plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "#     plt.title('Antarctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "    plt.title('Antarctic ice area min, mean and max')\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1), ncol=-(-len(ensemble)//25))\n",
    "\n",
    "    plt.tight_layout()\n",
    "    \n",
    "#     fname = os.path.join('figs', 'ice_area_min_mean_max_all_cycle'+str(cycle)+'.pdf')\n",
    "    fname = 'ice_area_min_mean_max_param.pdf'\n",
    "\n",
    "#     plt.savefig(fname, bbox_inches='tight')\n",
    "#     plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ide['NH_area'] #- obs_ext_NH.area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_ext_NH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "        da = ide['NH_area'].copy(deep=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ide['NH_area']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da = ide['NH_area'].copy(deep=True)\n",
    "for i, d in enumerate(da['time'].data):\n",
    "    da['time'].data[i] = d.replace(day=1, hour=0, minute=0, second=0, microsecond=0)\n",
    "# da['time'].data = [d.replace(day=1, hour=0, minute=0, second=0, microsecond=0) for d in da['time'].data]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_ext_NH.area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da['time'].data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 12-mo running mean minimum, mean and maximum of total area bias for all models\n",
    "\n",
    "def running(op, v):\n",
    "    return eval(\"v['time'][6:-5], v.rolling(time=12, center=True).\"+op+\"()[6:-5]\")\n",
    "\n",
    "\n",
    "cols = plt.get_cmap('nipy_spectral')\n",
    "cols = plt.get_cmap('hsv')\n",
    "\n",
    "cols = plt.get_cmap('plasma')\n",
    "\n",
    "# cols = cm.cm.thermal\n",
    "colsteps = min(20, len(ensemble))\n",
    "linestyles = ['-', '--', ':', '-.']\n",
    "lsstep = colsteps\n",
    "lwidth = 1\n",
    "for cycle in range(1, 2):\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, k in enumerate(ensemble):\n",
    "        ide = ice_data[k][cycle-1]\n",
    "        cval = ((c)/colsteps)%1\n",
    "        linestyle = linestyles[(c//lsstep) % len(linestyles)]\n",
    "        plt.subplot(1,2,1)\n",
    "        da = ide['NH_area'].copy(deep=True)\n",
    "        for i, d in enumerate(da['time'].data):\n",
    "            da['time'].data[i] = d.replace(day=1, hour=0, minute=0, second=0, microsecond=0)\n",
    "        v = da/1e12 - obs_ext_NH.area/1e12\n",
    "        plt.plot(*running('max', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle, label=ide['desc'])\n",
    "        plt.plot(*running('mean', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "        plt.plot(*running('min', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "\n",
    "        plt.subplot(1,2,2)\n",
    "        v = ide['SH_area']/1e12 - obs_ext_SH.area/1e12\n",
    "        plt.plot(*running('max', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle, label=ide['desc'])\n",
    "        plt.plot(*running('mean', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "        plt.plot(*running('min', v), color=cols(cval), linewidth=lwidth, linestyle=linestyle)\n",
    "\n",
    "#     plt.subplot(1,2,1)\n",
    "#     v = obs_ext_NH.area/1e12\n",
    "#     plt.plot(*running('max', v), color='k', linewidth=2*lwidth, label='Observations')\n",
    "#     plt.plot(*running('mean', v), color='k', linewidth=2*lwidth)\n",
    "#     plt.plot(*running('min', v), color='k', linewidth=2*lwidth)\n",
    "\n",
    "#     plt.subplot(1,2,2)\n",
    "#     v = obs_ext_SH.area/1e12\n",
    "#     plt.plot(*running('max', v), color='k', linewidth=2*lwidth, label='Observations')\n",
    "#     plt.plot(*running('mean', v), color='k', linewidth=2*lwidth)\n",
    "#     plt.plot(*running('min', v), color='k', linewidth=2*lwidth)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "    plt.title('Arctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "    plt.title('Antarctic ice area min, mean and max, cycle ' + str(cycle))\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1), ncol=-(-len(ensemble)//25))\n",
    "\n",
    "    plt.tight_layout()\n",
    "    \n",
    "#     fname = os.path.join('figs', 'ice_area_min_mean_max_all_cycle'+str(cycle)+'.pdf')\n",
    "    fname = 'ice_area_min_mean_max_param.pdf'\n",
    "\n",
    "#     plt.savefig(fname, bbox_inches='tight')\n",
    "#     plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da['time']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 12-mo running mean minimum, mean and maximum of extent for all models\n",
    "for cycle in range(1, 2):\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, e in enumerate(ice_data.values()):\n",
    "        try:\n",
    "            ide = e[cycle-1]\n",
    "            plt.subplot(1,2,1)\n",
    "            v = ide['NH_extent']/1e12\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='C'+str(c), linewidth=.1, label=ide['desc'])\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "\n",
    "            plt.subplot(1,2,2)\n",
    "            v = ide['SH_extent']/1e12\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='C'+str(c), linewidth=.1, label=ide['desc'])\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "            plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='C'+str(c), linewidth=.1)\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    v = obs_ext_NH.extent/1e12\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='k', linewidth=.2, label='Observations')\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='k', linewidth=.2)\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='k', linewidth=.2)\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    v = obs_ext_SH.extent/1e12\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).max()[6:-5], color='k', linewidth=.2, label='Observations')\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).mean()[6:-5], color='k', linewidth=.2)\n",
    "    plt.plot(v['time'][6:-5],v.rolling(time=12, center=True).min()[6:-5], color='k', linewidth=.2)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice extent (10$^{12}$ m$^2$)')\n",
    "    plt.title('Arctic ice extent min, mean and max, cycle ' + str(cycle))\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.grid(axis='y')\n",
    "    plt.xlabel('Year')\n",
    "    plt.ylabel(r'Sea ice extent (10$^{12}$ m$^2$)')\n",
    "    plt.title('Antarctic ice extent min, mean and max, cycle ' + str(cycle))\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1), ncol=-(-len(ice_data.values())//25))\n",
    "\n",
    "    plt.tight_layout()\n",
    "    \n",
    "#     fname = os.path.join('figs', 'ice_extent_min_mean_max_all_cycle'+str(cycle)+'.pdf')\n",
    "\n",
    "    fname = 'ice_extent_min_mean_max_param.pdf'\n",
    "\n",
    "    plt.savefig(fname, bbox_inches='tight')\n",
    "#     plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timeseries of each month\n",
    "Formatted to match left two columns of [Tsujino et al., 2020](https://doi.org/10.5194/gmd-13-3643-2020) fig 22:\n",
    "\n",
    "![](https://gmd.copernicus.org/articles/13/3643/2020/gmd-13-3643-2020-f22.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# timeseries for each month for all models\n",
    "\n",
    "for var, obs in zip(['SH_extent', 'NH_extent'], [obs_ext_SH.extent, obs_ext_NH.extent]):\n",
    "    hem = var.split('_')[0]\n",
    "    for m in range(1,13):\n",
    "        fname = os.path.join('figs', '_'.join([var, yearrange, 'month', str(m).zfill(2)])+'.pdf')\n",
    "        if False: #os.path.exists(fname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            print('doing', fname)\n",
    "            plt.figure(1,(6,3))\n",
    "            for cycle in range(1, 7):\n",
    "                for c, e in enumerate(ice_data.values()):\n",
    "                    try:\n",
    "                        ide = e[cycle-1]\n",
    "                        v = ide[var]/1e12\n",
    "                        if cycle == 1:\n",
    "                            plt.plot(v['time'].sel(time=(v['time.month']==m)),\n",
    "                                     v.sel(time=(v['time.month']==m)),\n",
    "                                     color='C'+str(c), linewidth=1, label=ide['desc'])\n",
    "                        else:\n",
    "                            plt.plot(v['time'].sel(time=(v['time.month']==m)),\n",
    "                                     v.sel(time=(v['time.month']==m)),\n",
    "                                     color='C'+str(c), linewidth=1) #, label=ide['desc'])\n",
    "                    except:\n",
    "                        pass\n",
    "\n",
    "            v = obs/1e12\n",
    "            plt.plot(v['time'].sel(time=(v['time.month']==m)),\n",
    "                     v.sel(time=(v['time.month']==m)),\n",
    "                     color='k', linewidth=4, label='NSIDC_SII obs')\n",
    "            \n",
    "\n",
    "# set axis limits to match Tsujino et al (2020) fig 22\n",
    "            plt.xlim([cftime.DatetimeGregorian(1948, 1, 1), cftime.DatetimeGregorian(2019, 1, 1)])\n",
    "            if hem == 'NH':\n",
    "                if m == 3:\n",
    "                    plt.yticks(np.arange(10, 21, 2))\n",
    "                    plt.ylim(ymin=10, ymax=20)\n",
    "                elif m == 9:\n",
    "                    plt.yticks(np.arange(0, 11, 2))\n",
    "                    plt.ylim(ymin=0, ymax=10)\n",
    "            else:\n",
    "                if m == 3:\n",
    "                    plt.yticks(np.arange(0, 7, 2))\n",
    "                    plt.ylim(ymin=0, ymax=7)\n",
    "                elif m == 9:\n",
    "                    plt.yticks(np.arange(10, 26, 5))\n",
    "                    plt.ylim(ymin=12, ymax=27)\n",
    "            plt.grid(axis='x')\n",
    "            plt.grid(axis='y')\n",
    "            plt.xlabel('Year')\n",
    "            plt.ylabel(r'Sea ice extent (10$^{6}$ km$^2$)')\n",
    "            plt.title(' '.join([calendar.month_name[m], hem]))\n",
    "            plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
    "\n",
    "            plt.tight_layout()\n",
    "\n",
    "            plt.savefig(fname, bbox_inches='tight')\n",
    "            plt.close()\n",
    "#             break\n",
    "#     break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean seasonal cycle of area and extent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# seasonal cycle of area for all models\n",
    "for cycle in range(1, 7):\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, e in enumerate(ice_data.values()):\n",
    "        try:\n",
    "            ide = e[cycle-1]\n",
    "            plt.subplot(2,1,1)\n",
    "            v = ide['NH_area']/1e12\n",
    "            v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "            plt.plot(v['month'],v, color='C'+str(c), linewidth=1, label=ide['desc'])\n",
    "\n",
    "            plt.subplot(2,1,2)\n",
    "            v = ide['SH_area']/1e12\n",
    "            v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "            plt.plot(v['month'],v, color='C'+str(c), linewidth=1, label=ide['desc'])\n",
    "        except:\n",
    "            pass\n",
    "    plt.subplot(2,1,1)\n",
    "    v = obs_ext_NH.area/1e12\n",
    "    v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "    plt.plot(v['month'],v, color='k', linewidth=1, label='Observations')\n",
    "\n",
    "    plt.subplot(2,1,2)\n",
    "    v = obs_ext_SH.area/1e12\n",
    "    v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "    plt.plot(v['month'],v, color='k', linewidth=1, label='Observations')\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.xlabel('Month')\n",
    "    plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "    plt.title('Arctic sea ice area '+yearrange+' mean annual cycle, for JRA55-do cycle ' + str(cycle))\n",
    "    plt.subplot(2,1,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.xlabel('Month')\n",
    "    plt.ylabel(r'Sea ice area (10$^{12}$ m$^2$)')\n",
    "    plt.title('Antarctic sea ice area '+yearrange+' mean annual cycle, for JRA55-do cycle ' + str(cycle))\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
    "    plt.tight_layout()\n",
    "\n",
    "    fname = os.path.join('figs', 'ice_area_seasonal_clim_cycle'+str(cycle)+'.pdf')\n",
    "    plt.savefig(fname, bbox_inches='tight')\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# seasonal cycle of extent for all models\n",
    "for cycle in range(1, 7):\n",
    "\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, e in enumerate(list(ice_data.values())[0:3]):\n",
    "        try:\n",
    "            ide = e[cycle-1]\n",
    "            plt.subplot(2,1,1)\n",
    "            v = ide['NH_extent']/1e12\n",
    "            v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "            plt.plot(v['month'],v, color='C'+str(c), linewidth=1, label=ide['desc'])\n",
    "\n",
    "            plt.subplot(2,1,2)\n",
    "            v = ide['SH_extent']/1e12\n",
    "            v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "            plt.plot(v['month'],v, color='C'+str(c), linewidth=1, label=ide['desc'])\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    v = obs_ext_NH.extent/1e12\n",
    "    v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "    plt.plot(v['month'],v, color='k', linewidth=2, label='Observations')\n",
    "\n",
    "    plt.subplot(2,1,2)\n",
    "    v = obs_ext_SH.extent/1e12\n",
    "    v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "    plt.plot(v['month'],v, color='k', linewidth=2, label='Observations')\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.xlabel('Month')\n",
    "    plt.ylabel(r'Sea ice extent (10$^{12}$ m$^2$)')\n",
    "    plt.title('Arctic sea ice extent '+yearrange+' mean annual cycle, for JRA55-do cycle ' + str(cycle))\n",
    "    plt.subplot(2,1,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.xlabel('Month')\n",
    "    plt.ylabel(r'Sea ice extent (10$^{12}$ m$^23$)')\n",
    "    plt.title('Antarctic sea ice extent '+yearrange+' mean annual cycle, for JRA55-do cycle ' + str(cycle))\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
    "    plt.tight_layout()\n",
    "\n",
    "    fname = os.path.join('figs', 'ice_extent_seasonal_clim_cycle'+str(cycle)+'.pdf')\n",
    "    plt.savefig(fname, bbox_inches='tight')\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# seasonal cycle of extent for all models\n",
    "for cycle in range(1, 7):\n",
    "\n",
    "    plt.figure(1,(12,5))\n",
    "    for c, e in enumerate(list(ice_data.values())[0:3]):\n",
    "        try:\n",
    "            ide = e[cycle-1]\n",
    "            plt.subplot(2,1,1)\n",
    "            v = ide['NH_extent']/1e12\n",
    "            v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "            plt.plot(v['month'],v, color='C'+str(c), linewidth=1, label=ide['desc'])\n",
    "\n",
    "            plt.subplot(2,1,2)\n",
    "            v = ide['SH_extent']/1e12\n",
    "            v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "            plt.plot(v['month'],v, color='C'+str(c), linewidth=1, label=ide['desc'])\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    v = obs_ext_NH.extent/1e12\n",
    "    v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "    plt.plot(v['month'],v, color='k', linewidth=2, label='Observations')\n",
    "\n",
    "    plt.subplot(2,1,2)\n",
    "    v = obs_ext_SH.extent/1e12\n",
    "    v = v.sel(time=slice(tstart,tend)).groupby('time.month').mean('time', skipna=True)\n",
    "    plt.plot(v['month'],v, color='k', linewidth=2, label='Observations')\n",
    "\n",
    "    plt.subplot(2,1,1)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.xlabel('Month')\n",
    "    plt.ylabel(r'Sea ice extent (10$^{12}$ m$^2$)')\n",
    "    plt.title('Arctic sea ice extent '+yearrange+' mean annual cycle, for JRA55-do cycle ' + str(cycle))\n",
    "    plt.subplot(2,1,2)\n",
    "    plt.ylim(ymin=0,ymax=22)\n",
    "    plt.xlabel('Month')\n",
    "    plt.ylabel(r'Sea ice extent (10$^{12}$ m$^23$)')\n",
    "    plt.title('Antarctic sea ice extent '+yearrange+' mean annual cycle, for JRA55-do cycle ' + str(cycle))\n",
    "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
    "    plt.tight_layout()\n",
    "\n",
    "    fname = os.path.join('figs', 'ice_extent_seasonal_clim_cycle'+str(cycle)+'.pdf')\n",
    "    plt.savefig(fname, bbox_inches='tight')\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean seasonal cycle of volume terms\n",
    "units: cm/day for all of\n",
    "- dvidtd_m\n",
    "- dvidtt_m\n",
    "- congel_m\n",
    "- frazil_m\n",
    "- meltt_m\n",
    "- meltb_m\n",
    "- meltl_m\n",
    "- snoice_m\n",
    "- evap_ai_m           ** NB: ai - so this is a grid-cell mean, like all the others **\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# volume tendency terms due to thermo (and dynamics)\n",
    "terms = ['congel_m', 'frazil_m', 'meltt_m', 'meltb_m', 'meltl_m', 'snoice_m', 'evap_ai_m', 'dvidtt_m'] #, 'dvidtd_m']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthdays = [ calendar.monthrange(2001, m)[1] for m in range(1, 13) ] # not a leap year\n",
    "rhoi = 917.0 # CICE ice density (kg/m^3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcterms(ide, varnames=terms, timerange=timerange):\n",
    "    loaddata(ide, varnames=varnames, timerange=timerange)\n",
    "    for var in varnames:\n",
    "        print(var)\n",
    "        if 'NH_'+var not in ide.keys():\n",
    "            vol = ide[var]*ide['area_t']\n",
    "            vol_zonalsum = vol.sum('xt_ocean').compute()  # do this once for both NH & SH\n",
    "            vol_zonalsum = vol_zonalsum/100*rhoi  # convert to kg/day\n",
    "            if var in ['meltt_m', 'meltb_m', 'meltl_m']:\n",
    "                vol_zonalsum = -vol_zonalsum\n",
    "            ide['NH_'+var] = vol_zonalsum.sel(yt_ocean=slice(0, 90)).sum('yt_ocean')\n",
    "            ide['SH_'+var] = vol_zonalsum.sel(yt_ocean=slice(-90,0)).sum('yt_ocean')\n",
    "            # monthly climatologies are in kg/month\n",
    "            ide['NH_'+var+'_clim'] = ide['NH_'+var].sel(time=timerange).groupby('time.month').mean('time', skipna=True)*monthdays\n",
    "            ide['SH_'+var+'_clim'] = ide['SH_'+var].sel(time=timerange).groupby('time.month').mean('time', skipna=True)*monthdays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ekey in ensemble:\n",
    "    for ide in ice_data[ekey]:\n",
    "        calcterms(ide)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "control = controlkeys[0]  # KLUDGE! do this better!\n",
    "for ekey in ensemble:\n",
    "    for cycle, ide in enumerate(ice_data[ekey], start=1):\n",
    "        idecontrol = ice_data[control][cycle-1]\n",
    "        title = 'Antarctic sea ice mass balance '+yearrange+' mean annual cycle for '+ide['desc']\n",
    "        fname = '_'.join(['SH', ide['expt'].split('_cycle')[0], 'cycle'+str(cycle), # FRAGLE! assumes filename cycle number = cycle\n",
    "                                          yearrange, 'mass_terms_seasonal_clim'])\n",
    "        pngfname = os.path.join(figdir, fname+'_'+str(dpi)+'dpi.png')\n",
    "        pdffname = os.path.join(figdir, fname+'.pdf')\n",
    "        if os.path.exists(pngfname):\n",
    "            print('   -- skipping', fname)\n",
    "        else:\n",
    "            print('doing '+fname)\n",
    "            plt.figure(figsize=(10, 8))\n",
    "            if not ekey == control:\n",
    "                for n, var in enumerate(terms):\n",
    "                    v = idecontrol['SH_'+var+'_clim']/1e15\n",
    "                    plt.plot(v['month'], v, '--', color='C'+str(n), linewidth=1)\n",
    "            for n, var in enumerate(terms):\n",
    "                if var == 'dvidtt_m':\n",
    "                    label = 'net thermo tendency'\n",
    "                else:\n",
    "                    label = ide[var].long_name\n",
    "                v = ide['SH_'+var+'_clim']/1e15\n",
    "                plt.plot(v['month'], v, color='C'+str(n), linewidth=2, label=label)\n",
    "            plt.plot([1,12], [0, 0], '-k', linewidth=0.5)  # zero line\n",
    "            plt.xlabel('Month')\n",
    "            plt.ylabel(r'Sea ice mass tendency (10$^{15}$ kg/month)')\n",
    "            plt.xlim(xmin=1, xmax=12)\n",
    "            plt.ylim(ymin=-6, ymax=3)\n",
    "            plt.legend(loc='lower center')\n",
    "            plt.title(title)\n",
    "            plt.savefig(pngfname, dpi=dpi, bbox_inches='tight')\n",
    "            plt.savefig(pdffname, dpi=dpi, bbox_inches='tight')\n",
    "            plt.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO: Mean seasonal cycle of area terms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:analysis3-22.07]",
   "language": "python",
   "name": "conda-env-analysis3-22.07-py"
  },
  "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.9.15"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}