diff --git "a/Gradio_app.ipynb" "b/Gradio_app.ipynb" --- "a/Gradio_app.ipynb" +++ "b/Gradio_app.ipynb" @@ -2,14 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Running on local URL: http://127.0.0.1:7862\n", + "Running on local URL: http://127.0.0.1:7865\n", "\n", "To create a public link, set `share=True` in `launch()`.\n" ] @@ -17,7 +17,7 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ "" @@ -30,9 +30,45 @@ "data": { "text/plain": [] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting to download inventory\n", + "Finished downloading inventory\n", + "Processing CI.CCC...\n", + "Downloading waveform for CI_CCC_2019-07-04T17:33:40.494920Z\n", + "Skipping CI_CCC_2019-07-04T17:33:40.494920Z\n", + "Processing CI.CLC...\n", + "Processing CI.JRC2...\n", + "Reading cached waveform\n", + "Added CI.JRC2 to the list of waveforms\n", + "Processing CI.LRL...\n", + "Reading cached waveform\n", + "Added CI.LRL to the list of waveforms\n", + "Processing CI.MPM...\n", + "Reading cached waveform\n", + "Processing CI.Q0072...\n", + "Reading cached waveform\n", + "Processing CI.SLA...\n", + "Reading cached waveform\n", + "Added CI.SLA to the list of waveforms\n", + "Processing CI.SRT...\n", + "Reading cached waveform\n", + "Added CI.SRT to the list of waveforms\n", + "Processing CI.TOW2...\n", + "Reading cached waveform\n", + "Added CI.TOW2 to the list of waveforms\n", + "Processing CI.WBM...\n", + "Downloading waveform for CI_WBM_2019-07-04T17:33:40.063616Z\n", + "Skipping CI_WBM_2019-07-04T17:33:40.063616Z\n", + "Processing CI.WCS2...\n", + "Downloading waveform for CI_WCS2_2019-07-04T17:33:40.200958Z\n" + ] } ], "source": [ @@ -67,6 +103,9 @@ "\n", "from glob import glob\n", "\n", + "import numpy as np\n", + "from matplotlib import colors, cm\n", + "from scipy.interpolate import griddata\n", "\n", "def resample_waveform(waveform, original_freq, target_freq):\n", " \"\"\"\n", @@ -473,10 +512,6 @@ " \n", " return image, output_picks, output_csv\n", "\n", - "import numpy as np\n", - "from matplotlib import colors, cm\n", - "from scipy.interpolate import griddata\n", - "\n", "def interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth):\n", " # Create a mask for points with the initial velocity\n", " initial_velocity_mask = (velocity_model == initial_velocity)\n", @@ -523,120 +558,123 @@ "def find_closest_index(array, value):\n", " return np.argmin(np.abs(array - value))\n", "\n", - "def compute_velocity_model(azimuth, elevation, interpolate, n_lat, n_lon, n_depth):\n", - " filename = list(output_csv.temp_files)[0]\n", + "# FIX AFTER CONFERENCE\n", + "# def compute_velocity_model(azimuth, elevation, interpolate, n_lat, n_lon, n_depth):\n", + "# filename = list(output_csv.temp_files)[0]\n", " \n", - " df = pd.read_csv(filename)\n", - " filename = filename.split('/')[-1]\n", + "# df = pd.read_csv(filename)\n", + "# filename = filename.split('/')[-1]\n", " \n", - " # Current EQ location\n", - " eq_lat = float(filename.split(\"_\")[0])\n", - " eq_lon = float(filename.split(\"_\")[1])\n", - " eq_depth = float(filename.split(\"_\")[2])\n", - "\n", - " # Define the region of interest (latitude, longitude, and depth ranges)\n", - " lat_range = (np.min([df.st_lat.min(), eq_lat]), np.max([df.st_lat.max(), eq_lat]))\n", - " lon_range = (np.min([df.st_lon.min(), eq_lon]), np.max([df.st_lon.max(), eq_lon]))\n", - " depth_range = (0, 50)\n", - "\n", - " # Define the number of nodes in each dimension\n", - " num_points = 100\n", - "\n", - " taup_model = TauPyModel(model='1066a')\n", - "\n", - " # Create the grid\n", - " lat_values = np.linspace(lat_range[0], lat_range[1], n_lat)\n", - " lon_values = np.linspace(lon_range[0], lon_range[1], n_lon)\n", - " depth_values = np.linspace(depth_range[0], depth_range[1], n_depth)\n", - "\n", - " # Initialize the velocity model with constant values\n", - " initial_velocity = 0 # km/s, this can be P-wave or S-wave velocity\n", - " velocity_model = np.full((n_lat, n_lon, n_depth), initial_velocity, dtype=float)\n", - "\n", - " # Loop through the stations and update the velocity model\n", - " for i in range(len(df)):\n", - " if ~np.isnan(df['velocity_p, km/s'].iloc[i]):\n", - "\n", - " ray_path = taup_model.get_ray_paths_geo(source_depth_in_km=eq_depth,\n", - " source_latitude_in_deg=eq_lat,\n", - " source_longitude_in_deg=eq_lon,\n", - " receiver_latitude_in_deg=df.st_lat.iloc[i],\n", - " receiver_longitude_in_deg=df.st_lon.iloc[i],\n", - " phase_list=['P', 'S'])\n", - "\n", - " # Create the interpolator objects for latitude, longitude, and depth\n", - " interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])\n", - " interp_longitude = interp1d(np.linspace(0, ray_path[0].path['lon'].max(), len(ray_path[0].path['lon'])), ray_path[0].path['lon'])\n", - " interp_depth = interp1d(np.linspace(0, ray_path[0].path['depth'].max(), len(ray_path[0].path['depth'])), ray_path[0].path['depth'])\n", - "\n", - " # Resample the ray path to N points\n", - " lat_values_interp = interp_latitude(np.linspace(0, ray_path[0].path['lat'].max(), num_points))\n", - " lon_values_interp = interp_longitude(np.linspace(0, ray_path[0].path['lon'].max(), num_points))\n", - " depth_values_interp = interp_depth(np.linspace(0, ray_path[0].path['depth'].max(), num_points))\n", - "\n", - " # Loop through the interpolated coordinates and update the grid cells with the average P-wave velocity\n", - " for lat, lon, depth in zip(lat_values_interp, lon_values_interp, depth_values_interp):\n", - " lat_index = find_closest_index(lat_values, lat)\n", - " lon_index = find_closest_index(lon_values, lon)\n", - " depth_index = find_closest_index(depth_values, depth)\n", + "# # Current EQ location\n", + "# eq_lat = float(filename.split(\"_\")[0])\n", + "# eq_lon = float(filename.split(\"_\")[1])\n", + "# eq_depth = float(filename.split(\"_\")[2])\n", + "\n", + "# # Define the region of interest (latitude, longitude, and depth ranges)\n", + "# lat_range = (np.min([df.st_lat.min(), eq_lat]), np.max([df.st_lat.max(), eq_lat]))\n", + "# lon_range = (np.min([df.st_lon.min(), eq_lon]), np.max([df.st_lon.max(), eq_lon]))\n", + "# depth_range = (0, 50)\n", + "\n", + "# # Define the number of nodes in each dimension\n", + "# num_points = 100\n", + "\n", + "# taup_model = TauPyModel(model='1066a')\n", + "\n", + "# # Create the grid\n", + "# lat_values = np.linspace(lat_range[0], lat_range[1], n_lat)\n", + "# lon_values = np.linspace(lon_range[0], lon_range[1], n_lon)\n", + "# depth_values = np.linspace(depth_range[0], depth_range[1], n_depth)\n", + "\n", + "# # Initialize the velocity model with constant values\n", + "# initial_velocity = 0 # km/s, this can be P-wave or S-wave velocity\n", + "# velocity_model = np.full((n_lat, n_lon, n_depth), initial_velocity, dtype=float)\n", + "\n", + "# # Loop through the stations and update the velocity model\n", + "# for i in range(len(df)):\n", + "# if ~np.isnan(df['velocity_p, km/s'].iloc[i]):\n", + "\n", + "# ray_path = taup_model.get_ray_paths_geo(source_depth_in_km=eq_depth,\n", + "# source_latitude_in_deg=eq_lat,\n", + "# source_longitude_in_deg=eq_lon,\n", + "# receiver_latitude_in_deg=df.st_lat.iloc[i],\n", + "# receiver_longitude_in_deg=df.st_lon.iloc[i],\n", + "# phase_list=['P', 'S'])\n", + " \n", + "# # THERE IS A PROBLEM WITH THE RAY PATHS. APPARENTLY LAT AND LON DON'T EXIST (HOW DID IT WORK BEFORE?)\n", + "# print(ray_path[0].path)\n", + "\n", + "# # Create the interpolator objects for latitude, longitude, and depth\n", + "# interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])\n", + "# interp_longitude = interp1d(np.linspace(0, ray_path[0].path['lon'].max(), len(ray_path[0].path['lon'])), ray_path[0].path['lon'])\n", + "# interp_depth = interp1d(np.linspace(0, ray_path[0].path['depth'].max(), len(ray_path[0].path['depth'])), ray_path[0].path['depth'])\n", + "\n", + "# # Resample the ray path to N points\n", + "# lat_values_interp = interp_latitude(np.linspace(0, ray_path[0].path['lat'].max(), num_points))\n", + "# lon_values_interp = interp_longitude(np.linspace(0, ray_path[0].path['lon'].max(), num_points))\n", + "# depth_values_interp = interp_depth(np.linspace(0, ray_path[0].path['depth'].max(), num_points))\n", + "\n", + "# # Loop through the interpolated coordinates and update the grid cells with the average P-wave velocity\n", + "# for lat, lon, depth in zip(lat_values_interp, lon_values_interp, depth_values_interp):\n", + "# lat_index = find_closest_index(lat_values, lat)\n", + "# lon_index = find_closest_index(lon_values, lon)\n", + "# depth_index = find_closest_index(depth_values, depth)\n", " \n", - " if velocity_model[lat_index, lon_index, depth_index] == initial_velocity:\n", - " velocity_model[lat_index, lon_index, depth_index] = df['velocity_p, km/s'].iloc[i]\n", - " else:\n", - " velocity_model[lat_index, lon_index, depth_index] = (velocity_model[lat_index, lon_index, depth_index] +\n", - " df['velocity_p, km/s'].iloc[i]) / 2\n", - "\n", - " # Create the figure and axis\n", - " fig = plt.figure(figsize=(8, 8))\n", - " ax = fig.add_subplot(111, projection='3d')\n", - "\n", - " # Set the plot limits\n", - " ax.set_xlim3d(lat_range[0], lat_range[1])\n", - " ax.set_ylim3d(lon_range[0], lon_range[1])\n", - " ax.set_zlim3d(depth_range[1], depth_range[0])\n", - "\n", - " ax.set_xlabel('Latitude')\n", - " ax.set_ylabel('Longitude')\n", - " ax.set_zlabel('Depth (km)')\n", - " ax.set_title('Velocity Model')\n", + "# if velocity_model[lat_index, lon_index, depth_index] == initial_velocity:\n", + "# velocity_model[lat_index, lon_index, depth_index] = df['velocity_p, km/s'].iloc[i]\n", + "# else:\n", + "# velocity_model[lat_index, lon_index, depth_index] = (velocity_model[lat_index, lon_index, depth_index] +\n", + "# df['velocity_p, km/s'].iloc[i]) / 2\n", + "\n", + "# # Create the figure and axis\n", + "# fig = plt.figure(figsize=(8, 8))\n", + "# ax = fig.add_subplot(111, projection='3d')\n", + "\n", + "# # Set the plot limits\n", + "# ax.set_xlim3d(lat_range[0], lat_range[1])\n", + "# ax.set_ylim3d(lon_range[0], lon_range[1])\n", + "# ax.set_zlim3d(depth_range[1], depth_range[0])\n", + "\n", + "# ax.set_xlabel('Latitude')\n", + "# ax.set_ylabel('Longitude')\n", + "# ax.set_zlabel('Depth (km)')\n", + "# ax.set_title('Velocity Model')\n", " \n", - " # Create the meshgrid\n", - " x, y, z = np.meshgrid(\n", - " np.linspace(lat_range[0], lat_range[1], velocity_model.shape[0]+1),\n", - " np.linspace(lon_range[0], lon_range[1], velocity_model.shape[1]+1),\n", - " np.linspace(depth_range[0], depth_range[1], velocity_model.shape[2]+1),\n", - " indexing='ij'\n", - " )\n", - "\n", - " # Create the color array\n", - " norm = plt.Normalize(vmin=2, vmax=8)\n", - " colors_vel = plt.cm.plasma(norm(velocity_model)) \n", + "# # Create the meshgrid\n", + "# x, y, z = np.meshgrid(\n", + "# np.linspace(lat_range[0], lat_range[1], velocity_model.shape[0]+1),\n", + "# np.linspace(lon_range[0], lon_range[1], velocity_model.shape[1]+1),\n", + "# np.linspace(depth_range[0], depth_range[1], velocity_model.shape[2]+1),\n", + "# indexing='ij'\n", + "# )\n", + "\n", + "# # Create the color array\n", + "# norm = plt.Normalize(vmin=2, vmax=8)\n", + "# colors_vel = plt.cm.plasma(norm(velocity_model)) \n", " \n", - " # Plot the voxels\n", - " if interpolate:\n", - " interpolated_velocity_model = interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth)\n", - " colors_interp = plt.cm.plasma(norm(interpolated_velocity_model))\n", - " ax.voxels(x, y, z, interpolated_velocity_model > 0, facecolors=colors_interp, alpha=0.5, edgecolor='k')\n", + "# # Plot the voxels\n", + "# if interpolate:\n", + "# interpolated_velocity_model = interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth)\n", + "# colors_interp = plt.cm.plasma(norm(interpolated_velocity_model))\n", + "# ax.voxels(x, y, z, interpolated_velocity_model > 0, facecolors=colors_interp, alpha=0.5, edgecolor='k')\n", " \n", - " ax.voxels(x, y, z, velocity_model > 0, facecolors=colors_vel, alpha=1, edgecolor='black')\n", + "# ax.voxels(x, y, z, velocity_model > 0, facecolors=colors_vel, alpha=1, edgecolor='black')\n", "\n", - " # Set the view angle\n", - " ax.view_init(elev=elevation, azim=azimuth)\n", + "# # Set the view angle\n", + "# ax.view_init(elev=elevation, azim=azimuth)\n", "\n", - " m = cm.ScalarMappable(cmap=plt.cm.plasma, norm=norm)\n", - " m.set_array([])\n", - " plt.colorbar(m)\n", + "# m = cm.ScalarMappable(cmap=plt.cm.plasma, norm=norm)\n", + "# m.set_array([])\n", + "# plt.colorbar(m)\n", "\n", - " # Show the plot\n", - " fig.canvas.draw();\n", - " image = np.array(fig.canvas.renderer.buffer_rgba())\n", - " plt.close(fig)\n", + "# # Show the plot\n", + "# fig.canvas.draw();\n", + "# image = np.array(fig.canvas.renderer.buffer_rgba())\n", + "# plt.close(fig)\n", "\n", - " return image\n", + "# return image\n", "\n", "# model = torch.jit.load(\"model.pt\")\n", "model = torch.jit.load(\"model.pt\")\n", - "\n", "model.eval()\n", "\n", "with gr.Blocks() as demo:\n", @@ -663,8 +701,8 @@ " -webkit-text-fill-color: transparent;\n", " background-clip: text;\">uncertainty

