From 668b3cbd442ba82bccc63950722e48c90065b8c4 Mon Sep 17 00:00:00 2001 From: weichangfeng Date: Tue, 7 Dec 2021 19:48:55 +0800 Subject: [PATCH] Upload New File --- encounter2VItamin.ipynb | 1059 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 1059 insertions(+) create mode 100755 encounter2VItamin.ipynb diff --git a/encounter2VItamin.ipynb b/encounter2VItamin.ipynb new file mode 100755 index 0000000..cb53680 --- /dev/null +++ b/encounter2VItamin.ipynb @@ -0,0 +1,1059 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import minke.sources\n", + "import lalsimulation\n", + "import lal\n", + "import numpy as np\n", + "import minke.distribution\n", + "import matplotlib.pyplot as plt\n", + "import bilby\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "mass_ratio=1\n", + "num_samples = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "nr_path = './h_psi4/{}'\n", + "waveforms_merge = {\n", + " 1: \"h_m1_L0.9_l2m2_r300.dat\",\n", + " 2: \"h_m2_L0.87_l2m2_r300.dat\",\n", + " 4: \"h_m4_L0.5_l2m2_r300.dat\",\n", + " 8: \"h_m8_L0.35_l2m2_r280.dat\",\n", + " 16: \"h_m16_L0.18_l2m2_r300.dat\"\n", + "}\n", + "\n", + "extraction = {\n", + " 1: 300,\n", + " 2: 300,\n", + " 4: 300,\n", + " 8: 280,\n", + " 16: 300\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "nr_waveform = waveforms_merge[mass_ratio]\n", + "\n", + "duration = 1\n", + "sampling_frequency = 256\n", + "Nt=duration*sampling_frequency\n", + "\n", + "ref_geocent_time = 1126259642.5\n", + "start_time = ref_geocent_time-duration/2.0\n", + "epoch = str(start_time)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "distance_set = {\n", + " 1: 5000,\n", + " 4: 1500,\n", + " 8: 1000,\n", + " 16: 400\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "total_mass = 150\n", + "#locations=(np.array([0.014168722617660154]),np.array([0.40882164684030586]),np.array([3.0314003036051638]))\n", + "ra = np.random.uniform(0.89,0.89,num_samples)\n", + "dec = np.random.uniform(-0.94,-0.94,num_samples)\n", + "psi = np.random.uniform(1.54,1.54,num_samples)\n", + "locations = (ra,dec,psi)\n", + "distances = np.random.uniform(distance_set[mass_ratio], distance_set[mass_ratio], num_samples)\n", + "#m16 distances = np.random.uniform(500, 500, num_samples)\n", + "\n", + "#m8 distances = np.random.uniform(1500, 1500, num_samples)\n", + "\n", + "#m4 distances = np.random.uniform(2000, 2000, num_samples)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_for_detector(source, ifos, sampling_frequency, epoch, distance, total_mass, ra, dec, psi):\n", + " \"\"\"\n", + " Generate an injection for a given waveform.\n", + " \n", + " Parameters\n", + " ----------\n", + " source : ``minke.Source`` object\n", + " The source which should generate the waveform.\n", + " ifos : list\n", + " A list of interferometer initialisms, e.g. ['L1', 'H1']\n", + " sampling_frequency : int\n", + " The sampling_frequency in hertz for the generated signal.\n", + " epoch : str\n", + " The epoch (start time) for the injection.\n", + " Note that this should be provided as a string to prevent overflows.\n", + " distance : float\n", + " The distance for the injection, in megaparsecs.\n", + " total_mass : float\n", + " The total mass for the injected signal.\n", + " ra : float\n", + " The right ascension of the source, in radians.\n", + " dec : float\n", + " The declination of the source, in radians.\n", + " psi : float\n", + " The polarisation angle of the source, in radians.\n", + " \n", + " Notes\n", + " -----\n", + " This is very much a draft implementation, and there are a number of \n", + " things which should be tidied-up before this is moved into Minke,\n", + " including bundling total mass with the source.\n", + " \"\"\"\n", + " nr_waveform = source.datafile\n", + " \n", + " waveform = {}\n", + " waveform['signal'] = {}\n", + " waveform['times'] = {}\n", + " \n", + " for ifo in ifos:\n", + " \n", + " det = lalsimulation.DetectorPrefixToLALDetector(ifo)\n", + " hp, hx = source._generate(half=True, epoch=epoch, rate=sampling_frequency)[:2]\n", + " h_tot = lalsimulation.SimDetectorStrainREAL8TimeSeries(hp, hx, ra, dec, psi, det)\n", + " waveform['signal'][ifo] = h_tot.data.data.tolist()\n", + " waveform['times'][ifo] = np.linspace(0, len(h_tot.data.data)*h_tot.deltaT, len(h_tot.data.data)).tolist()\n", + " \n", + " \n", + " return waveform" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "waveforms = []\n", + "ifos_list = ['H1','L1','V1']\n", + "for distance, location in zip(distances, np.vstack(locations).T):\n", + " \n", + " hyper_object = minke.sources.Hyperbolic(\n", + " datafile = nr_path.format(nr_waveform),\n", + " total_mass = total_mass,\n", + " distance = distance,\n", + " extraction=extraction[mass_ratio]\n", + " )\n", + " hyper_object.datafile = nr_waveform\n", + " \n", + " waveform = generate_for_detector(hyper_object, ifos_list, sampling_frequency, epoch, distance, total_mass, *location)\n", + " waveforms.append(waveform)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "238" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(waveforms[0]['signal']['H1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(waveforms[0]['signal']['H1'])\n", + "plt.title('signal')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(waveforms[0]['signal']['H1'])\n", + "plt.title('signal')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nfor i in range(num_samples):\\n peak_index[i] = waveforms[i]['signal']['H1'].index(max(waveforms[i]['signal']['H1']))\\n delta_peak[i] = supposed_peak_index - peak_index[i]\\n delta_start_time[i] = delta_peak[i]/256\\n new_start_time[i] = start_time + delta_start_time[i]\\n new_epoch[i] = str(new_start_time)\\n\"" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'''\n", + "for i in range(num_samples):\n", + " peak_index[i] = waveforms[i]['signal']['H1'].index(max(waveforms[i]['signal']['H1']))\n", + " delta_peak[i] = supposed_peak_index - peak_index[i]\n", + " delta_start_time[i] = delta_peak[i]/256\n", + " new_start_time[i] = start_time + delta_start_time[i]\n", + " new_epoch[i] = str(new_start_time)\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "peak_index = waveforms[0]['signal']['H1'].index(max(waveforms[0]['signal']['H1']))\n", + " \n", + "supposed_peak_index = int((0.5+0.22)/duration*256)\n", + "delta_peak = supposed_peak_index - peak_index\n", + "delta_start_time = delta_peak/256\n", + "new_start_time = start_time + delta_start_time\n", + "new_epoch = str(new_start_time)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "148" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "peak_index" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "new_waveforms = []\n", + "\n", + "for distance, location in zip(distances, np.vstack(locations).T):\n", + " \n", + " hyper_object = minke.sources.Hyperbolic(\n", + " datafile = nr_path.format(nr_waveform),\n", + " total_mass = total_mass,\n", + " distance = distance,\n", + " extraction=extraction[mass_ratio]\n", + " )\n", + " hyper_object.datafile = nr_waveform\n", + " \n", + " new_waveform = generate_for_detector(hyper_object, ifos_list, sampling_frequency, new_epoch, distance, total_mass, *location)\n", + " new_waveforms.append(new_waveform)\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "new_peak_index = new_waveforms[0]['signal']['H1'].index(max(new_waveforms[0]['signal']['H1']))" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "148" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_peak_index" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\ndef fix_waveform(ifos,num_samples,waveforms,t0):\\n \\n fixed_waveforms = []\\n supposed_peak_index = int((0.5+t0)/duration*256)\\n \\n for i in range(num_samples):\\n fixed_waveform = {}\\n fixed_waveform['signal'] = {}\\n for ifo in ifos_list:\\n\\n len_wfm = len(waveforms[i]['signal'][ifo])\\n peak_index = waveforms[i]['signal'][ifo].index(max(waveforms[i]['signal'][ifo]))\\n fixed_waveform['signal'][ifo] = waveforms[i]['signal'][ifo]\\n if supposed_peak_index > peak_index:\\n for j in range(supposed_peak_index-peak_index):\\n fixed_waveform['signal'][ifo] = [0] + fixed_waveform['signal'][ifo]\\n\\n if len(fixed_waveform['signal'][ifo]) >= 256:\\n fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo][0:256]\\n \\n else: \\n for k in range(256-len(fixed_waveform['signal'][ifo])):\\n fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo] + [0]\\n \\n \\n else:\\n fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo][peak_index-supposed_peak_index:len_wfm]\\n \\n if len(fixed_waveform['signal'][ifo]) >= 256:\\n fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo][0:256]\\n \\n else: \\n for j in range(256-len(fixed_waveform['signal'][ifo])):\\n fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo] + [0] \\n \\n fixed_waveforms.append(fixed_waveform)\\n \\n return fixed_waveforms \\n \\n\"" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'''\n", + "def fix_waveform(ifos,num_samples,waveforms,t0):\n", + " \n", + " fixed_waveforms = []\n", + " supposed_peak_index = int((0.5+t0)/duration*256)\n", + " \n", + " for i in range(num_samples):\n", + " fixed_waveform = {}\n", + " fixed_waveform['signal'] = {}\n", + " for ifo in ifos_list:\n", + "\n", + " len_wfm = len(waveforms[i]['signal'][ifo])\n", + " peak_index = waveforms[i]['signal'][ifo].index(max(waveforms[i]['signal'][ifo]))\n", + " fixed_waveform['signal'][ifo] = waveforms[i]['signal'][ifo]\n", + " if supposed_peak_index > peak_index:\n", + " for j in range(supposed_peak_index-peak_index):\n", + " fixed_waveform['signal'][ifo] = [0] + fixed_waveform['signal'][ifo]\n", + "\n", + " if len(fixed_waveform['signal'][ifo]) >= 256:\n", + " fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo][0:256]\n", + " \n", + " else: \n", + " for k in range(256-len(fixed_waveform['signal'][ifo])):\n", + " fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo] + [0]\n", + " \n", + " \n", + " else:\n", + " fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo][peak_index-supposed_peak_index:len_wfm]\n", + " \n", + " if len(fixed_waveform['signal'][ifo]) >= 256:\n", + " fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo][0:256]\n", + " \n", + " else: \n", + " for j in range(256-len(fixed_waveform['signal'][ifo])):\n", + " fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo] + [0] \n", + " \n", + " fixed_waveforms.append(fixed_waveform)\n", + " \n", + " return fixed_waveforms \n", + " \n", + "'''\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "def fix_waveform(ifos,num_samples,waveforms,delta_peak):\n", + " \n", + " fixed_waveforms = []\n", + " for i in range(num_samples):\n", + " fixed_waveform = {}\n", + " fixed_waveform['signal'] = {}\n", + " for ifo in ifos_list:\n", + " fixed_waveform['signal'][ifo] = waveforms[i]['signal'][ifo] \n", + " for j in range(delta_peak):\n", + " fixed_waveform['signal'][ifo] = [0] + fixed_waveform['signal'][ifo] \n", + " for k in range(Nt-len(fixed_waveform['signal'][ifo])):\n", + " fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo] + [0] \n", + " fixed_waveform['signal'][ifo] = fixed_waveform['signal'][ifo][0:Nt] \n", + " \n", + " fixed_waveforms.append(fixed_waveform)\n", + " \n", + " return fixed_waveforms \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "fixed_waveforms = fix_waveform(ifos_list,num_samples,new_waveforms,delta_peak)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "times = np.linspace(start_time, start_time+duration, 256)\n", + "plt.plot(times,fixed_waveforms[0]['signal']['H1'])\n", + "plt.title('signal')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "256" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(fixed_waveforms[0]['signal']['H1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "184" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fixed_peak_index = fixed_waveforms[0]['signal']['H1'].index(max(fixed_waveforms[0]['signal']['H1']))\n", + "fixed_peak_index" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(10000)\n", + "ifos={}\n", + "\n", + "for i in range(num_samples):\n", + " ifos[i] = bilby.gw.detector.InterferometerList(ifos_list)\n", + " ifos[i].set_strain_data_from_power_spectral_densities(\n", + " sampling_frequency=sampling_frequency, duration=duration,\n", + " start_time=ref_geocent_time-duration/2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def whiten_signal(signal,ifo):\n", + " \n", + " signal_fd = np.fft.rfft(signal)/Nt\n", + " \n", + " whitened_signal_fd = signal_fd/ifo.amplitude_spectral_density_array\n", + " whitened_signal_td = np.sqrt(2.0*Nt)*np.fft.irfft(whitened_signal_fd) + 1.0*np.random.randn(256)\n", + " \n", + " return whitened_signal_td" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(10000)\n", + "whitened_signal_td_array=np.zeros((num_samples,3,256))\n", + "\n", + "for i in range(num_samples):\n", + " k = 0\n", + " for ifo in ifos_list:\n", + " whitened_signal_td_array[i][k,:] = whiten_signal(fixed_waveforms[i]['signal'][ifo],ifos[i][k]) \n", + " k += 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAETCAYAAADUAmpRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABjPUlEQVR4nO2dd5hb1Zn/v6901abPeMYeN2xj00wHA6EFCAkh2ST8lvQOKZO2KZtN27ApmyzZJJtkQ8ommfSeAIEEEggttAABbMCAMc32uJfpRaOu8/vjFJ0rXWk0M9JIY7+f5/HjkXR177lX957vect5DwkhwDAMwxza+GrdAIZhGKb2sBgwDMMwLAYMwzAMiwHDMAwDFgOGYRgGLAYMwzAMWAzqCiISRLSmyGdvJqJb57pNXhDRz4jov2rdDoaZCiI6iogeI6JxIvpQrdtTz7AYzBOEEL8WQlykX5cSjlpCRJcR0d+t1y1EdB8R/YGIgrVsWymIqI+IYkQ0QUTDRPQXIlpufV4ggES0Uv0Ozty3uPIQ0V1E9K5at6PCfALAnUKIZiHEt2rdmHqGxYCpGkTUDuAOANsBvF4IkZzGd2vRwb5SCNEEYDGA/QC+XYM2zFuIyF/rNniwAsCmmXzxYBH5cmExqDJEdDkR3Wi9fo6IrrFe7ySik6yvvFhtM0JE3yUiUtuZETcR3aO23ahGsq9X779CmcQjRHQ/EZ1gHaePiD5GRI8T0SgR/Z6Iwtbnpb57MhE9okzt3wMw3ytx3l0A7gTwJIC3CCHS6v13E9HzRDRERDcQ0RLrO4KIPkBEzwF4rox2fYqItqh2PUVE/2x9dhkR/Z2IvqZG+tuI6GVTtRsAhBBxANcCWFvO9iWuQSsR/ZiI9hLRbiL6L91hTtU+Iuogop8S0R71+R+tzzyvoZelYo/2Sx2TiK4EcC6A76h76jvq/aOJ6DZ1rGeI6HXWvn9GRN8jopuIKArggrzzv4CInrBe30ZED1uv7yWi/6f+9vwtiSikfvvjrO91kbTiFqrXnvcIEf1NtUmf05HqN/kFEfUT0XYi+g8i8lnX5z4i+l8iGgTweXWO/0dEN6t93EdE3UT0TXUNnyaik6d/d9QhQgj+V8V/AA4HMAIpvEsgR8m7rM+GAfjUawHgzwDaABwGoB/AxeqzywD83dqvALDGen0ygAMAzgDgB/B2AH0AQurzPgAPqTZ0ANgM4L1TfRdAULX5XwEEALwGQArAfxU538sAPAU5GvseALI+exGAAQCnqH1/G8A9eed0m2pfpIxzeq06Hx+A1wOIAlhstSMF4N3qu+8DsMduT167+wC8WP3dAODnAH5hff6z/HMGsFK12Smyz+sB/ABAI4CF6vq/p5z2AfgLgN8DaFfX/byprqFXewDcBeBdZR7TbKteNwLYCeByAI76PQYArLWuySiAs9VvEM47/wiAOIBOdQ77AewG0Kw+iwFYUMZv+RMAV1r7/QCAv5Z53+ef0y8A/Em1YSWAZwG807o+aQAfVOcbUec4AOBUyEHQ3wBsA/A2dbz/gnRD1byvmXVfVesGHAr/1AN1CoA3AOiF7BSOVg/ZDdZ2AsA51uurAXxK/X0ZSovB9wB8Me+4zyDXifRBjtD1Z18F8P2pvgvghcjrRAHcj9JiMA7Z6ZyR99mPAXzVet2ktltpndOLyj0nj2M/BuASqx3PW581qP13F/luH4AJSOFOqXM+3vr8Z5Ad24j1bwxFxADAIgAJABHrvTfqjqNU+yDdVFkA7R77LXoNUZ4YFL0mKOw4Xw/g3rzj/wDA56xr8ov8NuZtfy+ASwG8AMCtkPf0xZAj9sdLfM/+LV8MYIv12X0A3lbmfW+fvx9AEkrM1HvvAXCXdX125O3rZwB+aL3+IIDN1uvjAYyU2xfU879DyidWQ+4GcD6ANervEciO9kz12maf9fck5MNeDisAvJ2IPmi9F4QcbRXbt/6s1HcFgN1C3fmK7VO0ZSOAawDcTEQXCiEeVe8vAfCI3kgIMaHM8aWQnTEghbOscyKitwH4KGQnCMhr1el1vkKISZIet1LX8/8JIW5XrpxLANxNRGuFEHo/XxNC/IfemIhWQo4SvVgBORreq44LyFGvfX7F2tcBYEgIMeyx31LXcHeJc5vqmMXO4QwiGrHecwD80nq9E6XR9/4u9fcw5L2fgHXvT/Fb3gmggYjOgLQuToK0unQbp7rvNdpCse/f7ZDXrtT57Lf+jnm8LvcZrWtYDOaGuwG8EsAqAF+CFIM3Q4rBdyp0jJ2QpvSVlfwuEZ0HYCkRkSUIhwHYUmqHQoiriCgE4DYiOl8I8STkaHuFte9GAAvg7sRs0SnVrhUAfgjgQgAPCCEyRPQYAMrfdroIITIAriOiHwA4BzJ+MF12QnZ4nULFS6b53Q4iahNCjOR9VuoaRtXbDZBWCyAtjXIRea93ArhbCPGSaXwnn7sBfB3ADgBfhhSDH0Jem+8CU/+W6vXVkJbVfgB/FkKMW20s974fgLSiVkC6MgF5Lxe7/w4pOIA8N9wNaRZHhBC7IE3niyEf4kdLfbEE+yFjDpofAngvEZ1BkkYi+iciai5jX6W++wCkH/VDRBQgoksBnF5OA4UQXwVwFYDbiegoAL8FcDkRnaSE4ksAHhRC9M2gXY2QD24/IAP1AI4rsp9poY51CaS/fvNM9iGE2AvpFvk6yfRaHxGtVuJazndvBvB/RNSurvsL1cdFr6EQoh+yY3sLEfmJ6B0AVk+j2fn31J8BHElEb1VtCBDRaUR0zDT2eT+AoyDvmYeEEJugLA4AOhGinN/yN5BuqzervzVl3/dK5K8GcCURNSsR+iiAX03jfA5aWAzmACHEs5D+6HvV6zEAWwHcp27QmfB5AD9XGRSvE0KshwwMfgdy9PU8pA+0nPYV/a6Q6aCXqtdDkA/kdeU2UgjxRQA/gkwx3QbgMwD+AGAvZEf1hhm26ynIEecDkJ3Y8ZC+5NlwIxFNQI6qrwTwdtV5zZS3QbosnoJs/7WQ8YByeCvkKPZpyADpRwBACHE7Sl/DdwP4OIBBAMdCdsblchWA16gsmW+p0fdFav97IF1MX4EMXJeFECIK6dbaJHKpxQ8A2C6EOKC2mfK3FEI8CGn5LIEUSv3+dO/7D6r9bAXwd0hh+Um553Mwo7MIGIZhmEMYtgwYhmEYFgOGYRiGxYBhGIZBHYsBEbUR0bVquvdmIjqz1m1iGIY5WKnneQZXQU45fw3JapcNtW4QwzDMwUpdZhMRUSvkdPTDRZEGdnZ2ipUrV85o//39/ejq6ppx++YjfM6HBofaOR9q5wvM7pw7Oztxyy233CKEuDj/s3q1DFZBTkD5KRGdCGADgA+rnGUAwMqVK7F+/foZ7XzdunUz/u58hc/50OBQO+dD7XyB2Z8zEXV6vV+vMQMHsrDb94QQJ0NOEvmUvUF/fz/WrVtn/vX29tainQzDMHVPb2+v6Svhrt9lqFfLYBdkmecH1etrkScGXV1dh9yIgGEYZib09PSgp6cHAEBEA17b1KVloKpE7lT1bABZwOqpEl+ZFvqiHErwOR8aHGrnfKidL1C9c67LADIAkFz960eQtV22ArjcLum7bt06wZYBwzDM9CCiDUKIdfnv16ubCEKIxwAUNJhhGIapPHXpJmIYhmHmFhYDhmEYhsWAYZjqkcpksfJTf8GvH5xqpVSm1rAYMAxTNXYPxwAA37ur5CqpTB3AYsAwTNXYpcRgaVukxi1hpoLFgGGYqrF7ZBIAi8F8gMWAYZiqod1E3a3hGreEmQoWA4ZhqsZOJQaOj2rcEmYqWAwYhqkaO4ekmyhbn4UOGAsWA4ZhqsbOYSkGAqwG9Q6LAcMwVSGeymD/WAIAWwbzARYDhmGqwp6RmPm7TuthMhYsBgzDVIXhyZT5u16rIzM5WAwYhqkKGcs3xFJQ/7AYMAxTFdKZrPk7q4ShfzyBazfsqlWTmBKwGDAMUxXSHpbBjRv34GPXbMRYPOX9JaZmsBgwDFMV0lnLMlAxg5SyFjIZdhzVGywGDMNUhbTV4ev4cUb9keGAct1Rt2JARH4iepSI/lzrtjAMM31cbiLV+evYQZYnHtQddSsGAD4MYHOtG8EwzMywxUD/qWPKbBnUH3UpBkS0DMA/AfhRrdvCMMzMsLOJdDkKLQJsGNQfdSkGAL4J4BMAslNsxzBMneJlGbCbqH6pOzEgolcAOCCE2FBqu/7+fqxbt8786+3tnaMWMgxTDiUDyCwGc0pvb6/pKwF0em3jzG2TyuJsAK8iopcDCANoIaJfCSHeYm/U1dWF9evX16SBDMNMTUalljo+Kgggc8xgbunp6UFPTw8AgIgGvLapO8tACPHvQohlQoiVAN4A4G/5QsAwTP2TUpZBwO8zloF2HXGtovqj7sSAYZiDA+0KCvjJTDrT72U4Glh31KObyCCEuAvAXTVuBsMwMyCl3ERBx5cLIHPMoG5hy4BhmKqQsd1EcItAlt1EdQeLAcMwVSGlOn7HTyZmkBUsBvUKiwHDMFUhk83C8RF8lMsmysUMWAzqDRYDhmGqQjoj4PgJhMJyFGwZ1B8sBgxzECOEwP1bBmqSypnOCjg+n7QM1HtZLkdRt7AYMMxBzKM7R/CmHz6IR3YMz/mx05ksHD8BVJhFxG6i+oPFgGEOYsbjaQDAyOTcrywmLQMZM9CmQSZvJjJTP7AYMMxBTCotnfSxVGbOj53OSDeRjBnkrWfAWlB3sBgwzEFMUkVsY8kaiEFWwG+yieR7Ga5NVLewGDDMQYxeczheC8sgm0XATyAqnF/AbqL6g8WAYQ5ikrV0EynLgIis1FIOINcrLAYMcxCTcxPNfWW4dCaLgN8HHwE6gpzmchR1C4sBU1d8+ean8WgN0iAPVmoZQM4YywAFhepYDOqPuq5ayhxaCCHw/bu3QAiBkw9rr3VzDgr0mgK1iBmkMjK1VAAe5SjmvDnMFLBlwNQN2oUwpnLjmdlTy2yiTFbA8ftc5ShUVWvOJqpDWAyYukGvmTsen5sJUr94oA8Xfv2uOTlWrdAB5MmaWAZZE0DWXb8WAV7prP5gMWDqhrQaNo7PkWWw5cAEtvRHD+o0x1SNLQOdWjpV1dI7Nu/H//vufZxlVENYDJi6Ya4tg3hKdpTR5Ny7pYQQczI61pZBTWIGWQG/LlQ3xUpnG3eN4rGdIzX5LRhJXYoBES0nojuJ6Cki2kREH651m5jqk5pjyyCelh3kZA1Gzb9/eCfO+cqdVRcEYxnUJJsoi4CPXOUotAjkn3ZMiUC8Br8FI6lLMQCQBvBvQoi1AF4A4ANEtLbGbWKqjO4o5kwMVAc5kZj70eiW/gnsHomZoHm1SCprqyblKDK5chQFVUvz1EALci2EmZHUpRgIIfYKIR5Rf48D2AxgaW1bNTUHxuMcGJsFtXITTSbmvgPSnZ5241SLWrqJ0lmBgN+nYgbyvWJuIi1WtbBgGEldioENEa0EcDKAB2vclJI8uXsUp195B65Zv2vG+8hmBSYPYZ+pdmlEk5k5CSTW0jKYKzGopZsobbKJUFCoLn/SmW4fWwa1o67FgIiaAPwBwEeEEGP2Z/39/Vi3bp3519vbW5tGKu57fgAA8NTesSm2LM6Nj+/BC750R01GcfWALQATc+AqiquOOFoTMZDHTJQQg5uf2Dvre6HWtYkcv6paCnfp6vwMLi0CtXBnHQr09vaavhJAp9c2dTsDmYgCkELwayHEdfmfd3V1Yf369XPfsCL0DU4CAJa1R2a8j13DMYzF04gm0ggH/JVqmuG2p/bjvucH8PlXHVvxfVcCPVsWAMbiKbQ2BKp6vITqIGuRwTKVZdA3EMX7fv0IvvXGk/GqE5fM+Di1TC1NqxnIdjmKXMzAvS27iapLT08Penp6AABENOC1TV1aBkREAH4MYLMQ4hu1bk85bB+Mznof+oEoNVqcDbc/tR+/eXBH3cY19DwDYG6CyHrUHa1lzCDjfWztupqthaRnICfS2TmfT5FWM5Blaqk7VlBgGaTkeR7KbtJaU5diAOBsAG8F8CIiekz9e3mtG1WK7coymI1Zr79bLT/yeCKFZCZbt6MvO7NmLoLIZp5BDWMGxYRf3wuVchMBuVTauSKdzcKRJUsLCtUVyyY6VF2k9UBdioEQ4u9CCBJCnCCEOEn9u6nW7SpGLJnBntEYgNmN6vXDWi3LQI+2h2uwHm45pDO2GMxFzKCWbiJ5zGLCr4VqtsKdsirCzbWrKKOWvfRZ5SiKlbCOz0FqaSqTxaY9o7Paxw0b9+Dn9/cV/TyZzuLOZw7M6hi1oi7FYL7x/IEJky0xO8tAm/TVeSByi6Mnq7L/2ZK2Oq7xRPmClUxnXd8tl5ybqP5iBrptiVmLQa7TnWuLMJXNwskrR5Et6iaqfszgk394HP/0rb9jYCIx43186LeP4nM3bCr6+R2b9+Pynz6MZ/aNz/gYtYLFoAJsHZgwf8/KMqiym0j7oUfq1TLIzswyeNMP/4Gv3vLMtI4lhDDiO1GDmMFU8aFYhTpHl5tojsUgk5UBZNcayCZ24N52LrKJrntkNwBgLDb7+7/YtRxXz1h+DDGbFdihXMn1CotBBdA3l99HFYkZzFRQ7nt+ALuGi99w2g9fv2IwswDy9qFJbDkw4fnZr/6xHd/523MF79vXeK6DlkII45qayjKIpTL4zB+fxBdufGpGx0plsmgIysy0uVztTAhh1jPwKkdhu4kyWZFLga2SGNhpy5VwRRV7zvR9tWck5nr/lk37cMHX70L/+MytkmrDYlAB9Gigsyk4S8tg5m6iTFbgXT9fjx/es7XoNrmYQX26iVIzjBnEkhmMFhnt3bJpH27YuKfg/UQq9zvNtZsokc6akXKyiHsrbmYOZ/HozmE8tnNmq78lM1m0hGWK7ly6iXTf6/h9rjWQsx5iYIuxdhfd/MRePLVn5nN28rH3VYlJhn0DRcRAtX93nhhsHYgikxV1++wBLAYVYTyehuMjtEYClbEMUtMXlN3DMcRSmaLB4UxWmBFRsY6zHD5/wybPkXYlyHhkE23eO4bX/eAB7BzyfviEkLO2i51TLJnxHAnamTVznVpqi08xyyBhWQaTCe9zKIdkOovWyNyLgQ5cy9pEVglrj3IUtjUQT2YghMDHrtmI7971fMXa84+tg+bv2Yh/V3MIANBXJJVcDwbzxUBbBFNZPj+4ewv++OjuGbdvNrAYVICJeBrNYQfhgL8i2UTFRoul2NIv3SRjRVIy7Xz14ejMRyc/u78PX7v1WVy7Yde05yus7xvCqV+8rejx7cyX8XgagxMJvOyqe/HQtiFsKjJKTKSzyIriAhdLFREDq2PULptfPtCHzbOYQV6KdCaLj1+zEc/uH3e1p5wAcjSZnnFHnspk0RKRc0vtjmjH4CRedtW9ODAWn9F+p0J39rn1DOT7Xiud2ec2mcxg/1gC0WSmInN3NHYWUdS6Dn96bDe+fPPTZe9Hu9y2F/H/58TAfV37VdB6qt/xVw9ux40eluxcwGJQASYSaTSFHYQdf2WyiWZgGWgxKOZesUViZBaWgR5lfuyajXjLjx+c1kSme54bwGA0iV3DMc/PdWppV3MI2wej+Ol9fbnPst7XRHesxc5JikHhNdHX2u8jTCTSyGQFPnfDplnVlirF/vEErtmwC/c82+/qEBKWAP7psd24dsMuV/tmaxmkMsK4iex789Gdw9i8dwyP75pdqmUx9G9p1jOA2zKwxxH2uU2mMtiq7uXtg5MVmyC5ZySOwzoaALgtg789fQA3PCZH4pmswFt//CBu3bSv6H70s1ncMlBuouEiloH6DfoGogXWAyDjebWqz8Ri4EE8lcGP7t1adrrieDyF5lAAoYBvVpZBLsNk+jfD8yqAWixTwvaTzia1VAiBN56+HJedtRL3PT+IfdMYWepRd7EJZXo0+bLjurFx1yh++9AO8wAXE0g7X99LiOPJDOKpbEHhO71te0MQk4kMRiaTyIrquVK0ZabLjWhsy+A3D+7ALx7oc7UvllSWQYXdRAfGZOc0nd9vOmjx1pZBQTmKIgHdeDKDLQOyox2Ppys2J2bPaAxHLmoC4BaDVCZrntmhaBL3PjeAnl9uKHqPaqu9qGWg7tOBiYTrfhxQYqDnU3zsmo34fF6KajqTxXg8beImAxMJvPNnD88qFXY6sBh4cOfTB/Bff9mM9dvLC9qNx6VlEHL8BZ1WIp3Bf9+0uaRrZttAFAfG4kYEZiIopdxE9zzbj+eUWPhodtlEqYxAU8jBhccsBADsKOLL98KIQRGfrV7c5tJTlgEABqNJvPZU+XfRFEyrI/FyFRVL0dQPamdTENFEGkPq94lVKbNIi/F4POVqsy38yUzWdFTaZTgSSyErpOhNNUoWQuDzN2zCxp0j5nUyk0WLEgO70z0wLkVg32i1xEBbBmoNZCFcVqRXzKA55GAylXZlhuWPwHcMThZ1hX7/7i340b2FCRSZrMC+0ThWL9RiYLvphLm37P1+/+4tnsfQsZxdw5PmGro+t+5TO6Mo3zIYjCZxIC+zSN+/WjDu3zKIO54+gCd2V8d6y4fFwANtvpWryOPxNJpDDkIBX8GU/w3bh/GDe7bitqf2m/ee2TeOq25/zjwc//KbR3DlTZutbKLSYnDvc/3GlNZs6ZcPzVissDN7zy834H9ukX7Rxa2RWWU0JDNZBB0fVnQ0AnCLwRf//BQ+/LtHAcgR1xXXP2ECv2PxlHEPFXNladfC8vYIzljVgaDfh1edJIu0FbOWJssUg3xXkc7W6WgMIppMl+3TnSlRq9ZQtEjMIJnOWmUZ5PuDE/K3yoqp74t4Kouf3d+HS757H4Bch6zFwBY63RFVzzJQMQOfDwTpFrLjBF7ZRB1NQcSSGWwdiKI5JOMcdtwgmc7ihf9zJ97/q0c8j/nnx/fgFg8Xz8BEAumswLL2BoQDPteMc2kZyGtuW9W3bNpfsB9A3v8XH9uNrJCWXD72fbpHxQ1iyYwZAOn7ayKRLrDitRWk6zTpZ3yu1ttgMfBA/4j6QZyKiYQMIIccX4FloCeabFET057cPYrXfv9+/O/tz5pRz+BEEv3jibLnGXzsmo34oTUCGo4mMRRNoq0hgFgqYzqYyWQaybSsRbRzSHbEyzsiM84mymSFWuTch8VtYfh9hB2Dk3hu/zhSmSwe2jaEx9So9Nn94/j1gztwz3P9AOCakTlRZGSnOxDH78MXLjkO33nTySZ7I5HO4sndo+gbcI8US4lBNpubWJb/QOlrvaAphKzI+Xir5a+NGssg7RKmfDEwlkGqMPNrKldRfjBav24M+hHwk+vc9Ei1apaBK5tIlqOwrYGsRwC5o1GJQf8EzlqzAETuFM4NylJ/fNeI5zHHYmnP308P7pa2hdEUclwu01Qmi1RGWi1japBy0dpFeP7AhAmupzNZfOi3j+LJ3aNIZQSOXtyM84/qws/v78N7f7nBNTBLpOVgCYApUWMPKvVvGPUQg9FY0rWNHuDNVbkUFgMPtHk3WKZlYALIAX/BCFaXtt5yQP6wv3xgu7nptBhoN4XuDKeKGUTzAor6pjumuwWAdEXcv2UAJ33hNuwYcneey9sbMDKZmlFgTmf7BB0fAn4flrSFcf+WAbz0m/fgDxt2Ye9ozLjDtKDqzs3O0iluGeT8zEd1N+OiY7sRcmT2RiKVxSu+/Xec/7W7AMhrfsX1T5gRPQCM5rm/3BPL5PV6as8Y0plcfGFBYxBAzsIplgDw7P7xguyWA+NxVwZUKfTIcDzhdhO5xCAjLQM5O7qwHZNTWC35903KXE8fIgF/nptIXre9o97BfJsD43HTEZdLTth1zEDkTTTLbauvx4LGEEZiKeweieGYxS1Y0hpxWZ53PysHFicd1u55zPF4ytOy26vuxcWtETSGHEzmiQEgr72OE1x8XDcA6aYBpEvnho17zPFDjh/vO281JpMZ/HXTPty3JZe2mkhlsaxNlrHXgmu7k2LJjFrESs6NsZ/D4aiyDLQYHNCWAYtBzdCda3+eZdA/nsCnr3/C9TALIWQAORzwtgxUZ6xLVkwk0mhTdfq3DchsiYlk2jUzsVQ5CiGEa/Sv2wUAh3dJ1814PI2+gUkk01k8fyBPDDoakM6KKSfeeImFDp4F/fK2WdHRiEd2jCArgE17xjAwkcRYPI10JovdaoamLvWwfXASkYAf4YCvaMzA9jNr/D5CwE+ujm7n0CQ27hzBrx/cgXvVAwpI/3o6k8UNG/cgmxV5KYtp7BmJ4Z++fS/+Yi0ao8VAi3YxN9G/Xb0R/2nNAk6kM7jwa3fjdw/v9Nw+H9sy0G4iH7nTiJPpLNJZ6eePewTMp4pn5FuUSUu8G4KOyyLRo979Y8UHPH0DUVy7YRdOv/IOvPp7909rAKFdfqZQncizDDwCyAsag0oMgTULm7BiQYMrZqA7Y+v2MAghR/Ze1pMWvCVtETQEHUwkMrh10z4cGI+bNaITqaxxsb7g8AVoCTu4f8uA+QzIJV4EHR/OOHwBNnzmJbL9dkKAitE0hx3zXNrPdkylCgPyfrcFWmfExVJSMLYNaMuA3UQ1o5hlcO9z/fjNgzvwj23WSCCdNUHVcMBfEDPQZu6OwUmkMllMJtNY1h5Bc8hB30DU3PxDlh/ffqhHYynXyCKVka6ahIcYrO6SAbKxeAoTqtCb/V3HR1jVKQXj7895rm9hOO3K2/GJaze63kulc50LIIVF89C2IVebtWmuH5SocqU1hwNTxgwCPvdtGXLc8zf+/PheI4Z7LTfHaCyFW5/ajw/99lE8unO4IH+9bzAKIeQiQrqzPVxds0d3DJvtvNg7GnMdayiaxHgijb0e6YFe2DED3am3NQQL3ESAdGl5WgZTdAr5JTb0/oJ+HxqCfisekcFYPI2WsHSZFMucec33H8DHrsndA9NJbNDZRLZlMKWbqClo3ju6uxlL2iJmVD8UTRrr0us6TKqlUr3EfPdIDI1BP1rCDppCfhwYj6Pnlxtwzfpd5p5OZDImgNzWEMDZazrxt6cPIJ7KmDUndOJFSN3/DWoBKrs9iVQGIceHruYQ+scTyKrgtX2udgDbdgNqsREC2DYYLRrvqhYsBnnEUxkMKItgMFpoGQDuqe26Y2tRMQPdWQNytLJjaBKtkQDSWYGdQ5OYTGbQEHCwsrMRfYNR00nYgy7buvj09U/gzT/MLf+cK3Nt+X8n3JbBWCxtUhn3WwHC5rCDi4/rxtrFLfjMnzYVuFU0OwYnMTCRxNV5OfdJy+0AwKR9AsAz+3MxgeHJpBEDPQqaSKTRFHLQHHJM57Nh+7DJfAFkB0IE+PKGfiHHh0Q6Yyb8/PXJvZ41YEZjKTO5qH886RolTiYzJi4wFE2azvb4pa0AYILbcY+OJpMVGIomXb5fHU8qN8agLaSxuPRrB/yExpBb5PTf0WTac+0Br2Nt7Z/AvSou4w5exkx5j4BDiAT95nro+/iEZW0A3PeIZjSWwsBEAu8/fzU+84q1su3TiDXlLAMCodAyyOQFkH2Um8MCACsXNKK7JYz+iQQyWVHgaslHP4eelsFIHIvbIiAiNIYc436JJTPGTSQtgxQcHyES8OOtZ67AwEQS127YZX4XPXLXYuDzkRLZXGedSGcRCvixsDmEA+Nx/MtvH8Hnb3wKPpKWTzyVcVnlbjHI/f2klUE0VzPkD2kx2D0Sw8uvutflN9WjP7+PCrKJjBjsLaxzomMGQO6hHIwmMZFI47wjuwAAW/ul2keCfiMGXi4T/X0hBB7aNoTnDkyYwli6s8p3EzWFHHS3hgFIy0Dv13YDNIUdBPw+fPaVazEwkcB9W7ytA52Rsagl5Ho/lZYPsHETLZBisLTNvdTn8GTKdLy6E4wm0mgMOWgOO+bB/cKNm/CVvz6Nrf0T+OBvH5WdpK/wlgw5PsRTuUV5+scTRpi0Sy/o92EslsLmveOqDUnX6HoymTYCJcVAfn9JWxgdjbkRqZdffigq5yAMRZMFwlBuaYOcm0hOKooE/Aj6fd6WgZobkc/zBybwhRufcnX6P7h7K/7194+5vg8AO4djuRiP34/GoGPERHesJyyTQrjXI4isf7/jlraiU43Yi6V0emEnA+hyFK5sIvX5l27ajB/cvRUNQceI/aKWEBy/D92tYWSyAgMTCTNwaY0ETOcrhMBfHt+Lj/zuUWzeJ5/JRLpwTsnukRiWqHu0MegYt0syk82JQTqLsXgKLZEAiAhnHr4AJy5vQ+89W81voTtubRkDQIPa3+a9Y3hi16gUA8eHruYw+scT2LB9GO0NAbz02G40hhzEksXFwM7y0wPOoONjy2AuWN83hKf2jrmCm3qkeeSi5oJsIj0C32wXvVIdW1MoYEYMemSvJ6ZccLQSg4EJaRkE/Vi1oAG7h2OeE8D0Q71vLG4E6P7npWtKd4j5bqKu5pCZaToWS5kO12UZhOTnuhMvllV085N7AcgJWa52KXM5oM7zRUcvxGdfsRaXn73Std1wNGmm4+fcRBk0hvxoCueyOXTZgQe2DuLGjXuwY2gSjr/QIRwK+DERTxvrKZHOmmsUT0lrYmFLCKOxlPkth6LJAjeRcf9Fk4inM3B8BMfvwxEq/xzwHlnqjj+TFfjFA30468t3YKvK9CjfMkibto/GUmgIOgha7i89J0Beq7Snm+jPj+/BT+7bhvuez4n4aCwlxSrPdbh7OGauUcAvLQPdqegJZ6XEQA8+lrVHTGrqWBH3nhc6GcBeA9meRK5rEvbes9XEsCJqMKXTlrtbwqZ9elS+uDVsfqPbNx/AB37zCP742B7c+FiuhEP+tds5PInDOpQYhHJriyeVi1f/Pa7KygAAEeHiY7uxY2jSZPmMGjdRbh+NIT8mE2lc+ZfN+NwNTyKRVm6iphD2jMaxfyyBd517OL73llMRCfiVmyh3HW1ry55Fry3VpW0RjhnMBSYH3srN16PHE5a2YiLvodQd8zbLvaNdHs2WZaBNfL3/45e2IeT4MDghXRfaMsgKmJGsjX6otQvFRzCjeCMGqTwxaAqZG3ksnjIipR/8xqDf1KixRSOfyWQaj+yQx80PMieNZSA77HDAj3ecs8rEKjT7x+KmAzVr+SbSaAw6aA4FMB5PIatGfPFkxpVu5/eIDoYcH0ZiOdFMWmIAAJGAH20NAWwfjJqObSia7yayLQOZxqt/ryMXNZvtvNYKtgOAdz/bj3gqi0dUjKHcCpj2dgfG42gI+RF0fEhmsti8d6xAuOKpXOlpjU4Pvn1zbiWtaDKNrAAmrBgBIDsTdwDZb1kG8nxOXN4GH8GzCKDdGen7Zc9IDJd8976CaqJeJUkyVjKALkdRbJ6BRrd3meq4taW7bzRuBi6LW8PGerNdjFus9M78dOORyZRxaTaq+QuAGlQYyyCDsVjKnCuQq0Ok+wd9D4YsyyAS8COazGB4MonRWAqJVBYhx4+FLSHze6xcIMUtHPQjlsoWtQxst+3e0ZiKsTmcTUREFxPRM0T0PBF9qhrH0A/XWDyFx3eNYOfQpAn2HLdUpmnarqL+8QQiAT+EAL526zPoG8i5eZpCToFloEf9CxqD0j2SkDnmDUG/GZ0/lVcYze/LZc48tnMUAT/hpcd2477nB10LsuTHDLqaQ2gMOvCR9J+a0bdyCfzPa0/EJy4+GoC8yf0+8jT7tXugrSFQKAZW52KjA8n6gbPPST+Y0aR0EzWFHUzE0zLzJyswmUq7xEDHI2xCjs/4U1vCDhKWea/PpzUSMCIGSOuk0DJQQjEh3URaDI5QZQq0mMZS0pes50bY98Cj6hh6VmgpE972D9ujwd3DMTlJ0e/DruFJ/NO37sUN1sg2mkgjkcoUWGbanfm3zQdMZo+2AEcnUy7LYNfwpCuAHHGJQRx+H2FRcxjL2htM1orNruEYIgE/OhqDaFWDiEd3jGDjzhEzdwQA7nrmAI7//C0FFm4qr1CdtAzcbiJ9D3e3hPGhC48wcYZjl0iLZZGyDPaPxc3AZXFbxJzHcwfGcXhXIxY0Bk1Ovr7uGi10RgyCOTGQloHtJkqbAROQ6/TH8tYBscVAu37G42lEExkVM5CWgUYnbUQCPsSTbssg302kraP9Ywm0RgJoCPoPbcuAiPwAvgvgZQDWAngjEa2t1P639k/goW1D2KlM4dHJFD7wm0fw9VufwcCE/BEWt8rRie0q6p9I4IVHdiLo9+Gn9/XhJ/dtswLIgQLLQHcEjSFHTnZRwcOGoIOuJnmj5+eut4Qdl2VwzOIWnLayAwMTCQxP5nLU82MGXc0h+HyE5nBAuonyVjU778gunKLys4lkuW2v2cq7LTdZNOEugZDKCyBrlrVHQCQD2EG/z3SUC5tD5saXbqJczCBX0jdrRnoTibRZQN0m5PjNQ6MzcGwxjAT95vcCZOcylBcziCZylsFgNIlEKoNwQJ7HEQulZbC8XXYYsVQGP7uvDy/95j14dMewSwx0O7QLsFRw79PXP4G3/+Qhc3xN3+AklnU0IOj4sGsohqwA9liumslkBvF0xgRUtbWk+9J9Y3FTxVXfY6OxlLkm7Q0BHBhP5H4vx4fGoGPE8cBYAp1NQfh8ZGJXgIxJ6PV9d49Mqt+VzGhZi4Y9yeqBLYOIJjMFxQczWT3pzKfKUeQFkLPC3H8fuGA1PvqSI/GG05fji5cci7efuQKAHEQF/IS9yjIgkvdUUsUFnj8wgSMWNqGrOeQauMRSMrPo4b4h8zst97AMkplsLpsonS2wDPTzrIVIP5fumIEf0aTMyJpIpHNuouacGKzslMee0k00mcKSNmUNjcXR1hAoSAmuJnUpBgBOB/C8EGKrECIJ4HcALqnUzq+64zm86+cPmxtlLJ5C/3gCe0ele6OzKYgFKmimO4JEOoORyRSOXdKKh694MZa2RTAWS5nZtE3hQstgIpFB0PEh6PjQFHbUA5tFJOA3+8+v7dMaCZiOvm8wiiMWNrvM5fxZyvGUHJXom68l4mAsni6Y5atHHJoW1Z47nzmAK65/Ar/6x3YAucliRy1qRirj9kOnrJGmTTjgx9rFLThuSSvaGgLGjXDCslbXyLgp5EdzyMFEMm1iGfGU7SbKeItBwGc6Yd1B2p1wQ8DBf77qWFz1hpPwlVcfjyO7m6VlkLRHiNKHvrQtgkQ6i6HJpHnYT1rehktOWoKXrF0EQMYNdJmG257aj/7xBMgjtx0obhkIIXD3M/2mgOBEIm3mNADAqgWNCCk3EeDuFMbjKaQyAu2N8lzbG4Lm+Nqi1JPAtDtwZDJl7pvlHQ3ot8RAp5bqTujAeAILm8OqHQ3oU/Ndrl6/E5+7YRP2jMSwaziGZe1SYJtVB9lnxCA3gNmsrKehvMy7lCubyCOALIQZceuYRMjx461nroTjz2XrLGwOY/9YHCOTKbRGAmZkPxpLoW9wEkcsbHZ1vICMMbyh9wG89vsP4Ntq7Y2cGNgxg0zRmIFsj7YM3L+xK2YQdBBNpNX8kbRxE+k2LWoJoUG1ORKUYqCTKoKOryC1VAe6M1lhLIPJRAaJdGZG63xPh3oVg6UA7Nk8u9R7hv7+fqxbt8786+3tLXvnw5MpjMVzI8X9YwnEU1n0TyQwMJFEZ1MIncrM02KgLYSu5hBaGwJojUg3yoTlJjKWgRnppkyNlaaQY/bVEPSjIehHyPGZzlfTEgmYDnhcma22uZwvBnqErc3SFm0ZWDdwQ9BfkK7ZEglgLJ7Cl296Gr9+cAf++6bNEEJg98gk/D4yaar2iCthjTTzuf79Z+NfX3Ik2huCyArpaz6so9GV/y0tgwCEyFlEk1ZFzolE2nQENiHHZ1wDWgzs84sE/WgMObjkpKV4/WmHoaMhgKHJnJuoKeTguQOy09KppLuHY8YyiAT9uOoNJ5vYQSyVMaO/+7YMYmAiiSWtEQQ8gtvFTPitA1EMRqUfWbuLtKgDwMrORtcI03az6JTmNuUmagr5jZivXdyCBY1Bk0Jr1rWOJc09saw9ggNjcSuALN1EOtNGikHItGMikcbARNJMRHtgy6ASA9mBhgM+BPxkBi5bLbfSMyqLJ7/eVcZkE+XKUbjcRNYaFC1WSmk+3a1hEzNojQQQUX78p/aMIZMVOGJRkxE2zfWP7MLDfcMIB3x4et842hsCZsSf7yZyxQzipS0DjcsyCPkxFJUuTyGktRFyfOb6aheR3l9MuYl8ysrR10BWp824MvO0+EWTabzphw/iSzeVv+5CPr29vaavBNDptU29isGUdHV1Yf369eZfT09P2d/Nz6LRZnL/WEJZBiF0t4YR9PuMLzK/021S7o7xeBohNfo3loF6CCdUNVNAZhvpwF1DyAERobMpVJAG1xoJIJGWMxBlzaNAzjIYi5sOTj/oOsPJWAbhAEZiKVcn3mA9ABotGjrNMJqUls+ekTi6W8LmoXCV+y1iGQDyAfH7yMyuPmFZK5pC0oS2BVOPvPR1zYpcYC6aTHtnE1kjMS0GelKdPD+31dPRGMJwNFeaYEFT0MwwPl5l0OwYmnQ9+AAQCcrziqlrAUhX3ea9Y+hqDmFBo7zGtvVSLLhnT8I7MJZANJHBYksMVnU2uDoVe/SpBx7t6lo2hnJplwuagli7pAWb9owhm82tpeyyDNobVFAzlwpp1kFOZdA/HsfClpwYAPIZ0PfnzU/uw2gshaXKMtCuIp0uOhRNYmQyieFo0qQuF1oGOpvIl5t0JvLdRDoOVEIMWqRloMVAn8dGVZ9ozcImcy4aPcC6aK0sK2HPh7HdRLaQ6zUjbGHKjxnkvw9IcRmMulPQQwEf2huCrkmegLxP9cCgMehIK3rvGL51x3N4Vs3TOU4NVgCgNRJEQ0haBpv3jrkW6JkuPT09pq8E4JlTXq9isBvAcuv1MvVeRRi3xMDvI2P+jidkyYLOpiACfh+OWNRkUhWNGKhOt1kVvNK5yQA8LIO0GYk0hfxmRrOeuahdRc0hx3QMLcpNNKEe8uaQg4XNIRBJN5ERg4zMetF10rUls6glhL0jMVdGRVPI3VkCslMdjCYxPJnCsUtksHzXcAy7h2NY2h4xImaPwIsFkG100POEZW1oCDkQImdd6QAy4B5d6posQqBIzCB3vBYjBsXFrqNRWm3az9zWEEQmK+AjYN0KGTdJpLNYt7LD9b1IQO5H1o3JdW5P7xuX1mKzPrfcAzupSgekMlnXYiUPW2KwdzSGaNJtGazqbHKJqj1A0R2rvpaNQceMiDsaQ1i7pAXP7h9XtW1y39cxA+3e0ckA0k2kMs1iKQxGk+gybiLZWW0byInB7Ztlxc4zVuWuT/7ofUt/FE9bxQfzS7Qby0BlE2WzhTOQc66/wsGKprs1bFJLbTF4YtcoiOSseztYCwB7x2IIOj68TNUYWu4Sg9yzYLv49KCqxXYTBdzZRJp8yyA/MSrkSEv86687Ee8693Dzvh0zaAo7aAkH8Oz+CXzjtmdxvVrq8qTlbWZ7bRnIxJOMmVNTLepVDB4GcAQRrSKiIIA3ALihUju3lX51V6NrVBZPZbFA3VzHLG7JiUHeCLwpLH2FesQCoNAySFiWQdgxAcAG82Crhz3kmJuwVbmJdCfcrCaKLWiUMxpdRc4yWWOea/9yd2vEFYyUx/OwDCKOybQ4+bA2ADIDZfdIDEvbImhSI6j8Co9AYQDZRrfjxGWtZhRm0luVmwgAtg3kgpD2yMrxmnQWyL3n5SbKtwza1XXdMxJHJOBHo/p85YJGV6D57NULXN/THW48JS2DdSvacYlVQlsL7hmHy++1N0iXVyyVwXWP7MKFX7/LdDAbd41gpfLv6zIYOm++JeygvSHg6lRsMdDXQ59rQ8iPBiVUnU1BHLukFamMwKM7c8XjRiaTxjJYpjo/LU4Bh8w12jUcgxAwboxl7RE4akB0YCxu3FGXn70SJ1sF4fT9qa2Vrf0TxkUU8JOrnApQWKhOuolyn2dFrkpoKTfR8vYIYqkMth6YUG4iPZiYwILGEMIBv7EMdExm/2gCbZEAzjmiE+GAzyQIADAuJRlDKUwbbw5PzzLQv4vX55ectNSVdm3EQGXW2WUqrntkF4KOD0d159ra1hBAgyVe+0bj01pZcLrUpRgIIdIA/gXALQA2A7haCLGp9LfK3jfGYmmcf1QXLjtrJY5WlT5tOi0xGFDlpfXNokfzuhTuWCxtHhQvyyAXM8jdZLrT0W6HxpAfLeEA/D5CU8hBIpU1gUF9c3a3hrBvNO4uX5DKYkiNqrWw6GwEIFfQq9HDMmgJB4w4nbxcPvTbhyaxbyzuEgOvVblKWQZdTSH4CDhuWavphLUrqjHoN/vVab2A28VQrpuolBh0NGgxkOmRWgzXLGwy9W8iAb+rs9PvAbJzH5lMoa0hgE+9TKbjrlvRgSVtESxsDuEoFVswyygm09g5JOsdaffSeDyNYxbLe0u7xNobgwg5PqzqbAQRFRWD0pZB0FhyD+bVg0qk5QQ87XfWE8d0ABnIuUS1GDh+Hw5b0IDNe8cwFk/jbWeuwCcvPhqfVGnIGt1hn7i8DY6PsG0giuf7J9ASdrC8o8FYdxq7UJ0pRzEDN9Ea1ZGPJ9Iuy2DH0KSZGa07+IVKbJMZubpbcziAWz7yQvS8MDc6P6q7GTd96FyctbrTNdDR1qstTMViBiErGcPr2Sr2fISD0ooYnEiiMeSYulgLGoMYi6dxxMImBPw+E8uyA+aADMoP5LmkKklx+8yCiFYB+CCAlfZ3hBCvqk6zACHETQBuqvR+4ykZNDp9VQfef/4afO5PTxZsozv8Y5RKb947hoGJhKo/JH98HTMYjaXMTekVMzi8U14uO0tBd06dlrCACGEVd0ikM2Yym7YsulvC2D3itgwSGblcY9DxmY7MHvkubA5j31i8iGWQu+lXL2xCc9jBhu3DyGQFlrTl3ET7xuJ4aNsQTl/VYSo8egVSNW87a6Wq+hjwtAzs0g+Oj5DOCtfMy6ncRK0ebqJIUcsghnDAbzqQIxY1oTEoJ3udtqqj4KHV200m5XU9ZnELFrdGsPGzF6Ex5MfwZApvO3OFmeuxemETNu4alctm6riHtYjJopYwQo7PpGI2qfPXnYAtcmMeYqDjLzrhAJBisGqBDD4/as2rkOIVdAUvddZPOOA3I2rtEtUdJwCs6Woys5oP72rE6087DPk0W/dhd2sYe0ZimEiksaQtguawUzxm4KdcOQrXPAN5zkHHZzpdL9ZYs8NbIwFzn8dTWTNoW2hl7myWk+fNtVuxoBH5rF3SgpDjcw10BrzcREWyiWz3ntezFSoiBrrt/RMJLG4N4xuvPxGjkyl86abNuPnJfWaQ0RB0EE8l0RoJFJQ72TMSLwiYV4qyxADAHwH8GMCNAKqb31RltMmnOxUvE9W2DAApBoPRpHkfkL78RDqLwYmEybwJeVgGuQCyLQbumEFT2IGPCGFVryYrcvMD9EO4sCWMR3aMuBdTT2UxFE2ioyEIUrmHdpCyu1WKgX1sjX3enU1BLGtvwAOqLvuKBQ3mO733bMWOoUk8fMWLjWUQ8hd/eDubQuhcE3Kds7YMmkIOVi5owGtOXYZrN+xCOODHRCLt8rl6ZhMFCi2DiVKWgRKDvaNxrFnYZEZvRyxsBhHh315yJE60fLOasG0ZxFLGJdKq/u9qDqGrOQQhBH7f8wIMTyZx3SO7EU2mze9lyk6ksogE/VjUEjadcmPQwXfedIqp+WSLkR5AhByfySZqCjnw+0gFkPUAQs4n6W4Jm4JrAT9hJCYDyEG/D60R6YIajCZxdHezKwCt06kXWumYRyxqwq1qJb5iHY0evS9oCmKx8uPrOEjQ7ytIkU5a52MmndmWgUotbS3hIgJkB6+tcJl3n/ut9WDKpHFabW+NuCfs5RO0MtSAnJtoKsuAyD0Y8rIMbJG30WIwMJ7Amq4mtIRlltMph7Xj5if34Ug1+NTbtXlcm70jMVdcoZKU6yaKCyG+JYS4Uwhxt/5XlRZVmXzTNPe/Y9wq+iZrbwyiqzmE5w5MYHAiYTpvINfR7R9PmH14xQzs1FKNHQwEZCehJ61p/7geqejvd7eEMRRNum7MRDqLYeXO0CyxUtO0jzq/s9Tnq+lsCmFZe8Tkwp++qsO0d/vgJISQo8zcJKbiloGNPu5+yzIgInz50uPx/vNX40MXrin4znQsA93p54/O7I4uEvCbwLCeafye81bjBYe74wV2e8dispicfV1tiAhnHL7AWD56oRJAzn9IZ6T1GXb8WNQSMsHyxpCDU1e0m5RNrxFke0PQiGM44McbTluO847qKogzdbeGjWgsaYuoGcgZhAJ+EJEJqr5QFUnMdxPZAxt79J2fs6/RneSCxhC6WyPYNxbHvlE5wu1oDBZYBnaygS5HkbYsy6xy19r3oRdEZNYulm4i930LyOt6WEcD1ixsMgJb7LfT5GfE5WIGdgBZbpO2LJqg32cGXkARyyBQxDLQ91c87eoPzlwtV3XTnbzersVyi+mJh/nxwEpSrhhcRUSfI6IziegU/a9qraoi+RNddOfS1RwynbP9oCxplaltQ9Gky8XRpARATw4BLDFQ5Qziqaz50ZvCJSyDkIN3nrsK//7yo82owoiBjhm06BnLuRFYMp3FyKS7Xe0NuYJ5OnulsYRl0KJqKukMlFedtAQB5WO2J1pt7Z8omVrqhRFMlb+uR1GO34dPXHw0zlpdmO5cbJ4BIIVCB9SkiyKMU1e040RVilnT1hA0wVtZUiGAoN9XUEMpHz0S1GUfWhtKjy51RxBNuC0Dvb5yJOgz7pig48PqhW6Xhdd1tDuxcMCPK//5eFxw1ELze+g4gm0BLmuPmHkGep86qHrOmk5XW7cPThYEr90B1iJioO5fYxmMyAmai1rCaG8MYngyid88uMO4xBL2vZJnGTg+H7JZmU1UKnica19ODGyXYKfV1ts++kK885xVJUfVNvkuQq9gdthjhJ8v4I0eA61ibqKwK9aQeyaPW9qKBz51oRmg6P6hNZJztR7WIddvLnf9jJlQrpvoeABvBfAi5NxEQr2eV+TPZNW1SDoagwg6flNqWbOoJYy+wSgGJ5KuVERb2fU+iAjhgM815bzRwzIwmSGNuZHNKYe145TD2vHbh+Qi23pNBT1SWaQe/m1W+YpEOoOhyaRZ7lK3YXFrGH2Dk6bD8LIMbBEEcpNjXn3KMrOfJpXWBsjUw6Ay+b2KyXmhz12PuvLdVfm+fgAIeM5Altvpss+ahoCDq997puexT1/Vgb7BSYQCPrz1zJU4/6iFJX3TgDyvoOMzWR5TdSha3KKJjMnqsiuORgJ+Mw/hsrNWFrhgvAKNWtg7m0KmjAEgA58nLG01195OU13W1oD1fcOmLg4gXSZBx4fTVXqovgcmEmkTgNas7moCEUCAyaTLR3eSnU0hdLeEzci/uyWM8XgaqYzAp69/AqeuaMcf3neWcVkRydRSWOUoAn4ybiJ7IFMMbbnYI2XdFo0eREUCsnTJlJaBx7UnApqskb6uq2S7MYN5AtFgPd8JNaN5KjcR4B4cAu7f0whaQ8AMXhe1yPTyaqaXlisGrwVwuCoNMa/ROcN6pKNdPO0NQUSCuXVQNYtawqr+irucgG1O2n7P5nBArR6VW+cAKOImasqllmr0qGIwmoSPcg+xtgzsCpqJdNZkvdgsbo2gb3CytGUQdovBa05dhiMXNbsmvTSGcmKwpT+K1QsbC8zkUuhMiP1jcfiosCRG/mvAW2j0NQmrWduaUllNp69agKvX78Ku4RhaIwG0WudVioag30xamqpD0ecXTaZNxcmoNaM6FPDj1acuw4btw3j/+asLvu/Vfm35vfvcVa5O5fKzV+Hys1eZ191WAHhpe8TU1tFi+Y5zVuFFx+QE0BZee56E/kyX6Sgm9LrTXtQScrkqu1vDcPzJgu10jR5Aiow96Szo+JDJAhPJlKnoWYrTVrYj6PdhxYJGBPxyNnQqI4w718aMqqew6ryufXPIcc3UJyKEHb8rTpc/6tfHaw47cFKEkclU8QCy9Ru89Njuom3ThSSbQo65xxa1hOH4CisWVJJyxeBJAG0ADkyxXd2T7ybS/3c0BvGy4xebSVya7taw6RBtMXBZBmFbDByMxdJmZmhznpvI8eVSChc0BtEUclzpoLoDGJyQC9bojtd++P0+MiUe8t1EALC4LayKeikx8IoZRHIBSUC6EfL96E1hBxiTx9s2MIHlHZGyXUQAjEsnmsyg2ToX87mXZVDCTRQO+FwdZKmsJj1hyqsiZykiAb9xE7VNEYTUImsXBhyPuy2DV5ywBK84YYnn9/V56SUSAeAVJyzGD+7Zije/YEXJY2urL+T4jLuxfzxhrKjTV3UYqwDITXQE4BmAPHFZm5lL48VL1i5C71tPxZqFza603u7WsCswrIPuyXTW3Of55Sgcnw9CaDfR1F3QqSs68OR/vtTsLxLwI5VJuywDTbhcN5HHfeblsgopS9+8LiIGOtg/MpkyqaH56MHPkYuaSgaBG4Jy3hFRzi26qCWMSMCP21SgvxqUKwZtAJ4moocBmDummqml1SI/gKxH9e2NQbMimY3tQ7VN6KYSloG9noDuMLQo2KODcMCP2z96nqszN5bBRNI1AaYl4iAckCt+tUYCcrWt8QSyIlfDRnPOmk70jyeM9dJQhmXghW77qYe149Gdw4inMp51iYoR8MsyHcl01jV5RuPltik1zyAS8LtGdKUsAxMDOdG7Iy5GJOg3ayJMZRnojsBeHEa6ibKmvaXQ7V/SGjZi8K8vORIfvejIoq4GTXerLiLnGNHaPxbHEdbaDDZ2LOak5e0Fn3/51ccXlEaxCTl+XKRGs/kVYu1V2WLqb1sM8tdADjhyMCPXYZ46ZgAUri42FvcWg4jlby93f5pmj7bIuEHKVNvN/54euTeHHWNVFfvt1i5uwRcuORaXnLTU83PNScvbICDMebRGAji6uxkHxhMYjCYLaihVinLF4HMVP3KNGI2lXJ1KuyqTu6TVO6XO9uUVtQysG69F1yxK5LmJdMecNxrubvX2Iw+oNQo0RDKdsG9wEm1KDHRgtqPRfWNcesoyXHrKMkQTaZy1eoEpXW0TDvjxxtOXm0qdXmgBO++oLjzUN4Qt/dFpWQYAcHhnI57eNw5Zu9KNTju0fbKebqJAbkToFoPiHSYR4ekvXjzt9tod+FRiEFL1mOx1mKOJtBlJThWjOGpRMw7vbMRxS1uxcdeo2Wc5bjhtKTaFHNPO4RIuChs7e0jj1REWo6s5BL+PEPDLUujHLWnBx196FH738A7ElEWczNhiICedaQsi6PdhIpFGJivKCiDnk5+A4fVZOb+dRrudvDKb9L3X1hAwdchcxwtpN1FAxkZQPIDs8xHedubKku0CgHdbk+RCjh8PfvpChBwfbtkkrYK+gahZv7qSTHnnqLUFfmCnlM7v1FL3AhZNIQd//uC5eO265Z7bL7LcMy7LIORtGbTkWQbGIgj4VQygtP5qK2EwmnTFJey26AdIl1nOtww0jSEHv3n3CzwffgD470tP8Mzo0TSFHEQCfpyq6vlsG4iWnVaq+cIlx7naakNELvcFgKJrIAOyc3XFDKbo6MOBwmqtU2G747zmZ9gQkYox5MRgIpHJuYmCpdt3xKJm/O1j55uCcNOJx+gOuSnsuO6/csSg3ASAUt9f1CwDyURy6dAPXLAGi5rDJnc/aWU26cOlTQA5N+FrKuvJi0hQrmzn5VLMuYnKjxloC9hLmHRGkd5f/qg/6PfB8RGaw7m6W1NZddMlrNKFdZLHdF2f5TKlZSCEyKgVxw4TQuyoSivmEC8Ty64Hko89kcUeiehUPyHcMYOWiONaaUzfIERkOtdSHLmoWS6UnskWdEbaitAP/75R6VromCJYNlPOXrMArZFATqAmEq4qjOVw+qoOfO6Va4vWM4qolZy0O8lfwk0UnoabaKZc+c/HI/WHxyGEKKtjbgw6rgJ107EMNPqemM75+H2Ehc0hl2Uw1T6+/toTXfNQZkN+CW5A/pY6npC0Mpu0VZixxEC7lsoRr3wagn5PF5H+DMhNFCyGPZBoCjkYmfR2vdiWgf1aQ5QTZJH3nUqj17LoGyhcprQSlOsmagewiYgeAmBkaT7GDOzCcuWgffWJdNa1DKHu3GWZ6dxlbA7LNX7zU0sBedN5BU1tgo4PRy9uxuO7RgtMdz1q1TemdhPlL49YKd6qTFpd5z4rShepK4adBZOP7jDbGwLYP5bwTi21Aod6gXUhZtaRTEV3axi/eMfpZW/fGPJjS7+8Pgsag4gmcwHkaooBAJy2sgOdTSGXZVhqVPrqU5dNa/+l+ObrT/JMCNClRxIelkHKmnSmU1Nn0nGes6bLFdS10RZ48xRWnX2t9aAr3xIHcpaBthq8rNFvvO5ErOpswg/u3lJ0m0oQDvixpDVsJg5WmnLF4DNVOXoNGIunplXbg4iwSOVS55vX+oazXRHNIQdxVSYCcC+m0RR2PHPr8zluaasSA283kRYzHbhsb6x8MMnGq8Z7pYgYMQhi/1jCc9KZvQgNESHol+JcDctguqxb0WEK0S1Vs7jtbKJy0KIx3U7kW288GYCs+6PrPFWrI8rHrm2kabCW1swPIAO5pTDtAcVMXCoffvERRT9bsaARaxY2Teke9BKDYtlEgMzIC/p9nuL1oqNl3K05LEvRT9c1OR1WdTXWzk0EAEKIu4loEYDT1FsPCSHmZZppd0vYs3hVKRa1hBHwF06xaAo7niuIAbKj1vnCmnedc3hZqXR6Na5iE1N02txgNIGg3zelb3u2hAN+U353JpZBKfIDfsXWQNbtkK+lGJRKLZ0rXnZ8N36/ficAeW9tG4iaeQblWgbmvGboXiCSiwoNTCSr5qIoh0jQb2IGiUwWrcGAaR9gWwa2GFS2ve8973C8+9zilqjG5SYyc468is7lrLZwwFdSbN98xoqqBHZtVi5oxJ8f31uVfZdbtfR1AP4HwF2Qc0i+TUQfF0JcW5VWVZEfvf20qTfK493nHu5aWUvTFHIK6u/r0fzW/okCv+brTvMOUuejxSDfh6ktg0aV05zJCnS3hssOOs6GtoYAYqOZio/Gw5ZlABRLLc3NMwB0FlEawRIF8+YKOwDfHA6omEF5qaUabS3OZlTfGpFiMFeWgReRgD+XTWS5iXKWQWHV20oHW2VAe+rnoVzLQN9zIcePzuaQqYjrxcrORrNyXLVYpZYpna67uxzKHVJeAeA0bQ0QUReA2wHMOzGYCcXSLy86tttUZ9ToDvyZ/eMFNXPK5ajuZly0dlHBJDBdp745HDDrAi8ukhJbaVojAewdjVfcMogYy0CJgWc2UW6egXytRaH2bqKg48O5R3Tiuf0TaA47LjdRuaPemcYMbEx9rBpaBg1BPyZTGQghkExnTFt8xjLwcBPVqL2eYjCFZfCLd5w+rRTcavDmM1bg7WetrPhzCJQvBr48t9Ag6nRhnLnkvecVlhjQlkE8lZ1x5kbA70Pv29YVvN/dGsbPLj8N61Z24Ku3PI3JZKZi2SFTod041XITtZdyEwV88BGs1L36EQMA+PnlMuD89dueQTSZQSwlSzGU6zvOWTwzPx8tppUeaU+HiFq8JZHOyjpJ2jJQnxs3kVM9N1G5hDzFoJRl4DPVZmtJOTHHmVKuGPyViG4B8Fv1+vWowsIzBwP2yMEuM1Epzj9qIYDczTxXlkEuz7rybiIf5a6bdwDZjx9fdpqxtIJ1Jga6028MOchkBUYnU9N6aCMzDCDb6DhSLa+JnjMSS2YKylEAVgDZVz03UbloFyNZ9b88A8jO7K22+UJJMSCikBAiIYT4OBFdCuAc9VGvEOL6ajSIiP4HwCsBJAFsAXC5EGKkGseqBnaA2J62X2n0Tbp4zi2DysYn5CpejhmBFdv/BUoEgdyDGaqhf9wLPcIcmEhMazJVuBJuIp0HX8NOSwvgZCqTNwNZfj4XAeRy0ZMnA36fqedU2jKofXyq2kxlGTwA4BQi+qUQ4q0ArpuDNt0G4N+FEGki+gqAfwfwyTk4bkWwLYOlVeyo9UNUrIxGpdGdTaVHSG88/TCcsKzNBBfLmR1bb24ijU4jHphIlJ1JBOQ60dl0ONpyq+U10UtrxpLpvABy3qSzKk8cLAfdtqDfZxa28pqoxpZBjiARvQnAWcoycCGEqLg4CCFutV7+A8BrKn2MaiKrc8pJUYur4CbSBI2baI4sA9XZVDpmcOySVhy7pBXXPbILgLebKB997tUIos2GRmMZJKdVcyc/MD4TzAzZGo5gtZtoUrmJcgFk+XkqW7g4Uq0sg9w9RLj0lGVYu6TFMzvHWAZ1dq9Vg6nE4L0A3gxZtfSVeZ8JVN9SeAeA31f5GBXF58stClPN4K6xDKooODZtVbIMNHok7TUDOR8zqquz0ZpOHuifSJh1jsuhEm6iav8+5WAvoCMnwCm/vPo8k/FILZ1BbaJKYA8o5HKkHZ7b6eeslllac0VJMRBC/B3A34lovRDix5U6KBHdDsBrdYcrhBB/UttcASAN4Nde++jv78e6dbmMm56eHvT09FSqibOiOexAwNsHWSlCjpwIVulc42K0lZiOXwn0Q1eOm6jeAsgaPSkwmc5Oy03k98lZ1bOdZwDUR8xAL/RjAsjqN7UL1Wlqlk2khGoq63Kms8Prjd7eXvT29uqXntUpy80m+h0R/QeAw4QQPUR0BICjhBB/nknDhBAvLvU5EV0G4BUALhRCeBZZ7+rqwvr162dy+KrTEgkUzB6uNOGATy1iMzezcKsVM9AYy6CMh874cevsAV3WHoFPrfc73WqcTWHHc82HcjmsowE+mrvsMi+MGMTcYqDv0LRyE2lXoI+8U4nnAttNVAptEcx3y8AeLBPRgNc25fZYPwGwAcBZ6vVuANcAmJEYlIKILgbwCQDnCSGqU56vyhyzuKXqHdX7zl9jiuHNBdWKGWi0b3Y+WwYhx48lbRHsGo4hPM188O+86WQc1jHzPPbDu5qw/j9eUtaawtVCr+09ki8GasCSzgiQJQAhxz9ng5l8yo07hc3Ag7OJNKuFEK8nojcCgBBikqr3K34HQAjAbeoQ/xBCvLdKx6oK//v6k6p+DHtJw7mgWpPONI3Wug9TYVJL60wMAFk7ZtdwzHQi5VJqXYlyqaUQADnLYES5icwayNZ6Bn4iE1Cu5Wjb7yO1QE/pNoQqMCFwvlCuGCSJKAIZNAYRrYa1/GUlEUKsqcZ+mdnR2RTCsUtasHZJS1X2f9SiZnzrjSfjhR5Lj+ZTr6mlgKw5//fnp17Y5mCkwYiBLOqofyefsQyy8PnIxBBqLeZBv2/KZVxPW9mBd56zCicsa52jVtWOcsXg8wD+CmA5Ef0awNkALqtSm5g6JOj48JcPnVu1/RNR2esV12tqKSAtA2BmK3jNd/Q5a8sgmF+OQlkGfsq5iWpJ0PEhOEXMoDkcwGdesXaOWlRbyi1hfSsRbQDwAsjf9sNCCM8gBMNUm1CdppYCudWoppNNdLDg8xFCjq8ggGzKUWQE/D6acq3guSLo+OpyQFEryi1hfSOA3wC4QQhRnZUVGKZMQnWc7qdLGB+KYgBIV1FhAFl+ls5m4aNcqmmtM3SCfhYDm3KvxNcAnAvgKSK6loheQ0S1y2FjDmmaw3I9h2pWcJwpKxY04OjuZqxdXJ3YSr3TEHQwamIGuhhcbnEbv4+gPTO1dhOF2DJwUfZKZwDuJiI/gBcBeDdkuumhecczNeXVpyzDMYtbqr7C20wIOX789SMvrHUzakYk6MeekRgA200kP0tns/D7fCZ9uNZuojMO78DyWaTzHmyU/TSpbKJXQpavPgXAz6vVKIYpRWPIwWkr5za1limPxpBjlr7MX+ksnRHw+3KWQq3F4L8vPaGmx683yo0ZXA3gdMiMou8AuFsIkS39LYZhDjUWt4SxUf2dH0DW8wy0ZVCPCQCHMuVaBj8G8EYhRKaajWEYZn5jF2fMH/mnswI+X/2kljJuyo0Z3EJExxHRWgBh6/1fVK1lDMPMO+wqul6Tzvw+Mm6jWruJGDfluok+B+B8AGshl7t8GYC/A2AxYBjGYC/oVJBaqrOJ6iS1lHFT7q/xGgAXAtgnhLgcwIkADv752QzDTIslHmKgLYNUNgvHFgN2E9UV5YpBXAWM00TUAuAAgOXVaxbDMPMRlxjklaNIZwR8RHWTTcS4KTeA/DARtQH4IWQp6wnI9ZEZhmEMC6zKqY5JLdWTzrJw/A4HkOuUcsWgBcBrAdwFmV7aIoR4vFqNYhhmfuLzWI/CrIGc0aml8jXHDOqL6aSWngvg2wBWA3iUiO4RQlxVtZYxDHNQYBa3yWbrqlAd46bc1NI7iegeAKcBuADAewEcC4DFgGEYF00hBxPWKny+vGwiH7uJ6pJyU0vvANAIGSe4F8BpQogD1WwYwzDzk7s+fj4GJ5LmNRk3UdadWsqWQV1R7q/xOIAkgOMAnADgOFWriGEYxkVnUwhHdTeb12SVo3B8vropYc24KevXEEL8qxDihQAuBTAI4KcARqrYLhDRvxGRIKLZLw7LMEzN0CHljCpHYdZAZjdRXVGum+hfIAPIpwLogyxffW+1GkVEywFcBGBHtY7BMMzcoGMEAOSkMw4g1yXlZhOFAXwDwAYhRHqqjSvA/wL4BIA/zcGxGIapIpYWwEeEVV2NOLyrEasXNtWuUUwB5WYTfa3aDdEQ0SUAdgshNhIV5iwzDDO/yLcMFrdG8Ld/O792DWI8qclSUUR0O4Buj4+uAPBpSBdRSfr7+7Fu3TrzuqenBz09PRVrI8MwlcEe0vk9JqUx1ae3txe9vb36pWcctiZiIIR4sdf7RHQ8gFUAtFWwDMAjRHS6EGKfvW1XVxfWr19f9bYyDDM7bAufxaA22INlIhrw2qauFpEVQjwBYKF+TUR9ANYJITwbzzBM/WP3/ywG9QuH8xmGqSpsGcwP6soyyEcIsbLWbWAYZnbY/b/DYlC3sGXAMExVcaWWshjULSwGDMNUFcpLLWXqExYDhmGqit39+3juUN3CYsAwTFXJn3TG1CcsBgzDVBXi1NJ5AYsBwzBVxceppfMCFgOGYaoKcWrpvIDFgGGYqkJWCJlTS+sXFgOGYaqKz+pl2DKoX1gMGIapKmwZzA9YDBiGqSpcjmJ+wGLAMExVyV/pjKlPWAwYhqkqXI5ifsBiwDBMVXGtdObnLqde4V+GYZiq4pp0xm6iuoXFgGGYqsKTzuYHLAYMw1QV2zLg1NL6hcWAYZiqwpbB/KAuxYCIPkhETxPRJiL6aq3bwzDMzCG2DOYFdbcGMhFdAOASACcKIRJEtLDWbWIYZubwpLP5QT1aBu8D8GUhRAIAhBAHatwehmFmgascBWcT1S31KAZHAjiXiB4koruJ6LRaN4hhmJnDlsH8oCZuIiK6HUC3x0dXQLapA8ALAJwG4GoiOlwIIewN+/v7sW7dOvO6p6cHPT091Ws0wzAzw17pzM9iUAt6e3vR29urX3Z6bVMTMRBCvLjYZ0T0PgDXqc7/ISLKQja+396uq6sL69evr25DGYaZNTzprPbYg2UiGvDaph7dRH8EcAEAENGRAIIAPBvPMEz9Y3f/7CaqX+oumwjATwD8hIieBJAE8PZ8FxHDMPMHnnQ2P6g7MRBCJAG8pdbtYBimMvCks/lBPbqJGIY5iOBJZ/MDFgOGYaoKp5bOD1gMGIapKrZl4GcxqFtYDBiGqSp2/89iUL+wGDAMU1XschTsJqpfWAwYhqkqdjYR1yaqX1gMGIapKu7UUu5y6hX+ZRiGqSruSWc1bAhTEv5pGIapKu5yFNzl1Cv8yzAMU1V8nFo6L2AxYBimqhCnls4LWAwYhqkqPOlsfsBiwDBM1dEawGJQv7AYMAxTdbR1wJPO6hcWA4Zhqo7WAJ50Vr+wGDAMU3V0SQq2DOoXFgOGYaoOkfzH6xnULywGDMNUHSLAzy6iuqbuxICITiKifxDRY0S0nohOr3WbGIaZHT4iziSqc+pODAB8FcB/CiFOAvBZ9ZphmHkMgdNK6x2n1g3wQABoUX+3AthTw7YwDFMBfETuIkVM3VGPYvARALcQ0dcgLZezvDbq7+/HunXrzOuenh709PTMSQMZhpkeHDyuLb29vejt7dUvO722qYkYENHtALo9ProCwIUA/lUI8Qcieh2AHwN4cf6GXV1dWL9+fXUbyjBMRSAiTiutIfZgmYgGvLapiRgIIQo6dw0R/QLAh9XLawD8aE4axTBM1fARTzird+oxgLwHwHnq7xcBeK6GbWEYpgKwZVD/1GPM4N0AriIiB0AcAAcCGGae4yPA72cxqGfqTgyEEH8HcGqt28EwTCUhnnRW59Sjm4hhmIMMH/E8g3qHxYBhmKpDLAZ1D4sBwzBVR5aj4O6mnuFfh2GYqiPLUdS6FUwp+OdhGKbqEFsGdQ//OgzDVB2fjxe2qXdYDBiGqTrEqaV1D4sBwzBVh1NL6x8WA4Zhqg7x4jZ1D4sBwzBVh+cZ1D8sBgzDVB1e6az+YTFgGKbq8BrI9Q+LAcMwVWdRSxiLW8O1bgZTgrqrWsowzMHHj96+jhe3qXNYDBiGqTrhgL/WTWCmgN1EDMMwDIsBwzAMw2LAMAzDoEZiQESvJaJNRJQlonV5n/07ET1PRM8Q0Utr0T6GYZhDjVpZBk8CuBTAPfabRLQWwBsAHAvgYgD/R0QVjzz19vZWepd1D5/zocGhds6H2vkC1TvnmoiBEGKzEOIZj48uAfA7IURCCLENwPMATq/08fkGOjTgcz74OdTOFzjIxKAESwHstF7vUu8V0N/fj3Xr1pl/h+JNwTAMUw69vb2mrwTQ6bVN1eYZENHtALo9PrpCCPGn2e5/x44dAzt27NiuX7/nPe/Be97znnK/3klEA7NtwzyDz/nQ4FA750PtfIHZnXPR71VNDIQQL57B13YDWG69Xqbe89p/10zaxTAMwxRSb26iGwC8gYhCRLQKwBEAHqpxmxiGYQ56apVa+s9EtAvAmQD+QkS3AIAQYhOAqwE8BeCvAD4ghMjUoo0MwzCHErXKJrpeCLFMCBESQiwSQrzU+uxKIcRqIcRRQoibZ3oMIlpORHcS0VNqTsOHPbYhIvqWmtfwOBGdMtPj1QNlnvOb1bk+QUT3E9GJtWhrJSjnfK1tTyOiNBG9Zi7bWGnKPWciOp+IHlPb3D3X7awkZd7XrUR0IxFtVNtcXou2VgoiChPRQ9b5/KfHNiEi+r3qvx4kopWzOqgQ4qD8B2AxgFPU380AngWwNm+blwO4GXLtjRcAeLDW7Z6Dcz4LQLv6+2Xz+ZzLOV/1mR/A3wDcBOA1tW73HPzGbZDW9WHq9cJat3sOzvnTAL6i/u4CMAQgWOu2z+KcCUCT+jsA4EEAL8jb5v0Avq/+fgOA38/mmPUWM6gYQoi9QohH1N/jADajME31EgC/EJJ/AGgjosVz3NSKUc45CyHuF0IMq5f/gAzSz0vK/I0B4IMA/gDgwBw2ryqUec5vAnCdEGKH2m5en3eZ5ywANBMRAWiCFIP0nDa0gqg+aUK9DKh/Im+zSwD8XP19LYAL1fnPiINWDGyU+XQypLralD2vYb5R4pxt3glpGc17ip0vES0F8M8AvleDZlWVEr/xkQDaieguItpARG+b88ZViRLn/B0AxwDYA+AJAB8WQmTntnWVhYj8RPQY5CDmNiFE0f5LCJEGMApgwUyPd9CvZ0BETZCjwo8IIcZq3Z65oJxzJqILIMXgnLlsWzWY4ny/CeCTQojsLAZNdccU5+wAOBXAhQAiAB4gon8IIZ6d42ZWlCnO+aUAHgPwIgCrAdxGRPfO52deyOSZk4ioDcD1RHScEOLJah3voLYMiCgAefP8WghxnccmZc9rmC+Ucc4gohMA/AjAJUKIwblsX6Up43zXAfgdEfUBeA1kvav/N3ctrDxlnPMuALcIIaJCiAHIGmDzNlEAKOucL4d0jQkhxPMAtgE4ei7bWC2EECMA7oSs12Zj+i8icgC0Apjx83zQioHynf0YwGYhxDeKbHYDgLeprKIXABgVQuyds0ZWmHLOmYgOA3AdgLceBCPFKc9XCLFKCLFSCLES0q/6fiHEH+eulZWlzPv6TwDOISKHiBoAnAHpZ5+XlHnOOyAtIRDRIgBHAdg6Ny2sPETUpSwCEFEEwEsAPJ232Q0A3q7+fg2AvwkVTZ4JB7Ob6GwAbwXwhPK7ATLj4DAAEEJ8HzK75OWQBfEmIUcX85lyzvmzkH7F/1Nuk7QQYl3hruYF5ZzvwcaU5yyE2ExEfwXwOIAsgB9V070wB5TzO38RwM+I6AnITJxPKqtovrIYwM9JVm32AbhaCPFnIvoCgPVCiBsgBfKXRPQ8ZMD8DbM5IM1CSBiGYZiDhIPWTcQwDMOUD4sBwzAMw2LAMAzDsBgwDMMwYDFgGOYggYheq4q6ZYmoaIYcEf2EiA4Q0ZN57/8PET2tCjler1M71WcnENEDav9PqEJyDUT0F/WdTUT0ZWv7y4ioXxULfIyI3mV99hUielL9e731PhHRlUT0LBFtJqIP5bWv7GKLRPRhtf9NRPSRqbYHWAwYpihE1EZE71d/LyGia2vdJkZCsirrz/LefhLApZCT7ErxMxRO4AKA2wAcJ4Q4AbIY3r+rYzkAfgXgvUKIYwGcDyClvvM1IcTRkCUyziail1n7+70Q4iT170dqX/8E4BQAJ0HO//gYEbWo7S+DnER2tBDiGAC/s87XD+ArAG6d4txARMcBeDfk+vEnAngFEa2Z6nssBgxTnDbIypAQQuwRQszr8tcHO0KIzUKIZ8rY7h7IvPz8929VNX4AdxHHiwA8LoTYqLYbFEJkhBCTQog71XtJAI9g6sKPawHcI4RICyGikHNBtDC9D8AXdE2lvAKDnsUWiejjRPSwsmZ0metjIKsRT6rzuRtSJEvCYsAwxfkygNXKzL9GuxWUC+CPRHQbEfUR0b8Q0UeJ6FEi+gcRdajtVhPRX0kWi7uXiI5W779WmfAbiWiqUSxTG96BXBHHIwEIIrqFiB4hok/kb6xcSq8EcIf19qtVJ30tEemyNxsBXKxcTJ0ALkCuJM5qAK8novVEdDMRHaH27VlskYguglwN8nRIS+NUInohpIV0LhEtUDPQXw532R1PDuYZyAwzWz4F6TY4iWS1zD9bnx0H6RoIQ85g/6QQ4mQi+l8Ab4MskNcL6Vp4jojOAPB/kIXUPgvgpUKI3bZfmpkaInoQQAiyTHWHNSP5k0KIWyp0jCsgy1//Wr3lQBZ0PA2yUsEdRLRBCHGH2t4B8FsA3xJC6BIYNwL4rRAiQUTvgSw1/SIhxK1EdBqA+wH0A3gAgF7NMQQgLoRYR0SXAvgJgHNRvNjiRerfo+p1E4AjhBD3EJF2KUUhC/hNuWIkiwHDzIw7VW39cSIahXz4AVk++QSSFTbPAnCN9QCH1P/3QZZOuBqyThRTJkKIMwAZMwBwmRDiskrun4guA/AKABdadX52Qbp2BtQ2N0H6/bUV0AvgOSHEN6122gXjfgTgq9ZnVwK4Uu3rN5DxCX0cfT9cD+Cn6m9dbBEAOgG8nIjSkGU3/lsI8YP88xBC/BiyXAWI6Etq3yVhNxHDzIyE9XfWep2FHGT5AIxYAcSTVFAQQoj3AvgPSNN9AxHNuAY9UzmI6GIAnwDwKiHEpPXRLQCOV64dB8B5kCvJgYj+C7Ja6Efy9mUvkvUqqEKBJNcoWKD+PgHACcgFhf8I6TaCOsazQMlii7cAeIcaeICIlhLRQvW3/v8wyHjBb6Y6fxYDhinOOOQyi9NG1dHfRkSvBUza4Inq79VCiAeFEJ+FdBVM6c9lpoaI/pmIdgE4E8BfiOgW9f4SNZrX2/0W0j1zFBHtIqJ3qo++A/l736biRN8HACFXBvwGgIchXS6PCCH+QkTLAFwBGRR+hNwppB9SaZ0bAXwIMlMIkCuW3UtET0FaFG+xgtZfhowzPAHgvwGYdFQvhBC3QnbyD6jvXIvc/foHdYwbAXxAlcEuff24UB3DFEeZ8SdAjuyOEUIcp1wJ64QQ/6K26VOvB+zPiGgVZNBvMWQn8DshxBeI6DrIwB9Buho+MpvSwwxTCVgMGIZhGHYTMQzDMCwGDMMwDFgMGIZhGLAYMAzDMGAxYBiGYcBiwDAMw4DFgGEYhgGLAcMwDAPg/wPyU2BmR98e4AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(times,whitened_signal_td_array[0][0])\n", + "plt.title('whitened Korean BH encounter waveform')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "\n", + "f1 = h5py.File('data_0.h5py','r')\n", + "name_list=[]\n", + "#shape_list=[]\n", + "#type_list=[]\n", + "data_set_list=[]\n", + "\n", + "for name in f1:\n", + " name_list.append(name)\n", + " #shape_list.append(f2[f'{name}'].shape)\n", + " #type_list.append(f2[f'{name}'].dtype)\n", + " data_set_list.append(f1[f'{name}'])\n", + " #print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "m2=total_mass/(mass_ratio+1)\n", + "m1=total_mass-m2" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01],\n", + " [ 1.41176471e+02, 8.82352941e+00, 4.00000000e+02,\n", + " 2.20000000e-01, 1.54000000e+00, 8.90000000e-01,\n", + " -9.40000000e-01]])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_data_sum = np.zeros((num_samples,7))\n", + "for i in range(num_samples):\n", + " x_data_sum[i] = [m1,m2,distance_set[mass_ratio],0.22,locations[2][i],locations[0][i],locations[1][i]]\n", + "x_data_sum" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(num_samples):\n", + " \n", + " with h5py.File(f'data_20211013{i}.h5py','w') as f1:\n", + " \n", + " for k in range(len(name_list)):\n", + " d = f1.create_dataset(name_list[k],data=data_set_list[k])\n", + " \n", + "\n", + " \n", + " del f1['x_data']\n", + " del f1['y_data_noisy']\n", + " \n", + " \n", + " d1 = f1.create_dataset('x_data',data = x_data_sum[i])\n", + " d2 = f1.create_dataset('y_data_noisy',data = whitened_signal_td_array[i])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} -- GitLab