{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3a194b38",
   "metadata": {},
   "outputs": [],
   "source": [
    "from netCDF4 import Dataset\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import matplotlib.colors as Normalize\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.feature as cfeature\n",
    "from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter\n",
    "import matplotlib.ticker as mticker\n",
    "import matplotlib\n",
    "import xarray as xr\n",
    "import netCDF4\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import glob\n",
    "import dask\n",
    "import os\n",
    "from matplotlib.colors import LinearSegmentedColormap, TwoSlopeNorm\n",
    "\n",
    "import wrf\n",
    "from wrf import (getvar, vinterp, interplevel, to_np, latlon_coords, get_cartopy,\n",
    "                 cartopy_xlim, cartopy_ylim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "75bd6e34",
   "metadata": {},
   "outputs": [],
   "source": [
    "monlist = ['06'] # months in the simulation\n",
    "sim_list = ['current','future','future_urban']\n",
    "top_thresh = '1e-6'\n",
    "''''\n",
    "filename1 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/current/cloud_base_hgt_month{monlist[0]}.nc'\n",
    "filename2 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future/cloud_base_hgt_month{monlist[0]}.nc'\n",
    "filename3 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future_urban/cloud_base_hgt_month{monlist[0]}.nc'\n",
    "\n",
    "c_cloud_base_ds = xr.open_dataset(filename1)\n",
    "f_cloud_base_ds = xr.open_dataset(filename2)\n",
    "fu_cloud_base_ds = xr.open_dataset(filename3)\n",
    "\n",
    "filename1 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/current/melting_level_hgt_month{monlist[0]}.nc'\n",
    "filename2 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future/melting_level_hgt_month{monlist[0]}.nc'\n",
    "filename3 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future_urban/melting_level_hgt_month{monlist[0]}.nc'\n",
    "\n",
    "c_ml_hgt = xr.open_dataset(filename1)\n",
    "f_ml_hgt = xr.open_dataset(filename2)\n",
    "fu_ml_hgt = xr.open_dataset(filename3)\n",
    "'''\n",
    "filename1 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/current/cloud_top_height_{top_thresh}_month{monlist[0]}.nc'\n",
    "filename2 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future/cloud_top_height_{top_thresh}_month{monlist[0]}.nc'\n",
    "filename3 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future_urban/cloud_top_height_{top_thresh}_month{monlist[0]}.nc'\n",
    "\n",
    "c_cloud_top_ds = xr.open_dataset(filename1)\n",
    "f_cloud_top_ds = xr.open_dataset(filename2)\n",
    "fu_cloud_top_ds = xr.open_dataset(filename3)\n",
    "\n",
    "#filename1 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/current/cloudtoptemp_month{monlist[0]}.nc' # these are derrived from wrf-python\n",
    "#filename2 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future/cloudtoptemp_month{monlist[0]}.nc'\n",
    "#filename3 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future_urban/cloudtoptemp_month{monlist[0]}.nc'\n",
    "\n",
    "filename1 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/current/cloud_height_{top_thresh}_temp_month{monlist[0]}.nc' # these were manually interpolated \n",
    "filename2 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future/cloud_height_{top_thresh}_temp_month{monlist[0]}.nc'\n",
    "filename3 = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future_urban/cloud_height_{top_thresh}_temp_month{monlist[0]}.nc'\n",
    "\n",
    "c_ctt_ds = xr.open_dataarray(filename1)\n",
    "f_ctt_ds = xr.open_dataarray(filename2)\n",
    "fu_ctt_ds = xr.open_dataarray(filename3)\n",
    "\n",
    "def load_in_mask(sim, month):\n",
    "    filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/{sim}/convective_core_mask_withtimes_month{month}.nc'\n",
    "    #filename = f'/home/dbrooks/wind_analysis/radar_data/{sim}/composite_ref_month{month}.nc'\n",
    "    #print(ds)\n",
    "    ds = xr.open_dataarray(filename)\n",
    "    #ds = ds['__xarray_dataarray_variable__']\n",
    "    #print(ds)\n",
    "    #ds = ds['mdbz'] > 5 \n",
    "    return ds\n",
    "\n",
    "current_mask = load_in_mask(sim_list[0],monlist[0])\n",
    "future_mask = load_in_mask(sim_list[1],monlist[0])\n",
    "future_urban_mask = load_in_mask(sim_list[2],monlist[0])\n",
    "'''\n",
    "c_cloud_base_ds = xr.where(current_mask, c_cloud_base_ds, float(\"nan\"))\n",
    "c_cloud_base_ds = xr.where(future_mask, f_cloud_base_ds, float(\"nan\"))\n",
    "fu_cloud_base_ds = xr.where(future_urban_mask, fu_cloud_base_ds, float(\"nan\"))\n",
    "\n",
    "c_ml_hgt = xr.where(current_mask, c_ml_hgt, float(\"nan\"))\n",
    "f_ml_hgt = xr.where(future_mask, f_ml_hgt, float(\"nan\"))\n",
    "fu_ml_hgt = xr.where(future_urban_mask, fu_ml_hgt, float(\"nan\"))\n",
    "'''\n",
    "c_cloud_top_ds = xr.where(current_mask, c_cloud_top_ds, float(\"nan\"))\n",
    "f_cloud_top_ds = xr.where(future_mask, f_cloud_top_ds, float(\"nan\"))\n",
    "fu_cloud_top_ds = xr.where(future_urban_mask, fu_cloud_top_ds, float(\"nan\"))\n",
    "\n",
    "c_ctt_ds = xr.where(current_mask, c_ctt_ds, float(\"nan\"))\n",
    "f_ctt_ds = xr.where(future_mask, c_ctt_ds, float(\"nan\"))\n",
    "fu_ctt_ds = xr.where(future_urban_mask, c_ctt_ds, float(\"nan\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "eee567ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray ()> Size: 8B\n",
      "array(-71.81324005)\n"
     ]
    }
   ],
   "source": [
    "print(f_ctt_ds.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "f9980fb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#c_ctt_ds = c_ctt_ds-273.15\n",
    "#f_ctt_ds= f_ctt_ds-273.15\n",
    "#fu_ctt_ds = fu_ctt_ds-273.15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2a488399",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset> Size: 1GB\n",
      "Dimensions:              (Time: 240, south_north: 1080, west_east: 1210)\n",
      "Coordinates:\n",
      "    XLONG                (south_north, west_east) float32 5MB -109.5 ... -82.01\n",
      "    XLAT                 (south_north, west_east) float32 5MB 26.33 ... 45.51\n",
      "  * Time                 (Time) datetime64[ns] 2kB 2017-06-01 ... 2017-06-30T...\n",
      "Dimensions without coordinates: south_north, west_east\n",
      "Data variables:\n",
      "    cloud_top_height_km  (Time, south_north, west_east) float32 1GB nan ... nan\n"
     ]
    }
   ],
   "source": [
    "print(c_cloud_top_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c7b2a7d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray ()> Size: 8B\n",
      "array(5.56431295)\n",
      "<xarray.DataArray ()> Size: 8B\n",
      "array(2.33626356)\n",
      "<xarray.DataArray ()> Size: 8B\n",
      "array(2.04468629)\n"
     ]
    }
   ],
   "source": [
    "ct = c_ctt_ds.where((c_ctt_ds >= -38) & (c_ctt_ds <= -4)).count()\n",
    "p_ct =  ct / c_ctt_ds.count() *100\n",
    "print(p_ct)\n",
    "\n",
    "ft = f_ctt_ds.where((f_ctt_ds >= -38) & (f_ctt_ds <= -4)).count()\n",
    "p_ft =  ft / f_ctt_ds.count() *100\n",
    "print(p_ft)\n",
    "\n",
    "fut = fu_ctt_ds.where((fu_ctt_ds >= -38) & (fu_ctt_ds <= -4)).count()\n",
    "p_fut =  fut / fu_ctt_ds.count() *100\n",
    "print(p_fut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "45fb3958",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray ()> Size: 8B\n",
      "array(-58.01344059)\n",
      "<xarray.DataArray ()> Size: 8B\n",
      "array(-5.24013074)\n"
     ]
    }
   ],
   "source": [
    "print(((p_ft / p_ct) - 1) *100)\n",
    "\n",
    "f = ((p_ft / p_ct) - 1) * 100\n",
    "fu = ((p_fut / p_ct) - 1) * 100\n",
    "print(fu-f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "c2bebda8",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def extract_temp_at_cloud_top(cloud_top_height_km, climate_state, month):\n",
    "    \"\"\"\n",
    "    Extract temperature at cloud top height for each time step from WRF outputs.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    cloud_top_height_km : xr.DataArray\n",
    "        3D array (Time, south_north, west_east) of cloud top heights in km.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    xr.DataArray\n",
    "        Temperatures (degC) at cloud top heights with same shape as cloud_top_height_km.\n",
    "    \"\"\"\n",
    "    file_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/3hr/wrfout_d01_2017-{month}*'\n",
    "    #file_path = f'/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/{climate_state}/3hr/wrfout_d01_2017-04-29_21:00:00'\n",
    "\n",
    "    \n",
    "    wrf_files = sorted(glob.glob(file_path))\n",
    "\n",
    "    times, ny, nx = cloud_top_height_km['cloud_top_height_km'].shape\n",
    "    temp_data = np.full((times, ny, nx), np.nan, dtype=np.float32)\n",
    "\n",
    "    mask = load_in_mask(climate_state,month)\n",
    "\n",
    "    for t_idx, wrf_file in enumerate(wrf_files):\n",
    "        with Dataset(wrf_file) as nc:\n",
    "            print(wrf_file)\n",
    "            temp_3d = getvar(nc, \"temp\", units=\"degC\")  # (nz, ny, nx)\n",
    "            time = temp_3d.Time.values\n",
    "            #print(time, type(time))\n",
    "            z_3d = getvar(nc, \"z\", units=\"km\")          # (nz, ny, nx)\n",
    "\n",
    "            # Cloud top heights for this time slice\n",
    "            cth_slice = cloud_top_height_km['cloud_top_height_km'].sel(Time=time).data  # (ny, nx)\n",
    "\n",
    "            # Find nearest vertical index at each (y,x)\n",
    "            idx_k = np.abs(z_3d.data - cth_slice[None, :, :]).argmin(axis=0)  # (ny, nx)\n",
    "\n",
    "            # Gather temps at those indices using take_along_axis\n",
    "            temp_slice = np.take_along_axis(\n",
    "                temp_3d.data, idx_k[None, :, :], axis=0\n",
    "            )[0]  # remove vertical axis after gather\n",
    "\n",
    "            temp_data[t_idx] = temp_slice\n",
    "\n",
    "    # Build DataArray\n",
    "    temp_da = xr.DataArray(\n",
    "        temp_data,\n",
    "        coords=cloud_top_height_km.coords,\n",
    "        dims=cloud_top_height_km.dims,\n",
    "        name=\"temp_at_cloud_top_degC\",\n",
    "        attrs={\"units\": \"degC\", \"description\": \"Temperature at cloud top height\"}\n",
    "    )\n",
    "\n",
    "    temp_da = xr.where(mask, temp_da, float(\"nan\"))\n",
    "\n",
    "    return temp_da\n",
    "\n",
    "#temp_da = extract_temp_at_cloud_top(c_cloud_top_ds, sim_list[0], monlist[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "f92c4047",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create the figure\n",
    "lats = c_cloud_top_ds.XLAT\n",
    "lons = c_cloud_top_ds.XLONG\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 6), subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "\n",
    "#cb = ax.pcolormesh(lons, lats, c_cloud_top_ds['cloud_top_height_km'][231,:,:], cmap='jet')\n",
    "cb = ax.pcolormesh(lons, lats, c_ctt_ds[231,:,:], cmap='jet', vmin=-38,vmax=-4)\n",
    "\n",
    "#contour = ax.contour(lons, lats, current_mask[0,:,:], levels=[0], colors=\"yellow\", linewidths=1.5)\n",
    "#contour = ax.contour(lons, lats, c_filtered_labeled_results[231], levels=[0], colors=\"purple\", linewidths=1)\n",
    "#contour = ax.contour(lons, lats, c_cw_mask['conv_wind_mask'][231,:,:], levels=[0], colors=\"orange\", linewidths=1.5)\n",
    "\n",
    "#contour = ax.contour(lons, lats, f_cpi_ds['CPI'].max(dim='Time'), levels=[0], colors=\"purple\", linewidths=1.5, label='Wind Mask')\n",
    "\n",
    "#winds = c_winds_ds['wspd_wdir10'].sel(wspd_wdir='wspd')\n",
    "\n",
    "#contour = ax.contour(lons, lats, winds[231,:,:], levels=[0,1], colors=\"limegreen\", linewidths=1.5)\n",
    "#cb = ax.pcolormesh(lons, lats, winds[231,:,:], cmap='coolwarm')\n",
    "\n",
    "#ax.set_extent([lons.max(), lats.max()*0.8, lons.min()*0.6, lats.min()])\n",
    "\n",
    "# Add labels and title\n",
    "ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "#ax.set_title(f\"Time: {ds2.Time.values}\")\n",
    "ax.set_xlabel(\"Longitude\")\n",
    "ax.set_ylabel(\"Latitude\")\n",
    "cbar = plt.colorbar(cb, ax=ax, orientation='vertical', fraction=0.05, pad=0.02, shrink=0.9, extend='both')\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "c9d0f1ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done bootstrapping\n",
      "done bootstrapping\n",
      "done bootstrapping\n",
      "99.99974\n",
      "99.999855\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import gaussian_kde\n",
    "\n",
    "\n",
    "def plot_param_pdf(c_ds, f_ds, fu_ds, var, threshold, max_bin, iters, bin_width=0.25):\n",
    "    \"\"\"\n",
    "    Plots the smoothed PDF of a variable from three simulations with mean in legend,\n",
    "    using a 3-bin rolling average and scaling frequency to 0–100%.\n",
    "    \"\"\"\n",
    "    \n",
    "    def preprocess(dataarray):\n",
    "        \"\"\"Flatten, clean, and clip data.\"\"\"\n",
    "        arr = dataarray.values.astype(np.float32).flatten()\n",
    "        arr = arr[~np.isnan(arr)]\n",
    "        #if max_bin is not None:\n",
    "        #    arr = np.clip(arr, None, max_bin)\n",
    "        return arr\n",
    "\n",
    "\n",
    "    def bootstrap_from_kde(data, bins, iters=1000, size=100_000):\n",
    "        kde = gaussian_kde(data)\n",
    "        resampled = kde.resample(iters * size).reshape(iters, size)\n",
    "\n",
    "        counts = np.zeros((iters, len(bins)), dtype=np.float32)\n",
    "\n",
    "        for i in range(iters):\n",
    "            sample = resampled[i]\n",
    "            # Don't filter; let values > bins[-1] fall into last bin via clip\n",
    "            indices = np.digitize(sample, bins, right=False) - 1\n",
    "            indices = np.clip(indices, 0, len(bins) - 1)\n",
    "\n",
    "            counts[i, :] = np.bincount(indices, minlength=len(bins))\n",
    "\n",
    "        freqs = (counts / counts.sum(axis=1, keepdims=True)) * 100\n",
    "        avg_freq = np.nanmean(freqs, axis=0)\n",
    "        avg_freq = avg_freq[1:-1] # removes the last index\n",
    "\n",
    "        print('done bootstrapping')\n",
    "        window=3\n",
    "        #return pd.Series(avg_freq).rolling(window, center=True).mean().to_numpy()\n",
    "        return avg_freq\n",
    "\n",
    "\n",
    "    if var == None:\n",
    "        # Preprocess each dataset\n",
    "        c_filtered = preprocess(c_ds.where(c_ds >= threshold))\n",
    "        f_filtered = preprocess(f_ds.where(f_ds >= threshold))\n",
    "        fu_filtered = preprocess(fu_ds.where(fu_ds >= threshold))\n",
    "    else:\n",
    "        # Preprocess each dataset\n",
    "        c_filtered = preprocess(c_ds[var].where((c_ds[var] >= threshold) & (c_ds[var] <= max_bin)))\n",
    "        f_filtered = preprocess(f_ds[var].where((f_ds[var] >= threshold) & (f_ds[var] <= max_bin)))\n",
    "        fu_filtered = preprocess(fu_ds[var].where((fu_ds[var] >= threshold) & (fu_ds[var] <= max_bin)))\n",
    "\n",
    "    # Shared bin range for all datasets\n",
    "    #min_val = min(c_filtered.min(), f_filtered.min(), fu_filtered.min())\n",
    "    min_val = threshold\n",
    "    effective_max = max_bin if max_bin is not None else max(c_filtered.max(), f_filtered.max()) #,fu_filtered.max())\n",
    "    bins = np.arange(min_val, effective_max + bin_width, bin_width)\n",
    "\n",
    "    # With this:\n",
    "    c_kde = bootstrap_from_kde(c_filtered, bins, iters=iters, size=100_000)\n",
    "    f_kde = bootstrap_from_kde(f_filtered, bins, iters=iters, size=100_000)\n",
    "    fu_kde = bootstrap_from_kde(fu_filtered, bins, iters=iters, size=100_000)\n",
    "\n",
    "    bins = bins[1:-1] # removes the last index\n",
    "\n",
    "    # Means\n",
    "    c_mean = np.mean(c_filtered)\n",
    "    f_mean = np.mean(f_filtered)\n",
    "    fu_mean = np.mean(fu_filtered)\n",
    "\n",
    "    print(c_kde.sum())\n",
    "    print(f_kde.sum())\n",
    "    #print(c_kde)\n",
    "\n",
    "    # Plot\n",
    "    plt.figure(figsize=(4, 3))\n",
    "    plt.plot(bins, c_kde, label=f\"C (Mean: {c_mean:.2f})\", color=\"black\", linewidth=2)\n",
    "    plt.plot(bins, f_kde, label=f\"F (Mean: {f_mean:.2f})\", color=\"#1E88E5\", linewidth=2)\n",
    "    plt.plot(bins, fu_kde, label=f\"F+U (Mean: {fu_mean:.2f})\", color=\"#D81B60\", linewidth=2)\n",
    "\n",
    "    #plt.axvline(x=-4, color='blue',linestyle='--', linewidth=1)\n",
    "    #plt.axvline(x=-38, color='blue',linestyle='--', linewidth=1)\n",
    "\n",
    "    # Labels\n",
    "    label_dict = {\n",
    "        'cloud_base_height_km': ('Cloud Base Height', '(km)'),\n",
    "        'cloud_top_height_km': ('Cloud Top Height', '(km)'),\n",
    "        'ctt': ('Cloud Top Temp', '(C)')\n",
    "    }\n",
    "    var='ctt'\n",
    "    title, units = label_dict.get(var, (var, ''))\n",
    "\n",
    "    # Month detection (you likely set monlist earlier)\n",
    "    try:\n",
    "        month = {'04': 'April', '05': 'May', '06': 'June'}.get(monlist[0], '')\n",
    "    except:\n",
    "        month = ''\n",
    "\n",
    "\n",
    "    plt.title(f\"{title} ({month})\")\n",
    "    #plt.title(f\"Cloud Top Height ({month})\")\n",
    "    plt.xlabel(f\"{title} {units}\")\n",
    "    #plt.xlabel(f\"Temperature (C)\")\n",
    "    plt.ylabel(\"Normalized Frequency (%)\")\n",
    "    #plt.gca().invert_xaxis()  # Reverse x-axis\n",
    "    #plt.ylim(0,1.2)\n",
    "    #plt.yscale('log')\n",
    "    #plt.yscale('symlog', linthresh=0.01)\n",
    "    #custom_ticks = [0.001,0.01,0.1,1]\n",
    "    #custom_ticks = [0.1,1]\n",
    "    plt.minorticks_off()\n",
    "    #plt.yticks(custom_ticks)\n",
    "    #plt.legend(fontsize=8, loc='upper right')\n",
    "    plt.legend(fontsize=7.5, loc='upper left')\n",
    "    plt.grid(alpha=0.5, linestyle=':')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "plot_param_pdf(c_cloud_top_ds, f_cloud_top_ds, fu_cloud_top_ds, var='cloud_top_height_km', threshold=5, max_bin=18, iters=1000, bin_width=0.05)\n",
    "#plot_param_pdf(c_ctt_ds, f_ctt_ds, fu_ctt_ds, var=None, threshold=-96, max_bin=0, iters=1000, bin_width=0.25)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myenv",
   "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": 5
}