RegressionSlopes_Daily.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For some variables, it would be more useful to know the relationship between them at *daily* scales rather than using monthly averages. \n",
    "<b>Author:</b> Meg Fowler <br>\n",
    "<b>Date:</b> 26 Oct 2020 <br><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load libraries\n",
    "\n",
    "# Plotting utils \n",
    "import matplotlib.pyplot as plt \n",
    "import matplotlib.colors as colors\n",
    "import matplotlib.ticker as ticker \n",
    "import matplotlib.patches as patches\n",
    "import matplotlib.animation as animation\n",
    "import matplotlib as matplotlib\n",
    "import cartopy\n",
    "import cartopy.feature as cfeature\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.util\n",
    "\n",
    "# Analysis\n",
    "import os\n",
    "import numpy as np \n",
    "import xarray as xr\n",
    "import datetime\n",
    "from   datetime import date, timedelta\n",
    "import pandas as pd \n",
    "#import regionmask\n",
    "import pickle\n",
    "import scipy.stats as stats\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Read in data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that for the UV daily data, since this is such a large dataset, only the lowest three levels were selected via the NCO command: <br> \n",
    "<i>ncrcat -d lev,950.0,999.0 -v U,V f.e20.FHIST.f09_f09.cesm2_1.001.cam.h1.199* f.e20.FHIST.f09_f09.cesm2_1.001.cam.h1.1990-99_sfcLevs-dailyUV.nc</i> <br><br>\n",
    "Once those files have been read in here, a new pickle file is created that contains the total surface wind speed, rather than U and V seperately. Once that pickle file is available, the original UV files will be deleted. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up directories \n",
    "dataDir    = '/Users/mdfowler/Documents/Analysis/CLUBB_initial/data/daily/'\n",
    "nameStart  = 'f.e20.FHIST.f09_f09.cesm2_1.001.cam.h1.'\n",
    "nameEnd_UV = '_sfcLevs-dailyUV.nc'\n",
    "nameEnd_FLX  = '_dailySfcFluxes.nc'\n",
    "\n",
    "decadeList = ['1970-79','1980-89','1990-99']\n",
    "#decadeList = ['1990-99']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-3-a62247b44c48>:16: RuntimeWarning: invalid value encountered in less\n",
      "  iceMask[iceContent<10000] = 1\n"
     ]
    }
   ],
   "source": [
    "# Read in single history file to get lat/lon and masks \n",
    "testName = '/Users/mdfowler/Documents/Analysis/CLUBB_initial/data/f.e20.FHIST.f09_f09.cesm2_1.001.clm2.h0.1989-12.nc'\n",
    "testDF   = xr.open_dataset(testName)\n",
    "\n",
    "# Set lat, lon \n",
    "lat = testDF.lat\n",
    "lon = testDF.lon\n",
    "\n",
    "# Make land mask\n",
    "landMask              = testDF.landmask.values\n",
    "landMask[landMask==0] = np.nan\n",
    "\n",
    "# Ideally, want to mask out Greenland/Antarctica too (ice sheets)\n",
    "iceContent = testDF.ICE_CONTENT1.values[0,:,:]  # \"Initial gridcell total ice content\"\n",
    "iceMask    = np.full([len(lat),len(lon)], np.nan)\n",
    "iceMask[iceContent<10000] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-4-e5f272e26ea6>:11: RuntimeWarning: Converting a CFTimeIndex with dates from a non-standard calendar, 'noleap', to a pandas.DatetimeIndex, which uses dates from the standard calendar.  This may lead to subtle errors in operations that depend on the length of time between dates.\n",
      "  flxDF['time'] = flxDF.indexes['time'].to_datetimeindex()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done with decade  1970-79  ... \n",
      "Done with decade  1980-89  ... \n",
      "Done with decade  1990-99  ... \n"
     ]
    }
   ],
   "source": [
    "# Read in data by decade \n",
    "for iDec in range(len(decadeList)): \n",
    "    \n",
    "    # Open datasets for each decade \n",
    "#     UVfile = dataDir+nameStart+decadeList[iDec]+nameEnd_UV \n",
    "#     windDF = xr.open_dataset(UVfile, decode_times=True)\n",
    "#     windDF['time'] = windDF.indexes['time'].to_datetimeindex()   \n",
    "    \n",
    "    FLXfile = dataDir+nameStart+decadeList[iDec]+nameEnd_FLX\n",
    "    flxDF   = xr.open_dataset(FLXfile, decode_times=True)\n",
    "    flxDF['time'] = flxDF.indexes['time'].to_datetimeindex()\n",
    "    \n",
    "    # Create *giant* datasets that span the full period of the simulations\n",
    "    if iDec==0:\n",
    "#         fullUV   = windDF\n",
    "        fullFLX  = flxDF\n",
    "    else:\n",
    "#         fullUV   = xr.concat([fullUV, windDF], dim=\"time\")\n",
    "        fullFLX  = xr.concat([fullFLX, flxDF], dim=\"time\")\n",
    "        \n",
    "    # Close files \n",
    "#     windDF.close() \n",
    "    flxDF.close()\n",
    "\n",
    "        \n",
    "    print('Done with decade ', decadeList[iDec], ' ... ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To be able to easily access years, months, days - use Pandas \n",
    "dates = pd.DatetimeIndex(flxDF['time'].values) \n",
    "\n",
    "# Let's set the monthly averages to be roughly mid-month\n",
    "#   This way, the average for January has a month of 1 instead of being the first day of February \n",
    "midTime = dates - timedelta(days=15)       # Get new dates array that has the right month/year in it \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read into individual arrays for easy access\n",
    "SHFLX = fullFLX.SHFLX.values\n",
    "LHFLX = fullFLX.LHFLX.values\n",
    "# U     = fullUV.U.values              # Zonal wind (m/s)\n",
    "# V     = fullUV.V.values              # Meridional wind (m/s)\n",
    "\n",
    "# # Flip along vertical (level) axis, so that index 0 is surface \n",
    "# U   = np.flip(U, axis=1)\n",
    "# V   = np.flip(V, axis=1)\n",
    "\n",
    "# # Save levels themselves to arrays and flip them \n",
    "# lev_middle    = np.flip(fullUV.lev.values)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now get surface wind magnitude and combine variances \n",
    "# windSpd = np.sqrt(U**2 + V**2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved file:  /Users/mdfowler/Documents/Analysis/CLUBB_initial/data/daily/1990-99_totalWindSpeeds.p\n"
     ]
    }
   ],
   "source": [
    "# # Save wind speed out to a pickle file\n",
    "# fileOutName = dataDir+decadeList[0]+'_totalWindSpeeds.p'\n",
    "# pickle.dump( [windSpd,lev_middle], open( fileOutName, \"wb\" ), protocol=4 )\n",
    "# print('Saved file: ', fileOutName)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now read in pickle files that contain total surface wind speeds. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load wind speed from pickle file:\n",
    "windSpd = np.full([np.shape(SHFLX)[0], 3, len(lat), len(lon)], np.nan)  # (all times, 3 levels, lat, lon)\n",
    "\n",
    "iStartTime = 0 \n",
    "for iDec in range(len(decadeList)):\n",
    "    # Read in file for one decade\n",
    "    fileOutName              = dataDir+decadeList[iDec]+'_totalWindSpeeds.p'\n",
    "    \n",
    "    with open(fileOutName, \"rb\") as f:\n",
    "        windSpd_temp, lev_middle = pickle.load(f)\n",
    "    \n",
    "    # Save to larger array \n",
    "    nTime      = np.shape(windSpd_temp)[0]\n",
    "    windSpd[iStartTime:nTime+iStartTime,:,:,:] = windSpd_temp\n",
    "    iStartTime = iStartTime+nTime\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Carry out linear regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linRegress3D(xVar, yVar):\n",
    "    \n",
    "    # Get length of lat/lon dimensions \n",
    "    shapeDat = np.shape(xVar)\n",
    "    nlat     = shapeDat[1]\n",
    "    nlon     = shapeDat[2]\n",
    "    \n",
    "    # Define empty arrays to return \n",
    "    slope     = np.full([nlat, nlon], np.nan)\n",
    "    intercept = np.full([nlat, nlon], np.nan)\n",
    "    rValue    = np.full([nlat, nlon], np.nan)\n",
    "    pValue    = np.full([nlat, nlon], np.nan)\n",
    "    \n",
    "    for ilat in range(len(lat)):\n",
    "        for ilon in range(len(lon)): \n",
    "            x = xVar[:,ilat,ilon]\n",
    "            y = yVar[:,ilat,ilon]\n",
    "\n",
    "            # Perform linear regression\n",
    "            slope[ilat,ilon], intercept[ilat,ilon], rValue[ilat,ilon], pValue[ilat,ilon], std_err = stats.linregress(x, y)\n",
    "\n",
    "\n",
    "    return(slope,intercept,rValue,pValue)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pull out surface layer of wind speed\n",
    "#   Levels are: [992.56, 976.33, 957.49] \n",
    "sfcWindSpd      = windSpd[:,0,:,:]\n",
    "\n",
    "# Use only land points... (and exclude ice sheets)\n",
    "sfcWindSpd_land = sfcWindSpd*landMask*iceMask\n",
    "SHFLX_land      = SHFLX*landMask*iceMask\n",
    "LHFLX_land      = LHFLX*landMask*iceMask\n",
    "\n",
    "# Also consider using the bowen ratio or EF rather than fluxes individually (more holistic energy concept)\n",
    "EF_land         = LHFLX_land / (LHFLX_land + SHFLX_land)\n",
    "bowen_land      = SHFLX_land / LHFLX_land\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get seasonal indices \n",
    "iDJF = np.where((midTime.month==12) | (midTime.month<=2))[0]\n",
    "iMAM = np.where((midTime.month>=3)  & (midTime.month<=5))[0]\n",
    "iJJA = np.where((midTime.month>=6)  & (midTime.month<=8))[0]\n",
    "iSON = np.where((midTime.month>=9)  & (midTime.month<=11))[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now pick out JJA values: \n",
    "sfcWindSpd_JJA = sfcWindSpd_land[iJJA,:,:]\n",
    "SHFLX_JJA      = SHFLX_land[iJJA,:,:]\n",
    "LHFLX_JJA      = LHFLX_land[iJJA,:,:]\n",
    "EF_JJA         = EF_land[iJJA,:,:]\n",
    "bowen_JJA      = bowen_land[iJJA,:,:]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "...Regression between wind speed and surface fluxes completed...\n",
      "...Regression between wind speed and EF/Bowen ratio completed...\n"
     ]
    }
   ],
   "source": [
    "# Linear regression between mean wind speed and SHFLX \n",
    "slope_SpdSHF_JJA,intercept_SpdSHF_JJA,rValue_SpdSHF_JJA,pValue_SpdSHF_JJA = linRegress3D(sfcWindSpd_JJA, np.abs(SHFLX_JJA))\n",
    "\n",
    "# Linear regression between mean wind speed and LHFLX\n",
    "slope_SpdLHF_JJA,intercept_SpdLHF_JJA,rValue_SpdLHF_JJA,pValue_SpdLHF_JJA = linRegress3D(sfcWindSpd_JJA, np.abs(LHFLX_JJA))\n",
    "print('...Regression between wind speed and surface fluxes completed...')\n",
    "\n",
    "# Linear regression between mean wind speed and evaporative fraction \n",
    "slope_SpdEF_JJA,intercept_SpdEF_JJA,rValue_SpdEF_JJA,pValue_SpdEF_JJA = linRegress3D(sfcWindSpd_JJA, EF_JJA)\n",
    "\n",
    "# Linear regresion between mean wind speed and bowen ratio \n",
    "slope_SpdBowen_JJA,intercept_SpdBowen_JJA,rValue_SpdBowen_JJA,pValue_SpdBowen_JJA = linRegress3D(sfcWindSpd_JJA, bowen_JJA)\n",
    "print('...Regression between wind speed and EF/Bowen ratio completed...')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Check out where correlation coefficients - higher?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14035\n",
      "14035\n",
      "14035\n",
      "14035\n"
     ]
    }
   ],
   "source": [
    "print(len(np.where(np.isfinite(rValue_SpdSHF_JJA)==True)[0]))\n",
    "print(len(np.where(np.isfinite(rValue_SpdLHF_JJA)==True)[0]))\n",
    "print(len(np.where(np.isfinite(rValue_SpdEF_JJA)==True)[0]))\n",
    "print(len(np.where(np.isfinite(rValue_SpdBowen_JJA)==True)[0]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78\n",
      "717\n",
      "211\n",
      "194\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-16-c31fa9562821>:2: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  print(len(np.where(np.abs(rValue_SpdSHF_JJA)>=threshold)[0]))\n",
      "<ipython-input-16-c31fa9562821>:3: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  print(len(np.where(np.abs(rValue_SpdLHF_JJA)>=threshold)[0]))\n",
      "<ipython-input-16-c31fa9562821>:4: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  print(len(np.where(np.abs(rValue_SpdEF_JJA)>=threshold)[0]))\n",
      "<ipython-input-16-c31fa9562821>:5: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  print(len(np.where(np.abs(rValue_SpdBowen_JJA)>=threshold)[0]))\n"
     ]
    }
   ],
   "source": [
    "threshold = 0.7\n",
    "print(len(np.where(np.abs(rValue_SpdSHF_JJA)>=threshold)[0]))\n",
    "print(len(np.where(np.abs(rValue_SpdLHF_JJA)>=threshold)[0]))\n",
    "print(len(np.where(np.abs(rValue_SpdEF_JJA)>=threshold)[0]))\n",
    "print(len(np.where(np.abs(rValue_SpdBowen_JJA)>=threshold)[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fraction of correlation coefficients > 0.50: \n",
      "   SpdSHF_JJA:   0.0546\n",
      "   SpdLHF_JJA:   0.1001\n",
      "   SpdEF_JJA:    0.0576\n",
      "   SpdBowen_JJA: 0.0583\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-25-ad8d71f926a6>:5: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  spdSHF_JJA_count   = len(np.where(np.abs(rValue_SpdSHF_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdSHF_JJA)==True)[0])\n",
      "<ipython-input-25-ad8d71f926a6>:6: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  spdLHF_JJA_count   = len(np.where(np.abs(rValue_SpdLHF_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdLHF_JJA)==True)[0])\n",
      "<ipython-input-25-ad8d71f926a6>:7: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  spdEF_JJA_count    = len(np.where(np.abs(rValue_SpdEF_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdEF_JJA)==True)[0])\n",
      "<ipython-input-25-ad8d71f926a6>:8: RuntimeWarning: invalid value encountered in greater_equal\n",
      "  spdBowen_JJA_count = len(np.where(np.abs(rValue_SpdBowen_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdBowen_JJA)==True)[0])\n"
     ]
    }
   ],
   "source": [
    "# Define threshold for cutting off values of slopes as 'significant'\n",
    "threshold = 0.70 \n",
    "\n",
    "# Get fraction of correlation coefficients above threshold \n",
    "spdSHF_JJA_count   = len(np.where(np.abs(rValue_SpdSHF_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdSHF_JJA)==True)[0])\n",
    "spdLHF_JJA_count   = len(np.where(np.abs(rValue_SpdLHF_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdLHF_JJA)==True)[0])\n",
    "spdEF_JJA_count    = len(np.where(np.abs(rValue_SpdEF_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdEF_JJA)==True)[0])\n",
    "spdBowen_JJA_count = len(np.where(np.abs(rValue_SpdBowen_JJA)>=threshold)[0])/len(np.where(np.isfinite(rValue_SpdBowen_JJA)==True)[0])\n",
    "\n",
    "# Print some summary values \n",
    "print('Fraction of correlation coefficients > %.2f: ' % (threshold))\n",
    "print('   SpdSHF_JJA:   %.4f' % (spdSHF_JJA_count))\n",
    "print('   SpdLHF_JJA:   %.4f' % (spdLHF_JJA_count))\n",
    "print('   SpdEF_JJA:    %.4f' % (spdEF_JJA_count))\n",
    "print('   SpdBowen_JJA: %.4f' % (spdBowen_JJA_count))\n",
    "\n",
    "\n",
    "## Define mask based on where corrCoef >= 0.7 for spdVar and varPBL;\n",
    "#    Mask based on where corrCoef>=0.5 otherwise. \n",
    "# maskR_spdSHF = np.full([len(lat), len(lon)], np.nan)\n",
    "# maskR_spdSHF[np.abs(rValue_SpdSHF_JJA)>=0.5] = 1 \n",
    "\n",
    "# maskR_spdLHF = np.full([len(lat), len(lon)], np.nan)\n",
    "# maskR_spdLHF[np.abs(rValue_SpdLHF_JJA)>=0.5] = 1\n",
    "\n",
    "# maskR_spdEF = np.full([len(lat), len(lon)], np.nan)\n",
    "# maskR_spdEF[np.abs(rValue_SpdEF_JJA)>=0.5] = 1\n",
    "\n",
    "# maskR_spdBowen = np.full([len(lat), len(lon)], np.nan)\n",
    "# maskR_spdBowen[np.abs(rValue_SpdBowen_JJA)>=0.5] = 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Function to plot a map of correlation coefficients. \n",
    "Note: If some masking is desired for which correlation coefficients \n",
    "      are plotted, apply that prior to submitting to plot call here. \n",
    "\n",
    "Inputs: \n",
    "     rVals    --> Array of correlation coefficients to plot. \n",
    "     lat, lon --> lat/lon of data to map against \n",
    "     maxVal   --> Max value to plot (min will be negative of that; center = 0)\n",
    "     corrStr  --> string used in title of plot to describe the regression variables \n",
    "'''\n",
    "\n",
    "def mapCorrCoef(rVals, lat, lon, maxVal, corrStr):\n",
    "    \n",
    "    # Make rVals cyclic for plotting\n",
    "    rVals_cyclic, lon_cyclic = cartopy.util.add_cyclic_point(rVals, lon)\n",
    "    \n",
    "    # ----------- Set up figure ------------------------------------------\n",
    "    fig, ax1 = plt.subplots(1,1, figsize=(8, 12), \n",
    "                            facecolor='w', edgecolor='k',\n",
    "                            subplot_kw={'projection':ccrs.PlateCarree()})\n",
    "\n",
    "    # Set limits of plot\n",
    "    ax1.set_extent([-180, 180, -60, 90], crs=ccrs.PlateCarree())\n",
    "\n",
    "    # Add coastlines \n",
    "    ax1.coastlines(linewidth=0.5,edgecolor='0.25')\n",
    "    ax1.add_feature(cfeature.BORDERS,linewidth=0.5,edgecolor='0.25')\n",
    "    # --------------------------------------------------------------------\n",
    "    \n",
    "    # --------- Plot regions --------------------\n",
    "    contour_plot = ax1.pcolormesh(lon_cyclic,lat, rVals_cyclic,\n",
    "                            vmax=maxVal,vmin=-maxVal,\n",
    "                            cmap = 'seismic')\n",
    "\n",
    "    ax1.set_title('CorrCoef [JJA]: '+corrStr, fontsize=14)\n",
    "\n",
    "    # Add colorbar \n",
    "    ax_position = ax1.get_position()\n",
    "    cbar_ax     = fig.add_axes([ax_position.x0, ax_position.y0-0.03, ax_position.width, 0.02])\n",
    "    cbar        = plt.colorbar(contour_plot, orientation='horizontal', cax=cbar_ax)\n",
    "#     # Control number of ticks via 'ticker' in matplotlib \n",
    "#     tick_locator = ticker.MaxNLocator(nbins=1)\n",
    "#     cbar.locator = tick_locator\n",
    "#     cbar.update_ticks()\n",
    "    # Set label and fontsize\n",
    "    cbar.set_label('Correlation Coefficient',fontsize=14)\n",
    "    cbar.ax.tick_params(labelsize=14)\n",
    "    # --------------------------------------\n",
    "\n",
    "    ax1.axhline(0, color='lightgray')\n",
    "    \n",
    "    \n",
    "    return(ax1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<cartopy.mpl.geoaxes.GeoAxesSubplot at 0x7f8da00121c0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ------ Map of correlation coefficients: wind speed vs. SHF  ----- \n",
    "mapCorrCoef(rValue_SpdSHF_JJA, lat, lon, 1.0, 'WindSpeed v. abs(SHFLX)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(192, 288)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(rValue_SpdSHF_JJA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7f8da2c400d0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax1 = plt.subplots(1,1, figsize=(8, 5))\n",
    "\n",
    "# PLOT 1: Correlation coefficients (wind speed vs. abs(SHFLX))\n",
    "binEdges = np.arange(-1, 1.05, 0.05)\n",
    "\n",
    "ax1.hist(rValue_SpdSHF_JJA.reshape([len(lat)*len(lon)]), bins=binEdges,facecolor='grey')\n",
    "ax1.set_xlabel('Correlation Coefficient')\n",
    "ax1.set_title('Corr. Coef.:\\nWindSpeed vs. SHFLX')\n",
    "ax1.axvline(0, color='k',linestyle='--',label='_hidezero')\n",
    "\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": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing/Debug section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure compiling method for windSpd pickle files functions as expected (doesn't step on previous time step or anything)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 4., 6., 3., 1., 2., 4., 6., 3.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# x = np.asarray([1,2,4,6,3])\n",
    "# xFull = np.full([len(x)*2], np.nan)\n",
    "\n",
    "# iStartTime = 0 \n",
    "# for iDec in range(2):\n",
    "#     xFull[iStartTime:len(x)+iStartTime] = x \n",
    "#     iStartTime = iStartTime+len(x)\n",
    "    \n",
    "# xFull\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": []
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}