From fde8a5ca7c19d945f5f4a8a290f72004756577a0 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 27 Apr 2022 23:11:56 -0700 Subject: [PATCH 01/94] setup branch and notebook --- templates/example_MPH_plots.ipynb | 62 +++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 templates/example_MPH_plots.ipynb diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb new file mode 100644 index 00000000..25d5c226 --- /dev/null +++ b/templates/example_MPH_plots.ipynb @@ -0,0 +1,62 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", + "metadata": {}, + "outputs": [], + "source": [ + "import sys \n", + "sys.path.append('../') \n", + "\n", + "import os\n", + "import shutil\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "\n", + "from mibi_bin_tools import bin_files\n", + "from ark.utils import io_utils\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "toffy_env", + "language": "python", + "name": "toffy_env" + }, + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 993c1a33e8c99c625b09b690a2811f62ef5527e0 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Fri, 29 Apr 2022 14:40:52 -0700 Subject: [PATCH 02/94] it works --- templates/example_MPH_plots.ipynb | 94 +++++++++++++++++++++++++++++-- 1 file changed, 89 insertions(+), 5 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 25d5c226..af259f3e 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 98, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -23,19 +23,103 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 99, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# set up directories for current run\n", + "base_dir = os.path.join('..', 'toffy', 'data')\n", + "run_name = 'tissue'\n", + "run_dir = os.path.join(base_dir, run_name)\n", + "plot_dir = run_dir\n", + "#plot_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\qc_metrics', run_name)\n", + "#if not os.path.exists(plot_dir):\n", + "# os.makedirs(plot_dir)" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 100, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# compute pulse heights of run files\n", + "target = 'CD8'\n", + "total_counts = bin_files.get_total_counts(run_dir)\n", + "\n", + "# compute pulse heights of run files\n", + "for i in range(1, 3): \n", + " pulse_height_file = 'fov-{}-pulse_height.csv'.format(i)\n", + " \n", + " if os.path.exists(os.path.join(run_dir, pulse_height_file)):\n", + " pass\n", + " else:\n", + " print(f'\\r{i}...', end='')\n", + " median = bin_files.get_median_pulse_height(run_dir, 'fov-{}-scan-1'.format(i) , target)\n", + " count = total_counts['fov-{}-scan-1'.format(i)]\n", + " #median = compute_pulse_height(run_dir, 'fov-{}-scan-1'.format(i), 98, 97.5, 98.5)\n", + "\n", + " out_df = pd.DataFrame({\n", + " 'fov': [i],\n", + " 'MPH': [median],\n", + " 'total_count': [count]})\n", + " out_df.to_csv(os.path.join(run_dir, pulse_height_file), index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", + "metadata": {}, + "outputs": [], + "source": [ + "pulse_heights = []\n", + "fov_counts = []\n", + "for i in range(1, 3):\n", + " temp_df = pd.read_csv(os.path.join(run_dir, 'fov-{}-pulse_height.csv'.format(i)))\n", + " pulse_heights.append(temp_df['MPH'].values[0])\n", + " if i>1:\n", + " fov_counts.append(temp_df['total_count'].values[0] + fov_counts[i-2])\n", + " else:\n", + " fov_counts.append(temp_df['total_count'].values[0])\n", + " \n", + "combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts})\n", + "combined_df.to_csv(os.path.join(plot_dir, 'total_count_vs_mph_data.csv'), index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#fov_counts = [72060, 145200, 224373, 314438, 372791]\n", + "#pulse_heights = [2222, 3800, 4372, 5273, 5908]\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use('dark_background')\n", + "plt.title('FOV total counts # vs median pulse height')\n", + "plt.scatter(fov_counts, pulse_heights)\n", + "plt.gca().set_xlabel('fov total count')\n", + "plt.gca().set_ylabel('median pulse hight')\n", + "plt.gcf().set_size_inches(18.5, 10.5)\n", + "plt.xlim(0, max(fov_counts)+10000)\n", + "#plt.xlim(min(fov_counts)-10000, max(fov_counts)+10000)\n", + "plt.savefig(os.path.join(plot_dir, 'fov_vs_mph.jpg'))" + ] } ], "metadata": { From 6b67313ab453dae1beb9588abbe29c2efc215cbc Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 4 May 2022 19:41:34 -0700 Subject: [PATCH 03/94] format and comments --- templates/example_MPH_plots.ipynb | 103 +++++++++++++++++++----------- 1 file changed, 67 insertions(+), 36 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index af259f3e..1afcbd79 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,83 +2,115 @@ "cells": [ { "cell_type": "code", - "execution_count": 98, + "execution_count": 28, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], "source": [ "import sys \n", - "sys.path.append('../') \n", - "\n", + "sys.path.append('../') " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", + "metadata": {}, + "outputs": [], + "source": [ "import os\n", "import shutil\n", - "\n", "import pandas as pd\n", "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "\n", - "\n", - "from mibi_bin_tools import bin_files\n", - "from ark.utils import io_utils\n" + "from mibi_bin_tools import bin_files" + ] + }, + { + "cell_type": "markdown", + "id": "88a66008-ce34-499c-9c73-8ce3bc150852", + "metadata": { + "tags": [] + }, + "source": [ + "### Define file parameters\n", + " * base_dir: this is the top-level directory to store the median pulse heights for different targets\n", + " * bin_file_path: the directory containing your bin files\n", + " * mph_dir: the directory to save the MPH visualizations to" ] }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 30, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], "source": [ "# set up directories for current run\n", "base_dir = os.path.join('..', 'toffy', 'data')\n", - "run_name = 'tissue'\n", - "run_dir = os.path.join(base_dir, run_name)\n", - "plot_dir = run_dir\n", - "#plot_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\qc_metrics', run_name)\n", - "#if not os.path.exists(plot_dir):\n", - "# os.makedirs(plot_dir)" + "bin_file_path = os.path.join(base_dir, 'tissue')\n", + "mph_dir = os.path.join(base_dir, 'tissue_mph')\n", + "#mph_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\qc_metrics', 'tissue')\n", + "\n", + "# make mph_dir if it doesn't exist\n", + "if not os.path.exists(mph_dir):\n", + " os.makedirs(mph_dir)" ] }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 31, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], "source": [ - "# compute pulse heights of run files\n", + "# define which channel to retrieve data for\n", "target = 'CD8'\n", - "total_counts = bin_files.get_total_counts(run_dir)\n", "\n", - "# compute pulse heights of run files\n", - "for i in range(1, 3): \n", + "# retrieve the total counts and compute pulse heights for each FOV run file\n", + "# saves individual .csv files to bin_file_path\n", + "total_counts = bin_files.get_total_counts(bin_file_path)\n", + "\n", + "for i in range(1, len(total_counts)+1): \n", " pulse_height_file = 'fov-{}-pulse_height.csv'.format(i)\n", " \n", - " if os.path.exists(os.path.join(run_dir, pulse_height_file)):\n", + " if os.path.exists(os.path.join(bin_file_path, pulse_height_file)):\n", " pass\n", " else:\n", " print(f'\\r{i}...', end='')\n", - " median = bin_files.get_median_pulse_height(run_dir, 'fov-{}-scan-1'.format(i) , target)\n", + " median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i) , target)\n", " count = total_counts['fov-{}-scan-1'.format(i)]\n", - " #median = compute_pulse_height(run_dir, 'fov-{}-scan-1'.format(i), 98, 97.5, 98.5)\n", "\n", " out_df = pd.DataFrame({\n", " 'fov': [i],\n", " 'MPH': [median],\n", " 'total_count': [count]})\n", - " out_df.to_csv(os.path.join(run_dir, pulse_height_file), index=False)" + " out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False)" + ] + }, + { + "cell_type": "markdown", + "id": "1c4c4bf8-015c-4610-b9f5-ae5ccd497259", + "metadata": {}, + "source": [ + "### Visualize MPH Plots" ] }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 32, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], "source": [ + "# prior to generating the graphs, need to combine the data for each FOV into one combined .csv\n", + "# saves directly to mph_dir\n", "pulse_heights = []\n", "fov_counts = []\n", - "for i in range(1, 3):\n", - " temp_df = pd.read_csv(os.path.join(run_dir, 'fov-{}-pulse_height.csv'.format(i)))\n", + "\n", + "for i in range(1, len(total_counts)+1):\n", + " temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i)))\n", " pulse_heights.append(temp_df['MPH'].values[0])\n", " if i>1:\n", " fov_counts.append(temp_df['total_count'].values[0] + fov_counts[i-2])\n", @@ -86,18 +118,18 @@ " fov_counts.append(temp_df['total_count'].values[0])\n", " \n", "combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts})\n", - "combined_df.to_csv(os.path.join(plot_dir, 'total_count_vs_mph_data.csv'), index=False)" + "combined_df.to_csv(os.path.join(mph_dir, 'total_count_vs_mph_data.csv'), index=False)" ] }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 33, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -107,18 +139,17 @@ } ], "source": [ - "#fov_counts = [72060, 145200, 224373, 314438, 372791]\n", - "#pulse_heights = [2222, 3800, 4372, 5273, 5908]\n", - "import matplotlib.pyplot as plt\n", + "# visualize the median pulse heights\n", "plt.style.use('dark_background')\n", - "plt.title('FOV total counts # vs median pulse height')\n", + "plt.title('FOV total counts vs median pulse height')\n", "plt.scatter(fov_counts, pulse_heights)\n", - "plt.gca().set_xlabel('fov total count')\n", + "plt.gca().set_xlabel('FOV cumulative count')\n", "plt.gca().set_ylabel('median pulse hight')\n", "plt.gcf().set_size_inches(18.5, 10.5)\n", "plt.xlim(0, max(fov_counts)+10000)\n", - "#plt.xlim(min(fov_counts)-10000, max(fov_counts)+10000)\n", - "plt.savefig(os.path.join(plot_dir, 'fov_vs_mph.jpg'))" + "\n", + "# save plot to mph_dir\n", + "plt.savefig(os.path.join(mph_dir, 'fov_vs_mph.jpg'))" ] } ], From d3b4d0eb7795bdec80fce5b32daa784f053b8e56 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 5 May 2022 10:54:32 -0700 Subject: [PATCH 04/94] regression line plot --- templates/example_MPH_plots.ipynb | 48 +++++++++++++++++++++++++++---- 1 file changed, 42 insertions(+), 6 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 1afcbd79..eb8b567b 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 28, + "execution_count": 1, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 2, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 3, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 15, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 6, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -151,6 +151,42 @@ "# save plot to mph_dir\n", "plt.savefig(os.path.join(mph_dir, 'fov_vs_mph.jpg'))" ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2978b381-e574-4b0c-9f66-b5176eaade51", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot with regression line\n", + "x = np.array(fov_counts)\n", + "y = np.array(pulse_heights)\n", + "m, b = np.polyfit(x, y, 1)\n", + "\n", + "plt.style.use('dark_background')\n", + "plt.title('FOV total counts vs median pulse height')\n", + "plt.scatter(fov_counts, pulse_heights)\n", + "plt.gca().set_xlabel('FOV cumulative count')\n", + "plt.gca().set_ylabel('median pulse hight')\n", + "plt.gcf().set_size_inches(18.5, 10.5)\n", + "plt.xlim(0, max(fov_counts)+10000)\n", + "plt.plot(x, m*x + b)\n", + "\n", + "# save plot to mph_dir\n", + "plt.savefig(os.path.join(mph_dir, 'fov_vs_mph_regression.jpg'))" + ] } ], "metadata": { From 1ac57d80e6503b9772cfde63f7199f3bee0b70e6 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Fri, 6 May 2022 19:12:34 -0700 Subject: [PATCH 05/94] move notebook functionality to helper functions --- templates/example_MPH_plots.ipynb | 78 ++++++------------------------- toffy/mph_comp.py | 73 +++++++++++++++++++++++++++++ 2 files changed, 87 insertions(+), 64 deletions(-) create mode 100644 toffy/mph_comp.py diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index eb8b567b..f38c5980 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 41, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 42, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -21,10 +21,9 @@ "import os\n", "import shutil\n", "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", "\n", - "from mibi_bin_tools import bin_files" + "from mibi_bin_tools import bin_files\n", + "from toffy import mph_comp" ] }, { @@ -42,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 43, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 44, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -70,23 +69,7 @@ "\n", "# retrieve the total counts and compute pulse heights for each FOV run file\n", "# saves individual .csv files to bin_file_path\n", - "total_counts = bin_files.get_total_counts(bin_file_path)\n", - "\n", - "for i in range(1, len(total_counts)+1): \n", - " pulse_height_file = 'fov-{}-pulse_height.csv'.format(i)\n", - " \n", - " if os.path.exists(os.path.join(bin_file_path, pulse_height_file)):\n", - " pass\n", - " else:\n", - " print(f'\\r{i}...', end='')\n", - " median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i) , target)\n", - " count = total_counts['fov-{}-scan-1'.format(i)]\n", - "\n", - " out_df = pd.DataFrame({\n", - " 'fov': [i],\n", - " 'MPH': [median],\n", - " 'total_count': [count]})\n", - " out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False)" + "mph_comp.compute_mph_metrics(bin_file_path, target)" ] }, { @@ -99,31 +82,19 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 45, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], "source": [ "# prior to generating the graphs, need to combine the data for each FOV into one combined .csv\n", "# saves directly to mph_dir\n", - "pulse_heights = []\n", - "fov_counts = []\n", - "\n", - "for i in range(1, len(total_counts)+1):\n", - " temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i)))\n", - " pulse_heights.append(temp_df['MPH'].values[0])\n", - " if i>1:\n", - " fov_counts.append(temp_df['total_count'].values[0] + fov_counts[i-2])\n", - " else:\n", - " fov_counts.append(temp_df['total_count'].values[0])\n", - " \n", - "combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts})\n", - "combined_df.to_csv(os.path.join(mph_dir, 'total_count_vs_mph_data.csv'), index=False)" + "mph_comp.combine_mph_metrics(bin_file_path, mph_dir)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 46, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -140,21 +111,14 @@ ], "source": [ "# visualize the median pulse heights\n", - "plt.style.use('dark_background')\n", - "plt.title('FOV total counts vs median pulse height')\n", - "plt.scatter(fov_counts, pulse_heights)\n", - "plt.gca().set_xlabel('FOV cumulative count')\n", - "plt.gca().set_ylabel('median pulse hight')\n", - "plt.gcf().set_size_inches(18.5, 10.5)\n", - "plt.xlim(0, max(fov_counts)+10000)\n", + "df_mph = pd.read_csv(os.path.join(mph_dir, 'total_count_vs_mph_data.csv'))\n", "\n", - "# save plot to mph_dir\n", - "plt.savefig(os.path.join(mph_dir, 'fov_vs_mph.jpg'))" + "mph_comp.visualize_mph(df_mph, False, mph_dir)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 47, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ @@ -171,21 +135,7 @@ ], "source": [ "# plot with regression line\n", - "x = np.array(fov_counts)\n", - "y = np.array(pulse_heights)\n", - "m, b = np.polyfit(x, y, 1)\n", - "\n", - "plt.style.use('dark_background')\n", - "plt.title('FOV total counts vs median pulse height')\n", - "plt.scatter(fov_counts, pulse_heights)\n", - "plt.gca().set_xlabel('FOV cumulative count')\n", - "plt.gca().set_ylabel('median pulse hight')\n", - "plt.gcf().set_size_inches(18.5, 10.5)\n", - "plt.xlim(0, max(fov_counts)+10000)\n", - "plt.plot(x, m*x + b)\n", - "\n", - "# save plot to mph_dir\n", - "plt.savefig(os.path.join(mph_dir, 'fov_vs_mph_regression.jpg'))" + "mph_comp.visualize_mph(df_mph, True, mph_dir)" ] } ], diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py new file mode 100644 index 00000000..77c95aaf --- /dev/null +++ b/toffy/mph_comp.py @@ -0,0 +1,73 @@ +import os +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt + +from mibi_bin_tools import bin_files + + +def compute_mph_metrics(bin_file_path, target, save_csv=True): + + # retrieve the total counts and compute pulse heights for each FOV run file + # saves individual .csv files to bin_file_path + total_counts = bin_files.get_total_counts(bin_file_path) + + for i in range(1, len(total_counts) + 1): + pulse_height_file = 'fov-{}-pulse_height.csv'.format(i) + + if os.path.exists(os.path.join(bin_file_path, pulse_height_file)): + # need to fix to parse thru existing csv + pass + else: + median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), target) + count = total_counts['fov-{}-scan-1'.format(i)] + + out_df = pd.DataFrame({ + 'fov': [i], + 'MPH': [median], + 'total_count': [count]}) + if save_csv: + out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) + else: + return out_df + + +def combine_mph_metrics(bin_file_path, output_dir): + total_counts = bin_files.get_total_counts(bin_file_path) + pulse_heights = [] + fov_counts = [] + + for i in range(1, len(total_counts) + 1): + temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i))) + pulse_heights.append(temp_df['MPH'].values[0]) + if i > 1: + fov_counts.append(temp_df['total_count'].values[0] + fov_counts[i - 2]) + else: + fov_counts.append(temp_df['total_count'].values[0]) + + combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts}) + combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) + + +def visualize_mph(mph_df, regression : bool, save_dir=None): + + # visualize the median pulse heights + plt.style.use('dark_background') + plt.title('FOV total counts vs median pulse height') + plt.scatter('cum_total_count', 'pulse_heights', data=mph_df) + plt.gca().set_xlabel('FOV cumulative count') + plt.gca().set_ylabel('median pulse hight') + plt.gcf().set_size_inches(18.5, 10.5) + plt.xlim(0, max(mph_df['cum_total_count']) + 10000) + if not regression and save_dir is not None: + plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) + return + + if regression: + # plot with regression line + x = np.array(mph_df['cum_total_count']) + y = np.array(mph_df['pulse_heights']) + m, b = np.polyfit(x, y, 1) + plt.plot(x, m * x + b) + if save_dir is not None: + plt.savefig(os.path.join(save_dir, 'fov_vs_mph_regression.jpg')) From 4618eeb3e54a6c05d0b2d01e8f64fa564fe8cd99 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 10 May 2022 10:45:49 -0700 Subject: [PATCH 06/94] pycode style --- toffy/mph_comp.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 77c95aaf..19927fa4 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -19,7 +19,8 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True): # need to fix to parse thru existing csv pass else: - median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), target) + median = bin_files.get_median_pulse_height(bin_file_path, + 'fov-{}-scan-1'.format(i), target) count = total_counts['fov-{}-scan-1'.format(i)] out_df = pd.DataFrame({ @@ -49,7 +50,7 @@ def combine_mph_metrics(bin_file_path, output_dir): combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) -def visualize_mph(mph_df, regression : bool, save_dir=None): +def visualize_mph(mph_df, regression: bool, save_dir=None): # visualize the median pulse heights plt.style.use('dark_background') From 51538d73fa264f9264abcb2ad5f3b04b0354131e Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 11 May 2022 15:54:50 -0700 Subject: [PATCH 07/94] add mass functionality --- templates/example_MPH_plots.ipynb | 17 +++++++++-------- toffy/mph_comp.py | 16 ++++++++++++---- 2 files changed, 21 insertions(+), 12 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index f38c5980..e61d57c6 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 41, + "execution_count": 1, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 2, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 3, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -59,17 +59,18 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 5, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], "source": [ "# define which channel to retrieve data for\n", "target = 'CD8'\n", + "mass_range = (-0.3, 0)\n", "\n", "# retrieve the total counts and compute pulse heights for each FOV run file\n", "# saves individual .csv files to bin_file_path\n", - "mph_comp.compute_mph_metrics(bin_file_path, target)" + "mph_comp.compute_mph_metrics(bin_file_path, target, mass_range)" ] }, { @@ -82,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 6, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -94,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 7, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -118,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 8, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 19927fa4..fa1d26e5 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -6,11 +6,12 @@ from mibi_bin_tools import bin_files -def compute_mph_metrics(bin_file_path, target, save_csv=True): +def compute_mph_metrics(bin_file_path, target, mass_range=None, save_csv=True): # retrieve the total counts and compute pulse heights for each FOV run file # saves individual .csv files to bin_file_path total_counts = bin_files.get_total_counts(bin_file_path) + metric_csvs = {} for i in range(1, len(total_counts) + 1): pulse_height_file = 'fov-{}-pulse_height.csv'.format(i) @@ -19,18 +20,25 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True): # need to fix to parse thru existing csv pass else: - median = bin_files.get_median_pulse_height(bin_file_path, - 'fov-{}-scan-1'.format(i), target) + if mass_range is None: + median = bin_files.get_median_pulse_height(bin_file_path, + 'fov-{}-scan-1'.format(i), target) + else: + median = bin_files.get_median_pulse_height(bin_file_path, + 'fov-{}-scan-1'.format(i), target, mass_range) count = total_counts['fov-{}-scan-1'.format(i)] out_df = pd.DataFrame({ 'fov': [i], 'MPH': [median], 'total_count': [count]}) + if save_csv: out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) else: - return out_df + metric_csvs['fov-{}-scan-1'.format(i)] = out_df + if not save_csv: + return metric_csvs def combine_mph_metrics(bin_file_path, output_dir): From 407bcd98cbd4bbe660bc5f3eed658eec67ac32f5 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 16 May 2022 12:18:48 -0700 Subject: [PATCH 08/94] fix existing csv issue --- toffy/mph_comp.py | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index fa1d26e5..92e8b16e 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -6,7 +6,7 @@ from mibi_bin_tools import bin_files -def compute_mph_metrics(bin_file_path, target, mass_range=None, save_csv=True): +def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None,): # retrieve the total counts and compute pulse heights for each FOV run file # saves individual .csv files to bin_file_path @@ -16,27 +16,25 @@ def compute_mph_metrics(bin_file_path, target, mass_range=None, save_csv=True): for i in range(1, len(total_counts) + 1): pulse_height_file = 'fov-{}-pulse_height.csv'.format(i) - if os.path.exists(os.path.join(bin_file_path, pulse_height_file)): - # need to fix to parse thru existing csv - pass + if mass_range is None: + median = bin_files.get_median_pulse_height(bin_file_path, + 'fov-{}-scan-1'.format(i), target) else: - if mass_range is None: - median = bin_files.get_median_pulse_height(bin_file_path, - 'fov-{}-scan-1'.format(i), target) - else: - median = bin_files.get_median_pulse_height(bin_file_path, - 'fov-{}-scan-1'.format(i), target, mass_range) - count = total_counts['fov-{}-scan-1'.format(i)] - - out_df = pd.DataFrame({ - 'fov': [i], - 'MPH': [median], - 'total_count': [count]}) + median = bin_files.get_median_pulse_height(bin_file_path, + 'fov-{}-scan-1'.format(i), target, mass_range) + count = total_counts['fov-{}-scan-1'.format(i)] + out_df = pd.DataFrame({ + 'fov': [i], + 'MPH': [median], + 'total_count': [count]}) + + metric_csvs['fov-{}-scan-1'.format(i)] = out_df + + if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): if save_csv: out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) - else: - metric_csvs['fov-{}-scan-1'.format(i)] = out_df + if not save_csv: return metric_csvs From 4ed3a600d96f4de6b6dc1bf2f00ae5a0232aa7fa Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 16 May 2022 14:16:45 -0700 Subject: [PATCH 09/94] add estimated time to mph functions and csvs --- toffy/mph_comp.py | 36 +++++++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 92e8b16e..bf6a8114 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -1,16 +1,37 @@ import os import pandas as pd import numpy as np +import json import matplotlib.pyplot as plt from mibi_bin_tools import bin_files -def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None,): +def get_estimated_time(bin_file_path): + + fov_files = bin_files._find_bin_files(bin_file_path) + json_files = \ + [(name, os.path.join(bin_file_path, fov['json'])) for name, fov in fov_files.items()] + time_list = {} + + for j in json_files: + with open(j[1]) as file: + run_metadata = json.load(file) + size = run_metadata.get('frameSize') + time = run_metadata.get('dwellTimeMillis') + estimated_time = size**2 * time + time_list[j[0]] = estimated_time + + return time_list + + +def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None): # retrieve the total counts and compute pulse heights for each FOV run file # saves individual .csv files to bin_file_path total_counts = bin_files.get_total_counts(bin_file_path) + fov_times = get_estimated_time(bin_file_path) + fov_keys = list(fov_times.keys()) metric_csvs = {} for i in range(1, len(total_counts) + 1): @@ -27,7 +48,8 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None,): out_df = pd.DataFrame({ 'fov': [i], 'MPH': [median], - 'total_count': [count]}) + 'total_count': [count], + 'time': [fov_times[fov_keys[i - 1]]]}) metric_csvs['fov-{}-scan-1'.format(i)] = out_df @@ -43,19 +65,27 @@ def combine_mph_metrics(bin_file_path, output_dir): total_counts = bin_files.get_total_counts(bin_file_path) pulse_heights = [] fov_counts = [] + estimated_time = [] for i in range(1, len(total_counts) + 1): temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i))) pulse_heights.append(temp_df['MPH'].values[0]) if i > 1: fov_counts.append(temp_df['total_count'].values[0] + fov_counts[i - 2]) + estimated_time.append(temp_df['time'].values[0] + estimated_time[i - 2]) else: fov_counts.append(temp_df['total_count'].values[0]) + estimated_time.append(temp_df['time'].values[0]) - combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts}) + combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts, + 'cum_total_time': estimated_time}) combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) +bin_file_path = os.path.join("data", "tissue") +output_dir = os.path.join("data", "tissue_mph") +combine_mph_metrics(bin_file_path, output_dir) + def visualize_mph(mph_df, regression: bool, save_dir=None): # visualize the median pulse heights From 35540d6bb824867c546ff3d5dacbb5d409845a08 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 16 May 2022 15:14:49 -0700 Subject: [PATCH 10/94] add time axis to plots --- templates/example_MPH_plots.ipynb | 16 +++++++------- toffy/mph_comp.py | 36 ++++++++++++++++++------------- 2 files changed, 29 insertions(+), 23 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index e61d57c6..8317784f 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -95,15 +95,15 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -119,15 +119,15 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index bf6a8114..5b0df6d7 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -19,7 +19,7 @@ def get_estimated_time(bin_file_path): run_metadata = json.load(file) size = run_metadata.get('frameSize') time = run_metadata.get('dwellTimeMillis') - estimated_time = size**2 * time + estimated_time = int(size**2 * time) time_list[j[0]] = estimated_time return time_list @@ -82,29 +82,35 @@ def combine_mph_metrics(bin_file_path, output_dir): combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) -bin_file_path = os.path.join("data", "tissue") -output_dir = os.path.join("data", "tissue_mph") -combine_mph_metrics(bin_file_path, output_dir) - def visualize_mph(mph_df, regression: bool, save_dir=None): - # visualize the median pulse heights + fig = plt.figure() + ax1 = fig.add_subplot(111) + ax2 = ax1.twiny() + x = mph_df['cum_total_count'] + y = mph_df['pulse_heights'] + ax1.scatter(x, y) + ax1.set_xlabel('FOV cumulative count') + ax1.set_ylabel('median pulse height') + ax2.set_xlabel('estimated time (ms)') + ax1.set_xlim(0, max(x) + 10000) + ax2.set_xlim(0, max(x) + 10000) + ax2.set_xticks(x) + ax2.set_xticklabels(mph_df['cum_total_time']) plt.style.use('dark_background') - plt.title('FOV total counts vs median pulse height') - plt.scatter('cum_total_count', 'pulse_heights', data=mph_df) - plt.gca().set_xlabel('FOV cumulative count') - plt.gca().set_ylabel('median pulse hight') + # plt.title('FOV total counts vs median pulse height') plt.gcf().set_size_inches(18.5, 10.5) - plt.xlim(0, max(mph_df['cum_total_count']) + 10000) + if not regression and save_dir is not None: plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) return if regression: # plot with regression line - x = np.array(mph_df['cum_total_count']) - y = np.array(mph_df['pulse_heights']) - m, b = np.polyfit(x, y, 1) - plt.plot(x, m * x + b) + x2 = np.array(mph_df['cum_total_count']) + y2 = np.array(mph_df['pulse_heights']) + m, b = np.polyfit(x2, y2, 1) + plt.plot(x2, m * x2 + b) if save_dir is not None: plt.savefig(os.path.join(save_dir, 'fov_vs_mph_regression.jpg')) + plt.show() From 64090d22b4c23a6437175211753e2d69cd8e90d1 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 16 May 2022 15:23:30 -0700 Subject: [PATCH 11/94] stupid character limit --- toffy/mph_comp.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 92e8b16e..b29522f0 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -20,8 +20,8 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None,): median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), target) else: - median = bin_files.get_median_pulse_height(bin_file_path, - 'fov-{}-scan-1'.format(i), target, mass_range) + median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), + target, mass_range) count = total_counts['fov-{}-scan-1'.format(i)] out_df = pd.DataFrame({ From aaa3e4b35fbe6512993a53513e9189cdf46d8243 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 16 May 2022 19:00:37 -0700 Subject: [PATCH 12/94] add default mass_range --- toffy/mph_comp.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index b29522f0..415f974d 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -6,7 +6,7 @@ from mibi_bin_tools import bin_files -def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None,): +def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=(-0.3, 0.0)): # retrieve the total counts and compute pulse heights for each FOV run file # saves individual .csv files to bin_file_path @@ -16,12 +16,8 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None,): for i in range(1, len(total_counts) + 1): pulse_height_file = 'fov-{}-pulse_height.csv'.format(i) - if mass_range is None: - median = bin_files.get_median_pulse_height(bin_file_path, - 'fov-{}-scan-1'.format(i), target) - else: - median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), - target, mass_range) + median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), + target, mass_range) count = total_counts['fov-{}-scan-1'.format(i)] out_df = pd.DataFrame({ From 3f3a29f27346ff7354abd0194f76e10054ea3d95 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 16 May 2022 19:21:06 -0700 Subject: [PATCH 13/94] comments --- toffy/mph_comp.py | 40 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 36 insertions(+), 4 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 415f974d..e5695359 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -7,15 +7,26 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=(-0.3, 0.0)): - - # retrieve the total counts and compute pulse heights for each FOV run file - # saves individual .csv files to bin_file_path + """Retrieves FOV total counts and median pulse heights for all bin files in the directory + Args: + bin_file_path (str): path to the FOV bin and json files + target (str): channel to use + save_csv (bool): whether to save to csv file or output data, defaults to True + mass_range (tuple): integration range for pulse heights, default same as pulse function + + Return: + None | Dict[str, pd.DataFrame]: if save_csv if False, return mph metrics + """ + + # get total counts for each FOV total_counts = bin_files.get_total_counts(bin_file_path) metric_csvs = {} + # retrieve the data from each bin file and store it / output to individual csv for i in range(1, len(total_counts) + 1): pulse_height_file = 'fov-{}-pulse_height.csv'.format(i) + # get median pulse heights median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), target, mass_range) count = total_counts['fov-{}-scan-1'.format(i)] @@ -27,32 +38,50 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=(-0.3, metric_csvs['fov-{}-scan-1'.format(i)] = out_df + # saves individual .csv files to bin_file_path if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): if save_csv: out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) + # return data if not save_csv: return metric_csvs def combine_mph_metrics(bin_file_path, output_dir): + """Combines data from individual csvs into one + Args: + bin_file_path (str): path to the FOV bin and json files + output_dir (str): path to output csv to + """ + + # get FOV total counts total_counts = bin_files.get_total_counts(bin_file_path) pulse_heights = [] fov_counts = [] + # for each csv retrieve mph values for i in range(1, len(total_counts) + 1): temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i))) pulse_heights.append(temp_df['MPH'].values[0]) + # calculate total counts cumulatively for plotting if i > 1: fov_counts.append(temp_df['total_count'].values[0] + fov_counts[i - 2]) else: fov_counts.append(temp_df['total_count'].values[0]) + # save csv to output_dir combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts}) combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) def visualize_mph(mph_df, regression: bool, save_dir=None): + """Create a scatterplot visualizing median pulse heights by FOV cumulative count + Args: + mph_df (pd.DataFrame): data detailing total counts and pulse heights + regression (bool): whether or not to plot regression line + save_dir (str): path of directory to save plot to + """ # visualize the median pulse heights plt.style.use('dark_background') @@ -62,15 +91,18 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): plt.gca().set_ylabel('median pulse hight') plt.gcf().set_size_inches(18.5, 10.5) plt.xlim(0, max(mph_df['cum_total_count']) + 10000) + + # save figure without regression line if not regression and save_dir is not None: plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) return + # plot regression line if regression: - # plot with regression line x = np.array(mph_df['cum_total_count']) y = np.array(mph_df['pulse_heights']) m, b = np.polyfit(x, y, 1) plt.plot(x, m * x + b) + # save figure if save_dir is not None: plt.savefig(os.path.join(save_dir, 'fov_vs_mph_regression.jpg')) From 3725bc37ce54788f13e2739c37c987fa8403cbc7 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 16 May 2022 19:24:30 -0700 Subject: [PATCH 14/94] path validation --- toffy/mph_comp.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index e5695359..8401dc42 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -4,6 +4,7 @@ import matplotlib.pyplot as plt from mibi_bin_tools import bin_files +from ark.utils import io_utils def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=(-0.3, 0.0)): @@ -18,6 +19,9 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=(-0.3, None | Dict[str, pd.DataFrame]: if save_csv if False, return mph metrics """ + # path validation checks + io_utils.validate_paths(bin_file_path) + # get total counts for each FOV total_counts = bin_files.get_total_counts(bin_file_path) metric_csvs = {} @@ -55,6 +59,10 @@ def combine_mph_metrics(bin_file_path, output_dir): output_dir (str): path to output csv to """ + # path validation checks + io_utils.validate_paths(bin_file_path) + io_utils.validate_paths(output_dir) + # get FOV total counts total_counts = bin_files.get_total_counts(bin_file_path) pulse_heights = [] @@ -83,6 +91,9 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): save_dir (str): path of directory to save plot to """ + # path validation checks + io_utils.validate_paths(save_dir) + # visualize the median pulse heights plt.style.use('dark_background') plt.title('FOV total counts vs median pulse height') From f53db8e9f1514f61d8eb132b673a94981f3c101e Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 17 May 2022 15:52:04 -0700 Subject: [PATCH 15/94] change mass_range to mass_start and mass_stop --- templates/example_MPH_plots.ipynb | 15 +++++++++------ toffy/mph_comp.py | 4 ++-- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index e61d57c6..dc151eff 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -66,11 +66,12 @@ "source": [ "# define which channel to retrieve data for\n", "target = 'CD8'\n", - "mass_range = (-0.3, 0)\n", + "mass_start = -0.3 \n", + "mass_stop = 0\n", "\n", "# retrieve the total counts and compute pulse heights for each FOV run file\n", "# saves individual .csv files to bin_file_path\n", - "mph_comp.compute_mph_metrics(bin_file_path, target, mass_range)" + "mph_comp.compute_mph_metrics(bin_file_path, target, mass_start, mass_stop)" ] }, { @@ -95,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -113,13 +114,14 @@ "source": [ "# visualize the median pulse heights\n", "df_mph = pd.read_csv(os.path.join(mph_dir, 'total_count_vs_mph_data.csv'))\n", + "regression = False\n", "\n", - "mph_comp.visualize_mph(df_mph, False, mph_dir)" + "mph_comp.visualize_mph(df_mph, regression, mph_dir)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ @@ -136,7 +138,8 @@ ], "source": [ "# plot with regression line\n", - "mph_comp.visualize_mph(df_mph, True, mph_dir)" + "regression = True\n", + "mph_comp.visualize_mph(df_mph, regression, mph_dir)" ] } ], diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 8401dc42..4d6feaf7 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -7,7 +7,7 @@ from ark.utils import io_utils -def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=(-0.3, 0.0)): +def compute_mph_metrics(bin_file_path, target, mass_start, mass_stop, save_csv=True): """Retrieves FOV total counts and median pulse heights for all bin files in the directory Args: bin_file_path (str): path to the FOV bin and json files @@ -32,7 +32,7 @@ def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=(-0.3, # get median pulse heights median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), - target, mass_range) + target, (mass_start, mass_stop)) count = total_counts['fov-{}-scan-1'.format(i)] out_df = pd.DataFrame({ From f92ee5124fc07209d5ab49d0a920e3ed558b267b Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 17 May 2022 16:14:52 -0700 Subject: [PATCH 16/94] get total_count for one fov at a time --- toffy/mph_comp.py | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 4d6feaf7..c0a78df5 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -13,7 +13,8 @@ def compute_mph_metrics(bin_file_path, target, mass_start, mass_stop, save_csv=T bin_file_path (str): path to the FOV bin and json files target (str): channel to use save_csv (bool): whether to save to csv file or output data, defaults to True - mass_range (tuple): integration range for pulse heights, default same as pulse function + mass_start (float): beginning of mass integration range + mass_stop (float): end of mass integration range Return: None | Dict[str, pd.DataFrame]: if save_csv if False, return mph metrics @@ -22,18 +23,22 @@ def compute_mph_metrics(bin_file_path, target, mass_start, mass_stop, save_csv=T # path validation checks io_utils.validate_paths(bin_file_path) - # get total counts for each FOV - total_counts = bin_files.get_total_counts(bin_file_path) + # list bin files in directory + fov_bins = io_utils.list_files(bin_file_path, ".bin") + fov_bins = io_utils.remove_file_extensions(fov_bins) + metric_csvs = {} + i = 0 # retrieve the data from each bin file and store it / output to individual csv - for i in range(1, len(total_counts) + 1): + for file in fov_bins: + i = i+1 pulse_height_file = 'fov-{}-pulse_height.csv'.format(i) # get median pulse heights median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), target, (mass_start, mass_stop)) - count = total_counts['fov-{}-scan-1'.format(i)] + count = bin_files.get_total_counts(bin_file_path, [file]) out_df = pd.DataFrame({ 'fov': [i], @@ -63,13 +68,17 @@ def combine_mph_metrics(bin_file_path, output_dir): io_utils.validate_paths(bin_file_path) io_utils.validate_paths(output_dir) - # get FOV total counts - total_counts = bin_files.get_total_counts(bin_file_path) + # list bin files in directory + fov_bins = io_utils.list_files(bin_file_path, ".bin") + fov_bins = io_utils.remove_file_extensions(fov_bins) + pulse_heights = [] fov_counts = [] + i = 0 # for each csv retrieve mph values - for i in range(1, len(total_counts) + 1): + for file in fov_bins: + i = i+1 temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i))) pulse_heights.append(temp_df['MPH'].values[0]) # calculate total counts cumulatively for plotting From f62d216c3768337958bbcfa3e5b1b96756ea1529 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 17 May 2022 16:27:02 -0700 Subject: [PATCH 17/94] fix background issue --- templates/example_MPH_plots.ipynb | 8 ++++---- toffy/mph_comp.py | 20 ++++++++++++++------ 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 8317784f..384ce5eb 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -95,13 +95,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -119,13 +119,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABEgAAAKFCAYAAADf3dyGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3XlYlXX+//HXORw2RYzcMFDRxDIbFwzURrO0QccWbbR+pqOUCogmaWmDS422uqZoKkLl0qZO4bjvabYMigaCGYkZk6RolhoogsD9+8OGb6YGCocbOM/Hdb2v8dzn3Pd53dV1nXrNfX9uiyRDAAAAAAAADsxqdgAAAAAAAACzUZAAAAAAAACHR0ECAAAAAAAcHgUJAAAAAABweBQkAAAAAADA4VGQAAAAAAAAh0dBAgAAAAAAHB4FCQAAKJOQkBA1bNiw+HVcXJxatmxZ5uM2adJEjz/++HXvt3jxYvXt2/eK7fbK+Xtubm7auXOnrNay/WvWnXfeqcWLF5dTKgAAUBIKEgAAUCZPPPGEbrnlluLXoaGh+vrrr8t8XD8/Pw0YMKDMx/kfe+X8vSFDhig+Pl5FRUVlOs6BAwfk6+urRo0alVMyAADwRyhIAADAFQYOHKjdu3crKSlJMTExslqtslqtWrx4sVJTU5WSkqLRo0erb9++uuuuu/Tee+8pKSlJbm5u2rFjh9q3by9Jys7O1tSpU7V3715t3bpVgYGB2rFjh7799ls99NBDki5dKbJr1y7t27dP+/btU6dOnSRJU6dOVZcuXZSUlKTRo0fLarVq+vTp2rNnj/bv36+wsLDivPPmzdNXX32ldevWqX79+lecT3nk/KPv//1fu9WrV0uSunbtqp07d2rFihX65ptv9Nprr2nAgAHavXu3UlJS1KxZM0lSv379lJqaquTkZH3yySfFx1q7dq369+9fpr+XAACg9AyGYRiGYZj/ze23326sWbPGsNlshiRj/vz5xqBBg4yAgABjy5YtxZ+rXbu2IcnYsWOH0b59++Ltv31tGIbRs2dPQ5IRHx9vbN682bDZbEbr1q2NpKQkQ5Lh7u5uuLq6GpKM5s2bG4mJiYYko2vXrsbatWuLjxsaGmpMnDjRkGS4uLgYiYmJhp+fn/HII48YW7ZsMaxWq9GwYUPj9OnTRt++fa84r7LmvNb3//Y7nJ2djePHjxe/7tq1q3H69GnD29vbcHFxMTIzM43JkycbkozIyEhj9uzZhiQjJSXFuOWWWy776yrJuPvuu401a9aY/s8EwzAMwzjC2AQAAPAb3bt3V/v27ZWYmChJcnd318mTJ7V27Vo1a9ZMc+fO1fr167Vly5YSj5WXl6dNmzZJklJTU5WXl6eCggKlpqbKz89PkuTs7Kw33nhDbdu2VWFhoVq0aHHVYwUHB6t169bq16+fJKl27dry9/fXPffcow8++EBFRUU6fvy4Pv744+s+59LkvNb3Z2RkFB+nbt26OnPmzGXHTkxMVFZWliTp22+/Lf7rlpqaqvvuu0+S9Pnnn2vJkiVauXKl4uPji/c9efLkZbcFAQAA+6EgAQAAl7FYLFq6dKkmTJhwxXtt2rRRjx49NHLkSD322GMaOnToHx7r4sWLxX8uKipSXl6eJMkwDNlsl/41ZMyYMTpx4oTatGkjq9WqCxcuXDPXqFGjrihmevXqJcMwruscbyTntb7/t3Jzc+Xm5nbZtv8d6/fHLioqKj52RESEgoKC9MADDyg5OVlt27bVzz//LDc3N+Xm5pbp3AAAQOmwBgkAALjM9u3b1a9fP9WrV0+S5OXlpcaNG6tOnTqyWq2Kj4/X888/r4CAAEmX1u+oVavWDX9f7dq1dfz4cRmGoUGDBhWXBr8/7ubNmxUREVH8vr+/v2rUqKFdu3apf//+slqt8vb2Lr4q4/fKmvNa3/9bZ86ckZOTk1xdXa/r2M2aNdOePXv0z3/+U6dOnSpemLVFixY6cODADWcGAAClxxUkAADgMl9//bUmTZqkLVu2yGq16uLFixo5cqRyc3O1ePHi4sfXjh8/XpK0ZMkSxcTEKDc3t3iB1euxYMECffTRR3r00Ue1Y8cO5eTkSJJSUlJUUFCg5ORkLVmyRNHR0fLz89OXX34pi8WiH3/8UX369NGqVavUrVs3paam6tChQ5ctcvpbZc355ptvXvX7f2/Lli3q3Lmztm/fXupjz5gxQ/7+/rJYLNq+fbv2798vSbrvvvu0fv36684KAACun0WXFiMBAABAOWjbtq2eeeYZDR48uEzHcXFx0SeffKLOnTursLCwnNIBAIBrcZI02ewQAAAA1UVWVpZuuukmpaSklGltlKZNm2rPnj367rvvyjEdAAC4Fq4gAQAAAAAADo9FWgEAwBW+++47paSkKCkpqfhxv/369dOBAwdUWFio9u3bF3/2/vvv1969e5WSkqK9e/dec5FUAABQdm+99ZZOnDih1NTU4m1eXl7asmWLDh06pC1btuimm26SVLrf6NWrV192LEdGQQIAAK7qvvvuU7t27RQYGChJOnDggP72t79p165dl33u1KlTeuihh9S6dWuFhITonXfeMSMuAAAOYcmSJerZs+dl26KiorR9+3a1aNFC27dvV1RUlKSSf6MfeeSR4sXRcYnBMAzDMAzz2/nuu++MOnXqXPW9HTt2GO3bt7/mvqdOnTJcXFxMPweGYRiGqa7TpEkTIzU1tfh1Wlqa4e3tbUgyvL29jbS0tKvu99vf6Jo1axqffvqp0bJly8uO5cjDFSQAAOAKhmFoy5Yt2rt3r0JDQ0u9X9++fZWUlKT8/Hw7pgMAAL/VoEEDZWVlSbq0WHj9+vWv+Mzvf6NfeuklzZo1S+fPn6/QrJWZzewAAACg8vnzn/+s48ePq169etq6davS0tL06aef/uE+d9xxh6ZNm6bg4OAKSgkAAErj97/Rbdq0UfPmzfXMM8+oSZMmJqerPLiCBAAAXOH48eOSpB9//FGrVq1SUFDQH37ex8dHq1at0uDBg3XkyJGKiAgAAH514sQJeXt7S5K8vb118uTJ4veu9hvdqVMntW/fXt99950+++wztWjRQjt27DAle2VCQQIAAC5To0YNeXh4FP85ODhYBw4cuObna9eurfXr12v8+PH64osvKiomAAD41Zo1axQSEiJJCgkJ0erVqyVd+zc6JiZGPj4+atq0qTp37qxDhw7xFLpfmb4QCsMwDMMwlWeaNm1qJCcnG8nJycaBAweMCRMmGJKMPn36GEePHjUuXLhgZGVlGZs2bTIkGRMnTjRycnKMpKSk4qlXr57p58EwDMMw1XHef/9949ixY0Z+fr5x9OhRY8iQIcbNN99sbNu2zTh06JCxbds2w8vLy5BK9xv9+wVfHXksv/4BAAAAAADAYXGLDQAAAAAAcHgUJAAAAAAAwOFRkAAAAAAAAIdHQQIAAAAAABweBQkAAAAAAHB4FCQAAOC6hYaGmh0BAACUgN/r60NBAgAArltYWJjZEQAAQAn4vb4+FCQAAAAAAMDhWSQZZoewh8LCQuXm5podAwCAaslms6mgoMDsGAAA4A/we32Ju7u7nJycSvycrQKymCI3N1ceHh5mxwAAAAAAACbKyckp1ee4xQYAAAAAADg8ChIAAAAAAODwKEgAAAAAAIDDoyABAAAAAAAOj4IEAAAAAAA4PAoSAAAAAADg8ChIAAAAAACAw6MgAQAAAAAADo+CBAAAAAAAODwKEgAAAAAA4PAoSAAAAAAAgMOjIAEAAAAAAA6PggQAAAAAADg8ChIAAAAAAODwKEgAAAAAAIDDoyABAAAAAAAOj4IEAAAAAAA4PAoSAAAAAADg8ChIAAAAAACAw6MgAQAAAAAADs9uBYmrq6t2796t5ORkHThwQJMnT5YktWnTRv/5z3+UlJSkxMREBQYGFu8TFRWl9PR0paWlKTg4uHh7QECAUlJSlJ6erujoaHtFBgAAAAAADsyw19SsWdOQZNhsNiMhIcHo0KGDsXnzZqNnz56GJOOvf/2rsWPHDkOS0bJlSyM5OdlwcXEx/Pz8jMOHDxtWq9WQZOzevdvo2LGjIcnYsGFD8f5/NDk5OXY7L4ZhGIZhGIZhGIaprNOuV7AxcXO8MXP/58bEzfFGu17Bpmcyc0rbD9j1Fptz585JkpydneXs7CzDMGQYhjw9PSVJtWvX1rFjxyRJvXv31vLly5Wfn6+MjAwdPnxYQUFB8vb2lqenpxISEiRJy5YtU58+fewZGwAAAACAKqldr2A9NjlKN9/SUBarVTff0lCPTY5Su17BJe/s4Gz2PLjVatW+ffvUvHlzzZ8/X3v27NHo0aO1efNmzZw5U1arVXfffbckycfHp7gEkaTMzEz5+Pjo4sWLyszMvGI7AAAAAAC4XK+nh8vF3f2ybS7u7ur19HAlbdhiUqqqwa5XkBQVFaldu3by9fVVUFCQWrVqpYiICI0ZM0aNGzfWmDFj9NZbb0mSLBbLFfsbhnHN7VcTGhqqxMREJSYmymaza/cDAAAAAECl4+Xd4Lq24/9UyFNszp49q507d6pnz54KCQlRfHy8JOlf//qXgoKCJF26MqRRo0bF+/j6+urYsWPKzMyUr6/vFduvJi4uToGBgQoMDFRBQYEdzwgAAAAAgMon58yZq24/nXWigpNUPXYrSOrWravatWtLktzc3HT//fcrLS1Nx44dU9euXSVJ3bp1U3p6uiRpzZo16t+/v1xcXOTn5yd/f3/t2bNHWVlZys7OVocOHSRJgwcP1urVq+0VGwAAAACAKum2uzuohqenioqKLtuen5urDdExJqWqOux2H0rDhg21dOlSOTk5yWq1auXKlVq/fr3OnDmj6Oho2Ww2XbhwQWFhYZKkgwcPauXKlTp48KAKCgo0cuTI4r+pERERWrJkidzd3bVx40Zt3LjRXrEBAAAAAKhymrVvqyfmTFVW+hF9vuIj3R/2hLy8G+h01gltiI5h/ZFSsOjS42yqnZycHHl4eJgdAwAAAAAAu2rUqqWGvzlPZ0/+qAVPjlDOz6fNjlSplLYfqJA1SAAAAAAAQPnzbt5MoTGzde7MWS0Ki6QcKQMKEgAAAAAAqqC6jX0VHhutgrx8xYSO0tkTP5odqUrjWbgAAAAAAFQxN3k3UHjcXFmdnDR/aIR+zrz6015RehQkAAAAAABUIbXq3KzhcXPl7uGhhUOf0snv/mt2pGqBggQAAAAAgCrC3dNTYbHR8qxfT7FhT+uHtENmR6o2KEgAAAAAAKgCXGvWUFjMbNX3a6w3R45Vxv5UsyNVKxQkAAAAAABUcs5urhr6xkz5tGyhpWPGKz0h0exI1Q5PsQEAAAAAoBJzstkUMvs1NQ1oow8mvKivdn5mdqRqiYIEAAAAAIBKyurkpIHTpqhl5076cMpUJW3canakaouCBAAAAACASshiseixKRPUJrib/j1tjnbHrzU7UrVGQQIAAAAAQCX0yIRnFdi7lza+EatP311hdpxqj4IEAAAAAIBK5oHREfpz/77a8fa72rZosdlxHAIFCQAAAAAAlUj30BB1GzpYX6yI17rZ882O4zAoSAAAAAAAqCS6DHxMvSKHa+/ajYp/ZabZcRwKBQkAAAAAAJVAUJ8H1SdqjFK27dSK51+RYRhmR3IoFCQAAAAAAJisTY/uenRylNI+S9C7z72gosJCsyM5HAoSAAAAAABM1PKeP2vga5P1XXKKloyJUuHFi2ZHckgUJAAAAAAAmKR5UHuFvP6KfvjmkN4aOVYXL+SZHclhUZAAAAAAAGCCJm3u1JB503Xq+0zFDR+jvHPnzY7k0ChIAAAAAACoYLfc5q/QBa/rlx9/0qKwp3X+7C9mR3J4FCQAAAAAAFSg+k2bKGzRHF04d06LQiOVfeonsyNBFCQAAAAAAFSYm30aKjxurgzDUExopE4fzzI7En5lMzsAAAAAAACOwLN+PQ1/c55c3Nw0/8kROvXfo2ZHwm9QkAAAAAAAYGc1vW5SeGy0anrdpJhhkcpK/9bsSPgdChIAAAAAAOzIrZaHwmLmqI7PLYqNGKOjBw6aHQlXQUECAAAAAICduLi7adj8WfL2b6a3Rz2nI3uTzI6Ea6AgAQAAAADADmwuLnpy7nQ1ad1Ky8ZO0jefJ5gdCX+Ap9gAAAAAAFDOrDYnDZ75slp0DNSKF15V6radZkdCCShIAAAAAAAoRxarVQNeeUGt7uuij16eob1rNpgdCaVAQQIAAAAAQDnq9/xzatcrWOtmz9cXK+LNjoNSoiABAAAAAKCcPDwuUh379dbW2MXa8fa7ZsfBdaAgAQAAAACgHPQYMUxdBz+uXe+u0KZ5sWbHwXWiIAEAAAAAoIzuDRmg4Iih2h2/VmumR5sdBzeAggQAAAAAgDLo9OgjemjsKCVv2qZ/TZkqwzDMjoQbQEECAAAAAMANCniwh/42aawOfvK53h8/RUZRkdmRcIMoSAAAAAAAuAF3duuq/i9N0reJX2rpsxNVWFBgdiSUAQUJAAAAAADX6ba7O2jQzJd09Kuv9fao51SQl2d2JJQRBQkAAAAAANehaUAbPTFnqk4c/k5vjnhW+bm5ZkdCOaAgAQAAAACglHzvuF3D5s/S6eNZih0+Wrm/ZJsdCeWEggQAAAAAgFLwbt5MYYvm6NyZs1oUFqmcn0+bHQnliIIEAAAAAIAS1G3sq/DYaBXk5SsmdJTOnvjR7EgoZzazAwAAAAAAUJnd5N1A4XFzZXVy0oJhI/Rz5jGzI8EOKEgAAAAAALiGWnVu1vC4uXKvVUsLh47UiSMZZkeCnVCQAAAAAABwFe6engqLjZZn/XqKDXtaP3x9yOxIsCMKEgAAAAAAfse1Rg2FxcxWfb/GenPkWGXsTzU7EuyMggQAAAAAgN9wdnPVkDdmyKdlCy0dM17pCYlmR0IF4Ck2AAAAAAD8yslmU8jrr6pZ+7b6YMKL+mrnZ2ZHQgWhIAEAAAAAQJLVyUkDp01Ryy5368MpU5W0cavZkVCBKEgAAAAAAA7PYrHosSkT1Ca4m/49bY52x681OxIqGAUJAAAAAMDhPTLhWQX27qVN8+P06bsrzI4DE1CQAAAAAAAc2gOjI/Tn/n21Y/F72hrzttlxYBIKEgAAAACAw+o+LETdhg7WFyvite71N8yOAxNRkAAAAAAAHFLnAY+q19PDtXftRsW/MtPsODAZBQkAAAAAwOEE9XlQj4x/RinbdmrF86/IMAyzI8FkFCQAAAAAAIfSpkd3PTo5SmmfJejd515QUWGh2ZFQCVCQAAAAAAAcRst7/qyBr03Wd8kpWjImSoUXL5odCZUEBQkAAAAAwCE0D2qvkNdf0bFD6Xr7qXG6eCHP7EioROxWkLi6umr37t1KTk7WgQMHNHny5OL3nnrqKaWlpenAgQOaNm1a8faoqCilp6crLS1NwcHBxdsDAgKUkpKi9PR0RUdH2ysyAAAAAKCaatLmTg2ZN12nvs9UbPhoXcg5Z3YkVEKGvaZmzZqGJMNmsxkJCQlGhw4djHvvvdfYunWr4eLiYkgy6tWrZ0gyWrZsaSQnJxsuLi6Gn5+fcfjwYcNqtRqSjN27dxsdO3Y0JBkbNmwwevbsWeJ35+Tk2O28GIZhGIZhGIZhmKozt9zmb7z8+RYjat1Ko1bdOqbnYSp2StsP2PUWm3PnLjVyzs7OcnZ2lmEYioiI0NSpU5Wfny9J+vHHHyVJvXv31vLly5Wfn6+MjAwdPnxYQUFB8vb2lqenpxISEiRJy5YtU58+fewZGwAAAABQTdRv2kRhi+bowrlzWhQaqexTP5kdCZWUXQsSq9WqpKQknTx5Ulu3btWePXvUokULdenSRQkJCdq5c6fuuusuSZKPj4+OHj1avG9mZqZ8fHzk4+OjzMzMK7YDAAAAAPBHbvZpqPC4uTIMQzGhkTp9PMvsSKjEbPY8eFFRkdq1a6fatWtr1apVatWqlWw2m7y8vNSxY0cFBgZq5cqVatasmSwWyxX7G4Zxze1XExoaqrCwMEmSzWbXUwMAAAAAVGKe9eoqPG6uXNzcNP/JETr136Ml7wSHViFPsTl79qx27typnj17KjMzU/Hx8ZKkxMREFRUVqW7dusrMzFSjRo2K9/H19dWxY8eUmZkpX1/fK7ZfTVxcnAIDAxUYGKiCggL7nhQAAAAAoFKq6XWTwuPmyuNmL8UOH6Os9G/NjoQqwG4FSd26dVW7dm1Jkpubm+6//36lpaXp3//+t7p16yZJ8vf3l4uLi06dOqU1a9aof//+cnFxkZ+fn/z9/bVnzx5lZWUpOztbHTp0kCQNHjxYq1evtldsAAAAAEAV5lbLQ2Exc1TH5xa99dQ4HT1w0OxIqCLsdh9Kw4YNtXTpUjk5OclqtWrlypVav369nJ2d9fbbbys1NVX5+fkKCQmRJB08eFArV67UwYMHVVBQoJEjR6qoqEiSFBERoSVLlsjd3V0bN27Uxo0b7RUbAAAAAFBFubi7adj8WfL2b6bFkc/pyN4ksyOhCrHo0uNsqp2cnBx5eHiYHQMAAAAAUAFsLi4aOn+mmgcGaNnYSUrdttPsSKgkStsPVMgaJAAAAAAA2IvV5qRBM19Si46BWvHCq5QjuCEUJAAAAACAKstiterxV17Qnffdo49enqG9azaYHQlVFAUJAAAAAKDK6vf8cwroFax1s+frixXxZsdBFUZBAgAAAACokh4eF6mO/Xpra+xi7Xj7XbPjoIqjIAEAAAAAVDk9RgxT18GPa9e7K7RpXqzZcVANUJAAAAAAAKqUe0MGKDhiqPasWqc106PNjoNqgoIEAAAAAFBldHr0ET00dpSSN23TysmvyTAMsyOhmqAgAQAAAABUCQEP9tDfJo3VwU8+1/vjp8goKjI7EqoRChIAAAAAQKV3Z7eu6v/SJH2b+KWWPjtRhQUFZkdCNUNBAgAAAACo1Fp0CtKgGS/q6Fdf6+1Rz6kgL8/sSKiGKEgAAAAAAJVW04A2ejJ6mk58m6E3Rzyr/NxcsyOhmqIgAQAAAABUSr533K5h82fpTNYJxQ4frdxfss2OhGqMggQAAAAAUOl4N2+msEVzdO7MWcWEjlLOz6fNjoRqjoIEAAAAAFCp1G3sq/DYaBXk52tRaKTOnvjR7EhwADazAwAAAAAA8D83eTdQeNxcWZ2ctODJEfop8wezI8FBUJAAAAAAACoFjzpeGh43V+61amnh0JE6cSTD7EhwIBQkAAAAAADTuXt6Kjx2rjzr11Ns2NP64etDZkeCg6EgAQAAAACYyrVGDYUufF31/RrrzZFjlbE/1exIcEAUJAAAAAAA0zi7uWrIGzPke8dtWjpmvNITEs2OBAfFU2wAAAAAAKZwstkU8vqrata+rT6Y8KK+2vmZ2ZHgwChIAAAAAAAVzurkpIHTpqhll7v14YvTlLRxq9mR4OAoSAAAAAAAFcpiseixKRPUJribVk+P1u6P1pgdCaAgAQAAAABUrD7jn1Fg717aND9Ou95ZbnYcQBIFCQAAAACgAvV6OkKdH++nHYvf09aYt82OAxSjIAEAAAAAVIjuw0LUfdhgfbEiXutef8PsOMBlKEgAAAAAAHbXecCj6vX0cO1du1Hxr8w0Ow5wBQoSAAAAAIBdBfV5UI+Mf0Yp23ZqxfOvyDAMsyMBV6AgAQAAAADYTZse3fXo5Ch983mC3n3uBRUVFpodCbgqChIAAAAAgF20vOfPGvjaZGUkp2rx6CgVXrxodiTgmihIAAAAAADlrnlQe4W8/oqOHUrXW0+N1cULeWZHAv4QBQkAAAAAoFw1bt1KQ+ZN16nvMxUbPloXcs6ZHQkoEQUJAAAAAKDc3HKbv0IXvq5ffvxJi8Ke1vmzv5gdCSgVChIAAAAAQLmo37SJwhbNUd6581oUGqnsUz+ZHQkoNQoSAAAAAECZ3ezTUOFxc2UYhmJCI3X6eJbZkYDrYjM7AAAAAACgavOsV1fhcXPl4uamBUNG6NR/j5odCbhuFCQAAAAAgBtW0+smhcfNlcfNXooZFqnjh741OxJwQyhIAAAAAAA3xK2Wh8Ji5qiOzy2KjRijowcOmh0JuGEUJAAAAACA6+bi7qZh82fJ27+ZFkc+pyN7k8yOBJQJBQkAAAAA4LrYXFz0ZPQ0NWndSsvGTlLaZwlmRwLKjKfYAAAAAABKzWpz0qCZL6lFpyCteOFVpW7baXYkoFxQkAAAAAAASsViterxV17Qnffdo49enqG9azaYHQkoNxQkAAAAAIBS6ff8cwroFax1s+frixXxZscByhUFCQAAAACgRA+Pi1THfr21LXaJdrz9rtlxgHJHQQIAAAAA+EM9RgxT18GPa9e7K7Rx3iKz4wB2QUECAAAAALime0MGKDhiqPasWqc106PNjgPYDQUJAAAAAOCqOj7aRw+NHaXkTdu0cvJrMgzD7EiA3VCQAAAAAACuEPBgD/WdNE4HP/lc74+fIqOoyOxIgF1RkAAAAAAALnNnt67q/9IkfZv4pZY+O1GFBQVmRwLsjoIEAAAAAFCsRacgDZrxoo5+9bXeHvWcCvLyzI4EVAgKEgAAAACAJKlpQBs9GT1NJ45k6M0Rzyo/N9fsSECFoSABAAAAAMj3jts1bP4snck6odjw0cr9JdvsSECFoiABAAAAAAfn3byZwhbN0bkzZxUTOko5P582OxJQ4ShIAAAAAMCB1Wnkq/DYaBXk52tRaKTOnvjR7EiAKWxmBwAAAAAAmOOmBvU1/M25sjo5acGTI/RT5g9mRwJMQ0ECAAAAAA7Io46XwuPmyr1WLS0cOlInjmSYHQkwFQUJAAAAADgYd09PhcfOVe0G9RUb9rR++PqQ2ZEA01GQAAAAAIADca1RQ6ELX1d9v8Z6c+RYZexPNTsSUCnYbZFWV1dX7d69W8nJyTpw4IAmT5582fvPPvusDMNQnTp1irdFRUUpPT1daWlpCg4OLt4eEBCglJQUpaenKzo62l6RAQAAAKBac3Zz1ZA3Zsj3jtu0bOwkpSckmh0JqFQMe03NmjUNSYbNZjMSEhKMDh06GJIMX19fY9OmTUZGRoZRp04dQ5LRsmVLIzk52XBxcTH8/PyMw4cPG1ar1ZBk7N692+jYsaMhydiwYYPRs2dc3iOLAAAgAElEQVTPEr87JyfHbufFMAzDMAzDMAxT1cbJZjOGLZhlzNj/udHur38xPQ/DVNSUth+w62N+z507J0lydnaWs7OzDMOQJM2ePVvPPfdc8WtJ6t27t5YvX678/HxlZGTo8OHDCgoKkre3tzw9PZWQkCBJWrZsmfr06WPP2AAAAABQrVidnDRw2hS17HK3PnxxmpI2bjU7ElDp2LUgsVqtSkpK0smTJ7V161bt2bNHDz30kH744QelpKRc9lkfHx8dPXq0+HVmZqZ8fHzk4+OjzMzMK7ZfTWhoqBITE5WYmCibjeVVAAAAAMBiseixKePVJribVk+P1u6P1pgdCaiU7NoiFBUVqV27dqpdu7ZWrVqlP/3pT5o4ceJl64v8j8ViuWKbYRjX3H41cXFxiouLkyTl5OSUMT0AAAAAVH19xj+jwN4PaNP8OO16Z7nZcYBKq0Iuszh79qx27typ3r17q2nTptq/f78kydfXV19++aWCgoKUmZmpRo0aFe/j6+urY8eOKTMzU76+vldsBwAAAAD8sV5PR6jz4/20Y/F72hrzttlxgErNbrfY1K1bV7Vr15Ykubm56f7771dSUpIaNGigpk2bqmnTpsrMzFRAQIBOnDihNWvWqH///nJxcZGfn5/8/f21Z88eZWVlKTs7Wx06dJAkDR48WKtXr7ZXbAAAAACoFroPC1H3YYP1xYp4rXv9DbPjAJWe3a4gadiwoZYuXSonJydZrVatXLlS69evv+bnDx48qJUrV+rgwYMqKCjQyJEjVVRUJEmKiIjQkiVL5O7uro0bN2rjxo32ig0AAAAAVV7nAY+q19PDtW/dJsW/MtPsOECVYNGlx9lUOzk5OfLw8DA7BgAAAABUqKA+D+r/vTRRqds/0bJnJ6qosNDsSICpStsP2PUpNgAAAACAitOmR3c9OjlK33yeoHfGPU85AlwHChIAAAAAqAZadrlbA1+brIzkVC0eHaXCixfNjgRUKRQkAAAAAFDF3RoYoJDZr+rYoXS99dRYXbyQZ3YkoMqhIAEAAACAKqxx61Ya+sYMnfo+U7Hho3Uh55zZkYAqiYIEAAAAAKqoW27zV+jC1/XLjz9pUdjTOn/2F7MjAVUWBQkAAAAAVEH1mzZR2KI5yj+fq0Whkco+9ZPZkYAqjYIEAAAAAKqYm30aKjxuriRp4bBROn08y+REQNVnMzsAAAAAAKD0POvVVXjcXLm4uWnBkBE69d+jZkcCqgUKEgAAAACoImreVFvhcXPlcbOXYoZF6vihb82OBFQbFCQAAAAAUAW4edRU6KI5quNzi2IjxujogYNmRwKqFQoSAAAAAKjkXNzdNGz+LDX0v1WLI5/Tkb1JZkcCqh0KEgAAAACoxGwuLnoyepqatLlTy8ZOUtpnCWZHAqolnmIDAAAAAJWU1eakQTNfUotOQVrxwqtK3bbT7EhAtUVBAgAAAACVkMVq1eOvvKA777tH8a/M1N41G8yOBFRrFCQAAAAAUAn1e/45BfQK1vo5C/T58o/MjgNUexQkAAAAAFDJPDwuUh379da22CX6+K13zI4DOAQKEgAAAACoRIIjhqrr4Me1690V2jhvkdlxAIdBQQIAAAAAlUTXwY+rx4hh2rNqndZMjzY7DuBQKEgAAAAAoBLo+GgfPTwuUsmbtmnl5NdkGIbZkQCHQkECAAAAACYLeLCH+k4ap4OffK73x0+RUVRkdiTA4VCQAAAAAICJ7uzWVf1fmqRvE7/U0mcnqrCgwOxIgEOiIAEAAAAAk7ToFKRBM15U5ldpWhz5DxXk5ZkdCXBYFCQAAAAAYIKmAW30ZPQ0nTiSobgRzyjv/HmzIwEOjYIEAAAAACqY7x23a9j8WTqTdUKx4aOV+0u22ZEAh0dBAgAAAAAVqMGtTRUWM1vnzpxVTOgo5fx82uxIAERBAgAAAAAVpk4jXw2Pm6uCixe1KDRSZ0/8aHYkAL+ymR0AAAAAABzBTQ3qa/ibc2V1ctKCJ0fop8wfzI4E4DcoSAAAAADAzjzqeCk8bq7ca9XSwqEjdeJIhtmRAPwOBQkAAAAA2JG7p6fCY+eqdoP6ig0frR++PmR2JABXQUECAAAAAHbiWqOGQhe+rvp+jfXmyLHKSE4xOxKAa6AgAQAAAAA7sLm6asgbM+R7x21a+swEpSckmh0JwB/gKTYAAAAAUM6cbDY9MftVNWvfVh9MeFFf7fjU7EgASkBBAgAAAADlyOrkpIHTpqhll7v14YvTlLRxq9mRAJQCBQkAAAAAlBOLxaLHpoxXm+BuWj09Wrs/WmN2JAClREECAAAAAOWkz/hnFNj7AW2aH6dd7yw3Ow6A60BBAgAAAADloNfTEer8eD/tXPK+tsa8bXYcANeJggQAAAAAyqj7sBB1HzZYX6xcpbWz5pkdB8ANoCABAAAAgDLoPKCfej09XPvWbVL8yzPMjgPgBlGQAAAAAMANCuzzgB4Z/6xSt3+i5ZNelmEYZkcCcIMoSAAAAADgBrQO7qbHJo/XN58n6J1xz6uosNDsSADKgIIEAAAAAK5Tyy536+9TpygjOVWLR0ep8OJFsyMBKCMKEgAAAAC4DrcGBihk9qs6dihdbz01Vhcv5JkdCUA5oCABAAAAgFJq3LqVhr4xQz8d/UFxw8foQs45syMBKCcUJAAAAABQCrfc5q/Qha8r+9TPigmN1LkzZ82OBKAcUZAAAAAAQAnqN22isEVzlH8+VzHDRin71E9mRwJQzihIAAAAAOAPeN3irfC4uZKkhcNG6fTxLJMTAbAHm9kBAAAAAKCy8qxXV8PfnCcXNzctGDJCp/571OxIAOyEggQAAAAArqLmTbUVHhstj5u9FDMsUscPfWt2JAB2REECAAAAAL/j5lFToYvmqI6vj2IjxujogYNmRwJgZxQkAAAAAPAbLu5uGjZ/lhr636rFkc/pyN4ksyMBqAAUJAAAAADwK5uLi56MnqYmbe7UO+OeV9pnCWZHAlBBeIoNAAAAAEiy2pw0aOZLatEpSCteeFUpW3eYHQlABaIgAQAAAODwLFarHn/5ed153z2Kf2Wm9q7ZYHYkABWMggQAAACAw+v7/DgFPNBD6+cs0OfLPzI7DgATUJAAAAAAcGgPjR2lTv36aFvsEn381jtmxwFgEgoSAAAAAA4rOGKo7g0ZoF3vrtDGeYvMjgPARHYrSFxdXbV7924lJyfrwIEDmjx5siRp+vTp+vrrr7V//37Fx8erdu3axftERUUpPT1daWlpCg4OLt4eEBCglJQUpaenKzo62l6RAQAAADiQroMfV48Rw7Rn1Tqtmc5/ZwCQDHtNzZo1DUmGzWYzEhISjA4dOhh/+ctfDCcnJ0OSMXXqVGPq1KmGJKNly5ZGcnKy4eLiYvj5+RmHDx82rFarIcnYvXu30bFjR0OSsWHDBqNnz54lfndOTo7dzothGIZhGIZhmKo9HR/tY8xK/Y8xaObLhuXX/+5gGKZ6Tmn7AbveYnPu3DlJkrOzs5ydnWUYhrZu3arCwkJJUkJCgnx9fSVJvXv31vLly5Wfn6+MjAwdPnxYQUFB8vb2lqenpxISLj1/fNmyZerTp489YwMAAACoxgIe7KG+k8bp4Cef6/2oyTKKisyOBKASsGtBYrValZSUpJMnT2rr1q3as2fPZe8PGTJEGzdulCT5+Pjo6NGjxe9lZmbKx8dHPj4+yszMvGI7AAAAAFyvO7t1Vf+XJunbxC+19NmJKiwoMDsSgErCrgVJUVGR2rVrJ19fXwUFBalVq1bF702YMEEFBQV67733JEkWi+WK/Q3DuOb2qwkNDVViYqISExNls9nK6SwAAAAAVActOgVp0IwXlflVmhZH/kMFeXlmRwJQiVTIU2zOnj2rnTt3qmfPnpKkwYMH68EHH9TAgQOLP5OZmalGjRoVv/b19dWxY8eUmZlZfBvOb7dfTVxcnAIDAxUYGKgCmmAAAAAAv2rarrWejJ6mE0cyFDfiGeWdP292JACVjN0Kkrp16xY/ocbNzU3333+/0tLS1KNHD/3jH//Qww8/rNzc3OLPr1mzRv3795eLi4v8/Pzk7++vPXv2KCsrS9nZ2erQoYOkS+XK6tWr7RUbAAAAQDXje8dtGjp/ls5knVBs+Gjl/pJtdiQAlZDd7kNp2LChli5dKicnJ1mtVq1cuVLr169Xenq6XF1dtXXrVkmXFmqNiIjQwYMHtXLlSh08eFAFBQUaOXKkin5dLCkiIkJLliyRu7u7Nm7cWLxuCQAAAAD8kQa3NlVYzBydP/uLYkJHKefn02ZHAlBJWXTpcTbVTk5Ojjw8PMyOAQAAAMAkdRr56qmlC2UYhuaHROinzB/MjgTABKXtB1jJFAAAAEC1c1OD+hr+5lw52Wya/wTlCICSUZAAAAAAqFY86ngpPG6u3GvV0sKhI3XiSIbZkQBUARQkAAAAAKoNd09PhcfOVe0G9RUbPlo/fH3I7EgAqggKEgAAAADVgmuNGgpd+Lrq+zXWmyPHKiM5xexIAKoQChIAAAAAVZ7N1VVD5k2X7x23aekzE5SekGh2JABVjNXsAAAAAABQFk42m56Y/aqa3dVOH0x4UV/t+NTsSACqIAoSAAAAAFWW1clJA6dNUcsud+vDF6cpaeNWsyMBqKIoSAAAAABUSRaLRY9NGa82wd20eka0dn+0xuxIAKqwEtcg8ff317hx49SkSRPZbP/38e7du9s1GAAAAAD8kT7jn1Fg7we0eX6cdi1bbnYcAFVciQXJv/71L8XExCguLk6FhYUVkQkAAAAA/tBfI4er8+P9tHPJ+9oS87bZcQBUAyUWJAUFBYqJiamILAAAAABQom5DB+v+0BB9sXKV1s6aZ3YcANXENdcg8fLykpeXl9auXauIiAh5e3sXb/Py8qrIjAAAAAAgSeo8oJ8eGB2hfes2Kf7lGWbHAVCNWCQZV3vjyJEjMgxDFovlivcMw9Ctt95q72xlkpOTIw8PD7NjAAAAACgngX0eUP+XJil1+yda9uxEFbEEAIBSKG0/cM1bbJo1ayZJcnV1VV5e3mXvubq6ljEeAAAAAJRe6+BuemzyeH3zxW69M+55yhEA5a7Ex/x+8cUXpdoGAAAAAPbQssvd+vvUKcpITtWS0VEqvHjR7EgAqqFrXkHSoEED+fj4yN3dXW3bti2+1cbT01M1atSosIAAAAAAHNetgQEKmf2qjh1K11tPjVV+7gWzIwGopq5ZkPTo0UNPPPGEfH199frrrxdvz87O1oQJEyokHAAAAADH1bh1Kw19Y4Z+OvqD4oaP0YWcc2ZHAlCNXXOR1v/529/+pvj4+AqKU35YpBUAAACouhq2aK4Ri+fr/Jlf9EbIcGWf+snsSACqqDIv0vo/TZo00ZgxYy7bdvbsWe3bt0/79++/8YQAAAAAcBX1/BorPDZa+edzFTNsFOUIgApR4iKtd911l4YPHy4fHx/5+PgoLCxM9957r+Li4jRu3LiKyAgAAADAQXjd4q3hcXMlSQuHjdLp41kmJwLgKEq8xWbTpk3q27evzp27dL9fzZo19eGHH+qRRx7Rvn371KpVq4rIed24xQYAAACoWjzr1dXIpQtVw9NTC4aM0PFD35odCUA1UG632DRu3Fj5+fnFry9evKgmTZrowoULysvLK1tKAAAAAJBU86baCo+NlsfNXloUGkk5AqDClViQvP/++0pISNDq1aslSQ899JA++OAD1ahRQwcPHrR7QAAAAADVm5tHTYUumqM6vj6Kixij71P57wwAFa/EW2wkKSAgQJ07d5bFYtFnn32mffv2VUC0suEWGwAAAKDyc3F3U1jMHDX60x1a/PQ/lPbpf8yOBKCaKW0/cM2CpFatWsrOzpaXl9dVdzx9+nSZAtobBQkAAABQudlcXDT0jRlqHtRe74x7Xilbd5gdCUA1VOY1SN5//3099NBD2rdvnwzDkMViuex/b7311nINDAAAAMBxWG1OGjTjRbXoFKQPJr5EOQLAdKW6xaYq4goSAAAAoHKyWK0a8OoLCnigh+JfmanPl39kdiQA1Vhp+wFraQ42cOBATZo0SZLUqFEjBQYGli0dAAAAAIfV9/lxCnigh9bPWUA5AqDSKLEgWbBggTp16qQBAwZIkrKzszV//ny7BwMAAABQ/Tw0dpQ69eujbbFL9PFb75gdBwCKlfiY3w4dOqh9+/b68ssvJUlnzpyRi4uL3YMBAAAAqF6CI4bq3pAB+vS9ldo4b5HZcQDgMiVeQXLx4kVZrVYZxqWlSurWrauioiK7BwMAAABQfXQd/Lh6jBimPf9ep9XT5pgdBwCuUGJBMnfuXK1atUr169fXyy+/rM8++0yvvvpqRWQDAAAAUA107NdbD4+LVPLm7Vr5z9eK/89XAKhMSvUUm9tuu03du3eXxWLR9u3blZaWVgHRyoan2AAAAADmC3ggWI+/+k+lffofLRkdpcKCArMjAXAwpe0HSlWQWK1WNWjQQDbb/y1ZcvTo0TIFtDcKEgAAAMBcd3a7R4NnvaIj+5L15sixKsjLMzsSAAdU2n6gxEVan3rqKf3zn//UiRMnVFhYKIvFIsMw1KZNm3IJCgAAAKD6adEpUINmvKTMr9K0OPIflCMAKr0SryBJT09Xhw4d9PPPP1dQpPLBFSQAAACAOZq2a62wRdH68b/fa+HQp5T7S7bZkQA4sNL2AyUu0nr06FGdPXu2XEIBAAAAqN5877hNQ+fP0pmsE4oNH005AqDKuOYtNmPGjJEkHTlyRDt37tT69euV95vL4mbPnm3/dAAAAACqjAa3NlVYzBzl/pKtRaGRyvn5tNmRAKDUrlmQ1KpVS5L0/fff6/vvv5eLi4tcXFwqLBgAAACAqqNOI18Nj5urgosXFTNslM6cOGl2JAC4LqV6ik1VxBokAAAAQMW4qUF9jVwaI9ca7pr/RIROHMkwOxIAFCu3p9gAAAAAwLV41PFSeNxcuXvW0sKhIylHAFRZFCQAAAAAboi7p6fCF0WrdoP6ig0frR++PmR2JAC4YRQkAAAAAK6ba40aCl34uuo3baI3R45VRnKK2ZEAoExKfMyvv7+/tm3bptTUVEnSn/70J02cONHuwQAAAABUTjZXVw2ZN12+d9ymZWMnKT0h0exIAFBmJRYkcXFxGj9+vC5evChJSk1NVf/+/e0eDAAAAEDl42Sz6YnZr6rZXe30wcSX9NWOT82OBADlosSCpEaNGkpMvLwRLigosFsgAAAAAJWT1clJA6dNUcsud+ujl6YracMWsyMBQLkpsSA5deqUmjVrJsO49DTgvn376vjx43YPBgAAAKDysFgsenRylNoEd9PqGdFK+HC12ZEAoFyVuEjryJEjFRsbq9tvv12ZmZn67rvv9Pe//70isgEAAACoJPpEjVFQnwe1eX6cdi1bbnYcACh3FklGaT5Yo0YNWa1W5eTk2DlS+cjJyZGHh4fZMQAAAIAq76+Rw3V/aIh2Lnlfa2fNMzsOAFyX0vYDJd5iExkZqVq1aun8+fOaPXu29u3bp7/85S/lEhIAAABA5dZt6GDdHxqiL1auohwBUK2VWJAMGTJE2dnZCg4OVv369fXkk09q6tSpFZENAAAAgIk6D+inB0ZHaN+6TYp/eYbZcQDArkosSCwWiySpV69eWrx4sVJSUoq3AQAAAKieAvs8oEfGP6sDH3+i5c+/XPzQBgCorkosSPbt26fNmzerV69e2rx5szw8PFRUVFQR2QAAAACYoHVwNz02eby++WK3lo19XkUFhWZHAgC7K3GRVovForZt2+rIkSM6e/asbr75Zvn4+Cg1NbWCIt4YFmkFAAAArl/LLnfryehp+m/KAcVFjFF+7gWzIwFAmZS2H7jmY37btWt32etmzZqVPRUAAACASuvWwACFzH5Vxw6l662nxlKOAHAo17yC5OOPP77mToZhqHv37vbKVC64ggQAAAAovcZ/ukPhcXN15vgJLXhyhM6dOWt2JAAoF6XtB0q8xaaqoiABAAAASqdhi+YasXi+zp/5RW+EDFf2qZ/MjgQA5abMt9j8z6BBg666/Z133vnD/VxdXbVr1y65urrKZrPpww8/1OTJk+Xl5aUVK1bIz89PGRkZeuyxx3TmzBlJUlRUlIYOHarCwkJFRkZqy5YtkqSAgAAtWbJE7u7u2rBhg55++ukSTwwAAABAyer5NVZ4bLTyz+cqZtgoyhEADqvEp9gEBgYWT5cuXTR58mQ9/PDDJR44Ly9P3bp1U9u2bdW2bVv17NlTHTp0UFRUlLZv364WLVpo+/btioqKkiS1bNlS/fv3V6tWrdSzZ08tWLBAVuuleAsXLlRYWJj8/f3l7++vnj17lvG0AQAAAHjd4q3hcXMlSQuHjdLp41kmJwIA85R4BUlkZORlrz09PUu8euR/zp07J0lydnaWs7OzDMNQ7969de+990qSli5dqp07dyoqKkq9e/fW8uXLlZ+fr4yMDB3+/+zde1TVZd7+8QvYoiiKqCXFLjFHE51MzFP5Mxsz00461VOWE55CMBUwx8PQQeexKQ+ZoqUYWmrjIQ1PlaaZnaYULUEkQEHR3BJqjiWUSsD9+6OJR8cDmGy+7L3fr7U+a8nN/sK15V5G19r7/ubkqGPHjjpw4IDq1aunbdu2SZIWL16svn376oMPPric5wkAAADgLPWuaqSo+bPlW9tPcwYN1/cHD1kdCQAsVe4rSP7bzz//rObNm1fsi3t7KyUlRUePHtWHH36o7du3q3HjxsrP/7WZzs/P19VXXy1JCg4O1qFD//ePssPhUHBwsIKDg+VwOM5bBwAAAPD71KkfoMjX4+XfIFCJUaP03d4cqyMBgOXKfQXJunXrZMyv57j6+PgoNDRUK1asqNAXLy0tVVhYmAICArR69Wq1bt36oo/18vI6b80Yc9H1C4mIiNDQoUMlSTZbuU8NAAAA8Di1/OsoYt5MNbQHK3HYKH27O8PqSABQLZTbIrz88stlfy4uLtbBgwd1+PDhy/omP/74oz755BP16tVLR44cUVBQkPLz8xUUFKSjR49K+vWVIdddd13ZNXa7XXl5eXI4HLLb7eetX0hiYqISExMl/XpKLQAAAID/4+tXS0++Nl3XNG+mN2PGad9XKVZHAoBqo9y32Hz22Wfas2ePAgIC1KBBAxUXF1foCzdq1EgBAQGSpFq1aqlHjx7KysrSunXrNGDAAEnSgAEDtHbtWkm/vlKlX79+8vX1VUhIiJo3b67t27crPz9fBQUF6tSpkyQpPDy87BoAAAAAFWPz9dXAmZPV5OY/asm4Ccr6fKvVkQCg2jGXmiFDhpiDBw+aN9980yxcuNDk5uaaQYMGXfIaSeamm24yO3fuNLt27TK7d+82zz33nJFkGjRoYDZv3mz27t1rNm/ebAIDA8uuiYuLMzk5OSYrK8v06tWrbP2WW24xu3fvNjk5OWb27Nnlfm9JprCwsEKPYxiGYRiGYRh3H2+bjxkUP9lM373VtH/gHsvzMAzDVOVUtB/w+s8fLiorK0u33Xab/v3vf0uSGjRooC+//FItW7a81GWWKywslL+/v9UxAAAAAEt5eXvr8RefV7t779aqF6fri2XvWB0JAKpURfuBct9i43A4VFBQUPZxQUHBOXebAQAAAFB9PfTcGLW79269P3Mu5QgAXEK5h7QePnxYycnJWrt2rYwx6tOnj7Zv365Ro0ZJkmbMmOH0kAAAAAAu3/1/HalbH+6rzYmLtGXBYqvjAEC1Vm5Bsm/fPu3bt6/s498OSK1bt67zUgEAAAC4Ij2jBuuOAY/r8yUrtGFWgtVxAKDaK/cMElfFGSQAAADwVLeH91OfMTHavuY9rXj+RRnjlr/yA0CFVNoZJAAAAABcR+eH+6jPmBilbvxIKya8RDkCABVEQQIAAAC4iXb39tRDz41VxqdfaOn4iTKlpVZHAgCXQUECAAAAuIE/dr9d/V54Tvu/StGi0c+opLjY6kgA4FLKPaS1UaNGioiIUEhIiGy2/3v4kCFDnBoMAAAAQMW0uLWDnpg2SY5vsvTGyLEqPnPG6kgA4HLKLUjWrl2rzz//XJs3b1ZJSUlVZAIAAABQQU3D2mhQ/FQdzT2oxKee1pmff7Y6EgC4pHILktq1a2v8+PFVkQUAAADAZbC3ulFDXpuuH/KPaF5kjE6dLLA6EgC4rHLPIHnvvffUu3fvqsgCAAAAoIIaN2uqoQkzdepkgeZFRKvw+AmrIwGAS/OSdMn7fp08eVJ16tTRmTNn9Msvv8jLy0vGGAUEBFRRxN+novc5BgAAAFxNQ3uwhi+aK0l6bcAwHXcctjgRAFRfFe0Hyn2LTb169SolEAAAAIArV7/x1YqaP1u2GjX02kDKEQCoLOUWJJJUv359NW/eXLVq1Spb+/zzz50WCgAAAMD5/BsGKjJxlvzq1dXcIcN1ZP8BqyMBgNsotyAZMmSIYmJiZLfblZqaqs6dO2vr1q268847qyIfAAAAAEl+9eopcl68AhpfrdcjY3U4c6/VkQDArZR7SGtMTIw6dOiggwcPqnv37goLC9OxY8eqIhsAAAAASTVr11bE3Fd0ddMmWhg7TgdS06yOBABup9xXkJw+fVpnzpyRJPn6+mrPnj268cYbnR4MAAAAgGSrWVODZ0+VvdWNWvR0nPZu3WF1JABwS+UWJA6HQwEBAVqzZo0+/PBDnThxQnl5eVWRDQAAAPBoPjabBrzyD93QPkxL//Z3ffMx5wACgLOUe5vfs91+++0KCAjQBx98oF9++cWJsa4ct/kFAACAK/P28VH/KX9X27vv1Mq/T9a2d9ZaHQkAXNIV3+a3bt26KigoUGBgYNna7t27JUn+/v46ceJEJcQEAAAA8N+8vLz0PxPHq+3dd2rttHjKEQCoAhctSJYuXar7779fX3/9tYwx8vLyKvucMUbNmjWrkoAAAACAp+k7fpQ69r1PG19L1GeLl3DiiJ4AACAASURBVFsdBwA8wmW9xcaV8BYbAAAAuKLe0VHqETFAnyxcqnenz7Y6DgC4vCt+i01YWNglL0xJSbn8VAAAAAAuqvuQcPWIGKCtK9dQjgBAFbtoQTJ9+nRJUq1atdS+fXvt2rVLXl5eatOmjZKTk9W1a9cqCwkAAAC4u//3+MO6N3aYdr6/UUkvTLM6DgB4HO+LfaJ79+7q3r27Dh48qHbt2qlDhw5q3769wsLClJOTU5UZAQAAALfWoe+9+vPfRit9y6da9uwkmdJSqyMBgMe5aEHym5YtWyo9Pb3s42+++UZt27Z1aigAAADAU7Tp2V2PTPyb9nyZrMV/fU6lxSVWRwIAj3TRt9j8JjMzU4mJifrnP/8pY4z+8pe/KDMzsyqyAQAAAG6tZddb9ZfJf9eB1N1aGDteJb/8YnUkAPBY5d7FpmbNmho2bJhuv/12SdJnn32muXPn6syZM1WR73fjLjYAAACozpq1D1PE3BnK37dfCU+O1OnCn6yOBABuqaL9QIVu81urVi1df/312rt3b2VkqxIUJAAAAKiurr+plSITZ+mH745ozqCn9NMPP1odCQDcVkX7gXLPILn//vuVmpqqDz74QJJ08803a+3atVeeEAAAAPBA17T4gyISZqjw+AklRERTjgBANVFuQTJhwgR17NhRP/zwgyRp165dCgkJcXYuAAAAwO1cFXK9Il+PV9HPp5QQMVIF3x+3OhIA4D/KLUiKi4t18uTJqsgCAAAAuK3Aa4MUlThLkpQQEa0TefkWJwIAnK3cu9ikp6frsccek4+Pj/7whz8oOjpaX375ZVVkAwAAANxCvasaKWr+bPnW9tOcQcN17MC3VkcCAPyXcl9BMnLkSLVu3VpnzpzRsmXLdPLkScXGxlZFNgAAAMDl1akfoMjX4+XfIFCJUaP03d4cqyMBAC6gQnexcUXcxQYAAABWq+VfR1ELXlXQDU2VOGyU9n2VYnUkAPA4Fe0Hyn2LzS233KK4uDiFhITIZvu/h998881XlhAAAABwY75+tfTka9N1TfNmejNmHOUIAFRz5RYkS5Ys0ZgxY7R7926VlpZWRSYAAADApdl8fTVw5mQ1ufmPemvs88r6fKvVkQAA5Si3IDl27JjefffdqsgCAAAAuDxvm4+emPa/uvG2Tlr+7CSlbdpidSQAQAWUewZJ9+7d9dhjj+mjjz7SmTNnytZXr17t7GxXhDNIAAAAUNW8vL31+IvPq929d2vVi9P1xbJ3rI4EAB6v0s4gGTRokFq2bKkaNWqUvcXGGFPtCxIAAACgqj307Bi1u/duvT9zLuUIALiYcguSm2++WW3atKmKLAAAAIDLun/0SN36P321OXGRtixYbHUcAMBl8i7vAdu2bVNoaGhVZAEAAABcUs+owbpj4OP6fMkKbZiVYHUcAMDvUO4ZJBkZGWrWrJlyc3N15swZeXl5yRhT7W/zyxkkAAAAqAq3h/dTnzEx2r7mPa14/kUZc8lfrwEAVazSziDp1atXpQQCAAAA3E3nh/uoz5gYpW78SCsmvEQ5AgAurNyC5Ntvv62KHAAAAIBLaXdvTz303FhlfPaFlo6fKPOfGxoAAFxTuWeQAAAAADjXH7vfrn4vPKf9X6Vo0dPPqKS42OpIAIArREECAAAAXIYWt3bQE9MmyfFNlt4YOVbFZ85YHQkAUAkoSAAAAIAKahrWRoPip+po7kElPvW0zvz8s9WRAACVhIIEAAAAqAB7qxs15LXp+iH/iOZFxujUyQKrIwEAKhEFCQAAAFCOxs2aamjCTJ06WaB5EdEqPH7C6kgAgEpGQQIAAABcQkN7sCJfj1fxL78o4cmR+uHIUasjAQCcoNzb/AIAAACeqn7jqxU1f7ZsNWrotUFP6bjjsNWRAABOQkECAAAAXIB/w0BFJs6SX726SnhyhI7sy7U6EgDAiShIAAAAgP/iV6+eIufFq35QY70eGSNHxh6rIwEAnIyCBAAAADhLzdq1FTFnuq5u2kQLRvxVuSlpVkcCAFQBChIAAADgP2w1a2rw7Kmyt26pRU/Hae/WHVZHAgBUEe5iAwAAAEjysdk04JV/6Ib2YVr2zCR98/HnVkcCAFQhpxUkdrtdW7ZsUUZGhtLT0xUdHS1Juvnmm7V161alpKRox44d6tChQ9k148ePV3Z2trKystSzZ8+y9Xbt2iktLU3Z2dmKj493VmQAAAB4KG8fHz0+eaJa3d5FSZOmKmX9JqsjAQAsYJwxQUFBJiwszEgy/v7+Zs+ePSY0NNRs3LjR9OrVy0gyvXv3Nh9//LGRZEJDQ01qaqrx9fU1ISEhJicnx3h7extJJjk52XTu3NlIMuvXry+7/lJTWFjolOfFMAzDMAzDuNd4eXmZRyc9Y6bv3mpuD+9neR6GYRimcqei/YDTXkGSn5+vlJQUSVJhYaEyMzMVHBwsY4zq1asnSQoICFBeXp4kqU+fPlq+fLmKiop04MAB5eTkqGPHjgoKClK9evW0bds2SdLixYvVt29fZ8UGAACAh+k7fpQ69r1PG+fM12eLl1sdBwBgkSo5pLVJkyYKCwtTcnKyYmNjtXHjRr388svy9vbWbbfdJkkKDg4uK0EkyeFwKDg4WL/88oscDsd56wAAAMCV6h0dpf/3+P/ok0VLtWnuAqvjAAAs5PRDWuvUqaOkpCTFxsaqoKBAw4YN06hRo3T99ddr1KhRWrDg1/8QeXl5nXetMeai6xcSERGhHTt2aMeOHbLZuEEPAAAALq77kHD1iBigrSvX6N2XZ1sdBwBgMacWJDabTUlJSVqyZIlWr14tSRowYIBWrVolSVq5cqU6duwo6ddXhlx33XVl19rtduXl5cnhcMhut5+3fiGJiYnq0KGDOnTooOLiYmc9LQAAALi4Lo89rHtjh2nn+xuV9MI0q+MAAKoBpxYkCxYsUGZmpmbMmFG2lpeXp27dukmSunfvruzsbEnSunXr1K9fP/n6+iokJETNmzfX9u3blZ+fr4KCAnXq1EmSFB4errVr1zozNgAAANxYhz736MG40Urf8qmWPTtJprTU6kgAgGrAae9D6dKli8LDw5WWllZ2WGtcXJwiIiIUHx8vm82m06dPa+jQoZKkjIwMrVixQhkZGSouLtbw4cNV+p//WA0bNkwLFy6Un5+fNmzYoA0bNjgrNgAAANxYm57d9cjf47Tny2Qt/utzKi0usToSAKCa8NKvt7NxO4WFhfL397c6BgAAAKqJll1v1eD4qTqYlq7EYaNUdOq01ZEAAFWgov2A0w9pBQAAAKzWrH2YBr7ykvKyc7RgxF8pRwAA56EgAQAAgFu7/qZWGvzqNB13HFZiZKxOF/5kdSQAQDVEQQIAAAC3dU2LPygiYYYKj5/QvKEx+umHH62OBACopihIAAAA4JauCrleka/Hq+jnU0qIGKmTx763OhIAoBqjIAEAAIDbCbw2SFGJsyRJCRHROpGXb3EiAEB157Tb/AIAAABWqNuooaISZ8u3tp/mDBquYwe+tToSAMAFUJAAAADAbdSpH6CoxFnybxioeRHR+m5vjtWRAAAugoIEAAAAbqGWfx1FzJuphvZgJQ4bpW93Z1gdCQDgQihIAAAA4PJ8/Wrpydem69rmf9CbMeO076sUqyMBAFwMBQkAAABcms3XVwNnTlaTm/+ot8Y+r8zPv7Q6EgDABXEXGwAAALgsb5uPnpj2v7rxtk5aMeFFpW3aYnUkAICLoiABAACAS/Ly8lK/Sc/qj927adWL07Vj7XqrIwEAXBgFCQAAAFzSg8+O0S339dL7M+fqi2XvWB0HAODiKEgAAADgcu4fPVK3PfJnbU5cpC0LFlsdBwDgBihIAAAA4FJ6Rg3WHQMf17+WrtSGWQlWxwEAuAkKEgAAALiM28P76e7hEdq+5j2tmTzD6jgAADdCQQIAAACX0PnhPuozJka7Nm3RyomTZYyxOhIAwI1QkAAAAKDaa3dvTz303FhlfPaFloyboNKSEqsjAQDcDAUJAAAAqrXWf+qqfi88p/1fpWjR08+opLjY6kgAADdEQQIAAIBqq8WtHRT+8gtyfJOlN0aOVfGZM1ZHAgC4KQoSAAAAVEtNw9po4MwpOpp7UIlPPa0zP/9sdSQAgBujIAEAAEC1Y291o4a8Nl0/HjmqeZExOnWywOpIAAA3R0ECAACAaqVxs6YamjBTp04WaF5EtAqPn7A6EgDAA1CQAAAAoNpoaA9W5OvxKikuVkJEtH44ctTqSAAAD2GzOgAAAAAgSfUbX62o+bNlq1FDrw16SscPOayOBADwIBQkAAAAsJx/g0BFJs6SX726SnhyhI7sy7U6EgDAw1CQAAAAwFJ+9epq6LyZqh/UWK9HxsiRscfqSAAAD0RBAgAAAMvUrF1bEXNeUeMbQrRgxF+Vm5JmdSQAgIeiIAEAAIAlbDVravDsqbK3bqlFT8dp79YdVkcCAHgw7mIDAACAKudjs2nAK//QDe3DtPzZSfrm48+tjgQA8HAUJAAAAKhS3j4+enzyRLW6vYuSJk3Vzvc3WR0JAAAKEgAAAFQdLy8v/c/E8Wp7951aN22Wtr2z1upIAABIoiABAABAFeozLlYd+96njXPm69PFy6yOAwBAGQoSAAAAVIneIyPVtf8j+mTRUm2au8DqOAAAnIOCBAAAAE7XfcgT6jF0oLauXKN3X55tdRwAAM5DQQIAAACn6vLYw7o39intfH+jkl6YZnUcAAAuiIIEAAAATtOhzz16MG600rd8qmXPTpIpLbU6EgAAF0RBAgAAAKdo07O7Hvl7nPZu3a63xjyv0uISqyMBAHBRFCQAAACodC273qq/TP67Du5K15sx41RcVGR1JAAALomCBAAAAJWqWfswDXzlJeVl52j+8NEqOnXa6kgAAJSLggQAAACV5vqbWmnwq9N03HFYiZGxOl34k9WRAACoEAoSAAAAVIprWjRTxNwZKjx+QvOGxuinH360OhIAABVGQQIAAIArdlXI9Yp8fZaKTp1SQsRInTz2vdWRAAC4LBQkAAAAuCKB1wYpKnGWJCkhIlon8vItTgQAwOWzWR0AAAAArqtuo4aKSpwt39p+mjNouI4d+NbqSAAA/C4UJAAAAPhd6tQPUFTiLNVt1EAJEdH6bm+O1ZEAAPjdKEgAAABw2Wr511HEvJlqaA9W4lNP69u0b6yOBADAFaEgAQAAwGXx9aulJ1+brmub/0FvxozTvh07rY4EAMAVoyABAABAhfnUqKGBMyeryc1/1Ftjn1fm519aHQkAgErBXWwAAABQId42Hz0xbZJuvK2TVkx4UWmbtlgdCQCASkNBAgAAgHJ5eXmp36RnddOd3bTqxenasXa91ZEAAKhUFCQAAAAo14PPjtEt9/XS+zPn6otl71gdBwCASkdBAgAAgEu6f/RI3fbIn/XR/MXasmCx1XEAAHAKChIAAABcVM+owbpj4OP619KVWh8/1+o4AAA4DQUJAAAALuj28H66e3iEtq95T2smz7A6DgAATkVBAgAAgPN0friP+oyJ0a5NW7Ry4mQZY6yOBACAU1GQAAAA4Bxh9/TUQ8+NVcZnX2jJuAkqLSmxOhIAAE7ntILEbrdry5YtysjIUHp6uqKjo8s+N2LECGVlZSk9PV1TpkwpWx8/fryys7OVlZWlnj17lq23a9dOaWlpys7OVnx8vLMiAwAAeLzWf+qqx/7xnPZ/laJFTz+jkuJiqyMBAFBljDMmKCjIhIWFGUnG39/f7Nmzx4SGhpo77rjDfPjhh8bX19dIMldddZWRZEJDQ01qaqrx9fU1ISEhJicnx3h7extJJjk52XTu3NlIMuvXrze9evUq9/sXFhY65XkxDMMwDMO467S4tYOZ8vWnJvqfiaZm7dqW52EYhmGYypiK9gNOewVJfn6+UlJSJEmFhYXKzMxUcHCwhg0bpsmTJ6uoqEiSdOzYMUlSnz59tHz5chUVFenAgQPKyclRx44dFRQUpHr16mnbtm2SpMWLF6tv377Oig0AAOCRmoa10cCZU3Q096ASnxqtMz//bHUkAACqVJWcQdKkSROFhYUpOTlZLVq0UNeuXbVt2zZ98sknat++vSQpODhYhw4dKrvG4XAoODhYwcHBcjgc560DAACgcthb3aghr03Xj0eOal5kjE6dPGl1JAAAqpzN2d+gTp06SkpKUmxsrAoKCmSz2RQYGKjOnTurQ4cOWrFihW644QZ5eXmdd60x5qLrFxIREaGhQ4dKkmw2pz81AAAAl9e4WVMNTZipUycLNC8iWoXHT1gdCQAASzj1FSQ2m01JSUlasmSJVq9eLenXV4CsWrVKkrRjxw6VlpaqUaNGcjgcuu6668qutdvtysvLk8PhkN1uP2/9QhITE9WhQwd16NBBxRwoBgAAcEkN7cGKfD1eJcXFSoiI1g9HjlodCQAAyzi1IFmwYIEyMzM1Y8aMsrU1a9aoe/fukqTmzZvL19dX33//vdatW6d+/frJ19dXISEhat68ubZv3678/HwVFBSoU6dOkqTw8HCtXbvWmbEBAADcXkDjqxQ1f7ZsNWooISJaxw85yr8IAAA35rT3oXTp0kXh4eFKS0srO6w1Li5Ob7zxht544w3t3r1bRUVFGjBggCQpIyNDK1asUEZGhoqLizV8+HCVlpZKkoYNG6aFCxfKz89PGzZs0IYNG5wVGwAAwO35NwhUVOJs+dWrq4QnR+jIvlyrIwEAYDkv/Xo7G7dTWFgof39/q2MAAABUK3716mrYgld1VZPr9XpkjHJT0qyOBACAU1W0H+AkUwAAAA9Rs3ZtRcx5RY1vCNGCEX+lHAEA4CwUJAAAAB7AVrOmBs+eKnvrllo8+hnt3brD6kgAAFQrTj2kFQAAANbzsdk04JV/6Ib2YVr+7CSlb/nM6kgAAFQ7FCQAAABuzMvbW49PnqhWt3dR0qSp2vn+JqsjAQBQLVGQAAAAuCkvLy89MvFvanv3nVo3bZa2vbPW6kgAAFRbFCQAAABuqs+4WHX8833aOGe+Pl28zOo4AABUaxQkAAAAbqj3yEh17f+IPlm0VJvmLrA6DgAA1R4FCQAAgJvpPuQJ9Rg6UFvfWaN3X55tdRwAAFwCBQkAAIAb6fLYw7o39intfH+jkiZNszoOAAAug4IEAADATXToc48ejBut9C2fatmzk2RKS62OBACAy6AgAQAAcANtenbXI3+P096t2/XWmOdVWlxidSQAAFwKBQkAAICLa9n1VvWfPFEHd6XrzZhxKi4qsjoSAAAuh4IEAADAhTVrH6aBr7yk77L3af7w0So6ddrqSAAAuCQKEgAAABd1/U2tNPjVaTruOKzEyFidLvzJ6kgAALgsChIAAAAXdE2LZoqYO0OFx09o3tAY/fTDj1ZHAgDApVGQAAAAuJirQq5X5OuzVHT6tBIiRurkse+tjgQAgMujIAEAAHAhgdcGKSpxliRpXkS0TuTlW5wIAAD3YLM6AAAAACqmbqOGikqcLd/afpozaLiO5h60OhIAAG6DggQAAMAF1KkfoKjEWarbqIESIqL13d4cqyMBAOBWKEgAAACquVr+dRSRMEMN7cFKfOppfZv2jdWRAABwOxQkAAAA1ZivXy0NefVlXduiud6MGad9O3ZaHQkAALdEQQIAAFBN+dSooYEzJyuk7U16a+zzyvz8S6sjAQDgtriLDQAAQDXkbfPRE9Mm6cbbOmnFxJeUtmmL1ZEAAHBrFCQAAADVjJeXl/pNelY33dlNq1+arh1r3rc6EgAAbo+CBAAAoJp58NkxuuW+Xlofn6B/LX3H6jgAAHgEChIAAIBq5P7RI3XbI3/WR/MX66P5i6yOAwCAx6AgAQAAqCbuihqsOwY+rn8tXan18XOtjgMAgEehIAEAAKgGbn+in3oNj9D2Ne9pzeQZVscBAMDjUJAAAABYrNNDD6jP2Bjt2rRFKydOljHG6kgAAHgcChIAAAALhd3TUw8/P04Zn32hJeMmqLSkxOpIAAB4JAoSAAAAi7T+U1c99o/ntP/rVC16+hmVFBdbHQkAAI9FQQIAAGCBFrd2UPjLL8iRsUdvjBij4jNnrI4EAIBHoyABAACoYk3D2mjgzCk6mntQicOe1pmff7Y6EgAAHo+CBAAAoAoFh7bQkNem68cjRzUvMkanTp60OhIAABAFCQAAQJVpfEOIIufF69TJAs2LiFbh8RNWRwIAAP9BQQIAAFAFGtqDFZk4SyXFxUqIiNYPR45aHQkAAJzFZnUAAAAAdxfQ+CpFzZ8tW40aem3QUzp+yGF1JAAA8F8oSAAAAJzIv0GgohJnq3ZAPc0dMlxH9uVaHQkAAFwABQkAAICT+NWrq6HzZqp+UGO9HhUrR8YeqyMBAICLoCABAABwgpq1aytizitqfEOIFowYo9ydu6yOBAAALoGCBAAAoJLZatbUoFlTZG/dUotHP6O9W7dbHQkAAJSDu9gAAABUIh+bTQOm/0PNOrTT8mcnKX3LZ1ZHAgAAFUBBAgAAUEm8vL31+EsT1KpbFyVNmqqd72+yOhIAAKggChIAAIBK4OXlpUcm/k1te/XQummztO2dtVZHAgAAl4GCBAAAoBL0GRerjn++TxvnzNeni5dZHQcAAFwmChIAAIAr1HtkpLr2f0SfLl6mTXMXWB0HAAD8DhQkAAAAV6D7kCfUY+hAbX1njdZNm2V1HAAA8DtRkAAAAPxOXR57WPfGPqWd729U0qRpVscBAABXgIIEAADgd2j/wD16MG600rd8qmXPTpIpLbU6EgAAuAIUJAAAAJepzV1/0qP/G6e9W7frrTHPq7S4xOpIAADgClGQAAAAXIaWXW9V/yl/18Fd6XozZpyKi4qsjgQAACoBBQkAAEAFNWsfpoGvvKTvsvdp/vDRKjp12upIAACgklCQAAAAVMD1N7XS4Fen6bjjsBIjY3W68CerIwEAgEpEQQIAAFCOa1o0U8TcGSr89wnNGxqjn3740epIAACgklGQAAAAXMJVIdcr8vVZKjp9WglPjtTJY99bHQkAADgBBQkAAMBFBF4TpKjEWZKkeRHROpGXb3EiAADgLDarAwAAAFRHdRs1VNT82fKt7ac5g4braO5BqyMBAAAnctorSOx2u7Zs2aKMjAylp6crOjr6nM+PHj1axhg1bNiwbG38+PHKzs5WVlaWevbsWbberl07paWlKTs7W/Hx8c6KDAAAIEmqUz9Aka/Hq26jBkoc9rS+25tjdSQAAFAFjDMmKCjIhIWFGUnG39/f7Nmzx4SGhhpJxm63mw8++MAcOHDANGzY0EgyoaGhJjU11fj6+pqQkBCTk5NjvL29jSSTnJxsOnfubCSZ9evXm169epX7/QsLC53yvBiGYRiGce+p5V/HxC5/w0ze8Ylp1qGd5XkYhmEYhrmyqWg/4LRXkOTn5yslJUWSVFhYqMzMTAUHB0uSZsyYobFjx8oYU/b4Pn36aPny5SoqKtKBAweUk5Ojjh07KigoSPXq1dO2bdskSYsXL1bfvn2dFRsAAHgwX79aGvLqy7q2RXMtejpO+3bstDoSAACoIlVySGuTJk0UFham5ORk3X///Tp8+LDS0tLOeUxwcLAOHTpU9rHD4VBwcLCCg4PlcDjOW7+QiIgI7dixQzt27JDNxvEqAACg4nxq1NDAmZMV0vYmLfnbRGV+/qXVkQAAQBVyeotQp04dJSUlKTY2VsXFxXrmmWfOOV/kN15eXuetGWMuun4hiYmJSkxMlPTrq1YAAAAqwtvmoyemTdKNt3XS8ude0K6NH1kdCQAAVDGnvoLEZrMpKSlJS5Ys0erVq9WsWTM1bdpUu3btUm5urux2u3bu3KnGjRvL4XDouuuuK7vWbrcrLy9PDodDdrv9vHUAAIDK4OXlpX6TntVNd3bT6pema8ea962OBAAALOK0g1AWLVpkZsyYcdHP5+bmlh3S2qpVq3MOad23b1/ZIa3bt283nTp1MtKvh7T27t270g5hYRiGYRjGs+ehZ8eY6bu3mjufHGB5FoZhGIZhKn8q2g847S02Xbp0UXh4uNLS0soOa42Li9OGDRsu+PiMjAytWLFCGRkZKi4u1vDhw1VaWipJGjZsmBYuXCg/Pz9t2LDhol8DAADgctz39Ajd9uiD+mj+Yn00f5HVcQAAgIW89GtT4nYKCwvl7+9vdQwAAFBN3RU1WL2GR+hfS1dq9UuvWB0HAAA4SUX7gSq5iw0AAEB1cvsT/dRreIR2rH1faybPsDoOAACoBihIAACAR+n00APqMzZGuzZt0YoJL1307ngAAMCzUJAAAACPEXZPTz38/Dhlfv6lloyboNKSEqsjAQCAaoKCBAAAeITWf+qqx/7xnPZ/naqFo+JUUlxsdSQAAFCNUJAAAAC317xzB4W//IIcGXv0xogxKj5zxupIAACgmqEgAQAAbi2kbRsNip+io7kHlTjsaZ35+WerIwEAgGqIggQAALit4NAWenLOdP145KjmRcbo1MmTVkcCAADVFAUJAABwS41vCFHkvHidOlmgeRHRKjx+wupIAACgGqMgAQAAbqehPViRibNUUlyshIho/XDkqNWRAABANWezOgAAAEBlCmh8laLmz5bN11dzBj2l44ccVkcCAAAugIIEAAC4Df8GgYpKnK3aAfU0d8gI5efstzoSAABwERQkAADALfjVq6uh82aqflBjvR4VK0dGltWRAACAC6EgAQAALq9m7dp6cs50Nb4hRAtGjFHuzl1WRwIAAC6GggQAALg0W82aGjRriq5rHarFo5/R3q3brY4EAABcEHexAQAALsvHZtOA6f9Qsw7ttPzZSUrf8pnVkQAAgIuiIAEAAC7Jy9tbj780Qa26dVHSC9O08/1NVkcCAAAujIIEAAC4HC8vLz0y8W9q26uH3n15tratXGN1JAAA4OIoSAAAgMvpMy5WHf98nzbNXaBPFi21Og4AAHADFCQAAMClGIeerwAAFk5JREFU9B4Zqa79H9Gni5dp45z5VscBAABugoIEAAC4jO5DnlCPoQO19Z01WjdtltVxAACAG6EgAQAALqFLv4d0b+xT2vn+RiVNmmZ1HAAA4GYoSAAAQLXX/oF79OAzf1X6lk+17NlJMqWlVkcCAABuhoIEAABUa23u+pMe/d847d26XW+NeV6lxSVWRwIAAG6IggQAAFRbLbveqv5T/q6Dad/ozZhxKi4qsjoSAABwUxQkAACgWmrWPkwDX3lJ+dn7NX/4aBWdOm11JAAA4MYoSAAAQLVz/U2tNPjVaTp+OE+vR8XqdEGh1ZEAAICboyABAADVyjUtmili7gwV/vuE5kVE66cTP1gdCQAAeAAKEgAAUG00anKdIl+fpaLTp5Xw5EidPPa91ZEAAICHoCABAADVQuA1QYpKnCVJmhcRrRN5+RYnAgAAnsRmdQAAAIC6jRoqav5s1axTW3MGDdfR3INWRwIAAB6GggQAAFiqTv0ARb4er7qNGighIlrf7c2xOhIAAPBAFCQAAMAytfzrKCJhhhpdb9f8p0br27RvrI4EAAA8FAUJAACwhK9fLQ159WVd26K53owZp5ztX1sdCQAAeDAKEgAAUOV8atTQwBkvKaTtTfrnuAnK/PxLqyMBAAAPx11sAABAlfL28dFfpv6vbuzSWSsmvqRdGz+yOhIAAAAFCQAAqDpeXl56dNIzatPjDq1+abp2rHnf6kgAAACSKEgAAEAVevCZv6r9/b21Pj5B/1r6jtVxAAAAylCQAACAKnHf0yN026MP6qP5i/XR/EVWxwEAADgHBQkAAHC6u6IG60+D+utfy97R+vi5VscBAAA4DwUJAABwqtuf6KdewyO0Y+37WvPSK1bHAQAAuCAKEgAA4DSdHnpAfcbGaNemLVox4SUZY6yOBAAAcEEUJAAAwCnCet+lh58fp8zPv9SScRNUWlJidSQAAICLoiABAACVrvUd/0+Pvfi89n+dqoWj4lRSXGx1JAAAgEuiIAEAAJWqeecOCp/+Dzky9uiNEWNUfOaM1ZEAAADKRUECAAAqTUjbNhoUP0VHcw8qcdjTOvPzz1ZHAgAAqBAKEgAAUCmCQ1voyTnTdfLoMc2LjNGpkyetjgQAAFBhFCQAAOCKNb4hRJHz4nWqoEAJEdEqPH7C6kgAAACXhYIEAABckYb2YEUmzlJJcbESnozWD/lHrI4EAABw2WxWBwAAAK4roPFVikycJZuvr+YMekrHDzmsjgQAAPC7UJAAAIDfxb9BoKISZ6tO/QDNHTJC+Tn7rY4EAADwu1GQAACACgu7p6fuiYlSYFBjlZSUSMYoISJajowsq6MBAABcEQoSAABQIWH39NQjE8fL189PkmTz9tYvZ86oflBji5MBAABcOQ5pBQAAFXJPTFRZOfKbGjVr6p6YKIsSAQAAVB4KEgAAUCGBF3mlyMXWAQAAXAkFCQAAqJATF7l978XWAQAAXAkFCQAAqJD18QkqOnXqnLWiU6e0Pj7BokQAAACVx2kFid1u15YtW5SRkaH09HRFR0dLkqZOnarMzEzt2rVLq1atUkBAQNk148ePV3Z2trKystSzZ8+y9Xbt2iktLU3Z2dmKj493VmQAAHAJKes3acXEyfp33ncypaX6d953WjFxslLWb7I6GgAAQKUwzpigoCATFhZmJBl/f3+zZ88eExoaau666y7j4+NjJJnJkyebyZMnG0kmNDTUpKamGl9fXxMSEmJycnKMt7e3kWSSk5NN586djSSzfv1606tXr3K/f2FhoVOeF8MwDMMwDMMwDMMwrjMV7Qec9gqS/Px8paSkSJIKCwuVmZmp4OBgffjhhyopKZEkbdu2TXa7XZLUp08fLV++XEVFRTpw4IBycnLUsWNHBQUFqV69etq2bZskafHixerbt6+zYgMAAAAAAA9UJWeQNGnSRGFhYUpOTj5nffDgwdqwYYMkKTg4WIcOHSr7nMPhUHBwsIKDg+VwOM5bBwAAAAAAqCw2Z3+DOnXqKCkpSbGxsSooKChbj4uLU3FxsZYsWSJJ8vLyOu9aY8xF1y8kIiJCQ4cOlSTZbE5/agAAAAAAwE04tUWw2WxKSkrSkiVLtHr16rL18PBw3XfffbrzzjvL1hwOh6677rqyj+12u/Ly8uRwOMrehnP2+oUkJiYqMTFR0q9v6wEAAAAAAKgIp77FZsGCBcrMzNSMGTPK1u6++26NGzdODzzwgE6ddavAdevWqV+/fvL19VVISIiaN2+u7du3Kz8/XwUFBerUqZOkX8uVtWvXOjM2AAAAAADwME57BUmXLl0UHh6utLS0ssNa4+LiNGvWLNWsWVMffvihpF8Pah02bJgyMjK0YsUKZWRkqLi4WMOHD1dpaakkadiwYVq4cKH8/Py0YcOGsnNLAAAAAAAAKoOXfr2djdspLCyUv7+/1TEAAAAAAICFKtoPVMldbAAAAAAAAKozChIAAAAAAODxKEgAAAAAAIDHoyABAAAAAAAej4IEAAAAAAB4PAoSAAAAAADg8ShIAAAAAACAx6MgAQAAAAAAHo+CBAAAAAAAeDwKEgAAAAAA4PEoSAAAAAAAgMejIAEAAAAAAB6PggQAAAAAAHg8ChIAAAAAAODxvCQZq0M4Q0lJiU6dOmV1DFQDNptNxcXFVsdANcF+wNnYD/gNewFnYz/gN+wFnI394Lr8/Pzk4+NToccad5wdO3ZYnoGpHsNeYM4e9gNz9rAfmN+GvcCcPewH5rdhLzBnD/vB/Ye32AAAAAAAAI9HQQIAAAAAADyej6SJVodwlp07d1odAdUEewFnYz/gbOwH/Ia9gLOxH/Ab9gLOxn5wb257SCsAAAAAAEBF8RYbAAAAAADg8dyuILn77ruVlZWl7OxsjRs3zuo4qCR2u11btmxRRkaG0tPTFR0dLUkKDAzUpk2btHfvXm3atEn169cvu2b8+PHKzs5WVlaWevbsWbberl07paWlKTs7W/Hx8WXrvr6+Wr58ubKzs7Vt2zY1adKk6p4gLpu3t7d27typd999VxJ7wZMFBARo5cqVyszMVEZGhjp37sx+8GCxsbFKT0/X7t27tXTpUtWsWZP94EEWLFigI0eOaPfu3WVrVfXzDw8P1969e7V3716Fh4c7+ZmiPBfaC1OnTlVmZqZ27dqlVatWKSAgoOxz7AX3dqH98JvRo0fLGKOGDRuWrbEfPJvlt9KprPH29jY5OTmmadOmpkaNGiY1NdWEhoZanou58gkKCjJhYWFGkvH39zd79uwxoaGhZsqUKWbcuHFGkhk3bpyZPHmykWRCQ0NNamqq8fX1NSEhISYnJ8d4e3sbSSY5Odl07tzZSDLr1683vXr1MpLMsGHDzNy5c40k8+ijj5rly5db/ryZi8+oUaPMkiVLzLvvvmsksRc8eBYuXGiGDBliJJkaNWqYgIAA9oOHzrXXXmv2799vatWqZSSZt99+2wwYMID94EHTtWtXExYWZnbv3l22VhU//8DAQLNv3z4TGBho6tevb/bt22fq169v+d+HJ8+F9sJdd91lfHx8jCQzefJk9oIHzYX2gyRjt9vNBx98YA4cOGAaNmzIfmCMqkGASpvOnTubDz74oOzj8ePHm/Hjx1uei6n8WbNmjenRo4fJysoyQUFBRvq1RMnKyrrgz/6DDz4wnTt3NkFBQSYzM7NsvV+/fiYhIeGcx0gyPj4+5tixY5Y/T+bCExwcbDZv3mz+9Kc/lRUk7AXPnLp165r9+/eft85+8My59tprzbfffmsCAwONj4+Peffdd81dd93FfvCwadKkyTn/E1QVP/+zHyPJJCQkmH79+ln+d+Hp89974ezp27ev+ec//8le8KC50H5YuXKladOmjcnNzS0rSNgPnj1u9Rab4OBgHTp0qOxjh8Oh4OBgCxPBGZo0aaKwsDAlJyercePGys/PlyTl5+fr6quvlnTxvRAcHCyHw3He+n9fU1JSoh9//PGcl9qh+pg5c6bGjh2r0tLSsjX2gme64YYbdOzYMb355pvauXOnEhMTVbt2bfaDh8rLy9PLL7+sb7/9Vt99951+/PFHffjhh+wHD1cVP39+B3U9gwcP1oYNGySxFzzV/fffr8OHDystLe2cdfaDZ3OrgsTLy+u8NWOMBUngLHXq1FFSUpJiY2NVUFBw0cddbC9cao+wf1zDvffeq6NHj1b4FmvsBfdms9nUrl07zZ07V+3atdNPP/2k8ePHX/Tx7Af3Vr9+ffXp00dNmzbVtddeqzp16qh///4XfTz7wbNV5s+ffeFa4uLiVFxcrCVLlkhiL3giPz8/PfPMM3r++efP+xz7wbO5VUHicDh03XXXlX1st9uVl5dnYSJUJpvNpqSkJC1ZskSrV6+WJB05ckRBQUGSpKCgIB09elTSxfeCw+GQ3W4/b/2/r/Hx8VFAQID+/e9/V8lzQ8V16dJFDzzwgHJzc7V8+XJ1795db731FnvBQzkcDjkcDm3fvl2S9M4776hdu3bsBw/Vo0cP5ebm6vvvv1dxcbFWrVql2267jf3g4ari58/voK4jPDxc99133znlKXvB8zRr1kxNmzbVrl27lJubK7vdrp07d6px48bsB1j/Pp/KGh8fH7Nv3z4TEhJSdkhrq1atLM/FVM4sWrTIzJgx45y1qVOnnnPw2pQpU4wk06pVq3MOV9q3b1/Z4Urbt283nTp1MtKvhyv17t3bSDJPPfXUOYcrvf3225Y/Z+bS061bt7IzSNgLnjufffaZadGihZFkJkyYYKZOncp+8NDp2LGjSU9PN35+fkb69QDfESNGsB88bP77nIGq+PkHBgaa/fv3m/r165v69eub/fv3m8DAQMv/Ljx9/nsv3H333eabb74xjRo1Oudx7AXPmEudSXP2GSTsB48fywNU6vTu3dvs2bPH5OTkmLi4OMvzMJUzXbp0McYYs2vXLpOSkmJSUlJM7969TYMGDczmzZvN3r17zebNm8/5BycuLs7k5OSYrKysshOmJZlbbrnF7N692+Tk5JjZs2eXrdesWdOsWLHCZGdnm+TkZNO0aVPLnzdz6Tm7IGEveO7cfPPNZseOHWbXrl1m9erVpn79+uwHD56JEyeazMxMs3v3brN48WLj6+vLfvCgWbp0qcnLyzNFRUXm0KFDZvDgwVX28x80aJDJzs422dnZZuDAgZb/XXj6XGgvZGdnm2+//bbsd8nf/oeWveD+c6H9cPbnzy5I2A+ePV7/+QMAAAAAAIDHcqszSAAAAAAAAH4PChIAAAAAAODxKEgAAAAAAIDHoyABAAAAAAAej4IEAAAAAAB4PAoSAACg4uJipaSklE2TJk0kSV26dFFycrIyMzOVmZmpiIgISVK3bt305ZdfnvM1fHx8lJ+fr6CgoCrPf7Y333xTDz300CUfM2DAAF1zzTVlHycmJio0NNTZ0a5Ynz59XCInAACuyGZ1AAAAYL1Tp04pLCzsnLXGjRtr6dKl6tu3r1JSUtSwYUNt3LhRhw8f1oYNG2S329WkSRMdPHhQktSjRw+lp6crPz/fiqdwWQYOHKj09HR99913klRW/FR3ffv21XvvvafMzEyrowAA4HZ4BQkAALig4cOHa+HChUpJSZEkHT9+XGPHjtX48eNljNHKlSv16KOPlj2+X79+WrZs2Xlf5+qrr9aqVauUmpqq1NRU3XrrrWrSpIl2795d9pjRo0drwoQJkqSPP/5Yr7zyij799FNlZGSoffv2SkpK0t69ezVp0iRJuuT1Z3vuuee0fft27d69W/PmzZMkPfTQQ2rfvr2WLFmilJQU1apVSx9//LFuueUWRUVFacqUKWXXDxgwQLNmzZIk9e/fX8nJyUpJSVFCQoK8vc//Nap9+/b64osvlJqaquTkZPn7+6tmzZp64403lJaWpp07d+qOO+4o+9qzZ88uu/bdd99Vt27dJEkFBQV64YUXlJqaqq1bt+rqq6/WrbfeqgceeEDTpk1TSkqKbrjhhkv9+AAAwGWiIAEAAPLz8yt7e82qVaskSa1bt9bXX399zuO++uortW7dWpK0bNky9evXT5Lk6+ure+65R0lJSed97VmzZunTTz9V27Zt1a5dO33zzTfl5ikqKlK3bt2UkJCgtWvXavjw4frjH/+ogQMHqkGDBhV+Xq+++qo6duyom266SX5+frrvvvuUlJSkr776Sv3791dYWJhOnz5d9vh33nlHDz74YNnHjz76qN5++221bNlSjz76qLp06aKwsDCVlJSof//+53yvGjVq6O2331ZMTIzatm2rHj166NSpUxo+fLgkqU2bNnrssce0aNEi1axZ85K5/f39tW3bNrVt21afffaZIiIitHXrVq1bt05jxoxRWFiY9u/fX+G/BwAAUD7eYgMAAC74FhsvLy8ZY8577G9rX331lfz9/dWiRQuFhoZq27Zt+uGHH/5/O3cPkmofxnH8p0WdCgeFGqLcSmopUIqgpaitoUF6gQihKYLaGiII2moKoohcaqqWgmoKWgKhKBsyXyKwF4JecOgFDNPiGaIbPMfqnPM8z+T3M9239//S67/Jz//lL+ubm5vV29srSXp7e9Pj46OsVuuX/ayvr0uSAoGAgsGgMbYTjUZVXl6e8XMyaWpq0vDwsAoLC2Wz2RQMBrW5ufnp+lgspmg0qvr6ep2ensrhcMjn82lgYEBOp1P7+/uS3gOlu7u7tFqHw6Hr62sdHBxIej8FIkmNjY3GSZGTkxNdXFyosrLyy74TiYTRp9/vV2tr62/tFwAA/D0CEgAAkFEwGJTL5dLGxobxmtPpVCgUMu6Xl5fV1dWlqqqqjOM1n0mlUmkjKj9+/Eh7nkgkJL0HKh/XH/e5ubnf1ktSfn6+Zmdn5XK5dHV1pbGxsYzrfraysqKOjg5FIhGtra1Jeg+LFhcXNTIy8mndZ4GSyWTKuP6rPSSTSeP69fVVubl8ZQMA4P/GiA0AAMhoZmZGHo9HNTU1kiSbzaaJiQlNTk4aa5aWltTT06Pm5mbj1MfPtre31d/fL0kym82yWCy6vb1VSUmJbDab8vLy1NbW9ke9/U79R+AQi8VUVFQkt9ttPHt6epLFYsn43qurq2pvb1d3d7dWVlaMPbjdbhUXF0uSrFar7HZ7Wl0kElFpaalcLpek9zGZnJwc7ezsGOM4FRUVstvtOjk50fn5uWpra2UymVRWVqa6urpv9/1V3wAA4N/h5wgAAJDRzc2Nenp65PV6ZbFYZDKZNDU1lTaiEg6HFY/H5ff7FY/HM77P0NCQ5ufn1dfXp9fXV/X392t3d1fj4+Pa29vT2dmZIpHIH/WWSqW+rX94eJDX61UgEND5+bkxHiNJCwsLmpub0/PzsxoaGtLq7u/vFQqFVF1dbdSEw2GNjo5qa2tLZrNZyWRSAwMDury8NOqSyaQ6Ozs1PT2tgoICPT8/q6WlRbOzs5qbm9PR0ZFSqZQ8Ho9eXl7k8/l0dnamQCCg4+NjHR4efrvv5eVleb1eDQ4Oyu128z8kAAD8h0ySfj0LCgAAAAAAkEUYsQEAAAAAAFmPgAQAAAAAAGQ9AhIAAAAAAJD1CEgAAAAAAEDWIyABAAAAAABZj4AEAAAAAABkPQISAAAAAACQ9QhIAAAAAABA1vsH/Qs/PKF8ya4AAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABEgAAAKFCAYAAADf3dyGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3XtclHX+///nDMNJETVPGKhoYpltKgZqq1naomuZtpo/01VKBUSTtLTFQy129JApmIpgeeikfgpXy7Om2WFRNBDMWDFjkxTNUgJFEbh+f9TyzdRAYbiAedxvt9ct55q5rnmOeruNPLuu622RZAgAAAAAAMCBWc0OAAAAAAAAYDYKEgAAAAAA4PAoSAAAAAAAgMOjIAEAAAAAAA6PggQAAAAAADg8ChIAAAAAAODwKEgAAAAAAIDDoyABAADlEhwcrKZNm5Y8jo+PV9u2bct93BYtWujRRx+97v2WLVumgQMHXrHdXjl/z83NTbt27ZLVWr5/Zt1xxx1atmxZBaUCAACloSABAADl8thjj+nmm28ueRwSEqKvv/663Mf19fXV0KFDy32c/7FXzt8bOXKkEhISVFxcXK7jHDx4UD4+PmrWrFkFJQMAAH+EggQAAFxh2LBh2rNnj5KTkxUbGyur1Sqr1aply5YpLS1NqampmjBhggYOHKi77rpL77zzjpKTk+Xm5qadO3eqU6dOkqTc3FzNnDlT+/bt07Zt2xQQEKCdO3fqm2++Ub9+/ST9cqbI7t27tX//fu3fv19du3aVJM2cOVPdu3dXcnKyJkyYIKvVqtmzZ2vv3r06cOCAQkNDS/IuWLBAX331lT766CM1btz4is9TETn/6P1//3u3bt06SVKPHj20a9curV69Wv/5z3/0yiuvaOjQodqzZ49SU1PVqlUrSdKgQYOUlpamlJQUffLJJyXH+vDDDzVkyJBy/VkCAICyMxiGYRiGYf43t912m7F+/XrDZrMZkoyFCxcaw4cPN/z9/Y2tW7eWvK5u3bqGJGPnzp1Gp06dSrb/9rFhGEafPn0MSUZCQoKxZcsWw2azGXfeeaeRnJxsSDLc3d0NV1dXQ5LRunVrIykpyZBk9OjRw/jwww9LjhsSEmJMmzbNkGS4uLgYSUlJhq+vr/Hwww8bW7duNaxWq9G0aVPjzJkzxsCBA6/4XOXNea33/+17ODs7GydOnCh53KNHD+PMmTOGl5eX4eLiYmRlZRlRUVGGJCMiIsKYN2+eIclITU01br755st+XyUZd999t7F+/XrT/04wDMMwjCOMTQAAAL/Rq1cvderUSUlJSZIkd3d3nTp1Sh9++KFatWqlmJgYbdiwQVu3bi31WBcvXtTmzZslSWlpabp48aIKCwuVlpYmX19fSZKzs7Nef/11dejQQUVFRWrTps1VjxUUFKQ777xTgwYNkiTVrVtXfn5+uueee/Tee++puLhYJ06c0Mcff3zdn7ksOa/1/pmZmSXHadiwoc6ePXvZsZOSkpSdnS1J+uabb0p+39LS0nTfffdJkj7//HMtX75ca9asUUJCQsm+p06duuyyIAAAYD8UJAAA4DIWi0UrVqzQ1KlTr3iuffv26t27t8aNG6fBgwdr1KhRf3isS5culfy6uLhYFy9elCQZhiGb7Zd/hkycOFEnT55U+/btZbVadeHChWvmGj9+/BXFTN++fWUYxnV9xhvJea33/638/Hy5ubldtu1/x/r9sYuLi0uOHR4ersDAQD3wwANKSUlRhw4d9NNPP8nNzU35+fnl+mwAAKBsuAcJAAC4zI4dOzRo0CA1atRIklS/fn01b95cDRo0kNVqVUJCgp599ln5+/tL+uX+HXXq1Lnh96tbt65OnDghwzA0fPjwktLg98fdsmWLwsPDS5738/NTrVq1tHv3bg0ZMkRWq1VeXl4lZ2X8XnlzXuv9f+vs2bNycnKSq6vrdR27VatW2rt3r/75z3/q9OnTJTdmbdOmjQ4ePHjDmQEAQNlxBgkAALjM119/renTp2vr1q2yWq26dOmSxo0bp/z8fC1btqxk+dopU6ZIkpYvX67Y2Fjl5+eX3GD1eixatEgffPCBHnnkEe3cuVN5eXmSpNTUVBUWFiolJUXLly9XdHS0fH199eWXX8piseiHH37QgAEDtHbtWvXs2VNpaWk6fPjwZTc5/a3y5ly6dOlV3//3tm7dqm7dumnHjh1lPvacOXPk5+cni8WiHTt26MCBA5Kk++67Txs2bLjurAAA4PpZ9MvNSAAAAFABOnTooKeeekojRowo13FcXFz0ySefqFu3bioqKqqgdAAA4FqcJEWZHQIAAKCmyM7OVr169ZSamlque6O0bNlSe/fu1bfffluB6QAAwLVwBgkAAAAAAHB43KQVAABc4dtvv1VqaqqSk5NLlvsdNGiQDh48qKKiInXq1Knktffff7/27dun1NRU7du375o3SQUAAOX3xhtv6OTJk0pLSyvZVr9+fW3dulWHDx/W1q1bVa9ePUll+45et27dZcdyZBQkAADgqu677z517NhRAQEBkqSDBw/qb3/7m3bv3n3Z606fPq1+/frpzjvvVHBwsN566y0z4gIA4BCWL1+uPn36XLYtMjJSO3bsUJs2bbRjxw5FRkZKKv07+uGHHy65OTp+YTAMwzAMw/x2vv32W6NBgwZXfW7nzp1Gp06drrnv6dOnDRcXF9M/A8MwDMPU1GnRooWRlpZW8jg9Pd3w8vIyJBleXl5Genr6Vff77Xd07dq1jU8//dRo27btZcdy5OEMEgAAcAXDMLR161bt27dPISEhZd5v4MCBSk5OVkFBgR3TAQCA32rSpImys7Ml/XKz8MaNG1/xmt9/R7/wwguaO3euzp8/X6lZqzKb2QEAAEDV8+c//1knTpxQo0aNtG3bNqWnp+vTTz/9w31uv/12zZo1S0FBQZWUEgAAlMXvv6Pbt2+v1q1b66mnnlKLFi1MTld1cAYJAAC4wokTJyRJP/zwg9auXavAwMA/fL23t7fWrl2rESNG6OjRo5UREQAA/OrkyZPy8vKSJHl5eenUqVMlz13tO7pr167q1KmTvv32W3322Wdq06aNdu7caUr2qoSCBAAAXKZWrVry8PAo+XVQUJAOHjx4zdfXrVtXGzZs0JQpU/TFF19UVkwAAPCr9evXKzg4WJIUHBysdevWSbr2d3RsbKy8vb3VsmVLdevWTYcPH2YVul+ZfiMUhmEYhmGqzrRs2dJISUkxUlJSjIMHDxpTp041JBkDBgwwjh07Zly4cMHIzs42Nm/ebEgypk2bZuTl5RnJyckl06hRI9M/B8MwDMPUxHn33XeN48ePGwUFBcaxY8eMkSNHGjfddJOxfft24/Dhw8b27duN+vXrG1LZvqN/f8NXRx7Lr78AAAAAAABwWFxiAwAAAAAAHB4FCQAAAAAAcHgUJAAAAAAAwOFRkAAAAAAAAIdHQQIAAAAAABweBQkAALhuISEhZkcAAACl4Pv6+lCQAACA6xYaGmp2BAAAUAq+r68PBQkAAAAAAHB4FkmG2SHsoaioSPn5+WbHAACgRrLZbCosLDQ7BgAA+AN8X//C3d1dTk5Opb7OVglZTJGfny8PDw+zYwAAAAAAABPl5eWV6XVcYgMAAAAAABweBQkAAAAAAHB4FCQAAAAAAMDhUZAAAAAAAACHR0ECAAAAAAAcHgUJAAAAAABweBQkAAAAAADA4VGQAAAAAAAAh0dBAgAAAAAAHB4FCQAAAAAAcHgUJAAAAAAAwOFRkAAAAAAAAIdHQQIAAAAAABweBQkAAAAAAHB4FCQAAAAAAMDhUZAAAAAAAACHR0ECAAAAAAAcHgUJAAAAAABweBQkAAAAAADA4VGQAAAAAAAAh2e3gsTV1VV79uxRSkqKDh48qKioKElS+/bt9e9//1vJyclKSkpSQEBAyT6RkZHKyMhQenq6goKCSrb7+/srNTVVGRkZio6OtldkAAAAAADgwAx7Te3atQ1Jhs1mMxITE43OnTsbW7ZsMfr06WNIMv76178aO3fuNCQZbdu2NVJSUgwXFxfD19fXOHLkiGG1Wg1Jxp49e4wuXboYkoyNGzeW7P9Hk5eXZ7fPxTAMwzAMwzAMwzBVdTr2DTKmbUkwXj3wuTFtS4LRsW+Q6ZnMnLL2A3a9xObcuXOSJGdnZzk7O8swDBmGIU9PT0lS3bp1dfz4cUlS//79tWrVKhUUFCgzM1NHjhxRYGCgvLy85OnpqcTEREnSypUrNWDAAHvGBgAAAACgWurYN0iDoyJ1081NZbFaddPNTTU4KlId+waVvrODs9nz4FarVfv371fr1q21cOFC7d27VxMmTNCWLVv06quvymq16u6775YkeXt7l5QgkpSVlSVvb29dunRJWVlZV2wHAAAAAACX6/vkGLm4u1+2zcXdXX2fHKPkjVtNSlU92PUMkuLiYnXs2FE+Pj4KDAxUu3btFB4erokTJ6p58+aaOHGi3njjDUmSxWK5Yn/DMK65/WpCQkKUlJSkpKQk2Wx27X4AAAAAAKhy6ns1ua7t+H8qZRWbnJwc7dq1S3369FFwcLASEhIkSf/3f/+nwMBASb+cGdKsWbOSfXx8fHT8+HFlZWXJx8fniu1XEx8fr4CAAAUEBKiwsNCOnwgAAAAAgKon7+zZq24/k32ykpNUP3YrSBo2bKi6detKktzc3HT//fcrPT1dx48fV48ePSRJPXv2VEZGhiRp/fr1GjJkiFxcXOTr6ys/Pz/t3btX2dnZys3NVefOnSVJI0aM0Lp16+wVGwAAAACAaunWuzurlqeniouLL9tekJ+vjdGxJqWqPux2HUrTpk21YsUKOTk5yWq1as2aNdqwYYPOnj2r6Oho2Ww2XbhwQaGhoZKkQ4cOac2aNTp06JAKCws1bty4kj/U8PBwLV++XO7u7tq0aZM2bdpkr9gAAAAAAFQ7rTp10GPzZyo746g+X/2B7g99TPW9muhM9kltjI7l/iNlYNEvy9nUOHl5efLw8DA7BgAAAAAAdtWsXVuNWbpAOad+0KLHxyrvpzNmR6pSytoPVMo9SAAAAAAAQMXzat1KIbHzdO5sjpaERlCOlAMFCQAAAAAA1VDD5j4Ki4tW4cUCxYaMV87JH8yOVK2xFi4AAAAAANVMPa8mCouPkdXJSQtHheunrKuv9oqyoyABAAAAAKAaqdPgJo2Jj5G7h4cWj3pCp779r9mRagQKEgAAAAAAqgl3T0+FxkXLs3EjxYU+qe/TD5sdqcagIAEAAAAAoBpwrV1LobHz1Ni3uZaOm6TMA2lmR6pRKEgAAAAAAKjinN1cNer1V+Xdto1WTJyijMQksyPVOKxiAwAAAABAFeZksyl43itq6d9e7019Xl/t+szsSDUSBQkAAAAAAFWU1clJw2bNUNtuXfX+jJlK3rTN7Eg1FgUJAAAAAABVkMVi0eAZU9U+qKf+NWu+9iR8aHakGo2CBAAAAACAKujhqU8roH9fbXo9Tp++vdrsODUeBQkAAAAAAFXMAxPC9echA7Xzzbe1fckys+M4BAoSAAAAAACqkF4hweo5aoS+WJ2gj+YtNDuOw6AgAQAAAACgiug+bLD6RozRvg83KeGlV82O41AoSAAAAAAAqAICBzyoAZETlbp9l1Y/+5IMwzA7kkOhIAEAAAAAwGTte/fSI1GRSv8sUW8/85yKi4rMjuRwKEgAAAAAADBR23v+rGGvROnblFQtnxipokuXzI7kkChIAAAAAAAwSevATgp+7SV9/5/DemPcJF26cNHsSA6LggQAAAAAABO0aH+HRi6YrdPfZSl+zERdPHfe7EgOjYIEAAAAAIBKdvOtfgpZ9Jp+/uFHLQl9UudzfjY7ksOjIAEAAAAAoBI1btlCoUvm68K5c1oSEqHc0z+aHQmiIAEAAAAAoNLc5N1UYfExMgxDsSEROnMi2+xI+JXN7AAAAAAAADgCz8aNNGbpArm4uWnh42N1+r/HzI6E36AgAQAAAADAzmrXr6ewuGjVrl9PsaMjlJ3xjdmR8DsUJAAAAAAA2JFbHQ+Fxs5XA++bFRc+UccOHjI7Eq6CggQAAAAAADtxcXfT6IVz5eXXSm+Of0ZH9yWbHQnXQEECAAAAAIAd2Fxc9HjMbLW4s51WTpqu/3yeaHYk/AFWsQEAAAAAoIJZbU4a8eqLatMlQKufe1lp23eZHQmloCABAAAAAKACWaxWDX3pObW7r7s+eHGO9q3faHYklAEFCQAAAAAAFWjQs8+oY98gfTRvob5YnWB2HJQRBQkAAAAAABXkockR6jKov7bFLdPON982Ow6uAwUJAAAAAAAVoPfY0eox4lHtfnu1Ni+IMzsOrhMFCQAAAAAA5XRv8FAFhY/SnoQPtX52tNlxcAMoSAAAAAAAKIeujzysfpPGK2Xzdv3fjJkyDMPsSLgBFCQAAAAAANwg/wd762/TJ+nQJ5/r3SkzZBQXmx0JN4iCBAAAAACAG3BHzx4a8sJ0fZP0pVY8PU1FhYVmR0I5UJAAAAAAAHCdbr27s4a/+oKOffW13hz/jAovXjQ7EsqJggQAAAAAgOvQ0r+9Hps/UyePfKulY59WQX6+2ZFQAShIAAAAAAAoI5/bb9PohXN15kS24sZMUP7PuWZHQgWhIAEAAAAAoAy8WrdS6JL5Onc2R0tCI5T30xmzI6ECUZAAAAAAAFCKhs19FBYXrcKLBYoNGa+ckz+YHQkVzGZ2AAAAAAAAqrJ6Xk0UFh8jq5OTFo0eq5+yjpsdCXZAQQIAAAAAwDXUaXCTxsTHyL1OHS0eNU4nj2aaHQl2QkECAAAAAMBVuHt6KjQuWp6NGyku9El9//VhsyPBjihIAAAAAAD4HddatRQaO0+NfZtr6bhJyjyQZnYk2BkFCQAAAAAAv+Hs5qqRr8+Rd9s2WjFxijISk8yOhErAKjYAAAAAAPzKyWZT8Gsvq1WnDnpv6vP6atdnZkdCJaEgAQAAAABAktXJScNmzVDb7nfr/Rkzlbxpm9mRUIkoSAAAAAAADs9isWjwjKlqH9RT/5o1X3sSPjQ7EioZBQkAAAAAwOE9PPVpBfTvq80L4/Xp26vNjgMTUJAAAAAAABzaAxPC9echA7Vz2TvaFvum2XFgEgoSAAAAAIDD6jU6WD1HjdAXqxP00Wuvmx0HJqIgAQAAAAA4pG5DH1HfJ8do34eblPDSq2bHgckoSAAAAAAADidwwIN6eMpTSt2+S6uffUmGYZgdCSajIAEAAAAAOJT2vXvpkahIpX+WqLefeU7FRUVmR0IVQEECAAAAAHAYbe/5s4a9EqVvU1K1fGKkii5dMjsSqggKEgAAAACAQ2gd2EnBr72k44cz9OYTk3XpwkWzI6EKsVtB4urqqj179iglJUUHDx5UVFRUyXNPPPGE0tPTdfDgQc2aNatke2RkpDIyMpSenq6goKCS7f7+/kpNTVVGRoaio6PtFRkAAAAAUEO1aH+HRi6YrdPfZSkubIIu5J0zOxKqIMNeU7t2bUOSYbPZjMTERKNz587Gvffea2zbts1wcXExJBmNGjUyJBlt27Y1UlJSDBcXF8PX19c4cuSIYbVaDUnGnj17jC5duhiSjI0bNxp9+vQp9b3z8vLs9rkYhmEYhmEYhmGY6jM33+pnvPj5ViPyozVGnYYNTM/DVO6UtR+w6yU258790sg5OzvL2dlZhmEoPDxcM2fOVEFBgSTphx9+kCT1799fq1atUkFBgTIzM3XkyBEFBgbKy8tLnp6eSkxMlCStXLlSAwYMsGdsAAAAAEAN0bhlC4Uuma8L585pSUiEck//aHYkVFF2LUisVquSk5N16tQpbdu2TXv37lWbNm3UvXt3JSYmateuXbrrrrskSd7e3jp27FjJvllZWfL29pa3t7eysrKu2A4AAAAAwB+5ybupwuJjZBiGYkMidOZEttmRUIXZ7Hnw4uJidezYUXXr1tXatWvVrl072Ww21a9fX126dFFAQIDWrFmjVq1ayWKxXLG/YRjX3H41ISEhCg0NlSTZbHb9aAAAAACAKsyzUUOFxcfIxc1NCx8fq9P/PVb6TnBolbKKTU5Ojnbt2qU+ffooKytLCQkJkqSkpCQVFxerYcOGysrKUrNmzUr28fHx0fHjx5WVlSUfH58rtl9NfHy8AgICFBAQoMLCQvt+KAAAAABAlVS7fj2FxcfI46b6ihszUdkZ35gdCdWA3QqShg0bqm7dupIkNzc33X///UpPT9e//vUv9ezZU5Lk5+cnFxcXnT59WuvXr9eQIUPk4uIiX19f+fn5ae/evcrOzlZubq46d+4sSRoxYoTWrVtnr9gAAAAAgGrMrY6HQmPnq4H3zXrjick6dvCQ2ZFQTdjtOpSmTZtqxYoVcnJyktVq1Zo1a7RhwwY5OzvrzTffVFpamgoKChQcHCxJOnTokNasWaNDhw6psLBQ48aNU3FxsSQpPDxcy5cvl7u7uzZt2qRNmzbZKzYAAAAAoJpycXfT6IVz5eXXSssintHRfclmR0I1YtEvy9nUOHl5efLw8DA7BgAAAACgEthcXDRq4atqHeCvlZOmK237LrMjoYooaz9QKfcgAQAAAADAXqw2Jw1/9QW16RKg1c+9TDmCG0JBAgAAAACotixWqx596Tndcd89+uDFOdq3fqPZkVBNUZAAAAAAAKqtQc8+I/++Qfpo3kJ9sTrB7DioxihIAAAAAADV0kOTI9RlUH9ti1umnW++bXYcVHMUJAAAAACAaqf32NHqMeJR7X57tTYviDM7DmoAChIAAAAAQLVyb/BQBYWP0t61H2n97Giz46CGoCABAAAAAFQbXR95WP0mjVfK5u1aE/WKDMMwOxJqCAoSAAAAAEC14P9gb/1t+iQd+uRzvTtlhoziYrMjoQahIAEAAAAAVHl39OyhIS9M1zdJX2rF09NUVFhodiTUMBQkAAAAAIAqrU3XQA2f87yOffW13hz/jAovXjQ7EmogChIAAAAAQJXV0r+9Ho+epZPfZGrp2KdVkJ9vdiTUUBQkAAAAAIAqyef22zR64VydzT6puDETlP9zrtmRUINRkAAAAAAAqhyv1q0UumS+zp3NUWzIeOX9dMbsSKjhKEgAAAAAAFVKw+Y+CouLVmFBgZaERCjn5A9mR4IDsJkdAAAAAACA/6nn1URh8TGyOjlp0eNj9WPW92ZHgoOgIAEAAAAAVAkeDeprTHyM3OvU0eJR43TyaKbZkeBAKEgAAAAAAKZz9/RUWFyMPBs3Ulzok/r+68NmR4KDoSABAAAAAJjKtVYthSx+TY19m2vpuEnKPJBmdiQ4IAoSAAAAAIBpnN1cNfL1OfK5/VatmDhFGYlJZkeCg2IVGwAAAACAKZxsNgW/9rJadeqg96Y+r692fWZ2JDgwChIAAAAAQKWzOjlp2KwZatv9br3//Cwlb9pmdiQ4OAoSAAAAAEClslgsGjxjqtoH9dS62dHa88F6syMBFCQAAAAAgMo1YMpTCujfV5sXxmv3W6vMjgNIoiABAAAAAFSivk+Gq9ujg7Rz2TvaFvum2XGAEhQkAAAAAIBK0Wt0sHqNHqEvVifoo9deNzsOcBkKEgAAAACA3XUb+oj6PjlG+z7cpISXXjU7DnAFChIAAAAAgF0FDnhQD095Sqnbd2n1sy/JMAyzIwFXoCABAAAAANhN+9699EhUpP7zeaLefuY5FRcVmR0JuCoKEgAAAACAXbS9588a9kqUMlPStGxCpIouXTI7EnBNFCQAAAAAgArXOrCTgl97SccPZ+iNJybp0oWLZkcC/hAFCQAAAACgQjW/s51GLpit099lKS5sgi7knTM7ElAqChIAAAAAQIW5+VY/hSx+TT//8KOWhD6p8zk/mx0JKBMKEgAAAABAhWjcsoVCl8zXxXPntSQkQrmnfzQ7ElBmFCQAAAAAgHK7ybupwuJjZBiGYkMidOZEttmRgOtiMzsAAAAAAKB682zUUGHxMXJxc9OikWN1+r/HzI4EXDcKEgAAAADADatdv57C4mPkcVN9xY6O0InD35gdCbghFCQAAAAAgBviVsdDobHz1cD7ZsWFT9Sxg4fMjgTcMAoSAAAAAMB1c3F30+iFc+Xl10rLIp7R0X3JZkcCyoWCBAAAAABwXWwuLno8epZa3NlOKydNV/pniWZHAsqNVWwAAAAAAGVmtTlp+KsvqE3XQK1+7mWlbd9ldiSgQlCQAAAAAADKxGK16tGXntMd992jD16co33rN5odCagwFCQAAAAAgDIZ9Owz8u8bpI/mLdQXqxPMjgNUKAoSAAAAAECpHpocoS6D+mt73HLtfPNts+MAFY6CBAAAAADwh3qPHa0eIx7V7rdXa9OCJWbHAeyCggQAAAAAcE33Bg9VUPgo7V37kdbPjjY7DmA3FCQAAAAAgKvq8sgA9Zs0Ximbt2tN1CsyDMPsSIDdUJAAAAAAAK7g/2BvDZw+WYc++VzvTpkho7jY7EiAXVGQAAAAAAAuc0fPHhrywnR9k/SlVjw9TUWFhWZHAuyOggQAAAAAUKJN10ANn/O8jn31td4c/4wKL140OxJQKShIAAAAAACSpJb+7fV49CydPJqppWOfVkF+vtmRgEpDQQIAAAAAkM/tt2n0wrk6m31ScWETlP9zrtmRgEpFQQIAAAAADs6rdSuFLpmvc2dzFBsyXnk/nTE7ElDpKEgAAAAAwIE1aOajsLhoFRYUaElIhHJO/mB2JMAUNrMDAAAAAADMUa9JY41ZGiOrk5MWPT5WP2Z9b3YkwDQUJAAAAADggDwa1FdYfIzc69TR4lHjdPJoptmRAFNRkAAAAACAg3H39FRYXIzqNmmsuNAn9f3Xh82OBJiOggQAAAAAHIhrrVoKWfyaGvs219Jxk5R5IM3sSECVYLebtLq6umrPnj1KSUnRwYMHFRUVddnzTz/9tAzDUIMGDUq2RUZGKiMjQ+np6QoKCirZ7u/vr9TUVGVkZCg6OtpekQEAAACgRnN2c9XI1+fI5/ZbtXLSdGUkJpkdCahSDHtN7dq1DUmGzWYzEhMTjc6dOxuSDB8fH2Pz5s1GZmam0aBBA0OS0bZtWyMlJcVwcXExfH19jSNHjhhWq9WQZOzZs8fo0qWLIcnYuHHUVVwVAAAgAElEQVSj0adPn1LfOy8vz26fi2EYhmEYhmEYprqNk81mjF4015hz4HOj41//YnoehqmsKWs/YNdlfs+dOydJcnZ2lrOzswzDkCTNmzdPzzzzTMljSerfv79WrVqlgoICZWZm6siRIwoMDJSXl5c8PT2VmJgoSVq5cqUGDBhgz9gAAAAAUKNYnZw0bNYMte1+t95/fpaSN20zOxJQ5di1ILFarUpOTtapU6e0bds27d27V/369dP333+v1NTUy17r7e2tY8eOlTzOysqSt7e3vL29lZWVdcX2qwkJCVFSUpKSkpJks3F7FQAAAACwWCwaPGOK2gf11LrZ0drzwXqzIwFVkl1bhOLiYnXs2FF169bV2rVr9ac//UnTpk277P4i/2OxWK7YZhjGNbdfTXx8vOLj4yVJeXl55UwPAAAAANXfgClPKaD/A9q8MF6731pldhygyqqU0yxycnK0a9cu9e/fXy1bttSBAwckST4+Pvryyy8VGBiorKwsNWvWrGQfHx8fHT9+XFlZWfLx8bliOwAAAADgj/V9MlzdHh2kncve0bbYN82OA1RpdrvEpmHDhqpbt64kyc3NTffff7+Sk5PVpEkTtWzZUi1btlRWVpb8/f118uRJrV+/XkOGDJGLi4t8fX3l5+envXv3Kjs7W7m5uercubMkacSIEVq3bp29YgMAAABAjdBrdLB6jR6hL1Yn6KPXXjc7DlDl2e0MkqZNm2rFihVycnKS1WrVmjVrtGHDhmu+/tChQ1qzZo0OHTqkwsJCjRs3TsXFxZKk8PBwLV++XO7u7tq0aZM2bdpkr9gAAAAAUO11G/qI+j45Rvs/2qyEl141Ow5QLVj0y3I2NU5eXp48PDzMjgEAAAAAlSpwwIP6/16YprQdn2jl09NUXFRkdiTAVGXtB+y6ig0AAAAAoPK0791Lj0RF6j+fJ+qtyc9SjgDXgYIEAAAAAGqAtt3v1rBXopSZkqZlEyJVdOmS2ZGAaoWCBAAAAACquVsC/BU872UdP5yhN56YpEsXLpodCah2KEgAAAAAoBprfmc7jXp9jk5/l6W4sAm6kHfO7EhAtURBAgAAAADV1M23+ilk8Wv6+YcftST0SZ3P+dnsSEC1RUECAAAAANVQ45YtFLpkvgrO52tJSIRyT/9odiSgWqMgAQAAAIBq5ibvpgqLj5EkLR49XmdOZJucCKj+bGYHAAAAAACUnWejhgqLj5GLm5sWjRyr0/89ZnYkoEagIAEAAACAaqJ2vboKi4+Rx031FTs6QicOf2N2JKDGoCABAAAAgGrAzaO2QpbMVwPvmxUXPlHHDh4yOxJQo1CQAAAAAEAV5+LuptEL56qp3y1aFvGMju5LNjsSUONQkAAAAABAFWZzcdHj0bPUov0dWjlputI/SzQ7ElAjsYoNAAAAAFRRVpuThr/6gtp0DdTq515W2vZdZkcCaiwKEgAAAACogixWqx596Tndcd89SnjpVe1bv9HsSECNRkECAAAAAFXQoGefkX/fIG2Yv0ifr/rA7DhAjUdBAgAAAABVzEOTI9RlUH9tj1uuj994y+w4gEOgIAEAAACAKiQofJR6jHhUu99erU0LlpgdB3AYFCQAAAAAUEX0GPGoeo8drb1rP9L62dFmxwEcCgUJAAAAAFQBXR4ZoIcmRyhl83atiXpFhmGYHQlwKBQkAAAAAGAy/wd7a+D0yTr0yed6d8oMGcXFZkcCHA4FCQAAAACY6I6ePTTkhen6JulLrXh6mooKC82OBDgkChIAAAAAMEmbroEaPud5ZX2VrmUR/1DhxYtmRwIcFgUJAAAAAJigpX97PR49SyePZip+7FO6eP682ZEAh0ZBAgAAAACVzOf22zR64VydzT6puLAJyv851+xIgMOjIAEAAACAStTklpYKjZ2nc2dzFBsyXnk/nTE7EgBRkAAAAABApWnQzEdj4mNUeOmSloREKOfkD2ZHAvArm9kBAAAAAMAR1GvSWGOWxsjq5KRFj4/Vj1nfmx0JwG9QkAAAAACAnXk0qK+w+Bi516mjxaPG6eTRTLMjAfgdChIAAAAAsCN3T0+FxcWobpPGiguboO+/Pmx2JABXQUECAAAAAHbiWquWQha/psa+zbV03CRlpqSaHQnANVCQAAAAAIAd2FxdNfL1OfK5/VateGqqMhKTzI4E4A+wig0AAAAAVDAnm02PzXtZrTp10HtTn9dXOz81OxKAUlCQAAAAAEAFsjo5adisGWrb/W69//wsJW/aZnYkAGVAQQIAAAAAFcRisWjwjClqH9RT62ZHa88H682OBKCMKEgAAAAAoIIMmPKUAvo/oM0L47X7rVVmxwFwHShIAAAAAKAC9H0yXN0eHaRdy9/Vttg3zY4D4DpRkAAAAABAOfUaHaxeo0foizVr9eHcBWbHAXADKEgAAAAAoBy6DR2kvk+O0f6PNivhxTlmxwFwgyhIAAAAAOAGBQx4QA9PeVppOz7RqukvyjAMsyMBuEEUJAAAAABwA+4M6qnBUVP0n88T9dbkZ1VcVGR2JADlQEECAAAAANepbfe79feZM5SZkqZlEyJVdOmS2ZEAlBMFCQAAAABch1sC/BU872UdP5yhN56YpEsXLpodCUAFoCABAAAAgDJqfmc7jXp9jn489r3ix0zUhbxzZkcCUEEoSAAAAACgDG6+1U8hi19T7umfFBsSoXNnc8yOBKACUZAAAAAAQCkat2yh0CXzVXA+X7Gjxyv39I9mRwJQwShIAAAAAOAP1L/ZS2HxMZKkxaPH68yJbJMTAbAHm9kBAAAAAKCq8mzUUGOWLpCLm5sWjRyr0/89ZnYkAHZCQQIAAAAAV1G7Xl2FxUXL46b6ih0doROHvzE7EgA7oiABAAAAgN9x86itkCXz1cDHW3HhE3Xs4CGzIwGwMwoSAAAAAPgNF3c3jV44V039btGyiGd0dF+y2ZEAVAIKEgAAAAD4lc3FRY9Hz1KL9nforcnPKv2zRLMjAagkrGIDAAAAAJKsNicNf/UFtekaqNXPvazUbTvNjgSgElGQAAAAAHB4FqtVj774rO647x4lvPSq9q3faHYkAJWMggQAAACAwxv47GT5P9BbG+Yv0uerPjA7DgATUJAAAAAAcGj9Jo1X10EDtD1uuT5+4y2z4wAwCQUJAAAAAIcVFD5K9wYP1e63V2vTgiVmxwFgIrsVJK6urtqzZ49SUlJ08OBBRUVFSZJmz56tr7/+WgcOHFBCQoLq1q1bsk9kZKQyMjKUnp6uoKCgku3+/v5KTU1VRkaGoqOj7RUZAAAAgAPpMeJR9R47WnvXfqT1s/k5A4Bk2Gtq165tSDJsNpuRmJhodO7c2fjLX/5iODk5GZKMmTNnGjNnzjQkGW3btjVSUlIMFxcXw9fX1zhy5IhhtVoNScaePXuMLl26GJKMjRs3Gn369Cn1vfPy8uz2uRiGYRiGYRiGqd7T5ZEBxty0fxvDX33RsPz6cwfDMDVzytoP2PUSm3PnzkmSnJ2d5ezsLMMwtG3bNhUVFUmSEhMT5ePjI0nq37+/Vq1apYKCAmVmZurIkSMKDAyUl5eXPD09lZj4y/rjK1eu1IABA+wZGwAAAEAN5v9gbw2cPlmHPvlc70ZGySguNjsSgCrArgWJ1WpVcnKyTp06pW3btmnv3r2XPT9y5Eht2rRJkuTt7a1jx46VPJeVlSVvb295e3srKyvriu0AAAAAcL3u6NlDQ16Yrm+SvtSKp6epqLDQ7EgAqgi7FiTFxcXq2LGjfHx8FBgYqHbt2pU8N3XqVBUWFuqdd96RJFksliv2NwzjmtuvJiQkRElJSUpKSpLNZqugTwEAAACgJmjTNVDD5zyvrK/StSziHyq8eNHsSACqkEpZxSYnJ0e7du1Snz59JEkjRozQgw8+qGHDhpW8JisrS82aNSt57OPjo+PHjysrK6vkMpzfbr+a+Ph4BQQEKCAgQIU0wQAAAAB+1bLjnXo8epZOHs1U/NindPH8ebMjAahi7FaQNGzYsGSFGjc3N91///1KT09X79699Y9//EMPPfSQ8vPzS16/fv16DRkyRC4uLvL19ZWfn5/27t2r7Oxs5ebmqnPnzpJ+KVfWrVtnr9gAAAAAahif22/VqIVzdTb7pOLCJij/51yzIwGogux2HUrTpk21YsUKOTk5yWq1as2aNdqwYYMyMjLk6uqqbdu2SfrlRq3h4eE6dOiQ1qxZo0OHDqmwsFDjxo1T8a83SwoPD9fy5cvl7u6uTZs2ldy3BAAAAAD+SJNbWio0dr7O5/ys2JDxyvvpjNmRAFRRFv2ynE2Nk5eXJw8PD7NjAAAAADBJg2Y+emLFYhmGoYXB4fox63uzIwEwQVn7Ae5kCgAAAKDGqdekscYsjZGTzaaFj1GOACgdBQkAAACAGsWjQX2FxcfIvU4dLR41TiePZpodCUA1QEECAAAAoMZw9/RUWFyM6jZprLiwCfr+68NmRwJQTVCQAAAAAKgRXGvVUsji19TYt7mWjpukzJRUsyMBqEYoSAAAAABUezZXV41cMFs+t9+qFU9NVUZiktmRAFQzVrMDAAAAAEB5ONlsemzey2p1V0e9N/V5fbXzU7MjAaiGKEgAAAAAVFtWJycNmzVDbbvfrfefn6XkTdvMjgSgmiq1IBk0aFCZtgEAAABAZbJYLBo8Y4raB/XUujnR2vPBerMjAajGSi1IpkyZUqZtAAAAAFCZBkx5SgH9H9CWhfHavXKV2XEAVHPXvElrnz591LdvX3l7eys6Orpku6enpwoLCyslHAAAAABczV8jxqjbo4O0a/m72hr7ptlxANQA1yxIjh8/rn379umhhx7S/v37S7bn5uZq4sSJlRIOAAAAAH6v56gRuj8kWF+sWasP5y4wOw6AGsIiyfijF9hstmp5xkheXp48PDzMjgEAAACgAnUbOkgPT3la+z/arPemPi/D+MMfZwCgzP3ANc8g+Z/AwEBFRUWpRYsWstlsslgsMgxDt9xyS4UEBQAAAICyCBjwgB6e8rTSdnyiVdNfpBwBUKFKLUjeeOMNTZw4Ufv371dRUVFlZAIAAACAy9wZ1FODo6boP1/s0VuTn1UxP5sAqGClFiQ5OTnavHlzZWQBAAAAgCu07X63/j5zhjJT0rR8QqSKLl0yOxKAGuia9yDp2LGjJGnw4MFycnJSQkKCLl68WPJ8cnJypQS8UdyDBAAAAKj+bgnwV8ji15R95KhiR4/XhbxzZkcCUM2UtR+4ZkHy8ccfX3MnwzDUq1evGw5XGShIAAAAgOqt+Z3tNCY+RmeOZ2vR42N17myO2ZEAVEPlLkiqOwoSAAAAoPpq2qa1xi5bqPNnf9brwWOUe/pHsyMBqKYqbBWbiRMnXrEtJydH+/fv14EDB24sHQAAAABcQyPf5gqLi1bB+XzFjh5POQKgUlhLe8Fdd92lMWPGyNvbW97e3goNDdW9996r+Ph4TZ48uTIyAgAAAHAQ9W/20pj4GEnS4tHjdeZEtsmJADiKUi+x2bx5swYOHKhz5365GVLt2rX1/vvv6+GHH9b+/fvVrl27ysh53bjEBgAAAKhePBs11LgVi1XL01OLRo7VicPfmB0JQA1QYZfYNG/eXAUFBSWPL126pBYtWujChQuXrWoDAAAAADeqdr26CouLlsdN9bUkJIJyBEClK7Ugeffdd5WYmKh169ZJkvr166f33ntPtWrV0qFDh+weEAAAAEDN5uZRWyFL5quBj7fiwyfquzR+zgBQ+cq0io2/v7+6desmi8Wizz77TPv376+EaOXDJTYAAABA1efi7qbQ2Plq9qfbtezJfyj903+bHQlADVPuZX7r1Kmj3Nxc1a9f/6o7njlzplwB7Y2CBAAAAKjabC4uGvX6HLUO7KS3Jj+r1G07zY4EoAYq9z1I3n33XfXr10/79++XYRiyWCyX/feWW26p0MAAAAAAHIfV5qThc55Xm66Bem/aC5QjAExXpktsqiPOIAEAAACqJovVqqEvPyf/B3or4aVX9fmqD8yOBKAGK2s/YC3LwYYNG6bp06dLkpo1a6aAgIDypQMAAADgsAY+O1n+D/TWhvmLKEcAVBmlFiSLFi1S165dNXToUElSbm6uFi5caPdgAAAAAGqefpPGq+ugAdoet1wfv/GW2XEAoESpy/x27txZnTp10pdffilJOnv2rFxcXOweDAAAAEDNEhQ+SvcGD9Wn76zRpgVLzI4DAJcp9QySS5cuyWq1yjB+uVVJw4YNVVxcbPdgAAAAAGqOHiMeVe+xo7X3Xx9p3az5ZscBgCuUWpDExMRo7dq1aty4sV588UV99tlnevnllysjGwAAAIAaoMug/npocoRStuzQmn++UvI/XwGgKinTKja33nqrevXqJYvFoh07dig9Pb0SopUPq9gAAAAA5vN/IEiPvvxPpX/6by2fEKmiwkKzIwFwMGXtB8pUkFitVjVp0kQ22/+7ZcmxY8fKFdDeKEgAAAAAc93R8x6NmPuSju5P0dJxk1R48aLZkQA4oLL2A6XepPWJJ57QP//5T508eVJFRUWyWCwyDEPt27evkKAAAAAAap42XQM0fM4LyvoqXcsi/kE5AqDKK/UMkoyMDHXu3Fk//fRTJUWqGJxBAgAAAJijZcc7FbokWj/89zstHvWE8n/ONTsSAAdW1n6g1Ju0Hjt2TDk5ORUSCgAAAEDN5nP7rRq1cK7OZp9UXNgEyhEA1cY1L7GZOHGiJOno0aPatWuXNmzYoIu/OS1u3rx59k8HAAAAoNpocktLhcbOV/7PuVoSEqG8n86YHQkAyuyaBUmdOnUkSd99952+++47ubi4yMXFpdKCAQAAAKg+GjTz0Zj4GBVeuqTY0eN19uQpsyMBwHUp0yo21RH3IAEAAAAqR70mjTVuRaxca7lr4WPhOnk00+xIAFCiwlaxAQAAAIBr8WhQX2HxMXL3rKPFo8ZRjgCotihIAAAAANwQd09PhS2JVt0mjRUXNkHff33Y7EgAcMMoSAAAAABcN9datRSy+DU1btlCS8dNUmZKqtmRAKBcSl3m18/PT9u3b1daWpok6U9/+pOmTZtm92AAAAAAqiabq6tGLpgtn9tv1cpJ05WRmGR2JAAot1ILkvj4eE2ZMkWXLl2SJKWlpWnIkCF2DwYAAACg6nGy2fTYvJfV6q6Oem/aC/pq56dmRwKAClFqQVKrVi0lJV3eCBcWFtotEAAAAICqyerkpGGzZqht97v1wQuzlbxxq9mRAKDClFqQnD59Wq1atZJh/LIa8MCBA3XixAm7BwMAAABQdVgsFj0SFan2QT21bk60Et9fZ3YkAKhQpd6kddy4cYqLi9Ntt92mrKwsffvtt/r73/9eGdkAAAAAVBEDIicqcMCD2rIwXrtXrjI7DgBUOIskoywvrFWrlqxWq/Ly8uwcqWLk5eXJw8PD7BgAAABAtffXiDG6PyRYu5a/qw/nLjA7DgBcl7L2A6VeYhMREaE6dero/Pnzmjdvnvbv36+//OUvFRISAAAAQNXWc9QI3R8SrC/WrKUcAVCjlVqQjBw5Urm5uQoKClLjxo31+OOPa+bMmZWRDQAAAICJug0dpAcmhGv/R5uV8OIcs+MAgF2VWpBYLBZJUt++fbVs2TKlpqaWbAMAAABQMwUMeEAPT3laBz/+RKuefbFk0QYAqKlKLUj279+vLVu2qG/fvtqyZYs8PDxUXFxcGdkAAAAAmODOoJ4aHDVF//lij1ZOelbFhUVmRwIAuyv1Jq0Wi0UdOnTQ0aNHlZOTo5tuukne3t5KS0urpIg3hpu0AgAAANevbfe79Xj0LP039aDiwyeqIP+C2ZEAoFzK2g9cc5nfjh07Xva4VatW5U8FAAAAoMq6JcBfwfNe1vHDGXrjiUmUIwAcyjXPIPn444+vuZNhGOrVq5e9MlUIziABAAAAyq75n25XWHyMzp44qUWPj9W5szlmRwKAClHWfqDUS2yqKwoSAAAAoGyatmmtscsW6vzZn/V68Bjlnv7R7EgAUGHKfYnN/wwfPvyq2996660/3M/V1VW7d++Wq6urbDab3n//fUVFRal+/fpavXq1fH19lZmZqcGDB+vs2bOSpMjISI0aNUpFRUWKiIjQ1q1bJUn+/v5avny53N3dtXHjRj355JOlfjAAAAAApWvk21xhcdEqOJ+v2NHjKUcAOKxSV7EJCAgome7duysqKkoPPfRQqQe+ePGievbsqQ4dOqhDhw7q06ePOnfurMjISO3YsUNt2rTRjh07FBkZKUlq27athgwZonbt2qlPnz5atGiRrNZf4i1evFihoaHy8/OTn5+f+vTpU86PDQAAAKD+zV4aEx8jSVo8erzOnMg2OREAmKfUM0giIiIue+zp6Vnq2SP/c+7cOUmSs7OznJ2dZRiG+vfvr3vvvVeStGLFCu3atUuRkZHq37+/Vq1apYKCAmVmZurIkSMKDAxUZmamPD09lZiYKElauXKlBvz/7N17VNVl3v7xC9iiKIqoJcUuMUcTnUzMU/kzGzPTTjrVU5YTnkIwFTDHw9BB57EpD5mipRhaauMhDU+VppmdphQtQSRAQdHcEmqOJZRKwP37o4lHxwOYbL7svd+vtT5ryc3+wrXlXkbX2vv+9u2rDz744HKeJwAAAICz1LuqkaLmz5ZvbT/NGTRc3x88ZHUkALBUua8g+W8///yzmjdvXrEv7u2tlJQUHT16VB9++KG2b9+uxo0bKz//12Y6Pz9fV199tSQpODhYhw793z/KDodDwcHBCg4OlsPhOG8dAAAAwO9Tp36AIl+Pl3+DQCVGjdJ3e3OsjgQAliv3FSTr1q2TMb+e4+rj46PQ0FCtWLGiQl+8tLRUYWFhCggI0OrVq9W6deuLPtbLy+u8NWPMRdcvJCIiQkOHDpUk2WzlPjUAAADA49Tyr6OIeTPV0B6sxGGj9O3uDKsjAUC1UG6L8PLLL5f9ubi4WAcPHtThw4cv65v8+OOP+uSTT9SrVy8dOXJEQUFBys/PV1BQkI4ePSrp11eGXHfddWXX2O125eXlyeFwyG63n7d+IYmJiUpMTJT06ym1AAAAAP6Pr18tPfnadF3TvJnejBmnfV+lWB0JAKqNct9i89lnn2nPnj0KCAhQgwYNVFxcXKEv3KhRIwUEBEiSatWqpR49eigrK0vr1q3TgAEDJEkDBgzQ2rVrJf36SpV+/frJ19dXISEhat68ubZv3678/HwVFBSoU6dOkqTw8PCyawAAAABUjM3XVwNnTlaTm/+oJeMmKOvzrVZHAoBqx1xqhgwZYg4ePGjefPNNs3DhQpObm2sGDRp0yWskmZtuusns3LnT7Nq1y+zevds899xzRpJp0KCB2bx5s9m7d6/ZvHmzCQwMLLsmLi7O5OTkmKysLNOrV6+y9VtuucXs3r3b5OTkmNmzZ5f7vSWZwsLCCj2OYRiGYRiGYdx9vG0+ZlD8ZDN991bT/oF7LM/DMAxTlVPRfsDrP3+4qKysLN12223697//LUlq0KCBvvzyS7Vs2fJSl1musLBQ/v7+VscAAAAALOXl7a3HX3xe7e69W6tenK4vlr1jdSQAqFIV7QfKfYuNw+FQQUFB2ccFBQXn3G0GAAAAQPX10HNj1O7eu/X+zLmUIwBwCeUe0nr48GElJydr7dq1MsaoT58+2r59u0aNGiVJmjFjhtNDAgAAALh89/91pG59uK82Jy7SlgWLrY4DANVauQXJvn37tG/fvrKPfzsgtW7dus5LBQAAAOCK9IwarDsGPK7Pl6zQhlkJVscBgGqv3DNIXBVnkAAAAMBT3R7eT33GxGj7mve04vkXZYxb/soPABVSaWeQAAAAAHAdnR/uoz5jYpS68SOtmPAS5QgAVBAFCQAAAOAm2t3bUw89N1YZn36hpeMnypSWWh0JAFwGBQkAAADgBv7Y/Xb1e+E57f8qRYtGP6OS4mKrIwGASyn3kNZGjRopIiJCISEhstn+7+FDhgxxajAAAAAAFdPi1g56YtokOb7J0hsjx6r4zBmrIwGAyym3IFm7dq0+//xzbd68WSUlJVWRCQAAAEAFNQ1ro0HxU3U096ASn3paZ37+2epIAOCSyi1IateurfHjx1dFFgAAAACXwd7qRg15bbp+yD+ieZExOnWywOpIAOCyyj2D5L333lPv3r2rIgsAAACACmrcrKmGJszUqZMFmhcRrcLjJ6yOBAAuzUvSJe/7dfLkSdWpU0dnzpzRL7/8Ii8vLxljFBAQUEURf5+K3ucYAAAAcDUN7cEavmiuJOm1AcN03HHY4kQAUH1VtB8o9y029erVq5RAAAAAAK5c/cZXK2r+bNlq1NBrAylHAKCylFuQSFL9+vXVvHlz1apVq2zt888/d1ooAAAAAOfzbxioyMRZ8qtXV3OHDNeR/QesjgQAbqPcgmTIkCGKiYmR3W5XamqqOnfurK1bt+rOO++sinwAAAAAJPnVq6fIefEKaHy1Xo+M1eHMvVZHAgC3Uu4hrTExMerQoYMOHjyo7t27KywsTMeOHauKbAAAAAAk1axdWxFzX9HVTZtoYew4HUhNszoSALidcl9Bcvr0aZ05c0aS5Ovrqz179ujGG290ejAAAAAAkq1mTQ2ePVX2Vjdq0dNx2rt1h9WRAMAtlVuQOBwOBQQEaM2aNfrwww914sQJ5eXlVUU2AAAAwKP52Gwa8Mo/dEP7MC3929/1zcecAwgAzlLubX7PdvvttysgIEAffPCBfvnlFyfGunLc5hcAAACuzNvHR/2n/F1t775TK/8+WdveWWt1JABwSVd8m9+6deuqoKBAgYGBZWu7d++WJPn7++vEiROVEBMAAADAf/Py8tL/TByvtnffqbXT4ilHAKAKXLQgWbp0qe6//359/fXXMsbIy8ur7HPGGDVr1qxKAgIAAACepu/4UerY9z5tfC1Rny1ebnUcAPAIl/UWG1fCW2wAAADgilPz6iUAACAASURBVHpHR6lHxAB9snCp3p0+2+o4AODyrvgtNmFhYZe8MCUl5fJTAQAAALio7kPC1SNigLauXEM5AgBV7KIFyfTp0yVJtWrVUvv27bVr1y55eXmpTZs2Sk5OVteuXassJAAAAODu/t/jD+ve2GHa+f5GJb0wzeo4AOBxvC/2ie7du6t79+46ePCg2rVrpw4dOqh9+/YKCwtTTk5OVWYEAAAA3FqHvvfqz38brfQtn2rZs5NkSkutjgQAHueiBclvWrZsqfT09LKPv/nmG7Vt29apoQAAAABP0aZndz0y8W/a82WyFv/1OZUWl1gdCQA80kXfYvObzMxMJSYm6p///KeMMfrLX/6izMzMqsgGAAAAuLWWXW/VXyb/XQdSd2th7HiV/PKL1ZEAwGOVexebmjVratiwYbr99tslSZ999pnmzp2rM2fOVEW+34272AAAAKA6a9Y+TBFzZyh/334lPDlSpwt/sjoSALilivYDFbrNb61atXT99ddr7969lZGtSlCQAAAAoLq6/qZWikycpR++O6I5g57STz/8aHUkAHBbFe0Hyj2D5P7771dqaqo++OADSdLNN9+stWvXXnlCAAAAwANd0+IPikiYocLjJ5QQEU05AgDVRLkFyYQJE9SxY0f98MMPkqRdu3YpJCTE2bkAAAAAt3NVyPWKfD1eRT+fUkLESBV8f9zqSACA/yi3ICkuLtbJkyerIgsAAADgtgKvDVJU4ixJUkJEtE7k5VucCABwtnLvYpOenq7HHntMPj4++sMf/qDo6Gh9+eWXVZENAAAAcAv1rmqkqPmz5VvbT3MGDdexA99aHQkA8F/KfQXJyJEj1bp1a505c0bLli3TyZMnFRsbWxXZAAAAAJdXp36AIl+Pl3+DQCVGjdJ3e3OsjgQAuIAK3cXGFXEXGwAAAFitln8dRS14VUE3NFXisFHa91WK1ZEAwONUtB8o9y02t9xyi+Li4hQSEiKb7f8efvPNN19ZQgAAAMCN+frV0pOvTdc1zZvpzZhxlCMAUM2VW5AsWbJEY8aM0e7du1VaWloVmQAAAACXZvP11cCZk9Xk5j/qrbHPK+vzrVZHAgCUo9yC5NixY3r33XerIgsAAADg8rxtPnpi2v/qxts6afmzk5S2aYvVkQAAFVDuGSTdu3fXY489po8++khnzpwpW1+9erWzs10RziABAABAVfPy9tbjLz6vdvferVUvTtcXy96xOhIAeLxKO4Nk0KBBatmypWrUqFH2FhtjTLUvSAAAAICq9tCzY9Tu3rv1/sy5lCMA4GLKLUhuvvlmtWnTpiqyAAAAAC7r/tEjdev/9NXmxEXasmCx1XEAAJfJu7wHbNu2TaGhoVWRBQAAAHBJPaMG646Bj+vzJSu0YVaC1XEAAL9DuWeQZGRkqFmzZsrNzdWZM2fk5eUlY0y1v80vZ5AAAACgKtwe3k99xsRo+5r3tOL5F2XMJX+9BgBUsUo7g6RXr16VEggAAABwN50f7qM+Y2KUuvEjrZjwEuUIALiwcguSb7/9tipyAAAAAC6l3b099dBzY5Xx2RdaOn6izH9uaAAAcE3lnkECAAAA4Fx/7H67+r3wnPZ/laJFTz+jkuJiqyMBAK4QBQkAAABwGVrc2kFPTJskxzdZemPkWBWfOWN1JABAJaAgAQAAACqoaVgbDYqfqqO5B5X41NM68/PPVkcCAFQSChIAAACgAuytbtSQ16brh/wjmhcZo1MnC6yOBACoRBQkAAAAQDkaN2uqoQkzdepkgeZFRKvw+AmrIwEAKhkFCQAAAHAJDe3Binw9XsW//KKEJ0fqhyNHrY4EAHCCcm/zCwAAAHiq+o2vVtT82bLVqKHXBj2l447DVkcCADgJBQkAAABwAf4NAxWZOEt+9eoq4ckROrIv1+pIAAAnoiABAAAA/otfvXqKnBev+kGN9XpkjBwZe6yOBABwMgoSAAAA4Cw1a9dWxJzpurppEy0Y8VflpqRZHQkAUAUoSAAAAID/sNWsqcGzp8reuqUWPR2nvVt3WB0JAFBFuIsNAAAAIMnHZtOAV/6hG9qHadkzk/TNx59bHQkAUIWcVpDY7XZt2bJFGRkZSk9PV3R0tCTp5ptv1tatW5WSkqIdO3aoQ4cOZdeMHz9e2dnZysrKUs+ePcvW27Vrp7S0NGVnZys+Pt5ZkQEAAOChvH189PjkiWp1exclTZqqlPWbrI4EALCAccYEBQWZsLAwI8n4+/ubPXv2mNDQULNx40bTq1cvI8n07t3bfPzxx0aSCQ0NNampqcbX19eEhISYnJwc4+3tbSSZ5ORk07lzZyPJrF+/vuz6S01hYaFTnhfDMAzDMAzjXuPl5WUenfSMmb57q7k9vJ/leRiGYZjKnYr2A057BUl+fr5SUlIkSYWFhcrMzFRwcLCMMapXr54kKSAgQHl5eZKkPn36aPny5SoqKtKBAweUk5Ojjh07KigoSPXq1dO2bdskSYsXL1bfvn2dFRsAAAAepu/4UerY9z5tnDNfny1ebnUcAIBFquSQ1iZNmigsLEzJycmKjY3Vxo0b9fLLL8vb21u33XabJCk4OLisBJEkh8Oh4OBg/fLLL3I4HOetAwAAAFeqd3SU/t/j/6NPFi3VprkLrI4DALCQ0w9prVOnjpKSkhQbG6uCggINGzZMo0aN0vXXX69Ro0ZpwYJf/0Pk5eV13rXGmIuuX0hERIR27NihHTt2yGbjBj0AAAC4uO5DwtUjYoC2rlyjd1+ebXUcAIDFnFqQ2Gw2JSUlacmSJVq9erUkacCAAVq1apUkaeXKlerYsaOkX18Zct1115Vda7fblZeXJ4fDIbvdft76hSQmJqpDhw7q0KGDiouLnfW0AAAA4OK6PPaw7o0dpp3vb1TSC9OsjgMAqAacWpAsWLBAmZmZmjFjRtlaXl6eunXrJknq3r27srOzJUnr1q1Tv3795Ovrq5CQEDVv3lzbt29Xfn6+CgoK1KlTJ0lSeHi41q5d68zYAAAAcGMd+tyjB+NGK33Lp1r27CSZ0lKrIwEAqgGnvQ+lS5cuCg8PV1paWtlhrXFxcYqIiFB8fLxsNptOnz6toUOHSpIyMjK0YsUKZWRkqLi4WMOHD1fpf/5jNWzYMC1cuFB+fn7asGGDNmzY4KzYAAAAcGNtenbXI3+P054vk7X4r8+ptLjE6kgAgGrCS7/ezsbtFBYWyt/f3+oYAAAAqCZadr1Vg+On6mBauhKHjVLRqdNWRwIAVIGK9gNOP6QVAAAAsFqz9mEa+MpLysvO0YIRf6UcAQCch4IEAAAAbu36m1pp8KvTdNxxWImRsTpd+JPVkQAA1RAFCQAAANzWNS3+oIiEGSo8fkLzhsbopx9+tDoSAKCaoiABAACAW7oq5HpFvh6vop9PKSFipE4e+97qSACAaoyCBAAAAG4n8NogRSXOkiQlRETrRF6+xYkAANWd027zCwAAAFihbqOGikqcLd/afpozaLiOHfjW6kgAABdAQQIAAAC3Uad+gKISZ8m/YaDmRUTru705VkcCALgIChIAAAC4hVr+dRQxb6Ya2oOVOGyUvt2dYXUkAIALoSABAACAy/P1q6UnX5uua5v/QW/GjNO+r1KsjgQAcDEUJAAAAHBpNl9fDZw5WU1u/qPeGvu8Mj//0upIAAAXxF1sAAAA4LK8bT56Ytr/6sbbOmnFhBeVtmmL1ZEAAC6KggQAAAAuycvLS/0mPas/du+mVS9O1461662OBABwYRQkAAAAcEkPPjtGt9zXS+/PnKsvlr1jdRwAgIujIAEAAIDLuX/0SN32yJ+1OXGRtixYbHUcAIAboCABAACAS+kZNVh3DHxc/1q6UhtmJVgdBwDgJihIAAAA4DJuD++nu4dHaPua97Rm8gyr4wAA3AgFCQAAAFxC54f7qM+YGO3atEUrJ06WMcbqSAAAN0JBAgAAgGqv3b099dBzY5Xx2RdaMm6CSktKrI4EAHAzFCQAAACo1lr/qav6vfCc9n+VokVPP6OS4mKrIwEA3BAFCQAAAKqtFrd2UPjLL8jxTZbeGDlWxWfOWB0JAOCmKEgAAABQLTUNa6OBM6foaO5BJT71tM78/LPVkQAAboyCBAAAANWOvdWNGvLadP145KjmRcbo1MkCqyMBANwcBQkAAACqlcbNmmpowkydOlmgeRHRKjx+wupIAAAPQEECAACAaqOhPViRr8erpLhYCRHR+uHIUasjAQA8hM3qAAAAAIAk1W98taLmz5atRg29NugpHT/ksDoSAMCDUJAAAADAcv4NAhWZOEt+9eoq4ckROrIv1+pIAAAPQ0ECAAAAS/nVq6uh82aqflBjvR4ZI0fGHqsjAQA8EAUJAAAALFOzdm1FzHlFjW8I0YIRf1VuSprVkQAAHoqCBAAAAJaw1aypwbOnyt66pRY9Hae9W3dYHQkA4MG4iw0AAACqnI/NpgGv/EM3tA/T8mcn6ZuPP7c6EgDAw1GQAAAAoEp5+/jo8ckT1er2LkqaNFU7399kdSQAAChIAAAAUHW8vLz0PxPHq+3dd2rdtFna9s5aqyMBACCJggQAAABVqM+4WHXse582zpmvTxcvszoOAABlKEgAAABQJXqPjFTX/o/ok0VLtWnuAqvjAABwDgoSAAAAOF33IU+ox9CB2rpyjd59ebbVcQAAOA8FCQAAAJyqy2MP697Yp7Tz/Y1KemGa1XEAALggChIAAAA4TYc+9+jBuNFK3/Kplj07Saa01OpIAABcEAUJAAAAnKJNz+565O9x2rt1u94a87xKi0usjgQAwEVRkAAAAKDStex6q/4y+e86uCtdb8aMU3FRkdWRAAC4JAoSAAAAVKpm7cM08JWXlJedo/nDR6vo1GmrIwEAUC4KEgAAAFSa629qpcGvTtNxx2ElRsbqdOFPVkcCAKBCKEgAAABQKa5p0UwRc2eo8PgJzRsao59++NHqSAAAVBgFCQAAAK7YVSHXK/L1WSo6dUoJESN18tj3VkcCAOCyUJAAAADgigReG6SoxFmSpISIaJ3Iy7c4EQAAl89mdQAAAAC4rrqNGioqcbZ8a/tpzqDhOnbgW6sjAQDwu1CQAAAA4HepUz9AUYmzVLdRAyVEROu7vTlWRwIA4HejIAEAAMBlq+VfRxHzZqqhPViJTz2tb9O+sToSAABXhIIEAAAAl8XXr5aefG26rm3+B70ZM077duy0OhIAAFeMggQAAAAV5lOjhgbOnKwmN/9Rb419Xpmff2l1JAAAKgV3sQEAAECFeNt89MS0Sbrxtk5aMeFFpW3aYnUkAAAqDQUJAAAAyuXl5aV+k57VTXd206oXp2vH2vVWRwIAoFJRkAAAAKBcDz47Rrfc10vvz5yrL5a9Y3UcAAAqHQUJAAAALun+0SN12yN/1kfzF2vLgsVWxwEAwCkoSAAAAHBRPaMG646Bj+tfS1dqffxcq+MAAOA0FCQAAAC4oNvD++nu4RHavuY9rZk8w+o4AAA4FQUJAAAAztP54T7qMyZGuzZt0cqJk2WMsToSAABORUECAACAc4Td01MPPTdWGZ99oSXjJqi0pMTqSAAAOJ3TChK73a4tW7YoIyND6enpio6OLvvciBEjlJWVpfT0dE2ZMqVsffz48crOzlZWVpZ69uxZtt6uXTulpaUpOztb8fHxzooMAADg8Vr/qase+8dz2v9VihY9/YxKioutjgQAQJUxzpigoCATFhZmJBl/f3+zZ88eExoaau644w7z4YcfGl9fXyPJXHXVVUaSCQ0NNampqcbX19eEhISYnJwc4+3tbSSZ5ORk07lzZyPJrF+/3vTq1avc719YWOiU58UwDMMwDOOu0+LWDmbK15+a6H8mmpq1a1ueh2EYhmEqYyraDzjtFST5+flKSUmRJBUWFiozM1PBwcEaNmyYJk+erKKiIknSsWPHJEl9+vTR8uXLVVRUpAMHDignJ0cdO3ZUUFCQ6tWrp23btkmSFi9erL59+zorNgAAgEdqGtZGA2dO0dHcg0p8arTO/Pyz1ZEAAKhSVXIGSZMmTRQWFqbk5GS1aNFCXbt21bZt2/TJJ5+offv2kqTg4GAdOnSo7BqHw6Hg4GAFBwfL4XCctw4AAIDKYW91o4a8Nl0/HjmqeZExOnXypNWRAACocjZnf4M6deooKSlJsbGxKigokM1mU2BgoDp37qwOHTpoxYoVuuGGG+Tl5XXetcaYi65fSEREhIYOHSpJstmc/tQAAABcXuNmTTU0YaZOnSzQvIhoFR4/YXUkAAAs4dRXkNhsNiUlJWnJkiVavXq1pF9fAbJq1SpJ0o4dO1RaWqpGjRrJ4XDouuuuK7vWbrcrLy9PDodDdrv9vPULSUxMVIcOHdShQwcVc6AYAADAJTW0Byvy9XiVFBcrISJaPxw5anUkAAAs49SCZMGCBcrMzNSMGTPK1tasWaPu3btLkpo3by5fX199//33Wrdunfr16ydfX1+FhISoefPm2r59u/Lz81VQUKBOnTpJksLDw7V27VpnxgYAAHB7AY2vUtT82bLVqKGEiGgdP+Qo/yIAANyY096H0qVLF4WHhystLa3ssNa4uDi98cYbeuONN7R7924VFRVpwIABkqSMjAytWLFCGRkZKi4u1vDhw1VaWipJGjZsmBYuXCg/Pz9t2LBBGzZscFZsAAAAt+ffIFBRibPlV6+uEp4coSP7cq2OBACA5bz06+1s3E5hYaH8/f2tjgEAAFCt+NWrq2ELXtVVTa7X65Exyk1JszoSAABOVdF+gJNMAQAAPETN2rUVMecVNb4hRAtG/JVyBACAs1CQAAAAeABbzZoaPHuq7K1bavHoZ7R36w6rIwEAUK049ZBWAAAAWM/HZtOAV/6hG9qHafmzk5S+5TOrIwEAUO1QkAAAALgxL29vPT55olrd3kVJk6Zq5/ubrI4EAEC1REECAADgpry8vPTIxL+p7d13at20Wdr2zlqrIwEAUG1RkAAAALipPuNi1fHP92njnPn6dPEyq+MAAFCtUZAAAAC4od4jI9W1/yP6ZNFSbZq7wOo4AABUexQkAAAAbqb7kCfUY+hAbX1njd59ebbVcQAAcAkUJAAAAG6ky2MP697Yp7Tz/Y1KmjTN6jgAALgMChIAAAA30aHPPXowbrTSt3yqZc9OkikttToSAAAug4IEAADADbTp2V2P/D1Oe7du11tjnldpcYnVkQAAcCkUJAAAAC6uZddb1X/yRB3cla43Y8apuKjI6kgAALgcChIAAAAX1qx9mAa+8pK+y96n+cNHq+jUaasjAQDgkihIAAAAXNT1N7XS4Fen6bjjsBIjY3W68CerIwEA4LIoSAAAAFzQNS2aKWLuDBUeP6F5Q2P00w8/Wh0JAACXRkECAADgYq4KuV6Rr89S0enTSogYqZPHvrc6EgAALo+CBAAAwIUEXhukqMRZkqR5EdE6kZdvcSIAANyDzeoAAAAAqJi6jRoqKnG2fGv7ac6g4Tqae9DqSAAAuA0KEgAAABdQp36AohJnqW6jBkqIiNZ3e3OsjgQAgFuhIAEAAKjmavnXUUTCDDW0Byvxqaf1bdo3VkcCAMDtUJAAAABUY75+tTTk1Zd1bYvmejNmnPbt2Gl1JAAA3BIFCQAAQDXlU6OGBs6crJC2N+mtsc8r8/MvrY4EAIDb4i42AAAA1ZC3zUdPTJukG2/rpBUTX1Lapi1WRwIAwK1RkAAAAFQzXl5e6jfpWd10Zzetfmm6dqx53+pIAAC4PQoSAACAaubBZ8folvt6aX18gv619B2r4wAA4BEoSAAAAKqR+0eP1G2P/FkfzV+sj+YvsjoOAAAeg4IEAACgmrgrarDuGPi4/rV0pdbHz7U6DgAAHoWCBAAAoBq4/Yl+6jU8QtvXvKc1k2dYHQcAAI9DQQIAAGCxTg89oD5jY7Rr0xatnDhZxhirIwEA4HEoSAAAACwUdk9PPfz8OGV89oWWjJug0pISqyMBAOCRKEgAAAAs0vpPXfXYP57T/q9TtejpZ1RSXGx1JAAAPBYFCQAAgAVa3NpB4S+/IEfGHr0xYoyKz5yxOhIAAB6NggQAAKCKNQ1ro4Ezp+ho7kElDntaZ37+2epIAAB4PAoSAACAKhQc2kJDXpuuH48c1bzIGJ06edLqSAAAQBQkAAAAVabxDSGKnBevUycLNC8iWoXHT1gdCQAA/AcFCQAAQBVoaA9WZOIslRQXKyEiWj8cOWp1JAAAcBab1QEAAADcXUDjqxQ1f7ZsNWrotUFP6fghh9WRAADAf6EgAQAAcCL/BoGKSpyt2gH1NHfIcB3Zl2t1JAAAcAEUJAAAAE7iV6+uhs6bqfpBjfV6VKwcGXusjgQAAC6CggQAAMAJataurYg5r6jxDSFaMGKMcnfusjoSAAC4BAoSAACASmarWVODZk2RvXVLLR79jPZu3W51JAAAUA7uYgMAAFCJfGw2DZj+DzXr0E7Ln52k9C2fWR0JAABUAAUJAABAJfHy9tbjL01Qq25dlDRpqna+v8nqSAAAoIIoSAAAACqBl5eXHpn4N7Xt1UPrps3StnfWWh0JAABcBgoSAACAStBnXKw6/vk+bZwzX58uXmZ1HAAAcJkoSAAAAK5Q75GR6tr/EX26eJk2zV1gdRwAAPA7UJAAAABcge5DnlCPoQO19Z01WjdtltVxAADA70RBAgAA8Dt1eexh3Rv7lHa+v1FJk6ZZHQcAAFwBChIAAIDfof0D9+jBuNFK3/Kplj07Saa01OpIAADgClCQAAAAXKY2d/1Jj/5vnPZu3a63xjyv0uISqyMBAIArREECAABwGVp2vVX9p/xdB3el682YcSouKrI6EgAAqAQUJAAAABXUrH2YBr7ykr7L3qf5w0er6NRpqyMBAIBKQkECAABQAdff1EqDX52m447DSoyM1enCn6yOBAAAKhEFCQAAQDmuadFMEXNnqPDfJzRvaIx++uFHqyMBAIBKRkECAABwCVeFXK/I12ep6PRpJTw5UiePfW91JAAA4AQUJAAAABcReE2QohJnSZLmRUTrRF6+xYkAAICz2KwOAAAAUB3VbdRQUfNny7e2n+YMGq6juQetjgQAAJzIaa8gsdvt2rJlizIyMpSenq7o6OhzPj969GgZY9SwYcOytfHjxys7O1tZWVnq2bNn2Xq7du2Ulpam7OxsxcfHOysyAACAJKlO/QBFvh6vuo0aKHHY0/pub47VkQAAQBUwzpigoCATFhZmJBl/f3+zZ88eExoaaiQZu91uPvjgA3PgwAHTsGFDI8mEhoaa1NRU4+vra0JCQkxOTo7x9vY2kkxycrLp3LmzkWTWr19vevXqVe73LywsdMrzYhiGYRjGvaeWfx0Tu/wNM3nHJ6ZZh3aW52EYhmEY5sqmov2A015Bkp+fr5SUFElSYWGhMjMzFRwcLEmaMWOGxo4dK2NM2eP79Omj5cuXq6ioSAcOHFBOTo46duyooKAg1atXT9u2bZMkLV68WH379nVWbAAA4MF8/WppyKsv69oWzbXo6Tjt27HT6kgAAKCKVMkhrU2aNFFYWJiSk5N1//336/Dhw0pLSzvnMcHBwTp06FDZxw6HQ8HBwQoODpbD4Thv/UIiIiK0Y8cO7dixQzYbx6sAAICK86lRQwNnTlZI25u05G8Tlfn5l1ZHAgAAVcjpLUKdOnWUlJSk2NhYFRcX65lnnjnnfJHfeHl5nbdmjLno+oUkJiYqMTFR0q+vWgEAAKgIb5uPnpg2STfe1knLn3tBuzZ+ZHUkAABQxZz6ChKbzaakpCQtWbJEq1evVrNmzdS0aVPt2rVLubm5stvt2rlzpxo3biyHw6Hrrruu7Fq73a68vDw5HA7Z7fbz1gEAACqDl5eX+k16Vjfd2U2rX5quHWvetzoSAACwiNMOQlm0aJGZMWPGRT+fm5tbdkhrq1atzjmkdd++fWWHtG7fvt106tTJSL8e0tq7d+9KO4SFYRiGYRjPnoeeHWOm795q7nxygOVZGIZhGIap/KloP+C0t9h06dJF4eHhSktLKzusNS4uThs2bLjg4zMyMrRixQplZGSouLhYw4cPV2lpqSRp2LBhWrhwofz8/LRhw4aLfg0AAIDLcd/TI3Tbow/qo/mL9dH8RVbHAQAAFvLSr02J2yksLJS/v7/VMQAAQDV1V9Rg9RoeoX8tXanVL71idRwAAOAkFe0HquQuNgAAANXJ7U/0U6/hEdqx9n2tmTzD6jgAAKAaoCABAAAepdNDD6jP2Bjt2rRFKya8dNG74wEAAM9CQQIAADxG2D099fDz45T5+ZdaMm6CSktKrI4EAACqCQoSAADgEVr/qase+8dz2v91qhaOilNJcbHVkQAAQDVCQQIAANxe884dFP7yC3Jk7NEbI8ao+MwZqyMBAIBqhoIEAAC4tZC2bTQofoqO5h5U4rCndebnn62OBAAAqiEKEgAA4LaCQ1voyTnT9eORo5oXGaNTJ09aHQkAAFRTFCQAAMAtNb4hRJHz4nXqZIHmRUSr8PgJqyMBAIBqjIIEAAC4nYb2YEUmzlJJcbESIqL1w5GjVkcCAADVnM3qAAAAAJUpoPFVipo/WzZfX80Z9JSOH3JYHQkAALgAChIAAOA2/BsEKipxtmoH1NPcISOUn7Pf6kgAAMBFUJAAAAC34FevrobOm6n6QY31elSsHBlZVkcCAAAuhIIEAAC4vJq1a+vJOdPV+IYQLRgxRrk7d1kdCQAAuBgKEgAA4NJsNWtq0Kwpuq51qBaPfkZ7t263OhIAAHBB3MUGAAC4LB+bTQOm/0PNOrTT8mcnKX3LZ1ZHAgAALoqCBAAAuCQvb289/tIEterWRUkvTNPO9zdZHQkAALgwChIAAOByvLy89MjEv6ltrx569+XZ2rZyjdWRAACAi6MgAQAALqfPuFh1/PN92jR3gT5ZtNTqOAAAwA1QkAAAAJfSe2SkuvZ/RJ8uXqaNc+ZbHQcAkXj5LgAAFjhJREFUALgJChIAAOAyug95Qj2GDtTWd9Zo3bRZVscBAABuhIIEAAC4hC79HtK9sU9p5/sblTRpmtVxAACAm6EgAQAA1V77B+7Rg8/8VelbPtWyZyfJlJZaHQkAALgZChIAAFCttbnrT3r0f+O0d+t2vTXmeZUWl1gdCQAAuCEKEgAAUG217Hqr+k/5uw6mfaM3Y8apuKjI6kgAAMBNUZAAAIBqqVn7MA185SXlZ+/X/OGjVXTqtNWRAACAG6MgAQAA1c71N7XS4Fen6fjhPL0eFavTBYVWRwIAAG6OggQAAFQr17Ropoi5M1T47xOaFxGtn078YHUkAADgAShIAABAtdGoyXWKfH2Wik6fVsKTI3Xy2PdWRwIAAB6CggQAAFQLgdcEKSpxliRpXkS0TuTlW5wIAAB4EpvVAQAAAOo2aqio+bNVs05tzRk0XEdzD1odCQAAeBgKEgAAYKk69QMU+Xq86jZqoISIaH23N8fqSAAAwANRkAAAAMvU8q+jiIQZanS9XfOfGq1v076xOhIAAPBQFCQAAMASvn61NOTVl3Vti+Z6M2accrZ/bXUkAADgwShIAABAlfOpUUMDZ7ykkLY36Z/jJijz8y+tjgQAADwcd7EBAABVytvHR3+Z+r+6sUtnrZj4knZt/MjqSAAAABQkAACg6nh5eenRSc+oTY87tPql6dqx5n2rIwEAAEiiIAEAAFXowWf+qvb399b6+AT9a+k7VscBAAAoQ0ECAACqxH1Pj9Btjz6oj+Yv1kfzF1kdBwAA4BwUJAAAwOnuihqsPw3qr38te0fr4+daHQcAAOA8FCQAAMCpbn+in3oNj9COte9rzUuvWB0HAADggihIAACA03R66AH1GRujXZu2aMWEl2SMsToSAADABVGQAAAApwjrfZcefn6cMj//UkvGTVBpSYnVkQAAAC6KggQAAFS61nf8Pz324vPa/3WqFo6KU0lxsdWRAAAALomCBAAAVKrmnTsofPo/5MjYozdGjFHxmTNWRwIAACgXBQkAAKg0IW3baFD8FB3NPajEYU/rzM8/Wx0JAACgQihIAABApQgObaEn50zXyaPHNC8yRqdOnrQ6EgAAQIVRkAAAgCvW+IYQRc6L16mCAiVERKvw+AmrIwEAAFwWChIAAHBFGtqDFZk4SyXFxUp4Mlo/5B+xOhIAAMBls1kdAAAAuK6AxlcpMnGWbL6+mjPoKR0/5LA6EgAAwO9CQQIAAH4X/waBikqcrTr1AzR3yAjl5+y3OhIAAMDvRkECAAAqLOyenronJkqBQY1VUlIiGaOEiGg5MrKsjgYAAHBFKEgAAECFhN3TU49MHC9fPz9Jks3bW7+cOaP6QY0tTgYAAHDlOKQVAABUyD0xUWXlyG9q1Kype2KiLEoEAABQeShIAABAhQRe5JUiF1sHAABwJRQkAACgQk5c5Pa9F1sHAABwJRQkAACgQtbHJ6jo1Klz1opOndL6+ASLEgEAAFQepxUkdrtdW7ZsUUZGhtLT0xUdHS1Jmjp1qjIzM7Vr1y6tWrVKAQEBZdeMHz9e2dnZysrKUs+ePcvW27Vrp7S0NGVnZys+Pt5ZkQEAwCWkrN+kFRMn699538mUlurfed9pxcTJSlm/yepoAAAAlcI4Y4KCgkxYWJiRZPz9/c2ePXtMaGioueuuu4yPj4+RZCZPnmwmT55sJJnQ0FCTmppqfH19TUhIiMnJyTHe3t5GkklOTjadO3c2ksz69etNr169yv3+hYWFTnleDMMwDMMwDMMwDMO4zlS0H3DaK0jy8/OVkpIiSSosLFRmZqaCg4P14YcfqqSkRJK0bds22e12SVKfPn20fPlyFRUV6cCBA8rJyVHHjh0VFBSkevXqadu2bZKkxYsXq2/fvs6KDQAAAAAAPFCVnEHSpEkThYWFKTk5+Zz1wYMHa8OGDZKk4OBgHTp0qOxzDodDwcHBCg4OlsPhOG8dAAAAAACgstic/Q3q1KmjpKQkxcbGqqCgoGw9Li5OxcXFWrJkiSTJy8vrvGuNMRddv5CIiAgNHTpUkmSzOf2pAQAAAAAAN+HUFsFmsykpKUlLlizR6tWry9bDw8N133336c477yxbczgcuu6668o+ttvtysvLk8PhKHsbztnrF5KYmKjExERJv76tBwAAAAAAoCKc+habBQsWKDMzUzNmzChbu/vuuzVu3Dg98MADOnXWrQLXrVunfv36ydfXVyEhIWrevLm2b9+u/Px8FRQUqFOnTpJ+LVfWrl3rzNgAAAAAAMDDOO0VJF26dFF4eLjS0tLKDmuNi4vTrFmzVLNmTX344YeSfj2oddiwYcrIyNCKFSuUkZGh4uJiDR8+XKWlpZKkYcOGaeHChfLz89OGDRvKzi0BAAAAAACoDF769XY2bqewsFD+/v5WxwAAAAAAABaqaD9QJXexAQAAAAAAqM4oSAAAAAAAgMejIAEAAAAAAB6PggQAAAAAAHg8ChIAAAAAAODxKEgAAAAAAIDHoyABAAAAAAAej4IEAAAAAAB4PAoSAAAAAADg8ShIAAAAAACAx6MgAQAAAAAAHo+CBAAAAAAAeDwKEgAAAAAA4PEoSAAAAAAAgMfzkmSsDuEMJSUlOnXqlNUxUA3YbDYVFxdbHQPVBPsBZ2M/4DfsBZyN/YDfsBdwNvaD6/Lz85OPj0+FHmvccXbs2GF5BqZ6DHuBOXvYD8zZw35gfhv2AnP2sB+Y34a9wJw97Af3H95iAwAAAAAAPB4FCQAAAAAA8Hg+kiZaHcJZdu7caXUEVBPsBZyN/YCzsR/wG/YCzsZ+wG/YCzgb+8G9ue0hrQAAAAAAABXFW2wAAAAAAIDHc7uC5O6771ZWVpays7M1btw4q+Ogktjtdm3ZskUZGRlKT09XdHS0JCkwMFCbNm3S3r17tWnTJtWvX7/smvHjxys7O1tZWVnq2bNn2Xq7du2Ulpam7OxsxcfHl637+vpq+fLlys7O1rZt29SkSZOqe4K4bN7e3tq5c6feffddSewFTxYQEKCVK1cqMzNTGRkZ6ty5M/vBg8XGxio9PV27d+/W0qVLVbNmTfaDB1mwYIGOHDmi3bt3l61V1c8/PDxce/fu1d69exUeHu7kZ4ryXGgvTJ06VZmZmdq1a5dWrVqlgICAss+xF9zbhfbDb0aPHi1jjBo2bFi2xn7wbJbfSqeyxtvb2+Tk5JimTZuaGjVqmNTUVBMaGmp5LubKJygoyISFhRlJxt/f3+zZs8eEhoaaKVOmmHHjxhlJZty4cWby5MlGkgkNDTWpqanG19fXhISEmJycHOPt7W0kmeTkZNO5c2cjyaxfv9706tXLSDLDhg0zc+fONZLMo48+apYvX27582YuPqNGjTJLliwx7777rpHEXvDgWbhwoRkyZIiRZGrUqGECAgLYDx461157rdm/f7+pVauWkWTefvttM2DAAPaDB03Xrl1NWFiY2b17d9laVfz8AwMDzb59+0xgYKCpX7++2bdvn6lfv77lfx+ePBfaC3fddZfx8fExkszkyZPZCx40F9oPkozdbjcffPCBOXDggGnYsCH7gTGqBgEqbTp37mw++OCDso/Hjx9vxo8fb3kupvJnzZo1pkePHiYrK8sEBQUZ6dcSJSsr64I/+w8++MB07tzZBAUFmczMzLL1fv36mYSEhHMeI8n4+PiYY8eOWf48mQtPcHCw2bx5s/nTn/5UVpCwFzxz6tata/bv33/eOvvBM+faa6813377rQkMDDQ+Pj7m3XffNXfddRf7wcOmSZMm5/xPUFX8/M9+jCSTkJBg+vXrZ/nfhafPf++Fs6dv377mn//8J3vBg+ZC+2HlypWmTZs2Jjc3t6wgYT949rjVW2yCg4N16NChso8dDoeCg4MtTARnaNKkicLCwpScnKzGjRsrPz9fkpSfn6+rr75a0sX3QnBwsBwOx3nr/31NSUmJfvzxx3NeaofqY+bMmRo7dqxKS0vL1tgLnumGG27QsWPH9Oabb2rnzp1KTExU7dq12Q8eKi8vTy+//LK+/fZbfffdd/rxxx/14Ycfsh88XFX8/Pkd1PUMHjxYGzZskMRe8FT333+/Dh8+rLS0tHPW2Q+eza0KEi8vr/PWjDEWJIGz1KlTR0lJSYqNjVVBQcFFH3exvXCpPcL+cQ333nuvjh49WuFbrLEX3JvNZlO7du00d+5ctWvXTj/99JPGjx9/0cezH9xb/fr11adPHzVt2lTXXnut6tSpo/79+1/08ewHz1aZP3/2hWuJi4tTcXGxlixZIom94In8/Pz0zDPP6Pnnnz/vc+wHz+ZWBYnD4dB1111X9rHdbldeXp6FiVCZbDabkpKStGTJEq1evVqSdOTIEQUFBUmSgoKCdPToUUkX3wsOh0N2u/289f++xsfHRwEBAfr3v/9dJc8NFdelSxc98MADys3N1fLly9W9e3e99dZb7AUP5XA45HA4tH37dknSO++8o3bt2rEfPFSPHj2Um5ur77//XsXFxVq1apVuu+029oOHq4qfP7+Duo7w8HDdd99955Sn7AXP06xZMzVt2lS7du1Sbm6u7Ha7du7cqcaNG7MfYP37fCprfHx8zL59+0xISEjZIa2tWrWyPBdTObNo0SIzY8aMc9amTp16zsFrU6ZMMZJMq1atzjlcad++fWWHK23fvt106tTJSL8ertS7d28jyTz11FPnHK709ttvW/6cmUtPt27dys4gYS947nz22WemRYsWRpKZMGGCmTp1KvvBQ6djx44mPT3d+Pn5GenXA3xHjBjBfvCw+e9zBqri5x8YGGj2799v6tevb+rXr2/2799vAgMDLf+78PT5771w9913m2+++cY0atTonMexFzxjLnUmzdlnkLAfPH4sD1Cp07t3b7Nnzx6Tk5Nj4uLiLM/DVM506dLFGGPMrl27TEpKiklJSTG9e/c2DRo0MJs3bzZ79+41mzdvPucfnLi4OJOTk2OysrLKTpiWZG655Raze/duk5OTY2bPnl22XrNmTbNixQqTnZ1tkpOTTdOmTS1/3syl5+yChL3guXPzzTebHTt2mF27dpnVq1eb+vXrsx88eCZOnGgyMzPN7t27zeLFi42vry/7wYNm6dKlJi8vzxQVFZlDhw6ZwYMHV9nPf9CgQSY7O9tkZ2ebgQMHWv534elzob2QnZ1tvv3227LfJX/7H1r2gvvPhfbD2Z8/uyBhP3j2eP3nDwAAAAAAAB7Lrc4gAQAAAAAA+D0oSAAAAAAAgMejIAEAAAAAAB6PggQAAAAAAHg8ChIAAAAAAODxKEgAAICKi4uVkpJSNk2aNJEkdenSRcnJycrMzFRmZqYiIiIkSd26ddOXX355ztfw8fFRfn6+goKCqjz/2d5880099NBDl3zMgAEDdM0115R9nJiYqNDQUGdHu2J9+vRxiZwAALgim9UBAACA9U6dOqWwsLBz1ho3bqylS5eqb9++SklJUcOGDbVx40YdPnxYGzZskN1uV5MmTXTw4EFJUo8ePZSenq78/HwrnsJlGThwoNLT0/Xdd99JUlnxU9317dtX7733njIzM62OAgCA2+EVJAAA4IKGDx+uhQsXKiUlRZJ0/PhxjR07VuPHj5cxRitXrtSjjz5a9vh+/fpp2bJl532dq6++WqtWrVJqaqpSU1N16623qkmTJtq9e3fZY0aPHq0JEyZIkj7++GO98sor+vTTT5WRkaH27dsrKSlJe/fu1aRJkyTpktef7bnnntP27du1e/duzZs3T5L00EMPqX379lqyZIlSUlJUq1Ytffzxx7rlllsUFRWlKVOmlF0/YMAAzZo1S5LUv39/JScnKyUlRQkJCfL2Pv/XqPbt2+uLL75QamqqkpOT5e/vr5o1a+qNN95QWlqadu7cqTvuuKPsa8+ePbvs2nfffVfdunWTJBUUFOiFF15Qamqqtm7dqquvvlq33nqrHnjgAU2bNk0pKSm64YYbLvXjAwAAl4mCBAAAyM/Pr+ztNatWrZIktW7dWl9//fU5j/vqq6/UunVrSdKyZcvUr18/SZKvr6/uueceJSUlnfe1Z82apU8//VRt27ZVu3bt9M0335Sbp6ioSN26dVNCQoLWrl2r4cOH649//KMGDhyoBg0aVPh5vfrqq+rYsaNuuukm+fn56b777lNSUpK++uor9e/fX2FhYTp9+nTZ49955x09+OCDZR8/+uijevvtt9WyZUs9+uij6tKli8LCwlRSUqL+/fuf871q1Kiht99+WzExMWrbtq169OihU6dOafjw4ZKkNm3a6LHHHtOiRYtUs2bNS+b29/fXtm3b1LZtW3322WeKiIjQ1q1btW7dOo0ZM0ZhYWHav39/hf8eAABA+XiLDQAAuOBbbLy8vGSMOe+xv6199dVX8vf3V4sWLRQaGqpt27bphx9+OO/x3bt3V3h4uCSptLRUJ0+eVGBg4CXzrFu37v+3c/cgybVxHMd/WvSKQ0INUW4ltRQoRdBS1NbQIL2AQ9AUQm0NEQRtNQWRRC41pUsNNQUtgVCUDZlvBFkR9IJDERilwjNEB7wfq/t+Xia/n+kcz/U/Xtd2+J3rfyRJ4XBYkUjEaNu5vLxUY2Njwf8ppKenR9PT06qqqpLValUkEtHu7u6X41OplC4vL9XZ2amLiwvZ7XYFg0F5PB45HA4dHx9L+giUHh8f82rtdrvu7u50cnIi6WMXiCR1d3cbO0USiYSur6/V3Nz87bzf3t6MeYZCIfX39//WegEAwD9HQAIAAAqKRCJyOp3a2dkxfnM4HIpGo8a53+/XyMiIWlpaCrbXfCWbzea1qFRUVORdf3t7k/QRqHwef56Xlpb+WC9J5eXl8nq9cjqdur291dzcXMFxvwoEAhoaGlI8Htf29rakj7BoY2NDMzMzX9Z9FSiZTKaC479bQyaTMY5zuZxKS3lkAwDg/0aLDQAAKGhlZUVjY2Nqa2uTJFmtVi0sLGhxcdEYs7m5Kbfbrd7eXmPXx6/29/c1MTEhSTKbzbJYLHp4eFBdXZ2sVqvKyso0MDDwR3P7nfrPwCGVSqm6uloul8u49vLyIovFUvDeW1tbGhwc1OjoqAKBgLEGl8ul2tpaSVJNTY1sNlteXTweV319vZxOp6SPNpmSkhIdHBwY7ThNTU2y2WxKJBK6urpSe3u7TCaTGhoa1NHR8eO6v5s3AAD4d3gdAQAACrq/v5fb7ZbP55PFYpHJZNLS0lJei0osFlM6nVYoFFI6nS54n6mpKa2trWl8fFy5XE4TExM6PDzU/Py8jo6OlEwmFY/H/2hu2Wz2x/rn52f5fD6Fw2FdXV0Z7TGStL6+rtXVVb2+vqqrqyuv7unpSdFoVK2trUZNLBbT7Oys9vb2ZDablclk5PF4dHNzY9RlMhkNDw9reXlZlZWVen19VV9fn7xer1ZXV3V2dqZsNquxsTG9v78rGAwqmUwqHA7r/Pxcp6enP67b7/fL5/NpcnJSLpeL75AAAPAfMkn6+15QAAAAAACAIkKLDQAAAAAAKHoEJAAAAAAAoOgRkAAAAAAAgKJHQAIAAAAAAIoeAQkAAAAAACh6BCQAAAAAAKDoEZAAAAAAAICiR0ACAAAAAACK3l+EkVq5N97p+QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 5b0df6d7..7e04f416 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -8,21 +8,29 @@ def get_estimated_time(bin_file_path): - + """Retrieve run time data for each bin file + Args: + bin_file_path (str): path to the FOV bin and json files + Returns: + fov_times (dictionary): fov bin file names and estimated run time + """ + + # get json files in bin_file_path fov_files = bin_files._find_bin_files(bin_file_path) json_files = \ [(name, os.path.join(bin_file_path, fov['json'])) for name, fov in fov_files.items()] - time_list = {} + fov_times = {} + # retrieve estimated time (frame dimensions x pixel dwell time) for j in json_files: with open(j[1]) as file: run_metadata = json.load(file) size = run_metadata.get('frameSize') time = run_metadata.get('dwellTimeMillis') estimated_time = int(size**2 * time) - time_list[j[0]] = estimated_time + fov_times[j[0]] = estimated_time - return time_list + return fov_times def compute_mph_metrics(bin_file_path, target, save_csv=True, mass_range=None): @@ -84,6 +92,8 @@ def combine_mph_metrics(bin_file_path, output_dir): def visualize_mph(mph_df, regression: bool, save_dir=None): # visualize the median pulse heights + plt.style.use('dark_background') + # plt.title('FOV total counts vs median pulse height') fig = plt.figure() ax1 = fig.add_subplot(111) ax2 = ax1.twiny() @@ -97,8 +107,6 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): ax2.set_xlim(0, max(x) + 10000) ax2.set_xticks(x) ax2.set_xticklabels(mph_df['cum_total_time']) - plt.style.use('dark_background') - # plt.title('FOV total counts vs median pulse height') plt.gcf().set_size_inches(18.5, 10.5) if not regression and save_dir is not None: From fabe5ed2f3cce7cf0dccbf9d60825054d6b51ae9 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 18 May 2022 10:05:42 -0700 Subject: [PATCH 18/94] validate paths issue --- toffy/mph_comp.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index c0a78df5..f2e9b5ce 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -101,7 +101,8 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): """ # path validation checks - io_utils.validate_paths(save_dir) + if save_dir is not None: + io_utils.validate_paths(save_dir) # visualize the median pulse heights plt.style.use('dark_background') From 8aec085145d641e349f5f4297e5b895614a64b46 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 18 May 2022 10:43:13 -0700 Subject: [PATCH 19/94] cumulative total counts list --- toffy/mph_comp.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index f2e9b5ce..b572a8e6 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -81,14 +81,14 @@ def combine_mph_metrics(bin_file_path, output_dir): i = i+1 temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i))) pulse_heights.append(temp_df['MPH'].values[0]) - # calculate total counts cumulatively for plotting - if i > 1: - fov_counts.append(temp_df['total_count'].values[0] + fov_counts[i - 2]) - else: - fov_counts.append(temp_df['total_count'].values[0]) + fov_counts.append(temp_df['total_count'].values[0]) + + # calculate cumulative sums of total counts + fov_counts_cum = [fov_counts[j]+fov_counts[j-1] if j > 0 else fov_counts[j] + for j in range(len(fov_counts))] # save csv to output_dir - combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts}) + combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts_cum}) combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) From 45fcb63abd45bb5ca32953ff47f03166e74813db Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 18 May 2022 10:54:31 -0700 Subject: [PATCH 20/94] enumerate --- toffy/mph_comp.py | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index b572a8e6..31cc9a95 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -28,24 +28,22 @@ def compute_mph_metrics(bin_file_path, target, mass_start, mass_stop, save_csv=T fov_bins = io_utils.remove_file_extensions(fov_bins) metric_csvs = {} - i = 0 # retrieve the data from each bin file and store it / output to individual csv - for file in fov_bins: - i = i+1 - pulse_height_file = 'fov-{}-pulse_height.csv'.format(i) + for i, file in enumerate(fov_bins): + pulse_height_file = 'fov-{}-pulse_height.csv'.format(i+1) # get median pulse heights - median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i), + median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i+1), target, (mass_start, mass_stop)) count = bin_files.get_total_counts(bin_file_path, [file]) out_df = pd.DataFrame({ - 'fov': [i], + 'fov': [i+1], 'MPH': [median], 'total_count': [count]}) - metric_csvs['fov-{}-scan-1'.format(i)] = out_df + metric_csvs['fov-{}-scan-1'.format(i+1)] = out_df # saves individual .csv files to bin_file_path if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): @@ -74,12 +72,10 @@ def combine_mph_metrics(bin_file_path, output_dir): pulse_heights = [] fov_counts = [] - i = 0 # for each csv retrieve mph values - for file in fov_bins: - i = i+1 - temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i))) + for i, file in enumerate(fov_bins): + temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i+1))) pulse_heights.append(temp_df['MPH'].values[0]) fov_counts.append(temp_df['total_count'].values[0]) From 0d0e5a7fda78febefe31e3ba2b9bb536cd3a54a8 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 10:12:48 -0700 Subject: [PATCH 21/94] compute_mph_metrics work one fov at a time --- templates/example_MPH_plots.ipynb | 18 +++++++++----- toffy/mph_comp.py | 40 +++++++++++++++---------------- 2 files changed, 31 insertions(+), 27 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index dc151eff..45c4fce8 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -23,7 +23,8 @@ "import pandas as pd\n", "\n", "from mibi_bin_tools import bin_files\n", - "from toffy import mph_comp" + "from toffy import mph_comp\n", + "from ark.utils import io_utils" ] }, { @@ -59,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -69,9 +70,14 @@ "mass_start = -0.3 \n", "mass_stop = 0\n", "\n", + "# retrieve all the fov names from bin_file_path\n", + "fovs = io_utils.remove_file_extensions(io_utils.list_files(bin_file_path, substrs='.bin'))\n", + "\n", "# retrieve the total counts and compute pulse heights for each FOV run file\n", "# saves individual .csv files to bin_file_path\n", - "mph_comp.compute_mph_metrics(bin_file_path, target, mass_start, mass_stop)" + "for fov in fovs:\n", + " if not os.path.exists(os.path.join(bin_file_path, '%s-pulse_height.csv' % fov)):\n", + " mph_comp.compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop)" ] }, { @@ -84,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -96,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -121,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 31cc9a95..a853cefa 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -7,10 +7,11 @@ from ark.utils import io_utils -def compute_mph_metrics(bin_file_path, target, mass_start, mass_stop, save_csv=True): +def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_csv=True): """Retrieves FOV total counts and median pulse heights for all bin files in the directory Args: bin_file_path (str): path to the FOV bin and json files + fov (string): name of fov bin file without the extension target (str): channel to use save_csv (bool): whether to save to csv file or output data, defaults to True mass_start (float): beginning of mass integration range @@ -23,32 +24,29 @@ def compute_mph_metrics(bin_file_path, target, mass_start, mass_stop, save_csv=T # path validation checks io_utils.validate_paths(bin_file_path) - # list bin files in directory - fov_bins = io_utils.list_files(bin_file_path, ".bin") - fov_bins = io_utils.remove_file_extensions(fov_bins) metric_csvs = {} - # retrieve the data from each bin file and store it / output to individual csv - for i, file in enumerate(fov_bins): - pulse_height_file = 'fov-{}-pulse_height.csv'.format(i+1) + # retrieve the data from bin file and store it output to individual csv + pulse_height_file = fov +'-pulse_height.csv' - # get median pulse heights - median = bin_files.get_median_pulse_height(bin_file_path, 'fov-{}-scan-1'.format(i+1), - target, (mass_start, mass_stop)) - count = bin_files.get_total_counts(bin_file_path, [file]) + # get median pulse heights + median = bin_files.get_median_pulse_height(bin_file_path, fov, + target, (mass_start, mass_stop)) + count_dict = bin_files.get_total_counts(bin_file_path, [fov]) + count = count_dict[fov] - out_df = pd.DataFrame({ - 'fov': [i+1], - 'MPH': [median], - 'total_count': [count]}) + out_df = pd.DataFrame({ + 'fov': [fov], + 'MPH': [median], + 'total_count': [count]}) - metric_csvs['fov-{}-scan-1'.format(i+1)] = out_df + metric_csvs[fov] = out_df - # saves individual .csv files to bin_file_path - if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): - if save_csv: - out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) + # saves individual .csv files to bin_file_path + if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): + if save_csv: + out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) # return data if not save_csv: @@ -75,7 +73,7 @@ def combine_mph_metrics(bin_file_path, output_dir): # for each csv retrieve mph values for i, file in enumerate(fov_bins): - temp_df = pd.read_csv(os.path.join(bin_file_path, 'fov-{}-pulse_height.csv'.format(i+1))) + temp_df = pd.read_csv(os.path.join(bin_file_path, file + '-pulse_height.csv')) pulse_heights.append(temp_df['MPH'].values[0]) fov_counts.append(temp_df['total_count'].values[0]) From 4f1e0d093a21cfa3a251e80034452cff865c1913 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 10:19:32 -0700 Subject: [PATCH 22/94] remove return functionality --- toffy/mph_comp.py | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index a853cefa..f826848f 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -13,20 +13,15 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ bin_file_path (str): path to the FOV bin and json files fov (string): name of fov bin file without the extension target (str): channel to use - save_csv (bool): whether to save to csv file or output data, defaults to True mass_start (float): beginning of mass integration range mass_stop (float): end of mass integration range + save_csv (bool): whether to save to csv file or output data, defaults to True - Return: - None | Dict[str, pd.DataFrame]: if save_csv if False, return mph metrics """ # path validation checks io_utils.validate_paths(bin_file_path) - - metric_csvs = {} - # retrieve the data from bin file and store it output to individual csv pulse_height_file = fov +'-pulse_height.csv' @@ -41,17 +36,11 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ 'MPH': [median], 'total_count': [count]}) - metric_csvs[fov] = out_df - # saves individual .csv files to bin_file_path if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): if save_csv: out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) - # return data - if not save_csv: - return metric_csvs - def combine_mph_metrics(bin_file_path, output_dir): """Combines data from individual csvs into one From 2c8d9c073802d87d3011982ff7ab7e33b6944d19 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 13:43:39 -0700 Subject: [PATCH 23/94] typo --- toffy/mph_comp.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index f826848f..d44a9c7e 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -23,7 +23,7 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ io_utils.validate_paths(bin_file_path) # retrieve the data from bin file and store it output to individual csv - pulse_height_file = fov +'-pulse_height.csv' + pulse_height_file = fov + '-pulse_height.csv' # get median pulse heights median = bin_files.get_median_pulse_height(bin_file_path, fov, From 6b1d4501f9d6779e66b4f7a62c644ebba76e9ceb Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 13:42:01 -0700 Subject: [PATCH 24/94] fix axis merge cumulative count --- templates/example_MPH_plots.ipynb | 22 +++++++++++----------- toffy/mph_comp.py | 12 ++++++------ 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 45c4fce8..a7388bf6 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,15 +102,15 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -127,15 +127,15 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 5d71322d..7ccda83d 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -49,14 +49,12 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ # saves individual .csv files to bin_file_path total_counts = bin_files.get_total_counts(bin_file_path) fov_times = get_estimated_time(bin_file_path) - fov_keys = list(fov_times.keys()) - metric_csvs = {} # path validation checks io_utils.validate_paths(bin_file_path) # retrieve the data from bin file and store it output to individual csv - pulse_height_file = fov +'-pulse_height.csv' + pulse_height_file = fov + '-pulse_height.csv' # get median pulse heights median = bin_files.get_median_pulse_height(bin_file_path, fov, @@ -68,7 +66,7 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ 'fov': [fov], 'MPH': [median], 'total_count': [count], - 'time': [fov_times[fov_keys[i - 1]]]}) + 'time': [fov_times[fov]]}) # saves individual .csv files to bin_file_path if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): @@ -105,10 +103,12 @@ def combine_mph_metrics(bin_file_path, output_dir): # calculate cumulative sums of total counts fov_counts_cum = [fov_counts[j]+fov_counts[j-1] if j > 0 else fov_counts[j] for j in range(len(fov_counts))] + estimated_time_cum = [estimated_time[j] + estimated_time[j - 1] if j > 0 + else estimated_time[j] for j in range(len(estimated_time))] # save csv to output_dir - combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts_cum - 'cum_total_time': estimated_time}) + combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts_cum, + 'cum_total_time': estimated_time_cum}) combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) From 6cc4fe198263e34d67b81d21c4c1c94ed8a4d9c2 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 13:53:39 -0700 Subject: [PATCH 25/94] save figure change --- toffy/mph_comp.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index d44a9c7e..823ac69c 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -96,17 +96,13 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): plt.gcf().set_size_inches(18.5, 10.5) plt.xlim(0, max(mph_df['cum_total_count']) + 10000) - # save figure without regression line - if not regression and save_dir is not None: - plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) - return - # plot regression line if regression: x = np.array(mph_df['cum_total_count']) y = np.array(mph_df['pulse_heights']) m, b = np.polyfit(x, y, 1) plt.plot(x, m * x + b) - # save figure - if save_dir is not None: - plt.savefig(os.path.join(save_dir, 'fov_vs_mph_regression.jpg')) + + # save figure + if save_dir is not None: + plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) From e55d3200d527dc78c1d31196bba95baba0e29107 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 13:54:50 -0700 Subject: [PATCH 26/94] save figure change --- toffy/mph_comp.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 7ccda83d..b11a93da 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -143,11 +143,6 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): plt.gcf().set_size_inches(18.5, 10.5) plt.xlim(0, max(mph_df['cum_total_count']) + 10000) - # save figure without regression line - if not regression and save_dir is not None: - plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) - return - # plot regression line if regression: # plot with regression line @@ -155,6 +150,8 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): y2 = np.array(mph_df['pulse_heights']) m, b = np.polyfit(x2, y2, 1) plt.plot(x2, m * x2 + b) - if save_dir is not None: - plt.savefig(os.path.join(save_dir, 'fov_vs_mph_regression.jpg')) + + # save figure + if save_dir is not None: + plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) plt.show() From 885ac1f9e5a49549edab737d00ba03a5d9baf30f Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 20:17:28 -0700 Subject: [PATCH 27/94] fix time axis to have standard ticks --- templates/example_MPH_plots.ipynb | 18 +++++++++--------- toffy/mph_comp.py | 9 +++------ 2 files changed, 12 insertions(+), 15 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index a7388bf6..cec701ed 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,13 +102,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -127,13 +127,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index b11a93da..3feedb01 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -132,16 +132,13 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): ax2 = ax1.twiny() x = mph_df['cum_total_count'] y = mph_df['pulse_heights'] + x_alt = mph_df['cum_total_time'] ax1.scatter(x, y) ax1.set_xlabel('FOV cumulative count') ax1.set_ylabel('median pulse height') ax2.set_xlabel('estimated time (ms)') - ax1.set_xlim(0, max(x) + 10000) - ax2.set_xlim(0, max(x) + 10000) - ax2.set_xticks(x) - ax2.set_xticklabels(mph_df['cum_total_time']) + ax2.scatter(x_alt, y) plt.gcf().set_size_inches(18.5, 10.5) - plt.xlim(0, max(mph_df['cum_total_count']) + 10000) # plot regression line if regression: @@ -149,7 +146,7 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): x2 = np.array(mph_df['cum_total_count']) y2 = np.array(mph_df['pulse_heights']) m, b = np.polyfit(x2, y2, 1) - plt.plot(x2, m * x2 + b) + ax1.plot(x2, m * x2 + b) # save figure if save_dir is not None: From d5569d7c5b86ba9a709b3ce801c2ffe9c24eecdd Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 19 May 2022 20:17:28 -0700 Subject: [PATCH 28/94] fix time axis to have standard ticks --- templates/example_MPH_plots.ipynb | 18 +++++++++--------- toffy/mph_comp.py | 9 +++------ 2 files changed, 12 insertions(+), 15 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index a7388bf6..324a703b 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,13 +102,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABEgAAAKFCAYAAADf3dyGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3X+Q1/V9J/DnLssCgmwwqJhddDXBynkRARfITxO0lHhnIdVmSNLAJQ5OGVKV3vRKtJ04czd3ps2Ng730MkeNaGtiaYVAKgj4g5o0WUBcBAqrkEjCBvHHRMmuUWDZz/1Bsw1B3DXw3VU/j8fMc+L3/f1+Pt/X12RmM8/5fN6fqiRFAAAAAEqsur8HAAAAAOhvChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEADgpc+bMyTnnnNP9evHixRk7duxJn/e8887Lpz/96Td93F133ZVrrrnmuPVKzfnrBg8enPXr16e6+uT+b9Z//I//MXfdddcpmgoA6ImCBAA4Kf/lv/yXvOc97+l+PXfu3OzcufOkz9vY2JjPfOYzJ32eX6rUnL/uC1/4QpYtW5aurq6TOs/27dvT0NCQ0aNHn6LJAIA3oiABAI7z2c9+Nhs2bEhLS0u+/vWvp7q6OtXV1bnrrruybdu2bN26NTfddFOuueaaXHbZZbn33nvT0tKSwYMH59FHH83EiROTJO3t7bntttvy+OOPZ926dWlqasqjjz6aH/7wh7n66quTHL1S5LHHHsvmzZuzefPmfOADH0iS3HbbbfnIRz6SlpaW3HTTTamurs5f/MVfZOPGjXnyySdz/fXXd8/7V3/1V/nXf/3X/NM//VPOOuus437PqZjzjb7/1//drVixIkly+eWXZ/369fn7v//7PPXUU/lf/+t/5TOf+Uw2bNiQrVu35oILLkiSXHvttdm2bVu2bNmSf/7nf+4+13e+853MmjXrpP67BAB6rxARERH5ZS666KJi5cqVRU1NTZGk+NrXvlZ87nOfKyZMmFCsXbu2+3N1dXVFkuLRRx8tJk6c2L3+q6+LoiimT59eJCmWLVtWrFmzpqipqSkuueSSoqWlpUhSDBkypBg0aFCRpHjf+95XbNq0qUhSXH755cV3vvOd7vPOnTu3uOWWW4okRW1tbbFp06aisbGx+OQnP1msXbu2qK6uLs4555zipZdeKq655prjftfJznmi7//V7xg4cGDx7LPPdr++/PLLi5deeqkYNWpUUVtbW7S1tRW33nprkaS44YYbittvv71IUmzdurV4z3vec8y/1yTFBz/4wWLlypX9/r8JERGRMqQmAAC/4oorrsjEiROzadOmJMmQIUPy/PPP5zvf+U4uuOCC3HHHHXnggQeydu3aHs918ODBPPjgg0mSbdu25eDBg+ns7My2bdvS2NiYJBk4cGD+z//5P7n00ktz5MiRXHjhha97rmnTpuWSSy7JtddemySpq6vLmDFj8tGPfjTf+ta30tXVlWeffTaPPPLIm/7NvZnzRN+/Z8+e7vOMHDkyL7/88jHn3rRpU/bv358k+eEPf9j9723btm35+Mc/niT5l3/5lyxZsiRLly7NsmXLuo99/vnnj7ktCACoHAUJAHCMqqqq3H333bn55puPe2/cuHH5nd/5ncyfPz+f+tSnct11173huQ4fPtz9z11dXTl48GCSpCiK1NQc/b8hCxYsyHPPPZdx48aluro6r7322gnn+qM/+qPjipmrrroqRVG8qd/4m8x5ou//Va+++moGDx58zNovz/Xr5+7q6uo+97x58zJp0qT8p//0n7Jly5Zceuml+dnPfpbBgwfn1VdfPanfBgD0jj1IAIBjPPzww7n22mtz5plnJklGjBiRc889N+9+97tTXV2dZcuW5c///M8zYcKEJEf37zj99NN/4++rq6vLs88+m6Io8rnPfa67NPj1865Zsybz5s3rfn/MmDE57bTT8thjj2XWrFmprq7OqFGjuq/K+HUnO+eJvv9XvfzyyxkwYEAGDRr0ps59wQUXZOPGjfnyl7+cF198sXtj1gsvvDDbt2//jWcGAHrPFSQAwDF27tyZP/uzP8vatWtTXV2dw4cPZ/78+Xn11Vdz1113dT++9ktf+lKSZMmSJfn617+eV199tXuD1Tfjr//6r3P//ffn93//9/Poo4+mo6MjSbJ169Z0dnZmy5YtWbJkSRYtWpTGxsY88cQTqaqqygsvvJCZM2dm+fLlmTp1arZt25ann376mE1Of9XJzvk3f/M3r/v9v27t2rX58Ic/nIcffrjX5/7Lv/zLjBkzJlVVVXn44Yfz5JNPJkk+/vGP54EHHnjTswIAb15Vjm5GAgDAKXDppZfmj//4jzN79uyTOk9tbW3++Z//OR/+8Idz5MiRUzQdAHAiA5Lc2t9DAAC8U+zfvz/vete7snXr1pPaG+X888/Pxo0b88wzz5zC6QCAE3EFCQAAAFB6NmkFAI7zzDPPZOvWrWlpael+3O+1116b7du358iRI5k4cWL3Z6+88so8/vjj2bp1ax5//PETbpIKAJy8O++8M88991y2bdvWvTZixIisXbs2Tz/9dNauXZt3vetdSXr3N3rFihXHnKvMFCQAwOv6+Mc/nvHjx6epqSlJsn379vze7/1eHnvssWM+9+KLL+bqq6/OJZdckjlz5uRv//Zv+2NcACiFJUuWZPr06cesLVy4MA8//HAuvPDCPPzww1m4cGGSnv9Gf/KTn+zeHJ2jChEREZFfzTPPPFO8+93vft33Hn300WLixIknPPbFF18samtr+/03iIiIvFNz3nnnFdu2bet+3draWowaNapIUowaNapobW193eN+9W/00KFDi+9+97vF2LFjjzlXmeMKEgDgOEVRZO3atXn88cczd+7cXh93zTXXpKWlJYcOHargdADArzr77LOzf//+JEc3Cz/rrLOO+8yv/43+7//9v+d//+//nV/84hd9OutbWU1/DwAAvPV86EMfyrPPPpszzzwz69atS2tra7773e++4TH/4T/8h3zlK1/JtGnT+mhKAKA3fv1v9Lhx4/K+970vf/zHf5zzzjuvn6d763AFCQBwnGeffTZJ8sILL2T58uWZNGnSG36+vr4+y5cvz+zZs/OjH/2oL0YEAP7Nc889l1GjRiVJRo0aleeff777vdf7G/2BD3wgEydOzDPPPJPvfe97ufDCC/Poo4/2y+xvJQoSAOAYp512WoYNG9b9z9OmTcv27dtP+Pm6uro88MAD+dKXvpTvf//7fTUmAPBvVq5cmTlz5iRJ5syZkxUrViQ58d/or3/966mvr8/555+fD3/4w3n66ac9he7f9PtGKCIiIvLWyfnnn19s2bKl2LJlS7F9+/bi5ptvLpIUM2fOLPbu3Vu89tprxf79+4sHH3ywSFLccsstRUdHR9HS0tKdM888s99/h4iIyDsx3/zmN4t9+/YVhw4dKvbu3Vt84QtfKM4444zioYceKp5++unioYceKkaMGFEkvfsb/esbvpY5Vf/2DwAAAACl5RYbAAAAoPQUJAAAAEDpKUgAAACA0lOQAAAAAKWnIAEAAABKT0ECALxpc+fO7e8RAIAe+Hv95ihIAIA37frrr+/vEQCAHvh7/eYoSAAAAIDSq0pS9PcQlXDkyJG8+uqr/T0GALwj1dTUpLOzs7/HAADegL/XRw0ZMiQDBgzo8XM1fTBLv3j11VczbNiw/h4DAAAA6EcdHR29+pxbbAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUXsUKkkGDBmXDhg3ZsmVLtm/fnltvvTVJMm7cuPzgBz9IS0tLNm3alKampu5jFi5cmF27dqW1tTXTpk3rXp8wYUK2bt2aXbt2ZdGiRZUaGQAAACixolIZOnRokaSoqakpmpubi8mTJxdr1qwppk+fXiQpPvGJTxSPPvpokaQYO3ZssWXLlqK2trZobGwsdu/eXVRXVxdJig0bNhRTpkwpkhSrVq3qPv6N0tHRUbHfJSIiIiIiIvJWzfirphW3rFlWfPXJfyluWbOsGH/VtH6fqT/T236gorfYvPLKK0mSgQMHZuDAgSmKIkVRZPjw4UmSurq67Nu3L0kyY8aM3HfffTl06FD27NmT3bt3Z9KkSRk1alSGDx+e5ubmJMk999yTmTNnVnJsAAAAeFsaf9W0fOrWhTnjPeekqro6Z7znnHzq1oUZf9W0ng8uuZpKnry6ujqbN2/O+973vnzta1/Lxo0bc9NNN2XNmjX56le/murq6nzwgx9MktTX13eXIEnS1taW+vr6HD58OG1tbcetAwAAAMe66sY/TO2QIces1Q4Zkqtu/MO0rFrbT1O9PVT0CpKurq6MHz8+DQ0NmTRpUi6++OLMmzcvCxYsyLnnnpsFCxbkzjvvTJJUVVUdd3xRFCdcfz1z587Npk2bsmnTptTUVLT7AQAAgLecEaPOflPr/Ls+eYrNgQMHsn79+kyfPj1z5szJsmXLkiT/8A//kEmTJiU5emXI6NGju49paGjIvn370tbWloaGhuPWX8/ixYvT1NSUpqamdHZ2VvAXAQAAwFvPS/ufe1Pr/LuKFSQjR45MXV1dkmTw4MG58sor09ramn379uXyyy9PkkydOjW7du1KkqxcuTKzZs1KbW1tGhsbM2bMmGzcuDH79+9Pe3t7Jk+enCSZPXt2VqxYUamxAQAA4G1r1aKv59Crrx6zdujVV7Nq0df7aaK3j4rdh3LOOefk7rvvzoABA1JdXZ2lS5fmgQceyMsvv5xFixalpqYmr732Wq6//vokyY4dO7J06dLs2LEjnZ2dmT9/frq6upIk8+bNy5IlSzJkyJCsXr06q1evrtTYAAAA8Lb1y31GrrrxDzNi1Nl5af9zWbXo6/Yf6YWqHH2czTtOR0dHhg0b1t9jAAAAAP2ot/1An+xBAgAAAPBWpiABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClV7GCZNCgQdmwYUO2bNmS7du359Zbb+1+74tf/GJaW1uzffv2fOUrX+leX7hwYXbt2pXW1tZMmzate33ChAnZunVrdu3alUWLFlVqZAAAAKDEikpl6NChRZKipqamaG5uLiZPnlx87GMfK9atW1fU1tYWSYozzzyzSFKMHTu22LJlS1FbW1s0NjYWu3fvLqqrq4skxYYNG4opU6YUSYpVq1YV06dP7/G7Ozo6Kva7REREREREROTtkd72AxW9xeaVV15JkgwcODADBw5MURSZN29ebrvtthw6dChJ8sILLyRJZsyYkfvuuy+HDh3Knj17snv37kyaNCmjRo3K8OHD09zcnCS55557MnPmzEqODQAAAJRMRQuS6urqtLS05Pnnn8+6deuycePGXHjhhfnIRz6S5ubmrF+/PpdddlmSpL6+Pnv37u0+tq2tLfX19amvr09bW9tx6wAAAACnSk0lT97V1ZXx48enrq4uy5cvz8UXX5yampqMGDEiU6ZMSVNTU5YuXZoLLrggVVVVxx1fFMUJ11/P3Llzc/311ydJamoq+tMAAACAd5A+eYrNgQMHsn79+kyfPj1tbW1ZtmxZkmTTpk3p6urKyJEj09bWltGjR3cf09DQkH379qWtrS0NDQ3Hrb+exYsXp6mpKU1NTens7KzsjwIAAADeMSpWkIwcOTJ1dXVJksGDB+fKK69Ma2trvv3tb2fq1KlJkjFjxqS2tjYvvvhiVq5cmVmzZqW2tjaNjY0ZM2ZMNm7cmP3796e9vT2TJ09OksyePTsrVqyo1NgAAABACVXsPpRzzjknd999dwYMGJDq6uosXbo0DzzwQAYOHJhvfOMb2bZtWw4dOpQ5c+YkSXbs2JGlS5dmx44d6ezszPz589PV1ZUkmTdvXpYsWZIhQ4Zk9erVWb16daXGBgAAAEqoKkcfZ/OO09HRkWHDhvX3GAAAAEA/6m0/0Cd7kAAAAAC8lSlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6VWsIBk0aFA2bNiQLVu2ZPv27bn11luPef+//tf/mqIo8u53v7t7beHChdm1a1daW1szbdq07vUJEyZk69at2bVrVxYtWlSpkQEAAIASKyqVoUOHFkmKmpqaorm5uZg8eXKRpGhoaCgefPDBYs+ePcW73/3uIkkxduzYYsuWLUVtbW3R2NhY7N69u6iuri6SFBs2bCimTJlSJClWrVpVTJ8+vcfv7ujoqNjvEhEREREREZG3R3rbD1T0FptXXnklSTJw4MAMHDgwRVEkSW6//fb8t//237pfJ8mMGTNy33335dChQ9mzZ092796dSZMmZdSoURk+fHiam5uTJPfcc09mzpxZybEBAACAkqloQVJdXZ2WlpY8//zzWbduXTZu3Jirr746P/3pT7N169ZjPltfX5+9e/d2v25ra0t9fX3q6+vT1tZ23PrrmTt3bjZt2pRNmzalpqamMj8KAAAAeMepaIvQ1dWV8ePHp66uLsuXL8/73//+3HLLLcfsL/JLVVVVx60VRXHC9dezePHiLF68OEnS0dFxktMDAAAAZdEnl1kcOHAg69evz4wZM3L++efnySefTJI0NDTkiSeeyKRJk9LW1pbRo0d3H9PQ0JB9+/alra0tDQ0Nx60DAAAAnCoVu8Vm5MiRqaurS5IMHjw4V155ZVpaWnL22Wfn/PPPz/nnn5+2trZMmDAhzz33XFauXJlZs2altrY2jY2NGTNmTDZu3Jj9+/envb09kydPTpLMnj07K1asqNTYAAAAQAlV7AqSc845J3fffXcGDBiQ6urqLF26NA888MAJP79jx44sXbo0O3bsSGdnZ+bPn5+urq4kybx587JkyZIMGTIkq1evzurVqys1NgAAAFBCVTn6OJt3nI6OjgwbNqy/xwAAAAD6UW/7gYo+xQYAAADg7UBBAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClpyABAAAASk9BAgAAAJSeggQAAAAoPQUJAAAAUHoKEgAAAKD0FCQAAABA6SlIAAAAgNJTkAAAAAClV7GCZNCgQdmwYUO2bNmS7du359Zbb02S/MVf/EV27tyZJ598MsuWLUtdXV33MQsXLsyuXbvS2tqaadOmda9PmDAhW7duza5du7Jo0aJKjQwAAACUWFGpDB06tEhS1NTUFM3NzcXkyZOL3/7t3y4GDBhQJCluu+224rbbbiuSFGPHji22bNlS1NbWFo2NjcXu3buL6urqIkmxYcOGYsqUKUWSYtWqVcX06dN7/O6Ojo6K/S4REREREREReXukt/1ARW+xeeWVV5IkAwcOzMCBA1MURdatW5cjR44kSZqbm9PQ0JAkmTFjRu67774cOnQoe/bsye7duzNp0qSMGjUqw4cPT3Nzc5LknnvuycyZMys5NgAAAFAyFS1Iqqur09LSkueffz7r1q3Lxo0bj3n/C1/4QlavXp0kqa+vz969e7vfa2trS319ferr69PW1nbcOgAAAMCpUtGCpKurK+PHj09DQ0MmTZqUiy++uPu9m2++OZ2dnbn33nuTJFVVVccdXxTFCddfz9y5c7Np06Zs2rQpNTU1p+hXAAAAAO90ffIUmwMHDmT9+vWZPn16kmT27Nn5z//5P+ezn/1s92fa2toyevTo7tcNDQ3Zt29f2traum/D+dX117N48eI0NTWlqakpnZ2dFfo1AAAAwDtNxQqSkSNHdj+hZvDgwbnyyivT2tqa3/md38mf/umf5nd/93fz6quvdn9+5cqVmTVrVmpra9PY2JgxY8Zk48aN2b9/f9rb2zN58uQkR8uVFStWVGpsAAAAoIQqdh/KOeeck7vvvjsDBgxIdXV1li5dmgceeCC7du3KoEGDsm7duiRHN2qdN29eduzYkaVLl2bHjh3p7OzM/Pnz09XVlSSZN29elixZkiFDhmT16tXd+5YAAAAAnApVOfo4m3ecjo6ODBs2rL/HAAAAAPpRb/uBPtmDBAAAAOCtTEECAAAAlJ6CBAAAACg9BQkAAABQegoSAAAAoPQUJAAAAEDpKUgAAACA0uuxILn22mt7tQYAAADwdtVjQfKlL32pV2sAAAAAb1c1J3pj+vTpueqqq1JfX59FixZ1rw8fPjydnZ19MhwAAABAXzhhQbJv3748/vjj+d3f/d1s3ry5e729vT0LFizok+EAAAAA+kJVkuKNPlBTU/O2vGKko6Mjw4YN6+8xAAAAgH7U237ghFeQ/NKkSZNy66235rzzzktNTU2qqqpSFEXe+973npJBAQAAAPpbjwXJnXfemQULFmTz5s05cuRIX8wEAAAA0Kd6LEgOHDiQBx98sC9mAQAAAOgXJ9yDZPz48UmST33qUxkwYECWLVuWgwcPdr/f0tLSJwP+puxBAgAAAPS2HzhhQfLII4+c8KCiKHLFFVf8xsP1BQUJAAAAcNIFydudggQAAAA4ZU+xWbBgwXFrBw4cyObNm/Pkk0/+ZtMBAAAAvIVU9/SByy67LH/4h3+Y+vr61NfX5/rrr8/HPvaxLF68OH/yJ3/SFzMCAAAAVFSPt9g8+OCDueaaa/LKK68kSYYOHZp//Md/zCc/+cls3rw5F198cV/M+aa5xQYAAADobT/Q4xUk5557bg4dOtT9+vDhwznvvPPy2muvHfNUGwAAAIC3qx73IPnmN7+Z5ubmrFixIkly9dVX51vf+lZOO+207Nixo+IDAgAAAFRar55iM2HChHz4wx9OVVVVvve972Xz5s19MNrJcYsNAAAAcNKP+T399NPT3t6eESNGvO6BL7300kkNWGkKEgAAAOCkH/P7zW9+M1dffXU2b96coihSVVV1zH++973vPaUDAwAAAPSXXt1i83bkChIAAADglD3FJkk++9nP5s/+7M+SJKNHj05TU9PJTQcAAADwFtJjQfLXf/3X+cAHPpDPfOYzSZL29vZ87Wtfq/hgAAAAAH2lx8f8Tp48ORMnTswTTzyRJHn55ZdTW1tb8cEAAAAA+kqPV5AcPnw41dXVKYqjW5WMHDkyXV1dFR8MAAAAoK/0WJDccccdWb58ec4666z8j//xP/K9730v//N//s++mA0AAACgT/TqKTa/9Vu/lSuuuCJVVVV5+OGH09ra2gejnRxPsQEAAAB62w/0qiCprq7O2WefnZqaf9+yZO/evSc1YKUpSAAAAIDe9gM9btL6xS9+MV/+8pfz3HPP5ciRI6mqqkpRFBk3btwpGRQAAACgv/V4BcmuXbsyefLk/OxnP+ujkU4NV5AAAAAAve0Hetykde/evTlw4MApGQoAAADgreiEt9gsWLAgSfKjH/0o69evzwMPPJCDBw92v3/77bdXfjoAAACAPnDCguT0009PkvzkJz/JT37yk9TW1qa2trbPBgMAAADoK716is3bkT1IAAAAgFO2BwkAAADAO52CBAAAACg9BQkAAABQej0WJGPGjMlDDz2Ubdu2JUne//7355Zbbqn4YAAAAAB9pceCZPHixfnSl76Uw4cPJ0m2bduWWbNmVXwwAAAAgL7SY0Fy2mmnZdOmTcd9H9sIAAAgAElEQVSsdXZ2VmwgAAAAgL7WY0Hy4osv5oILLkhRHH0a8DXXXJNnn3224oMBAAAA9JWanj4wf/78/L//9/9y0UUXpa2tLc8880z+4A/+oC9mAwAAAOgTVUmK3nzwtNNOS3V1dTo6Oio80qnR0dGRYcOG9fcYAAAAQD/qbT/Q4y02N9xwQ04//fT84he/yO23357Nmzfnt3/7t0/JkAAAAABvBT0WJF/4whfS3t6eadOm5ayzzsrnP//53HbbbX0xGwAAAECf6LEgqaqqSpJcddVVueuuu7J169buNQAAAIB3gh4Lks2bN2fNmjW56qqrsmbNmgwbNixdXV19MRsAAABAn+hxk9aqqqpceuml+dGPfpQDBw7kjDPOSH19fbZt29ZHI/5mbNIKAAAA9LYfOOFjfsePH3/M6wsuuODkpwIAAAB4CzrhFSSPPPLICQ8qiiJXXHFFpWY6JVxBAgAAAPS2H+jxFpu3KwUJAAAAcNK32PzS5z73uddd/9u//ds3PG7QoEF57LHHMmjQoNTU1OQf//Efc+utt2bEiBH5+7//+zQ2NmbPnj351Kc+lZdffjlJsnDhwlx33XU5cuRIbrjhhqxduzZJMmHChCxZsiRDhgzJqlWrcuONN/b4wwAAAAB6q8crSO64447ufx48eHCuuOKKPPHEE/n93//9Hk8+dOjQvPLKK6mpqcn3vve93Hjjjfm93/u9/OxnP8tXvvKV/Omf/mlGjBiRhQsXZuzYsfnWt76VSZMm5T3veU8eeuihXHjhhenq6sqGDRty4403prm5OatWrcodd9yRBx988A2/2xUkAAAAwCm7guSGG2445vXw4cN7vHrkl1555ZUkycCBAzNw4MAURZEZM2bkYx/7WJLk7rvvzvr167Nw4cLMmDEj9913Xw4dOpQ9e/Zk9+7dmTRpUvbs2ZPhw4enubk5SXLPPfdk5syZPRYkAAAAAL1V/WYP+MUvfpExY8b07uTV1Wlpacnzzz+fdevWZePGjTn77LOzf//+JMn+/ftz1llnJUnq6+uzd+/e7mPb2tpSX1+f+vr6tLW1HbcOAAAAcKr0eAXJypUrUxRH78IZMGBAxo4dm6VLl/bq5F1dXRk/fnzq6uqyfPnyXHzxxSf8bFVV1XFrRVGccP31zJ07N9dff32SpKamx58GAAAAkKQXBclXv/rV7n/u7OzMj3/84/z0pz99U19y4MCBrF+/PtOnT89zzz2XUaNGZf/+/Rk1alSef/75JEevDBk9enT3MQ0NDdm3b1/a2trS0NBw3PrrWbx4cRYvXpzk6D1GAAAAAL3R4y02jz32WJ566qnU1dXljDPOSGdnZ69OPHLkyNTV1SU5urnrlVdemdbW1qxcuTJz5sxJksyZMycrVqxIcvRKlVmzZqW2tjaNjY0ZM2ZMNm7cmP3796e9vT2TJ09OksyePbv7GAAAAIBTpXijXHfddcWPf/zj4q677iqWLFlSPPPMM8XnP//5NzwmSfH+97+/eOKJJ4onn3yy2LZtW/Hnf/7nRZLijDPOKB566KHi6aefLh566KFixIgR3cfcfPPNxe7du4vW1tZi+vTp3esTJ04stm3bVuzevbv4q7/6qx6/O0nR0dHRq8+JiIiIiIiIyDs3ve0HenzMb2traz74wQ/mZz/7WZLkjDPOyPe///1cdNFFb3RYv/OYXwAAAKC3/UCPt9i0tbWlvb29+3V7e/sxT5sBAAAAeLvrcZPWn/70p9mwYUNWrFiRoigyY8aMbNy4MQsWLEiS3H777RUfEgAAAKCSeixIfvjDH+aHP/xh9+tfbpB6+umnV24qAAAAgD7U4x4kb1f2IAEAAABO2R4kAAAAAO90ChIAAACg9BQkAAAAQOn1uEnryJEjM3fu3DQ2Nqam5t8/ft1111V0MAAAAIC+0mNBsmLFinz3u9/NQw89lCNHjvTFTAAAAAB9qseC5LTTTsvChQv7YhYAAACAftHjHiT/9E//lE984hN9MQsAAABAv6hKUrzRB37+859n6NChOXjwYA4fPpyqqqoURZG6uro+GvE309vnHAMAAADvXL3tB3q8xWb48OGnZCAAAACAt6oeC5Ikede73pUxY8Zk8ODB3Wvf/e53KzYUAAAAQF/qsSC57rrrcuONN6ahoSFbtmzJlClT8oMf/CBXXHFFX8wHAAAAUHE9btJ64403pqmpKT/+8Y8zderUjB8/Pi+88EJfzAYAAADQJ3osSF577bUcPHgwSVJbW5unnnoqv/Vbv1XxwQAAAAD6So+32LS1taWuri7f/va3s27durz00kvZt29fX8wGAAAA0Cd6fMzvr/roRz+aurq6PPjggzl8+HAFxzp5HvMLAAAA9LYfOGFBcvrpp6e9vT0jRox43QNfeumlkxqw0hQkAAAAQG/7gRPeYvPNb34zV199dTZv3pyiKFJVVdX9XlEUee9733tqJgUAAADoZ2/qFpu3E1eQAAAAACd9Bcn48ePf8MCWlpY3PxUAAADAW9AJryB55JFHkiSDBw/OZZddlieffDJVVVW55JJLsmHDhnzkIx/pyznfNFeQAAAAAL3tB6pP9MbUqVMzderU/PjHP86ECRPS1NSUyy67LOPHj8/u3btP6bAAAAAA/emEBckvXXTRRdm+fXv363/913/NpZdeWtGhAAAAAPrSCfcg+aWdO3dm8eLF+bu/+7sURZE/+IM/yM6dO/tiNgAAAIA+0eNTbAYNGpR58+blox/9aJLksccey//9v/83Bw8e7Iv5fmP2IAEAAAB62w/06jG/gwcPzrnnnpunn376VMzWJxQkAAAAwElv0vpLV199dbZs2ZIHH3wwSTJu3LisWLHi5CcEAAAAeIvosSD58pe/nEmTJuXll19Okjz55JNpbGys9FwAAAAAfabHgqSzszM///nP+2IWAAAAgH7RY0Gyffv2fPrTn86AAQPyvve9L3fccUe+//3v98VsAAAAAH2ix4Lkj/7oj3LxxRfn4MGD+da3vpWf//znuemmm/piNgAAAIA+0aun2LwdeYoNAAAA0Nt+oKanD0ycODE333xzGhsbU1Pz7x8fN27cyU0IAAAA8BbRY0Fy77335k/+5E+ybdu2dHV19cVMAAAAAH2qx4LkhRdeyHe+852+mAUAAACgX/S4B8nUqVPz6U9/Og8//HAOHjzYvb58+fJKz3ZS7EECAAAAnLI9SD7/+c/noosuysCBA7tvsSmK4i1fkAAAAAD0Vo8Fybhx43LJJZf0xSwAAAAA/aK6pw80Nzdn7NixfTELAAAAQL/ocQ+SHTt25L3vfW+eeeaZHDx4MFVVVSmK4i3/mF97kAAAAACnbA+S6dOnn5KBAAAAAN6qeixIfvKTn/TFHAAAAAD9psc9SAAAAADe6RQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApVexgqShoSGPPPJIduzYke3bt+eGG25IkowbNy4/+MEP0tLSkk2bNqWpqan7mIULF2bXrl1pbW3NtGnTutcnTJiQrVu3ZteuXVm0aFGlRgYAAABKrKhERo0aVYwfP75IUgwbNqx46qmnirFjxxZr1qwppk+fXiQpPvGJTxSPPvpokaQYO3ZssWXLlqK2trZobGwsdu/eXVRXVxdJig0bNhRTpkwpkhSrVq3qPv6N0tHRUZHfJSIiIiIiIiJvn/S2H6jYFST79+9PS0tLkqSjoyM7d+5MfX19iqLI8OHDkyR1dXXZt29fkmTGjBm57777cujQoezZsye7d+/OpEmTMmrUqAwfPjzNzc1JknvuuSczZ86s1NgAAABACdX0xZecd955GT9+fDZs2JCbbropa9asyVe/+tVUV1fngx/8YJKkvr6+uwRJkra2ttTX1+fw4cNpa2s7bh0AAADgVKn4Jq1Dhw7N/fffn5tuuint7e2ZN29eFixYkHPPPTcLFizInXfemSSpqqo67tiiKE64/nrmzp2bTZs2ZdOmTamp6ZPuBwAAAHgHqGhBUlNTk/vvvz/33ntvli9fniSZM2dOli1bliT5h3/4h0yaNCnJ0StDRo8e3X1sQ0ND9u3bl7a2tjQ0NBy3/noWL16cpqamNDU1pbOzs1I/CwAAAHiHqWhBcuedd2bnzp25/fbbu9f27duXyy+/PEkyderU7Nq1K0mycuXKzJo1K7W1tWlsbMyYMWOycePG7N+/P+3t7Zk8eXKSZPbs2VmxYkUlxwYAAABKpmL3oXzoQx/K7Nmzs3Xr1u7NWm+++ebMnTs3ixYtSk1NTV577bVcf/31SZIdO3Zk6dKl2bFjRzo7OzN//vx0dXUlSebNm5clS5ZkyJAhWb16dVavXl2psQEAAIASqsrRx9m843R0dGTYsGH9PQYAAADQj3rbD1R8k1YAAACAtzoFCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKD0FCQAAAFB6ChIAAACg9BQkAAAAQOkpSAAAAIDSU5AAAAAApacgAQAAAEpPQQIAAACUnoIEAAAAKL2KFSQNDQ155JFHsmPHjmzfvj033HBD93tf/OIX09ramu3bt+crX/lK9/rChQuza9eutLa2Ztq0ad3rEyZMyNatW7Nr164sWrSoUiMDAAAAJVZUIqNGjSrGjx9fJCmGDRtWPPXUU8XYsWOLj33sY8W6deuK2traIklx5plnFkmKsWPHFlu2bClqa2uLxsbGYvfu3UV1dXWRpNiwYUMxZcqUIkmxatWqYvr06T1+f0dHR0V+l4iIiIiIiIi8fdLbfqBiV5Ds378/LS0tSZKOjo7s3Lkz9fX1mTdvXm677bYcOnQoSfLCCy8kSWbMmJH77rsvhw4dyp49e7J79+5MmjQpo0aNyvDhw9Pc3JwkueeeezJz5sxKjQ0AAACUUJ/sQXLeeedl/Pjx2bBhQy688MJ85CMfSXNzc9avX5/LLrssSVJfX5+9e/d2H9PW1pb6+vrU19enra3tuHUAAACAU6Wm0l8wdOjQ3H///bnpppvS3t6empqajBgxIlOmTElTU1OWLl2aCy64IFVVVccdWxTFCddfz9y5c3P99dcnSWpqKv7TAAAAgHeIil5BUlNTk/vvvz/33ntvli9fnuToFSDLli1LkmzatCldXV0ZOXJk2traMnr06O5jGxoasm/fvrS1taWhoeG49dezePHiNDU1pampKZ2dnRX8ZQAAAMA7SUULkjvvvDM7d+7M7bff3r327W9/O1OnTk2SjBkzJrW1tXnxxRezcuXKzJo1K7W1tWlsbMyYMWOycePG7N+/P+3t7Zk8eXKSZPbs2VmxYkUlxwYAAABKpmL3oXzoQx/K7Nmzs3Xr1u7NWm+++eZ84xvfyDe+8Y1s27Ythw4dypw5c5IkO3bsyNKlS7Njx450dnZm/vz56erqSpLMmzcvS5YsyZAhQ7J69eqsXr26UmMDAAAAJVSVo4+zecfp6OjIsGHD+nsMAADg/7d390FWluf9wL+8uEjA8NbKxl0DJKPpmjZxkUEs7dhYfK1RpnECGTNIzdgJpaN2nCpD2uq0/UNpp0ZNE1rGBm1R0ABVMmLVmokzNiwoCyzsLiwC0RVXY9NYaGhw8f794c8zEFBJw7LK8/nMXDN77vM8Z+9nzzXO4etz3wegHx1tPnBcvsUGAAAA4INMQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACqvzwKSxsbGPP3002lvb8/mzZtz/fXXH/L8TTfdlFJKxowZUxubN29eurq60tnZmYsuuqg2PnHixGzatCldXV256667+mrKAAAAQIWVvqj6+vrS3NxckpThw4eXrVu3lqamppKkNDY2lscff7zs2rWrjBkzpiQpTU1NZcOGDaWurq6MHz++bN++vQwcOLAkKS0tLWXKlCklSXnsscfKJZdc8r6/f+/evX1yXUoppZRSSimllPrw1NHmA312B0lPT09aW1uTJHv37k1HR0caGhqSJHfeeWduvvnmlFJqx1955ZVZunRp9u/fn127dmX79u2ZPHly6uvr89GPfjRr1qxJktx///2ZPn16X00bAAAAqKDjsgfJuHHj0tzcnJaWlnz+85/Pyy+/nE2bNh1yTENDQ1566aXa4+7u7jQ0NKShoSHd3d2HjR/Jddddl3Xr1mXdunUZPHhw31wMAAAAcMLp8xRh2LBhWb58eW688cb09vbma1/72iH7i7xjwIABh42VUt51/EgWLVqURYsWJXn7rhUAAACAo9Gnd5AMHjw4y5cvz5IlS7Jy5cp88pOfzIQJE7Jx48bs3LkzjY2NWb9+fcaOHZvu7u6cfvrptXMbGxuze/fudHd3p7Gx8bBxAAAAgGOlTwOSe++9Nx0dHbnzzjuTJJs3b87YsWMzYcKETJgwId3d3Zk4cWJeffXVPProo5k5c2bq6uoyfvz4nHHGGVm7dm16enqyZ8+enHvuuUmSWbNm5ZFHHunLaQMAAAAV02dLbKZOnZpZs2Zl06ZNtc1a58+fn9WrVx/x+Pb29jz00ENpb29Pb29v5s6dm7feeitJMmfOnCxevDhDhw7N6tWr3/U1AAAAAP4vBuTtr7M54ezduzfDhw/v72kAAAAA/eho84Hj8i02AAAAAB9kAhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gQkAAAAQOUJSAAAAIDKE5AAAAAAlScgAQAAACpPQAIAAABUnoAEAAAAqDwBCQAAAFB5AhIAAACg8gb39wQAgA+P5ssuymU3fDWj6sfmv3pezWN3LUzrY0/097QAAH5pAhIA4Kg0X3ZRvnjbvNQNHZokGX3ax/LF2+YliZAEAPjQs8QGADgql93w1Vo48o66oUNz2Q1f7acZAQAcOwISAOCojKof+wuNAwB8mAhIAICj8l89r/5C4wAAHyYCEgDgqDx218Ls37fvkLH9+/blsbsW9tOMAACOnT4LSBobG/P000+nvb09mzdvzvXXX58kWbBgQTo6OrJx48asWLEiI0aMqJ0zb968dHV1pbOzMxdddFFtfOLEidm0aVO6urpy11139dWUAYD30PrYE3nottvz492vpLz1Vn68+5U8dNvtNmgFAE4YpS+qvr6+NDc3lyRl+PDhZevWraWpqalceOGFZdCgQSVJuf3228vtt99ekpSmpqayYcOGUldXV8aPH1+2b99eBg4cWJKUlpaWMmXKlJKkPPbYY+WSSy5539+/d+/ePrkupZRSSimllFJKfXjqaPOBPruDpKenJ62trUmSvXv3pqOjIw0NDXnyySdz4MCBJMmaNWvS2NiYJLnyyiuzdOnS7N+/P7t27cr27dszefLk1NfX56Mf/WjWrFmTJLn//vszffr0vpo2AAAAUEHHZQ+ScePGpbm5OS0tLYeMX3vttVm9enWSpKGhIS+99FLtue7u7jQ0NKShoSHd3d2HjQMAAAAcK4P7+hcMGzYsy5cvz4033pg9e/bUxufPn5/e3t4sWbIkSTJgwIDDzi2lvOv4kVx33XX5wz/8wyTJ4MF9fmkAAADACaJPU4TBgwdn+fLlWbJkSVauXFkbnzVrVi6//PL87u/+bm2su7s7p59+eu1xY2Njdu/ene7u7toynIPHj2TRokVZtGhRkreX9QAAAAAcjT5dYnPvvfemo6Mjd955Z23s4osvzi233JIrrrgi+w76qsBHH300M2fOTF1dXcaPH58zzjgja9euTU9PT/bs2ZNzzz03ydvhyiOPPNKX0wYAAAAqps/uIJk6dWpmzZqVTZs21TZrnT9/fu6+++4MGTIkTz75ZJK3N2qdM2dO2tvb89BDD6W9vT29vb2ZO3du3nrrrSTJnDlzsnjx4gwdOjSrV6+u7VsCAAAAcCwMyNtfZ3PC2bt3b4YPH97f0wAAAAD60dHmA8flW2wAAAAAPsgEJAAAAEDlCUgAAACAyhOQAAAAAJUnIAEAAAAqT0ACAAAAVJ6ABAAAAKg8AQkAAABQeQISAAAAoPIEJAAAAEDlCUgAAACAyhOQAAAAAJUnIAEAAAAqT0ACAAAAVN6AJKW/J9EXDhw4kH379vX3NPgAGDx4cHp7e/t7GnxA6AcOph94h17gYPqBd+gFDqYfPryGDh2aQYMGHdWx5USsdevW9fsc1Aej9II6uPSDOrj0g3qn9II6uPSDeqf0gjq49MOJX5bYAAAAAJUnIAEAAAAqb1CS2/p7En1l/fr1/T0FPiD0AgfTDxxMP/AOvcDB9APv0AscTD+c2E7YTVoBAAAAjpYlNgAAAEDlnXABycUXX5zOzs50dXXllltu6e/pcIw0Njbm6aefTnt7ezZv3pzrr78+STJq1Kg88cQT2bZtW5544omMHDmyds68efPS1dWVzs7OXHTRRbXxiRMnZtOmTenq6spdd91VG6+rq8vSpUvT1dWVNWvWZNy4ccfvAvmFDRw4MOvXr8+qVauS6IUqGzFiRB5++OF0dHSkvb09U6ZM0Q8VduONN2bz5s1pa2vLAw88kCFDhuiHCrn33nvz6quvpq2trTZ2vN7/WbNmZdu2bdm2bVtmzZrVx1fK+zlSLyxYsCAdHR3ZuHFjVqxYkREjRtSe0wsntiP1wztuuummlFIyZsyY2ph+qLZ+/yqdY1UDBw4s27dvLxMmTCgnnXRS2bBhQ2lqaur3ealfvurr60tzc3NJUoYPH162bt1ampqayh133FFuueWWkqTccsst5fbbby9JSlNTU9mwYUOpq6sr48ePL9u3by8DBw4sSUpLS0uZMmVKSVIee+yxcskll5QkZc6cOeVb3/pWSVJmzJhRli5d2u/Xrd69/uRP/qQsWbKkrFq1qiTRCxWuxYsXl6985SslSTnppJPKiBEj9ENF67TTTis7duwoJ598cklSli1bVq655hr9UKH67d/+7dLc3Fza2tpqY8fj/R81alR54YUXyqhRo8rIkSPLCy+8UEaOHNnvf48q15F64cILLyyDBg0qScrtt9+uFypUR+qHJKWxsbE8/vjjZdeuXWXMmDH6QZV8ACZwzGrKlCnl8ccfrz2eN29emTdvXr/PSx37+td//dcybdq00tnZWerr60vydojS2dl5xPf+8ccfL1OmTCn19fWlo6OjNj5z5syycOHCQ45JUgYNGlR+9KMf9ft1qiNXQ0NDeeqpp8rnPve5WkCiF6pZp5xyStmxY8dh4/qhmnXaaaeVF198sYwaNaoMGjSorFq1qlx44YX6oWI1bty4Q/4RdDze/4OPSVIWLlxYZs6c2e9/i6rXz/fCwTV9+vTyL//yL3qhQnWkfnj44YfLZz7zmbJz585aQKIfql0n1BKbhoaGvPTSS7XH3d3daWho6McZ0RfGjRuX5ubmtLS0ZOzYsenp6UmS9PT05NRTT03y7r3Q0NCQ7u7uw8Z//pwDBw7kjTfeOORWOz44vv71r+fmm2/OW2+9VRvTC9X0iU98Ij/60Y/y7W9/O+vXr8+iRYvykY98RD9U1O7du/O3f/u3efHFF/PKK6/kjTfeyJNPPqkfKu54vP8+g374XHvttVm9enUSvVBVn//85/Pyyy9n06ZNh4zrh2o7oQKSAQMGHDZWSumHmdBXhg0bluXLl+fGG2/Mnj173vW4d+uF9+oR/fPh8Hu/93t57bXXjobF+TIAAApbSURBVPor1vTCiW3w4MGZOHFivvWtb2XixIn5n//5n8ybN+9dj9cPJ7aRI0fmyiuvzIQJE3Laaadl2LBhufrqq9/1eP1Qbcfy/dcXHy7z589Pb29vlixZkkQvVNHQoUPzta99LX/xF39x2HP6odpOqICku7s7p59+eu1xY2Njdu/e3Y8z4lgaPHhwli9fniVLlmTlypVJkldffTX19fVJkvr6+rz22mtJ3r0Xuru709jYeNj4z58zaNCgjBgxIj/+8Y+Py7Vx9KZOnZorrrgiO3fuzNKlS3PBBRfkn//5n/VCRXV3d6e7uztr165NknznO9/JxIkT9UNFTZs2LTt37szrr7+e3t7erFixIr/5m7+pHyrueLz/PoN+eMyaNSuXX375IeGpXqieT37yk5kwYUI2btyYnTt3prGxMevXr8/YsWP1A/2/zudY1aBBg8oLL7xQxo8fX9uk9ayzzur3ealjU/fdd1+58847DxlbsGDBIRuv3XHHHSVJOeussw7ZXOmFF16oba60du3acu6555bk7c2VLr300pKk/NEf/dEhmystW7as369ZvXedf/75tT1I9EJ165lnnilnnnlmSVJuvfXWsmDBAv1Q0Zo8eXLZvHlzGTp0aEne3sD3j//4j/VDxern9xk4Hu//qFGjyo4dO8rIkSPLyJEjy44dO8qoUaP6/W9R9fr5Xrj44ovLli1byq/8yq8ccpxeqEa91540B+9Boh8qX/0+gWNal156adm6dWvZvn17mT9/fr/PRx2bmjp1aimllI0bN5bW1tbS2tpaLr300jJ69Ojy1FNPlW3btpWnnnrqkP/gzJ8/v2zfvr10dnbWdphOUs4555zS1tZWtm/fXu65557a+JAhQ8pDDz1Uurq6SktLS5kwYUK/X7d67zo4INEL1a3PfvazZd26dWXjxo1l5cqVZeTIkfqhwnXbbbeVjo6O0tbWVu6///5SV1enHypUDzzwQNm9e3fZv39/eemll8q111573N7/P/iDPyhdXV2lq6urzJ49u9//FlWvI/VCV1dXefHFF2ufJd/5B61eOPHrSP1w8PMHByT6odo14P//AAAAAFBZJ9QeJAAAAAD/FwISAAAAoPIEJAAAAEDlCUgAAACAyhOQAAAAAJUnIAEA0tvbm9bW1lqNGzcuSTJ16tS0tLSko6MjHR0due6665Ik559/fv7jP/7jkNcYNGhQenp6Ul9ff9znf7Bvf/vb+cIXvvCex1xzzTX52Mc+Vnu8aNGiNDU19fXUfmlXXnnlh2KeAPBhNLi/JwAA9L99+/alubn5kLGxY8fmgQceyPTp09Pa2poxY8bk3/7t3/Lyyy9n9erVaWxszLhx4/LDH/4wSTJt2rRs3rw5PT09/XEJv5DZs2dn8+bNeeWVV5KkFvx80E2fPj3f/e5309HR0d9TAYATjjtIAIAjmjt3bhYvXpzW1tYkyX/+53/m5ptvzrx581JKycMPP5wZM2bUjp85c2YefPDBw17n1FNPzYoVK7Jhw4Zs2LAh5513XsaNG5e2trbaMTfddFNuvfXWJMn3vve9/N3f/V2+//3vp729PZMmTcry5cuzbdu2/NVf/VWSvOf5B/vzP//zrF27Nm1tbfmHf/iHJMkXvvCFTJo0KUuWLElra2tOPvnkfO9738s555yTr371q7njjjtq519zzTW5++67kyRXX311Wlpa0tramoULF2bgwMM/Rk2aNCnPPvtsNmzYkJaWlgwfPjxDhgzJP/3TP2XTpk1Zv359fud3fqf22vfcc0/t3FWrVuX8889PkuzZsyd//dd/nQ0bNuQHP/hBTj311Jx33nm54oor8jd/8zdpbW3NJz7xifd6+wCAX5CABADI0KFDa8trVqxYkST59Kc/neeff/6Q45577rl8+tOfTpI8+OCDmTlzZpKkrq4ul112WZYvX37Ya9999935/ve/n7PPPjsTJ07Mli1b3nc++/fvz/nnn5+FCxfmkUceydy5c/Prv/7rmT17dkaPHn3U1/WNb3wjkydPzm/8xm9k6NChufzyy7N8+fI899xzufrqq9Pc3Jz//d//rR3/ne98J7//+79fezxjxowsW7Ysv/Zrv5YZM2Zk6tSpaW5uzoEDB3L11Vcf8rtOOumkLFu2LDfccEPOPvvsTJs2Lfv27cvcuXOTJJ/5zGfypS99Kffdd1+GDBnynvMePnx41qxZk7PPPjvPPPNMrrvuuvzgBz/Io48+mj/90z9Nc3NzduzYcdR/BwDg/VliAwAccYnNgAEDUko57Nh3xp577rkMHz48Z555ZpqamrJmzZr85Cc/Oez4Cy64ILNmzUqSvPXWW/nv//7vjBo16j3n8+ijjyZJ2trasmXLltqynR07duT0008/4u85ks997nO5+eab85GPfCSjR4/Oli1b8t3vfvddj3/99dezY8eOnHvuuenq6sqnPvWpPPvss5k7d27OOeecrFu3LsnbgdJrr712yLmf+tSn8sorr+S5555L8vZdIEnyW7/1W7U7RbZu3Zof/vCHOfPMM99z3j/72c9q83z++edz4YUXHtX1AgD/dwISAOCItmzZkkmTJmXVqlW1sXPOOSft7e21x0uXLs3MmTPT1NR0xOU176a3t/eQJSonn3zyIc//7Gc/S/J2oPLOz+88Hjx48PuenyRDhgzJN7/5zUyaNCnd3d259dZbj3jcz1u2bFm++MUvprOzMytXrkzydlh03333Zf78+e963rsFSgMGDDji8e91DW+++Wbt5wMHDmTwYB/ZAKCvWWIDABzR3//932f27Nn57Gc/myQZPXp07rjjjixYsKB2zIMPPpgvf/nLueCCC2p3ffy8f//3f8+cOXOSJAMHDswpp5ySV199NaeeempGjx6durq6XH755b/Q3I7m/HcCh9dffz3Dhg3LVVddVXtuz549OeWUU4742itWrMj06dPzpS99KcuWLatdw1VXXZVf/dVfTZKMGjUqH//4xw85r7OzM6eddlomTZqU5O1lMoMGDcozzzxTW45zxhln5OMf/3i2bt2aXbt25eyzz86AAQPS2NiYyZMnv+91v9e8AYBfjv8dAQAcUU9PT7785S9n0aJFOeWUUzJgwIB8/etfP2SJSkdHR37605/m+eefz09/+tMjvs4NN9yQf/zHf8xXvvKVHDhwIHPmzMmaNWvyl3/5l2lpacnOnTvT2dn5C82tt7f3fc9/4403smjRorS1tWXXrl215TFJsnjx4ixcuDD79u3Leeedd8h5P/nJT9Le3p6zzjqrdk5HR0f+7M/+LE888UQGDhyYN998M3Pnzs2LL75YO+/NN9/MjBkzcs8992To0KHZt29fpk2blm9+85tZuHBhNm3alN7e3syePTv79+/Ps88+m507d6atrS2bN2/O+vXr3/e6ly5dmkWLFuX666/PVVddZR8SADiGBiQ5/F5QAAAAgAqxxAYAAACoPAEJAAAAUHkCEgAAAKDyBCQAAABA5QlIAAAAgMoTkAAAAACVJyABAAAAKk9AAgAAAFTe/wO9ifEDmW5Z+QAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -127,13 +127,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABFAAAAKFCAYAAADrpB2aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3XlclPX+///nDMMmCi64goqallqpuKap5YIglppWtGlZmEi5nD6dbDknz+d7PmXLOX2sTItyqTTF0tQExVzSSgQVBEQSTNPJfRdDEXj//uhz+GVmZDJeMDzut9vrdpP3zFzzvOx9M3s21zU2SUYAAAAAAAC4LLvVAQAAAAAAACo6ChQAAAAAAIAyUKAAAAAAAACUgQIFAAAAAACgDBQoAAAAAAAAZaBAAQAAAAAAKAMFCgAAAAAAQBkoUAAAwFUZOXKkGjZsWPpzXFycWrdufdXHbdq0qe67774rft2sWbM0bNiwS9ZdlfPXfHx8tG7dOtntV/fXrBtvvFGzZs0qp1QAAOBqUaAAAICr8vDDD6tRo0alP0dHR2vHjh1XfdyQkBDdf//9V32c/3BVzl8bNWqUFi1apJKSkqs6TlZWloKDg9W4ceNySgYAAK4GBQoAALjEAw88oE2bNiktLU0zZsyQ3W6X3W7XrFmzlJmZqYyMDE2YMEHDhg1Tp06dNHfuXKWlpcnHx0dr165Vx44dJUlnzpzRlClTtHnzZq1atUqdO3fW2rVrtWvXLt1xxx2Sfv6kyfr167VlyxZt2bJFt9xyiyRpypQp6tmzp9LS0jRhwgTZ7Xa9+uqrSklJ0bZt2zR69OjSvG+99Za2b9+uL774QvXq1bvkfMoj5++9/69/75YsWSJJ6t27t9atW6cFCxbou+++08svv6z7779fmzZtUkZGhpo3by5JGj58uDIzM5Wenq6vvvqq9FjLli1TVFTUVf2zBAAA5ccwDMMwDMP8Z2644QazdOlS43A4jCQzbdo089BDD5nQ0FCTlJRU+ryAgAAjyaxdu9Z07NixdP2XPxtjTHh4uJFkFi1aZFauXGkcDoe5+eabTVpampFkfH19jbe3t5FkrrvuOpOammokmd69e5tly5aVHjc6Oto8//zzRpLx8vIyqampJiQkxAwdOtQkJSUZu91uGjZsaE6cOGGGDRt2yXldbc7Lvf8v38PT09McOHCg9OfevXubEydOmAYNGhgvLy/jdDrN5MmTjSQzbtw488YbbxhJJiMjwzRq1Oii31dJpnv37mbp0qWW7wmGYRiGYWQcAgAA+IW+ffuqY8eOSk1NlST5+vrq8OHDWrZsmZo3b64333xTy5cvV1JSUpnHOn/+vFasWCFJyszM1Pnz51VUVKTMzEyFhIRIkjw9PfX222+rffv2Ki4uVqtWrX7zWGFhYbr55ps1fPhwSVJAQIBatmypXr166ZNPPlFJSYkOHDigNWvWXPE5/5Gcl3v/PXv2lB4nMDBQJ0+evOjYqampOnjwoCRp165dpb9vmZmZuv322yVJ33zzjWbPnq34+HgtWrSo9LWHDx++6LIjAABgHQoUAABwEZvNpjlz5ui555675LF27dppwIABio2N1T333KNHH330d4914cKF0l+XlJTo/PnzkiRjjByOn/8aMnHiRB06dEjt2rWT3W7XuXPnLpvrySefvKS4GThwoIwxV3SOfybn5d7/lwoKCuTj43PR2n+O9etjl5SUlB47JiZGXbp0UWRkpNLT09W+fXsdP35cPj4+KigouKpzAwAA5YN7oAAAgIusXr1aw4cPV926dSVJtWrVUpMmTVSnTh3Z7XYtWrRIf/vb3xQaGirp5/uH1KhR40+/X0BAgA4cOCBjjB566KHSUuHXx125cqViYmJKH2/ZsqWqVaum9evXKyoqSna7XQ0aNCj9VMevXW3Oy73/L508eVIeHh7y9va+omM3b95cKSkpevHFF3X06NHSG8e2atVKWVlZfzozAAAoP3wCBQAAXGTHjh164YUXlJSUJLvdrgsXLig2NlYFBQWaNWtW6dfzPvvss5Kk2bNna8aMGSooKCi9AeyVeOedd/TZZ5/p7rvv1tq1a5Wfny9JysjIUFFRkdLT0zV79mxNnTpVISEh2rp1q2w2m44cOaIhQ4Zo8eLF6tOnjzIzM7Vz586LbsL6S1eb8/333//N9/+1pKQk3XrrrVq9evUfPvZrr72mli1bymazafXq1dq2bZsk6fbbb9fy5cuvOCsAACh/Nv18MxQAAACUg/bt2+svf/mLRowYcVXH8fLy0ldffaVbb71VxcXF5ZQOAAD8WR6SJlsdAgAAwF0cPHhQNWvWVEZGxlXdm6VZs2ZKSUnR7t27yzEdAAD4s/gECgAAAAAAQBm4iezv2L17tzIyMpSWllb6VY61atVSUlKSdu7cqaSkJNWsWbP0+ZMmTVJubq5ycnIUFhZmVWygTAEBAVq4cKF27Nih7OxsdevWjb2NSq9Vq1ZKS0srnVOnTmn8+PHsbbiNCRMmKCsrS5mZmZo3b568vb3Z33AL48aNU2ZmprKysjR+/HhJ/J0bldMHH3ygQ4cOKTMzs3Ttz+zl0NBQZWRkKDc3V1OnTr2m54CyGea3Z/fu3aZOnToXrb3yyivmmWeeMZLMM888Y6ZMmWIkmdatW5v09HTj5eVlQkJCTF5enrHb7ZafA8P81syePds8+uijRpLx9PQ0AQEB7G3GrcZut5sDBw6YJk2asLcZt5hGjRqZ77//3vj4+BhJZsGCBWbkyJHsb6bST9u2bU1mZqbx9fU1Hh4eZtWqVea6665jbzOVcnr27Gk6dOhgMjMzS9f+zF7etGmT6datm5FkEhISTHh4uOXnxpSO5QEq7PxWgZKTk2MaNGhgJJkGDRqYnJwcI8lMmjTJTJo0qfR5K1asKN30DFORpkaNGub777+/ZJ29zbjT9O/f33z99ddGYm8z7jGNGjUye/fuNbVq1TIeHh5m2bJlpn///uxvptLP8OHDTVxcXOnPL7zwgnn66afZ20ylnaZNm15UoFzpXm7QoIHZsWNH6XpUVJSZMWOG5efF/DxcwvM7jDFKSkrS5s2bFR0dLUmqX7++Dh48KOnnm8TVq1dPkhQUFKR9+/aVvtbpdCooKOjahwbK0Lx5cx05ckSzZs3S1q1bFRcXp2rVqrG34VaioqL0ySefSOLPbbiH/fv36/XXX9fevXt14MABnTp1SqtWrWJ/o9LLyspSr169VLt2bfn6+mrgwIFq3Lgxextu40r3clBQkJxO5yXrqBgoUH5Hjx491LFjR0VERCg2NlY9e/a87HNtNtsla1dz533AVRwOh0JDQzV9+nSFhobq7NmzmjRp0mWfz95GZePp6ak777xTCxcu/N3nsbdRmdSsWVODBw9Ws2bN1KhRI/n5+emBBx647PPZ36gscnJy9Morr2jVqlVasWKFtm3bpqKioss+n70Nd3G5vcwer9goUH7HgQMHJElHjhzR4sWL1aVLFx06dEgNGjSQJDVo0ECHDx+W9HMz2Lhx49LXBgcHa//+/dc+NFAGp9Mpp9OplJQUSdKnn36q0NBQ9jbcRkREhLZu3Vq6h9nbcAf9+vXT7t27dfToURUVFWnRokXq3r07+xtuYebMmerYsaN69+6t48ePKzc3l70Nt3Gle9npdCo4OPiSdVQMFCiXUa1aNVWvXr3012FhYcrKytLSpUs1cuRISdLIkSO1ZMkSSdLSpUsVFRUlLy8vhYSEqGXLlqX/gQpUJIcOHdK+ffvUqlUrSVLfvn2VnZ3N3obbuO+++0ov35HE3oZb2Lt3r7p16yZfX19JP//ZvWPHDvY33ELdunUlSY0bN9Zdd92lTz75hL0Nt3Gle/ngwYM6c+aMunbtKkkaMWJE6WtQMVh+I5aKOM2aNTPp6ekmPT3dZGVlmeeee85IMrVr1zZffvml2blzp/nyyy9NrVq1Sl/z3HPPmby8PJOTk8OdkpkKPe3atTOpqalm27ZtZvHixaZmzZrsbcYtxtfX1xw9etT4+/uXrrG3GXeZyZMnmx07dpjMzEzz4YcfGi8vL/Y34xazfv16s337dpOenm769OljJP7sZirnzJs3z+zfv98UFhaaffv2mVGjRv2pvdyxY0eTmZlp8vLyzFtvvWX5eTH//9j+7xcAAAAAAAC4DC7hAQAAAAAAKAMFCgAAAAAAQBkoUAAAAAAAAMpAgQIAAAAAAFAGChQAAAAAAIAyUKBchejoaKsjAC7B3oa7Ym/DnbG/4a7Y23BX7O3KhwLlKowePdrqCIBLsLfhrtjbcGfsb7gr9jbcFXu78qFAAQAAAAAAKINNkrE6hCsUFxeroKDApe/hcDhUVFTk0vcArMDehrtib8Odsb/hrtjbcFfs7WvH19dXHh4eV30cRzlkqZAKCgpUvXp1q2MAAAAAAAAL5efnl8txuIQHAAAAAACgDBQoAAAAAAAAZaBAAQAAAAAAKAMFCgAAAAAAQBkoUAAAAAAAAMpAgQIAAAAAAFAGChQAAAAAAIAyUKAAAAAAAACUgQIFAAAAAACgDBQoAAAAAAAAZaBAAQAAAAAAKAMFCgAAAAAAQBkoUAAAAAAAAMpAgQIAAAAAAFAGChQAAAAAAIAyUKAAAAAAAACUgQIFAAAAAACgDBQoAAAAAAAAZaBAAQAAAAAAKAMFCgAAAAAAQBkoUAAAAAAAAMpAgQIAAAAAAFAGChQAAAAAAIAyUKAAAAAAAACUgQIFAAAAAACgDBQoAAAAAAAAZaBAAQAAAAAAKAMFCgAAAAAAQBlcVqB4e3tr06ZNSk9PV1ZWliZPnixJateunTZu3Ki0tDSlpqaqc+fOpa+ZNGmScnNzlZOTo7CwsNL10NBQZWRkKDc3V1OnTnVVZAAAAAAAgMsyrho/Pz8jyTgcDpOcnGy6du1qVq5cacLDw40kExERYdauXWskmdatW5v09HTj5eVlQkJCTF5enrHb7UaS2bRpk+nWrZuRZBISEkpf/3uTn5/vsvNiGIZhGIZhGIZhmKowQ597yryatsG8nvGteTVtgxn63FOWZ7rSKa9+wKWX8Jw9e1aS5OnpKU9PTxljZIyRv7+/JCkgIED79++XJA0ePFjz589XYWGh9uzZo7y8PHXp0kUNGjSQv7+/kpOTJUkffvihhgwZ4srYAAAAAABUeUOfe0o9oobJw+GQzWaTh8OhHlHDNPS5p6yOZgmXFih2u11paWk6fPiwVq1apZSUFE2YMEGvvfaa9u7dq9dff13PPvusJCkoKEj79u0rfa3T6VRQUJCCgoLkdDovWQcAAAAAAK5zy91DZLPZLlqz2Wy65e6q+aEGlxYoJSUl6tChg4KDg9WlSxe1bdtWMTExmjhxopo0aaKJEyfqgw8+kKRL/qFIkjHmsuu/JTo6WqmpqUpNTZXD4SjfkwEAAAAAoIq4qd9tsnt4/OZjl1t3d9fkW3hOnTqldevWKTw8XCNHjtSiRYskSQsXLlSXLl0k/fzJksaNG5e+Jjg4WPv375fT6VRwcPAl678lLi5OnTt3VufOnVVUVOTCMwIAAAAAwP206ByqcXPf18NvvHzZ55QUF1/DRBWHywqUwMBABQQESJJ8fHzUr18/5eTkaP/+/erdu7ckqU+fPsrNzZUkLV26VFFRUfLy8lJISIhatmyplJQUHTx4UGfOnFHXrl0lSSNGjNCSJUtcFRsAAAAAgCqn0fUtFT39DY2dOU3+deto/gv/T98sWHTJFSDGGG1c+LlFKa3lsutcGjZsqDlz5sjDw0N2u13x8fFavny5Tp48qalTp8rhcOjcuXMaPXq0JCk7O1vx8fHKzs5WUVGRYmNjVVJSIkmKiYnR7Nmz5evrq8TERCUmJroqNgAAAAAAVUbt4EaKeGK0QiMH6KdTp7X0tTf1zfzPVFRYqNQlCZIxuuXuIbJ7eKikuFgbF36uxS/9y+rYlrDp56/jcTv5+fmqXr261TEAAAAAAKhwqteupX6jH9Yt9wxVSVGx1n+8QGtnfaxzZ/Ktjlbuyqsf4E6rAAAAAABUEd7Vqqn3iCj1fvh+eXp7K2XxF0qa/oFOHzlqdbQKjwIFAAAAAAA35+Fw6JZ7hqjf6EdUo05tbUtao8S33tWRPXutjlZpUKAAAAAAAOCmbDab2kf0V/gT0QpsHKy8lC364ImntS8r2+polQ4FCgAAAAAAbuj67l0VOWGsglq30o85O/XemIn67ptkq2NVWhQoAAAAAAC4kcZtWyty4li17NpJx5w/au6kF5WWsOqSryTGlaFAAQAAAADADQQ2bayB48aoXVgfnTl2XItf/pc2xn+u4qIiq6O5BQoUAAAAAAAqsRqBdRQW86i63nWHigoLtfKd9/XVnE90/qefrI7mVihQAAAAAACohHyq++n2Rx5Ur4eiZHd4aGP8Yq16b5byj52wOppbokABAAAAAKAScXh5qUfUMPWNHim/mgHampCkFW+9p2POH62O5tYoUAAAAAAAqARsdrs63RGuAbHRqtWwgXK+TlbC1On6MWen1dGqBAoUAAAAAAAquDa9b9XA8WPUsGUL7c3K1vwX/qm8lC1Wx6pSKFAAAAAAAKigQtrfrEETx6pZaDsd2bNXc556XhlJa6yOVSVRoAAAAAAAUMHUb9FMA8eP0Y2399LpI0e18L9fUcriZSopKrY6WpVFgQIAAAAAQAVRs349DYiNVqc7I3T+pwIlTJ2hDXMXqLDgnNXRqjwKFAAAAAAALObr76++j43QrfcPl81m0/qPF2h13Bz9dOq01dHwfyhQAAAAAACwiKePt3o+cI/6jHpI3tX9tHlpglZOe18nDx6yOhp+hQIFAAAAAIBrzO7hoS5DBylszKMKqF9X29duUMKbM3Qw73uro+EyKFAAAAAAALiGbup3mwaOG6N6zZpqd1qGPnr6Be1Oy7A6FspAgQIAAAAAwDXQonOoIieMVdOb2+pg3vea+eTT2r7ua6tj4Q+iQAEAAAAAwIUaXd9SAyfEqPWtt+jkwUOa/7d/avPSRJmSEquj4QpQoAAAAAAA4AK1gxoq/InR6jgoXD+dOq1lr7+lr+d/pqLz562Ohj+BAgUAAAAAgHJUvXYt9Rv9sG65Z6hKioq1+v0PtWbmRzp3Jt/qaLgKFCgAAAAAAJQD72rV1HtElHo/fL88vb2VsvgLJU3/QKePHLU6GsoBBQoAAAAAAFfBw+FQt7uHqP/jj6hGndralrRGiW+9qyN79lodDeWIAgUAAAAAgD/BZrOpfXg/hT85WoGNg5WXskUzn3xaezOzrY4GF6BAAQAAAADgCl3fvasGjo9RcJvr9WPOTr03ZqK++ybZ6lhwIQoUAAAAAAD+oMZtWytywli17NZJx5z7NXfSi0pLWCVjjNXR4GIUKAAAAAAAlCGwaWNFPPm42g/oq/zjJ7T45X9r48LPVXzhgtXRcI1QoAAAAAAAcBk1AusoLOZRdb3rDhUVFipp+gdaN2eezp/9yepouMYoUAAAAAAA+BWf6n66/ZEH1fPBe+Xw9NTG+MVa9d4s5R87YXU0WIQCBQAAAACA/+Pw8lL3qLvUL/ph+dUM0NaEJK146z0dc/5odTRYjAIFAAAAAFDl2ex2dRwUrgGxj6l2o4b67ptkLZ86XT/u2Gl1NFQQFCgAAAAAgCqtda8eipwQo4YtW2hvVrbi//6ScjdttjoWKhgKFAAAAABAlRTS7iZFThyr5h3b68ievZrz1PPKSFpjdSxUUBQoAAAAAIAqpX7zEA0cP0Y39umt00eOauF/v6KUxctUUlRsdTRUYBQoAAAAAIAqoWb9ehoQG61Od0bo/E8FSpg6QxvmLlBhwTmro6ESoEABAAAAALg1X39/9X1shG69f7hsNpvWf7xAq+Pm6KdTp62OhkqEAgUAAAAA4JY8fbzV84F71GfUQ/Ku7qctyxK1ctr7OnHgoNXRUAlRoAAAAAAA3Irdw0Ndhg5S2JhHFVC/rrav+1oJb87QwdxdVkdDJUaBAgAAAABwGzf1u00Dx41RvWZNtTstQx89/YJ2p2VYHQtugAIFAAAAAFDptejUQZETY9X05rY6mPe9Zo77q7av3WB1LLgRChQAAAAAQKXVsNV1ipw4Vq1vvUUnDx7S/L/9U5uXJsqUlFgdDW6GAgUAAAAAUOnUDmqo8CdGq8PAMJ07k69lr7+lr+d/pqLz562OBjdFgQIAAAAAqDT8atVUv9EPq/u9d6mkqFhrZ36sNTM/0rkz+VZHg5ujQAEAAAAAVHhevr7qPfI+3fbw/fL09lbK518oafpMnT58xOpoqCIoUAAAAAAAFZaHw6Fudw9R/8cfUY06tZWxaq0S33pXh3f/YHU0VDEUKAAAAACACsdms6l9eD+FPzlagY2DlZe6VTOffFp7M7OtjoYqigIFAAAAAFChtLqliyInjFVwm+u1/7tcxcVMVM7XyVbHQhVHgQIAAAAAqBAat22tyAlj1bJbJx1z7tfcZycrbXmSjDFWRwMoUAAAAAAA1gpsEqyIcWPUfkBf5R8/ocUv/1sbF36u4gsXrI4GlKJAAQAAAABYokZgHYWNGaWuw+5UUWGhkqZ/oHVz5un82Z+sjgZcggIFAAAAAHBN+VT3022PPKBeD0bJ4empjQs/16p3Zyr/2AmrowGXRYECAAAAALgmHF5e6h51l/o9NlJ+tWoqLSFJiW/H6dg+p9XRgDJRoAAAAAAAXMpmt6vjoHANiH1MtRs11HffJGv51On6ccdOq6MBfxgFCgAAAADAZVr36qHICTFq2LKF9mZlK/7vLyl302arYwFXzO6qA3t7e2vTpk1KT09XVlaWJk+eXPrYE088oZycHGVlZemVV14pXZ80aZJyc3OVk5OjsLCw0vXQ0FBlZGQoNzdXU6dOdVVkAAAAAEA5CWl3k2JnT9dj016Xw8tLc556XlPve5TyBJWacdX4+fkZScbhcJjk5GTTtWtXc9ttt5lVq1YZLy8vI8nUrVvXSDKtW7c26enpxsvLy4SEhJi8vDxjt9uNJLNp0ybTrVs3I8kkJCSY8PDwMt87Pz/fZefFMAzDMAzDMAzD/PbUbx5iHpk6xfwrc6N5cc0yc8vdQ43d4WF5LqbqTnn1Ay69hOfs2bOSJE9PT3l6esoYo5iYGE2ZMkWFhYWSpCNHjkiSBg8erPnz56uwsFB79uxRXl6eunTpoj179sjf31/JycmSpA8//FBDhgzRihUrXBkdAAAAAHAFatavpwGx0ep0Z4TO/1SghDdnaMPHC1RYcM7qaEC5cNklPJJkt9uVlpamw4cPa9WqVUpJSVGrVq3Us2dPJScna926derUqZMkKSgoSPv27St9rdPpVFBQkIKCguR0Oi9Z/y3R0dFKTU1VamqqHA5u7wIAAAAArubr769Bf3lCk5bHKzQyTOs/XqCXBw7X6rg5lCdwKy5tGUpKStShQwcFBARo8eLFatu2rRwOh2rVqqVu3bqpc+fOio+PV/PmzWWz2S55vTHmsuu/JS4uTnFxcZKk/Pz88j0ZAAAAAEApTx9v9XzgHvUZ9ZC8q/tpy7JErZz2vk4cOGh1NMAlrsnHNE6dOqV169YpPDxcTqdTixYtkiSlpqaqpKREgYGBcjqdaty4celrgoODtX//fjmdTgUHB1+yDgAAAAC49uweHuo8JFIDYh5TQP262r7uayW8OUMHc3dZHQ1wKZddwhMYGKiAgABJko+Pj/r166ecnBx9/vnn6tOnjySpZcuW8vLy0tGjR7V06VJFRUXJy8tLISEhatmypVJSUnTw4EGdOXNGXbt2lSSNGDFCS5YscVVsAAAAAMBl3NS3t55ePFf3TH5WJw4c1Nsjx2jmk09TnqBKcNknUBo2bKg5c+bIw8NDdrtd8fHxWr58uTw9PTVz5kxlZmaqsLBQI0eOlCRlZ2crPj5e2dnZKioqUmxsrEpKSiRJMTExmj17tnx9fZWYmKjExERXxQYAAAAA/EqLTh0UOWGsmra7UQd37dbMcX/V9rUbrI4FXFM2/fx1PG4nPz9f1atXtzoGAAAAAFRaDVtdp8gJMWrds7tOHjykldPe1+ZliSopLrY6GvCHlVc/wFfVAAAAAAAuUjuooQbERis0coDOncnXsn+9ra8/+VRF589bHQ2wDAUKAAAAAECS5FerpvqNfljd771LprhE62Z9rDUzP1bB6TNWRwMsR4ECAAAAAFWcl6+veo+8T7eNvF9evj7atHiZkqbP1OnDR6yOBlQYFCgAAAAAUEV5OBzqNnyw+o8ZpRp1aitj1VolvvWuDu/+wepoQIVDgQIAAAAAVYzNZlO7AX0VMe5xBTYOVl7qVs0c91ftzdhudTSgwqJAAQAAAIAqpNUtnRU5IVbBba7X/u9yFRczUTlfJ1sdC6jwKFAAAAAAoAoIbnODIieOVatunXX8xwOa++xkpS1PkjHG6mhApUCBAgAAAABuLLBJsCKefFztw/sp//gJfT7lDX0bv1jFFy5YHQ2oVChQAAAAAMAN1Qiso7Axo9T1rjtVdKFQSTNmat3suTp/9ierowGVEgUKAAAAALgRn+p+uu2RB9TrwSg5PD218dPPterdmco/dsLqaEClRoECAAAAAG7Aw9NTPaKGqV/0SPnVqqm0hCQlvh2nY/ucVkcD3AIFCgAAAABUYja7XR0HhWtA7GOq3aihvvsmWcunTtePO3ZaHQ1wKxQoAAAAAFBJte7VQ5ETYtSwZQvt275D8X9/SbmbNlsdC3BLFCgAAAAAUMmEtLtJkRPHqnnH9jrywz59+F8vKCNpDV9JDLgQBQoAAAAAVBL1m4do4PgxurFPb50+ekyf/ver2rR4qUqKiq2OBrg9ChQAAAAAqOBq1q+nsLGPqfPggSosOKeEN2dow8cLVFhwzupoQJVBgQIAAAAAFZSvv7/6PvqQbn3gbtlsNm2YG6/VcXN09uQpq6MBVQ4FCgAAAABUMJ4+3rr1/rvV59GH5FO9urYsW6GV0+J04sBBq6MBVRYFCgAAAABUEHYPD3UeEqkBMY8poH5dZX/1jZZPna6DubusjgZUeRQoAAAAAFAB3NS3twaOj1G9Zk21Jz1TH/31b9q9dZvVsQD8HwoUAAAAALBQ804dNGhhK0niAAAgAElEQVTCWDVtd6MO7tqtWeOfUdaa9VbHAvArFCgAAAAAYIGGra5T5IQYte7ZXScPHdaCv7+kzUsTVFLMVxIDFREFCgAAAABcQ7UaNVD4E6MVGjlA5/Lztexfb+vrTz5V0fnzVkcD8DsoUAAAAADgGvCrVVP9oh9W93uHypQYrZv1sdbM/FgFp89YHQ3AH0CBAgAAAAAu5OXrq14jonT7ww/Iy9dHKYu/UNKMD3Tq0BGrowG4AhQoAAAAAOACHg6Hug0frH6PPyL/wDrK+HKdEt+cocO7f7A6GoA/gQIFAAAAAMqRzWZTuwF9FfHk4wpsEqxdm9M0a/wz2pux3epoAK4CBQoAAAAAlJNWt3TWwAlj1bjNDdq/M09xY/+inA0brY4FoBxQoAAAAADAVQpuc4MiJ45Vq26ddfzHA5r37D+0NSFJpqTE6mgAygkFCgAAAAD8SYFNghXx5ONqH95P+cdP6PMpb+jb+MUqvnDB6mgAyhkFCgAAAABcoRp1aqv/mFHqNmywii4UKmnGTK2bPVfnz/5kdTQALkKBAgAAAAB/kE91P932yAPq9WCUHJ6e2vjp51r17kzlHzthdTQALkaBAgAAAABl8PD0VI+oYeoXPVJ+tWoqLSFJiW/H6dg+p9XRAFwjFCgAAAAAcBk2u12hkQMU/kS0ajdqqO++3aSEqdPlzP7O6mgArjEKFAAAAAD4Da17dlfkxLFq2LKF9m3fofgXX1ZucqrVsQBYhAIFAAAAAH6habsbFTlxrFp07KAjP+zTh//1gjKS1sgYY3U0ABaiQAEAAAAASfWaNdXA8TG6qW9vnT56TJ/+v1e1adFSlRQVWx0NQAVAgQIAAACgSguoX1cDYh5T5yGRKiw4p8S33tX6jxaosKDA6mgAKhAKFAAAAABVkq+/v/o++pBuvf9u2ew2bZi3UKvfm62zJ09ZHQ1ABUSBAgAAAKBKcXh7q+cDd6vPow/Jp3p1bVm2QivfidOJ/QetjgagAqNAAQAAAFAl2D081HnwQIWNfUw169dT9lffKOHN6Tqwc5fV0QBUAhQoAAAAANzejX16a+D4MarfPER7tmVq7jMv6vst6VbHAlCJUKAAAAAAcFvNO3VQ5IQYhbS7SYe+36NZ459R1pr1VscCUAlRoAAAAABwOw1btdDA8TFq06uHTh46rAV/f0mblyaopJivJAbw51CgAAAAAHAbtRo1UHjsaIUOGqBz+fn64t9va8O8T1V0/rzV0QBUchQoAAAAACo9v1o11S/6YXW/d6hMidG62XO15oOPVHD6jNXRALgJChQAAAAAlZaXr696jYjS7Q8/IC9fH6Us/kJJMz7QqUNHrI4GwM1QoAAAAACodOwOD3UbNlj9x4ySf2AdZXy5TolvztDh3T9YHQ2Am6JAAQAAAFBp2Gw2tQvro4hxYxTYJFi7Nqdp1vhntDdju9XRALg5ChQAAAAAlULLbp0VOXGsGre5Qft35ilu7F+Us2Gj1bEAVBEUKAAAAAAqtOA21ytywli1uqWLjv94QPOe/Ye2JiTJlJRYHQ1AFUKBAgAAAKBCCmwSrIgnH1f78H46e+KkPp/yhr6NX6ziCxesjgagCqJAAQAAAFCh1KhTW/3HjFK3YYNVdOGCkmbM1LrZc3X+7E9WRwNQhVGgAAAAAKgQvP2q6fZHHlSvh6Lk8PRU8mdLtGrGTJ05dtzqaAAgu6sO7O3trU2bNik9PV1ZWVmaPHnyRY8/9dRTMsaoTp06pWuTJk1Sbm6ucnJyFBYWVroeGhqqjIwM5ebmaurUqa6KDAAAAMACHp6e6vngvXo+8TP1f/wRZX/1tV4ZfJ8W/c/rlCcAKhTjqvHz8zOSjMPhMMnJyaZr165GkgkODjYrVqwwe/bsMXXq1DGSTOvWrU16errx8vIyISEhJi8vz9jtdiPJbNq0yXTr1s1IMgkJCSY8PLzM987Pz3fZeTEMwzAMwzAMc/Vjs9tNxzsizPMrFpl/ZW40j7831QS3ud7yXAzDuNeUVz/gsk+gSNLZs2clSZ6envL09JQxRpL0xhtv6K9//Wvpz5I0ePBgzZ8/X4WFhdqzZ4/y8vLUpUsXNWjQQP7+/kpOTpYkffjhhxoyZIgrYwMAAABwsdY9u+svC+fo/pf+rrMnT2pG9Di9O3q8nNnfWR0NAH6TS++BYrfbtWXLFl133XWaNm2aUlJSdMcdd+jHH39URkbGRc8NCgoqLUkkyel0KigoSBcuXJDT6bxkHQAAAEDl0+Tmtho0MVYtOnXQ0b1OffRfL2hb0pqL/ucqAFRELi1QSkpK1KFDBwUEBGjx4sW66aab9Pzzz190f5P/sNlsl6wZYy67/luio6M1evRoSZLDwf1xAQAAgIqiXrOmGjg+Rjf17a3TR4/ps3++puTPlqikqNjqaADwh1yTluHUqVNat26dBg8erGbNmmnbtm2SpODgYG3dulVdunSR0+lU48aNS18THBys/fv3y+l0Kjg4+JL13xIXF6e4uDhJUn5+vgvPCAAAAMAfEVC/rgbEPKbOQyJVWHBOiW+9q/UfLVBhQYHV0QDgirnkJi2BgYEmICDASDI+Pj5m/fr1JjIy8qLn7N69u/Qmsm3atLnoJrK7du0qvYlsSkpK6Q1oExISTERExDW7SQzDMAzDMAzDMFc+vv41TOTEsWZK6jrzypavzJ1/HW/8atW0PBfDMFVvyqsfcNknUBo2bKg5c+bIw8NDdrtd8fHxWr58+WWfn52drfj4eGVnZ6uoqEixsbEqKSmRJMXExGj27Nny9fVVYmKiEhMTXRUbAAAAwFVweHur5/3D1eexEfKpXl1bv1ipFdPe04n9B62OBgBXxaafmxS3k5+fr+rVq1sdAwAAAKgS7B4e6jx4oMLGPqaa9espe/03Spg6XQd27rI6GoAqrrz6Ae60CgAAAOCq3NintwaOH6P6zUO0Z1um5j7zor7fkm51LAAoVxQoAAAAAP6U5h3bK3LiWIW0u0mHvt+jWeMnKWvNV1bHAgCXoEABAAAAcEUatmqhgeNj1KZXD508dFjxL76k1CUJKinmK4kBuC8KFAAAAAB/SK1GDRQeO1qhgwboXH6+vvj329ow71MVnT9vdTQAcDkKFAAAAAC/y69mgPqOflg97r1LpsRo3ey5WvPBRyo4fcbqaABwzVCgAAAAAPhNXr4+6vVQlG5/5EF5+fooZfEXSprxgU4dOmJ1NAC45ihQAAAAAFzE7vBQt2GD1X/MKPkH1lHGl+uU+OYMHd79g9XRAMAyFCgAAAAAJEk2m03twvooYtwYBTYJ1q7NaZo9YZJ+2JZldTQAsBwFCgAAAAC17NZZkRPHqnGbG7R/Z57ixv5FORs2Wh0LACoMChQAAACgCgtuc70iJ4xVq1u66PiPBzTv2X9oa0KSTEmJ1dEAoEKhQAEAAACqoDqNgxXx5Gh1iOivsydO6vNX/lffLlik4gsXrI4GABUSBQoAAABQhdSoU1v9x4xSt2GDVXThgla9O0vrZs/VufyzVkcDgAqNAgUAAACoArz9qun2Rx5Ur4ei5PD0VPJnS7RqxkydOXbc6mgAUClQoAAAAABuzMPTU93vvUv9okeqeu1aSktcpcS33tOxfU6rowFApUKBAgAAALghm92u0IFhCn9itGoHNdTOjSla/r/vyJn9ndXRAKBSokABAAAA3MwNPW9R5ISxatTqOu3LztHCf7ysnRtTrY4FAJUaBQoAAADgJprc3FaDJsaqRacOOrrXqY/+6wVtS1ojY4zV0QCg0qNAAQAAACq5es2aKmLcGN3c7zadPnpMn/3zNW36bKmKi4qsjgYAboMCBQAAAKik/OvV1YCYR9Vl6CAVFpxT4tvvaf2H81VYUGB1NABwOxQoAAAAQCXj619DfR59SD3vv0c2D7u+nvepvoybrbMnTlodDQDcFgUKAAAAUEk4vL3V8/7h6vPYCPlUr66tX6zUimnv6cT+g1ZHAwC3R4ECAAAAVHB2Dw91unOgBsQ+ppr16yl7/TdKmDpdB3busjoaAFQZFCgAAABABXZjn16KGDdGDVo00w/bsjR30mR9vznN6lgAUOVQoAAAAAAVUPOO7RU5YaxC2t+kQ9/v0azxk5S15iurYwFAlUWBAgAAAFQgDVq2UOT4GLXp3UMnDx1W/IsvKXVJgkqKi62OBgBVGgUKAAAAUAHUathAA2Kj1fGOcJ3Lz9cX/35bG+Z9qqLz562OBgAQBQoAAABgKb+aAeo7+mH1uPcumRKjdbPnas0HH6ng9BmrowEAfoECBQAAALCAl6+Pej0UpdsfeVBevj5K/Xy5Vk5/X6cOHbE6GgDgN1CgAAAAANeQ3eGhrnfdqbCYR+UfWEeZq79SwtTpOrz7B6ujAQB+BwUKAAAAcA3YbDa1C+uj8CcfV92mjbVrS5pmT5ikH7ZlWR0NAPAHUKAAAAAALtayW2dFTohR47attX9nnt4f+5R2bPjW6lgAgCtAgQIAAAC4SFDrVoqcMFbXd++q4/sPaN5z/62ty1fKlJRYHQ0AcIUoUAAAAIByVqdxsCKeHK0OEf119sRJLXl1qr5dsEhFhYVWRwMA/EkUKAAAAEA5qVGntvqPGaVuwwar6MIFrXp3ltbNnqtz+WetjgYAuEoUKAAAAMBV8varptsefkC9R0TJ4eml5M+WaNW7s3Tm6DGrowEAygkFCgAAAPAneXh6qvs9Q9Vv9MOqXruW0ld8qcS33tXRvU6rowEAyhkFCgAAAHCFbHa7QgeGaUBstOoEN9LO5FQtf+MdObNzrI4GAHARChQAAADgCtzQ8xZFjo9Ro+tbal92jj4dPUU7N6ZaHQsA4GIUKAAAAMAf0OTmtoqcMFbXdQ7V0b1OffT037Rt5WoZY6yOBgC4BihQAAAAgN9Rr1lTRYwbo5v73aYzx45r0f+8ruRPl6i4qMjqaACAa4gCBQAAAPgN/vXqakDMo+oydJAKz51T4tvvaf2H81VYUGB1NACABShQAAAAgF/w9a+hPqMeVM8H7pXNw66v532qL+Nm6+yJk1ZHAwBYiAIFAAAAkOTw9tat9w1X38dGyKdGdW1dvlIrp8Xp+I8HrI4GAKgAKFAAAABQpdk9PNTpjggNiH1MNRvU144N32r5/07XgZ15VkcDAFQgFCgAAACosm7s00sR48aoQYtm+mFbluY++w99vznN6lgAgAqIAgUAAABVTvOO7RU5YaxC2t+kw7t/0Kzxk5S15iurYwEAKjAKFAAAAFQZDVq2UOT4GLXp3UOnDh1R/IsvKXVJgkqKi62OBgCo4ChQAAAA4PZqNWygAbHR6nhHuM7l5+uLN6bp63kLdeHceaujAQAqCQoUAAAAuC2/mgHqGz1SPaKGyRijr2bP0+oPPlLB6dNWRwMAVDIUKAAAAHA7Xr4+6vVQlG57+AF5V/NV6pIEJb3zvk4eOmx1NABAJUWBAgAAALdhd3io6113KmzMKPnXDVTm6q+U+OYMHfp+j9XRAACVHAUKAAAAKj2bzaabw/oo4snHVbdpY+3akqY5E5/Tnm2ZVkcDALgJChQAAABUai27dlLkxLFq3La1DuTu0vtjn9KODd9aHQsA4GYoUAAAAFApBbVupcgJY3V99646vv+A5j3339q6fKVMSYnV0QAAbogCBQAAAJVKneAgRTw5Wh0GhunsiZNa8upUfbtgkYoKC62OBgBwY3ZXHdjb21ubNm1Senq6srKyNHnyZEnSq6++qh07dmjbtm1atGiRAgICSl8zadIk5ebmKicnR2FhYaXroaGhysjIUG5urqZOneqqyAAAAKjAqteppaHPPaVnls5Xm9t6atV7s/TSwOFa/9F8yhMAwDVhXDV+fn5GknE4HCY5Odl07drV9O/f33h4eBhJZsqUKWbKlClGkmndurVJT083Xl5eJiQkxOTl5Rm73W4kmU2bNplu3boZSSYhIcGEh4eX+d75+fkuOy+GYRiGYRjm2o23XzUzIDbavLRptXk1bYMZ9sLTpkZgHctzMQzDMJVjyqsfcOklPGfPnpUkeXp6ytPTU8YYrVq1qvTx5ORkDR8+XJI0ePBgzZ8/X4WFhdqzZ4/y8vLUpUsX7dmzR/7+/kpOTpYkffjhhxoyZIhWrFjhyugAAACwmIenp7rfM1T9Rj+s6rVrKX3Fl0p8610d3eu0OhoAoApyaYFit9u1ZcsWXXfddZo2bZpSUlIuenzUqFFasGCBJCkoKKi0JJEkp9OpoKAgXbhwQU6n85J1AAAAuCebzaYOkWEKjx2tOsGNlJu8WV+8MU3O7ByrowEAqjCXFiglJSXq0KGDAgICtHjxYrVt21bbt2+XJD333HMqKirS3LlzJf38L8pfM8Zcdv23REdHa/To0ZIkh4P74wIAAFQ2N9zaTZETxqrR9S3lzP5O744er50bU8p+IQAALnZNWoZTp05p3bp1Cg8P1/bt2zVixAgNGjRIffv2LX2O0+lU48aNS38ODg7W/v375XQ6FRwcfMn6b4mLi1NcXJwkKT8/30VnAwAAgPLW5KY2ipwYq+s6h+roPqc+evpv2rZy9WX/xxkAAFZwyU1aAgMDTUBAgJFkfHx8zPr1601kZKQZMGCA2b59uwkMDLzo+W3atLnoJrK7du0qvYlsSkqK6dq1q5F+volsRETENbtJDMMwDMMwDOO6qdesqRn575fMvzI3msnrlpseUcOMh8NheS6GYRjGfabC30S2YcOGmjNnjjw8PGS32xUfH6/ly5crNzdX3t7epTeTTU5OVkxMjLKzsxUfH6/s7GwVFRUpNjZWJSUlkqSYmBjNnj1bvr6+SkxMVGJioqtiAwAA4Brwr1dXYTGj1GXIIF04f14rpsXpqzmfqLCgwOpoAAD8Jpt+blLcTn5+vqpXr251DAAAAPyCr38N9Rn1oHo+cK9sHnZ9O3+RvoybrbMnTlodDQDgpsqrH+BOqwAAAHA5h7e3br1vuPo+NkI+Napr6/KVWjktTsd/PGB1NAAA/hAKFAAAALiM3cNDne6I0IDYx1SzQX3t2PCtlv/vdB3YmWd1NAAArggFCgAAAFzixj69FDFujBq0aKYfMrZr3rP/0K7NaVbHAgDgT6FAAQAAQLlqFtpOgybGKqT9TTq8+wfNnjBJmau/sjoWAABXhQIFAAAA5aJByxaKHB+jNr176NShI4qf/LJSP1+ukuJiq6MBAHDV7GU9Yfjw4X9oDQAAAFVTrYYNFPXPv+mpTz9Usw4364s3punlQXdr02dLKU8AAG6jzK8x3rJlizp27FjmWkXD1xgDAAC4ll/NAPWNHqkeUcNkjNHXcxdq9QcfqeD0aaujAQBQyuVfYxweHq6BAwcqKChIU6dOLV339/dXUVHRVb8xAAAAKicvXx/1fPBe3f7Ig/Ku5qvUJQlKeud9nTx02OpoAAC4zGULlP3792vz5s268847tWXLltL1M2fOaOLEidckHAAAACoOu8NDXYfeqbCYUfKvG6isNV8pYeoMHfp+j9XRAABwuTIv4XE4HJXyEydcwgMAAFB+2g3oq4gnRqtuSBN9vyVdy994R3u2ZVodCwCAMrn8Ep7/6NKliyZPnqymTZvK4XDIZrPJGKMWLVpc9ZsDAACgYmvZtZMGTohRkxvb6EDuLr0f+1/asf4bq2MBAHDNlfkJlB07dmjixInasmWLin9xF/Xjx4+7OttV4RMoAAAAf17QDa0UOSFG1/fopuP7D2jltPe15YsVMiUlVkcDAOCKXLNPoJw6dUorVqy46jcCAABAxVcnOEgRT45Wh4FhOnvylJa8NlXfzl+kosJCq6MBAGCpy34CpUOHDpKke+65Rx4eHlq0aJHOnz9f+nhaWto1Cfhn8QkUAACAP656nVrq//go3TJ8iIqLivTVR59o3ay5Opd/1upoAABclfLqBy5boKxZs+ayLzLGqG/fvlf95q5EgQIAAFA2b79qum3k/eo98j45vLy06bOlSpoxU2eOHrM6GgAA5cLlBUplR4ECAABweR6enrrl7iHq//gjql67ltJXrlbiW+/q6A/7rI4GAEC5umb3QJk4ceIla6dOndKWLVu0bdu2qw4AAACAa8dms6lDZJjCY0erTnAj5SZv1vL/fUf7tu+wOhoAABVamQVKp06d1KlTJy1btkySFBkZqdTUVI0ZM0YLFy7Ua6+95vKQAAAAuHo33NpNA8fHKOiGVnJmf6d3R4/Xzo0pVscCAKBSKPMSnhUrVmjYsGE6e/bnG4j5+fnp008/1dChQ7Vlyxa1bdv2WuS8YlzCAwAA8LMmN7VR5ISxuq5LRx3d51Tim+9q28rVMsYtr+QGAOAi1+wSniZNmqjwF19bd+HCBTVt2lTnzp276Ft5AAAAULHUDWmigePG6Ob+t+vMseNa9D+vK/nTJSouKrI6GgAAlU6ZBcq8efOUnJysJUuWSJLuuOMOffLJJ6pWrZqys7NdHhAAAABXxr9eXYXFjFKXIYN04fx5rZgWp6/mfKLCggKrowEAUGn9oW/hCQ0N1a233iqbzaavv/5aW7ZsuQbRrg6X8AAAgKrG17+G+ox6UD0fuFf/H3v3HZblfbd//LzZCKI4UVBRg4rGgTtuUZGh0WyNxg0RiIC/NqlJk6Zp0zZt08dohgN3olET4wZ3jBoFt2hwgBEVFfcAB/P6/ZHWPnmiwcHNxXi/juNzRC7ui+vkL3Ocfq/v12Jro+2LvtHG2LnKunLV7GgAAJjG6scYV6xYUZmZmXJ3d7/njVevluy/iClQAABAeWHn6Kgug59XrzHD5FTRVXtXr9XaT2N15cw5s6MBAGA6q++BsmDBAvXv31979uyRYRiyWCw/+2/Dhg0f++EAAAB4dDa2tmrbP0h9I8eoskdNHd66Xas/mqJzx1LNjgYAQJnzQK/wlEasQAEAAGVZs55dFRwdLo+G9XUy6Qetnvipju/eZ3YsAABKnGI7hUeShgwZovr16+v9999XnTp15OHhoV27dj32wwEAAPBw6rduqZCYCNX3a6ELJ05qTswEHdz4ndmxAAAo8wpdgfLZZ5+poKBA/v7+atq0qSpXrqx169apffv2xRTx0bACBQAAlCUeTzRQcHS4mvXoousXLmrtZzO0a9lqFeTnmx0NAIASrdhWoHTo0EFt2rTR3r17JUnXrl2Tg4PDYz8YAAAAhXOv5aG+kWPUpn+QsrNuavVHn2nr/MXKvZNtdjQAAMqVQguU3Nxc2djYyDB+WqhSrVo1FRQUWD0YAABAeVahkpt6hQ5Xl8HPyzAMfTf3S22cMU+3b9wwOxoAAOVSoQXK5MmTtXTpUtWoUUPvv/++nn/+eb399tvFkQ0AAKDccXB2UtehL6nnyKFyrOCs3SvitfbTWF07f8HsaAAAlGsPdApP48aN1atXL1ksFm3cuFFHjhwphmiPhz1QAABAaWJjZ6sOzzytgPBRcqteTYc2fae4ydN0/vgJs6MBAFCqFVU/8EAFio2NjWrWrCk7u/8uWDl9+vRjP9yaKFAAAEBp0SLAX8HjXlV177r6cc9+rf5oitL2J5kdCwCAMqHYNpF97bXX9O677+r8+fPKz8+XxWKRYRhq2bLlYz8cAACgPHuifRuFjI9Q3Seb6lzKcc187XUlf7fN7FgAAOAeCl2BkpKSog4dOujKlSvFFKlosAIFAACUVJ5NGikkJlyNO3fU1XMZWvNJrPasWiODjfoBAChyxbYC5fTp07p+/fpjPwgAAKC8q+rlqcBxYWodHKCb165r+T8nafvCb5SXk2N2NAAAUIj7Fijjx4+XJP3444/avHmzVq9erezs7LvfnzhxovXTAQAAlAGuVd3VJ2yknnrhGeXn5WnD9Dn6dvYXupN10+xoAADgAd23QKlYsaIk6dSpUzp16pQcHBzk4OBQbMEAAABKO8cKFdRjxMvqPnyw7BwclPjNSq2fOks3Ll4yOxoAAHhID3QKT2nEHigAAMAstvb2euqFgeodNkIVq1bR/rUbFf/xNF06WbJPMQQAoCwqtj1QAAAA8GAsFov8gvso8LUwVfXyVErCbs2M/K1O/3DY7GgAAOAxUaAAAAAUgcadOyokJlyeTRrpzOFjmhYWrWM7dpodCwAAFBEKFAAAgMdQt3lThcRE6In2bXTpdLq+eOMP2r9mgwyjTL4lDQBAuVVogeLj46MpU6aoZs2aat68uZo3b66nn35af/nLX4ojHwAAQIlU3buugqPGqkWfnsq8fEXf/PVfSvhqmfLz8syOBgAArKDQTWQ3b96s119/XdOmTVPr1q0lSQcPHlTz5s2LI98jYxNZAABgDW41qisgfJTaD+yn3OxsbZ6zQFvmLVT2rVtmRwMAAPdQbJvIVqhQQbt27frZtTz+ZQUAAJQzThVd5T/qFXUd8qJs7Gz1/cIl2hg7V1lXrpodDQAAFINCC5RLly6pQYMGd9/jfe6553Tu3DmrBwMAACgJ7Bwc1GXw8+oVOlxOFV21L26d1nwaqyvpZ82OBgAAilGhBUpkZKSmT5+uJk2aKD09XSdOnNDQoUOLIxsAAIBpLDY2avt0kAIjQ1XZo6YOb9uhuI+m6OzRFLOjAQAAExS6B8p/VKhQQTY2NsrKyrJypKLBHigAAOBRNevZVcFRY+XxRAOdTPpBqz/6TMd37TU7FgAAeARF1Q/YFPaBqKgoVaxYUbdu3dLEiRO1Z88e9enT57EfDAAAUNLU92uh1+ZN06jJ/5CNra3mjH9Tk4eMoTwBAACFv8IzatQoTZ48WQEBAapRo4ZGjhyp2bNna/369cWRDwAAwOo8nmig4Kixatazq65fuKiv3vtAO5euUkF+vtnRAABACVFogWKxWCRJwcHBmj17tpKSku5eAwAAKM0qe9RU4GuhatM/SNlZN7X6oynaOn+Rcu9kmx0NAACUMIUWKHv27NHatWtVv359vfnmm3J1dVVBQUFxZAMAALCKCpXc1Ct0uHF4OTkAACAASURBVDoPek6S9N3cL7Vp5jzdun7D5GQAAKCkKnQTWYvFolatWunHH3/U9evXVaVKFXl6eurgwYPFFPHRsIksAAD4vxycndR1yEvqOWqoHCs4a/eKeK39bIauZZw3OxoAALCSouoH7rsCxc/P72dfN2jQ4LEfBgAAYAYbO1u1f6a/+oaPllv1ajr07RbFTZqq88dPmB0NAACUEvddgbJp06b73mQYhnr16mWtTEWCFSgAAECSWgT4K3jcq6ruXVcn9h7QqomfKW1/ktmxAABAMSmqfqDQV3hKKwoUAADKtyfat1FITITqNm+qcynHFTdpqpK/22Z2LAAAUMys/grPf7zyyiv3vP7555//6n2Ojo7asmWLHB0dZWdnp6+//lp//OMf5e7urkWLFsnb21tpaWl68cUXde3aNUnShAkTNHr0aOXn5ysqKkrr1q2TJLVu3Vpz5syRs7Oz4uLiFB0d/bC/JwAAKCc8mzRScHS4mnTpqKvnMrTw7T9r98o1MtgEHwAAPIZCV6BMnjz57p+dnJzUq1cv7d27Vy+88EKhP9zFxUU3b96UnZ2dtm3bpujoaD377LO6cuWK/v73v+t3v/ud3N3dNWHCBPn6+urLL79U+/btVbt2bW3YsEGNGjVSQUGBEhMTFR0drYSEBMXFxWny5Mlas2bNrz6bFSgAAJQvVbxqK2jcq2odHKCb165rY+xcfb9wifJycsyOBgAATFRsK1CioqJ+9rWbm1uhq0/+4+bNm5Ike3t72dvbyzAMDRgwQD169JAkzZ07V5s3b9aECRM0YMAALVy4UDk5OUpLS1Nqaqrat2+vtLQ0ubm5KSEhQZI0b948DRw4sNACBQAAlA+uVdzV59WR6vjCQBXk5WvD9Dn6dvYXupN10+xoAACgDCm0QPm/bt26JR8fnwf6rI2Njfbs2aMnnnhCn376qXbu3KmaNWsqIyNDkpSRkaEaNWpIkjw9Pe+WJJKUnp4uT09P5ebmKj09/RfXAQBA+eZYoYK6Dx+s7sMHy97RUYnfrNT6qbN04+Ils6MBAIAyqNACZcWKFTKMn97ysbW1la+vrxYvXvxAP7ygoEB+fn6qVKmSli5dqmbNmt33sxaL5RfXDMO47/V7CQ0NVVhYmCTJzu6huyEAAFAK2Nrb66kXBqp32AhVrFpF+9duVPzH03Tp5GmzowEAgDKs0Jbhww8/vPvnvLw8nTx5UmfOnHmoh1y/fl2bN29WYGCgzp8/Lw8PD2VkZMjDw0MXLlyQ9NPKkjp16ty9x8vLS2fPnlV6erq8vLx+cf1eYmNjFRsbK+mnd5wAAEDZYbFY5BfcR4Gvhamql6dSEndrZuRvdfqHw2ZHAwAA5YBNYR/YsmWLjh49qkqVKqlKlSrKy8t7oB9crVo1VapUSdJPm8/27t1bR44c0YoVKzR8+HBJ0vDhw7V8+XJJP610GTRokBwcHOTt7S0fHx/t3LlTGRkZyszMVIcOHSRJw4YNu3sPAAAoHxp37qjxi+doyAfv6U7mTU1/NUZTx4yjPAEAAMXK+LUZPXq0cfLkSWP27NnGnDlzjBMnThgjR4781XskGc2bNzf27t1rHDhwwDh48KDxzjvvGJKMKlWqGBs2bDCOHTtmbNiwwXB3d797z1tvvWWkpqYaR44cMQIDA+9eb9OmjXHw4EEjNTXV+Pjjjwt9tiQjKyvrgT7HMAzDMEzJnTpPNjXCZ35i/OvgDuOt+K8Nv6A+hsViMT0XwzAMwzClZ4qqHyj0GOMjR46oU6dOunLliiSpSpUq2r59u5o0afJrt5mOY4wBACi9qnvXVdC4V9UywF+Zl69o/bTZSvhqmfIfcCUsAADAfxTbMcbp6enKzMy8+3VmZqZOn2aTNgAAUPTcqldTQPhotX+mn3Kzs7X201h9N2+hsm/dMjsaAAAo5wotUM6cOaPExEQtX75chmFowIAB2rlzp8aPHy9JmjhxotVDAgCAss2poqt6jhyqbkNfko2drbYv+kYbps9R1pWrZkcDAACQ9AAFyvHjx3X8+PG7X/9nA9eKFStaLxUAACgX7Bwc1GXw8+oVOlwVKrlp7+q1iv9kuq6k3/vEPQAAALMUugdKacUeKAAAlFwWGxu1fTpIfSPGyL2Whw5v26G4j6bo7NEUs6MBAIAyptj2QAEAAChKzXp0UVDUWNXyaahTB5P15e//rOO79podCwAA4FdRoAAAgGJR36+FQmIiVL91S104cVJz/99bSlr/rdmxAAAAHggFCgAAsCqPJxooOGqsmvXsqusXLuqr9z7QzmWrVJCXb3Y0AACAB1ZogVKtWjWFhobK29tbdnb//fjo0aOtGgwAAJRulT1qqm/kGLV9OljZWTe1+qMp2jp/kXLvZJsdDQAA4KEVWqAsX75cW7du1YYNG5Sfz78UAQCAX1ehkpt6jRmuzoOfkyRtmbdQG2fM1a3rN0xOBgAA8OgKLVAqVKigCRMmFEcWAABQijk4O6nrkJfUc9RQOVZw1u6V8Vr76QxdyzhvdjQAAIDHVmiBsmrVKgUFBSk+Pr448gAAgFLGxs5W7Z/pr4Cxo1SpRnUd+naL4iZN1fnjJ8yOBgAAUGQskoxf+8CNGzfk4uKi7Oxs5ebmymKxyDAMVapUqZgiPpqiOucZAADcX4s+PRU07lXVqF9PJ/Ye0OqPPtOJfUlmxwIAALirqPqBQleguLm5PfZDAABA2dKwXWv1Gx+pus2b6lzKcc0a97p+2LzN7FgAAABW80DHGFeuXFk+Pj5ycnK6e23r1q1WCwUAAEqm2o19FBIToSZdOurquQwtfPvP2r1yjYyCArOjAQAAWFWhBcro0aMVHR0tLy8v7d+/Xx07dtSOHTvUq1ev4sgHAABKgCpetRX0Wphah/TVzWvXteKfk/X9wiXKy8kxOxoAAECxKLRAiY6OVrt27ZSQkCB/f381btxY7733XnFkAwAAJnOt4q4+r45UxxcGqiAvXxumz9G3c+brTmaW2dEAAACKVaEFyp07d5SdnS1JcnBw0NGjR9W4cWOrBwMAAOZxrFBB3YcPVvfhg2Xv6KjEb1Zq/dRZunHxktnRAAAATFFogZKenq5KlSpp2bJlWr9+va5evaqzZ88WRzYAAFDMbO3s9NSLA9U7bKQqVq2iA+s2Kf7jabqYdsrsaAAAAKYq9Bjj/61bt26qVKmS1qxZo9zcXCvGenwcYwwAwIOzWCxqFdRHQePCVNXLUymJu7X6oyk6fSjZ7GgAAACPpaj6gfsWKBUrVlRmZqbc3d3veePVq1cf++HWRIECAMCDady5o0Kiw+Xp20hnjhzT6omf6ej2RLNjAQAAFImi6gfu+wrPggUL1L9/f+3Zs0eGYchisdz9nmEYatiw4WM/HAAAmKfOk00VEhMunw5tdTn9jL743bvaH79ehvHAi1MBAADKjYd6hac0YQUKAAD3Vq1eHQVHjVXLAH9lXr6iDdNna8fiZcrPyzM7GgAAQJGz+goUPz+/X71x3759j/1wAABQfNyqV1NA+Gi1f6afcrOztfazGfpu7pfKvnXL7GgAAAAl3n1XoGzatEmS5OTkpLZt2+rAgQOyWCxq0aKFEhMT1bVr1+LM+dBYgQIAwE+cKrqq58ih6jb0JdnY2WrH4qXaMH2Osq6U7P3MAAAAioLVV6D4+/tLkr788kuFhYXp0KFDkqRmzZrpt7/97WM/GAAAWJedg4M6D3pOvUKHy6VyJe1dvVbxn0zXlfSzZkcDAAAode5boPxHkyZN7pYnkvTDDz+oVatWVg0FAAAencXGRm37B6pvZKjca3noyLYExU2aojNHjpkdDQAAoNQqtEA5fPiwYmNj9cUXX8gwDA0dOlSHDx8ujmwAAOAhNevRRUFRY1XLp6FOHUzWwrffV+rOPWbHAgAAKPUKPYXH0dFR4eHh6tatmyRpy5YtmjJlirKzs4sj3yNjDxQAQHni3aqF+o2PUP3WLXXhxEnFfzxNSeu/NTsWAACA6YqqH3igY4ydnJxUt25dHTtWepb+UqAAAMqDmg3rKzh6rJ7s2U3XL1zUuqmztHPpShXk5ZsdDQAAoESw+iay/9G/f3/985//lIODgxo0aKCWLVvqT3/6kwYMGPDYDwcAAI+mskdN9Y0co7b9g5R967biJk3V1vmLlHP7jtnRAAAAyqRCC5R3331X7du31+bNmyVJBw4ckLe3t5VjAQCAe6lQyU29xgxX58HPyWKxaMvni7Rxxlzdun7D7GgAAABlWqEFSl5enm7c4H/KAAAwk72To7oOeUn+o4bK0aWCdq+M19pPZ+haxnmzowEAAJQLhRYohw4d0uDBg2Vra6snnnhCUVFR2r59e3FkAwCg3LOxtVX7Z/opIHy0KtWorkPfblHcpKk6f/yE2dEAAADKlUI3kXV2dtbvf/97BQQEyGKxaO3atfrzn//MKTwAAFhZ8949FBw1VjXq19OJvQe0+qPPdGJfktmxAAAASpViPYWnNKJAAQCUVg3btVZITITqtWimjNQfFTdpin7YvM3sWAAAAKVSsZ3C06ZNG7311lvy9vaWnd1/P96yZcvHfjgAAPiv2o19FBIToSZdOurquQwtfPvP2r1yjYyCArOjAQAAlHuFFijz58/X66+/roMHD6qA/4EDAKDIVfGqraDXwtQ6pK9uXb+hFf+crO8XLlFeTo7Z0QAAAPBvhRYoFy9e1MqVK4sjCwAA5YprFXf1Dhuhp158RgV5+doQO1ffzv5CdzKzzI4GAACA/6PQPVD8/f01ePBgbdy48Wcbxy5dutTa2R4Le6AAAEoqxwoV1H3YIHUf8bLsHR21c+kqrZsyUzcuXjI7GgAAQJlTbHugjBw5Uk2aNJG9vf3dV3gMwyjxBQoAACWNrZ2dnnpxoHqHjVTFqlV0YN0mxX88TRfTTpkdDQAAAIUotEBp2bKlWrRoURxZAAAokywWi1oF9VHga6GqVsdLqTv3aOZrr+v0oWSzowEAAOABFVqgJCQkyNfXV4cPHy6OPAAAlCmNO3VQSEyEPH0b6cyRY5o+dryOfp9gdiwAAAA8pEL3QElOTlbDhg114sQJZWdny2KxyDCMEn+MMXugAADMVKeZr0LGR8inQ1tdTj+jNZ9M17649TKMX/1rFwAAAEWs2PZACQwMfOyHAABQXlSrV0fBUWPVMsBfmZevaOnf/qUdi5cpPy/P7GgAAAB4DIUWKKdOsbEdAACFqVitqgLCR6vDs/2Vl5OjtZ/N0Hdzv1T2rVtmRwMAAEARKLRAAQAA9+fk6qKeI4eq2yuDZGNnqx2Ll2r99NnKunzV7GgAAAAoQhQoAAA8AjsHB3Ue9Jx6hQ6XS+VK2hu3Tms+nq7L6WfMjgYAAAAroEABAOAhWGxs1LZ/oPpGhsq9loeObEtQ3KQpOnPkmNnRAAAAYEUUKAAAPKCm3bsoOHqsavk01KlDyVr49vtK3bnH7FgAAAAoBhQoAAAUwrtVC/UbH6H6rVvqYtopzf3N75W0bpPZsQAAAFCMKFAAALiPmg3rKzh6rJ7s2U03Ll7SV3/6u3YuXamCvHyzowEAAKCYUaAAAPB/VK5ZQ30jQ9X26SBl37qtuElTtXX+IuXcvmN2NAAAAJiEAgUAgH9zdnNTrzHD1OXl52WxWLTl80XaOGOubl2/YXY0AAAAmIwCBQBQ7tk7OarrkJfkP2qoHF1dtHtFnNZ+OkPXMs6bHQ0AAAAlBAUKAKDcsrG1Vftn+ikgfLQq1aiuH77dqrjJU5WR+qPZ0QAAAFDC2FjrB3t5eWnTpk1KTk7WoUOHFBUVJUlq2bKlduzYoX379mnXrl1q167d3XsmTJiglJQUHTlyRAEBAXevt27dWklJSUpJSdGkSZOsFRkAUI40791Dry+drxfenaArZ87pk2GvalbUG5QnAAAAuC/DGuPh4WH4+fkZkgxXV1fj6NGjhq+vr7F27VojMDDQkGQEBQUZ3377rSHJ8PX1Nfbv3284ODgY3t7eRmpqqmFjY2NIMhITE42OHTsakoy4uLi79//aZGVlWeX3YhiGYUr3NGzX2oiaP8P418EdxutL5xvNenQxPRPDMAzDMAxjvSmqfsBqr/BkZGQoIyNDkpSVlaXDhw/L09NThmHIzc1NklSpUiWdPXtWkjRgwAAtXLhQOTk5SktLU2pqqtq3b6+0tDS5ubkpISFBkjRv3jwNHDhQa9assVZ0AEAZVLuxj4JjwuXb5Sldyzivhe+8r90r4mUUFJgdDQAAAKVAseyBUq9ePfn5+SkxMVExMTFau3atPvzwQ9nY2KhTp06SJE9Pz7sliSSlp6fL09NTubm5Sk9P/8V1AAAeRBXPWgp8LUxt+gXq1vUbWvnhx9q2cInysrPNjgYAAIBSxOoFiouLi5YsWaKYmBhlZmYqPDxc48eP1zfffKMXXnhBM2fOVJ8+fWSxWH5xr2EY971+L6GhoQoLC5Mk2dmxPy4AlGeuVdzVO2yEnnrxGRXk5WvjjHnaNOtz3cnMMjsaAAAASiGrtgx2dnZasmSJ5s+fr6VLl0qShg8frujoaEnSV199pRkzZkj6aWVJnTp17t7r5eWls2fPKj09XV5eXr+4fi+xsbGKjY2V9NNrQwCA8sexQgV1HzZI3Ue8LHtHR+1cukrrpszUjYuXzI4GAACAUsxqp/BI0syZM3X48GFNnDjx7rWzZ8+qe/fukiR/f3+lpKRIklasWKFBgwbJwcFB3t7e8vHx0c6dO5WRkaHMzEx16NBBkjRs2DAtX77cmrEBAKWQrZ2dOg9+Xm/GfaW+kaE6+n2i/vnMEH39p79TngAAAOCxWW0FSufOnTVs2DAlJSVp3759kqS33npLoaGhmjRpkuzs7HTnzp27r9wkJydr8eLFSk5OVl5eniIjI1Xw7439wsPDNWfOHDk7Oys+Pl7x8fHWig0AKGUsFotaBfZW4LgwVavjpdSdezRr3Os6dTDZ7GgAAAAoQyz66TieMicrK0uurq5mxwAAWFHjTh0UHB0ur6aNdebIMa3+aIqOfp9Q+I0AAAAoN4qqH2CnVQBAqVOnma9CYiLk07GtLqef1fwJ72pf3Pr7bjIOAAAAPC4KFABAqVGtXh0FjXtVrfr2UtaVq1r6t//Rjq+WKT831+xoAAAAKOMoUAAAJV7FalUVED5aHZ7tr7ycHK2bMlOb5y5Q9s1bZkcDAABAOUGBAgAosZxcXdRz5FB1HfqS7OzttWPxUq2fPltZl6+aHQ0AAADlDAUKAKDEsXNwUKdBz6p36Ai5VK6kvXHrtObj6bqcfsbsaAAAACinKFAAACWGxcZGbfoFqm/kGFWpXUtHv0/Q6klTdObwMbOjAQAAoJyjQAEAlAi+3TorJCZctXwa6tShZC165y9K3bnH7FgAAACAJAoUAIDJvFs2V8j4CDVo00oX005p7m9+r6R1m8yOBQAAAPwMBQoAwBQ1G3grOHqsnvTvrhsXL+mrP/1dO5euVEFevtnRAAAAgF+gQAEAFKvKNWuob2So2j4dpOxbtxU3aaq2zl+knNt3zI4GAAAA3BcFCgCgWDi7uanXmGHq8vLzslgs2vLFIm2Mnatb12+YHQ0AAAAoFAUKAMCq7J0c1XXIi/If9YocXV20Z2W81n46Q1fPZZgdDQAAAHhgFCgAAKuwsbVV+2f6KWDsaFWqWV0/bN6muMlTlZFy3OxoAAAAwEOjQAEAFLnmvXsoOGqsatSvpxP7kvT562/rxL4ks2MBAAAAj4wCBQBQZBq29VPI+EjVa9FMGak/albUG/rh261mxwIAAAAeGwUKAOCx1Wr0hELGR8i3y1O6lnFeC995X7tXxMsoKDA7GgAAAFAkKFAAAI+simctBb4WJr/gAN3JzNLKDz/WtoVLlJedbXY0AAAAoEhRoAAAHpqLe2X1DhuhTi89q4K8fH076wttmvW57mRmmR0NAAAAsAoKFADAA3Nwdlb34YPVY8TLsnd01M5lq7RuyizduHDR7GgAAACAVVGgAAAKZWtnp44vDFSfV0eqYtUqSlr/reI/nqYLJ06aHQ0AAAAoFhQoAID7slgsahXYW4HjwlStjpdSd+3VrHGv69TBZLOjAQAAAMWKAgUAcE+NnmqvkJgIeTVtrLNHUxQbPl5HtiWYHQsAAAAwBQUKAOBn6jTzVUhMhHw6ttXl9LOa/+YftW/1OhmGYXY0AAAAwDQUKAAASVK1ul4KihqrVn17KevKVS392/9ox1fLlJ+ba3Y0AAAAwHQUKABQzlWsVlUBY0epw3NPKy8nR+umzNTmuQuUffOW2dEAAACAEoMCBQDKKSdXF/UYOUTdhg6Snb29dny1TOunzVLW5atmRwMAAABKHAoUAChn7Bwc1GnQs+o9Zrhc3CtrX9w6xX8Sq8un082OBgAAAJRYFCgAUE5YbGzUpl+g+kaOUZXatXT0+wStnjRFZw4fMzsaAAAAUOJRoABAOeDbrbNCYsJVy6ehTh1K1uI//FUpibvNjgUAAACUGhQoAFCGebdsrpDxEWrQppUunjytub/5vZLWbTI7FgAAAFDqUKAAQBlUs4G3gqPH6kn/7rpx8ZK+/tM/lLh0hQry8s2OBgAAAJRKFCgAUIZUrllDfSND1fbpIGXfuq24yVO19YtFyrl9x+xoAAAAQKlGgQIAZYCzm5t6jRmmLi8/L4vFoi1fLNKmGfN089p1s6MBAAAAZQIFCgCUYvZOjuo65EX5j3pFjq4u2rMyXms/naGr5zLMjgYAAACUKRQoAFAK2djaqt3AEPUNH6NKNavrh83bFDd5qjJSjpsdDQAAACiTKFAAoJRp3qu7gqPDVaN+PaXtP6jP33hHJ/YeMDsWAAAAUKZRoABAKdGwrZ9CYiJUr+WTyjh+QrOi3tAP3241OxYAAABQLlCgAEAJV6vREwqJCZdv1066lnFei975i3avjFdBPkcSAwAAAMWFAgUASqgqnrXUNzJUrUP66k5mllb+6xNt+/Jr5WVnmx0NAAAAKHcoUACghHFxr6zeYSPU6aVnZeQXaPPsL7Rp1he6fSPT7GgAAABAuUWBAgAlhIOzs7oPH6wew1+Wg7OTEpeu1Lops3TjwkWzowEAAADlHgUKAJjM1s5OHZ8foD5jR6li1SpKWv+t4j+epgsnTpodDQAAAMC/UaAAgEksFota9u2loKhXVa2Ol1J37dWsqDd0KukHs6MBAAAA+D8oUADABI2eaqeQmEh5NW2ss0dTFBs+Xke2JZgdCwAAAMB9UKAAQDHyatpEIeMj1KhjO105c07z3/yj9q1eJ8MwzI4GAAAA4FdQoABAMahW10tB415Vq8DeyrpyVcs+mKjti5cqPzfX7GgAAAAAHgAFCgBYUcVqVRUwdpQ6PPu08nJztG7KTG2eu0DZN2+ZHQ0AAADAQ6BAAQArcHJ1UY+RQ9Rt6CDZ2dtrx9fLtH7aLGVdvmp2NAAAAACPgAIFAIqQnYODOr30rHqHDpeLe2Xti1un+E9idfl0utnRAAAAADwGChQAKAIWGxu16ReovpFjVKV2LR39PkGrJ03RmcPHzI4GAAAAoAhQoADAY/Lt1lkhMeGq5dNQp384rMV/+KtSEnebHQsAAABAEaJAAYBH5N2yuULGR6hBm1a6ePK05v32bSWt28SRxAAAAEAZRIECAA+pZgNvBUeP1ZP+3XXj0mV9/ad/KHHpChXk5ZsdDQAAAICVUKAAwAOqXLOGAiLGqN2AYOXcvqO4yVO19YtFyrl9x+xoAAAAAKyMAgUACuHs5qZeo19RlyEvyGKxaOv8xdoYO1c3r103OxoAAACAYmJjrR/s5eWlTZs2KTk5WYcOHVJUVNTd77322ms6cuSIDh06pL///e93r0+YMEEpKSk6cuSIAgIC7l5v3bq1kpKSlJKSokmTJlkrMgD8jL2To3qOGqq34r9S9xEva/+ajfqg30ta8c/JlCcAAABAOWRYYzw8PAw/Pz9DkuHq6mocPXrU8PX1NXr06GGsX7/ecHBwMCQZ1atXNyQZvr6+xv79+w0HBwfD29vbSE1NNWxsbAxJRmJiotGxY0dDkhEXF2cEBgYW+vysrCyr/F4Mw5T9sbG1NTo897Txhw0rjH8d3GGM/uRDw8Onoem5GIZhGIZhGIZ5+CmqfsBqr/BkZGQoIyNDkpSVlaXDhw/L09NToaGh+uCDD5STkyNJunjxoiRpwIABWrhwoXJycpSWlqbU1FS1b99eaWlpcnNzU0JCgiRp3rx5GjhwoNasWWOt6ADKsea9uis4Olw16tdT2v6D+vyNd3Ri7wGzYwEAAAAwmdVe4fnf6tWrJz8/PyUmJqpRo0bq2rWrEhIStHnzZrVt21aS5OnpqdOnT9+9Jz09XZ6envL09FR6evovrgNAUWrQ1k9RX8RqxEcfqKCgQLOjf6ePXwmjPAEAAAAgqRg2kXVxcdGSJUsUExOjzMxM2dnZyd3dXR07dlS7du20ePFiNWjQQBaL5Rf3GoZx3+v3EhoaqrCwMEmSnR374wIoXK1GTygkJly+XTvp2vkLWvSHv2r3ijgV5HMkMQAAAID/smrLYGdnpyVLlmj+/PlaunSppJ9WkHzzzTeSpF27dqmgoEDVqlVTenq66tSpc/deLy8vnT17Vunp6fLy8vrF9XuJjY1VbGyspJ9eGwKA+3Gv7aHA18LUOqSv7mRlaeW/PtG2L79WXna22dEAAAAAlEBWfYVn5syZOnz4sCZOnHj32rJly+Tv7y9J8vHxkYODgy5duqQVK1Zo0KBBcnBwkLe3t3x8fLRz505lZGQoMzNTHTp0kCQNGzZMy5cvt2ZsAGWYi3tlDXgjRhNWLlLLPv7aPPsL/TXoeW2eM5/yBAAAAMB9WW0FSufOnTVs2DAlJSVp3759kqS33npLs2bN0qxZs3Tw4EHl5ORo+PDhkqTk5GQtXrxYycnJysvLU2RkpAoKCiRJ4eHhmjNnjpydnRUfRqINsgAAIABJREFUH6/4+HhrxQZQRjk4O6vbsEHqOWKIHJydtHPpKq2bOlPXz180OxoAAACAUsCin47jKXOysrLk6upqdgwAJrO1s1PH5weo96sj5VatqpI2bFb85Km6cOKk2dEAAAAAFIOi6gfYaRVAmWSxWNSyby8FjXtV1ep6KXXXXs2O/p1OJf1gdjQAAAAApRAFCoAyp9FT7RQcE6E6TZvo7NEUxYaP15FtCWbHAgAAAFCKUaAAKDO8mjZRyPgINerYTlfOnNP8N/+ofavX3ffocwAAAAB4UBQoAEq9anW9FDTuVbUK7K2sK1e17IOJ2r54qfJzc82OBgAAAKCMoEABUGpVrFZVAWNHqcOzTysvN0frps7S5jnzlX3zltnRAAAAAJQxFCgASh0nVxf1GDlE3YYOkp29vXZ8vUzrp81S1uWrZkcDAAAAUEZRoAAoNWzt7dV50HPqHTpcLu6VtS9uneI/idXl0+lmRwMAAABQxlGgACjxLDY2ah3SV4GvhapK7Vo6uj1RcZOmKD35qNnRAAAAAJQTFCgASjTfrp0UMj5CtXwa6vQPh7X43b8pJWGX2bEAAAAAlDMUKABKpHotn1TI+Ag1bOOniydPa95v31bSuk0cSQwAAADAFBQoAEqUGvXrKTg6XM17ddeNS5f19Z//ocRvVqggL9/saAAAAADKMQoUACVCpZrV1Td8jNoNDFHO7TuK/3iatny+SDm3b5sdDQAAAAAoUACYy9nNTb1Gv6IuL78gi41FWxd8pY3T5+jmtetmRwMAAACAuyhQAJjCztFRXYe8IP/Rr8jJ1VV7Vq7R2s9idfVshtnRAAAAAOAXKFAAFCsbW1u1GxCsgIgxqlyzhpK/+15xk6fo3LHjZkcDAAAAgPuiQAFQbJ70767g6LGq2cBbaQcOav7v3tWPe/abHQsAAAAACkWBAsDqGrT1U0hMuLxbNtf5H9M0O/p3OrRpi9mxAAAAAOCBUaAAsJpajRoqODpcTbt11rXzF7ToD3/V7hVxKsjnSGIAAAAApQsFCoAi517bQ4GRYWrdr6/uZGVp1f98oq0LvlZedrbZ0QAAAADgkVCgACgyLu6V1Tt0hDq99IyMAkOb58zXppmf6/aNTLOjAQAAAMBjoUAB8NgcnJ3Vbdgg9RwxRA7OTtq5dJXWTZ2p6+cvmh0NAAAAAIoEBQqAR2ZjZ6uOzw1Qn7Gj5FatqpI2bFb85Km6cOKk2dEAAAAAoEhRoAB4aBaLRS0D/BUUNVbV6nrp+O59mh39O51K+sHsaAAAAABgFRQoAB5Ko6faKTgmQnWaNtHZY6mKjfh/OrJ1h9mxAAAAAMCqKFAAPBCvpk0UMj5CjTq205Uz57Tgzfe0N26djIICs6MBAAAAgNVRoAD4VdXqeilo3KtqFdhbN69e07IPJmr74qXKz801OxoAAAAAFBsKFAD3VLFqFfUZO0odnxugvNxcrZs6S5vnzFf2zVtmRwMAAACAYkeBAuBnHF0qqOfIoer2yiDZ2dsrYclyrZ86S5mXr5gdDQAAAABMQ4ECQJJka2+vTi89qz5hI+TiXln74tcr/uPpunw63exoAAAAAGA6ChSgnLPY2Kh1SF8FRoaqimctHduxU6s/+kzpyUfNjgYAAAAAJQYFClCO+XbtpOCYcNVu9IRO/3BYi//4N6Uk7DI7FgAAAACUOBQoQDlUt0Uz9RsfqYZt/XTpVLo+/+3bOrBukwzDMDsaAAAAAJRIFChAOVKjfj0FR4erea/uunHpspa8/08lLFmugrx8s6MBAAAAQIlGgQKUA5VqVlff8DFqNzBEObfvKP7jadry+SLl3L5tdjQAAAAAKBUoUIAyzNmtovxHv6KuL78oi41FWxd8pY2xc3Xz6jWzowEAAABAqUKBApRBdo6O6vry8/IfM0xOrq7au2qt1nw6XVfPZpgdDQAAAABKJQoUoAyxsbVVuwHBCogYo8o1ayh5y/eKmzRF544dNzsaAAAAAJRqFChAGfGkf3cFR49VzQbeSjtwUPN/965+3LPf7FgAAAAAUCZQoAClXIM2rRQyPkLeLZvr/I9pmh09QYc2fWd2LAAAAAAoUyhQgFKqVqOGCo4OV9NunXXt/AUtfvev2rU8TgX5HEkMAAAAAEWNAgUoZdxreygwMkyt+/XVnawsrfqfT7R1wdfKy842OxoAAAAAlFkUKEAp4VK5knqFjVDnl56VUWBo85z52jTzc92+kWl2NAAAAAAo8yhQgBLOwdlZ3YYNUs8RQ+Tg7KSdS1dp3dSZun7+otnRAAAAAKDcoEABSigbO1t1fG6A+owdJbdqVZW0YbPiJ0/VhRMnzY4GAAAAAOUOBQpQwlgsFrUM8FdQ1FhVq+ul47v3aU7MBJ08cMjsaAAAAABQblGgACWIT8d2ChkfoTpNm+jssVTFRvw/Hdm6w+xYAAAAAFDuUaAAJYBX08YKiYlQo6fa68qZc1rw5nvaG7dORkGB2dEAAAAAAKJAAUxVtY6XgsaFyS+oj25evaZlf/9I2xd9o/zcXLOjAQAAAAD+FwoUwAQVq1ZRn7Gj1PG5AcrLzdX6abO1ec583cm6aXY0AAAAAMA9UKAAxcjRpYJ6jhyqbq8Mkp29vRKWLNf6qbOUefmK2dEAAAAAAL+CAgUoBrb29ur00rPqHTpcrlXctS9+veI/nq7Lp9PNjgYAAAAAeAAUKIAVWWxs1Do4QIGvhamKZy0d27FTqz/6TOnJR82OBgAAAAB4CBQogJU06fqUQmIiVLvREzqdfERfvfc3Hduxy+xYAAAAAIBHQIECFLG6LZqp3/hINWzrp0un0vX5b9/WgXWbZBiG2dEAAAAAAI+IAgUoIjXq11NQ1Fi16N1DNy5d1pL3/6nEJSuUn5dndjQAAAAAwGOysdYP9vLy0qZNm5ScnKxDhw4pKirqZ9//zW9+I8MwVLVq1bvXJkyYoJSUFB05ckQBAQF3r7du3VpJSUlKSUnRpEmTrBUZeCRuNarrhXcn6PWl89WoYzvFfzJdfwt+QdsXfUN5AgAAAABliGGN8fDwMPz8/AxJhqurq3H06FHD19fXkGR4eXkZa9asMdLS0oyqVasakgxfX19j//79hoODg+Ht7W2kpqYaNjY2hiQjMTHR6NixoyHJiIuLMwIDAwt9flZWllV+L4b5zzi7VTRCxkcYH+zabPx97xZjwBsxhot7ZdNzMQzDMAzDMAzDMP+douoHrPYKT0ZGhjIyMiRJWVlZOnz4sDw9PXX48GFNnDhRb7zxhpYvX3738wMGDNDChQuVk5OjtLQ0paamqn379kpLS5Obm5sSEhIkSfPmzdPAgQO1Zs0aa0UHfpWdo6O6vvy8/McMk5Orq/auWqs1n07X1bMZZkcDAAAAAFhJseyBUq9ePfn5+SkxMVH9+/fXmTNnlJSU9LPPeHp63i1JJCk9PV2enp7Kzc1Venr6L67fS2hoqMLCwiRJdnZs74KiZWNrq7ZPB6tv5BhVrllDyVu+V9ykKTp37LjZ0QAAAAAAVmb1lsHFxUVLlixRTEyM8vLy9Pvf//5n+5v8h8Vi+cU1wzDue/1eYmNjFRsbK+mnVS9AUXnSv5uCosbKo2F9nTxwSPMn/FE/7t5ndiwAAAAAQDGxaoFiZ2enJUuWaP78+Vq6dKmefPJJ1a9fXwcOHJD000aze/fuVfv27ZWenq46dercvdfLy0tnz55Venq6vLy8fnEdKA4N2rRSSEyEvFs11/kf0zQ7eoIObfrO7FgAAAAAABNYbaOWuXPnGhMnTrzv90+cOHF3E9mmTZv+bBPZ48eP391EdufOnUaHDh0M6adNZIOCgoptkximfI6HT0Nj9CcfGv86uMN4Z8Nyo8Oz/Q0bW1vTczEMwzAMwzAMwzAPNyV+E9nOnTtr2LBhSkpK0r59P73q8NZbbyk+Pv6en09OTtbixYuVnJysvLw8RUZGqqCgQJIUHh6uOXPmyNnZWfHx8ff9GcDjcq/tocDIMLXu11d3srK06n8+0dYFXysvO9vsaAAAAAAAE1n0U5NS5mRlZcnV1dXsGCglXCpXUq+wEer80rMyCgxtXbBYm2Z+rts3Ms2OBgAAAAB4DEXVD3BUDco1B2cndXtlkHqOHCoHZyftWrZaa6fM0PXzF82OBgAAAAAoQShQUC7Z2Nmqw7NPKyB8tNyqVdXBjd8pbtIUXThx0uxoAAAAAIASiAIF5YrFYlHLAH8FjntV1evV0fE9+zQnZoJOHjhkdjQAAAAAQAlGgYJyw6djO4XEhKtOM1+dPZaqGRG/0eGt282OBQAAAAAoBShQUOZ5+jZSSEyEGnfqoCtnz2nBW3/S3tVrZfz7lCcAAAAAAApDgYIyq2odLwWNC5NfUB/dvHpNy/8xSdsXfaO8nByzowEAAAAAShkKFJQ5FatWUZ+xo9TxuQHKy83V+mmztXnOfN3Juml2NAAAAABAKUWBgjLD0aWCeowYou7DBsnO3kEJS5Zr/bTZyrx02exoAAAAAIBSjgIFpZ6tvb06vfiMeoeNkGsVd+1fs0HxH0/TpVPpZkcDAAAAAJQRFCgotSw2NmodHKC+kaGq6lVbxxJ2afXEz5SefMTsaAAAAACAMoYCBaVSk65PKSQ6XLUb++h08hF9HfaBju3YZXYsAAAAAEAZRYGCUqVui2YKiYnQE+1a69KpdH3++js6sHajDMMwOxoAAAAAoAyjQEGpUKN+PQVFjVWL3j2UefmKvvnLh0r4erny8/LMjgYAAAAAKAcoUFCiudWorr7ho9X+mX7KuXNH8Z9M15Z5C5Vz+7bZ0QAAAAAA5QgFCkokZ7eK8h81VF2HvCSLrY22LfhaG2Ln6ObVa2ZHAwAAAACUQxQoKFHsHB3VZfDz6jVmmJwqumrvqrVa8+l0XT2bYXY0AAAAAEA5RoGCEsHG1lZt+wepb+QYVfaoqeQt3ytu0hSdO3bc7GgAAAAAAFCgwHxP+ndTUNRYeTSsr5MHDmn+m+/px937zI4FAAAAAMBdFCgwTYM2rRQSEyHvVs114cRJzY6eoEObvjM7FgAAAAAAv0CBgmLn4dNQIdHhatq9s66fv6jF7/5Vu5bHqSA/3+xoAAAAAADcEwUKio17LQ/1jQxVm/6BupOVpVUTP9W2BV8p90622dEAAAAAAPhVFCiwOpfKldQrdLg6D3pOhmHouzkLtHHm57p944bZ0QAAAAAAeCAUKLAaB2cndXtlkHqMGCLHCs7atTxO6z6boWvnL5gdDQAAAACAh0KBgiJnY2erDs8+rYCxo+RWvZoObvxO8ZOn6vyPaWZHAwAAAADgkVCgoMhYLBa1CPBX0LhXVb1eHR3fs09zx7+ltAMHzY4GAAAAAMBjoUBBkfDp0FYh4yNUp5mvzqUc14yI3+jw1u1mxwIAAAAAoEhQoOCxePo2UkhMhBp36qArZ89pwVt/0t7Va2UUFJgdDQAAAACAIkOBgkdS1ctTQePC5BccoJtXr2n5PyZp+6JvlJeTY3Y0AAAAAACKHAUKHoprVXf1eXWUnnp+oPJyc7V++mxtnj1fd7Jumh0NAAAAAACroUDBA3F0qaAeI4ao+7BBsnNwUOKSFVo3dZYyL102OxoAAAAAAFZHgYJfZWtvr04vPqPeYSPkWsVd+9dsUPzH03TpVLrZ0QAAAAAAKDYUKLgni8Uiv5AABUaGqapXbaUk7NaqiZ8qPfmI2dEAAAAAACh2FCj4hSZdOiokJkK1G/soPfmopoVF69iOnWbHAgAAAADANBQouKtu86YKGR+pJ9q11qXT6fr89Xd0YO1GGYZhdjQAAAAAAExFgQLVqF9PQeNeVYs+PZV5+Yq++cuHSvh6ufLz8syOBgAAAABAiUCBUo651aiugPBRaj+wn3KzsxX/yXRtmbdQObdvmx0NAAAAAIAShQKlHHJ2qyj/UUPVdchLstja6Psvl2hD7BzdvHrN7GgAAAAAAJRIFCjliJ2jo7oMfl69xgyTU0VX7V29Vms/jdWVM+fMjgYAAAAAQIlGgVIO2Njaqm3/IPWNHKPKHjV1eOt2rf5ois4dSzU7GgAAAAAApQIFShn3pH83BUWNlUfD+jqZ9IMWvPmeju/eZ3YsAAAAAABKFQqUMqp+65bqNz5S3q2a68KJk5oTM0EHN35ndiwAAAAAAEolCpQyxsOnoUKiw9W0e2ddP39Ri//4N+1atloF+flmRwMAAAAAoNSiQCkj3Gt5qG9kqNr0D1R21k2tmvipti34Srl3ss2OBgAAAABAqUeBUsq5VK6kXqHD1XnQczIMQ9/NWaCNMz/X7Rs3zI4GAAAAAECZQYFSSjk4O/3/9u4/purr/uP4Cy4Fb0UFrEoFRdfWltq1IMQfc52rlbY2Ttl0g0aD1MVmDKcuflsJdbNpm0Xduq26WTZmZ80QqAWnNmqlq6mZFax6gQtc5CJapYLONXWa0urF8/3D+YkIem0mXLz3+UjeCffcz/nc87mvkNK393yuHp2TpseenaOwO+36eMt27Vr7F31+6rSvlwYAAAAAgN+hgXKbCQ6xadz3p+uJrHnqP+gu1Xzwoba/nqdTTcd8vTQAAAAAAPwWDZTbyCNPPq6pC57ToBHD1XSwUm/9PFfHqpy+XhYAAAAAAH6PBspt4L5xyXp6cZaGP/SgWtxH9Jfs/5Nrz15fLwsAAAAAgIBBA6UX+X7uEk34YaqCbTZdam9Xddlu3dm/n+6fOF6fnWxR4Yuv6OC7O2UuXfL1UgEAAAAACChBkoyvF9Edzp8/r/DwcF8v46Z9P3eJJqbPVFBQUIfxi19+pe1r8vRRUak8Fy74aHUAAAAAANyeblV/gE+g9BITfpjaqXkiXb5p7J4NRT5YEQAAAAAAuCLY1wvAZcE229caBwAAAAAAPYcGSi9xqb39a40DAAAAAICeQwOll9i36e8ypuPtaIwx2rfp7z5aEQAAAAAAuKLbGiixsbH64IMPVFdXp5qaGi1cuFCStGrVKrlcLlVVVam0tFQDBgyw5uTk5Mjtdqu+vl5PPPGENT5mzBhVV1fL7Xbr9ddf764l+9TmX72mvUUlavd4ZIxRu8ejvUUl2vyr13y9NAAAAAAAoMvfwnPLKzo62iQmJhpJJjw83Bw+fNjEx8eblJQUY7PZjCSzYsUKs2LFCiPJxMfHm8rKShMaGmpGjBhhGhsbTXBwsJFkKioqzPjx440ks337dvPUU095ff3z5893y3VRFEVRFEVRFEVRFHX71K3qD3TbJ1BaW1vlcDgkXf7KIJfLpZiYGJWVlan9v/f1KC8vV2xsrCRpxowZKioq0oULF3Ts2DE1NjZq7Nixio6OVv/+/VVeXi5J2rBhg1JTU7tr2QAAAAAAAJ30yD1Q4uLilJiYqIqKig7j8+bN044dOyRJMTExOnHihPVcc3OzYmJiFBMTo+bm5k7jAAAAAAAAPSWku1+gb9++Kikp0eLFi3Xu3DlrPDc3Vx6PRwUFBZKkoKCgTnONMdcd78r8+fP13HPPSZJCQrr90gAAAAAAQIDo1i5DSEiISkpKVFBQoM2bN1vjGRkZmjZtmh5//HFrrLm5WcOGDbMex8bG6uTJk2pubra2+Vw93pX8/Hzl5+dLurxtCAAAAAAA4Fbo1i0869atk8vl0u9+9ztr7Mknn9TSpUs1ffp0tbW1WeNbt25Venq6QkNDNWLECN13333av3+/Wltbde7cOY0bN07S5ebLli1bunPZAAAAAAAAHXTbJ1AmTpyojIwMVVdXWzeTzc3N1erVqxUWFqaysjJJl28km5WVpbq6Or399tuqq6uTx+NRdna2Ll26JEnKysrS+vXrZbfbtWPHDuu+KQAAAAAAAD0hSJe/jsfvnD9/XuHh4b5eBgAAAAAA8KFb1R/okW/hAQAAAAAAuJ3RQAEAAAAAAPCCBgoAAAAAAIAXNFAAAAAAAAC8oIECAAAAAADgBQ0UAAAAAAAAL2igAAAAAAAAeEEDBQAAAAAAwAsaKAAAAAAAAF7QQAEAAAAAAPCCBgoAAAAAAIAXNFAAAAAAAAC8oIECAAAAAADgBQ0UAAAAAAAAL2igAAAAAAAAeEEDBQAAAAAAwAsaKAAAAAAAAF7QQAEAAAAAAPCCBgoAAAAAAIAXNFAAAAAAAAC8oIECAAAAAADgBQ0UAAAAAAAAL4IkGV8voju0t7erra3tlp4zJCREHo/nlp4TvRuZByZyDzxkHpjIPfCQeWAi98BD5oHHW+Z2u102m+2WvJahbq4+/vhjn6+BInOK3Ckyp8idInOK3Ckyp3o+c7bwAAAAAAAAeEEDBQAAAAAAwAubpJd8vYjbyaFDh3y9BPQwMg9M5B54yDwwkXvgIfPARO6Bh8wDT09k7rc3kQUAAAAAALhV2MIDAAAAAADgRcA1UEaNGiWHw2HV2bNntWjRIkVGRmrXrl1qaGjQrl27FBERYc3JycmR2+1WfX29nnjiCWt8zJgxqq6ultvt1uuvv26Nh4aGqqioSG63W+Xl5YqLi+vRa0RnixcvVk1NjZxOpzZu3KiwsDAy93MLFy6U0+lUTU2NFi1aJElk7ofWrVunU6dOyel0WmM9lXNGRoYaGhrU0NCgjIyMbr5SXK2r3GfNmqWamhq1t7crKSmpw/HkfvvrKvNVq1bJ5XKpqqpKpaWlGjBggPUcmfuHrnJ/+eWXVVVVJYfDoffee09333239Ry53/66yvyKJUuWyBijgQMHWmNkfvvrKvPly5erubnZ+n/2qVOnWs/1hsx9/pVDvqrg4GDT0tJihg8fblauXGmWLl1qJJmlS5eaFStWGEkmPj7eVFZWmtDQUDNixAjT2NhogoODjSRTUVFhxo8fbySZ7du3m6eeespIMllZWeaNN94wkkxaWpopKiry+bUGcg0dOtQ0NTWZPn36GEmmuLjYzJ07l8z9uEaPHm2cTqex2+3GZrOZsrIyc++995K5H9ajjz5qEhMTjdPptMZ6IufIyEhz5MgRExkZaSIiIsyRI0dMRESEz9+PQKmucn/ggQfMqFGjzO7du01SUpI1Tu7+UV1lnpKSYmw2m5FkVqxYwe+6H1ZXuffr18/6+Wc/+5mVG7n7R3WVuSQTGxtrdu7caY4dO2YGDhxI5n5UXWW+fPlys2TJkk7H9pLMff+m+apSUlLMP//5TyPJ1NfXm+joaCPJREdHm/r6eiPJ5OTkmJycHGvOzp07zfjx4010dLRxuVzWeHp6usnLy+twjCRjs9nMv/71L59fayDX0KFDzfHjx01kZKSx2Wxm27ZtJiUlhcz9uGbNmmXy8/Otx8uWLTPPP/88mftpxcXFdfiPbk/kfPUxkkxeXp5JT0/3+XsRSHVt7lfq2gYKuftPXS9zSSY1NdX87W9/I3M/rBvlnpOTY9auXUvuflZdZb5p0ybz8MMPm6NHj1oNFDL3n7o28+s1UHpD5gG3hedq6enpKiwslCQNGTJEra2tkqTW1lYNHjxYkhQTE6MTJ05Yc5qbmxUTE6OYmBg1Nzd3Gr92Tnt7u86ePdvho2boWSdPntRvfvMbHT9+XC0tLTp79qzKysrI3I/V1NToO9/5jqKiomS32/X0009r2LBhZB4geiLn650LvQ+5B4Z58+Zpx44dksg8ELz66qs6fvy4Zs+erV/+8peSyN2ffe9739Onn36q6urqDuNk7t8WLFigqqoqrVu3ztqO3RsyD9gGyh133KHp06dr06ZNNzwuKCio05gx5rrjN5oD34iIiNCMGTM0cuRIDR06VH379tXs2bOvezyZ3/7q6+u1cuVKlZWVaefOnaqqqpLH47nu8WQeGG5lzuR/+yB3/5ebmyuPx6OCggJJZB4Ili1bpuHDh6ugoEALFiyQRO7+ym6368UXX7QaZVcjc//1xhtv6J577lFCQoJaWlr02muvSeodmQdsA2Xq1Kk6dOiQTp8+LUk6deqUoqOjJUnR0dHWeHNzs4YNG2bNi42N1cmTJ9Xc3KzY2NhO49fOsdlsGjBggD777LMeuS50NmXKFB09elRnzpyRx+NRaWmpvvWtb5G5n3vzzTeVlJSkSZMm6bPPPpPb7SbzANETOV/vXOh9yN2/ZWRkaNq0aR3+YYTMA8fGjRs1c+ZMSeTur+655x6NHDlSVVVVOnr0qGJjY3Xo0CENGTKEzP3Y6dOndenSJRljlJ+fr7Fjx0rqPb/nPt/z5IsqLCw0mZmZ1uNVq1Z1uOngypUrjSTz4IMPdrhRzZEjR6wb1ezfv9+MGzfOSJdvVDN16lQjyfz0pz/tcKOa4uJin19vINfYsWNNTU2NsdvtRpJZv369WbBgAZn7eQ0aNMhIMsOGDTMul8tERESQuZ/WtftmeyLnyMhI09TUZCIiIkxERIRpamoykZGRPn8vAqlu9h4o5O4/dW3mTz75pKmtrTV33XVXh+PI3L/q2tzvvfde6+cFCxaYTZs2kbuf1Y3ue3P1PVDI3H/q2syv3MtOklm8eLEpLCzsTZn7/g3r6bLb7ebMmTOmf//+1lhUVJR5//33TUNDg3n//fc7vHm5ubmmsbHR1NfXW3fzlWSSkpKM0+k0jY2NZs2aNdZ4WFiYefvtt43b7TYVFRVm5MiRPr/mQK+XXnrJuFwu43Q6zYYNG0xoaCiZ+3nt2bPH1NbWmsrKSjN58mQj8Xvuj7Vx40Zz8uRJc+HCBXPixAkzb968Hsv52WefNW6327jd7g4Neco3uaemppoTJ06YL7/80rS2tpqdO3eSux9VV5m73W5z/Phx43A4jMPhsP5AJnP/qa5yf+edd4zT6TRVVVVm69atZujQoeTuR9VV5lc/f3UDhcz9o7rKfMOGDaa6utpUVVWZLVu2dGio+DrzoP/+AAAAAAAAgOsI2HugAAAAAAAA3CwaKAAAAAAAAF7QQAEAAAAAAPCCBgoAAAAAAIAXNFAAAAAAAAC8oIECAADk8XjkcDisiouLkyRNnDhRFRUVcrm7EIT7AAAGhklEQVRccrlcmj9/viRp0qRJ+uijjzqcw2azqbW1VdHR0T2+/qv99a9/1cyZM294zNy5c3X33Xdbj/Pz8xUfH9/dS/ufzZgx47ZYJwAA/ijE1wsAAAC+19bWpsTExA5jQ4YM0caNG5WamiqHw6GBAwfqvffe06effqodO3YoNjZWcXFx+uSTTyRJU6ZMUU1NjVpbW31xCV9LZmamampq1NLSIklWY6i3S01N1bvvviuXy+XrpQAAEHD4BAoAAOhSdna21q9fL4fDIUn697//rRdeeEE5OTkyxmjTpk1KS0uzjk9PT1dhYWGn8wwePFilpaWqrKxUZWWlJkyYoLi4ODmdTuuYJUuWaPny5ZKk3bt367e//a0+/PBD1dXVKTk5WSUlJWpoaNArr7wiSTecf7Vf/OIX2r9/v5xOp/70pz9JkmbOnKnk5GQVFBTI4XCoT58+2r17t5KSkvSTn/xEK1eutObPnTtXq1evliTNnj1bFRUVcjgcysvLU3Bw5z+jkpOTtXfvXlVWVqqiokLh4eEKCwvTm2++qerqah06dEjf/e53rXOvWbPGmrtt2zZNmjRJknTu3Dm9+uqrqqys1L59+zR48GBNmDBB06dP169//Ws5HA594xvfuFF8AADgFqOBAgAAZLfbre07paWlkqTRo0fr4MGDHY47cOCARo8eLUkqLCxUenq6JCk0NFRPP/20SkpKOp179erV+vDDD5WQkKAxY8aotrbW63ouXLigSZMmKS8vT1u2bFF2drYeeughZWZmKioq6qav6w9/+IPGjh2rb37zm7Lb7Zo2bZpKSkp04MABzZ49W4mJifryyy+t49955x394Ac/sB6npaWpuLhYDzzwgNLS0jRx4kQlJiaqvb1ds2fP7vBad9xxh4qLi7Vo0SIlJCRoypQpamtrU3Z2tiTp4Ycf1jPPPKO33npLYWFhN1x3eHi4ysvLlZCQoD179mj+/Pnat2+ftm7dqueff16JiYlqamq66fcBAAD879jCAwAAutzCExQUJGNMp2OvjB04cEDh4eEaNWqU4uPjVV5ers8//7zT8ZMnT1ZGRoYk6dKlS/rPf/6jyMjIG65n69atkiSn06na2lprW1BTU5OGDRvW5et05bHHHtMLL7ygO++8U1FRUaqtrdW777573ePPnDmjpqYmjRs3Tm63W/fff7/27t2r7OxsJSUl6eOPP5Z0ueF0+vTpDnPvv/9+tbS06MCBA5Iuf4pEkr797W9bnzQ5fPiwPvnkE40aNeqG6/7qq6+sdR48eFApKSk3db0AAKD70EABAABdqq2tVXJysrZt22aNJSUlqa6uznpcVFSk9PR0xcfHd7l953o8Hk+HLTB9+vTp8PxXX30l6XLD5crPVx6HhIR4nS9JYWFhWrt2rZKTk9Xc3Kzly5d3edy1iouL9aMf/Uj19fXavHmzpMvNpLfeeku5ubnXnXe9hlNQUFCXx9/oGi5evGj93N7erpAQ/mQDAMDX2MIDAAC69Mc//lGZmZl65JFHJElRUVFauXKlVq1aZR1TWFioOXPmaPLkydanRq71j3/8Q1lZWZKk4OBg9evXT6dOndLgwYMVFRWl0NBQTZs27Wut7WbmX2lInDlzRn379tWsWbOs586dO6d+/fp1ee7S0lKlpqbqmWeeUXFxsXUNs2bN0qBBgyRJkZGRGj58eId59fX1Gjp0qJKTkyVd3oZjs9m0Z88ea7vPfffdp+HDh+vw4cM6duyYEhISFBQUpNjYWI0dO9brdd9o3QAAoHvxzxkAAKBLra2tmjNnjvLz89WvXz8FBQXp97//fYctMC6XS1988YUOHjyoL774osvzLFq0SH/+85/14x//WO3t7crKylJ5eblefvllVVRU6OjRo6qvr/9aa/N4PF7nnz17Vvn5+XI6nTp27Ji1/UaS1q9fr7y8PLW1tWnChAkd5n3++eeqq6vTgw8+aM1xuVxatmyZdu3apeDgYF28eFHZ2dk6fvy4Ne/ixYtKS0vTmjVrZLfb1dbWpilTpmjt2rXKy8tTdXW1PB6PMjMzdeHCBe3du1dHjx6V0+lUTU2NDh065PW6i4qKlJ+fr4ULF2rWrFncBwUAgB4UJKnzZ00BAAAAAABgYQsPAAAAAACAFzRQAAAAAAAAvKCBAgAAAAAA4AUNFAAAAAAAAC9ooAAAAAAAAHhBAwUAAAAAAMALGigAAAAAAABe0EABAAAAAADw4v8B2HHk9qFQC/YAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index b11a93da..3feedb01 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -132,16 +132,13 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): ax2 = ax1.twiny() x = mph_df['cum_total_count'] y = mph_df['pulse_heights'] + x_alt = mph_df['cum_total_time'] ax1.scatter(x, y) ax1.set_xlabel('FOV cumulative count') ax1.set_ylabel('median pulse height') ax2.set_xlabel('estimated time (ms)') - ax1.set_xlim(0, max(x) + 10000) - ax2.set_xlim(0, max(x) + 10000) - ax2.set_xticks(x) - ax2.set_xticklabels(mph_df['cum_total_time']) + ax2.scatter(x_alt, y) plt.gcf().set_size_inches(18.5, 10.5) - plt.xlim(0, max(mph_df['cum_total_count']) + 10000) # plot regression line if regression: @@ -149,7 +146,7 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): x2 = np.array(mph_df['cum_total_count']) y2 = np.array(mph_df['pulse_heights']) m, b = np.polyfit(x2, y2, 1) - plt.plot(x2, m * x2 + b) + ax1.plot(x2, m * x2 + b) # save figure if save_dir is not None: From 60ba28af8b21668aed4840b2dcc0637c9963f7d6 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Fri, 20 May 2022 00:43:40 -0700 Subject: [PATCH 29/94] update images --- templates/example_MPH_plots.ipynb | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 49bbe8ee..e0c454f5 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ From 1dba497532eca183dc5ace4145d4a730446a37aa Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 24 May 2022 10:23:51 -0700 Subject: [PATCH 30/94] delete and generate new csv for combine_mph_metrics --- toffy/mph_comp.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 4f555a02..0939cc18 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -109,7 +109,10 @@ def combine_mph_metrics(bin_file_path, output_dir): # save csv to output_dir combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts_cum, 'cum_total_time': estimated_time_cum}) - combined_df.to_csv(os.path.join(output_dir, 'total_count_vs_mph_data.csv'), index=False) + file_path = os.path.join(output_dir, 'total_count_vs_mph_data.csv') + if os.path.exists(file_path): + os.remove(file_path) + combined_df.to_csv(file_path, index=False) def visualize_mph(mph_df, regression: bool, save_dir=None): From ca7cc8e9062c18cfb8b08c7a35e38fc15ff39969 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 24 May 2022 10:31:11 -0700 Subject: [PATCH 31/94] delete and generate new jpg for visualize_mph --- toffy/mph_comp.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 0939cc18..0dc1f18c 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -153,6 +153,9 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): # save figure if save_dir is not None: - plt.savefig(os.path.join(save_dir, 'fov_vs_mph.jpg')) + file_path = os.path.join(save_dir, 'fov_vs_mph.jpg') + if os.path.exists(file_path): + os.remove(file_path) + plt.savefig(file_path) plt.show() From 47445ab006df4b2a269ae16da32de721ca7dfc03 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 24 May 2022 15:36:50 -0700 Subject: [PATCH 32/94] fix time retrieval to work one fov at a time --- templates/example_MPH_plots.ipynb | 14 ++++++------ toffy/mph_comp.py | 37 +++++++++++++------------------ 2 files changed, 22 insertions(+), 29 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index e0c454f5..324a703b 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 0dc1f18c..557a38e9 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -8,34 +8,30 @@ from ark.utils import io_utils -def get_estimated_time(bin_file_path): - """Retrieve run time data for each bin file +def get_estimated_time(bin_file_path, fov): + """Retrieve run time data for each fov json file Args: bin_file_path (str): path to the FOV bin and json files + fov (str): name of fov to get estimated time for Returns: - fov_times (dictionary): fov bin file names and estimated run time + fov_time (int): estimated run time for the given fov """ # get json files in bin_file_path - fov_files = bin_files._find_bin_files(bin_file_path) - json_files = \ - [(name, os.path.join(bin_file_path, fov['json'])) for name, fov in fov_files.items()] - fov_times = {} + json_file = io_utils.list_files(bin_file_path, fov+".json") # retrieve estimated time (frame dimensions x pixel dwell time) - for j in json_files: - with open(j[1]) as file: - run_metadata = json.load(file) - size = run_metadata.get('frameSize') - time = run_metadata.get('dwellTimeMillis') - estimated_time = int(size**2 * time) - fov_times[j[0]] = estimated_time + with open(os.path.join(bin_file_path, json_file[0])) as file: + run_metadata = json.load(file) + size = run_metadata.get('frameSize') + time = run_metadata.get('dwellTimeMillis') + estimated_time = int(size**2 * time) - return fov_times + return estimated_time def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_csv=True): - """Retrieves FOV total counts and median pulse heights for all bin files in the directory + """Retrieves FOV total counts, pulse heights, & estimated time for all fovs in the directory Args: bin_file_path (str): path to the FOV bin and json files fov (string): name of fov bin file without the extension @@ -45,10 +41,6 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ save_csv (bool): whether to save to csv file or output data, defaults to True """ - # retrieve the total counts and compute pulse heights for each FOV run file - # saves individual .csv files to bin_file_path - total_counts = bin_files.get_total_counts(bin_file_path) - fov_times = get_estimated_time(bin_file_path) # path validation checks io_utils.validate_paths(bin_file_path) @@ -56,17 +48,18 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ # retrieve the data from bin file and store it output to individual csv pulse_height_file = fov + '-pulse_height.csv' - # get median pulse heights + # get median pulse heights, counts, and time median = bin_files.get_median_pulse_height(bin_file_path, fov, target, (mass_start, mass_stop)) count_dict = bin_files.get_total_counts(bin_file_path, [fov]) count = count_dict[fov] + time = get_estimated_time(bin_file_path, fov) out_df = pd.DataFrame({ 'fov': [fov], 'MPH': [median], 'total_count': [count], - 'time': [fov_times[fov]]}) + 'time': [time]}) # saves individual .csv files to bin_file_path if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): From 216917976a967027a6ef289c1bb62a395dd980d5 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 24 May 2022 16:37:19 -0700 Subject: [PATCH 33/94] tests for get_estimated_time --- templates/example_MPH_plots.ipynb | 10 +++++----- toffy/mph_comp.py | 9 +++++++-- toffy/mph_comp_test.py | 25 +++++++++++++++++++++++++ 3 files changed, 37 insertions(+), 7 deletions(-) create mode 100644 toffy/mph_comp_test.py diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 324a703b..59f9da6d 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 557a38e9..0eb96724 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -17,8 +17,13 @@ def get_estimated_time(bin_file_path, fov): fov_time (int): estimated run time for the given fov """ - # get json files in bin_file_path + # path validation + io_utils.validate_paths(bin_file_path) + + # get fov json file in bin_file_path json_file = io_utils.list_files(bin_file_path, fov+".json") + if len(json_file) == 0: + raise ValueError(f"The new FOV name supplied doesn't have a JSON file: {fov}") # retrieve estimated time (frame dimensions x pixel dwell time) with open(os.path.join(bin_file_path, json_file[0])) as file: @@ -42,7 +47,7 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ """ - # path validation checks + # path validation io_utils.validate_paths(bin_file_path) # retrieve the data from bin file and store it output to individual csv diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py new file mode 100644 index 00000000..3590a95b --- /dev/null +++ b/toffy/mph_comp_test.py @@ -0,0 +1,25 @@ +import pytest +import os + +from toffy import mph_comp as mph + +def get_estimated_time(): + bad_path = os.path.join("data", "not-a-folder") + bad_fov = "not-a-fov" + + good_path = os.path.join("data", "tissue") + good_fov = 'fov-1-scan-1' + + # bad run file data should raise an error + with pytest.raises(ValueError): + mph.get_estimated_time(bad_path, good_fov) + + # bad run file data should raise an error + with pytest.raises(ValueError): + mph.get_estimated_time(good_path, bad_fov) + + # bad run file data should raise an error + + + # test sucessful time data retrieval + assert mph.get_estimated_time(good_path, good_fov) == 512 From fdbb60ed92f1c744c6b3c1e53e780b98241ddbcd Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 24 May 2022 19:06:59 -0700 Subject: [PATCH 34/94] tests for compute_mph_metrics --- toffy/mph_comp.py | 17 +++++++++++------ toffy/mph_comp_test.py | 43 +++++++++++++++++++++++++++++++++++++++--- 2 files changed, 51 insertions(+), 9 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 0eb96724..20497e1a 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -23,7 +23,7 @@ def get_estimated_time(bin_file_path, fov): # get fov json file in bin_file_path json_file = io_utils.list_files(bin_file_path, fov+".json") if len(json_file) == 0: - raise ValueError(f"The new FOV name supplied doesn't have a JSON file: {fov}") + raise FileNotFoundError(f"The FOV name supplied doesn't have a JSON file: {fov}") # retrieve estimated time (frame dimensions x pixel dwell time) with open(os.path.join(bin_file_path, json_file[0])) as file: @@ -50,13 +50,18 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ # path validation io_utils.validate_paths(bin_file_path) - # retrieve the data from bin file and store it output to individual csv + # retrieve the data from bin file and output to individual csv pulse_height_file = fov + '-pulse_height.csv' - # get median pulse heights, counts, and time - median = bin_files.get_median_pulse_height(bin_file_path, fov, - target, (mass_start, mass_stop)) - count_dict = bin_files.get_total_counts(bin_file_path, [fov]) + try: + median = bin_files.get_median_pulse_height(bin_file_path, fov, + target, (mass_start, mass_stop)) + count_dict = bin_files.get_total_counts(bin_file_path, [fov]) + except FileNotFoundError: + raise FileNotFoundError(f"The FOV name supplied doesn't have a JSON file: {fov}") + except ValueError: + raise ValueError(f"The target name is invalid: {target}") + count = count_dict[fov] time = get_estimated_time(bin_file_path, fov) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 3590a95b..7d240468 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -1,3 +1,4 @@ +import pandas as pd import pytest import os @@ -10,12 +11,12 @@ def get_estimated_time(): good_path = os.path.join("data", "tissue") good_fov = 'fov-1-scan-1' - # bad run file data should raise an error + # bad directory path should raise an error with pytest.raises(ValueError): mph.get_estimated_time(bad_path, good_fov) - # bad run file data should raise an error - with pytest.raises(ValueError): + # bad fov name data should raise an error + with pytest.raises(FileNotFoundError): mph.get_estimated_time(good_path, bad_fov) # bad run file data should raise an error @@ -23,3 +24,39 @@ def get_estimated_time(): # test sucessful time data retrieval assert mph.get_estimated_time(good_path, good_fov) == 512 + + +def compute_mph_metrics(): + bin_file_path = os.path.join("data", "tissue") + fov_name = 'fov-1-scan-1' + target_name = 'CD8' + start_mass = -0.3 + stop_mass = 0.0 + + # bad run file data should raise an error + bad_path = os.path.join("data", "not-a-folder") + with pytest.raises(ValueError): + mph.compute_mph_metrics(bad_path, fov_name, target_name, start_mass, stop_mass) + + # invalid fov name should raise an error + with pytest.raises(FileNotFoundError): + mph.compute_mph_metrics(bin_file_path, "not-a-fov", target_name, start_mass, stop_mass) + + # invalid target name should raise an error + with pytest.raises(ValueError, match="target name is invalid"): + mph.compute_mph_metrics(bin_file_path, fov_name, "not-a-target", start_mass, stop_mass) + + # test successful data retrieval and csv output + mph.compute_mph_metrics(bin_file_path, fov_name, target_name, start_mass, stop_mass) + csv_path = os.path.join(bin_file_path, fov_name + '-pulse_height.csv') + assert os.path.exists(csv_path) + + # check the csv data is correct + mph_data = pd.DataFrame([{ + 'fov': fov_name, + 'MPH': 2222, + 'total_count': 72060, + 'time': 512, + }]) + csv_data = pd.read_csv(csv_path) + assert csv_data.equals(mph_data) From fbbaf105aff80171d93243bc40ba79c959debefe Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 25 May 2022 22:01:30 -0700 Subject: [PATCH 35/94] raise error for bad json and add test --- toffy/mph_comp.py | 10 +++++++--- toffy/mph_comp_test.py | 14 +++++++++++--- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 20497e1a..850b901b 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -28,9 +28,13 @@ def get_estimated_time(bin_file_path, fov): # retrieve estimated time (frame dimensions x pixel dwell time) with open(os.path.join(bin_file_path, json_file[0])) as file: run_metadata = json.load(file) - size = run_metadata.get('frameSize') - time = run_metadata.get('dwellTimeMillis') - estimated_time = int(size**2 * time) + try: + size = run_metadata.get('frameSize') + time = run_metadata.get('dwellTimeMillis') + estimated_time = int(size**2 * time) + except TypeError: + raise KeyError("The FOV json file is missing one of the necessary keys " + "(frameSize or dwellTimeMillis)") return estimated_time diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 7d240468..1a92f356 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -1,9 +1,12 @@ import pandas as pd import pytest import os +import tempfile +import json from toffy import mph_comp as mph + def get_estimated_time(): bad_path = os.path.join("data", "not-a-folder") bad_fov = "not-a-fov" @@ -19,10 +22,15 @@ def get_estimated_time(): with pytest.raises(FileNotFoundError): mph.get_estimated_time(good_path, bad_fov) - # bad run file data should raise an error - + # bad FOV json file data should raise an error, no frameSize or dwellTimeMillis keys + bad_data = {'fov': {'not_frameSize': 0, 'not_dwellTimeMillis': 0}} + temp_json = tempfile.NamedTemporaryFile(mode="w", suffix='fov_name.json', delete=False) + temp_json.write(json.dumps(bad_data)) + temp_dir = tempfile.gettempdir() + with pytest.raises(KeyError, match="missing one of the necessary keys"): + mph.get_estimated_time(temp_dir, 'fov_name') - # test sucessful time data retrieval + # test successful time data retrieval assert mph.get_estimated_time(good_path, good_fov) == 512 From e09b44765692ae105077ddaada710896c07854f4 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 25 May 2022 23:18:42 -0700 Subject: [PATCH 36/94] tests for combine_mph_metrics and add os.remove for test csvs --- toffy/mph_comp_test.py | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 1a92f356..485028be 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -68,3 +68,41 @@ def compute_mph_metrics(): }]) csv_data = pd.read_csv(csv_path) assert csv_data.equals(mph_data) + + os.remove('fov-1-scan-1-pulse_height.csv') + + +def combine_mph_metrics(): + bin_file_path = os.path.join("data", "tissue") + data1 = pd.DataFrame([{ + 'fov': 'fov-1-scan-1', + 'MPH': 2222, + 'total_count': 72060, + 'time': 512, + }]) + data2 = pd.DataFrame([{ + 'fov': 'fov-2-scan-1', + 'MPH': 3800, + 'total_count': 74799, + 'time': 512, + }]) + + data1.to_csv(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv'), index=False) + data2.to_csv(os.path.join(bin_file_path, 'fov-2-scan-1-pulse_height.csv'), index=False) + + combined_data = pd.DataFrame({ + 'pulse_heights': [2222, 3800], + 'cum_total_count': [72060, 146859], + 'cum_total_time': [512, 1024], + }, index=[0, 1]) + + # test successful data retrieval and csv output + mph.combine_mph_metrics(bin_file_path, bin_file_path) + csv_path = os.path.join(bin_file_path, 'total_count_vs_mph_data.csv') + csv_data = pd.read_csv(csv_path) + assert os.path.exists(csv_path) + assert csv_data.equals(combined_data) + + os.remove(csv_path) + os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) + os.remove(os.path.join(bin_file_path, 'fov-2-scan-1-pulse_height.csv')) From d0f9ef23dadac5aeb8d20fb47356fef393e0a7d4 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 25 May 2022 23:36:09 -0700 Subject: [PATCH 37/94] remove unecessary plt.show() --- toffy/mph_comp.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 850b901b..48d48bd0 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -164,5 +164,3 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): if os.path.exists(file_path): os.remove(file_path) plt.savefig(file_path) - - plt.show() From 1285b3c418233a40c1fc78b5bbae59c2d3aa3e7b Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 25 May 2022 23:42:38 -0700 Subject: [PATCH 38/94] add directory tests to combine_mph --- templates/example_MPH_plots.ipynb | 10 +++++----- toffy/mph_comp_test.py | 12 +++++++++++- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 59f9da6d..c06fa6d9 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 485028be..be300054 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -41,7 +41,7 @@ def compute_mph_metrics(): start_mass = -0.3 stop_mass = 0.0 - # bad run file data should raise an error + # bad directory path should raise an error bad_path = os.path.join("data", "not-a-folder") with pytest.raises(ValueError): mph.compute_mph_metrics(bad_path, fov_name, target_name, start_mass, stop_mass) @@ -74,6 +74,16 @@ def compute_mph_metrics(): def combine_mph_metrics(): bin_file_path = os.path.join("data", "tissue") + bad_path = os.path.join("data", "not-a-folder") + + # bad bin file directory path should raise an error + with pytest.raises(ValueError): + mph.combine_mph_metrics(bad_path, bin_file_path) + + # bad output directory path should raise an error + with pytest.raises(ValueError): + mph.combine_mph_metrics(bin_file_path, bad_path) + data1 = pd.DataFrame([{ 'fov': 'fov-1-scan-1', 'MPH': 2222, From 1673e40ecc920fc8119e4f6d2baba353f94af5d0 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 25 May 2022 23:47:42 -0700 Subject: [PATCH 39/94] tests for visualize_mph --- toffy/mph_comp_test.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index be300054..572c7a6e 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -116,3 +116,25 @@ def combine_mph_metrics(): os.remove(csv_path) os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) os.remove(os.path.join(bin_file_path, 'fov-2-scan-1-pulse_height.csv')) + + +def visualize_mph(): + bad_path = os.path.join("data", "not-a-folder") + mph_data = pd.DataFrame({ + 'pulse_heights': [2222, 3800], + 'cum_total_count': [72060, 146859], + 'cum_total_time': [512, 1024], + }, index=[0, 1]) + + # bad output directory path should raise an error + with pytest.raises(ValueError): + mph.visualize_mph(mph_data, False, bad_path) + + with tempfile.TemporaryDirectory() as temp_dir: + # test without saving + mph.visualize_mph(mph_data, True) + assert not os.path.exists(os.path.join(temp_dir, 'fov_vs_mph.jpg')) + + # test with saving + mph.visualize_mph(mph_data, True, save_dir=temp_dir) + assert os.path.exists(os.path.join(temp_dir, 'fov_vs_mph.jpg')) From 943457016be907ad7463ad9a086761aabe2cfc39 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 31 May 2022 10:27:18 -0700 Subject: [PATCH 40/94] add return functionality & test for combine_mph_metrics --- toffy/mph_comp.py | 15 ++++++++++----- toffy/mph_comp_test.py | 3 ++- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 48d48bd0..a2ad7763 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -39,7 +39,7 @@ def get_estimated_time(bin_file_path, fov): return estimated_time -def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_csv=True): +def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop): """Retrieves FOV total counts, pulse heights, & estimated time for all fovs in the directory Args: bin_file_path (str): path to the FOV bin and json files @@ -47,7 +47,6 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ target (str): channel to use mass_start (float): beginning of mass integration range mass_stop (float): end of mass integration range - save_csv (bool): whether to save to csv file or output data, defaults to True """ @@ -77,15 +76,18 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop, save_ # saves individual .csv files to bin_file_path if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): - if save_csv: - out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) + out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) -def combine_mph_metrics(bin_file_path, output_dir): +def combine_mph_metrics(bin_file_path, output_dir, return_data=False): """Combines data from individual csvs into one Args: bin_file_path (str): path to the FOV bin and json files output_dir (str): path to output csv to + return_data (bool): whether to return dataframe with mph metrics, default False + + Returns: + combined mph data for all FOVs """ # path validation checks @@ -121,6 +123,9 @@ def combine_mph_metrics(bin_file_path, output_dir): os.remove(file_path) combined_df.to_csv(file_path, index=False) + if return_data: + return combined_df + def visualize_mph(mph_df, regression: bool, save_dir=None): """Create a scatterplot visualizing median pulse heights by FOV cumulative count diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 572c7a6e..94309a78 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -107,11 +107,12 @@ def combine_mph_metrics(): }, index=[0, 1]) # test successful data retrieval and csv output - mph.combine_mph_metrics(bin_file_path, bin_file_path) + mph_data = mph.combine_mph_metrics(bin_file_path, bin_file_path, return_data=True) csv_path = os.path.join(bin_file_path, 'total_count_vs_mph_data.csv') csv_data = pd.read_csv(csv_path) assert os.path.exists(csv_path) assert csv_data.equals(combined_data) + assert mph_data.equals(combined_data) os.remove(csv_path) os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) From 400d12d0cfb4ae13519dedcb078ee1ee73c9b7c9 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 31 May 2022 10:52:52 -0700 Subject: [PATCH 41/94] condense data retrieval from csv --- toffy/mph_comp.py | 25 +++++++------------------ toffy/mph_comp_test.py | 12 +++++++----- 2 files changed, 14 insertions(+), 23 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index a2ad7763..c7144961 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -98,26 +98,15 @@ def combine_mph_metrics(bin_file_path, output_dir, return_data=False): fov_bins = io_utils.list_files(bin_file_path, ".bin") fov_bins = io_utils.remove_file_extensions(fov_bins) - pulse_heights = [] - fov_counts = [] - estimated_time = [] - - # for each csv retrieve mph values + combined_rows = [] for i, file in enumerate(fov_bins): - temp_df = pd.read_csv(os.path.join(bin_file_path, file + '-pulse_height.csv')) - pulse_heights.append(temp_df['MPH'].values[0]) - fov_counts.append(temp_df['total_count'].values[0]) - estimated_time.append(temp_df['time'].values[0]) + combined_rows.append(pd.read_csv(os.path.join(bin_file_path, file + '-pulse_height.csv'))) - # calculate cumulative sums of total counts - fov_counts_cum = [fov_counts[j]+fov_counts[j-1] if j > 0 else fov_counts[j] - for j in range(len(fov_counts))] - estimated_time_cum = [estimated_time[j] + estimated_time[j - 1] if j > 0 - else estimated_time[j] for j in range(len(estimated_time))] + combined_df = pd.concat(combined_rows) + combined_df['cum_total_count'] = combined_df['total_count'].cumsum() + combined_df['cum_total_time'] = combined_df['time'].cumsum() # save csv to output_dir - combined_df = pd.DataFrame({'pulse_heights': pulse_heights, 'cum_total_count': fov_counts_cum, - 'cum_total_time': estimated_time_cum}) file_path = os.path.join(output_dir, 'total_count_vs_mph_data.csv') if os.path.exists(file_path): os.remove(file_path) @@ -146,7 +135,7 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): ax1 = fig.add_subplot(111) ax2 = ax1.twiny() x = mph_df['cum_total_count'] - y = mph_df['pulse_heights'] + y = mph_df['MPH'] x_alt = mph_df['cum_total_time'] ax1.scatter(x, y) ax1.set_xlabel('FOV cumulative count') @@ -159,7 +148,7 @@ def visualize_mph(mph_df, regression: bool, save_dir=None): if regression: # plot with regression line x2 = np.array(mph_df['cum_total_count']) - y2 = np.array(mph_df['pulse_heights']) + y2 = np.array(mph_df['MPH']) m, b = np.polyfit(x2, y2, 1) ax1.plot(x2, m * x2 + b) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 94309a78..df93f981 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -101,9 +101,12 @@ def combine_mph_metrics(): data2.to_csv(os.path.join(bin_file_path, 'fov-2-scan-1-pulse_height.csv'), index=False) combined_data = pd.DataFrame({ - 'pulse_heights': [2222, 3800], - 'cum_total_count': [72060, 146859], - 'cum_total_time': [512, 1024], + 'fov': ['fov-1-scan-1', 'fov-2-scan-1'], + 'MPH': [2222, 3800], + 'total_count': [72060, 74799], + 'time': [512, 512], + 'cum_total_count': [72060, 146859], + 'cum_total_time': [512, 1024], }, index=[0, 1]) # test successful data retrieval and csv output @@ -112,7 +115,6 @@ def combine_mph_metrics(): csv_data = pd.read_csv(csv_path) assert os.path.exists(csv_path) assert csv_data.equals(combined_data) - assert mph_data.equals(combined_data) os.remove(csv_path) os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) @@ -122,7 +124,7 @@ def combine_mph_metrics(): def visualize_mph(): bad_path = os.path.join("data", "not-a-folder") mph_data = pd.DataFrame({ - 'pulse_heights': [2222, 3800], + 'MPH': [2222, 3800], 'cum_total_count': [72060, 146859], 'cum_total_time': [512, 1024], }, index=[0, 1]) From ee4da480d1ee300a24e95eab53e3a3f0d60ad3cd Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 31 May 2022 16:46:10 -0700 Subject: [PATCH 42/94] csv_dir to save fov csvs to, remove bin_file_path arg for combine_mph --- templates/example_MPH_plots.ipynb | 10 ++++---- toffy/mph_comp.py | 28 +++++++++++---------- toffy/mph_comp_test.py | 42 +++++++++++++++---------------- 3 files changed, 41 insertions(+), 39 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index c06fa6d9..dfc71612 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -77,7 +77,7 @@ "# saves individual .csv files to bin_file_path\n", "for fov in fovs:\n", " if not os.path.exists(os.path.join(bin_file_path, '%s-pulse_height.csv' % fov)):\n", - " mph_comp.compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop)" + " mph_comp.compute_mph_metrics(bin_file_path, mph_dir, fov, target, mass_start, mass_stop)" ] }, { @@ -90,19 +90,19 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], "source": [ "# prior to generating the graphs, need to combine the data for each FOV into one combined .csv\n", "# saves directly to mph_dir\n", - "mph_comp.combine_mph_metrics(bin_file_path, mph_dir)" + "mph_comp.combine_mph_metrics(mph_dir)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index c7144961..9f30ea5a 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -39,10 +39,11 @@ def get_estimated_time(bin_file_path, fov): return estimated_time -def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop): +def compute_mph_metrics(bin_file_path, csv_dir, fov, target, mass_start, mass_stop): """Retrieves FOV total counts, pulse heights, & estimated time for all fovs in the directory Args: bin_file_path (str): path to the FOV bin and json files + csv_dir (str): path to output csv to fov (string): name of fov bin file without the extension target (str): channel to use mass_start (float): beginning of mass integration range @@ -52,6 +53,7 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop): # path validation io_utils.validate_paths(bin_file_path) + io_utils.validate_paths(csv_dir) # retrieve the data from bin file and output to individual csv pulse_height_file = fov + '-pulse_height.csv' @@ -75,15 +77,14 @@ def compute_mph_metrics(bin_file_path, fov, target, mass_start, mass_stop): 'time': [time]}) # saves individual .csv files to bin_file_path - if not os.path.exists(os.path.join(bin_file_path, pulse_height_file)): - out_df.to_csv(os.path.join(bin_file_path, pulse_height_file), index=False) + if not os.path.exists(os.path.join(csv_dir, pulse_height_file)): + out_df.to_csv(os.path.join(csv_dir, pulse_height_file), index=False) -def combine_mph_metrics(bin_file_path, output_dir, return_data=False): +def combine_mph_metrics(csv_dir, return_data=False): """Combines data from individual csvs into one Args: - bin_file_path (str): path to the FOV bin and json files - output_dir (str): path to output csv to + csv_dir (str): path where FOV csvs are stored return_data (bool): whether to return dataframe with mph metrics, default False Returns: @@ -91,27 +92,28 @@ def combine_mph_metrics(bin_file_path, output_dir, return_data=False): """ # path validation checks - io_utils.validate_paths(bin_file_path) - io_utils.validate_paths(output_dir) + io_utils.validate_paths(csv_dir) # list bin files in directory - fov_bins = io_utils.list_files(bin_file_path, ".bin") - fov_bins = io_utils.remove_file_extensions(fov_bins) + fov_files = io_utils.list_files(csv_dir, "-pulse_height.csv") + # for each csv retrieve mph values combined_rows = [] - for i, file in enumerate(fov_bins): - combined_rows.append(pd.read_csv(os.path.join(bin_file_path, file + '-pulse_height.csv'))) + for i, file in enumerate(fov_files): + combined_rows.append(pd.read_csv(os.path.join(csv_dir, file))) + # calculate cumulative sums of total counts and time combined_df = pd.concat(combined_rows) combined_df['cum_total_count'] = combined_df['total_count'].cumsum() combined_df['cum_total_time'] = combined_df['time'].cumsum() # save csv to output_dir - file_path = os.path.join(output_dir, 'total_count_vs_mph_data.csv') + file_path = os.path.join(csv_dir, 'total_count_vs_mph_data.csv') if os.path.exists(file_path): os.remove(file_path) combined_df.to_csv(file_path, index=False) + # return data if return_data: return combined_df diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index df93f981..082c4fd4 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -44,18 +44,22 @@ def compute_mph_metrics(): # bad directory path should raise an error bad_path = os.path.join("data", "not-a-folder") with pytest.raises(ValueError): - mph.compute_mph_metrics(bad_path, fov_name, target_name, start_mass, stop_mass) + mph.compute_mph_metrics(bad_path, bin_file_path, fov_name, + target_name, start_mass, stop_mass) # invalid fov name should raise an error with pytest.raises(FileNotFoundError): - mph.compute_mph_metrics(bin_file_path, "not-a-fov", target_name, start_mass, stop_mass) + mph.compute_mph_metrics(bin_file_path, bin_file_path, "not-a-fov", + target_name, start_mass, stop_mass) # invalid target name should raise an error with pytest.raises(ValueError, match="target name is invalid"): - mph.compute_mph_metrics(bin_file_path, fov_name, "not-a-target", start_mass, stop_mass) + mph.compute_mph_metrics(bin_file_path, bin_file_path, fov_name, + "not-a-target", start_mass, stop_mass) # test successful data retrieval and csv output - mph.compute_mph_metrics(bin_file_path, fov_name, target_name, start_mass, stop_mass) + mph.compute_mph_metrics(bin_file_path, bin_file_path, fov_name, + target_name, start_mass, stop_mass) csv_path = os.path.join(bin_file_path, fov_name + '-pulse_height.csv') assert os.path.exists(csv_path) @@ -69,20 +73,16 @@ def compute_mph_metrics(): csv_data = pd.read_csv(csv_path) assert csv_data.equals(mph_data) - os.remove('fov-1-scan-1-pulse_height.csv') + os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) def combine_mph_metrics(): - bin_file_path = os.path.join("data", "tissue") + csv_path = os.path.join("data", "tissue") bad_path = os.path.join("data", "not-a-folder") - # bad bin file directory path should raise an error - with pytest.raises(ValueError): - mph.combine_mph_metrics(bad_path, bin_file_path) - - # bad output directory path should raise an error + # bad directory path should raise an error with pytest.raises(ValueError): - mph.combine_mph_metrics(bin_file_path, bad_path) + mph.combine_mph_metrics(bad_path) data1 = pd.DataFrame([{ 'fov': 'fov-1-scan-1', @@ -97,8 +97,8 @@ def combine_mph_metrics(): 'time': 512, }]) - data1.to_csv(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv'), index=False) - data2.to_csv(os.path.join(bin_file_path, 'fov-2-scan-1-pulse_height.csv'), index=False) + data1.to_csv(os.path.join(csv_path, 'fov-1-scan-1-pulse_height.csv'), index=False) + data2.to_csv(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv'), index=False) combined_data = pd.DataFrame({ 'fov': ['fov-1-scan-1', 'fov-2-scan-1'], @@ -110,15 +110,15 @@ def combine_mph_metrics(): }, index=[0, 1]) # test successful data retrieval and csv output - mph_data = mph.combine_mph_metrics(bin_file_path, bin_file_path, return_data=True) - csv_path = os.path.join(bin_file_path, 'total_count_vs_mph_data.csv') - csv_data = pd.read_csv(csv_path) - assert os.path.exists(csv_path) + mph_data = mph.combine_mph_metrics(csv_path, return_data=True) + combined_csv_path = os.path.join(csv_path, 'total_count_vs_mph_data.csv') + csv_data = pd.read_csv(combined_csv_path) + assert os.path.exists(combined_csv_path) assert csv_data.equals(combined_data) - os.remove(csv_path) - os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) - os.remove(os.path.join(bin_file_path, 'fov-2-scan-1-pulse_height.csv')) + os.remove(combined_csv_path) + os.remove(os.path.join(csv_path, 'fov-1-scan-1-pulse_height.csv')) + os.remove(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv')) def visualize_mph(): From 45b50d874b4423696be9d249e1c14228a186ecdd Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 31 May 2022 16:55:58 -0700 Subject: [PATCH 43/94] add watcher callbacks --- toffy/watcher_callbacks.py | 44 +++++++++++++++++++++++++++++++++++++- 1 file changed, 43 insertions(+), 1 deletion(-) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index bca08a81..e64d1e3b 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -13,11 +13,14 @@ from toffy.qc_comp import compute_qc_metrics_direct, combine_qc_metrics, visualize_qc_metrics +from toffy.mph_comp import compute_mph_metrics, combine_mph_metrics, visualize_mph + from toffy.settings import QC_COLUMNS, QC_SUFFIXES RUN_PREREQUISITES = { 'plot_qc_metrics': set(['generate_qc']), + 'plot_mph_metrics': set(['generate_mph']) } @@ -51,6 +54,21 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): qc_df = pd.read_csv(os.path.join(qc_out_dir, 'combined_%s.csv' % ms)) visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) + def plot_mph_metrics(self, mph_out_dir, **kwargs): + """Plots qc metrics generated by the `generate_qc` callback + + Args: + mph_out_dir (str): directory containing qc metric csv + + """ + + # filter kwargs + valid_kwargs = ['regression', 'save_dir'] + viz_kwargs = {k: v for k, v in kwargs.items() if k in valid_kwargs} + + mph_df = combine_mph_metrics(mph_out_dir, return_data=True) + visualize_mph(mph_df, **viz_kwargs) + @dataclass class FovCallbacks: @@ -148,9 +166,33 @@ def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): for metric_name, data in metric_data.items(): data.to_csv(os.path.join(qc_out_dir, metric_name), index=False) + def generate_mph(self, mph_output_dir, panel: pd.DataFrame = None): + """Generates mph metrics from given panel, and saves output to provided directory + + Args: + mph_output_dir (str): where to output mph csvs to + panel (pd.DataFrame): + Target mass integration ranges + + """ + + if self.__fov_data is None: + if panel is None: + raise ValueError('Must provide panel if fov data is not already generated...') + self._generate_fov_data(panel) + + compute_mph_metrics( + bin_file_path=self.run_folder, + output_dir=mph_output_dir, + fov=self.point_name, + target=self.__panel['Target'], + mass_start=self.__panel['Start'], + mass_stop=self.__panel['Stop'] + ) + def build_fov_callback(*args, **kwargs): - """Assembles callbacks to be run for each transfered FoV + """Assembles callbacks to be run for each transferred FoV Args: *args (List[str]): From 7d01b370c334002f0cfb739caf23d340a9ef855d Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 31 May 2022 17:13:50 -0700 Subject: [PATCH 44/94] update requirements.txt --- requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 06832808..efa3962d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,4 +4,5 @@ jupyter>=1.0.0,<2 jupyter_contrib_nbextensions>=0.5.1,<1 jupyterlab>=3.1.5,<4 numpy>=1.22,<2 -watchdog>=2.1.6,<3 \ No newline at end of file +watchdog>=2.1.6,<3 +traitlets==5.2.0 \ No newline at end of file From b430c24c0799d54619d456b114ad31f250eae6f6 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 1 Jun 2022 20:44:53 -0700 Subject: [PATCH 45/94] add test prefix --- toffy/mph_comp_test.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 082c4fd4..7b2d7624 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -34,7 +34,7 @@ def get_estimated_time(): assert mph.get_estimated_time(good_path, good_fov) == 512 -def compute_mph_metrics(): +def test_compute_mph_metrics(): bin_file_path = os.path.join("data", "tissue") fov_name = 'fov-1-scan-1' target_name = 'CD8' @@ -76,7 +76,7 @@ def compute_mph_metrics(): os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) -def combine_mph_metrics(): +def test_combine_mph_metrics(): csv_path = os.path.join("data", "tissue") bad_path = os.path.join("data", "not-a-folder") @@ -121,7 +121,7 @@ def combine_mph_metrics(): os.remove(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv')) -def visualize_mph(): +def test_visualize_mph(): bad_path = os.path.join("data", "not-a-folder") mph_data = pd.DataFrame({ 'MPH': [2222, 3800], From 3ace025c0b58ed94c10434cfedbf3ec47beeb411 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 1 Jun 2022 23:30:28 -0700 Subject: [PATCH 46/94] fix path issues --- toffy/mph_comp_test.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 7b2d7624..236414b6 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -7,11 +7,11 @@ from toffy import mph_comp as mph -def get_estimated_time(): - bad_path = os.path.join("data", "not-a-folder") +def test_get_estimated_time(): + bad_path = os.path.join("..", "data", "not-a-folder") bad_fov = "not-a-fov" - good_path = os.path.join("data", "tissue") + good_path = os.path.join("..", "data", "tissue") good_fov = 'fov-1-scan-1' # bad directory path should raise an error @@ -35,14 +35,14 @@ def get_estimated_time(): def test_compute_mph_metrics(): - bin_file_path = os.path.join("data", "tissue") + bin_file_path = os.path.join("..", "data", "tissue") fov_name = 'fov-1-scan-1' target_name = 'CD8' start_mass = -0.3 stop_mass = 0.0 # bad directory path should raise an error - bad_path = os.path.join("data", "not-a-folder") + bad_path = os.path.join("..", "data", "not-a-folder") with pytest.raises(ValueError): mph.compute_mph_metrics(bad_path, bin_file_path, fov_name, target_name, start_mass, stop_mass) @@ -77,8 +77,8 @@ def test_compute_mph_metrics(): def test_combine_mph_metrics(): - csv_path = os.path.join("data", "tissue") - bad_path = os.path.join("data", "not-a-folder") + csv_path = os.path.join("..", "data", "tissue") + bad_path = os.path.join("..", "data", "not-a-folder") # bad directory path should raise an error with pytest.raises(ValueError): @@ -122,7 +122,7 @@ def test_combine_mph_metrics(): def test_visualize_mph(): - bad_path = os.path.join("data", "not-a-folder") + bad_path = os.path.join("..", "data", "not-a-folder") mph_data = pd.DataFrame({ 'MPH': [2222, 3800], 'cum_total_count': [72060, 146859], From adbd0ff6de8b54eb35d2f5aa688bcd919a43f2dd Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 2 Jun 2022 00:00:16 -0700 Subject: [PATCH 47/94] really fix the path issues this time --- toffy/mph_comp_test.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 236414b6..410352a1 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -4,14 +4,16 @@ import tempfile import json +from pathlib import Path + from toffy import mph_comp as mph def test_get_estimated_time(): - bad_path = os.path.join("..", "data", "not-a-folder") + bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") bad_fov = "not-a-fov" - good_path = os.path.join("..", "data", "tissue") + good_path = os.path.join(Path(__file__).parent, "data", "tissue") good_fov = 'fov-1-scan-1' # bad directory path should raise an error @@ -35,14 +37,14 @@ def test_get_estimated_time(): def test_compute_mph_metrics(): - bin_file_path = os.path.join("..", "data", "tissue") + bin_file_path = os.path.join(Path(__file__).parent, "data", "tissue") fov_name = 'fov-1-scan-1' target_name = 'CD8' start_mass = -0.3 stop_mass = 0.0 # bad directory path should raise an error - bad_path = os.path.join("..", "data", "not-a-folder") + bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") with pytest.raises(ValueError): mph.compute_mph_metrics(bad_path, bin_file_path, fov_name, target_name, start_mass, stop_mass) @@ -77,8 +79,8 @@ def test_compute_mph_metrics(): def test_combine_mph_metrics(): - csv_path = os.path.join("..", "data", "tissue") - bad_path = os.path.join("..", "data", "not-a-folder") + csv_path = os.path.join(Path(__file__).parent, "data", "tissue") + bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") # bad directory path should raise an error with pytest.raises(ValueError): @@ -122,7 +124,7 @@ def test_combine_mph_metrics(): def test_visualize_mph(): - bad_path = os.path.join("..", "data", "not-a-folder") + bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") mph_data = pd.DataFrame({ 'MPH': [2222, 3800], 'cum_total_count': [72060, 146859], From e1ab03db0556a1ca87ddc80995ff9d791fddc492 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 2 Jun 2022 00:25:42 -0700 Subject: [PATCH 48/94] fix json test error --- toffy/mph_comp_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 410352a1..dba1c17b 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -25,7 +25,7 @@ def test_get_estimated_time(): mph.get_estimated_time(good_path, bad_fov) # bad FOV json file data should raise an error, no frameSize or dwellTimeMillis keys - bad_data = {'fov': {'not_frameSize': 0, 'not_dwellTimeMillis': 0}} + bad_data = {"fov": {"not_frameSize": 0, "not_dwellTimeMillis": 0}} temp_json = tempfile.NamedTemporaryFile(mode="w", suffix='fov_name.json', delete=False) temp_json.write(json.dumps(bad_data)) temp_dir = tempfile.gettempdir() From b43a0a8d5ae0b8076c3d29872684e335d282ad86 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 2 Jun 2022 09:57:43 -0700 Subject: [PATCH 49/94] really fix json test error --- toffy/mph_comp_test.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index dba1c17b..c8541ce4 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -27,10 +27,10 @@ def test_get_estimated_time(): # bad FOV json file data should raise an error, no frameSize or dwellTimeMillis keys bad_data = {"fov": {"not_frameSize": 0, "not_dwellTimeMillis": 0}} temp_json = tempfile.NamedTemporaryFile(mode="w", suffix='fov_name.json', delete=False) - temp_json.write(json.dumps(bad_data)) - temp_dir = tempfile.gettempdir() + json.dump(bad_data, temp_json) + json_dir = tempfile.gettempdir() with pytest.raises(KeyError, match="missing one of the necessary keys"): - mph.get_estimated_time(temp_dir, 'fov_name') + mph.get_estimated_time(json_dir, 'fov_name') # test successful time data retrieval assert mph.get_estimated_time(good_path, good_fov) == 512 From 07955bc7f54fe6c6d697c0c4e7a4d41682e96f8b Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 6 Jun 2022 12:57:42 -0700 Subject: [PATCH 50/94] use TemporaryDirectory instead of NamedTemporaryFile --- toffy/mph_comp_test.py | 111 ++++++++++++++++++------------------- toffy/watcher_callbacks.py | 3 +- 2 files changed, 55 insertions(+), 59 deletions(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index c8541ce4..2c28f0af 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -26,11 +26,11 @@ def test_get_estimated_time(): # bad FOV json file data should raise an error, no frameSize or dwellTimeMillis keys bad_data = {"fov": {"not_frameSize": 0, "not_dwellTimeMillis": 0}} - temp_json = tempfile.NamedTemporaryFile(mode="w", suffix='fov_name.json', delete=False) - json.dump(bad_data, temp_json) - json_dir = tempfile.gettempdir() - with pytest.raises(KeyError, match="missing one of the necessary keys"): - mph.get_estimated_time(json_dir, 'fov_name') + with tempfile.TemporaryDirectory() as tmpdir: + with open(os.path.join(tmpdir, 'fov_name.json'), 'w') as f: + json.dump(bad_data, f) + with pytest.raises(KeyError, match="missing one of the necessary keys"): + mph.get_estimated_time(tmpdir, 'fov_name') # test successful time data retrieval assert mph.get_estimated_time(good_path, good_fov) == 512 @@ -43,43 +43,41 @@ def test_compute_mph_metrics(): start_mass = -0.3 stop_mass = 0.0 - # bad directory path should raise an error - bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") - with pytest.raises(ValueError): - mph.compute_mph_metrics(bad_path, bin_file_path, fov_name, + with tempfile.TemporaryDirectory() as tmpdir: + # bad directory path should raise an error + bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") + with pytest.raises(ValueError): + mph.compute_mph_metrics(bad_path, tmpdir, fov_name, + target_name, start_mass, stop_mass) + + # invalid fov name should raise an error + with pytest.raises(FileNotFoundError): + mph.compute_mph_metrics(bin_file_path, tmpdir, "not-a-fov", + target_name, start_mass, stop_mass) + + # invalid target name should raise an error + with pytest.raises(ValueError, match="target name is invalid"): + mph.compute_mph_metrics(bin_file_path, tmpdir, fov_name, + "not-a-target", start_mass, stop_mass) + + # test successful data retrieval and csv output + mph.compute_mph_metrics(bin_file_path, tmpdir, fov_name, target_name, start_mass, stop_mass) + csv_path = os.path.join(tmpdir, fov_name + '-pulse_height.csv') + assert os.path.exists(csv_path) - # invalid fov name should raise an error - with pytest.raises(FileNotFoundError): - mph.compute_mph_metrics(bin_file_path, bin_file_path, "not-a-fov", - target_name, start_mass, stop_mass) - - # invalid target name should raise an error - with pytest.raises(ValueError, match="target name is invalid"): - mph.compute_mph_metrics(bin_file_path, bin_file_path, fov_name, - "not-a-target", start_mass, stop_mass) - - # test successful data retrieval and csv output - mph.compute_mph_metrics(bin_file_path, bin_file_path, fov_name, - target_name, start_mass, stop_mass) - csv_path = os.path.join(bin_file_path, fov_name + '-pulse_height.csv') - assert os.path.exists(csv_path) - - # check the csv data is correct - mph_data = pd.DataFrame([{ - 'fov': fov_name, - 'MPH': 2222, - 'total_count': 72060, - 'time': 512, - }]) - csv_data = pd.read_csv(csv_path) - assert csv_data.equals(mph_data) - - os.remove(os.path.join(bin_file_path, 'fov-1-scan-1-pulse_height.csv')) + # check the csv data is correct + mph_data = pd.DataFrame([{ + 'fov': fov_name, + 'MPH': 2222, + 'total_count': 72060, + 'time': 512, + }]) + csv_data = pd.read_csv(csv_path) + assert csv_data.equals(mph_data) def test_combine_mph_metrics(): - csv_path = os.path.join(Path(__file__).parent, "data", "tissue") bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") # bad directory path should raise an error @@ -99,28 +97,27 @@ def test_combine_mph_metrics(): 'time': 512, }]) - data1.to_csv(os.path.join(csv_path, 'fov-1-scan-1-pulse_height.csv'), index=False) - data2.to_csv(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv'), index=False) - - combined_data = pd.DataFrame({ - 'fov': ['fov-1-scan-1', 'fov-2-scan-1'], - 'MPH': [2222, 3800], - 'total_count': [72060, 74799], - 'time': [512, 512], - 'cum_total_count': [72060, 146859], - 'cum_total_time': [512, 1024], - }, index=[0, 1]) + with tempfile.TemporaryDirectory() as tmpdir: + csv_path = tmpdir - # test successful data retrieval and csv output - mph_data = mph.combine_mph_metrics(csv_path, return_data=True) - combined_csv_path = os.path.join(csv_path, 'total_count_vs_mph_data.csv') - csv_data = pd.read_csv(combined_csv_path) - assert os.path.exists(combined_csv_path) - assert csv_data.equals(combined_data) + data1.to_csv(os.path.join(csv_path, 'fov-1-scan-1-pulse_height.csv'), index=False) + data2.to_csv(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv'), index=False) - os.remove(combined_csv_path) - os.remove(os.path.join(csv_path, 'fov-1-scan-1-pulse_height.csv')) - os.remove(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv')) + combined_data = pd.DataFrame({ + 'fov': ['fov-1-scan-1', 'fov-2-scan-1'], + 'MPH': [2222, 3800], + 'total_count': [72060, 74799], + 'time': [512, 512], + 'cum_total_count': [72060, 146859], + 'cum_total_time': [512, 1024], + }, index=[0, 1]) + + # test successful data retrieval and csv output + mph.combine_mph_metrics(csv_path) + combined_csv_path = os.path.join(csv_path, 'total_count_vs_mph_data.csv') + csv_data = pd.read_csv(combined_csv_path) + assert os.path.exists(combined_csv_path) + assert csv_data.equals(combined_data) def test_visualize_mph(): diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index e64d1e3b..71d8d354 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -55,11 +55,10 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) def plot_mph_metrics(self, mph_out_dir, **kwargs): - """Plots qc metrics generated by the `generate_qc` callback + """Plots mph metrics generated by the `generate_mph` callback Args: mph_out_dir (str): directory containing qc metric csv - """ # filter kwargs From 13885ca64d1ba78ba962b6d205ac3b462de0229f Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 6 Jun 2022 13:24:53 -0700 Subject: [PATCH 51/94] fix watcher argument names --- toffy/watcher_callbacks.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 71d8d354..f1e03d06 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -54,18 +54,24 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): qc_df = pd.read_csv(os.path.join(qc_out_dir, 'combined_%s.csv' % ms)) visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) - def plot_mph_metrics(self, mph_out_dir, **kwargs): + def plot_mph_metrics(self, mph_output_dir, **kwargs): """Plots mph metrics generated by the `generate_mph` callback Args: - mph_out_dir (str): directory containing qc metric csv + mph_output_dir (str): directory containing qc metric csv + **kwargs (Dict[str, Any]): + Additional arguments for `toffy.mph_comp.visualize_mph`. + Accepted kwargs are + + - regression + - save_dir """ # filter kwargs valid_kwargs = ['regression', 'save_dir'] viz_kwargs = {k: v for k, v in kwargs.items() if k in valid_kwargs} - mph_df = combine_mph_metrics(mph_out_dir, return_data=True) + mph_df = combine_mph_metrics(mph_output_dir, return_data=True) visualize_mph(mph_df, **viz_kwargs) @@ -182,7 +188,7 @@ def generate_mph(self, mph_output_dir, panel: pd.DataFrame = None): compute_mph_metrics( bin_file_path=self.run_folder, - output_dir=mph_output_dir, + csv_dir=mph_output_dir, fov=self.point_name, target=self.__panel['Target'], mass_start=self.__panel['Start'], From ca59fca965d990ba2585761880a7803c8bad86ee Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 6 Jun 2022 18:11:48 -0700 Subject: [PATCH 52/94] argument name change to bin_file_dir and comments --- templates/example_MPH_plots.ipynb | 16 ++++++++-------- toffy/mph_comp.py | 30 ++++++++++++++---------------- 2 files changed, 22 insertions(+), 24 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index dfc71612..bf4e7b03 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -49,7 +49,7 @@ "source": [ "# set up directories for current run\n", "base_dir = os.path.join('..', 'toffy', 'data')\n", - "bin_file_path = os.path.join(base_dir, 'tissue')\n", + "bin_file_dir = os.path.join(base_dir, 'tissue')\n", "mph_dir = os.path.join(base_dir, 'tissue_mph')\n", "#mph_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\qc_metrics', 'tissue')\n", "\n", @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -71,13 +71,13 @@ "mass_stop = 0\n", "\n", "# retrieve all the fov names from bin_file_path\n", - "fovs = io_utils.remove_file_extensions(io_utils.list_files(bin_file_path, substrs='.bin'))\n", + "fovs = io_utils.remove_file_extensions(io_utils.list_files(bin_file_dir, substrs='.bin'))\n", "\n", "# retrieve the total counts and compute pulse heights for each FOV run file\n", "# saves individual .csv files to bin_file_path\n", "for fov in fovs:\n", - " if not os.path.exists(os.path.join(bin_file_path, '%s-pulse_height.csv' % fov)):\n", - " mph_comp.compute_mph_metrics(bin_file_path, mph_dir, fov, target, mass_start, mass_stop)" + " if not os.path.exists(os.path.join(bin_file_dir, '%s-pulse_height.csv' % fov)):\n", + " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, target, mass_start, mass_stop)" ] }, { @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 9f30ea5a..5034784e 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -8,25 +8,25 @@ from ark.utils import io_utils -def get_estimated_time(bin_file_path, fov): +def get_estimated_time(bin_file_dir, fov): """Retrieve run time data for each fov json file Args: - bin_file_path (str): path to the FOV bin and json files + bin_file_dir (str): path to the FOV bin and json files fov (str): name of fov to get estimated time for Returns: fov_time (int): estimated run time for the given fov """ # path validation - io_utils.validate_paths(bin_file_path) + io_utils.validate_paths(bin_file_dir) # get fov json file in bin_file_path - json_file = io_utils.list_files(bin_file_path, fov+".json") + json_file = io_utils.list_files(bin_file_dir, fov+".json") if len(json_file) == 0: raise FileNotFoundError(f"The FOV name supplied doesn't have a JSON file: {fov}") # retrieve estimated time (frame dimensions x pixel dwell time) - with open(os.path.join(bin_file_path, json_file[0])) as file: + with open(os.path.join(bin_file_dir, json_file[0])) as file: run_metadata = json.load(file) try: size = run_metadata.get('frameSize') @@ -39,10 +39,10 @@ def get_estimated_time(bin_file_path, fov): return estimated_time -def compute_mph_metrics(bin_file_path, csv_dir, fov, target, mass_start, mass_stop): - """Retrieves FOV total counts, pulse heights, & estimated time for all fovs in the directory +def compute_mph_metrics(bin_file_dir, csv_dir, fov, target, mass_start, mass_stop): + """Retrieves total counts, pulse heights, & estimated time for a given FOV Args: - bin_file_path (str): path to the FOV bin and json files + bin_file_dir (str): path to the FOV bin and json files csv_dir (str): path to output csv to fov (string): name of fov bin file without the extension target (str): channel to use @@ -52,23 +52,23 @@ def compute_mph_metrics(bin_file_path, csv_dir, fov, target, mass_start, mass_st """ # path validation - io_utils.validate_paths(bin_file_path) + io_utils.validate_paths(bin_file_dir) io_utils.validate_paths(csv_dir) # retrieve the data from bin file and output to individual csv pulse_height_file = fov + '-pulse_height.csv' try: - median = bin_files.get_median_pulse_height(bin_file_path, fov, + median = bin_files.get_median_pulse_height(bin_file_dir, fov, target, (mass_start, mass_stop)) - count_dict = bin_files.get_total_counts(bin_file_path, [fov]) + count_dict = bin_files.get_total_counts(bin_file_dir, [fov]) except FileNotFoundError: raise FileNotFoundError(f"The FOV name supplied doesn't have a JSON file: {fov}") except ValueError: raise ValueError(f"The target name is invalid: {target}") count = count_dict[fov] - time = get_estimated_time(bin_file_path, fov) + time = get_estimated_time(bin_file_dir, fov) out_df = pd.DataFrame({ 'fov': [fov], @@ -94,10 +94,8 @@ def combine_mph_metrics(csv_dir, return_data=False): # path validation checks io_utils.validate_paths(csv_dir) - # list bin files in directory - fov_files = io_utils.list_files(csv_dir, "-pulse_height.csv") - # for each csv retrieve mph values + fov_files = io_utils.list_files(csv_dir, "-pulse_height.csv") combined_rows = [] for i, file in enumerate(fov_files): combined_rows.append(pd.read_csv(os.path.join(csv_dir, file))) @@ -118,7 +116,7 @@ def combine_mph_metrics(csv_dir, return_data=False): return combined_df -def visualize_mph(mph_df, regression: bool, save_dir=None): +def visualize_mph(mph_df, regression: bool, save_dir): """Create a scatterplot visualizing median pulse heights by FOV cumulative count Args: mph_df (pd.DataFrame): data detailing total counts and pulse heights From 82f863975e92e081100af5f831851342bf825147 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 6 Jun 2022 18:33:24 -0700 Subject: [PATCH 53/94] remove excess path validations --- toffy/mph_comp.py | 16 +++++----------- toffy/mph_comp_test.py | 11 +---------- 2 files changed, 6 insertions(+), 21 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 5034784e..1a69989f 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -51,10 +51,6 @@ def compute_mph_metrics(bin_file_dir, csv_dir, fov, target, mass_start, mass_sto """ - # path validation - io_utils.validate_paths(bin_file_dir) - io_utils.validate_paths(csv_dir) - # retrieve the data from bin file and output to individual csv pulse_height_file = fov + '-pulse_height.csv' @@ -77,8 +73,7 @@ def compute_mph_metrics(bin_file_dir, csv_dir, fov, target, mass_start, mass_sto 'time': [time]}) # saves individual .csv files to bin_file_path - if not os.path.exists(os.path.join(csv_dir, pulse_height_file)): - out_df.to_csv(os.path.join(csv_dir, pulse_height_file), index=False) + out_df.to_csv(os.path.join(csv_dir, pulse_height_file), index=False) def combine_mph_metrics(csv_dir, return_data=False): @@ -153,8 +148,7 @@ def visualize_mph(mph_df, regression: bool, save_dir): ax1.plot(x2, m * x2 + b) # save figure - if save_dir is not None: - file_path = os.path.join(save_dir, 'fov_vs_mph.jpg') - if os.path.exists(file_path): - os.remove(file_path) - plt.savefig(file_path) + file_path = os.path.join(save_dir, 'fov_vs_mph.jpg') + if os.path.exists(file_path): + os.remove(file_path) + plt.savefig(file_path) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 2c28f0af..a1842e3b 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -44,11 +44,6 @@ def test_compute_mph_metrics(): stop_mass = 0.0 with tempfile.TemporaryDirectory() as tmpdir: - # bad directory path should raise an error - bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") - with pytest.raises(ValueError): - mph.compute_mph_metrics(bad_path, tmpdir, fov_name, - target_name, start_mass, stop_mass) # invalid fov name should raise an error with pytest.raises(FileNotFoundError): @@ -133,10 +128,6 @@ def test_visualize_mph(): mph.visualize_mph(mph_data, False, bad_path) with tempfile.TemporaryDirectory() as temp_dir: - # test without saving - mph.visualize_mph(mph_data, True) - assert not os.path.exists(os.path.join(temp_dir, 'fov_vs_mph.jpg')) - - # test with saving + # test for saving to directory mph.visualize_mph(mph_data, True, save_dir=temp_dir) assert os.path.exists(os.path.join(temp_dir, 'fov_vs_mph.jpg')) From 4e3aa1091308d194cb1ec7fdf0a648d1ba21db22 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 6 Jun 2022 19:44:20 -0700 Subject: [PATCH 54/94] tims axis from ms to hours --- templates/example_MPH_plots.ipynb | 12 ++++++------ toffy/mph_comp.py | 5 ++++- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index bf4e7b03..57cd7c49 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -102,13 +102,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -127,13 +127,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 1a69989f..768a52fc 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -135,8 +135,11 @@ def visualize_mph(mph_df, regression: bool, save_dir): ax1.scatter(x, y) ax1.set_xlabel('FOV cumulative count') ax1.set_ylabel('median pulse height') - ax2.set_xlabel('estimated time (ms)') ax2.scatter(x_alt, y) + ticks = ax2.get_xticks().tolist() + new_ticks = [round(tick/3600, 2) for tick in ticks] + ax2.set_xticklabels(new_ticks) + ax2.set_xlabel('estimated time (hours)') plt.gcf().set_size_inches(18.5, 10.5) # plot regression line From 277294b9c72bfc022f1f84906a195d225a96f595 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 6 Jun 2022 22:23:59 -0700 Subject: [PATCH 55/94] function for sample mph data --- toffy/mph_comp_test.py | 42 ++++++++++++++++-------------------------- 1 file changed, 16 insertions(+), 26 deletions(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index a1842e3b..6fdca1ac 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -9,6 +9,16 @@ from toffy import mph_comp as mph +def create_sample_mph_data(fov, mph_value, total_count, time): + data = pd.DataFrame([{ + 'fov': fov, + 'MPH': mph_value, + 'total_count': total_count, + 'time': time, + }]) + return data + + def test_get_estimated_time(): bad_path = os.path.join(Path(__file__).parent, "data", "not-a-folder") bad_fov = "not-a-fov" @@ -62,12 +72,7 @@ def test_compute_mph_metrics(): assert os.path.exists(csv_path) # check the csv data is correct - mph_data = pd.DataFrame([{ - 'fov': fov_name, - 'MPH': 2222, - 'total_count': 72060, - 'time': 512, - }]) + mph_data = create_sample_mph_data(fov_name, 2222, 72060, 512) csv_data = pd.read_csv(csv_path) assert csv_data.equals(mph_data) @@ -79,18 +84,8 @@ def test_combine_mph_metrics(): with pytest.raises(ValueError): mph.combine_mph_metrics(bad_path) - data1 = pd.DataFrame([{ - 'fov': 'fov-1-scan-1', - 'MPH': 2222, - 'total_count': 72060, - 'time': 512, - }]) - data2 = pd.DataFrame([{ - 'fov': 'fov-2-scan-1', - 'MPH': 3800, - 'total_count': 74799, - 'time': 512, - }]) + data1 = create_sample_mph_data(fov='fov-1', mph_value=1000, total_count=50000, time=500) + data2 = create_sample_mph_data(fov='fov-2', mph_value=2000, total_count=70000, time=500) with tempfile.TemporaryDirectory() as tmpdir: csv_path = tmpdir @@ -98,14 +93,9 @@ def test_combine_mph_metrics(): data1.to_csv(os.path.join(csv_path, 'fov-1-scan-1-pulse_height.csv'), index=False) data2.to_csv(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv'), index=False) - combined_data = pd.DataFrame({ - 'fov': ['fov-1-scan-1', 'fov-2-scan-1'], - 'MPH': [2222, 3800], - 'total_count': [72060, 74799], - 'time': [512, 512], - 'cum_total_count': [72060, 146859], - 'cum_total_time': [512, 1024], - }, index=[0, 1]) + combined_data = pd.concat([data1, data2], axis=0, ignore_index=True) + combined_data['cum_total_count'] = [50000, 120000] + combined_data['cum_total_time'] = [500, 1000] # test successful data retrieval and csv output mph.combine_mph_metrics(csv_path) From 19068d4dc251f66a982128a7cedf54e999e935ba Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 7 Jun 2022 22:25:54 -0700 Subject: [PATCH 56/94] watcher tests --- toffy/test_utils.py | 27 ++++++++++++++++++++++++--- toffy/watcher_callbacks.py | 16 +++++++++++----- toffy/watcher_callbacks_test.py | 8 +++++++- 3 files changed, 42 insertions(+), 9 deletions(-) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index ceef5a4e..b3148822 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -92,8 +92,8 @@ def generate_sample_fovs_list(fov_coords, fov_names, fov_sizes): # generation parameters for the extraction/qc callback build # this should be limited to the panel, foldernames, and kwargs -FOV_CALLBACKS = ('extract_tiffs', 'generate_qc') -RUN_CALLBACKS = ('plot_qc_metrics',) +FOV_CALLBACKS = ('extract_tiffs', 'generate_qc', 'generate_mph') +RUN_CALLBACKS = ('plot_qc_metrics', 'plot_mph_metrics') class ExtractionQCGenerationCases: @@ -105,7 +105,7 @@ def case_extract_only(self): cbs, kwargs = self.case_both_callbacks() return cbs[:1], kwargs - def case_qc_only(self): + def case_qc_and_mph(self): cbs, kwargs = self.case_both_callbacks() return cbs[1:], kwargs @@ -123,6 +123,8 @@ def case_missing_panel(self): def case_bad_callback(self): return ['invalid_callback'], {} + # mph bad target case + class PlotQCMetricsCases: def case_default(self): @@ -192,6 +194,25 @@ def check_qc_dir_structure(out_dir: str, point_names: List[str], qc_plots: bool assert(os.path.exists(os.path.join(out_dir, '%s_barplot_stats.png' % mn))) +def check_mph_dir_structure(out_dir: str, point_names: List[str]): + """Checks MPH directory for minimum expected structure + + Args: + out_dir (str): + Folder containing MPH output + point_names (list): + List of expected point names + + Raises: + AssertionError: + Assertion error on missing csv + """ + for point in point_names: + assert(os.path.exists(os.path.join(out_dir, f'{point}-pulse_height.csv'))) + + assert(os.path.exists(os.path.join(out_dir, 'fov_vs_mph.jpg'))) + + def create_sample_run(name_list, run_order_list, scan_count_list, create_json=False, bad=False): """Creates sample run metadata with option to create a temporary json file diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index f1e03d06..1e811ae1 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -140,7 +140,7 @@ def extract_tiffs(self, tiff_out_dir: str, panel: pd.DataFrame, **kwargs): ) def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): - """Genereates qc metrics from given panel, and saves output to provided directory + """Generates qc metrics from given panel, and saves output to provided directory Args: qc_out_dir (str): @@ -171,11 +171,12 @@ def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): for metric_name, data in metric_data.items(): data.to_csv(os.path.join(qc_out_dir, metric_name), index=False) - def generate_mph(self, mph_output_dir, panel: pd.DataFrame = None): + def generate_mph(self, mph_output_dir, target, panel: pd.DataFrame = None): """Generates mph metrics from given panel, and saves output to provided directory Args: mph_output_dir (str): where to output mph csvs to + target (str): panel (pd.DataFrame): Target mass integration ranges @@ -186,13 +187,18 @@ def generate_mph(self, mph_output_dir, panel: pd.DataFrame = None): raise ValueError('Must provide panel if fov data is not already generated...') self._generate_fov_data(panel) + row = self.__panel[self.__panel['Target'] == target] + if len(row) == 0: + raise ValueError(f"The target supplied was not found in the panel: {target}") + row = row[0] + compute_mph_metrics( bin_file_path=self.run_folder, csv_dir=mph_output_dir, fov=self.point_name, - target=self.__panel['Target'], - mass_start=self.__panel['Start'], - mass_stop=self.__panel['Stop'] + target=target, + mass_start=row['Start'], + mass_stop=row['Stop'] ) diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index 7662c103..56d33ce3 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -11,6 +11,7 @@ PlotQCMetricsCases, check_extraction_dir_structure, check_qc_dir_structure, + check_mph_dir_structure ) @@ -26,6 +27,7 @@ def test_build_fov_callback(callbacks, kwargs, data_path): qc_dir = os.path.join(tmp_dir, 'qc') kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir + kwargs['mph_output_dir'] = qc_dir # test cb generates w/o errors cb = watcher_callbacks.build_fov_callback(*callbacks, **kwargs) @@ -39,8 +41,10 @@ def test_build_fov_callback(callbacks, kwargs, data_path): # just check SMA if 'extract_tiffs' in callbacks: check_extraction_dir_structure(extracted_dir, point_names, ['SMA'], intensities) - if 'genereate_qc' in callbacks: + if 'generate_qc' in callbacks: check_qc_dir_structure(qc_dir, point_names) + if 'generate_mph' in callbacks: + check_mph_dir_structure(qc_dir, point_names) @parametrize_with_cases('callbacks, kwargs', cases=PlotQCMetricsCases) @@ -52,6 +56,7 @@ def test_build_callbacks(callbacks, kwargs, data_path): qc_dir = os.path.join(tmp_dir, 'qc') kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir + kwargs['mph_output_dir'] = qc_dir if kwargs.get('save_dir', False): kwargs['save_dir'] = qc_dir @@ -68,3 +73,4 @@ def test_build_callbacks(callbacks, kwargs, data_path): check_extraction_dir_structure(extracted_dir, point_names, ['SMA']) check_qc_dir_structure(qc_dir, point_names, 'save_dir' in kwargs) + check_mph_dir_structure(qc_dir, point_names) From e1dc8056eb423c0d71f505c95ae134c6286b6121 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 9 Jun 2022 09:29:11 -0700 Subject: [PATCH 57/94] some case name changing --- toffy/test_utils.py | 20 +++++++++++--------- toffy/watcher_callbacks.py | 2 +- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index b3148822..3089f984 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -97,34 +97,36 @@ def generate_sample_fovs_list(fov_coords, fov_names, fov_sizes): class ExtractionQCGenerationCases: - def case_both_callbacks(self): + def case_all_callbacks(self): panel_path = os.path.join(Path(__file__).parent, 'data', 'sample_panel_tissue.csv') return FOV_CALLBACKS, {'panel': pd.read_csv(panel_path)} def case_extract_only(self): - cbs, kwargs = self.case_both_callbacks() + cbs, kwargs = self.case_all_callbacks() return cbs[:1], kwargs - def case_qc_and_mph(self): - cbs, kwargs = self.case_both_callbacks() - return cbs[1:], kwargs + def case_qc_only(self): + cbs, kwargs = self.case_all_callbacks() + return cbs[1:2], kwargs + + def case_mph_only(self): + cbs, kwargs = self.case_all_callbacks() + return cbs[2:3], kwargs def case_extraction_intensities(self): - cbs, kwargs = self.case_both_callbacks() + cbs, kwargs = self.case_all_callbacks() kwargs['intensities'] = True return cbs, kwargs @pytest.mark.xfail(raises=ValueError) def case_missing_panel(self): - cbs, _ = self.case_both_callbacks() + cbs, _ = self.case_all_callbacks() return cbs, {} @pytest.mark.xfail(raises=ValueError) def case_bad_callback(self): return ['invalid_callback'], {} - # mph bad target case - class PlotQCMetricsCases: def case_default(self): diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 1e811ae1..a8d87f3a 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -176,7 +176,7 @@ def generate_mph(self, mph_output_dir, target, panel: pd.DataFrame = None): Args: mph_output_dir (str): where to output mph csvs to - target (str): + target (str): channel to use panel (pd.DataFrame): Target mass integration ranges From a900e20bcce9b7550e99ac4f2e20e3822d4bac69 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Thu, 9 Jun 2022 12:51:02 -0700 Subject: [PATCH 58/94] take in all args --- toffy/watcher_callbacks.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index a8d87f3a..d76673db 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -171,7 +171,7 @@ def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): for metric_name, data in metric_data.items(): data.to_csv(os.path.join(qc_out_dir, metric_name), index=False) - def generate_mph(self, mph_output_dir, target, panel: pd.DataFrame = None): + def generate_mph(self, mph_output_dir, target, input_mass_start, input_mass_stop): """Generates mph metrics from given panel, and saves output to provided directory Args: @@ -181,24 +181,23 @@ def generate_mph(self, mph_output_dir, target, panel: pd.DataFrame = None): Target mass integration ranges """ - + ''' if self.__fov_data is None: if panel is None: raise ValueError('Must provide panel if fov data is not already generated...') self._generate_fov_data(panel) - row = self.__panel[self.__panel['Target'] == target] if len(row) == 0: raise ValueError(f"The target supplied was not found in the panel: {target}") - row = row[0] + row = row[0]''' compute_mph_metrics( bin_file_path=self.run_folder, csv_dir=mph_output_dir, fov=self.point_name, target=target, - mass_start=row['Start'], - mass_stop=row['Stop'] + mass_start=input_mass_start, + mass_stop=input_mass_stop ) From c8a1f93a06f94b689348f6b385c5fdfa9c1f44ec Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 13 Jun 2022 12:24:46 -0700 Subject: [PATCH 59/94] add required args to tests --- toffy/watcher_callbacks.py | 9 +++------ toffy/watcher_callbacks_test.py | 6 ++++++ 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index d76673db..df61cd6f 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -171,7 +171,8 @@ def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): for metric_name, data in metric_data.items(): data.to_csv(os.path.join(qc_out_dir, metric_name), index=False) - def generate_mph(self, mph_output_dir, target, input_mass_start, input_mass_stop): + def generate_mph(self, mph_output_dir, target, input_mass_start, input_mass_stop, + panel: pd.DataFrame = None): """Generates mph metrics from given panel, and saves output to provided directory Args: @@ -181,15 +182,11 @@ def generate_mph(self, mph_output_dir, target, input_mass_start, input_mass_stop Target mass integration ranges """ - ''' + if self.__fov_data is None: if panel is None: raise ValueError('Must provide panel if fov data is not already generated...') self._generate_fov_data(panel) - row = self.__panel[self.__panel['Target'] == target] - if len(row) == 0: - raise ValueError(f"The target supplied was not found in the panel: {target}") - row = row[0]''' compute_mph_metrics( bin_file_path=self.run_folder, diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index 56d33ce3..dd18aab7 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -28,6 +28,9 @@ def test_build_fov_callback(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_output_dir'] = qc_dir + kwargs['target'] = 'CD8' + kwargs['input_mass_start'] = -0.3 + kwargs['input_mass_stop'] = 0.0 # test cb generates w/o errors cb = watcher_callbacks.build_fov_callback(*callbacks, **kwargs) @@ -57,6 +60,9 @@ def test_build_callbacks(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_output_dir'] = qc_dir + kwargs['target'] = 'CD8' + kwargs['input_mass_start'] = -0.3 + kwargs['input_mass_stop'] = 0.0 if kwargs.get('save_dir', False): kwargs['save_dir'] = qc_dir From eaf9e696f00c5b06655856afc9b1adaecfe1b968 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 13 Jun 2022 17:11:06 -0700 Subject: [PATCH 60/94] remove target argument --- templates/example_MPH_plots.ipynb | 12 ++++++------ toffy/mph_comp.py | 15 +++++++++++---- toffy/mph_comp_test.py | 17 ++++++----------- 3 files changed, 23 insertions(+), 21 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 57cd7c49..cfb8bb55 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -66,9 +66,9 @@ "outputs": [], "source": [ "# define which channel to retrieve data for\n", - "target = 'CD8'\n", - "mass_start = -0.3 \n", - "mass_stop = 0\n", + "mass = 98\n", + "mass_start = 97.5\n", + "mass_stop = 98.5\n", "\n", "# retrieve all the fov names from bin_file_path\n", "fovs = io_utils.remove_file_extensions(io_utils.list_files(bin_file_dir, substrs='.bin'))\n", @@ -77,7 +77,7 @@ "# saves individual .csv files to bin_file_path\n", "for fov in fovs:\n", " if not os.path.exists(os.path.join(bin_file_dir, '%s-pulse_height.csv' % fov)):\n", - " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, target, mass_start, mass_stop)" + " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" ] }, { @@ -108,7 +108,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -133,7 +133,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 768a52fc..4763cd3e 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -39,29 +39,36 @@ def get_estimated_time(bin_file_dir, fov): return estimated_time -def compute_mph_metrics(bin_file_dir, csv_dir, fov, target, mass_start, mass_stop): +def compute_mph_metrics(bin_file_dir, csv_dir, fov, mass, mass_start, mass_stop): """Retrieves total counts, pulse heights, & estimated time for a given FOV Args: bin_file_dir (str): path to the FOV bin and json files csv_dir (str): path to output csv to fov (string): name of fov bin file without the extension target (str): channel to use + mass (float): mass for the panel mass_start (float): beginning of mass integration range mass_stop (float): end of mass integration range """ + target = None + panel = pd.DataFrame([{ + 'Mass': mass, + 'Target': target, + 'Start': mass_start, + 'Stop': mass_stop, + }]) + # retrieve the data from bin file and output to individual csv pulse_height_file = fov + '-pulse_height.csv' try: median = bin_files.get_median_pulse_height(bin_file_dir, fov, - target, (mass_start, mass_stop)) + target, panel) count_dict = bin_files.get_total_counts(bin_file_dir, [fov]) except FileNotFoundError: raise FileNotFoundError(f"The FOV name supplied doesn't have a JSON file: {fov}") - except ValueError: - raise ValueError(f"The target name is invalid: {target}") count = count_dict[fov] time = get_estimated_time(bin_file_dir, fov) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 6fdca1ac..be52f7a4 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -49,30 +49,25 @@ def test_get_estimated_time(): def test_compute_mph_metrics(): bin_file_path = os.path.join(Path(__file__).parent, "data", "tissue") fov_name = 'fov-1-scan-1' - target_name = 'CD8' - start_mass = -0.3 - stop_mass = 0.0 + mass = 98 + start_mass = 97.5 + stop_mass = 98.5 with tempfile.TemporaryDirectory() as tmpdir: # invalid fov name should raise an error with pytest.raises(FileNotFoundError): mph.compute_mph_metrics(bin_file_path, tmpdir, "not-a-fov", - target_name, start_mass, stop_mass) - - # invalid target name should raise an error - with pytest.raises(ValueError, match="target name is invalid"): - mph.compute_mph_metrics(bin_file_path, tmpdir, fov_name, - "not-a-target", start_mass, stop_mass) + mass, start_mass, stop_mass) # test successful data retrieval and csv output mph.compute_mph_metrics(bin_file_path, tmpdir, fov_name, - target_name, start_mass, stop_mass) + mass, start_mass, stop_mass) csv_path = os.path.join(tmpdir, fov_name + '-pulse_height.csv') assert os.path.exists(csv_path) # check the csv data is correct - mph_data = create_sample_mph_data(fov_name, 2222, 72060, 512) + mph_data = create_sample_mph_data(fov_name, 3404, 72060, 512) csv_data = pd.read_csv(csv_path) assert csv_data.equals(mph_data) From a2f201b195293acd413f15f286b188f35303c2c6 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Mon, 13 Jun 2022 19:14:22 -0700 Subject: [PATCH 61/94] watcher tests are working omg --- toffy/mph_comp.py | 12 +++++------- toffy/mph_comp_test.py | 2 +- toffy/test_utils.py | 8 ++++++-- toffy/watcher_callbacks.py | 30 ++++++++++++------------------ toffy/watcher_callbacks_test.py | 17 +++++++++-------- 5 files changed, 33 insertions(+), 36 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 4763cd3e..a729b256 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -45,11 +45,9 @@ def compute_mph_metrics(bin_file_dir, csv_dir, fov, mass, mass_start, mass_stop) bin_file_dir (str): path to the FOV bin and json files csv_dir (str): path to output csv to fov (string): name of fov bin file without the extension - target (str): channel to use mass (float): mass for the panel mass_start (float): beginning of mass integration range mass_stop (float): end of mass integration range - """ target = None @@ -118,17 +116,17 @@ def combine_mph_metrics(csv_dir, return_data=False): return combined_df -def visualize_mph(mph_df, regression: bool, save_dir): +def visualize_mph(mph_df, regression: bool, out_dir): """Create a scatterplot visualizing median pulse heights by FOV cumulative count Args: mph_df (pd.DataFrame): data detailing total counts and pulse heights regression (bool): whether or not to plot regression line - save_dir (str): path of directory to save plot to + out_dir (str): path of directory to save plot to """ # path validation checks - if save_dir is not None: - io_utils.validate_paths(save_dir) + if out_dir is not None: + io_utils.validate_paths(out_dir) # visualize the median pulse heights plt.style.use('dark_background') @@ -158,7 +156,7 @@ def visualize_mph(mph_df, regression: bool, save_dir): ax1.plot(x2, m * x2 + b) # save figure - file_path = os.path.join(save_dir, 'fov_vs_mph.jpg') + file_path = os.path.join(out_dir, 'fov_vs_mph.jpg') if os.path.exists(file_path): os.remove(file_path) plt.savefig(file_path) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index be52f7a4..9ec0a310 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -114,5 +114,5 @@ def test_visualize_mph(): with tempfile.TemporaryDirectory() as temp_dir: # test for saving to directory - mph.visualize_mph(mph_data, True, save_dir=temp_dir) + mph.visualize_mph(mph_data, True, out_dir=temp_dir) assert os.path.exists(os.path.join(temp_dir, 'fov_vs_mph.jpg')) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index 3089f984..c34068ff 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -196,7 +196,7 @@ def check_qc_dir_structure(out_dir: str, point_names: List[str], qc_plots: bool assert(os.path.exists(os.path.join(out_dir, '%s_barplot_stats.png' % mn))) -def check_mph_dir_structure(out_dir: str, point_names: List[str]): +def check_mph_dir_structure(out_dir: str, point_names: List[str], combined: bool = False): """Checks MPH directory for minimum expected structure Args: @@ -204,6 +204,8 @@ def check_mph_dir_structure(out_dir: str, point_names: List[str]): Folder containing MPH output point_names (list): List of expected point names + combined (bool): + whether to check for combined mph data csv and plot image Raises: AssertionError: @@ -212,7 +214,9 @@ def check_mph_dir_structure(out_dir: str, point_names: List[str]): for point in point_names: assert(os.path.exists(os.path.join(out_dir, f'{point}-pulse_height.csv'))) - assert(os.path.exists(os.path.join(out_dir, 'fov_vs_mph.jpg'))) + if combined: + assert(os.path.exists(os.path.join(out_dir, 'total_count_vs_mph_data.csv'))) + assert(os.path.exists(os.path.join(out_dir, 'fov_vs_mph.jpg'))) def create_sample_run(name_list, run_order_list, scan_count_list, create_json=False, bad=False): diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index df61cd6f..0a68cec0 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -54,7 +54,7 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): qc_df = pd.read_csv(os.path.join(qc_out_dir, 'combined_%s.csv' % ms)) visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) - def plot_mph_metrics(self, mph_output_dir, **kwargs): + def plot_mph_metrics(self, mph_output_dir, regression, out_dir, **kwargs): """Plots mph metrics generated by the `generate_mph` callback Args: @@ -64,15 +64,11 @@ def plot_mph_metrics(self, mph_output_dir, **kwargs): Accepted kwargs are - regression - - save_dir + - out_dir """ - # filter kwargs - valid_kwargs = ['regression', 'save_dir'] - viz_kwargs = {k: v for k, v in kwargs.items() if k in valid_kwargs} - mph_df = combine_mph_metrics(mph_output_dir, return_data=True) - visualize_mph(mph_df, **viz_kwargs) + visualize_mph(mph_df, regression, out_dir) @dataclass @@ -171,28 +167,26 @@ def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): for metric_name, data in metric_data.items(): data.to_csv(os.path.join(qc_out_dir, metric_name), index=False) - def generate_mph(self, mph_output_dir, target, input_mass_start, input_mass_stop, - panel: pd.DataFrame = None): + def generate_mph(self, mph_output_dir, input_mass, input_mass_start, input_mass_stop, + **kwargs): """Generates mph metrics from given panel, and saves output to provided directory Args: mph_output_dir (str): where to output mph csvs to - target (str): channel to use - panel (pd.DataFrame): - Target mass integration ranges + input_mass (float): mass for the panel + input_mass_start (float): beginning of mass integration range + input_mass_stop (float): end of mass integration range """ - if self.__fov_data is None: - if panel is None: - raise ValueError('Must provide panel if fov data is not already generated...') - self._generate_fov_data(panel) + if not os.path.exists(mph_output_dir): + os.mkdir(mph_output_dir) compute_mph_metrics( - bin_file_path=self.run_folder, + bin_file_dir=self.run_folder, csv_dir=mph_output_dir, fov=self.point_name, - target=target, + mass=input_mass, mass_start=input_mass_start, mass_stop=input_mass_stop ) diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index dd18aab7..5a9a244c 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -28,9 +28,9 @@ def test_build_fov_callback(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_output_dir'] = qc_dir - kwargs['target'] = 'CD8' - kwargs['input_mass_start'] = -0.3 - kwargs['input_mass_stop'] = 0.0 + kwargs['input_mass'] = 98 + kwargs['input_mass_start'] = 97.5 + kwargs['input_mass_stop'] = 98.5 # test cb generates w/o errors cb = watcher_callbacks.build_fov_callback(*callbacks, **kwargs) @@ -60,9 +60,11 @@ def test_build_callbacks(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_output_dir'] = qc_dir - kwargs['target'] = 'CD8' - kwargs['input_mass_start'] = -0.3 - kwargs['input_mass_stop'] = 0.0 + kwargs['input_mass'] = 98 + kwargs['input_mass_start'] = 97.5 + kwargs['input_mass_stop'] = 98.5 + kwargs['regression'] = True + kwargs['out_dir'] = qc_dir if kwargs.get('save_dir', False): kwargs['save_dir'] = qc_dir @@ -74,9 +76,8 @@ def test_build_callbacks(callbacks, kwargs, data_path): for name in point_names: fcb(data_path, name) - rcb() check_extraction_dir_structure(extracted_dir, point_names, ['SMA']) check_qc_dir_structure(qc_dir, point_names, 'save_dir' in kwargs) - check_mph_dir_structure(qc_dir, point_names) + check_mph_dir_structure(qc_dir, point_names, combined=True) From 0585aefb2d67d36098c0da2b1877d7a1f3a3ca32 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 14 Jun 2022 10:33:02 -0700 Subject: [PATCH 62/94] add mph to WatcherCases --- toffy/test_utils.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index c34068ff..7c451588 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -362,6 +362,7 @@ def case_default(self, intensity): channels=list(panel['Target']), intensities=intensity), check_qc_dir_structure, + check_mph_dir_structure, ] kwargs = {'panel': panel, 'intensities': intensity} @@ -369,6 +370,7 @@ def case_default(self, intensity): return ( ['plot_qc_metrics'], ['extract_tiffs'], + ['plot_mph_metrics'], kwargs, validators ) From 19c132edb08fb2e276bae8653cbbe7d73230d71d Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 14 Jun 2022 14:03:11 -0700 Subject: [PATCH 63/94] set defaults for mass specs --- templates/example_MPH_plots.ipynb | 24 ++++++++++++++++++------ toffy/mph_comp.py | 4 ++-- toffy/mph_comp_test.py | 9 ++------- toffy/watcher_callbacks.py | 19 +++++++++++-------- toffy/watcher_callbacks_test.py | 6 ------ 5 files changed, 33 insertions(+), 29 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index cfb8bb55..1a8cb91e 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -58,6 +58,15 @@ " os.makedirs(mph_dir)" ] }, + { + "cell_type": "markdown", + "id": "e569bf40-d83c-41c1-8828-1b3d18357b95", + "metadata": {}, + "source": [ + "### Compute median pulse height data\n", + "The mass specifications are set to have the defaults shown below." + ] + }, { "cell_type": "code", "execution_count": 4, @@ -65,19 +74,22 @@ "metadata": {}, "outputs": [], "source": [ - "# define which channel to retrieve data for\n", - "mass = 98\n", - "mass_start = 97.5\n", - "mass_stop = 98.5\n", + "# these are the defaults for the function, user can input different values if needed\n", + "# mass = 98\n", + "# mass_start = 97.5\n", + "# mass_stop = 98.5\n", "\n", "# retrieve all the fov names from bin_file_path\n", "fovs = io_utils.remove_file_extensions(io_utils.list_files(bin_file_dir, substrs='.bin'))\n", "\n", "# retrieve the total counts and compute pulse heights for each FOV run file\n", - "# saves individual .csv files to bin_file_path\n", + "# saves individual .csv files to mph_dir\n", "for fov in fovs:\n", " if not os.path.exists(os.path.join(bin_file_dir, '%s-pulse_height.csv' % fov)):\n", - " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" + " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov)\n", + " \n", + " # use the function below instead if specifying new mass integration\n", + " # mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" ] }, { diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index a729b256..3586aa34 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -39,7 +39,7 @@ def get_estimated_time(bin_file_dir, fov): return estimated_time -def compute_mph_metrics(bin_file_dir, csv_dir, fov, mass, mass_start, mass_stop): +def compute_mph_metrics(bin_file_dir, csv_dir, fov, mass=98, mass_start=97.5, mass_stop=98.5): """Retrieves total counts, pulse heights, & estimated time for a given FOV Args: bin_file_dir (str): path to the FOV bin and json files @@ -120,7 +120,7 @@ def visualize_mph(mph_df, regression: bool, out_dir): """Create a scatterplot visualizing median pulse heights by FOV cumulative count Args: mph_df (pd.DataFrame): data detailing total counts and pulse heights - regression (bool): whether or not to plot regression line + regression (bool): whether to plot regression line out_dir (str): path of directory to save plot to """ diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 9ec0a310..4e52a1e2 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -49,20 +49,15 @@ def test_get_estimated_time(): def test_compute_mph_metrics(): bin_file_path = os.path.join(Path(__file__).parent, "data", "tissue") fov_name = 'fov-1-scan-1' - mass = 98 - start_mass = 97.5 - stop_mass = 98.5 with tempfile.TemporaryDirectory() as tmpdir: # invalid fov name should raise an error with pytest.raises(FileNotFoundError): - mph.compute_mph_metrics(bin_file_path, tmpdir, "not-a-fov", - mass, start_mass, stop_mass) + mph.compute_mph_metrics(bin_file_path, tmpdir, "not-a-fov") # test successful data retrieval and csv output - mph.compute_mph_metrics(bin_file_path, tmpdir, fov_name, - mass, start_mass, stop_mass) + mph.compute_mph_metrics(bin_file_path, tmpdir, fov_name) csv_path = os.path.join(tmpdir, fov_name + '-pulse_height.csv') assert os.path.exists(csv_path) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 0a68cec0..45d04f64 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -167,15 +167,18 @@ def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): for metric_name, data in metric_data.items(): data.to_csv(os.path.join(qc_out_dir, metric_name), index=False) - def generate_mph(self, mph_output_dir, input_mass, input_mass_start, input_mass_stop, - **kwargs): + def generate_mph(self, mph_output_dir, **kwargs): """Generates mph metrics from given panel, and saves output to provided directory Args: mph_output_dir (str): where to output mph csvs to - input_mass (float): mass for the panel - input_mass_start (float): beginning of mass integration range - input_mass_stop (float): end of mass integration range + + **kwargs (dict): + Additional arguments for `toffy.qc_comp.compute_mph_metrics`. Accepted kwargs are: + + - mass + - mass_start + - mass_stop """ @@ -186,9 +189,9 @@ def generate_mph(self, mph_output_dir, input_mass, input_mass_start, input_mass_ bin_file_dir=self.run_folder, csv_dir=mph_output_dir, fov=self.point_name, - mass=input_mass, - mass_start=input_mass_start, - mass_stop=input_mass_stop + mass=kwargs.get('mass', 98), + mass_start=kwargs.get('mass_start', 97.5), + mass_stop=kwargs.get('mass_stop', 98.5), ) diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index 5a9a244c..1251b24c 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -28,9 +28,6 @@ def test_build_fov_callback(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_output_dir'] = qc_dir - kwargs['input_mass'] = 98 - kwargs['input_mass_start'] = 97.5 - kwargs['input_mass_stop'] = 98.5 # test cb generates w/o errors cb = watcher_callbacks.build_fov_callback(*callbacks, **kwargs) @@ -60,9 +57,6 @@ def test_build_callbacks(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_output_dir'] = qc_dir - kwargs['input_mass'] = 98 - kwargs['input_mass_start'] = 97.5 - kwargs['input_mass_stop'] = 98.5 kwargs['regression'] = True kwargs['out_dir'] = qc_dir From 5af5de8759784676c381f302cade81f6c0207bd8 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 14 Jun 2022 14:11:10 -0700 Subject: [PATCH 64/94] mph_output_dir --> mph_out_dir --- toffy/watcher_callbacks.py | 16 ++++++++-------- toffy/watcher_callbacks_test.py | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 45d04f64..223d90d9 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -54,11 +54,11 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): qc_df = pd.read_csv(os.path.join(qc_out_dir, 'combined_%s.csv' % ms)) visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) - def plot_mph_metrics(self, mph_output_dir, regression, out_dir, **kwargs): + def plot_mph_metrics(self, mph_out_dir, regression, out_dir, **kwargs): """Plots mph metrics generated by the `generate_mph` callback Args: - mph_output_dir (str): directory containing qc metric csv + mph_out_dir (str): directory containing qc metric csv **kwargs (Dict[str, Any]): Additional arguments for `toffy.mph_comp.visualize_mph`. Accepted kwargs are @@ -67,7 +67,7 @@ def plot_mph_metrics(self, mph_output_dir, regression, out_dir, **kwargs): - out_dir """ - mph_df = combine_mph_metrics(mph_output_dir, return_data=True) + mph_df = combine_mph_metrics(mph_out_dir, return_data=True) visualize_mph(mph_df, regression, out_dir) @@ -167,11 +167,11 @@ def generate_qc(self, qc_out_dir: str, panel: pd.DataFrame = None, **kwargs): for metric_name, data in metric_data.items(): data.to_csv(os.path.join(qc_out_dir, metric_name), index=False) - def generate_mph(self, mph_output_dir, **kwargs): + def generate_mph(self, mph_out_dir, **kwargs): """Generates mph metrics from given panel, and saves output to provided directory Args: - mph_output_dir (str): where to output mph csvs to + mph_out_dir (str): where to output mph csvs to **kwargs (dict): Additional arguments for `toffy.qc_comp.compute_mph_metrics`. Accepted kwargs are: @@ -182,12 +182,12 @@ def generate_mph(self, mph_output_dir, **kwargs): """ - if not os.path.exists(mph_output_dir): - os.mkdir(mph_output_dir) + if not os.path.exists(mph_out_dir): + os.mkdir(mph_out_dir) compute_mph_metrics( bin_file_dir=self.run_folder, - csv_dir=mph_output_dir, + csv_dir=mph_out_dir, fov=self.point_name, mass=kwargs.get('mass', 98), mass_start=kwargs.get('mass_start', 97.5), diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index 1251b24c..d5277cb0 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -27,7 +27,7 @@ def test_build_fov_callback(callbacks, kwargs, data_path): qc_dir = os.path.join(tmp_dir, 'qc') kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir - kwargs['mph_output_dir'] = qc_dir + kwargs['mph_out_dir'] = qc_dir # test cb generates w/o errors cb = watcher_callbacks.build_fov_callback(*callbacks, **kwargs) @@ -56,7 +56,7 @@ def test_build_callbacks(callbacks, kwargs, data_path): qc_dir = os.path.join(tmp_dir, 'qc') kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir - kwargs['mph_output_dir'] = qc_dir + kwargs['mph_out_dir'] = qc_dir kwargs['regression'] = True kwargs['out_dir'] = qc_dir From 408c9ffd9a09dba268a7332205e2a8f91f5e7382 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 14 Jun 2022 14:18:27 -0700 Subject: [PATCH 65/94] out_dir --> img_out_dir --- toffy/test_utils.py | 12 ++++++------ toffy/watcher_callbacks.py | 6 +++--- toffy/watcher_callbacks_test.py | 2 +- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index 7c451588..3df07396 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -196,12 +196,12 @@ def check_qc_dir_structure(out_dir: str, point_names: List[str], qc_plots: bool assert(os.path.exists(os.path.join(out_dir, '%s_barplot_stats.png' % mn))) -def check_mph_dir_structure(out_dir: str, point_names: List[str], combined: bool = False): +def check_mph_dir_structure(img_out_dir: str, point_names: List[str], combined: bool = False): """Checks MPH directory for minimum expected structure Args: - out_dir (str): - Folder containing MPH output + img_out_dir (str): + Folder containing MPH plot output point_names (list): List of expected point names combined (bool): @@ -212,11 +212,11 @@ def check_mph_dir_structure(out_dir: str, point_names: List[str], combined: bool Assertion error on missing csv """ for point in point_names: - assert(os.path.exists(os.path.join(out_dir, f'{point}-pulse_height.csv'))) + assert(os.path.exists(os.path.join(img_out_dir, f'{point}-pulse_height.csv'))) if combined: - assert(os.path.exists(os.path.join(out_dir, 'total_count_vs_mph_data.csv'))) - assert(os.path.exists(os.path.join(out_dir, 'fov_vs_mph.jpg'))) + assert(os.path.exists(os.path.join(img_out_dir, 'total_count_vs_mph_data.csv'))) + assert(os.path.exists(os.path.join(img_out_dir, 'fov_vs_mph.jpg'))) def create_sample_run(name_list, run_order_list, scan_count_list, create_json=False, bad=False): diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 223d90d9..0ed1f1b5 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -54,7 +54,7 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): qc_df = pd.read_csv(os.path.join(qc_out_dir, 'combined_%s.csv' % ms)) visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) - def plot_mph_metrics(self, mph_out_dir, regression, out_dir, **kwargs): + def plot_mph_metrics(self, mph_out_dir, regression, img_out_dir, **kwargs): """Plots mph metrics generated by the `generate_mph` callback Args: @@ -64,11 +64,11 @@ def plot_mph_metrics(self, mph_out_dir, regression, out_dir, **kwargs): Accepted kwargs are - regression - - out_dir + - img_out_dir """ mph_df = combine_mph_metrics(mph_out_dir, return_data=True) - visualize_mph(mph_df, regression, out_dir) + visualize_mph(mph_df, regression, img_out_dir) @dataclass diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index d5277cb0..b4c8d18c 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -58,7 +58,7 @@ def test_build_callbacks(callbacks, kwargs, data_path): kwargs['qc_out_dir'] = qc_dir kwargs['mph_out_dir'] = qc_dir kwargs['regression'] = True - kwargs['out_dir'] = qc_dir + kwargs['img_out_dir'] = qc_dir if kwargs.get('save_dir', False): kwargs['save_dir'] = qc_dir From 275f942a3cfaa206a67b4f7c1583d7d569360ef7 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 14 Jun 2022 14:29:38 -0700 Subject: [PATCH 66/94] update watcher notebook --- templates/3a_monitor_MIBI_run.ipynb | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/templates/3a_monitor_MIBI_run.ipynb b/templates/3a_monitor_MIBI_run.ipynb index bf427f1d..82d5c056 100644 --- a/templates/3a_monitor_MIBI_run.ipynb +++ b/templates/3a_monitor_MIBI_run.ipynb @@ -91,7 +91,11 @@ " - `axes_size`\n", " - `wrap`\n", " - `dpi`\n", - " - `save_dir`" + " - `save_dir`\n", + " \n", + "The `plot_mph_metrics` run callback will compute the median pulse height data for each \n", + "FoV, and plot the results once the run has completed. Additional arguments are:\n", + "`regression` which when set to True will also plot the linear regression line for the data." ] }, { @@ -104,12 +108,15 @@ "qc_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\run_metrics', run_name)\n", "\n", "fov_callback, run_callback = build_callbacks(\n", - " run_callbacks = ['plot_qc_metrics'],\n", + " run_callbacks = ['plot_qc_metrics', 'plot_mph_metrics'],\n", " fov_callbacks = ['extract_tiffs'],\n", " tiff_out_dir=extraction_dir,\n", " qc_out_dir=qc_dir,\n", + " mph_out_dir=qc_dir,\n", + " img_out_dir=qc_dir,\n", " panel=panel,\n", " intensities=False,\n", + " regression=False,\n", ")" ] }, @@ -139,7 +146,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.9.7" } }, "nbformat": 4, From d269df3de657086c16f22d79c4ed6f5d410ebff5 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 14 Jun 2022 14:42:02 -0700 Subject: [PATCH 67/94] set default regression=False --- templates/example_MPH_plots.ipynb | 15 +++++++-------- toffy/mph_comp.py | 4 ++-- toffy/mph_comp_test.py | 4 ++-- toffy/watcher_callbacks.py | 11 +++++++---- 4 files changed, 18 insertions(+), 16 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 1a8cb91e..3ec946e1 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -89,7 +89,7 @@ " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov)\n", " \n", " # use the function below instead if specifying new mass integration\n", - " # mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" + " #mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" ] }, { @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -114,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ @@ -132,14 +132,13 @@ "source": [ "# visualize the median pulse heights\n", "df_mph = pd.read_csv(os.path.join(mph_dir, 'total_count_vs_mph_data.csv'))\n", - "regression = False\n", "\n", - "mph_comp.visualize_mph(df_mph, regression, mph_dir)" + "mph_comp.visualize_mph(df_mph, mph_dir)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ @@ -157,7 +156,7 @@ "source": [ "# plot with regression line\n", "regression = True\n", - "mph_comp.visualize_mph(df_mph, regression, mph_dir)" + "mph_comp.visualize_mph(df_mph, mph_dir, regression)" ] } ], diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 3586aa34..1688a6e6 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -116,12 +116,12 @@ def combine_mph_metrics(csv_dir, return_data=False): return combined_df -def visualize_mph(mph_df, regression: bool, out_dir): +def visualize_mph(mph_df, out_dir, regression: bool = False): """Create a scatterplot visualizing median pulse heights by FOV cumulative count Args: mph_df (pd.DataFrame): data detailing total counts and pulse heights - regression (bool): whether to plot regression line out_dir (str): path of directory to save plot to + regression (bool): whether to plot regression line, default is False """ # path validation checks diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 4e52a1e2..e2004e87 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -105,9 +105,9 @@ def test_visualize_mph(): # bad output directory path should raise an error with pytest.raises(ValueError): - mph.visualize_mph(mph_data, False, bad_path) + mph.visualize_mph(mph_data, bad_path, regression=False) with tempfile.TemporaryDirectory() as temp_dir: # test for saving to directory - mph.visualize_mph(mph_data, True, out_dir=temp_dir) + mph.visualize_mph(mph_data, out_dir=temp_dir, regression=True) assert os.path.exists(os.path.join(temp_dir, 'fov_vs_mph.jpg')) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 0ed1f1b5..77edb6d2 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -54,21 +54,24 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): qc_df = pd.read_csv(os.path.join(qc_out_dir, 'combined_%s.csv' % ms)) visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) - def plot_mph_metrics(self, mph_out_dir, regression, img_out_dir, **kwargs): + def plot_mph_metrics(self, mph_out_dir, img_out_dir, **kwargs): """Plots mph metrics generated by the `generate_mph` callback Args: - mph_out_dir (str): directory containing qc metric csv + mph_out_dir (str): directory containing mph metric csv + img_out_dir (str): director to store the plot to **kwargs (Dict[str, Any]): Additional arguments for `toffy.mph_comp.visualize_mph`. Accepted kwargs are - regression - - img_out_dir """ + # filter kwargs + valid_kwargs = ['regression', ] + viz_kwargs = {k: v for k, v in kwargs.items() if k in valid_kwargs} mph_df = combine_mph_metrics(mph_out_dir, return_data=True) - visualize_mph(mph_df, regression, img_out_dir) + visualize_mph(mph_df, img_out_dir, **viz_kwargs) @dataclass From 804739a9275668bebdc58ce880774db87f319fa4 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Tue, 14 Jun 2022 14:50:17 -0700 Subject: [PATCH 68/94] comments --- toffy/mph_comp.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 1688a6e6..e04f972a 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -77,14 +77,14 @@ def compute_mph_metrics(bin_file_dir, csv_dir, fov, mass=98, mass_start=97.5, ma 'total_count': [count], 'time': [time]}) - # saves individual .csv files to bin_file_path + # saves individual .csv files to csv_dir out_df.to_csv(os.path.join(csv_dir, pulse_height_file), index=False) def combine_mph_metrics(csv_dir, return_data=False): """Combines data from individual csvs into one Args: - csv_dir (str): path where FOV csvs are stored + csv_dir (str): path where FOV mph data csvs are stored return_data (bool): whether to return dataframe with mph metrics, default False Returns: @@ -105,7 +105,7 @@ def combine_mph_metrics(csv_dir, return_data=False): combined_df['cum_total_count'] = combined_df['total_count'].cumsum() combined_df['cum_total_time'] = combined_df['time'].cumsum() - # save csv to output_dir + # save csv to csv_dir file_path = os.path.join(csv_dir, 'total_count_vs_mph_data.csv') if os.path.exists(file_path): os.remove(file_path) From 751c591aa9d56d3d6b9578d787b4363fc2684675 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 15 Jun 2022 14:49:20 -0700 Subject: [PATCH 69/94] regression defualt in tests --- toffy/watcher_callbacks_test.py | 1 - 1 file changed, 1 deletion(-) diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index b4c8d18c..de007309 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -57,7 +57,6 @@ def test_build_callbacks(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_out_dir'] = qc_dir - kwargs['regression'] = True kwargs['img_out_dir'] = qc_dir if kwargs.get('save_dir', False): From ef2cb06052c9018dca1dff713c0ac9f078b724dd Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 15 Jun 2022 15:39:34 -0700 Subject: [PATCH 70/94] fix failing tests --- toffy/test_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index 3df07396..73e4214c 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -362,7 +362,7 @@ def case_default(self, intensity): channels=list(panel['Target']), intensities=intensity), check_qc_dir_structure, - check_mph_dir_structure, + check_mph_dir_structure ] kwargs = {'panel': panel, 'intensities': intensity} From 886c203b59e4a33a4c62ef8e4c28527bf29371e7 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 15 Jun 2022 16:02:23 -0700 Subject: [PATCH 71/94] fix failing tests 2 --- toffy/fov_watcher_test.py | 2 ++ toffy/test_utils.py | 3 +-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/toffy/fov_watcher_test.py b/toffy/fov_watcher_test.py index 764652ed..a1cc068b 100644 --- a/toffy/fov_watcher_test.py +++ b/toffy/fov_watcher_test.py @@ -70,6 +70,8 @@ def test_watcher(run_cbs, fov_cbs, kwargs, validators, add_blank): # add directories to kwargs kwargs['tiff_out_dir'] = tiff_out_dir kwargs['qc_out_dir'] = qc_out_dir + kwargs['mph_out_dir'] = qc_out_dir + kwargs['img_out_dir'] = qc_out_dir run_data = os.path.join(tmpdir, 'test_run') log_out = os.path.join(tmpdir, 'log_output') diff --git a/toffy/test_utils.py b/toffy/test_utils.py index 73e4214c..3e1730be 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -368,9 +368,8 @@ def case_default(self, intensity): kwargs = {'panel': panel, 'intensities': intensity} return ( - ['plot_qc_metrics'], + ['plot_qc_metrics', 'plot_mph_metrics'], ['extract_tiffs'], - ['plot_mph_metrics'], kwargs, validators ) From 031926c293409f22a7463ac717befe3845032fc5 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 15 Jun 2022 17:01:12 -0700 Subject: [PATCH 72/94] update test_watcher --- toffy/fov_watcher_test.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/toffy/fov_watcher_test.py b/toffy/fov_watcher_test.py index a1cc068b..d72c5079 100644 --- a/toffy/fov_watcher_test.py +++ b/toffy/fov_watcher_test.py @@ -66,12 +66,14 @@ def test_watcher(run_cbs, fov_cbs, kwargs, validators, add_blank): tiff_out_dir = os.path.join(tmpdir, 'cb_0', RUN_DIR_NAME) qc_out_dir = os.path.join(tmpdir, 'cb_1', RUN_DIR_NAME) + mph_out_dir = os.path.join(tmpdir, 'cb_2', RUN_DIR_NAME) + img_out_dir = os.path.join(tmpdir, 'cb_3', RUN_DIR_NAME) # add directories to kwargs kwargs['tiff_out_dir'] = tiff_out_dir kwargs['qc_out_dir'] = qc_out_dir - kwargs['mph_out_dir'] = qc_out_dir - kwargs['img_out_dir'] = qc_out_dir + kwargs['mph_out_dir'] = mph_out_dir + kwargs['img_out_dir'] = img_out_dir run_data = os.path.join(tmpdir, 'test_run') log_out = os.path.join(tmpdir, 'log_output') From 1a17736edac7f9867b245d400cb4019e1f13f264 Mon Sep 17 00:00:00 2001 From: Cami PC Date: Wed, 15 Jun 2022 17:40:16 -0700 Subject: [PATCH 73/94] adam is the goat --- toffy/watcher_callbacks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 77edb6d2..852483a1 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -186,7 +186,7 @@ def generate_mph(self, mph_out_dir, **kwargs): """ if not os.path.exists(mph_out_dir): - os.mkdir(mph_out_dir) + os.makedirs(mph_out_dir) compute_mph_metrics( bin_file_dir=self.run_folder, From 4860e432b8e4acd6d36c07f7b6eae047a6ff53db Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 22 Jun 2022 11:28:37 -0700 Subject: [PATCH 74/94] fix double points --- templates/example_MPH_plots.ipynb | 18 +++++++++--------- toffy/mph_comp.py | 15 ++++++--------- 2 files changed, 15 insertions(+), 18 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index 3ec946e1..d46fcb38 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -49,8 +49,8 @@ "source": [ "# set up directories for current run\n", "base_dir = os.path.join('..', 'toffy', 'data')\n", - "bin_file_dir = os.path.join(base_dir, 'tissue')\n", - "mph_dir = os.path.join(base_dir, 'tissue_mph')\n", + "bin_file_dir = os.path.join(base_dir, '6-15_brain')\n", + "mph_dir = os.path.join(base_dir, 'MPH')\n", "#mph_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\qc_metrics', 'tissue')\n", "\n", "# make mph_dir if it doesn't exist\n", @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -114,13 +114,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 4, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -138,13 +138,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -176,7 +176,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.8.13" } }, "nbformat": 4, diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index e04f972a..40135d06 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -134,23 +134,20 @@ def visualize_mph(mph_df, out_dir, regression: bool = False): fig = plt.figure() ax1 = fig.add_subplot(111) ax2 = ax1.twiny() - x = mph_df['cum_total_count'] + x = mph_df['cum_total_count']/1000000 y = mph_df['MPH'] - x_alt = mph_df['cum_total_time'] - ax1.scatter(x, y) - ax1.set_xlabel('FOV cumulative count') + x_alt = mph_df['cum_total_time']/3600 + ax1.set_xlabel('FOV cumulative count (in millions)') ax1.set_ylabel('median pulse height') - ax2.scatter(x_alt, y) - ticks = ax2.get_xticks().tolist() - new_ticks = [round(tick/3600, 2) for tick in ticks] - ax2.set_xticklabels(new_ticks) ax2.set_xlabel('estimated time (hours)') + ax1.scatter(x, y) + ax2.scatter(x_alt, y, s=0) plt.gcf().set_size_inches(18.5, 10.5) # plot regression line if regression: # plot with regression line - x2 = np.array(mph_df['cum_total_count']) + x2 = np.array(mph_df['cum_total_count']/1000000) y2 = np.array(mph_df['MPH']) m, b = np.polyfit(x2, y2, 1) ax1.plot(x2, m * x2 + b) From 8a35f002b9f53a4fc1b6b86472446c8d58618dce Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 22 Jun 2022 11:46:22 -0700 Subject: [PATCH 75/94] clean notebook --- templates/example_MPH_plots.ipynb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/templates/example_MPH_plots.ipynb b/templates/example_MPH_plots.ipynb index d46fcb38..9d0d3e8d 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/example_MPH_plots.ipynb @@ -35,7 +35,7 @@ }, "source": [ "### Define file parameters\n", - " * base_dir: this is the top-level directory to store the median pulse heights for different targets\n", + " * run_name: should contain the exact name of the MIBI run to locate the mph data from\n", " * bin_file_path: the directory containing your bin files\n", " * mph_dir: the directory to save the MPH visualizations to" ] @@ -48,10 +48,11 @@ "outputs": [], "source": [ "# set up directories for current run\n", - "base_dir = os.path.join('..', 'toffy', 'data')\n", - "bin_file_dir = os.path.join(base_dir, '6-15_brain')\n", - "mph_dir = os.path.join(base_dir, 'MPH')\n", - "#mph_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\qc_metrics', 'tissue')\n", + "run_name = 'YYYY-MM-DD_run_name'\n", + "\n", + "bin_file_dir = os.path.join('D:\\\\Data', run_name)\n", + "\n", + "mph_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\run_metrics', run_name)\n", "\n", "# make mph_dir if it doesn't exist\n", "if not os.path.exists(mph_dir):\n", From 9f9d48df65677e66a0dd3e611cffb264bb7f867c Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 22 Jun 2022 15:41:02 -0700 Subject: [PATCH 76/94] name change and mph_dir --- README.md | 2 +- ...PH_plots.ipynb => 3d_example_MPH_plots.ipynb} | 16 +++++++--------- toffy/mph_comp.py | 2 +- 3 files changed, 9 insertions(+), 11 deletions(-) rename templates/{example_MPH_plots.ipynb => 3d_example_MPH_plots.ipynb} (99%) diff --git a/README.md b/README.md index f501e021..c7295203 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ There are a number of different computational tasks to complete once a MIBI run - 3a: real time monitoring. The [MIBI monitoring](./templates/3a_monitor_MIBI_run.ipynb) notebook will monitor an ongoing MIBI run, and begin processing the image data as soon as it is generated. This notebook is being continually be updated as we move more of our processing pipeline to happen in real time as the data is generated. - 3b: post-run monitoring. For each step in the monitoring notebook, we have a dedicated notebook that can perform the same tasks once a run is complete. This includes [the image extraction notebook](./templates/extract_bin_file.ipynb) and the [qc metrics notebook](./templates/3b_generate_qc_metrics.ipynb). - +- 3d: visualizing. The [example MPH plots notebook](./templates/3d_example_MPH_plots.ipynb) can be run to generate plots showing median pulse heights for each FOV along with estimated run time. ### 4. Processing MIBI Data Once your run has finished, you can begin to process the data to make it ready for analysis. To remove background signal contamination, as well as compensate for channel crosstalk, you can use the [compensation](./templates/4_compensate_image_data.ipynb) notebook. This will guide you through the Rosetta algorithm, which uses a flow-cytometry style compensation approach to remove spurious signal. diff --git a/templates/example_MPH_plots.ipynb b/templates/3d_example_MPH_plots.ipynb similarity index 99% rename from templates/example_MPH_plots.ipynb rename to templates/3d_example_MPH_plots.ipynb index 9d0d3e8d..89bf4062 100644 --- a/templates/example_MPH_plots.ipynb +++ b/templates/3d_example_MPH_plots.ipynb @@ -50,9 +50,10 @@ "# set up directories for current run\n", "run_name = 'YYYY-MM-DD_run_name'\n", "\n", - "bin_file_dir = os.path.join('D:\\\\Data', run_name)\n", + "#bin_file_dir = os.path.join('D:\\\\Data', run_name)\n", + "#mph_dir = bin_file_dir\n", "\n", - "mph_dir = os.path.join('C:\\\\Users\\\\Customer.ION\\\\Documents\\\\run_metrics', run_name)\n", + "bin_file_dir = os.path.join('..', 'toffy', 'data', '6-1')\n", "\n", "# make mph_dir if it doesn't exist\n", "if not os.path.exists(mph_dir):\n", @@ -76,9 +77,9 @@ "outputs": [], "source": [ "# these are the defaults for the function, user can input different values if needed\n", - "# mass = 98\n", - "# mass_start = 97.5\n", - "# mass_stop = 98.5\n", + "mass = 98\n", + "mass_start = 97.5\n", + "mass_stop = 98.5\n", "\n", "# retrieve all the fov names from bin_file_path\n", "fovs = io_utils.remove_file_extensions(io_utils.list_files(bin_file_dir, substrs='.bin'))\n", @@ -87,10 +88,7 @@ "# saves individual .csv files to mph_dir\n", "for fov in fovs:\n", " if not os.path.exists(os.path.join(bin_file_dir, '%s-pulse_height.csv' % fov)):\n", - " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov)\n", - " \n", - " # use the function below instead if specifying new mass integration\n", - " #mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" + " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" ] }, { diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 40135d06..abe139cc 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -136,7 +136,7 @@ def visualize_mph(mph_df, out_dir, regression: bool = False): ax2 = ax1.twiny() x = mph_df['cum_total_count']/1000000 y = mph_df['MPH'] - x_alt = mph_df['cum_total_time']/3600 + x_alt = mph_df['cum_total_time']/(3600*1000) ax1.set_xlabel('FOV cumulative count (in millions)') ax1.set_ylabel('median pulse height') ax2.set_xlabel('estimated time (hours)') From 11dba1d0fcae63d39533c1ea56567e565343cdec Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 22 Jun 2022 15:45:02 -0700 Subject: [PATCH 77/94] pulse_height.csv -> mph_pulse.csv --- templates/3d_example_MPH_plots.ipynb | 8 +++----- toffy/mph_comp.py | 4 ++-- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/templates/3d_example_MPH_plots.ipynb b/templates/3d_example_MPH_plots.ipynb index 89bf4062..b9c3aae7 100644 --- a/templates/3d_example_MPH_plots.ipynb +++ b/templates/3d_example_MPH_plots.ipynb @@ -50,10 +50,8 @@ "# set up directories for current run\n", "run_name = 'YYYY-MM-DD_run_name'\n", "\n", - "#bin_file_dir = os.path.join('D:\\\\Data', run_name)\n", - "#mph_dir = bin_file_dir\n", - "\n", - "bin_file_dir = os.path.join('..', 'toffy', 'data', '6-1')\n", + "bin_file_dir = os.path.join('D:\\\\Data', run_name)\n", + "mph_dir = bin_file_dir\n", "\n", "# make mph_dir if it doesn't exist\n", "if not os.path.exists(mph_dir):\n", @@ -87,7 +85,7 @@ "# retrieve the total counts and compute pulse heights for each FOV run file\n", "# saves individual .csv files to mph_dir\n", "for fov in fovs:\n", - " if not os.path.exists(os.path.join(bin_file_dir, '%s-pulse_height.csv' % fov)):\n", + " if not os.path.exists(os.path.join(bin_file_dir, '%s-mph_pulse.csv' % fov)):\n", " mph_comp.compute_mph_metrics(bin_file_dir, mph_dir, fov, mass, mass_start, mass_stop)" ] }, diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index abe139cc..6da28ac0 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -59,7 +59,7 @@ def compute_mph_metrics(bin_file_dir, csv_dir, fov, mass=98, mass_start=97.5, ma }]) # retrieve the data from bin file and output to individual csv - pulse_height_file = fov + '-pulse_height.csv' + pulse_height_file = fov + '-mph_pulse.csv' try: median = bin_files.get_median_pulse_height(bin_file_dir, fov, @@ -95,7 +95,7 @@ def combine_mph_metrics(csv_dir, return_data=False): io_utils.validate_paths(csv_dir) # for each csv retrieve mph values - fov_files = io_utils.list_files(csv_dir, "-pulse_height.csv") + fov_files = io_utils.list_files(csv_dir, "-mph_pulse.csv") combined_rows = [] for i, file in enumerate(fov_files): combined_rows.append(pd.read_csv(os.path.join(csv_dir, file))) From b9bdae19f0c83b4696c26d0239743bca26cee93a Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 22 Jun 2022 15:48:50 -0700 Subject: [PATCH 78/94] img_out_dir -> plot_dir --- toffy/test_utils.py | 10 +++++----- toffy/watcher_callbacks.py | 6 +++--- toffy/watcher_callbacks_test.py | 2 +- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index 3e1730be..35dfc1c1 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -196,11 +196,11 @@ def check_qc_dir_structure(out_dir: str, point_names: List[str], qc_plots: bool assert(os.path.exists(os.path.join(out_dir, '%s_barplot_stats.png' % mn))) -def check_mph_dir_structure(img_out_dir: str, point_names: List[str], combined: bool = False): +def check_mph_dir_structure(plot_dir: str, point_names: List[str], combined: bool = False): """Checks MPH directory for minimum expected structure Args: - img_out_dir (str): + plot_dir (str): Folder containing MPH plot output point_names (list): List of expected point names @@ -212,11 +212,11 @@ def check_mph_dir_structure(img_out_dir: str, point_names: List[str], combined: Assertion error on missing csv """ for point in point_names: - assert(os.path.exists(os.path.join(img_out_dir, f'{point}-pulse_height.csv'))) + assert(os.path.exists(os.path.join(plot_dir, f'{point}-pulse_height.csv'))) if combined: - assert(os.path.exists(os.path.join(img_out_dir, 'total_count_vs_mph_data.csv'))) - assert(os.path.exists(os.path.join(img_out_dir, 'fov_vs_mph.jpg'))) + assert(os.path.exists(os.path.join(plot_dir, 'total_count_vs_mph_data.csv'))) + assert(os.path.exists(os.path.join(plot_dir, 'fov_vs_mph.jpg'))) def create_sample_run(name_list, run_order_list, scan_count_list, create_json=False, bad=False): diff --git a/toffy/watcher_callbacks.py b/toffy/watcher_callbacks.py index 852483a1..680d3a31 100644 --- a/toffy/watcher_callbacks.py +++ b/toffy/watcher_callbacks.py @@ -54,12 +54,12 @@ def plot_qc_metrics(self, qc_out_dir: str, **kwargs): qc_df = pd.read_csv(os.path.join(qc_out_dir, 'combined_%s.csv' % ms)) visualize_qc_metrics(qc_df, metric_name, ax=axes[i], **viz_kwargs) - def plot_mph_metrics(self, mph_out_dir, img_out_dir, **kwargs): + def plot_mph_metrics(self, mph_out_dir, plot_dir, **kwargs): """Plots mph metrics generated by the `generate_mph` callback Args: mph_out_dir (str): directory containing mph metric csv - img_out_dir (str): director to store the plot to + plot_dir (str): director to store the plot to **kwargs (Dict[str, Any]): Additional arguments for `toffy.mph_comp.visualize_mph`. Accepted kwargs are @@ -71,7 +71,7 @@ def plot_mph_metrics(self, mph_out_dir, img_out_dir, **kwargs): viz_kwargs = {k: v for k, v in kwargs.items() if k in valid_kwargs} mph_df = combine_mph_metrics(mph_out_dir, return_data=True) - visualize_mph(mph_df, img_out_dir, **viz_kwargs) + visualize_mph(mph_df, plot_dir, **viz_kwargs) @dataclass diff --git a/toffy/watcher_callbacks_test.py b/toffy/watcher_callbacks_test.py index de007309..cdf69e1c 100644 --- a/toffy/watcher_callbacks_test.py +++ b/toffy/watcher_callbacks_test.py @@ -57,7 +57,7 @@ def test_build_callbacks(callbacks, kwargs, data_path): kwargs['tiff_out_dir'] = extracted_dir kwargs['qc_out_dir'] = qc_dir kwargs['mph_out_dir'] = qc_dir - kwargs['img_out_dir'] = qc_dir + kwargs['plot_dir'] = qc_dir if kwargs.get('save_dir', False): kwargs['save_dir'] = qc_dir From 15057913bc58affe4d49a6f201e4b830cffe18d0 Mon Sep 17 00:00:00 2001 From: camisowers Date: Thu, 23 Jun 2022 10:27:59 -0700 Subject: [PATCH 79/94] img_out_dir -> plot_dir 2 --- templates/3a_monitor_MIBI_run.ipynb | 8 ++++---- toffy/fov_watcher_test.py | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/templates/3a_monitor_MIBI_run.ipynb b/templates/3a_monitor_MIBI_run.ipynb index 82d5c056..34b0c63e 100644 --- a/templates/3a_monitor_MIBI_run.ipynb +++ b/templates/3a_monitor_MIBI_run.ipynb @@ -113,7 +113,7 @@ " tiff_out_dir=extraction_dir,\n", " qc_out_dir=qc_dir,\n", " mph_out_dir=qc_dir,\n", - " img_out_dir=qc_dir,\n", + " plot_dir=qc_dir,\n", " panel=panel,\n", " intensities=False,\n", " regression=False,\n", @@ -132,9 +132,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "toffy_env", "language": "python", - "name": "python3" + "name": "toffy_env" }, "language_info": { "codemirror_mode": { @@ -146,7 +146,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.13" } }, "nbformat": 4, diff --git a/toffy/fov_watcher_test.py b/toffy/fov_watcher_test.py index d72c5079..bef029a6 100644 --- a/toffy/fov_watcher_test.py +++ b/toffy/fov_watcher_test.py @@ -67,13 +67,13 @@ def test_watcher(run_cbs, fov_cbs, kwargs, validators, add_blank): tiff_out_dir = os.path.join(tmpdir, 'cb_0', RUN_DIR_NAME) qc_out_dir = os.path.join(tmpdir, 'cb_1', RUN_DIR_NAME) mph_out_dir = os.path.join(tmpdir, 'cb_2', RUN_DIR_NAME) - img_out_dir = os.path.join(tmpdir, 'cb_3', RUN_DIR_NAME) + plot_dir = os.path.join(tmpdir, 'cb_3', RUN_DIR_NAME) # add directories to kwargs kwargs['tiff_out_dir'] = tiff_out_dir kwargs['qc_out_dir'] = qc_out_dir kwargs['mph_out_dir'] = mph_out_dir - kwargs['img_out_dir'] = img_out_dir + kwargs['plot_dir'] = plot_dir run_data = os.path.join(tmpdir, 'test_run') log_out = os.path.join(tmpdir, 'log_output') From 445a42845ff671ad6b5510d0c54151e10db2fef1 Mon Sep 17 00:00:00 2001 From: camisowers Date: Thu, 23 Jun 2022 14:00:33 -0700 Subject: [PATCH 80/94] csv renaming --- toffy/mph_comp_test.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index e2004e87..70506a2e 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -58,7 +58,7 @@ def test_compute_mph_metrics(): # test successful data retrieval and csv output mph.compute_mph_metrics(bin_file_path, tmpdir, fov_name) - csv_path = os.path.join(tmpdir, fov_name + '-pulse_height.csv') + csv_path = os.path.join(tmpdir, fov_name + '-mph_pulse.csv') assert os.path.exists(csv_path) # check the csv data is correct @@ -80,8 +80,8 @@ def test_combine_mph_metrics(): with tempfile.TemporaryDirectory() as tmpdir: csv_path = tmpdir - data1.to_csv(os.path.join(csv_path, 'fov-1-scan-1-pulse_height.csv'), index=False) - data2.to_csv(os.path.join(csv_path, 'fov-2-scan-1-pulse_height.csv'), index=False) + data1.to_csv(os.path.join(csv_path, 'fov-1-scan-1-mph_pulse.csv'), index=False) + data2.to_csv(os.path.join(csv_path, 'fov-2-scan-1-mph_pulse.csv'), index=False) combined_data = pd.concat([data1, data2], axis=0, ignore_index=True) combined_data['cum_total_count'] = [50000, 120000] From 8f0a7cbc3eb2b09baac93c4beb8f639259710ccf Mon Sep 17 00:00:00 2001 From: camisowers Date: Mon, 27 Jun 2022 11:14:02 -0700 Subject: [PATCH 81/94] new data and fov sortiing --- templates/3d_example_MPH_plots.ipynb | 29 ++++++++++++++++++---------- toffy/mph_comp.py | 6 ++++++ 2 files changed, 25 insertions(+), 10 deletions(-) diff --git a/templates/3d_example_MPH_plots.ipynb b/templates/3d_example_MPH_plots.ipynb index b9c3aae7..754d2da1 100644 --- a/templates/3d_example_MPH_plots.ipynb +++ b/templates/3d_example_MPH_plots.ipynb @@ -1,9 +1,17 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "dbec154c", + "metadata": {}, + "source": [ + "# Example MPH Plots" + ] + }, { "cell_type": "code", - "execution_count": 1, - "id": "bc698d45-fbb1-45f3-ad36-33d262ad2858", + "execution_count": null, + "id": "b4973eb5", "metadata": {}, "outputs": [], "source": [ @@ -13,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 91, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -42,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 20, "id": "fc2b28d1-1a05-45ac-ab7b-80d9f04acd96", "metadata": {}, "outputs": [], @@ -69,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "id": "fefbfe63-8c92-45ba-9bad-0aac3b6a7c72", "metadata": {}, "outputs": [], @@ -99,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 62, "id": "162f8549-6d7d-44f4-9436-09e70fcbef40", "metadata": {}, "outputs": [], @@ -111,13 +119,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 105, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -135,13 +143,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 106, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -153,6 +161,7 @@ "source": [ "# plot with regression line\n", "regression = True\n", + "\n", "mph_comp.visualize_mph(df_mph, mph_dir, regression)" ] } diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 6da28ac0..522be545 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -102,8 +102,14 @@ def combine_mph_metrics(csv_dir, return_data=False): # calculate cumulative sums of total counts and time combined_df = pd.concat(combined_rows) + run_order = [] + for index, row in combined_df.iterrows(): + run_order.append(int(''.join(filter(str.isdigit, row['fov'])))) + combined_df['run_order'] = run_order + combined_df = combined_df.sort_values(by=['run_order']) combined_df['cum_total_count'] = combined_df['total_count'].cumsum() combined_df['cum_total_time'] = combined_df['time'].cumsum() + combined_df = combined_df.drop(columns=['run_order']) # save csv to csv_dir file_path = os.path.join(csv_dir, 'total_count_vs_mph_data.csv') From 685708756d610d596c229e99b35f5d5a22c62939 Mon Sep 17 00:00:00 2001 From: camisowers Date: Mon, 27 Jun 2022 18:00:26 -0700 Subject: [PATCH 82/94] time axis accurate --- templates/3d_example_MPH_plots.ipynb | 12 ++++++------ toffy/mph_comp.py | 23 +++++++++++++++++++---- 2 files changed, 25 insertions(+), 10 deletions(-) diff --git a/templates/3d_example_MPH_plots.ipynb b/templates/3d_example_MPH_plots.ipynb index 754d2da1..fd3a1e91 100644 --- a/templates/3d_example_MPH_plots.ipynb +++ b/templates/3d_example_MPH_plots.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "b4973eb5", "metadata": {}, "outputs": [], @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": null, "id": "87437522-8ec9-4c03-a03a-0e63584ac24f", "metadata": {}, "outputs": [], @@ -119,13 +119,13 @@ }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 4, "id": "1a6da8b5-a83e-4be0-a4af-cf80838955e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -143,13 +143,13 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": 5, "id": "2978b381-e574-4b0c-9f66-b5176eaade51", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 522be545..a72b3df0 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -139,15 +139,30 @@ def visualize_mph(mph_df, out_dir, regression: bool = False): # plt.title('FOV total counts vs median pulse height') fig = plt.figure() ax1 = fig.add_subplot(111) - ax2 = ax1.twiny() x = mph_df['cum_total_count']/1000000 y = mph_df['MPH'] - x_alt = mph_df['cum_total_time']/(3600*1000) ax1.set_xlabel('FOV cumulative count (in millions)') ax1.set_ylabel('median pulse height') - ax2.set_xlabel('estimated time (hours)') ax1.scatter(x, y) - ax2.scatter(x_alt, y, s=0) + ax2 = ax1.twiny() + ax2.set_xlabel('estimated time (hours)') + + # create time axis + sub_df = mph_df[['cum_total_count', 'cum_total_time']] + total_time = sub_df.at[len(sub_df.index)-1, 'cum_total_time'] + tick_num = int(total_time / (6*(3600*1000))) + tick_labels = [i * 6 for i in range(0, tick_num+1)] + time_ticks = [tick*(3600*1000) for tick in tick_labels[1:len(tick_labels)]] + + tick_locations = [0] + for tick in time_ticks: + count_tick = (sub_df.iloc[(sub_df['cum_total_time'] - tick).abs().argsort()[:1]])['cum_total_count'] + count_tick = (count_tick.to_string()).split(' ')[4] + tick_locations.append(int(count_tick)/1000000) + + ax2.set_xlim(ax1.get_xlim()) + ax2.set_xticks(tick_locations) + ax2.set_xticklabels(tick_labels) plt.gcf().set_size_inches(18.5, 10.5) # plot regression line From 016356e8640c6b52cbf338140ca9a9ec0d8779be Mon Sep 17 00:00:00 2001 From: camisowers Date: Tue, 28 Jun 2022 15:51:14 -0700 Subject: [PATCH 83/94] stray pulse_height.csv --- toffy/test_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index 35dfc1c1..e5dc8d4d 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -212,7 +212,7 @@ def check_mph_dir_structure(plot_dir: str, point_names: List[str], combined: boo Assertion error on missing csv """ for point in point_names: - assert(os.path.exists(os.path.join(plot_dir, f'{point}-pulse_height.csv'))) + assert(os.path.exists(os.path.join(plot_dir, f'{point}-mph_pulse.csv'))) if combined: assert(os.path.exists(os.path.join(plot_dir, 'total_count_vs_mph_data.csv'))) From 5614cb6f8d635d8b44140f2c783ebfcbe56f54a6 Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 29 Jun 2022 10:40:18 -0700 Subject: [PATCH 84/94] separate generate_time_ticks() function --- toffy/mph_comp.py | 40 ++++++++++++++++++++++++++++------------ 1 file changed, 28 insertions(+), 12 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index a72b3df0..bb0d9741 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -39,6 +39,31 @@ def get_estimated_time(bin_file_dir, fov): return estimated_time +def generate_time_ticks(mph_df): + """Create a time axis for median pulse heights with ticks at approx. 6 hour increments + Args: + mph_df: contains mph date, specifically requires cum_total_count and cum_total_time columns + Returns: + list of two lists detailing tick locations and tick number labels + """ + + # determine number of ticks and what the labels should be based on total run time + sub_df = mph_df[['cum_total_count', 'cum_total_time']] + total_time = sub_df['cum_total_time'].iloc[-1] + tick_num = int(total_time / (6*(3600*1000))) + tick_labels = [i * 6 for i in range(0, tick_num+1)] + time_ticks = [tick*(3600*1000) for tick in tick_labels[1:len(tick_labels)]] + + # find count value associated with the time closest to each tick + tick_locations = [0] + for tick in time_ticks: + count_tick = (sub_df.iloc[(sub_df['cum_total_time'] - tick).abs().argsort()[:1]])['cum_total_count'] + count_tick = (count_tick.to_string()).split(' ')[4] + tick_locations.append(int(count_tick)/1000000) + + return [tick_locations, tick_labels] + + def compute_mph_metrics(bin_file_dir, csv_dir, fov, mass=98, mass_start=97.5, mass_stop=98.5): """Retrieves total counts, pulse heights, & estimated time for a given FOV Args: @@ -148,18 +173,9 @@ def visualize_mph(mph_df, out_dir, regression: bool = False): ax2.set_xlabel('estimated time (hours)') # create time axis - sub_df = mph_df[['cum_total_count', 'cum_total_time']] - total_time = sub_df.at[len(sub_df.index)-1, 'cum_total_time'] - tick_num = int(total_time / (6*(3600*1000))) - tick_labels = [i * 6 for i in range(0, tick_num+1)] - time_ticks = [tick*(3600*1000) for tick in tick_labels[1:len(tick_labels)]] - - tick_locations = [0] - for tick in time_ticks: - count_tick = (sub_df.iloc[(sub_df['cum_total_time'] - tick).abs().argsort()[:1]])['cum_total_count'] - count_tick = (count_tick.to_string()).split(' ')[4] - tick_locations.append(int(count_tick)/1000000) - + new_ticks = generate_time_ticks(mph_df) + tick_locations = new_ticks[0] + tick_labels = new_ticks[1] ax2.set_xlim(ax1.get_xlim()) ax2.set_xticks(tick_locations) ax2.set_xticklabels(tick_labels) From 9d83c0e87b8aa09c6ab5dcb580fae65dc30e55e7 Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 29 Jun 2022 11:41:32 -0700 Subject: [PATCH 85/94] test_generate_time_ticks --- toffy/mph_comp_test.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 70506a2e..b23b1a39 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -46,6 +46,22 @@ def test_get_estimated_time(): assert mph.get_estimated_time(good_path, good_fov) == 512 +def test_generate_time_ticks(): + example_df = {'cum_total_count': [1,2,3,4,5,6,7,8,9], 'cum_total_time': [5, 9, 11, 12.5, 14, 16, 19, 20, 23]} + example_df = pd.DataFrame(example_df) + for i in range(0, len(example_df)): + example_df['cum_total_time'][i] = example_df['cum_total_time'][i] * 3600 * 1000 + example_df['cum_total_count'][i] = example_df['cum_total_count'][i] * 1000000 + new_ticks = mph.generate_time_ticks(example_df) + + correct_locations = [0, 1, 4, 7] + correct_labels = [0, 6, 12, 18] + + # test successful new ticks + assert new_ticks[0] == correct_locations + assert new_ticks[1] == correct_labels + + def test_compute_mph_metrics(): bin_file_path = os.path.join(Path(__file__).parent, "data", "tissue") fov_name = 'fov-1-scan-1' From 0292f79a3e13a85a23c87a95ea97d1b4890f81b9 Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 29 Jun 2022 14:09:53 -0700 Subject: [PATCH 86/94] use normalize.compute_run_metrics, changes to mph_pulse_combined.csv --- toffy/mph_comp.py | 16 +++++----------- toffy/mph_comp_test.py | 4 ++-- toffy/test_utils.py | 2 +- 3 files changed, 8 insertions(+), 14 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index bb0d9741..c6d2f8b0 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -6,6 +6,7 @@ from mibi_bin_tools import bin_files from ark.utils import io_utils +from toffy.normalize import combine_run_metrics def get_estimated_time(bin_file_dir, fov): @@ -119,14 +120,11 @@ def combine_mph_metrics(csv_dir, return_data=False): # path validation checks io_utils.validate_paths(csv_dir) - # for each csv retrieve mph values - fov_files = io_utils.list_files(csv_dir, "-mph_pulse.csv") - combined_rows = [] - for i, file in enumerate(fov_files): - combined_rows.append(pd.read_csv(os.path.join(csv_dir, file))) + # combine individual csv files + combine_run_metrics(csv_dir, 'mph_pulse') # calculate cumulative sums of total counts and time - combined_df = pd.concat(combined_rows) + combined_df = pd.read_csv(os.path.join(csv_dir, 'mph_pulse_combined.csv')) run_order = [] for index, row in combined_df.iterrows(): run_order.append(int(''.join(filter(str.isdigit, row['fov'])))) @@ -136,11 +134,7 @@ def combine_mph_metrics(csv_dir, return_data=False): combined_df['cum_total_time'] = combined_df['time'].cumsum() combined_df = combined_df.drop(columns=['run_order']) - # save csv to csv_dir - file_path = os.path.join(csv_dir, 'total_count_vs_mph_data.csv') - if os.path.exists(file_path): - os.remove(file_path) - combined_df.to_csv(file_path, index=False) + combined_df.to_csv(os.path.join(csv_dir, 'mph_pulse_combined.csv'), index=False) # return data if return_data: diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index b23b1a39..9ca9cfa9 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -47,7 +47,7 @@ def test_get_estimated_time(): def test_generate_time_ticks(): - example_df = {'cum_total_count': [1,2,3,4,5,6,7,8,9], 'cum_total_time': [5, 9, 11, 12.5, 14, 16, 19, 20, 23]} + example_df = {'cum_total_count': list(range(1, 10)), 'cum_total_time': [5, 9, 11, 12.5, 14, 16, 19, 20, 23]} example_df = pd.DataFrame(example_df) for i in range(0, len(example_df)): example_df['cum_total_time'][i] = example_df['cum_total_time'][i] * 3600 * 1000 @@ -105,7 +105,7 @@ def test_combine_mph_metrics(): # test successful data retrieval and csv output mph.combine_mph_metrics(csv_path) - combined_csv_path = os.path.join(csv_path, 'total_count_vs_mph_data.csv') + combined_csv_path = os.path.join(csv_path, 'mph_pulse_combined.csv') csv_data = pd.read_csv(combined_csv_path) assert os.path.exists(combined_csv_path) assert csv_data.equals(combined_data) diff --git a/toffy/test_utils.py b/toffy/test_utils.py index e5dc8d4d..217c0d2c 100644 --- a/toffy/test_utils.py +++ b/toffy/test_utils.py @@ -215,7 +215,7 @@ def check_mph_dir_structure(plot_dir: str, point_names: List[str], combined: boo assert(os.path.exists(os.path.join(plot_dir, f'{point}-mph_pulse.csv'))) if combined: - assert(os.path.exists(os.path.join(plot_dir, 'total_count_vs_mph_data.csv'))) + assert(os.path.exists(os.path.join(plot_dir, 'mph_pulse_combined.csv'))) assert(os.path.exists(os.path.join(plot_dir, 'fov_vs_mph.jpg'))) From 3b8d7389ae10dc943740a843ec688cef5eadb776 Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 29 Jun 2022 14:19:13 -0700 Subject: [PATCH 87/94] edit notebook for new csv name --- templates/3d_example_MPH_plots.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/templates/3d_example_MPH_plots.ipynb b/templates/3d_example_MPH_plots.ipynb index fd3a1e91..3864e10d 100644 --- a/templates/3d_example_MPH_plots.ipynb +++ b/templates/3d_example_MPH_plots.ipynb @@ -136,7 +136,7 @@ ], "source": [ "# visualize the median pulse heights\n", - "df_mph = pd.read_csv(os.path.join(mph_dir, 'total_count_vs_mph_data.csv'))\n", + "df_mph = pd.read_csv(os.path.join(mph_dir, 'mph_pulse_combined.csv'))\n", "\n", "mph_comp.visualize_mph(df_mph, mph_dir)" ] From e5d99b2322891f9a12719ba9f1223b65cd2f4211 Mon Sep 17 00:00:00 2001 From: camisowers Date: Wed, 29 Jun 2022 14:58:49 -0700 Subject: [PATCH 88/94] pycodestyle --- toffy/mph_comp.py | 3 ++- toffy/mph_comp_test.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index c6d2f8b0..1d2ca72a 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -58,7 +58,8 @@ def generate_time_ticks(mph_df): # find count value associated with the time closest to each tick tick_locations = [0] for tick in time_ticks: - count_tick = (sub_df.iloc[(sub_df['cum_total_time'] - tick).abs().argsort()[:1]])['cum_total_count'] + count_tick = (sub_df.iloc[(sub_df['cum_total_time'] + - tick).abs().argsort()[:1]])['cum_total_count'] count_tick = (count_tick.to_string()).split(' ')[4] tick_locations.append(int(count_tick)/1000000) diff --git a/toffy/mph_comp_test.py b/toffy/mph_comp_test.py index 9ca9cfa9..fb86220e 100644 --- a/toffy/mph_comp_test.py +++ b/toffy/mph_comp_test.py @@ -47,7 +47,8 @@ def test_get_estimated_time(): def test_generate_time_ticks(): - example_df = {'cum_total_count': list(range(1, 10)), 'cum_total_time': [5, 9, 11, 12.5, 14, 16, 19, 20, 23]} + example_df = {'cum_total_count': list(range(1, 10)), + 'cum_total_time': [5, 9, 11, 12.5, 14, 16, 19, 20, 23]} example_df = pd.DataFrame(example_df) for i in range(0, len(example_df)): example_df['cum_total_time'][i] = example_df['cum_total_time'][i] * 3600 * 1000 From 23c1ff2345bbcf2c0dec7a0e17f3d1f4d513a404 Mon Sep 17 00:00:00 2001 From: camisowers Date: Thu, 30 Jun 2022 14:08:49 -0700 Subject: [PATCH 89/94] pycodestyle --- toffy/mph_comp.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 1d2ca72a..854229f7 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -43,7 +43,8 @@ def get_estimated_time(bin_file_dir, fov): def generate_time_ticks(mph_df): """Create a time axis for median pulse heights with ticks at approx. 6 hour increments Args: - mph_df: contains mph date, specifically requires cum_total_count and cum_total_time columns + mph_df: contains mph date, specifically requires cum_total_count and cum_total_time + columns Returns: list of two lists detailing tick locations and tick number labels """ From 08a2e688c3cfe7be41d0e5a3f5cd6575e0c73fcf Mon Sep 17 00:00:00 2001 From: camisowers Date: Fri, 8 Jul 2022 12:03:54 -0700 Subject: [PATCH 90/94] notebook tested on data and comments --- templates/3a_monitor_MIBI_run.ipynb | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/templates/3a_monitor_MIBI_run.ipynb b/templates/3a_monitor_MIBI_run.ipynb index 34b0c63e..fccfe0ce 100644 --- a/templates/3a_monitor_MIBI_run.ipynb +++ b/templates/3a_monitor_MIBI_run.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -7,7 +14,7 @@ "# Monitoring an ongoing MIBI run\n", "\n", "This notebook can be run alongside an active MIBIScope run. As images are generated, this notebook will automatically pass the data through pre-specified functions, like tiff \n", - "extraction, qc metric computation, etc. Eventually, all of the processing steps in the toffy repo will be incorporated into the Watcher functionality here. For now, this notebook will automatically extract tifs and generate QC plots of your data. \n", + "extraction, qc metric computation, etc. Eventually, all of the processing steps in the toffy repo will be incorporated into the Watcher functionality here. For now, this notebook will automatically extract tifs and generate the QC and MPH plots of your data. \n", "\n", "## This notebook is an example: create a copy before running it or you will get merge conflicts!" ] From 4d285d85a40701f1f73f6e2a2ef01b00e81e6270 Mon Sep 17 00:00:00 2001 From: camisowers Date: Sun, 10 Jul 2022 22:41:03 -0700 Subject: [PATCH 91/94] notebook updated --- templates/3d_example_MPH_plots.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/templates/3d_example_MPH_plots.ipynb b/templates/3d_example_MPH_plots.ipynb index 3864e10d..1403644b 100644 --- a/templates/3d_example_MPH_plots.ipynb +++ b/templates/3d_example_MPH_plots.ipynb @@ -5,7 +5,9 @@ "id": "dbec154c", "metadata": {}, "source": [ - "# Example MPH Plots" + "# Example MPH Plots\n", + "## This notebook is an example: create a copy before running it or you will get merge conflicts!\n", + "This notebook can be run to generate plots showing the median pulse heights for each FOV along with the estimated run time." ] }, { From 52dbe1ea977858b6983b68eaf2ee67c2a0449260 Mon Sep 17 00:00:00 2001 From: camisowers Date: Tue, 12 Jul 2022 13:18:54 -0700 Subject: [PATCH 92/94] natsort and readme update --- README.md | 6 ++++-- toffy/mph_comp.py | 8 ++------ 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 621b7ce8..3f6d4cc9 100644 --- a/README.md +++ b/README.md @@ -34,8 +34,10 @@ The [second notebook](./templates/2_create_tma_mibi_run.ipynb) is for TMAs. This There are a number of different computational tasks to complete once a MIBI run has finished to ensure everything went smoothly. - 3a: real time monitoring. The [MIBI monitoring](./templates/3a_monitor_MIBI_run.ipynb) notebook will monitor an ongoing MIBI run, and begin processing the image data as soon as it is generated. This notebook is being continually be updated as we move more of our processing pipeline to happen in real time as the data is generated. -- 3b: post-run monitoring. For each step in the monitoring notebook, we have a dedicated notebook that can perform the same tasks once a run is complete. This includes [the image extraction notebook](./templates/extract_bin_file.ipynb) and the [qc metrics notebook](./templates/3b_generate_qc_metrics.ipynb). -- 3d: visualizing. The [example MPH plots notebook](./templates/3d_example_MPH_plots.ipynb) can be run to generate plots showing median pulse heights for each FOV along with estimated run time. +- 3b - 3d: post-run monitoring. For each step in the monitoring notebook, we have a dedicated notebook that can perform the same tasks once a run is complete. + - 3b: [the image extraction notebook](./templates/extract_bin_file.ipynb) will extract images from bin files that have not already been processed + - 3c: [qc metrics notebook](./templates/3b_generate_qc_metrics.ipynb) computes and visualizes the QC metrics for the images + - 3d: [median pulse heights notebook](./templates/3d_example_MPH_plots.ipynb) generates plots showing median pulse heights for each FOV, along with estimated run time ### 4. Processing MIBI data Once your run has finished, you can begin to process the data to make it ready for analysis. To remove background signal contamination, as well as compensate for channel crosstalk, you can use the [compensation](./templates/4a_compensate_image_data.ipynb) notebook. This will guide you through the Rosetta algorithm, which uses a flow-cytometry style compensation approach to remove spurious signal. diff --git a/toffy/mph_comp.py b/toffy/mph_comp.py index 854229f7..78dfa891 100644 --- a/toffy/mph_comp.py +++ b/toffy/mph_comp.py @@ -3,6 +3,7 @@ import numpy as np import json import matplotlib.pyplot as plt +from natsort import natsort_keygen from mibi_bin_tools import bin_files from ark.utils import io_utils @@ -127,14 +128,9 @@ def combine_mph_metrics(csv_dir, return_data=False): # calculate cumulative sums of total counts and time combined_df = pd.read_csv(os.path.join(csv_dir, 'mph_pulse_combined.csv')) - run_order = [] - for index, row in combined_df.iterrows(): - run_order.append(int(''.join(filter(str.isdigit, row['fov'])))) - combined_df['run_order'] = run_order - combined_df = combined_df.sort_values(by=['run_order']) + combined_df = combined_df.sort_values(by="fov", key=natsort_keygen()) combined_df['cum_total_count'] = combined_df['total_count'].cumsum() combined_df['cum_total_time'] = combined_df['time'].cumsum() - combined_df = combined_df.drop(columns=['run_order']) combined_df.to_csv(os.path.join(csv_dir, 'mph_pulse_combined.csv'), index=False) From 6139219b05a259acc8a5b3bf07308d013db87364 Mon Sep 17 00:00:00 2001 From: camisowers Date: Tue, 12 Jul 2022 13:53:04 -0700 Subject: [PATCH 93/94] notebook renaming --- ...{3b_generate_qc_metrics.ipynb => 3c_generate_qc_metrics.ipynb} | 0 ...ample_MPH_plots.ipynb => 3d_compute_median_pulse_height.ipynb} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename templates/{3b_generate_qc_metrics.ipynb => 3c_generate_qc_metrics.ipynb} (100%) rename templates/{3d_example_MPH_plots.ipynb => 3d_compute_median_pulse_height.ipynb} (100%) diff --git a/templates/3b_generate_qc_metrics.ipynb b/templates/3c_generate_qc_metrics.ipynb similarity index 100% rename from templates/3b_generate_qc_metrics.ipynb rename to templates/3c_generate_qc_metrics.ipynb diff --git a/templates/3d_example_MPH_plots.ipynb b/templates/3d_compute_median_pulse_height.ipynb similarity index 100% rename from templates/3d_example_MPH_plots.ipynb rename to templates/3d_compute_median_pulse_height.ipynb From 0f9b8c240d7fab45cd5f551a648742b7d4594335 Mon Sep 17 00:00:00 2001 From: camisowers Date: Tue, 12 Jul 2022 13:57:48 -0700 Subject: [PATCH 94/94] broken links fix --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 3f6d4cc9..092f2969 100644 --- a/README.md +++ b/README.md @@ -36,8 +36,8 @@ There are a number of different computational tasks to complete once a MIBI run - 3a: real time monitoring. The [MIBI monitoring](./templates/3a_monitor_MIBI_run.ipynb) notebook will monitor an ongoing MIBI run, and begin processing the image data as soon as it is generated. This notebook is being continually be updated as we move more of our processing pipeline to happen in real time as the data is generated. - 3b - 3d: post-run monitoring. For each step in the monitoring notebook, we have a dedicated notebook that can perform the same tasks once a run is complete. - 3b: [the image extraction notebook](./templates/extract_bin_file.ipynb) will extract images from bin files that have not already been processed - - 3c: [qc metrics notebook](./templates/3b_generate_qc_metrics.ipynb) computes and visualizes the QC metrics for the images - - 3d: [median pulse heights notebook](./templates/3d_example_MPH_plots.ipynb) generates plots showing median pulse heights for each FOV, along with estimated run time + - 3c: [qc metrics notebook](./templates/3c_generate_qc_metrics.ipynb) computes and visualizes the QC metrics for the images + - 3d: [median pulse heights notebook](./templates/3d_compute_median_pulse_height.ipynb) generates plots showing median pulse heights for each FOV, along with estimated run time ### 4. Processing MIBI data Once your run has finished, you can begin to process the data to make it ready for analysis. To remove background signal contamination, as well as compensate for channel crosstalk, you can use the [compensation](./templates/4a_compensate_image_data.ipynb) notebook. This will guide you through the Rosetta algorithm, which uses a flow-cytometry style compensation approach to remove spurious signal.