{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from netCDF4 import Dataset\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import matplotlib.colors as Normalize\n",
    "import cartopy.crs as crs\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",
    "import re\n",
    "import warnings\n",
    "import gc\n",
    "\n",
    "import wrf\n",
    "from wrf import (getvar, interplevel, to_np, latlon_coords, get_cartopy,\n",
    "                 cartopy_xlim, cartopy_ylim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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",
    "\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",
    "    array_list = []\n",
    "    for file in file_list:\n",
    "        # Read file\n",
    "        ncfile = netCDF4.Dataset(file, 'r') \n",
    "        # Check if RAINNC is the variable we want\n",
    "        if var_name == 'RAINNC':\n",
    "            # Extract RAINNC variable directly\n",
    "            rainnc_data = ncfile.variables['RAINNC'][:]\n",
    "            times_char_array = ncfile.variables['Times'][:]\n",
    "\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",
    "            rainnc_da = xr.DataArray(\n",
    "                rainnc_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=\"RAINNC\"\n",
    "            )\n",
    "            \n",
    "            \n",
    "            # Convert to xarray Dataset\n",
    "            data = rainnc_da.to_dataset(name=\"RAINNC\")\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",
    "def drop_zero_values(dataset):\n",
    "    \"\"\"\n",
    "    Drops all zero values from the specified data variable in the xarray dataset.\n",
    "\n",
    "    Parameters:\n",
    "    - dataset (xarray.Dataset): The input dataset.\n",
    "\n",
    "    Returns:\n",
    "    - xarray.Dataset: A new dataset with zero values dropped from the specified data variable.\n",
    "    \"\"\"\n",
    "\n",
    "    # Select the data variable\n",
    "    data_var = dataset['RAINNC']\n",
    "\n",
    "    # Mask the values where the data variable is non-zero\n",
    "    non_zero_mask = data_var != 0\n",
    "\n",
    "    # Use the mask to filter the dataset\n",
    "    dataset_filtered = dataset.where(non_zero_mask, drop=True)\n",
    "    \n",
    "    return dataset_filtered\n",
    "\n",
    "def compute_hourly_precipitation(ds):\n",
    "    \"\"\"\n",
    "    Convert the cumulative precipitation (RAINNC) in each dataset to hourly precipitation by \n",
    "    calculating the difference between consecutive timesteps.\n",
    "    \n",
    "    Parameters:\n",
    "        ds_list (list of xarray.Dataset): List of datasets with cumulative precipitation (RAINNC).\n",
    "    \n",
    "    Returns:\n",
    "        List of xarray.Dataset: Datasets with hourly precipitation (RAINNC).\n",
    "    \"\"\"\n",
    "    # Compute the hourly precipitation by taking the difference along the 'Time' dimension\n",
    "    hourly_precip = ds['RAINNC'].diff(dim='Time', label='upper', n=1)\n",
    "    \n",
    "    # Prepend a zero for the first timestep (since there's no previous timestep to subtract from)\n",
    "    hourly_precip = xr.concat([xr.zeros_like(hourly_precip.isel(Time=0)), hourly_precip], dim='Time')\n",
    "    \n",
    "    # Replace the cumulative RAINNC variable with the hourly precipitation\n",
    "    #hourly_ds = ds.copy()\n",
    "    hourly_ds = hourly_precip.to_dataset(name='RAINNC')\n",
    "\n",
    "    #hourly_ds['RAINNC'] = hourly_precip\n",
    "    #hourly_ds = drop_zero_values(hourly_ds)\n",
    "    #print(hourly_ds)\n",
    "\n",
    "    return hourly_ds\n",
    "\n",
    "monlist = ['04','05','06'] # months in the simulation\n",
    "sim_list = ['current','future','future_urban']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\ncurrent_list=[]\\nfuture_list=[]\\nfuture_urban_list=[]\\n\\nfor month in monlist:\\n    for sim in sim_list:\\n        ds = read_in_monthly_data(month, '1hr', sim, 'RAINNC')\\n        ds = compute_hourly_precipitation(ds)\\n        if sim == 'current':\\n            filename = f'/pscratch/sd/d/dbrooks/precip_data/Current/hourly_precip_data_month{month}.nc'\\n            ds.to_netcdf(filename)\\n            current_list.append(ds)\\n        elif sim == 'future':\\n            filename = f'/pscratch/sd/d/dbrooks/precip_data/Future/hourly_precip_data_month{month}.nc'\\n            ds.to_netcdf(filename)\\n            future_list.append(ds)\\n        elif sim == 'future_urban':\\n            filename = f'/pscratch/sd/d/dbrooks/precip_data/Future_urban/hourly_precip_data_month{month}.nc'\\n            ds.to_netcdf(filename)\\n            future_urban_list.append(ds)\\n        else:\\n            print('incorrect input simulation name')\\n        print(sim)\\n    print(month)\\n\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "current_list=[]\n",
    "future_list=[]\n",
    "future_urban_list=[]\n",
    "\n",
    "for month in monlist:\n",
    "    for sim in sim_list:\n",
    "        ds = read_in_monthly_data(month, '1hr', sim, 'RAINNC')\n",
    "        ds = compute_hourly_precipitation(ds)\n",
    "        if sim == 'current':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/precip_data/Current/hourly_precip_data_month{month}.nc'\n",
    "            ds.to_netcdf(filename)\n",
    "            current_list.append(ds)\n",
    "        elif sim == 'future':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/precip_data/Future/hourly_precip_data_month{month}.nc'\n",
    "            ds.to_netcdf(filename)\n",
    "            future_list.append(ds)\n",
    "        elif sim == 'future_urban':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/precip_data/Future_urban/hourly_precip_data_month{month}.nc'\n",
    "            ds.to_netcdf(filename)\n",
    "            future_urban_list.append(ds)\n",
    "        else:\n",
    "            print('incorrect input simulation name')\n",
    "        print(sim)\n",
    "    print(month)\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current\n",
      "future\n",
      "future_urban\n",
      "04\n",
      "current\n",
      "future\n",
      "future_urban\n",
      "05\n",
      "current\n",
      "future\n",
      "future_urban\n",
      "06\n"
     ]
    }
   ],
   "source": [
    "current_list=[]\n",
    "future_list=[]\n",
    "future_urban_list=[]\n",
    "\n",
    "for month in monlist:\n",
    "    for sim in sim_list:\n",
    "        if sim == 'current':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/precip_data/Current/hourly_precip_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            current_list.append(ds)\n",
    "        elif sim == 'future':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/precip_data/Future/hourly_precip_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            future_list.append(ds)\n",
    "        elif sim == 'future_urban':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/precip_data/Future_urban/hourly_precip_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            future_urban_list.append(ds)\n",
    "        else:\n",
    "            print('incorrect input simulation name')\n",
    "        print(sim)\n",
    "    print(month)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# concat along time dimension\n",
    "current_ds = xr.concat(current_list, dim='Time')\n",
    "future_ds = xr.concat(future_list, dim='Time')\n",
    "future_urban_ds = xr.concat(future_urban_list, dim='Time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################### Colormap ###########################################\n",
    "nws_precip_colors = [\n",
    "\"#fdfdfd\",  \n",
    "\"#04e9e7\",  \n",
    "\"#019ff4\", \n",
    "\"#0300f4\",  \n",
    "\"#02fd02\",  \n",
    "\"#01c501\",  \n",
    "\"#008e00\",  \n",
    "\"#fdf802\",  \n",
    "\"#e5bc00\",  \n",
    "\"#fd9500\",  \n",
    "\"#fd0000\",  \n",
    "\"#d40000\",  \n",
    "\"#bc0000\",  \n",
    "#\"#f800fd\",  \n",
    "#\"#9854c6\",  \n",
    "]\n",
    "cmap1 = mcolors.ListedColormap(nws_precip_colors)\n",
    "\n",
    "clevs=[50,100,150,200,300,400,500,600,700,800,1000]\n",
    "#cmap1=matplotlib.colormaps[\"gist_ncar\"]\n",
    "cmap = mcolors.ListedColormap(cmap1(np.linspace(0.1,0.85,len(clevs))))\n",
    "norm = mcolors.BoundaryNorm(clevs, len(clevs))\n",
    "#norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "cmap.set_over(cmap1(np.linspace(0.99,1,1)))\n",
    "cmap.set_under('white')\n",
    "#############################################################################\n",
    "\n",
    "############### Diverging colormap #####################\n",
    "clevs2=[-500,-250,-150,-100,-50,50,100,150,250,500]\n",
    "cmap2=matplotlib.colormaps[\"RdBu_r\"]\n",
    "newcmap = cmap2(np.linspace(0.1,0.9,len(clevs2)))\n",
    "newcmap[4:5]=[1,1,1,1] # set range between -0.1 and 0.1 as white\n",
    "#newcmap[3:4]=cmap2(np.linspace(0.79,0.8,1))\n",
    "cmap3 = mcolors.ListedColormap(newcmap)\n",
    "norm3 = mcolors.BoundaryNorm(clevs2, len(clevs2))\n",
    "\n",
    "cmap3.set_over(cmap2(np.linspace(0.99,1,1)))\n",
    "cmap3.set_under(cmap2(np.linspace(0,0.01,1)))\n",
    "#######################################################\n",
    "\n",
    "def plot_precipitation_3x3(current_ds_list, future_ds_list, future_urban_ds_list):\n",
    "    \"\"\"\n",
    "    Creates a 3x3 subplot where each row represents a simulation type (current, future, future-urban),\n",
    "    and each column represents a month (April, May, June). Each plot shows the total precipitation (RAINNC)\n",
    "    across the domain for the entire month.\n",
    "    \n",
    "    Parameters:\n",
    "        current_ds_list (list of xarray.Dataset): List of datasets for 'Current' simulation for April, May, June.\n",
    "        future_ds_list (list of xarray.Dataset): List of datasets for 'Future' simulation for April, May, June.\n",
    "        future_urban_ds_list (list of xarray.Dataset): List of datasets for 'Future-Urban' simulation for April, May, June.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define the simulation types and corresponding dataset lists\n",
    "    simulations = ['Current', 'Future', 'Future-Urban']\n",
    "    datasets_list = [current_ds_list, future_ds_list, future_urban_ds_list]\n",
    "\n",
    "    # Create a 3x3 subplot\n",
    "    fig, axs = plt.subplots(3, 3, figsize=(20, 15), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Define months\n",
    "    months = ['April', 'May', 'June']  # These correspond to your dataset order\n",
    "\n",
    "    # Iterate over each simulation type and its corresponding dataset list\n",
    "    for row, (simulation, ds_list) in enumerate(zip(simulations, datasets_list)):\n",
    "        # Loop over each month (column)\n",
    "        for col, (month, ds) in enumerate(zip(months, ds_list)):\n",
    "            # Compute the total precipitation across the entire month\n",
    "            # Get the cumulative precipitation at the first and last time steps of the month\n",
    "            precip_first_timestep = ds['RAINNC'].isel(Time=0)  # Cumulative at the start of the month\n",
    "            precip_last_timestep = ds['RAINNC'].isel(Time=-1)  # Cumulative at the end of the month\n",
    "\n",
    "            # Compute the total monthly precipitation by taking the difference\n",
    "            total_precip = precip_last_timestep - precip_first_timestep\n",
    "            # Extract latitude and longitude coordinates\n",
    "            lats = ds['XLAT']\n",
    "            lons = ds['XLONG']\n",
    "\n",
    "            # Select the correct subplot\n",
    "            ax = axs[row, col]\n",
    "\n",
    "            # Plot the total precipitation\n",
    "            precip_plot = ax.pcolormesh(lons, lats, total_precip, cmap=cmap, norm=norm, transform=crs.PlateCarree())\n",
    "\n",
    "            # Add geographic features\n",
    "            ax.add_feature(cfeature.STATES, edgecolor=\"black\")\n",
    "            ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\")\n",
    "\n",
    "            # Set titles for each subplot\n",
    "            ax.set_title(f'{month}', loc='left')\n",
    "            ax.set_title(f'{simulation}', loc='right')\n",
    "\n",
    "            # Add gridlines and tick marks for latitude and longitude\n",
    "            gl = ax.gridlines(draw_labels=True, crs=crs.PlateCarree(), linewidth=1, color='gray', alpha=0.5, linestyle='--')\n",
    "            gl.top_labels = False  # Disable labels at the top\n",
    "            gl.right_labels = False  # Disable labels on the right\n",
    "            gl.left_labels = True  # Enable labels on the left (latitude)\n",
    "            gl.bottom_labels = True  # Enable labels at the bottom (longitude)\n",
    "\n",
    "            # Customizing the tick label appearance\n",
    "            gl.xlabel_style = {'size': 10}\n",
    "            gl.ylabel_style = {'size': 10}\n",
    "\n",
    "            # Add a colorbar for each plot\n",
    "            cbar = plt.colorbar(precip_plot, ax=ax, orientation='vertical', fraction=0.05, pad=0.04, extend='max', shrink=0.9)\n",
    "            cbar.set_label('mm')\n",
    "            cbar.set_ticks(clevs)\n",
    "\n",
    "    # Set a main title for the entire figure\n",
    "    fig.suptitle('Total Monthly Precipitation Across Different Simulations', fontsize=18)\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",
    "def plot_precipitation_differences(current_ds_list, future_ds_list, future_urban_ds_list):\n",
    "    \"\"\"\n",
    "    Creates a 3x3 subplot where each row represents a simulation comparison (Future vs Current, Future-Urban vs Current, Future-Urban vs Future),\n",
    "    and each column represents a month (April, May, June). Each plot shows the difference in total precipitation between the two simulations.\n",
    "    \n",
    "    Parameters:\n",
    "        current_ds_list (list of xarray.Dataset): List of datasets for 'Current' simulation for April, May, June.\n",
    "        future_ds_list (list of xarray.Dataset): List of datasets for 'Future' simulation for April, May, June.\n",
    "        future_urban_ds_list (list of xarray.Dataset): List of datasets for 'Future-Urban' simulation for April, May, June.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define the comparisons: (simulation_1, simulation_2)\n",
    "    comparisons = [\n",
    "        ('Future', 'Current', future_ds_list, current_ds_list),\n",
    "        ('Future-Urban', 'Current', future_urban_ds_list, current_ds_list),\n",
    "        ('Future-Urban', 'Future', future_urban_ds_list, future_ds_list)\n",
    "    ]\n",
    "\n",
    "    # Create a 3x3 subplot for 3 comparisons and 3 months\n",
    "    fig, axs = plt.subplots(3, 3, figsize=(20, 15), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Define the months\n",
    "    months = ['April', 'May', 'June']  # These correspond to your dataset order\n",
    "\n",
    "    # Iterate over the comparisons\n",
    "    for row, (sim1, sim2, ds_list_1, ds_list_2) in enumerate(comparisons):\n",
    "        # Loop over each month (column)\n",
    "        for col, (month, ds1, ds2) in enumerate(zip(months, ds_list_1, ds_list_2)):\n",
    "            # Compute the total precipitation for each simulation\n",
    "            precip_diff = (\n",
    "                ds1['RAINNC'].isel(Time=-1) - ds1['RAINNC'].isel(Time=0)\n",
    "            ) - (\n",
    "                ds2['RAINNC'].isel(Time=-1) - ds2['RAINNC'].isel(Time=0)\n",
    "            )\n",
    "\n",
    "            # Extract latitude and longitude coordinates (assuming they're the same for all datasets)\n",
    "            lats = ds1['XLAT']\n",
    "            lons = ds1['XLONG']\n",
    "\n",
    "            # Select the correct subplot\n",
    "            ax = axs[row, col]\n",
    "\n",
    "            # Plot the precipitation difference for the current month\n",
    "            diff_plot = ax.pcolormesh(lons, lats, precip_diff, cmap=cmap3, norm=norm3, transform=crs.PlateCarree())\n",
    "\n",
    "            # Add geographic features\n",
    "            ax.add_feature(cfeature.STATES, edgecolor=\"black\")\n",
    "            ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\")\n",
    "\n",
    "            # Add gridlines and tick marks for latitude and longitude\n",
    "            gl = ax.gridlines(draw_labels=True, crs=crs.PlateCarree(), linewidth=1, color='gray', alpha=0.5, linestyle='--')\n",
    "            gl.top_labels = False  # Disable labels at the top\n",
    "            gl.right_labels = False  # Disable labels on the right\n",
    "            gl.left_labels = True  # Enable labels on the left (latitude)\n",
    "            gl.bottom_labels = True  # Enable labels at the bottom (longitude)\n",
    "\n",
    "            # Customizing the tick label appearance\n",
    "            gl.xlabel_style = {'size': 10}\n",
    "            gl.ylabel_style = {'size': 10}\n",
    "\n",
    "            # Set titles for each subplot\n",
    "            ax.set_title(f'{month}', loc='left')\n",
    "            ax.set_title(f'{sim1} minus {sim2}', loc='right')\n",
    "\n",
    "            # Add a colorbar for each plot\n",
    "            cbar = plt.colorbar(diff_plot, ax=ax, orientation='vertical', fraction=0.05, pad=0.04, extend='both', shrink=0.9)\n",
    "            cbar.set_label('mm')\n",
    "            cbar.set_ticks(clevs2)\n",
    "\n",
    "    # Set a main title for the entire figure\n",
    "    fig.suptitle('Monthly Precipitation Differences Between Simulations', fontsize=18)\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_precipitation_3x3(current_list, future_list, future_urban_list)\n",
    "#plot_precipitation_differences(current_list, future_list, future_urban_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n",
      "1\n",
      "1\n",
      "1\n",
      "2\n",
      "2\n",
      "2\n",
      "3\n",
      "3\n",
      "3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1469766/893007240.py:166: UserWarning: Tight layout not applied. The left and right margins cannot be made large enough to accommodate all Axes decorations.\n",
      "  plt.tight_layout(rect=[0.96, 0, 1, 0.96])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_ladder_precip_histogram(current_ds, future_ds, future_urban_ds):\n",
    "    # Step 1: Define the simulations, datasets, and colors\n",
    "    simulations = ['Current', 'Future', 'Future_Urban']\n",
    "    datasets = [current_ds, future_ds, future_urban_ds]\n",
    "    colors = ['black', 'blue', 'orangered']  # Define different colors for each simulation\n",
    "\n",
    "    # Step 2: Define the months (assuming data for April, May, June)\n",
    "    months = [4, 5, 6]\n",
    "    month_labels = ['April', 'May', 'June']\n",
    "    \n",
    "    # Step 3: Define wind speed thresholds (ranges)\n",
    "    thresholds = {\n",
    "        '0.25-2 mm/hr': (0.25, 2),\n",
    "        '2-10 mm/hr': (2, 10),\n",
    "        '10-40 mm/hr': (10, 40),\n",
    "        '40+ mm/hr': (40, np.inf)\n",
    "    }\n",
    "\n",
    "    # Step 4: Prepare the figure with subplots for each threshold\n",
    "    fig, axs = plt.subplots(len(thresholds), 1, figsize=(12, 10), sharex=True)\n",
    "    \n",
    "    # Step 5: Iterate over each threshold (for each subplot row)\n",
    "    for i, (threshold_name, (low, high)) in enumerate(thresholds.items()):\n",
    "        ax = axs[i]  # Select the appropriate subplot axis\n",
    "        bar_width = 0.2  # Width of each bar\n",
    "        month_positions = np.arange(len(months))  # Position of the months on the x-axis\n",
    "\n",
    "        # Step 6: Iterate over each simulation and corresponding dataset\n",
    "        for j, (simulation, ds) in enumerate(zip(simulations, datasets)):\n",
    "            # Extract wind speed data\n",
    "            wind_speed = ds['RAINNC']\n",
    "\n",
    "            # Create a mask for wind speeds in the current threshold range\n",
    "            wind_speed_in_range = wind_speed.where((wind_speed > low) & (wind_speed <= high))\n",
    "\n",
    "            # Group data by month using the 'Time' dimension and count occurrences\n",
    "            monthly_counts = wind_speed_in_range.groupby('Time.month').count(dim=['south_north', 'west_east', 'Time'])\n",
    "\n",
    "            # Extract counts for the specified months (April, May, June)\n",
    "            counts = [monthly_counts.sel(month=month).values for month in months]\n",
    "\n",
    "            # Plot the bars for the current simulation, offsetting each simulation's bars to avoid overlap\n",
    "            ax.bar(month_positions + j * bar_width, counts, bar_width, label=simulation, color=colors[j], zorder=2)\n",
    "\n",
    "        # Step 7: Customize each subplot\n",
    "        ax.set_title(f'Precipitation {threshold_name}', loc='left')\n",
    "        ax.set_yscale('log')  # Set y-axis to logarithmic scale\n",
    "        ax.grid(True, zorder=0)\n",
    "        \n",
    "        # Only show legend in the first subplot\n",
    "        if i == 0:\n",
    "            ax.legend(loc=1)\n",
    "\n",
    "    # Step 8: Customize the common x-axis (shared across all subplots)\n",
    "    axs[-1].set_xticks(month_positions + bar_width)  # Set x-ticks in the middle of grouped bars\n",
    "    axs[-1].set_xticklabels(month_labels)\n",
    "    axs[-1].set_xlabel('Month')\n",
    "\n",
    "    # Step 9: Set a common ylabel\n",
    "    fig.text(0.04, 0.5, 'Occurrences', va='center', rotation='vertical')\n",
    "\n",
    "    # Set the main title for the entire figure\n",
    "    fig.suptitle('Precipitation Frequency by Hourly Intensity and Simulation', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0.96, 0, 1, 0.96])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "def plot_ladder_relative_change(current_ds, future_ds, future_urban_ds):\n",
    "    # Step 1: Define the datasets and comparisons\n",
    "    datasets = {\n",
    "        'Current': current_ds,\n",
    "        'Future': future_ds,\n",
    "        'Future_Urban': future_urban_ds\n",
    "    }\n",
    "\n",
    "    # Define the comparisons: (simulation_1, simulation_2)\n",
    "    comparisons = [\n",
    "        ('Future_Urban', 'Current'),\n",
    "        ('Future', 'Current'),\n",
    "        ('Future_Urban', 'Future')\n",
    "    ]\n",
    "    \n",
    "    # Define the colors for each comparison\n",
    "    colors = ['orangered', 'blue', 'green']\n",
    "\n",
    "    # Step 2: Define the months (assuming data for April, May, June)\n",
    "    months = [4, 5, 6]\n",
    "    month_labels = ['April', 'May', 'June']\n",
    "    \n",
    "    # Step 3: Define wind speed thresholds (ranges)\n",
    "    thresholds = {\n",
    "        '0.25-2 mm/hr': (0.25, 2),\n",
    "        '2-10 mm/hr': (2, 10),\n",
    "        '10-40 mm/hr': (10, 40),\n",
    "        '40+ mm/hr': (40, np.inf)\n",
    "    }\n",
    "\n",
    "    # Step 4: Prepare the figure with subplots for each threshold\n",
    "    fig, axs = plt.subplots(len(thresholds), 1, figsize=(12, 10), sharex=True)\n",
    "\n",
    "    # Step 5: Iterate over each threshold (for each subplot row)\n",
    "    for i, (threshold_name, (low, high)) in enumerate(thresholds.items()):\n",
    "        ax = axs[i]  # Select the appropriate subplot axis\n",
    "        bar_width = 0.2  # Width of each bar\n",
    "        month_positions = np.arange(len(months))  # Position of the months on the x-axis\n",
    "\n",
    "        # Step 6: Create a list to store percentage changes for each comparison\n",
    "        change_list = []\n",
    "\n",
    "        # Step 7: Iterate over each comparison and calculate the percentage change\n",
    "        for j, (sim1, sim2) in enumerate(comparisons):\n",
    "            # Extract wind speed data for both simulations\n",
    "            precip_1 = datasets[sim1]['RAINNC']\n",
    "            precip_2 = datasets[sim2]['RAINNC']\n",
    "\n",
    "            # Create masks for wind speeds within the current threshold range for both datasets\n",
    "            precip_1_in_range = precip_1.where((precip_1 > low) & (precip_1 <= high))\n",
    "            precip_2_in_range = precip_2.where((precip_2 > low) & (precip_2 <= high))\n",
    "\n",
    "            # Group data by month using the 'Time' dimension and count occurrences for both datasets\n",
    "            monthly_counts_1 = precip_1_in_range.groupby('Time.month').count(dim=['south_north', 'west_east', 'Time'])\n",
    "            monthly_counts_2 = precip_2_in_range.groupby('Time.month').count(dim=['south_north', 'west_east', 'Time'])\n",
    "\n",
    "            # Calculate the percentage change between the two simulations\n",
    "            percentage_change = ((monthly_counts_1 / monthly_counts_2) - 1) * 100\n",
    "\n",
    "            # Extract the percentage changes for the specified months (April, May, June)\n",
    "            changes = [percentage_change.sel(month=month).values for month in months]\n",
    "            change_list.append(changes)\n",
    "\n",
    "            # Ensures that the future_urban vs future bars is the difference between the percentages from the other two bars\n",
    "            if sim2 == 'Future':\n",
    "                for p, (sim1, sim2) in enumerate(comparisons):\n",
    "                    changes[p] = change_list[0][p] - change_list[1][p]\n",
    "\n",
    "            # Plot the bars for the current comparison, offsetting each comparison's bars to avoid overlap\n",
    "            ax.bar(month_positions + j * bar_width, changes, bar_width, label=f'{sim1} vs {sim2}', color=colors[j], zorder=2)\n",
    "\n",
    "            # Step 7: Free up memory by deleting large variables\n",
    "            del precip_1, precip_2, precip_1_in_range, precip_2_in_range, monthly_counts_1, monthly_counts_2, percentage_change, changes\n",
    "            gc.collect()  # Force garbage collection to free up memory\n",
    "\n",
    "            print(i)\n",
    "        # Step 8: Customize each subplot\n",
    "        ax.set_title(f'Precipitation {threshold_name}', loc='left')\n",
    "        ax.grid(True, zorder=0)\n",
    "        # Only show legend in the first subplot\n",
    "        if i == 0:\n",
    "            ax.legend(loc=0)\n",
    "\n",
    "    # Step 9: Customize the common x-axis (shared across all subplots)\n",
    "    axs[-1].set_xticks(month_positions + bar_width)  # Set x-ticks in the middle of grouped bars\n",
    "    axs[-1].set_xticklabels(month_labels)\n",
    "    axs[-1].set_xlabel('Month')\n",
    "\n",
    "    # Step 10: Set a common ylabel\n",
    "    fig.text(0.04, 0.5, 'Relative Change (%)', va='center', rotation='vertical')\n",
    "\n",
    "    # Set the main title for the entire figure\n",
    "    fig.suptitle('Relative Change in Precipitation Intensity by Simulation', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0.96, 0, 1, 0.96])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_ladder_precip_histogram(current_ds, future_ds, future_urban_ds)\n",
    "#plot_ladder_relative_change(current_ds, future_ds, future_urban_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1469766/2067435112.py:81: RuntimeWarning: divide by zero encountered in divide\n",
      "  return ((future / current) - 1) * 100\n",
      "/tmp/ipykernel_1469766/2067435112.py:81: RuntimeWarning: invalid value encountered in divide\n",
      "  return ((future / current) - 1) * 100\n",
      "/tmp/ipykernel_1469766/2067435112.py:85: RuntimeWarning: divide by zero encountered in divide\n",
      "  f = ((future / current) - 1) * 100\n",
      "/tmp/ipykernel_1469766/2067435112.py:85: RuntimeWarning: invalid value encountered in divide\n",
      "  f = ((future / current) - 1) * 100\n",
      "/tmp/ipykernel_1469766/2067435112.py:86: RuntimeWarning: divide by zero encountered in divide\n",
      "  fu = ((future_urban / current) - 1) * 100\n",
      "/tmp/ipykernel_1469766/2067435112.py:86: RuntimeWarning: invalid value encountered in divide\n",
      "  fu = ((future_urban / current) - 1) * 100\n",
      "/tmp/ipykernel_1469766/2067435112.py:87: RuntimeWarning: invalid value encountered in subtract\n",
      "  urban_effect = fu - f\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "precip_threshold1=40\n",
    "precip_threshold2=1000\n",
    "#################################### Time series of precip intensity freq #################################\n",
    "\n",
    "def plot_precip_timeseries_all(current_ds, future_ds, future_urban_ds, precip_threshold1, precip_threshold2):\n",
    "    # Helper function to calculate daily precipitation occurrences\n",
    "    def calculate_daily_counts(ds, precip_threshold1, precip_threshold2):\n",
    "        precip = ds['RAINNC']\n",
    "\n",
    "        # Find where precip exceeds threshold\n",
    "        precip_greater_than = precip.where((precip >= precip_threshold1) & (precip < precip_threshold2), drop=False)\n",
    "\n",
    "        # Group by day\n",
    "        grouped_by_day = precip_greater_than.groupby(precip_greater_than['Time'].dt.floor('D'))\n",
    "\n",
    "        # Sum occurrences of precip\n",
    "        daily_counts = grouped_by_day.count(dim=['south_north', 'west_east'])\n",
    "\n",
    "        return daily_counts\n",
    "\n",
    "    # Step 1: Calculate daily counts for all three simulations\n",
    "    daily_counts_current = calculate_daily_counts(current_ds, precip_threshold1, precip_threshold2)\n",
    "    daily_counts_future = calculate_daily_counts(future_ds, precip_threshold1, precip_threshold2)\n",
    "    daily_counts_future_urban = calculate_daily_counts(future_urban_ds, precip_threshold1, precip_threshold2)\n",
    "\n",
    "    # Step 2: Extract the time values (assuming all simulations have the same time dimension)\n",
    "    time_values = daily_counts_current['Time'].values\n",
    "\n",
    "    # Step 3: Calculate relative change for the second y-axis\n",
    "    def calculate_relative_change(future, current):\n",
    "        # Avoid division by zero and only compute where the current values are non-zero\n",
    "        return ((future / current) - 1) * 100\n",
    "    \n",
    "    def calculate_relative_change_urbanization(future, current, future_urban):\n",
    "        # Avoid division by zero and only compute where the current values are non-zero\n",
    "        f = ((future / current) - 1) * 100\n",
    "        fu = ((future_urban / current) - 1) * 100\n",
    "        urban_effect = fu - f\n",
    "        return urban_effect\n",
    "\n",
    "    # Calculate the relative changes for each comparison\n",
    "    relative_change_future_vs_current = calculate_relative_change(daily_counts_future.values, daily_counts_current.values)\n",
    "    relative_change_future_urban_vs_current = calculate_relative_change(daily_counts_future_urban.values, daily_counts_current.values)\n",
    "    relative_change_future_urban_vs_future = calculate_relative_change_urbanization(daily_counts_future.values, daily_counts_current.values, daily_counts_future_urban.values)\n",
    "\n",
    "    # Step 4: Plot the time series on the primary y-axis (occurrences)\n",
    "    fig, ax1 = plt.subplots(figsize=(16, 8))\n",
    "\n",
    "    # Plot the occurrences on the primary y-axis\n",
    "    ax1.plot(time_values, daily_counts_current.values, color='black', label='Current')\n",
    "    ax1.plot(time_values, daily_counts_future.values, color='red', label='Future', linestyle='dashed')\n",
    "    ax1.plot(time_values, daily_counts_future_urban.values, color='blue', label='Future-Urban', linestyle='dashed')\n",
    "\n",
    "    # Customize the primary y-axis\n",
    "    ax1.set_xlabel('Date')\n",
    "    ax1.set_ylabel('Number of Occurrences')\n",
    "    ax1.set_title(f'Occurrences of Hourly Precipitation {precip_threshold1}+ mm (All Simulations)')\n",
    "    ax1.grid(True)\n",
    "    ax1.legend(loc='upper left')\n",
    "\n",
    "    # Step 5: Create the secondary y-axis for relative change\n",
    "    ax2 = ax1.twinx()  # Create a second y-axis that shares the same x-axis\n",
    "\n",
    "    # Plot the relative changes on the secondary y-axis\n",
    "    #ax2.plot(time_values, relative_change_future_vs_current, color='blue', label='Future vs Current', linestyle='solid')\n",
    "    #ax2.plot(time_values, relative_change_future_urban_vs_current, color='orangered', label='Future-Urban vs Current', linestyle='solid')\n",
    "    ax2.plot(time_values, relative_change_future_urban_vs_future, color='green', label='Future-Urban vs Future', linestyle='solid')\n",
    "\n",
    "    # Customize the secondary y-axis\n",
    "    ax2.set_ylabel('Relative Change (%)')\n",
    "    ax2.set_ylim(-30000,30000)\n",
    "    ax2.legend(loc='upper right')\n",
    "\n",
    "    # Rotate x-axis labels for readability\n",
    "    plt.xticks(rotation=45, ha='right')\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout()\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "# Example usage (replace with actual datasets and thresholds)\n",
    "plot_precip_timeseries_all(current_ds, future_ds, future_urban_ds, 10, 1000)\n"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}