{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "6c6379c0", "metadata": {}, "outputs": [], "source": [ "#Import libraries\n", "import numpy as np\n", "import xarray as xr\n", "import scipy\n", "from scipy import stats\n", "import scipy.special as sp\n", "import matplotlib.pyplot as plt\n", "import matplotlib.cm as cm\n", "from matplotlib.patches import Patch\n", "from matplotlib.lines import Line2D\n", "from matplotlib.colors import ListedColormap\n", "import cartopy.crs as ccrs\n", "import cartopy.feature as cfeature\n", "from glob import glob\n", "import os\n", "import warnings\n", "import pandas as pd" ] }, { "cell_type": "code", "execution_count": null, "id": "338d98b6", "metadata": {}, "outputs": [], "source": [ "dir_data = '/Users/jzhang/Documents/Data/'\n", "dir_proj = '/Users/jzhang/Documents/Projects/Albedo_Symmetry_WE/codes/'\n", "dir_fig = '/Users/jzhang/Documents/Projects/Albedo_Symmetry_WE/figs/paper_figs/'\n", "model_long = ['CanESM5','CESM2-WACCM','GFDL-ESM4', 'MIROC6', 'GISS-E2-1-H', 'UKESM1-0-LL','IPSL-CM6A-LR','MPI-ESM1-2']\n", "model_short = ['CanESM', 'CESM2', 'GFDL', 'MIROC6', 'GISS_H', 'UKESM', 'IPSL', 'MPI']\n", "G6_index = [1, 5, 6, 7]\n", "tmpd = ['1850-1870 (PI)','1940-1960 (MC)','1995-2015 (PD)','2080-2100 (EOC)']" ] }, { "cell_type": "code", "execution_count": 3, "id": "468c8bd0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loading data for CanESM... CanESM5\n", "Loading data for CESM2... CESM2-WACCM\n", "Loading data for GFDL... GFDL-ESM4\n", "Loading data for MIROC6... MIROC6\n", "Loading data for GISS_H... GISS-E2-1-H\n", "Loading data for UKESM... UKESM1-0-LL\n", "Loading data for IPSL... IPSL-CM6A-LR\n", "Loading data for MPI... MPI-ESM1-2\n" ] } ], "source": [ "# load results\n", "for i, md in enumerate(model_short):\n", " print(f'Loading data for {md}...', model_long[i])\n", " data = np.load(dir_data+'CMIP6/'+model_long[i]+f'/{md}_Symmetry_LON_PI_MC_PD_EOC_20yrs.npz')\n", " if i == 0:\n", " dR_all = data['dR'][np.newaxis,:,:]\n", " dR_cld_all = data['dR_cld'][np.newaxis,:,:]\n", " dR_clr_all = data['dR_clr'][np.newaxis,:,:]\n", " dO_all = data['dO'][np.newaxis,:,:]\n", " symmetry_all = data['symmetry'][np.newaxis,:]\n", " dR_intann_sym_all = data['dR_intann_sym'][np.newaxis,:,:]\n", " dR_intann_27_all = data['dR_intann_27'][np.newaxis,:,:]\n", " ewR_sym_all = data['ewR_sym'][np.newaxis,:,:]\n", " ewR_sym_cld_all = data['ewR_sym_cld'][np.newaxis,:,:]\n", " ewR_sym_clr_all = data['ewR_sym_clr'][np.newaxis,:,:]\n", " ewO_sym_all = data['ewO_sym'][np.newaxis,:,:]\n", " ewR_27_all = data['ewR_27'][np.newaxis,:,:]\n", " ewR_27_cld_all = data['ewR_27_cld'][np.newaxis,:,:]\n", " ewR_27_clr_all = data['ewR_27_clr'][np.newaxis,:,:]\n", " ewO_27_all = data['ewO_27'][np.newaxis,:,:]\n", " else:\n", " dR_all = np.concatenate((dR_all, data['dR'][np.newaxis,:,:]), axis=0)\n", " dR_cld_all = np.concatenate((dR_cld_all, data['dR_cld'][np.newaxis,:,:]), axis=0)\n", " dR_clr_all = np.concatenate((dR_clr_all, data['dR_clr'][np.newaxis,:,:]), axis=0)\n", " dO_all = np.concatenate((dO_all, data['dO'][np.newaxis,:,:]), axis=0)\n", " symmetry_all = np.concatenate((symmetry_all, data['symmetry'][np.newaxis,:]), axis=0)\n", " dR_intann_sym_all = np.concatenate((dR_intann_sym_all, data['dR_intann_sym'][np.newaxis,:,:]), axis=0)\n", " dR_intann_27_all = np.concatenate((dR_intann_27_all, data['dR_intann_27'][np.newaxis,:,:]), axis=0)\n", " ewR_sym_all = np.concatenate((ewR_sym_all, data['ewR_sym'][np.newaxis,:,:]), axis=0)\n", " ewR_sym_cld_all = np.concatenate((ewR_sym_cld_all, data['ewR_sym_cld'][np.newaxis,:,:]), axis=0)\n", " ewR_sym_clr_all = np.concatenate((ewR_sym_clr_all, data['ewR_sym_clr'][np.newaxis,:,:]), axis=0)\n", " ewO_sym_all = np.concatenate((ewO_sym_all, data['ewO_sym'][np.newaxis,:,:]), axis=0)\n", " ewR_27_all = np.concatenate((ewR_27_all, data['ewR_27'][np.newaxis,:,:]), axis=0)\n", " ewR_27_cld_all = np.concatenate((ewR_27_cld_all, data['ewR_27_cld'][np.newaxis,:,:]), axis=0)\n", " ewR_27_clr_all = np.concatenate((ewR_27_clr_all, data['ewR_27_clr'][np.newaxis,:,:]), axis=0)\n", " ewO_27_all = np.concatenate((ewO_27_all, data['ewO_27'][np.newaxis,:,:]), axis=0)" ] }, { "cell_type": "code", "execution_count": 4, "id": "b338f188", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loading data for CanESM... CanESM5\n", "Loading data for CESM2... CESM2-WACCM\n", "Loading data for GFDL... GFDL-ESM4\n", "Loading data for MIROC6... MIROC6\n", "Loading data for GISS_H... GISS-E2-1-H\n", "Loading data for UKESM... UKESM1-0-LL\n", "Loading data for IPSL... IPSL-CM6A-LR\n", "Loading data for MPI... MPI-ESM1-2\n" ] } ], "source": [ "# load results N-S symmetry\n", "for i, md in enumerate(model_short):\n", " print(f'Loading data for {md}...', model_long[i])\n", " data = np.load(dir_data+'CMIP6/'+model_long[i]+f'/{md}_Symmetry_NS_PI_MC_PD_EOC_20yrs.npz')\n", " if i == 0:\n", " dR_NS_all = data['dR'][np.newaxis,:]\n", " dR_NS_cld_all = data['dR_cld'][np.newaxis,:]\n", " dR_NS_clr_all = data['dR_clr'][np.newaxis,:]\n", " dR_intann_NS_sym_all = data['dR_intann_sym'][np.newaxis,:,:]\n", " nsR_NS_sym_all = data['nsR_sym'][np.newaxis,:,:]\n", " nsR_NS_sym_cld_all = data['nsR_sym_cld'][np.newaxis,:,:]\n", " nsR_NS_sym_clr_all = data['nsR_sym_clr'][np.newaxis,:,:]\n", " else:\n", " dR_NS_all = np.concatenate((dR_NS_all, data['dR'][np.newaxis,:]), axis=0)\n", " dR_NS_cld_all = np.concatenate((dR_NS_cld_all, data['dR_cld'][np.newaxis,:]), axis=0)\n", " dR_NS_clr_all = np.concatenate((dR_NS_clr_all, data['dR_clr'][np.newaxis,:]), axis=0)\n", " dR_intann_NS_sym_all = np.concatenate((dR_intann_NS_sym_all, data['dR_intann_sym'][np.newaxis,:,:]), axis=0)\n", " nsR_NS_sym_all = np.concatenate((nsR_NS_sym_all, data['nsR_sym'][np.newaxis,:,:]), axis=0)\n", " nsR_NS_sym_cld_all = np.concatenate((nsR_NS_sym_cld_all, data['nsR_sym_cld'][np.newaxis,:,:]), axis=0)\n", " nsR_NS_sym_clr_all = np.concatenate((nsR_NS_sym_clr_all, data['nsR_sym_clr'][np.newaxis,:,:]), axis=0)" ] }, { "cell_type": "code", "execution_count": null, "id": "d3e656a4", "metadata": {}, "outputs": [], "source": [ "#load results from .npz file for observations\n", "results = np.load(dir_proj+'EBAF_FBCT_diff_record_symmetry_results.npz')\n", "results_NS = np.load(dir_proj+'EBAF_FBCT_diff_record_symmetry_results_NS.npz')\n", "results_NS_hemi = np.load(dir_proj+'EBAF_FBCT_diff_record_symmetry_results_NS_hemi.npz')\n", "results_interannual = np.load(dir_proj+'EBAF_FBCT_diff_record_symmetry_interannual_results.npz')\n", "results_interannual_NS = np.load(dir_proj+'EBAF_FBCT_diff_record_symmetry_interannual_results_NS.npz')" ] }, { "cell_type": "code", "execution_count": null, "id": "1d094f0e", "metadata": {}, "outputs": [], "source": [ "# load results from CERES\n", "fTr = xr.open_dataset(dir_data+'CERES/EBAFed421/EBAF_gavg_jz_3catnew_01-24_27degree.nc')\n", "\n", "months = np.array([np.datetime64('2001-01')+np.timedelta64(i,'M') for i in range(12*(2024-2001+1))])\n", "Mwts = np.array((months+np.timedelta64(1,'M')+np.timedelta64(1,'D'))-(months+np.timedelta64(1,'D')),dtype=float)\n", "\n", "dR_obs=results['ebaf_01_24'][26,0]\n", "dO_obs=results['ebaf_01_24'][26,1]\n", "\n", "dR_obs_yr=results_interannual['ebaf_01_24'][:,0]\n", "dO_obs_yr=results_interannual['ebaf_01_24'][:,1]\n", "\n", "ewR_obs=np.array([np.average(fTr['R'].sel(reg='EH'),weights=Mwts), np.average(fTr['R'].sel(reg='WH'),weights=Mwts)])\n", "ewR_obs_yr = np.array([[np.average(fTr['R'].sel(reg='EH').isel(time=slice(y*12,(y+1)*12)),weights=Mwts[y*12:(y+1)*12]),\n", " np.average(fTr['R'].sel(reg='WH').isel(time=slice(y*12,(y+1)*12)),weights=Mwts[y*12:(y+1)*12])]\n", " for y in range(2024-2001+1)])\n", "\n", "nsR_obs=np.array([results_NS_hemi['ebaf_01_24'][0], results_NS_hemi['ebaf_01_24'][1]])\n", "\n", "ewR_cld_obs=np.array([np.average(fTr['R_cld'].sel(reg='EH'),weights=Mwts), np.average(fTr['R_cld'].sel(reg='WH'),weights=Mwts)])\n", "ewR_cld_obs_yr = np.array([[np.average(fTr['R_cld'].sel(reg='EH').isel(time=slice(y*12,(y+1)*12)),weights=Mwts[y*12:(y+1)*12]),\n", " np.average(fTr['R_cld'].sel(reg='WH').isel(time=slice(y*12,(y+1)*12)),weights=Mwts[y*12:(y+1)*12])]\n", " for y in range(2024-2001+1)])" ] }, { "cell_type": "code", "execution_count": 7, "id": "44e25369", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loading data for CESM2... CESM2-WACCM\n", "Loading data for UKESM... UKESM1-0-LL\n", "Loading data for IPSL... IPSL-CM6A-LR\n", "Loading data for MPI... MPI-ESM1-2\n" ] } ], "source": [ "# load G6sulfur results\n", "for i in G6_index:\n", " md = model_short[i]\n", " print(f'Loading data for {md}...', model_long[i])\n", " data = np.load(dir_data+'CMIP6/'+model_long[i]+f'/{md}_Symmetry_LON_MC-SAI_EOC-SAI_20yrs.npz')\n", " if i == G6_index[0]:\n", " dR_SAI_all = data['dR'][np.newaxis,:,:]\n", " dR_cld_SAI_all = data['dR_cld'][np.newaxis,:,:]\n", " dR_clr_SAI_all = data['dR_clr'][np.newaxis,:,:]\n", " dO_SAI_all = data['dO'][np.newaxis,:,:]\n", " symmetry_SAI_all = data['symmetry'][np.newaxis,:]\n", " dR_intann_sym_SAI_all = data['dR_intann_sym'][np.newaxis,:,:]\n", " dR_intann_27_SAI_all = data['dR_intann_27'][np.newaxis,:,:]\n", " ewR_sym_SAI_all = data['ewR_sym'][np.newaxis,:,:]\n", " ewR_sym_cld_SAI_all = data['ewR_sym_cld'][np.newaxis,:,:]\n", " ewR_sym_clr_SAI_all = data['ewR_sym_clr'][np.newaxis,:,:]\n", " ewO_sym_SAI_all = data['ewO_sym'][np.newaxis,:,:]\n", " ewR_27_SAI_all = data['ewR_27'][np.newaxis,:,:]\n", " ewR_27_cld_SAI_all = data['ewR_27_cld'][np.newaxis,:,:]\n", " ewR_27_clr_SAI_all = data['ewR_27_clr'][np.newaxis,:,:]\n", " ewO_27_SAI_all = data['ewO_27'][np.newaxis,:,:]\n", " else:\n", " dR_SAI_all = np.concatenate((dR_SAI_all, data['dR'][np.newaxis,:,:]), axis=0)\n", " dR_cld_SAI_all = np.concatenate((dR_cld_SAI_all, data['dR_cld'][np.newaxis,:,:]), axis=0)\n", " dR_clr_SAI_all = np.concatenate((dR_clr_SAI_all, data['dR_clr'][np.newaxis,:,:]), axis=0)\n", " dO_SAI_all = np.concatenate((dO_SAI_all, data['dO'][np.newaxis,:,:]), axis=0)\n", " symmetry_SAI_all = np.concatenate((symmetry_SAI_all, data['symmetry'][np.newaxis,:]), axis=0)\n", " dR_intann_sym_SAI_all = np.concatenate((dR_intann_sym_SAI_all, data['dR_intann_sym'][np.newaxis,:,:]), axis=0)\n", " dR_intann_27_SAI_all = np.concatenate((dR_intann_27_SAI_all, data['dR_intann_27'][np.newaxis,:,:]), axis=0)\n", " ewR_sym_SAI_all = np.concatenate((ewR_sym_SAI_all, data['ewR_sym'][np.newaxis,:,:]), axis=0)\n", " ewR_sym_cld_SAI_all = np.concatenate((ewR_sym_cld_SAI_all, data['ewR_sym_cld'][np.newaxis,:,:]), axis=0)\n", " ewR_sym_clr_SAI_all = np.concatenate((ewR_sym_clr_SAI_all, data['ewR_sym_clr'][np.newaxis,:,:]), axis=0)\n", " ewO_sym_SAI_all = np.concatenate((ewO_sym_SAI_all, data['ewO_sym'][np.newaxis,:,:]), axis=0)\n", " ewR_27_SAI_all = np.concatenate((ewR_27_SAI_all, data['ewR_27'][np.newaxis,:,:]), axis=0)\n", " ewR_27_cld_SAI_all = np.concatenate((ewR_27_cld_SAI_all, data['ewR_27_cld'][np.newaxis,:,:]), axis=0)\n", " ewR_27_clr_SAI_all = np.concatenate((ewR_27_clr_SAI_all, data['ewR_27_clr'][np.newaxis,:,:]), axis=0)\n", " ewO_27_SAI_all = np.concatenate((ewO_27_SAI_all, data['ewO_27'][np.newaxis,:,:]), axis=0)" ] }, { "cell_type": "code", "execution_count": 8, "id": "93db4269", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loading data for CESM2... CESM2-WACCM\n", "Loading data for UKESM... UKESM1-0-LL\n", "Loading data for IPSL... IPSL-CM6A-LR\n", "Loading data for MPI... MPI-ESM1-2\n" ] } ], "source": [ "# load results N-S symmetry G6sulfur\n", "for i in G6_index:\n", " md = model_short[i]\n", " print(f'Loading data for {md}...', model_long[i])\n", " data = np.load(dir_data+'CMIP6/'+model_long[i]+f'/{md}_Symmetry_NS_MC-SAI_EOC-SAI_20yrs.npz')\n", " if i == G6_index[0]:\n", " dR_NS_SAI_all = data['dR'][np.newaxis,:]\n", " dR_NS_SAI_cld_all = data['dR_cld'][np.newaxis,:]\n", " dR_NS_SAI_clr_all = data['dR_clr'][np.newaxis,:]\n", " dR_intann_NS_SAI_sym_all = data['dR_intann_sym'][np.newaxis,:,:]\n", " nsR_NS_SAI_sym_all = data['nsR_sym'][np.newaxis,:,:]\n", " nsR_NS_SAI_sym_cld_all = data['nsR_sym_cld'][np.newaxis,:,:]\n", " nsR_NS_SAI_sym_clr_all = data['nsR_sym_clr'][np.newaxis,:,:]\n", " else:\n", " dR_NS_SAI_all = np.concatenate((dR_NS_SAI_all, data['dR'][np.newaxis,:]), axis=0)\n", " dR_NS_SAI_cld_all = np.concatenate((dR_NS_SAI_cld_all, data['dR_cld'][np.newaxis,:]), axis=0)\n", " dR_NS_SAI_clr_all = np.concatenate((dR_NS_SAI_clr_all, data['dR_clr'][np.newaxis,:]), axis=0)\n", " dR_intann_NS_SAI_sym_all = np.concatenate((dR_intann_NS_SAI_sym_all, data['dR_intann_sym'][np.newaxis,:,:]), axis=0)\n", " nsR_NS_SAI_sym_all = np.concatenate((nsR_NS_SAI_sym_all, data['nsR_sym'][np.newaxis,:,:]), axis=0)\n", " nsR_NS_SAI_sym_cld_all = np.concatenate((nsR_NS_SAI_sym_cld_all, data['nsR_sym_cld'][np.newaxis,:,:]), axis=0)\n", " nsR_NS_SAI_sym_clr_all = np.concatenate((nsR_NS_SAI_sym_clr_all, data['nsR_sym_clr'][np.newaxis,:,:]), axis=0)" ] }, { "cell_type": "code", "execution_count": null, "id": "2558ee93", "metadata": {}, "outputs": [], "source": [ "# calculate 95% confidence intervals for the mean of a time series, accounting for autocorrelation using an AR(1) model\n", "# this is assuming a red noise process, which is common for climate data. \n", "# The function returns the mean, lag-1 autocorrelation (phi), effective sample size (Neff), standard error (SE), and 95% confidence interval (CI95) for the mean. \n", "# The input is a 1D array of values (e.g., annual means) with optional detrending and bias correction for phi.\n", "\n", "def ar1_uncertainty_mean(x, detrend=True, bias_correct_phi=True):\n", " \"\"\"\n", " x: 1D array of (annual) values; NaNs allowed.\n", " Returns dict with mean, phi, Neff, SE, CI95.\n", " \"\"\"\n", " x = np.asarray(x, float)\n", " x = x[np.isfinite(x)]\n", " N = x.size\n", " if N < 3:\n", " raise ValueError(\"Need at least 3 finite points.\")\n", "\n", " # Detrend -> anomalies\n", " if detrend:\n", " t = np.arange(N)\n", " slope, intercept, *_ = stats.linregress(t, x)\n", " x_anom = x - (intercept + slope*t)\n", " else:\n", " x_anom = x - np.nanmean(x)\n", "\n", " # Sample variance (unbiased)\n", " s = np.nanstd(x_anom, ddof=1)\n", "\n", " # Lag-1 autocorrelation (Yule-Walker style)\n", " x0 = x_anom[:-1] - x_anom[:-1].mean()\n", " x1 = x_anom[1:] - x_anom[1:].mean()\n", " phi = np.sum(x0*x1) / np.sum(x0*x0)\n", " #phi = np.corrcoef(x_anom[:-1],x_anom[1:])[0,1]\n", "\n", " # Small-sample bias correction (Quenouille)\n", " if bias_correct_phi:\n", " phi = phi * (1 + 1/N)\n", "\n", " # Effective sample size\n", " phi = np.clip(phi, -0.99, 0.99)\n", " Neff = N * (1 - phi) / (1 + phi)\n", " Neff = float(np.clip(Neff, 1.0, N))\n", "\n", " # SE of the mean\n", " SE = s / np.sqrt(Neff)\n", "\n", " # Mean of original series (not anomalies)\n", " xbar = np.nanmean(x)\n", "\n", " # 95% CI using t with effective dof\n", " dof = max(1, Neff - 1)\n", " tcrit = stats.t.ppf(0.975, dof)\n", " #CI95 = (xbar - tcrit*SE, xbar + tcrit*SE)\n", " CI95 = tcrit*SE\n", "\n", " return dict(mean=xbar, phi=phi, N=N, Neff=Neff, s=s, SE=SE, CI95=CI95)" ] }, { "cell_type": "code", "execution_count": null, "id": "a1d8bd83", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-0.24432806160146098 0.10455778380666629 -0.2604498906295573\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# supplement fig. 9\n", "\n", "from matplotlib.patches import Ellipse\n", "\n", "# Plot dR (E-W symmetry) vs dR_NS (N-S symmetry) for all models and time periods\n", "plt.figure(figsize=(9, 7))\n", "plt.clf()\n", "fs = 19\n", "\n", "colors = ['blue','red','orange','yellow','green','cyan','magenta','olive']\n", "\n", "dv = 26 # idx 26 is 27 E \n", "\n", "for t in range(len(tmpd)):\n", " for i, md in enumerate(model_short):\n", " if t == 0:\n", " marker = '<'\n", " elif t == 1:\n", " continue\n", " elif t == 2:\n", " marker = 's'\n", " elif t == 3:\n", " marker = '>'\n", "\n", " plt.scatter(dR_NS_all[i, t], dR_all[i, dv, t],\n", " s=200, c=colors[i], edgecolors='k', linewidths=1.5,\n", " zorder=10, marker=marker, alpha=0.75)\n", " annual_values_NS = dR_intann_NS_sym_all[i, :, t]\n", " annual_values_EW = dR_intann_27_all[i, :, t] \n", " uncertainty_NS = ar1_uncertainty_mean(annual_values_NS)['CI95']\n", " uncertainty_EW = ar1_uncertainty_mean(annual_values_EW)['CI95']\n", " plt.errorbar(dR_NS_all[i, t], dR_all[i, dv, t], xerr=uncertainty_NS, yerr=uncertainty_EW, color=colors[i], capsize=0, lw=2, zorder=6)\n", "\n", "\n", "# calculate linear regression and confidence interval, but do not plot\n", "mdl_idx = np.arange(len(model_short))\n", "time_idx = [0, 1, 2, 3]\n", "\n", "x = dR_NS_all[np.ix_(mdl_idx, time_idx)].ravel()\n", "y = dR_all[np.ix_(mdl_idx, [dv], time_idx)].ravel()\n", "# add dR_SAI_all and dR_NS_SAI_all for G6Sulfur points\n", "x = np.concatenate((x, dR_NS_SAI_all[np.ix_([0,1,2,3], [0,1])].ravel()))\n", "y = np.concatenate((y, dR_SAI_all[np.ix_([0,1,2,3], [dv], [0,1])].ravel()))\n", "n = x.size\n", "res = stats.linregress(x, y)\n", "x_line = np.linspace(-6, 6, 1200)\n", "y_line = res.intercept + res.slope * x_line\n", "print(res.slope, res.pvalue, np.corrcoef(x, y)[0, 1])\n", "tcrit = stats.t.ppf(0.975, n - 2)\n", "upper = (res.intercept-tcrit*res.intercept_stderr) + (res.slope-tcrit*res.stderr) * x_line\n", "lower = (res.intercept+tcrit*res.intercept_stderr) + (res.slope+tcrit*res.stderr) * x_line\n", "#plt.plot(x_line, y_line, c='magenta', lw=1, zorder=1)\n", "#plt.fill_between(x_line, lower, upper, color='magenta', alpha=0.08, zorder=1, linewidth=0, edgecolor='none')\n", "\n", "\n", "\n", "# CERES observation\n", "dR_NS_obs = results_NS['ebaf_01_24'][0] # N-S dR\n", "plt.scatter(dR_NS_obs, dR_obs,\n", " s=200, c='gray', edgecolors='k', linewidths=1.5,\n", " zorder=10, marker='o', alpha=0.9)\n", "annual_values_obs = results_interannual_NS['ebaf_01_24'][:] # N-S dR annual values\n", "annual_values_obs_EW = results_interannual['ebaf_01_24'][:, 0] # E-W dR annual values\n", "uncertainty_obs_NS = ar1_uncertainty_mean(annual_values_obs)['CI95']\n", "uncertainty_obs_EW = ar1_uncertainty_mean(annual_values_obs_EW)['CI95']\n", "\n", "plt.fill_between([-6,6], dR_obs-uncertainty_obs_EW, dR_obs+uncertainty_obs_EW, color='gray', alpha=0.15, zorder=4)\n", "plt.fill_betweenx([-3,6], dR_NS_obs-uncertainty_obs_NS, dR_NS_obs+uncertainty_obs_NS, color='gray', alpha=0.15, zorder=4)\n", "#plt.errorbar(dR_NS_obs, dR_obs, xerr=uncertainty_obs_NS, yerr=uncertainty_obs_EW, color='gray', capsize=0, lw=2, zorder=6)\n", "\n", "# G6Sulfur EOC points\n", "for g, mdl_idx in enumerate(G6_index):\n", " plt.scatter(dR_NS_SAI_all[g, 1], dR_SAI_all[g, dv, 1],\n", " s=200, c=colors[mdl_idx], edgecolors='k', linewidths=1.5,\n", " zorder=10, marker='>', alpha=0.75, hatch='/////')\n", " annual_values_NS = dR_intann_NS_SAI_sym_all[g, :, 1]\n", " annual_values_EW = dR_intann_27_SAI_all[g, :, 1]\n", " uncertainty_NS = ar1_uncertainty_mean(annual_values_NS)['CI95']\n", " uncertainty_EW = ar1_uncertainty_mean(annual_values_EW)['CI95']\n", " plt.errorbar(dR_NS_SAI_all[g, 1], dR_SAI_all[g, dv, 1], xerr=uncertainty_NS, yerr=uncertainty_EW, color=colors[mdl_idx], capsize=0, lw=2, zorder=6)\n", "\n", "plt.plot([-20, 20], [0, 0], 'k', lw=2, zorder=0, linestyle='dashed')\n", "plt.plot([0, 0], [-20, 20], 'k', lw=2, zorder=0, linestyle='dashed')\n", "\n", "# Legend: colored rectangles for models\n", "model_handles = [Patch(facecolor=colors[i], label=model_long[i]) for i in range(len(model_short))]\n", "\n", "# Gray markers for time periods\n", "time_markers = ['<', 's', '>', '>', 'o']\n", "tpd = ['1850-1870 (PI)', '1995-2015 (PD)', '2080-2100 (SSP3-7.0)', '2080-2100 (G6Sulfur)', 'CERES (2001-2024)']\n", "mcol = ['w', 'w', 'w', 'w', 'gray']\n", "mecol = ['k', 'k', 'k', 'k', 'k']\n", "time_handles = []\n", "for j, mk in enumerate(time_markers):\n", " if tpd[j] == '2080-2100 (G6Sulfur)':\n", " time_handles.append(\n", " plt.scatter([], [], marker='>', s=200,\n", " facecolor='white', edgecolor='k', linewidths=1.5,\n", " hatch='/////', alpha=0.75, label=tpd[j])\n", " )\n", " else:\n", " time_handles.append(\n", " Line2D([0], [0], marker=mk, linestyle='None', color='k',\n", " markerfacecolor=mcol[j], markeredgecolor=mecol[j],\n", " markersize=15, label=tpd[j])\n", " )\n", "\n", "plt.legend(handles=model_handles + time_handles, frameon=True, fontsize=fs-6,\n", " framealpha=0.7, ncol=1, loc='upper right')\n", "\n", "plt.xlabel(r'$\\Delta\\overline{R}_{\\mathrm{NS}}$, W m$^{-2}$', fontsize=fs)\n", "plt.xticks(fontsize=fs)\n", "plt.ylabel(r'$\\Delta\\overline{R}_{\\mathrm{EW}}$, W m$^{-2}$', fontsize=fs)\n", "plt.yticks(fontsize=fs)\n", "\n", "plt.grid(linewidth=0.5, color='gray', alpha=0.5)\n", "plt.axis([-6, 6, -3, 6])\n", "plt.tight_layout()\n", "\n", "plt.savefig(dir_fig + 'Zhang26_dR_EW_vs_dR_NS_scatter.png', dpi=450)\n", "plt.savefig(dir_fig + 'Zhang26_dR_EW_vs_dR_NS_scatter.pdf')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "346bc3e5", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Figure 4a\n", "\n", "# Bar plot at the current divider (dv): PD as bars, colored by dO; other periods overlaid as symbols\n", "fs = 17\n", "dv = 26 # idx 26 is 27 E \n", "pd_idx = 2\n", "other_idx = [0, 1, 3]\n", "other_labels = ['PI', 'MC', 'EOC']\n", "other_markers = ['<', 'o', '>']\n", "\n", "# Sort models by PD dR: most negative -> most positive\n", "order = np.argsort(dR_all[:, dv, pd_idx])\n", "\n", "x = np.arange(len(model_long))\n", "y_pd = dR_all[order, dv, pd_idx]\n", "c_pd = dO_all[order, dv, pd_idx]\n", "model_long_sorted = np.array(model_long)[order]\n", "\n", "norm = plt.Normalize(vmin=-0.03, vmax=0.03)\n", "cmap = plt.cm.bwr\n", "bar_colors = cmap(norm(c_pd))\n", "\n", "fig, ax = plt.subplots(figsize=(10, 6))\n", "ax.bar(x, y_pd, color=bar_colors, edgecolor='k', linewidth=2, alpha=0.9, width=0.75)\n", "#add error bars for PD bars using ar1_uncertainty_mean on the underlying annual data\n", "for i, mdl_idx in enumerate(order):\n", " # Extract annual values for the current model and PD period\n", " annual_values = dR_intann_27_all[mdl_idx, :, pd_idx] # This should be the array of annual values, not just the mean\n", " # Calculate uncertainty using the ar1_uncertainty_mean function\n", " uncertainty = ar1_uncertainty_mean(annual_values)['CI95'] # Get the 95% confidence interval (half-width)\n", " # Add error bar to the bar plot\n", " ax.errorbar(x[i], y_pd[i], yerr=uncertainty, color='k', capsize=3, lw=2, zorder=6)\n", "\n", "# Overlay other time periods as symbols (same sorted order)\n", "symcols = ['green', 'orange', 'brown']\n", "xposadj = [-0.3,-0.15,0.15]\n", "for j, (t, mk, lab) in enumerate(zip(other_idx, other_markers, other_labels)):\n", " ax.scatter(\n", " x + xposadj[j], dR_all[order, dv, t],\n", " marker=mk, s=120, color=cmap(norm(dO_all[order, dv, t])),\n", " edgecolor=symcols[j], linewidth=2, zorder=5\n", " )\n", "#add error bars for other time periods using ar1_uncertainty_mean on the underlying annual data\n", "for j, t in enumerate(other_idx):\n", " for i, mdl_idx in enumerate(order):\n", " annual_values = dR_intann_27_all[mdl_idx, :, t] # Annual values for the current model and time period\n", " uncertainty = ar1_uncertainty_mean(annual_values)['CI95'] # 95% CI\n", " ax.errorbar(x[i] + xposadj[j], dR_all[mdl_idx, dv, t], yerr=uncertainty, color=symcols[j], capsize=0, lw=2, zorder=4)\n", "\n", "#overlay G6Sulfur points for the 4 available models\n", "for g, mdl_idx in enumerate(G6_index):\n", " ax.scatter(\n", " np.where(order == mdl_idx)[0][0] + 0.3, dR_SAI_all[g, dv, 1],\n", " marker='>', s=120, color=cmap(norm(dO_SAI_all[g, dv, 1])),\n", " edgecolor='magenta', linewidth=2, zorder=5\n", " )\n", "#add error bars for G6Sulfur points using ar1_uncertainty_mean on the underlying annual data\n", "for g, mdl_idx in enumerate(G6_index):\n", " annual_values_SAI = dR_intann_27_SAI_all[g, :, 1] # Annual values for G6Sulfur EOC\n", " uncertainty_SAI = ar1_uncertainty_mean(annual_values_SAI)['CI95'] # 95% CI\n", " ax.errorbar(\n", " np.where(order == mdl_idx)[0][0] + 0.3, dR_SAI_all[g, dv, 1],\n", " yerr=uncertainty_SAI, color='magenta', capsize=0, lw=2, zorder=4\n", " )\n", "\n", "\n", "# Make obs reference and uncertainty span the full x-axis width\n", "ax.axhline(dR_obs, color='k', lw=2, zorder=8, linestyle='--')\n", "ax.axhspan(dR_obs - 0.24, dR_obs + 0.24, facecolor='gray', alpha=0.75, zorder=7)\n", "\n", "# maker info\n", "time_markers = ['s','<', 'o', '>', '>']\n", "tpd = ['1995-2015 (PD) ±95%CI','1850-1870 (PI) ±95%CI', '1940-1960 (MC) ±95%CI','2080-2100 (SSP3-7.0) ±95%CI','2080-2100 (G6Sulfur) ±95% CI']\n", "mcol = ['w','w','w','w','w']\n", "mecol = ['black','green','orange','brown','magenta']\n", "\n", "time_handles = []\n", "for j, (mk, lab) in enumerate(zip(time_markers, tpd)):\n", " time_handles.append(\n", " Line2D(\n", " [0], [0],\n", " marker=mk, linestyle='-', color=mecol[j],\n", " markerfacecolor=mcol[j], markeredgecolor=mecol[j],\n", " markersize=12, markeredgewidth=2, label=lab\n", " )\n", " )\n", "# Add CERES dashed line legend entry\n", "time_handles.append(\n", " Line2D([0], [0], color='k', lw=2, linestyle='--', label='CERES (2001-2024)')\n", ")\n", "# Add CERES 95% CI gray shading legend entry\n", "time_handles.append(\n", " Patch(facecolor='gray', alpha=0.75, label='CERES 95% CI')\n", ")\n", "\n", "ax.legend(handles=time_handles, frameon=False, fontsize=fs - 3, loc='upper left')\n", "\n", "ax.set_xticks(x)\n", "ax.set_xticklabels(model_long_sorted, rotation=30, ha='right', fontsize=fs)\n", "ax.tick_params(axis='y', labelsize=fs)\n", "ax.set_ylabel(r'$\\Delta\\overline{R}$, W m$^{-2}$', fontsize=fs)\n", "ax.grid(axis='y', linestyle='--', alpha=0.4)\n", "ax.axhline(0, color='k', linewidth=1)\n", "ax.set_ylim(-3,7)\n", "\n", "# Colorbar for dO\n", "sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)\n", "sm.set_array([])\n", "cbar = fig.colorbar(sm, ax=ax, pad=0.02, aspect=25)\n", "cbar.ax.tick_params(labelsize=fs - 2)\n", "cbar.set_label(r'$\\Delta\\overline{O}$', fontsize=fs)\n", "\n", "plt.tight_layout()\n", "plt.savefig(dir_fig+'Zhang26_fig3_GCM_bar.png', dpi=450, bbox_inches='tight')\n", "plt.savefig(dir_fig+'Zhang26_fig3_GCM_bar.pdf', bbox_inches='tight')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "b4e98cb2", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Figure 4b\n", "\n", "plt.figure(figsize=(9,9))\n", "plt.clf()\n", "fs = 25\n", "\n", "colors = ['blue','red','orange','yellow','green','cyan','magenta','olive']\n", "\n", "for t in range(len(tmpd)):\n", " for i, md in enumerate(model_short):\n", " if t == 0:\n", " marker = '<'\n", " elif t == 1:\n", " continue\n", " elif t == 2:\n", " marker = 's'\n", " elif t == 3:\n", " marker = '>'\n", "\n", " plt.scatter(ewR_sym_cld_all[i,0,t], ewR_sym_cld_all[i,1,t], \n", " s=400, c=colors[i], edgecolors='k', linewidths=1.5,\n", " zorder=10, marker=marker, alpha=0.9)\n", "\n", "plt.scatter(ewR_cld_obs[0], ewR_cld_obs[1], \n", " s=450, c='gray', edgecolors='k', linewidths=1.5,\n", " zorder=10, marker='o')\n", "\n", "for y in range(len(ewR_cld_obs_yr[:,0])):\n", " plt.plot(ewR_cld_obs_yr[y,0], ewR_cld_obs_yr[y,1], \n", " marker='.', color='k', markersize=5, zorder=11, alpha=0.5)\n", "\n", "for g, mdl_idx in enumerate(G6_index):\n", " plt.scatter(ewR_sym_cld_SAI_all[g,0,1], ewR_sym_cld_SAI_all[g,1,1], \n", " s=400, c=colors[mdl_idx], edgecolors='k', linewidths=1.5,\n", " zorder=10, marker='>', alpha=0.9, hatch='/////')\n", "\n", "plt.xlabel('EH $\\overline{\\mathrm{CRE}}$, W m$^{-2}$',fontsize=fs)\n", "plt.xticks(fontsize=fs)\n", "plt.ylabel('WH $\\overline{\\mathrm{CRE}}$, W m$^{-2}$',fontsize=fs)\n", "plt.yticks(fontsize=fs)\n", "\n", "plt.axis([33,65,33,65])\n", "\n", "\n", "# colored rectangles for models\n", "model_handles = [Patch(facecolor=colors[i], label=model_long[i]) for i in range(len(model_short))]\n", "\n", "# gray markers for time periods\n", "time_markers = ['<', 's', '>', '>', 'o']\n", "tpd = ['1850-1870 (PI)','1995-2015 (PD)','2080-2100 (SSP3-7.0)','2080-2100 (G6Sulfur)','CERES (2001-2024)']\n", "mcol = ['w','w','w','w','gray']\n", "mecol = ['k','k','k','k','k']\n", "# Line2D does not support `hatch`, so use a hatched Patch only for G6Sulfur\n", "time_handles = []\n", "for j, mk in enumerate(time_markers):\n", " if tpd[j] == '2080-2100 (G6Sulfur)':\n", " # Use a dummy scatter handle so legend matches plotted marker style\n", " time_handles.append(\n", " plt.scatter(\n", " [], [],\n", " marker='>', s=200,\n", " facecolor='white', edgecolor='k', linewidths=1.5,\n", " hatch='/////', alpha=0.9,\n", " label=tpd[j]\n", " )\n", " )\n", " else:\n", " time_handles.append(\n", " Line2D(\n", " [0], [0],\n", " marker=mk, linestyle='None', color='k',\n", " markerfacecolor=mcol[j], markeredgecolor=mecol[j],\n", " markersize=15, label=tpd[j]\n", " )\n", " )\n", "\n", "\n", "leg1 = plt.legend(handles=model_handles, frameon=True, fontsize=fs-10,\n", " framealpha=1, ncol=1, loc='upper left')\n", "plt.gca().add_artist(leg1)\n", "plt.legend(handles=time_handles, frameon=True, fontsize=fs-10,\n", " framealpha=1, ncol=1, loc=[0.35,0.78])\n", "\n", "\n", "for e in [2.5,5,7.5,10,12.5]:\n", " plt.plot([-100+e,100+e],[-100-e,100-e],'.75',lw=1,zorder=0,linestyle='solid')\n", " plt.plot([-100-e,100-e],[-100+e,100+e],'.75',lw=1,zorder=0,linestyle='solid')\n", "\n", "\n", "plt.plot([-100,100],[100,-100],'.75',lw=3,zorder=0,linestyle='solid')\n", "plt.plot([-100,100],[-100,100],'.75',lw=3,zorder=0,linestyle='solid')\n", "\n", "plt.grid(linewidth=0.5, color='.75')\n", "\n", "#ax1.text(-.16,1,s='(a)',transform = ax1.transAxes,fontsize=fs+2,fontweight='bold')\n", "plt.tight_layout()\n", "plt.savefig(dir_fig+'Zhang26_fig3_GCM_EW_Rcld.png', dpi=450)\n", "plt.savefig(dir_fig+'Zhang26_fig3_GCM_EW_Rcld.pdf')\n", "\n" ] } ], "metadata": { "kernelspec": { "display_name": "tf215env", "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.13" } }, "nbformat": 4, "nbformat_minor": 5 }