1-2-check_nan_in_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Checks nans in the streamflow & forcing data\n",
    "Originally written by 2022 SI team\n",
    "- Lauren A. Bolotin; San Diego State University; lbolotin3468@sdsu.edu\n",
    "- Francisco Haces-Garcia; University of Houston; fhacesgarcia@uh.edu\n",
    "- Mochi Liao; Duke University; mochi.liao@duke.edu\n",
    "- Qiyue Liu; University of Illinois at Urbana-Champaign; qiyuel3@illinois.edu\n",
    "\n",
    "Modified by \n",
    "- Ryoko Araki (San Diego State University & UCSB, raraki8159@sdsu.edu) in 2023 SI\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import json\n",
    "from tqdm import tqdm\n",
    "import yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read in config for the file path "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the config file\n",
    "with open('config.yaml', 'r') as f:\n",
    "    config = yaml.safe_load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = config['io_dir']['gauch_2020_dir'].replace(\"${cwd}\", \"..\")\n",
    "obs_dir = config['io_dir']['usgs_streamflow_dir'].replace(\"${cwd}\", \"..\")\n",
    "forcing_path = config['io_dir']['nldas_forcing_dir'].replace(\"${cwd}\", \"..\")\n",
    "time_split_file = config['model_settings']['time_split_file'].replace(\"${cwd}\", \"..\")\n",
    "missing_data_file = config['model_settings']['missing_data_file'].replace(\"${cwd}\", \"..\")\n",
    "missing_data_file_testing = config['model_settings']['missing_data_file_testing'].replace(\"${cwd}\", \"..\")\n",
    "basin_file = config['model_settings']['basin_file'].replace(\"${cwd}\", \"..\")\n",
    "output_dir = data_dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def load_basin_list(basin_file):\n",
    "    with open(basin_file, 'r') as file:\n",
    "        lines = file.readlines()\n",
    "    lines = [line.strip() for line in lines]\n",
    "    return lines\n",
    "\n",
    "def load_csv(file_path):\n",
    "    return pd.read_csv(file_path)\n",
    "\n",
    "def calc_nan_percentages_forcing(forcing_data, fields):\n",
    "    return [len(np.where(np.isnan(forcing_data[field]))[0]) / len(forcing_data[field]) for field in fields]\n",
    "\n",
    "def calc_nan_percentages_obs(obs_data):\n",
    "    return len(np.where(np.isnan(obs_data['QObs(mm/h)'].values))[0]) / len(obs_data['QObs(mm/h)'])\n",
    "\n",
    "def calc_indices(data, datetime):\n",
    "    start_idx = np.where(data['date'] == datetime[\"start_datetime\"])\n",
    "    end_idx = np.where(data['date'] == datetime[\"end_datetime\"])\n",
    "    return start_idx, end_idx\n",
    "\n",
    "def initialize_nan_check():\n",
    "    keys = [\n",
    "            'basin_id', \n",
    "            'spinup-for-calibration - pet', \n",
    "            'spinup-for-calibration - precip', \n",
    "            'spinup-for-testing - pet', \n",
    "            'spinup-for-testing - precip', \n",
    "            'calibration - pet', \n",
    "            'calibration - precip', \n",
    "            'calibration - usgs', \n",
    "            'testing - pet', \n",
    "            'testing - precip', \n",
    "            'testing - usgs'\n",
    "            ]\n",
    "    return {key: [] for key in keys}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get a stats on NaN data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  1.51it/s]\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "def process_data(data_dir, obs_dir, forcing_path, time_split_file, output_dir):\n",
    "    \n",
    "    nan_check = initialize_nan_check()\n",
    "\n",
    "    basin_list = load_basin_list(os.path.join(data_dir, 'basin_list_516.txt'))\n",
    "    time_split = json.load(open(time_split_file, 'r'))\n",
    "\n",
    "    for basin in tqdm(basin_list):\n",
    "        nan_check[f'basin_id'].append(basin)\n",
    "        \n",
    "        obs_data = load_csv(os.path.join(obs_dir, f'{basin}-usgs-hourly.csv'))\n",
    "        forcing_data = load_csv(os.path.join(forcing_path, f'{basin}_hourly_nldas.csv'))\n",
    "\n",
    "        for phase, fields in time_split.items():\n",
    "            \n",
    "            # Forcing \n",
    "            start_idx_forcing, end_idx_forcing = calc_indices(forcing_data, fields)\n",
    "            if start_idx_forcing[0].size == 0 or end_idx_forcing[0].size == 0: \n",
    "                warnings.warn(f\"none or missing forcing data for {phase} period\")\n",
    "                nan_perc = [1, 1]\n",
    "            else:\n",
    "                sliced_forcing_data = forcing_data.iloc[start_idx_forcing[0][0]:end_idx_forcing[0][0]+1,:]\n",
    "                nan_perc = calc_nan_percentages_forcing(sliced_forcing_data, ['potential_evaporation', 'total_precipitation'])\n",
    "            \n",
    "            nan_check[f'{phase} - pet'].append(nan_perc[0])\n",
    "            nan_check[f'{phase} - precip'].append(nan_perc[1])\n",
    "            \n",
    "            if \"spinup\" not in phase:\n",
    "                # Observation\n",
    "                start_idx_obs, end_idx_obs = calc_indices(obs_data, fields)\n",
    "                if start_idx_obs[0].size == 0 or end_idx_obs[0].size == 0: \n",
    "                    warnings.warn(f\"none or missing observation data for {phase} period\")\n",
    "                    nan_perc_obs = 1\n",
    "                else:\n",
    "                    sliced_obs_data = obs_data.iloc[start_idx_obs[0][0]:end_idx_obs[0][0]+1,:]\n",
    "                    nan_perc_obs = calc_nan_percentages_obs(sliced_obs_data)\n",
    "                nan_check[f'{phase} - usgs'].append(nan_perc_obs)\n",
    "\n",
    "    df = pd.DataFrame(nan_check)\n",
    "    df.to_csv(os.path.join(output_dir, \"check_for_nan_in_data_hourly.csv\"))\n",
    "\n",
    "process_data(data_dir, obs_dir, forcing_path, time_split_file, output_dir)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get the list of basins with missing data\n",
    "Set the threshold in the following cell (Currently set as 50%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df is the DataFrame obtained from your code\n",
    "nan_stats = pd.read_csv(os.path.join(output_dir, \"check_for_nan_in_data_hourly.csv\"))\n",
    "nan_stats_calib = nan_stats[['basin_id', 'calibration - usgs']].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "threshold = 0.99 # set the threshold\n",
    "mask = (nan_stats_calib['calibration - usgs'] > threshold)  # filter the DataFrame, ignore the 'basin id' column\n",
    "basin_ids = nan_stats_calib.loc[mask, 'basin_id'].tolist()  # get the 'basin id' of the rows that meet the condition\n",
    "basin_ids\n",
    "print(basin_ids)\n",
    "print(len(basin_ids))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABSHUlEQVR4nO3dd3hUZfr/8c+EdEhogdBCEnoogiZKW75IC0UUCyuK0lHYiAjBAqJSLFgRCwFdwbgWzKpYcBEIIogUKcIqAjaqEBaJdCSkPL8/+GV0mAmZGXIyKe/XdXHpPPOcc+65z5ncc8+cOWMzxhgBAAAAAIAi5+frAAAAAAAAKKtougEAAAAAsAhNNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARmm4AAAAAACxC0w0AAAAAgEVoukuQqVOnymaz6ciRIy7vb9mypa6++mqHsf379yspKUlNmjRRSEiIqlWrplatWumOO+7Q/v37ndbx1Vdf6dZbb1X9+vUVFBSkihUrqkWLFpowYYJ27tzpMNcYo3fffVedOnVSzZo1FRwcrHr16qlnz5567bXXLvnxnjlzRlOnTtXKlSsveV2+tmXLFnXu3FmVK1eWzWbTrFmztHLlStlsthL7+IYOHaqYmBivlk1JSVFqamqRxuOtXbt2acyYMfbnQGhoqFq0aKGHHnpIBw4c8Hh9qampstls2rNnj33MVa5sNpvGjBlzidG75+DBg5o6daq2bt3qdF/+342ybs+ePbLZbEV63Lna10BxoN6XXtT74hUTEyObzVbov6KK8YknntBHH33kNF7S93FRsuJ1xdVXX+30N6288fd1APDer7/+qiuuuEJVqlTRhAkT1LRpUx0/flzbt2/Xv//9b+3atUtRUVH2+Q899JAef/xxtW/fXg899JAaN26snJwcffvtt3rjjTc0c+ZM5eTkqEKFCpKkSZMm6amnntIdd9yh++67T2FhYdq7d69WrFihjz/+WCNHjryk+M+cOaNp06ZJUql/Ig4fPlynT5/Wu+++q6pVqyomJsbpRU1ZkpKSooiICA0dOtSncXz66ae65ZZbFBERoTFjxujyyy+XzWbTd999p/nz5+s///mPtmzZcsnbefjhh3XPPfcUQcTeOXjwoKZNm6aYmBi1adPG4b6RI0eqV69evgmsGNWuXVvr1q1Tw4YNfR0KUOyo9yUH9b54ffjhh8rKyrLffu211zRv3jwtWbJElStXto8XVW144okn1L9/f11//fUO41dccYXWrVun5s2bF8l2SrLy8rqiuNF0l2L//Oc/deTIEW3YsEGxsbH28euvv14PPvig8vLy7GMLFizQ448/rtGjRyslJcXhHawePXooOTlZKSkp9rE//vhDs2bN0uDBg/Xqq686bHfo0KEO6y4uZ86cUWhoaLFv1x3btm3THXfcod69e9vHynIRLgl2796tW265RU2aNNEXX3zhUHy7du2qsWPH6sMPPyySbRV1o/fHH38oODi4SN5JrlevnurVq1cEUZVMubm5ysnJUVBQkNq1a+frcACfoN6XHNT74nX55Zc73F6yZIkkKT4+XhEREcUWR3h4eJmvQfnPu7L+usJXOL28FMvMzJSfn59q1qzp8n4/vz9372OPPaaIiAg9//zzLl/o22w23XXXXfZ3vU+fPq2srCzVrl270HUXZMWKFbr66qtVvXp1hYSEqH79+rrpppt05swZ7dmzRzVq1JAkTZs2zX56UP47qfmntnzzzTfq37+/qlatam98jDFKSUlRmzZtFBISoqpVq6p///7atWuXw/bT09PVr18/1atXT8HBwWrUqJFGjRrldDpf/ra+/fZb/f3vf1flypVVrVo1JScnKycnRz/88IN69eqlsLAwxcTE6Omnn7Yvm396ak5OjubMmWN/HBfzySefqH379goNDVVYWJh69OihdevW2e///vvvZbPZ9N5779nHNm/eLJvNphYtWjis67rrrlN8fHyh+yI1NVVNmzZVUFCQ4uLi9K9//cvlvGnTpqlt27aqVq2awsPDdcUVV2jevHkyxtjnxMTE6Pvvv9eqVavsjzf/tLWzZ89qwoQJatOmjT2P7du318cff1xojJ6aOXOmTp8+rZSUFIeGO5/NZtONN95ov+3u8eDKxU7Ne+WVV9SkSRMFBQWpefPmevfddx3uzz9Gli1bpuHDh6tGjRoKDQ1VVlaWfv75Zw0bNkyNGzdWaGio6tatq2uvvVbfffedffmVK1fqyiuvlCQNGzbMnvOpU6dKcn0aWF5enp5++mk1a9ZMQUFBqlmzpgYPHqxff/3VYd7VV1+tli1bauPGjerUqZNCQ0PVoEEDPfnkk2690M4/xb6wHEjSoUOHNGrUKNWrV0+BgYGKjY3VtGnTlJOTY5+Tfwr5008/rccee0yxsbEKCgrSF198UeDp5V999ZW6deumsLAwhYaGqkOHDvrPf/7jtP3169erY8eOCg4OVp06dTRp0iRlZ2cX+hiBkoB6T70vz/W+MO4eJ1u2bFHfvn1Vs2ZNBQUFqU6dOrrmmmvstdFms+n06dN644037I83/8wMV6eXDx06VJUqVdLPP/+sPn36qFKlSoqKitKECRMcPp2Xzp+t0r9/f4WFhalKlSq67bbbtHHjRrdOjc8/9tLT0zVs2DBVq1ZNFStW1LXXXuv0GCVp+fLl6tatm8LDwxUaGqqOHTvq888/d5hzsefdpbyuMMbo6aefVnR0tIKDg3XFFVfos88+u+jjKzcMSowpU6YYSea3335zeX+LFi1M586d7bffeustI8kkJiaaJUuWmOPHj7tc7sCBA0aSufXWWz2Kp1GjRiYsLMw899xzZseOHSYvL8/tZXfv3m2Cg4NNjx49zEcffWRWrlxp3n77bTNo0CBz9OhRc/bsWbNkyRIjyYwYMcKsW7fOrFu3zvz888/GmD9zER0dbR544AGTnp5uPvroI2OMMXfccYcJCAgwEyZMMEuWLDHvvPOOadasmYmMjDSHDh2yxzBnzhwzY8YM88knn5hVq1aZN954w7Ru3do0bdrUnDt3zj4vf1tNmzY1jz76qElPTzf333+/kWTGjBljmjVrZl588UWTnp5uhg0bZiSZDz74wBhjzOHDh826deuMJNO/f3/74zDGmC+++MJIMl988YV9W2+//bZ9n3300UcmLS3NxMfHm8DAQLN69Wr7vNq1a5s777zTfvvJJ580ISEhRpI5cOCAMcaY7OxsEx4ebu6///6L7ovXX3/dSDL9+vUzixYtMm+99ZZp1KiRiYqKMtHR0Q5zhw4daubNm2fS09NNenq6efTRR01ISIiZNm2afc4333xjGjRoYC6//HL74/3mm2+MMcYcO3bMDB061Lz55ptmxYoVZsmSJebee+81fn5+5o033rj4QeOhJk2amMjISLfnu3s85Odr9+7d9rEhQ4Y45UqSiYqKMs2bNzcLFiwwn3zyienVq5eRZN577z2n9dWtW9fceeed5rPPPjPvv/++ycnJMatWrTITJkww77//vlm1apX58MMPzfXXX29CQkLMzp07jTHGHD9+3L6Ohx56yJ7z/fv3G2P+PH7/6s4777Qfv0uWLDFz5841NWrUMFFRUQ5/Xzp37myqV69uGjdubObOnWvS09NNUlKSkeTW/nI3BxkZGfbj7ZVXXjHLly83jz76qAkKCjJDhw61z9u9e7c9V126dDHvv/++WbZsmdm9e7f9vtdff90+f+XKlSYgIMDEx8ebtLQ089FHH5nExERjs9nMu+++a5/3/fffm9DQUHucH3/8senZs6epX7++074GigP1nnqfj3rvGVfPHXeOk1OnTpnq1aubhIQE8+9//9usWrXKpKWlmdGjR5vt27cbY4xZt26dCQkJMX369LE/3u+//94Y43ofDxkyxAQGBpq4uDjz7LPPmuXLl5tHHnnE2Gw2hzyeOnXKNGrUyFSrVs3Mnj3bLF261IwfP97ExsY61TVX8vdrVFSUGT58uPnss8/Mq6++amrWrGmioqLM0aNH7XPffPNNY7PZzPXXX28WLlxoFi1aZPr27WsqVKhgli9f7pRHV8+7S3ldkb/siBEj7HHWrVvX1KpVy+FvWnlE012CeFqE8/LyzKhRo4yfn5+RZGw2m4mLizPjx493eBG5fv16I8lMnDjRaZ05OTkmOzvb/u+vhXbDhg32F6WSTFhYmOnbt6/517/+VWhBfv/9940ks3Xr1gLn/Pbbb0aSmTJlSoG5eOSRRxzG8wvec8895zC+f/9+ExISUmBBysvLM9nZ2Wbv3r1Gkvn444+dtnXhOtu0aWMkmYULF9rHsrOzTY0aNcyNN97oMFeSueuuuxzGLvwDnZuba+rUqWNatWplcnNz7fNOnjxpatasaTp06GAfu/32202DBg3st7t3727uuOMOU7VqVXsxW7NmjZFkli1b5vIx/3WbV1xxhcM+27NnjwkICHAqwhcum52dbaZPn26qV6/usPyFx2JB8o+vESNGmMsvv7zQ+Z4IDg427dq182rZix0PnjTdISEhDi/8cnJyTLNmzUyjRo2c1jd48OBC48rJyTHnzp0zjRs3NuPHj7ePb9y4scDCfGFx3LFjh5FkkpKSHOZ9/fXXRpJ58MEH7WOdO3c2kszXX3/tMLd58+amZ8+ehcbrbg5GjRplKlWqZPbu3euw/LPPPmsk2V/U5DfWDRs2dHih/Nf7/pqDdu3amZo1a5qTJ086bL9ly5amXr169mN2wIABBcZJ0w1foN4754J6fx71/uIufO64e5xs2rTJSLI3lgWpWLGiGTJkiNN4QU23JPPvf//bYW6fPn1M06ZN7bdnz55tJJnPPvvMYd6oUaM8arpvuOEGh/H84+Kxxx4zxhhz+vRpU61aNXPttdc6zMvNzTWtW7c2V111lX2soOfdX+/L5+7riqNHj5rg4OAC4yzvTTenl5diNptNc+fO1a5du5SSkqJhw4YpOztbzz//vFq0aKFVq1YVuo7q1asrICDA/u+DDz6w33fllVfq559/1pIlS/Tggw+qffv2+vzzzzV48GBdd911DqcgXahNmzYKDAzUnXfeqTfeeMPl6S/uuOmmmxxuf/rpp7LZbLr99tuVk5Nj/1erVi21bt3a4bSfw4cPa/To0YqKipK/v78CAgIUHR0tSdqxY4fTtvr27etwOy4uTjabzeF7W/7+/mrUqJH27t3r8WP54YcfdPDgQQ0aNMjhdL1KlSrppptu0vr163XmzBlJUrdu3bRr1y7t3r1bZ8+e1VdffaVevXqpS5cuSk9Pl3T+9KGgoCD97W9/K3SbAwcOdDhVKDo6Wh06dHCav2LFCnXv3l2VK1dWhQoVFBAQoEceeUSZmZk6fPiwW4/zvffeU8eOHVWpUiV73ufNm+cy539ljHHYp3897bgoeHo8uKNbt26KjIy0365QoYIGDBign3/+2emUqwuPZUnKycnRE088oebNmyswMFD+/v4KDAzUTz/95HVMX3zxhSQ5XfTmqquuUlxcnNMpZrVq1dJVV13lMHbZZZe5fYy7k4NPP/1UXbp0UZ06dRz2b/5z68K/Vdddd50CAgIuut3Tp0/r66+/Vv/+/VWpUiWH7Q8aNEi//vqrfvjhB0nnc1JQnEBpQL2n3lPvXXP3OGnUqJGqVq2qBx54QHPnztX27du93uZf2Ww2XXvttQ5jF9bQVatWKSwszOniZLfeeqtH27rtttscbnfo0EHR0dH2ur927Vr9/vvvGjJkiEMu8vLy1KtXL23cuFGnT592WIer1yYXcvd1xbp163T27NkC4yzvaLpLEH//89e1y83NdXl/Tk6Oyxei0dHR+sc//qF58+bpp59+Ulpams6ePav77rtPkuxXNHVVOFauXKmNGzdq7ty5LrcZEBCgnj176vHHH9fSpUu1f/9+XX311fr0008v+h2Nhg0bavny5apZs6buuusuNWzYUA0bNtQLL7xw8SRc4MLvmP3vf/+TMUaRkZEOLx4CAgK0fv16+/e38vLylJiYqIULF+r+++/X559/rg0bNmj9+vWSzl845kLVqlVzuB0YGKjQ0FAFBwc7jZ89e9ajxyGd/06eq8ckSXXq1FFeXp6OHj0qSerevbuk84X2q6++UnZ2trp27aru3bvb/7gtX75cHTt2VEhISKHbrFWrltN9F45t2LBBiYmJks5ftGfNmjXauHGjJk+eLMl1zi60cOFC3Xzzzapbt67eeustrVu3Ths3btTw4cMLzdkbb7zhtE8vpn79+tq9e3ehMUneHQ/uuFhe83Ofz9V+T05O1sMPP6zrr79eixYt0tdff62NGzeqdevWXsdU2HF2YVzVq1d3mhcUFOT29t3Jwf/+9z8tWrTIaf/mf2fxwu9dFvTd0r86evSojDEFPs6/bj8zM9Ot5wBQXKj3zqj31HtvuHucVK5cWatWrVKbNm304IMPqkWLFqpTp46mTJlySdf3cHXcBAUFOeQgMzPT4U3ffK7GLqagffvXWitJ/fv3d8rFU089JWOMfv/9d4fl3am37r6u8OQYLI+4enkJkv/kO3DggNMT0RijjIwMJSQkFLqem2++WTNmzNC2bdsknX9CtGjRQunp6Tp79qzDH4f8nx86deqUWzFWr15d48aN08qVK7Vt2zb16dOnwLmdOnVSp06dlJubq02bNumll17SuHHjFBkZqVtuucWt7V14IYeIiAjZbDatXr1aQUFBTvPzx7Zt26b//ve/Sk1N1ZAhQ+z3//zzz25t1wr5zU1GRobTfQcPHpSfn5+qVq0q6fwVqZs0aaLly5crJiZGCQkJqlKlirp166akpCR9/fXXWr9+vf0nWArb5qFDh5zuu3Ds3XffVUBAgD799FOHY8TV71UW5K233lJsbKzS0tIc9t2FFxRx5dprr9XGjRvd3lbPnj310ksvaf369YVeUdSq4+Fieb2wmXV1wZ233npLgwcP1hNPPOEwfuTIEVWpUsWrmP56nF149dGDBw8W+dVe3clBRESELrvsMj3++OMu15HfJOdz56ruVatWlZ+fX4HPp/zt5sfhznMAKC7Ue2fUe+q9N9w9TiSpVatWevfdd2WM0bfffqvU1FRNnz5dISEhmjhxYpHE40r16tW1YcMGp3FPa1BB+7ZRo0aS/qx5L730UoGviy78e+NOvXX3dUVhx6C3vxVfVvBJdwnStWtX2Ww2paWlOd23ZMkSnThxwv6OqOT6j7l0vqDu37/f4YXs5MmTdeTIESUnJ1/0NLF82dnZTp+I5cs/bejCF8oFqVChgtq2bavZs2dLkr755htJf/4h9OQTvb59+8oYowMHDighIcHpX6tWrST9+Ufkwj/Ar7zyitvbKmpNmzZV3bp19c477zjsg9OnT+uDDz6wX+E0X/fu3bVixQqlp6erR48ekqQmTZqofv36euSRR5Sdne1wPBS0zdq1a2vBggUO29y7d6/Wrl3rMNdms8nf399+RVvp/L558803ndZb0CehNptNgYGBDn/EDx065NbVTKtXr+60Py9m/PjxqlixopKSknT8+HGn+40x9p8Ms+p4+Pzzz+3vLEvnP7VKS0tTw4YN3fq5DZvN5hTTf/7zHx04cMBhzJPnSteuXSWdf0H0Vxs3btSOHTvUrVu3QtfhCXdy0LdvX23btk0NGzZ0+bx192/JX1WsWFFt27bVwoULHfKSl5ent956y/5CVpK6dOlSYJyAL1DvC0e9p967w93j5MLYW7dureeff15VqlSxH6eSZ2d6uatz5846efKk0xkjrn7p42Lefvtth9tr167V3r177VdY79ixo6pUqaLt27e7zEVCQoICAwM9jt/d1xXt2rVTcHBwgXGWd3zSXYI0bNhQY8aM0TPPPKNjx46pT58+CgkJ0caNG/Xkk08qISFBAwcOtM9//PHHtWbNGg0YMMD+Mwm7d+/Wyy+/rMzMTD3zzDP2ubfeequ+//57Pf744/rvf/+roUOHqnHjxsrLy9P+/fvtf2jDwsIkScePH1dMTIz+/ve/q3v37oqKitKpU6e0cuVKvfDCC4qLi3P4OaYLzZ07VytWrNA111yj+vXr6+zZs5o/f76kP0+lCgsLU3R0tD7++GN169ZN1apVU0RExEXfCevYsaPuvPNODRs2TJs2bdL//d//qWLFisrIyNBXX32lVq1a6R//+IeaNWumhg0bauLEiTLGqFq1alq0aJH9+1G+4Ofnp6efflq33Xab+vbtq1GjRikrK8u+v5988kmH+d26dVNKSoqOHDmiWbNmOYy//vrrqlq1aqE/H+Ln56dHH31UI0eO1A033KA77rhDx44d09SpU51O9bnmmms0c+ZMDRw4UHfeeacyMzP17LPPunznOP/d4rS0NDVo0EDBwcFq1aqV+vbtq4ULFyopKUn9+/fX/v379eijj6p27dr66aefvE+eC7GxsXr33Xftx/+YMWPsv+e5fft2zZ8/X8YY3XDDDZYdDxEREeratasefvhhVaxYUSkpKdq5c6fbhbRv375KTU1Vs2bNdNlll2nz5s165plnnBr2hg0bKiQkRG+//bbi4uJUqVIl1alTx+UL4aZNm+rOO+/USy+9JD8/P/Xu3Vt79uzRww8/rKioKI0fP/6SHvOF3MnB9OnTlZ6erg4dOmjs2LFq2rSpzp49qz179mjx4sWaO3euV78JOmPGDPXo0UNdunTRvffeq8DAQKWkpGjbtm1asGCB/cXgQw89pE8++URdu3bVI488otDQUM2ePdvpu21AcaHeU+//inrvPXePk08//VQpKSm6/vrr1aBBAxljtHDhQh07dsz+Rkf+4125cqUWLVqk2rVrKywsTE2bNr2kGIcMGaLnn39et99+ux577DE1atRIn332mZYuXSrJvZ/lk6RNmzZp5MiR+vvf/679+/dr8uTJqlu3rpKSkiSdv2bASy+9pCFDhuj3339X//79VbNmTf3222/673//q99++01z5szxOH53X1dUrVpV9957rx577DGHOF0dg+VSMV2wDW7Ky8szc+bMMQkJCSY0NNQEBgaaxo0bmwceeMDhCr3GnL9K6V133WVat25tqlWrZipUqGBq1KhhevXqZRYvXuxy/V9++aUZMGCAqVevngkICLD/jM4//vEPs2nTJvu8rKws8+yzz5revXub+vXrm6CgIBMcHGzi4uLM/fffbzIzMy/6ONatW2duuOEGEx0dbYKCgkz16tVN586dzSeffOIwb/ny5ebyyy83QUFBRpL9ipGFXdl1/vz5pm3btqZixYomJCTENGzY0AwePNjhMWzfvt306NHDhIWFmapVq5q///3vZt++fU5XUC1oW0OGDDEVK1Z02nbnzp1NixYtHMbkxtVM83300Uembdu2Jjg42FSsWNF069bNrFmzxmk7R48eNX5+fqZixYoOV3LO/xmSC6+oejGvvfaaady4sQkMDDRNmjQx8+fPd3lF7vnz55umTZuaoKAg06BBAzNjxgwzb948pys879mzxyQmJpqwsDD7T07ke/LJJ01MTIwJCgoycXFx5p///KfLn58oKr/88otJSkoyjRo1MkFBQSYkJMQ0b97cJCcnO8Ts7vHgydXL77rrLpOSkmIaNmxoAgICTLNmzczbb7/tMC9/fRs3bnSK/ejRo2bEiBGmZs2aJjQ01Pztb38zq1evNp07d3a6yueCBQtMs2bNTEBAgEPMrnKbm5trnnrqKdOkSRMTEBBgIiIizO23327/mbF8ro7lgh6vK+7mwJjzVy8eO3asiY2NNQEBAaZatWomPj7eTJ482Zw6dcoY8+cVyp955hmn5V1dvdwYY1avXm26du1q/1vQrl07s2jRIqfl16xZY9q1a2eCgoJMrVq1zH333WdeffVVrl4On6HeDzHGUO+Nod57oqB9WNhxsnPnTnPrrbeahg0bmpCQEFO5cmVz1VVXmdTUVIf1bN261XTs2NGEhoY6XHG7oKuXuzpuXOVg37595sYbbzSVKlUyYWFh5qabbjKLFy92usK+K/mvI5YtW2YGDRpkqlSpYv9ps59++slp/qpVq8w111xjqlWrZgICAkzdunXNNddc4/BTnhd73l3K64q8vDwzY8YMExUVZQIDA81ll11mFi1a5PJ1TXljM8aNc48AALiAzWbTXXfdpZdfftnXoQAAUKo88cQTeuihh7Rv376Lnu2VmpqqYcOGaePGjZd0Kj58i9PLAQAAAMAi+W9ON2vWTNnZ2VqxYoVefPFF3X777V59vQqlD003AAAAAFgkNDRUzz//vPbs2aOsrCzVr19fDzzwgB566CFfh4ZiwunlAAAAAABYhJ8MAwAAAADAIjTdAAAAAABYhKYbAAAAAACLlLsLqeXl5engwYMKCwuTzWbzdTgAADgxxujkyZOqU6eO/PzK7/vj1GwAQEnmbr0ud033wYMHFRUV5eswAAAo1P79+8v1z8lQswEApUFh9brcNd1hYWGSzicmPDzcx9H4XnZ2tpYtW6bExEQFBAT4OpxSgZx5jpx5h7x5rqzk7MSJE4qKirLXrPLqwppdVvZvcSJn3iFvniNn3iFvnitJOXO3Xpe7pjv/9LTw8HCabp0/aENDQxUeHu7zg7a0IGeeI2feIW+eK2s5K++nVF9Ys8va/i0O5Mw75M1z5Mw75M1zJTFnhdXr8vtFMQAAAAAALEbTDQAAAACARWi6AQAAAACwCE03AAAAAAAWoekGAAAAAMAiNN0AAAAAAFiEphsAAAAAAIv4tOn+8ssvde2116pOnTqy2Wz66KOPCl1m1apVio+PV3BwsBo0aKC5c+daHygAAOUcNRsAAO/4tOk+ffq0WrdurZdfftmt+bt371afPn3UqVMnbdmyRQ8++KDGjh2rDz74wOJIAQAo36jZAAB4x9+XG+/du7d69+7t9vy5c+eqfv36mjVrliQpLi5OmzZt0rPPPqubbrrJoigBAAA1GwAA75Sq73SvW7dOiYmJDmM9e/bUpk2blJ2d7aOoAADAhajZAACc59NPuj116NAhRUZGOoxFRkYqJydHR44cUe3atZ2WycrKUlZWlv32iRMnJEnZ2dkUfcmeA3LhPnLmOXLmHfLmubKSs9Iev2RNzS4r+7c4kTPvkDfPkTPvkDfPlaScuRtDqWq6JclmszncNsa4HM83Y8YMTZs2zWl82bJlCg0NLfoAS6n09HRfh1DqkDPPkTPvkDfPlfacnTlzxtchFAmranZp37++QM68Q948R868Q948VxJy5m69LlVNd61atXTo0CGHscOHD8vf31/Vq1d3ucykSZOUnJxsv33ixAlFRUUpMTFR4eHhlsZbGmRnZys9PV09evRQQECAr8MpFciZs5ZTl170/iA/o0cT8vTwJj9l5bl+sW2VbVN7Fuv2ihLHmufKSs7yP+Etzayo2WVl/xYncuadspy3wmq2t4qi1pfmmu2tsnysWaUk5czdel2qmu727dtr0aJFDmPLli1TQkJCgQkPCgpSUFCQ03hAQIDPd1JJQj48R87+lJXrXnHNyrO5PbeolIV9xLHmudKes9Icez4ra3Zp37++QM68UxbzZnUdvpRaX9Zy7YmyeKxZrSTkzN3t+/RCaqdOndLWrVu1detWSed/XmTr1q3at2+fpPPveA8ePNg+f/To0dq7d6+Sk5O1Y8cOzZ8/X/PmzdO9997ri/ABACg3qNkAAHjHp590b9q0SV26dLHfzj+lbMiQIUpNTVVGRoa9mEtSbGysFi9erPHjx2v27NmqU6eOXnzxRX56BAAAi1GzAQDwjk+b7quvvtp+URVXUlNTncY6d+6sb775xsKoAADAhajZAAB4p1T9TjcAAAAAAKUJTTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFfN50p6SkKDY2VsHBwYqPj9fq1asvOv/tt99W69atFRoaqtq1a2vYsGHKzMwspmgBACi/qNkAAHjOp013Wlqaxo0bp8mTJ2vLli3q1KmTevfurX379rmc/9VXX2nw4MEaMWKEvv/+e7333nvauHGjRo4cWcyRAwBQvlCzAQDwjk+b7pkzZ2rEiBEaOXKk4uLiNGvWLEVFRWnOnDku569fv14xMTEaO3asYmNj9be//U2jRo3Spk2bijlyAADKF2o2AADe8ffVhs+dO6fNmzdr4sSJDuOJiYlau3aty2U6dOigyZMna/Hixerdu7cOHz6s999/X9dcc02B28nKylJWVpb99okTJyRJ2dnZys7OLoJHUrrl54BcuI+cOQuqYC5+v59x+G9xKs37iWPNc2UlZyUt/pJSs8vK/i1O5Mw7ZTlvhdVsr9dbBLW+LOa7MGX5WLNKScqZuzHYjDHF/ypY0sGDB1W3bl2tWbNGHTp0sI8/8cQTeuONN/TDDz+4XO7999/XsGHDdPbsWeXk5Oi6667T+++/r4CAAJfzp06dqmnTpjmNv/POOwoNDS2aBwMAQBE6c+aMBg4cqOPHjys8PNzX4VCzAQBwwd167bNPuvPZbDaH28YYp7F827dv19ixY/XII4+oZ8+eysjI0H333afRo0dr3rx5LpeZNGmSkpOT7bdPnDihqKgoJSYmlogXMr6WnZ2t9PR09ejRo8AXQXBEzpy1nLr0ovcH+Rk9mpCnhzf5KSvP9fPbKtum9izW7RUljjXPlZWc5X/CW9L4umaXlf1bnMiZd8py3gqr2d4qilpfmmu2t8rysWaVkpQzd+u1z5ruiIgIVahQQYcOHXIYP3z4sCIjI10uM2PGDHXs2FH33XefJOmyyy5TxYoV1alTJz322GOqXbu20zJBQUEKCgpyGg8ICPD5TipJyIfnyNmfsnLdK65ZeTa35xaVsrCPONY8V9pzVtJiL2k1u7TvX18gZ94pi3mzug5fSq0va7n2RFk81qxWEnLm7vZ9diG1wMBAxcfHKz093WE8PT3d4dS1vzpz5oz8/BxDrlChgqTz77YDAICiR80GAMB7Pr16eXJysl577TXNnz9fO3bs0Pjx47Vv3z6NHj1a0vnTzAYPHmyff+2112rhwoWaM2eOdu3apTVr1mjs2LG66qqrVKdOHV89DAAAyjxqNgAA3vHpd7oHDBigzMxMTZ8+XRkZGWrZsqUWL16s6OhoSVJGRobD738OHTpUJ0+e1Msvv6wJEyaoSpUq6tq1q5566ilfPQQAAMoFajYAAN7x+YXUkpKSlJSU5PK+1NRUp7G7775bd999t8VRAQCAC1GzAQDwnE9PLwcAAAAAoCyj6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFfN50p6SkKDY2VsHBwYqPj9fq1asvOj8rK0uTJ09WdHS0goKC1LBhQ82fP7+YogUAoPyiZgMA4Dl/X248LS1N48aNU0pKijp27KhXXnlFvXv31vbt21W/fn2Xy9x888363//+p3nz5qlRo0Y6fPiwcnJyijlyAADKF2o2AADe8WnTPXPmTI0YMUIjR46UJM2aNUtLly7VnDlzNGPGDKf5S5Ys0apVq7Rr1y5Vq1ZNkhQTE1OcIQMAUC5RswEA8I7PTi8/d+6cNm/erMTERIfxxMRErV271uUyn3zyiRISEvT000+rbt26atKkie6991798ccfxREyAADlEjUbAADv+eyT7iNHjig3N1eRkZEO45GRkTp06JDLZXbt2qWvvvpKwcHB+vDDD3XkyBElJSXp999/L/A7YllZWcrKyrLfPnHihCQpOztb2dnZRfRoSq/8HJAL95EzZ0EVzMXv9zMO/y1OpXk/cax5rqzkrKTFX1JqdlnZv8WJnHmnLOetsJrt9XqLoNaXxXwXpiwfa1YpSTlzNwabMab4XwVLOnjwoOrWrau1a9eqffv29vHHH39cb775pnbu3Om0TGJiolavXq1Dhw6pcuXKkqSFCxeqf//+On36tEJCQpyWmTp1qqZNm+Y0/s477yg0NLQIHxEAAEXjzJkzGjhwoI4fP67w8HBfh0PNBgDABXfrtc8+6Y6IiFCFChWc3iE/fPiw0zvp+WrXrq26devai7ckxcXFyRijX3/9VY0bN3ZaZtKkSUpOTrbfPnHihKKiopSYmFgiXsj4WnZ2ttLT09WjRw8FBAT4OpxSgZw5azl16UXvD/IzejQhTw9v8lNWnq2Yojpv29Sexbq9osSx5rmykrP8T3hLipJSs8vK/i1O5Mw7ZTlvhdVsbxVFrS/NNdtbZflYs0pJypm79dpnTXdgYKDi4+OVnp6uG264wT6enp6ufv36uVymY8eOeu+993Tq1ClVqlRJkvTjjz/Kz89P9erVc7lMUFCQgoKCnMYDAgJ8vpNKEvLhOXL2p6xc94prVp7N7blFpSzsI441z5X2nJW02EtazS7t+9cXyJl3ymLerK7Dl1Lry1quPVEWjzWrlYScubt9ry6k1qBBA2VmZjqNHzt2TA0aNHB7PcnJyXrttdc0f/587dixQ+PHj9e+ffs0evRoSeff8R48eLB9/sCBA1W9enUNGzZM27dv15dffqn77rtPw4cPd3maGgAA5VlR1WuJmg0AgLe8+qR7z549ys3NdRrPysrSgQMH3F7PgAEDlJmZqenTpysjI0MtW7bU4sWLFR0dLUnKyMjQvn377PMrVaqk9PR03X333UpISFD16tV1880367HHHvPmYQAAUKYVVb2WqNkAAHjLo6b7k08+sf//0qVLHb6nlZubq88//9zj3+BMSkpSUlKSy/tSU1Odxpo1a6b09HSPtgEAQHliRb2WqNkAAHjDo6b7+uuvlyTZbDYNGTLE4b6AgADFxMToueeeK7LgAACA56jXAACUHB413Xl5eZKk2NhYbdy4UREREZYEBQAAvEe9BgCg5PDqO927d+8u6jgAAEARo14DAOB7Xv9k2Oeff67PP/9chw8ftr+jnm/+/PmXHBgAALh01GsAAHzLq6Z72rRpmj59uhISElS7dm3ZbMX7u7sAAKBw1GsAAHzPq6Z77ty5Sk1N1aBBg4o6HgAAUESo1wAA+J6fNwudO3dOHTp0KOpYAABAEaJeAwDge1413SNHjtQ777xT1LEAAIAiRL0GAMD3vDq9/OzZs3r11Ve1fPlyXXbZZQoICHC4f+bMmUUSHAAA8B71GgAA3/Oq6f7222/Vpk0bSdK2bdsc7uMiLQAAlAzUawAAfM+rpvuLL74o6jgAAEARo14DAOB7Xn2nGwAAAAAAFM6rT7q7dOly0dPSVqxY4XVAAACgaFCvAQDwPa+a7vzvh+XLzs7W1q1btW3bNg0ZMqQo4gIAAJeIeg0AgO951XQ///zzLsenTp2qU6dOXVJAAACgaFCvAQDwvSL9Tvftt9+u+fPnF+UqAQBAEaNeAwBQfIq06V63bp2Cg4OLcpUAAKCIUa8BACg+Xp1efuONNzrcNsYoIyNDmzZt0sMPP1wkgQEAgEtDvQYAwPe8arorV67scNvPz09NmzbV9OnTlZiYWCSBAQCAS0O9BgDA97xqul9//fWijgMAABQx6jUAAL7nVdOdb/PmzdqxY4dsNpuaN2+uyy+/vKjiAgAARYR6DQCA73jVdB8+fFi33HKLVq5cqSpVqsgYo+PHj6tLly569913VaNGjaKOEwAAeIh6DQCA73l19fK7775bJ06c0Pfff6/ff/9dR48e1bZt23TixAmNHTu2qGMEAABeoF4DAOB7Xn3SvWTJEi1fvlxxcXH2sebNm2v27NlcmAUAgBKCeg0AgO959Ul3Xl6eAgICnMYDAgKUl5d3yUEBAIBLR70GAMD3vGq6u3btqnvuuUcHDx60jx04cEDjx49Xt27diiw4AADgPeo1AAC+51XT/fLLL+vkyZOKiYlRw4YN1ahRI8XGxurkyZN66aWXijpGAADgBeo1AAC+59V3uqOiovTNN98oPT1dO3fulDFGzZs3V/fu3Ys6PgAA4CXqNQAAvufRJ90rVqxQ8+bNdeLECUlSjx49dPfdd2vs2LG68sor1aJFC61evdqSQAEAgHuo1wAAlBweNd2zZs3SHXfcofDwcKf7KleurFGjRmnmzJlFFhwAAPAc9RoAgJLDo6b7v//9r3r16lXg/YmJidq8efMlBwUAALxHvQYAoOTwqOn+3//+5/KnR/L5+/vrt99+u+SgAACA96jXAACUHB413XXr1tV3331X4P3ffvutateufclBAQAA71GvAQAoOTxquvv06aNHHnlEZ8+edbrvjz/+0JQpU9S3b98iCw4AAHiOeg0AQMnh0U+GPfTQQ1q4cKGaNGmiMWPGqGnTprLZbNqxY4dmz56t3NxcTZ482apYAQCAG6jXAACUHB413ZGRkVq7dq3+8Y9/aNKkSTLGSJJsNpt69uyplJQURUZGWhIoAABwD/UaAICSw6OmW5Kio6O1ePFiHT16VD///LOMMWrcuLGqVq1qRXwAAMAL1GsAAEoGj5vufFWrVtWVV15ZlLEAAIAiRr0GAMC3PLqQGgAAAAAAcB9NNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARmm4AAAAAACxC0w0AAAAAgEVougEAAAAAsAhNNwAAAAAAFvF5052SkqLY2FgFBwcrPj5eq1evdmu5NWvWyN/fX23atLE2QAAAIImaDQCAN3zadKelpWncuHGaPHmytmzZok6dOql3797at2/fRZc7fvy4Bg8erG7duhVTpAAAlG/UbAAAvOPTpnvmzJkaMWKERo4cqbi4OM2aNUtRUVGaM2fORZcbNWqUBg4cqPbt2xdTpAAAlG/UbAAAvOPvqw2fO3dOmzdv1sSJEx3GExMTtXbt2gKXe/311/XLL7/orbfe0mOPPVbodrKyspSVlWW/feLECUlSdna2srOzvYy+7MjPAblwHzlzFlTBXPx+P+Pw3+JUmvcTx5rnykrOSlr8JaVml5X9W5zImXfKct4Kq9ler7cIan1ZzHdhyvKxZpWSlDN3Y/BZ033kyBHl5uYqMjLSYTwyMlKHDh1yucxPP/2kiRMnavXq1fL3dy/0GTNmaNq0aU7jy5YtU2hoqOeBl1Hp6em+DqHUIWd/evoq9+Y9mpBnbSAuLF68uNi3WdQ41jxX2nN25swZX4fgoKTV7NK+f32BnHmnLObN3ZrtrUup9WWhZnurLB5rVisJOXO3Xvus6c5ns9kcbhtjnMYkKTc3VwMHDtS0adPUpEkTt9c/adIkJScn22+fOHFCUVFRSkxMVHh4uPeBlxHZ2dlKT09Xjx49FBAQ4OtwSgVy5qzl1KUXvT/Iz+jRhDw9vMlPWXnOz28rbZvas1i3V5Q41jxXVnKW/wlvSePrml1W9m9xImfeKct5K6xme6soan1prtneKsvHmlVKUs7crdc+a7ojIiJUoUIFp3fIDx8+7PROuiSdPHlSmzZt0pYtWzRmzBhJUl5enowx8vf317Jly9S1a1en5YKCghQUFOQ0HhAQ4POdVJKQD8+Rsz9l5bpXXLPybG7PLSplYR9xrHmutOespMVe0mp2ad+/vkDOvFMW82Z1Hb6UWl/Wcu2JsnisWa0k5Mzd7fvsQmqBgYGKj493Oi0gPT1dHTp0cJofHh6u7777Tlu3brX/Gz16tJo2baqtW7eqbdu2xRU6AADlCjUbAADv+fT08uTkZA0aNEgJCQlq3769Xn31Ve3bt0+jR4+WdP40swMHDuhf//qX/Pz81LJlS4fla9asqeDgYKdxAABQtKjZAAB4x6dN94ABA5SZmanp06crIyNDLVu21OLFixUdHS1JysjIKPT3PwEAgPWo2QAAeMfnF1JLSkpSUlKSy/tSU1MvuuzUqVM1derUog8KAAA4oWYDAOA5n32nGwAAAACAso6mGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABbxedOdkpKi2NhYBQcHKz4+XqtXry5w7sKFC9WjRw/VqFFD4eHhat++vZYuXVqM0QIAUH5RswEA8JxPm+60tDSNGzdOkydP1pYtW9SpUyf17t1b+/btczn/yy+/VI8ePbR48WJt3rxZXbp00bXXXqstW7YUc+QAAJQv1GwAALzj06Z75syZGjFihEaOHKm4uDjNmjVLUVFRmjNnjsv5s2bN0v33368rr7xSjRs31hNPPKHGjRtr0aJFxRw5AADlCzUbAADv+Ptqw+fOndPmzZs1ceJEh/HExEStXbvWrXXk5eXp5MmTqlatWoFzsrKylJWVZb994sQJSVJ2drays7O9iLxsyc8BuXAfOXMWVMFc/H4/4/Df4lSa9xPHmufKSs5KWvwlpWaXlf1bnMiZd8py3gqr2V6vtwhqfVnMd2HK8rFmlZKUM3dj8FnTfeTIEeXm5ioyMtJhPDIyUocOHXJrHc8995xOnz6tm2++ucA5M2bM0LRp05zGly1bptDQUM+CLsPS09N9HUKpQ87+9PRV7s17NCHP2kBcWLx4cbFvs6hxrHmutOfszJkzvg7BQUmr2aV9//oCOfNOWcybuzXbW5dS68tCzfZWWTzWrFYScuZuvfZZ053PZrM53DbGOI25smDBAk2dOlUff/yxatasWeC8SZMmKTk52X77xIkTioqKUmJiosLDw70PvIzIzs5Wenq6evTooYCAAF+HUyqQM2ctp1784khBfkaPJuTp4U1+ysor/PldlLZN7Vms2ytKHGueKys5y/+Et6Txdc0uK/u3OJEz75TlvBVWs71VFLW+NNdsb5XlY80qJSln7tZrnzXdERERqlChgtM75IcPH3Z6J/1CaWlpGjFihN577z117979onODgoIUFBTkNB4QEODznVSSkA/PkbM/ZeW6V1yz8mxuzy0qZWEfcax5rrTnrKTFXtJqdmnfv75AzrxTFvNmdR2+lFpf1nLtibJ4rFmtJOTM3e377EJqgYGBio+PdzotID09XR06dChwuQULFmjo0KF65513dM0111gdJgAA5R41GwAA7/n09PLk5GQNGjRICQkJat++vV599VXt27dPo0ePlnT+NLMDBw7oX//6l6TzxXvw4MF64YUX1K5dO/s77iEhIapcubLPHgcAAGUdNRsAAO/4tOkeMGCAMjMzNX36dGVkZKhly5ZavHixoqOjJUkZGRkOv//5yiuvKCcnR3fddZfuuusu+/iQIUOUmppa3OEDAFBuULMBAPCOzy+klpSUpKSkJJf3XViUV65caX1AAADAJWo2AACe89l3ugEAAAAAKOtougEAAAAAsAhNNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARmm4AAAAAACxC0w0AAAAAgEVougEAAAAAsAhNNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARmm4AAAAAACxC0w0AAAAAgEVougEAAAAAsAhNNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARmm4AAAAAACxC0w0AAAAAgEVougEAAAAAsAhNNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARmm4AAAAAACxC0w0AAAAAgEVougEAAAAAsAhNNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARmm4AAAAAACxC0w0AAAAAgEVougEAAAAAsAhNNwAAAAAAFqHpBgAAAADAIjTdAAAAAABYhKYbAAAAAACL0HQDAAAAAGARnzfdKSkpio2NVXBwsOLj47V69eqLzl+1apXi4+MVHBysBg0aaO7cucUUKQAA5Rs1GwAAz/m06U5LS9O4ceM0efJkbdmyRZ06dVLv3r21b98+l/N3796tPn36qFOnTtqyZYsefPBBjR07Vh988EExRw4AQPlCzQYAwDs+bbpnzpypESNGaOTIkYqLi9OsWbMUFRWlOXPmuJw/d+5c1a9fX7NmzVJcXJxGjhyp4cOH69lnny3myAEAKF+o2QAAeMdnTfe5c+e0efNmJSYmOownJiZq7dq1LpdZt26d0/yePXtq06ZNys7OtixWAADKM2o2AADe8/fVho8cOaLc3FxFRkY6jEdGRurQoUMulzl06JDL+Tk5OTpy5Ihq167ttExWVpaysrLst48fPy5J+v333yn6krKzs3XmzBllZmYqICDA1+GUCuTMmX/O6Yvfn2d05kye/LP9lJtnK6aozsvMzCzW7RUljjXPlZWcnTx5UpJkjPFxJOeVlJpdVvZvcSJn3inLeSusZnu93iKo9aW5ZnurLB9rVilJOXO3Xvus6c5nszk+KY0xTmOFzXc1nm/GjBmaNm2a03hsbKynoQK4BAN9tN2I53y0YaAInDx5UpUrV/Z1GHbUbAAXc6m1npqN0qqweu2zpjsiIkIVKlRweof88OHDTu+M56tVq5bL+f7+/qpevbrLZSZNmqTk5GT77by8PP3++++qXr36RV8olBcnTpxQVFSU9u/fr/DwcF+HUyqQM8+RM++QN8+VlZwZY3Ty5EnVqVPH16FIKjk1u6zs3+JEzrxD3jxHzrxD3jxXknLmbr32WdMdGBio+Ph4paen64YbbrCPp6enq1+/fi6Xad++vRYtWuQwtmzZMiUkJBR4akFQUJCCgoIcxqpUqXJpwZdB4eHhPj9oSxty5jly5h3y5rmykLOS9Al3SavZZWH/Fjdy5h3y5jly5h3y5rmSkjN36rVPr16enJys1157TfPnz9eOHTs0fvx47du3T6NHj5Z0/h3vwYMH2+ePHj1ae/fuVXJysnbs2KH58+dr3rx5uvfee331EAAAKBeo2QAAeMen3+keMGCAMjMzNX36dGVkZKhly5ZavHixoqOjJUkZGRkOv/8ZGxurxYsXa/z48Zo9e7bq1KmjF198UTfddJOvHgIAAOUCNRsAAO/4/EJqSUlJSkpKcnlfamqq01jnzp31zTffWBxV+REUFKQpU6Y4nc6HgpEzz5Ez75A3z5Eza/m6ZrN/PUfOvEPePEfOvEPePFcac2YzJeX3SAAAAAAAKGN8+p1uAAAAAADKMppuAAAAAAAsQtMNAAAAAIBFaLrLmaNHj2rQoEGqXLmyKleurEGDBunYsWMFzs/OztYDDzygVq1aqWLFiqpTp44GDx6sgwcPFl/QPpCSkqLY2FgFBwcrPj5eq1evvuj8VatWKT4+XsHBwWrQoIHmzp1bTJGWHJ7kbOHCherRo4dq1Kih8PBwtW/fXkuXLi3GaEsOT4+1fGvWrJG/v7/atGljbYAlkKc5y8rK0uTJkxUdHa2goCA1bNhQ8+fPL6Zocak8rVsXGjVqlGw2m2bNmmVZjCUNtd491HrPUeu9Q633XJmr9QblSq9evUzLli3N2rVrzdq1a03Lli1N3759C5x/7Ngx0717d5OWlmZ27txp1q1bZ9q2bWvi4+OLMeri9e6775qAgADzz3/+02zfvt3cc889pmLFimbv3r0u5+/atcuEhoaae+65x2zfvt3885//NAEBAeb9998v5sh9x9Oc3XPPPeapp54yGzZsMD/++KOZNGmSCQgIMN98800xR+5bnuYt37Fjx0yDBg1MYmKiad26dfEEW0J4k7PrrrvOtG3b1qSnp5vdu3ebr7/+2qxZs6YYo8al8LRu/dWHH35oWrduberUqWOef/55awMtQaj1haPWe45a7x1qvefKYq2n6S5Htm/fbiSZ9evX28fWrVtnJJmdO3e6vZ4NGzYYSYX+sSitrrrqKjN69GiHsWbNmpmJEye6nH///febZs2aOYyNGjXKtGvXzrIYSxpPc+ZK8+bNzbRp04o6tBLN27wNGDDAPPTQQ2bKlCnlrhB7mrPPPvvMVK5c2WRmZhZHeChil1K3fv31V1O3bl2zbds2Ex0dXW6abmq9e6j1nqPWe4da77myWOs5vbwcWbdunSpXrqy2bdvax9q1a6fKlStr7dq1bq/n+PHjstlsqlKligVR+ta5c+e0efNmJSYmOownJiYWmKN169Y5ze/Zs6c2bdqk7Oxsy2ItKbzJ2YXy8vJ08uRJVatWzYoQSyRv8/b666/rl19+0ZQpU6wOscTxJmeffPKJEhIS9PTTT6tu3bpq0qSJ7r33Xv3xxx/FETIukbd1Ky8vT4MGDdJ9992nFi1aFEeoJQa1vnDUes9R671DrfdcWa31/r4OAMXn0KFDqlmzptN4zZo1dejQIbfWcfbsWU2cOFEDBw5UeHh4UYfoc0eOHFFubq4iIyMdxiMjIwvM0aFDh1zOz8nJ0ZEjR1S7dm3L4i0JvMnZhZ577jmdPn1aN998sxUhlkje5O2nn37SxIkTtXr1avn7l78/397kbNeuXfrqq68UHBysDz/8UEeOHFFSUpJ+//33kvVdL7jkbd166qmn5O/vr7Fjx1oZXolErS8ctd5z1HrvUOs9V1ZrPZ90lwFTp06VzWa76L9NmzZJkmw2m9PyxhiX4xfKzs7WLbfcory8PKWkpBT54yhJLsxHYTlyNd/VeFnmac7yLViwQFOnTlVaWprLF4plnbt5y83N1cCBAzVt2jQ1adKkuMIrkTw51vLy8mSz2fT222/rqquuUp8+fTRz5kylpqaWqHfAyxsr69bmzZv1wgsvKDU1tUz9DabWFz1qveeo9d6h1nuurNX68vf2SRk0ZswY3XLLLRedExMTo2+//Vb/+9//nO777bffnN5NulB2drZuvvlm7d69WytWrCiT73xLUkREhCpUqOD0Ttrhw4cLzFGtWrVczvf391f16tUti7Wk8CZn+dLS0jRixAi999576t69u5Vhljie5u3kyZPatGmTtmzZojFjxkg6X2SMMfL399eyZcvUtWvXYondV7w51mrXrq26deuqcuXK9rG4uDgZY/Trr7+qcePGlsYM16ysW6tXr9bhw4dVv359+1hubq4mTJigWbNmac+ePZcUu69Q64sOtd5z1HrvUOs9V1ZrPU13GRAREaGIiIhC57Vv317Hjx/Xhg0bdNVVV0mSvv76ax0/flwdOnQocLn8IvzTTz/piy++KNPFJTAwUPHx8UpPT9cNN9xgH09PT1e/fv1cLtO+fXstWrTIYWzZsmVKSEhQQECApfGWBN7kTDr/rvfw4cO1YMECXXPNNcURaoniad7Cw8P13XffOYylpKRoxYoVev/99xUbG2t5zL7mzbHWsWNHvffeezp16pQqVaokSfrxxx/l5+enevXqFUvccGZl3Ro0aJDTC/uePXtq0KBBGjZs2KUH7yPU+qJDrfcctd471HrPldlaX+yXboNP9erVy1x22WVm3bp1Zt26daZVq1ZOPyPStGlTs3DhQmOMMdnZ2ea6664z9erVM1u3bjUZGRn2f1lZWb54CJbL/5mCefPmme3bt5tx48aZihUrmj179hhjjJk4caIZNGiQfX7+z4iMHz/ebN++3cybN6/c/oyIuzl75513jL+/v5k9e7bDMXXs2DFfPQSf8DRvFyqPVzT1NGcnT5409erVM/379zfff/+9WbVqlWncuLEZOXKkrx4CPORp3XKlPF293BhqvTuo9Z6j1nuHWu+5sljrabrLmczMTHPbbbeZsLAwExYWZm677TZz9OhRhzmSzOuvv26MMWb37t1Gkst/X3zxRbHHX1xmz55toqOjTWBgoLniiivMqlWr7PcNGTLEdO7c2WH+ypUrzeWXX24CAwNNTEyMmTNnTjFH7Hue5Kxz584uj6khQ4YUf+A+5umx9lflsRAb43nOduzYYbp3725CQkJMvXr1THJysjlz5kwxRw1veVq3XClvTTe13j3Ues9R671DrfdcWav1NmP+/1UgAAAAAABAkeLq5QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03UA5tWfPHtlsNm3dutXrdaSmpqpKlSpFFtNfxcTEaNasWZas+69Wrlwpm82mY8eOWb4tAAC8Qc0+j5qN0oqmG3DD0KFDZbPZ9OSTTzqMf/TRR7LZbD5blyfbvP766x3GoqKilJGRoZYtW3q93gEDBujHH3+8pNisfBFglauvvlrjxo3zdRgAABeo2a5RswHfoekG3BQcHKynnnpKR48eLTHrys7O9nrZChUqqFatWvL39/d6HSEhIapZs6bXywMAYAVqtjNqNuA7NN2Am7p3765atWppxowZBc7JzMzUrbfeqnr16ik0NFStWrXSggULvFqXKzabTXPnzlW/fv1UsWJFPfbYY8rNzdWIESMUGxurkJAQNW3aVC+88IJ9malTp+qNN97Qxx9/LJvNJpvNppUrV7o8VW3VqlW66qqrFBQUpNq1a2vixInKyckpMJ4L3/GeOnWq2rRpozfffFMxMTGqXLmybrnlFp08edLl8itXrtSwYcN0/Phxe2xTp06133/mzBkNHz5cYWFhql+/vl599VWH5Q8cOKABAwaoatWqql69uvr166c9e/ZcNIeLFy9WkyZNFBISoi5dujjNL2wfDh06VKtWrdILL7xgj3nPnj2F7gcAQPGhZjujZlOz4UMGQKGGDBli+vXrZxYuXGiCg4PN/v37jTHGfPjhh+avT6Nff/3VPPPMM2bLli3ml19+MS+++KKpUKGCWb9+vcfrckWSqVmzppk3b5755ZdfzJ49e8y5c+fMI488YjZs2GB27dpl3nrrLRMaGmrS0tKMMcacPHnS3HzzzaZXr14mIyPDZGRkmKysLLN7924jyWzZssUee2hoqElKSjI7duwwH374oYmIiDBTpkwpMJ7XX3/dVK5c2X57ypQpplKlSubGG2803333nfnyyy9NrVq1zIMPPuhy+aysLDNr1iwTHh5uj+3kyZPGGGOio6NNtWrVzOzZs81PP/1kZsyYYfz8/MyOHTuMMcacPn3aNG7c2AwfPtx8++23Zvv27WbgwIGmadOmJisry+X29u3bZ4KCgsw999xjdu7cad566y0TGRlpJJmjR4+6tQ+PHTtm2rdvb+644w57zDk5OYXuBwBA8aBmu0bNpmbDd2i6ATfkF11jjGnXrp0ZPny4Mca9otunTx8zYcKEIlmXJDNu3LhC401KSjI33XSTy23mu7CAP/jgg6Zp06YmLy/PPmf27NmmUqVKJjc31+V2XBXw0NBQc+LECfvYfffdZ9q2bVtgrBeuI190dLS5/fbb7bfz8vJMzZo1zZw5c4wxxsybN88p3qysLBMSEmKWLl3qcluTJk0ycXFxDss88MADDgXclQv3YefOnc0999xT4Px8F+4HAID1qNnUbGo2ShrvvxgClFNPPfWUunbtqgkTJjjdl5ubqyeffFJpaWk6cOCAsrKylJWVpYoVK3q8roIkJCQ4jc2dO1evvfaa9u7dqz/++EPnzp1TmzZt3F6nJO3YsUPt27d3uDBMx44dderUKf3666+qX7++W+uJiYlRWFiY/Xbt2rV1+PBhj2LJd9lll9n/32azqVatWvZ1bd68WT///LPDtiTp7Nmz+uWXX1yub8eOHWrXrp3DY2zfvr3DHE/34V8VxX4AABQdavbFUbOp2SgefKcb8ND//d//qWfPnnrwwQed7nvuuef0/PPP6/7779eKFSu0detW9ezZU+fOnfN4XQW5sJD8+9//1vjx4zV8+HAtW7ZMW7du1bBhwwrcZkGMMU5XYjXGSJJHV2gNCAhwuG2z2ZSXl+dRLO6sKy8vT/Hx8dq6davDvx9//FEDBw50ub78x3Mxnu7DfEW1HwAARYeafXHUbGo2igefdANeePLJJ9WmTRs1adLEYXz16tXq16+fbr/9dknni8xPP/2kuLg4j9flrtWrV6tDhw5KSkqyj134rnFgYKByc3Mvup7mzZvrgw8+cCjka9euVVhYmOrWretVbO5wJzZXrrjiCqWlpalmzZoKDw93a5nmzZvro48+chhbv369w2139qGrmN3ZDwCA4kfNLjrUbMA7fNINeKFVq1a67bbb9NJLLzmMN2rUSOnp6Vq7dq127NihUaNG6dChQ16ty12NGjXSpk2btHTpUv344496+OGHtXHjRoc5MTEx+vbbb/XDDz/oyJEjLn+2JCkpSfv379fdd9+tnTt36uOPP9aUKVOUnJwsPz/r/lTExMTo1KlT+vzzz3XkyBGdOXPGreVuu+02RUREqF+/flq9erV2796tVatW6Z577tGvv/7qcpnRo0frl19+UXJysn744Qe98847Sk1NdZjjzj6MiYnR119/rT179ujIkSPKy8tzaz8AAIofNbvoULMB79B0A1569NFHnU59evjhh3XFFVeoZ8+euvrqq1WrVi1df/31Xq3LXaNHj9aNN96oAQMGqG3btsrMzHR451aS7rjjDjVt2lQJCQmqUaOG1qxZ47SeunXravHixdqwYYNat26t0aNHa8SIEXrooYe8istdHTp00OjRozVgwADVqFFDTz/9tFvLhYaG6ssvv1T9+vV14403Ki4uTsOHD9cff/xR4Lvo9evX1wcffKBFixapdevWmjt3rp544gmHOe7sw3vvvVcVKlRQ8+bNVaNGDe3bt8+t/QAA8A1qdtGgZgPesRlv/2oAAAAAAICL4pNuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABah6QYAAAAAwCI03QAAAAAAWISmGwAAAAAAi9B0AwAAAABgEZpuAAAAAAAsQtMNAAAAAIBFaLoBAAAAALAITTcAAAAAABb5f+qO+cg8WVvvAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Create subplots\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n",
    "\n",
    "# Plot the first histogram\n",
    "hist_cal = nan_stats['calibration - usgs'].hist(ax=axes[0])\n",
    "hist_cal.set_xlabel('NaN ratio in the data')\n",
    "hist_cal.set_ylabel('Count')\n",
    "hist_cal.set_title('USGS streamflow data - Calibration period')\n",
    "\n",
    "# Plot the second histogram\n",
    "hist_test = nan_stats['testing - usgs'].hist(ax=axes[1])\n",
    "hist_test.set_xlabel('NaN ratio in the data')\n",
    "hist_test.set_ylabel('Count')\n",
    "hist_test.set_title('USGS streamflow data - Testing period')\n",
    "\n",
    "# Adjust spacing between subplots\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save the list of basin id with more than threshold misssing data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For the calibration period"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_id_list = sorted(basin_ids)\n",
    "basin_ids_string = [str(basin_id).zfill(8) for basin_id in sorted_id_list]\n",
    "with open(missing_data_file, 'w') as file:\n",
    "    for item in basin_ids_string:\n",
    "        file.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Do the same thing for the testing period"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "0\n",
      "[]\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "threshold = 0.99 # set the threshold\n",
    "nan_stats_test = nan_stats[['basin_id', 'testing - usgs']].copy()\n",
    "mask = (nan_stats_test['testing - usgs'] > threshold)  # filter the DataFrame, ignore the 'basin id' column\n",
    "basin_ids_testing_ = nan_stats_test.loc[mask, 'basin_id'].tolist()  # get the 'basin id' of the rows that meet the condition\n",
    "print(basin_ids_testing_)\n",
    "print(len(basin_ids_testing_))\n",
    "\n",
    "basin_ids_testing = np.concatenate([basin_ids_testing_, basin_ids])\n",
    "print(basin_ids_testing)\n",
    "print(len(basin_ids_testing))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_id_list = sorted(basin_ids_testing)\n",
    "basin_ids_string = [str(basin_id).zfill(8) for basin_id in sorted_id_list]\n",
    "with open(missing_data_file_testing, 'w') as file:\n",
    "    for item in basin_ids_string:\n",
    "        file.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save the list of basin id with less than threshold missing data \n",
    "Gauch et al., (2020) used 516 basins (saved as \"basin_list_516.txt\")  \n",
    "By removing the basin with >50% missing data (saved as \"basin_list_missing_data_v2023.txt\"),  \n",
    "we get 500 basins for this project (saved as \"basin_list_500.txt\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(data_dir,'basin_list_516.txt'), 'r') as file1, open(os.path.join(data_dir, 'basin_list_missing_data_v2023.txt'), 'r') as file2:\n",
    "    basin_ids_516 = set(map(int, file1.read().splitlines()))\n",
    "    basin_ids_missing = set(map(int, file2.read().splitlines()))\n",
    "    \n",
    "filtered_basin_ids = list(basin_ids_516 - basin_ids_missing)\n",
    "filtered_basin_ids_string = [str(basin_id).zfill(8) for basin_id in filtered_basin_ids]\n",
    "\n",
    "# with open(os.path.join(data_dir,'basin_list_500.txt'), 'w') as file:\n",
    "#     file.write('\\n'.join(map(str, filtered_basin_ids_string)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# (Skip this, just for checking)\n",
    "# Checking timeseries of data to see how missing data looks like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>date</th>\n",
       "      <th>QObs(mm/h)</th>\n",
       "      <th>QObs count</th>\n",
       "      <th>qualifiers</th>\n",
       "      <th>utcoffset(h)</th>\n",
       "      <th>(iv-camels)/camels</th>\n",
       "      <th>QObs_CAMELS(mm/h)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1989-10-01 04:00:00</th>\n",
       "      <td>1989-10-01 04:00:00</td>\n",
       "      <td>0.027234</td>\n",
       "      <td>3</td>\n",
       "      <td>A [92]/A [92]/A [92]</td>\n",
       "      <td>-4.0</td>\n",
       "      <td>-0.00989</td>\n",
       "      <td>0.025846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1989-10-01 05:00:00</th>\n",
       "      <td>1989-10-01 05:00:00</td>\n",
       "      <td>0.027234</td>\n",
       "      <td>4</td>\n",
       "      <td>A [92]/A [92]/A [92]/A [92]</td>\n",
       "      <td>-4.0</td>\n",
       "      <td>-0.00989</td>\n",
       "      <td>0.025846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1989-10-01 06:00:00</th>\n",
       "      <td>1989-10-01 06:00:00</td>\n",
       "      <td>0.026887</td>\n",
       "      <td>4</td>\n",
       "      <td>A [92]/A [92]/A [92]/A [92]</td>\n",
       "      <td>-4.0</td>\n",
       "      <td>-0.00989</td>\n",
       "      <td>0.025846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1989-10-01 07:00:00</th>\n",
       "      <td>1989-10-01 07:00:00</td>\n",
       "      <td>0.026887</td>\n",
       "      <td>4</td>\n",
       "      <td>A [92]/A [92]/A [92]/A [92]</td>\n",
       "      <td>-4.0</td>\n",
       "      <td>-0.00989</td>\n",
       "      <td>0.025846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1989-10-01 08:00:00</th>\n",
       "      <td>1989-10-01 08:00:00</td>\n",
       "      <td>0.026887</td>\n",
       "      <td>4</td>\n",
       "      <td>A [92]/A [92]/A [92]/A [92]</td>\n",
       "      <td>-4.0</td>\n",
       "      <td>-0.00989</td>\n",
       "      <td>0.025846</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                    date  QObs(mm/h)  QObs count  \\\n",
       "date                                                               \n",
       "1989-10-01 04:00:00  1989-10-01 04:00:00    0.027234           3   \n",
       "1989-10-01 05:00:00  1989-10-01 05:00:00    0.027234           4   \n",
       "1989-10-01 06:00:00  1989-10-01 06:00:00    0.026887           4   \n",
       "1989-10-01 07:00:00  1989-10-01 07:00:00    0.026887           4   \n",
       "1989-10-01 08:00:00  1989-10-01 08:00:00    0.026887           4   \n",
       "\n",
       "                                      qualifiers  utcoffset(h)  \\\n",
       "date                                                             \n",
       "1989-10-01 04:00:00         A [92]/A [92]/A [92]          -4.0   \n",
       "1989-10-01 05:00:00  A [92]/A [92]/A [92]/A [92]          -4.0   \n",
       "1989-10-01 06:00:00  A [92]/A [92]/A [92]/A [92]          -4.0   \n",
       "1989-10-01 07:00:00  A [92]/A [92]/A [92]/A [92]          -4.0   \n",
       "1989-10-01 08:00:00  A [92]/A [92]/A [92]/A [92]          -4.0   \n",
       "\n",
       "                     (iv-camels)/camels  QObs_CAMELS(mm/h)  \n",
       "date                                                        \n",
       "1989-10-01 04:00:00            -0.00989           0.025846  \n",
       "1989-10-01 05:00:00            -0.00989           0.025846  \n",
       "1989-10-01 06:00:00            -0.00989           0.025846  \n",
       "1989-10-01 07:00:00            -0.00989           0.025846  \n",
       "1989-10-01 08:00:00            -0.00989           0.025846  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs_dir = os.path.join(data_dir, 'usgs_streamflow')\n",
    "obs_data = pd.read_csv(os.path.join(obs_dir, '01022500-usgs-hourly.csv'))\n",
    "obs_data.set_index(pd.to_datetime(obs_data['date']), inplace=True)\n",
    "obs_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x150693150>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1 = obs_data['QObs_CAMELS(mm/h)']['1999-01-01':'2008-12-31'].plot()\n",
    "p2 = obs_data['QObs(mm/h)']['1999-01-01':'2008-12-31'].plot()\n",
    "p1.legend()\n",
    "p2.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='date'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "obs_data['QObs_CAMELS(mm/h)']['2009-10-01':'2010-09-30'].plot()\n",
    "obs_data['QObs(mm/h)']['2009-10-01':'2010-09-30'].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}