From 423cf3acb6e82a4b0d2a422a70ae0f7a6e67050b Mon Sep 17 00:00:00 2001 From: Jonah Shaw Date: Thu, 26 Feb 2026 17:17:55 -0700 Subject: [PATCH 1/9] added example of plot 1 --- J01-OLR_ASR_plotexample.py | 91 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 J01-OLR_ASR_plotexample.py diff --git a/J01-OLR_ASR_plotexample.py b/J01-OLR_ASR_plotexample.py new file mode 100644 index 0000000..2f355e8 --- /dev/null +++ b/J01-OLR_ASR_plotexample.py @@ -0,0 +1,91 @@ +# %% +import xarray as xr +import numpy as np +import matplotlib.pyplot as plt +import matplotlib as mpl +import seaborn as sns + +# %% +def plot_radiative_imbalance( + olr_ds, + asr_ds, + ax=None, + plot_kwargs=None, + fontsize=14, + cmap=sns.color_palette("viridis", as_cmap=True), +): + if ax is None: + fig, ax = plt.subplots(figsize=(10, 5)) + + if plot_kwargs is None: + plot_kwargs = {} + + # Plot OLR vs ASR with color gradient for time dimension + ax.plot( + olr_ds, + asr_ds, + color="black", + alpha=0.5, + zorder=5, + linewidth=0.5, + ) + scatter = ax.scatter( + olr_ds, + asr_ds, + c=np.arange(len(olr_ds)), + cmap=cmap, + zorder=10, + **plot_kwargs, + ) + + # Add a colorbar with discrete intervals and extend='both' keyword + bounds = np.arange(olr_ds["time"].min().item(), olr_ds["time"].max().item() + 1, max(1, len(olr_ds)//10)) + norm = mpl.colors.BoundaryNorm(bounds, cmap.N, extend='both') + + plt.colorbar( + mpl.cm.ScalarMappable(norm=norm, cmap=cmap), + ax=ax, orientation='vertical', + label="Time", + ) + + # Plot the 1:1 line + min_val = min(olr_ds.min().item(), asr_ds.min().item()) + max_val = max(olr_ds.max().item(), asr_ds.max().item()) + ax.plot( + [min_val, max_val], + [min_val, max_val], + color="grey", + linestyle="--", + zorder=0, + ) + ax.set_aspect("equal", adjustable="box") + ax.set_xlabel("OLR (Wm$^{-2}$)", fontsize=fontsize) + ax.set_ylabel("ASR (Wm$^{-2}$)", fontsize=fontsize) + + if fig is None: + return ax + else: + return fig, ax + +# %% + +olr = np.arange(0, 10, 0.5) # Example ASR values +asr = 0.5 * (olr**2) + +fig, ax = plot_radiative_imbalance( + olr_ds=xr.DataArray(olr, dims=["time"], coords={"time": np.arange(len(olr))}), + asr_ds=xr.DataArray(asr, dims=["time"], coords={"time": np.arange(len(asr))}), + plot_kwargs={"marker": "o", "linestyle": "solid"}, +) + +# Get rid of the plot edges and add gridlines through the origin +ax.spines["top"].set_visible(False) +ax.spines["bottom"].set_visible(False) +ax.spines["right"].set_visible(False) +ax.spines["left"].set_visible(False) +ax.axhline(0, color="grey", linestyle="solid", linewidth=1.5) +ax.axvline(0, color="grey", linestyle="solid", linewidth=1.5) +ax.grid(True, which="both", linestyle="--", linewidth=0.5) + +# %% + From 9f5229b308e21c8f838f48b0f416a418abbadd03 Mon Sep 17 00:00:00 2001 From: jshaw35 Date: Thu, 5 Mar 2026 16:28:23 -0700 Subject: [PATCH 2/9] Start integration routine --- J01-OLR_ASR_plotexample.py | 60 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/J01-OLR_ASR_plotexample.py b/J01-OLR_ASR_plotexample.py index 2f355e8..23d5d11 100644 --- a/J01-OLR_ASR_plotexample.py +++ b/J01-OLR_ASR_plotexample.py @@ -67,6 +67,66 @@ def plot_radiative_imbalance( else: return fig, ax + +def compute IEEI( + olr_ds, + asr_ds, + account_for_leap: bool = False, +): + """ + Compute the integrated earth's energy imbalance (IEEI) from ASR and OLR fields. + """ + assert olr_ds["time"] == asr_ds["time"], "OLR and ASR time fields are not identical" + time_ds = olr_ds["time"] + + days_per_month = np.array([31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]) + days_per_month_leap = np.array([31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]) + seconds_per_month = 60 * 60 * 24 * days_per_month + seconds_per_month_leap = 60 * 60 * 24 * days_per_month_leap + + weights = xr.DataArray( + data=seconds_per_month, + dims=["month"], + coords={ + "month": np.arange(12), + } + ) + weights_leap = xr.DataArray( + data=seconds_per_month_leap, + dims=["month"], + coords={ + "month": np.arange(12), + } + ) + + time_weights = [] + if account_for_leap == False: + for _t in time_ds: + time_weights.append(weights.sel(month=_t['time.month'])) + else: + for _t in time_ds: + if _t["time.year"] % 4 == 0: + time_weights.append(weights_leap.sel(month=_t['time.month'])) + else: + time_weights.append(weights.sel(month=_t['time.month'])) + + # Duplicate the time dimension but with weights as values + weights_ds = xr.DataArray( + data=time_weights, + + ) + + return time_weights + + +def get_weights_by_month( + time_step, + weights, +): + + return weights.sel(month=time_step['time.month']) + + # %% olr = np.arange(0, 10, 0.5) # Example ASR values From e1761779b1c3eb0497b89e945794bee7f922b620 Mon Sep 17 00:00:00 2001 From: jshaw35 Date: Thu, 12 Mar 2026 15:49:59 -0600 Subject: [PATCH 3/9] manual merge with Leah's improvements --- J01-OLR_ASR_plotexample.py | 74 ++++++++++++++++++++++---------------- 1 file changed, 43 insertions(+), 31 deletions(-) diff --git a/J01-OLR_ASR_plotexample.py b/J01-OLR_ASR_plotexample.py index 23d5d11..dd05cb5 100644 --- a/J01-OLR_ASR_plotexample.py +++ b/J01-OLR_ASR_plotexample.py @@ -7,12 +7,12 @@ # %% def plot_radiative_imbalance( - olr_ds, - asr_ds, + olr_da, + asr_da, ax=None, plot_kwargs=None, fontsize=14, - cmap=sns.color_palette("viridis", as_cmap=True), + cmap=mpl.colormaps['viridis'], ): if ax is None: fig, ax = plt.subplots(figsize=(10, 5)) @@ -22,25 +22,32 @@ def plot_radiative_imbalance( # Plot OLR vs ASR with color gradient for time dimension ax.plot( - olr_ds, - asr_ds, + olr_da, + asr_da, color="black", alpha=0.5, zorder=5, linewidth=0.5, ) scatter = ax.scatter( - olr_ds, - asr_ds, - c=np.arange(len(olr_ds)), + olr_da, + asr_da, + c=olr_da['time.year']+0.083*olr_da['time.month'], #fractional year coordinate cmap=cmap, zorder=10, **plot_kwargs, ) # Add a colorbar with discrete intervals and extend='both' keyword - bounds = np.arange(olr_ds["time"].min().item(), olr_ds["time"].max().item() + 1, max(1, len(olr_ds)//10)) - norm = mpl.colors.BoundaryNorm(bounds, cmap.N, extend='both') + # bounds = pd.date_range( + # start=pd.to_datetime(olr_da["time"].min().data), + # end=pd.to_datetime(olr_da["time"].max().data), + # periods=min(olr_da.sizes['time'],255)) + bounds = np.arange( + olr_da['time.year'].min(), + olr_da['time.year'].max(), + max(1,(olr_da['time.year'].max()-olr_da['time.year'].min())/255)) + norm = mpl.colors.BoundaryNorm(np.array(bounds), cmap.N, extend='both') plt.colorbar( mpl.cm.ScalarMappable(norm=norm, cmap=cmap), @@ -49,8 +56,8 @@ def plot_radiative_imbalance( ) # Plot the 1:1 line - min_val = min(olr_ds.min().item(), asr_ds.min().item()) - max_val = max(olr_ds.max().item(), asr_ds.max().item()) + min_val = min(olr_da.min().item(), asr_da.min().item()) + max_val = max(olr_da.max().item(), asr_da.max().item()) ax.plot( [min_val, max_val], [min_val, max_val], @@ -59,8 +66,8 @@ def plot_radiative_imbalance( zorder=0, ) ax.set_aspect("equal", adjustable="box") - ax.set_xlabel("OLR (Wm$^{-2}$)", fontsize=fontsize) - ax.set_ylabel("ASR (Wm$^{-2}$)", fontsize=fontsize) + ax.set_xlabel("OLR [Wm$^{-2}$]", fontsize=fontsize) + ax.set_ylabel("ASR [Wm$^{-2}$]", fontsize=fontsize) if fig is None: return ax @@ -129,23 +136,28 @@ def get_weights_by_month( # %% -olr = np.arange(0, 10, 0.5) # Example ASR values -asr = 0.5 * (olr**2) - -fig, ax = plot_radiative_imbalance( - olr_ds=xr.DataArray(olr, dims=["time"], coords={"time": np.arange(len(olr))}), - asr_ds=xr.DataArray(asr, dims=["time"], coords={"time": np.arange(len(asr))}), - plot_kwargs={"marker": "o", "linestyle": "solid"}, -) - -# Get rid of the plot edges and add gridlines through the origin -ax.spines["top"].set_visible(False) -ax.spines["bottom"].set_visible(False) -ax.spines["right"].set_visible(False) -ax.spines["left"].set_visible(False) -ax.axhline(0, color="grey", linestyle="solid", linewidth=1.5) -ax.axvline(0, color="grey", linestyle="solid", linewidth=1.5) -ax.grid(True, which="both", linestyle="--", linewidth=0.5) +def main(): + olr = np.arange(0, 10, 0.5) # Example ASR values + asr = 0.5 * (olr**2) + + fig, ax = plot_radiative_imbalance( + olr_da=xr.DataArray(olr, dims=["time"], coords={"time": np.arange(len(olr))}), + asr_da=xr.DataArray(asr, dims=["time"], coords={"time": np.arange(len(asr))}), + plot_kwargs={"marker": "o", "linestyle": "solid"}, + ) + + # Get rid of the plot edges and add gridlines through the origin + ax.spines["top"].set_visible(False) + ax.spines["bottom"].set_visible(False) + ax.spines["right"].set_visible(False) + ax.spines["left"].set_visible(False) + ax.axhline(0, color="grey", linestyle="solid", linewidth=1.5) + ax.axvline(0, color="grey", linestyle="solid", linewidth=1.5) + ax.grid(True, which="both", linestyle="--", linewidth=0.5) + # %% +if __name__ == '__main__': + main() + From 6cf0d1d62a136276f002440d922efa8a9df86793 Mon Sep 17 00:00:00 2001 From: Andrew Buggee Date: Thu, 12 Mar 2026 16:37:22 -0600 Subject: [PATCH 4/9] Add requirements.txt for PRISM Python environment Includes xarray, numpy, matplotlib, pandas, netCDF4, and ipykernel for running notebooks in the repository. --- requirements.txt | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..56581c2 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,42 @@ +asttokens==3.0.1 +certifi==2026.2.25 +cftime==1.6.5 +comm==0.2.3 +contourpy==1.3.3 +cycler==0.12.1 +debugpy==1.8.20 +decorator==5.2.1 +executing==2.2.1 +fonttools==4.62.0 +ipykernel==7.2.0 +ipython==9.11.0 +ipython_pygments_lexers==1.1.1 +jedi==0.19.2 +jupyter_client==8.8.0 +jupyter_core==5.9.1 +kiwisolver==1.5.0 +matplotlib==3.10.8 +matplotlib-inline==0.2.1 +nest-asyncio==1.6.0 +netCDF4==1.7.4 +numpy==2.4.3 +packaging==26.0 +pandas==3.0.1 +parso==0.8.6 +pexpect==4.9.0 +pillow==12.1.1 +platformdirs==4.9.4 +prompt_toolkit==3.0.52 +psutil==7.2.2 +ptyprocess==0.7.0 +pure_eval==0.2.3 +Pygments==2.19.2 +pyparsing==3.3.2 +python-dateutil==2.9.0.post0 +pyzmq==27.1.0 +six==1.17.0 +stack-data==0.6.3 +tornado==6.5.5 +traitlets==5.14.3 +wcwidth==0.6.0 +xarray==2026.2.0 From 9c3d53898f3676c686cb6c398fb5f67069d4c097 Mon Sep 17 00:00:00 2001 From: wk2500 <97990166+wk2500@users.noreply.github.com> Date: Fri, 12 Jun 2026 10:42:54 -0600 Subject: [PATCH 5/9] Add files via upload Simple energy models. Current values for constants such as thermal inertia, heat exchange, etc. are not tuned --- multliayerModel.ipynb | 1599 +++++++++++++++++++++++++++++++++++++++++ simpleModel.ipynb | 572 +++++++++++++++ 2 files changed, 2171 insertions(+) create mode 100644 multliayerModel.ipynb create mode 100644 simpleModel.ipynb diff --git a/multliayerModel.ipynb b/multliayerModel.ipynb new file mode 100644 index 0000000..db5f6ef --- /dev/null +++ b/multliayerModel.ipynb @@ -0,0 +1,1599 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ef472d5d", + "metadata": {}, + "source": [ + "# Multi-Layer Energy Balance Model (EBM)\n", + "### Atmosphere · Upper Ocean (0–200 m) · Lower Ocean (>200 m)\n", + "\n", + "This extends the zero-dimensional EBM to **three coupled layers**, each with its own\n", + "heat capacity, so the fast atmospheric response and the slow deep-ocean heat uptake are\n", + "represented explicitly:\n", + "\n", + "$$C_a\\frac{dT_a}{dt} = S\\bigl(1-\\alpha(t)\\bigr) - (a + bT_a) + F(t) - \\gamma_{au}(T_a - T_u)$$\n", + "$$C_u\\frac{dT_u}{dt} = \\gamma_{au}(T_a - T_u) - \\gamma_{ul}(T_u - T_l)$$\n", + "$$C_l\\frac{dT_l}{dt} = \\gamma_{ul}(T_u - T_l)$$\n", + "\n", + "| Symbol | Meaning | Units |\n", + "|--------|---------|-------|\n", + "| $T_a,\\,T_u,\\,T_l$ | Atmosphere / upper-ocean / lower-ocean temperature | K |\n", + "| $C_a$ | Atmospheric-column heat capacity | W·yr/m²/°C |\n", + "| $C_u$ | Upper-ocean (0–200 m) heat capacity | W·yr/m²/°C |\n", + "| $C_l$ | Lower-ocean (>200 m) heat capacity | W·yr/m²/°C |\n", + "| $\\gamma_{au}$ | Atmosphere ↔ upper-ocean heat exchange | W/m²/°C |\n", + "| $\\gamma_{ul}$ | Upper ↔ lower-ocean heat exchange (deep uptake) | W/m²/°C |\n", + "| $S,\\ \\alpha(t),\\ a+bT,\\ F(t)$ | Insolation, albedo, OLR, CO₂ forcing | as in the single-layer model |\n", + "\n", + "Only the atmosphere exchanges radiation with space, so the CO₂ forcing $F$ and the SAI\n", + "albedo offset act on $T_a$; heat then flows downward through the ocean via the exchange\n", + "terms. At equilibrium all three layers converge to the same temperature — identical to the\n", + "single-layer EBM — but the transient now carries the realistic **two-timescale** behaviour:\n", + "a fast (~weeks) atmospheric/surface adjustment riding on a slow (century-scale) deep-ocean\n", + "drift." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8edf82c0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T20:12:07.882003Z", + "iopub.status.busy": "2026-06-11T20:12:07.881885Z", + "iopub.status.idle": "2026-06-11T20:12:08.304617Z", + "shell.execute_reply": "2026-06-11T20:12:08.304153Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.integrate import solve_ivp\n", + "import ipywidgets as widgets\n", + "from ipywidgets import interact, FloatSlider, IntSlider, Dropdown\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "plt.rcParams.update({\n", + " 'figure.dpi': 110,\n", + " 'axes.spines.top': False,\n", + " 'axes.spines.right': False,\n", + " 'axes.grid': True,\n", + " 'grid.alpha': 0.3,\n", + " 'font.size': 11,\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6be1b0fd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T20:12:08.306025Z", + "iopub.status.busy": "2026-06-11T20:12:08.305927Z", + "iopub.status.idle": "2026-06-11T20:12:08.309050Z", + "shell.execute_reply": "2026-06-11T20:12:08.308616Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OLR: a = -364.058 W/m2, b = 2.09 W/m2/K\n", + "Heat capacities [W.yr/m2/K]: C_a = 0.329 C_u = 18.40 C_l = 322.1\n", + "Response timescales: atmosphere ~ 0.027 yr upper ocean ~ 26 yr deep ocean ~ 460 yr\n", + "Equilibrium check -> T_eq = 288.1500 K (target: 288.15 K)\n" + ] + } + ], + "source": [ + "# == Physical constants =======================================================\n", + "S0 = 1361.0 # Solar constant [W/m2]\n", + "S = S0 / 4 # Sphere-averaged mean insolation [W/m2]\n", + "\n", + "# == Pre-industrial baseline (1850) ===========================================\n", + "alpha0 = 0.30 # Planetary albedo\n", + "T0 = 288.15 # Surface temperature [K] (~15 C)\n", + "\n", + "# == OLR linearization: OLR = a + b*T (Budyko 1969) ==========================\n", + "b = 2.09 # OLR slope [W/m2/K]\n", + "a = S * (1 - alpha0) - b * T0 # Intercept tuned so T_eq = T0 exactly\n", + "\n", + "# == Layer heat capacities ====================================================\n", + "# Ocean layer: C = rho * c_p * h * f_ocean / (seconds per year) [W.yr/m2/K]\n", + "# Atmosphere : C = c_p_air * p_s / g / (seconds per year)\n", + "RHO_W = 1025.0 # seawater density [kg/m3]\n", + "CP_W = 3990.0 # seawater heat capacity [J/kg/K]\n", + "F_OCEAN = 0.71 # ocean fraction of Earth's surface\n", + "CP_AIR = 1004.0 # air heat capacity [J/kg/K]\n", + "P_SURF = 1.01325e5 # surface pressure [Pa]\n", + "G_GRAV = 9.81 # gravity [m/s2]\n", + "SEC_PER_YR = 3.1557e7\n", + "\n", + "UPPER_DEPTH = 200.0 # upper-ocean thickness [m]\n", + "LOWER_DEPTH = 3500.0 # lower-ocean thickness [m] (ocean below 200 m; mean depth ~3700 m)\n", + "\n", + "def ocean_layer_C(depth_m, f_ocean=F_OCEAN):\n", + " \"\"\"Heat capacity per m2 of Earth for an ocean layer [W.yr/m2/K].\"\"\"\n", + " return RHO_W * CP_W * depth_m * f_ocean / SEC_PER_YR\n", + "\n", + "C_ATMOS = CP_AIR * P_SURF / G_GRAV / SEC_PER_YR # atmospheric column\n", + "C_UPPER = ocean_layer_C(UPPER_DEPTH)\n", + "C_LOWER = ocean_layer_C(LOWER_DEPTH)\n", + "\n", + "# == Inter-layer heat-exchange coefficients [W/m2/K] ==========================\n", + "GAMMA_AU = 10.0 # atmosphere <-> upper ocean (strong air-sea coupling)\n", + "GAMMA_UL = 0.7 # upper <-> lower ocean (deep-ocean heat-uptake efficiency; Geoffroy 2013)\n", + "\n", + "print(f\"OLR: a = {a:.3f} W/m2, b = {b} W/m2/K\")\n", + "print(f\"Heat capacities [W.yr/m2/K]: C_a = {C_ATMOS:.3f} C_u = {C_UPPER:.2f} C_l = {C_LOWER:.1f}\")\n", + "print(f\"Response timescales: atmosphere ~ {C_ATMOS/(b+GAMMA_AU):.3f} yr \"\n", + " f\"upper ocean ~ {C_UPPER/GAMMA_UL:.0f} yr deep ocean ~ {C_LOWER/GAMMA_UL:.0f} yr\")\n", + "print(f\"Equilibrium check -> T_eq = {(S*(1-alpha0) - a)/b:.4f} K (target: {T0} K)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9ca64d2f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T20:12:08.310096Z", + "iopub.status.busy": "2026-06-11T20:12:08.310041Z", + "iopub.status.idle": "2026-06-11T20:12:08.313246Z", + "shell.execute_reply": "2026-06-11T20:12:08.312875Z" + } + }, + "outputs": [], + "source": [ + "def co2_forcing(t, scenario='rcp45'):\n", + " \"\"\"\n", + " CO2 radiative forcing relative to pre-industrial [W/m2].\n", + "\n", + " Historical (1850-2023): linear ramp 0 -> 2.3 W/m2 for all scenarios.\n", + " Post-2023 projections follow IPCC RCP pathways.\n", + " \"\"\"\n", + " if scenario == 'none':\n", + " return 0.0\n", + "\n", + " # Historical ramp (identical for all scenarios)\n", + " if t <= 2023:\n", + " return float(np.interp(t, [1850, 2023], [0.0, 2.3]))\n", + "\n", + " # Post-2023 scenario divergence\n", + " projections = {\n", + " 'rcp26': ([2023, 2040, 2100, 2150], [2.3, 3.0, 2.6, 1.0]),\n", + " 'rcp45': ([2023, 2100, 2150], [2.3, 4.5, 6.5]),\n", + " 'rcp85': ([2023, 2100, 2150], [2.3, 8.5, 12.5]),\n", + " }\n", + " ts, Fs = projections[scenario]\n", + " return float(np.interp(t, ts, Fs))\n", + "\n", + "\n", + "def sai_delta_alpha(t, d_alpha=0.0, start_year=2030, ramp_years=10):\n", + " \"\"\"Additional albedo from stratospheric aerosol injection (SAI).\"\"\"\n", + " if d_alpha == 0.0 or t < start_year:\n", + " return 0.0\n", + " ramp_end = start_year + ramp_years\n", + " if t < ramp_end:\n", + " return d_alpha * (t - start_year) / ramp_years\n", + " return d_alpha\n", + "\n", + "\n", + "def net_toa_imbalance(t, Ta, d_alpha=0.0, scenario='rcp45', sai_start=2030, sai_ramp=10):\n", + " \"\"\"Net top-of-atmosphere radiative flux S(1-alpha) - (a + b*Ta) + F [W/m2].\"\"\"\n", + " alpha = alpha0 + sai_delta_alpha(t, d_alpha=d_alpha, start_year=sai_start, ramp_years=sai_ramp)\n", + " F = co2_forcing(t, scenario=scenario)\n", + " return S * (1 - alpha) - (a + b * Ta) + F\n", + "\n", + "\n", + "def layer_derivs(t, y, C_a, C_u, C_l, gamma_au, gamma_ul,\n", + " d_alpha=0.0, scenario='rcp45', sai_start=2030, sai_ramp=10):\n", + " \"\"\"\n", + " Right-hand side of the three-layer system. y = [T_a, T_u, T_l].\n", + "\n", + " Atmosphere sees the net TOA radiation and loses heat to the upper ocean;\n", + " the upper ocean passes heat to the lower ocean.\n", + " \"\"\"\n", + " Ta, Tu, Tl = y\n", + " R = net_toa_imbalance(t, Ta, d_alpha, scenario, sai_start, sai_ramp) # into atmosphere\n", + " f_au = gamma_au * (Ta - Tu) # atmosphere -> upper ocean\n", + " f_ul = gamma_ul * (Tu - Tl) # upper ocean -> lower ocean\n", + " return [(R - f_au) / C_a,\n", + " (f_au - f_ul) / C_u,\n", + " (f_ul) / C_l]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fe396bc6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T20:12:08.314719Z", + "iopub.status.busy": "2026-06-11T20:12:08.314644Z", + "iopub.status.idle": "2026-06-11T20:12:08.317213Z", + "shell.execute_reply": "2026-06-11T20:12:08.316860Z" + } + }, + "outputs": [], + "source": [ + "def run_ebm(C_a=C_ATMOS, C_u=C_UPPER, C_l=C_LOWER,\n", + " gamma_au=GAMMA_AU, gamma_ul=GAMMA_UL,\n", + " scenario='rcp45', d_alpha=0.0, sai_start=2030, sai_ramp=10,\n", + " t_span=(1850, 2150), n_pts=2400):\n", + " \"\"\"\n", + " Integrate the three-layer EBM.\n", + "\n", + " The system spans timescales from days (atmosphere) to centuries (deep ocean),\n", + " so it is stiff -> solved with the implicit BDF method.\n", + "\n", + " Returns\n", + " -------\n", + " t : time [years]\n", + " Ta : atmospheric temperature [K]\n", + " Tu : upper-ocean temperature [K]\n", + " Tl : lower-ocean temperature [K]\n", + " Q : net TOA energy imbalance [W/m2]\n", + " \"\"\"\n", + " kw = dict(d_alpha=d_alpha, scenario=scenario, sai_start=sai_start, sai_ramp=sai_ramp)\n", + " args = (C_a, C_u, C_l, gamma_au, gamma_ul)\n", + "\n", + " t_eval = np.linspace(*t_span, n_pts)\n", + " sol = solve_ivp(lambda t, y: layer_derivs(t, y, *args, **kw),\n", + " t_span, [T0, T0, T0], t_eval=t_eval,\n", + " method='BDF', rtol=1e-8, atol=1e-10)\n", + "\n", + " Ta, Tu, Tl = sol.y\n", + " Q = np.array([net_toa_imbalance(ti, Ta_i, **kw) for ti, Ta_i in zip(sol.t, Ta)])\n", + " return sol.t, Ta, Tu, Tl, Q" + ] + }, + { + "cell_type": "markdown", + "id": "d7324305", + "metadata": {}, + "source": [ + "## Scenario Comparison\n", + "\n", + "**Left column** — CO₂ forcing only (no SAI), across four RCP pathways.\n", + "**Right column** — SAI at varying deployment levels under RCP 4.5.\n", + "\n", + "Rows (top → bottom): **atmospheric temperature** $T_a$, **upper-ocean** temperature change\n", + "$\\Delta T_u$, **lower-ocean** temperature change $\\Delta T_l$, and the **energy imbalance**\n", + "$Q$ (net TOA flux). Note how the deep ocean warms only a fraction of the surface amount over\n", + "this period — the signature of slow deep-ocean heat uptake." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41189967", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T20:12:08.318250Z", + "iopub.status.busy": "2026-06-11T20:12:08.318197Z", + "iopub.status.idle": "2026-06-11T20:12:08.666890Z", + "shell.execute_reply": "2026-06-11T20:12:08.666449Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(4, 2, figsize=(14, 16), sharex=True)\n", + "fig.suptitle('Multi-Layer EBM - Scenario Comparison', fontsize=13, fontweight='bold', y=1.003)\n", + "\n", + "# -- CO2 scenarios (no SAI), left column --------------------------------------\n", + "co2_cases = [\n", + " ('none', 'Pre-industrial control', '#888888'),\n", + " ('rcp26', 'RCP 2.6 - strong mitigation', '#1a9641'),\n", + " ('rcp45', 'RCP 4.5 - moderate', '#fdae61'),\n", + " ('rcp85', 'RCP 8.5 - high emissions', '#d7191c'),\n", + "]\n", + "for scen, label, color in co2_cases:\n", + " t, Ta, Tu, Tl, Q = run_ebm(scenario=scen, d_alpha=0.0)\n", + " axes[0, 0].plot(t, Ta, color=color, lw=2, label=label)\n", + " axes[1, 0].plot(t, Tu - T0, color=color, lw=2, label=label)\n", + " axes[2, 0].plot(t, Tl - T0, color=color, lw=2, label=label)\n", + " axes[3, 0].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# -- SAI levels under RCP 4.5, right column -----------------------------------\n", + "sai_cases = [\n", + " (0.000, 'No SAI', '#d7191c'),\n", + " (0.005, 'SAI da = 0.005', '#fdae61'),\n", + " (0.010, 'SAI da = 0.010', '#74add1'),\n", + " (0.015, 'SAI da = 0.015', '#2c7bb6'),\n", + "]\n", + "for da, label, color in sai_cases:\n", + " t, Ta, Tu, Tl, Q = run_ebm(scenario='rcp45', d_alpha=da)\n", + " axes[0, 1].plot(t, Ta, color=color, lw=2, label=label)\n", + " axes[1, 1].plot(t, Tu - T0, color=color, lw=2, label=label)\n", + " axes[2, 1].plot(t, Tl - T0, color=color, lw=2, label=label)\n", + " axes[3, 1].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# -- Annotations --------------------------------------------------------------\n", + "for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.45)\n", + "for ax in axes[:, 1]:\n", + " ax.axvline(2030, color='navy', ls=':', lw=1.5, alpha=0.55)\n", + "for ax in list(axes[1, :]) + list(axes[2, :]) + list(axes[3, :]):\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "\n", + "axes[0, 0].set(title='Atmospheric temperature - CO2 pathways', ylabel='T_a [K]')\n", + "axes[0, 1].set(title='Atmospheric temperature - SAI levels (RCP 4.5)', ylabel='T_a [K]')\n", + "axes[1, 0].set(title='Upper-ocean temperature change - CO2 pathways', ylabel='dT_u [K]')\n", + "axes[1, 1].set(title='Upper-ocean temperature change - SAI levels', ylabel='dT_u [K]')\n", + "axes[2, 0].set(title='Lower-ocean temperature change - CO2 pathways', ylabel='dT_l [K]')\n", + "axes[2, 1].set(title='Lower-ocean temperature change - SAI levels', ylabel='dT_l [K]')\n", + "axes[3, 0].set(title='Energy imbalance - CO2 pathways', ylabel='Q [W/m2]', xlabel='Year')\n", + "axes[3, 1].set(title='Energy imbalance - SAI levels', ylabel='Q [W/m2]', xlabel='Year')\n", + "\n", + "axes[0, 0].legend(fontsize=9)\n", + "axes[0, 1].legend(fontsize=9)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "52197469", + "metadata": {}, + "source": [ + "## Interactive Exploration\n", + "\n", + "Adjust the layer heat capacities, the deep-ocean coupling $\\gamma_{ul}$, the CO₂ pathway, and\n", + "the SAI deployment to see how each shapes the response in real time.\n", + "\n", + "- **Top-left** — atmospheric temperature, with the SAI cooling offset shaded.\n", + "- **Top-right** — ocean temperature change for the **upper** (solid) and **lower** (dashed) layers.\n", + "- **Bottom-left** — net TOA energy imbalance $Q$ and the **deep-ocean heat uptake** $\\gamma_{ul}(T_u-T_l)$.\n", + "- **Bottom-right** — energy-balance decomposition $Q = F_{\\mathrm{CO_2}} + F_{\\mathrm{SAI}} +$ OLR feedback." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8028eb34", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T20:12:08.668667Z", + "iopub.status.busy": "2026-06-11T20:12:08.668602Z", + "iopub.status.idle": "2026-06-11T20:12:08.866939Z", + "shell.execute_reply": "2026-06-11T20:12:08.866462Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "287ed1f9c95b4cb2a71fda9bb28a03af", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=18.403032607662325, description='C_u [W.yr/m2/K]', max=40.0, min=5.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_ebm(C_u, C_l, gamma_ul, scenario, d_alpha, sai_start, sai_ramp):\n", + " t_b, Ta_b, Tu_b, Tl_b, Q_b = run_ebm(C_u=C_u, C_l=C_l, gamma_ul=gamma_ul,\n", + " scenario=scenario, d_alpha=0.0)\n", + " t_s, Ta_s, Tu_s, Tl_s, Q_s = run_ebm(C_u=C_u, C_l=C_l, gamma_ul=gamma_ul,\n", + " scenario=scenario, d_alpha=d_alpha,\n", + " sai_start=sai_start, sai_ramp=sai_ramp)\n", + "\n", + " fig, axes = plt.subplots(2, 2, figsize=(15, 9))\n", + " fig.suptitle(f'Multi-Layer EBM | {scenario.upper()} | '\n", + " f'C_u={C_u:.0f}, C_l={C_l:.0f} W.yr/m2/K, gamma_ul={gamma_ul:.2f}',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + " # -- Atmospheric temperature ----------------------------------------------\n", + " ax = axes[0, 0]\n", + " ax.plot(t_b, Ta_b, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, Ta_s, color='#2c7bb6', lw=2, label=f'SAI da = {d_alpha:.3f}')\n", + " ax.fill_between(t_s, Ta_b, Ta_s, where=(Ta_s < Ta_b),\n", + " alpha=0.15, color='#2c7bb6', label='Cooling offset')\n", + " ax.set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "\n", + " # -- Ocean temperature change (upper solid, lower dashed) -----------------\n", + " ax = axes[0, 1]\n", + " ax.plot(t_b, Tu_b - T0, color='#d7191c', lw=2, label='Upper, no SAI')\n", + " ax.plot(t_s, Tu_s - T0, color='#2c7bb6', lw=2, label='Upper, SAI')\n", + " ax.plot(t_b, Tl_b - T0, color='#d7191c', lw=2, ls='--', label='Lower, no SAI')\n", + " ax.plot(t_s, Tl_s - T0, color='#2c7bb6', lw=2, ls='--', label='Lower, SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Ocean temperature change', ylabel='dT [K]', xlabel='Year')\n", + "\n", + " # -- Energy imbalance + deep-ocean heat uptake ----------------------------\n", + " ax = axes[1, 0]\n", + " ax.plot(t_b, Q_b, color='#d7191c', lw=2, label='Q (TOA), no SAI')\n", + " ax.plot(t_s, Q_s, color='#2c7bb6', lw=2, label='Q (TOA), SAI')\n", + " ax.plot(t_b, gamma_ul * (Tu_b - Tl_b), color='#d7191c', lw=1.3, ls=':', label='Deep uptake, no SAI')\n", + " ax.plot(t_s, gamma_ul * (Tu_s - Tl_s), color='#2c7bb6', lw=1.3, ls=':', label='Deep uptake, SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy imbalance & deep-ocean heat uptake', ylabel='W/m2', xlabel='Year')\n", + "\n", + " # -- Energy-balance decomposition (SAI run) -------------------------------\n", + " ax = axes[1, 1]\n", + " F_co2 = np.array([co2_forcing(ti, scenario=scenario) for ti in t_s])\n", + " F_sai = np.array([-S * sai_delta_alpha(ti, d_alpha=d_alpha,\n", + " start_year=sai_start, ramp_years=sai_ramp) for ti in t_s])\n", + " OLR_fb = -(b * (Ta_s - T0))\n", + " Q_dec = F_co2 + F_sai + OLR_fb\n", + " ax.fill_between(t_s, F_co2, alpha=0.35, color='#d7191c', label='CO2 forcing F(t)')\n", + " ax.fill_between(t_s, F_sai, alpha=0.35, color='#2c7bb6', label='SAI forcing -S*da')\n", + " ax.fill_between(t_s, OLR_fb, alpha=0.35, color='#fdae61', label='OLR feedback -b(Ta-T0)')\n", + " ax.plot(t_s, Q_dec, 'k-', lw=1.6, label='Q (sum)')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy balance decomposition (SAI run)', ylabel='W/m2', xlabel='Year')\n", + "\n", + " for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " if d_alpha > 0:\n", + " ax.axvline(sai_start, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.legend(fontsize=8)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_ebm,\n", + " C_u = FloatSlider(value=C_UPPER, min=5.0, max=40.0, step=1.0, description='C_u [W.yr/m2/K]', style={'description_width':'initial'}),\n", + " C_l = FloatSlider(value=C_LOWER, min=50.0, max=600.0, step=10.0, description='C_l [W.yr/m2/K]', style={'description_width':'initial'}),\n", + " gamma_ul = FloatSlider(value=GAMMA_UL, min=0.1, max=2.0, step=0.1, description='gamma_ul [W/m2/K]', style={'description_width':'initial'}, readout_format='.2f'),\n", + " scenario = Dropdown(options=['none','rcp26','rcp45','rcp85'], value='rcp45', description='CO2 scenario'),\n", + " d_alpha = FloatSlider(value=0.0, min=0.0, max=0.025, step=0.001, description='SAI da', style={'description_width':'initial'}, readout_format='.3f'),\n", + " sai_start = IntSlider( value=2030, min=2025, max=2080, step=5, description='SAI start year', style={'description_width':'initial'}),\n", + " sai_ramp = IntSlider( value=10, min=1, max=30, step=1, description='Ramp-up years', style={'description_width':'initial'}),\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "d1d59879", + "metadata": {}, + "source": [ + "## Deep-Ocean Coupling Sensitivity\n", + "\n", + "The new physics in this model is the **deep-ocean heat uptake**, set by $\\gamma_{ul}$. A larger\n", + "$\\gamma_{ul}$ lets heat drain into the lower ocean faster — warming the deep ocean but **slowing**\n", + "surface warming and **raising** the persistent energy imbalance $Q$. Below: all four layers'\n", + "responses for five values of $\\gamma_{ul}$ under RCP 4.5 with a moderate SAI deployment\n", + "($\\Delta\\alpha = 0.010$)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "aff5ca22", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T20:12:08.869226Z", + "iopub.status.busy": "2026-06-11T20:12:08.869175Z", + "iopub.status.idle": "2026-06-11T20:12:09.099691Z", + "shell.execute_reply": "2026-06-11T20:12:09.099303Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gamma_values = [0.2, 0.5, 0.7, 1.0, 1.5]\n", + "colors = plt.cm.viridis(np.linspace(0.1, 0.85, len(gamma_values)))\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 9))\n", + "fig.suptitle('Deep-Ocean Coupling Sensitivity (RCP 4.5, SAI da = 0.010, start 2030)',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + "for g, color in zip(gamma_values, colors):\n", + " t, Ta, Tu, Tl, Q = run_ebm(scenario='rcp45', d_alpha=0.010, gamma_ul=g)\n", + " axes[0, 0].plot(t, Ta, color=color, lw=2, label=f'gamma_ul = {g}')\n", + " axes[0, 1].plot(t, Tu - T0, color=color, lw=2)\n", + " axes[1, 0].plot(t, Tl - T0, color=color, lw=2)\n", + " axes[1, 1].plot(t, Q, color=color, lw=2)\n", + "\n", + "for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " ax.axvline(2030, color='gray', ls=':', lw=1.5, alpha=0.55)\n", + "for ax in (axes[0, 1], axes[1, 0], axes[1, 1]):\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "\n", + "axes[0, 0].set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "axes[0, 1].set(title='Upper-ocean temperature change', ylabel='dT_u [K]', xlabel='Year')\n", + "axes[1, 0].set(title='Lower-ocean temperature change', ylabel='dT_l [K]', xlabel='Year')\n", + "axes[1, 1].set(title='Energy imbalance Q', ylabel='W/m2', xlabel='Year')\n", + "\n", + "axes[0, 0].legend(title='Deep coupling', fontsize=9)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4243e700", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c56a2a1c726e40c289ef01c45f24cae0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=18.403032607662325, description='C_u [W.yr/m2/K]', max=40.0, min=5.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ── SAI with post-ramp slope ──────────────────────────────────────────────────\n", + "# Redefines the sai_delta_alpha → net_toa_imbalance → layer_derivs → run_ebm\n", + "# chain to thread a d_alpha_slope parameter (increase in da per year after ramp).\n", + "\n", + "def sai_delta_alpha(t, d_alpha=0.0, start_year=2030, ramp_years=10, d_alpha_slope=0.0):\n", + " \"\"\"\n", + " Albedo offset from SAI.\n", + "\n", + " Phase 1 – pre-deployment [t < start_year]: 0\n", + " Phase 2 – ramp-up [start_year, start_year+ramp): linear 0 → d_alpha\n", + " Phase 3 – post-ramp [t >= start_year+ramp): d_alpha + d_alpha_slope*(t-ramp_end)\n", + " \"\"\"\n", + " if d_alpha == 0.0 or t < start_year:\n", + " return 0.0\n", + " ramp_end = start_year + ramp_years\n", + " if t < ramp_end:\n", + " return d_alpha * (t - start_year) / ramp_years\n", + " return d_alpha + d_alpha_slope * (t - ramp_end)\n", + "\n", + "\n", + "def net_toa_imbalance(t, Ta, d_alpha=0.0, scenario='rcp45',\n", + " sai_start=2030, sai_ramp=10, d_alpha_slope=0.0):\n", + " alpha = alpha0 + sai_delta_alpha(t, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " F = co2_forcing(t, scenario=scenario)\n", + " return S * (1 - alpha) - (a + b * Ta) + F\n", + "\n", + "\n", + "def layer_derivs(t, y, C_a, C_u, C_l, gamma_au, gamma_ul,\n", + " d_alpha=0.0, scenario='rcp45', sai_start=2030, sai_ramp=10, d_alpha_slope=0.0):\n", + " Ta, Tu, Tl = y\n", + " R = net_toa_imbalance(t, Ta, d_alpha, scenario, sai_start, sai_ramp, d_alpha_slope)\n", + " f_au = gamma_au * (Ta - Tu)\n", + " f_ul = gamma_ul * (Tu - Tl)\n", + " return [(R - f_au) / C_a,\n", + " (f_au - f_ul) / C_u,\n", + " (f_ul) / C_l]\n", + "\n", + "\n", + "def run_ebm(C_a=C_ATMOS, C_u=C_UPPER, C_l=C_LOWER,\n", + " gamma_au=GAMMA_AU, gamma_ul=GAMMA_UL,\n", + " scenario='rcp45', d_alpha=0.0, sai_start=2030, sai_ramp=10,\n", + " d_alpha_slope=0.0, t_span=(1850, 2150), n_pts=2400):\n", + " kw = dict(d_alpha=d_alpha, scenario=scenario, sai_start=sai_start,\n", + " sai_ramp=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " args = (C_a, C_u, C_l, gamma_au, gamma_ul)\n", + " t_eval = np.linspace(*t_span, n_pts)\n", + " sol = solve_ivp(lambda t, y: layer_derivs(t, y, *args, **kw),\n", + " t_span, [T0, T0, T0], t_eval=t_eval,\n", + " method='BDF', rtol=1e-8, atol=1e-10)\n", + " Ta, Tu, Tl = sol.y\n", + " Q = np.array([net_toa_imbalance(ti, Ta_i, **kw) for ti, Ta_i in zip(sol.t, Ta)])\n", + " return sol.t, Ta, Tu, Tl, Q\n", + "\n", + "\n", + "def plot_ebm(C_u, C_l, gamma_ul, scenario, d_alpha, sai_start, sai_ramp, d_alpha_slope):\n", + " t_b, Ta_b, Tu_b, Tl_b, Q_b = run_ebm(C_u=C_u, C_l=C_l, gamma_ul=gamma_ul,\n", + " scenario=scenario, d_alpha=0.0)\n", + " t_s, Ta_s, Tu_s, Tl_s, Q_s = run_ebm(C_u=C_u, C_l=C_l, gamma_ul=gamma_ul,\n", + " scenario=scenario, d_alpha=d_alpha,\n", + " sai_start=sai_start, sai_ramp=sai_ramp,\n", + " d_alpha_slope=d_alpha_slope)\n", + "\n", + " fig, axes = plt.subplots(2, 2, figsize=(15, 9))\n", + " fig.suptitle(f'Multi-Layer EBM | {scenario.upper()} | '\n", + " f'C_u={C_u:.0f}, C_l={C_l:.0f} W.yr/m2/K, gamma_ul={gamma_ul:.2f}',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + " # -- Atmospheric temperature -----------------------------------------------\n", + " ax = axes[0, 0]\n", + " ax.plot(t_b, Ta_b, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, Ta_s, color='#2c7bb6', lw=2,\n", + " label=f'SAI da={d_alpha:.3f}, slope={d_alpha_slope:.4f}/yr')\n", + " ax.fill_between(t_s, Ta_b, Ta_s, where=(Ta_s < Ta_b),\n", + " alpha=0.15, color='#2c7bb6', label='Cooling offset')\n", + " ax.set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "\n", + " # -- Ocean temperature change ----------------------------------------------\n", + " ax = axes[0, 1]\n", + " ax.plot(t_b, Tu_b - T0, color='#d7191c', lw=2, label='Upper, no SAI')\n", + " ax.plot(t_s, Tu_s - T0, color='#2c7bb6', lw=2, label='Upper, SAI')\n", + " ax.plot(t_b, Tl_b - T0, color='#d7191c', lw=2, ls='--', label='Lower, no SAI')\n", + " ax.plot(t_s, Tl_s - T0, color='#2c7bb6', lw=2, ls='--', label='Lower, SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Ocean temperature change', ylabel='dT [K]', xlabel='Year')\n", + "\n", + " # -- Energy imbalance + deep-ocean heat uptake -----------------------------\n", + " ax = axes[1, 0]\n", + " ax.plot(t_b, Q_b, color='#d7191c', lw=2, label='Q (TOA), no SAI')\n", + " ax.plot(t_s, Q_s, color='#2c7bb6', lw=2, label='Q (TOA), SAI')\n", + " ax.plot(t_b, gamma_ul * (Tu_b - Tl_b), color='#d7191c', lw=1.3, ls=':', label='Deep uptake, no SAI')\n", + " ax.plot(t_s, gamma_ul * (Tu_s - Tl_s), color='#2c7bb6', lw=1.3, ls=':', label='Deep uptake, SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy imbalance & deep-ocean heat uptake', ylabel='W/m2', xlabel='Year')\n", + "\n", + " # -- Energy-balance decomposition -----------------------------------------\n", + " ax = axes[1, 1]\n", + " F_co2 = np.array([co2_forcing(ti, scenario=scenario) for ti in t_s])\n", + " F_sai = np.array([-S * sai_delta_alpha(ti, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " for ti in t_s])\n", + " OLR_fb = -(b * (Ta_s - T0))\n", + " Q_dec = F_co2 + F_sai + OLR_fb\n", + " ax.fill_between(t_s, F_co2, alpha=0.35, color='#d7191c', label='CO2 forcing F(t)')\n", + " ax.fill_between(t_s, F_sai, alpha=0.35, color='#2c7bb6', label='SAI forcing -S*da(t)')\n", + " ax.fill_between(t_s, OLR_fb, alpha=0.35, color='#fdae61', label='OLR feedback -b(Ta-T0)')\n", + " ax.plot(t_s, Q_dec, 'k-', lw=1.6, label='Q (sum)')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy balance decomposition (SAI run)', ylabel='W/m2', xlabel='Year')\n", + "\n", + " for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " if d_alpha > 0:\n", + " ax.axvline(sai_start, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.axvline(sai_start + sai_ramp, color='steelblue', ls=':', lw=1.0, alpha=0.5)\n", + " ax.legend(fontsize=8)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_ebm,\n", + " C_u = FloatSlider(value=C_UPPER, min=5.0, max=40.0, step=1.0, description='C_u [W.yr/m2/K]', style={'description_width': 'initial'}),\n", + " C_l = FloatSlider(value=C_LOWER, min=50.0, max=600.0, step=10.0, description='C_l [W.yr/m2/K]', style={'description_width': 'initial'}),\n", + " gamma_ul = FloatSlider(value=GAMMA_UL, min=0.1, max=2.0, step=0.1, description='gamma_ul [W/m2/K]', style={'description_width': 'initial'}, readout_format='.2f'),\n", + " scenario = Dropdown(options=['none', 'rcp26', 'rcp45', 'rcp85'], value='rcp45', description='CO2 scenario'),\n", + " d_alpha = FloatSlider(value=0.0, min=0.0, max=0.025, step=0.001, description='SAI da', style={'description_width': 'initial'}, readout_format='.3f'),\n", + " sai_start = IntSlider( value=2030, min=2025, max=2080, step=5, description='SAI start year', style={'description_width': 'initial'}),\n", + " sai_ramp = IntSlider( value=10, min=1, max=30, step=1, description='Ramp-up years', style={'description_width': 'initial'}),\n", + " d_alpha_slope= FloatSlider(value=0.0, min=0.0, max=0.0005, step=0.00001, description='Post-ramp slope (da/yr)', style={'description_width': 'initial'}, readout_format='.4f'),\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d66205f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "baseEnv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "118b2208521a47639850c3a5303b40c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "120da69a0204466bb624ca970bc9c9cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + }, + "171215d49a974170b092020fc443c71f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "FloatSliderView", + "behavior": "drag-tap", + "continuous_update": true, + "description": "SAI da", + "description_allow_html": false, + "disabled": false, + "layout": "IPY_MODEL_2ba26c53f0c7408689b6e56f2780c9fc", + "max": 0.025, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": ".3f", + "step": 0.001, + "style": "IPY_MODEL_773a9b77ccc7464d8823300ea0bc719e", + "tabbable": null, + "tooltip": null, + "value": 0 + } + }, + "21965f3fcf314f989d34a91f23f8912d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ba26c53f0c7408689b6e56f2780c9fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c12cd340f1140d1a9880104d0a33c06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "FloatSliderView", + "behavior": "drag-tap", + "continuous_update": true, + "description": "C_u [W.yr/m2/K]", + "description_allow_html": false, + "disabled": false, + "layout": "IPY_MODEL_21965f3fcf314f989d34a91f23f8912d", + "max": 40, + "min": 5, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 1, + "style": "IPY_MODEL_120da69a0204466bb624ca970bc9c9cc", + "tabbable": null, + "tooltip": null, + "value": 18.403032607662325 + } + }, + "2e384288190b44ec85816468e5ed4e93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e8515695d034d36a1eafeae15237cef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2f3438cdb3094839afe01f50340941e8": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_b044d31f52b9476f822b1b679210ac52", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": "
" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "tabbable": null, + "tooltip": null + } + }, + "3d27d97ec1f84a45990b83f9f96ecd73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "IntSliderView", + "behavior": "drag-tap", + "continuous_update": true, + "description": "SAI start year", + "description_allow_html": false, + "disabled": false, + "layout": "IPY_MODEL_f07dbd893e084990a4a3b2478153c91b", + "max": 2080, + "min": 2025, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 5, + "style": "IPY_MODEL_fd689d4f069746d283d32d702bacd2cc", + "tabbable": null, + "tooltip": null, + "value": 2030 + } + }, + "4b664a7a57774f5ea1458a47dceea701": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57004e3b402a4b43b5fceb953888dd60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "DropdownModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "DropdownModel", + "_options_labels": [ + "none", + "rcp26", + "rcp45", + "rcp85" + ], + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "DropdownView", + "description": "CO2 scenario", + "description_allow_html": false, + "disabled": false, + "index": 2, + "layout": "IPY_MODEL_d6108c93bfe94f2880c1aeb5845a1289", + "style": "IPY_MODEL_2e8515695d034d36a1eafeae15237cef", + "tabbable": null, + "tooltip": null + } + }, + "6cdee2ca19cd4845b283b69fffc77bc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2c12cd340f1140d1a9880104d0a33c06", + "IPY_MODEL_d3fa736b327240efa39355a2b3be1265", + "IPY_MODEL_cefddc2efc6e4ebcb358f8d8eb1b2573", + "IPY_MODEL_57004e3b402a4b43b5fceb953888dd60", + "IPY_MODEL_171215d49a974170b092020fc443c71f", + "IPY_MODEL_3d27d97ec1f84a45990b83f9f96ecd73", + "IPY_MODEL_e73e78a0fe7f41c48a025b16a10c17fe", + "IPY_MODEL_2f3438cdb3094839afe01f50340941e8" + ], + "layout": "IPY_MODEL_2e384288190b44ec85816468e5ed4e93", + "tabbable": null, + "tooltip": null + } + }, + "773a9b77ccc7464d8823300ea0bc719e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + }, + "83ad52488aee4d36a04af304707cba1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + }, + "9ca98e182a534685ab16a9a8285ee2a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + }, + "af68ce45388a4a8e98002ac2215c1b6c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afa5038d7c194a15800eedb06224cbfd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + }, + "b044d31f52b9476f822b1b679210ac52": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cefddc2efc6e4ebcb358f8d8eb1b2573": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "FloatSliderView", + "behavior": "drag-tap", + "continuous_update": true, + "description": "gamma_ul [W/m2/K]", + "description_allow_html": false, + "disabled": false, + "layout": "IPY_MODEL_118b2208521a47639850c3a5303b40c1", + "max": 2, + "min": 0.1, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_afa5038d7c194a15800eedb06224cbfd", + "tabbable": null, + "tooltip": null, + "value": 0.7 + } + }, + "d3fa736b327240efa39355a2b3be1265": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "FloatSliderView", + "behavior": "drag-tap", + "continuous_update": true, + "description": "C_l [W.yr/m2/K]", + "description_allow_html": false, + "disabled": false, + "layout": "IPY_MODEL_af68ce45388a4a8e98002ac2215c1b6c", + "max": 600, + "min": 50, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 10, + "style": "IPY_MODEL_83ad52488aee4d36a04af304707cba1f", + "tabbable": null, + "tooltip": null, + "value": 322.0530706340907 + } + }, + "d6108c93bfe94f2880c1aeb5845a1289": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e73e78a0fe7f41c48a025b16a10c17fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "IntSliderView", + "behavior": "drag-tap", + "continuous_update": true, + "description": "Ramp-up years", + "description_allow_html": false, + "disabled": false, + "layout": "IPY_MODEL_4b664a7a57774f5ea1458a47dceea701", + "max": 30, + "min": 1, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 1, + "style": "IPY_MODEL_9ca98e182a534685ab16a9a8285ee2a8", + "tabbable": null, + "tooltip": null, + "value": 10 + } + }, + "f07dbd893e084990a4a3b2478153c91b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd689d4f069746d283d32d702bacd2cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/simpleModel.ipynb b/simpleModel.ipynb new file mode 100644 index 0000000..47b156e --- /dev/null +++ b/simpleModel.ipynb @@ -0,0 +1,572 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d06f4aea", + "metadata": {}, + "source": [ + "# Simple Energy Balance Model (EBM)\n", + "### Solar Geoengineering & CO₂ Forcing\n", + "\n", + "The model integrates the zero-dimensional EBM:\n", + "\n", + "$$C \\frac{dT}{dt} = S\\bigl(1 - \\alpha(t)\\bigr) - (a + bT) + F(t)$$\n", + "\n", + "| Symbol | Meaning | Units |\n", + "|--------|---------|-------|\n", + "| $C$ | Thermal inertia (ocean mixed-layer heat capacity) | W·yr/m²/°C |\n", + "| $T$ | Global mean surface temperature | °C |\n", + "| $S$ | Mean insolation ($S_0 / 4$) | W/m² |\n", + "| $\\alpha(t)$ | Planetary albedo — increased by SAI | — |\n", + "| $a + bT$ | Outgoing longwave radiation (Budyko linearization) | W/m² |\n", + "| $F(t)$ | CO₂ radiative forcing | W/m² |\n", + "\n", + "**SAI** raises $\\alpha(t)$ to offset $F(t)$; both are time-varying. The **energy imbalance** $Q = C\\,dT/dt$ tracks how heat uptake changes under each scenario." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "111ee865", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.integrate import solve_ivp\n", + "import ipywidgets as widgets\n", + "from ipywidgets import interact, FloatSlider, IntSlider, Dropdown\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "plt.rcParams.update({\n", + " 'figure.dpi': 110,\n", + " 'axes.spines.top': False,\n", + " 'axes.spines.right': False,\n", + " 'axes.grid': True,\n", + " 'grid.alpha': 0.3,\n", + " 'font.size': 11,\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b803d808", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OLR: a = -364.058 W/m², b = 2.09 W/m²/K\n", + "Equilibrium check → T_eq = 288.1500 K (target: 288.15 K)\n", + "Absorbed solar → 238.17 W/m²\n", + "OLR at T0 → 238.17 W/m²\n" + ] + } + ], + "source": [ + "# ── Physical constants ───────────────────────────────────────────────────────\n", + "S0 = 1361.0 # Solar constant [W/m²]\n", + "S = S0 / 4 # Sphere-averaged mean insolation [W/m²]\n", + "\n", + "# ── Pre-industrial baseline (1850) ───────────────────────────────────────────\n", + "alpha0 = 0.30 # Planetary albedo\n", + "T0 = 288.15 # Surface temperature [K] (≈ 15°C)\n", + "\n", + "# ── OLR linearization: OLR = a + b·T (Budyko 1969) ────────────────────────\n", + "b = 2.09 # OLR slope [W/m²/K]\n", + "a = S * (1 - alpha0) - b * T0 # Intercept tuned so T_eq = T0 exactly\n", + "\n", + "# ── Default thermal inertia (~70 m ocean mixed layer) ───────────────────────\n", + "C_DEFAULT = 8.0 # [W·yr/m²/K]\n", + "\n", + "print(f\"OLR: a = {a:.3f} W/m², b = {b} W/m²/K\")\n", + "print(f\"Equilibrium check → T_eq = {(S*(1-alpha0) - a)/b:.4f} K (target: {T0} K)\")\n", + "print(f\"Absorbed solar → {S*(1-alpha0):.2f} W/m²\")\n", + "print(f\"OLR at T0 → {a + b*T0:.2f} W/m²\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "be6373f4", + "metadata": {}, + "outputs": [], + "source": [ + "def co2_forcing(t, scenario='rcp45'):\n", + " \"\"\"\n", + " CO₂ radiative forcing relative to pre-industrial [W/m²].\n", + "\n", + " Historical (1850–2023): linear ramp 0 → 2.3 W/m² for all scenarios.\n", + " Post-2023 projections follow IPCC RCP pathways.\n", + " 'none' : no forcing at any time (pre-industrial control)\n", + " 'rcp26' : strong mitigation, peaks ~3.0 then declines\n", + " 'rcp45' : moderate stabilisation at 4.5 W/m²\n", + " 'rcp85' : high-emission pathway to 8.5 W/m²\n", + " \"\"\"\n", + " if scenario == 'none':\n", + " return 0.0\n", + "\n", + " # Historical ramp (identical for all scenarios)\n", + " if t <= 2023:\n", + " return float(np.interp(t, [1850, 2023], [0.0, 2.3]))\n", + "\n", + " # Post-2023 scenario divergence\n", + " # projections = {\n", + " # 'rcp26': ([2023, 2040, 2100, 2150], [2.3, 3.0, 2.6, 2.4]),\n", + " # 'rcp45': ([2023, 2100, 2150], [2.3, 4.5, 4.5]),\n", + " # 'rcp85': ([2023, 2100, 2150], [2.3, 8.5, 8.5]),\n", + " # }\n", + " projections = {\n", + " 'rcp26': ([2023, 2040, 2100, 2150], [2.3, 3.0, 2.6, 1.0]),\n", + " 'rcp45': ([2023, 2100, 2150], [2.3, 4.5, 6.5]),\n", + " 'rcp85': ([2023, 2100, 2150], [2.3, 8.5, 12.5]),\n", + " }\n", + " ts, Fs = projections[scenario]\n", + " return float(np.interp(t, ts, Fs))\n", + "\n", + "\n", + "def sai_delta_alpha(t, d_alpha=0.0, start_year=2030, ramp_years=10):\n", + " \"\"\"\n", + " Additional albedo from stratospheric aerosol injection (SAI) [dimensionless].\n", + "\n", + " Ramps linearly from start_year over ramp_years, then holds indefinitely.\n", + " d_alpha = 0.01 offsets roughly -3.4 W/m² of solar forcing.\n", + " \"\"\"\n", + " if d_alpha == 0.0 or t < start_year:\n", + " return 0.0\n", + " ramp_end = start_year + ramp_years\n", + " if t < ramp_end:\n", + " return d_alpha * (t - start_year) / ramp_years\n", + " return d_alpha\n", + "\n", + "\n", + "def energy_imbalance(t, T, d_alpha=0.0, scenario='rcp45', sai_start=2030, sai_ramp=10):\n", + " \"\"\"Net energy flux Q = S(1−α) − OLR + F [W/m²] (= C·dT/dt)\"\"\"\n", + " alpha = alpha0 + sai_delta_alpha(t, d_alpha=d_alpha, start_year=sai_start, ramp_years=sai_ramp)\n", + " F = co2_forcing(t, scenario=scenario)\n", + " return S * (1 - alpha) - (a + b * T) + F" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "33712c4a", + "metadata": {}, + "outputs": [], + "source": [ + "def run_ebm(C=C_DEFAULT, scenario='rcp45', d_alpha=0.0,\n", + " sai_start=2030, sai_ramp=10, t_span=(1850, 2150), n_pts=2400):\n", + " \"\"\"\n", + " Integrate C·dT/dt = Q(t, T) using RK45.\n", + "\n", + " Returns\n", + " -------\n", + " t : ndarray — time [years]\n", + " T : ndarray — temperature [°C]\n", + " Q : ndarray — energy imbalance [W/m²] (= C·dT/dt)\n", + " \"\"\"\n", + " kw = dict(d_alpha=d_alpha, scenario=scenario, sai_start=sai_start, sai_ramp=sai_ramp)\n", + "\n", + " def rhs(t, y):\n", + " return [energy_imbalance(t, y[0], **kw) / C]\n", + "\n", + " t_eval = np.linspace(*t_span, n_pts)\n", + " sol = solve_ivp(rhs, t_span, [T0], t_eval=t_eval, method='RK45', rtol=1e-8, atol=1e-10)\n", + "\n", + " Q = np.array([energy_imbalance(ti, Ti, **kw) for ti, Ti in zip(sol.t, sol.y[0])])\n", + " return sol.t, sol.y[0], Q" + ] + }, + { + "cell_type": "markdown", + "id": "9061f969", + "metadata": {}, + "source": [ + "## Scenario Comparison\n", + "**Left column** — CO₂ forcing only (no SAI), across four RCP pathways. \n", + "**Right column** — SAI at varying deployment levels under RCP 4.5. \n", + "Top row: temperature trajectory. Bottom row: energy imbalance $Q = C\\,dT/dt$." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fad235e5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 2, figsize=(14, 9), sharex=True)\n", + "fig.suptitle('EBM Scenario Comparison', fontsize=13, fontweight='bold', y=1.01)\n", + "\n", + "# ── CO₂ scenarios (no SAI) ───────────────────────────────────────────────────\n", + "co2_cases = [\n", + " ('none', 'Pre-industrial control', '#888888'),\n", + " ('rcp26', 'RCP 2.6 — strong mitigation', '#1a9641'),\n", + " ('rcp45', 'RCP 4.5 — moderate', '#fdae61'),\n", + " ('rcp85', 'RCP 8.5 — high emissions', '#d7191c'),\n", + "]\n", + "for scen, label, color in co2_cases:\n", + " t, T, Q = run_ebm(scenario=scen, d_alpha=0.0)\n", + " axes[0, 0].plot(t, T, color=color, lw=2, label=label)\n", + " axes[1, 0].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# ── SAI levels under RCP 4.5 ────────────────────────────────────────────────\n", + "sai_cases = [\n", + " (0.000, 'No SAI', '#d7191c'),\n", + " (0.005, 'SAI Δα = 0.005', '#fdae61'),\n", + " (0.010, 'SAI Δα = 0.010', '#74add1'),\n", + " (0.015, 'SAI Δα = 0.015', '#2c7bb6'),\n", + "]\n", + "for da, label, color in sai_cases:\n", + " t, T, Q = run_ebm(scenario='rcp45', d_alpha=da)\n", + " axes[0, 1].plot(t, T, color=color, lw=2, label=label)\n", + " axes[1, 1].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# ── Annotations ─────────────────────────────────────────────────────────────\n", + "for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.45, label='Present (2023)')\n", + "for ax in axes[:, 1]:\n", + " ax.axvline(2030, color='navy', ls=':', lw=1.5, alpha=0.55, label='SAI start (2030)')\n", + "for ax in axes[1, :]:\n", + " ax.axhline(0, color='k', ls='-', lw=0.8, alpha=0.3)\n", + "\n", + "axes[0, 0].set(title='Temperature — CO₂ pathways', ylabel='Temperature [K]')\n", + "axes[1, 0].set(title='Energy imbalance — CO₂ pathways', ylabel='Q [W/m²]', xlabel='Year')\n", + "axes[0, 1].set(title='Temperature — SAI levels (RCP 4.5)', ylabel='Temperature [K]')\n", + "axes[1, 1].set(title='Energy imbalance — SAI levels (RCP 4.5)', ylabel='Q [W/m²]', xlabel='Year')\n", + "\n", + "for ax in axes[0, :]:\n", + " ax.legend(fontsize=9)\n", + "for ax in axes[1, :]:\n", + " ax.legend(fontsize=8)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7f34c7f2", + "metadata": {}, + "source": [ + "## Interactive Exploration\n", + "\n", + "Use the sliders to explore how changing CO₂ pathway, SAI deployment, thermal inertia, and timing affect the temperature trajectory and energy imbalance in real time.\n", + "\n", + "The **forcing breakdown** (right panel) decomposes $Q$ into its CO₂ and SAI components so you can see when and how much each term contributes." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4440c258", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41157ee103f9441aacf97e210c8d3492", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=8.0, description='C [W·yr/m²/K]', max=20.0, min=2.0, step=0.5, style=S…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_ebm(C, scenario, d_alpha, sai_start, sai_ramp):\n", + " t_base, T_base, Q_base = run_ebm(C=C, scenario=scenario, d_alpha=0.0)\n", + " t_sai, T_sai, Q_sai = run_ebm(C=C, scenario=scenario, d_alpha=d_alpha,\n", + " sai_start=sai_start, sai_ramp=sai_ramp)\n", + "\n", + " fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n", + " fig.suptitle(f'EBM | {scenario.upper()} | C = {C:.1f} W·yr/m²/K', fontsize=12, fontweight='bold')\n", + "\n", + " # — Temperature ————————————————————————————————————————————————————————\n", + " axes[0].plot(t_base, T_base, color='#d7191c', lw=2, label='No SAI')\n", + " axes[0].plot(t_sai, T_sai, color='#2c7bb6', lw=2, label=f'SAI Δα = {d_alpha:.3f}')\n", + " axes[0].fill_between(t_sai, T_base, T_sai,\n", + " where=(T_sai < T_base), alpha=0.15, color='#2c7bb6', label='Cooling offset')\n", + " axes[0].set(title='Temperature', ylabel='T [K]', xlabel='Year')\n", + "\n", + " # — Energy imbalance ——————————————————————————————————————————————————\n", + " axes[1].plot(t_base, Q_base, color='#d7191c', lw=2, label='No SAI')\n", + " axes[1].plot(t_sai, Q_sai, color='#2c7bb6', lw=2, label=f'SAI Δα = {d_alpha:.3f}')\n", + " axes[1].axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " axes[1].set(title='Energy Imbalance Q = C·dT/dt', ylabel='W/m²', xlabel='Year')\n", + "\n", + " # — Energy balance decomposition ——————————————————————————————————————\n", + " # Q = F_CO2 + F_SAI + OLR_feedback\n", + " # = F(t) + (−S·Δα) + (−b·(T−T0))\n", + " # All three terms sum to Q (shown as black line, matching center panel).\n", + " # OLR feedback is the missing term that explains why Q can be negative\n", + " # even when the radiative forcings alone (F_CO2 + F_SAI) are positive.\n", + " F_co2_arr = np.array([co2_forcing(ti, scenario=scenario) for ti in t_sai])\n", + " F_sai_arr = np.array([-S * sai_delta_alpha(ti, d_alpha=d_alpha,\n", + " start_year=sai_start, ramp_years=sai_ramp)\n", + " for ti in t_sai])\n", + " OLR_fb_arr = -(b * (T_sai - T0)) # negative when T > T0; drives Q negative during overshoot\n", + "\n", + " Q_decomp = F_co2_arr + F_sai_arr + OLR_fb_arr # must equal Q_sai\n", + "\n", + " axes[2].fill_between(t_sai, F_co2_arr, alpha=0.35, color='#d7191c', label='CO₂ forcing F(t)')\n", + " axes[2].fill_between(t_sai, F_sai_arr, alpha=0.35, color='#2c7bb6', label='SAI forcing −S·Δα')\n", + " axes[2].fill_between(t_sai, OLR_fb_arr, alpha=0.35, color='#fdae61', label='OLR feedback −b·(T−T₀)')\n", + " axes[2].plot(t_sai, Q_decomp, 'k-', lw=1.8, label='Q (= center panel)')\n", + " axes[2].axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " axes[2].set(title='Energy Balance Decomposition\\nQ = F_CO₂ + F_SAI + OLR feedback',\n", + " ylabel='W/m²', xlabel='Year')\n", + "\n", + " for ax in axes:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " if d_alpha > 0:\n", + " ax.axvline(sai_start, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.legend(fontsize=8)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_ebm,\n", + " C = FloatSlider(value=8.0, min=2.0, max=20.0, step=0.5, description='C [W·yr/m²/K]', style={'description_width':'initial'}),\n", + " scenario = Dropdown(options=['none','rcp26','rcp45','rcp85'], value='rcp45', description='CO₂ scenario'),\n", + " d_alpha = FloatSlider(value=0.0, min=0.0, max=0.025, step=0.001, description='SAI Δα', style={'description_width':'initial'}, readout_format='.3f'),\n", + " sai_start = IntSlider( value=2030, min=2025, max=2080, step=5, description='SAI start year', style={'description_width':'initial'}),\n", + " sai_ramp = IntSlider( value=10, min=1, max=30, step=1, description='Ramp-up years', style={'description_width':'initial'}),\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "bba7fe2d", + "metadata": {}, + "source": [ + "## Thermal Inertia Sensitivity\n", + "\n", + "$C$ sets how quickly the system responds to forcing — larger $C$ (deeper ocean coupling) slows warming but also slows the response to SAI. Below: temperature and energy imbalance for five values of $C$ under RCP 4.5 with a moderate SAI deployment (Δα = 0.010)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2430ac73", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "C_values = [2.0, 4.0, 8.0, 12.0, 20.0]\n", + "colors = plt.cm.plasma(np.linspace(0.1, 0.85, len(C_values)))\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", + "fig.suptitle('Thermal Inertia Sensitivity (RCP 4.5, SAI Δα = 0.010, start 2030)',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + "for C_val, color in zip(C_values, colors):\n", + " t, T, Q = run_ebm(C=C_val, scenario='rcp45', d_alpha=0.010)\n", + " lbl = f'C = {C_val}'\n", + " axes[0].plot(t, T, color=color, lw=2, label=lbl)\n", + " axes[1].plot(t, Q, color=color, lw=2, label=lbl)\n", + "\n", + "for ax in axes:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4, label='Present')\n", + " ax.axvline(2030, color='gray', ls=':', lw=1.5, alpha=0.55, label='SAI start')\n", + "\n", + "axes[1].axhline(0, color='k', lw=0.8, alpha=0.35)\n", + "\n", + "axes[0].set(title='Temperature', ylabel='T [K]', xlabel='Year')\n", + "axes[1].set(title='Energy Imbalance Q', ylabel='W/m²', xlabel='Year')\n", + "\n", + "for ax in axes:\n", + " ax.legend(title='C [W·yr/m²/K]', fontsize=9)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1005eaab", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7672402ae4bd490cb2500c1d62dcaf2f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=8.0, description='C [W·yr/m²/K]', max=20.0, min=2.0, step=0.5, style=S…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ── SAI with post-ramp slope ──────────────────────────────────────────────────\n", + "# Redefines the sai_delta_alpha → energy_imbalance → run_ebm → plot_ebm chain\n", + "# to thread a d_alpha_slope parameter (increase in da per year after ramp).\n", + "\n", + "def sai_delta_alpha(t, d_alpha=0.0, start_year=2030, ramp_years=10, d_alpha_slope=0.0):\n", + " \"\"\"\n", + " Additional albedo from SAI.\n", + "\n", + " Phase 1 – pre-deployment [t < start_year]: 0\n", + " Phase 2 – ramp-up [start_year, start_year+ramp): linear 0 → d_alpha\n", + " Phase 3 – post-ramp [t >= start_year+ramp): d_alpha + d_alpha_slope*(t-ramp_end)\n", + " \"\"\"\n", + " if d_alpha == 0.0 or t < start_year:\n", + " return 0.0\n", + " ramp_end = start_year + ramp_years\n", + " if t < ramp_end:\n", + " return d_alpha * (t - start_year) / ramp_years\n", + " return d_alpha + d_alpha_slope * (t - ramp_end)\n", + "\n", + "\n", + "def energy_imbalance(t, T, d_alpha=0.0, scenario='rcp45',\n", + " sai_start=2030, sai_ramp=10, d_alpha_slope=0.0):\n", + " alpha = alpha0 + sai_delta_alpha(t, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " F = co2_forcing(t, scenario=scenario)\n", + " return S * (1 - alpha) - (a + b * T) + F\n", + "\n", + "\n", + "def run_ebm(C=C_DEFAULT, scenario='rcp45', d_alpha=0.0,\n", + " sai_start=2030, sai_ramp=10, d_alpha_slope=0.0,\n", + " t_span=(1850, 2150), n_pts=2400):\n", + " kw = dict(d_alpha=d_alpha, scenario=scenario, sai_start=sai_start,\n", + " sai_ramp=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + "\n", + " def rhs(t, y):\n", + " return [energy_imbalance(t, y[0], **kw) / C]\n", + "\n", + " t_eval = np.linspace(*t_span, n_pts)\n", + " sol = solve_ivp(rhs, t_span, [T0], t_eval=t_eval, method='RK45', rtol=1e-8, atol=1e-10)\n", + " Q = np.array([energy_imbalance(ti, Ti, **kw) for ti, Ti in zip(sol.t, sol.y[0])])\n", + " return sol.t, sol.y[0], Q\n", + "\n", + "\n", + "def plot_ebm(C, scenario, d_alpha, sai_start, sai_ramp, d_alpha_slope):\n", + " t_base, T_base, Q_base = run_ebm(C=C, scenario=scenario, d_alpha=0.0)\n", + " t_sai, T_sai, Q_sai = run_ebm(C=C, scenario=scenario, d_alpha=d_alpha,\n", + " sai_start=sai_start, sai_ramp=sai_ramp,\n", + " d_alpha_slope=d_alpha_slope)\n", + "\n", + " fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n", + " fig.suptitle(f'EBM | {scenario.upper()} | C = {C:.1f} W·yr/m²/K', fontsize=12, fontweight='bold')\n", + "\n", + " # — Temperature ————————————————————————————————————————————————————————\n", + " axes[0].plot(t_base, T_base, color='#d7191c', lw=2, label='No SAI')\n", + " axes[0].plot(t_sai, T_sai, color='#2c7bb6', lw=2,\n", + " label=f'SAI Δα={d_alpha:.3f}, slope={d_alpha_slope:.4f}/yr')\n", + " axes[0].fill_between(t_sai, T_base, T_sai,\n", + " where=(T_sai < T_base), alpha=0.15, color='#2c7bb6', label='Cooling offset')\n", + " axes[0].set(title='Temperature', ylabel='T [K]', xlabel='Year')\n", + "\n", + " # — Energy imbalance ——————————————————————————————————————————————————\n", + " axes[1].plot(t_base, Q_base, color='#d7191c', lw=2, label='No SAI')\n", + " axes[1].plot(t_sai, Q_sai, color='#2c7bb6', lw=2,\n", + " label=f'SAI Δα={d_alpha:.3f}, slope={d_alpha_slope:.4f}/yr')\n", + " axes[1].axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " axes[1].set(title='Energy Imbalance Q = C·dT/dt', ylabel='W/m²', xlabel='Year')\n", + "\n", + " # — Energy balance decomposition ——————————————————————————————————————\n", + " F_co2_arr = np.array([co2_forcing(ti, scenario=scenario) for ti in t_sai])\n", + " F_sai_arr = np.array([-S * sai_delta_alpha(ti, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " for ti in t_sai])\n", + " OLR_fb_arr = -(b * (T_sai - T0))\n", + " Q_decomp = F_co2_arr + F_sai_arr + OLR_fb_arr\n", + "\n", + " axes[2].fill_between(t_sai, F_co2_arr, alpha=0.35, color='#d7191c', label='CO₂ forcing F(t)')\n", + " axes[2].fill_between(t_sai, F_sai_arr, alpha=0.35, color='#2c7bb6', label='SAI forcing −S·Δα(t)')\n", + " axes[2].fill_between(t_sai, OLR_fb_arr, alpha=0.35, color='#fdae61', label='OLR feedback −b·(T−T₀)')\n", + " axes[2].plot(t_sai, Q_decomp, 'k-', lw=1.8, label='Q (= center panel)')\n", + " axes[2].axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " axes[2].set(title='Energy Balance Decomposition\\nQ = F_CO₂ + F_SAI + OLR feedback',\n", + " ylabel='W/m²', xlabel='Year')\n", + "\n", + " for ax in axes:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " if d_alpha > 0:\n", + " ax.axvline(sai_start, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.axvline(sai_start + sai_ramp, color='steelblue', ls=':', lw=1.0, alpha=0.5)\n", + " ax.legend(fontsize=8)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_ebm,\n", + " C = FloatSlider(value=8.0, min=2.0, max=20.0, step=0.5, description='C [W·yr/m²/K]', style={'description_width': 'initial'}),\n", + " scenario = Dropdown(options=['none', 'rcp26', 'rcp45', 'rcp85'], value='rcp45', description='CO₂ scenario'),\n", + " d_alpha = FloatSlider(value=0.0, min=0.0, max=0.025, step=0.001, description='SAI Δα', style={'description_width': 'initial'}, readout_format='.3f'),\n", + " sai_start = IntSlider( value=2030, min=2025, max=2080, step=5, description='SAI start year', style={'description_width': 'initial'}),\n", + " sai_ramp = IntSlider( value=10, min=1, max=30, step=1, description='Ramp-up years', style={'description_width': 'initial'}),\n", + " d_alpha_slope= FloatSlider(value=0.0, min=0.0, max=0.0005, step=0.00001, description='Post-ramp slope (da/yr)', style={'description_width': 'initial'}, readout_format='.4f'),\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53c19f89", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "baseEnv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 15e2e28ee024e0e819e22c41c4a8c5d71e60d673 Mon Sep 17 00:00:00 2001 From: wk2500 <97990166+wk2500@users.noreply.github.com> Date: Thu, 18 Jun 2026 11:52:47 -0600 Subject: [PATCH 6/9] Add files via upload 2-layer model added which in theory is closest to what we want. Parameters are not tuned --- TwoLayerModel.ipynb | 498 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 498 insertions(+) create mode 100644 TwoLayerModel.ipynb diff --git a/TwoLayerModel.ipynb b/TwoLayerModel.ipynb new file mode 100644 index 0000000..09f31a7 --- /dev/null +++ b/TwoLayerModel.ipynb @@ -0,0 +1,498 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1b2c3d4", + "metadata": {}, + "source": [ + "# Two-Layer Energy Balance Model (EBM)\n", + "### Atmosphere · Ocean (combined, full depth)\n", + "\n", + "A two-layer extension of the zero-dimensional EBM with an **atmosphere** and a **single\n", + "combined ocean layer** (0 – ~3700 m). The upper and lower ocean are merged into one\n", + "reservoir, so only the single timescale of atmosphere ↔ ocean exchange appears:\n", + "\n", + "$$C_a\\frac{dT_a}{dt} = S\\bigl(1-\\alpha(t)\\bigr) - (a + bT_a) + F(t) - \\gamma_{ao}(T_a - T_o)$$\n", + "$$C_o\\frac{dT_o}{dt} = \\gamma_{ao}(T_a - T_o)$$\n", + "\n", + "| Symbol | Meaning | Units |\n", + "|--------|---------|-------|\n", + "| $T_a,\\,T_o$ | Atmosphere / ocean temperature | K |\n", + "| $C_a$ | Atmospheric-column heat capacity | W·yr/m²/°C |\n", + "| $C_o$ | Full-column ocean heat capacity | W·yr/m²/°C |\n", + "| $\\gamma_{ao}$ | Atmosphere ↔ ocean heat exchange | W/m²/°C |\n", + "| $S,\\ \\alpha(t),\\ a+bT,\\ F(t)$ | Insolation, albedo, OLR, CO₂ forcing | as in the single-layer model |\n", + "\n", + "Only the atmosphere exchanges radiation with space, so the CO₂ forcing $F$ and the SAI\n", + "albedo offset act on $T_a$; heat then flows into the ocean via $\\gamma_{ao}$. At\n", + "equilibrium both layers converge to the same temperature — identical to the single-layer\n", + "EBM result." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b2c3d4e5", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.integrate import solve_ivp\n", + "import ipywidgets as widgets\n", + "from ipywidgets import interact, FloatSlider, IntSlider, Dropdown\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "plt.rcParams.update({\n", + " 'figure.dpi': 110,\n", + " 'axes.spines.top': False,\n", + " 'axes.spines.right': False,\n", + " 'axes.grid': True,\n", + " 'grid.alpha': 0.3,\n", + " 'font.size': 11,\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c3d4e5f6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OLR: a = -364.058 W/m2, b = 2.09 W/m2/K\n", + "Heat capacities [W.yr/m2/K]: C_a = 0.329 C_o = 340.5\n", + "Response timescales: atmosphere ~ 0.027 yr ocean ~ 34 yr\n", + "Equilibrium check -> T_eq = 288.1500 K (target: 288.15 K)\n" + ] + } + ], + "source": [ + "# == Physical constants =======================================================\n", + "S0 = 1361.0 # Solar constant [W/m2]\n", + "S = S0 / 4 # Sphere-averaged mean insolation [W/m2]\n", + "\n", + "# == Pre-industrial baseline (1850) ===========================================\n", + "alpha0 = 0.30 # Planetary albedo\n", + "T0 = 288.15 # Surface temperature [K] (~15 C)\n", + "\n", + "# == OLR linearization: OLR = a + b*T (Budyko 1969) ==========================\n", + "b = 2.09 # OLR slope [W/m2/K]\n", + "a = S * (1 - alpha0) - b * T0 # Intercept tuned so T_eq = T0 exactly\n", + "\n", + "# == Layer heat capacities ====================================================\n", + "RHO_W = 1025.0 # seawater density [kg/m3]\n", + "CP_W = 3990.0 # seawater heat capacity [J/kg/K]\n", + "F_OCEAN = 0.71 # ocean fraction of Earth's surface\n", + "CP_AIR = 1004.0 # air heat capacity [J/kg/K]\n", + "P_SURF = 1.01325e5 # surface pressure [Pa]\n", + "G_GRAV = 9.81 # gravity [m/s2]\n", + "SEC_PER_YR = 3.1557e7\n", + "\n", + "OCEAN_DEPTH = 3700.0 # combined ocean thickness [m] (0–3700 m)\n", + "\n", + "def ocean_layer_C(depth_m, f_ocean=F_OCEAN):\n", + " \"\"\"Heat capacity per m2 of Earth for an ocean layer [W.yr/m2/K].\"\"\"\n", + " return RHO_W * CP_W * depth_m * f_ocean / SEC_PER_YR\n", + "\n", + "C_ATMOS = CP_AIR * P_SURF / G_GRAV / SEC_PER_YR # atmospheric column\n", + "C_OCEAN = ocean_layer_C(OCEAN_DEPTH) # combined ocean layer\n", + "\n", + "# == Atmosphere <-> ocean heat-exchange coefficient [W/m2/K] ==================\n", + "GAMMA_AO = 10.0 # atmosphere <-> ocean (air-sea coupling)\n", + "\n", + "print(f\"OLR: a = {a:.3f} W/m2, b = {b} W/m2/K\")\n", + "print(f\"Heat capacities [W.yr/m2/K]: C_a = {C_ATMOS:.3f} C_o = {C_OCEAN:.1f}\")\n", + "print(f\"Response timescales: atmosphere ~ {C_ATMOS/(b+GAMMA_AO):.3f} yr \"\n", + " f\"ocean ~ {C_OCEAN/GAMMA_AO:.0f} yr\")\n", + "print(f\"Equilibrium check -> T_eq = {(S*(1-alpha0) - a)/b:.4f} K (target: {T0} K)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d4e5f6a7", + "metadata": {}, + "outputs": [], + "source": [ + "def co2_forcing(t, scenario='rcp45'):\n", + " \"\"\"\n", + " CO2 radiative forcing relative to pre-industrial [W/m2].\n", + "\n", + " Historical (1850-2023): linear ramp 0 -> 2.3 W/m2 for all scenarios.\n", + " Post-2023 projections follow IPCC RCP pathways.\n", + " \"\"\"\n", + " if scenario == 'none':\n", + " return 0.0\n", + "\n", + " # Historical ramp (identical for all scenarios)\n", + " if t <= 2023:\n", + " return float(np.interp(t, [1850, 2023], [0.0, 2.3]))\n", + "\n", + " # Post-2023 scenario divergence\n", + " projections = {\n", + " 'rcp26': ([2023, 2040, 2100, 2150], [2.3, 3.0, 2.6, 1.0]),\n", + " 'rcp45': ([2023, 2100, 2150], [2.3, 4.5, 6.5]),\n", + " 'rcp85': ([2023, 2100, 2150], [2.3, 8.5, 12.5]),\n", + " }\n", + " ts, Fs = projections[scenario]\n", + " return float(np.interp(t, ts, Fs))\n", + "\n", + "\n", + "def sai_delta_alpha(t, d_alpha=0.0, start_year=2030, ramp_years=10, d_alpha_slope=0.0):\n", + " \"\"\"\n", + " Albedo offset from stratospheric aerosol injection (SAI).\n", + "\n", + " Phase 1 – pre-deployment [t < start_year]: 0\n", + " Phase 2 – ramp-up [start_year, start_year+ramp): linear 0 -> d_alpha\n", + " Phase 3 – post-ramp [t >= start_year+ramp): d_alpha + d_alpha_slope*(t-ramp_end)\n", + " \"\"\"\n", + " if d_alpha == 0.0 or t < start_year:\n", + " return 0.0\n", + " ramp_end = start_year + ramp_years\n", + " if t < ramp_end:\n", + " return d_alpha * (t - start_year) / ramp_years\n", + " return d_alpha + d_alpha_slope * (t - ramp_end)\n", + "\n", + "\n", + "def net_toa_imbalance(t, Ta, d_alpha=0.0, scenario='rcp45',\n", + " sai_start=2030, sai_ramp=10, d_alpha_slope=0.0):\n", + " \"\"\"Net top-of-atmosphere radiative flux S(1-alpha) - (a + b*Ta) + F [W/m2].\"\"\"\n", + " alpha = alpha0 + sai_delta_alpha(t, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " F = co2_forcing(t, scenario=scenario)\n", + " return S * (1 - alpha) - (a + b * Ta) + F\n", + "\n", + "\n", + "def layer_derivs(t, y, C_a, C_o, gamma_ao,\n", + " d_alpha=0.0, scenario='rcp45', sai_start=2030, sai_ramp=10, d_alpha_slope=0.0):\n", + " \"\"\"\n", + " Right-hand side of the two-layer system. y = [T_a, T_o].\n", + "\n", + " Atmosphere sees the net TOA radiation and exchanges heat with the ocean;\n", + " the single ocean layer absorbs whatever the atmosphere passes down.\n", + " \"\"\"\n", + " Ta, To = y\n", + " R = net_toa_imbalance(t, Ta, d_alpha, scenario, sai_start, sai_ramp, d_alpha_slope)\n", + " f_ao = gamma_ao * (Ta - To) # atmosphere -> ocean\n", + " return [(R - f_ao) / C_a,\n", + " (f_ao) / C_o]\n", + "\n", + "\n", + "def run_ebm(C_a=C_ATMOS, C_o=C_OCEAN,\n", + " gamma_ao=GAMMA_AO,\n", + " scenario='rcp45', d_alpha=0.0, sai_start=2030, sai_ramp=10,\n", + " d_alpha_slope=0.0, t_span=(1850, 2150), n_pts=2400):\n", + " \"\"\"\n", + " Integrate the two-layer EBM.\n", + "\n", + " The system spans timescales from days (atmosphere) to centuries (ocean),\n", + " so it is stiff -> solved with the implicit BDF method.\n", + "\n", + " Returns\n", + " -------\n", + " t : time [years]\n", + " Ta : atmospheric temperature [K]\n", + " To : ocean temperature [K]\n", + " Q : net TOA energy imbalance [W/m2]\n", + " \"\"\"\n", + " kw = dict(d_alpha=d_alpha, scenario=scenario, sai_start=sai_start,\n", + " sai_ramp=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " args = (C_a, C_o, gamma_ao)\n", + "\n", + " t_eval = np.linspace(*t_span, n_pts)\n", + " sol = solve_ivp(lambda t, y: layer_derivs(t, y, *args, **kw),\n", + " t_span, [T0, T0], t_eval=t_eval,\n", + " method='BDF', rtol=1e-8, atol=1e-10)\n", + "\n", + " Ta, To = sol.y\n", + " Q = np.array([net_toa_imbalance(ti, Ta_i, **kw) for ti, Ta_i in zip(sol.t, Ta)])\n", + " return sol.t, Ta, To, Q" + ] + }, + { + "cell_type": "markdown", + "id": "e5f6a7b8", + "metadata": {}, + "source": [ + "## Scenario Comparison\n", + "\n", + "**Left column** — CO₂ forcing only (no SAI), across four RCP pathways.\n", + "**Right column** — SAI at varying deployment levels under RCP 4.5.\n", + "\n", + "Rows (top → bottom): **atmospheric temperature** $T_a$, **ocean** temperature change\n", + "$\\Delta T_o$, and the **energy imbalance** $Q$ (net TOA flux)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f6a7b8c9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(3, 2, figsize=(14, 12), sharex=True)\n", + "fig.suptitle('Two-Layer EBM - Scenario Comparison', fontsize=13, fontweight='bold', y=1.003)\n", + "\n", + "# -- CO2 scenarios (no SAI), left column --------------------------------------\n", + "co2_cases = [\n", + " ('none', 'Pre-industrial control', '#888888'),\n", + " ('rcp26', 'RCP 2.6 - strong mitigation', '#1a9641'),\n", + " ('rcp45', 'RCP 4.5 - moderate', '#fdae61'),\n", + " ('rcp85', 'RCP 8.5 - high emissions', '#d7191c'),\n", + "]\n", + "for scen, label, color in co2_cases:\n", + " t, Ta, To, Q = run_ebm(scenario=scen, d_alpha=0.0)\n", + " axes[0, 0].plot(t, Ta, color=color, lw=2, label=label)\n", + " axes[1, 0].plot(t, To - T0, color=color, lw=2, label=label)\n", + " axes[2, 0].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# -- SAI levels under RCP 4.5, right column -----------------------------------\n", + "sai_cases = [\n", + " (0.000, 'No SAI', '#d7191c'),\n", + " (0.005, 'SAI da = 0.005', '#fdae61'),\n", + " (0.010, 'SAI da = 0.010', '#74add1'),\n", + " (0.015, 'SAI da = 0.015', '#2c7bb6'),\n", + "]\n", + "for da, label, color in sai_cases:\n", + " t, Ta, To, Q = run_ebm(scenario='rcp45', d_alpha=da)\n", + " axes[0, 1].plot(t, Ta, color=color, lw=2, label=label)\n", + " axes[1, 1].plot(t, To - T0, color=color, lw=2, label=label)\n", + " axes[2, 1].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# -- Annotations --------------------------------------------------------------\n", + "for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.45)\n", + "for ax in axes[:, 1]:\n", + " ax.axvline(2030, color='navy', ls=':', lw=1.5, alpha=0.55)\n", + "for ax in list(axes[1, :]) + list(axes[2, :]):\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "\n", + "axes[0, 0].set(title='Atmospheric temperature - CO2 pathways', ylabel='T_a [K]')\n", + "axes[0, 1].set(title='Atmospheric temperature - SAI levels (RCP 4.5)', ylabel='T_a [K]')\n", + "axes[1, 0].set(title='Ocean temperature change - CO2 pathways', ylabel='dT_o [K]')\n", + "axes[1, 1].set(title='Ocean temperature change - SAI levels', ylabel='dT_o [K]')\n", + "axes[2, 0].set(title='Energy imbalance - CO2 pathways', ylabel='Q [W/m2]', xlabel='Year')\n", + "axes[2, 1].set(title='Energy imbalance - SAI levels', ylabel='Q [W/m2]', xlabel='Year')\n", + "\n", + "axes[0, 0].legend(fontsize=9)\n", + "axes[0, 1].legend(fontsize=9)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a7b8c9d0", + "metadata": {}, + "source": [ + "## Interactive Exploration\n", + "\n", + "Adjust the ocean heat capacity, the atmosphere–ocean coupling $\\gamma_{ao}$, the CO₂\n", + "pathway, and the SAI deployment to see how each shapes the response in real time.\n", + "\n", + "- **Top-left** — atmospheric temperature, with the SAI cooling offset shaded.\n", + "- **Top-right** — ocean temperature change.\n", + "- **Bottom-left** — net TOA energy imbalance $Q$ and the **ocean heat uptake** $\\gamma_{ao}(T_a-T_o)$.\n", + "- **Bottom-right** — energy-balance decomposition $Q = F_{\\mathrm{CO_2}} + F_{\\mathrm{SAI}} +$ OLR feedback." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b8c9d0e1", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e127bdac94d1401b957ddf22275f177b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=340.456103241753, description='C_o [W.yr/m2/K]', max=700.0, min=50.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_ebm(C_o, gamma_ao, scenario, d_alpha, sai_start, sai_ramp, d_alpha_slope):\n", + " t_b, Ta_b, To_b, Q_b = run_ebm(C_o=C_o, gamma_ao=gamma_ao,\n", + " scenario=scenario, d_alpha=0.0)\n", + " t_s, Ta_s, To_s, Q_s = run_ebm(C_o=C_o, gamma_ao=gamma_ao,\n", + " scenario=scenario, d_alpha=d_alpha,\n", + " sai_start=sai_start, sai_ramp=sai_ramp,\n", + " d_alpha_slope=d_alpha_slope)\n", + "\n", + " fig, axes = plt.subplots(2, 2, figsize=(15, 9))\n", + " fig.suptitle(f'Two-Layer EBM | {scenario.upper()} | '\n", + " f'C_o={C_o:.0f} W.yr/m2/K, gamma_ao={gamma_ao:.2f}',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + " # -- Atmospheric temperature -----------------------------------------------\n", + " ax = axes[0, 0]\n", + " ax.plot(t_b, Ta_b, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, Ta_s, color='#2c7bb6', lw=2,\n", + " label=f'SAI da={d_alpha:.3f}, slope={d_alpha_slope:.4f}/yr')\n", + " ax.fill_between(t_s, Ta_b, Ta_s, where=(Ta_s < Ta_b),\n", + " alpha=0.15, color='#2c7bb6', label='Cooling offset')\n", + " ax.set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "\n", + " # -- Ocean temperature change ----------------------------------------------\n", + " ax = axes[0, 1]\n", + " ax.plot(t_b, To_b - T0, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, To_s - T0, color='#2c7bb6', lw=2, label='SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Ocean temperature change', ylabel='dT_o [K]', xlabel='Year')\n", + "\n", + " # -- Energy imbalance + ocean heat uptake ----------------------------------\n", + " ax = axes[1, 0]\n", + " ax.plot(t_b, Q_b, color='#d7191c', lw=2, label='Q (TOA), no SAI')\n", + " ax.plot(t_s, Q_s, color='#2c7bb6', lw=2, label='Q (TOA), SAI')\n", + " ax.plot(t_b, gamma_ao * (Ta_b - To_b), color=\"#fe9408\", lw=1.3, ls=':', label='Ocean uptake, no SAI')\n", + " ax.plot(t_s, gamma_ao * (Ta_s - To_s), color=\"#00fad5\", lw=1.3, ls=':', label='Ocean uptake, SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy imbalance & ocean heat uptake', ylabel='W/m2', xlabel='Year')\n", + "\n", + " # -- Energy-balance decomposition -----------------------------------------\n", + " ax = axes[1, 1]\n", + " F_co2 = np.array([co2_forcing(ti, scenario=scenario) for ti in t_s])\n", + " F_sai = np.array([-S * sai_delta_alpha(ti, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " for ti in t_s])\n", + " OLR_fb = -(b * (Ta_s - T0))\n", + " Q_dec = F_co2 + F_sai + OLR_fb\n", + " ax.fill_between(t_s, F_co2, alpha=0.35, color='#d7191c', label='CO2 forcing F(t)')\n", + " ax.fill_between(t_s, F_sai, alpha=0.35, color='#2c7bb6', label='SAI forcing -S*da(t)')\n", + " ax.fill_between(t_s, OLR_fb, alpha=0.35, color='#fdae61', label='OLR feedback -b(Ta-T0)')\n", + " ax.plot(t_s, Q_dec, 'k-', lw=1.6, label='Q (sum)')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy balance decomposition (SAI run)', ylabel='W/m2', xlabel='Year')\n", + "\n", + " for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " if d_alpha > 0:\n", + " ax.axvline(sai_start, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.axvline(sai_start + sai_ramp, color='steelblue', ls=':', lw=1.0, alpha=0.5)\n", + " ax.legend(fontsize=8)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_ebm,\n", + " C_o = FloatSlider(value=C_OCEAN, min=50.0, max=700.0, step=10.0, description='C_o [W.yr/m2/K]', style={'description_width': 'initial'}),\n", + " gamma_ao = FloatSlider(value=GAMMA_AO, min=0.5, max=20.0, step=0.5, description='gamma_ao [W/m2/K]', style={'description_width': 'initial'}, readout_format='.2f'),\n", + " scenario = Dropdown(options=['none', 'rcp26', 'rcp45', 'rcp85'], value='rcp45', description='CO2 scenario'),\n", + " d_alpha = FloatSlider(value=0.0, min=0.0, max=0.025, step=0.001, description='SAI da', style={'description_width': 'initial'}, readout_format='.3f'),\n", + " sai_start = IntSlider( value=2030, min=2025, max=2080, step=5, description='SAI start year', style={'description_width': 'initial'}),\n", + " sai_ramp = IntSlider( value=10, min=1, max=30, step=1, description='Ramp-up years', style={'description_width': 'initial'}),\n", + " d_alpha_slope= FloatSlider(value=0.0, min=0.0, max=0.0005, step=0.00001, description='Post-ramp slope (da/yr)', style={'description_width': 'initial'}, readout_format='.4f'),\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "c9d0e1f2", + "metadata": {}, + "source": [ + "## Ocean Coupling Sensitivity\n", + "\n", + "The key tunable parameter in this model is $\\gamma_{ao}$, which controls how quickly\n", + "heat transfers from the atmosphere to the ocean. A larger $\\gamma_{ao}$ couples\n", + "the layers more tightly, giving a faster ocean response and a smaller persistent\n", + "energy imbalance $Q$. Below: both layers' responses for five values of $\\gamma_{ao}$\n", + "under RCP 4.5 with a moderate SAI deployment ($\\Delta\\alpha = 0.010$)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d0e1f2a3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gamma_values = [1.0, 3.0, 5.0, 10.0, 15.0]\n", + "colors = plt.cm.viridis(np.linspace(0.1, 0.85, len(gamma_values)))\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n", + "fig.suptitle('Ocean Coupling Sensitivity (RCP 4.5, SAI da = 0.010, start 2030)',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + "for g, color in zip(gamma_values, colors):\n", + " t, Ta, To, Q = run_ebm(scenario='rcp45', d_alpha=0.010, gamma_ao=g)\n", + " axes[0].plot(t, Ta, color=color, lw=2, label=f'gamma_ao = {g}')\n", + " axes[1].plot(t, To - T0, color=color, lw=2)\n", + " axes[2].plot(t, Q, color=color, lw=2)\n", + "\n", + "for ax in axes:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " ax.axvline(2030, color='gray', ls=':', lw=1.5, alpha=0.55)\n", + "axes[1].axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "axes[2].axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "\n", + "axes[0].set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "axes[1].set(title='Ocean temperature change', ylabel='dT_o [K]', xlabel='Year')\n", + "axes[2].set(title='Energy imbalance Q', ylabel='W/m2', xlabel='Year')\n", + "\n", + "axes[0].legend(title='Coupling', fontsize=9)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "baseEnv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 96be58e6cd9188eb790c10515f815eede58f6b14 Mon Sep 17 00:00:00 2001 From: wk2500 <97990166+wk2500@users.noreply.github.com> Date: Wed, 19 Aug 2026 14:45:01 -0400 Subject: [PATCH 7/9] Added ASR vs OLR plot --- TwoLayerModel.ipynb | 128 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 124 insertions(+), 4 deletions(-) diff --git a/TwoLayerModel.ipynb b/TwoLayerModel.ipynb index 09f31a7..4f474bb 100644 --- a/TwoLayerModel.ipynb +++ b/TwoLayerModel.ipynb @@ -310,20 +310,21 @@ "\n", "- **Top-left** — atmospheric temperature, with the SAI cooling offset shaded.\n", "- **Top-right** — ocean temperature change.\n", - "- **Bottom-left** — net TOA energy imbalance $Q$ and the **ocean heat uptake** $\\gamma_{ao}(T_a-T_o)$.\n", - "- **Bottom-right** — energy-balance decomposition $Q = F_{\\mathrm{CO_2}} + F_{\\mathrm{SAI}} +$ OLR feedback." + "- **Middle-left** — net TOA energy imbalance $Q$ and the **ocean heat uptake** $\\gamma_{ao}(T_a-T_o)$.\n", + "- **Middle-right** — energy-balance decomposition $Q = F_{\\mathrm{CO_2}} + F_{\\mathrm{SAI}} +$ OLR feedback.\n", + "- **Bottom** — incoming shortwave $S(1-\\alpha(t))$ vs. OLR $(a+bT_a)$ for the SAI run, each point colored by year (viridis). Points above the dashed $Q=0$ line indicate a net energy gain." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "b8c9d0e1", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e127bdac94d1401b957ddf22275f177b", + "model_id": "2a9001d766154df8991e8beee55f4a7f", "version_major": 2, "version_minor": 0 }, @@ -336,6 +337,125 @@ } ], "source": [ + "def plot_ebm(C_o, gamma_ao, scenario, d_alpha, sai_start, sai_ramp, d_alpha_slope):\n", + " t_b, Ta_b, To_b, Q_b = run_ebm(C_o=C_o, gamma_ao=gamma_ao,\n", + " scenario=scenario, d_alpha=0.0)\n", + " t_s, Ta_s, To_s, Q_s = run_ebm(C_o=C_o, gamma_ao=gamma_ao,\n", + " scenario=scenario, d_alpha=d_alpha,\n", + " sai_start=sai_start, sai_ramp=sai_ramp,\n", + " d_alpha_slope=d_alpha_slope)\n", + "\n", + " fig = plt.figure(figsize=(15, 13))\n", + " gs = fig.add_gridspec(3, 2, height_ratios=[1, 1, 1.15], hspace=0.4)\n", + " axes = np.array([[fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[0, 1])],\n", + " [fig.add_subplot(gs[1, 0]), fig.add_subplot(gs[1, 1])]])\n", + " ax5 = fig.add_subplot(gs[2, :])\n", + "\n", + " fig.suptitle(f'Two-Layer EBM | {scenario.upper()} | '\n", + " f'C_o={C_o:.0f} W.yr/m2/K, gamma_ao={gamma_ao:.2f}',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + " # -- Atmospheric temperature -----------------------------------------------\n", + " ax = axes[0, 0]\n", + " ax.plot(t_b, Ta_b, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, Ta_s, color='#2c7bb6', lw=2,\n", + " label=f'SAI da={d_alpha:.3f}, slope={d_alpha_slope:.4f}/yr')\n", + " ax.fill_between(t_s, Ta_b, Ta_s, where=(Ta_s < Ta_b),\n", + " alpha=0.15, color='#2c7bb6', label='Cooling offset')\n", + " ax.set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "\n", + " # -- Ocean temperature change ----------------------------------------------\n", + " ax = axes[0, 1]\n", + " ax.plot(t_b, To_b - T0, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, To_s - T0, color='#2c7bb6', lw=2, label='SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Ocean temperature change', ylabel='dT_o [K]', xlabel='Year')\n", + "\n", + " # -- Energy imbalance + ocean heat uptake ----------------------------------\n", + " ax = axes[1, 0]\n", + " ax.plot(t_b, Q_b, color='#d7191c', lw=2, label='Q (TOA), no SAI')\n", + " ax.plot(t_s, Q_s, color='#2c7bb6', lw=2, label='Q (TOA), SAI')\n", + " ax.plot(t_b, gamma_ao * (Ta_b - To_b), color=\"#fe9408\", lw=1.3, ls=':', label='Ocean uptake, no SAI')\n", + " ax.plot(t_s, gamma_ao * (Ta_s - To_s), color=\"#00fad5\", lw=1.3, ls=':', label='Ocean uptake, SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy imbalance & ocean heat uptake', ylabel='W/m2', xlabel='Year')\n", + "\n", + " # -- Energy-balance decomposition -----------------------------------------\n", + " ax = axes[1, 1]\n", + " F_co2 = np.array([co2_forcing(ti, scenario=scenario) for ti in t_s])\n", + " F_sai = np.array([-S * sai_delta_alpha(ti, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " for ti in t_s])\n", + " OLR_fb = -(b * (Ta_s - T0))\n", + " Q_dec = F_co2 + F_sai + OLR_fb\n", + " ax.fill_between(t_s, F_co2, alpha=0.35, color='#d7191c', label='CO2 forcing F(t)')\n", + " ax.fill_between(t_s, F_sai, alpha=0.35, color='#2c7bb6', label='SAI forcing -S*da(t)')\n", + " ax.fill_between(t_s, OLR_fb, alpha=0.35, color='#fdae61', label='OLR feedback -b(Ta-T0)')\n", + " ax.plot(t_s, Q_dec, 'k-', lw=1.6, label='Q (sum)')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy balance decomposition (SAI run)', ylabel='W/m2', xlabel='Year')\n", + "\n", + " for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " if d_alpha > 0:\n", + " ax.axvline(sai_start, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.axvline(sai_start + sai_ramp, color='steelblue', ls=':', lw=1.0, alpha=0.5)\n", + " ax.legend(fontsize=8)\n", + "\n", + " # -- Incoming shortwave vs. OLR, colored by year (SAI run) -----------------\n", + " alpha_s = alpha0 + np.array([sai_delta_alpha(ti, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " for ti in t_s])\n", + " S_in = S * (1 - alpha_s)\n", + " OLR_s = a + b * Ta_s\n", + "\n", + " lims = [min(OLR_s.min(), S_in.min()), max(OLR_s.max(), S_in.max())]\n", + " ax5.plot(lims, lims, color='k', lw=0.8, ls='--', alpha=0.4, label='S(1-a) = OLR (Q = 0)')\n", + " sc = ax5.scatter(OLR_s, S_in, c=t_s, cmap='viridis', s=14, edgecolor='none')\n", + " fig.colorbar(sc, ax=ax5, label='Year', pad=0.01)\n", + " ax5.set(title='Incoming shortwave vs. OLR (SAI run)',\n", + " xlabel='OLR = a + b*T_a [W/m2]', ylabel='S(1 - alpha(t)) [W/m2]')\n", + " ax5.legend(fontsize=8, loc='upper left')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_ebm,\n", + " C_o = FloatSlider(value=C_OCEAN, min=50.0, max=700.0, step=10.0, description='C_o [W.yr/m2/K]', style={'description_width': 'initial'}),\n", + " gamma_ao = FloatSlider(value=GAMMA_AO, min=0.5, max=20.0, step=0.5, description='gamma_ao [W/m2/K]', style={'description_width': 'initial'}, readout_format='.2f'),\n", + " scenario = Dropdown(options=['none', 'rcp26', 'rcp45', 'rcp85'], value='rcp45', description='CO2 scenario'),\n", + " d_alpha = FloatSlider(value=0.0, min=0.0, max=0.025, step=0.001, description='SAI da', style={'description_width': 'initial'}, readout_format='.3f'),\n", + " sai_start = IntSlider( value=2030, min=2025, max=2080, step=5, description='SAI start year', style={'description_width': 'initial'}),\n", + " sai_ramp = IntSlider( value=10, min=1, max=30, step=1, description='Ramp-up years', style={'description_width': 'initial'}),\n", + " d_alpha_slope= FloatSlider(value=0.0, min=0.0, max=0.0005, step=0.00001, description='Post-ramp slope (da/yr)', style={'description_width': 'initial'}, readout_format='.4f'),\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "afe95e66", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f66117de772f49ca8e62f5a2513b14c1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=340.456103241753, description='C_o [W.yr/m2/K]', max=700.0, min=50.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Old version with no scatter plot of ASR vs OLR\n", "def plot_ebm(C_o, gamma_ao, scenario, d_alpha, sai_start, sai_ramp, d_alpha_slope):\n", " t_b, Ta_b, To_b, Q_b = run_ebm(C_o=C_o, gamma_ao=gamma_ao,\n", " scenario=scenario, d_alpha=0.0)\n", From 1ad7efe3af7f0965df880d8e69c87fd65ae0bb33 Mon Sep 17 00:00:00 2001 From: wk2500 <97990166+wk2500@users.noreply.github.com> Date: Wed, 26 Aug 2026 13:54:15 -0400 Subject: [PATCH 8/9] Added updated model that uses emissivity and CO2 Now uses emissivity and real values for CO2, which are included in the new data subdirectory --- TwoLayerModel_VarEm.ipynb | 879 +++++++++++++++++++++++++++ data/co2_historical_1850_2023.csv | 175 ++++++ data/co2_ssp_scenarios_2024_2100.csv | 78 +++ 3 files changed, 1132 insertions(+) create mode 100644 TwoLayerModel_VarEm.ipynb create mode 100644 data/co2_historical_1850_2023.csv create mode 100644 data/co2_ssp_scenarios_2024_2100.csv diff --git a/TwoLayerModel_VarEm.ipynb b/TwoLayerModel_VarEm.ipynb new file mode 100644 index 0000000..32fe4db --- /dev/null +++ b/TwoLayerModel_VarEm.ipynb @@ -0,0 +1,879 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "42ba55cb", + "metadata": {}, + "source": [ + "# Two-Layer Energy Balance Model (EBM) — Variable Atmospheric Emissivity\n", + "### Atmosphere · Ocean (combined, full depth)\n", + "\n", + "This is a variant of the two-layer EBM in `TwoLayerModel.ipynb`. Everything about the\n", + "model geometry, ocean heat capacity, and SAI mechanism is unchanged — the only physical\n", + "difference is **how CO₂ affects outgoing longwave radiation (OLR)**.\n", + "\n", + "The original model linearizes OLR as $a + bT$ and adds a prescribed CO₂ forcing $F(t)$\n", + "on top. Here, instead, the atmosphere is treated as a grey body with an **effective\n", + "emissivity $\\varepsilon$ that decreases as CO₂ rises** — a more physically motivated\n", + "representation of the greenhouse effect, in which added CO₂ makes the atmospheric column\n", + "more opaque to infrared radiation rather than simply shifting a linear intercept:\n", + "\n", + "$$C_a\\frac{dT_a}{dt} = S\\bigl(1-\\alpha(t)\\bigr) - \\varepsilon\\bigl(\\mathrm{CO_2}(t)\\bigr)\\,\\sigma T_a^4 - \\gamma_{ao}(T_a - T_o)$$\n", + "$$C_o\\frac{dT_o}{dt} = \\gamma_{ao}(T_a - T_o)$$\n", + "$$\\varepsilon(\\mathrm{CO_2}) = \\varepsilon_0 - \\frac{5.35\\,\\ln(\\mathrm{CO_2}/\\mathrm{CO_2}_0)}{\\sigma T_0^4}$$\n", + "\n", + "| Symbol | Meaning | Units |\n", + "|--------|---------|-------|\n", + "| $T_a,\\,T_o$ | Atmosphere / ocean temperature | K |\n", + "| $C_a$ | Atmospheric-column heat capacity | W·yr/m²/°C |\n", + "| $C_o$ | Full-column ocean heat capacity | W·yr/m²/°C |\n", + "| $\\gamma_{ao}$ | Atmosphere ↔ ocean heat exchange | W/m²/°C |\n", + "| $\\sigma$ | Stefan–Boltzmann constant | W/m²/K⁴ |\n", + "| $\\varepsilon(\\mathrm{CO_2})$ | Effective atmospheric emissivity | dimensionless |\n", + "| $\\mathrm{CO_2}(t)$ | Atmospheric CO₂ concentration | ppm |\n", + "| $S,\\ \\alpha(t)$ | Insolation, albedo (incl. SAI offset) | as in the single-layer model |\n", + "\n", + "The logarithmic term $5.35\\ln(\\mathrm{CO_2}/\\mathrm{CO_2}_0)$ is the standard Myhre et al.\n", + "(1998) CO₂ radiative-forcing formula. Rather than adding it to the flux directly, it is\n", + "folded into $\\varepsilon$ so that CO₂ acts on the *radiative properties of the\n", + "atmosphere* — reducing $\\varepsilon$, and hence OLR — instead of appearing as a bare\n", + "additive forcing term.\n", + "\n", + "$\\mathrm{CO_2}(t)$ is **real data**, not a synthetic curve:\n", + "\n", + "- **1850–1978**: Meinshausen et al. (2017) / CMIP6 historical GHG concentrations\n", + " (RCMIP \"historical\" series).\n", + "- **1979–2023**: NOAA GML observed global annual-mean CO₂ — actual measurements.\n", + "- **2024–2100**: an RCMIP/CMIP6 **SSP concentration pathway** (SSP1-2.6 / SSP2-4.5 /\n", + " SSP5-8.5) for the chosen scenario, offset-anchored to the real 2023 value so each\n", + " projection continues smoothly from observations instead of jumping to RCMIP's\n", + " (decade-old, slightly higher) projected 2023 value.\n", + "\n", + "See `data/co2_historical_1850_2023.csv` and `data/co2_ssp_scenarios_2024_2100.csv`\n", + "(sourced from the [RCMIP concentrations dataset](https://zenodo.org/records/4589756) and\n", + "[NOAA GML](https://gml.noaa.gov/ccgg/trends/gl_data.html)). CO₂ radiative forcing\n", + "$F(t) = 5.35\\ln(\\mathrm{CO_2}(t)/\\mathrm{CO_2}_0)$ is now *derived* from this real record\n", + "rather than independently fit — earlier versions of this notebook back-calculated a\n", + "CO₂-equivalent concentration by inverting a synthetic multi-gas forcing curve; this\n", + "version runs on literal atmospheric CO₂ instead. The model horizon is **1850–2100**.\n", + "\n", + "Because OLR now depends on $T_a^4$ instead of a linear $a+bT$, the Planck feedback is no\n", + "longer a free-tuned parameter ($b=2.09$ W/m²/K in the original model) but instead falls\n", + "out of $4\\varepsilon_0\\sigma T_0^3$ — a pure Planck response, with no implicit\n", + "water-vapor/ice-albedo feedback baked in. Expect a *stronger* net negative feedback (more\n", + "resistance to warming) than the original linear-OLR model." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5a97f75f", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import pathlib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.integrate import solve_ivp\n", + "import ipywidgets as widgets\n", + "from ipywidgets import interact, FloatSlider, IntSlider, Dropdown\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "plt.rcParams.update({\n", + " 'figure.dpi': 110,\n", + " 'axes.spines.top': False,\n", + " 'axes.spines.right': False,\n", + " 'axes.grid': True,\n", + " 'grid.alpha': 0.3,\n", + " 'font.size': 11,\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d1e23954", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-industrial OLR = 238.175 W/m2 -> eps0 = 0.6093\n", + "Planck feedback at T0: 4*eps0*sigma*T0^3 = 3.306 W/m2/K (cf. tuned b = 2.09 W/m2/K in the linear-OLR model)\n", + "Heat capacities [W.yr/m2/K]: C_a = 0.329 C_o = 340.5\n", + "Response timescales: atmosphere ~ 0.025 yr ocean ~ 34 yr\n", + "Equilibrium check -> T_eq = 288.1500 K (target: 288.15 K)\n" + ] + } + ], + "source": [ + "# == Physical constants =======================================================\n", + "S0 = 1361.0 # Solar constant [W/m2]\n", + "S = S0 / 4 # Sphere-averaged mean insolation [W/m2]\n", + "SIGMA = 5.670374419e-8 # Stefan-Boltzmann constant [W/m2/K4]\n", + "\n", + "# == Pre-industrial baseline (1850) ===========================================\n", + "alpha0 = 0.30 # Planetary albedo\n", + "T0 = 288.15 # Surface temperature [K] (~15 C)\n", + "\n", + "# == CO2 -> emissivity: Myhre et al. (1998) logarithmic forcing =============\n", + "CO2_0 = 280.0 # pre-industrial CO2 concentration [ppm]\n", + "K_CO2 = 5.35 # log-CO2 forcing coefficient [W/m2]\n", + "\n", + "# OLR = eps(CO2) * SIGMA * Ta^4 ; eps0 is set so that CO2=CO2_0 gives T_eq = T0 exactly.\n", + "OLR0 = S * (1 - alpha0) # required pre-industrial OLR [W/m2]\n", + "EPS0 = OLR0 / (SIGMA * T0**4) # pre-industrial effective atmospheric emissivity [-]\n", + "\n", + "# == Layer heat capacities ====================================================\n", + "RHO_W = 1025.0 # seawater density [kg/m3]\n", + "CP_W = 3990.0 # seawater heat capacity [J/kg/K]\n", + "F_OCEAN = 0.71 # ocean fraction of Earth's surface\n", + "CP_AIR = 1004.0 # air heat capacity [J/kg/K]\n", + "P_SURF = 1.01325e5 # surface pressure [Pa]\n", + "G_GRAV = 9.81 # gravity [m/s2]\n", + "SEC_PER_YR = 3.1557e7\n", + "\n", + "OCEAN_DEPTH = 3700.0 # combined ocean thickness [m] (0–3700 m)\n", + "\n", + "def ocean_layer_C(depth_m, f_ocean=F_OCEAN):\n", + " \"\"\"Heat capacity per m2 of Earth for an ocean layer [W.yr/m2/K].\"\"\"\n", + " return RHO_W * CP_W * depth_m * f_ocean / SEC_PER_YR\n", + "\n", + "C_ATMOS = CP_AIR * P_SURF / G_GRAV / SEC_PER_YR # atmospheric column\n", + "C_OCEAN = ocean_layer_C(OCEAN_DEPTH) # combined ocean layer\n", + "\n", + "# == Atmosphere <-> ocean heat-exchange coefficient [W/m2/K] ==================\n", + "GAMMA_AO = 10.0 # atmosphere <-> ocean (air-sea coupling)\n", + "\n", + "B_PLANCK = 4 * EPS0 * SIGMA * T0**3 # Planck feedback at T0, for comparison to the\n", + " # tuned b=2.09 W/m2/K slope in TwoLayerModel.ipynb\n", + "\n", + "print(f\"Pre-industrial OLR = {OLR0:.3f} W/m2 -> eps0 = {EPS0:.4f}\")\n", + "print(f\"Planck feedback at T0: 4*eps0*sigma*T0^3 = {B_PLANCK:.3f} W/m2/K \"\n", + " f\"(cf. tuned b = 2.09 W/m2/K in the linear-OLR model)\")\n", + "print(f\"Heat capacities [W.yr/m2/K]: C_a = {C_ATMOS:.3f} C_o = {C_OCEAN:.1f}\")\n", + "print(f\"Response timescales: atmosphere ~ {C_ATMOS/(B_PLANCK+GAMMA_AO):.3f} yr \"\n", + " f\"ocean ~ {C_OCEAN/GAMMA_AO:.0f} yr\")\n", + "print(f\"Equilibrium check -> T_eq = {(OLR0/(EPS0*SIGMA))**0.25:.4f} K (target: {T0} K)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ae37d38f", + "metadata": {}, + "outputs": [], + "source": [ + "# Real CO2 data, replacing the earlier synthetic linear-ramp + quadratic-fit\n", + "# approximation:\n", + "#\n", + "# 1850-1978 : Meinshausen et al. (2017) / CMIP6 historical GHG\n", + "# concentrations (RCMIP \"historical\" series).\n", + "# 1979-2023 : NOAA GML observed global annual-mean CO2 -- real\n", + "# measurements, not a reconstruction.\n", + "# 2024-2100 : RCMIP/CMIP6 SSP concentration pathway for the chosen\n", + "# scenario (SSP1-2.6 / SSP2-4.5 / SSP5-8.5), offset-anchored\n", + "# to the actual 2023 observed value so each projection\n", + "# continues smoothly from real data instead of jumping to\n", + "# RCMIP's (decade-old, slightly higher) projected 2023 value.\n", + "#\n", + "# See data/co2_historical_1850_2023.csv and data/co2_ssp_scenarios_2024_2100.csv\n", + "# (built from https://zenodo.org/records/4589756 and\n", + "# https://gml.noaa.gov/ccgg/trends/gl_data.html).\n", + "DATA_DIR = None\n", + "for _candidate in [pathlib.Path(\"data\"), pathlib.Path(\"../data\")]:\n", + " if (_candidate / \"co2_historical_1850_2023.csv\").exists():\n", + " DATA_DIR = _candidate\n", + " break\n", + "if DATA_DIR is None:\n", + " raise FileNotFoundError(\n", + " \"Could not find data/co2_historical_1850_2023.csv -- run this notebook \"\n", + " \"from the 'code' directory it lives in (or alongside a sibling 'data' folder).\"\n", + " )\n", + "\n", + "SSP_SCENARIOS = ['ssp126', 'ssp245', 'ssp585']\n", + "\n", + "\n", + "def _load_co2_data():\n", + " hist = np.genfromtxt(DATA_DIR / \"co2_historical_1850_2023.csv\", delimiter=\",\", skip_header=1)\n", + " ssp = np.genfromtxt(DATA_DIR / \"co2_ssp_scenarios_2024_2100.csv\", delimiter=\",\", skip_header=1)\n", + " hist_years, hist_ppm = hist[:, 0], hist[:, 1]\n", + " ssp_years = ssp[:, 0]\n", + " ssp_cols = {'ssp126': ssp[:, 1], 'ssp245': ssp[:, 2], 'ssp585': ssp[:, 3]}\n", + "\n", + " years_by_scenario, ppm_by_scenario = {}, {}\n", + " for name in SSP_SCENARIOS:\n", + " years_by_scenario[name] = np.concatenate([hist_years, ssp_years])\n", + " ppm_by_scenario[name] = np.concatenate([hist_ppm, ssp_cols[name]])\n", + " return years_by_scenario, ppm_by_scenario\n", + "\n", + "\n", + "_CO2_YEARS, _CO2_PPM = _load_co2_data()\n", + "\n", + "\n", + "def co2_ppm(t, scenario='ssp245'):\n", + " \"\"\"\n", + " Atmospheric CO2 concentration [ppm] -- real historical record spliced\n", + " with a real SSP concentration pathway (see module docstring above).\n", + " 'none' is a pre-industrial control: CO2 held at CO2_0 for all t.\n", + " \"\"\"\n", + " if scenario == 'none':\n", + " return CO2_0\n", + " return np.interp(t, _CO2_YEARS[scenario], _CO2_PPM[scenario])\n", + "\n", + "\n", + "def co2_forcing(t, scenario='ssp245'):\n", + " \"\"\"\n", + " CO2 radiative forcing relative to pre-industrial [W/m2], via the\n", + " Myhre et al. (1998) logarithmic formula applied to the real CO2 record\n", + " from co2_ppm() (rather than an independently-fit forcing curve).\n", + " \"\"\"\n", + " if scenario == 'none':\n", + " return 0.0\n", + " return K_CO2 * np.log(co2_ppm(t, scenario=scenario) / CO2_0)\n", + "\n", + "\n", + "def emissivity(CO2):\n", + " \"\"\"\n", + " Effective atmospheric emissivity: decreases (atmosphere becomes more\n", + " IR-opaque) as CO2 rises above CO2_0. Vectorized over CO2.\n", + " \"\"\"\n", + " return EPS0 - K_CO2 * np.log(CO2 / CO2_0) / (SIGMA * T0**4)\n", + "\n", + "\n", + "def sai_delta_alpha(t, d_alpha=0.0, start_year=2030, ramp_years=10, d_alpha_slope=0.0):\n", + " \"\"\"\n", + " Albedo offset from stratospheric aerosol injection (SAI).\n", + "\n", + " Phase 1 – pre-deployment [t < start_year]: 0\n", + " Phase 2 – ramp-up [start_year, start_year+ramp): linear 0 -> d_alpha\n", + " Phase 3 – post-ramp [t >= start_year+ramp): d_alpha + d_alpha_slope*(t-ramp_end)\n", + " \"\"\"\n", + " if d_alpha == 0.0 or t < start_year:\n", + " return 0.0\n", + " ramp_end = start_year + ramp_years\n", + " if t < ramp_end:\n", + " return d_alpha * (t - start_year) / ramp_years\n", + " return d_alpha + d_alpha_slope * (t - ramp_end)\n", + "\n", + "\n", + "def net_toa_imbalance(t, Ta, d_alpha=0.0, scenario='ssp245',\n", + " sai_start=2030, sai_ramp=10, d_alpha_slope=0.0):\n", + " \"\"\"Net top-of-atmosphere radiative flux S(1-alpha) - eps(CO2(t))*sigma*Ta^4 [W/m2].\"\"\"\n", + " alpha = alpha0 + sai_delta_alpha(t, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " eps = emissivity(co2_ppm(t, scenario=scenario))\n", + " return S * (1 - alpha) - eps * SIGMA * Ta**4\n", + "\n", + "\n", + "def layer_derivs(t, y, C_a, C_o, gamma_ao,\n", + " d_alpha=0.0, scenario='ssp245', sai_start=2030, sai_ramp=10, d_alpha_slope=0.0):\n", + " \"\"\"\n", + " Right-hand side of the two-layer system. y = [T_a, T_o].\n", + "\n", + " Atmosphere sees the net TOA radiation -- whose OLR term now depends on the\n", + " CO2-dependent emissivity eps(CO2(t)) rather than a linear a+bT+F(t) -- and\n", + " exchanges heat with the ocean; the single ocean layer absorbs whatever the\n", + " atmosphere passes down.\n", + " \"\"\"\n", + " Ta, To = y\n", + " R = net_toa_imbalance(t, Ta, d_alpha, scenario, sai_start, sai_ramp, d_alpha_slope)\n", + " f_ao = gamma_ao * (Ta - To) # atmosphere -> ocean\n", + " return [(R - f_ao) / C_a,\n", + " (f_ao) / C_o]\n", + "\n", + "\n", + "def run_ebm(C_a=C_ATMOS, C_o=C_OCEAN,\n", + " gamma_ao=GAMMA_AO,\n", + " scenario='ssp245', d_alpha=0.0, sai_start=2030, sai_ramp=10,\n", + " d_alpha_slope=0.0, t_span=(1850, 2100), n_pts=2400):\n", + " \"\"\"\n", + " Integrate the two-layer EBM.\n", + "\n", + " The T_a^4 emissivity-based OLR term is nonlinear on top of the usual\n", + " stiff atmosphere/ocean timescale split -> still solved with the implicit\n", + " BDF method.\n", + "\n", + " Returns\n", + " -------\n", + " t : time [years]\n", + " Ta : atmospheric temperature [K]\n", + " To : ocean temperature [K]\n", + " Q : net TOA energy imbalance [W/m2]\n", + " \"\"\"\n", + " kw = dict(d_alpha=d_alpha, scenario=scenario, sai_start=sai_start,\n", + " sai_ramp=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " args = (C_a, C_o, gamma_ao)\n", + "\n", + " t_eval = np.linspace(*t_span, n_pts)\n", + " sol = solve_ivp(lambda t, y: layer_derivs(t, y, *args, **kw),\n", + " t_span, [T0, T0], t_eval=t_eval,\n", + " method='BDF', rtol=1e-8, atol=1e-10)\n", + "\n", + " Ta, To = sol.y\n", + " Q = np.array([net_toa_imbalance(ti, Ta_i, **kw) for ti, Ta_i in zip(sol.t, Ta)])\n", + " return sol.t, Ta, To, Q" + ] + }, + { + "cell_type": "markdown", + "id": "e6457cdf", + "metadata": {}, + "source": [ + "## Scenario Comparison\n", + "\n", + "**Left column** — CO₂ forcing only (no SAI), across a pre-industrial control and three\n", + "SSP pathways (SSP1-2.6, SSP2-4.5, SSP5-8.5).\n", + "**Right column** — SAI at varying deployment levels under SSP2-4.5.\n", + "\n", + "Rows (top → bottom): **atmospheric temperature** $T_a$, **ocean** temperature change\n", + "$\\Delta T_o$, and the **energy imbalance** $Q$ (net TOA flux, now $S(1-\\alpha) -\n", + "\\varepsilon(\\mathrm{CO_2})\\sigma T_a^4$)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "56a65175", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(3, 2, figsize=(14, 12), sharex=True)\n", + "fig.suptitle('Two-Layer EBM (variable emissivity) - Scenario Comparison', fontsize=13, fontweight='bold', y=1.003)\n", + "\n", + "# -- CO2 scenarios (no SAI), left column --------------------------------------\n", + "co2_cases = [\n", + " ('none', 'Pre-industrial control', '#888888'),\n", + " ('ssp126', 'SSP1-2.6 - strong mitigation', '#1a9641'),\n", + " ('ssp245', 'SSP2-4.5 - moderate', '#fdae61'),\n", + " ('ssp585', 'SSP5-8.5 - high emissions', '#d7191c'),\n", + "]\n", + "for scen, label, color in co2_cases:\n", + " t, Ta, To, Q = run_ebm(scenario=scen, d_alpha=0.0)\n", + " axes[0, 0].plot(t, Ta, color=color, lw=2, label=label)\n", + " axes[1, 0].plot(t, To - T0, color=color, lw=2, label=label)\n", + " axes[2, 0].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# -- SAI levels under SSP2-4.5, right column -----------------------------------\n", + "sai_cases = [\n", + " (0.000, 'No SAI', '#d7191c'),\n", + " (0.005, 'SAI da = 0.005', '#fdae61'),\n", + " (0.010, 'SAI da = 0.010', '#74add1'),\n", + " (0.015, 'SAI da = 0.015', '#2c7bb6'),\n", + "]\n", + "for da, label, color in sai_cases:\n", + " t, Ta, To, Q = run_ebm(scenario='ssp245', d_alpha=da)\n", + " axes[0, 1].plot(t, Ta, color=color, lw=2, label=label)\n", + " axes[1, 1].plot(t, To - T0, color=color, lw=2, label=label)\n", + " axes[2, 1].plot(t, Q, color=color, lw=2, label=label)\n", + "\n", + "# -- Annotations --------------------------------------------------------------\n", + "for ax in axes.flat:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.45)\n", + "for ax in axes[:, 1]:\n", + " ax.axvline(2030, color='navy', ls=':', lw=1.5, alpha=0.55)\n", + "for ax in list(axes[1, :]) + list(axes[2, :]):\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "\n", + "axes[0, 0].set(title='Atmospheric temperature - CO2 pathways', ylabel='T_a [K]')\n", + "axes[0, 1].set(title='Atmospheric temperature - SAI levels (SSP2-4.5)', ylabel='T_a [K]')\n", + "axes[1, 0].set(title='Ocean temperature change - CO2 pathways', ylabel='dT_o [K]')\n", + "axes[1, 1].set(title='Ocean temperature change - SAI levels', ylabel='dT_o [K]')\n", + "axes[2, 0].set(title='Energy imbalance - CO2 pathways', ylabel='Q [W/m2]', xlabel='Year')\n", + "axes[2, 1].set(title='Energy imbalance - SAI levels', ylabel='Q [W/m2]', xlabel='Year')\n", + "\n", + "axes[0, 0].legend(fontsize=9)\n", + "axes[0, 1].legend(fontsize=9)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8bee7b8d", + "metadata": {}, + "source": [ + "## Interactive Exploration\n", + "\n", + "Adjust the ocean heat capacity, the atmosphere–ocean coupling $\\gamma_{ao}$, the CO₂\n", + "pathway, and the SAI deployment to see how each shapes the response in real time.\n", + "\n", + "- **Top-left** — atmospheric temperature, with the SAI cooling offset shaded.\n", + "- **Top-right** — ocean temperature change.\n", + "- **Middle-left** — net TOA energy imbalance $Q$ and the **ocean heat uptake** $\\gamma_{ao}(T_a-T_o)$.\n", + "- **Middle-right** — the **CO₂ concentration** $\\mathrm{CO_2}(t)$ implied by the scenario\n", + " and the resulting **atmospheric emissivity** $\\varepsilon(\\mathrm{CO_2})$ — this is the\n", + " new mechanism replacing the linear $a+bT+F(t)$ OLR term.\n", + "- **Bottom-left** — energy-balance decomposition $Q = F_{\\mathrm{CO_2}} + F_{\\mathrm{SAI}} +$\n", + " OLR feedback. Unlike the linear model, the OLR feedback term is the nonlinear Planck\n", + " response $\\varepsilon(\\mathrm{CO_2})\\sigma(T_0^4 - T_a^4)$ rather than $-b(T_a-T_0)$ — but\n", + " the three terms still sum to $Q$ exactly, by construction of $\\varepsilon(\\mathrm{CO_2})$.\n", + "- **Bottom-right** — incoming shortwave $S(1-\\alpha(t))$ vs. OLR $\\varepsilon(\\mathrm{CO_2})\\sigma\n", + " T_a^4$ for the SAI run, each point colored by year (viridis). Points above the dashed\n", + " $Q=0$ line indicate a net energy gain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40f7bfa2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d95c8c589a341c99f5ab9712aef7bd2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=340.456103241753, description='C_o [W.yr/m2/K]', max=700.0, min=50.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_ebm(C_o, gamma_ao, scenario, d_alpha, sai_start, sai_ramp, d_alpha_slope):\n", + " t_b, Ta_b, To_b, Q_b = run_ebm(C_o=C_o, gamma_ao=gamma_ao,\n", + " scenario=scenario, d_alpha=0.0)\n", + " t_s, Ta_s, To_s, Q_s = run_ebm(C_o=C_o, gamma_ao=gamma_ao,\n", + " scenario=scenario, d_alpha=d_alpha,\n", + " sai_start=sai_start, sai_ramp=sai_ramp,\n", + " d_alpha_slope=d_alpha_slope)\n", + "\n", + " fig, axes = plt.subplots(3, 2, figsize=(15, 15), gridspec_kw={'height_ratios': [1, 1, 1.15]})\n", + " fig.subplots_adjust(hspace=0.45, wspace=0.3)\n", + "\n", + " fig.suptitle(f'Two-Layer EBM (variable emissivity) | {scenario.upper()} | '\n", + " f'C_o={C_o:.0f} W.yr/m2/K, gamma_ao={gamma_ao:.2f}',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + " # -- Atmospheric temperature -----------------------------------------------\n", + " ax = axes[0, 0]\n", + " ax.plot(t_b, Ta_b, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, Ta_s, color='#2c7bb6', lw=2,\n", + " label=f'SAI da={d_alpha:.3f}, slope={d_alpha_slope:.4f}/yr')\n", + " ax.fill_between(t_s, Ta_b, Ta_s, where=(Ta_s < Ta_b),\n", + " alpha=0.15, color='#2c7bb6', label='Cooling offset')\n", + " ax.set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "\n", + " # -- Ocean temperature change ----------------------------------------------\n", + " ax = axes[0, 1]\n", + " ax.plot(t_b, To_b - T0, color='#d7191c', lw=2, label='No SAI')\n", + " ax.plot(t_s, To_s - T0, color='#2c7bb6', lw=2, label='SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Ocean temperature change', ylabel='dT_o [K]', xlabel='Year')\n", + "\n", + " # -- Energy imbalance + ocean heat uptake ----------------------------------\n", + " ax = axes[1, 0]\n", + " ax.plot(t_b, Q_b, color='#d7191c', lw=2, label='Q (TOA), no SAI')\n", + " ax.plot(t_s, Q_s, color='#2c7bb6', lw=2, label='Q (TOA), SAI')\n", + " ax.plot(t_b, gamma_ao * (Ta_b - To_b), color=\"#fe9408\", lw=1.3, ls=':', label='Ocean uptake, no SAI')\n", + " ax.plot(t_s, gamma_ao * (Ta_s - To_s), color=\"#00fad5\", lw=1.3, ls=':', label='Ocean uptake, SAI')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy imbalance & ocean heat uptake', ylabel='W/m2', xlabel='Year')\n", + "\n", + " # -- CO2 concentration & atmospheric emissivity -----------------------------\n", + " ax = axes[1, 1]\n", + " CO2_s = np.array([co2_ppm(ti, scenario=scenario) for ti in t_s])\n", + " eps_s = emissivity(CO2_s)\n", + " ln1 = ax.plot(t_s, CO2_s, color='#8c510a', lw=2, label='CO2 [ppm]')\n", + " ax.set(title='CO2 concentration & atmospheric emissivity', ylabel='CO2 [ppm]', xlabel='Year')\n", + " ax2 = ax.twinx()\n", + " ln2 = ax2.plot(t_s, eps_s, color='#01665e', lw=2, ls='--', label='eps(CO2)')\n", + " ax2.set_ylabel('emissivity eps [-]')\n", + " ax2.grid(False)\n", + " lns = ln1 + ln2\n", + " ax.legend(lns, [l.get_label() for l in lns], fontsize=8, loc='upper left')\n", + "\n", + " # -- Energy-balance decomposition (SAI run) ---------------------------------\n", + " # Exact identity: Q = F_co2 + F_sai + OLR_fb, where the Planck feedback term\n", + " # eps(CO2)*sigma*(T0^4 - Ta^4) replaces the linear model's -b*(Ta-T0).\n", + " ax = axes[2, 0]\n", + " F_co2 = np.array([co2_forcing(ti, scenario=scenario) for ti in t_s])\n", + " F_sai = np.array([-S * sai_delta_alpha(ti, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " for ti in t_s])\n", + " OLR_fb = eps_s * SIGMA * (T0**4 - Ta_s**4)\n", + " Q_dec = F_co2 + F_sai + OLR_fb\n", + " ax.fill_between(t_s, F_co2, alpha=0.35, color='#d7191c', label='CO2 forcing F(t)')\n", + " ax.fill_between(t_s, F_sai, alpha=0.35, color='#2c7bb6', label='SAI forcing -S*da(t)')\n", + " ax.fill_between(t_s, OLR_fb, alpha=0.35, color='#fdae61', label='OLR feedback eps*sigma*(T0^4-Ta^4)')\n", + " ax.plot(t_s, Q_dec, 'k-', lw=1.6, label='Q (sum)')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy balance decomposition (SAI run)', ylabel='W/m2', xlabel='Year')\n", + "\n", + " for ax in axes.flat[:-1]:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " if d_alpha > 0:\n", + " ax.axvline(sai_start, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.axvline(sai_start + sai_ramp, color='steelblue', ls=':', lw=1.0, alpha=0.5)\n", + " for ax in [axes[0, 0], axes[0, 1], axes[1, 0], axes[2, 0]]:\n", + " ax.legend(fontsize=8)\n", + "\n", + " # -- Incoming shortwave vs. OLR, colored by year (SAI run) -----------------\n", + " ax5 = axes[2, 1]\n", + " alpha_s = alpha0 + np.array([sai_delta_alpha(ti, d_alpha=d_alpha, start_year=sai_start,\n", + " ramp_years=sai_ramp, d_alpha_slope=d_alpha_slope)\n", + " for ti in t_s])\n", + " S_in = S * (1 - alpha_s)\n", + " OLR_s = eps_s * SIGMA * Ta_s**4\n", + "\n", + " lims = [min(OLR_s.min(), S_in.min()), max(OLR_s.max(), S_in.max())]\n", + " ax5.plot(lims, lims, color='k', lw=0.8, ls='--', alpha=0.4, label='S(1-a) = OLR (Q = 0)')\n", + " sc = ax5.scatter(OLR_s, S_in, c=t_s, cmap='viridis', s=14, edgecolor='none')\n", + " fig.colorbar(sc, ax=ax5, label='Year', pad=0.01)\n", + " ax5.set(title='Incoming shortwave vs. OLR (SAI run)',\n", + " xlabel='OLR = eps(CO2)*sigma*T_a^4 [W/m2]', ylabel='S(1 - alpha(t)) [W/m2]')\n", + " ax5.legend(fontsize=8, loc='upper left')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_ebm,\n", + " C_o = FloatSlider(value=C_OCEAN, min=50.0, max=700.0, step=10.0, description='C_o [W.yr/m2/K]', style={'description_width': 'initial'}),\n", + " gamma_ao = FloatSlider(value=GAMMA_AO, min=0.5, max=20.0, step=0.5, description='gamma_ao [W/m2/K]', style={'description_width': 'initial'}, readout_format='.2f'),\n", + " scenario = Dropdown(options=['none', 'ssp126', 'ssp245', 'ssp585'], value='ssp245', description='CO2 scenario'),\n", + " d_alpha = FloatSlider(value=0.0, min=0.0, max=0.015, step=0.0005, description='SAI da', style={'description_width': 'initial'}, readout_format='.4f'),\n", + " sai_start = IntSlider( value=2030, min=2025, max=2080, step=5, description='SAI start year', style={'description_width': 'initial'}),\n", + " sai_ramp = IntSlider( value=10, min=1, max=30, step=1, description='Ramp-up years', style={'description_width': 'initial'}),\n", + " d_alpha_slope= FloatSlider(value=0.0, min=0.0, max=0.00025, step=0.000005, description='Post-ramp slope (da/yr)', style={'description_width': 'initial'}, readout_format='.5f'),\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "25ac554d", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8a099da68e1f4a0fb3d5331bb560a8f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=340.456103241753, description='C_o [W.yr/m2/K]', max=700.0, min=50.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Controller for constant atmospheric temperature\n", + "#\n", + "# ARISE-1.5-style closed-loop SAI feedback controller (simplified analog --\n", + "# not the actual ensemble PI-controller used in ARISE, but the same two-phase\n", + "# structure):\n", + "#\n", + "# t < 2035 : no SAI, baseline warming under the CO2 scenario\n", + "# 2035 <= t < 2045 : ramp-in -- T_target is frozen at whatever T_a is when\n", + "# the ramp begins (2035), and each year the controller\n", + "# solves for the d_alpha that would hold Ta AT T_target\n", + "# given the current ocean state, then applies only a\n", + "# linearly increasing fraction of it (0 -> 1 over the\n", + "# decade)\n", + "# t >= 2045 : full control -- each year the controller re-solves\n", + "# for the d_alpha that holds Ta at the same fixed\n", + "# T_target and applies it in full\n", + "#\n", + "# The \"solve\" is closed-form. Because the atmospheric heat capacity C_a is\n", + "# tiny (~0.03 yr response time) compared to the annual control step, Ta\n", + "# relaxes to its instantaneous radiative equilibrium well within each year --\n", + "# so choosing d_alpha to make T_target *itself* that equilibrium (rather than\n", + "# solving relative to whatever Ta has drifted to) is what actually pins Ta,\n", + "# instead of merely freezing its rate of change from a moving baseline.\n", + "# Setting Ta = T_target in\n", + "# C_a dTa/dt = S(1 - alpha0 - d_alpha) - eps(CO2(t))*sigma*Ta^4 - gamma_ao*(Ta-To)\n", + "# and solving dTa/dt = 0 for d_alpha gives\n", + "# d_alpha = (1 - alpha0) - [eps(CO2(t))*sigma*T_target^4 + gamma_ao*(T_target - To)] / S\n", + "\n", + "CTRL_START = 2035 # year SAI ramp-in begins\n", + "CTRL_RAMP = 10 # ramp-in duration [yr]; full control from CTRL_START+CTRL_RAMP\n", + "\n", + "\n", + "def controller_d_alpha_step(T_target, To, t_year, scenario, gamma_ao):\n", + " \"\"\"SAI albedo offset that holds Ta at the fixed T_target, given the current ocean state.\"\"\"\n", + " eps = emissivity(co2_ppm(t_year, scenario=scenario))\n", + " d_alpha = (1 - alpha0) - (eps * SIGMA * T_target**4 + gamma_ao * (T_target - To)) / S\n", + " return max(d_alpha, 0.0) # SAI only adds reflective aerosol -- no negative injection\n", + "\n", + "\n", + "def _layer_derivs_fixed_alpha(t, y, C_a, C_o, gamma_ao, d_alpha, scenario):\n", + " \"\"\"Two-layer RHS with a single, already-solved albedo offset held fixed.\"\"\"\n", + " Ta, To = y\n", + " eps = emissivity(co2_ppm(t, scenario=scenario))\n", + " R = S * (1 - (alpha0 + d_alpha)) - eps * SIGMA * Ta**4\n", + " f_ao = gamma_ao * (Ta - To)\n", + " return [(R - f_ao) / C_a, f_ao / C_o]\n", + "\n", + "\n", + "def run_controller_ebm(C_o=C_OCEAN, gamma_ao=GAMMA_AO, scenario='ssp245',\n", + " t_span=(1850, 2100), pts_per_year=8):\n", + " \"\"\"\n", + " Integrate the two-layer EBM one calendar year at a time, re-solving the\n", + " controller's d_alpha at the start of each year (see module docstring\n", + " above) and holding it fixed while that year is integrated.\n", + "\n", + " Returns\n", + " -------\n", + " t, Ta, To, Q, d_alpha : all on the same fine (sub-year) grid.\n", + " T_target : the frozen atmospheric-temperature target [K].\n", + " \"\"\"\n", + " C_a = C_ATMOS\n", + " t0, t_end = t_span\n", + " years = np.arange(t0, t_end)\n", + "\n", + " t_chunks, Ta_chunks, To_chunks, da_chunks = [], [], [], []\n", + " y = [T0, T0]\n", + " T_target = None\n", + "\n", + " for yr in years:\n", + " if yr < CTRL_START:\n", + " d_alpha = 0.0\n", + " else:\n", + " if T_target is None:\n", + " T_target = y[0] # freeze the target at the state when the ramp begins\n", + " d_alpha_full = controller_d_alpha_step(T_target, y[1], yr, scenario, gamma_ao)\n", + " ramp_frac = min(1.0, (yr - CTRL_START + 1) / CTRL_RAMP)\n", + " d_alpha = ramp_frac * d_alpha_full\n", + "\n", + " t_eval = np.linspace(yr, yr + 1, pts_per_year, endpoint=False)\n", + " sol = solve_ivp(lambda t, yy: _layer_derivs_fixed_alpha(t, yy, C_a, C_o, gamma_ao,\n", + " d_alpha, scenario),\n", + " (yr, yr + 1), y, t_eval=t_eval,\n", + " method='BDF', rtol=1e-8, atol=1e-10, dense_output=True)\n", + "\n", + " t_chunks.append(sol.t)\n", + " Ta_chunks.append(sol.y[0])\n", + " To_chunks.append(sol.y[1])\n", + " da_chunks.append(np.full_like(sol.t, d_alpha))\n", + " y = sol.sol(yr + 1) # true state at the year boundary (t_eval excludes\n", + " # it via endpoint=False, so sol.y[:, -1] is the\n", + " # state at yr+0.875 -- using that as next year's\n", + " # IC silently skips the last 1/pts_per_year of\n", + " # each year and re-injects a stale state)\n", + "\n", + " t = np.concatenate(t_chunks)\n", + " Ta = np.concatenate(Ta_chunks)\n", + " To = np.concatenate(To_chunks)\n", + " d_alpha_t = np.concatenate(da_chunks)\n", + "\n", + " eps_t = emissivity(np.array([co2_ppm(ti, scenario=scenario) for ti in t]))\n", + " Q = S * (1 - (alpha0 + d_alpha_t)) - eps_t * SIGMA * Ta**4\n", + " return t, Ta, To, Q, d_alpha_t, T_target\n", + "\n", + "\n", + "def plot_controller_ebm(C_o, gamma_ao, scenario):\n", + " t_c, Ta_c, To_c, Q_c, da_c, T_target = run_controller_ebm(C_o=C_o, gamma_ao=gamma_ao, scenario=scenario)\n", + " t_b, Ta_b, To_b, Q_b = run_ebm(C_o=C_o, gamma_ao=gamma_ao, scenario=scenario, d_alpha=0.0)\n", + "\n", + " fig, axes = plt.subplots(3, 2, figsize=(15, 15), gridspec_kw={'height_ratios': [1, 1, 1.15]})\n", + " fig.subplots_adjust(hspace=0.45, wspace=0.3)\n", + "\n", + " fig.suptitle(f'Two-Layer EBM | Constant-T_a SAI Controller | {scenario.upper()} | '\n", + " f'C_o={C_o:.0f} W.yr/m2/K, gamma_ao={gamma_ao:.2f}',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + " # -- Atmospheric temperature -----------------------------------------------\n", + " ax = axes[0, 0]\n", + " ax.plot(t_b, Ta_b, color='#d7191c', lw=2, label='No SAI (baseline)')\n", + " ax.plot(t_c, Ta_c, color='#2c7bb6', lw=2, label='Controller (constant T_a)')\n", + " if T_target is not None:\n", + " ax.axhline(T_target, color='#2c7bb6', lw=1, ls=':', alpha=0.6, label=f'T_target = {T_target:.2f} K')\n", + " ax.set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "\n", + " # -- Ocean temperature change ----------------------------------------------\n", + " ax = axes[0, 1]\n", + " ax.plot(t_b, To_b - T0, color='#d7191c', lw=2, label='No SAI (baseline)')\n", + " ax.plot(t_c, To_c - T0, color='#2c7bb6', lw=2, label='Controller')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Ocean temperature change', ylabel='dT_o [K]', xlabel='Year')\n", + "\n", + " # -- Energy imbalance + ocean heat uptake ----------------------------------\n", + " ax = axes[1, 0]\n", + " ax.plot(t_b, Q_b, color='#d7191c', lw=2, label='Q (TOA), no SAI')\n", + " ax.plot(t_c, Q_c, color='#2c7bb6', lw=2, label='Q (TOA), controller')\n", + " ax.plot(t_b, gamma_ao * (Ta_b - To_b), color=\"#fe9408\", lw=1.3, ls=':', label='Ocean uptake, no SAI')\n", + " ax.plot(t_c, gamma_ao * (Ta_c - To_c), color=\"#00fad5\", lw=1.3, ls=':', label='Ocean uptake, controller')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy imbalance & ocean heat uptake', ylabel='W/m2', xlabel='Year')\n", + "\n", + " # -- CO2 concentration & atmospheric emissivity -----------------------------\n", + " ax = axes[1, 1]\n", + " CO2_c = np.array([co2_ppm(ti, scenario=scenario) for ti in t_c])\n", + " eps_c = emissivity(CO2_c)\n", + " ln1 = ax.plot(t_c, CO2_c, color='#8c510a', lw=2, label='CO2 [ppm]')\n", + " ax.set(title='CO2 concentration & atmospheric emissivity', ylabel='CO2 [ppm]', xlabel='Year')\n", + " ax2 = ax.twinx()\n", + " ln2 = ax2.plot(t_c, eps_c, color='#01665e', lw=2, ls='--', label='eps(CO2)')\n", + " ax2.set_ylabel('emissivity eps [-]')\n", + " ax2.grid(False)\n", + " lns = ln1 + ln2\n", + " ax.legend(lns, [l.get_label() for l in lns], fontsize=8, loc='upper left')\n", + "\n", + " # -- Controller SAI injection ------------------------------------------------\n", + " ax = axes[2, 0]\n", + " ax.plot(t_c, da_c, color='#762a83', lw=2, label='SAI d_alpha (solved)')\n", + " ax.set(title='Controller SAI injection', ylabel='d_alpha [-]', xlabel='Year')\n", + " ax.legend(fontsize=8)\n", + "\n", + " for ax in axes.flat[:-1]:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " ax.axvline(CTRL_START, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.axvline(CTRL_START + CTRL_RAMP, color='steelblue', ls=':', lw=1.0, alpha=0.5)\n", + " for ax in [axes[0, 0], axes[0, 1], axes[1, 0]]:\n", + " ax.legend(fontsize=8)\n", + "\n", + " # -- Incoming shortwave vs. OLR, colored by year (controller run) ----------\n", + " # Annual means -- one point per calendar year, rather than one point per\n", + " # sub-year integration step, since the sub-year spread within a year is a\n", + " # real but uninteresting transient (see the per-year re-solve above) that\n", + " # otherwise dominates the plot.\n", + " ax5 = axes[2, 1]\n", + " S_in = S * (1 - (alpha0 + da_c))\n", + " OLR_c = eps_c * SIGMA * Ta_c**4\n", + "\n", + " year_labels, year_idx = np.unique(np.floor(t_c).astype(int), return_inverse=True)\n", + " counts = np.bincount(year_idx)\n", + " S_in_annual = np.bincount(year_idx, weights=S_in) / counts\n", + " OLR_annual = np.bincount(year_idx, weights=OLR_c) / counts\n", + "\n", + " lims = [min(OLR_annual.min(), S_in_annual.min()), max(OLR_annual.max(), S_in_annual.max())]\n", + " ax5.plot(lims, lims, color='k', lw=0.8, ls='--', alpha=0.4, label='S(1-a) = OLR (Q = 0)')\n", + " sc = ax5.scatter(OLR_annual, S_in_annual, c=year_labels, cmap='viridis', s=14, edgecolor='none')\n", + " fig.colorbar(sc, ax=ax5, label='Year', pad=0.01)\n", + " ax5.set(title='Incoming shortwave vs. OLR (controller run, annual means)',\n", + " xlabel='OLR = eps(CO2)*sigma*T_a^4 [W/m2]', ylabel='S(1 - alpha(t)) [W/m2]')\n", + " ax5.legend(fontsize=8, loc='upper left')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_controller_ebm,\n", + " C_o = FloatSlider(value=C_OCEAN, min=50.0, max=700.0, step=10.0, description='C_o [W.yr/m2/K]', style={'description_width': 'initial'}),\n", + " gamma_ao = FloatSlider(value=GAMMA_AO, min=0.5, max=20.0, step=0.5, description='gamma_ao [W/m2/K]', style={'description_width': 'initial'}, readout_format='.2f'),\n", + " scenario = Dropdown(options=['none', 'ssp126', 'ssp245', 'ssp585'], value='ssp245', description='CO2 scenario'),\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "c18d8dfb", + "metadata": {}, + "source": [ + "## Ocean Coupling Sensitivity\n", + "\n", + "The key tunable parameter in this model is $\\gamma_{ao}$, which controls how quickly\n", + "heat transfers from the atmosphere to the ocean. A larger $\\gamma_{ao}$ couples\n", + "the layers more tightly, giving a faster ocean response and a smaller persistent\n", + "energy imbalance $Q$. Below: both layers' responses for five values of $\\gamma_{ao}$\n", + "under SSP2-4.5 with a moderate SAI deployment ($\\Delta\\alpha = 0.010$)." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "58479917", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gamma_values = [1.0, 3.0, 5.0, 10.0, 15.0]\n", + "colors = plt.cm.viridis(np.linspace(0.1, 0.85, len(gamma_values)))\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n", + "fig.suptitle('Ocean Coupling Sensitivity, variable emissivity (SSP2-4.5, SAI da = 0.010, start 2030)',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + "for g, color in zip(gamma_values, colors):\n", + " t, Ta, To, Q = run_ebm(scenario='ssp245', d_alpha=0.010, gamma_ao=g)\n", + " axes[0].plot(t, Ta, color=color, lw=2, label=f'gamma_ao = {g}')\n", + " axes[1].plot(t, To - T0, color=color, lw=2)\n", + " axes[2].plot(t, Q, color=color, lw=2)\n", + "\n", + "for ax in axes:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " ax.axvline(2030, color='gray', ls=':', lw=1.5, alpha=0.55)\n", + "axes[1].axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "axes[2].axhline(0, color='k', lw=0.8, alpha=0.3)\n", + "\n", + "axes[0].set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "axes[1].set(title='Ocean temperature change', ylabel='dT_o [K]', xlabel='Year')\n", + "axes[2].set(title='Energy imbalance Q', ylabel='W/m2', xlabel='Year')\n", + "\n", + "axes[0].legend(title='Coupling', fontsize=9)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e4542689", + "metadata": {}, + "source": [ + "### Features to add or verify performance\n", + "-fix CO2 ramp from 1850-2023 and for RCP conditions\n", + "-fix T_a to match SSP2-4.5 (may need to add a second ocean layer)\n", + "-add ARISE 1.5 solver\n", + "-is methane’s impact negligible? Are the changes to CO2 not sufficient to represent emissivity changes?\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "baseEnv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/data/co2_historical_1850_2023.csv b/data/co2_historical_1850_2023.csv new file mode 100644 index 0000000..1131ae0 --- /dev/null +++ b/data/co2_historical_1850_2023.csv @@ -0,0 +1,175 @@ +year,co2_ppm +1850,284.3170 +1851,284.4510 +1852,284.5980 +1853,284.7310 +1854,284.8460 +1855,284.9410 +1856,285.0490 +1857,285.2040 +1858,285.3690 +1859,285.5450 +1860,285.7390 +1861,285.9330 +1862,286.1000 +1863,286.2710 +1864,286.4420 +1865,286.6140 +1866,286.7810 +1867,286.9550 +1868,287.1050 +1869,287.2250 +1870,287.3550 +1871,287.4940 +1872,287.6640 +1873,287.8600 +1874,288.0610 +1875,288.2910 +1876,288.5200 +1877,288.7520 +1878,288.9930 +1879,289.2210 +1880,289.4700 +1881,289.7370 +1882,290.0190 +1883,290.2630 +1884,290.5120 +1885,290.7970 +1886,291.1000 +1887,291.4140 +1888,291.7630 +1889,292.1130 +1890,292.4580 +1891,292.8160 +1892,293.1670 +1893,293.4770 +1894,293.7910 +1895,294.0790 +1896,294.3650 +1897,294.6460 +1898,294.9540 +1899,295.3000 +1900,295.6750 +1901,296.0070 +1902,296.3250 +1903,296.6540 +1904,296.9540 +1905,297.2890 +1906,297.6620 +1907,298.0980 +1908,298.5180 +1909,298.9360 +1910,299.3770 +1911,299.8290 +1912,300.3530 +1913,300.9100 +1914,301.4190 +1915,301.9370 +1916,302.4850 +1917,303.0110 +1918,303.4490 +1919,303.8140 +1920,304.2460 +1921,304.6000 +1922,304.9450 +1923,305.2710 +1924,305.6300 +1925,305.8130 +1926,305.9540 +1927,306.1770 +1928,306.3290 +1929,306.4950 +1930,306.6200 +1931,306.8220 +1932,307.0930 +1933,307.4020 +1934,307.7850 +1935,308.2270 +1936,309.0120 +1937,309.7640 +1938,310.2940 +1939,310.8510 +1940,311.3570 +1941,311.8110 +1942,312.1720 +1943,312.3900 +1944,312.4130 +1945,312.3850 +1946,312.3900 +1947,312.4860 +1948,312.5210 +1949,312.6320 +1950,312.8210 +1951,313.0140 +1952,313.3420 +1953,313.7300 +1954,314.0950 +1955,314.4150 +1956,314.6980 +1957,314.9920 +1958,315.3450 +1959,315.8070 +1960,316.6250 +1961,317.2990 +1962,318.0440 +1963,318.6500 +1964,319.3330 +1965,319.8160 +1966,320.8800 +1967,321.4800 +1968,322.3890 +1969,323.2510 +1970,324.7830 +1971,325.4000 +1972,327.3490 +1973,329.9090 +1974,330.7560 +1975,330.8270 +1976,331.5449 +1977,333.3529 +1978,335.0099 +1979,336.8500 +1980,338.9100 +1981,340.1100 +1982,340.8500 +1983,342.5300 +1984,344.0700 +1985,345.5400 +1986,346.9700 +1987,348.6800 +1988,351.1600 +1989,352.7900 +1990,354.0600 +1991,355.4000 +1992,356.0900 +1993,356.8300 +1994,358.3300 +1995,360.1800 +1996,361.9300 +1997,363.0400 +1998,365.7000 +1999,367.7900 +2000,368.9600 +2001,370.5700 +2002,372.5800 +2003,375.1400 +2004,376.9400 +2005,378.9800 +2006,381.1500 +2007,382.9000 +2008,385.0200 +2009,386.5000 +2010,388.7500 +2011,390.6200 +2012,392.6500 +2013,395.4000 +2014,397.3400 +2015,399.6500 +2016,403.0700 +2017,405.2200 +2018,407.6100 +2019,410.0700 +2020,412.4400 +2021,414.7000 +2022,417.0800 +2023,419.3500 diff --git a/data/co2_ssp_scenarios_2024_2100.csv b/data/co2_ssp_scenarios_2024_2100.csv new file mode 100644 index 0000000..492d7db --- /dev/null +++ b/data/co2_ssp_scenarios_2024_2100.csv @@ -0,0 +1,78 @@ +year,ssp126,ssp245,ssp585 +2024,421.9710,422.2940,422.8490 +2025,424.5250,425.2550,426.4590 +2026,427.0170,428.2360,430.1790 +2027,429.4490,431.2370,434.0070 +2028,431.8250,434.2580,437.9440 +2029,434.1460,437.3020,441.9900 +2030,436.4150,440.3680,446.1440 +2031,438.6320,443.4570,450.4080 +2032,440.7800,446.5580,454.7930 +2033,442.8410,449.6600,459.3110 +2034,444.8200,452.7660,463.9600 +2035,446.7170,455.8770,468.7410 +2036,448.5360,458.9950,473.6540 +2037,450.2770,462.1220,478.7010 +2038,451.9430,465.2580,483.8810 +2039,453.5350,468.4040,489.1960 +2040,455.0520,471.5610,494.6480 +2041,456.4980,474.7290,500.2370 +2042,457.8700,477.8990,505.9710 +2043,459.1660,481.0630,511.8570 +2044,460.3870,484.2210,517.8960 +2045,461.5340,487.3750,524.0890 +2046,462.6060,490.5250,530.4380 +2047,463.6040,493.6720,536.9430 +2048,464.5290,496.8170,543.6060 +2049,465.3810,499.9590,550.4290 +2050,466.1610,503.1000,557.4130 +2051,466.8700,506.2390,564.5590 +2052,467.5140,509.3620,571.8870 +2053,468.1010,512.4550,579.4130 +2054,468.6300,515.5170,587.1360 +2055,469.1020,518.5510,595.0580 +2056,469.5160,521.5570,603.1789 +2057,469.8730,524.5350,611.4990 +2058,470.1730,527.4860,620.0200 +2059,470.4150,530.4110,628.7429 +2060,470.6010,533.3100,637.6699 +2061,470.7290,536.1830,646.8009 +2062,470.8100,539.0200,656.1360 +2063,470.8500,541.8120,665.6739 +2064,470.8500,544.5600,675.4179 +2065,470.8080,547.2640,685.3679 +2066,470.7240,549.9250,695.5279 +2067,470.5980,552.5440,705.8979 +2068,470.4290,555.1200,716.4799 +2069,470.2160,557.6560,727.2769 +2070,469.9610,560.1500,738.2909 +2071,469.6620,562.6050,749.5219 +2072,469.3090,564.9970,760.9519 +2073,468.8920,567.3080,772.5589 +2074,468.4120,569.5390,784.3479 +2075,467.8690,571.6910,796.3199 +2076,467.2650,573.7650,808.4769 +2077,466.6000,575.7620,820.8219 +2078,465.8730,577.6830,833.3559 +2079,465.0870,579.5290,846.0809 +2080,464.2410,581.2990,858.9979 +2081,463.3350,582.9950,872.1089 +2082,462.3870,584.6030,885.3379 +2083,461.4120,586.1110,898.6099 +2084,460.4090,587.5210,911.9299 +2085,459.3780,588.8340,925.2999 +2086,458.3170,590.0500,938.7209 +2087,457.2260,591.1700,952.1959 +2088,456.1060,592.1950,965.7249 +2089,454.9550,593.1250,979.3099 +2090,453.7750,593.9600,992.9499 +2091,452.5640,594.7020,1006.6489 +2092,451.3530,595.3750,1020.3689 +2093,450.1700,596.0010,1034.0789 +2094,449.0110,596.5800,1047.7789 +2095,447.8750,597.1110,1061.4789 +2096,446.7600,597.5910,1075.1589 +2097,445.6630,598.0220,1088.8389 +2098,444.5850,598.4020,1102.5189 +2099,443.5230,598.7300,1116.1789 +2100,442.4760,599.0070,1129.8389 From 01c295f8a73923a3e08e10bd716e12c59296876b Mon Sep 17 00:00:00 2001 From: wk2500 <97990166+wk2500@users.noreply.github.com> Date: Thu, 27 Aug 2026 12:35:23 -0600 Subject: [PATCH 9/9] Added solver for TOA energy balance --- TwoLayerModel_VarEm.ipynb | 217 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 208 insertions(+), 9 deletions(-) diff --git a/TwoLayerModel_VarEm.ipynb b/TwoLayerModel_VarEm.ipynb index 32fe4db..11dcd9f 100644 --- a/TwoLayerModel_VarEm.ipynb +++ b/TwoLayerModel_VarEm.ipynb @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 1, "id": "5a97f75f", "metadata": {}, "outputs": [], @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 2, "id": "d1e23954", "metadata": {}, "outputs": [ @@ -162,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 3, "id": "ae37d38f", "metadata": {}, "outputs": [], @@ -336,7 +336,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "id": "56a65175", "metadata": {}, "outputs": [ @@ -430,14 +430,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "40f7bfa2", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1d95c8c589a341c99f5ab9712aef7bd2", + "model_id": "a6f8ad2fea2340279b5c4f120e559a9a", "version_major": 2, "version_minor": 0 }, @@ -562,14 +562,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 6, "id": "25ac554d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8a099da68e1f4a0fb3d5331bb560a8f1", + "model_id": "a836e0ca32ab4b19bb68504b69f2d87c", "version_major": 2, "version_minor": 0 }, @@ -781,6 +781,205 @@ ");" ] }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8669b810", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f2cc8f4e723b48c4b381f7cc78f409ca", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=340.456103241753, description='C_o [W.yr/m2/K]', max=700.0, min=50.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Controller for zero TOA imbalance (incoming shortwave = OLR)\n", + "#\n", + "# Same closed-loop, two-phase (ramp-in then full control) structure as the\n", + "# constant-T_a controller above, but with a different control target: instead\n", + "# of pinning Ta at a fixed value, each year the controller solves for the\n", + "# d_alpha that makes incoming shortwave equal outgoing longwave -- i.e. zeros\n", + "# the net TOA imbalance Q -- given the atmospheric temperature at the start of\n", + "# that year.\n", + "#\n", + "# t < 2035 : no SAI, baseline warming under the CO2 scenario\n", + "# 2035 <= t < 2045 : ramp-in -- each year the controller solves for the\n", + "# d_alpha that would make Q = 0 given the current Ta,\n", + "# then applies only a linearly increasing fraction of\n", + "# it (0 -> 1 over the decade)\n", + "# t >= 2045 : full control -- each year the controller re-solves\n", + "# for the d_alpha that zeros Q and applies it in full\n", + "#\n", + "# Unlike the constant-T_a controller, this target is purely radiative: Q\n", + "# doesn't depend on the atmosphere-ocean exchange term gamma_ao*(Ta-To), so\n", + "# the solve doesn't need To either. Setting Q = 0 in\n", + "# Q = S(1 - alpha0 - d_alpha) - eps(CO2(t))*sigma*Ta^4\n", + "# and solving for d_alpha gives\n", + "# d_alpha = (1 - alpha0) - eps(CO2(t))*sigma*Ta^4 / S\n", + "# Because this is solved from the current (not a frozen-target) Ta, Ta is\n", + "# still free to drift year to year -- the controller only holds the annual\n", + "# imbalance at zero, not the temperature itself.\n", + "\n", + "def controller_d_alpha_step_qbal(Ta, t_year, scenario):\n", + " \"\"\"SAI albedo offset that makes S(1-alpha) = OLR (zero TOA imbalance) at the given Ta.\"\"\"\n", + " eps = emissivity(co2_ppm(t_year, scenario=scenario))\n", + " d_alpha = (1 - alpha0) - eps * SIGMA * Ta**4 / S\n", + " return max(d_alpha, 0.0) # SAI only adds reflective aerosol -- no negative injection\n", + "\n", + "\n", + "def run_controller_ebm_qbal(C_o=C_OCEAN, gamma_ao=GAMMA_AO, scenario='ssp245',\n", + " t_span=(1850, 2100), pts_per_year=8):\n", + " \"\"\"\n", + " Integrate the two-layer EBM one calendar year at a time, re-solving the\n", + " Q=0 controller's d_alpha at the start of each year (see module docstring\n", + " above) and holding it fixed while that year is integrated.\n", + "\n", + " Returns\n", + " -------\n", + " t, Ta, To, Q, d_alpha : all on the same fine (sub-year) grid.\n", + " \"\"\"\n", + " C_a = C_ATMOS\n", + " t0, t_end = t_span\n", + " years = np.arange(t0, t_end)\n", + "\n", + " t_chunks, Ta_chunks, To_chunks, da_chunks = [], [], [], []\n", + " y = [T0, T0]\n", + "\n", + " for yr in years:\n", + " if yr < CTRL_START:\n", + " d_alpha = 0.0\n", + " else:\n", + " d_alpha_full = controller_d_alpha_step_qbal(y[0], yr, scenario)\n", + " ramp_frac = min(1.0, (yr - CTRL_START + 1) / CTRL_RAMP)\n", + " d_alpha = ramp_frac * d_alpha_full\n", + "\n", + " t_eval = np.linspace(yr, yr + 1, pts_per_year, endpoint=False)\n", + " sol = solve_ivp(lambda t, yy: _layer_derivs_fixed_alpha(t, yy, C_a, C_o, gamma_ao,\n", + " d_alpha, scenario),\n", + " (yr, yr + 1), y, t_eval=t_eval,\n", + " method='BDF', rtol=1e-8, atol=1e-10, dense_output=True)\n", + "\n", + " t_chunks.append(sol.t)\n", + " Ta_chunks.append(sol.y[0])\n", + " To_chunks.append(sol.y[1])\n", + " da_chunks.append(np.full_like(sol.t, d_alpha))\n", + " y = sol.sol(yr + 1) # true state at the year boundary -- see the same\n", + " # note in run_controller_ebm above\n", + "\n", + " t = np.concatenate(t_chunks)\n", + " Ta = np.concatenate(Ta_chunks)\n", + " To = np.concatenate(To_chunks)\n", + " d_alpha_t = np.concatenate(da_chunks)\n", + "\n", + " eps_t = emissivity(np.array([co2_ppm(ti, scenario=scenario) for ti in t]))\n", + " Q = S * (1 - (alpha0 + d_alpha_t)) - eps_t * SIGMA * Ta**4\n", + " return t, Ta, To, Q, d_alpha_t\n", + "\n", + "\n", + "def plot_controller_ebm_qbal(C_o, gamma_ao, scenario):\n", + " t_c, Ta_c, To_c, Q_c, da_c = run_controller_ebm_qbal(C_o=C_o, gamma_ao=gamma_ao, scenario=scenario)\n", + " t_b, Ta_b, To_b, Q_b = run_ebm(C_o=C_o, gamma_ao=gamma_ao, scenario=scenario, d_alpha=0.0)\n", + "\n", + " fig, axes = plt.subplots(3, 2, figsize=(15, 15), gridspec_kw={'height_ratios': [1, 1, 1.15]})\n", + " fig.subplots_adjust(hspace=0.45, wspace=0.3)\n", + "\n", + " fig.suptitle(f'Two-Layer EBM | Zero-Imbalance (Q=0) SAI Controller | {scenario.upper()} | '\n", + " f'C_o={C_o:.0f} W.yr/m2/K, gamma_ao={gamma_ao:.2f}',\n", + " fontsize=12, fontweight='bold')\n", + "\n", + " # -- Atmospheric temperature -----------------------------------------------\n", + " ax = axes[0, 0]\n", + " ax.plot(t_b, Ta_b, color='#d7191c', lw=2, label='No SAI (baseline)')\n", + " ax.plot(t_c, Ta_c, color='#2c7bb6', lw=2, label='Controller (Q = 0)')\n", + " ax.set(title='Atmospheric temperature', ylabel='T_a [K]', xlabel='Year')\n", + "\n", + " # -- Ocean temperature change ----------------------------------------------\n", + " ax = axes[0, 1]\n", + " ax.plot(t_b, To_b - T0, color='#d7191c', lw=2, label='No SAI (baseline)')\n", + " ax.plot(t_c, To_c - T0, color='#2c7bb6', lw=2, label='Controller')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Ocean temperature change', ylabel='dT_o [K]', xlabel='Year')\n", + "\n", + " # -- Energy imbalance + ocean heat uptake ----------------------------------\n", + " ax = axes[1, 0]\n", + " ax.plot(t_b, Q_b, color='#d7191c', lw=2, label='Q (TOA), no SAI')\n", + " ax.plot(t_c, Q_c, color='#2c7bb6', lw=2, label='Q (TOA), controller')\n", + " ax.plot(t_b, gamma_ao * (Ta_b - To_b), color=\"#fe9408\", lw=1.3, ls=':', label='Ocean uptake, no SAI')\n", + " ax.plot(t_c, gamma_ao * (Ta_c - To_c), color=\"#00fad5\", lw=1.3, ls=':', label='Ocean uptake, controller')\n", + " ax.axhline(0, color='k', lw=0.8, alpha=0.4)\n", + " ax.set(title='Energy imbalance & ocean heat uptake', ylabel='W/m2', xlabel='Year')\n", + "\n", + " # -- CO2 concentration & atmospheric emissivity -----------------------------\n", + " ax = axes[1, 1]\n", + " CO2_c = np.array([co2_ppm(ti, scenario=scenario) for ti in t_c])\n", + " eps_c = emissivity(CO2_c)\n", + " ln1 = ax.plot(t_c, CO2_c, color='#8c510a', lw=2, label='CO2 [ppm]')\n", + " ax.set(title='CO2 concentration & atmospheric emissivity', ylabel='CO2 [ppm]', xlabel='Year')\n", + " ax2 = ax.twinx()\n", + " ln2 = ax2.plot(t_c, eps_c, color='#01665e', lw=2, ls='--', label='eps(CO2)')\n", + " ax2.set_ylabel('emissivity eps [-]')\n", + " ax2.grid(False)\n", + " lns = ln1 + ln2\n", + " ax.legend(lns, [l.get_label() for l in lns], fontsize=8, loc='upper left')\n", + "\n", + " # -- Controller SAI injection ------------------------------------------------\n", + " ax = axes[2, 0]\n", + " ax.plot(t_c, da_c, color='#762a83', lw=2, label='SAI d_alpha (solved)')\n", + " ax.set(title='Controller SAI injection', ylabel='d_alpha [-]', xlabel='Year')\n", + " ax.legend(fontsize=8)\n", + "\n", + " for ax in axes.flat[:-1]:\n", + " ax.axvline(2023, color='k', ls='--', lw=1, alpha=0.4)\n", + " ax.axvline(CTRL_START, color='navy', ls=':', lw=1.5, alpha=0.5)\n", + " ax.axvline(CTRL_START + CTRL_RAMP, color='steelblue', ls=':', lw=1.0, alpha=0.5)\n", + " for ax in [axes[0, 0], axes[0, 1], axes[1, 0]]:\n", + " ax.legend(fontsize=8)\n", + "\n", + " # -- Incoming shortwave vs. OLR, colored by year (controller run) ----------\n", + " # Annual means -- one point per calendar year, rather than one point per\n", + " # sub-year integration step, since the sub-year spread within a year is a\n", + " # real but uninteresting transient (see the per-year re-solve above) that\n", + " # otherwise dominates the plot. Post-ramp, points should sit almost\n", + " # exactly on the Q=0 line by construction.\n", + " ax5 = axes[2, 1]\n", + " S_in = S * (1 - (alpha0 + da_c))\n", + " OLR_c = eps_c * SIGMA * Ta_c**4\n", + "\n", + " year_labels, year_idx = np.unique(np.floor(t_c).astype(int), return_inverse=True)\n", + " counts = np.bincount(year_idx)\n", + " S_in_annual = np.bincount(year_idx, weights=S_in) / counts\n", + " OLR_annual = np.bincount(year_idx, weights=OLR_c) / counts\n", + "\n", + " lims = [min(OLR_annual.min(), S_in_annual.min()), max(OLR_annual.max(), S_in_annual.max())]\n", + " ax5.plot(lims, lims, color='k', lw=0.8, ls='--', alpha=0.4, label='S(1-a) = OLR (Q = 0)')\n", + " sc = ax5.scatter(OLR_annual, S_in_annual, c=year_labels, cmap='viridis', s=14, edgecolor='none')\n", + " fig.colorbar(sc, ax=ax5, label='Year', pad=0.01)\n", + " ax5.set(title='Incoming shortwave vs. OLR (controller run, annual means)',\n", + " xlabel='OLR = eps(CO2)*sigma*T_a^4 [W/m2]', ylabel='S(1 - alpha(t)) [W/m2]')\n", + " ax5.legend(fontsize=8, loc='upper left')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "interact(\n", + " plot_controller_ebm_qbal,\n", + " C_o = FloatSlider(value=C_OCEAN, min=50.0, max=700.0, step=10.0, description='C_o [W.yr/m2/K]', style={'description_width': 'initial'}),\n", + " gamma_ao = FloatSlider(value=GAMMA_AO, min=0.5, max=20.0, step=0.5, description='gamma_ao [W/m2/K]', style={'description_width': 'initial'}, readout_format='.2f'),\n", + " scenario = Dropdown(options=['none', 'ssp126', 'ssp245', 'ssp585'], value='ssp245', description='CO2 scenario'),\n", + ");\n" + ] + }, { "cell_type": "markdown", "id": "c18d8dfb", @@ -797,7 +996,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 7, "id": "58479917", "metadata": {}, "outputs": [