{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import xarray as xr\n", "import pandas as pd\n", "from salishsea_tools import viz_tools, places, visualisations\n", "from matplotlib import pyplot as plt, dates\n", "from datetime import datetime, timedelta\n", "from calendar import month_name\n", "from scipy.io import loadmat\n", "from tqdm.notebook import tqdm\n", "from salishsea_tools import nc_tools\n", "from dask.diagnostics import ProgressBar\n", "import cmocean\n", "\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Note that all biological rates (e.g., grazing) are scaled (multiplied by 1.111) to correct for a time splitting/Roberts-Asselin filter error in hte model as reported in Olson et al. 2020" ] }, { "cell_type": "raw", "metadata": {}, "source": [ "from IPython.display import HTML\n", "\n", "HTML('''\n", "\n", "
''')" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "plt.rcParams.update({'font.size': 12, 'axes.titlesize': 'medium'})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Load files from monthly averages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Z1 grazing on Diatoms" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "#years, months, data\n", "monthly_array_Z1diatoms_depthint_slice = np.zeros([14,12,50,50])\n", "# Load monthly averages\n", "mask = xr.open_dataset('/data/eolson/results/MEOPAR/NEMO-forcing-new/grid/mesh_mask201702.nc')\n", "slc = {'y': slice(450,500), 'x': slice(250,300)}\n", "e3t, tmask = [mask[var].isel(z=slice(None, 27),**slc).values for var in ('e3t_0', 'tmask')]\n", "years, variables = range(2007, 2021), ['GRMICZDIAT']\n", "# Temporary list dict\n", "data = {}\n", "# Permanent aggregate dict\n", "#aggregates = {var: {} for var in variables}\n", "#monthlydat = {var: {} for var in variables}\n", "\n", "# Loop through years\n", "for year in [2007,2008,2009,2010,2011,2012,2015,2016,2017,2018,2019,2020]:\n", " # Initialize lists\n", " for var in variables: data[var] = []\n", " # Load monthly averages\n", " for month in range(1, 13):\n", " datestr = f'{year}{month:02d}'\n", " prefix = f'/data/sallen/results/MEOPAR/v201905r/SalishSea_1m_{datestr}_{datestr}'\n", " \n", " # Load grazing variables\n", " with xr.open_dataset(prefix + '_dia2_T.nc') as ds:\n", " q = np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data\n", " q2 = q[0,:,:]\n", " monthly_array_Z1diatoms_depthint_slice[year-2007,month-1,:,:] = q2 #year2015 is index 0 along 1st dimension\n", " for var in ['GRMICZDIAT']:\n", " data[var].append(np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data)\n", " \n", " \n", "# Loop through years for wrap files\n", "for year in [2013,2014]:\n", " # Initialize lists\n", " for var in variables: data[var] = []\n", " # Load monthly averages\n", " for month in range(1, 13):\n", " datestr = f'{year}{month:02d}'\n", " prefix = f'/data/sallen/results/MEOPAR/v201905r_wrap/SalishSea_1m_{datestr}_{datestr}'\n", " \n", " # Load grazing variables\n", " with xr.open_dataset(prefix + '_dia2_T.nc') as ds:\n", " q = np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data\n", " q2 = q[0,:,:]\n", " monthly_array_Z1diatoms_depthint_slice[year-2007,month-1,:,:] = q2 #year2015 is index 0 along 1st dimension\n", " for var in ['GRMICZDIAT']:\n", " data[var].append(np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data)\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " # Concatenate months\n", " #for var in variables: aggregates[var][year] = np.concatenate(data[var]).mean(axis=0)\n", "# # Calculate 5 year mean and anomalies\n", "# for var in variables:\n", "# aggregates[var][‘mean’] = np.concatenate([aggregates[var][year][None, ...] for year in years]).mean(axis=0)\n", "# for year in years: aggregates[var][year] = aggregates[var][year] - aggregates[var][‘mean’]\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(14, 12)\n" ] } ], "source": [ "monthly_array_Z1diatoms_depthint_slice=np.where(np.isnan(monthly_array_Z1diatoms_depthint_slice), 0, monthly_array_Z1diatoms_depthint_slice)\n", "monthly_array_Z1diatoms_depthint_slicemean = \\\n", "np.nanmean(np.nanmean(monthly_array_Z1diatoms_depthint_slice, axis = 2),axis = 2)\n", "print(np.shape(monthly_array_Z1diatoms_depthint_slicemean))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Select 4 warmest and 4 coldest years; leave NPGO \"neutral\" years out" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "#2008, 2010, 2011, 2012\n", "NPGO_C_Z1diat=np.array([[monthly_array_Z1diatoms_depthint_slicemean[1,:]],[monthly_array_Z1diatoms_depthint_slicemean[3,:]],\\\n", " [monthly_array_Z1diatoms_depthint_slicemean[4,:]],[monthly_array_Z1diatoms_depthint_slicemean[5,:]]])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "NPGO_C_Z1diat_mean=NPGO_C_Z1diat.mean(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "NPGO_C_Z1diat_std=NPGO_C_Z1diat.std(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "#2015, 2018, 2019, 2020\n", "NPGO_W_Z1diat=np.array([[monthly_array_Z1diatoms_depthint_slicemean[8,:]],[monthly_array_Z1diatoms_depthint_slicemean[11,:]],\\\n", " [monthly_array_Z1diatoms_depthint_slicemean[12,:]],[monthly_array_Z1diatoms_depthint_slicemean[13,:]]])\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "NPGO_W_Z1diat_mean=NPGO_W_Z1diat.mean(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "NPGO_W_Z1diat_std=NPGO_W_Z1diat.std(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5.853982189725535" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_C_Z1diat_mean.max()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6.757904071950235" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_W_Z1diat_mean.max()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Load files from monthly averages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Z1 grazing on Nanoflagellates" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "\n", "#years, months, data\n", "monthly_array_Z1flag_depthint_slice = np.zeros([14,12,50,50])\n", "# Load monthly averages\n", "mask = xr.open_dataset('/data/eolson/results/MEOPAR/NEMO-forcing-new/grid/mesh_mask201702.nc')\n", "slc = {'y': slice(450,500), 'x': slice(250,300)}\n", "e3t, tmask = [mask[var].isel(z=slice(None, 27),**slc).values for var in ('e3t_0', 'tmask')]\n", "years, variables = range(2007, 2021), ['GRMICZPHY']\n", "# Temporary list dict\n", "data = {}\n", "# Permanent aggregate dict\n", "#aggregates = {var: {} for var in variables}\n", "#monthlydat = {var: {} for var in variables}\n", "\n", "# Loop through years\n", "for year in [2007,2008,2009,2010,2011,2012,2015,2016,2017,2018,2019,2020]:\n", " # Initialize lists\n", " for var in variables: data[var] = []\n", " # Load monthly averages\n", " for month in range(1, 13):\n", " datestr = f'{year}{month:02d}'\n", " prefix = f'/data/sallen/results/MEOPAR/v201905r/SalishSea_1m_{datestr}_{datestr}'\n", " \n", " # Load grazing variables\n", " with xr.open_dataset(prefix + '_dia2_T.nc') as ds:\n", " q = np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data\n", " q2 = q[0,:,:]\n", " monthly_array_Z1flag_depthint_slice[year-2007,month-1,:,:] = q2 #year2015 is index 0 along 1st dimension\n", " for var in ['GRMICZPHY']:\n", " data[var].append(np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data)\n", " \n", "# Loop through years for wrap files\n", "for year in [2013,2014]:\n", " # Initialize lists\n", " for var in variables: data[var] = []\n", " # Load monthly averages\n", " for month in range(1, 13):\n", " datestr = f'{year}{month:02d}'\n", " prefix = f'/data/sallen/results/MEOPAR/v201905r_wrap/SalishSea_1m_{datestr}_{datestr}'\n", " \n", " # Load grazing variables\n", " with xr.open_dataset(prefix + '_dia2_T.nc') as ds:\n", " q = np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data\n", " q2 = q[0,:,:]\n", " monthly_array_Z1flag_depthint_slice[year-2007,month-1,:,:] = q2 #year2015 is index 0 along 1st dimension\n", " for var in ['GRMICZPHY']:\n", " data[var].append(np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data)\n", " \n", " \n", " \n", " \n", " # Concatenate months\n", " #for var in variables: aggregates[var][year] = np.concatenate(data[var]).mean(axis=0)\n", "# # Calculate 5 year mean and anomalies\n", "# for var in variables:\n", "# aggregates[var][‘mean’] = np.concatenate([aggregates[var][year][None, ...] for year in years]).mean(axis=0)\n", "# for year in years: aggregates[var][year] = aggregates[var][year] - aggregates[var][‘mean’]\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(14, 12)\n" ] } ], "source": [ "monthly_array_Z1flag_depthint_slice[monthly_array_Z1flag_depthint_slice == 0 ] = np.nan\n", "monthly_array_Z1flag_depthint_slicemean = \\\n", "np.nanmean(np.nanmean(monthly_array_Z1flag_depthint_slice, axis = 2),axis = 2)\n", "print(np.shape(monthly_array_Z1flag_depthint_slicemean))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Select 4 warmest and 4 coldest years; leave NPGO \"neutral\" years out" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "#2008, 2010, 2011, 2012\n", "NPGO_C_Z1flag=np.array([[monthly_array_Z1flag_depthint_slicemean[1,:]],[monthly_array_Z1flag_depthint_slicemean[3,:]],\\\n", " [monthly_array_Z1flag_depthint_slicemean[4,:]],[monthly_array_Z1flag_depthint_slicemean[5,:]]])" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "NPGO_C_Z1flag_mean=NPGO_C_Z1flag.mean(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "NPGO_C_Z1flag_std=NPGO_C_Z1flag.std(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "#2015, 2018, 2019, 2020\n", "NPGO_W_Z1flag=np.array([[monthly_array_Z1flag_depthint_slicemean[8,:]],[monthly_array_Z1flag_depthint_slicemean[11,:]],\\\n", " [monthly_array_Z1flag_depthint_slicemean[12,:]],[monthly_array_Z1flag_depthint_slicemean[13,:]]])\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "NPGO_W_Z1flag_mean=NPGO_W_Z1flag.mean(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "NPGO_W_Z1flag_std=NPGO_W_Z1flag.std(axis=0).flatten()*86400*1.111" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5.543413180928081" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_C_Z1flag_mean.max()" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6.664183563148394" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_W_Z1flag_mean.max()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Z1 Grazing on both diatoms and nanoflagelles for Cold Years" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "NPGO_C_Z1Both=NPGO_C_Z1diat_mean+NPGO_C_Z1flag_mean" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.10268752, 0.42718894, 1.05655672, 4.58719945, 6.87334479,\n", " 7.61734177, 8.85194247, 6.29357942, 3.35244758, 0.56951175,\n", " 0.11327659, 0.08977801])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_C_Z1Both" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "#### Z1 Grazing on both diatoms and nanoflagelles for Warm Years" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "NPGO_W_Z1Both=NPGO_W_Z1diat_mean+NPGO_W_Z1flag_mean" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.14284651, 0.52294073, 3.93385487, 7.52276735, 6.2666193 ,\n", " 7.42655869, 7.66459905, 6.1478577 , 2.3778494 , 0.37108638,\n", " 0.14533633, 0.07999317])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_W_Z1Both" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.3279045835973626" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_C_Z1Both.mean()" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.5501924577589943" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_W_Z1Both.mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Load monthly average files for Z1 biomass" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "\n", "\n", "#years, months, data\n", "monthly_array_microzooplankton_depthint_slice = np.zeros([14,12,50,50])\n", "# Load monthly averages\n", "mask = xr.open_dataset('/data/eolson/results/MEOPAR/NEMO-forcing-new/grid/mesh_mask201702.nc')\n", "slc = {'y': slice(450,500), 'x': slice(250,300)}\n", "e3t, tmask = [mask[var].isel(z=slice(None, 27),**slc).values for var in ('e3t_0', 'tmask')]\n", "years, variables = range(2007, 2021), ['microzooplankton']\n", "# Temporary list dict\n", "data = {}\n", "# Permanent aggregate dict\n", "aggregates = {var: {} for var in variables}\n", "monthlydat = {var: {} for var in variables}\n", "\n", "# Loop through years\n", "for year in [2007,2008,2009,2010,2011,2012,2016,2017,2018,2019,2020]:\n", " # Initialize lists\n", " for var in variables: data[var] = []\n", " # Load monthly averages\n", " for month in range(1, 13):\n", " datestr = f'{year}{month:02d}'\n", " prefix = f'/data/sallen/results/MEOPAR/v201905r/SalishSea_1m_{datestr}_{datestr}'\n", " # Load grazing variables\n", " with xr.open_dataset(prefix + '_ptrc_T.nc') as ds:\n", " q = np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data\n", " q2 = q[0,:,:]\n", " monthly_array_microzooplankton_depthint_slice[year-2007,month-1,:,:] = q2 #year2015 is index 0 along 1st dimension\n", " for var in ['microzooplankton']:\n", " data[var].append(np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data)\n", " # Concatenate months\n", " for var in variables: aggregates[var][year] = np.concatenate(data[var]).mean(axis=0)\n", "\n", "# Loop through years for wrap files\n", "for year in [2013,2014,2015]:\n", " # Initialize lists\n", " for var in variables: data[var] = []\n", " # Load monthly averages\n", " for month in range(1, 13):\n", " datestr = f'{year}{month:02d}'\n", " prefix = f'/data/sallen/results/MEOPAR/v201905r_wrap/SalishSea_1m_{datestr}_{datestr}'\n", " # Load grazing variables\n", " with xr.open_dataset(prefix + '_ptrc_T.nc') as ds:\n", " q = np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data\n", " q2 = q[0,:,:]\n", " monthly_array_microzooplankton_depthint_slice[year-2007,month-1,:,:] = q2 #year2015 is index 0 along 1st dimension\n", " for var in ['microzooplankton']:\n", " data[var].append(np.ma.masked_where(tmask == 0, ds[var].isel(deptht=slice(None, 27), **slc).values * e3t).sum(axis=1).data)\n", " # Concatenate months\n", " for var in variables: aggregates[var][year] = np.concatenate(data[var]).mean(axis=0) \n", " \n", " \n", "# # Calculate 5 year mean and anomalies\n", "# for var in variables:\n", "# aggregates[var][‘mean’] = np.concatenate([aggregates[var][year][None, ...] for year in years]).mean(axis=0)\n", "# for year in years: aggregates[var][year] = aggregates[var][year] - aggregates[var][‘mean’]\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(14, 12)\n" ] } ], "source": [ "monthly_array_microzooplankton_depthint_slice[monthly_array_microzooplankton_depthint_slice == 0 ] = np.nan\n", "monthly_array_microzooplankton_depthint_slicemean = \\\n", "np.nanmean(np.nanmean(monthly_array_microzooplankton_depthint_slice, axis = 2),axis = 2)\n", "print(np.shape(monthly_array_microzooplankton_depthint_slicemean))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Select 4 warmest and 4 coldest years; leave NPGO \"neutral\" years out" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "#2008, 2010, 2011, 2012\n", "NPGO_C_micro=np.array([[monthly_array_microzooplankton_depthint_slicemean[1,:]],[monthly_array_microzooplankton_depthint_slicemean[3,:]],\\\n", " [monthly_array_microzooplankton_depthint_slicemean[4,:]],[monthly_array_microzooplankton_depthint_slicemean[5,:]]])" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "NPGO_C_micro_mean=NPGO_C_micro.mean(axis=0).flatten() #*5.7*12/1000" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "NPGO_C_micro_std=NPGO_C_micro.std(axis=0).flatten() #*5.7*12/1000" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "#2015, 2018, 2019, 2020\n", "NPGO_W_micro=np.array([[monthly_array_microzooplankton_depthint_slicemean[8,:]],[monthly_array_microzooplankton_depthint_slicemean[11,:]],\\\n", " [monthly_array_microzooplankton_depthint_slicemean[12,:]],[monthly_array_microzooplankton_depthint_slicemean[13,:]]])\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "NPGO_W_micro_mean=NPGO_W_micro.mean(axis=0).flatten() #*5.7*12/1000" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "NPGO_W_micro_std=NPGO_W_micro.std(axis=0).flatten() #*5.7*12/1000" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "23.464871504056774" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_W_micro_mean.max()" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "24.462228715060135" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "NPGO_C_micro_mean.max()" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'Cold Years')" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "