mini_survey_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "261e95ca",
   "metadata": {},
   "source": [
    "### Import packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "01308029",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import dva_sdhdf_combine\n",
    "import imp\n",
    "import os\n",
    "import subprocess\n",
    "import h5py\n",
    "import numpy as np\n",
    "from astropy.time import Time\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import griddata\n",
    "import datetime\n",
    "import matplotlib.dates as mdates\n",
    "from matplotlib.dates import HourLocator as HourLocator\n",
    "from matplotlib.dates import MinuteLocator as MinuteLocator\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "from astropy import units as u\n",
    "from astropy.time import TimeDelta\n",
    "from ipywidgets import interact\n",
    "\n",
    "#### Change the directory to where the files are located\" ####\n",
    "directory = '../DVA/Data_Files/Mini_survey_scans/'\n",
    "\n",
    "### Change the scan details to your current scan\n",
    "df = 0.5        \n",
    "dt = 6.9444431574083865e-06\n",
    "\n",
    "#TODO: actually do the scan properties definition in the beginning\n",
    "##############################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29db1ea5",
   "metadata": {},
   "source": [
    "### Import Leo's functions for RFI Excision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0f507ec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# in_power_array        Input power array (RR, LL, reRL, imRL) at a single frequency\n",
    "# numt                  Number of time points to include in the 'window' in which the standard deviation is calculated\n",
    "# threshold             Array of standard deviation thresholds to use in each stage of the RFI excision \n",
    "\n",
    "def Is_RFI(in_power_array, threshold, idx, interval_start, interval_end):\n",
    "    retVal = False\n",
    "    in_power_mean = np.nanmean(in_power_array[interval_start:interval_end])\n",
    "    in_power_std = np.nanstd(in_power_array[interval_start:interval_end])\n",
    "    if abs(in_power_array[idx]) > abs(in_power_mean)+threshold*in_power_std:\n",
    "        retVal = True\n",
    "    return retVal\n",
    "    \n",
    "def Find_Slope(array, idx):\n",
    "    return array[idx+2] - array[idx]\n",
    "\n",
    "def Get_RFI_Duration(in_power_array, interval_start, interval_end):  #NOTE: This approach might have issues if the interval has a nan on it\n",
    "    #Find the first slope\n",
    "    first_slope = Find_Slope(in_power_array, interval_start)\n",
    "    #Initiate the RFI interval indexes at the boundaries of the set\n",
    "    RFI_start = interval_start\n",
    "    RFI_end = interval_end\n",
    "    #Initiate as the fastest rise & fall\n",
    "    steepest_rise = first_slope\n",
    "    steepest_fall = first_slope \n",
    "    start_idx = interval_start + 1  # Ignores the first slope (since it's already calculated)\n",
    "    end_idx = interval_end - 2      # Avoids overflowing (since each slope is calculated 2 indexes ahead)\n",
    "    for idx in range(start_idx, end_idx):\n",
    "        current_slope = Find_Slope(in_power_array, idx)\n",
    "        if(current_slope >  steepest_rise):\n",
    "            steepest_rise = current_slope\n",
    "            RFI_start = idx\n",
    "        elif(current_slope < steepest_fall):\n",
    "            steepest_fall = current_slope\n",
    "            RFI_end = idx + 2\n",
    "    return (RFI_end - RFI_start)\n",
    "\n",
    "def Get_RFI_Duration(in_power_array, interval_start, interval_end):  #NOTE: This approach might have issues if the interval has a nan on it\n",
    "    #Find the first slope\n",
    "    first_slope = Find_Slope(in_power_array, interval_start)\n",
    "    #Initiate the RFI interval indexes at the boundaries of the set\n",
    "    RFI_start = interval_start\n",
    "    RFI_end = interval_end\n",
    "    #Initiate as the fastest rise & fall\n",
    "    steepest_rise = first_slope\n",
    "    steepest_fall = first_slope \n",
    "    start_idx = interval_start + 1  # Ignores the first slope (since it's already calculated)\n",
    "    end_idx = interval_end - 2      # Avoids overflowing (since each slope is calculated 2 indexes ahead)\n",
    "    for idx in range(start_idx, end_idx):\n",
    "        current_slope = Find_Slope(in_power_array, idx)\n",
    "        if(current_slope >  steepest_rise):\n",
    "            steepest_rise = current_slope\n",
    "            RFI_start = idx\n",
    "        elif(current_slope < steepest_fall):\n",
    "            steepest_fall = current_slope\n",
    "            RFI_end = idx + 2\n",
    "    return (RFI_end - RFI_start)\n",
    "\n",
    "def Get_Polarized_Set(reRL_set, imRL_set, freq_measured):\n",
    "    polarized = []\n",
    "    reRL_set_in_use = reRL_set[:,freq_measured]    #TODO: maybe I can try making something general that I can scan over all frequencies\n",
    "    imRL_set_in_use = imRL_set[:,freq_measured]\n",
    "    for i,j in zip(reRL_set_in_use,imRL_set_in_use):\n",
    "        PI = np.sqrt((i**2)+(j**2))\n",
    "        polarized.append(PI)\n",
    "    return np.array(polarized)\n",
    "\n",
    "def Get_RFI_Excision_Mask(time_array,in_power_array,time_steps,threshold):\n",
    "    # for freq in range(0, len(power_array)):     \n",
    "    mask = np.zeros([len(time_array)])  #Initiate empty mask\n",
    "    start_idx = time_steps\n",
    "    end_idx = len(time_array)-time_steps              \n",
    "    for idx in range(start_idx, end_idx):\n",
    "        if Is_RFI(in_power_array, threshold, idx, idx - time_steps, idx + time_steps):\n",
    "            RFI_duration = Get_RFI_Duration(in_power_array, idx - time_steps, idx + time_steps)\n",
    "            mask[idx - RFI_duration:idx + RFI_duration] = 1\n",
    "    return(mask)\n",
    "\n",
    "def Apply_RFI_Excision_Mask(mask, input_array):\n",
    "    masked_copy = input_array.copy()\n",
    "    for idx in range(0, len(input_array)-1):\n",
    "        if(mask[idx] == 1):\n",
    "            masked_copy[idx] = np.nan\n",
    "    return(masked_copy)\n",
    "\n",
    "def Get_RFI_Excision_Freq_Mask(freq_array, power_spectrum_array, freq_steps, slope_threshold):\n",
    "    interval_start = 0\n",
    "    first_slope = Find_Slope(power_spectrum_array, interval_start)\n",
    "    second_slope = Find_Slope(power_spectrum_array, interval_start + 1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e85baeba",
   "metadata": {},
   "source": [
    "# NEW RFI_Excision functions (WORK IN PROGRESS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b9cd4790",
   "metadata": {},
   "outputs": [],
   "source": [
    "# power_array has time and frequency\n",
    "#TODO: Count how long it takes to run this for a single frequency \n",
    "\n",
    "def Find_Slope(array, idx):\n",
    "    return array[idx+2] - array[idx]\n",
    "\n",
    "def Is_Time_RFI(in_power_array, threshold, idx, interval_start, interval_end):\n",
    "    retVal = False\n",
    "    in_power_mean = np.nanmean(in_power_array[interval_start:interval_end])\n",
    "    in_power_std = np.nanstd(in_power_array[interval_start:interval_end])\n",
    "    if abs(in_power_array[idx]) > abs(in_power_mean)+threshold*in_power_std:\n",
    "        retVal = True\n",
    "    return retVal\n",
    "\n",
    "#TODO: Change the name of the function below to Find_RFI_Excision_Regions, or make a wrapper function to go through all the frequencies\n",
    "\n",
    "# def Get_RFI_Excision_Mask(time_array, power_array, time_steps, slope_threshold, starting_frequency): #TODO: The final function will not take starting_frequency as an input, I'll loop through all frequencies\n",
    "#     confirmed_RFI_events = Find_RFI_Excision_Intervals(time_array, power_array, time_steps, slope_threshold, starting_frequency)\n",
    "#     mask = []\n",
    "#     #TODO: Populate mask\n",
    "#     return mask\n",
    "def RFI_Time_Scan(time_array, single_freq_power_array, time_steps, threshold):\n",
    "    possible_RFI_events = []\n",
    "    start_idx = time_steps\n",
    "    end_idx = len(time_array)-time_steps              \n",
    "    for idx in range(start_idx, end_idx):\n",
    "        if Is_Time_RFI(single_freq_power_array, threshold, idx, idx - time_steps, idx + time_steps):\n",
    "            RFI_duration = Get_RFI_Duration(single_freq_power_array, idx - time_steps, idx + time_steps)\n",
    "            possible_RFI_events.append([idx, RFI_duration])\n",
    "    return(possible_RFI_events)\n",
    "\n",
    "def Spectrum_RFI_Start_Found(spectrum_power_array, idx, slope_threshold):\n",
    "    RFI_Start_Found = False\n",
    "    current_slope = Find_Slope(spectrum_power_array, idx)\n",
    "    next_slope = Find_Slope(spectrum_power_array, idx+3)\n",
    "    if((current_slope <= slope_threshold) and (next_slope >= slope_threshold)):\n",
    "        RFI_Start_Found = True\n",
    "    return RFI_Start_Found\n",
    "\n",
    "def Spectrum_RFI_End_Found(spectrum_power_array, idx, slope_threshold):\n",
    "    RFI_End_Found = False\n",
    "    current_slope = Find_Slope(spectrum_power_array, idx)\n",
    "    next_slope = Find_Slope(spectrum_power_array, idx+3)\n",
    "    if((current_slope <= (-1)*slope_threshold) and (next_slope >= (-1)*slope_threshold)):\n",
    "        RFI_End_Found = True\n",
    "    return RFI_End_Found\n",
    "\n",
    "def RFI_Spectrum_Scan(spectrum_power_array, freq_measured, slope_threshold): #NOTE: This might be an issue if I have a nan value on my array\n",
    "    scan_bandwidth = 50 #[MHz]\n",
    "    start_idx = int(freq_measured - int((scan_bandwidth/df)/2))  #This changes the bandwidth from MHz to idxes\n",
    "    end_idx = int(freq_measured + int((scan_bandwidth/df)/2))\n",
    "    RFI_confirmed = False\n",
    "    RFI_spectral_thickness = 0\n",
    "    for rfi_start_idx in range(start_idx, end_idx):                                             #Scan over the entire bandwith interval\n",
    "        if(Spectrum_RFI_Start_Found(spectrum_power_array, rfi_start_idx, slope_threshold)):     #If I found the starting pattern\n",
    "            for rfi_end_idx in range(rfi_start_idx, end_idx):                                   #Finish looking at the bandwidth interval looking for the end\n",
    "                if(Spectrum_RFI_End_Found(spectrum_power_array, rfi_end_idx, slope_threshold)):     #If I found the ending pattern\n",
    "                    RFI_confirmed = True                                                                #If there's a start and end, I'll confirm that event as RFI\n",
    "                    RFI_spectral_thickness = (rfi_end_idx - rfi_start_idx)\n",
    "            if(RFI_confirmed):                                                                          #and stop looping throught the interval for efficiency\n",
    "                break\n",
    "        if(RFI_confirmed):\n",
    "            break                           #TODO: this looks ugly AF, I should be using else and continue to clean this thing\n",
    "    return RFI_confirmed, RFI_spectral_thickness\n",
    "    \n",
    "def find_nearest_idx(array, value):\n",
    "    array = np.asarray(array)\n",
    "    idx = (np.abs(array - value)).argmin()\n",
    "    return idx\n",
    "\n",
    "def Find_RFI_Regions(time_array, power_array, time_steps, slope_threshold, starting_frequency):\n",
    "    confirmed_RFI_events = []\n",
    "    # mask = np.zeros([len(time_array)])  #Initiate empty mask\n",
    "    # freq_measured = np.min(np.where(abs(freq-starting_frequency)<df))#[0][0] #[MHz]\n",
    "    freq_idx = find_nearest_idx(freq, starting_frequency)\n",
    "    freq_measured = freq[freq_idx]\n",
    "    print(\"input starting frequency:\", starting_frequency)\n",
    "    print(\"closest frequency measured:\", freq_measured)\n",
    "    \n",
    "    gaussian_threshold = 4  #Arbitrary, changed as needed\n",
    "    possible_RFI_events = RFI_Time_Scan(time_array, power_array[:, freq_idx], time_steps, gaussian_threshold) #Returns an array with [idx, RFI_idx_duration] of candidate RFI signals\n",
    "    print(\"possible RFI events:\", len(possible_RFI_events))\n",
    "    for event in range(len(possible_RFI_events)):\n",
    "        dt = (time_array[1] - time_array[0])\n",
    "        RFI_event_time_idx = possible_RFI_events[event][0]              #in [idxes]\n",
    "        RFI_event_duration = possible_RFI_events[event][1]*(dt)         #in [time_units]\n",
    "        # print(\"event\", event, \"happens at\", time_array[possible_RFI_events[event][0]])\n",
    "        #Confirms by doing a small spectrum scan\n",
    "        RFI_event_confirmation_result = RFI_Spectrum_Scan(power_array[RFI_event_time_idx, :], freq_measured, slope_threshold) #Returns [bool, idx_spectral_thickness]\n",
    "        if(RFI_event_confirmation_result[0]):\n",
    "            confirmed_RFI_events.append([freq_measured, RFI_event_confirmation_result[1]*df, time_array[possible_RFI_events[event][0]], RFI_event_duration])\n",
    "    print(\"confirmed RFI events:\", len(confirmed_RFI_events))\n",
    "    return confirmed_RFI_events #An Array with [freq, df, time, dt] for each confirmed RFI\n",
    "\n",
    "###################################################################################################################################################################\n",
    "# in_power_array        Input power array (RR, LL, reRL, imRL) at a single frequency TODO: This needs to change to \n",
    "# numt                  Number of time points to include in the 'window' in which the standard deviation is calculated\n",
    "# threshold             Array of standard deviation thresholds to use in each stage of the RFI excision \n",
    "\n",
    "def Get_Polarized_Set(reRL_set, imRL_set, freq_measured):\n",
    "    polarized = []\n",
    "    reRL_set_in_use = reRL_set[:,freq_measured]    #TODO: maybe I can try making something general that I can scan over all frequencies\n",
    "    imRL_set_in_use = imRL_set[:,freq_measured]\n",
    "    for i,j in zip(reRL_set_in_use,imRL_set_in_use):\n",
    "        PI = np.sqrt((i**2)+(j**2))\n",
    "        polarized.append(PI)\n",
    "    return np.array(polarized)\n",
    "\n",
    "\n",
    "def Apply_RFI_Excision_Mask(mask, input_array): #TODO: This needs to be updated to implement all frequencies\n",
    "    \n",
    "    masked_copy = input_array.copy()\n",
    "    for idx in range(0, len(input_array)-1):\n",
    "        if(mask[idx] == 1):\n",
    "            masked_copy[idx] = np.nan\n",
    "    return(masked_copy)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90880dac",
   "metadata": {},
   "source": [
    "### Read in the file listing the scan start and stop times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "aff50d1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2022-05-18T02:19:57.799 2022-05-18T02:37:59.622\n",
      "3 2022-05-18T02:42:23.768 2022-05-18T03:00:25.975\n",
      "4 2022-05-18T03:04:50.203 2022-05-18T03:22:52.085\n",
      "5 2022-05-18T03:27:16.790 2022-05-18T03:45:18.698\n",
      "6 2022-05-18T03:49:43.137 2022-05-18T04:07:45.238\n",
      "7 2022-05-18T04:12:09.273 2022-05-18T04:30:11.468\n",
      "8 2022-05-18T04:34:35.727 2022-05-18T04:52:37.999\n",
      "9 2022-05-18T04:57:02.029 2022-05-18T05:15:04.069\n",
      "10 2022-05-18T05:19:28.248 2022-05-18T05:37:30.300\n",
      "11 2022-05-18T05:41:54.444 2022-05-18T05:59:56.440\n",
      "12 2022-05-18T06:04:20.926 2022-05-18T06:22:22.771\n",
      "13 2022-05-18T06:26:47.173 2022-05-18T06:44:49.373\n",
      "14 2022-05-18T06:49:13.296 2022-05-18T07:07:15.002\n",
      "15 2022-05-18T07:11:39.591 2022-05-18T07:29:41.713\n",
      "16 2022-05-18T07:34:06.119 2022-05-18T07:52:07.963\n",
      "17 2022-05-18T07:56:32.414 2022-05-18T08:14:34.333\n",
      "18 2022-05-18T08:18:58.755 2022-05-18T08:37:00.654\n",
      "19 2022-05-18T08:41:24.975 2022-05-18T08:59:27.324\n",
      "20 2022-05-18T09:03:51.078 2022-05-18T09:21:52.714\n",
      "21 2022-05-18T09:26:17.720 2022-05-18T09:44:19.794\n",
      "22 2022-05-18T09:48:43.965 2022-05-18T10:06:46.054\n",
      "23 2022-05-18T10:11:10.479 2022-05-18T10:29:12.685\n",
      "24 2022-05-18T10:33:36.387 2022-05-18T10:51:38.126\n",
      "25 2022-05-18T10:56:02.688 2022-05-18T11:14:04.796\n",
      "26 2022-05-18T11:18:29.368 2022-05-18T11:36:31.197\n",
      "27 2022-05-18T11:40:55.633 2022-05-18T11:58:57.587\n",
      "28 2022-05-18T12:03:21.831 2022-05-18T12:21:23.707\n",
      "29 2022-05-18T12:25:47.981 2022-05-18T12:43:49.787\n",
      "30 2022-05-18T12:48:14.335 2022-05-18T13:06:16.489\n",
      "31 2022-05-18T13:10:40.791 2022-05-18T13:28:43.158\n",
      "32 2022-05-18T13:33:06.859 2022-05-18T13:51:08.959\n",
      "33 2022-05-18T13:55:33.563 2022-05-18T14:13:35.550\n",
      "34 2022-05-18T14:17:59.915 2022-05-18T14:36:02.081\n",
      "35 2022-05-18T14:40:25.797 2022-05-18T14:58:27.744\n",
      "36 2022-05-18T15:02:52.161 2022-05-18T15:20:54.065\n",
      "37 2022-05-18T15:25:18.674 2022-05-18T15:43:20.486\n",
      "38 2022-05-18T15:47:44.951 2022-05-18T16:05:46.998\n",
      "40 2022-05-18T16:32:38.248 2022-05-18T16:50:38.248\n",
      "41 2022-05-18T16:55:04.563 2022-05-18T17:13:04.563\n",
      "42 2022-05-18T17:17:30.877 2022-05-18T17:35:30.877\n",
      "43 2022-05-18T17:39:57.191 2022-05-18T17:57:57.191\n",
      "44 2022-05-18T18:02:23.505 2022-05-18T18:20:23.505\n",
      "45 2022-05-18T18:24:49.819 2022-05-18T18:42:49.819\n",
      "46 2022-05-18T18:47:16.133 2022-05-18T19:05:16.133\n",
      "47 2022-05-18T19:09:42.447 2022-05-18T19:27:42.447\n",
      "48 2022-05-18T19:32:08.761 2022-05-18T19:50:08.761\n",
      "49 2022-05-18T19:54:35.075 2022-05-18T20:12:35.075\n",
      "50 2022-05-18T20:17:01.389 2022-05-18T20:35:01.389\n",
      "51 2022-05-18T20:39:27.703 2022-05-18T20:57:27.703\n",
      "60 2022-05-19T00:01:23.931 2022-05-19T00:19:25.784\n",
      "61 2022-05-19T00:23:50.197 2022-05-19T00:41:52.720\n",
      "62 2022-05-19T00:46:16.556 2022-05-19T01:04:18.785\n",
      "63 2022-05-19T01:08:42.781 2022-05-19T01:26:45.201\n",
      "64 2022-05-19T01:31:09.089 2022-05-19T01:49:11.047\n",
      "65 2022-05-19T02:08:32.714 2022-05-19T02:26:34.766\n",
      "66 2022-05-19T02:30:59.091 2022-05-19T02:49:01.341\n",
      "67 2022-05-19T02:53:25.815 2022-05-19T03:11:28.037\n",
      "68 2022-05-19T03:15:52.142 2022-05-19T03:33:54.312\n",
      "69 2022-05-19T03:38:18.363 2022-05-19T03:56:20.416\n",
      "70 2022-05-19T04:00:44.443 2022-05-19T04:18:46.431\n",
      "71 2022-05-19T04:23:10.807 2022-05-19T04:41:12.806\n",
      "72 2022-05-19T04:45:37.047 2022-05-19T05:03:39.172\n",
      "73 2022-05-19T05:08:03.590 2022-05-19T05:26:05.905\n",
      "74 2022-05-19T05:30:29.653 2022-05-19T05:48:31.499\n",
      "75 2022-05-19T05:52:55.956 2022-05-19T06:10:57.975\n",
      "76 2022-05-19T06:15:22.421 2022-05-19T06:33:24.708\n",
      "77 2022-05-19T06:37:48.793 2022-05-19T06:55:51.072\n",
      "78 2022-05-19T07:00:14.987 2022-05-19T07:18:16.957\n",
      "79 2022-05-19T07:22:41.194 2022-05-19T07:40:43.400\n",
      "80 2022-05-19T07:45:07.896 2022-05-19T08:03:10.295\n",
      "81 2022-05-19T08:07:34.167 2022-05-19T08:25:36.319\n",
      "82 2022-05-19T08:30:00.219 2022-05-19T08:48:02.203\n",
      "83 2022-05-19T08:52:26.774 2022-05-19T09:10:28.917\n",
      "84 2022-05-19T09:14:52.865 2022-05-19T09:32:54.862\n",
      "85 2022-05-19T09:37:19.454 2022-05-19T09:55:21.885\n",
      "86 2022-05-19T09:59:45.605 2022-05-19T10:17:47.899\n",
      "87 2022-05-19T10:22:11.691 2022-05-19T10:40:13.692\n",
      "88 2022-05-19T10:44:38.155 2022-05-19T11:02:40.596\n",
      "89 2022-05-19T11:07:04.716 2022-05-19T11:25:06.781\n",
      "90 2022-05-19T11:29:30.861 2022-05-19T11:47:32.794\n",
      "91 2022-05-19T11:51:57.231 2022-05-19T12:09:59.428\n",
      "92 2022-05-19T12:14:23.620 2022-05-19T12:32:25.633\n",
      "93 2022-05-19T12:36:49.985 2022-05-19T12:54:52.226\n",
      "94 2022-05-19T12:59:15.903 2022-05-19T13:17:18.350\n",
      "95 2022-05-19T13:21:42.203 2022-05-19T13:39:44.434\n",
      "96 2022-05-19T13:44:08.506 2022-05-19T14:02:10.788\n",
      "97 2022-05-19T14:06:34.967 2022-05-19T14:24:37.412\n",
      "98 2022-05-19T14:29:01.366 2022-05-19T14:47:03.587\n",
      "99 2022-05-19T14:51:27.648 2022-05-19T15:09:29.820\n",
      "100 2022-05-19T15:13:53.817 2022-05-19T15:31:55.944\n",
      "101 2022-05-19T15:36:20.283 2022-05-19T15:54:22.309\n",
      "102 2022-05-19T15:58:46.383 2022-05-19T16:16:48.332\n",
      "103 2022-05-19T16:21:13.084 2022-05-19T16:39:15.078\n",
      "104 2022-05-19T16:43:39.233 2022-05-19T17:01:40.942\n",
      "105 2022-05-19T17:06:05.288 2022-05-19T17:24:07.456\n",
      "106 2022-05-19T17:28:31.922 2022-05-19T17:46:33.871\n",
      "107 2022-05-19T17:50:57.905 2022-05-19T18:08:59.806\n",
      "108 2022-05-19T18:13:24.469 2022-05-19T18:31:26.450\n",
      "109 2022-05-19T18:35:50.840 2022-05-19T18:53:53.025\n",
      "110 2022-05-19T18:58:17.070 2022-05-19T19:16:18.799\n",
      "111 2022-05-19T19:20:43.441 2022-05-19T19:38:45.775\n",
      "112 2022-05-19T19:43:09.498 2022-05-19T20:01:11.439\n",
      "113 2022-05-19T20:05:35.988 2022-05-19T20:23:38.015\n",
      "114 2022-05-19T20:28:02.431 2022-05-19T20:46:04.489\n",
      "115 2022-05-19T20:50:28.796 2022-05-19T21:08:30.943\n",
      "116 2022-05-19T21:12:55.214 2022-05-19T21:30:57.139\n",
      "117 2022-05-19T21:35:21.519 2022-05-19T21:53:23.453\n",
      "118 2022-05-19T21:57:47.681 2022-05-19T22:15:49.939\n",
      "119 2022-05-19T22:20:13.993 2022-05-19T22:38:16.023\n",
      "120 2022-05-19T22:42:40.062 2022-05-19T23:00:41.889\n",
      "121 2022-05-19T23:05:06.438 2022-05-19T23:23:08.754\n",
      "122 2022-05-19T23:27:32.861 2022-05-19T23:45:34.648\n",
      "123 2022-05-19T23:49:59.179 2022-05-20T00:08:01.434\n",
      "124 2022-05-20T00:12:25.639 2022-05-20T00:30:27.478\n",
      "125 2022-05-20T00:34:51.706 2022-05-20T00:52:53.774\n",
      "126 2022-05-20T00:57:17.939 2022-05-20T01:15:19.777\n",
      "127 2022-05-20T01:19:44.389 2022-05-20T01:37:46.513\n",
      "128 2022-05-20T01:42:10.486 2022-05-20T02:00:12.698\n",
      "129 2022-05-20T02:19:34.621 2022-05-20T02:37:36.855\n",
      "130 2022-05-20T02:42:01.057 2022-05-20T03:00:03.100\n",
      "131 2022-05-20T03:04:26.986 2022-05-20T03:22:29.225\n",
      "132 2022-05-20T03:26:53.342 2022-05-20T03:44:55.170\n",
      "133 2022-05-20T03:49:19.715 2022-05-20T04:07:21.815\n",
      "134 2022-05-20T04:11:46.266 2022-05-20T04:29:48.180\n",
      "135 2022-05-20T04:34:12.579 2022-05-20T04:52:14.974\n",
      "136 2022-05-20T04:56:38.617 2022-05-20T05:14:40.879\n",
      "137 2022-05-20T05:19:05.141 2022-05-20T05:37:07.073\n",
      "138 2022-05-20T05:41:31.339 2022-05-20T05:59:33.597\n",
      "139 2022-05-20T06:03:57.556 2022-05-20T06:21:59.562\n",
      "140 2022-05-20T06:26:23.795 2022-05-20T06:44:25.687\n",
      "141 2022-05-20T06:48:50.421 2022-05-20T07:06:52.840\n",
      "142 2022-05-20T07:11:16.509 2022-05-20T07:29:18.425\n",
      "143 2022-05-20T07:33:42.884 2022-05-20T07:51:44.999\n",
      "144 2022-05-20T07:56:09.372 2022-05-20T08:14:11.413\n",
      "145 2022-05-20T08:18:35.852 2022-05-20T08:36:38.198\n",
      "146 2022-05-20T08:41:01.914 2022-05-20T08:59:04.102\n",
      "147 2022-05-20T09:03:28.455 2022-05-20T09:21:30.424\n",
      "148 2022-05-20T09:25:54.313 2022-05-20T09:43:56.148\n",
      "149 2022-05-20T09:48:21.095 2022-05-20T10:06:23.340\n",
      "150 2022-05-20T10:10:46.961 2022-05-20T10:28:49.104\n",
      "151 2022-05-20T10:33:13.445 2022-05-20T10:51:15.746\n",
      "152 2022-05-20T10:55:39.631 2022-05-20T11:13:41.871\n",
      "153 2022-05-20T11:18:06.287 2022-05-20T11:36:08.268\n",
      "154 2022-05-20T11:40:32.499 2022-05-20T11:58:34.346\n",
      "155 2022-05-20T12:02:58.913 2022-05-20T12:21:00.979\n",
      "156 2022-05-20T12:25:25.167 2022-05-20T12:43:27.102\n",
      "157 2022-05-20T12:47:51.224 2022-05-20T13:05:53.074\n",
      "158 2022-05-20T13:10:17.506 2022-05-20T13:28:19.828\n",
      "159 2022-05-20T13:32:44.004 2022-05-20T13:50:46.220\n",
      "160 2022-05-20T13:55:10.087 2022-05-20T14:13:12.104\n",
      "161 2022-05-20T14:17:36.479 2022-05-20T14:35:38.477\n",
      "162 2022-05-20T14:40:02.944 2022-05-20T14:58:05.082\n",
      "163 2022-05-20T15:02:29.491 2022-05-20T15:20:31.646\n",
      "164 2022-05-20T15:24:55.339 2022-05-20T15:42:57.450\n",
      "165 2022-05-20T15:47:22.060 2022-05-20T16:05:24.395\n",
      "166 2022-05-20T16:09:48.320 2022-05-20T16:27:50.270\n",
      "167 2022-05-20T16:32:14.576 2022-05-20T16:50:16.715\n",
      "168 2022-05-20T16:54:40.873 2022-05-20T17:12:42.999\n",
      "169 2022-05-20T17:17:07.258 2022-05-20T17:35:09.475\n",
      "170 2022-05-20T17:39:33.569 2022-05-20T17:57:35.400\n",
      "171 2022-05-20T18:01:59.845 2022-05-20T18:20:01.954\n"
     ]
    }
   ],
   "source": [
    "scan_num = []    # The scan id number\n",
    "scan_start = []  # Start time of the scan (UTC)\n",
    "scan_stop = []   # Stop time of the scan (UTC)\n",
    "\n",
    "# Read in the data and store it in arrays:\n",
    "with open(directory+'azscans_out_mini_survey_good.txt') as fp:\n",
    "    for line in fp:       \n",
    "        scan_num.append(int(line.split()[0]))\n",
    "        scan_start.append(line.split()[1]+'T'+line.split()[2][0:12])\n",
    "        scan_stop.append(line.split()[3]+'T'+line.split()[4][0:12])\n",
    "\n",
    "# Print out the scan numbers with their start and stop times:\n",
    "for i in range(0,len(scan_num)):\n",
    "    print(scan_num[i],scan_start[i],scan_stop[i])\n",
    "\n",
    "# Convert start and stop times to Modified Julian Day (MJD).\n",
    "# This is needed for plotting and for selecting out data collected\n",
    "# between particular times:\n",
    "scan_start_mjd = Time(scan_start, format='isot',scale='utc').mjd\n",
    "scan_stop_mjd  = Time(scan_stop,  format='isot',scale='utc').mjd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "078df22c",
   "metadata": {},
   "source": [
    "### Read in scan files and stitch them together:\n",
    "#### Note: this will take several minutes to run if stitching together all 3 days of data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7c31928e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<HDF5 file \"Mini_survey_scan_002.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_003.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_004.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_005.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_006.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_007.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_008.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_009.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_010.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_011.h5\" (mode r)>\n",
      "<HDF5 file \"Mini_survey_scan_012.h5\" (mode r)>\n"
     ]
    }
   ],
   "source": [
    "t_set = []\n",
    "az_set = []\n",
    "dec_set = []\n",
    "ra_set = []\n",
    "el_set = []\n",
    "\n",
    "# Use one of the scans to get the list of frequencies:\n",
    "file = h5py.File(directory+'Mini_survey_scan_002.h5','r')\n",
    "freq = file['data']['beam_0']['band_SB0']['frequency'][:]/1e6\n",
    "\n",
    "# Create empty arrays for the power data:\n",
    "RR_set_raw = np.empty([0,len(freq)])\n",
    "LL_set_raw = np.empty([0,len(freq)])\n",
    "reRL_set_raw = np.empty([0,len(freq)])\n",
    "imRL_set_raw = np.empty([0,len(freq)])\n",
    "\n",
    "# Loop through all the scans in the \"scan_num\" list:\n",
    "for i in range(2,13):   #NOTE: This is hardcoded because I only have a few files downloaded locally\n",
    "    \n",
    "    # select the file:\n",
    "    file = h5py.File(directory+'Mini_survey_scan_'+f\"{i:03}\"+'.h5','r')\n",
    "    print(file)\n",
    "    \n",
    "    # access the correct location in the file structure:\n",
    "    dataset = file['data']['beam_0']['band_SB0']['scan_0']\n",
    "    \n",
    "    # Add the position and time data to the corresponding arrays:\n",
    "    dec_set = np.concatenate([dec_set,dataset['metadata']['declination']])\n",
    "    ra_set = np.concatenate([ra_set,dataset['metadata']['right_ascension']])\n",
    "    el_set = np.concatenate([el_set,dataset['metadata']['elevation']])\n",
    "    az_set = np.concatenate([az_set,dataset['metadata']['azimuth']])\n",
    "    t_set = np.concatenate([t_set,dataset['metadata']['utc']])\n",
    "    \n",
    "    # Add the spectrometer power data to the corresponding arrays:\n",
    "    RR_set_raw = np.concatenate([RR_set_raw,dataset['data'][:,0,:]],axis=0)\n",
    "    LL_set_raw = np.concatenate([LL_set_raw,dataset['data'][:,1,:]],axis=0)\n",
    "    reRL_set_raw = np.concatenate([reRL_set_raw,dataset['data'][:,2,:]],axis=0)\n",
    "    imRL_set_raw = np.concatenate([imRL_set_raw,dataset['data'][:,3,:]],axis=0)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cd12cac",
   "metadata": {},
   "source": [
    "### Make a degrees (instead of hours) version of RA, and an MJD version of the time array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "415bf3ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "ra_set_deg = ra_set*360./24.\n",
    "t_plt = Time(t_set, format='isot',scale='utc').mjd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b826cf9e",
   "metadata": {},
   "source": [
    "### Read in the times when the noise source was turned on, and mask this out in the power data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "618d761c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20600\n"
     ]
    }
   ],
   "source": [
    "t_noise1 = []\n",
    "t_noise2 = []\n",
    "\n",
    "with open(directory+'noise_mini_survey_part1.txt') as fp:\n",
    "    for line in fp:       \n",
    "        t_noise1.append(line.split()[0]+'T'+line.split()[1][0:12])\n",
    "        t_noise2.append(line.split()[2]+'T'+line.split()[3][0:12])\n",
    "\n",
    "t_noise1_plt = Time(t_noise1, format='isot',scale='utc').mjd\n",
    "t_noise2_plt = Time(t_noise2, format='isot',scale='utc').mjd\n",
    "\n",
    "# Buffer time (in seconds) around data points where noise source\n",
    "# is being turned on or off:\n",
    "t_buff = 1./(3600.*24.)\n",
    "\n",
    "# Make copies of the arrays in which noise will be masked out:\n",
    "RR_set = RR_set_raw.copy()\n",
    "LL_set = LL_set_raw.copy()\n",
    "reRL_set = reRL_set_raw.copy()\n",
    "imRL_set = imRL_set_raw.copy()\n",
    "\n",
    "print(len(LL_set))\n",
    "\n",
    "# #Extract masks TODO: Currenct my Get_RFI_Excision_Mask only works for a single frequency\n",
    "# time_steps = 30\n",
    "# threshold = 4\n",
    "# RR_mask = Get_RFI_Excision_Mask(t_plt, RR_set, time_steps, threshold)\n",
    "# LL_mask = Get_RFI_Excision_Mask(t_plt, LL_set, time_steps, threshold)\n",
    "# reRL_mask = Get_RFI_Excision_Mask(t_plt, reRL_set, time_steps, threshold)\n",
    "# imRL_mask = Get_RFI_Excision_Mask(t_plt, imRL_set, time_steps, threshold)\n",
    "\n",
    "# Loop through times when noise source was turned on and replace\n",
    "# data values with NaN at those times:\n",
    "for i in range(0,len(t_noise1)):\n",
    "    wnoise_sub_rem = np.where( (t_plt >= t_noise1_plt[i]-t_buff) & (t_plt <= t_noise2_plt[i]+t_buff) )[0]\n",
    "    RR_set[wnoise_sub_rem,:] = np.nan\n",
    "    LL_set[wnoise_sub_rem,:] = np.nan\n",
    "    reRL_set[wnoise_sub_rem,:] = np.nan\n",
    "    imRL_set[wnoise_sub_rem,:] = np.nan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "807955c5",
   "metadata": {},
   "source": [
    "### Plot the scans in RA/dec at a particular frequency:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "119a8b08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Pick frequency to plot: ############\n",
    "freq_plt = 800. # in MHz\n",
    "########################################\n",
    "\n",
    "w = np.where(abs(freq-freq_plt)<df)[0][0]\n",
    "\n",
    "fs = 12\n",
    "fig1, axs = plt.subplots(1,1,figsize=(16,6))\n",
    "\n",
    "axs.scatter(ra_set_deg, dec_set,s=2,c=10.*np.log10(LL_set[:,w]),cmap='viridis',vmin=70.5, vmax=71.5)\n",
    "axs.set_xlabel('RA (deg.)',fontsize=fs)\n",
    "axs.set_ylabel('dec (deg.)',fontsize=fs)\n",
    "axs.tick_params(axis=\"x\", labelsize=fs)\n",
    "axs.tick_params(axis=\"y\", labelsize=fs)\n",
    "axs.set_xlim(360,0)\n",
    "axs.set_ylim(0,90)\n",
    "axs.set(aspect='equal')\n",
    "axs.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "336510ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f9a2efdde0d0453da357fc7973608d57",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Checkbox(value=True, description='waterfall_enabled'), Output()), _dom_classes=('widget-…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.DVA_Visualization(waterfall_enabled)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#TODO: Maybe I could create an interactive plot that if I tick a box I could flip to a power vs frequency plot or power vs time plot\n",
    "#I should have a knob for changing frequency and time\n",
    "#I could also introduce a vertical line to show which slice I'm currently at to help navigating through the data\n",
    "df = freq[1]-freq[0]\n",
    "\n",
    "def DVA_Waterfall_View(scan_id, show_all_scans):\n",
    "    #TODO: Add another DVA_Waterfall interactive_function such that I can change between LL_Set, RR_set, etc...\n",
    "    power_min = 70\n",
    "    power_max = 78\n",
    "    if not show_all_scans:\n",
    "        w = np.where(np.array(scan_num) == scan_id)[0][0]\n",
    "        t1_plt = scan_start_mjd[w]\n",
    "        t2_plt = scan_stop_mjd[w]\n",
    "        ######################################\n",
    "        wplot = np.where( (t_plt <= t2_plt) & (t_plt >= t1_plt) )\n",
    "\n",
    "        time_plot = t_plt[wplot]\n",
    "\n",
    "        fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "        fs = 16\n",
    "\n",
    "        im = axs.imshow(10.*np.log10(LL_set[wplot].T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "                    extent=[time_plot[0],time_plot[-1],freq[0],freq[-1]])\n",
    "\n",
    "        divider = make_axes_locatable(axs)\n",
    "        cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "        cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "        cbar.ax.tick_params(labelsize=fs) \n",
    "        cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "        axs.set_xlim(time_plot[0],time_plot[-1])\n",
    "        axs.set_ylim(freq[0],freq[-1])\n",
    "        axs.tick_params(axis='both', labelsize=fs)\n",
    "        axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "        axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "        axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "        axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "    else:\n",
    "        fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "        fs = 16\n",
    "\n",
    "        im = axs.imshow(10.*np.log10(LL_set.T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "                    extent=[t_plt[0],t_plt[-1],freq[0],freq[-1]])\n",
    "\n",
    "        divider = make_axes_locatable(axs)\n",
    "        cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "        cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "        cbar.ax.tick_params(labelsize=fs) \n",
    "        cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "        axs.set_xlim(t_plt[0],t_plt[-1])\n",
    "        axs.set_ylim(freq[0],freq[-1])\n",
    "        axs.tick_params(axis='both', labelsize=fs)\n",
    "        axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "        axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "        axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "        axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "\n",
    "def DVA_Cross_Sections(scan_id, freq_chosen, time_idx, freq_cross_section):\n",
    "    freq_measured = np.where(abs(freq-freq_chosen)<df)[0][0]\n",
    "    \n",
    "    w = np.where(np.array(scan_num) == scan_id)[0][0]\n",
    "    t1 = scan_start[w]\n",
    "    t2 = scan_stop[w]\n",
    "    t1_plt = scan_start_mjd[w]\n",
    "    t2_plt = scan_stop_mjd[w]\n",
    "    \n",
    "    wplot = np.where((t_plt>=t1_plt) & (t_plt<=t2_plt))\n",
    "    \n",
    "    polarized_set = Get_Polarized_Set(reRL_set, imRL_set, freq_measured)\n",
    "    time_steps = 30\n",
    "    threshold = 4\n",
    "    polarized_mask = Get_RFI_Excision_Mask(t_plt[wplot], polarized_set[wplot], time_steps, threshold)\n",
    "    LL_set_with_polarized_mask = Apply_RFI_Excision_Mask(polarized_mask, LL_set[wplot])\n",
    "    \n",
    "    fs = 12\n",
    "    fig, axs = plt.subplots(1,1,figsize=(12,6))\n",
    "    axs.scatter(ra_set_deg[wplot], dec_set[wplot],s=2,c=10.*np.log10(LL_set[wplot,freq_measured]),\n",
    "                cmap='viridis',vmin=70.5, vmax=71.5)\n",
    "    axs.set_xlabel('RA (deg.)',fontsize=fs)\n",
    "    axs.set_ylabel('dec (deg.)',fontsize=fs)\n",
    "    axs.tick_params(axis=\"x\", labelsize=fs)\n",
    "    axs.tick_params(axis=\"y\", labelsize=fs)\n",
    "    axs.set_xlim(360,0)\n",
    "    axs.set_ylim(0,90)\n",
    "    axs.set(aspect='equal')\n",
    "    axs.grid()\n",
    "    \n",
    "    \n",
    "    fig,axs1 = plt.subplots(1,1,figsize=(16,6))  \n",
    "    # TODO: use the log of LL_set_clean\n",
    "\n",
    "    if(freq_cross_section):\n",
    "        time_chosen = int(time_idx/len(LL_set_with_polarized_mask)) #NOTE: I have no idea what 100 actually means\n",
    "        axs1.plot(freq, LL_set_with_polarized_mask[time_chosen,:], label = 'LL_set with polarized mask')   #I need to plot freq vs power\n",
    "        axs1.vlines(freq_chosen, 0 , 100e9, color = 'red')\n",
    "        axs1.set_ylim(0, np.max(LL_set_with_polarized_mask[time_chosen,:]))\n",
    "        axs1.set_xlabel('Frequency',fontsize=fs)\n",
    "        axs1.set_ylabel('Power',fontsize=fs)\n",
    "    else:\n",
    "        # axs.plot(t_plt_one_scan,wplot[0])\n",
    "        axs1.plot(t_plt[wplot], LL_set[wplot,freq_measured][0], label = 'LL_set unmasked RFI')\n",
    "        axs1.plot(t_plt[wplot], LL_set_with_polarized_mask[:,freq_measured], label = 'LL_set with polarized mask')\n",
    "        axs1.plot(t_plt[wplot], polarized_set[wplot], label = 'polarized set')\n",
    "        axs1.set_ylim(0, np.nanmax(LL_set_with_polarized_mask[:,freq_measured]))\n",
    "        axs1.vlines(t_plt[time_idx], 0 , 100e9, color = 'red')\n",
    "\n",
    "        axs1.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "        axs1.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "        axs1.set_xlabel('Time (UTC)',fontsize=fs)\n",
    "        axs1.set_ylabel('Power',fontsize=fs)\n",
    "        axs1.legend()\n",
    "\n",
    "def DVA_Visualization(waterfall_enabled):             #TODO: use t_plt, polarized_plot, ymasked as inputs on this function so I can use it at different locations\n",
    "    if waterfall_enabled:\n",
    "        interact(DVA_Waterfall_View, scan_id = (2,12), show_all_scans = False)\n",
    "    else:\n",
    "        interact(DVA_Cross_Sections, scan_id = (2,12), freq_chosen = (350, 1000, df), freq_cross_section = False, time_idx = (0,len(t_plt)-1))\n",
    "\n",
    "\n",
    "interact(DVA_Visualization, waterfall_enabled = True)\n",
    "\n",
    "#TODO: I could try to figure out if I could zoom in on time, and adjust the dec vs RA plot accordingly\n",
    "#TODO: plot power in DB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2744f954",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input starting frequency: 850\n",
      "closest frequency measured: 849.75\n",
      "possible RFI events: 4\n",
      "confirmed RFI events: 4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Frequency (MHz)')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_steps = 30\n",
    "slope_threshold = 10000 #This number needs to be adjusted in order to correctly filter out non-RFI NOTE: 5000 works\n",
    "LL_Set_RFI_Regions = Find_RFI_Regions(t_plt, LL_set, time_steps, slope_threshold, 850) #Returns an array of [freq, df, time, dt]\n",
    "\n",
    "first_RFI_region = LL_Set_RFI_Regions[3]\n",
    "\n",
    "#Try plotting the first RFI_Region\n",
    "\n",
    "power_min = 69\n",
    "power_max = 75\n",
    "\n",
    "t1_plt = first_RFI_region[2] - first_RFI_region[3]\n",
    "t2_plt = first_RFI_region[2] + first_RFI_region[3]\n",
    "\n",
    "freq1 = first_RFI_region[0] - first_RFI_region[1]\n",
    "freq2 = first_RFI_region[0] + first_RFI_region[1]\n",
    "######################################\n",
    "rfi_start_idx = find_nearest_idx(t_plt, t1_plt)\n",
    "rfi_end_idx = find_nearest_idx(t_plt, t2_plt)\n",
    "\n",
    "f_plt_start_idx = find_nearest_idx(freq, freq1)\n",
    "f_plt_end_idx = find_nearest_idx(freq, freq2)\n",
    "\n",
    "RFI_duration_time = t_plt[rfi_start_idx: rfi_end_idx]\n",
    "\n",
    "RFI_freq_bandwith = freq[f_plt_start_idx: f_plt_end_idx]\n",
    "\n",
    "\n",
    "fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "fs = 16\n",
    "\n",
    "im = axs.imshow(10.*np.log10(LL_set[rfi_start_idx: rfi_end_idx,f_plt_start_idx: f_plt_end_idx].T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "            extent=[RFI_duration_time[0],RFI_duration_time[-1],RFI_freq_bandwith[0],RFI_freq_bandwith[-1]])\n",
    "\n",
    "divider = make_axes_locatable(axs)\n",
    "cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "cbar.ax.tick_params(labelsize=fs) \n",
    "cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "axs.set_xlim(RFI_duration_time[0],RFI_duration_time[-1])\n",
    "# axs.set_ylim(RFI_freq_bandwith[0],RFI_freq_bandwith[-1])\n",
    "axs.tick_params(axis='both', labelsize=fs)\n",
    "axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "\n",
    "#TODO: I don't think it's clear which region this method is flaggin as RFI\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ade17336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input starting frequency: 900\n",
      "closest frequency measured: 899.75\n",
      "possible RFI events: 2\n",
      "confirmed RFI events: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Frequency (MHz)')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7oAAAJdCAYAAAAcMgvjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABYUklEQVR4nO3dd5xtZXn3/8/3FJpAqBZMBIwmRiyYEAULNp6ADSsqikdFQdT402BLnqghiiUaCyZRJCpiBfuDRgElglGxIAHliAVEY0HawUI7ba7fH2uN2ezZM7PnzMyevfd83rzWa2buda973Wv2PjNcc90lVYUkSZIkSeNixVJ3QJIkSZKkhWSgK0mSJEkaKwa6kiRJkqSxYqArSZIkSRorBrqSJEmSpLFioCtJkiRJGisGupIkSZKkaSU5J0lNc5zRUW+fJJ9M8sskNyRZm+TFSVYNus8Dv6EkSZIkaaQ8D9ixq+wA4C3A6QBJ9gDOAX4BvAi4Bngo8Cbg1sDLB9PVRqpqkPeTJEmSJI24JO8BjgBuV1XrkhwNvAv406r6YUe9U4EHVtXtBtk/hy5LkiRJkvqWZFvgMOAzVbWuLd6q/fjbruq/ZgniTgNdSZIkSdJcPA7YATilo+xjNMOV/zXJ3kl2TPJY4GnAmwfdQYcuS5IkSZL6luRMYF/g9lW1qaP8TsD/A+7aFhVwXFW9etB9XPaLUW2VrWsbbrXU3ZAkSZKkvtzMDWyo9QE4+MG3qmvXbZ5Xe9/+zvq1wM0dRSdV1Um96raLTh0EnNAV5O4OfBK4AXgCcC3wEOAVSdZX1T/Nq5NztOwD3W24FffJQ5e6G5IkSZLUl2/U2b///Np1m/nmmXeYV3srb/ejm6tqvz6rH0EzBfaUrvKXAXsBe1bVdW3ZOUlWAq9J8p6qumZeHZ0D5+hKkiRJkvq1Brioqi7qKr87cGlHkDvpm8Bq4E6D6NwkA11JkiRJGlEFTMzzv34l2Q/Yh6nZXIBfAXdKsnNX+X3aj7/YkufbUst+6LIkSZIkqS9rgE3Ah3ucOxF4KnBWkjfRzNF9EPAS4FNV9bNBdRKWIKOb5MFJvpLkpiTrknwgyW1mueZdSSrJB3uc2ybJm5Jc0bZ5XpIDF+8JJEmSJGlYFJtrYl5HP5KsBg4HzqiqK6f0ourrwAOAq4ETgNNptiF6NU0APFADzegmeQBwFnAm8HhgV+B44Owkf1FV63tcc1+ab0z3xsOT3gM8Angp8GPg+cCZSQ6oqgsX/CEkSZIkaZmpqo3A7rPU+Trw8MH0aGaDHrr8D8BPgcdMLkWd5Ps0E5SfBbyjs3L7V4OTgNcCz+luLMk9gacAR1bVyW3ZucBamr8cHLpoTyJJkiRJS6yZo1tL3Y2hM+ihy/sDX+jcb6mqvkUzfvuxPeq/FFgJvHma9g4FNgKndbS3CTgVODjJ1gvUb0mSJEnSiBh0RnczsKFH+Xrgbp0FSf4YeAXwiKrakKRXe/sAl1fVjV3la4GtaJawXjvfTkuSJEnSsJrLysnLxaAD3R/QZHV/L8mewO1oMrOdTgQ+WVVfmqG9XYDufZoA1nWclyRJkiQtI4MOdE8APpjkeODtNIHoScBEewCQ5AjgL4G7zNJeoOeA9J7p3472jwaOBtiG7frtuyRJkiQNlaLYXM7R7TbQObpV9SGaVZZfDFwJfI9m4+DPAVcAJNkeeAvwT8DNSXZKslPb19Xt16vbJtfRO2u7c8f5Xv04qar2q6r9VuM0XkmSJEkaJwPfR7eqXgnsBtwDuF1VHQ7cGfhKW2U3mmWrX0czLHny+CPgie3nj2jrrgX2TtKdlr0rzVzgSxfvSSRJkiRp6U1Q8zrG0cADXYCquqGqvltVVyY5hGaI8ont6V8BD+5xXAl8sf18Mig+HVgNHDbZdpJVwJOAs3rtyytJkiRJGm8DnaOb5F7Aw4AL2qL702wh9Maq+hpAVd0MnNPj2puBK6vq9+eq6sIkpwFva4czXw48F9gbeOriPYkkSZIkaVgNejGqDcDDgZcBWwOXAMdU1cnzaPOZwGtp5v7uBFwEHFJVF8x0kSRJkiSNugI2j+nw4/kYaKBbVWtpsrhbcu1e05TfBBzbHpIkSZKkZW7QGV1JkiRJ0gIa1wWl5mNJFqOSJEmSJGmxmNGVJEmSpBFVwOYyo9vNjK4kSZIkaayY0ZUkSZKkETax1B0YQmZ0JUmSJEljxYyuJEmSJI2ootxHtwczupIkSZKksWJGV5IkSZJGVcFmE7pTmNGVJEmSJI0VM7qSJEmSNKIKV13uxYyuJEmSJGmsmNGVJEmSpJEVNpOl7sTQMaMrSZIkSRorBrqSJEmSpLHi0GVJkiRJGlEFTLi90BRmdCVJkiRJY8WMriRJkiSNMBejmsqMriRJkiRprJjRlSRJkqQRVZjR7cWMriRJkiRprJjRlSRJkqQRNlFmdLuZ0ZUkSZIkjRUzupIkSZI0opyj25sZXUmSJEnSWDGjK0mSJEkjqgibzV9O4XdEkiRJkjRWzOhKkiRJ0ghz1eWpzOhKkiRJksaKGV1JkiRJGlGuutybGV1JkiRJ0lgx0JUkSZIkjRWHLkuSJEnSyAqby/xlN78jkiRJkqSxYkZXkiRJkkZUARPmL6fwOyJJkiRJGitmdCVJkiRphLm90FRmdCVJkiRJY8WMriRJkiSNqCpXXe7F74gkSZIkaayY0ZUkSZKkETbhHN0pzOhKkiRJksaKGV1JkiRJGlEFbDZ/OYXfEUmSJEnSWDHQlSRJkqSR1ay6PJ9j1jsk5ySpaY4z2jrvm6HO9xf929DFocuSJEmSpJk8D9ixq+wA4C3A6e3XrwFO7KqzF/CRjjoDY6ArSZIkSSOqgIlFHqhbVd/rLktyFLABOLWtcxlwWVed/9N+esqidrAHhy5LkiRJkvqWZFvgMOAzVbVuhqprgG9X1drB9Ox/GehKkiRJkubiccAOzJCpTXI/4E4z1VlMDl2WJEmSpBG2uTLoW64BrgI+P0udjTRzdAfOjK4kSZIkLW+7JTm/4zh6uopJ9gAOAj5UVZumqbM18ETgs1V1zeJ0eWZmdCVJkiRpRBVh8/zzl9dU1X591j2CJmE605DkRwM7zVJnUQ08o5vkwUm+kuSmJOuSfCDJbbrq/EWSM5L8IsnNSX6V5HNJDujR3jZJ3pTkirbN85IcOLgnkiRJkqRlYw1wUVVdNEOdpwPXAJ8bTJemGmigm+QBwFnAr4HHAy8EDgTObtPbk3YCLgVeDBwMvKAtOzfJvbuafQ9wFPAq4JHAFcCZSfZdpMeQJEmSpKExUSvmdfQryX7APsy8CNVtgL8CPlxVG+f9cFto0EOX/wH4KfCYyfHcSb4PfBN4FvAOgKo6Gzi788IkZ9D8VeBpbX2S3BN4CnBkVZ3clp0LrAVeDRy6+I8kSZIkScvCGmAT8OEZ6jyVJs5csmHLMPihy/sDX+ictFxV3wKuBR47y7U3AOtpVu6adGj79Wkd7W2i2bT44K4ssSRJkiSNlQI2s2JeRz+SrAYOB86oqitnqPp04OKqumD+T7flBp3R3Qxs6FG+Hrhbd2GSFcBK4HbA37bF7+6osg9weVXd2HXpWmArmn2bBr45sSRJkiSNk3YY8u591LvnALozq0EHuj+gyer+XpI9aQLZXuO3P0ozlxeafZoeXlXf6zi/C3Bdj+vWdZyXJEmSpLFUZCn20R16gx66fAJw7yTHJ7l1krsAHwAm2qPby4B70wS7FwOfbSdATwpNtr7bjK90kqMn94jayPoteQ5JkiRJ0pAaaKBbVR8CjqdZTflK4HvAL2iWnb6iR/0fV9W3quqTwMNosrrHd1RZR++s7c4d53v146Sq2q+q9luN03glSZIkja4JVszrGEcDf6qqeiWwG3AP4HZVdThwZ+Ars1y3AfgOzbzbSWuBvZNs11X9rjRzgS9dqH5LkiRJkkbDkoTvVXVDVX23qq5McghwF+DEma5pg9n9gMs6ik8HVgOHddRbBTwJOKuqHJcsSZIkaWxVweZaMa9jHA10Maok96IZgjy51PT9gZcCb6yqr3XUexfNsOPzafbO3RP4a5pFq542Wa+qLkxyGvC2drnry4HnAnvT7N8kSZIkSVpmBr3q8gbg4TSLTG0NXAIcU1Und9X7BvBs4GjgVjTzeL8BPKuqvttV95nAa2nm7u4EXAQcstT7NkmSJEnS4gsTM6/FuywNNNCtqrU0WdzZ6r0XeG+fbd4EHNsekiRJkqRlbjwHZEuSJEmSlq1BD12WJEmSJC2QgrFdUGo+/I5IkiRJksaKGV1JkiRJGmGbzV9O4XdEkiRJkjRWzOhKkiRJ0ogqwkS5vVA3M7qSJEmSpLFiRleSJEmSRphzdKfyOyJJkiRJGitmdCVJkiRpRBUw4T66U/gdkSRJkiSNFTO6kiRJkjSywmZcdbmbGV1JkiRJ0lgxoytJkiRJI8o5ur35HZEkSZIkjRUzupIkSZI0wpyjO5UZXUmSJEnSWDGjK0mSJEkjqirO0e3B74gkSZIkaawY6EqSJEmSxopDlyVJkiRphG126PIUfkckSZIkSWPFjK4kSZIkjagCJtxeaAozupIkSZKksWJGV5IkSZJGVpyj24PfEUmSJEnSWDGjK0mSJEkjqoCJco5uNzO6kiRJkqSxYkZXkiRJkkbYZvOXU/gdkSRJkiSNFTO6kiRJkjSiijhHtwczupIkSZKksWJGV5IkSZJG2IT5yyn8jkiSJEmSxooZXUmSJEkaUVWw2Tm6U5jRlSRJkiSNFQNdSZIkSdJYceiyJEmSJI0wtxeayoyuJEmSJGmsmNGVJEmSpBFVhIkyf9nN74gkSZIkaayY0ZUkSZKkEbYZ5+h2M6MrSZIkSRorZnQlSZIkaUQVrrrcixldSZIkSdJYMaMrSZIkSSPLVZd78TsiSZIkSRorBrqSJEmSNMImyLyO2SQ5J0lNc5zRVXf/JGck+XWSG5J8N8mTF+3hp+HQZUmSJEnSTJ4H7NhVdgDwFuD0yYIkjwA+BXwYeAqwAbgrsM1guvm/DHQlSZIkaURVweZFXnW5qr7XXZbkKJpA9tT26x2Ak4F3VNWLOqp+cVE7Nw2HLkuSJEmS+pZkW+Aw4DNVta4tPgzYHXjzknWsw8AD3SQPTvKVJDclWZfkA0lu01XnoUk+mOSytt5lSd6Z5NY92tsmyZuSXNHWPS/JgYN7IkmSJElaOhO1Yl7HFngcsANwSkfZ/YF1wN3bebmbkvwsyT8kWbkAjzknAw10kzwAOAv4NfB44IXAgcDZSbbuqHoMsCtwPHAI8HrgUODrSbbvavY9wFHAq4BHAlcAZybZd9EeRJIkSZKWrzXAVcDnO8r2ALajmZ/7PuAgmkD4lcA/D7h/A5+j+w/AT4HHVNUmgCTfB74JPAt4R1vveVV1dcd15yb5IXAu8ETgve2196SZ5HxkVZ3clp0LrAVeTRMcS5IkSZKmt1uS8zu+PqmqTupVMckeNEHsCZMxXWsFzaJTf19Vb2nLzkmyK/D8JMdV1W8Wo/O9DHro8v7AFzq/IVX1LeBa4LEdZVf3uPZb7cfbd5QdCmwETuu4dhPNhOiDu7LEkiRJkjRWijBR8zuAa6pqv46jZ5DbOoImjjylq/za9uMXusrPAlYD+yzE8/Zr0IHuZpqVubqtB+42y7UPbD9e0lG2D3B5Vd3YVXctsBVwpy3ppCRJkiSppzXARVV1UVf52vZjdZVPLgk9sai96jLoQPcHNFnd30uyJ3A7YJfpLmqXqn4bTZD76Y5TuwDX9bhkXcd5SZIkSRpbE2ReR7+S7EeTbOzO5sL/xmmHdJUfDNwMXLwFj7bFBj1H9wTgg0mOB95OE4ieRBPd94zwk6wCPkIzZPl+XePAw9S/GEyWTyvJ0cDRANuw3RwfQZIkSZKWpTXAJpoFp26hqi5O8j7g1UlWABfQzOV9NvCaqrp+kB0daKBbVR9KchfgJcDf0wSppwGfo8fQ5fYbdArNN+gRVfWdrirrgDv0uNXOHed79eMkmgCbHbNLr0BZkiRJkoZeweQ820WVZDVwOHBGVV05TbXnAL8AXgDcBvgJcGxVnbDoHewy6IwuVfXKJG8A7ghcVVVXJrkE+EqP6icCTwKeUFVn9zi/Fnhsku265unelWYu8KUL3H1JkiRJWnaqaiOw+yx1NgCvaI8lNeg5ugBU1Q1V9d02yD0EuAtNUPt7Sd5Mk+Z+ZlV9epqmTqdZweuwjutW0QTHZ1XV+sXovyRJkiQNi4laMa9jHA00o5vkXsDDaMZrA9wfeCnwxqr6Wke9lwPH0uyX+6MknQtYXV1VlwFU1YVJTgPe1qbSLweeC+wNPHWxn0eSJEmSNHwGPXR5A/Bw4GXA1jSrKB9TVSd31XtY+/HI9uh0CvCMjq+fCbwWOB7YCbgIOKSqLkCSJEmSxtn/7oWrDoNejGotTRZ3tnoPmkObN9Fkf4/d8p5JkiRJksbFwBejkiRJkiQtjII57YW7XIznzGNJkiRJ0rJlRleSJEmSRphzdKcyoytJkiRJGitmdCVJkiRpRBVmdHsxoytJkiRJGisGupIkSZKkseLQZUmSJEkaYQ5dnsqMriRJkiRprJjRlSRJkqQRVcSMbg9mdCVJkiRJY8WMriRJkiSNsAnM6HYzoytJkiRJGitmdCVJkiRpVJWrLvdiRleSJEmSNFbM6EqSJEnSiCrM6PZiRleSJEmSNFbM6EqSJEnSCDOjO5UZXUmSJEnSWDGjK0mSJEkjqogZ3R7M6EqSJEmSxooZXUmSJEkaYWVGdwozupIkSZKksWKgK0mSJEkaKw5dliRJkqQRNoFDl7uZ0ZUkSZIkjRUzupIkSZI0oqpwe6EezOhKkiRJksaKGV1JkiRJGmFuLzSVGV1JkiRJ0lgxoytJkiRJIyvO0e3BjK4kSZIkaayY0ZUkSZKkEeYc3anM6EqSJEmSxooZXUmSJEkaUYX76PZiRleSJEmSNFbM6EqSJEnSqCqoWupODB8zupIkSZKksWJGV5IkSZJG2ATO0e1mRleSJEmSNFYMdCVJkiRJY8Why5IkSZI0ogootxeawoyuJEmSJGmsmNGVJEmSpJEVJszoTmFGV5IkSZI0VszoSpIkSdIIq1rqHgwfM7qSJEmSpLFiRleSJEmSRpirLk9lRleSJEmSNFbM6EqSJEnSiKoyo9uLGV1JkiRJ0lgZeKCb5MFJvpLkpiTrknwgyW266uyQ5J+TnJPkt0kqyYOmaW+bJG9KckXb5nlJDhzEs0iSJEnSUpuozOuYTRuX1TTHGW2dvWaos9Nifw+6DXTocpIHAGcBZwKPB3YFjgfOTvIXVbW+rborcCRwAfAF4HEzNPse4BHAS4EfA88HzkxyQFVduBjPIUmSJEnLyPOAHbvKDgDeApzeVf76HmW/W6R+TWvQc3T/Afgp8Jiq2gSQ5PvAN4FnAe9o6/20qnZpzx/ENIFuknsCTwGOrKqT27JzgbXAq4FDF+9RJEmSJGnpLfY+ulX1ve6yJEcBG4BTu079uKq+vrg9mt2ghy7vD3xhMsgFqKpvAdcCj+0o6/elOhTYCJzWce0mmm/2wUm2XohOS5IkSZIaSbYFDgM+U1Xrlro/vQw60N1ME/V3Ww/cbQva2we4vKpu7CpfC2wF3GkL2pQkSZKkkVGVeR1b4HHADsApPc69PsmmJL9JcnqSu8/r4bbQoIcu/4Amq/t7SfYEbkeTmZ2rXYDrepSv6zgvSZIkSVo4a4CrgM93lK0H3kWzJtPVwF2A/wt8Lcm9q+qSQXZw0BndE4B7Jzk+ya2T3AX4ADDRHnMVoNcw5xn/LJHk6CTnJzl/I+tnqipJkiRJ4263yfioPY6ermKSPYCDgA91TUm9oqqOqapPVtV/VdW/AwfSxGt/v+hP0GWgGd2q+lAb3L6E5mGLZn7t59iyocvrgDv0KN+543yvfpwEnASwY3ZZ5KnbkiRJkrQ4ii0eftzpmqrar8+6R9AkTHsNW76FqvpZkq8Afzmfzm2Jge+jW1WvBHYD7gHcrqoOB+4MfGULmlsL7J1ku67yu9LMBb50Pn2VJEmSJN3CGuCiqrqoz/rTjcJdVH0Fukn2T3JckjOSfCfJj5Kcl+R9SZ6ZZOfZW/lfVXVDVX23qq5McgjN+O0Tt6D/pwOraVb8muzrKuBJwFkd+/JKkiRJ0liqeR79SrIfzYLAs2Zz2/p3AO4HfGMOt1kQMw5dTvJ0mmHG+wC/Bb4D/Ai4iWahp/sATwP+LclHgX+sqstnaO9ewMOAC9qi+wMvBd5YVV/rqvsw4FbA5CpdD0yyG3BDVX0eoKouTHIa8LYkq4HLgecCewNP7es7IEmSJEnqxxpgE/Dh7hNJ3kyTSD2PZjGqPwX+jmYtptcNsI/ADIFukouAWwPvp3mgC3vtb5vkD4BH0gSWa5M8s6pO667X2gA8HHgZsDVwCXBMVZ3co+47gT07vj6u/fhTYK+O8mcCrwWOB3YCLgIOqaoLkCRJkqRxVizEHN1ZtYnFw4EzqurKHlXW0iQdn0Gz9dA1wH/SJEN/sOgd7DJTRvdk4MSqunmmBqrqN8CHgA8luSdw2xnqrqXJ4s6qqvbqs95NwLHtIUmSJElaYFW1Edh9hvPvBd47uB7NbNpAt6reNtfG2gnJ/U5KliRJkiTNl/vITNHvYlQHJtlrmnM7JDlwQXslSZIkSdIW6nd7oXOA7yZ5VI9zdwW+tGA9kiRJkiT1rSrzOsbRXPbRvRD4ZJK/WaS+SJIkSZI0bzNuL9TlxcCBwJuS/Anw/KqaWJxuSZIkSZL6MXVvHM0l0KWq/jnJD2hWWd47yRMXp1uSJEmSJG2ZuQxdBqCqPgM8ALgL8FVg74XulCRJkiRpdoVzdHuZc6ALv99G6D7ADcD7FrJDkiRJkiTNR79Dl08Bru4sqKorkzwQOAH404XumCRJkiRpFgWMaVZ2PvoKdKvqmdOUrweOWdAeSZIkSZI0D1s0dFmSJEmSpGE1bUY3yQRNIrwfVVVzWsFZkiRJkjR/bi801UzB6eu4ZaC7Avg74L3AFYvZKUmSJEmSttS0gW5VvaLz6yQraQLdd1TVBYvdMUmSJElSH8zoTuEcXUmSJEnSWHFerSRJkiSNrFBuLzSFGV1JkiRJ0ljZkoyuI8AlSZIkaVgYoU0x0/ZC7+8uaj++Jsm6rnNVVU9f0J5JkiRJkrQFZsroHsjUvw38FNinR13/hiBJkiRJg1Y4R7eHmbYX2muA/ZAkSZIkLUNJtgIeBxwC7A/sAWwDXAv8ADgXOK2qvtdvm666LEmSJEmjbETH1ybZDngp8NfAzsAlwDeBq4GbgF2AvYHnA69I8hXg/1bVV2dr20BXkiRJkrQULgN+BbwK+GhVXTtdxST3A44Azkzy4qp610wNz7QY1f/MoYNVVXvOob4kSZIkaUGM7Bzd51bVp/up2GZxv5rkOGCv2erPlNH9Q+C3wJnAjf3cXJIkSZKkfvQb5HZdcyVw5Wz1Zgp03w88lmZC8CeB91fVl+baEUmSJEnSIhrRObqLacV0J6rqGcBtaSb+7gF8IclPkxyf5E8G1D9JkiRJ0phKsmeS5yT56yR7tmUPSHJekhuS/CTJsXNtd9pAF6CqbqqqD1bVwcAdgH8DDgUuSfL1JI/fkoeRJEmSJC1vSf4SuAh4J/B24OIkhwCfB24FfBa4AXhTkifOpe0ZA91OVfXLqnojsB/w+vbjU+dyM0mSJEnSAqt5HkvnOOBHwJ1pRhN/FvgwcHpV3aOqngTcjWYq7Qvn0nDfgW6S/ZO8A/gl8DfAx4A3z+VmkiRJkiS1/hx4Q1VdVlVXAf8X2Ak4ZbJCVVX79Z/OpeEZ99FNckeavYqOAP4Y+Arwcpo9jn43lxtJkiRJkhZYATWy2wvdBvh5x9c/az9e3VXvamDnuTQ80z66XwEOAC6lWYH5g1X1k7k0LkmSJEnSDGqaz+dlpozufWn20b0S+Cvgr5Jp/1JQVfXAheqUJEmSJKk/NdrbC+2XZPv28xU0we5fJtmpo85d59roTIHul1nqqcmSJEmSpHH2L0B3RvWdHZ9Xe35Osem0gW5VPWguDUmSJEmSlsDopicfvFgNz7gYlSRJkiRJi6Gqzl2stqfdXijJ7bakwSS33fLuSJIkSZLmpDK/YwzNlNG9NMm7gXdW1fdnaiTJtsBjgZcBHweOX7guSpIkSZLGTZL3zqF6VdWz+q08U6B7IPBGYG2S7wD/BVxEs4fRepp9jO4I3Bt4CDDR1n/LHDorSZIkSZqHjO4c3YdwyxnGOwF/AGwCrgV2pYlZfwNcN5eGZ1qM6tvAQ5P8OXAU8Ejgr7uq3Qx8gyaT+6Gq+t1cbi5JkiRJWp6qaq/Jz5PcH/gI8BzgE1W1OclK4AnAPwNHzKXtWRejqqoLgOe2N781sAewDU2E/ZOq2jiXG0qSJEmSFkgxyqsud3oL8Pqq+uhkQVVtBk5LshvwNprRxH2Z06rLVXUVcNVcrpEkSZIkaRZ3By6d5tyPgLvNpbFpV12WJEmSJA27ea64PDyrLv8KeOI0554MXDmXxtxHV5IkSZK01N4GvLXd5vZjNIHtbWiC34OBF82lMQNdSZIkSdKSqqoTklwP/APwsI5TPwOOqqq5bEVkoCtJkiRJI208FqOiqt7T7q37h8DtgCuAn1fVnJ/QQFeSJEmSNBTaoPZn7bHF+lqMKslrk+w5nxtJkiRJkhZBzfNYIkkeuwXX3C7J/rPV63fV5f8PuCzJ55IcmsTVmiVJkiRJ8/FvSS5KckySXWaqmOQBSU6i2YLoHrM13O/Q5dsCRwBHA58GfpHk3cC7q+oXfbYhSZIkSVpooztH907AS4BXA/+S5BLgIuBqYD2wM3BHYD/gD4AvA/+nqr42W8N9ZWar6oaqeldV/QVwH+As4KXA5Uk+leSQuT+TJEmSJGm5qqobq+rVwO1pEqvnA38BHAn8DfAoYCVwArBPVT24nyAXtmAxqqr6FvCtJH9Ls7/Ro4FDk/wUeDPwzqqamGu7kiRJkqQ5KqCy1L2Yl6raCJzWHgtiznNtk/xxkjcCa4H7Ap8CngqcR7PJ74mzXP/gJF9JclOSdUk+kOQ2PertnOTdSa5JckOSLya5e4962yR5U5Ir2jbPS3LgXJ9LkiRJkjQe+l11eWWSJyT5AvADmsD2ncBeVfX4qjq1qp4KvAB40gztPIBm2POvgccDLwQOBM5OsnVHvQCnA4e0bT4eWA18KckfdjX7HuAo4FXAI2n2Wjozyb79PJskSZIkjbLU/I5x1O/Q5V8Au9NM/j0c+FRVbepR77+BHWZo5x+AnwKPmbw+yfeBbwLPAt7R1jsUuD/wkKr6UlvvPOBy4GU0q0CT5J7AU4Ajq+rktuxcmmzzq9t2JEmSJEnLSL9Dlz8G3K2d/PuxaYJcquobVTVTm/sDX+i8vp3zey3QuYfSocAvJ4Pctt5vgM/QzAnurDc5nnuy3ibgVODgziyxJEmSJI2lRd5HN8k5SWqa44xprnlXe/6D836+LdBXRreqXrBA99sMbOhRvh64W8fX+wAX96i3FliTZPuqur6td3lV3dij3lY0y1WvnXevJUmSJGn5eh6wY1fZAcBbaKac3kKS+9JMd/3t4nett37n6L48yb9Mc+7tSV7a5/1+QJPV7bx+T+B2QOcGwbsA1/W4fl37cec+68246bAkSZIkaWZV9b2q+nrnQZOo3EAzmvb3kqwGTgJeS+9YbYokWyV5YZK7zV67P/0OXX4m8J1pzl3Ynu/HCcC9kxyf5NZJ7gJ8AJhoj0mhdxK9e93sfuvd8mRydJLzk5y/kfV9dl2SJEmSlGRb4DDgM1W1ruv0S2n2vn1zv+1V1QbgDSxgorLfQPcOwI+mOfdjYM9+GqmqDwHHAy8GrgS+R7PQ1edoVkuetI7eDzmZyb2uz3rd3/TJfpxUVftV1X6rcRqvJEmSpNG1BKsuP45mEeJTbtGP5I+BVwDPa4PXubgEuOMW9aaHfgPdG4HbT3PuD6H/tGhVvRLYDbgHcLuqOhy4M/CVjmpraebfdrsr8D/t/NzJensn2a5HvQ3Apf32S5IkSZLUlzXAVcDnu8pPBD7ZuajwHLwKeGWSu8+3c9B/oPtfwEu7VzFuv35xe75vVXVDVX23qq5McghwF5pvyqTTgdsneWDHvXYEHsUtJzufTrO/7mEd9VbR7OV7VlU5LlmSJEnSeKvM74DdJqd2tsfR090qyR7AQcCHOnfTSXIE8JfAS7bwKV4ObA/8d5JLk/xXki93HOfOpbF+99E9Dvga8MN2eehf0GR4jwB2BZ7RTyNJ7gU8DLigLbo/zRjuN1bV1zqqng6cB3ywXejqOuDvaObevnGyUlVdmOQ04G3tpOfLgecCe9Os8iVJkiRJmtk1VbVfn3WPoEmY/n7YcpLtaVZg/ifg5iQ7tadWAKvbr2+oqo0ztLuZZmrrguh3e6GLkjwY+GeaSHsFzeJRXwEeX1UX9Xm/DcDDgZcBW9OMwz6mqk7uut9Ekke293sHsA1N4PvgqvpZV5vPpFnR63hgJ+Ai4JCqugBJkiRJ0kJaA1zUFQPuBuwOvK49Ov0R8ETgscCnp2u0qh60kJ3sN6NLVX0TOLBdYWtn4LqqumkuN6uqtTRZ3H7qrgOObI+Z6t0EHNsekiRJkrR8FL33oVkESfajWUupO/b6FfDgHpecCnyXJjF58eL27pb6DnQntYHlnAJcSZIkSdLIWwNsAj7cWVhVNwPndFdOcjNwZVVNOddLktvTrAF1IM0U2UdV1cVJXgScV1Xf6LejfQe6Se5Ik3K+A81Q4k5VVc/qty1JkiRJ0gIZQEa3XRPpcOCMqrpyEdrfh2aR480001bvBWzVnt4TuDfwlH7b6yvQTfJo4GM0c3OvYup2QgNKlkuSJEmSBq1dSGr3OV6z1xyqv5lmDaeDgZtp1nea9DWaha761m9G93iaVPRTq+rqudxAkiRJkrR4Mh5px/sDh1fV9UlWdp27ErjtXBrrN9C9I/Big1xJkiRJ0iKYmOHcbsxxnagVfdb7Ps1kYEmSJEnSMKl5HsPhmzRbx/byROCrc2ms34zuy4C3JflGVf14LjeQJEmSJGkWrwG+mOQsmlWdCzgoyQtp9uA9cC6N9RvoHkeT0b0kyY+AdV3nq6oeOJcbS5IkSZIWwPBkZbdYVZ2b5DHA24D3tsVvAH4CPGYuWwtB/4HuZuAHc2lYkiRJkqR+VdV/AP+R5E7ArYFrq2qL4tC+At2qetCWNC5JkiRJWjyp8Vh1Ocn2VXU9QFVdClw6n/b6zehKkiRJkrRYrktyPvAl4D+Br1bVnFZa7tTvqsskuX2StyQ5P8nlSe7Wlr8oyX22tAOSJEmSpHmozO8YDs8DLgeeAZxFE/h+OclxSR6YZKu5NNZXoJtkH+C7wNOAXwJ3ACZvtCfwwrncVJIkSZKkSVX171X1lKraA7gbcCxwFU0A/J/AdXNpr9+M7puBS4C9gccBnWH/14D953JTSZIkSdICGY99dDv9FPgxTYb35zTx581zaaDfObr3Bw6vquuTrOw6dyVw27ncVJIkSZKkSUkeAjwEeDDwlzSB7X8BHwKeDfz3XNrrN9CdmOHcbsAWTxKWJEmSJC17XwRuBN5FM2z5/KravKWN9Tt0+ZvAM6c590Tgq1vaAUmSJEnSlpvcYmhLjyHxKZoE6ouAdwJvTPLwJDtsSWP9ZnRfA3wxyVnAh2lGch+U5IXAY4EDt+TmkiRJkiRV1eMBkuxLM3z5wcCzgO2SXACcXVV/3297fWV0q+pc4DE0i1G9l2Yy8BuABwCPqapv9P8IkiRJkqQFM0aLUVXVhVX1VuAwmtHD5wL3Bv52Lu30m9Glqv4D+I8kdwJuDVxbVT+Yy80kSZIkSeqWZBXNbj4PplmUan+aLW2vAT4GfGku7fUd6E6qqkuBS+d6nSRJkiRpgQ3XPNv5+DWwbfvxy8DLgC9V1cVb0lhfgW6SNbPVqar3b0kHJEmSJEnL3j8A/wlcWFXzDt37zei+b5ryzg4Y6EqSJEnSoI1BRreq3ryQ7fUb6O7do2xX4JHAU4AjFqxHkiRJkqRlJ8ntgBcDDwR2Aa4FzgHeUlW/mktbfQW6VfXTHsU/BS5IEpoNfZ8ylxtLkiRJkhbAGGR0k/wJ8BVgJ+CrNOtC3RZ4IbAmyQOq6kf9tjfnxah6+C+aQFeSJEmSpC3xT8BvgHtX1U8mC5PsCZzVnn9cv40tRKC7P3D9ArQjSZIkSZqjMVl1+cHAMZ1BLjSji5McB7xjLo31u+ryq3oUbwXcDXgE8K9zuakkSZIkSR22An43zbnftef71m9G97geZetp5um+Fnj9XG4qSZIkSVKHC4EXJPl8VU1MFrZrQj2vPd+3fhejWjGXRiVJkiRJmoNXA58FLklyGnAFzWJUhwF3phlJ3LeFmKMrSZIkSVoqYzBHt6rOSPJI4Hjg74HQPNm3gUdW1Vlzaa/fObp3mGMn/2cu9SVJkiRJy1eS3YBzqmq/JNsBOwPXVdWNW9JevxndnzC3vxOsnHtXJEmSJEnLRZKVwCuBFwE7AJuTfAZ4VlX9Yj5t9xvoPpcmffxb4KPAlTTjpZ8IbE+zINX6+XREkiRJkjRHNdLbCx0DvAo4B/gWcEfgsTRx5zPn03C/ge6fARcAj62q338bk7wa+DTwZ1X1N/PpiCRJkiRpWTkK+Peqes5kQZLnAP+a5DlVtWFLG+53NeXDgXd1BrkA7dcnAk/Z0g5IkiRJkuah5nksnTsCH+sqO41mKuye82m430B3e2D3ac7dGrjVfDohSZIkSVp2tqcZptzpd+3HHebTcL9Dl88BXpfkkqr61mRhknvTzM89Zz6dkCRJkiRtodGdowtw+yR37Ph6ZUf5rzsrVtWP+22030D3r4EvAl9P8jOaxahuA/wRcHl7Xlo4K1y4exit2Gbrpe6CppFtt1nqLqgXf5YNpazydRlGtXHjUndB09m0aal7oC757Vj9HPv4NOWf7lHW94P3FehW1eVJ7gI8A9gfuB1wMXAecEpV+ZNJkiRJkgYsjPSqy/NaWXkm/WZ0aYPZf28PSZIkSZK2WFWdslht9x3oAiS5B3AgsCvNKsy/SnIn4Mqq+t3MV0tzMLF5qXugHiZuvHGpu6Dp+NpIkrRsVHX9v/LoZnQXTV+BbpKtgQ8Cj6PJjhfwGeBXwBuBHwJ/u0h9lCRJkiSpb/1uL/Ra4CDgaTSLUKXj3OeBgxe4X5IkSZKk2VQzR3c+xzjqd+jy4cArqurDSbpXuroc2GtBeyVJkiRJ0hbqN9DdFbhkmnMrAPcckSRJkqSlMKZZ2fnod+jy5cAB05y7N/CDhemOJEmSJEnz029G9/3A/03yE+CTbVkleTDwN8BxC9+1wci227DiTndZ6m6oS60eq02wx8fKzF5HSyO+NsOofFmGUiZMfQyjbHTHhaFV/psZNvnhV29Z4Es0Rb8Z3TcC/wF8AFjXln0F+CJwRlX9yyL0TZIkSZKkOesro1vNRk1PTvJvNCss3xq4libIPXcR+ydJkiRJ0pzMGugm2Qr4OvC3VXUW8F+L3qsBqptuZuLi7y91NyRJ0oA4wm84+bpI/au6+RZfj+sWQfMx69DlqtoA7A1sWogbJrlfkrOSXJXkt0kuSHJkV519k5yR5Pq2zulJ7tSjrW2SvCnJFUluSnJekgMXop+SJEmSpNHU7xzdLwB/Nd+bJbkHzbze1cBRwOOBbwHvSfLcts6dabLGfwA8FXgmzT69X05y664m39O28yrgkcAVwJlJ9p1vXyVJkiRpJNQ8jzHU76rL/wJ8MMkq4NM0AeUtviVV9eM+2nkysBJ4VFVd35Z9Ick9gTXAO4GXA5uBh1XVrwGSfAO4FHgJ8LK27J7AU4Ajq+rktuxcYC3wauDQPp9NkiRJkjRG+s3ongv8EXBs+/kPgR91Hf3YCtgI3NRV/uuOvuwPnDcZ5AJU1c+Bi4HHdlxzaNvWaR31NgGnAgcn2brPPkmSJEnSaJpvNneZZ3SfuUD3ex/wXODtSV4L3AgcBjwUeFpbZzOwoce164E/TrJNNbOv9wEur6obu+qtpQmo79R+LkmSJElaRqYNdJM8BPhmVV1fVacsxM2q6uIkDwI+BTyvLd4IHFNVp7Zf/wC4b5LVVbWx7csONIFtgJ1phk7vAlzX4zaT+/zushB9liRJkqRh5qrLU800dPkLwF0nv0iyIsmX28Witkh77SdoMq2PAg4CTgROTPLUttoJwO3bstsn2RM4Gdi+PT8x2Ry9E+3pox9HJzk/yfkbWb+ljyNJkiRJGkIzBbrdAWOA+wM7zON+r6PJ4D6yqj5bVWdX1f8HfBQ4IcmKqvoq8HzgCcDPgZ8AOwGn0AxpnszYrqN31nbnjvM9VdVJVbVfVe23GqfySpIkSRphizxHN8k5SWqa44y2zl+0W8T+IsnNSX6V5HNJDljw5+1Dv4tRLZS7AxdNDknu8E1gV+DWAFX1jvbzuwF3qKqDgD2Ab3RcuxbYO8l2XW3dlSYgvnRxHkGSJEmSlpXnAQd0Hce2505vP+5EE4O9GDgYeEFbdm6Sew+wr0D/i1EtlF8B+ybZqqo6F5y6D3AzHVnYqlpPu5hUkrvTDHNe03HN6cA/0ixmdUpbbxXwJOCs9vpZ/ck9buTMMy/c0ufRIrlwvUPKh9H/bNp59kpaEj/e0L3NuIbBTiu710vUMLj71j9f6i6oh5XjuvTrGNh79cTslTRQD3nY9bf4erHn6FbV97rLkhxFk2A8ta1zNnB2V50zgGtoFh7+5uL28pZmC3Rvn+SO7ecrO8p+3V2xz310/xX4GPCZJO+g2WboUOBw4K1VtSHJH9KszPw1mpWW/wL4v8Anq+ojHfe7MMlpwNuSrAYub6/bG3gqkiRJkqQFl2RbmoTjZ6pq2imjwA00MV33iN5FN1ug+/EeZZ+epu7Kacp/r6o+nuThwMuBdwPbAJfRzMl9V1ttI02G9zk084EvA15Ns0hVt2cCrwWOp0mLXwQcUlUXzNYXSZIkSRoLgx8Q8TiaWG3K7jxJVtDEhrcD/rYtfvfgutaYKdBdqL1zb6GqPg98fobzV9IMU+6nrZtoxoYfO1tdjZZ9t3aRsGG079YOwxxat/rJUvdAGiFbLXUHJGleVg58qaUp1gBX0Tuu+yjw+Pbzq4CH9xr6vNimDXQXau9cSZIkSdIi6XPl5FnsluT8jq9PqqqTelVMsgdNYvKEqtrUo8rLgH8C/ohm5O5nkxxUVef3qLtoBr0YlSRJkiRpuFxTVfv1WfcImt17eiZG27Wbfgx8K8lngYtpppoeshAd7deS57wlSZIkSSNjDc2WsRfNVrHdaec7wJ0WvVddDHQlSZIkaURlAY6+75XsB+zDNNncHvW3A/ajWWB4oBy6LEmSJEnqxxpgE/Dh7hNJ3gWsA86n2Tt3T+CvaVZfftoA+wgY6EqSJEnSaBvA9kJJVgOHA2e0O+V0+wbwbOBo4FbAL9qyZ1XVdxe/h7dkoCtJkiRJmlFVbQR2n+H8e4H3Dq5HMzPQlSRJkqQRlgFkdEeNi1FJkiRJksaKGV1JkiRJGmVmdKcwoytJkiRJGitmdCVJkiRplJnRnWLZB7pFsbkmlrob6vKJG3Ze6i5II2Wlv+GG0p9v/cul7oJ62GmFA9qG0c3+/9jQ2ib+mxk2m/Dfy2yWfaArSZIkSSOrXHW5F/88I0mSJEkaK8s+oxvCSodjDJ0nbv+bpe6CJC2A7Ze6A5KkMbSqO19pRncKIzxJkiRJ0lhZ9hldSZIkSRplztGdyoyuJEmSJGmsGOhKkiRJksaKQ5clSZIkaZQ5dHkKM7qSJEmSpLGy7DO6P/zOdhy8x75L3Q1JkiRJ6ssP69pbfO1iVFOZ0ZUkSZIkjZVln9GVJEmSpJFVOEe3h2Uf6P7JPW7kzDMvXOpuSJIkSVJf7n3wjUvdhaG37ANdSZIkSRppZnSncI6uJEmSJGmsmNGVJEmSpBEVXHW5FzO6kiRJkqSxYkZXkiRJkkaZGd0pzOhKkiRJksaKGV1JkiRJGmEpU7rdzOhKkiRJksaKGV1JkiRJGlWFc3R7MKMrSZIkSRorBrqSJEmSpLHi0GVJkiRJGmFx6PIUZnQlSZIkSWPFjK4kSZIkjTIzulOY0ZUkSZIkjRUzupIkSZI0wpyjO5UZXUmSJEnSWDGjK0mSJEmjzIzuFGZ0JUmSJEljxYyuJEmSJI2qco5uL2Z0JUmSJEljxYyuJEmSJI0yM7pTmNGVJEmSJI0VM7qSJEmSNKKCc3R7MaMrSZIkSRorAw90k9wvyVlJrkry2yQXJDmyq84+ST6Z5JdJbkiyNsmLk6zqqrdNkjcluSLJTUnOS3LgYJ9IkiRJkpZQ1fyOMTTQQDfJPYAvAquBo4DHA98C3pPkuW2dPYBzgDsCLwIeBXwaeBPw2q4m39O28yrgkcAVwJlJ9l3UB5EkSZIkDa1Bz9F9MrASeFRVXd+WfSHJPYE1wDtpAtbdgPtV1Q/bOv+Z5I/bOi8HaK95CnBkVZ3clp0LrAVeDRw6mEeSJEmSJA2TQQ9d3grYCNzUVf7rjr5s1X787Qx1oAlkNwKnTRZU1SbgVODgJFsvSI8lSZIkaYil5neMo0EHuu9rP749yR5JdkpyFPBQ4K3tuY8B1wD/mmTvJDsmeSzwNODNHW3tA1xeVTd23WMtTbB8p8V6CEmSJEnS8Bro0OWqujjJg4BPAc9rizcCx1TVqW2dK5McAPw/4MeTlwLHVdUbO5rbBbiux23WdZyXJEmSpPFV7aFbGGigm+TOwCdosq7H0AxhfjRwYpKbq+pDSXYHPgncADwBuBZ4CPCKJOur6p8mm6P3S5o++nE0cDTA9re9Fc/7xf7zezAtuF9v2Hapu6AeNkysXOouaBobJtwWfRhtmnAXv2E0UbP+r4KkDivGdWzrCPvRzacudReG3qD/z+h1NBncR1bVxrbs7CS7Aick+QjwMmAvYM+qmszYnpNkJfCaJO+pqmtoMrd36HGPnduP63qcA6CqTgJOAtj9rrv6L1eSJEnSyMrEUvdg+Az6T813By7qCHInfRPYFbh1W+fSjiC3s85q/nfu7Vpg7yTbddW7K7ABuHQhOy5JkiRJGg2Dzuj+Ctg3yVZVtaGj/D7AzTRZ2F8B902yc1ewe5/24y/aj6cD/wgcBpwCkGQV8CTgrKpa30+H9lx9A++4/de39HkkSZIkaaDuvc1vblngGNUpBh3o/ivNqsqfSfIOmjm6hwKHA2+tqg1JTgSeCpyV5E00c3QfBLwE+FRV/Qygqi5MchrwtiSrgcuB5wJ7t9dLkiRJkpahgQ5drqqPAw8HtgbeTbMw1f2B5wMvbet8HXgAcDVwAk3m9nHAq5kawD4TOBk4HvgP4I+AQ6rqgsV+FkmSJEkaBou9j26Sc5LUNMcZbZ2HJvlgksuS3NR+fGeSWy/28/cy8GU6q+rzwOdnqfN1moB4trZuAo5tjy2y9oZd2Oc8E8DDZodt+xp5rgG7w469dvTSMNht6xuWugvq4VYr/Vk2jP5g1U1L3QX1sLlcpVzq1y83XT3oWz4P2LGr7ADgLTSJSWh21dmeJgn5Y+DONFNND05yj6q6fkB9BZYg0JUkSZIkLZACanEn6VbV97rLkhxFswjw5F5Hz6uqzgj83CQ/BM4Fngi8d1E72cU/nUmSJEmS+pZkW5pFgT9TVesAuoLcSd9qP95+UH2btOwzuvnNSrb9fHcWXkvtxh2z1F1QDz+oJZlioT78YKk7oJ62+o3LYA6jiWX/fz/DadN2/u4fVtte7Satw+Y3v7rlkkT9zLNdYI8DdqDd/WYGD2w/XrK43ZnKjK4kSZIkaS7WAFcxw9pLSXYA3kYT5H56IL3q4N80JUmSJGmUzT+ju1uS8zu+PqmqTupVMckewEHACVW1aZo6q4CP0AxZvt909RaTga4kSZIkLW/XVNV+fdY9gmZkcM9hy0kmzx0EPKKqvrMwXZwbA93A5q2cEzJsVl/vvDZpLuL0qaG0YuB/v1Zf/BUzlLb6rS/MsFq5wddm2CzBnNxOa4CLquqiac6fCDwJeEJVnT24bt2Sga4kSZIkjagwuMA3yX7APsCx05x/M/Bs4OlV9enB9Ko3A11JkiRJUj/WAJuAD3efSPJymgD4vcCPkuzfcfrqqrpsMF1sLPtAd+WGYsefObZs2Gza1gXBh9GmrR3mP6zcLmU4rdjocL9h5FD/4TSx0t8xw8ppGEOo89dLVXMssiSrgcOBM6rqyh5VHtZ+PLI9Op0CPGPxejeV/2skSZIkSZpRVW0Edp/h/IMG15vZGehKkiRJ0ghb4sWphtKyD3Q3/EH42SEOlRk2tdJxZUNphT9Fh9Zmf44No1W/XbnUXVAPE6v9WTaMJrbbvNRd0DS2utafZcNm0zeWugfDb9kHupIkSZI00vz73RSu+CNJkiRJGivLPqO76nq4zVcd8jd0ytdEmouVG/xT7jBadbNLlUr92ryV+ZdhtfV165e6C+py5W9v+XvfObpT+RNFkiRJkjRWln1GV5IkSZJGVgETpnS7GegGNm3tMNlhs2k7X5NhtOomf4gOq4nV/psZSr4sQ6lW+MIMI/9/bHit3OCqy8OmHJc7KwNdSZIkSRpl5iKm8G8BkiRJkqSxYkZXkiRJkkaYqy5PtewD3c3bwG/uvNS9ULeJ1f5rHUYrNi51DzSdbF7qHqiXleud1zaUnAo6lJxzOLxuvO3qpe6Cumz6lj/IZuOPFEmSJEnSWFn2GV1JkiRJGmnlaMhuyz7Q3eq6zdzxk79b6m6oy8Rqh/sNo/hDdHi5f95QWvmbm5a6C+pllb9jhtHmW2211F3QNFZd9Zul7oK6/Pw655PNZtkHupIkSZI0ylyMairn6EqSJEmSxooZ3Rtvpi64ZKl7oS6ZcAlZSaPPn2SSxsGmpe6Apqja0PFFe+gWzOhKkiRJksaKGV1JkiRJGlHBBUN7WfaB7obb34rL//reS90NdVn9OzfBHkYbd/SH6LBa4eKLQ2nz1kvdA/Wycv1S90C9rLzZ3/3DqhwDOnQ2vPvrS92FobfsA11JkiRJGmkTS92B4ePfZyRJkiRJY2XZZ3RX3gS7XuxwzGGTCV+TYbThVg4rG1YrHbo8lDavXuoeqJeY+RhKKzf6wgyriZX+/h82Kzfc8mvn6E5lRleSJEmSNFaWfUZXkiRJkkaW++j2ZEZXkiRJkjRWln1Gt1bC+h2ddzBsnD81nOJfC4fWxlstdQ/Uy8Rqf78MJX+WDaWJDbPX0dLIpqXugbrVLX69FDhHdwozupIkSZKksbLsM7qSJEmSNMocdTfVsg90U1OX59bSc+jycNq4ncMwh9XmbZa6B+rF3y/DaeP2S90D9ZLN/o4ZVis3G0Vp9Dh0WZIkSZI0VpZ9RleSJEmSRpqLUU2x7APdAiaW/Xdh+KzYuNQ9UC8r1/tDdGjFIX/DyCHlw2nl+qXugXpZdZO/Y4bVal+bobPCaX6zMsSTJEmSpFFVrm/Ti3N0JUmSJEljZdlndCe2ht/dcal7oSkcITOUVmxweOywqlX+oxlG5T+Z4eTrMpQ23soXZli5Ivbw2bxVV4FzdKcwoytJkiRJGivLPqMrSZIkSSPNhO4Uyz7QLXxfDKPVNzpEZii50MHQmvCfzFBa4XC/oTSx2t/8w2jFpqXugabjNAyNomUf6EqSJEnSKItzdKcY+BzdJPdLclaSq5L8NskFSY7sOP++JDXN8f2utrZJ8qYkVyS5Kcl5SQ4c9DNJkiRJkobHQDO6Se4BfBH4OnAUcCPwBOA9SbauqncCrwFO7Lp0L+AjwOld5e8BHgG8FPgx8HzgzCQHVNWFi/QYkiRJkjQ8zOhOMeihy08GVgKPqqrr27IvJLknsAZ4Z1VdBlzWeVGS/9N+ekpH2T2BpwBHVtXJbdm5wFrg1cCh/XRo1bab2Olu1275E2lRXLtu+6XugnrYapuNS90FTWPjemeiDKOVqzcvdRfUw6abVy91F9TD5tUuBDGsNt/o75hhM7G1ge1sBj10eStgI3BTV/mvZ+nLGuDbVbW2o+zQtq3TJguqahNwKnBwkq0XosOSJEmSNLSKZsHQ+RxjaNCB7vvaj29PskeSnZIcBTwUeGuvC5LcD7gTHdnc1j7A5VV1Y1f5WpqA+k4L1mtJkiRJ0sgY6DiEqro4yYOATwHPa4s3AsdU1anTXLamrfORrvJdgOt61F/XcX5261ax8tT+qmpwdlvpOvbDaGIrB0oMK7d+GE6bt/aFkfq16kaHYg6rFc7CGDrXXP+/v19CuepyD4NejOrOwCdosq7H0AxhfjRwYpKbq+pDXfW3Bp4IfLaqrulujt5b4M76fxVJjgaOBtjqVjvP9TEkSZIkSUNs0DPLX0eTnX1kVU2uanN2kl2BE5J8pKo6R4k/GtiJqcOWocnc3qFH+c4d53uqqpOAkwButesf+ecPSZIkSRojgw507w5c1BHkTvomzQrKtwZ+1VH+dOAa4HM92loLPDbJdl3zdO8KbAAu7adDf/aHV/P1N3bvZiRJkiRJw+ne3776lgUOXZ5i0ItR/QrYN8lWXeX3AW6mIwub5DbAXwEf7hEYQ7On7mrgsI5rVgFPAs6qqvUL3HdJkiRJ0ggYdEb3X4GPAZ9J8g6aObqHAocDb62qDR11n9r2r9ewZarqwiSnAW9Lshq4HHgusHd7rSRJkiSNPzO6Uwx61eWPJ3k48HLg3cA2wGXA84F3dVV/OnBxVV0wQ5PPBF4LHE8zl/ci4JBZrrmFH35nOw7eY99+q0uSJEnSkvphXbvUXRh6g87oUlWfBz7fR7179lHnJuDY9pAkSZKk5aWAiVlrLTuDnqMrSZIkSdKiMtCVJEmSpBGWqnkds7afnJOkpjnOaOvskOSf27q/bc89aJEffVoDH7osSZIkSRopzwN27Co7AHgLzW44ALsCRwIXAF8AHjew3vVgoCtJkiRJo2yRV12uqu91lyU5CtgAnNoW/bSqdmnPHcQSB7oOXZYkSZIk9S3JtsBhwGeqah1A1XDtcWRGV5IkSZJGVi3FPrqPA3YAThn0jftlRleSJEmSNBdrgKvoY9vYpWJGV5IkSZJGVbEQGd3dkpzf8fVJVXVSr4pJ9gAOAk6oqk3zvfFiMdCVJEmSpOXtmqrar8+6R9CMDB7aYctgoCtJkiRJo21ioHdbA1xUVRcN9K5z5BxdSZIkSdKskuwH7MOQZ3PBjK4kSZIkqT9rgE3Ah3udTPIw4FbA3duiBybZDbihqga6cJWBriRJkiSNsAxge6Ekq4HDgTOq6sppqr0T2LPj6+Pajz8F9lq0zvVgoCtJkiRJmlFVbQR2n6XOXoPpzewMdCVJkiRplA0goztqXIxKkiRJkjRWzOhKkiRJ0qgqYMKMbjczupIkSZKksWJGV5IkSZJGVjlHtwczupIkSZKksWJGV5IkSZJGmRndKczoSpIkSZLGihldSZIkSRplZnSnMKMrSZIkSRorZnQlSZIkaVS5j25PZnQlSZIkSWPFjK4kSZIkjayCmljqTgwdM7qSJEmSpLFioCtJkiRJGisOXZYkSZKkUeb2QlOY0ZUkSZIkjRUzupIkSZI0qtxeqCczupIkSZKksWJGV5IkSZJGmXN0pzCjK0mSJEkaK2Z0JUmSJGmUmdGdwoyuJEmSJGmsmNGVJEmSpJFVZnR7MKMrSZIkSRorZnQlSZIkaVQVMDGx1L0YOmZ0JUmSJEljxYyuJEmSJI0y5+hOYUZXkiRJkjRWzOhKkiRJ0igzozuFGV1JkiRJ0lgx0JUkSZIkjRWHLkuSJEnSyCqYcOhyNzO6kiRJkqSxYkZXkiRJkkZVQdXEUvdi6JjRlSRJkiSNFTO6kiRJkjTKnKM7xcAzuknul+SsJFcl+W2SC5Ic2aPe/knOSPLrJDck+W6SJ3fV2SbJm5JckeSmJOclOXBwTyNJkiRJGjYDDXST3AP4IrAaOAp4PPAt4D1JnttR7xHAl4FfAU8BHg38O7BNV5Pvadt5FfBI4ArgzCT7LuqDSJIkSdKwqJrfMYYGPXT5ycBK4FFVdX1b9oUk9wTWAO9MsgNwMvCOqnpRx7Vf7GyoveYpwJFVdXJbdi6wFng1cOhiPogkSZIkaTgNeujyVsBG4Kau8l939OUwYHfgzbO0dWjb1mmTBVW1CTgVODjJ1gvQX0mSJEkaXlUwMTG/YwwNOtB9X/vx7Un2SLJTkqOAhwJvbc/dH1gH3L2dl7spyc+S/EOSlR1t7QNcXlU3dt1jLU1AfafFewxJkiRJ0rAa6NDlqro4yYOATwHPa4s3AsdU1ant13sA2wEfBl4DfBs4CHglsBPwN229XYDretxmXcd5SZIkSRpvYzrPdj4GGugmuTPwCZqs6zE0Q5gfDZyY5Oaq+hBNlnkb4O+r6i3tpeck2RV4fpLjquo3QIBer2j66MfRwNEA27DdPJ9KkiRJkjRMBr0Y1etoMriPrKqNbdnZbRB7QpKPANe25V/ouvYsmuB4H+BrNJnbO/S4x87tx3U9zgFQVScBJwHsmF3884ckSZKkkVVjOs92PgY9R/fuwEUdQe6kbwK7AremyfbC1GztZKZ28lVcC+ydpDsle1dgA3DpgvRYkiRJkjRSBh3o/grYN8lWXeX3AW6mycJ+ui07pKvOwW2di9uvT6fZj/ewyQpJVgFPAs6qqvUL2nNJkiRJGjrz3EN3TOf3Dnro8r8CHwM+k+QdNHN0DwUOB95aVRuAi5O8D3h1khXABTSLUT0beM3k/rtVdWGS04C3JVkNXA48F9gbeOpgH0uSJEmSNCwGveryx5M8HHg58G6aRacuA54PvKuj6nOAXwAvAG4D/AQ4tqpO6GrymcBrgeNpVmS+CDikqi5YvKeQJEmSJA2zQWd0qarPA5+fpc4G4BXtMVO9m4Bj20OSJEmSlpcCJsZz+PF8DHqOriRJkiRJi2rgGV1JkiRJ0gIqtxfqZkZXkiRJkjRWzOhKkiRJ0ogqoJyjO4UZXUmSJEnSWDHQlSRJkqRRVdXM0Z3PMYsk5ySpaY4zOurtnOTdSa5JckOSLya5+6I+/zQcuixJkiRJmsnzgB27yg4A3gKcDpAk7ed7Ay8ArgP+DvhSkn2r6ueD666BriRJkiSNtMWeo1tV3+suS3IUsAE4tS06FLg/8JCq+lJb5zzgcuBlwP+3qJ3s4tBlSZIkSVLfkmwLHAZ8pqrWtcWHAr+cDHIBquo3wGeARw+6jwa6kiRJkjTKFnmObg+PA3YATuko2we4uEfdtcAdkmy/JTfaUga6kiRJkqS5WANcBXy+o2wXmnm53SYzvjsvdqc6Lfs5ur/jumu+WB//6VL3Ywa7AdcsdSekafj+1DDz/alh5vtTw8z35/Dbc/KT33HdmV+sj+82z/a2SXJ+x9cnVdVJvSom2QM4CDihqjZ1nqLZ1nfKJfPs2xZZ9oFuVe2+1H2YSZLzq2q/pe6H1IvvTw0z358aZr4/Ncx8f46WqjpkwLc8gmZk8Cld5etosrrdJjO5vbK9i8ahy5IkSZKkfq0BLqqqi7rK19LM0+12V+B/qur6Re9ZBwNdSZIkSdKskuxHE8x2Z3Oh2UP39kke2FF/R+BR7bmBMtAdfj3HxktDwvenhpnvTw0z358aZr4/NZ01wCbgwz3OnQ6cB3wwyZOTHNyWBXjj4LrYSNXibi4sSZIkSRptSVYDvwS+XlWPmqbOLsA/A48BtqEJfI/tMcx50RnoSpIkSZLGikOXp5Hkj5J8PMlvkvw2ySeT3KGrzkOTfDDJZUluaj++M8mt+7zHG5J8J8mvk9yY5PtJXplku656NcPxt33cZ7pr9+2qt1uS9ya5un2eb7RDDjRkhun92dZ9epJvt325OskXkjygz/tsk+RNSa5o+3lekgN71FuR5O+S/CTJzUkuSvL4fu6hwVqm789jk3ymrVdJjuunfS2N5fYeTfInSU5o+3N9W/f0JPfs5x4arGX4/twhyUeTXJrkhrZP30hyRD/3kKZjRreH9h/5RcB64BU0+0EdD2wH3KOqbmjrfQzYHvgo8GPgzsA/ttfdY7aVxZK8A/gR8IP2mvsCfw+cWVWP7qi3f4/Ln0+ztPfdqmrtLPcp4H3Au7pOfaeqbmzrbA18i2bftL8HfgU8C3g08H+q6pyZ7qHBGcL359E0760TgU+2/TgWuA9wQFX99yz3+RDwCOClbT+fDzysvfbCjnqvBV7S9uHbwJOBo4BHVtXnZrqHBmcZvz8vAX4LXAAcA/xjVR03U9taGsvxPZrkr4GjaRaPuQDYCXgZcC/gflX17ZnuocFZpu/PXYF/Ac4GfgJsDTyJZi7osVX11pnuIU2rqjy6DuCFwGbgTh1le9NMvD62o2z3HtceSPND6cgtvPfr2+t3m6XepcC3+myzgONnqXNEW+9BHWUBvgN8c6lfE49bvFZD9f4EvgZ8raveDsAG4PWztHfPtr1ndpStovnFe3pH2a1pfhH/Y9f1Z9P8wWbJXxeP5fv+bMtXdJwv4Lilfi08pn1dl917lOaP2Om69g9o9rR8/1K/Jh7L+/05w/XnAd9d6tfEY3QPhy73dijNJOtLJwuq6nLgqzQZzsmyq3tc+6324+238N7Xth83Tlchyf2BP6b3st5ban/gJuDcyYKqKuAs4C+TbOnzaOEN2/tzK5pMVqcb2zqz/Yw5tK132mRBVW0CTgUObkcaABzc3ueDXdd/ELh7kr37fQAtuuX4/qSqJrawzxq8Zfcerapr2t/pdNT7DfBDtvxZtDiW3ftzlv5M+//D0mwMdHvbB7i4R/lamg2PZzK5b9QlnYVp5hWe0+uCJKuSbJ/kIJrhIO9tfwFN5+k0f0n7SFc7D2rnhj2jxzXPTbK+nYfxnz3mVmwGNnb/IqTJogHcbYb+aLCG7f35DuCgJM9KslP7R5F/pfnl9J6Odnq9P/cBLq92CH3Xs2wF3Kmj3nqakQzd9WD259bgLMf3p0aL71F+vzLq3bqfRUtu2b4/01iVZNd2yPTBwNtmeWZpWquWugNDahea4Tzd1gE7T3dRkh1o/kFeAny66/QmmmCy+5q7Ad/tKHo/zTya6e6xDXAY8B9VdW3X6Wrv0Z1Z+CDwWZrlwPekmSfxn0k6597+ANgxyZ9VVecPyAPaj7tM1ycN3FC9P6vqvUmg+WX47rb4VzRzu3/YWZWp78+ZnmXy/OTHX/f4Q0x3PS295fj+1GjxPdr4F5opSm+boY4Gbzm/P59P876EJpB+YVW9v8f1Ul8MdKfX/T/U0PxC6CnJKpoM6+1pFnbYdIvGqqb7q+qlwF8Ct6JZCODvaF6Xp05T/zE082reN6XDVefS4zWtqqd1fPlfSf4fzV8Ljwfu35Z/GDgOOCXJs4AraH7YTa6M57C84TI0788kjwb+jWaxitOBbWnmGH0uyYOr6uL2Hr3en+nzWfqtp+Gw3N6fGj3L+j2a5O+ApwDP6hwiq6GxXN+fpwFfp5lTfijwL0k2V1X3YqpSXwx0e7uO3n8F3Zkef5lKsoJmvuxBwCOq6jv93qiqbgbOb788N8kVwMlJ/qWqvt7jkjXA1cDn+71Hj3v+Lsl/0KyqPFn26zRbtZxCswAVwGU0we9raAJfDYeheX+m+TPvScDHq+qFHfc8C/g+zXvnsTPcYh1whx7lO3ecn/y4c5J0ZXW762npLcf3p0bLsn6PJjkGeB3wiqp6b7/PooFZtu/Pdt7x5NzjM9KsQP3PSd5bVc7V1Zw5R7e3tTTzCrrdFfhej/ITaZZBf3JVnT3Pe0/+wJny17cktwX+CvjwAvyDn/JXtqr6L5pFrv4E+LP240aaRaoumOf9tHCG6f15G5oVkb/VWamqNtBsj/Bns7S3Ftg7U/ftuyvNPPRLO+ptTfP+7K4HvZ9bS2M5vj81WpbtezTJ02iGoL65ql47595rEJbt+3Oa/mzf9kOaMwPd3k4H9k9yx8mCJHsB92vP0VH+ZuDZNEunf3oB7j25kMBlPc4dAaxknqstJ9mRZk+zb3Sfq8aPqur7NHulHQV8oGbZj00DNUzvz+toFom6d9d9twL2BX4xS3unA6tp5p1PXruK5pf2WVU1uRjaGTS/FLuH9B8BXNyuSKnhsBzfnxoty/I9muSxwMnAu6vqJVv+CFpky/L9OUN/rgeu6qPv0lQ1BHscDdtBM1fhUpoJ+o+mmSdwEc1G19t31Hs5TVb0PTTb83Qef9zV5qXA2R1f34Nm656jgIcCDwfeQJM9/dw0/foOM+wZSvMDYROwpqPsJcC/08zFeRDNis3fpQkaHtB1/euBJ7T1nk2zQNUlwC5L/Zp4DO/7k2bhiALeTjPi4NHAF9qyR8/0/mzLT6X5Zfrs9l4fB24G/ryr3hva8mPb9+g7aeaOP2qpXxMP35/Afu3Pzye2bX+0/foJwHZL/bp4LO/3KM16GzfTjM66b9ez3GupXxOPZf/+fA7NH2Ge2rbzuPa6Al6+1K+Jx+geS96BYT1o5hR8gmbvsN/RrGC3V1edc9p/hL2O93XV/QlwTsfXt6FZAOry9gfLtTRDQ54PbN2jP/dq233xDH1+UFvnGR1lj6LZe+0ammHI19L8he3ePa5/L/BzmiD45+0PN4PcITyG6f1JM9f/r4EL275c3d77r2Z7f7bl2wJvoVnF8WaakQYP6vHMK4FXAD+l+Qvzd4AnLPVr4eH7s633vhmeZ6+5fP88fI8u9HuUZr2N6Z7lJ0v9engs+/fnfYHP0awHs54mU/xFmjnHS/56eIzukapCkiRJkqRx4RxdSZIkSdJYMdCVJEmSJI0VA11JkiRJ0lgx0JUkSZIkjRUDXUmSJEnSWDHQlSRJkiSNFQNdSdJISFJ9HD9Jslf7+TOWus+Tktw+yQ1J9uso+0mSD05T/7j2GVYleV+fz/6g9trdkrw+ycXtPW9M8t0kb0hyu7bOtkmuSHLYIJ5fkqRBW7XUHZAkqU8HdH39KeAi4LiOsvXAFW3dywbTrb68BvhSVZ2/hdee2PH1s4FnAfcHNneUfy/JXYGzgABvBybvdy/gOcCfAo+tqpuSvBF4fZJPV9XGLeiXJElDy0BXkjQSqurrnV8nWQ9c013e6lW2JJLcBjgCeOyWXF9Vl9ERtCc5pP30G1W1qaN8FfAJ4GbgvlV1VUczZyd5G/CwjrL3AW9o+/XRLembJEnDyqHLkqSx0mvocjv89+dJ9kvytSQ3JflBkke0549thxL/Nsn/S7J7V5urkvxdku8nWZ/kl0nenGSbPrr0DOB3wJkL+Ji9PA64C/C3XUEuAFW1qao+0/H1dW2fnr3I/ZIkaeAMdCVJy8WOwPuBd9NkMa8CPpHkzcCDgecDL2o//7euaz8IvAL4MPAI4PU0w4c/1Md9DwHO68y+LpKDaIYyf24O13wZeGCfAbskSSPDocuSpOViB+CYqvoyQJJf0szxfSRw16ra3JbfDXhBkpVVtTnJA4AnAU+vqve3bX0xyTrgg0n2raoLe90wSYD7AG9dzAdr/RFwdVXdOIdr/hvYCvhz4GuL0itJkpaAGV1J0nJxw2SQ2/p++/GLk0FuR/kq4Hbt14cAG2iyv6smD5pFnwAOnOGeOwHbAlfPt/OLZLJfeyxpLyRJWmAGupKk5eLXnV9U1Yb20+u66k2WTw7nvTVN1vN6YGPHMTkPdtcZ7jnZxvoe5zYBK6e5biVQ3HJV5dn8DNg9yXZzuOam9uO2c7hGkqSh59BlSZJmdi3NSsYPmOb8L2e5FmDnHueuYvpM6h40w5Crrx42vggcRbOy8if6vGaX9uM1c7iPJElDz4yuJEkzO4MmM/sHVXV+j2PaQLfNGl8O3LHH6S8B+ye5RbCbZFuaYPVLc+znJ4EfAP/UvWp02+6qyVWmO+zdfvzBHO8lSdJQM6MrSdIMquqcJB8BPp7kLcA3gQlgL+DhwMur6oczNPFl4N49yk+g2Xroa0leB/wIuD3wYpoVol8zx35uSvI44AvAhUlOAM5vT98TOJpm/vF/dFx2H+AXVfXjudxLkqRhZ6ArSdLsjgBeABwJ/D3NnNuf0OxDe+Us154GrEmyV1X9ZLKwqq5KcgDwj8BxwO7Ab4BzgTVVtXaunayq7yW5J/ASmiD6OCA0QfQnaYLrTo8ATp3rfSRJGnaZ2/QfSZI0F0lW0ASaJ1fV8Uvdn0lJ7kOzpdCfzZKRliRp5BjoSpK0yJI8FXgLsPcc97ldNEk+BVxXVUcudV8kSVpoDl2WJGnxfZhm/u1ewPeWtiuQZBvgv4F/X+q+SJK0GMzoSpIkSZLGitsLSZIkSZLGioGuJEmSJGmsGOhKkiRJksaKga4kSZIkaawY6EqSJEmSxoqBriRJkiRprPz/oeYIiGeyjTsAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_steps = 30\n",
    "slope_threshold = 10000 #This number needs to be adjusted in order to correctly filter out non-RFI NOTE: 5000 works\n",
    "LL_Set_RFI_Regions = Find_RFI_Regions(t_plt, LL_set, time_steps, slope_threshold, 900) #Returns an array of [freq, df, time, dt]\n",
    "\n",
    "first_RFI_region = LL_Set_RFI_Regions[0]\n",
    "\n",
    "#Try plotting the first RFI_Region\n",
    "\n",
    "power_min = 70\n",
    "power_max = 78\n",
    "\n",
    "t1_plt = first_RFI_region[2] - first_RFI_region[3]\n",
    "t2_plt = first_RFI_region[2] + first_RFI_region[3]\n",
    "\n",
    "freq1 = first_RFI_region[0] - first_RFI_region[1]\n",
    "freq2 = first_RFI_region[0] + first_RFI_region[1]\n",
    "######################################\n",
    "rfi_start_idx = find_nearest_idx(t_plt, t1_plt)\n",
    "rfi_end_idx = find_nearest_idx(t_plt, t2_plt)\n",
    "\n",
    "f_plt_start_idx = find_nearest_idx(freq, freq1)\n",
    "f_plt_end_idx = find_nearest_idx(freq, freq2)\n",
    "\n",
    "RFI_duration_time = t_plt[rfi_start_idx: rfi_end_idx]\n",
    "\n",
    "RFI_freq_bandwith = freq[f_plt_start_idx: f_plt_end_idx]\n",
    "\n",
    "\n",
    "fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "fs = 16\n",
    "\n",
    "im = axs.imshow(10.*np.log10(LL_set[rfi_start_idx: rfi_end_idx,f_plt_start_idx: f_plt_end_idx].T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "            extent=[RFI_duration_time[0],RFI_duration_time[-1],RFI_freq_bandwith[0],RFI_freq_bandwith[-1]])\n",
    "\n",
    "divider = make_axes_locatable(axs)\n",
    "cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "cbar.ax.tick_params(labelsize=fs) \n",
    "cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "axs.set_xlim(RFI_duration_time[0],RFI_duration_time[-1])\n",
    "# axs.set_ylim(RFI_freq_bandwith[0],RFI_freq_bandwith[-1])\n",
    "axs.tick_params(axis='both', labelsize=fs)\n",
    "axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "\n",
    "#TODO: I don't think it's clear which region this method is flaggin as RFI\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ad2bdc8ecc057115af97d19610ffacc2b4e99fae6737bb82f5d7fb13d2f2c186"
  },
  "kernelspec": {
   "display_name": "Python 3.8.8 ('base')",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}