STORM_data_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Demo notebook for handling STORM datasets\n",
    "\n",
    "https://www.nature.com/articles/s41597-020-0381-2\n",
    "\n",
    "https://doi.org/10.4121/uuid:82c1dc0d-5485-43d8-901a-ce7f26cda35d\n",
    "\n",
    "https://data.4tu.nl/articles/STORM_IBTrACS_present_climate_synthetic_tropical_cyclone_tracks/12706085?file=24876980\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import xarray as xr\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import matplotlib.ticker as mticker\n",
    "\n",
    "import cartopy as ctpi\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.feature as cfeature\n",
    "from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER\n",
    "print(\"cartopy Version = {}\".format(ctpi.__version__))\n",
    "\n",
    "# import seaborn as sns\n",
    "# sns.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addFeatures(ax):\n",
    "    \"\"\"\n",
    "    \"\"\"\n",
    "    kwargs = {\"scale\": '50m', \"facecolor\": \"none\",  \"edgecolor\": \"k\", \"linewidth\": 1.5} \n",
    "    ax.add_feature(cfeature.NaturalEarthFeature(category='physical', name='coastline', **kwargs))\n",
    "    kwargs = {\"scale\": '110m', \"facecolor\": \"none\",  \"edgecolor\": \"k\", \"linewidth\": .5} \n",
    "    ax.add_feature(cfeature.NaturalEarthFeature(category='physical', name='lakes', **kwargs))\n",
    "    ax.add_feature(cfeature.NaturalEarthFeature(category='cultural', name='admin_1_states_provinces_lines', **kwargs))\n",
    "    ax.add_feature(cfeature.NaturalEarthFeature(category='cultural', name='admin_0_boundary_lines_land', **kwargs))\n",
    "\n",
    "def discrete_cmap(N, base_cmap=None):\n",
    "    \"\"\"\n",
    "    Create an N-bin discrete colormap from the specified input map\n",
    "    \"\"\"\n",
    "\n",
    "    # Note that if base_cmap is a string or None, you can simply do\n",
    "    #    return plt.cm.get_cmap(base_cmap, N)\n",
    "    # The following works for string, None, or a colormap instance:\n",
    "\n",
    "    base = plt.cm.get_cmap(base_cmap)\n",
    "    color_list = base(np.linspace(0, 1, N))\n",
    "    cmap_name = base.name + str(N)\n",
    "    return base.from_list(cmap_name, color_list, N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=24\n",
    "cmap=discrete_cmap(N, 'jet_r')\n",
    "norm = mpl.colors.Normalize(vmin=900, vmax=1020)\n",
    "crs = ccrs.PlateCarree() # central_longitude=central_lon)\n",
    "\n",
    "def TrackPlot(df,extent=None,axx=None,fname=None,circ=None):\n",
    "    \n",
    "    #addcolorbar=False\n",
    "    if axx is None:\n",
    "        fig, axx = plt.subplots(nrows=1, ncols=1, dpi=72,\n",
    "                           figsize=(12, 12), \n",
    "                           subplot_kw={'projection': crs})\n",
    "    #    addcolorbar=True\n",
    "    addcolorbar=True\n",
    "    \n",
    "    IDX=np.unique(df.index).astype(int)\n",
    "    \n",
    "    for i,idx in enumerate(IDX): # [0:10]:\n",
    "        x=df.loc[df.index==idx].Longitude\n",
    "        y=df.loc[df.index==idx].Latitude\n",
    "        c=df.loc[df.index==idx].Min_pres\n",
    "        axx.plot(x, y, linewidth=.1, transform=crs, color='k')\n",
    "        axx.plot(x.iloc[0], y.iloc[0], marker='*', transform=crs, color='g')\n",
    "        axx.plot(x.iloc[-1], y.iloc[-1], marker='*', transform=crs, color='r')\n",
    "        cm=axx.scatter(x=x, y=y, c=c, cmap=cmap, transform=crs, norm=norm, s=12)\n",
    "        \n",
    "    if extent is not None: \n",
    "        axx.set_extent(extent)\n",
    "        \n",
    "    addFeatures(axx)\n",
    "    gl = axx.gridlines(draw_labels=True, dms=True, x_inline=False, y_inline=False)\n",
    "    gl.xlabel_style = {'size': 12, 'color': 'k'}\n",
    "    gl.ylabel_style = {'size': 12, 'color': 'k'}\n",
    "    gl.left_labels = True\n",
    "    gl.right_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    gl.xlocator = mticker.FixedLocator(np.arange(-120, 0, 5))\n",
    "    gl.ylocator = mticker.FixedLocator(np.arange(   0, 70, 5))\n",
    "    \n",
    "    if circ is not None:\n",
    "        axx.plot(circ['cirx'],circ['ciry'],transform=crs,linewidth=3, color='k')\n",
    "        \n",
    "    \n",
    "    if addcolorbar:\n",
    "        cb1 = plt.colorbar(cm, ax=axx, orientation='vertical', pad=0.02, aspect=15, shrink=0.15)\n",
    "        cb1.ax.set_ylabel('[mb]', size=12)\n",
    "        cb1.ax.tick_params(labelsize='large')\n",
    "    \n",
    "    if fname is not None:\n",
    "        fig.savefig(fname)\n",
    "    \n",
    "def fullTrackPlot(dfnc,extentnc,nc_circ,dftx,extenttx,tx_circ,fname=None):\n",
    "\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=2, dpi=144,\n",
    "                           figsize=(18, 36), # sharey=True,\n",
    "                           subplot_kw={'projection': crs})\n",
    "\n",
    "    TrackPlot(dftx,extent=extenttx,axx=ax[0],circ=tx_circ)\n",
    "    TrackPlot(dfnc,extent=extentnc,axx=ax[1],circ=nc_circ)\n",
    "\n",
    "    # cb1 = fig.colorbar(cm, ax=ax, orientation='vertical', pad=0.02, shrink=0.19, aspect=15)\n",
    "    # cb1.ax.set_ylabel('[mb]', size=12)\n",
    "    # cb1.ax.tick_params(labelsize='large')\n",
    "\n",
    "    if fname is not None:\n",
    "        fig.savefig(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "basin='NA'\n",
    "ensnum=0\n",
    "#url=f'/srv/jupyterhub/share/DATA/STORM_data/STORM_DATA_IBTRACS_{basin}_1000_YEARS_{ensnum}.txt'\n",
    "# url=f'/home/bblanton/DATA/STORM_data/STORM_DATA_IBTRACS_{basin}_1000_YEARS_{ensnum}.txt'\n",
    "# os.path.exists(url)\n",
    "url=f'http://tds3.renci.org:8080/thredds/fileServer/cheer/STORM_Bloemendaal_data/current/STORM_DATA_IBTRACS_{basin}_1000_YEARS_{ensnum}.txt'\n",
    "#url=f'http://tds3.renci.org:8080/thredds/fileServer/cheer/STORM_Bloemendaal_data/future/HADGEM/STORM_DATA_HadGEM3-GC31-HM_{basin}_1000_YEARS_{ensnum}_IBTRACSDELTA.txt'\n",
    "\n",
    "# define dicts for filtering circles for case study areas:\n",
    "a=np.arange(0,370,10)*np.pi/180\n",
    "rad=3\n",
    "lo=-76.5\n",
    "la=34.75\n",
    "nc_circ={'lo': lo,\n",
    "         'la': la, \n",
    "         'rad': rad,\n",
    "         'cirx': rad*np.cos(a)+lo,\n",
    "         'ciry': rad*np.sin(a)+la}\n",
    "\n",
    "rad=3\n",
    "lo=-94\n",
    "la=29.5\n",
    "tx_circ={'lo': lo,\n",
    "         'la':  la,\n",
    "         'rad': rad,\n",
    "         'cirx': rad*np.cos(a)+lo,\n",
    "         'ciry': rad*np.sin(a)+la}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cols=[\n",
    "    'Year',       # Starts at 0\n",
    "    'Month', \n",
    "    'TC_number',  # For every year; starts at 0.\n",
    "    'Time_step',  # 3-hr, For every TC; starts at 0.\n",
    "    'Basin_ID',   # 0=EP, 1=NA, 2=NI, 3=SI, 4=SP, 5=WP\n",
    "    'Latitude',   # Deg, Position of the eye.\n",
    "    'Longitude',  # Deg, Position of the eye. Ranges from 0-360°, with prime meridian at Greenwich.\n",
    "    'Min_pres',   # hPa\n",
    "    'MaxWindSpd', # m/s\n",
    "    'RMW',        # km\n",
    "    'Category',   #\n",
    "    'Landfall',   # 0= no landfall, 1= landfall\n",
    "    'Dist2land'   # km\n",
    "    ]\n",
    "\n",
    "def LoadSTORMFile(url):\n",
    "    df=pd.read_csv(url, names=cols)\n",
    "\n",
    "    # generate an \"absolute storm number (abssn)\" to uniquely identify each storm \n",
    "    # in the dataset, then set that to be the dataframe index\n",
    "    df['abssn']=np.cumsum(1*(df.Time_step==0))\n",
    "    df.set_index('abssn',inplace=True)\n",
    "\n",
    "    idx_all=np.unique(df.index).astype(int)\n",
    "\n",
    "    # add a Day, Hour columns\n",
    "    day=np.floor(df['Time_step']*3/24+1)\n",
    "    df.insert(2, 'Day', day)\n",
    "    hour=24*(df['Time_step']*3/24+1-df['Day'])\n",
    "    df.insert(3, 'Hour', hour)\n",
    "\n",
    "    df['Longitude']=df['Longitude']-360\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the STORM dataset\n",
    "df=LoadSTORMFile(url)\n",
    "\n",
    "# Compute a \"distance\" to the target areas, used to screen storm population\n",
    "df['dist2nc']=np.sqrt(np.square(df['Longitude']-nc_circ['lo']) + np.square(df['Latitude']-nc_circ['la']))\n",
    "df['dist2tx']=np.sqrt(np.square(df['Longitude']-tx_circ['lo']) + np.square(df['Latitude']-tx_circ['la']))\n",
    "\n",
    "display(df.head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# plot the screening circles\n",
    "crs = ccrs.PlateCarree() # central_longitude=central_lon)\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, \n",
    "                       figsize=(10, 10), \n",
    "                       subplot_kw={'projection': crs})\n",
    "ax.plot(nc_circ['cirx'],nc_circ['ciry'],transform=crs)\n",
    "ax.plot(tx_circ['cirx'],tx_circ['ciry'],transform=crs)\n",
    "#ax.plot(df['Longitude'].iloc[0],df['Latitude'].iloc[0],transform=crs,marker='*')\n",
    "\n",
    "addFeatures(ax)\n",
    "gl = ax.gridlines(draw_labels=True, dms=True, x_inline=False, y_inline=False)\n",
    "gl.xlabel_style = {'size': 12, 'color': 'k'}\n",
    "gl.ylabel_style = {'size': 12, 'color': 'k'}\n",
    "gl.left_labels = True\n",
    "gl.right_labels = False\n",
    "gl.bottom_labels = True\n",
    "gl.xlocator = mticker.FixedLocator(np.arange(-100, -40, 5))\n",
    "gl.ylocator = mticker.FixedLocator(np.arange(   0,  50, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Find the storm index numbers (anssn) that pass thru the screening circles\n",
    "# This gets the parts of tracks that enter the circles.  The complete track will be extracted below\n",
    "df_nc=df.loc[(df['dist2nc'] <=nc_circ['rad'])] #  & (df['Min_pres'] <= 980)]\n",
    "df_tx=df.loc[(df['dist2tx'] <=tx_circ['rad'])] #  & (df['Min_pres'] <= 980)]\n",
    "idx_nc=np.unique(df_nc.index).astype(int)\n",
    "idx_tx=np.unique(df_tx.index).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Screen out storms shorter than MinDays\n",
    "\n",
    "MinDays=4\n",
    "temp_list=list()\n",
    "for idx in idx_nc: \n",
    "    df_temp=df.loc[df.index==idx].copy()    \n",
    "    d=df_temp.iloc[:,2].values[-1]\n",
    "    if d > MinDays: \n",
    "        temp_list.append(df_temp)\n",
    "df_nc=pd.concat(temp_list)\n",
    "idx_nc=np.unique(df_nc.index).astype(int)  # update index\n",
    "          \n",
    "temp_list=list()\n",
    "for idx in idx_tx:\n",
    "    df_temp=df.loc[df.index==idx].copy()\n",
    "    d=df_temp.iloc[:,2].values[-1]\n",
    "    if d > MinDays: \n",
    "        temp_list.append(df_temp)    \n",
    "df_tx=pd.concat(temp_list)\n",
    "idx_tx=np.unique(df_tx.index).astype(int)\n",
    "\n",
    "extent=[-100, 0, 0, 60]\n",
    "fullTrackPlot(df_nc,extent,nc_circ,df_tx,extent,tx_circ,fname='STORM_NA_0_NC_TX_PRESENT_1.png')\n",
    "\n",
    "# display(df_nc.head())\n",
    "# display(df_tx.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Screen out parts of storm tracks significantly far from the study areas\n",
    "#  and eliminate storms that start within the screening circle.  [Need to think about\n",
    "# this, but probably too close to coast to allow for complete spinup.]\n",
    "MaxLon_At_Start_Of_Track_NC=-60\n",
    "temp_list=list()\n",
    "for i,idx in enumerate(idx_nc): \n",
    "    df_temp=df_nc.loc[df_nc.index==idx].copy()    \n",
    "    \n",
    "    while df_temp['Longitude'].iloc[0] > MaxLon_At_Start_Of_Track_NC:\n",
    "        df_temp = df_temp.iloc[1: , :]\n",
    "    while df_temp['Longitude'].iloc[-1] > MaxLon_At_Start_Of_Track_NC:\n",
    "        df_temp = df_temp.iloc[:-2 , :]\n",
    "    if df_temp.dist2nc.iloc[0] < nc_circ['rad']:\n",
    "        df_temp = pd.DataFrame()\n",
    "    temp_list.append(df_temp)\n",
    "    \n",
    "df_nc=pd.concat(temp_list)\n",
    "idx_nc=np.unique(df_nc.index).astype(int)  # update index\n",
    "#print(len(idx_nc))\n",
    "\n",
    "MinLon_At_Start_Of_Track_TX=-81\n",
    "temp_list=list()\n",
    "for i,idx in enumerate(idx_tx): \n",
    "    df_temp=df_tx.loc[df_tx.index==idx].copy()    \n",
    "    \n",
    "    while df_temp['Longitude'].iloc[0] > MinLon_At_Start_Of_Track_TX:\n",
    "        df_temp = df_temp.iloc[1: , :]\n",
    "    while df_temp['Longitude'].iloc[-1] > MinLon_At_Start_Of_Track_TX:\n",
    "        df_temp = df_temp.iloc[:-2 , :]\n",
    "    if df_temp.dist2tx.iloc[0] < tx_circ['rad']:\n",
    "        df_temp = pd.DataFrame()\n",
    "        \n",
    "    temp_list.append(df_temp)\n",
    "    \n",
    "df_tx=pd.concat(temp_list)\n",
    "idx_tx=np.unique(df_tx.index).astype(int)\n",
    "#print(len(idx_tx))\n",
    "\n",
    "# make plot of result\n",
    "dlo, dla = 20, 20\n",
    "extnc=[nc_circ['lo']-dlo, nc_circ['lo']+dlo, nc_circ['la']-dla, nc_circ['la']+dla]\n",
    "exttx=[tx_circ['lo']-dlo, tx_circ['lo']+dlo, tx_circ['la']-dla, tx_circ['la']+dla]\n",
    "fullTrackPlot(df_nc,extnc,nc_circ,df_tx,exttx,tx_circ,fname='STORM_NA_0_NC_TX_PRESENT_2.png')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Flush tracks to csv files\n",
    "# Loop over abssns in subset and export complete track for each\n",
    "if not os.path.exists('CHEER'):\n",
    "    os.mkdir('CHEER')\n",
    "    \n",
    "for idx in idx_nc: # [0:10]:\n",
    "    fname=f'CHEER/NC_Present_{ensnum}_{idx:05d}.csv'\n",
    "    df_temp=df_nc2.loc[df_nc2.index==idx]\n",
    "    df_temp.to_csv(fname)\n",
    "\n",
    "for idx in idx_tx: # [0:10]:\n",
    "    fname=f'CHEER/TX_Present_{ensnum}_{idx:05d}.csv'\n",
    "    df_temp=df_tx2.loc[df_tx2.index==idx]\n",
    "    df_temp.to_csv(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "v='RMW'\n",
    "ylim1=0.07\n",
    "xlim1=400\n",
    "hargs={}\n",
    "kwargs = {\"density\": True, \"bins\": 25} \n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=3, dpi=72,\n",
    "                       figsize=(12,6),sharey=True) \n",
    "#df_nc[v].hist(ax=ax[0],**kwargs)\n",
    "# ax[0].set_xlim([0.,xlim1])\n",
    "# ax[0].set_ylim([0.,ylim1])\n",
    "df_nc['Min_pres'].hist(ax=ax[0],color='blue',**kwargs)\n",
    "ax[0].set_xlabel('Central Pres [mb]')\n",
    "df_nc['RMW'].hist(ax=ax[1],color='blue',**kwargs)\n",
    "ax[1].set_xlabel('RMW [km]')\n",
    "df_nc['MaxWindSpd'].hist(ax=ax[2],color='blue',**kwargs)\n",
    "ax[2].set_xlabel('Max Wind Spd [m/s]')\n",
    "# df_tx[v].hist(ax=ax[1],**kwargs)\n",
    "# ax[1].set_xlim([0.,xlim1])\n",
    "ax[0].set_ylim([0.,ylim1])\n",
    "ax[1].set_xlim([0.,200])\n",
    "\n",
    "fig.savefig('STORM_NA_dists.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx=idx_nc[0]\n",
    "df_sub=df_nc.loc[df_nc.index==idx]\n",
    "TrackPlot(df_sub,fname='STORM_NA_exampleTrack.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # subset the data frame using filters on the columns\n",
    "\n",
    "# # in this example, select the first 50 years of the synthetic, 1000yr set\n",
    "# df_sub=df.loc[(df['Year'] < 50)]\n",
    "# x=df_sub.Longitude\n",
    "# y=df_sub.Latitude\n",
    "# z=df_sub.Min_pres\n",
    "\n",
    "# # df_sub=df_nc\n",
    "# # x=df_sub.Longitude\n",
    "# # y=df_sub.Latitude\n",
    "# # z=df_sub.Min_pres\n",
    "\n",
    "# print(x.shape, np.min(x), np.max(x))\n",
    "# print(z.shape, np.min(z), np.max(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basin-scale\n",
    "extent = [ -90, -15, 5, 60] \n",
    "central_lon = np.mean(extent[:2])\n",
    "central_lat = np.mean(extent[2:])\n",
    "crs = ccrs.LambertConformal(central_longitude=central_lon, central_latitude=central_lat)\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, \n",
    "                       figsize=(16, 16), \n",
    "                       constrained_layout=True,\n",
    "                       subplot_kw={'projection': crs})\n",
    "\n",
    "for idx in idx_all:\n",
    "    x=df.loc[df.index==idx].Longitude\n",
    "    y=df.loc[df.index==idx].Latitude\n",
    "    c=df.loc[df.index==idx].Min_pres\n",
    "    ax.plot(x, y, linewidth=.1, transform=ccrs.PlateCarree(), color='k')\n",
    "    #cm=ax[0].scatter(x=x, y=y, c=c, cmap=cmap, transform=crs, norm=norm, s=12)\n",
    "    \n",
    "for i,idx in enumerate(idx_tx): # [0:10]:\n",
    "    x=df_tx.loc[df_tx.index==idx].Longitude\n",
    "    y=df_tx.loc[df_tx.index==idx].Latitude\n",
    "    c=df_tx.loc[df_tx.index==idx].Min_pres\n",
    "    ax.plot(x, y, linewidth=.5,  transform=ccrs.PlateCarree(), color='r')\n",
    "    \n",
    "for k,idx in enumerate(idx_nc): # [0:10]:\n",
    "    x=df_nc.loc[df_nc.index==idx].Longitude\n",
    "    y=df_nc.loc[df_nc.index==idx].Latitude\n",
    "    c=df_nc.loc[df_nc.index==idx].Min_pres\n",
    "    ax.plot(x, y, linewidth=.5,  transform=ccrs.PlateCarree(), color='b')\n",
    "    \n",
    "plt.grid(True)\n",
    "cb1 = fig.colorbar(cm, ax=ax, orientation='vertical', shrink=0.65, pad=0.025)\n",
    "cb1.ax.set_ylabel('[mb]', size=16)\n",
    "cb1.ax.tick_params(labelsize='large')\n",
    "\n",
    "ax.set_extent(extent)\n",
    "addFeatures(ax)\n",
    "#set_gridLines(ax,False,True,True,False)\n",
    "gl = ax.gridlines(draw_labels=True, dms=True, x_inline=False, y_inline=False)\n",
    "gl.xlabel_style = {'size': 15, 'color': 'k'}\n",
    "gl.ylabel_style = {'size': 15, 'color': 'k'}\n",
    "gl.right_labels = False\n",
    "gl.bottom_labels = False\n",
    "gl.xlocator = mticker.FixedLocator(np.arange(-100,0,5))\n",
    "gl.ylocator = mticker.FixedLocator(np.arange(0,80,5))\n",
    "\n",
    "plt.box(True)\n",
    "\n",
    "fig.savefig('STORM_NA_0.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Figure 4: Synthetic hurricanes from the STORM dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Pangeo",
   "language": "python",
   "name": "pangeo"
  },
  "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}