\n", " \n", "

Please contact me at anovosel@stanford.edu with questions and feedback

\n", @@ -814,25 +852,25 @@ " button_phases = gr.Button(\"Predict phases\")\n", " output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)\n", " \n", - " with gr.Row():\n", - " with gr.Column(scale=2):\n", - " azimuth_input = gr.Slider(minimum=-180, maximum=180, value=0, step=5, label=\"Azimuth\", interactive=True)\n", - " elevation_input = gr.Slider(minimum=-90, maximum=90, value=30, step=5, label=\"Elevation\", interactive=True)\n", - "\n", - " with gr.Row():\n", - " interpolate_input = gr.Checkbox(label=\"Interpolate\", info=\"Interpolate velocity model\")\n", - " n_lat_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lat\", info='Number of Lat grid points', interactive=True)\n", - " n_lon_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lon\", info='Number of Lon grid points', interactive=True)\n", - " n_depth_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N depth\", info='Number of Depth grid points', interactive=True)\n", + " # with gr.Row():\n", + " # with gr.Column(scale=2):\n", + " # azimuth_input = gr.Slider(minimum=-180, maximum=180, value=0, step=5, label=\"Azimuth\", interactive=True)\n", + " # elevation_input = gr.Slider(minimum=-90, maximum=90, value=30, step=5, label=\"Elevation\", interactive=True)\n", + "\n", + " # with gr.Row():\n", + " # interpolate_input = gr.Checkbox(label=\"Interpolate\", info=\"Interpolate velocity model\")\n", + " # n_lat_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lat\", info='Number of Lat grid points', interactive=True)\n", + " # n_lon_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lon\", info='Number of Lon grid points', interactive=True)\n", + " # n_depth_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N depth\", info='Number of Depth grid points', interactive=True)\n", " \n", - " button = gr.Button(\"Look at 3D Velocities\")\n", - " outputs_vel_model = gr.Image(label=\"3D Velocity Model\")\n", - "\n", - " button.click(compute_velocity_model, \n", - " inputs=[azimuth_input, elevation_input, \n", - " interpolate_input, n_lat_input, \n", - " n_lon_input, n_depth_input], \n", - " outputs=[outputs_vel_model])\n", + " # button = gr.Button(\"Look at 3D Velocities\")\n", + " # outputs_vel_model = gr.Image(label=\"3D Velocity Model\")\n", + "\n", + " # button.click(compute_velocity_model, \n", + " # inputs=[azimuth_input, elevation_input, \n", + " # interpolate_input, n_lat_input, \n", + " # n_lon_input, n_depth_input], \n", + " # outputs=[outputs_vel_model])\n", " \n", " with gr.Row():\n", " output_picks = gr.Dataframe(label='Pick data', \n", @@ -851,454 +889,13 @@ "demo.launch()" ] }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import obspy\n", - "from obspy.clients.fdsn import Client\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "client = Client('IRIS')\n", - "\n", - "radius_km = 150\n", - "window = radius_km / 111.2\n", - "max_waveforms = 10\n", - "\n", - "starttime = obspy.UTCDateTime('2023-01-23 00:00:00.000')\n", - "endtime = starttime + 60*60*24\n", - "\n", - "eq_lat = 35.6173961\n", - "eq_lon = 139.7453414\n", - "\n", - "inv = client.get_stations(network=\"*\", station=\"*\", location=\"*\", channel=\"*H*\", \n", - " starttime=starttime, endtime=endtime, \n", - " minlatitude=(eq_lat-window), maxlatitude=(eq_lat+window),\n", - " minlongitude=(eq_lon-window), maxlongitude=(eq_lon+window), \n", - " level='response')\n", - "\n", - "waveform = client.get_waveforms(network=inv[0].code, station=inv[0][0].code, location=\"*\", channel=\"*\", \n", - " starttime=starttime, endtime=endtime)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - " waveform.copy().select(channel=\"*Z\")[0].filter('lowpass', freq=0.1).plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "db = pd.read_csv('/Users/anovosel/Downloads/trades.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "db_res = db.set_index(pd.DatetimeIndex(db['ts']))\n", - "db_res = db_res.resample('50L').interpolate()" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " WARNING: FIR normalized: sum[coef]=6.156722E-01; \n", - " WARNING (norm_resp): computed and reported sensitivities differ by more than 5 percent. \n", - "\t Execution continuing.\n" - ] - } - ], - "source": [ - "from scipy import stats\n", - "\n", - "length = int(1e7)\n", - "start = int(1e6)\n", - "\n", - "disp = waveform.copy().select(channel=\"*Z\")[0].remove_response(inventory=inv, output=\"DISP\", water_level=60).data[start:length]\n", - "\n", - "norm_bid = db_res['bid_price_1'][start:length]/db_res['bid_price_1'][start:length].max()\n", - "norm_disp = np.abs(disp)/np.abs(disp).max()\n", - "\n", - "n = int(1e5) # Change this value to adjust the window size\n", - "window = np.ones(n)\n", - "running_sum = np.convolve(norm_disp, window, mode='same')\n", - "\n", - "fig,ax = plt.subplots(nrows=2)\n", - "ax[0].plot(norm_bid.index, running_sum, color='red')\n", - "ax[1].plot(norm_bid.index, norm_bid, color='blue')\n", - "\n", - "print('Pearson correlation coefficient: ', stats.pearsonr(running_sum, norm_bid).pvalue)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " WARNING: FIR normalized: sum[coef]=6.156722E-01; \n", - " WARNING (norm_resp): computed and reported sensitivities differ by more than 5 percent. \n", - "\t Execution continuing.\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "length = int(1e7)\n", - "\n", - "disp = waveform.copy().select(channel=\"*Z\")[0].filter('lowpass', freq=0.1).remove_response(inventory=inv, output=\"DISP\", water_level=60).data[:length]\n", - "\n", - "norm_bid = db_res['bid_price_1'][:length]/db_res['bid_price_1'][:length].max()\n", - "norm_disp = np.abs(disp)/np.abs(disp).max()\n", - "\n", - "n = int(1e6) # Change this value to adjust the window size\n", - "window = np.ones(n) / n\n", - "running_mean = np.convolve(norm_disp, window, mode='same')\n", - "\n", - "# Calculate gradients using numpy\n", - "grad_running_mean = np.gradient(running_mean)\n", - "grad_norm_bid = np.gradient(norm_bid)\n", - "\n", - "fig, ax = plt.subplots(nrows=2)\n", - "ax[0].plot(norm_bid.index, grad_running_mean, color='red')\n", - "ax[1].plot(norm_bid.index, grad_norm_bid, color='blue')\n", - "\n", - "# Compute Pearson correlation coefficient using numpy\n", - "pearson_corr_coeff = np.corrcoef(running_mean, norm_bid)[0, 1]\n", - "print('Pearson correlation coefficient: ', pearson_corr_coeff)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(db_res['bid_price_1'])" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bid_price_1 0.012663067531922095\n", - "bid_volume_1 2.0945533214878415e-68\n", - "ask_price_1 0.012663067531922095\n", - "ask_volume_1 3.5434123510723287e-25\n", - "bid_price_2 0.012663067531922095\n", - "bid_volume_2 1.61850808697619e-120\n", - "ask_price_2 0.012663067531922095\n", - "ask_volume_2 5.8902861400057176e-136\n", - "bid_price_3 0.012663067531922095\n", - "bid_volume_3 2.8038e-319\n", - "ask_price_3 0.012663067531922095\n", - "ask_volume_3 6.910930394043699e-63\n", - "bid_price_4 0.012663067531922095\n", - "bid_volume_4 2.573769455490031e-129\n", - "ask_price_4 0.012663067531922095\n", - "ask_volume_4 3.302722834897649e-179\n", - "bid_price_5 0.012663067531922095\n", - "bid_volume_5 1.2606365805909815e-226\n", - "ask_price_5 0.012663067531922095\n", - "ask_volume_5 1.3647948258840875e-62\n", - "bid_price_6 0.012663067531922095\n", - "bid_volume_6 1.8974778193854842e-87\n", - "ask_price_6 0.012663067531922095\n", - "ask_volume_6 0.001575430227266945\n", - "bid_price_7 0.012663067531922095\n", - "bid_volume_7 4.592422309223935e-56\n", - "ask_price_7 0.012663067531922095\n", - "ask_volume_7 0.06260176464553072\n", - "bid_price_8 0.012663067531922095\n", - "bid_volume_8 3.1065840939075623e-46\n", - "ask_price_8 0.012663067531922095\n", - "ask_volume_8 1.0769675953861268e-58\n", - "bid_price_9 0.012663067531922095\n", - "bid_volume_9 0.4792246937037036\n", - "ask_price_9 0.012663067531922095\n", - "ask_volume_9 7.12041825406306e-54\n", - "bid_price_10 0.012663067531922095\n", - "bid_volume_10 0.0052885260547899035\n", - "ask_price_10 0.012663067531922095\n", - "ask_volume_10 0.0\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "from scipy import stats\n", - "for column in db_res.columns:\n", - " if column not in ['receive_ts', 'exchange_ts', 'ts', ]:\n", - " print(column, stats.pearsonr(disp, db_res[column]).pvalue)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['exchange_ts', 'receive_ts', 'ts', 'bid_price_1', 'bid_volume_1',\n", - " 'ask_price_1', 'ask_volume_1', 'bid_price_2', 'bid_volume_2',\n", - " 'ask_price_2', 'ask_volume_2', 'bid_price_3', 'bid_volume_3',\n", - " 'ask_price_3', 'ask_volume_3', 'bid_price_4', 'bid_volume_4',\n", - " 'ask_price_4', 'ask_volume_4', 'bid_price_5', 'bid_volume_5',\n", - " 'ask_price_5', 'ask_volume_5', 'bid_price_6', 'bid_volume_6',\n", - " 'ask_price_6', 'ask_volume_6', 'bid_price_7', 'bid_volume_7',\n", - " 'ask_price_7', 'ask_volume_7', 'bid_price_8', 'bid_volume_8',\n", - " 'ask_price_8', 'ask_volume_8', 'bid_price_9', 'bid_volume_9',\n", - " 'ask_price_9', 'ask_volume_9', 'bid_price_10', 'bid_volume_10',\n", - " 'ask_price_10', 'ask_volume_10'],\n", - " dtype='object')" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "db_res.columns" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(db_res['bid_price_1'], disp )" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1728001, 1728001)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 107, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAGdCAYAAADZiZ2PAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABeE0lEQVR4nO3deZhV1Z3v//fa+8w1MhRQyqDEIGJCyqYVISHodUAS02oSpLWNEDC5pk2rrd5u0PwM5mlDbtvaxr7dMWlAzA1JxCQYHGJrTKk3kZh2KIwDBLRMoVLIVOfUqTrzXr8/TnGkrIGqglPj5/U8+0nO3muvvXZtq86Xtdb+LmOttYiIiIhIrzkD3QARERGRoUqBlIiIiEgfKZASERER6SMFUiIiIiJ9pEBKREREpI8USImIiIj0kQIpERERkT5SICUiIiLSR76BbsBw53ke7733HmVlZRhjBro5IiIi0gPWWpqbmznuuONwnK77nRRIFdl7773HpEmTBroZIiIi0ge7du1i4sSJXR5XIFVkZWVlQP5BlJeXD3BrREREpCdisRiTJk0qfI93RYFUkR0azisvL1cgJSIiMsQcaVqOJpuLiIiI9FHRAqnbb7+duXPnEolEqKys7LTMtddey6xZswgGg9TU1HQ4vmrVKowxHbaSkpIjXn/9+vXMnDmTUCjEuHHjuOaaa9odf+WVV5g3bx6hUIhJkybxz//8zx3qePDBB5k+fTqhUIiPf/zjPPbYYz26dxERERkZihZIpdNpFi1axNe+9rVuyy1btozFixd3euymm25i9+7d7bYZM2awaNGibuu86667uOWWW1ixYgWvvfYav/71r1mwYEHheCwW4/zzz2fKlCm8+OKL3HHHHaxatYof/OAHhTLPPfccl112GcuXL+fll1/m4osv5uKLL+bVV1/txU9BREREhjNjrbXFvMD69eu5/vrraWpq6rLMqlWreOihh6irq+u2rq1bt1JTU8Ozzz7LvHnzOi1z8OBBjj/+eB5++GHOOeecTst873vf45ZbbqGxsZFAIADAihUreOihh9i2bRsAixcvpqWlhUceeaRw3plnnklNTQ333ntvt+08XCwWo6Kigmg0qjlSIiIiQ0RPv7+H1BypNWvWMG3atC6DKIAnn3wSz/N49913OeWUU5g4cSKXXnopu3btKpTZsmULn/70pwtBFMCCBQvYvn07Bw8eLJQ599xz29W9YMECtmzZ0m0bU6kUsVis3SYiIiLD05AJpJLJJBs2bGD58uXdlnvrrbfwPI9vf/vb3H333fzsZz/jwIEDnHfeeaTTaQAaGxsZP358u/MOfW5sbOy2zKHjXVm9ejUVFRWFTTmkREREhq9eBVIrVqzodPL34duhobFjbdOmTTQ3N7NkyZJuy3meRyaT4Z577mHBggWceeaZ/OQnP2HHjh3U1tYWpW2HW7lyJdFotLAd3hMmIiIiw0uv8kjdeOONLF26tNsyU6dOPZr2dGnNmjVceOGFHXqJPqy6uhqAGTNmFPZVVVUxduxYGhoaAJgwYQJ79uxpd96hzxMmTOi2zKHjXQkGgwSDwR7ckYiIiAx1vQqkqqqqqKqqKlZbulRfX09tbS2bN28+YtlPfvKTAGzfvr2Q0v3AgQPs27ePKVOmADBnzhxuueUWMpkMfr8fyM+tOvnkkxk1alShzFNPPcX1119fqPvJJ59kzpw5x/LW+iSd3cfBxP/DI0N5YCYlwekD3SQREZERqWhzpBoaGqirq6OhoYFcLkddXR11dXXE4/FCmZ07d1JXV0djYyOJRKJQ5tBcpkPWrVtHdXU1Cxcu7HCdTZs2MX36B4HEtGnTuOiii7juuut47rnnePXVV1myZAnTp0/n7LPPBuDyyy8nEAiwfPlyXnvtNR544AG++93vcsMNNxTque6663j88ce588472bZtG6tWreKFF17g61//+rH+UfVYzkvyp70r+MM7n+RP+/8XO/ffzEu7L+Tl975Aa/rtAWuXiIjIiGWLZMmSJRbosNXW1hbKzJ8/v9My9fX1hTK5XM5OnDjR3nzzzZ1e57777rMfvo1oNGqXLVtmKysr7ejRo+0ll1xiGxoa2pXZunWr/dSnPmWDwaA9/vjj7Xe+850OdW/cuNFOmzbNBgIBe+qpp9pHH3201z+HaDRqARuNRnt97uE8z7Ov7F5qn60/yT5b/5EPbR+1z/35L2w89eZRXUNERETyevr9XfQ8UiPdscojdTDxHK/uubKbEobRoU8xdfQ3CfmnHHFtIBEREenasMwjNZLtif8ccLspYWlK/oFY62O0JF4il0t3U1ZERESOhV5NNpeBk8ntA3LdlvFIkc28Q6uNYe1+wqG/xOeO7p8GioiIjEAKpIaIgDuOfAei12UZ1wQxBmymiWTu/+Hl3iccmovff6KG+kRERIpAQ3tDxPjSL9JdEAWGct8JuGRxjcEYi5d5jWT8EVLJF8jlkv3VVBERkRFDgdQQURE6g9Hhc4HOepYMPhOi0n8ijvUwJodjcxjrYL1GcsknySRryeX293ezRUREhjUFUkOEMYbpVfcwofQyDP52x8LOeI4PnYXfhDFYjLUY8sGU3+4mkHocX/M3sPu/iNd8N15WCymLiIgcC0p/UGTHKv3B4RKZ93g/upFk9g2CJkTALcVHDmMtDlmMAcdaIrkX8bEbi8FgOfSgjTMeRv8ExzfxmLRHRERkuFH6g2Es7D+OSaOv4fiKrxP2n4yDwVgHx7gY48fBJWT/hMtuAExbCGXaNuvthYN/i2JoERGRo6NAaohyHD+l4Y8zqvyvCAVmYhw/WHBwcSz4vfpOZ1MBGDzIbcOmX+jXNouIiAw3CqSGuIBvImUlCwkHP43PLccYi2taMGSOcKYD6d/3SxtFRESGKwVSw4DrlhGOzCdUciE+3+Que6I60tCeiIjI0VBCzmHCcXwEgx/D544m2zoGm336CL1SHgTO6Lf2iYiIDEfqkRpmXN9x+EoWYoMLsF32TTngfhQTmN2vbRMRERluFEgNQ65bilP+Txj/XwJ8KKAy4IyBUf+hZWNERESOkob2hinHjWBH/xCbeBiTeAByu8CUQ/hzEL4Mx60c6CaKiIgMeQqkhjFjXEzkYohc3KfzrfWALPnsUz71YImIiHyIAinpwFoLNo71YmDT+Z0mBE45xikZ2MaJiIgMIgqkpB1rLdbbD95BwAcmAFiwrdhcK1CFcY7NUjciIiJDnQIpac+2ghcFE8GYw/7zMH6sTWJz+8GEMCYwcG0UEREZJPTWnrRjbQtg2wdRbYwJARmwyX5vl4iIyGCkQErasxkwbjcFHKzN9ltzREREBjMFUvIhLlivm+MepttAS0REZORQICXtGKcU8NpSH7RnbYb8BPRQv7dLRERkMFIgJe2ZMJhSsM3YttQH1lqsTYFNgFOBMcEBbqSIiMjgoLf2pB1jXHCrsJ4fvGasTQAmnwbBGYtxKga6iSIiIoOGAinpwBgfxh2Ldcrzk8/bAqnO3uQTEREZyfTNKF0yJtCWkLN38sOAqbZPvra8UxpFFhGR4UeBlBwz1ubasqLH+WCNPsBEwB2ruVUiIjLsqJtAjokPlpZpAhPEOBX5pWRMCdgENre37a0/ERGR4UOBlBwjKfCawZS0m0tljNv2FmBrfhMRERlGihZI3X777cydO5dIJEJlZWWnZa699lpmzZpFMBikpqamw/FVq1ZhjOmwlZSUHPH669evZ+bMmYRCIcaNG8c111xTOPb0009z0UUXUV1dTUlJCTU1NWzYsKHD+R++biik/Eldsikg18XSMgbwY714vzdLRESkmIo2RyqdTrNo0SLmzJnD2rVruyy3bNkynn/+eV555ZUOx2666SauvvrqdvvOOeccTj/99G6vfdddd3HnnXdyxx13MHv2bFpaWnj77bcLx5977jlmzpzJP/7jPzJ+/HgeeeQRrrzySioqKrjwwgsL5crLy9m+fXvhcz4gkM5ZCnOiOmNMWxkREZHho2iB1G233Qbke3a6cs899wCwd+/eTgOp0tJSSktLC5+3bt3K66+/zr333ttlnQcPHuQb3/gGDz/8MOecc05h/8yZMwv//+abb253znXXXccTTzzBL37xi3aBlDGGCRMmdHktOVz+PyVrbecBp82CU9pxv4iIyBA2pOZIrVmzhmnTpjFv3rwuyzz55JN4nse7777LKaecwsSJE7n00kvZtWtXt3VHo1FGjx7dbl88HmfKlClMmjSJiy66iNdee+2IbUylUsRisXbbiGDC+aVjbEuHQ9amAAfjHHlIVkREZCgZMoFUMplkw4YNLF++vNtyb731Fp7n8e1vf5u7776bn/3sZxw4cIDzzjuPdDrd6TkbN27kv//7v/nyl79c2HfyySezbt06fvnLX/KjH/0Iz/OYO3cu77zzTrfXX716NRUVFYVt0qRJvb/ZIcgYF+OMAVysF8PaBNamsF5zPqmnMwpjwgPdTBERkWOqV4HUihUrOp38ffi2bdu2ojR006ZNNDc3s2TJkm7LeZ5HJpPhnnvuYcGCBZx55pn85Cc/YceOHdTW1nYoX1tby5e//GX+8z//k1NPPbWwf86cOVx55ZXU1NQwf/58fvGLX1BVVcX3v//9bq+/cuVKotFoYTtST9hwYpwIxncctAVUADjlGLcaxx01oG0TEREphl7NkbrxxhtZunRpt2WmTp16NO3p0po1a7jwwgsZP358t+Wqq6sBmDFjRmFfVVUVY8eOpaGhoV3ZZ555hs997nP867/+K1deeWW39fr9fk477TR27tzZbblgMEgwOHITTxoTwLijsXZU2+feT9Dvcp6ViIjIINOrQKqqqoqqqqpitaVL9fX11NbWsnnz5iOW/eQnPwnA9u3bmThxIgAHDhxg3759TJkypVDu6aef5sILL+R//+//zVe/+tUj1pvL5fjjH//IZz7zmT7excjS20DI2izY1vxQIDksvraEnhEtLyMiIoNW0b6hGhoaqKuro6GhgVwuR11dHXV1dcTjH+QS2rlzJ3V1dTQ2NpJIJAplPjyXad26dVRXV7Nw4cIO19m0aRPTp08vfJ42bRoXXXQR1113Hc899xyvvvoqS5YsYfr06Zx99tlAfjjvs5/9LNdeey1f+MIXaGxspLGxkQMHDhTq+da3vsUTTzzBW2+9xUsvvcQVV1zBn//8Z6666qpj/aMa8azNYHPvY3N7wLY9e5vA5t7Devuw1hvYBoqIiHTFFsmSJUss+cRB7bba2tpCmfnz53dapr6+vlAml8vZiRMn2ptvvrnT69x33332w7cRjUbtsmXLbGVlpR09erS95JJLbENDwxHbNn/+/EKZ66+/3k6ePNkGAgE7fvx4+5nPfMa+9NJLvf45RKNRC9hoNNrrc0eKXHaPzaX/ZHOZ3dbLNha2XOYdm0tvt16uaaCbKCIiI0xPv7+NtVZZEosoFotRUVFBNBqlvLx8oJsz6FibxmbfBePHGH8nx1sBP8Y9TkN8IiLSb3r6/a1vJhlYNgNkOg2i8gJtZbL92CgREZGeUSAlA8wAhq47Ru1h5URERAYXBVIysEwwv5Hs/LhNggl302MlIiIycBRIyYAyxgVTDjbTtpRMnrW2bX6Um0+DICIiMggVbdFikZ4yTgUWC14T1h62NqEJYNwxGCcycI0TERHphgIpGXDGGIw7CuuUgE0BHuCCCWGM/hMVEZHBS99SMmgYEwAT6PV5+YnqabBZMA4QVKoEERHpFwqkZEizNoXNHQTbCuQAAyYMTgXGKR3o5omIyDCnQEqGLGvTHywrY8IY48svJ2OT+f2gYEpERIpK4x8yZFmvGWwS45QV5lIZ47RNTnewXpPW6RMRkaJSICVDkrU5sHEwoc4LmFA+B5XtIj+ViIjIMaBASoYoD2zb232dyE82t/lyIiIiRaJASoYoF4xLV2vwWXto4nnngZaIiMixoEBKhiRjHDBlYFOdz4Oyrfm39+hi6E9EROQY0Ft7MmQZpwxrE2CbsQTJ/+fstc2L8mPc0RijxY5FRKR4FEjJkGWMD9xxWC8EtjmfBgHackiVY7qaiC4iInKMKJCSIc0YH8YdjbUVHErIaYx/oJslIiIjhAIpGRaMcenqDb6uWJsBm8DaJPkALNyW2FMT1EVEpGcUSMmIZL0WrLevbZFkF7BYmsBEwK3Kr/snIiJyBAqkZMTJLy2zF/AwTsVh+y3YeP6YW62Fj0VE5Ij0TSEjjvVagDTGKWm33xgDpiSfOsG2DkzjRERkSFEgJSOPTQCdT0g/1AtlD70BKCIi0g0FUiIiIiJ9pEBKRh4TBjKdHjqUJV2TzUVEpCcUSMmIk58bFWibK/WB/GTzlvybeyYyMI0TEZEhRW/tyYhjTADcKqy3D+tFOZT+ACyYCMat0ht7IiLSIwqkZEQyTgmYQFtCzgTgKCGniIj0mgIpGbGM8YPxYyjv9bnWWj6YZ+VTD5aIyAilQEqkl/JZ0WNgk/kdxg9OOZhSBVQiIiOMAimRXrBec1tWdAsmCBggjc3tAScFzth8Yk8RERkRivbP59tvv525c+cSiUSorKzstMy1117LrFmzCAaD1NTUdDi+atUqjDEdtpKSko6Vfcj69euZOXMmoVCIcePGcc011xSOvf32253W+/vf/75dHQ8++CDTp08nFArx8Y9/nMcee6xXPwMZXqzNYHP7wTgYpxRj/Bjjwxx6y89ryr/1JyIiI0bRAql0Os2iRYv42te+1m25ZcuWsXjx4k6P3XTTTezevbvdNmPGDBYtWtRtnXfddRe33HILK1as4LXXXuPXv/41CxYs6FDu17/+dbu6Z82aVTj23HPPcdlll7F8+XJefvllLr74Yi6++GJeffXVHty9DEs2CWTyk9I/xBgfYLBevN+bJSIiA8fY/KzZolm/fj3XX389TU1NXZZZtWoVDz30EHV1dd3WtXXrVmpqanj22WeZN29ep2UOHjzI8ccfz8MPP8w555zTaZm3336bE088kZdffrnTnjCAxYsX09LSwiOPPFLYd+aZZ1JTU8O9997bbTsPF4vFqKioIBqNUl7e+0nNMnhYrwmb24txOn+O1iYBB8c3qX8bJiIix1xPv7+H1MzYNWvWMG3atC6DKIAnn3wSz/N49913OeWUU5g4cSKXXnopu3bt6lD2r/7qrxg3bhyf+tSn2Lx5c7tjW7Zs4dxzz223b8GCBWzZsuXY3IwMQQ75fFNdsDnyOalERGSkGDKBVDKZZMOGDSxfvrzbcm+99Rae5/Htb3+bu+++m5/97GccOHCA8847j3Q6vxBtaWkpd955Jw8++CCPPvoon/rUp7j44ovbBVONjY2MHz++Xd3jx4+nsbGx2+unUilisVi7TYYJEwL8nS5onF9aJodxyvq9WSIiMnB6FUitWLGi00nah2/btm0rSkM3bdpEc3MzS5Ys6bac53lkMhnuueceFixYwJlnnslPfvITduzYQW1tLQBjx47lhhtuYPbs2Zx++ul85zvf4YorruCOO+446nauXr2aioqKwjZpkoZ5hgtjAuBUtCXxTHJoVNzaNNhmMCVaWkZEZITpVfqDG2+8kaVLl3ZbZurUqUfTni6tWbOGCy+8sEMv0YdVV1cDMGPGjMK+qqoqxo4dS0NDQ5fnzZ49myeffLLwecKECezZs6ddmT179jBhwoRur79y5UpuuOGGwudYLKZgahgxzigsDtgo2GbysZQPnFEYp1JZ0UVERpheBVJVVVVUVVUVqy1dqq+vp7a2tsM8ps588pOfBGD79u1MnDgRgAMHDrBv3z6mTJnS5Xl1dXWFIAxgzpw5PPXUU1x//fWFfU8++SRz5szp9vrBYJBgMHjEdsrQZIzBuJVYWwY21bbTl++tEhGREadoCTkbGho4cOAADQ0N5HK5wht5J510EqWlpQDs3LmTeDxOY2MjiUSiUGbGjBkEAh98Ma1bt47q6moWLlzY4TqbNm1i5cqVhSHFadOmcdFFF3Hdddfxgx/8gPLyclauXMn06dM5++yzAbj//vsJBAKcdtppAPziF79g3bp1rFmzplDvddddx/z587nzzjv57Gc/y09/+lNeeOEFfvCDHxzzn5UMPca4fRrGyw8DpgAPcMGE2lIniIjIkGSLZMmSJZb8K07tttra2kKZ+fPnd1qmvr6+UCaXy9mJEyfam2++udPr3HffffbDtxGNRu2yZctsZWWlHT16tL3kkktsQ0ND4fj69evtKaecYiORiC0vL7dnnHGGffDBBzvUvXHjRjtt2jQbCATsqaeeah999NFe/xyi0agFbDQa7fW5Mnx4nmdz2QM2l37L5tJ/+mDLvG29XPNAN09ERD6kp9/fRc8jNdIpj5QAeLkoeO+DCWJMfug3/6uXyK82447HOJqoLiIyWAzLPFIiQ5G1ufzkdOMvBFHQNt/KRIBcfhFkEREZchRIiRSbTbXNiwp1ftyE2lIqdMxPJSIig5sCKZGiy4+eG2O6ON7VfhERGewUSIkUm/EDPqzNdFEgUygjIiJDiwIpkSLLZ0QvaRu+a/9uR37+VBrjlGGMfh1FRIYa/RNYpB8YZxTWZtuyofvAuGAzQA6cSjBao09EZChSICXSD4zxgzsObCvWawZyYMIYpxxMRL1RIiJDlAIpkX5ijA9MOcYpx1rbzeTzrvX1PBERKQ4FUiIDoDfBkLVeW09WDMhicTFOaVtPlr94jRQRkSNSICUyiFnrYb394DUBTtvbfWlsbg+YEnCrtGCyiMgAUiAlMpjZeD6IMpF2ixtbbH7ieu4AuOM13CciMkA0w1VkkLLWtk1M97ULoqBtaNBEwLYCyoguIjJQFEiJDFpZsOm24byO8sFVri2NgoiIDAQFUiKDlmnbbKdHP0juqWE9EZGBokBKZJAyxgdOBGyyixIpMAEwwX5tl4iIfECBlMggZpwywIf1WtotL2NtCmwqn5fK6J0REZGBor/AIoOYMWFwx2G9A2Bj5GMpA/jAGYtxKge2gSIiI5wCKZFBzjglYEJgE0COfD6poPJHiYgMAgqkRIYAY1wwpX0619p025t9BkxAQ4EiIseQ/qKKDFPWZrFeE3jNQLZtrx/rVGCcCi2ULCJyDCiQEhmGrPWwuX1gY2DCGBNpm6yeBm8fFg+c0cqILiJylPRPUpHhyLa2BVFlhblUxhiMCYIJgxdFGdFFRI6eAimRYch6ccDtdPjOGD/5jOiJfm+XiMhwo0BKZFjKQbdzoAzW5vqtNSIiw5UCKZHhyASg20DJa+uZEhGRo6FASmQYMqYEyL+592HWJgF/PjeViIgcFb21JzIcmTA4o8Dbj7X+fA8VNr+sDGDcKiX0FBE5BhRIiQxDxhhwRoMJYL0Y2LY39EwY45RjnL4l9xQRkfYUSIkMU8YYMGVgSjg8IadyR4mIHDsKpESGuXwKhN4N41mbT49gbStgMSbUlthTw4EiIodTICUi7Vibxub25pN6YgAHSxQIgDtWw4IiIocp2lt7t99+O3PnziUSiVBZWdlpmWuvvZZZs2YRDAapqanpcHzVqlVt2ZjbbyUlJUe8/vr165k5cyahUIhx48ZxzTXX9Kre9evXdzgeCuktJxnePlhapjWfFd0pwzglGKcCjMXm9mLbJqyLiEgRe6TS6TSLFi1izpw5rF27tstyy5Yt4/nnn+eVV17pcOymm27i6quvbrfvnHPO4fTTT+/22nfddRd33nknd9xxB7Nnz6alpYW333671/WWl5ezffv2wmfNLZFhzybBtoAp6fDfe369vijWa8G4wQFqoIjI4FK0QOq2224D8j07XbnnnnsA2Lt3b6eBVGlpKaWlHwwjbN26lddff5177723yzoPHjzIN77xDR5++GHOOeecwv6ZM2f2ul5jDBMmTOjyWiLDT/7tPmPczg+bQNuQ3+j+a5KIyCA2pBJyrlmzhmnTpjFv3rwuyzz55JN4nse7777LKaecwsSJE7n00kvZtWtXr+uNx+NMmTKFSZMmcdFFF/Haa68dsY2pVIpYLNZuExERkeFpyARSyWSSDRs2sHz58m7LvfXWW3iex7e//W3uvvtufvazn3HgwAHOO+880umOq913Ve/JJ5/MunXr+OUvf8mPfvQjPM9j7ty5vPPOO91ef/Xq1VRUVBS2SZMm9f5mRQZM/q28LtfhsxkwkX5sj4jI4NarQGrFihWdTtI+fNu2bVtRGrpp0yaam5tZsmRJt+U8zyOTyXDPPfewYMECzjzzTH7yk5+wY8cOamtre1zvnDlzuPLKK6mpqWH+/Pn84he/oKqqiu9///vdXn/lypVEo9HC1l1PmMigY0L5vFO2BWu9does1wr4MM6RX/YQERkpejVH6sYbb2Tp0qXdlpk6derRtKdLa9as4cILL2T8+PHdlquurgZgxowZhX1VVVWMHTuWhoaGPtfr9/s57bTT2LlzZ7flgsEgwaAm4srQZIwD7lhszoJtxlqHfAqEHBDAuGMxRv99i4gc0qtAqqqqiqqqqmK1pUv19fXU1tayefPmI5b95Cc/CcD27duZOHEiAAcOHGDfvn1MmTKlz/Xmcjn++Mc/8pnPfKYPdyAydBgTAHdCW0LOJODlgycl5BQR6aBoc6QaGhqoq6ujoaGBXC5HXV0ddXV1xOPxQpmdO3dSV1dHY2MjiUSiUObDc5nWrVtHdXU1Cxcu7HCdTZs2MX369MLnadOmcdFFF3Hdddfx3HPP8eqrr7JkyRKmT5/O2Wef3eN6v/Wtb/HEE0/w1ltv8dJLL3HFFVfw5z//mauuuupofzQig54xLsYpxXHH4rjjME5Fj4Moay1e+o94yWfxMm8WuaUiIgOraOkPbr31Vu6///7C59NOOw2A2tpazjrrLACuuuoqnnnmmQ5l6uvrOeGEE4D8nKf169ezdOlSXLfjK9nRaLRdrieAH/7wh/z93/89n/3sZ3Ech/nz5/P444/j9/sLZY5U78GDB/nKV75CY2Mjo0aNYtasWTz33HPthgxFpD0v8TjE74DcB3MDPd9MKP8GTqBm4BomIlIkxlprB7oRw1ksFqOiooJoNEp5eflAN0ekaLzEQxD9B/Jzqg7/s+IAPhj9IwVTIjJk9PT7e8ikPxCRwcvzUhD7p7ZPH/63mQdkofnb/dwqEZHiUyAlIkcv9Wuw3SWf9SBTh5d5q9+aJCLSHxRIicjRy71Dj/6ceO8WvSkiIv1JgZSIHD1nNPkhvCMwWqNPRIYXBVIicvSCF3BoeZnOGXBPwPj11quIDC8KpETkqDluGZR8tZsSFspuwhjTb20SEekPCqRE5JgwpX8HJX8HHFpCpi1oMhVQ8S84ofMHqmkiIkVTtIScIjKyGGMwZX+HF1kKqSfAOwju8RD8HziO1ucTkeFJgZSIHFOOWwaRL/T6PGtzYBPkF0h2wAS1tp+IDHoKpERkwFkvjvUOgE2RT+hpAB/WqcA4ozS3SkQGLQVSIjKgrE1gc3vzH0xZIWiyNgXePiwG444awBaKiHRNk81FZEBZrxnIYpxIu54nY4JggmBjWJsduAaKiHRDgZSIDBhrs+C1gAl1USIINt025CciMvgokBKRAXRogePO/xR90EP14YWQRUQGBwVSIjKAfGAC+V6nTuSH9Fww/v5tlohIDymQEpEBY4zBOGVAtsM8KGst2FYwkfx8KRGRQUhv7YnIwDKl4KTAa8Jap633KQc2A6YE42qhYxEZvBRIiciAMsYBZwyYcNsbfBkgkA+gTASjYT0RGcQUSInIgDPGAVOKcUqx1vYpAWdfzxMRORoKpERkUOltMGRtAuu1gE3k3+0zJRinVMvLiEi/UCAlIkOW9WLY3D7Aa5tbZfPZ0L0YuOMwTmSgmygiw5ze2hORIcnaJDa3H4wP45RhTAhjwhinAvCw3j5lRBeRolMgJSJDkvVagGznqRFMJJ8N3Sb7vV0iMrIokBKRockmwXQ+OyE/z8pgu0j0KSJyrCiQEpEhyhxh5RibfxtQRKSI9FdGRIYk45SSz4jeMZqyNgcYQG/uiUhxKZASkaHJhPObjWOtV9htbRZsPJ8x3YQHsIEiMhIo/YGIDEnG+MGtyqc/sC1twZQBHDAVGHeMEnSKSNEpkBKRIcuYILjVYBNAW6oDEwSCCqJEpF8okBKRIS2/vExJn87Nz6VKg7Vg/FrXT0R6rahzpG6//Xbmzp1LJBKhsrKy0zLXXnsts2bNIhgMUlNT0+H4qlWrMMZ02EpKuv7DuX79+k7PMcbw/vvvF8o9/fTT/MVf/AXBYJCTTjqJ9evXd6jr3//93znhhBMIhULMnj2bP/zhD739MYjIIGOtbcuK/i42+27b/76Dl9uvJJ4i0itFDaTS6TSLFi3ia1/7Wrflli1bxuLFizs9dtNNN7F79+5224wZM1i0aFGX9S1evLjDOQsWLGD+/PmMGzcOgPr6ej772c9y9tlnU1dXx/XXX89VV13Ff/3XfxXqeeCBB7jhhhv45je/yUsvvcQnPvEJFixY0C4YE5Ghx3oHsbk95JeWKcU45WBc8PZjc3vbeqpERI7M2M7eHT7G1q9fz/XXX09TU1OXZVatWsVDDz1EXV1dt3Vt3bqVmpoann32WebNm9ej6+/du5fjjz+etWvX8qUvfQmAf/zHf+TRRx/l1VdfLZT767/+a5qamnj88ccBmD17Nqeffjr/5//8HwA8z2PSpEn83d/9HStWrOjRtWOxGBUVFUSjUcrLy3t0jogUj7VpbPZdMG6HrOjWemDjGLe6Lb2CiIxUPf3+HnLpD9asWcO0adN6HEQB/PCHPyQSifDFL36xsG/Lli2ce+657cotWLCALVu2APnetBdffLFdGcdxOPfccwtlOpNKpYjFYu02ERlEbBLIdLq0TD6Bp5Nf9FhEpAeGVCCVTCbZsGEDy5cv79V5a9eu5fLLLycc/iCnTGNjI+PHj29Xbvz48cRiMRKJBPv27SOXy3VaprGxsctrrV69moqKisI2adKkXrVVRIrtUJqELhi3rYyIyJH1OpBasWJFlxO5D23btm0rRlvZtGkTzc3NLFmypMfnbNmyhTfeeKPXwVdfrVy5kmg0Wth27drVL9cVkZ5yuz9ss+iFZhHpqV7/tbjxxhtZunRpt2WmTp3a1/Z0a82aNVx44YUdeomOdE5NTQ2zZs1qt3/ChAns2bOn3b49e/ZQXl5OOBzGdV1c1+20zIQJE7q8XjAYJBjsZDV6ERkcTBDwYW0SY0LtDuXf2LOaHyUiPdbrQKqqqoqqqqpitKVb9fX11NbWsnnz5h6fE4/H2bhxI6tXr+5wbM6cOTz22GPt9j355JPMmTMHgEAgwKxZs3jqqae4+OKLgfxk86eeeoqvf/3rfb8RERlQxgTAHYPNvZ9/O88EyQ/1pcGmwakEExngVorIUFHUOVINDQ3U1dXR0NBALpejrq6Ouro64vF4oczOnTupq6ujsbGRRCJRKJNOp9vVtW7dOqqrq1m4cGGH62zatInp06d32P/AAw+QzWa54oorOhy7+uqreeutt/iHf/gHtm3bxn/8x3+wceNG/v7v/75Q5oYbbuA///M/uf/++3njjTf42te+RktLC1/+8peP5sciIgPMOOUYdwKYUD54sknAxbjjMc7YtknnIiI9YItoyZIlFuiw1dbWFsrMnz+/0zL19fWFMrlczk6cONHefPPNnV7nvvvus53dypw5c+zll1/eZftqa2ttTU2NDQQCdurUqfa+++7rUObf/u3f7OTJk20gELBnnHGG/f3vf9/j+7fW2mg0agEbjUZ7dZ6IFJ/nedbzUm1bbqCbIyKDSE+/v/slj9RIpjxSIsNL/k9mEuslAC+/rIwJ54cMRWTY6On3t15NERHpIWs9rHcAvCiH0ihYPMAP7miMUzHALRSR/qZASkSkh6zXBN4BMCUY88GfT2tT2NxewNUbfyIjjGZUioj0gLUZ8GJgQu2CKKAtS7rJL4Ss2RIiI4oCKRGRnrBpIAN0MRfKBMGmgGw/NkpEBpoCKRGRHrMY09XyMqZQRkRGDgVSIiI9YfyAH2vTnR+3KTABwN+frRKRAaZASkSkB4wJgFMGNpHPiH4YazNALp/os8seKxEZjvTWnohIDxmnMr8en23GWkN+AeQs4IAzBoze2BMZaRRIiYj0kDE+cMeBLcPaFrBZMOUYJwKE1BslMgIpkBIR6QVjnHweKUr6dL61HpADHIxxj2nbRKT/KZASEekH1ubAxrFeM9gMGAdrSjFOmZaXERnCNNlcRKTIrM1hc+9jc3uATNsbgAa8/dhcI9amBrqJItJHCqRERIrMejGwzWDKMCaCMX6MCebX5rNpbO6AMqKLDFEKpEREishary2ICuTnV32YCYNNAOqVEhmKFEiJiBRVFmyOrhJ15tfty7WVEZGhRoGUiEhROeSXj+k8UMq/xWf4YIkZERlKFEiJiBSRMT5wStoWNO5MMr/gsQn1a7tE5NhQICUiUmTGKQf8WK+5sLyMtRZrW8HmME5l5/OnRGTQUx4pEZEiMyYIvvHY3AGwrVgsWMAEMe5YjFM20E0UkT5SICUi0g+MCYN7HJBsm1huwISU3VxkiFMgJSLST/Jr8YV7Pa88n2MqlV/bD9pSKSgbushgoEBKRGQQszaNze0H2wp4+SDM+rBOedvcKvVoiQwkBVIiIoOUtVlsbm8+iDKRtpxTYEmDdyA/18oZ09bTJSIDQa+JiIgMVjbRFkSVFYIoID+sZyLgxVBGdJGBpUBKRGSQsl4z4Hba45QPrLLd5KcSkf6gQEpEZNCy0G1+KQN4/dUYEemEAikRkcHKBMBmOj2Uf5MPNNVVZGApkBIRGaSMKQEcbGfBlE3kAy0T7vd2icgH9E8ZEZHByoTBGZV/Q8+m8oETFmwacDHOmHaT0EWk/+k3UERkkDLG5AMpE8B6sXwAZQw4lRinFKOFjkUGXFGH9m6//Xbmzp1LJBKhsrKy0zLXXnsts2bNIhgMUlNT0+H4qlWrMMZ02EpKSrq87vr16zs9xxjD+++/D8AvfvELzjvvPKqqqigvL2fOnDn813/91xGvPX369D7/PEREessYkw+a3GqMbxLGnYjjjlUQJTJIFDWQSqfTLFq0iK997Wvdllu2bBmLFy/u9NhNN93E7t27220zZsxg0aJFXda3ePHiDucsWLCA+fPnM27cOACeffZZzjvvPB577DFefPFFzj77bD73uc/x8ssvt6vr1FNPbVfPb3/7217+FEREjl7+H3NurzKZW5vBelG87Hv5Ldc2RCgix0xRh/Zuu+02IN9D1JV77rkHgL179/LKK690OF5aWkppaWnh89atW3n99de59957u6wzHA4TDn8wAXPv3r385je/Ye3atYV9d999d7tzvv3tb/PLX/6Shx9+mNNOO62w3+fzMWHChC6vJSIyGFmbbMuKngD8bZkSWrBeFNwqjFN6pCpEpAeG3Ft7a9asYdq0acybN6/H5/zwhz8kEonwxS9+scsynufR3NzM6NGj2+3fsWMHxx13HFOnTuVv/uZvaGho6PZaqVSKWCzWbhMR6U/W5trW50thnAqME8GYCMYpB2Owub3qmRI5RoZUIJVMJtmwYQPLly/v1Xlr167l8ssvb9dL9WH/8i//Qjwe59JLLy3smz17NuvXr+fxxx/ne9/7HvX19cybN4/m5uYu61m9ejUVFRWFbdKkSb1qq4jIUbMJsC1gOvY6GRMGslivpf/bJTIM9TqQWrFiRZcTuQ9t27ZtK0Zb2bRpE83NzSxZsqTH52zZsoU33nij2+Drxz/+MbfddhsbN24szKECWLhwIYsWLWLmzJksWLCAxx57jKamJjZu3NhlXStXriQajRa2Xbt29bitIiLHgrVpwHS9mLHxtQ35icjR6vUcqRtvvJGlS5d2W2bq1Kl9bU+31qxZw4UXXsj48eN7dU5NTQ2zZs3q9PhPf/pTrrrqKh588EHOPffcbuuqrKxk2rRp7Ny5s8sywWCQYDDY4/aJiBxrxjhYbNcFLPk0CiJy1HodSFVVVVFVVVWMtnSrvr6e2tpaNm/e3ONz4vE4GzduZPXq1Z0e/8lPfsKyZcv46U9/ymc/+9ke1ffmm2/ypS99qcdtEBHpfwHAYG2ui7f8MhhndCf7RaS3ijpHqqGhgbq6OhoaGsjlctTV1VFXV0c8Hi+U2blzJ3V1dTQ2NpJIJApl0ul0u7rWrVtHdXU1Cxcu7HCdTZs2dZrf6YEHHiCbzXLFFVd0OPbjH/+YK6+8kjvvvJPZs2fT2NhIY2Mj0Wi0UOamm27imWee4e233+a5557jkksuwXVdLrvssqP5sYiIFJcJgSkBG8faDxY1ttZivea241paRuRYKGr6g1tvvZX777+/8PlQWoHa2lrOOussAK666iqeeeaZDmXq6+s54YQTgPwbdevXr2fp0qW4bsd/XUWjUbZv395h/9q1a/n85z/faTLQH/zgB2SzWa655hquueaawv4lS5YU0jW88847XHbZZezfv5+qqio+9alP8fvf/35AeuRERHrKGAfcsdgcYFvaFjg2gAUTwrhjMSYwwK0UGR6M/WAJcSmCWCxGRUUF0WiU8vLygW6OiIwg1npgE4VUB6ZtkePeJPUUGal6+v2ttfZERIYpYxwwJRi6XlKrK/l/Y2fIz0x3MMZ/rJsnMiwokBIRkXasTWBz0bYUCR7gYJ0yjFOuIUGRD1EgJSIiBdZrxeb2ALm2CekOkAFvf36I0B2n3imRwwypzOYiIlI81npY7yDgYZwyjPFhjIMxQTAV+YnrXtcrO4iMRAqkRESkTSo/nNdJagRjDJgg2GaszQ1A20QGJwVSIiKSl8+X0M1bfT6wHvl5UyICCqREROQQ45LPiN5VoJQD46CvDpEP6LdBRETaBPPDep0saGytBZsEU6Y8VCKHUSAlIiJAPu+UcSoBg/XiWJvNLytjM2Bj+ZxUTulAN1NkUFH6AxERKTBOCTAO60XzPVDkAB84lRinUnmkRD5EgZSIiLRjnBIwESBNfmK5qwBKpAsKpEREpANjDBDs9Xn5YcBDPVmmbW0/BWEyfCmQEhGRY8J6zdjcfvJr9EF+nT4/1qnAOKPagjOR4UWBlIiIHDXrtWBze8E4GFP+wX6bBm8fFgfjVg5cA0WKRG/tiYjIUbHWYr0Y+WSe7bOiGxNoy4gexdrswDRQpIgUSImIyFFqmxdluppTFQSbAZvu11aJ9AcFUiIicox0PgcqPzfKtm0iw4sCKREROUo+MH7y6RI6sjZ9WBmR4UWBlIiIHJV8RvRysNkO86Cs9fJLzjhlSoMgw5Le2hMRkaNnSsFJg9eEtYDxgfXIL3Rc2rb0jMjwo0BKRESOmjEOOGPAhLFeHEiDCWCcMjARLXQsw5YCKREROSaMMW0LG5f0uQ5rvba6NPNEhgYFUiIiMqCstWBbsV4zkAIM1pRgnFJMlykVRAYHBVIiIjJg8sk8D4J3ELBgAvn/9fbnAyt3HMaJDHQzRbqkQEpERAaOTeSDKBNo/1afCeWXnfH2gwlqjpUMWhqEFhGRAWNtnPzSMp2kRjCRfMZ0m+j3don0lAIpEREZODbVZaLOfEZ0AK3RJ4OXAikRERlATlu+qa5Yulp6RmQwUCAlIiIDxjilQCb/5t6H5LOk+7pZDFlk4CmQEhGRgWMibXOh4libK+y2NgO2BZwyQIGUDF5FDaRuv/125s6dSyQSobKystMy1157LbNmzSIYDFJTU9Ph+KpVqzDGdNhKSrpO+LZ+/fpOzzHG8P777wPw9NNPd3q8sbGxXV3//u//zgknnEAoFGL27Nn84Q9/6PPPQ0RE2jPGj3Gr2oKpVqwXw3oxsBlwRmOc0YfNlRIZfIqa/iCdTrNo0SLmzJnD2rVruyy3bNkynn/+eV555ZUOx2666SauvvrqdvvOOeccTj/99C7rW7x4MRdccEG7fUuXLiWZTDJu3Lh2+7dv3055eXnh8+HHH3jgAW644QbuvfdeZs+ezd13382CBQvYvn17h3pERKRvjAmCW932dl4WMG0pD7TIsQx+RQ2kbrvtNiDfQ9SVe+65B4C9e/d2GkiVlpZSWlpa+Lx161Zef/117r333i7rDIfDhMPhwue9e/fym9/8ptNgbty4cV32lt1111185Stf4ctf/jIA9957L48++ijr1q1jxYoVXV5fRER6J7+8TN8Sb3qZNyD1DNgcBE7DBOaoF0v6zZCbI7VmzRqmTZvGvHnzenzOD3/4QyKRCF/84hc7HKupqaG6uprzzjuP3/3ud4X96XSaF198kXPPPbewz3Eczj33XLZs2dLltVKpFLFYrN0mIiLHnpfbj7f/b2D/Rdj4v2Jb/g0OLsXbdz5e+o2Bbp6MEEMqkEomk2zYsIHly5f36ry1a9dy+eWXt+ulqq6u5t577+XnP/85P//5z5k0aRJnnXUWL730EgD79u0jl8sxfvz4dnWNHz++wzyqw61evZqKiorCNmnSpF61VUREjszzUnDgSmzmRQAMFkNbGoVcA/bA35BNbx/AFspI0etAasWKFV1O5D60bdu2rRhtZdOmTTQ3N7NkyZIen7NlyxbeeOONDsHXySefzP/8n/+TWbNmMXfuXNatW8fcuXP513/916Nq48qVK4lGo4Vt165dR1WfiIh0IvUryO34IHg6jMECLdjm/002/VanqRVEjpVez5G68cYbWbp0abdlpk6d2tf2dGvNmjVceOGFHXqJjnROTU0Ns2bNOmLZM844g9/+9rcAjB07Ftd12bNnT7sye/bsYcKECV3WEQwGCQb1qq6ISFElHsbidBpIQVsPVeZF0olHcLwz8ftn4rqhfm6kjAS9DqSqqqqoqqoqRlu6VV9fT21tLZs3b+7xOfF4nI0bN7J69eoela+rq6O6uhqAQCDArFmzeOqpp7j44osB8DyPp556iq9//eu9br+IiBxDXlOXQdQhhgypTCPknsIL7icYPAPXN6afGigjRVHf2mtoaODAgQM0NDSQy+Woq6sD4KSTTiq8ibdz507i8TiNjY0kEolCmRkzZhAIfPDq67p166iurmbhwoUdrrNp0yZWrlzZYUjxgQceIJvNcsUVV3Q45+677+bEE0/k1FNPJZlMsmbNGn7zm9/wxBNPFMrccMMNLFmyhL/8y7/kjDPO4O6776alpaXwFp+IiAwQdzI2+1qXwZQFPCLgQNaLkm39Lens+4TDcwn4P4IxQ2qKsAxiRQ2kbr31Vu6///7C59NOOw2A2tpazjrrLACuuuoqnnnmmQ5l6uvrOeGEE4B8T9D69etZunQprut2uE40GmX79o6TCteuXcvnP//5TtMbpNNpbrzxRt59910ikQgzZ87k17/+NWeffXahzOLFi9m7dy+33norjY2N1NTU8Pjjj/dqaFFERIogcikm9Wi3RVLOFHJeFmscMJDMbCftNREOnkkk+AkN9ckxYaxm4RVVLBajoqKCaDTaLvGniIj0nbUW23QDNvVohyWNLYYcFTS7c/Hw4TkO1jp41pefeO6WEAl8gpLwbAK+sQPSfhn8evr9XdQeKRERkWIwxkDlv2CbJ2Jbf4ShBQCLS8ZMocX5GJ4xeNZibY4chqyXoiW3i1jyTXLNG3CdMsaVXMTEiqsJ+EYN8B3JUKUeqSJTj5SISHHlsgfJtj5MLvNHMp7BMwE8cuTw8GyOnLFkvAx7kltIewc/dLYh4FbxiQkbCfknDkj7ZXDq6fe3ZtuJiMiQ5vpG4S+9HF/JMlz/NHDBMwZrHazxYa3DgdRrpL2mTs62pHP7eGPvtf3dbBkmFEiJiMiQ5zg+AqFTCJd+Dr97Gg75t76t9ZHxcrTkdpF/l68zHvH0K+xv3ULWSyiBp/SKAikRERk2XN94wiUXEAyejXErsFjSthmOkHMKoCnxO1ozu0lm9+LZbPEbK8OCAikRERlWXLeESORTlEX+Cr97AnR4r6+L85wIPidM2ouRzn14LpVI5/TWnoiIDDuO4xIOzcDxjYaWcvYmn8XSfS9TeegvyS8u4xDPvI9nDX63FJ8J5t8SFOmEeqRERGTYCvomMLr0QsaEz6XrnimHsuAZ+N3jiGf3k8g20ZLZT3OmkebMHlqy+8lpqE+6oEBKRESGNZ9bwkfH3kFF8Iy2PYe++vKBVch3AieMupXWbBNZL4XfCRFwIwTdUvxOiLTXTCLbpEno0ikN7YmIyLDnc8N8fML/ZX/rr9nd/ADJbAOuKWNsyYWMjiwga9PkbAsBJ4LF4uDgGD+OcTH4iWf2AoagW4rPBDTUJwUKpEREZEQwxmFsyfmMLTmfrNdKa2YPjuPHNX6SmSiOcQBL1mvF75QAPloyUZJeK8lcnLTnEfaVE3QjlPgqcI2+QkVDeyIiMgL5nAgh3xiszZLOxch4CbJekoyXwO9ECLiVtOZiJHLN+IyPkBsh7EbwOwGS2TjxzEE8mxvo25BBQOG0iIiMSAG3HNcE2oKoHCkvTtg/Fp8JkbVZ0l6CgBPCGAc8i2N8uMZHwAkRz0YxuIR9Zfgd/0DfigwgBVIiIjJiuU4I1wnhcyI0Z/ZgcDHGJZNrzc+VMi5pm8B1ArgmSCLXSmu2hdZcnNZsgrLAGEJOmFJfGT5HX6kjkYb2RERkxPM5QSK+0Xg2RzIXJ+slyXppUl4LBoewW0HKSxJLR7FAyAkTckP48dOaixPNHFSKhBFK4bOIiAgQdEtxjI9MrpWclwNrCDsV+J0wGIfWXAyf48vPk8q14jN+fI4Px4vQnG3GNT71TI1AetoiIiJt/E4IvxMi6JbhOmEM4Dp+krkEWZsl4paQ9TIYDH43RNpL05JtJZ6JE8vEGR0YS9gXotRXorlTI4SG9kRERD7EdfyU+irxrEcyFyfjZch5OVK5BDmbJeKW4XmGg+koSS9JwA0QdP04xiGebeFgOkrW01DfSKBASkREpBNBN0JFoIqQW4oBLB5+J0SZfzQht5SWbAseHmE3DFhc4yfg+ClxIyRyCaLpGDmlSBj2NLQnIiLSBb8TxO8ECbvluE4ILAScEGkvQ8pLE3QDeNaSsx5lbpic9WjNJollWtlvm2n10pS6EUr8EQKaOzUsqUdKRETkCHyOn3J/JdZAItdKJpciZ7PkbJZkLkHYF8HBR1M6RjQTx3FcfMYFC7FMnP3Jg6S9zEDfhhSBAikREZEeCLlhRgVGE3IjeMaSJYvFUuGvpMxXTjKXIpFLU+IL4TMOPscl6AYo9ZeQ9jIcTDfjWW+gb0OOMfUzioiI9FDACRIIBCn1leI3+SG+sC9CzuZoyaUIuPmv1bSXptRXisGhNZuiOZNmT6qZRDZDhb+EEn9IQ33DhHqkREREesnn+KkIVOBzfLRmW8l4WTwvh7XQmksQcIKEnBDRdCv7UjFy1gMsOZvjYCbO+8kmUjkN9Q0HCqRERET6IOQGGR2oJOwLk8llSdkUGS9LiS9Chb+MrPWIZVsJuQFCro+A4yPkBijzRch4nob6hgn1K4qIiPRR0A0ScAKU+Urxu0Fas0kq/GVYa2nKxnBxcI1DIpci6OTTIyRzGZLZLI2tTbRkMowOllLiCxaGBWVo0VMTERE5CsYY/MbP6EA51nq0ZBP4HR8ZL4drIJFLAYZSf4R4JsWBdAuetXjWI+1l2Z+KE8skqQqVEfEFBvp2pJc0tCciInIMBN0Ao4OVhN0gKS9DIpekNZfG7/gYFSjFWIcD6RZcHEp9IYI+P2FfgPJAPv/U/lScrKcEnkONeqRERESOkZAbIOj4KfcyhJwgTekWRgfLMDg0pVrJWY+IL0jGZnGNQ9Dxk/VyeNbyTvwgqVyWqlAZYV+AgOMO9O1IDyiQEhEROYaMMW29U+XkrKUlkyLsC5LysviNj7SXIWNzVPrCZK3HvmQLqVyGlJclnknhWQg4LlXhMko01DfoaWhPRESkCAKOj7HBcsI+P4lcipZsgni2FQ+PUf4IEX+IfckWMl6W8kCIsBsg4gtQEQhjgb2JZtIa6hv0ihpI3X777cydO5dIJEJlZWWnZa699lpmzZpFMBikpqamw/FVq1ZhjOmwlZSUdHnd9evXd3qOMYb3338fgKVLl3Z6/NRTT+322tOnTz+qn4mIiIwcQdfP+NAoJoRHMblkLBWBEsYHKykLREjlsqRyGUp8AXLWwyEffHnWYjDsTcRpaD5ALJ0knVNANVgVdWgvnU6zaNEi5syZw9q1a7sst2zZMp5//nleeeWVDsduuukmrr766nb7zjnnHE4//fQu61u8eDEXXHBBu31Lly4lmUwybtw4AL773e/yne98p3A8m83yiU98gkWLFrU779RTT+XXv/514bPPp9FQERHpOWMMYTeAL+TiWZtfyNgJkfJyOMbk92XTlPqD+IzLvkQL8WyKZDZDxrPkLARdlzHBEsoCwYG+HfmQokYFt912G5DvIerKPffcA8DevXs7DaRKS0spLS0tfN66dSuvv/469957b5d1hsNhwuFw4fPevXv5zW9+0y6Yq6iooKKiovD5oYce4uDBg3z5y19uV5fP52PChAldXktERKQn/I7L2FAZ+1NxWrIp4ukU8XQSE4BSf5AKf4SmdIJ4JkXE78c1hpDrpzIQojWbZm8yjt9xCPn8A30rcpgh172yZs0apk2bxrx583p8zg9/+EMikQhf/OIXuyyzdu1azj33XKZMmdJu/44dOzjuuOMIhULMmTOH1atXM3ny5C7rSaVSpFKpwudYLNbjdoqIyPAWdP1MCFeQzGUIuwFc41AZCBP2BUh5OVqyacI+P65x2t7wC2Ct5ZX397D5zTdozWY5sWIUfzP9E5w6dvxA344wxAKpZDLJhg0bWLFiRa/OW7t2LZdffnm7XqrDvffee/zqV7/ixz/+cbv9s2fPZv369Zx88sns3r2b2267jXnz5vHqq69SVlbWaV2rV68u9MSJiIh8mGMcIr4gQdePtYbWbAoLZL0cOc/iug7xbIqg4yOX87j66c28vHc3DgYPy+9372LDtq1cPPUU7pq/ENdVmoSB1OvJ5itWrOhyIvehbdu2bcVoK5s2baK5uZklS5b0+JwtW7bwxhtvsHz58i7L3H///VRWVnLxxRe3279w4UIWLVrEzJkzWbBgAY899hhNTU1s3Lixy7pWrlxJNBotbLt27epxW0VEZORwjUNVqISIL0g8k6Q5kySRTdGSTRI0PsaESvmn55+mbu9uADxsu/996K03uLb2UVrS6QG7B+lDj9SNN97I0qVLuy0zderUvranW2vWrOHCCy9k/Pied2euWbOGmpoaZs2a1elxay3r1q3jS1/6EoFA9/k6KisrmTZtGjt37uyyTDAYJBjUZEARETmygOtjQqSMRDZENJUgm7NUBEJEfAF2x2M8++6fuz3/8T/vYNJ/l3H5jE8wedTofmq1HK7XgVRVVRVVVVXFaEu36uvrqa2tZfPmzT0+Jx6Ps3HjRlavXt1lmWeeeYadO3d222N1eH1vvvkmX/rSl3rcBhERke64xqHUH6TEF8AxDs3pFK4x/L/3ug+iALKex8/feJ0X3nmPvz51Jp+fcSqOoxSR/amoP+2Ghgbq6upoaGggl8tRV1dHXV0d8Xi8UGbnzp3U1dXR2NhIIpEolEl/qKty3bp1VFdXs3Dhwg7X2bRpU6f5nR544AGy2SxXXHFFl21cu3Yts2fP5mMf+1iHYzfddBPPPPMMb7/9Ns899xyXXHIJruty2WWX9ebHICIickTGGMaESoj4A0QzKeKZNKarwhZMyuC0OuxvSfFS4x7+4aknOf//3s+f9u3rz2aPeEWdbH7rrbdy//33Fz6fdtppANTW1nLWWWcBcNVVV/HMM890KFNfX88JJ5wAgOd5rF+/nqVLl3Y6qS4ajbJ9+/YO+9euXcvnP//5LpOBRqNRfv7zn/Pd73630+PvvPMOl112Gfv376eqqopPfepT/P73vx+QHjkRERn+Aq5LdaSM1myGmWMntM2G+pC2IMrkDOZDoVZ900EuffABHrn8CiYeluJHisdYazt9TnJsxGIxKioqiEajlJeXD3RzRERkiLDW8qkHfsC78Vj7gCoHbrLrN/UMcNHJ07nt7HMoDQQwpst+LelGT7+/NZAqIiIyCBlj+D//43OEXF+7fieTNdjO+6oAsMB/vbmT92Ix9re2ov6S4lIgJSIiMkidNu44Hr7oS8w7bgpuW8+SYzsO6X1YIptlX7yVbXv28m40RjKT7Y/mjkgKpERERAaxj44ey/0XfJEHLriUz086mcpA6IjnRHx+In4/nrXsjjWzu7mZeEr5pophSGU2FxERGYkcx+H04ydTXVJGyDzPA2+83mVZA5xz4lQCPhcnY0hmMjRGY+xrbuGkqjGUhYL4lCLhmNFPUkREZIiYWDmKb559Dmccf3ynxw1QEQzxxVNmEEskeb+5hZZ0Fp/j0JxM8ef9B9kTbSad1VDfsaJASkREZAgJ+f3830u+yN98/BMEPpQS6JQxVdxx7vmEfX4OtCbwOYaxJREigQAB1yWdzfJOU5Q39+6nNZXWRPRjQOkPikzpD0REpFiak0n+682dHEwkGB8ppbq0jEjAT2OsmYOtCcaXllARDtOaSrM7FqcsEKIk6COZyTCurJRxZWWMLg3jaqivg55+f2uOlIiIyBBVFgpxySkziCaT7I42s7s5RjqXJZHJMLakhMpwmFQ2x/6WBH7XYXRpiKDPR86zZHIeuw40kcykmVBZjr+ThNdyZAqkREREhjDXcRgdiRD2+wn4XFrSaRwMQZ8PYwxNrUlS2SzjSksIOA7NiRT7m1vJZHL4HId4MkU661FVXkJ5+MhvBEp76ssTEREZBsJ+P1NGVTKutBS/63Iw3srB1iSJdJoxJREqwiESmSwH4q34XIdRJWHGlEXwuw6x1hRvv3+QvbG45k31knqkREREhomAz0d1eRlhv5/3fDEy2RwuUBIMQlvvVCaXY2xZCX7XoSWZZl+shYqQh8XSkkyTyeQYVRYhHPAP9O0MCQqkREREhhFjDKMiYfyuy754nHg6zcHWBI4xtCTTjC4JUx4K0prK8H40juu4VJSGcI0hnsiwLxanJZmmenQ5peHgQN/OoKdASkREZBgqDQYI+SsJ+vy8dzCK6zgYaxkVCQPQ1JIg5+WoKivDZxxaU2kOxlvxwkH2NSdoSWaYNLaC8tKQJqJ3Q4GUiIjIMOVzHCaUlxLyuextbiXWkiSWSJP1POLJNGPLw5SFA7Qk07wfbcF1DWWRICUeJNMZGptitKTTVI8qx+9TMNUZBVIiIiLDmDGGykiYcCCAawx7Y3FKgn4oKWF0JEzOs8RaE1jrMaa0DNdxaE2mibUmsdayr6mVZCpL9egySsNBjOl+weSRRoGUiIjIMGeMIeT3MWXsKEqDAfY2t9Bi0iQyWVqTGZoTGcZVRCgJ+oknUuyNtuB3XSKBAK6TJdaSAGsZVRZhbEWJgqnDKJASEREZIXyuw9jyEiJBP57nEU+kCfodRpeFqSyJkPM8oi1JMDCmLILPdUikLYlkBpuz7G9qIZnKUFVZSiiot/pAeaRERERGFNdxKAuHOPm4cUwaU0nY78c1DtlcPohqTqQZXRoiHPQRb02x90AL6UyWYMAPBvY1tdB4oJl4IjXQtzIoqEdKRERkBAr6fYwfVUrI7yOR2k8inQFgbGmEikiYTMajqSWB4xrGVpYS8LskkoZEMk0u63GgKc6Jx42hrCSEbwRPRFePlIiIyAgV8Pmoqixl+qTxjC0voTwUxO/zYYFYa4pEIk1lSZCgz6W5Jcneg3ESqQx+n0trIsOuxibePxAnlc4O9K0MGPVIiYiIjHAVJSH8rsP7vjjNjU20JDJkczlGV5RSURomk8kRbU7gug5jKkrw+xxe376b51+qZ+/+ZkpLQlwwfwYXL6ihvGxkrddnrBbVKapYLEZFRQXRaJTy8vKBbo6IiEiXPM9jz4E4TS0JWhNpwFISDrJ3fzNN8QRjRpVQ6g/w7/c/w2vbd2MMHIoiDDC6soR7vnUpUyaOGcjbOCZ6+v2toT0REREBwHEcxo8uo3pMOaXhAM2taQ7GE6TSWUaVlVAZCbP5yT/y2vbdwAdBFIAFDkRb+YdvbyLWnBiYGxgACqRERESkwHEMlaVhTjhuDCdMGE15KEhlaZiySJBszuPpLX/q8lxrLe82NrHpsZd4r7EJz/P6seUDQ3OkREREpIOg38fx4yo4GGulMRfjYHOC/fviJJOZbs8zBra+8S5jKsv46InjOPHEKgL+4ftWnwIpERER6ZTf51I1qpRQwEdgX4x4c7JH5xmg6WCcVxNp4vEkH/3oeMrLwsVt7ABRICUiIiJdMsZQXhrG7/MRdF3CIT+JbnqlrIUJY8sx1pJMZtj+p93Eoq2cfPIEqqtHDbvlZTRHSkRERI4oHPIz+fjRfO7cj9NVKGQMjKksobI0hOM62GwOrMfuPU289PKf+dO23aSHWc4pBVIiIiLSI67j8LUvfZozak4A8oHT4UrCQc4546P4HUMykcFa8HLgeBA70Mqrf2zgla0NxJqGz1t9yiNVZMojJSIiw43nWZ74f2/ws0de5L09UYIBH9NOqOKkSWMJuQYwZHIWP4ZMNkckEsDL5XBsPvI67rhKpp0ykXETKnCcwTnUN+B5pG6//Xbmzp1LJBKhsrKy0zLXXnsts2bNIhgMUlNT0+H4qlWrMMZ02EpKSrq99n//939zzjnnUFlZyahRo1iwYAFbt25tV+aVV15h3rx5hEIhJk2axD//8z93qOfBBx9k+vTphEIhPv7xj/PYY4/1+P5FRESGK8cxXDB/Bv/+T3/N3au+yJc/P5tPTDuOkrAfx+cjk7EEfC5ZL4fP55BszeDl8rmmjDG8s+sALz//Jm9ubxzyQ31FC6TS6TSLFi3ia1/7Wrflli1bxuLFizs9dtNNN7F79+5224wZM1i0aFGX9cXjcS644AImT57M888/z29/+1vKyspYsGABmUx+clwsFuP8889nypQpvPjii9xxxx2sWrWKH/zgB4V6nnvuOS677DKWL1/Oyy+/zMUXX8zFF1/Mq6++2oefhoiIyPATDPo56YTxzP7LqUyorsTzDMZAKOgnl83hug5gsXgYLMlEGmstjmOIxhK8uOVPPPeb19j3fnSgb6XPij60t379eq6//nqampq6LLNq1Soeeugh6urquq1r69at1NTU8OyzzzJv3rxOy7zwwgucfvrpNDQ0MGnSJAD++Mc/MnPmTHbs2MFJJ53E9773PW655RYaGxsJBAIArFixgoceeoht27YBsHjxYlpaWnjkkUcKdZ955pnU1NRw77339vj+NbQnIiIjQaw5wc439/DWm++TTmZwMFg8kon8IsfZdBbXdbA5S9O+GFt//xbv1u8DwO93mb9wJsuuP5/RVYPju3LAh/aKYc2aNUybNq3LIArg5JNPZsyYMaxdu5Z0Ok0ikWDt2rWccsopnHDCCQBs2bKFT3/604UgCmDBggVs376dgwcPFsqce+657epesGABW7Zs6baNqVSKWCzWbhMRERnuysvCnHrKRE47bTLlFRFy1mJwCAX9eDmLz/WBB+/9eT+/euC/ee/tfYVzM5kcTz1cxzWX/juN7x4YwLvovSETSCWTSTZs2MDy5cu7LVdWVsbTTz/Nj370I8LhMKWlpTz++OP86le/wufLp81qbGxk/Pjx7c479LmxsbHbMoeOd2X16tVUVFQUtkO9YiIiIsNdMOjjxBPGc/rpJzLx+FEYLNbme5z8AYd0OsOWJ1/FepYPj4dZa2na38Ld33yI2MGWgbmBPuhVILVixYpOJ38fvh0aGjvWNm3aRHNzM0uWLOm2XCKRYPny5Xzyk5/k97//Pb/73e/42Mc+xmc/+1kSieK/brly5Uqi0Whh27VrV9GvKSIiMlg4jmH8+EpOm3UC06ZXE/Q7GJMf0tv3bhOpRHfJPC2v/Pdb/O7Xr9K4a/+QWKuvV5nNb7zxRpYuXdptmalTpx5Ne7q0Zs0aLrzwwg69RB/24x//mLfffpstW7bgOE5h36hRo/jlL3/JX//1XzNhwgT27NnT7rxDnydMmFD4387KHDrelWAwSDAY7NW9iYiIDDfl5RE+/okplJWF2fHGe0QPttC0vwXjGKzX9fRsz7O8+cZ72EyWj35sMpM/Op5gONBl+YHWq0CqqqqKqqqqYrWlS/X19dTW1rJ58+Yjlm1tbcVxnHYp6A99PhTZzpkzh1tuuYVMJoPf7wfgySef5OSTT2bUqFGFMk899RTXX399oZ4nn3ySOXPmHMM7ExERGb58PpePfHQCJaVBdrz+Hq8F3qbDmF4nAj6XeCzBq394k9jBOB+dOYnyUaXFb3AfFG2OVENDA3V1dTQ0NJDL5airq6Ouro54PF4os3PnTurq6mhsbCSRSBTKpNPpdnWtW7eO6upqFi5c2OE6mzZtYvr06YXP5513HgcPHuSaa67hjTfe4LXXXuPLX/4yPp+Ps88+G4DLL7+cQCDA8uXLee2113jggQf47ne/yw033FCo57rrruPxxx/nzjvvZNu2baxatYoXXniBr3/968f6RyUiIjJsGWOoPm40NadPZf6Cjx8xjiqvDBOOBLCeJZvJ8Nbr7/LSs9t55633B+VQX9EWLb711lu5//77C59PO+00AGpraznrrLMAuOqqq3jmmWc6lKmvry+8Yed5HuvXr2fp0qW4rtvhOtFolO3btxc+T58+nYcffpjbbruNOXPm4DgOp512Go8//jjV1dUAVFRU8MQTT3DNNdcwa9Ysxo4dy6233spXv/rVQj1z587lxz/+Md/4xje4+eab+ehHP8pDDz3Exz72sWPzAxIRERlByisizD//4zz96FZe/N2OLgOqmTWTcZz8KFIuZ3Fdw55d+2iNttLa1MKUGRMJhvz92/huaImYIlMeKRERkQ8kE2n+6e9/zAu/25GfhmPyk8yNMZx+5kmcNH08rnHIZTOEwn7SySz+gAsWAgEfE08az0drplA5trjfqT39/lYgVWQKpERERDp69cV6Hvnp8+xtjBKOBJg6bQLBgIvf55JKJDEAOTCug+OAweIYg8Uy7vhRnFRzAsedOK7T0apjoaff30Ub2hMRERHpysdmncjJH5/In3fs4c3X36VpfzNYyOWyuI6LsR4Zm8PxLOlUjlBJkGwmg+M4NP55Py3NCVoOtnDixycTDA3cW30KpERERGRA+AN+PjLjeMorS9jxxwbefXtvvtfJtWSTHoGQj0wig+tzSLemcF2DtTkc47Dnrfd59enXGFM9inlfmM300z86IPegQEpEREQGjDGGccePIlIWorQiQv0b75BuzeAPueTSOVyfA9Yjay3Ws7TEErz4+Mu8VVdfmLC+8Z9/ySfOOpWVG65lTPXofm3/kFkiRkRERIav0vIwM2adwMzZH6ViTAnGGly/H8fnks16BAI+MokUtT96lrfq3u7w1t8fn32dv5/3/9ESa+3XdiuQEhERkUHBH/BzwinH8RfzZ3DcR8ZjjIdjIBDwk81keGdHI3t37aOz9+Q8z9JYv5dHvv9kv7ZZgZSIiIgMGo7jUHXcKGo+OY1T/vIj+P0u1svhD/p586W3OGzhkg4slv+6r7b/GosCKRERERmESitLmD7rRP7i7BmMGl+Bl/VojbV2nxndQtP70X5rI2iyuYiIiAxS/oCfyScfT6Qswp9efJOSyhIONkY7HdoDwMDo6lH92kb1SImIiMigZYyh6vjRzPz0KfyPy+d1HUS1uWDZ2f3UsjwFUiIiIjLolVWWsujGz3HyGSfll5b5EMd1mDz9eD7zlXP7tV0KpERERGRICIYC3PHUNzn3S5/G9X2wNIzjGOZ87i+585lvESkN92ubtNZekWmtPRERkWOvaW+UPz77Bp7nccqZH2XcpKpjWr/W2hMREZFhq7KqgnlfOHOgm6GhPREREZG+UiAlIiIi0kcKpERERET6SIGUiIiISB8pkBIRERHpIwVSIiIiIn2kQEpERESkjxRIiYiIiPSRAikRERGRPlJm8yI7tAJPLBYb4JaIiIhITx363j7SSnoKpIqsubkZgEmTJg1wS0RERKS3mpubqaio6PK4Fi0uMs/zeO+99ygrK8MYM9DNGRFisRiTJk1i165dWih6ENLzGdz0fAY3PZ/+Y62lubmZ4447DsfpeiaUeqSKzHEcJk6cONDNGJHKy8v1h2YQ0/MZ3PR8Bjc9n/7RXU/UIZpsLiIiItJHCqRERERE+kiBlAw7wWCQb37zmwSDwYFuinRCz2dw0/MZ3PR8Bh9NNhcRERHpI/VIiYiIiPSRAikRERGRPlIgJSIiItJHCqRERERE+kiBlAwa3/ve95g5c2Yh0dycOXP41a9+VTh+1llnYYxpt1199dXd1hmPx/n617/OxIkTCYfDzJgxg3vvvbddmWQyyTXXXMOYMWMoLS3lC1/4Anv27CnKPQ5lA/V8+lLvSFWMZ7Rnzx6WLl3KcccdRyQS4YILLmDHjh3tyuh3qGcG6vnod6jIrMggsXnzZvvoo4/aP/3pT3b79u325ptvtn6/37766qvWWmvnz59vv/KVr9jdu3cXtmg02m2dX/nKV+xHPvIRW1tba+vr6+33v/9967qu/eUvf1koc/XVV9tJkybZp556yr7wwgv2zDPPtHPnzi3qvQ5FA/V8+lLvSHWsn5HnefbMM8+08+bNs3/4wx/stm3b7Fe/+lU7efJkG4/HC+X0O9QzA/V89DtUXAqkZFAbNWqUXbNmjbU2/8fguuuu69X5p556qv3Wt77Vbt9f/MVf2FtuucVaa21TU5P1+/32wQcfLBx/4403LGC3bNlydI0fAYr9fPpar3zgaJ7R9u3bLVD4orfW2lwuZ6uqqux//ud/Wmv1O3S0iv18+lKv9I6G9mRQyuVy/PSnP6WlpYU5c+YU9m/YsIGxY8fysY99jJUrV9La2tptPXPnzmXz5s28++67WGupra3lT3/6E+effz4AL774IplMhnPPPbdwzvTp05k8eTJbtmwpzs0NA/31fPparxybZ5RKpQAIhUKFfY7jEAwG+e1vfwvod6iv+uv59KVe6aWBjuREDvfKK6/YkpIS67quraiosI8++mjh2Pe//337+OOP21deecX+6Ec/sscff7y95JJLuq0vmUzaK6+80gLW5/PZQCBg77///sLxDRs22EAg0OG8008/3f7DP/zDsbuxYaK/n09f6x3JjuUzSqfTdvLkyXbRokX2wIEDNpVK2e985zsWsOeff761Vr9DvdXfz6cv9UrvKJCSQSWVStkdO3bYF154wa5YscKOHTvWvvbaa52Wfeqppyxgd+7c2WV9d9xxh502bZrdvHmz3bp1q/23f/s3W1paap988klrrb4Eequ/n09f6x3JjvUzeuGFF+wnPvEJC1jXde2CBQvswoUL7QUXXGCt1e9Qb/X38+lrvdJzCqRkUDvnnHPsV7/61U6PxeNxC9jHH3+80+Otra3W7/fbRx55pN3+5cuX2wULFlhrP/iDcvDgwXZlJk+ebO+6666jv4FhrtjPpy/1SntH84wO19TUZN9//31rrbVnnHGG/du//VtrrX6Hjlaxn8/R1itHpjlSMqh5nleYB/BhdXV1AFRXV3d6PJPJkMlkcJz2/5m7rovneQDMmjULv9/PU089VTi+fft2Ghoa2s1bkM4V+/n0pV5p72ie0eEqKiqoqqpix44dvPDCC1x00UWAfoeOVrGfz9HWKz0w0JGcyCErVqywzzzzjK2vr7evvPKKXbFihTXG2CeeeMLu3LnTfutb37IvvPCCra+vt7/85S/t1KlT7ac//el2dZx88sn2F7/4ReHz/Pnz7amnnmpra2vtW2+9Ze+77z4bCoXsf/zHfxTKXH311Xby5Mn2N7/5jX3hhRfsnDlz7Jw5c/rtvoeKgXg+Pa1X8orxjDZu3Ghra2vtm2++aR966CE7ZcoU+/nPf77dOfod6pmBeD76HSo+BVIyaCxbtsxOmTLFBgIBW1VVZc855xz7xBNPWGutbWhosJ/+9Kft6NGjbTAYtCeddJL9X//rf3XIhQLY++67r/B59+7ddunSpfa4446zoVDInnzyyfbOO++0nucVyiQSCfu3f/u3dtSoUTYSidhLLrnE7t69u1/ueSgZiOfT03olrxjP6Lvf/a6dOHGi9fv9dvLkyfYb3/iGTaVS7c7R71DPDMTz0e9Q8RlrrR3YPjERERGRoUlzpERERET6SIGUiIiISB8pkBIRERHpIwVSIiIiIn2kQEpERESkjxRIiYiIiPSRAikRERGRPlIgJSIiItJHCqRERERE+kiBlIiIiEgfKZASERER6SMFUiIiIiJ99P8DqN96ZMq/od8AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from scipy.interpolate import interp1d\n", - "\n", - "taup_model = TauPyModel(model='1066a')\n", - "\n", - "ray_path = taup_model.get_ray_paths_geo(source_depth_in_km=10,\n", - " source_latitude_in_deg=35.766,\n", - " source_longitude_in_deg=-117.605,\n", - " receiver_latitude_in_deg=35.98249,\n", - " receiver_longitude_in_deg=-117.80885,\n", - " phase_list=['P', 'S'])\n", - "\n", - "ray_path[0].path\n", - "\n", - "# Define the number of points N\n", - "N = 100\n", - "\n", - "# Create the interpolator objects for latitude, longitude, and depth\n", - "interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])\n", - "interp_longitude = interp1d(np.linspace(0, ray_path[0].path['lon'].max(), len(ray_path[0].path['lon'])), ray_path[0].path['lon'])\n", - "interp_depth = interp1d(np.linspace(0, ray_path[0].path['depth'].max(), len(ray_path[0].path['depth'])), ray_path[0].path['depth'])\n", - "\n", - "# Resample the ray path to N points\n", - "resampled_latitude = interp_latitude(np.linspace(0, ray_path[0].path['lat'].max(), N))\n", - "resampled_longitude = interp_longitude(np.linspace(0, ray_path[0].path['lon'].max(), N))\n", - "resampled_depth = interp_depth(np.linspace(0, ray_path[0].path['depth'].max(), N))\n", - "\n", - "plt.scatter(resampled_latitude, resampled_longitude, c=resampled_depth, cmap='viridis', alpha=0.1)\n", - "plt.scatter(ray_path[0].path['lat'], ray_path[0].path['lon'], c=ray_path[0].path['depth'], cmap='viridis')\n" - ] - }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([(825.43624587, 0. , 0. , 10. , 35.766 , -117.605 ),\n", - " (825.43624587, 0.26845098, 0.00012109, 11. , 35.7715199 , -117.61017979),\n", - " (825.43624587, 1.63173458, 0.00177268, 11.01091139, 35.84678737, -117.68090241),\n", - " (825.43624587, 2.99501819, 0.00342427, 11. , 35.92201332, -117.75175935),\n", - " (825.43624587, 3.26346917, 0.00354535, 10. , 35.92752691, -117.75695956),\n", - " (825.43624587, 4.33607208, 0.00402859, 6.00385879, 35.94952856, -117.77772004),\n", - " (825.43624587, 4.47129397, 0.00408945, 5.5 , 35.9522991 , -117.78033535),\n", - " (825.43624587, 5.20940225, 0.00442139, 2.74941477, 35.96740958, -117.79460335),\n", - " (825.43624587, 5.57829224, 0.00458712, 1.37456112, 35.97495353, -117.80172933),\n", - " (825.43624587, 5.94707298, 0.0047527 , 0. , 35.98248996, -117.80884997)],\n", - " dtype=[('p', '" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def compute_velocity_model(azimuth, elevation, interpolate):\n", + "def compute_velocity_model(azimuth, elevation, interpolate, n_lat, n_lon, n_depth):\n", " filename = list(output_csv.temp_files)[0]\n", " \n", " df = pd.read_csv(filename)\n", @@ -1315,9 +912,6 @@ " depth_range = (0, 50)\n", "\n", " # Define the number of nodes in each dimension\n", - " n_lat = 10\n", - " n_lon = 10\n", - " n_depth = 10\n", " num_points = 100\n", "\n", " taup_model = TauPyModel(model='1066a')\n", @@ -1341,6 +935,9 @@ " receiver_latitude_in_deg=df.st_lat.iloc[i],\n", " receiver_longitude_in_deg=df.st_lon.iloc[i],\n", " phase_list=['P', 'S'])\n", + " \n", + " # HERE IS THE PROBLEM\n", + " print(ray_path[0].path)\n", "\n", " # Create the interpolator objects for latitude, longitude, and depth\n", " interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])\n", @@ -1401,52 +998,16 @@ " # Set the view angle\n", " ax.view_init(elev=elevation, azim=azimuth)\n", "\n", + " m = cm.ScalarMappable(cmap=plt.cm.plasma, norm=norm)\n", + " m.set_array([])\n", + " plt.colorbar(m)\n", "\n", - "compute_velocity_model(0, 40, False)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "35.766_-117.605_10.0_2019-07-04 17:33:49_3.csv\n", - "35.766_-117.605_10.0_2019-07-04T17:33:49-00_3.csv\n", - "35.766_-117.605_2019-07-04 17:33:49_3.csv\n", - "35.766_-117.605_2019-07-04 17:33:49_9.csv\n", - "current_vel_model.csv\n", - "testt\n" - ] - } - ], - "source": [ - "!ls data/velocity" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "35.766_-117.605_10.0_2019-07-04 17:33:49_3.csv\n", - "35.766_-117.605_10.0_2019-07-04T17:33:49-00_3.csv\n", - "35.766_-117.605_2019-07-04 17:33:49_3.csv\n", - "35.766_-117.605_2019-07-04 17:33:49_9.csv\n", - "current_vel_model.csv\n", - "testt\n" - ] - } - ], - "source": [ - "!ls '/Users/anovosel/Documents/phase-hunter/data/velocity'" + " # Show the plot\n", + " fig.canvas.draw();\n", + " image = np.array(fig.canvas.renderer.buffer_rgba())\n", + " plt.close(fig)\n", + "\n", + " return image" ] } ],