{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Figure 11.\n",
    "\n",
    "Histograms of instantaneous TOA OLR values in (a, b) the full *HighRes* domain, sampled over 100 days, and (c, d) in the central part of the *HighRes* domain (shown by the blue box in Figs. 9 and 10), sampled over 10 days for (a) Trappist-1e and (b) Proxima b. Light blue bars show the global model values, while dark blue bars show *HighRes* model values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Skip code and jump to the figure](#Show-the-figure)\n",
    "\n",
    "----------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the necessary libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Progress bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastprogress import progress_bar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scientific stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import iris\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from aeolus.coord_utils import UM_LATLON\n",
    "from aeolus.core import Run\n",
    "from aeolus.region import Region\n",
    "from aeolus.subset import _dim_constr\n",
    "from aeolus.util import fmt_lonlat, subplot_label_generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Local modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from commons import (\n",
    "    DT_FMT,\n",
    "    FCST_DIM_CNSTR,\n",
    "    FCST_PRD_CNSTR,\n",
    "    GLM_RUNID,\n",
    "    NS_COLORS,\n",
    "    NS_MODEL_TYPES,\n",
    "    NS_OUTPUT_NAME_PREFIX,\n",
    "    NS_RUN_ALIASES,\n",
    "    NS_RUNID,\n",
    "    PLANET_ALIASES,\n",
    "    SS_REGION,\n",
    ")\n",
    "import mypaths\n",
    "from plot_func import use_style\n",
    "from proc_um_output import process_cubes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Global stylesheet for figures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "use_style()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define two sampling methods: a large domain and the duration of 100 days, and a smaller domain with only the last 10 days."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulation time (the UM simulation length is defined using real Earth dates,\n",
    "# whose exact values obviously do not matter for exoplanets)\n",
    "\n",
    "SAMPLE_METHODS = {\n",
    "    \"100day_full_domain\": {\n",
    "        \"start\": datetime(2009, 4, 28, 9, 0),\n",
    "        \"ndays\": 100,\n",
    "        \"region\": Region(-22, 42, -30, 30, \"highres_domain\"),\n",
    "        \"title\": \"Full HighRes domain,\\nlast 100 days\",\n",
    "    },\n",
    "    \"10day_ss_region\": {\n",
    "        \"start\": datetime(2009, 7, 27, 9, 0),\n",
    "        \"ndays\": 10,\n",
    "        \"region\": SS_REGION,\n",
    "        \"title\": \"Subset of HighRes domain,\\nlast 10 days\",\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Change file mask to load only the files with TOA radiation data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "NS_MODEL_TYPES[\"global\"][\"path\"] = (\n",
    "    NS_MODEL_TYPES[\"global\"][\"path\"].parent / f\"{GLM_RUNID}_pd*\"\n",
    ")\n",
    "NS_MODEL_TYPES[\"lam\"][\"path\"] = NS_MODEL_TYPES[\"lam\"][\"path\"].parent / f\"{NS_RUNID}_pa*\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a dictionary of `Run` objects with UM data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 01:01<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='1' class='' max='1', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [1/1 00:31<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 00:31<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 00:20<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 00:10<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='1' class='' max='1', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [1/1 00:30<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 00:30<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 00:19<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 00:11<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "runs = {}\n",
    "for planet in progress_bar(PLANET_ALIASES.keys()):\n",
    "    for run_key in progress_bar(NS_RUN_ALIASES.keys()):\n",
    "        for model_type, model_specs in progress_bar(NS_MODEL_TYPES.items()):\n",
    "            subdir = f\"{planet}_{run_key}\"\n",
    "            for sm_key, sample_method in progress_bar(SAMPLE_METHODS.items()):\n",
    "                label = f\"{planet}_{run_key}_{model_type}_{sm_key}\"\n",
    "                flist = []\n",
    "                for i in range(sample_method[\"ndays\"]):\n",
    "                    _cycle = (sample_method[\"start\"] + timedelta(days=i)).strftime(\n",
    "                        DT_FMT\n",
    "                    )\n",
    "                    flist.append(mypaths.nsdir / subdir / _cycle / model_specs[\"path\"])\n",
    "                # Load data\n",
    "                run = Run(\n",
    "                    files=flist,\n",
    "                    name=label,\n",
    "                    planet=planet,\n",
    "                    model_type=model_type,\n",
    "                    timestep=model_specs[\"timestep\"],\n",
    "                )\n",
    "                # Regrid & interpolate data\n",
    "                run.proc_data(\n",
    "                    process_cubes,\n",
    "                    timestep=run.timestep,\n",
    "                    extract_mean=False,\n",
    "                    regrid_multi_lev=False,\n",
    "                )\n",
    "                # Select domain\n",
    "                run.proc = run.proc.extract(sample_method[\"region\"].constraint)\n",
    "                # Save to dict\n",
    "                runs[label] = run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate the distribution of TOA OLR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "varname = \"toa_outgoing_longwave_flux\"\n",
    "short_name = \"TOA OLR\"\n",
    "tex_units = \"$W$ $m^{-2}$\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define histogram bins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin_step = 5\n",
    "bins = np.arange(50, 301, bin_step)\n",
    "bin_mid = (bins[:-1] + bins[1:]) * 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate a histogram for each of the simulations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_dict = {}\n",
    "for planet in PLANET_ALIASES.keys():\n",
    "    hist_dict[planet] = {}\n",
    "    for run_key in NS_RUN_ALIASES.keys():\n",
    "        hist_dict[planet][run_key] = {}\n",
    "        for model_type in NS_MODEL_TYPES.keys():\n",
    "            hist_dict[planet][run_key][model_type] = {}\n",
    "            for sm_key, sample_method in SAMPLE_METHODS.items():\n",
    "                label = f\"{planet}_{run_key}_{model_type}_{sm_key}\"\n",
    "                cube = (\n",
    "                    runs[label].proc.extract(FCST_PRD_CNSTR).extract_strict(varname)\n",
    "                )\n",
    "                ntimes = cube.coord(\"time\").shape[-1]\n",
    "                arr = cube.data\n",
    "                tot_pnts = arr.size\n",
    "                hist, _ = np.histogram(arr.ravel(), bins=bins)\n",
    "                hist_dict[planet][run_key][model_type][sm_key] = hist / tot_pnts * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ncol = len(PLANET_ALIASES)\n",
    "nrow = len(SAMPLE_METHODS)\n",
    "\n",
    "fig, axs = plt.subplots(nrows=nrow, ncols=ncol, figsize=(8 * ncol, 4 * nrow))\n",
    "\n",
    "iletters = subplot_label_generator()\n",
    "for (sm_key, sample_method), axrow in zip(SAMPLE_METHODS.items(), axs):\n",
    "    for i, (planet, ax) in enumerate(zip(PLANET_ALIASES, axrow)):\n",
    "        ax.set_title(f\"({next(iletters)})\", fontsize=\"small\", pad=5, loc=\"left\")\n",
    "        ax.set_title(sample_method[\"title\"], fontsize=\"small\", pad=5, loc=\"right\")\n",
    "        if ax.is_first_row():\n",
    "            ax.set_title(PLANET_ALIASES[planet], fontsize=\"large\", pad=5, loc=\"center\")\n",
    "        if ax.is_first_col():\n",
    "            ax.set_ylabel(\"[% of grid points]\")\n",
    "        if ax.is_last_row():\n",
    "            ax.set_xlabel(f\"{short_name} within the substellar region [{tex_units}]\")\n",
    "\n",
    "        for run_key in NS_RUN_ALIASES.keys():\n",
    "            for model_type in NS_MODEL_TYPES.keys():\n",
    "\n",
    "                ax.bar(\n",
    "                    bin_mid,\n",
    "                    hist_dict[planet][run_key][model_type][sm_key],\n",
    "                    width=bin_step,\n",
    "                    alpha=0.5,\n",
    "                    color=NS_COLORS[run_key][model_type],\n",
    "                    label=NS_MODEL_TYPES[model_type][\"title\"],\n",
    "                )\n",
    "\n",
    "        ax.set_xlim(bins[0], bins[-1])\n",
    "        ax.set_xticks(bins[::5])\n",
    "\n",
    "ax = axs.flatten()[-1]\n",
    "leg = ax.legend(loc=\"upper right\")\n",
    "\n",
    "plt.subplots_adjust(wspace=0.1, hspace=0.25)\n",
    "plt.close()  # Show the figure in a separate cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show the figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 4 Axes>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And save it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "imgname = mypaths.plotdir / f\"{NS_OUTPUT_NAME_PREFIX}__toa_olr_hist\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved to ../plots/trap1e_proxb__grcs__toa_olr_hist\n"
     ]
    }
   ],
   "source": [
    "fig.savefig(imgname, dpi=200)\n",
    "print(f\"Saved to ../{imgname.relative_to(mypaths.topdir)}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:exo]",
   "language": "python",
   "name": "conda-env-exo-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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}