{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "065626f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "## You are using the Python ARM Radar Toolkit (Py-ART), an open source\n",
      "## library for working with weather radar data. Py-ART is partly\n",
      "## supported by the U.S. Department of Energy as part of the Atmospheric\n",
      "## Radiation Measurement (ARM) Climate Research Facility, an Office of\n",
      "## Science user facility.\n",
      "##\n",
      "## If you use this software to prepare a publication, please cite:\n",
      "##\n",
      "##     JJ Helmus and SM Collis, JORS 2016, doi: 10.5334/jors.119\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "import gzip\n",
    "import io\n",
    "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 as mpl\n",
    "import matplotlib.dates as mdates\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",
    "#from metpy.plots import colortables, USCOUNTIES\n",
    "import pyart\n",
    "from datetime import datetime, time\n",
    "from shapely.geometry import box\n",
    "\n",
    "import wrf\n",
    "from wrf import (getvar, vinterp, interplevel, to_np, latlon_coords, get_cartopy,\n",
    "                 cartopy_xlim, cartopy_ylim, vertcross, CoordPair)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e827836c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_in_wrf_data(var_name, climate_state, month):\n",
    "    \"\"\"\n",
    "    Reads in all NetCDF files for a given month and combines them into one dataset.\n",
    "\n",
    "    Parameters:\n",
    "        sim (str): Name of folder where output files are kept\n",
    "        var_name (str): what variable you want to load in, e.g. \"RAINNC\"\n",
    "\n",
    "    Returns:\n",
    "        xarray dataset of full month of data\n",
    "    \"\"\"\n",
    "    \n",
    "    # Determine the file path based on the input parameters\n",
    "    file_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/3hr/wrfout_d01_2017-{month}*_12*'\n",
    "\n",
    "    \n",
    "    file_list=[]\n",
    "    \n",
    "    file_list = sorted(glob.glob(file_path))\n",
    "    \n",
    "    # Define allowed time range \n",
    "    start_dt = datetime(2017, 6, 21, 12, 00)  \n",
    "    end_dt   = datetime(2017, 6, 22, 13, 00)      \n",
    "\n",
    "    filtered_files = []\n",
    "\n",
    "    for file_path in file_list:\n",
    "        # Extract timestamp string from filename\n",
    "        try:\n",
    "            timestamp_str = file_path.split(\"_d01_\")[-1]\n",
    "            timestamp = datetime.strptime(timestamp_str, \"%Y-%m-%d_%H:%M:%S\")\n",
    "\n",
    "            if start_dt <= timestamp < end_dt:\n",
    "                filtered_files.append(file_path)\n",
    "        except Exception as e:\n",
    "            print(f\"Skipping file (couldn't parse time): {file_path}\")\n",
    "            continue\n",
    "\n",
    "\n",
    "    #print(file_list[-1])\n",
    "\n",
    "    array_list=[]\n",
    "    for file in filtered_files:\n",
    "        ##-- read file  \n",
    "        print(file)          \n",
    "        ncfile = netCDF4.Dataset(file,'r')\n",
    "        #print(ncfile) \n",
    "        #data = getvar(ncfile,var_name)\n",
    "\n",
    "        # Extract the Geopotential Height and Pressure (hPa) fields\n",
    "        z = getvar(ncfile, \"z\", units='dm')\n",
    "        p = getvar(ncfile, \"pressure\")\n",
    "        ua = getvar(ncfile, \"ua\", units=\"m s-1\")\n",
    "        va = getvar(ncfile, \"va\", units=\"m s-1\")\n",
    "        wspd = getvar(ncfile, \"wspd_wdir\", units=\"m s-1\")[0,:]\n",
    "\n",
    "        # interpolate to 500mb\n",
    "        ht_500mb = interplevel(z, p, 500)\n",
    "        u_500 = interplevel(ua, p, 500)\n",
    "        v_500 = interplevel(va, p, 500)\n",
    "        wspd_500 = interplevel(wspd, p, 500)\n",
    "\n",
    "        #data = data.to_dataset(name=var_name)\n",
    "\n",
    "        data = xr.merge([ht_500mb, u_500, v_500, wspd_500])\n",
    "        \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()\n",
    "\n",
    "    #combined_ds[var_name].attrs['projection'] = str(combined_ds[var_name].attrs['projection'])\n",
    "\n",
    "    return combined_ds\n",
    "\n",
    "#c_ds = read_in_wrf_data(var_name=None, climate_state='current', month='06')\n",
    "#f_ds = read_in_wrf_data(var_name=None, climate_state='future', month='06')\n",
    "#fu_ds = read_in_wrf_data(var_name=None, climate_state='future_urban', month='06')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baf08c69",
   "metadata": {},
   "outputs": [],
   "source": [
    "select_subregion = True\n",
    "\n",
    "# Select subregion if desired\n",
    "if select_subregion == True:\n",
    "    def select_region(bounding_box, ds):\n",
    "        min_lon,min_lat,max_lon,max_lat = bounding_box[0], bounding_box[1], bounding_box[2], bounding_box[3]\n",
    "\n",
    "        # Access the latitude and longitude arrays (XLAT, XLONG)\n",
    "        lats = ds['XLAT']\n",
    "        lons = ds['XLONG']\n",
    "\n",
    "        # Create a boolean mask for the region of interest\n",
    "        region_mask = (lats >= min_lat) & (lats <= max_lat) & (lons >= min_lon) & (lons <= max_lon)\n",
    "\n",
    "        # Subset the data using the bounding box\n",
    "        ds = ds.where(region_mask, drop=True)\n",
    "\n",
    "        return ds\n",
    "    \n",
    "    bbox = [-97,26,-84,38]\n",
    "    \n",
    "    #c_winds_ds = select_region(bbox, c_ds)\n",
    "    #f_winds_ds = select_region(bbox, f_ds)\n",
    "    #fu_winds_ds = select_region(bbox, fu_ds) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "664eca63",
   "metadata": {},
   "outputs": [],
   "source": [
    "#------------- Wind Color map -------------------- \n",
    "clevs1 = [2,6,8,12,16,20,24,28,32]\n",
    "#Define the RGBA values for the custom colormap \n",
    "custom_rgb = ['#446db0', '#6894bd', '#88b6c6', '#a5d2c9', '#c1e8c6', '#dbf7bf', '#f4feb2', '#fff197', '#fdd675', '#f8bb57', '#ef9e3c', '#e48125', '#d76210', '#c83f02'] \n",
    "# Create a ListedColormap from the custom RGBA values \n",
    "cmap_wind = mcolors.ListedColormap(custom_rgb) \n",
    "# Create a normalization for the contour levels \n",
    "norm_wind = mcolors.BoundaryNorm(clevs1, len(custom_rgb)) \n",
    "cmap_wind.set_under('#00429d') \n",
    "cmap_wind.set_over('#730000') # For values below min level\n",
    "\n",
    "from matplotlib.patches import Rectangle\n",
    "import matplotlib.patheffects as pe\n",
    "\n",
    "def plot_wind_comparison(timestep=0):\n",
    "    # Set up the figure with a 1x3 grid of subplots\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(20, 7), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "    \n",
    "    # Simulation names for labeling\n",
    "    simulation_labels = ['Current', 'Future', 'Future+Urban']\n",
    "    \n",
    "    # Define contour levels and color map for the pressure (mean height)\n",
    "    contour_levels = np.arange(560, 598, 6)\n",
    "    \n",
    "    # Iterate through each dataset and plot\n",
    "    for i, ax in enumerate(axs):\n",
    "        # Select datasets based on the desired plot\n",
    "        if i == 0:\n",
    "            # Current simulation data\n",
    "            u_data = c_winds_ds['ua_interp'][timestep,:,:] # timestep 0\n",
    "            v_data = c_winds_ds['ua_interp'][timestep,:,:]\n",
    "            p_data = c_winds_ds['height_interp'][timestep,:,:]\n",
    "            label = simulation_labels[0]\n",
    "   \n",
    "        elif i == 1:\n",
    "            # Future simulation data\n",
    "            u_data = f_winds_ds['ua_interp'][timestep,:,:] # timestep 0\n",
    "            v_data = f_winds_ds['ua_interp'][timestep,:,:]\n",
    "            p_data = f_winds_ds['height_interp'][timestep,:,:]\n",
    "            label = simulation_labels[1]\n",
    "\n",
    "        elif i == 2:\n",
    "            # Future_urban data\n",
    "            u_data = fu_winds_ds['ua_interp'][timestep,:,:] # timestep 0\n",
    "            v_data = fu_winds_ds['ua_interp'][timestep,:,:]\n",
    "            p_data = fu_winds_ds['height_interp'][timestep,:,:]\n",
    "            label = simulation_labels[2]\n",
    "\n",
    "        # Get the latitude and longitude for plotting\n",
    "        lats = u_data['XLAT']\n",
    "        lons = u_data['XLONG']\n",
    "        \n",
    "        wind_magnitude = np.sqrt(u_data ** 2 + v_data ** 2)\n",
    "\n",
    "        contours = ax.contour(\n",
    "            lons, lats, p_data, levels=contour_levels, colors='black',\n",
    "            linewidths=2, transform=ccrs.PlateCarree(), zorder=2\n",
    "        )\n",
    "        labels = ax.clabel(contours, inline=True, fontsize=16, fmt='%d', zorder=4)\n",
    "        for lab in labels:\n",
    "            lab.set_path_effects([pe.withStroke(linewidth=4, foreground='white')])\n",
    "        \n",
    "        wb = ax.pcolormesh(\n",
    "            lons, lats, wind_magnitude, cmap=cmap_wind, norm=norm_wind,\n",
    "            transform=ccrs.PlateCarree(), zorder=1\n",
    "        )\n",
    "        '''\n",
    "        quiver_key_position = [0.93, 0.07]\n",
    "        ax.add_patch(\n",
    "            Rectangle(\n",
    "                (quiver_key_position[0] - 0.06, quiver_key_position[1] - 0.04),\n",
    "                0.12, 0.15,\n",
    "                transform=ax.transAxes,\n",
    "                facecolor='white', edgecolor='black', zorder=2\n",
    "            )\n",
    "        )\n",
    "\n",
    "        stride = 100\n",
    "        \n",
    "        q = ax.quiver(\n",
    "            lons[::stride, ::stride], lats[::stride, ::stride],\n",
    "            u_data[::stride, ::stride], v_data[::stride, ::stride],\n",
    "            transform=ccrs.PlateCarree(), color='black',\n",
    "            scale_units='xy', width=0.0035, scale=8, zorder=2\n",
    "        )\n",
    "        qk = ax.quiverkey(q, *quiver_key_position, 10, label='10 m s$^{-1}$',\n",
    "                            labelpos='N', coordinates='axes',\n",
    "                            fontproperties={'size': 10}, color='black', zorder=3)\n",
    "        '''\n",
    "        # Add geographic features\n",
    "        ax.add_feature(cfeature.STATES, edgecolor=\"black\")\n",
    "        ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\")\n",
    "\n",
    "       \n",
    "        cbar = plt.colorbar(wb, ax=ax, orientation='vertical',\n",
    "                            fraction=0.05, pad=0.01, extend='both', shrink=0.8, drawedges=True)\n",
    "        cbar.set_label('m s$^{-1}$')\n",
    "        \n",
    "        # Gridlines and labels\n",
    "        gl = ax.gridlines(draw_labels=True, crs=ccrs.PlateCarree(), linewidth=0.5, color='gray', alpha=0.5, linestyle='--')\n",
    "        gl.top_labels = False\n",
    "        gl.right_labels = False \n",
    "        gl.left_labels = i == 0  # Only enable left labels on the leftmost plot\n",
    "        gl.bottom_labels = True  # Enable bottom labels on the bottom\n",
    "        \n",
    "        # Set title for each subplot\n",
    "        ax.set_title(label, fontsize=18)\n",
    "        \n",
    "    # Main title for the entire figure\n",
    "    #fig.suptitle('500mb Wind Comparison', fontsize=16)\n",
    "    timestamp1 = pd.Timestamp(u_data.Time.values)\n",
    "    timestamp_str1 = timestamp1.strftime('%Y-%m-%d %Hz')\n",
    "    fig.suptitle(f'500mb Wind Comparison {timestamp_str1}', fontsize=18)\n",
    "    \n",
    "    # Adjust layout\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "#plot_wind_comparison(timestep=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71b6c7da",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def analyze_wind_shear(simulation_ds, wind_shear_ds):\n",
    "    \"\"\"\n",
    "    Compute the minimum pressure and mean wind shear around the minimum pressure point for each timestep.\n",
    "    \n",
    "    Parameters:\n",
    "    simulation_ds (xr.Dataset): Dataset containing sea level pressure (slp), latitude (XLAT), and longitude (XLONG).\n",
    "    wind_shear_ds (xr.Dataset): Dataset containing wind shear magnitudes at 200-850mb.\n",
    "    \n",
    "    Returns:\n",
    "    pd.DataFrame: DataFrame with columns for timestep, minimum pressure, and mean wind shear.\n",
    "    \"\"\"\n",
    "    results = {\"time\": [], \"min_pressure\": [], \"mean_wind_shear\": []}\n",
    "    \n",
    "    for time_idx in range(simulation_ds.dims[\"Time\"]):\n",
    "        # Select data for the current timestep\n",
    "        slp = simulation_ds['slp'].isel(Time=time_idx)\n",
    "        wind_shear = wind_shear_ds['wind_shear'].isel(Time=time_idx)\n",
    "        \n",
    "        # Find the minimum pressure and its location\n",
    "        min_loc = slp.argmin(dim=[\"south_north\", \"west_east\"])\n",
    "        min_pressure = slp.isel(south_north=min_loc[\"south_north\"], west_east=min_loc[\"west_east\"]).values\n",
    "        center_lat = min_loc[\"south_north\"].values\n",
    "        center_lon = min_loc[\"west_east\"].values\n",
    "        \n",
    "        # Extract a 200km radius region (100 grid cells each side)\n",
    "        lat_start = max(center_lat - 100, 0)\n",
    "        lat_end = min(center_lat + 100, simulation_ds.dims[\"south_north\"])\n",
    "        lon_start = max(center_lon - 100, 0)\n",
    "        lon_end = min(center_lon + 100, simulation_ds.dims[\"west_east\"])\n",
    "        \n",
    "        wind_shear_area = wind_shear.isel(\n",
    "            south_north=slice(lat_start, lat_end), \n",
    "            west_east=slice(lon_start, lon_end)\n",
    "        )\n",
    "        \n",
    "        # Apply a circular mask to include only the 200 km radius\n",
    "        y, x = np.ogrid[:wind_shear_area.south_north.size, :wind_shear_area.west_east.size]\n",
    "        mask = (x - 100)**2 + (y - 100)**2 <= 100**2\n",
    "        wind_shear_circular = wind_shear_area.where(mask, drop=True)\n",
    "        \n",
    "        # Compute mean wind shear\n",
    "        mean_wind_shear = wind_shear_circular.mean().values\n",
    "        \n",
    "        # Append results\n",
    "        results[\"time\"].append(simulation_ds['Time'].isel(Time=time_idx).values)\n",
    "        results[\"min_pressure\"].append(min_pressure)\n",
    "        results[\"mean_wind_shear\"].append(mean_wind_shear)\n",
    "    \n",
    "    # Convert results to a DataFrame\n",
    "    df = pd.DataFrame(results)\n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90dc8916",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode_times(times_char_array):\n",
    "    \"\"\"\n",
    "    Convert the Times character array into datetime64 objects, handling the\n",
    "    WRF datetime format with underscores.\n",
    "    \"\"\"\n",
    "    # Decode the character array into strings\n",
    "    times_str = [''.join(t.astype(str)) for t in times_char_array]\n",
    "    \n",
    "    # Replace underscore with space to make it compatible with datetime format\n",
    "    times_str = [t.replace('_', ' ') for t in times_str]\n",
    "    \n",
    "    # Convert to numpy datetime64 array\n",
    "    return np.array(times_str, dtype=\"datetime64[ns]\")\n",
    "\n",
    "# Use to read in reflectivity data and grid it to the proper lat lon grid\n",
    "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): Variable name you want to load in, e.g., \"RAINNC\" for accumulated precipitation\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",
    "    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",
    "        # also need to grab xlat and xlon from the 3hr files\n",
    "        file_path2 = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/3hr/wrfout_d01_2017-04-01_00:00:00'\n",
    "        ncfile2 = netCDF4.Dataset(file_path2, 'r') \n",
    "        # Extract latitude and longitude\n",
    "        lats = ncfile2.variables['XLAT'][:]  # Latitude\n",
    "        lons = ncfile2.variables['XLONG'][:]  # Longitude\n",
    "\n",
    "    # Use glob to find all matching files for the month\n",
    "    file_list = sorted(glob.glob(file_path))\n",
    "\n",
    "    # Define allowed time range \n",
    "    start_dt = datetime(2017, 6, 20, 6, 00)  \n",
    "    end_dt   = datetime(2017, 6, 24, 6, 00)    \n",
    "\n",
    "    filtered_files = []\n",
    "\n",
    "    for file_path in file_list:\n",
    "        # Extract timestamp string from filename\n",
    "        try:\n",
    "            timestamp_str = file_path.split(\"_d01_\")[-1]\n",
    "            timestamp = datetime.strptime(timestamp_str, \"%Y-%m-%d_%H:%M:%S\")\n",
    "\n",
    "            if start_dt <= timestamp < end_dt:\n",
    "                filtered_files.append(file_path)\n",
    "        except Exception as e:\n",
    "            print(f\"Skipping file (couldn't parse time): {file_path}\")\n",
    "            continue\n",
    "\n",
    "    array_list = []\n",
    "    for file in filtered_files:\n",
    "        print(file)\n",
    "        # Read file\n",
    "        ncfile = netCDF4.Dataset(file, 'r') \n",
    "        # Check if REFL_10CM is the variable we want\n",
    "        if var_name == 'REFL_10CM':\n",
    "            # Extract REFL_10CM variable directly\n",
    "            ref_data = ncfile.variables['REFL_10CM'][:]\n",
    "            times_char_array = ncfile.variables['Times'][:]\n",
    "\n",
    "            ref_data = ref_data.max(axis=1) # Get max dbz for vertical column\n",
    "\n",
    "            # Decode times (convert to string or datetime64)\n",
    "            times = decode_times(times_char_array)\n",
    "            \n",
    "            # Convert to xarray DataArray with time, lat, lon as dimensions\n",
    "            ref_da = xr.DataArray(\n",
    "                ref_data, \n",
    "                dims=[\"Time\", \"south_north\", \"west_east\"], \n",
    "                coords={\"Time\": times, \"XLAT\": ([\"south_north\", \"west_east\"], lats[0]), \"XLONG\": ([\"south_north\", \"west_east\"], lons[0])},\n",
    "                name=\"REFL_10CM\",\n",
    "                attrs={\"Description\": \"Composite ref for vertical columns (dbz)\"}\n",
    "            )\n",
    "            \n",
    "            \n",
    "            # Convert to xarray Dataset\n",
    "            data = ref_da.to_dataset(name=\"REFL_10CM\")\n",
    "            #print(data)\n",
    "        else:\n",
    "            # For other variables, use wrf-python getvar\n",
    "            data = getvar(ncfile, var_name).to_dataset(name=var_name)\n",
    "        \n",
    "        array_list.append(data)\n",
    "        ncfile.close()\n",
    "\n",
    "    print('done')\n",
    "    \n",
    "    # Combine all datasets along the Time dimension\n",
    "    combined_ds = xr.concat(array_list, dim='Time')\n",
    "    \n",
    "    return combined_ds\n",
    "\n",
    "#c_ref = read_in_monthly_data('06', hour_interval='1hr', climate_state='current', var_name='REFL_10CM')\n",
    "#f_ref = read_in_monthly_data('06', hour_interval='1hr', climate_state='future', var_name='REFL_10CM')\n",
    "#fu_ref = read_in_monthly_data('06', hour_interval='1hr', climate_state='future_urban', var_name='REFL_10CM')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a8ef0fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#c_ref.to_netcdf('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/current_reflectivity.nc')\n",
    "#f_ref.to_netcdf('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/future_reflectivity.nc')\n",
    "#fu_ref.to_netcdf('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/future_urban_reflectivity.nc')\n",
    "\n",
    "c_ref = xr.open_dataset('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/current_reflectivity.nc')\n",
    "f_ref  = xr.open_dataset('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/future_reflectivity.nc')\n",
    "fu_ref  = xr.open_dataset('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/future_urban_reflectivity.nc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d975ce9",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b89e1b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "88c8a0563a684658b66bb27f6e75d1a8",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,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' width=1200.0/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.widgets import Slider\n",
    "from IPython.display import display # To display widgets\n",
    "\n",
    "import cmweather\n",
    "wind_cmap = cmweather.cm_colorblind.ChaseSpectral\n",
    "#wind_cmap = pyart.graph.cm.LangRainbow12\n",
    "\n",
    "p_clevs=np.arange(0,61,5)\n",
    "#p_clevs=[1,3,5,7,9,12,15,20,25,30,35,40,45,50]\n",
    "#p_clevs=[0.25,1,2,3,4,6,8,10,12,14,16,20,24]\n",
    "p_cmap = mcolors.ListedColormap(wind_cmap(np.linspace(0.1,0.8,len(p_clevs))))\n",
    "p_norm = mcolors.BoundaryNorm(p_clevs, len(p_clevs))\n",
    "#norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "#p_cmap.set_over(wind_cmap(np.linspace(0.9,0.91,1)))\n",
    "p_cmap.set_over('#feb2fa')\n",
    "p_cmap.set_under('white')\n",
    "\n",
    "def plot_radar_with_slider(current_radar_da=c_ref['REFL_10CM'], \n",
    "                           future_radar_da=f_ref['REFL_10CM'], \n",
    "                           future_urban_radar_da=fu_ref['REFL_10CM']):\n",
    "    \"\"\"\n",
    "    Plots radar reflectivity data for three simulations with a slider to move through timesteps.\n",
    "\n",
    "    Parameters:\n",
    "        current_radar_da (xarray.DataArray): Current simulation radar data.\n",
    "        future_radar_da (xarray.DataArray): Future simulation radar data.\n",
    "        future_urban_radar_da (xarray.DataArray): Future-Urban simulation radar data.\n",
    "    \"\"\"\n",
    "    # Get lat/lon for georeferencing\n",
    "    lats = current_radar_da.XLAT.values\n",
    "    lons = current_radar_da.XLONG.values\n",
    "    timesteps = current_radar_da.Time.values  # Shared timesteps for all simulations\n",
    "\n",
    "    # Create the 1x3 subplot\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(12, 6), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "    fig.subplots_adjust(bottom=0.2)  # Make room for the slider and its label\n",
    "\n",
    "    \n",
    "    # Initial timestep index\n",
    "    initial_timestep = 0\n",
    "\n",
    "    # Titles for subplots\n",
    "    titles = [\"Current\", \"Future\", \"Future+Urban\"]\n",
    "\n",
    "    # Plot the initial timestep for each simulation\n",
    "    plots = []\n",
    "    datasets = [current_radar_da, future_radar_da, future_urban_radar_da]\n",
    "\n",
    "    for i, ax in enumerate(axs):\n",
    "        radar_data = datasets[i].isel(Time=initial_timestep)\n",
    "        plot = ax.pcolormesh(lons, lats, radar_data, cmap=p_cmap, norm=p_norm, transform=ccrs.PlateCarree())\n",
    "        ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidth=0.5)\n",
    "        ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidth=0.5)\n",
    "        ax.set_title(titles[i], fontsize=12)\n",
    "        plots.append(plot)\n",
    "        #ax.set_extent([-93,-89,33,38])\n",
    "        ax.set_extent([-96,-92,31,36])\n",
    "        #ax.set_extent([-96,-92,27,32])\n",
    "\n",
    "        gl = ax.gridlines(draw_labels=True, linewidth=0.5, color='gray', alpha=0.25, linestyle='--', zorder=2)\n",
    "        gl.top_labels = False\n",
    "        gl.right_labels = False\n",
    "        gl.left_labels = True\n",
    "        gl.bottom_labels = True\n",
    "        gl.xlabel_style = {'size': 8, 'color': 'black'}\n",
    "        gl.ylabel_style = {'size': 8, 'color': 'black'}\n",
    "    \n",
    "    # Add a colorbar for each plot\n",
    "    for i, ax in enumerate(axs):\n",
    "        cbar = fig.colorbar(plots[i], ax=ax, orientation='horizontal', fraction=0.04, pad=0.05, shrink=0.8, extend='both')\n",
    "        cbar.set_label(\"Reflectivity (dBZ)\")\n",
    "\n",
    "    # Create the slider\n",
    "    ax_slider = plt.axes([0.25, 0.05, 0.5, 0.03])  # [left, bottom, width, height]\n",
    "    slider = Slider(ax_slider, \"\", 0, len(timesteps) - 1, valinit=initial_timestep, valstep=1)\n",
    "\n",
    "    # Add a label to display the selected time\n",
    "    time_label = plt.text(0.5, 0.1, \"\", transform=fig.transFigure, ha=\"center\", fontsize=12)\n",
    "\n",
    "    def format_time_label(index):\n",
    "        \"\"\"Formats the time label in 'Y-m-d HH:MMz'.\"\"\"\n",
    "        timestep = timesteps[int(index)]\n",
    "        return timestep.astype('M8[s]').item().strftime(\"%Y-%m-%d %H:%Mz\")\n",
    "\n",
    "    # Update function for the slider\n",
    "    def update(val):\n",
    "        timestep = int(slider.val)  # Get the timestep index\n",
    "        for i, plot in enumerate(plots):\n",
    "            # Update data for each subplot\n",
    "            plot.set_array(datasets[i].isel(Time=timestep).values.ravel())\n",
    "        # Update the time label\n",
    "        time_label.set_text(format_time_label(timestep))\n",
    "        # Redraw the figure\n",
    "        fig.canvas.draw_idle()\n",
    "\n",
    "    # Initialize the time label with the first timestep\n",
    "    time_label.set_text(format_time_label(initial_timestep))\n",
    "\n",
    "    # Connect the slider to the update function\n",
    "    slider.on_changed(update)\n",
    "\n",
    "# Call the function in your notebook\n",
    "plot_radar_with_slider()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40629e3d",
   "metadata": {},
   "source": [
    "# Cross Section Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e7c715df",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "dimensions ('south_north', 'west_east') must have the same length as the number of data dimensions, ndim=0",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mTypeError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/numpy/_core/fromnumeric.py:57\u001b[39m, in \u001b[36m_wrapfunc\u001b[39m\u001b[34m(obj, method, *args, **kwds)\u001b[39m\n\u001b[32m     56\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m57\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mbound\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     58\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[32m     59\u001b[39m     \u001b[38;5;66;03m# A TypeError occurs if the object does have such a method in its\u001b[39;00m\n\u001b[32m     60\u001b[39m     \u001b[38;5;66;03m# class, but its signature is not identical to that of NumPy's. This\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m     64\u001b[39m     \u001b[38;5;66;03m# Call _wrapit from within the except clause to ensure a potential\u001b[39;00m\n\u001b[32m     65\u001b[39m     \u001b[38;5;66;03m# exception has a traceback chain.\u001b[39;00m\n",
      "\u001b[31mTypeError\u001b[39m: DataArray.argmin() got an unexpected keyword argument 'out'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[31mValueError\u001b[39m                                Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 34\u001b[39m\n\u001b[32m     32\u001b[39m \u001b[38;5;66;03m# Convert x-axis to distance (km)\u001b[39;00m\n\u001b[32m     33\u001b[39m lats, lons = latlon_coords(theta)\n\u001b[32m---> \u001b[39m\u001b[32m34\u001b[39m start_idx = \u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43margmin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlats\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[43m.\u001b[49m\u001b[43mlat\u001b[49m\u001b[43m)\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[32;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mlons\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[43m.\u001b[49m\u001b[43mlon\u001b[49m\u001b[43m)\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[32;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m     35\u001b[39m end_idx   = np.argmin((lats - end.lat)**\u001b[32m2\u001b[39m + (lons - end.lon)**\u001b[32m2\u001b[39m)\n\u001b[32m     37\u001b[39m num_pts = theta_xs.shape[-\u001b[32m1\u001b[39m]\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/numpy/_core/fromnumeric.py:1439\u001b[39m, in \u001b[36margmin\u001b[39m\u001b[34m(a, axis, out, keepdims)\u001b[39m\n\u001b[32m   1350\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m   1351\u001b[39m \u001b[33;03mReturns the indices of the minimum values along an axis.\u001b[39;00m\n\u001b[32m   1352\u001b[39m \n\u001b[32m   (...)\u001b[39m\u001b[32m   1436\u001b[39m \u001b[33;03m(2, 1, 4)\u001b[39;00m\n\u001b[32m   1437\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m   1438\u001b[39m kwds = {\u001b[33m'\u001b[39m\u001b[33mkeepdims\u001b[39m\u001b[33m'\u001b[39m: keepdims} \u001b[38;5;28;01mif\u001b[39;00m keepdims \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np._NoValue \u001b[38;5;28;01melse\u001b[39;00m {}\n\u001b[32m-> \u001b[39m\u001b[32m1439\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_wrapfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43margmin\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m=\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[43m=\u001b[49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/numpy/_core/fromnumeric.py:66\u001b[39m, in \u001b[36m_wrapfunc\u001b[39m\u001b[34m(obj, method, *args, **kwds)\u001b[39m\n\u001b[32m     57\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m bound(*args, **kwds)\n\u001b[32m     58\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[32m     59\u001b[39m     \u001b[38;5;66;03m# A TypeError occurs if the object does have such a method in its\u001b[39;00m\n\u001b[32m     60\u001b[39m     \u001b[38;5;66;03m# class, but its signature is not identical to that of NumPy's. This\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m     64\u001b[39m     \u001b[38;5;66;03m# Call _wrapit from within the except clause to ensure a potential\u001b[39;00m\n\u001b[32m     65\u001b[39m     \u001b[38;5;66;03m# exception has a traceback chain.\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m66\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_wrapit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/numpy/_core/fromnumeric.py:48\u001b[39m, in \u001b[36m_wrapit\u001b[39m\u001b[34m(obj, method, *args, **kwds)\u001b[39m\n\u001b[32m     45\u001b[39m arr, = conv.as_arrays(subok=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m     46\u001b[39m result = \u001b[38;5;28mgetattr\u001b[39m(arr, method)(*args, **kwds)\n\u001b[32m---> \u001b[39m\u001b[32m48\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mconv\u001b[49m\u001b[43m.\u001b[49m\u001b[43mwrap\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresult\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mto_scalar\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/xarray/core/dataarray.py:4857\u001b[39m, in \u001b[36mDataArray.__array_wrap__\u001b[39m\u001b[34m(self, obj, context, return_scalar)\u001b[39m\n\u001b[32m   4856\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__array_wrap__\u001b[39m(\u001b[38;5;28mself\u001b[39m, obj, context=\u001b[38;5;28;01mNone\u001b[39;00m, return_scalar=\u001b[38;5;28;01mFalse\u001b[39;00m) -> Self:\n\u001b[32m-> \u001b[39m\u001b[32m4857\u001b[39m     new_var = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvariable\u001b[49m\u001b[43m.\u001b[49m\u001b[43m__array_wrap__\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_scalar\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   4858\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._replace(new_var)\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/xarray/core/variable.py:2420\u001b[39m, in \u001b[36mVariable.__array_wrap__\u001b[39m\u001b[34m(self, obj, context, return_scalar)\u001b[39m\n\u001b[32m   2419\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__array_wrap__\u001b[39m(\u001b[38;5;28mself\u001b[39m, obj, context=\u001b[38;5;28;01mNone\u001b[39;00m, return_scalar=\u001b[38;5;28;01mFalse\u001b[39;00m):\n\u001b[32m-> \u001b[39m\u001b[32m2420\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mVariable\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mdims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mobj\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/xarray/core/variable.py:399\u001b[39m, in \u001b[36mVariable.__init__\u001b[39m\u001b[34m(self, dims, data, attrs, encoding, fastpath)\u001b[39m\n\u001b[32m    371\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\n\u001b[32m    372\u001b[39m     \u001b[38;5;28mself\u001b[39m,\n\u001b[32m    373\u001b[39m     dims,\n\u001b[32m   (...)\u001b[39m\u001b[32m    377\u001b[39m     fastpath=\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[32m    378\u001b[39m ):\n\u001b[32m    379\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    380\u001b[39m \u001b[33;03m    Parameters\u001b[39;00m\n\u001b[32m    381\u001b[39m \u001b[33;03m    ----------\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    397\u001b[39m \u001b[33;03m        unrecognized encoding items.\u001b[39;00m\n\u001b[32m    398\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m399\u001b[39m     \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[32m    400\u001b[39m \u001b[43m        \u001b[49m\u001b[43mdims\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m=\u001b[49m\u001b[43mas_compatible_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfastpath\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfastpath\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mattrs\u001b[49m\n\u001b[32m    401\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    403\u001b[39m     \u001b[38;5;28mself\u001b[39m._encoding: \u001b[38;5;28mdict\u001b[39m[Any, Any] | \u001b[38;5;28;01mNone\u001b[39;00m = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    404\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m encoding \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/xarray/namedarray/core.py:261\u001b[39m, in \u001b[36mNamedArray.__init__\u001b[39m\u001b[34m(self, dims, data, attrs)\u001b[39m\n\u001b[32m    254\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\n\u001b[32m    255\u001b[39m     \u001b[38;5;28mself\u001b[39m,\n\u001b[32m    256\u001b[39m     dims: _DimsLike,\n\u001b[32m    257\u001b[39m     data: duckarray[Any, _DType_co],\n\u001b[32m    258\u001b[39m     attrs: _AttrsLike = \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m    259\u001b[39m ):\n\u001b[32m    260\u001b[39m     \u001b[38;5;28mself\u001b[39m._data = data\n\u001b[32m--> \u001b[39m\u001b[32m261\u001b[39m     \u001b[38;5;28mself\u001b[39m._dims = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_parse_dimensions\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdims\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    262\u001b[39m     \u001b[38;5;28mself\u001b[39m._attrs = \u001b[38;5;28mdict\u001b[39m(attrs) \u001b[38;5;28;01mif\u001b[39;00m attrs \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/xarray/namedarray/core.py:505\u001b[39m, in \u001b[36mNamedArray._parse_dimensions\u001b[39m\u001b[34m(self, dims)\u001b[39m\n\u001b[32m    503\u001b[39m dims = (dims,) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(dims, \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mtuple\u001b[39m(dims)\n\u001b[32m    504\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(dims) != \u001b[38;5;28mself\u001b[39m.ndim:\n\u001b[32m--> \u001b[39m\u001b[32m505\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m    506\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mdimensions \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdims\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m must have the same length as the \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    507\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnumber of data dimensions, ndim=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.ndim\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m    508\u001b[39m     )\n\u001b[32m    509\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mset\u001b[39m(dims)) < \u001b[38;5;28mlen\u001b[39m(dims):\n\u001b[32m    510\u001b[39m     repeated_dims = {d \u001b[38;5;28;01mfor\u001b[39;00m d \u001b[38;5;129;01min\u001b[39;00m dims \u001b[38;5;28;01mif\u001b[39;00m dims.count(d) > \u001b[32m1\u001b[39m}\n",
      "\u001b[31mValueError\u001b[39m: dimensions ('south_north', 'west_east') must have the same length as the number of data dimensions, ndim=0"
     ]
    }
   ],
   "source": [
    "# file: cross_section_wrf.py\n",
    "\n",
    "\n",
    "# Load WRF file\n",
    "wrf_file = \"/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future/3hr/wrfout_d01_2017-06-22_03:00:00\"\n",
    "wrfin = netCDF4.Dataset(wrf_file,'r')\n",
    "#print(wrfin)\n",
    "\n",
    "# Extract variables\n",
    "theta = getvar(wrfin, \"theta\")        # potential temperature\n",
    "u = getvar(wrfin, \"ua\")               # u-wind\n",
    "w = getvar(wrfin, \"wa\")               # vertical wind\n",
    "z = getvar(wrfin, \"z\")                # height (m)\n",
    "\n",
    "# Define cross section start/end (lat/lon)\n",
    "start = CoordPair(lat=35.0, lon=-97.0)\n",
    "end   = CoordPair(lat=35.0, lon=-94.0)\n",
    "\n",
    "# Build cross-sections\n",
    "theta_xs = vertcross(theta, z, wrfin=wrfin, start_point=start,\n",
    "                      end_point=end, meta=True)\n",
    "\n",
    "u_xs = vertcross(u, z, wrfin=wrfin, start_point=start,\n",
    "                 end_point=end, meta=True)\n",
    "\n",
    "w_xs = vertcross(w, z, wrfin=wrfin, start_point=start,\n",
    "                 end_point=end, meta=True)\n",
    "\n",
    "z_xs = vertcross(z, z, wrfin=wrfin, start_point=start,\n",
    "                 end_point=end, meta=True)\n",
    "\n",
    "# Convert x-axis to distance (km)\n",
    "lats, lons = latlon_coords(theta)\n",
    "start_idx = np.argmin((lats - start.lat)**2 + (lons - start.lon)**2)\n",
    "end_idx   = np.argmin((lats - end.lat)**2 + (lons - end.lon)**2)\n",
    "\n",
    "num_pts = theta_xs.shape[-1]\n",
    "dist = np.linspace(0, np.hypot(end.lat - start.lat, end.lon - start.lon) * 111,\n",
    "                   num_pts)  # approx distance in km\n",
    "\n",
    "# Prepare data as plain numpy arrays\n",
    "theta_xs = np.ma.filled(theta_xs, np.nan)\n",
    "u_xs = np.ma.filled(u_xs, np.nan)\n",
    "w_xs = np.ma.filled(w_xs, np.nan)\n",
    "z_xs = np.ma.filled(z_xs, np.nan)\n",
    "\n",
    "# Plot\n",
    "fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "# Contours: potential temperature\n",
    "cs = ax.contour(dist, z_xs / 1000.0, theta_xs, levels=25, linewidths=1)\n",
    "ax.clabel(cs, inline=True, fontsize=8)\n",
    "\n",
    "# Quiver: wind vectors (thin for readability)\n",
    "step = 5\n",
    "ax.quiver(dist[::step], (z_xs[:, ::step] / 1000),\n",
    "          u_xs[:, ::step], w_xs[:, ::step],\n",
    "          scale=200)\n",
    "\n",
    "ax.set_xlabel(\"Cross-section distance (km)\")\n",
    "ax.set_ylabel(\"Height (km)\")\n",
    "ax.set_title(\"WRF Cross Section: Potential Temperature + Wind Vectors\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "168a0790",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/current/3hr/wrfout_d01_2017-04-29_21:00:00\n",
      "/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/current/Ze/wrfout_hourly_d01_2017-04-29_21:00:00\n"
     ]
    },
    {
     "ename": "NotImplementedError",
     "evalue": "Dataset is not picklable",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mNotImplementedError\u001b[39m                       Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 159\u001b[39m\n\u001b[32m    153\u001b[39m     \u001b[38;5;66;03m#combined_ds = combined_ds.to_dataset(name='QTOTAL')\u001b[39;00m\n\u001b[32m    154\u001b[39m \n\u001b[32m    155\u001b[39m     \u001b[38;5;66;03m#combined_ds[var_name].attrs['projection'] = str(combined_ds[var_name].attrs['projection'])\u001b[39;00m\n\u001b[32m    157\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m combined_ds, theta_smoothed\n\u001b[32m--> \u001b[39m\u001b[32m159\u001b[39m \u001b[43mread_in_monthly_data3\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m06\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m3hr\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mcurrent\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmask2d\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 53\u001b[39m, in \u001b[36mread_in_monthly_data3\u001b[39m\u001b[34m(month, hour_interval, climate_state, mask2d)\u001b[39m\n\u001b[32m     51\u001b[39m \u001b[38;5;28mprint\u001b[39m(file)\n\u001b[32m     52\u001b[39m \u001b[38;5;28mprint\u001b[39m(hail_file)\n\u001b[32m---> \u001b[39m\u001b[32m53\u001b[39m q_total = \u001b[43mgetvar\u001b[49m\u001b[43m(\u001b[49m\u001b[43mncfile\u001b[49m\u001b[43m,\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mQCLOUD\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m + getvar(ncfile,\u001b[33m'\u001b[39m\u001b[33mQRAIN\u001b[39m\u001b[33m'\u001b[39m) + getvar(ncfile,\u001b[33m'\u001b[39m\u001b[33mQICE\u001b[39m\u001b[33m'\u001b[39m) + getvar(ncfile,\u001b[33m'\u001b[39m\u001b[33mQSNOW\u001b[39m\u001b[33m'\u001b[39m) + getvar(ncfile,\u001b[33m'\u001b[39m\u001b[33mQGRAUP\u001b[39m\u001b[33m'\u001b[39m) + hail\n\u001b[32m     54\u001b[39m q_vapor = getvar(ncfile,\u001b[33m'\u001b[39m\u001b[33mQVAPOR\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m     55\u001b[39m theta = getvar(ncfile,\u001b[33m'\u001b[39m\u001b[33mtheta\u001b[39m\u001b[33m'\u001b[39m)\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/wrf/routines.py:339\u001b[39m, in \u001b[36mgetvar\u001b[39m\u001b[34m(wrfin, varname, timeidx, method, squeeze, cache, meta, **kwargs)\u001b[39m\n\u001b[32m    231\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mgetvar\u001b[39m(wrfin, varname, timeidx=\u001b[32m0\u001b[39m,\n\u001b[32m    232\u001b[39m            method=\u001b[33m\"\u001b[39m\u001b[33mcat\u001b[39m\u001b[33m\"\u001b[39m, squeeze=\u001b[38;5;28;01mTrue\u001b[39;00m, cache=\u001b[38;5;28;01mNone\u001b[39;00m, meta=\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[32m    233\u001b[39m            **kwargs):\n\u001b[32m    235\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"Returns basic diagnostics from the WRF ARW model output.\u001b[39;00m\n\u001b[32m    236\u001b[39m \n\u001b[32m    237\u001b[39m \u001b[33;03m    A table of all available diagnostics is below.\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    336\u001b[39m \n\u001b[32m    337\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m339\u001b[39m     _key = \u001b[43mget_id\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwrfin\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    341\u001b[39m     wrfin = get_iterable(wrfin)\n\u001b[32m    343\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m is_standard_wrf_var(wrfin, varname) \u001b[38;5;129;01mand\u001b[39;00m varname != \u001b[33m\"\u001b[39m\u001b[33mTimes\u001b[39m\u001b[33m\"\u001b[39m:\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/wrf/util.py:3102\u001b[39m, in \u001b[36mget_id\u001b[39m\u001b[34m(obj, prefix)\u001b[39m\n\u001b[32m   3100\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_mapping(obj):\n\u001b[32m   3101\u001b[39m     _obj = get_iterable(obj)\n\u001b[32m-> \u001b[39m\u001b[32m3102\u001b[39m     _next = \u001b[38;5;28mnext\u001b[39m(\u001b[38;5;28;43miter\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m_obj\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m   3103\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m get_id(_next, prefix + \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mid\u001b[39m(obj)))\n\u001b[32m   3105\u001b[39m \u001b[38;5;66;03m# For each key in the mapping, recursively call get_id until\u001b[39;00m\n\u001b[32m   3106\u001b[39m \u001b[38;5;66;03m# until a non-mapping is found\u001b[39;00m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/site-packages/wrf/util.py:363\u001b[39m, in \u001b[36mIterWrapper.__iter__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    361\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m gen_copy\n\u001b[32m    362\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m363\u001b[39m     obj_copy = \u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_wrapped\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    364\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m obj_copy.\u001b[34m__iter__\u001b[39m()\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/atms-shap/lib/python3.11/copy.py:92\u001b[39m, in \u001b[36mcopy\u001b[39m\u001b[34m(x)\u001b[39m\n\u001b[32m     90\u001b[39m reductor = \u001b[38;5;28mgetattr\u001b[39m(x, \u001b[33m\"\u001b[39m\u001b[33m__reduce_ex__\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[32m     91\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m reductor \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m92\u001b[39m     rv = reductor(\u001b[32m4\u001b[39m)\n\u001b[32m     93\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m     94\u001b[39m     reductor = \u001b[38;5;28mgetattr\u001b[39m(x, \u001b[33m\"\u001b[39m\u001b[33m__reduce__\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n",
      "\u001b[36mFile \u001b[39m\u001b[32msrc/netCDF4/_netCDF4.pyx:2695\u001b[39m, in \u001b[36mnetCDF4._netCDF4.Dataset.__reduce__\u001b[39m\u001b[34m()\u001b[39m\n",
      "\u001b[31mNotImplementedError\u001b[39m: Dataset is not picklable"
     ]
    }
   ],
   "source": [
    "from scipy.ndimage import uniform_filter\n",
    "\n",
    "# Convert to NumPy, apply uniform filter on each level\n",
    "def apply_spatial_filter(data_array, size):\n",
    "    # Apply to each level separately\n",
    "    filtered = np.empty_like(data_array)\n",
    "    for k in range(data_array.shape[0]):\n",
    "        filtered[k] = uniform_filter(data_array[k], size=size, mode='nearest')\n",
    "    return filtered\n",
    "\n",
    "# Buoyancy calculation\n",
    "def read_in_monthly_data3(month, hour_interval, climate_state, mask2d=None):\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-04-29_21: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",
    "\n",
    "    # Use glob to find all matching files for the month\n",
    "    file_list = sorted(glob.glob(file_path))\n",
    " \n",
    "    # To also get hail data\n",
    "    #hail_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/Ze/wrfout_hourly_d01_2017-{month}*'\n",
    "    hail_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/Ze/wrfout_hourly_d01_2017-04-29_21:00:00'\n",
    "    hail_list = sorted(glob.glob(hail_path))\n",
    "\n",
    "    array_list=[]\n",
    "    for file, hail_file in zip(file_list, hail_list):\n",
    "        ##-- read file            \n",
    "        ncfile = netCDF4.Dataset(file,'r')\n",
    "\n",
    "        ncfile2 = netCDF4.Dataset(hail_file,'r')\n",
    "        hail = xr.open_dataset(xr.backends.NetCDF4DataStore(ncfile2))\n",
    "        hail=hail['QHAIL'][0,:,:,:]\n",
    "        #print(hail.mean())\n",
    "        print(file)\n",
    "        print(hail_file)\n",
    "        q_total = getvar(ncfile,'QCLOUD') + getvar(ncfile,'QRAIN') + getvar(ncfile,'QICE') + getvar(ncfile,'QSNOW') + getvar(ncfile,'QGRAUP') + hail\n",
    "        q_vapor = getvar(ncfile,'QVAPOR')\n",
    "        theta = getvar(ncfile,'theta')\n",
    "\n",
    "        height = getvar(ncfile, \"height_agl\", units=\"m\")  # Height in m (ABOVE GROUND LEVEL)\n",
    "\n",
    "        '''\n",
    "        # Threshold: 1000 m AGL\n",
    "        threshold = 2000.0\n",
    "\n",
    "        # Count levels < threshold at each horizontal grid point\n",
    "        mask = height < threshold  # shape: (bottom_top, south_north, west_east)\n",
    "        counts = np.sum(mask, axis=0)  # shape: (south_north, west_east)\n",
    "\n",
    "        # Compute mean across domain\n",
    "        mean_levels_1km = np.mean(counts)\n",
    "\n",
    "        print(f\"Mean number of model levels in first 2 km AGL: {mean_levels_1km:.2f}\")\n",
    "        '''\n",
    "\n",
    "        q_total = interplevel(q_total,vert=height, desiredlev=np.linspace(30,2000,12))\n",
    "        q_vapor = interplevel(q_vapor,vert=height, desiredlev=np.linspace(30,2000,12))\n",
    "        theta = interplevel(theta,vert=height, desiredlev=np.linspace(30,2000,12))\n",
    "\n",
    "        #q_total = remove_lateral_boundaries(q_total)\n",
    "        #q_vapor = remove_lateral_boundaries(q_vapor)\n",
    "        #theta = remove_lateral_boundaries(theta)\n",
    "\n",
    "        #domain_mean_theta = theta.mean(dim=['south_north','west_east']) \n",
    "        #domain_mean_q_vapor = q_vapor.mean(dim=['south_north','west_east'])\n",
    "\n",
    "        window=50 # Assume you want a 100kmx100km (50x50 since resolution is 2km) box filter\n",
    "\n",
    "        # Apply to xarray DataArray\n",
    "        smoothed_values = apply_spatial_filter(theta.values, size=(window, window))\n",
    "        theta_smoothed = xr.DataArray(\n",
    "            smoothed_values,\n",
    "            dims=theta.dims,\n",
    "            coords=theta.coords,\n",
    "            name=\"theta_smoothed\"\n",
    "        )\n",
    "\n",
    "        smoothed_values = apply_spatial_filter(q_vapor.values, size=(window, window))\n",
    "        qvapor_smoothed = xr.DataArray(\n",
    "            smoothed_values,\n",
    "            dims=q_vapor.dims,\n",
    "            coords=q_vapor.coords,\n",
    "            name=\"qvapor_smoothed\"\n",
    "        )\n",
    "        \n",
    "\n",
    "        #print(theta_smoothed)\n",
    "\n",
    "        '''\n",
    "        # Get mask\n",
    "        mask = mask2d.sel(Time=domain_mean_theta.Time.values)\n",
    "\n",
    "        # Expand mask to include the 'bottom_top' dimension\n",
    "        expanded_mask = mask.expand_dims(dim={\"level\": q_total.sizes[\"level\"]})\n",
    "\n",
    "        # Apply the mask to 'wa'\n",
    "        q_total = xr.where(expanded_mask, q_total, float(\"nan\"))\n",
    "        q_vapor = xr.where(expanded_mask, q_vapor, float(\"nan\"))\n",
    "        theta = xr.where(expanded_mask, theta, float(\"nan\"))\n",
    "        '''\n",
    "\n",
    "        g=9.81 # gravity constant (m/s^2)\n",
    "\n",
    "        ####### Need to change mean theta to a mean over smaller area #######\n",
    "        total_buoyancy = g * (((theta - theta_smoothed)/theta_smoothed) + 0.61*(q_vapor-qvapor_smoothed) - q_total) # with condensate loading\n",
    "        #thermal_buoyancy = g * (((theta - domain_mean_theta)/domain_mean_theta)) # thermal buouyancy only\n",
    "        #wv_buoyancy = g * (0.61*(q_vapor-domain_mean_q_vapor))\n",
    "        #cl_buoyancy = -g * q_total\n",
    "        #print(total_buoyancy)\n",
    "        #cpi = compute_cpi_optimized(total_buoyancy)\n",
    "        #integrated_buoyancy = compute_cpi_optimized(total_buoyancy)\n",
    "        integrated_buoyancy = integrate_buoyancy_fast(total_buoyancy)\n",
    "        #cp_height = compute_cold_pool_height(total_buoyancy)\n",
    "        #print(cp_height['cold_pool_height'].max())\n",
    "        #print(integrated_buoyancy)\n",
    "\n",
    "        #total_buoyancy = total_buoyancy.mean(dim=['south_north','west_east'])\n",
    "        #thermal_buoyancy = thermal_buoyancy.mean(dim=['south_north','west_east'])\n",
    "        #wv_buoyancy = wv_buoyancy.mean(dim=['south_north','west_east'])\n",
    "        #cl_buoyancy = cl_buoyancy.mean(dim=['south_north','west_east'])\n",
    "\n",
    "        #buoyancy = total_buoyancy.to_dataset(name='B_total')\n",
    "        #buoyancy['B_thermal'] = thermal_buoyancy\n",
    "        #buoyancy['B_vapor'] = wv_buoyancy\n",
    "        #buoyancy['B_cl'] = cl_buoyancy\n",
    "        #print(buoyancy)\n",
    "\n",
    "        #array_list.append(total_buoyancy)\n",
    "        array_list.append(integrated_buoyancy)\n",
    "        ncfile.close()\n",
    " \n",
    "\n",
    "    print('done')\n",
    "    combined_ds = xr.concat(array_list, dim='Time')\n",
    "\n",
    "    #combined_ds = combined_ds.to_dataset(name='QTOTAL')\n",
    "\n",
    "    #combined_ds[var_name].attrs['projection'] = str(combined_ds[var_name].attrs['projection'])\n",
    "\n",
    "    return combined_ds, theta_smoothed\n",
    "\n",
    "read_in_monthly_data3('06', '3hr', 'current', mask2d=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "219308ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# file: analysis/wrf/spatial_mean_box.py\n",
    "\n",
    "def select_region(bounding_box, current_ds, mrms=False):\n",
    "        min_lon,min_lat,max_lon,max_lat = bounding_box[0], bounding_box[1], bounding_box[2], bounding_box[3]\n",
    "\n",
    "        if mrms==True:\n",
    "            lats = current_ds['latitude']\n",
    "            lons = current_ds['longitude']\n",
    "        else:\n",
    "            # Access the latitude and longitude arrays (XLAT, XLONG)\n",
    "            lats = current_ds['XLAT']\n",
    "            lons = current_ds['XLONG']\n",
    "\n",
    "        # Create a boolean mask for the region of interest\n",
    "        region_mask = (lats >= min_lat) & (lats <= max_lat) & (lons >= min_lon) & (lons <= max_lon)\n",
    "\n",
    "        # Subset the data using the bounding box\n",
    "        current_ds = current_ds.where(region_mask, drop=True)\n",
    "\n",
    "        return current_ds\n",
    "\n",
    "\n",
    "def compute_spatial_mean_on_min_slp(climate_state, hour_interval, month, var_name, box_size=100):\n",
    "    \"\"\"\n",
    "    Reads WRF files, extracts SLP + variable at each timestep, and returns\n",
    "    a time series of spatial means over a box around the min SLP.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    climate_state : str\n",
    "    hour_interval : str\n",
    "    month : str\n",
    "    var_name : str\n",
    "    box_size : int\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    xarray.DataArray (Time)\n",
    "    \"\"\"\n",
    "\n",
    "    half = box_size // 2\n",
    "\n",
    "    file_path = (\n",
    "        f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/'\n",
    "        f'{climate_state}/{hour_interval}/wrfout_d01_2017-{month}*'\n",
    "    )\n",
    "\n",
    "    file_list = sorted(glob.glob(file_path))\n",
    "\n",
    "    start_dt = datetime(2017, 6, 20, 6, 00)  \n",
    "    end_dt   = datetime(2017, 6, 24, 6, 00) \n",
    "\n",
    "    filtered_files = []\n",
    "    for fp in file_list:\n",
    "        try:\n",
    "            timestamp_str = fp.split(\"_d01_\")[-1]\n",
    "            timestamp = datetime.strptime(timestamp_str, \"%Y-%m-%d_%H:%M:%S\")\n",
    "            if start_dt <= timestamp < end_dt:\n",
    "                filtered_files.append(fp)\n",
    "        except Exception:\n",
    "            continue\n",
    "\n",
    "    means = []\n",
    "    times = []\n",
    "\n",
    "    for fp in filtered_files:\n",
    "        nc = netCDF4.Dataset(fp, \"r\")\n",
    "        print(fp)\n",
    "        slp = getvar(nc, \"slp\")       # SLP directly from file\n",
    "        slp = select_region([-96,26,-85,38], slp)\n",
    "        var = getvar(nc, var_name)    # Variable directly from file\n",
    "        var = select_region([-96,26,-85,38], var)\n",
    "        #print(var)\n",
    "\n",
    "        if var_name == 'wa':\n",
    "            # Extract the Geopotential Height and Pressure (hPa) fields\n",
    "            p = getvar(nc, \"pressure\")\n",
    "            p = select_region([-96,26,-85,38], p)\n",
    "            var = interplevel(var, p, 700.)\n",
    "\n",
    "        print(var)\n",
    "\n",
    "        # Extract timestamp\n",
    "        time_val = var.Time.values\n",
    "        times.append(time_val)\n",
    "\n",
    "        # Locate min SLP index\n",
    "        flat_idx = np.argmin(slp.values)\n",
    "        iy, ix = np.unravel_index(flat_idx, slp.shape)\n",
    "\n",
    "        ny, nx = var.shape[-2], var.shape[-1]\n",
    "\n",
    "        y1, y2 = max(0, iy - half), min(ny, iy + half)\n",
    "        x1, x2 = max(0, ix - half), min(nx, ix + half)\n",
    "\n",
    "        region = var[:, y1:y2, x1:x2] if var.ndim == 3 else var[y1:y2, x1:x2]\n",
    "\n",
    "        means.append(region.mean().values)\n",
    "\n",
    "        nc.close()\n",
    "\n",
    "    return xr.DataArray(\n",
    "        data=np.array(means),\n",
    "        dims=[\"Time\"],\n",
    "        coords={\"Time\": np.array(times)},\n",
    "        name=f\"{var_name}_mean100x100_minSLP\",\n",
    "    )\n",
    "\n",
    "#compute_spatial_mean_on_min_slp('future', '3hr', '06', 'wa', box_size=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cc0333ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"'\\nmonlist=['06']\\n\\n# cape\\nc_cape = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/current/mu_cape_total_month{monlist[0]}.nc')\\nf_cape = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future/mu_cape_total_month{monlist[0]}.nc')\\nfu_cape = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/thermo_data/future_urban/mu_cape_total_month{monlist[0]}.nc')\\n\\nc_cape = c_cape.sel(Time=slice('2017-06-20 06:00:00','2017-06-24 06:00:00'))\\nf_cape = f_cape.sel(Time=slice('2017-06-20 06:00:00','2017-06-24 06:00:00'))\\nfu_cape = fu_cape.sel(Time=slice('2017-06-20 06:00:00','2017-06-24 06:00:00'))\\n\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''''\n",
    "monlist=['06']\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",
    "c_cape = c_cape.sel(Time=slice('2017-06-20 06:00:00','2017-06-24 06:00:00'))\n",
    "f_cape = f_cape.sel(Time=slice('2017-06-20 06:00:00','2017-06-24 06:00:00'))\n",
    "fu_cape = fu_cape.sel(Time=slice('2017-06-20 06:00:00','2017-06-24 06:00:00'))\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "53e7733e",
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "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_cape,\n",
    "        'Future': f_cape,\n",
    "        'Future+Urban': fu_cape\n",
    "    }\n",
    "    import matplotlib\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,1600]\n",
    "        #cape_levels = [1000,1500,2000,2500,3000,3500,4000]\n",
    "        #diff_levels = [-2000, -1500, -1000, -500, -250, 250, 500, 1000, 1500, 2000]\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",
    "    # 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=(12, 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']['cape_2d'].mean(dim='Time')\n",
    "    lats = cape_datasets['Current']['XLAT']\n",
    "    lons = cape_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax = axs[0]\n",
    "    ax.set_extent([-96,-85,26,38])\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 CAPE', loc='left', fontsize=10)\n",
    "    ax.set_title(f'(Current)', loc='right', fontsize=10)\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('CAPE')\n",
    "\n",
    "    ##### Middle Plot: Future - Current CAPE Difference #####\n",
    "    mean_cape_future = cape_datasets['Future']['cape_2d'].mean(dim='Time')\n",
    "    mean_cape_diff_future_current = mean_cape_future - mean_cape_current\n",
    "    \n",
    "    ax = axs[1]\n",
    "    ax.set_extent([-96,-85,26,38])\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 CAPE (J/kg)', loc='left', fontsize=10)\n",
    "    ax.set_title(f'(Warming Effect)', loc='right', fontsize=10)\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('CAPE Difference')\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future CAPE Difference #####\n",
    "    mean_cape_future_urban = cape_datasets['Future+Urban']['cape_2d'].mean(dim='Time')\n",
    "    mean_cape_diff_future_urban_future = mean_cape_future_urban - mean_cape_future\n",
    "    \n",
    "    ax = axs[2]\n",
    "    ax.set_extent([-96,-85,26,38])\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 CAPE (J/kg)', loc='left', fontsize=10)\n",
    "    ax.set_title(f'(Urbanization Effect)', loc='right', fontsize=10)\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('CAPE Difference')\n",
    "\n",
    "    # Set the overall title\n",
    "    fig.suptitle(f'Mean CAPE and Differences Between Simulations\\nFrom 2017-06-20 06z to 2017-06-24 06z', 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()"
   ]
  }
 ],
 "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": 5
}