{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import netCDF4 as nc\n", "import matplotlib.pylab as plt\n", "import imp\n", "import csv\n", "import pandas as pd\n", "import random as rnd" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "651\n" ] } ], "source": [ "# Read atmospheric forcing\n", "\n", "NumTensemble = 600\n", "Tlen = 651\n", "\n", "fname = \"../MAGICC/CMIP5_RCP2500/Temp_CMIP5_RCP85_HistConstraint.dat\" # File to read\n", "df = pd.read_csv(fname,sep='\\s+',index_col=0,header=None)\n", "df.columns.name = \"ensemble member\"\n", "df.index.name = \"Time\"\n", "SAT = np.array(df.values)\n", "\n", "print(len(SAT[:,1]))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Normalize and crop temperature series\n", "Temp = []\n", "Tavebeg = 0\n", "Taveend = 80\n", "tbeg = 51\n", "tend = 251\n", "for i in range(len(SAT[1,:])):\n", " SATave = np.mean(SAT[Tavebeg:Taveend,i])\n", " SAT[:,i] = SAT[:,i]-SATave\n", "SAT = SAT[tbeg:tend,:]" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Read ocean scaling\n", "\n", "NumOmodel = 19\n", "\n", "fname = \"../ScalingCoefficients/OceanScaling/OS_R1.dat\" # File to read\n", "with open(fname) as f:\n", " OS_NoDelay_R1 = np.array([float(row.split(\"\\t\")[0]) for row in f])\n", "with open(fname) as f:\n", " OS_WiDelay_R1 = np.array([float(row.split(\"\\t\")[3]) for row in f])\n", "with open(fname) as f:\n", " OS_Delay_R1 = np.array([float(row.split(\"\\t\")[2]) for row in f])\n", "\n", "fname = \"../ScalingCoefficients/OceanScaling/OS_R2.dat\" # File to read\n", "with open(fname) as f:\n", " OS_NoDelay_R2 = np.array([float(row.split(\"\\t\")[0]) for row in f])\n", "with open(fname) as f:\n", " OS_WiDelay_R2 = np.array([float(row.split(\"\\t\")[3]) for row in f])\n", "with open(fname) as f:\n", " OS_Delay_R2 = np.array([float(row.split(\"\\t\")[2]) for row in f])\n", "\n", "fname = \"../ScalingCoefficients/OceanScaling/OS_R3.dat\" # File to read\n", "with open(fname) as f:\n", " OS_NoDelay_R3 = np.array([float(row.split(\"\\t\")[0]) for row in f])\n", "with open(fname) as f:\n", " OS_WiDelay_R3 = np.array([float(row.split(\"\\t\")[3]) for row in f])\n", "with open(fname) as f:\n", " OS_Delay_R3 = np.array([float(row.split(\"\\t\")[2]) for row in f])\n", "\n", "fname = \"../ScalingCoefficients/OceanScaling/OS_R4.dat\" # File to read\n", "with open(fname) as f:\n", " OS_NoDelay_R4 = np.array([float(row.split(\"\\t\")[0]) for row in f])\n", "with open(fname) as f:\n", " OS_WiDelay_R4 = np.array([float(row.split(\"\\t\")[3]) for row in f])\n", "with open(fname) as f:\n", " OS_Delay_R4 = np.array([float(row.split(\"\\t\")[2]) for row in f])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Read melting sensitivity\n", "fname = \"../ScalingCoefficients/MeltSensitivity/MeltSensitivity.dat\" # File to read\n", "with open(fname) as f:\n", " MeltSensitivity = np.array([float(row) for row in f])" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# GRIS_LSC = GRIS_LSC\n", "# Read ice scaling\n", "fname = \"../ScalingCoefficients/IceScaling/ES_GRIS_LSC_scaledto08.dat\" # File to read\n", "with open(fname) as f:\n", " FS_GRIS_LSC_BM08 = np.array([float(row) for row in f])" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# GRIS_LSC = GRIS_LSC\n", "# Read response functions\n", "\n", "fname = \"../RFunctions/RF_GRIS_LSC_BM08_R1.dat\" # File to read\n", "with open(fname) as f:\n", " RF_GRIS_LSC_BM08_R1 = np.array([float(row) for row in f])\n", "\n", "fname = \"../RFunctions/RF_GRIS_LSC_BM08_R2.dat\" # File to read\n", "with open(fname) as f:\n", " RF_GRIS_LSC_BM08_R2 = np.array([float(row) for row in f])\n", "\n", "fname = \"../RFunctions/RF_GRIS_LSC_BM08_R3.dat\" # File to read\n", "with open(fname) as f:\n", " RF_GRIS_LSC_BM08_R3 = np.array([float(row) for row in f])\n", "\n", "fname = \"../RFunctions/RF_GRIS_LSC_BM08_R4.dat\" # File to read\n", "with open(fname) as f:\n", " RF_GRIS_LSC_BM08_R4 = np.array([float(row) for row in f])\n", "\n", "fname = \"../RFunctions/RF_GRIS_LSC_BM08_R5.dat\" # File to read\n", "with open(fname) as f:\n", " RF_GRIS_LSC_BM08_R5 = np.array([float(row) for row in f])\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.5259 0.5555555555555556\n", "0.89415 0.6666666666666666\n", "0.5279 0.5555555555555556\n", "0.4781 1.0\n" ] } ], "source": [ "EnsembleSize = 20000\n", "scaled_forcing = False\n", "\n", "countR1 = 0\n", "countR2 = 0\n", "countR3 = 0\n", "countR4 = 0\n", "\n", "SL_wTd_nos_base_GRIS_LSC_R1_RCP85 = [0] * (tend-tbeg)\n", "SL_wTd_nos_base_GRIS_LSC_R2_RCP85 = [0] * (tend-tbeg)\n", "SL_wTd_nos_base_GRIS_LSC_R3_RCP85 = [0] * (tend-tbeg)\n", "SL_wTd_nos_base_GRIS_LSC_R4_RCP85 = [0] * (tend-tbeg)\n", "SL_wTd_nos_base_GRIS_LSC_R5_RCP85 = [0] * (tend-tbeg)\n", "\n", "for i in range(EnsembleSize):\n", "\n", " # Select forcing randomly\n", "\n", " # select global warming path\n", " iTens = rnd.randint(0,NumTensemble-1)\n", " Temp = np.array(SAT[:,iTens])\n", "\n", " # select ocean model\n", " iOmod = rnd.randint(0,NumOmodel-1)\n", " OS_R1 = OS_WiDelay_R1[iOmod]\n", " OS_R2 = OS_WiDelay_R2[iOmod]\n", " OS_R3 = OS_WiDelay_R3[iOmod]\n", " OS_R4 = OS_WiDelay_R4[iOmod]\n", " OS_R5 = OS_WiDelay_R4[iOmod]\n", "\n", " tau_R1 = int(OS_Delay_R1[iOmod])\n", " tau_R2 = int(OS_Delay_R2[iOmod])\n", " tau_R3 = int(OS_Delay_R3[iOmod])\n", " tau_R4 = int(OS_Delay_R4[iOmod])\n", " tau_R5 = int(OS_Delay_R4[iOmod])\n", "\n", " if tau_R1>0:\n", " countR1 = countR1+1\n", " if tau_R2>0:\n", " countR2 = countR2+1\n", " if tau_R3>0:\n", " countR3 = countR3+1\n", " if tau_R4>0:\n", " countR4 = countR4+1\n", " \n", " Temp_R1 = np.append(np.zeros(tau_R1),Temp[:tend-tbeg-tau_R1])\n", " Temp_R2 = np.append(np.zeros(tau_R2),Temp[:tend-tbeg-tau_R2])\n", " Temp_R3 = np.append(np.zeros(tau_R3),Temp[:tend-tbeg-tau_R3])\n", " Temp_R4 = np.append(np.zeros(tau_R4),Temp[:tend-tbeg-tau_R4])\n", " Temp_R5 = np.append(np.zeros(tau_R5),Temp[:tend-tbeg-tau_R5])\n", " \n", " # select melting sensitivity\n", " MS_R1 = rnd.uniform(MeltSensitivity[0],MeltSensitivity[1])\n", " MS_R2 = rnd.uniform(MeltSensitivity[0],MeltSensitivity[1])\n", " MS_R3 = rnd.uniform(MeltSensitivity[0],MeltSensitivity[1])\n", " MS_R4 = rnd.uniform(MeltSensitivity[0],MeltSensitivity[1])\n", " MS_R5 = rnd.uniform(MeltSensitivity[0],MeltSensitivity[1])\n", "\n", " # Compose forcing time series\n", " M_R1 = MS_R1*OS_R1*Temp_R1\n", " M_R2 = MS_R2*OS_R2*Temp_R2\n", " M_R3 = MS_R3*OS_R3*Temp_R3\n", " M_R4 = MS_R4*OS_R4*Temp_R4\n", " M_R5 = MS_R5*OS_R5*Temp_R5\n", "\n", " M_R1[M_R1 < 0.0] = 0.0\n", " M_R2[M_R2 < 0.0] = 0.0\n", " M_R3[M_R3 < 0.0] = 0.0\n", " M_R4[M_R4 < 0.0] = 0.0\n", " M_R5[M_R5 < 0.0] = 0.0\n", " \n", " # Scaling of forcing\n", " if (scaled_forcing == True):\n", " for i in range(len(M_R1)):\n", " if M_R1[i] > 0.0:\n", " dump = np.log(M_R1[i]/8)/np.log(2.0)\n", " M_R1[i] = M_R1[i] * FS_GRIS_LSC_BM08[1]**dump\n", " if M_R2[i] > 0.0:\n", " dump = np.log(M_R2[i]/8)/np.log(2.0)\n", " M_R2[i] = M_R2[i] * FS_GRIS_LSC_BM08[2]**dump\n", " if M_R3[i] > 0.0:\n", " dump = np.log(M_R3[i]/8)/np.log(2.0)\n", " M_R3[i] = M_R3[i] * FS_GRIS_LSC_BM08[3]**dump\n", " if M_R4[i] > 0.0:\n", " dump = np.log(M_R4[i]/8)/np.log(2.0)\n", " M_R4[i] = M_R4[i] * FS_GRIS_LSC_BM08[4]**dump\n", " if M_R5[i] > 0.0:\n", " dump = np.log(M_R5[i]/8)/np.log(2.0)\n", " M_R5[i] = M_R5[i] * FS_GRIS_LSC_BM08[5]**dump\n", "\n", " # Linear response\n", " SL = []\n", " SL.append(0)\n", " for t in range(1,tend-tbeg):\n", " #print(t)\n", " dSL = 0\n", " for tp in range(0,t):\n", " #print(t,tp)\n", " dSL = dSL + M_R1[tp]*RF_GRIS_LSC_BM08_R1[t-tp]\n", " SL.append(dSL)\n", " SL_wTd_nos_base_GRIS_LSC_R1_RCP85=np.vstack([SL_wTd_nos_base_GRIS_LSC_R1_RCP85, SL])\n", "\n", " SL = []\n", " SL.append(0)\n", " for t in range(1,tend-tbeg):\n", " dSL = 0\n", " for tp in range(0,t):\n", " dSL = dSL + M_R2[tp]*RF_GRIS_LSC_BM08_R2[t-tp]\n", " SL.append(dSL)\n", " SL_wTd_nos_base_GRIS_LSC_R2_RCP85=np.vstack([SL_wTd_nos_base_GRIS_LSC_R2_RCP85, SL])\n", "\n", " SL = []\n", " SL.append(0)\n", " for t in range(1,tend-tbeg):\n", " dSL = 0\n", " for tp in range(0,t):\n", " dSL = dSL + M_R3[tp]*RF_GRIS_LSC_BM08_R3[t-tp]\n", " SL.append(dSL)\n", " SL_wTd_nos_base_GRIS_LSC_R3_RCP85=np.vstack([SL_wTd_nos_base_GRIS_LSC_R3_RCP85, SL])\n", "\n", " SL = []\n", " SL.append(0)\n", " for t in range(1,tend-tbeg):\n", " dSL = 0\n", " for tp in range(0,t):\n", " dSL = dSL + M_R4[tp]*RF_GRIS_LSC_BM08_R4[t-tp]\n", " SL.append(dSL)\n", " SL_wTd_nos_base_GRIS_LSC_R4_RCP85=np.vstack([SL_wTd_nos_base_GRIS_LSC_R4_RCP85, SL])\n", "\n", " SL = []\n", " SL.append(0)\n", " for t in range(1,tend-tbeg):\n", " dSL = 0\n", " for tp in range(0,t):\n", " dSL = dSL + M_R5[tp]*RF_GRIS_LSC_BM08_R5[t-tp]\n", " SL.append(dSL)\n", " SL_wTd_nos_base_GRIS_LSC_R5_RCP85=np.vstack([SL_wTd_nos_base_GRIS_LSC_R5_RCP85, SL])\n", "\n", "SL_wTd_nos_base_GRIS_LSC_SU_RCP85 = SL_wTd_nos_base_GRIS_LSC_R1_RCP85+SL_wTd_nos_base_GRIS_LSC_R2_RCP85+SL_wTd_nos_base_GRIS_LSC_R3_RCP85+SL_wTd_nos_base_GRIS_LSC_R4_RCP85+SL_wTd_nos_base_GRIS_LSC_R5_RCP85\n", "\n", "print(countR1/EnsembleSize,10/19)\n", "print(countR2/EnsembleSize,17/19)\n", "print(countR3/EnsembleSize,10/19)\n", "print(countR4/EnsembleSize,9/19)\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "Time = range(1900,2100)\n", "ncfile = nc.Dataset('EnsembleSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_RCP85.nc','w', format='NETCDF4')\n", "ncfile.createDimension('Time', None)\n", "ncfile.createDimension('Emember', None)\n", "\n", "SL_wTd_nos_base_R1 = ncfile.createVariable('EAIS', 'f4', ('Emember', 'Time'))\n", "SL_wTd_nos_base_R2 = ncfile.createVariable('Ross', 'f4', ('Emember', 'Time'))\n", "SL_wTd_nos_base_R3 = ncfile.createVariable('Amundsen', 'f4', ('Emember', 'Time'))\n", "SL_wTd_nos_base_R4 = ncfile.createVariable('Weddell', 'f4', ('Emember', 'Time'))\n", "SL_wTd_nos_base_R5 = ncfile.createVariable('Peninsula', 'f4', ('Emember', 'Time'))\n", "SL_wTd_nos_base_SU = ncfile.createVariable('Antarctica', 'f4', ('Emember', 'Time'))\n", "t = ncfile.createVariable('Time', 'i4', 'Time')\n", "\n", "SL_wTd_nos_base_R1[:,:] = SL_wTd_nos_base_GRIS_LSC_R1_RCP85\n", "SL_wTd_nos_base_R2[:,:] = SL_wTd_nos_base_GRIS_LSC_R2_RCP85\n", "SL_wTd_nos_base_R3[:,:] = SL_wTd_nos_base_GRIS_LSC_R3_RCP85\n", "SL_wTd_nos_base_R4[:,:] = SL_wTd_nos_base_GRIS_LSC_R4_RCP85\n", "SL_wTd_nos_base_R5[:,:] = SL_wTd_nos_base_GRIS_LSC_R5_RCP85\n", "SL_wTd_nos_base_SU[:,:] = SL_wTd_nos_base_GRIS_LSC_SU_RCP85\n", "t[:] = Time\n", "\n", "SL_wTd_nos_base_R1.units = 'meter'\n", "SL_wTd_nos_base_R2.units = 'meter'\n", "SL_wTd_nos_base_R3.units = 'meter'\n", "SL_wTd_nos_base_R4.units = 'meter'\n", "SL_wTd_nos_base_R5.units = 'meter'\n", "SL_wTd_nos_base_SU.units = 'meter'\n", "\n", "t.units = 'years'\n", "\n", "ncfile.close()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "SL_wTd_nos_base_GRIS_LSC_SU_RCP85_50pc = np.percentile(SL_wTd_nos_base_GRIS_LSC_SU_RCP85, 50, axis=0, out=None, overwrite_input=False, interpolation='linear', keepdims=False)\n", "SL_wTd_nos_base_GRIS_LSC_SU_RCP85_83pc = np.percentile(SL_wTd_nos_base_GRIS_LSC_SU_RCP85, 83.33, axis=0, out=None, overwrite_input=False, interpolation='linear', keepdims=False)\n", "SL_wTd_nos_base_GRIS_LSC_SU_RCP85_17pc = np.percentile(SL_wTd_nos_base_GRIS_LSC_SU_RCP85, 16.66, axis=0, out=None, overwrite_input=False, interpolation='linear', keepdims=False)\n", "SL_wTd_nos_base_GRIS_LSC_SU_RCP85_95pc = np.percentile(SL_wTd_nos_base_GRIS_LSC_SU_RCP85, 5, axis=0, out=None, overwrite_input=False, interpolation='linear', keepdims=False)\n", "SL_wTd_nos_base_GRIS_LSC_SU_RCP85_05pc = np.percentile(SL_wTd_nos_base_GRIS_LSC_SU_RCP85, 95, axis=0, out=None, overwrite_input=False, interpolation='linear', keepdims=False)\n", "SL_wTd_nos_base_GRIS_LSC_SU_RCP85_99pc = np.percentile(SL_wTd_nos_base_GRIS_LSC_SU_RCP85, 99, axis=0, out=None, overwrite_input=False, interpolation='linear', keepdims=False)\n", "SL_wTd_nos_base_GRIS_LSC_SU_RCP85_01pc = np.percentile(SL_wTd_nos_base_GRIS_LSC_SU_RCP85, 1, axis=0, out=None, overwrite_input=False, interpolation='linear', keepdims=False)\n", "\n", "np.savetxt(\"PercentilesSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_50pc.dat\", SL_wTd_nos_base_GRIS_LSC_SU_RCP85_50pc, delimiter=\",\")\n", "np.savetxt(\"PercentilesSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_83pc.dat\", SL_wTd_nos_base_GRIS_LSC_SU_RCP85_83pc, delimiter=\",\")\n", "np.savetxt(\"PercentilesSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_17pc.dat\", SL_wTd_nos_base_GRIS_LSC_SU_RCP85_17pc, delimiter=\",\")\n", "np.savetxt(\"PercentilesSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_05pc.dat\", SL_wTd_nos_base_GRIS_LSC_SU_RCP85_05pc, delimiter=\",\")\n", "np.savetxt(\"PercentilesSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_95pc.dat\", SL_wTd_nos_base_GRIS_LSC_SU_RCP85_95pc, delimiter=\",\")\n", "np.savetxt(\"PercentilesSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_01pc.dat\", SL_wTd_nos_base_GRIS_LSC_SU_RCP85_01pc, delimiter=\",\")\n", "np.savetxt(\"PercentilesSingleModelProjections/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_99pc.dat\", SL_wTd_nos_base_GRIS_LSC_SU_RCP85_99pc, delimiter=\",\")\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fp3=plt.figure()\n", "for i in range(EnsembleSize):\n", " plt.plot(Time,SL_wTd_nos_base_GRIS_LSC_SU_RCP85[i,:])\n", "\n", "plt.show()\n", "fp3.savefig(\"Figures/SL_wTd_nos_base_GRIS_LSC_SU_RCP85_alllines.pdf\", bbox_inches='tight')\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.1" } }, "nbformat": 4, "nbformat_minor": 2 }