{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from netCDF4 import Dataset\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import matplotlib.colors as Normalize\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.feature as cfeature\n",
    "from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter\n",
    "import matplotlib.ticker as mticker\n",
    "import matplotlib\n",
    "import xarray as xr\n",
    "import netCDF4\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import glob\n",
    "import dask\n",
    "import os\n",
    "from matplotlib.colors import LinearSegmentedColormap, TwoSlopeNorm\n",
    "\n",
    "import wrf\n",
    "from wrf import (getvar, vinterp, interplevel, to_np, latlon_coords, get_cartopy,\n",
    "                 cartopy_xlim, cartopy_ylim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_in_monthly_data(month, hour_interval, climate_state, var_name):\n",
    "    \"\"\"\n",
    "    Reads in all NetCDF files for a given month and combines them into one dataset.\n",
    "\n",
    "    Parameters:\n",
    "        month (str): month you want data for, e.g., '04'\n",
    "        hour_interval (str): '1hr' or '3hr'\n",
    "        climate_state (str): 'current', 'future', or 'future_urban'\n",
    "        var_name (str): what variable you want to load in, e.g. \"wspd_wdir10\"\n",
    "\n",
    "    Returns:\n",
    "        xarray dataset of full month of data\n",
    "    \"\"\"\n",
    "    \n",
    "    # Determine the file path based on the input parameters\n",
    "    if hour_interval == '3hr':\n",
    "        #file_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/{hour_interval}/wrfout_d01_2017-{month}*'\n",
    "        file_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/{hour_interval}/wrfout_d01_2017-06-01_0*:00:00'\n",
    "    elif hour_interval == '1hr':\n",
    "        file_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/{hour_interval}/wrfout_hourly_d01_2017-{month}*'\n",
    "\n",
    "    # Use glob to find all matching files for the month\n",
    "    file_list = sorted(glob.glob(file_path))\n",
    "\n",
    "    array_list=[]\n",
    "    for file in file_list:\n",
    "        ##-- read file            \n",
    "        ncfile = netCDF4.Dataset(file,'r')\n",
    "        #print(ncfile) \n",
    "        print(file)\n",
    "        data = getvar(ncfile,var_name)\n",
    "        data = data.sel(mcape_mcin_lcl_lfc='mcape')\n",
    "        cloudfrac = getvar(ncfile,'cloudfrac')\n",
    "\n",
    "        # Mask all values where any level in low_mid_high is > 0\n",
    "        mask = (cloudfrac > 0).any(dim=\"low_mid_high\")\n",
    "        cloud_mask = cloudfrac.where(~mask, np.nan).min(dim='low_mid_high') == 0\n",
    "\n",
    "\n",
    "        # Apply cloud mask to only derive clear sky points\n",
    "        data = xr.where(cloud_mask, data, float(\"nan\"))\n",
    "\n",
    "        data = data.to_dataset(name=var_name)\n",
    "        array_list.append(data)\n",
    "        ncfile.close()\n",
    "\n",
    "    print('done')\n",
    "    combined_ds = xr.concat(array_list, dim='Time')\n",
    "\n",
    "    #combined_ds = combined_ds.to_dataset(name='vert_velo_mask')\n",
    "\n",
    "    #combined_ds[var_name].attrs['projection'] = str(combined_ds[var_name].attrs['projection'])\n",
    "\n",
    "    return combined_ds\n",
    "\n",
    "#ds1 = read_in_monthly_data('06', '3hr', 'current', 'cape_2d')\n",
    "#print(ds1)\n",
    "\n",
    "def create_custom_diverging_colormap(levels):\n",
    "    \"\"\"\n",
    "    Creates a custom diverging colormap with cool colors (blues) on one end and \n",
    "    warm colors (yellows, oranges, reds) on the other end.\n",
    "\n",
    "    Parameters:\n",
    "    - levels (int): The number of intervals or levels in the colormap.\n",
    "\n",
    "    Returns:\n",
    "    - colormap: A matplotlib colormap object.\n",
    "    \"\"\"\n",
    "\n",
    "    # Ensure levels is an odd number for symmetry around the white midpoint\n",
    "    \n",
    "    # Define the cool-to-warm color transition\n",
    "    custom_rgb = [\n",
    "        '#37569e', '#5578af', '#719cc1', '#b8e3e7', '#ffffff', \n",
    "        '#ffd784', '#fda75e', '#eb7949', '#d24d37', '#b12122'\n",
    "    ]\n",
    "\n",
    "    # Create a colormap with the specified number of levels\n",
    "    cmap = LinearSegmentedColormap.from_list(\"CoolWarmCustom\", custom_rgb, N=levels)\n",
    "\n",
    "\n",
    "    # Set the over and under values\n",
    "    cmap.set_under(np.array(hex_to_rgb('#0a348c'))/255)  # For values above max level\n",
    "    cmap.set_over(np.array(hex_to_rgb('#840000'))/255)  # For values below min level\n",
    "\n",
    "    return cmap\n",
    "\n",
    "def hex_to_rgb(value):\n",
    "    '''\n",
    "    Converts hex to rgb colours\n",
    "    value: string of 6 characters representing a hex colour.\n",
    "    Returns: list length 3 of RGB values'''\n",
    "    value = value.strip(\"#\") # removes hash symbol if present\n",
    "    lv = len(value)\n",
    "    return tuple(int(value[i:i + lv // 3], 16) for i in range(0, lv, lv // 3))\n",
    "\n",
    "# Remove boundaries\n",
    "def remove_lateral_boundaries(current_ds,future_ds,future_urban_ds):\n",
    "    # Access the latitude and longitude arrays (XLAT, XLONG)\n",
    "    lats = current_ds['XLAT']\n",
    "    lons = current_ds['XLONG']\n",
    "\n",
    "    # Get the shape of the latitude and longitude arrays\n",
    "    n_lat, n_lon = lats.shape\n",
    "    # Exclude 15 grid cells from each side (latitude and longitude)\n",
    "    lat_slice = slice(15, n_lat - 15)\n",
    "    lon_slice = slice(15, n_lon - 15)\n",
    "\n",
    "    # Subset the data using the grid cell indices\n",
    "    current_ds = current_ds.isel(south_north=lat_slice, west_east=lon_slice)\n",
    "    future_ds = future_ds.isel(south_north=lat_slice, west_east=lon_slice)\n",
    "    future_urban_ds = future_urban_ds.isel(south_north=lat_slice, west_east=lon_slice)\n",
    "\n",
    "    return current_ds,future_ds,future_urban_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "monlist=['04']\n",
    "'''\n",
    "# cape\n",
    "c_cape = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/current/mu_cape_total_month{monlist[0]}.nc')\n",
    "f_cape = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future/mu_cape_total_month{monlist[0]}.nc')\n",
    "fu_cape = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future_urban/mu_cape_total_month{monlist[0]}.nc')\n",
    "'''\n",
    "# lcl\n",
    "c_lcl = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/current/lcl_month{monlist[0]}.nc')\n",
    "f_lcl = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future/lcl_month{monlist[0]}.nc')\n",
    "fu_lcl = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future_urban/lcl_month{monlist[0]}.nc')\n",
    "'''\n",
    "\n",
    "# dew point\n",
    "c_dp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/current/dewpoint2m_data_month{monlist[0]}.nc')\n",
    "f_dp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future/dewpoint2m_data_month{monlist[0]}.nc')\n",
    "fu_dp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future_urban/dewpoint2m_data_month{monlist[0]}.nc')\n",
    "\n",
    "# pressure\n",
    "c_slp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/pressure_data/Current/slp_data_month{monlist[0]}.nc')\n",
    "f_slp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/pressure_data/Future/slp_data_month{monlist[0]}.nc')\n",
    "fu_slp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/pressure_data/Future_urban/slp_data_month{monlist[0]}.nc')\n",
    "\n",
    "# temp\n",
    "c_temp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/temp_data/Current/temp_data_month{monlist[0]}.nc')\n",
    "f_temp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/temp_data/Future/temp_data_month{monlist[0]}.nc')\n",
    "fu_temp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/temp_data/Future_urban/temp_data_month{monlist[0]}.nc')\n",
    "'''\n",
    "# 0-6km bulk shear\n",
    "c_bulk = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/current/bulk_shear_0_6km_month{monlist[0]}.nc')\n",
    "f_bulk = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future/bulk_shear_0_6km_month{monlist[0]}.nc')\n",
    "fu_bulk = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future_urban/bulk_shear_0_6km_month{monlist[0]}.nc')\n",
    "'''\n",
    "# 0-3km srh\n",
    "c_srh = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/current/0_3km_srh_month{monlist[0]}.nc')\n",
    "f_srh = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future/0_3km_srh_month{monlist[0]}.nc')\n",
    "fu_srh = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future_urban/0_3km_srh_month{monlist[0]}.nc')\n",
    "\n",
    "\n",
    "# 0-1km srh\n",
    "c_srh = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/current/0_1km_srh_month{monlist[0]}.nc')\n",
    "f_srh = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future/0_1km_srh_month{monlist[0]}.nc')\n",
    "fu_srh = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future_urban/0_1km_srh_month{monlist[0]}.nc')\n",
    "\n",
    "# bulk shear\n",
    "c_bulk = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/current/bulk_shear_month{monlist[0]}.nc')\n",
    "f_bulk = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future/bulk_shear_month{monlist[0]}.nc')\n",
    "fu_bulk = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future_urban/bulk_shear_month{monlist[0]}.nc')\n",
    "\n",
    "# lapse rate\n",
    "#c_lr = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/current/lapse_rate_3_8km_month{monlist[0]}.nc')\n",
    "#f_lr = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future/lapse_rate_3_8km_month{monlist[0]}.nc')\n",
    "#fu_lr = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future_urban/lapse_rate_3_8km_month{monlist[0]}.nc')\n",
    "\n",
    "'''\n",
    "# cloud mask\n",
    "c_cloud = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/current/MSKCLD_2017{monlist[0]}.nc')\n",
    "f_cloud = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/future/MSKCLD_2017{monlist[0]}.nc')\n",
    "fu_cloud = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/future_urban/MSKCLD_2017{monlist[0]}.nc')\n",
    "\n",
    "\n",
    "#c_cape,f_cape,fu_cape = remove_lateral_boundaries(c_cape,f_cape,fu_cape)\n",
    "c_lcl,f_lcl,fu_lcl = remove_lateral_boundaries(c_lcl,f_lcl,fu_lcl)\n",
    "#c_dp,f_dp,fu_dp = remove_lateral_boundaries(c_dp,f_dp,fu_dp)\n",
    "#c_slp,f_slp,fu_slp = remove_lateral_boundaries(c_slp,f_slp,fu_slp)\n",
    "#c_temp,f_temp,fu_temp = remove_lateral_boundaries(c_temp,f_temp,fu_temp)\n",
    "#c_srh,f_srh,fu_srh = remove_lateral_boundaries(c_srh,f_srh,fu_srh)\n",
    "c_bulk,f_bulk,fu_bulk = remove_lateral_boundaries(c_bulk,f_bulk,fu_bulk)\n",
    "#c_lr,f_lr,fu_lr = remove_lateral_boundaries(c_lr,f_lr,fu_lr)\n",
    "c_cloud,f_cloud,fu_cloud = remove_lateral_boundaries(c_cloud,f_cloud,fu_cloud)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_clear_sky_points(c_ds, f_ds, fu_ds):\n",
    "    c_clear_points = c_cloud['MSKCLD1'] < 1\n",
    "    f_clear_points = f_cloud['MSKCLD1'] < 1\n",
    "    fu_clear_points = fu_cloud['MSKCLD1'] < 1\n",
    "\n",
    "    c_ds = xr.where(c_clear_points, c_ds, float(\"nan\"))\n",
    "    f_ds = xr.where(f_clear_points, f_ds, float(\"nan\"))\n",
    "    fu_ds = xr.where(fu_clear_points, fu_ds, float(\"nan\"))\n",
    "\n",
    "    return c_ds, f_ds, fu_ds\n",
    "\n",
    "\n",
    "#c_cape,f_cape,fu_cape = get_clear_sky_points(c_cape,f_cape,fu_cape)\n",
    "c_lcl,f_lcl,fu_lcl = get_clear_sky_points(c_lcl,f_lcl,fu_lcl)\n",
    "#c_dp,f_dp,fu_dp = get_clear_sky_points(c_dp,f_dp,fu_dp)\n",
    "#c_slp,f_slp,fu_slp = get_clear_sky_points(c_slp,f_slp,fu_slp)\n",
    "#c_temp,f_temp,fu_temp = get_clear_sky_points(c_temp,f_temp,fu_temp)\n",
    "c_bulk,f_bulk,fu_bulk = get_clear_sky_points(c_bulk,f_bulk,fu_bulk)\n",
    "#c_lr,f_lr,fu_lr = get_clear_sky_points(c_lr,f_lr,fu_lr)\n",
    "#c_srh,f_srh,fu_srh = get_clear_sky_points(c_srh,f_srh,fu_srh)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          date  c_count  f_count  fu_count\n",
      "0   2017-05-03     3512     2806      4082\n",
      "1   2017-05-07       59        1         5\n",
      "2   2017-05-08      308      219       224\n",
      "3   2017-05-10      278      186       441\n",
      "4   2017-05-11      160       59       120\n",
      "5   2017-05-13        8        0         0\n",
      "6   2017-05-14       90       48        92\n",
      "7   2017-05-15      706      567       586\n",
      "8   2017-05-17      899      681       837\n",
      "9   2017-05-19      428      407       421\n",
      "10  2017-05-27     5610     3087      3012\n",
      "11  2017-05-28      991      634       430\n",
      "12  2017-05-29      623      544       793\n",
      "          date  c_count  f_count  fu_count\n",
      "0   2017-04-30      113      196       428\n",
      "1   2017-05-01        0        2         0\n",
      "2   2017-05-04      447      775      1851\n",
      "3   2017-05-05        0       12         4\n",
      "4   2017-05-09      311      697       920\n",
      "5   2017-05-12       12      114        21\n",
      "6   2017-05-16     1325     2824      2602\n",
      "7   2017-05-18      905     1509      1510\n",
      "8   2017-05-20       89      219       425\n",
      "9   2017-05-21     1396     1785      1108\n",
      "10  2017-05-22     2221     4975      4037\n",
      "11  2017-05-23     2497     7738      6662\n",
      "12  2017-05-24        8        9        22\n",
      "13  2017-05-25        5       23         0\n",
      "14  2017-05-26      808     1014       607\n",
      "15  2017-05-30      252      838       626\n",
      "16  2017-05-31       53      116       131\n"
     ]
    }
   ],
   "source": [
    "# convective winds\n",
    "'''\n",
    "c_winds = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Current/convective_winds_month{monlist[0]}.nc').sel(wspd_wdir='wspd')\n",
    "f_winds = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future/convective_winds_month{monlist[0]}.nc').sel(wspd_wdir='wspd')\n",
    "fu_winds = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future_urban/convective_winds_month{monlist[0]}.nc').sel(wspd_wdir='wspd')\n",
    "\n",
    "c_winds['wspd_wdir10'] = c_winds['wspd_wdir10'] >= 17\n",
    "f_winds['wspd_wdir10'] = f_winds['wspd_wdir10'] >= 17\n",
    "fu_winds['wspd_wdir10'] = fu_winds['wspd_wdir10'] >= 17\n",
    "'''\n",
    "\n",
    "# Load in days with damaging wind events\n",
    "severe_wind_days = pd.read_csv(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/damaging_wind_days_csv/damaging_wind_days{monlist[0]}.csv', usecols=['date','c_count','f_count','fu_count'])\n",
    "severe_wind_days = severe_wind_days[~((severe_wind_days[['c_count', 'f_count', 'fu_count']] == 0).all(axis=1))] # filters out days where all 3 are zero\n",
    "\n",
    "# Rows where c_count >= f_count\n",
    "df_c_ge_f = severe_wind_days[severe_wind_days['c_count'] >= severe_wind_days['f_count']].reset_index(drop=True)\n",
    "\n",
    "# Rows where f_count > c_count\n",
    "df_f_gt_c = severe_wind_days[severe_wind_days['f_count'] > severe_wind_days['c_count']].reset_index(drop=True)\n",
    "\n",
    "#print(severe_wind_days)\n",
    "print(df_c_ge_f)\n",
    "print(df_f_gt_c)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'conv_wind_mask' (Time: 248, south_north: 1050,\n",
      "                                    west_east: 1180)> Size: 307MB\n",
      "[307272000 values with dtype=bool]\n",
      "Coordinates:\n",
      "    XLONG    (south_north, west_east) float32 5MB ...\n",
      "    XLAT     (south_north, west_east) float32 5MB ...\n",
      "  * Time     (Time) datetime64[ns] 2kB 2017-05-01 ... 2017-05-31T21:00:00\n",
      "    XTIME    (Time) float32 992B ...\n",
      "Dimensions without coordinates: south_north, west_east\n"
     ]
    }
   ],
   "source": [
    "def load_in_mask(sim, month):\n",
    "    #filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/{sim}/convective_core_mask_withtimes_month{month}.nc'\n",
    "    filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/{sim}/convective_wind_mask_{month}'\n",
    "    #filename = f'/pscratch/sd/d/dbrooks/radar_data/{sim}/composite_ref_month{month}.nc'\n",
    "    ds = xr.open_dataarray(filename)\n",
    "    ds=ds.to_dataset(name='conv_wind_mask')\n",
    "    #ds=ds.to_dataset(name='conv_core_mask')\n",
    "    #print(ds)\n",
    "    #ds = ds['__xarray_dataarray_variable__']\n",
    "    #ds = ds['MSKCLD2'] == 1\n",
    "    #ds = ds['mdbz'] > 5 \n",
    "    return ds\n",
    "\n",
    "c_cw_mask = load_in_mask('current',monlist[0])\n",
    "f_cw_mask = load_in_mask('future',monlist[0])\n",
    "\n",
    "print(c_cw_mask['conv_wind_mask'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shift_dataset_back_one_step(ds: xr.Dataset, variable='conv_wind_mask') -> xr.Dataset:\n",
    "    \"\"\"\n",
    "    Shift the data for a variable backward by one timestep, converting to boolean.\n",
    "\n",
    "    Parameters:\n",
    "        ds (xr.Dataset): The original dataset.\n",
    "        variable (str): The variable name to shift (e.g., \"conv_wind_mask\").\n",
    "\n",
    "    Returns:\n",
    "        xr.Dataset: A new dataset with the variable shifted and cleaned.\n",
    "    \"\"\"\n",
    "    shifted_var = ds[variable].shift(Time=-1).fillna(False).astype(bool)\n",
    "    ds_shifted = ds.copy()\n",
    "    ds_shifted[variable] = shifted_var\n",
    "    return ds_shifted\n",
    "\n",
    "c_cw_mask_offset = shift_dataset_back_one_step(c_cw_mask)\n",
    "f_cw_mask_offset = shift_dataset_back_one_step(f_cw_mask)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_contours(c_cw_mask, c_cw_mask2, timestep=0):\n",
    "    \"\"\"Plots contours around all regions where the value is 1 for a given timestep.\"\"\"\n",
    "    \n",
    "    # Extract a single time step\n",
    "    c_cw_mask = c_cw_mask['conv_wind_mask'].isel(Time=timestep)\n",
    "    c_cw_mask2 = c_cw_mask2['conv_wind_mask'].isel(Time=timestep)\n",
    "    #print(c_cw_mask2)\n",
    "    #print(c_cw_mask)\n",
    "\n",
    "    # Create the figure\n",
    "    fig, ax = plt.subplots(figsize=(10, 6), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "\n",
    "    \n",
    "    # Plot contours where the value is 1\n",
    "    contour = ax.contour(c_cw_mask.XLONG, c_cw_mask.XLAT, c_cw_mask, levels=[0], colors=\"blue\", linewidths=1.5, label='Conv. Core Mask')\n",
    "    contour = ax.contour(c_cw_mask2.XLONG, c_cw_mask2.XLAT, c_cw_mask2, levels=[0], colors=\"red\", linewidths=1.5, label ='Conv. Core Mask Offset')\n",
    "\n",
    "    \n",
    "    # Add labels and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.set_title(f\"Time: {c_cw_mask.Time.values}\")\n",
    "    ax.set_xlabel(\"Longitude\")\n",
    "    ax.set_ylabel(\"Latitude\")\n",
    "    ax.legend(loc='upper right')\n",
    "    #cbar = plt.colorbar(cb, ax=ax, orientation='vertical', fraction=0.05, pad=0.02, shrink=0.9, extend='both')\n",
    "    \n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "# Example usage\n",
    "#plot_contours(c_cw_mask, c_cw_mask_offset, timestep=224)  # Replace `ctt` with your DataArray variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset> Size: 307MB\n",
      "Dimensions:         (south_north: 1050, west_east: 1180, Time: 240)\n",
      "Coordinates:\n",
      "    XLONG           (south_north, west_east) float32 5MB ...\n",
      "    XLAT            (south_north, west_east) float32 5MB ...\n",
      "  * Time            (Time) datetime64[ns] 2kB 2017-06-01 ... 2017-06-30T21:00:00\n",
      "    XTIME           (Time) float32 960B ...\n",
      "Dimensions without coordinates: south_north, west_east\n",
      "Data variables:\n",
      "    conv_wind_mask  (Time, south_north, west_east) bool 297MB False ... False\n"
     ]
    }
   ],
   "source": [
    "print(c_cw_mask_offset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "########### Get data from offset convective wind mask #################\n",
    "def get_points_from_offset_cw_mask(c_ds, f_ds):\n",
    "\n",
    "    c_ds = xr.where(c_cw_mask_offset['conv_wind_mask'], c_ds, float(\"nan\"))\n",
    "    f_ds = xr.where(f_cw_mask_offset['conv_wind_mask'], f_ds, float(\"nan\"))\n",
    "\n",
    "    return c_ds, f_ds\n",
    "\n",
    "\n",
    "#c_cape,f_cape = get_points_from_offset_cw_mask(c_cape,f_cape)\n",
    "#c_bulk,f_bulk = get_points_from_offset_cw_mask(c_bulk,f_bulk)\n",
    "#c_ehi,f_ehi = get_points_from_offset_cw_mask(c_ehi,f_ehi)\n",
    "#c_stp,f_stp = get_points_from_offset_cw_mask(c_stp,f_stp)\n",
    "c_srh,f_srh = get_points_from_offset_cw_mask(c_srh,f_srh)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset> Size: 1GB\n",
      "Dimensions:    (Time: 240, south_north: 1050, west_east: 1180)\n",
      "Coordinates:\n",
      "    XLONG      (south_north, west_east) float32 5MB -109.2 -109.2 ... -82.45\n",
      "    XLAT       (south_north, west_east) float32 5MB 26.63 26.63 ... 45.3 45.29\n",
      "  * Time       (Time) datetime64[ns] 2kB 2017-04-01 ... 2017-04-30T21:00:00\n",
      "    XTIME      (Time) float32 960B 720.0 900.0 1.08e+03 ... 4.356e+04 4.374e+04\n",
      "Dimensions without coordinates: south_north, west_east\n",
      "Data variables:\n",
      "    0_1km_srh  (Time, south_north, west_east) float32 1GB nan nan ... nan nan\n"
     ]
    }
   ],
   "source": [
    "print(c_srh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Function to grab data from fcount and ccount days\n",
    "def extract_12z_windows(current_ds: xr.Dataset, future_ds: xr.Dataset, dates_df: pd.DataFrame, variable: str):\n",
    "    \"\"\"\n",
    "    Extracts 24-hour time windows starting from 12Z for each date in the dates_df,\n",
    "    for both the current and future datasets, and for the specified variable.\n",
    "    \n",
    "    Parameters:\n",
    "        current_ds (xr.Dataset): Current climate dataset.\n",
    "        future_ds (xr.Dataset): Future climate dataset.\n",
    "        dates_df (pd.DataFrame): DataFrame with a 'date' column containing dates of interest.\n",
    "        variable (str): Variable name in the datasets to extract (e.g., \"cape_2d\").\n",
    "        \n",
    "    Returns:\n",
    "        Tuple[xr.Dataset, xr.Dataset]: Filtered current and future datasets with time windows concatenated.\n",
    "    \"\"\"\n",
    "    # Ensure 'date' is in datetime format\n",
    "    dates_df['date'] = pd.to_datetime(dates_df['date'])\n",
    "    \n",
    "    current_chunks = []\n",
    "    future_chunks = []\n",
    "\n",
    "    for date in dates_df['date']:\n",
    "        start_time = pd.Timestamp(date) + pd.Timedelta(hours=12)\n",
    "        end_time = start_time + pd.Timedelta(hours=24)\n",
    "\n",
    "        # Extract the 24-hour window for both datasets\n",
    "        current_slice = current_ds.sel(Time=slice(start_time, end_time))[variable]\n",
    "        future_slice = future_ds.sel(Time=slice(start_time, end_time))[variable]\n",
    "        \n",
    "        # Keep track of these slices\n",
    "        current_chunks.append(current_slice)\n",
    "        future_chunks.append(future_slice)\n",
    "    \n",
    "    # Concatenate along the Time dimension\n",
    "    current_concat = xr.concat(current_chunks, dim='Time').to_dataset(name=variable)\n",
    "    future_concat = xr.concat(future_chunks, dim='Time').to_dataset(name=variable)\n",
    "    \n",
    "    return current_concat, future_concat\n",
    "\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_cape, f_cape, df_c_ge_f, variable='cape_2d') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_cape, f_cape, df_f_gt_c, variable='cape_2d') # Fcount days\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_cape, f_cape, df_c_ge_f, variable='mcin') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_cape, f_cape, df_f_gt_c, variable='mcin') # Fcount days\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_bulk, f_bulk, df_c_ge_f, variable='bulk_shear_0_6km') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_bulk, f_bulk, df_f_gt_c, variable='bulk_shear_0_6km') # Fcount days\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_srh, f_srh, df_c_ge_f, variable='helicity') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_srh, f_srh, df_f_gt_c, variable='helicity') # Fcount days\n",
    "\n",
    "c_ccount_days, f_ccount_days = extract_12z_windows(c_srh, f_srh, df_c_ge_f, variable='0_1km_srh') # Ccount days\n",
    "c_fcount_days, f_fcount_days = extract_12z_windows(c_srh, f_srh, df_f_gt_c, variable='0_1km_srh') # Fcount days\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_ehi, f_ehi, df_c_ge_f, variable='ehi') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_ehi, f_ehi, df_f_gt_c, variable='ehi') # Fcount days\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_stp, f_stp, df_c_ge_f, variable='stp') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_stp, f_stp, df_f_gt_c, variable='stp') # Fcount days\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_cc_mask, f_cc_mask, df_c_ge_f, variable='conv_core_mask') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_cc_mask, f_cc_mask, df_f_gt_c, variable='conv_core_mask') # Fcount days\n",
    "\n",
    "#c_ccount_days, f_ccount_days = extract_12z_windows(c_winds, f_winds, df_c_ge_f, variable='wspd_wdir10') # Ccount days\n",
    "#c_fcount_days, f_fcount_days = extract_12z_windows(c_winds, f_winds, df_f_gt_c, variable='wspd_wdir10') # Fcount days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current Fcount days:  1031.3972\n",
      "future Fcount days:  1269.853\n",
      "current Ccount days:  836.4081\n",
      "future Ccount days:  954.1396\n"
     ]
    }
   ],
   "source": [
    "print('current Fcount days: ', c_fcount_days['cape_2d'].mean(dim=['south_north', 'west_east']).mean().values)\n",
    "print('future Fcount days: ',f_fcount_days['cape_2d'].mean(dim=['south_north', 'west_east']).mean().values)\n",
    "\n",
    "print('current Ccount days: ', c_ccount_days['cape_2d'].mean(dim=['south_north', 'west_east']).mean().values)\n",
    "print('future Ccount days: ',f_ccount_days['cape_2d'].mean(dim=['south_north', 'west_east']).mean().values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_mean_cape_differences(var):\n",
    "    \"\"\"\n",
    "    Plots the mean CAPE for the current simulation,\n",
    "    and the differences in mean CAPE between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    cape_datasets = {\n",
    "        'Current': current_daily_max,\n",
    "        'Future': future_daily_max,\n",
    "        'Future-Urban': future_urban_daily_max\n",
    "    }\n",
    "\n",
    "    if var == 'cape_2d':\n",
    "        title='CAPE'\n",
    "        cape_levels = [0,100,200,300,400,600,800,1000,1200]\n",
    "        #cape_levels = [1000,1500,2000,2500,3000,3500,4000]\n",
    "        #diff_levels = [-2000, -1500, -1000, -500, -250, 250, 500, 1000, 1500, 2000]\n",
    "        diff_levels = [-300, -200, -150, -100, -50, 50, 100, 150, 200, 300]\n",
    "    elif var == 'mcin':\n",
    "        title='CIN'\n",
    "        cape_levels = [0,25,50,75,100,125,150,200,250]\n",
    "        diff_levels = [-100, -75, -50, -25, -10, 10, 25, 50, 75, 100]\n",
    "\n",
    "    # Colormap for CAPE\n",
    "    cape_cmap1 = matplotlib.colormaps['plasma']\n",
    "\n",
    "    #cape_levels=np.arange(0,1201,100)  # Adjust as needed\n",
    "    #cape_levels = [0,100,200,300,400,600,800,1000,1200]\n",
    "    #cape_levels = [0,25,50,75,100,125,150,200,250]\n",
    "    cape_cmap = mcolors.ListedColormap(cape_cmap1(np.linspace(0.1,0.8,len(cape_levels))))\n",
    "    cape_norm = mcolors.BoundaryNorm(cape_levels, len(cape_levels))\n",
    "    cape_cmap.set_over(cape_cmap1(np.linspace(0.99,1,1)))\n",
    "    cape_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    #diff_levels = [-300, -200, -150, -100, -50, 50, 100, 150, 200, 300]\n",
    "    #diff_levels = [-100, -75, -50, -25, -10, 10, 25, 50, 75, 100]\n",
    "    import colormaps \n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    diff_cmap = diff_cmap1[1:10]\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(diff_levels) - 1)) for i in range(len(diff_levels))]\n",
    "\n",
    "    diff_cmap.set_over(colors[-1])   # Upper bound color\n",
    "    diff_cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    diff_norm = mcolors.BoundaryNorm(diff_levels, diff_cmap.N)\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 2, figsize=(10, 4), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on monlist\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Mean CAPE for Current Simulation #####\n",
    "    mean_cape_current = cape_datasets['Current'][var].mean(dim='Time')\n",
    "    lats = cape_datasets['Current']['XLAT']\n",
    "    lons = cape_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_current, cmap=cape_cmap, norm=cape_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(f'Mean {title} (J/kg)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    current_spatial_mean = mean_cape_current.mean(dim=['south_north','west_east'])\n",
    "    current_spatial_max = mean_cape_current.max(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "                f\"Mean: {current_spatial_mean:.2f} J/kg\\nMax: {current_spatial_max:.0f} J/kg\"\n",
    "            )\n",
    "    ax.text(\n",
    "        -111.8, 43.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=9, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = cape_datasets['Future'][var].mean(dim='Time')\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_current, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(fr'$\\Delta${title} (J/kg)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_current.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_current.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_current.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f} J/kg\\n\"\n",
    "    f\"Min: {min_diff:.0f} J/kg\\n\"\n",
    "    f\"Max: {max_diff:.0f} J/kg\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -111.8, 42.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=9, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    '''\n",
    "    mean_cape_future_urban = cape_datasets['Future-Urban'][var].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_future = mean_cape_future_urban - mean_cape_future\n",
    "    \n",
    "    ax = axs[2]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_urban_future, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(fr'$\\Delta${title} (J/kg)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_urban_future.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_urban_future.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_urban_future.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f} J/kg\\n\"\n",
    "    f\"Min: {min_diff:.0f} J/kg\\n\"\n",
    "    f\"Max: {max_diff:.0f} J/kg\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -112.0, 42.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    '''\n",
    "    # Set the overall title\n",
    "    fig.suptitle(f'Mean Daily {title} for Days Where C_count > F_count\\n({month}, n_Days={len(current_daily_max.Time)})', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0.01, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "def plot_mean_shear_differences(var='bulk_shear_0_6km'):\n",
    "    \"\"\"\n",
    "    Plots the mean CAPE for the current simulation,\n",
    "    and the differences in mean CAPE between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    cape_datasets = {\n",
    "        'Current': current_daily_max,\n",
    "        'Future': future_daily_max,\n",
    "        'Future-Urban': future_urban_daily_max\n",
    "    }\n",
    "\n",
    "    if var == 'bulk_shear_0_6km':\n",
    "        title='S06'\n",
    "    elif var == 'mcin':\n",
    "        title='CIN'\n",
    "\n",
    "    # Colormap for CAPE\n",
    "    cape_cmap1 = matplotlib.colormaps['plasma']\n",
    "\n",
    "    cape_levels=np.arange(9,25,3)  # Adjust as needed\n",
    "    #cape_levels = [0,100,200,300,400,600,800,1000,1200]\n",
    "    #cape_levels = [0,25,50,75,100,125,150,200,250]\n",
    "    cape_cmap = mcolors.ListedColormap(cape_cmap1(np.linspace(0.1,0.8,len(cape_levels))))\n",
    "    cape_norm = mcolors.BoundaryNorm(cape_levels, len(cape_levels))\n",
    "    cape_cmap.set_over(cape_cmap1(np.linspace(0.99,1,1)))\n",
    "    cape_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    #diff_levels = [-300, -200, -150, -100, -50, 50, 100, 150, 200, 300]\n",
    "    diff_levels = [-4, -3, -2, -1,-0.5, 0.5, 1, 2, 3, 4]\n",
    "    import colormaps \n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    diff_cmap = diff_cmap1[1:10]\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(diff_levels) - 1)) for i in range(len(diff_levels))]\n",
    "\n",
    "    diff_cmap.set_over(colors[-1])   # Upper bound color\n",
    "    diff_cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    diff_norm = mcolors.BoundaryNorm(diff_levels, diff_cmap.N)\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 2, figsize=(10, 4), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on monlist\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Mean CAPE for Current Simulation #####\n",
    "    mean_cape_current = cape_datasets['Current'][var].mean(dim='Time')\n",
    "    lats = cape_datasets['Current']['XLAT']\n",
    "    lons = cape_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_current, cmap=cape_cmap, norm=cape_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(f'Mean {title} (m s$^{{-1}}$)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    current_spatial_mean = mean_cape_current.mean(dim=['south_north','west_east'])\n",
    "    current_spatial_max = mean_cape_current.max(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "                f\"Mean: {current_spatial_mean:.2f}\\nMax: {current_spatial_max:.0f}\"\n",
    "            )\n",
    "    ax.text(\n",
    "        -112.0, 43.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = cape_datasets['Future'][var].mean(dim='Time')\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_current, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(fr'$\\Delta${title} (m s$^{{-1}}$)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_current.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_current.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_current.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f}\\n\"\n",
    "    f\"Min: {min_diff:.0f}\\n\"\n",
    "    f\"Max: {max_diff:.0f}\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -112.0, 42.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    '''\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    mean_cape_future_urban = cape_datasets['Future-Urban'][var].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_future = mean_cape_future_urban - mean_cape_future\n",
    "    \n",
    "    ax = axs[2]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_urban_future, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(fr'$\\Delta${title} (m/s)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_urban_future.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_urban_future.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_urban_future.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f} m/s\\n\"\n",
    "    f\"Min: {min_diff:.0f} m/s\\n\"\n",
    "    f\"Max: {max_diff:.0f} m/s\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -112.0, 42.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    '''\n",
    "    # Set the overall title\n",
    "    #fig.suptitle(f'Mean {title} and Differences Between Simulations in {month} (Clear Sky points)', fontsize=14)\n",
    "    fig.suptitle(f'Mean Daily {title} for Days Where F_count > C_count\\n({month}, n_Days={len(current_daily_max.Time)})', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_mean_cape_differences(var='cape_2d')\n",
    "#plot_mean_cape_differences(var='mcin')\n",
    "plot_mean_shear_differences()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "############## Temperature Differences ##################\n",
    "def plot_mean_temp_differences(var):\n",
    "    \"\"\"\n",
    "    Plots the mean temp for the current simulation,\n",
    "    and the differences in mean temp between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    temp_datasets = {\n",
    "        'Current': current_daily_max,\n",
    "        'Future': future_daily_max,\n",
    "        'Future-Urban': future_urban_daily_max\n",
    "    }\n",
    "\n",
    "    if var == 'T2':\n",
    "        title='2m T'\n",
    "        cape_levels = [10,12,14,16,18,20,22,24,26]\n",
    "        #cape_levels = [1000,1500,2000,2500,3000,3500,4000]\n",
    "        #diff_levels = [-2000, -1500, -1000, -500, -250, 250, 500, 1000, 1500, 2000]\n",
    "        diff_levels = [-3.00, -2.00, -1.50, -1.00, -0.5, 0.5, 1, 1.50, 2.00, 3.00]\n",
    "    elif var == 'Td':\n",
    "        title='2m Td'\n",
    "        cape_levels = [0,25,50,75,100,125,150,200,250]\n",
    "        diff_levels = [-100, -75, -50, -25, -10, 10, 25, 50, 75, 100]\n",
    "\n",
    "    # Colormap for CAPE\n",
    "    cape_cmap1 = matplotlib.colormaps['plasma']\n",
    "\n",
    "    #cape_levels=np.arange(0,1201,100)  # Adjust as needed\n",
    "    #cape_levels = [0,100,200,300,400,600,800,1000,1200]\n",
    "    #cape_levels = [0,25,50,75,100,125,150,200,250]\n",
    "    cape_cmap = mcolors.ListedColormap(cape_cmap1(np.linspace(0.1,0.8,len(cape_levels))))\n",
    "    cape_norm = mcolors.BoundaryNorm(cape_levels, len(cape_levels))\n",
    "    cape_cmap.set_over(cape_cmap1(np.linspace(0.99,1,1)))\n",
    "    cape_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    #diff_levels = [-300, -200, -150, -100, -50, 50, 100, 150, 200, 300]\n",
    "    #diff_levels = [-100, -75, -50, -25, -10, 10, 25, 50, 75, 100]\n",
    "    import colormaps \n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    diff_cmap = diff_cmap1[1:10]\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(diff_levels) - 1)) for i in range(len(diff_levels))]\n",
    "\n",
    "    diff_cmap.set_over(colors[-1])   # Upper bound color\n",
    "    diff_cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    diff_norm = mcolors.BoundaryNorm(diff_levels, diff_cmap.N)\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 2, figsize=(10, 4), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on monlist\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Mean CAPE for Current Simulation #####\n",
    "    mean_cape_current = temp_datasets['Current'][var].mean(dim='Time') - 273.15 # K to C\n",
    "    lats = temp_datasets['Current']['XLAT']\n",
    "    lons = temp_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_current, cmap=cape_cmap, norm=cape_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(f'Mean {title} (°C)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    current_spatial_mean = mean_cape_current.mean(dim=['south_north','west_east'])\n",
    "    current_spatial_max = mean_cape_current.max(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "                f\"Mean: {current_spatial_mean:.2f} °C\\nMax: {current_spatial_max:.2f} °C\"\n",
    "            )\n",
    "    ax.text(\n",
    "        -111.8, 43.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=9, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = temp_datasets['Future'][var].mean(dim='Time') - 273.15\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_current, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(fr'$\\Delta${title} (°C)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_current.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_current.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_current.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f} °C\\n\"\n",
    "    f\"Min: {min_diff:.2f} °C\\n\"\n",
    "    f\"Max: {max_diff:.2f} °C\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -111.8, 42.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=9, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    '''\n",
    "    mean_cape_future_urban = cape_datasets['Future-Urban'][var].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_future = mean_cape_future_urban - mean_cape_future\n",
    "    \n",
    "    ax = axs[2]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_urban_future, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(fr'$\\Delta${title} (J/kg)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_urban_future.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_urban_future.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_urban_future.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f} J/kg\\n\"\n",
    "    f\"Min: {min_diff:.0f} J/kg\\n\"\n",
    "    f\"Max: {max_diff:.0f} J/kg\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -112.0, 42.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    '''\n",
    "    # Set the overall title\n",
    "    fig.suptitle(f'Mean Daily {title} for Days Where C_count > F_count\\n({month}, n_Days={len(current_daily_max.Time)})', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0.01, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_mean_temp_differences(var='T2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "################ SRH Plots ##################\n",
    "def plot_mean_srh_differences():\n",
    "    \"\"\"\n",
    "    Plots the mean SRH for the current simulation,\n",
    "    and the differences in mean SRH between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    cape_datasets = {\n",
    "        'Current': c_srh['helicity'].where(c_srh['helicity'] > 0),\n",
    "        'Future': f_srh['helicity'].where(f_srh['helicity'] > 0),\n",
    "        'Future-Urban': fu_srh['helicity'].where(fu_srh['helicity'] > 0)\n",
    "    }\n",
    "\n",
    "    # Colormap for CAPE\n",
    "    cape_cmap1 = matplotlib.colormaps['plasma']\n",
    "\n",
    "    cape_levels=np.arange(0,301,50)  # Adjust as needed\n",
    "    #cape_levels = [1,1.25,1.5,1.75,2,2.25,2.5,2.75,3]\n",
    "    cape_cmap = mcolors.ListedColormap(cape_cmap1(np.linspace(0.1,0.8,len(cape_levels))))\n",
    "    cape_norm = mcolors.BoundaryNorm(cape_levels, len(cape_levels))\n",
    "    cape_cmap.set_over(cape_cmap1(np.linspace(0.99,1,1)))\n",
    "    cape_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    diff_levels = [-30, -20, -15, -10, -5, 5, 10, 15, 20, 30]\n",
    "    import colormaps \n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    diff_cmap = diff_cmap1[1:10]\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(diff_levels) - 1)) for i in range(len(diff_levels))]\n",
    "\n",
    "    diff_cmap.set_over(colors[-1])   # Upper bound color\n",
    "    diff_cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    diff_norm = mcolors.BoundaryNorm(diff_levels, diff_cmap.N)\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(12, 3), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on monlist\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Mean CAPE for Current Simulation #####\n",
    "    mean_cape_current = cape_datasets['Current'].mean(dim='Time')\n",
    "    lats = cape_datasets['Current']['XLAT']\n",
    "    lons = cape_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_current, cmap=cape_cmap, norm=cape_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title('Mean SRH (m$^{2}$ s$^{-2}$)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('$m^{2}$ $s^{-2}$')\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = cape_datasets['Future'].mean(dim='Time')\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_current, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(r'$\\Delta$SRH (m$^{2}$ s$^{-2}$)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('m$^{2}$ s$^{-2}$')\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    mean_cape_future_urban = cape_datasets['Future-Urban'].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_future = mean_cape_future_urban - mean_cape_future\n",
    "    \n",
    "    ax = axs[2]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_urban_future, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(r'$\\Delta$SRH (m$^{2}$ s$^{-2}$)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('m$^{2}$ s$^{-2}$')\n",
    "\n",
    "    # Set the overall title\n",
    "    fig.suptitle(f'Mean 0-3km SRH and Differences Between Simulations in {month} (Clear Sky Points)', fontsize=12)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_mean_srh_differences()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "############## Energy Helicity Index #################\n",
    "def get_ehi(cape_ds, srh_ds):\n",
    "    ehi = (cape_ds['cape_2d'] * srh_ds['helicity']) / 160000\n",
    "    \n",
    "    ehi = ehi.where(ehi > 0)\n",
    "\n",
    "    ehi = ehi.to_dataset(name='ehi')\n",
    "\n",
    "    return ehi\n",
    "\n",
    "c_ehi = get_ehi(c_cape, c_srh)\n",
    "f_ehi = get_ehi(f_cape, f_srh)\n",
    "fu_ehi = get_ehi(fu_cape, fu_srh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mean_ehi_differences():\n",
    "    \"\"\"\n",
    "    Plots the mean EHI for the current simulation,\n",
    "    and the differences in mean EHI between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    cape_datasets = {\n",
    "        'Current': c_ehi,\n",
    "        'Future': f_ehi,\n",
    "        'Future-Urban': fu_ehi\n",
    "    }\n",
    "\n",
    "    # Colormap for CAPE\n",
    "    cape_cmap1 = matplotlib.colormaps['plasma']\n",
    "\n",
    "    #cape_levels=np.arange(0,1201,100)  # Adjust as needed\n",
    "    cape_levels = [1,1.25,1.5,1.75,2,2.25,2.5,2.75,3]\n",
    "    cape_cmap = mcolors.ListedColormap(cape_cmap1(np.linspace(0.1,0.8,len(cape_levels))))\n",
    "    cape_norm = mcolors.BoundaryNorm(cape_levels, len(cape_levels))\n",
    "    cape_cmap.set_over(cape_cmap1(np.linspace(0.99,1,1)))\n",
    "    cape_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    diff_levels = [-1.25, -1, -0.75, -0.5, -0.25, 0.25, 0.5, 0.75, 1, 1.25]\n",
    "    # Create a ListedColormap from the custom RGBA values\n",
    "    diff_cmap = create_custom_diverging_colormap(levels=len(diff_levels))\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    diff_norm = mcolors.BoundaryNorm(diff_levels, len(diff_levels))\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(17, 4), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on monlist\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Mean CAPE for Current Simulation #####\n",
    "    mean_cape_current = cape_datasets['Current'].mean(dim='Time')\n",
    "    lats = cape_datasets['Current']['XLAT']\n",
    "    lons = cape_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_current, cmap=cape_cmap, norm=cape_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(f'Mean EHI', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('EHI')\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = cape_datasets['Future'].mean(dim='Time')\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_current, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(r'$\\Delta$Mean EHI', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('EHI Difference')\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    mean_cape_future_urban = cape_datasets['Future-Urban'].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_future = mean_cape_future_urban - mean_cape_future\n",
    "    \n",
    "    ax = axs[2]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_urban_future, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(r'$\\Delta$Mean EHI (J/kg)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('EHI Difference')\n",
    "\n",
    "    # Set the overall title\n",
    "    fig.suptitle(f'Mean EHI and Differences Between Simulations in {month} (Clear Sky Points)', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_mean_ehi_differences()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "################## Specific Humidity #####################\n",
    "\n",
    "# Function to calculate actual vapor pressure\n",
    "def get_vap_pressure(Td):\n",
    "    \"\"\"\n",
    "    Calculates actual vapor pressure (e) from dew point temperature (Td in Kelvin).\n",
    "    \"\"\"\n",
    "    Td = Td + 273.16 # C to K\n",
    "\n",
    "    a1 = 6.1121  # hPa\n",
    "    a3 = 17.502\n",
    "    a4 = 32.19   # K\n",
    "    To = 273.16  # K\n",
    "    t = ((Td - To) / (Td - a4)) * a3\n",
    "    e  = a1 * np.exp(t)\n",
    "\n",
    "    return e\n",
    "\n",
    "def get_specific_humidity(ds_dew_point, ds_pressure):\n",
    "    \"\"\"\n",
    "    Calculates specific humidity (q)\n",
    "    \n",
    "    Inputs:\n",
    "    - ds_dew_point: xarray.DataArray for dew point (Kelvin).\n",
    "    - ds_pressure: xarray.DataArray for pressure (hPa).\n",
    "\n",
    "    Outputs:\n",
    "    - q as an xarray.DataArray (g/kg).\n",
    "    \"\"\"\n",
    "    E = 0.622  # kg/kg, ratio of gas constants for dry air and water vapor\n",
    "\n",
    "    # Calculate vapor pressure\n",
    "    e = get_vap_pressure(ds_dew_point)\n",
    "\n",
    "    # Calculate q\n",
    "    q = (E * e) / (ds_pressure - ((1 - E) * e))\n",
    "    return q\n",
    "\n",
    "c_q = get_specific_humidity(c_dp['td2'], c_slp['slp']) * 1000 # the *1000 turns it to g/kg\n",
    "f_q = get_specific_humidity(f_dp['td2'], f_slp['slp']) * 1000\n",
    "fu_q = get_specific_humidity(fu_dp['td2'], fu_slp['slp']) * 1000\n",
    "\n",
    "c_q = c_q.to_dataset(name='q')\n",
    "f_q = f_q.to_dataset(name='q')\n",
    "fu_q = fu_q.to_dataset(name='q')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "monlist = ['06']\n",
    "# 850mb Specific Humidity\n",
    "# It says its in g/kg but its actually in kg/kg\n",
    "c_q = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/current/specific_humidity_850mb_month{monlist[0]}.nc')\n",
    "f_q = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future/specific_humidity_850mb_month{monlist[0]}.nc')\n",
    "fu_q = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future_urban/specific_humidity_850mb_month{monlist[0]}.nc')\n",
    "\n",
    "# 850mb Relative Humidity\n",
    "c_q = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/current/relative_humidity_850mb_month{monlist[0]}.nc')\n",
    "f_q = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future/relative_humidity_850mb_month{monlist[0]}.nc')\n",
    "fu_q = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/humidity_data/future_urban/relative_humidity_850mb_month{monlist[0]}.nc')\n",
    "\n",
    "# 850mb Temperature\n",
    "c_temp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/temp_data/current/temperature_850mb_month{monlist[0]}.nc')\n",
    "f_temp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/temp_data/future/temperature_850mb_month{monlist[0]}.nc')\n",
    "fu_temp = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/temp_data/future_urban/temperature_850mb_month04.nc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n",
       "<defs>\n",
       "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n",
       "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n",
       "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
       "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
       "</symbol>\n",
       "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n",
       "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n",
       "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
       "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
       "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
       "</symbol>\n",
       "</defs>\n",
       "</svg>\n",
       "<style>/* CSS stylesheet for displaying xarray objects in notebooks */\n",
       "\n",
       ":root {\n",
       "  --xr-font-color0: var(\n",
       "    --jp-content-font-color0,\n",
       "    var(--pst-color-text-base rgba(0, 0, 0, 1))\n",
       "  );\n",
       "  --xr-font-color2: var(\n",
       "    --jp-content-font-color2,\n",
       "    var(--pst-color-text-base, rgba(0, 0, 0, 0.54))\n",
       "  );\n",
       "  --xr-font-color3: var(\n",
       "    --jp-content-font-color3,\n",
       "    var(--pst-color-text-base, rgba(0, 0, 0, 0.38))\n",
       "  );\n",
       "  --xr-border-color: var(\n",
       "    --jp-border-color2,\n",
       "    hsl(from var(--pst-color-on-background, white) h s calc(l - 10))\n",
       "  );\n",
       "  --xr-disabled-color: var(\n",
       "    --jp-layout-color3,\n",
       "    hsl(from var(--pst-color-on-background, white) h s calc(l - 40))\n",
       "  );\n",
       "  --xr-background-color: var(\n",
       "    --jp-layout-color0,\n",
       "    var(--pst-color-on-background, white)\n",
       "  );\n",
       "  --xr-background-color-row-even: var(\n",
       "    --jp-layout-color1,\n",
       "    hsl(from var(--pst-color-on-background, white) h s calc(l - 5))\n",
       "  );\n",
       "  --xr-background-color-row-odd: var(\n",
       "    --jp-layout-color2,\n",
       "    hsl(from var(--pst-color-on-background, white) h s calc(l - 15))\n",
       "  );\n",
       "}\n",
       "\n",
       "html[theme=\"dark\"],\n",
       "html[data-theme=\"dark\"],\n",
       "body[data-theme=\"dark\"],\n",
       "body.vscode-dark {\n",
       "  --xr-font-color0: var(\n",
       "    --jp-content-font-color0,\n",
       "    var(--pst-color-text-base, rgba(255, 255, 255, 1))\n",
       "  );\n",
       "  --xr-font-color2: var(\n",
       "    --jp-content-font-color2,\n",
       "    var(--pst-color-text-base, rgba(255, 255, 255, 0.54))\n",
       "  );\n",
       "  --xr-font-color3: var(\n",
       "    --jp-content-font-color3,\n",
       "    var(--pst-color-text-base, rgba(255, 255, 255, 0.38))\n",
       "  );\n",
       "  --xr-border-color: var(\n",
       "    --jp-border-color2,\n",
       "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 10))\n",
       "  );\n",
       "  --xr-disabled-color: var(\n",
       "    --jp-layout-color3,\n",
       "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 40))\n",
       "  );\n",
       "  --xr-background-color: var(\n",
       "    --jp-layout-color0,\n",
       "    var(--pst-color-on-background, #111111)\n",
       "  );\n",
       "  --xr-background-color-row-even: var(\n",
       "    --jp-layout-color1,\n",
       "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 5))\n",
       "  );\n",
       "  --xr-background-color-row-odd: var(\n",
       "    --jp-layout-color2,\n",
       "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 15))\n",
       "  );\n",
       "}\n",
       "\n",
       ".xr-wrap {\n",
       "  display: block !important;\n",
       "  min-width: 300px;\n",
       "  max-width: 700px;\n",
       "  line-height: 1.6;\n",
       "}\n",
       "\n",
       ".xr-text-repr-fallback {\n",
       "  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n",
       "  display: none;\n",
       "}\n",
       "\n",
       ".xr-header {\n",
       "  padding-top: 6px;\n",
       "  padding-bottom: 6px;\n",
       "  margin-bottom: 4px;\n",
       "  border-bottom: solid 1px var(--xr-border-color);\n",
       "}\n",
       "\n",
       ".xr-header > div,\n",
       ".xr-header > ul {\n",
       "  display: inline;\n",
       "  margin-top: 0;\n",
       "  margin-bottom: 0;\n",
       "}\n",
       "\n",
       ".xr-obj-type,\n",
       ".xr-obj-name,\n",
       ".xr-group-name {\n",
       "  margin-left: 2px;\n",
       "  margin-right: 10px;\n",
       "}\n",
       "\n",
       ".xr-group-name::before {\n",
       "  content: \"📁\";\n",
       "  padding-right: 0.3em;\n",
       "}\n",
       "\n",
       ".xr-group-name,\n",
       ".xr-obj-type {\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-sections {\n",
       "  padding-left: 0 !important;\n",
       "  display: grid;\n",
       "  grid-template-columns: 150px auto auto 1fr 0 20px 0 20px;\n",
       "  margin-block-start: 0;\n",
       "  margin-block-end: 0;\n",
       "}\n",
       "\n",
       ".xr-section-item {\n",
       "  display: contents;\n",
       "}\n",
       "\n",
       ".xr-section-item input {\n",
       "  display: inline-block;\n",
       "  opacity: 0;\n",
       "  height: 0;\n",
       "  margin: 0;\n",
       "}\n",
       "\n",
       ".xr-section-item input + label {\n",
       "  color: var(--xr-disabled-color);\n",
       "  border: 2px solid transparent !important;\n",
       "}\n",
       "\n",
       ".xr-section-item input:enabled + label {\n",
       "  cursor: pointer;\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-section-item input:focus + label {\n",
       "  border: 2px solid var(--xr-font-color0) !important;\n",
       "}\n",
       "\n",
       ".xr-section-item input:enabled + label:hover {\n",
       "  color: var(--xr-font-color0);\n",
       "}\n",
       "\n",
       ".xr-section-summary {\n",
       "  grid-column: 1;\n",
       "  color: var(--xr-font-color2);\n",
       "  font-weight: 500;\n",
       "}\n",
       "\n",
       ".xr-section-summary > span {\n",
       "  display: inline-block;\n",
       "  padding-left: 0.5em;\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:disabled + label {\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-section-summary-in + label:before {\n",
       "  display: inline-block;\n",
       "  content: \"►\";\n",
       "  font-size: 11px;\n",
       "  width: 15px;\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:disabled + label:before {\n",
       "  color: var(--xr-disabled-color);\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:checked + label:before {\n",
       "  content: \"▼\";\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:checked + label > span {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       ".xr-section-summary,\n",
       ".xr-section-inline-details {\n",
       "  padding-top: 4px;\n",
       "}\n",
       "\n",
       ".xr-section-inline-details {\n",
       "  grid-column: 2 / -1;\n",
       "}\n",
       "\n",
       ".xr-section-details {\n",
       "  display: none;\n",
       "  grid-column: 1 / -1;\n",
       "  margin-top: 4px;\n",
       "  margin-bottom: 5px;\n",
       "}\n",
       "\n",
       ".xr-section-summary-in:checked ~ .xr-section-details {\n",
       "  display: contents;\n",
       "}\n",
       "\n",
       ".xr-group-box {\n",
       "  display: inline-grid;\n",
       "  grid-template-columns: 0px 20px auto;\n",
       "  width: 100%;\n",
       "}\n",
       "\n",
       ".xr-group-box-vline {\n",
       "  grid-column-start: 1;\n",
       "  border-right: 0.2em solid;\n",
       "  border-color: var(--xr-border-color);\n",
       "  width: 0px;\n",
       "}\n",
       "\n",
       ".xr-group-box-hline {\n",
       "  grid-column-start: 2;\n",
       "  grid-row-start: 1;\n",
       "  height: 1em;\n",
       "  width: 20px;\n",
       "  border-bottom: 0.2em solid;\n",
       "  border-color: var(--xr-border-color);\n",
       "}\n",
       "\n",
       ".xr-group-box-contents {\n",
       "  grid-column-start: 3;\n",
       "}\n",
       "\n",
       ".xr-array-wrap {\n",
       "  grid-column: 1 / -1;\n",
       "  display: grid;\n",
       "  grid-template-columns: 20px auto;\n",
       "}\n",
       "\n",
       ".xr-array-wrap > label {\n",
       "  grid-column: 1;\n",
       "  vertical-align: top;\n",
       "}\n",
       "\n",
       ".xr-preview {\n",
       "  color: var(--xr-font-color3);\n",
       "}\n",
       "\n",
       ".xr-array-preview,\n",
       ".xr-array-data {\n",
       "  padding: 0 5px !important;\n",
       "  grid-column: 2;\n",
       "}\n",
       "\n",
       ".xr-array-data,\n",
       ".xr-array-in:checked ~ .xr-array-preview {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       ".xr-array-in:checked ~ .xr-array-data,\n",
       ".xr-array-preview {\n",
       "  display: inline-block;\n",
       "}\n",
       "\n",
       ".xr-dim-list {\n",
       "  display: inline-block !important;\n",
       "  list-style: none;\n",
       "  padding: 0 !important;\n",
       "  margin: 0;\n",
       "}\n",
       "\n",
       ".xr-dim-list li {\n",
       "  display: inline-block;\n",
       "  padding: 0;\n",
       "  margin: 0;\n",
       "}\n",
       "\n",
       ".xr-dim-list:before {\n",
       "  content: \"(\";\n",
       "}\n",
       "\n",
       ".xr-dim-list:after {\n",
       "  content: \")\";\n",
       "}\n",
       "\n",
       ".xr-dim-list li:not(:last-child):after {\n",
       "  content: \",\";\n",
       "  padding-right: 5px;\n",
       "}\n",
       "\n",
       ".xr-has-index {\n",
       "  font-weight: bold;\n",
       "}\n",
       "\n",
       ".xr-var-list,\n",
       ".xr-var-item {\n",
       "  display: contents;\n",
       "}\n",
       "\n",
       ".xr-var-item > div,\n",
       ".xr-var-item label,\n",
       ".xr-var-item > .xr-var-name span {\n",
       "  background-color: var(--xr-background-color-row-even);\n",
       "  border-color: var(--xr-background-color-row-odd);\n",
       "  margin-bottom: 0;\n",
       "  padding-top: 2px;\n",
       "}\n",
       "\n",
       ".xr-var-item > .xr-var-name:hover span {\n",
       "  padding-right: 5px;\n",
       "}\n",
       "\n",
       ".xr-var-list > li:nth-child(odd) > div,\n",
       ".xr-var-list > li:nth-child(odd) > label,\n",
       ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n",
       "  background-color: var(--xr-background-color-row-odd);\n",
       "  border-color: var(--xr-background-color-row-even);\n",
       "}\n",
       "\n",
       ".xr-var-name {\n",
       "  grid-column: 1;\n",
       "}\n",
       "\n",
       ".xr-var-dims {\n",
       "  grid-column: 2;\n",
       "}\n",
       "\n",
       ".xr-var-dtype {\n",
       "  grid-column: 3;\n",
       "  text-align: right;\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-var-preview {\n",
       "  grid-column: 4;\n",
       "}\n",
       "\n",
       ".xr-index-preview {\n",
       "  grid-column: 2 / 5;\n",
       "  color: var(--xr-font-color2);\n",
       "}\n",
       "\n",
       ".xr-var-name,\n",
       ".xr-var-dims,\n",
       ".xr-var-dtype,\n",
       ".xr-preview,\n",
       ".xr-attrs dt {\n",
       "  white-space: nowrap;\n",
       "  overflow: hidden;\n",
       "  text-overflow: ellipsis;\n",
       "  padding-right: 10px;\n",
       "}\n",
       "\n",
       ".xr-var-name:hover,\n",
       ".xr-var-dims:hover,\n",
       ".xr-var-dtype:hover,\n",
       ".xr-attrs dt:hover {\n",
       "  overflow: visible;\n",
       "  width: auto;\n",
       "  z-index: 1;\n",
       "}\n",
       "\n",
       ".xr-var-attrs,\n",
       ".xr-var-data,\n",
       ".xr-index-data {\n",
       "  display: none;\n",
       "  border-top: 2px dotted var(--xr-background-color);\n",
       "  padding-bottom: 20px !important;\n",
       "  padding-top: 10px !important;\n",
       "}\n",
       "\n",
       ".xr-var-attrs-in + label,\n",
       ".xr-var-data-in + label,\n",
       ".xr-index-data-in + label {\n",
       "  padding: 0 1px;\n",
       "}\n",
       "\n",
       ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",
       ".xr-var-data-in:checked ~ .xr-var-data,\n",
       ".xr-index-data-in:checked ~ .xr-index-data {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       ".xr-var-data > table {\n",
       "  float: right;\n",
       "}\n",
       "\n",
       ".xr-var-data > pre,\n",
       ".xr-index-data > pre,\n",
       ".xr-var-data > table > tbody > tr {\n",
       "  background-color: transparent !important;\n",
       "}\n",
       "\n",
       ".xr-var-name span,\n",
       ".xr-var-data,\n",
       ".xr-index-name div,\n",
       ".xr-index-data,\n",
       ".xr-attrs {\n",
       "  padding-left: 25px !important;\n",
       "}\n",
       "\n",
       ".xr-attrs,\n",
       ".xr-var-attrs,\n",
       ".xr-var-data,\n",
       ".xr-index-data {\n",
       "  grid-column: 1 / -1;\n",
       "}\n",
       "\n",
       "dl.xr-attrs {\n",
       "  padding: 0;\n",
       "  margin: 0;\n",
       "  display: grid;\n",
       "  grid-template-columns: 125px auto;\n",
       "}\n",
       "\n",
       ".xr-attrs dt,\n",
       ".xr-attrs dd {\n",
       "  padding: 0;\n",
       "  margin: 0;\n",
       "  float: left;\n",
       "  padding-right: 10px;\n",
       "  width: auto;\n",
       "}\n",
       "\n",
       ".xr-attrs dt {\n",
       "  font-weight: normal;\n",
       "  grid-column: 1;\n",
       "}\n",
       "\n",
       ".xr-attrs dt:hover span {\n",
       "  display: inline-block;\n",
       "  background: var(--xr-background-color);\n",
       "  padding-right: 10px;\n",
       "}\n",
       "\n",
       ".xr-attrs dd {\n",
       "  grid-column: 2;\n",
       "  white-space: pre-wrap;\n",
       "  word-break: break-all;\n",
       "}\n",
       "\n",
       ".xr-icon-database,\n",
       ".xr-icon-file-text2,\n",
       ".xr-no-icon {\n",
       "  display: inline-block;\n",
       "  vertical-align: middle;\n",
       "  width: 1em;\n",
       "  height: 1.5em !important;\n",
       "  stroke-width: 0;\n",
       "  stroke: currentColor;\n",
       "  fill: currentColor;\n",
       "}\n",
       "\n",
       ".xr-var-attrs-in:checked + label > .xr-icon-file-text2,\n",
       ".xr-var-data-in:checked + label > .xr-icon-database,\n",
       ".xr-index-data-in:checked + label > .xr-icon-database {\n",
       "  color: var(--xr-font-color0);\n",
       "  filter: drop-shadow(1px 1px 5px var(--xr-font-color2));\n",
       "  stroke-width: 0.8px;\n",
       "}\n",
       "</style><pre class='xr-text-repr-fallback'>&lt;xarray.Dataset&gt; Size: 3GB\n",
       "Dimensions:   (Time: 240, south_north: 1080, west_east: 1210)\n",
       "Coordinates:\n",
       "  * Time      (Time) datetime64[ns] 2kB 2017-06-01 ... 2017-06-30T21:00:00\n",
       "    XLONG     (south_north, west_east) float32 5MB ...\n",
       "    XLAT      (south_north, west_east) float32 5MB ...\n",
       "    XTIME     (Time) float32 960B ...\n",
       "    level     float64 8B ...\n",
       "Dimensions without coordinates: south_north, west_east\n",
       "Data variables:\n",
       "    temp_850  (Time, south_north, west_east) float64 3GB ...</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-db4f4f27-bcd2-49d0-86b1-af891620a0e4' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-db4f4f27-bcd2-49d0-86b1-af891620a0e4' class='xr-section-summary'  title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>Time</span>: 240</li><li><span>south_north</span>: 1080</li><li><span>west_east</span>: 1210</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-59bb74f6-9877-4316-8683-6c95db37ff9e' class='xr-section-summary-in' type='checkbox'  checked><label for='section-59bb74f6-9877-4316-8683-6c95db37ff9e' class='xr-section-summary' >Coordinates: <span>(5)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>Time</span></div><div class='xr-var-dims'>(Time)</div><div class='xr-var-dtype'>datetime64[ns]</div><div class='xr-var-preview xr-preview'>2017-06-01 ... 2017-06-30T21:00:00</div><input id='attrs-52947fd4-597f-450c-bd30-f09adddd45d0' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-52947fd4-597f-450c-bd30-f09adddd45d0' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-204dbe3c-6878-48b5-bb62-0cf5f5d4877e' class='xr-var-data-in' type='checkbox'><label for='data-204dbe3c-6878-48b5-bb62-0cf5f5d4877e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([&#x27;2017-06-01T00:00:00.000000000&#x27;, &#x27;2017-06-01T03:00:00.000000000&#x27;,\n",
       "       &#x27;2017-06-01T06:00:00.000000000&#x27;, ..., &#x27;2017-06-30T15:00:00.000000000&#x27;,\n",
       "       &#x27;2017-06-30T18:00:00.000000000&#x27;, &#x27;2017-06-30T21:00:00.000000000&#x27;],\n",
       "      shape=(240,), dtype=&#x27;datetime64[ns]&#x27;)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>XLONG</span></div><div class='xr-var-dims'>(south_north, west_east)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-69cc880d-8ade-4ce2-be69-67442b8eff1c' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-69cc880d-8ade-4ce2-be69-67442b8eff1c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d3f13e1f-8be3-466e-8113-c1df420c14ce' class='xr-var-data-in' type='checkbox'><label for='data-d3f13e1f-8be3-466e-8113-c1df420c14ce' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>[1306800 values with dtype=float32]</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>XLAT</span></div><div class='xr-var-dims'>(south_north, west_east)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-7bb98bf4-5be0-41d9-be79-d8771e2f2112' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-7bb98bf4-5be0-41d9-be79-d8771e2f2112' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-2da55da1-e088-49a1-8985-47419de26186' class='xr-var-data-in' type='checkbox'><label for='data-2da55da1-e088-49a1-8985-47419de26186' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>[1306800 values with dtype=float32]</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>XTIME</span></div><div class='xr-var-dims'>(Time)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-6dc87931-29fd-417b-a281-7642f4ad4341' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-6dc87931-29fd-417b-a281-7642f4ad4341' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5fc016b0-7be3-4da1-9cb2-5aff604643b5' class='xr-var-data-in' type='checkbox'><label for='data-5fc016b0-7be3-4da1-9cb2-5aff604643b5' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>[240 values with dtype=float32]</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>level</span></div><div class='xr-var-dims'>()</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-0c9f843d-af3d-47ad-8203-1f5cca4c7222' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-0c9f843d-af3d-47ad-8203-1f5cca4c7222' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-499c5f83-a1c3-4df2-9ba7-b521b1a40443' class='xr-var-data-in' type='checkbox'><label for='data-499c5f83-a1c3-4df2-9ba7-b521b1a40443' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>[1 values with dtype=float64]</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-60a1b3f0-7320-4914-b482-b60119f73bbb' class='xr-section-summary-in' type='checkbox'  checked><label for='section-60a1b3f0-7320-4914-b482-b60119f73bbb' class='xr-section-summary' >Data variables: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>temp_850</span></div><div class='xr-var-dims'>(Time, south_north, west_east)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>...</div><input id='attrs-e6327b1c-c280-4bae-be4e-c2ff9c6e8cd9' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-e6327b1c-c280-4bae-be4e-c2ff9c6e8cd9' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-886b7cb3-90ca-41ba-9527-82f419717a09' class='xr-var-data-in' type='checkbox'><label for='data-886b7cb3-90ca-41ba-9527-82f419717a09' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>FieldType :</span></dt><dd>104</dd><dt><span>units :</span></dt><dd>C</dd><dt><span>stagger :</span></dt><dd></dd><dt><span>projection :</span></dt><dd>LambertConformal(stand_lon=-97.5, moad_cen_lat=36.70001220703125, truelat1=32.5, truelat2=42.5, pole_lat=90.0, pole_lon=0.0)</dd><dt><span>vert_units :</span></dt><dd>hPa</dd><dt><span>description :</span></dt><dd>Temperature at 850 hPa</dd></dl></div><div class='xr-var-data'><pre>[313632000 values with dtype=float64]</pre></div></li></ul></div></li></ul></div></div>"
      ],
      "text/plain": [
       "<xarray.Dataset> Size: 3GB\n",
       "Dimensions:   (Time: 240, south_north: 1080, west_east: 1210)\n",
       "Coordinates:\n",
       "  * Time      (Time) datetime64[ns] 2kB 2017-06-01 ... 2017-06-30T21:00:00\n",
       "    XLONG     (south_north, west_east) float32 5MB ...\n",
       "    XLAT      (south_north, west_east) float32 5MB ...\n",
       "    XTIME     (Time) float32 960B ...\n",
       "    level     float64 8B ...\n",
       "Dimensions without coordinates: south_north, west_east\n",
       "Data variables:\n",
       "    temp_850  (Time, south_north, west_east) float64 3GB ..."
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x400 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "def plot_mean_humidity_differences(var):\n",
    "    \"\"\"\n",
    "    Plots the mean temp for the current simulation,\n",
    "    and the differences in mean temp between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    temp_datasets = {\n",
    "        'Current': c_temp,\n",
    "        'Future': f_temp,\n",
    "        'Future+Urban': fu_temp,\n",
    "    }\n",
    "\n",
    "    if var == 'q_850':\n",
    "        title='850mb q'\n",
    "        cape_levels = np.arange(1,11,1)\n",
    "        #cape_levels = [1000,1500,2000,2500,3000,3500,4000]\n",
    "        #diff_levels = [-2000, -1500, -1000, -500, -250, 250, 500, 1000, 1500, 2000]\n",
    "        #diff_levels = [-1, -0.75, -0.5,-0.25, 0.25, 0.5, 0.75, 1]\n",
    "        diff_levels = [-1.5,-1.25,-1, -0.5, 0.5, 1, 1.25, 1.5]\n",
    "    elif var == 'rh_850':\n",
    "        title='850mb RH'\n",
    "        cape_levels = np.arange(10,81,10)\n",
    "        diff_levels = [-8, -6, -4,-2, 2, 4, 6, 8]\n",
    "    elif var == 'temp_850':\n",
    "        title='850mb Temp'\n",
    "        cape_levels = np.arange(-20,31,5)\n",
    "        diff_levels = [-2.5, -2, -1.5, -1, 1, 1.5, 2, 2.5]\n",
    "\n",
    "    # Colormap for CAPE\n",
    "    cape_cmap1 = matplotlib.colormaps['plasma']\n",
    "\n",
    "    #cape_levels=np.arange(0,1201,100)  # Adjust as needed\n",
    "    #cape_levels = [0,100,200,300,400,600,800,1000,1200]\n",
    "    #cape_levels = [0,25,50,75,100,125,150,200,250]\n",
    "    cape_cmap = mcolors.ListedColormap(cape_cmap1(np.linspace(0.1,0.8,len(cape_levels))))\n",
    "    cape_norm = mcolors.BoundaryNorm(cape_levels, len(cape_levels))\n",
    "    cape_cmap.set_over(cape_cmap1(np.linspace(0.99,1,1)))\n",
    "    cape_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    #diff_levels = [-300, -200, -150, -100, -50, 50, 100, 150, 200, 300]\n",
    "    #diff_levels = [-100, -75, -50, -25, -10, 10, 25, 50, 75, 100]\n",
    "    import colormaps \n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    diff_cmap = diff_cmap1[1:10]\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(diff_levels) - 1)) for i in range(len(diff_levels))]\n",
    "\n",
    "    diff_cmap.set_over(colors[-1])   # Upper bound color\n",
    "    diff_cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    diff_norm = mcolors.BoundaryNorm(diff_levels, diff_cmap.N)\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(15, 4), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on monlist\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Mean CAPE for Current Simulation #####\n",
    "    mean_cape_current = temp_datasets['Current'][var].mean(dim='Time')\n",
    "    lats = temp_datasets['Current']['XLAT']\n",
    "    lons = temp_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_current, cmap=cape_cmap, norm=cape_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    if var == 'q_850' or var == 'rh_850':\n",
    "        ax.set_title(f'Mean {title} (g kg$^{{-1}}$)', loc='left', fontsize=12)\n",
    "    elif var == 'temp_850':\n",
    "        ax.set_title(f'Mean {title} (°C)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    current_spatial_mean = mean_cape_current.mean(dim=['south_north','west_east'])\n",
    "    current_spatial_max = mean_cape_current.max(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "                f\"Mean: {current_spatial_mean:.2f}\\n Max: {current_spatial_max:.2f}\"\n",
    "            )\n",
    "    ax.text(\n",
    "        -111.8, 42.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=9, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = temp_datasets['Future'][var].mean(dim='Time')\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_current, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    if var == 'q_850' or var == 'rh_850':\n",
    "        ax.set_title(fr'$\\Delta${title} (g kg$^{{-1}}$)', loc='left', fontsize=12)\n",
    "    elif var == 'temp_850':\n",
    "        ax.set_title(fr'$\\Delta${title} (°C)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Warming Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_current.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_current.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_current.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f}\\n\"\n",
    "    f\"Min: {min_diff:.2f}\\n\"\n",
    "    f\"Max: {max_diff:.2f}\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -111.8, 41.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=9, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    \n",
    "    mean_cape_future_urban = temp_datasets['Future+Urban'][var].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_future = mean_cape_future_urban - mean_cape_future\n",
    "    \n",
    "    ax = axs[2]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_urban_future, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    if var == 'q_850' or var == 'rh_850':\n",
    "        ax.set_title(fr'$\\Delta${title} (g kg$^{{-1}}$)', loc='left', fontsize=12)\n",
    "    elif var == 'temp_850':\n",
    "        ax.set_title(fr'$\\Delta${title} (°C)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_urban_future.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_urban_future.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_urban_future.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f}\\n\"\n",
    "    f\"Min: {min_diff:.2f}\\n\"\n",
    "    f\"Max: {max_diff:.2f}\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -111.8, 41.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=9, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    \n",
    "    # Set the overall title\n",
    "    fig.suptitle(f'Mean {title} and Differences Between Simulations in {month}', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0.01, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "plot_mean_humidity_differences(var='temp_850')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "################# Relative Humidity #################\n",
    "def get_sat_vap_pressure(T):\n",
    "    \"\"\"\n",
    "    Calculates saturation vapor pressure (es) from temperature (T in Kelvin).\n",
    "    \"\"\"\n",
    "    a1 = 6.1121  # hPa\n",
    "    a3 = 17.502\n",
    "    a4 = 32.19   # K\n",
    "    To = 273.16  # K\n",
    "    t = ((T - To) / (T - a4)) * a3\n",
    "    es = a1 * np.exp(t)\n",
    "    return es\n",
    "\n",
    "# get RH in percentage: (e/es)*100\n",
    "c_rh2m = (get_vap_pressure(c_dp['td2']) / get_sat_vap_pressure(c_temp['T2'])) * 100\n",
    "f_rh2m = (get_vap_pressure(f_dp['td2']) / get_sat_vap_pressure(f_temp['T2'])) * 100\n",
    "fu_rh2m = (get_vap_pressure(fu_dp['td2']) / get_sat_vap_pressure(fu_temp['T2'])) * 100\n",
    "\n",
    "c_rh2m = c_rh2m.to_dataset(name='rh2m')\n",
    "f_rh2m = f_rh2m.to_dataset(name='rh2m')\n",
    "fu_rh2m = fu_rh2m.to_dataset(name='rh2m')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mean_rh_differences():\n",
    "    \"\"\"\n",
    "    Plots the mean relative humidity (%) for the current simulation,\n",
    "    and the differences in between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    cape_datasets = {\n",
    "        'Current': c_rh2m,\n",
    "        'Future': f_rh2m,\n",
    "        'Future-Urban': fu_rh2m\n",
    "    }\n",
    "\n",
    "    # Colormap for CAPE\n",
    "    cape_cmap1 = matplotlib.colormaps['plasma']\n",
    "\n",
    "    cape_levels=np.arange(10,81,10)  # Adjust as needed\n",
    "    #cape_levels = [0,100,200,300,400,600,800,1000,1200]\n",
    "    #cape_levels = [0,25,50,75,100,125,150,200,250]\n",
    "    cape_cmap = mcolors.ListedColormap(cape_cmap1(np.linspace(0.1,0.8,len(cape_levels))))\n",
    "    cape_norm = mcolors.BoundaryNorm(cape_levels, len(cape_levels))\n",
    "    cape_cmap.set_over(cape_cmap1(np.linspace(0.99,1,1)))\n",
    "    cape_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    #diff_levels = [-300, -200, -150, -100, -50, 50, 100, 150, 200, 300]\n",
    "    diff_levels = [-8, -6, -4,-2, 2, 4, 6, 8]\n",
    "    import colormaps \n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    diff_cmap = diff_cmap1[1:10]\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(diff_levels) - 1)) for i in range(len(diff_levels))]\n",
    "\n",
    "    diff_cmap.set_over(colors[-1])   # Upper bound color\n",
    "    diff_cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    diff_norm = mcolors.BoundaryNorm(diff_levels, diff_cmap.N)\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(12, 3), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on monlist\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Mean CAPE for Current Simulation #####\n",
    "    mean_cape_current = cape_datasets['Current'].mean(dim='Time')\n",
    "    lats = cape_datasets['Current']['XLAT']\n",
    "    lons = cape_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_current, cmap=cape_cmap, norm=cape_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.5)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.5)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.75, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(f'Mean 2m-RH (%)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    current_spatial_mean = mean_cape_current.mean(dim=['south_north','west_east'])\n",
    "    current_spatial_max = mean_cape_current.max(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "                f\"Mean: {current_spatial_mean:.2f} (%)\\n\"\n",
    "                f\"Max: {current_spatial_max:.2f} (%)\"\n",
    "            )\n",
    "    ax.text(\n",
    "        -112.0, 43.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = cape_datasets['Future'].mean(dim='Time')\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_current, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    #pb = ax.contourf(lons, lats, mean_cape_diff_future_current, levels=diff_levels, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.5)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.5)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.75, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(fr'$\\Delta$2m-RH (%)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_current.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_current.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_current.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f} (%)\\n\"\n",
    "    f\"Min: {min_diff:.2f} (%)\\n\"\n",
    "    f\"Max: {max_diff:.2f} (%)\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -112.0, 42.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    mean_cape_future_urban = cape_datasets['Future-Urban'].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_current = mean_cape_future_urban - mean_cape_current\n",
    "    mean_cape_diff_future_urban_future = mean_cape_diff_future_urban_current - mean_cape_diff_future_current\n",
    "    mean_cape_diff_future_urban_future2 = mean_cape_diff_future_urban_future.where((mean_cape_diff_future_urban_future <=-0.01) | (mean_cape_diff_future_urban_future >=0.01), drop=False)\n",
    "    \n",
    "    ax = axs[2]\n",
    "    pb = ax.pcolormesh(lons, lats, mean_cape_diff_future_urban_future2, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "    #pb = ax.contourf(lons, lats, mean_cape_diff_future_urban_future, levels=diff_levels, cmap=diff_cmap, norm=diff_norm, transform=ccrs.PlateCarree(), zorder=1)\n",
    "\n",
    "    # Add features and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.5)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.5)\n",
    "    gl = ax.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.75, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax.set_title(r'$\\Delta$2m-RH (%)', loc='left', fontsize=12)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar\n",
    "    cbar = plt.colorbar(pb, ax=ax, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('J/kg')\n",
    "\n",
    "    min_diff = mean_cape_diff_future_urban_future.min(dim=['south_north','west_east'])\n",
    "    max_diff = mean_cape_diff_future_urban_future.max(dim=['south_north','west_east'])\n",
    "    mean_diff = mean_cape_diff_future_urban_future.mean(dim=['south_north','west_east'])\n",
    "\n",
    "    \n",
    "    text_str = (\n",
    "    f\"Mean: {mean_diff:.2f} (%)\\n\"\n",
    "    f\"Min: {min_diff:.2f} (%)\\n\"\n",
    "    f\"Max: {max_diff:.2f} (%)\"\n",
    "    )\n",
    "    ax.text(\n",
    "        -112.0, 42.3, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=ccrs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    \n",
    "\n",
    "    # Set the overall title\n",
    "    fig.suptitle(f'Mean 2m-RH and Differences Between Simulations in {month} (Clear Sky points)', fontsize=12)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_mean_rh_differences()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "############### STP Calculation ###################\n",
    "def get_stp(cape_ds, srh_ds, bulk_ds, lcl_ds):\n",
    "    cs = (cape_ds['cape_2d'] /1500) * (srh_ds['0_1km_srh'] / 150) # first two terms\n",
    "\n",
    "    bs = (bulk_ds['bulk_shear_0_6km'] / 12)\n",
    "    bs = bs.clip(max=1.5) # caps the bulk shear term at 1.5\n",
    "\n",
    "    lcl = (2000-lcl_ds['lcl']) / 1000\n",
    "    lcl = lcl.clip(max=1) # sets the lcl term to 1 for lcls <1000m\n",
    "\n",
    "    stp = cs * bs * lcl\n",
    "    \n",
    "    stp = stp.where(stp > 0)\n",
    "\n",
    "    stp = stp.to_dataset(name='stp')\n",
    "\n",
    "    return stp\n",
    "\n",
    "c_stp = get_stp(c_cape, c_srh, c_bulk, c_lcl)\n",
    "f_stp = get_stp(f_cape, f_srh, f_bulk, f_lcl)\n",
    "fu_stp = get_stp(fu_cape, fu_srh, fu_bulk, fu_lcl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7.24067928e-13 3.85775479e-02 1.51934957e-01 6.84267406e-01\n",
      " 2.37574897e+01]\n",
      "[0 1 2 3]\n",
      "ACC_Impact_06= [ 2.23969245  1.97921305  2.90561419 21.31297594]\n",
      "Urbanization_Impact_06= [-1.66113505 -0.25650285  0.70314449 -0.75776789]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_2307264/3530804892.py:120: UserWarning: Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n",
      "  ax1.set_ylim(0, 100)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Precipitation intensity bins and labels (same as before)\n",
    "#VAR_BINS = [(1000, 2000), (2000, 3000), (3000, 4000),(4000, np.inf)] # cape\n",
    "#VAR_BINS = [(100, 200), (200, 300), (300, 400),(400, np.inf)] # srh\n",
    "#VAR_BINS = [(1, 2), (2, 3), (3, 4),(4, np.inf)] # ehi\n",
    "#VAR_BINS = [(1, 3), (3, 5), (5, 7),(7, np.inf)] # stp\n",
    "#VAR_BINS = [(0, 6), (6, 10), (10, 14),(14, np.inf)] # q\n",
    "#VAR_BINS = [(0, 70), (70, 90), (90, 95),(95, np.inf)] # rh\n",
    "#BIN_LABELS = [f'{VAR_BINS[0][0]}-{VAR_BINS[0][1]}', f'{VAR_BINS[1][0]}-{VAR_BINS[1][1]}', f'{VAR_BINS[2][0]}-{VAR_BINS[2][1]}',f'≥{VAR_BINS[3][0]}']\n",
    "\n",
    "# Functions to calculate relative changes\n",
    "def calculate_relative_change(future, current):\n",
    "    return ((future / current) - 1) * 100\n",
    "\n",
    "def calculate_relative_change_urbanization(future, current, future_urban):\n",
    "    f = ((future / current) - 1) * 100\n",
    "    fu = ((future_urban / current) - 1) * 100\n",
    "    return fu - f\n",
    "\n",
    "# Function to calculate frequency (number of occurrences) per intensity bin\n",
    "def calculate_frequency_per_bin(precip_data, bins):\n",
    "    bin_frequencies = []\n",
    "    for lower, upper in bins:\n",
    "        # Count occurrences within each bin across all time steps and grid points\n",
    "        bin_mask = (precip_data >= lower) & (precip_data < upper)\n",
    "        bin_frequency = bin_mask.sum().item()  # Total occurrences in this bin\n",
    "        bin_frequencies.append(bin_frequency)\n",
    "    return bin_frequencies\n",
    "\n",
    "def calculate_percentage_per_bin(precip_data, bins):\n",
    "    total_occurrences = precip_data.size  # Total number of grid points across all time steps\n",
    "    bin_percentages = []\n",
    "\n",
    "    for lower, upper in zip(bins[:-1], bins[1:]):\n",
    "        bin_mask = (precip_data >= lower) & (precip_data < upper)\n",
    "        bin_frequency = bin_mask.sum().item()  # Count occurrences in this bin\n",
    "        bin_percentage = (bin_frequency / total_occurrences) * 100  # Normalize to percentage\n",
    "        bin_percentages.append(bin_percentage)\n",
    "\n",
    "    return bin_percentages\n",
    "\n",
    "def plot_precip_intensity_frequency_bar(c,f,fu, var):\n",
    "    # Step 1: Use all occurrences of precipitation values for each simulation across all time steps and grid cells\n",
    "    if var =='q' or var=='rh2m':\n",
    "        all_current = c\n",
    "        all_future = f\n",
    "        all_future_urban = fu\n",
    "    else:\n",
    "        all_current = c[var]\n",
    "        all_future = f[var]\n",
    "        all_future_urban = fu[var]\n",
    "    \n",
    "    # Flatten data\n",
    "    data_flat_c = all_current.values.flatten()\n",
    "    data_flat_c = data_flat_c[~np.isnan(data_flat_c)]\n",
    "\n",
    "    # Define desired percentiles (e.g., 0–50, 50–70, 70–90, 90–100)\n",
    "    percentiles = [0, 50, 70, 90, 100]\n",
    "    VAR_BINS_c = np.percentile(data_flat_c, percentiles)\n",
    "\n",
    "    print(VAR_BINS_c)\n",
    "\n",
    "    #print(VAR_BINS)\n",
    "\n",
    "    BIN_LABELS = [f'{percentiles[0]}-{percentiles[1]}', f'{percentiles[1]}-{percentiles[2]}', f'{percentiles[2]}-{percentiles[3]}',f'≥{percentiles[3]}']\n",
    "\n",
    "\n",
    "    # Step 2: Calculate frequency for each bin for each simulation\n",
    "    freq_current = calculate_percentage_per_bin(all_current, VAR_BINS_c)\n",
    "    freq_future = calculate_percentage_per_bin(all_future, VAR_BINS_c)\n",
    "    freq_future_urban = calculate_percentage_per_bin(all_future_urban, VAR_BINS_c)\n",
    "\n",
    "\n",
    "    # Step 3: Calculate relative change between simulations\n",
    "    relative_change_future = calculate_relative_change(np.array(freq_future), np.array(freq_current))\n",
    "    relative_change_urban = calculate_relative_change_urbanization(\n",
    "        np.array(freq_future), np.array(freq_current), np.array(freq_future_urban)\n",
    "    )\n",
    "\n",
    "\n",
    "    if var=='cape_2d':\n",
    "        title='CAPE'\n",
    "        units='(J kg$^{-1}$)'\n",
    "    elif var=='helicity':\n",
    "        title='0-3km SRH'\n",
    "        units='(m$^{2}$ s$^{-2}$)'\n",
    "    elif var=='ehi':\n",
    "        title='EHI'\n",
    "        units=' '\n",
    "    elif var=='stp':\n",
    "        title='STP'\n",
    "        units=' '\n",
    "    elif var=='q':\n",
    "        title='2m q'\n",
    "        units='(g kg$^{-1}$)'\n",
    "    elif var=='rh2m':\n",
    "        title='2m RH'\n",
    "        units='(%)'\n",
    "    \n",
    "\n",
    "    # Step 4: Plotting\n",
    "    fig, ax1 = plt.subplots(figsize=(5, 4))\n",
    "\n",
    "    # Bar width and positions\n",
    "    bar_width = 0.2\n",
    "    x = np.arange(len(VAR_BINS_c)-1)\n",
    "    print(x)\n",
    "\n",
    "    # Plot bars for each simulation\n",
    "    ax1.bar(x - bar_width, freq_current, width=bar_width, color='black', label='Current',zorder=2)\n",
    "    ax1.bar(x, freq_future, width=bar_width, color='#1E88E5', label='Future',zorder=2)\n",
    "    ax1.bar(x + bar_width, freq_future_urban, width=bar_width, color='#D81B60', label='Future+Urban',zorder=2)\n",
    "\n",
    "    # Primary Y-axis (left)\n",
    "    #ax1.set_xlabel(f'{title} {units}')\n",
    "    ax1.set_xlabel(f'Percentile Range')\n",
    "    ax1.set_ylabel('Percentage of All Occurrences (%)')\n",
    "    ax1.set_yscale('log')\n",
    "    ax1.set_xticks(x)\n",
    "    ax1.set_xticklabels(BIN_LABELS)\n",
    "    ax1.set_ylim(0, 100)\n",
    "\n",
    "    # Secondary Y-axis (right) for relative changes\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.plot(x, relative_change_future, color='black', marker='o', linestyle='--', label='ACC Impact', linewidth=2)\n",
    "    ax2.plot(x, relative_change_urban, color='black', marker='s', linestyle=':', label='Urbanization', linewidth=2)\n",
    "    ax2.set_ylabel('Relative change (%)', color='black')\n",
    "    ax2.set_ylim(-30, 60)  # Adjust based on expected range of relative changes\n",
    "    ax2.grid(True, axis='y', alpha=0.5)\n",
    "\n",
    "    # Add legend for secondary y-axis lines\n",
    "    ax2.legend(loc='upper right')\n",
    "    ax1.legend(loc='upper left')\n",
    "\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    print(f'ACC_Impact_{monlist[0]}=', relative_change_future)\n",
    "    print(f'Urbanization_Impact_{monlist[0]}=', relative_change_urban)\n",
    "\n",
    "    # Title and layout adjustments\n",
    "    ax1.set_title(f'Frequency of {title} in {month}')\n",
    "    fig.tight_layout()\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "#plot_precip_intensity_frequency_bar(c=c_cape,f=f_cape,fu=fu_cape, var='cape_2d')\n",
    "#plot_precip_intensity_frequency_bar(c=c_srh,f=f_srh,fu=fu_srh, var='helicity')\n",
    "#plot_precip_intensity_frequency_bar(c=c_ehi,f=f_ehi,fu=fu_ehi, var='ehi')\n",
    "#plot_precip_intensity_frequency_bar(c=c_stp,f=f_stp,fu=fu_stp, var='stp')\n",
    "#plot_precip_intensity_frequency_bar(c=c_q,f=f_q,fu=fu_q, var='q')\n",
    "#plot_precip_intensity_frequency_bar(c=c_rh2m,f=f_rh2m,fu=fu_rh2m, var='rh2m')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done bootstrapping\n",
      "done bootstrapping\n",
      "done bootstrapping\n",
      "99.999985\n",
      "99.98213\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "from scipy.stats import gaussian_kde\n",
    "\n",
    "\n",
    "def plot_param_pdf(c_ds, f_ds, var, threshold, max_bin, iters, fu_ds=None, bin_width=0.25, fcount_days=None):\n",
    "    \"\"\"\n",
    "    Plots the smoothed PDF of a variable from three simulations with mean in legend,\n",
    "    using a 3-bin rolling average and scaling frequency to 0–100%.\n",
    "    \"\"\"\n",
    "    \n",
    "    def preprocess(dataarray):\n",
    "        \"\"\"Flatten, clean, and clip data.\"\"\"\n",
    "        arr = dataarray.values.astype(np.float32).flatten()\n",
    "        arr = arr[~np.isnan(arr)]\n",
    "        #if max_bin is not None:\n",
    "        #    arr = np.clip(arr, None, max_bin)\n",
    "        return arr\n",
    "\n",
    "\n",
    "    def bootstrap_from_kde(data, bins, iters=1000, size=100_000):\n",
    "        kde = gaussian_kde(data)\n",
    "        resampled = kde.resample(iters * size).reshape(iters, size)\n",
    "\n",
    "        counts = np.zeros((iters, len(bins)), dtype=np.float32)\n",
    "\n",
    "        for i in range(iters):\n",
    "            sample = resampled[i]\n",
    "            # Don't filter; let values > bins[-1] fall into last bin via clip\n",
    "            indices = np.digitize(sample, bins, right=False) - 1\n",
    "            indices = np.clip(indices, 0, len(bins) - 1)\n",
    "\n",
    "            counts[i, :] = np.bincount(indices, minlength=len(bins))\n",
    "\n",
    "        freqs = (counts / counts.sum(axis=1, keepdims=True)) * 100\n",
    "        avg_freq = np.nanmean(freqs, axis=0)\n",
    "        avg_freq = avg_freq[1:-1] # removes the last index\n",
    "\n",
    "        print('done bootstrapping')\n",
    "        #return pd.Series(avg_freq).rolling(window, center=True).mean().to_numpy()\n",
    "        return avg_freq\n",
    "\n",
    "\n",
    "    \n",
    "    # Preprocess each dataset\n",
    "    c_filtered = preprocess(c_ds[var].where(c_ds[var] >= threshold))\n",
    "    f_filtered = preprocess(f_ds[var].where(f_ds[var] >= threshold))\n",
    "    fu_filtered = preprocess(fu_ds[var].where(fu_ds[var] >= threshold))\n",
    "\n",
    "    # Shared bin range for all datasets\n",
    "    #min_val = min(c_filtered.min(), f_filtered.min(), fu_filtered.min())\n",
    "    min_val = threshold\n",
    "    effective_max = max_bin if max_bin is not None else max(c_filtered.max(), f_filtered.max()) #,fu_filtered.max())\n",
    "    bins = np.arange(min_val, effective_max + bin_width, bin_width)\n",
    "\n",
    "    # With this:\n",
    "    c_kde = bootstrap_from_kde(c_filtered, bins, iters=iters, size=100_000)\n",
    "    f_kde = bootstrap_from_kde(f_filtered, bins, iters=iters, size=100_000)\n",
    "    fu_kde = bootstrap_from_kde(fu_filtered, bins, iters=iters, size=100_000)\n",
    "\n",
    "    bins = bins[1:-1] # removes the last index\n",
    "\n",
    "    # Means\n",
    "    c_mean = np.mean(c_filtered)\n",
    "    f_mean = np.mean(f_filtered)\n",
    "    fu_mean = np.mean(fu_filtered)\n",
    "\n",
    "    print(c_kde.sum())\n",
    "    print(f_kde.sum())\n",
    "    #print(c_kde)\n",
    "\n",
    "    # Plot\n",
    "    plt.figure(figsize=(4, 3))\n",
    "    plt.plot(bins, c_kde, label=f\"Current (Mean: {c_mean:.2f})\", color=\"black\", linewidth=2)\n",
    "    plt.plot(bins, f_kde, label=f\"Future (Mean: {f_mean:.2f})\", color=\"#1E88E5\", linewidth=2)\n",
    "    plt.plot(bins, fu_kde, label=f\"Future+Urban (Mean: {fu_mean:.2f})\", color=\"#D81B60\", linewidth=2)\n",
    "\n",
    "    # Labels\n",
    "    label_dict = {\n",
    "        'cape_2d': ('CAPE', '(J kg$^{-1}$)'),\n",
    "        'mcin': ('CIN', '(J kg$^{-1}$)'),\n",
    "        'helicity': ('0-3km SRH', '(m$^{2}$ s$^{-2}$)'),\n",
    "        '0_1km_srh': ('0-1km SRH', '(m$^{2}$ s$^{-2}$)'),\n",
    "        'ehi': ('EHI', ''),\n",
    "        'stp': ('STP', ''),\n",
    "        'q': ('2m q', '(g kg$^{-1}$)'),\n",
    "        'rh2m': ('2m RH', '(%)'),\n",
    "        'bulk_shear_0_6km': ('0-6km Bulk Shear', '(m s$^{-1}$)'),\n",
    "        'lcl': ('LCL', '(m)')\n",
    "    }\n",
    "    title, units = label_dict.get(var, (var, ''))\n",
    "\n",
    "    # Month detection (you likely set monlist earlier)\n",
    "    try:\n",
    "        month = {'04': 'April', '05': 'May', '06': 'June'}.get(monlist[0], '')\n",
    "    except:\n",
    "        month = ''\n",
    "\n",
    "    plt.title(f\"{title} ({month})\")\n",
    "    #plt.title(f\"{title} ({month})\")\n",
    "    plt.xlabel(f\"{title} {units}\")\n",
    "    plt.ylabel(\"Normalized Frequency (%)\")\n",
    "    plt.ylim(0,5)\n",
    "    #plt.yscale('log')\n",
    "    plt.yscale('symlog', linthresh=0.01)\n",
    "    custom_ticks = [0.001,0.01,0.1,1]\n",
    "    #custom_ticks = [0.1,1]\n",
    "    plt.minorticks_off()\n",
    "    plt.yticks(custom_ticks)\n",
    "    plt.legend(fontsize=8, loc='upper right')\n",
    "    #plt.legend(fontsize=8, loc='lower left')\n",
    "    plt.grid(alpha=0.5, linestyle=':')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "#plot_param_pdf(c_cape,f_cape,fu_cape, var='cape_2d', bin_width=10, max_bin=6000, threshold=1000)\n",
    "#plot_param_pdf(c_bulk,f_bulk,fu_bulk, var='bulk_shear_0_6km',threshold=10, max_bin=60, bin_width=1)\n",
    "#plot_param_pdf(c_stp,f_stp,fu_stp, var='stp',threshold=1,  max_bin=15, bin_width=0.1)\n",
    "#plot_param_pdf(c_srh,f_srh,fu_ds=fu_srh, var='0_1km_srh', bin_width=10, max_bin=1200, threshold=10, iters=100)\n",
    "#plot_param_pdf(c_ehi,f_ehi,fu_ehi, var='ehi', bin_width=0.1, max_bin=30, threshold=1, iters=1000)\n",
    "#plot_param_pdf(c_q,f_q,fu_q, var='q', bin_width=0.1, max_bin=25, threshold=5, iters=100)\n",
    "#plot_param_pdf(c_rh2m,f_rh2m,fu_rh2m, var='rh2m', bin_width=0.1, max_bin=100, threshold=60, iters=100)\n",
    "#plot_param_pdf(c_cape,f_cape, fu_ds=fu_cape, var='mcin', bin_width=1, max_bin=1200, threshold=1, iters=100)\n",
    "plot_param_pdf(c_lcl,f_lcl, fu_ds=fu_lcl, var='lcl', bin_width=10, max_bin=12000, threshold=1, iters=100)\n",
    "\n"
   ]
  },
  {
   "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.11.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}