From 1314a1149ec002a87b6f422aa344cbd5d1526405 Mon Sep 17 00:00:00 2001 From: dtaghayor Date: Tue, 23 Jun 2026 01:14:09 +0200 Subject: [PATCH 1/2] adding the angular analysis of the pmts and finding the charge inside and outside the expected Cherenkov cone --- .../Example Ring Angular Analysis.ipynb | 942 ++++++++++++ analysis_tools/__init__.py | 14 +- analysis_tools/ring_analysis.py | 1288 +++++++++++++++++ 3 files changed, 2241 insertions(+), 3 deletions(-) create mode 100644 analysis_examples/Example Ring Angular Analysis.ipynb create mode 100644 analysis_tools/ring_analysis.py diff --git a/analysis_examples/Example Ring Angular Analysis.ipynb b/analysis_examples/Example Ring Angular Analysis.ipynb new file mode 100644 index 0000000..daade2d --- /dev/null +++ b/analysis_examples/Example Ring Angular Analysis.ipynb @@ -0,0 +1,942 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c0907d24", + "metadata": {}, + "source": [ + "# Example: Cherenkov ring angular analysis \n", + "\n", + "This example shows the standardised, class-based way to do the *tank-side* part\n", + "of a pion / single-ring analysis:\n", + "\n", + "1. load data and apply data-quality cuts with `DataLoader`,\n", + "2. (optionally) select a particle type from the beam monitors with `BeamSelection`,\n", + "3. use `RingGeometry` to turn each hit into an angle relative to the beam and a\n", + " time residual (hit time minus time-of-flight from the beam entry point),\n", + "4. use `CherenkovRingSelection` to apply a prompt-time window and a Cherenkov-cone\n", + " angular cut, and split each event's charge into the part **inside** the cone\n", + " and the part **outside** it,\n", + "5. classify events into track-like (low charge outside the expectred cone) vs shower-like (high charge outside the expectred cone) topologies and plot.\n", + "\n", + "The PMT positions come from Dean's `Geometry` package (design or survey\n", + "placements). The same code also works with the in-repo `DetectorGeometry` if you\n", + "prefer -- see the geometry cell." + ] + }, + { + "cell_type": "markdown", + "id": "94b08acc", + "metadata": {}, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "433980b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Geometry at: /eos/user/s/staghayo/SWAN_projects/Geometry/Geometry/__init__.py\n" + ] + } + ], + "source": [ + "import time\n", + "import numpy as np\n", + "import awkward as ak\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Note: if you edit analysis_tools (or change sys.path), do Kernel -> Restart,\n", + "# then re-run. A live kernel keeps the already-imported modules cached;\n", + "# importlib.reload(analysis_tools) does NOT reload its submodules.\n", + "import analysis_tools\n", + "\n", + "from analysis_tools import (\n", + " DataLoader,\n", + " BeamSelection,\n", + " RingGeometry,\n", + " BeamGeometry,\n", + " CherenkovRingSelection,\n", + " RingResults,\n", + " classify_charge_topology,\n", + " plot_inside_vs_outside,\n", + " load_geometry_package_positions,\n", + " cherenkov_angle_deg,\n", + " cherenkov_cone_halfangle,\n", + ")\n", + "# DetectorGeometry is also importable if you prefer the in-repo geometry:\n", + "# from analysis_tools import DetectorGeometry\n", + "\n", + "\n", + "\n", + "\n", + "#change later\n", + "# The Geometry package must be importable in THIS kernel. Point at the directory\n", + "# that CONTAINS the Geometry/ package folder, then verify before constructing.\n", + "# (Do Kernel -> Restart & Run All after changing paths; edits to imported modules\n", + "# are not picked up by a live kernel.)\n", + "import sys\n", + "GEO_PKG_DIR = \"/eos/user/s/staghayo/SWAN_projects/Geometry\" # dir containing Geometry/\n", + "GEO_FILE = f\"{GEO_PKG_DIR}/examples/wcte_bldg157.geo\"\n", + "\n", + "if GEO_PKG_DIR not in sys.path:\n", + " sys.path.insert(0, GEO_PKG_DIR)\n", + "import Geometry # must succeed; check the printed path\n", + "print(\"Geometry at:\", Geometry.__file__)" + ] + }, + { + "cell_type": "markdown", + "id": "ff4b9553", + "metadata": {}, + "source": [ + "### Open the file, use the data loader tools\n", + "\n", + "Load the data in batches the same way as you did in \"Example Using Data Loader\" notebook.\n", + "You can apply the PID selection cuts to select a particle (in this example pions),\n", + "or run the analysis on samples with specific properties or on everything. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dea53bac", + "metadata": {}, + "outputs": [], + "source": [ + "run_number = 1610\n", + "FILE = f\"/eos/experiment/wcte/data/2025_commissioning/processed_offline_data/production_v1_0/{run_number}/WCTE_merged_production_R{run_number}.root\"\n", + "loader = DataLoader(FILE)\n", + "\n", + "# Apply the standard data-quality cuts. These are applied automatically to every\n", + "# batch returned by loader.iterate().\n", + "loader.apply_mPMT_data_quality_cuts() # window + hit-level mPMT quality masks\n", + "loader.apply_vme_event_quality_cuts() # VME digitisation / event quality" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2e64f207", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1562 good WCTE PMT channels\n" + ] + } + ], + "source": [ + "# Restrict to channels that read out stably during the run (slot*100 + pos).\n", + "good_slots, good_pos = loader.get_good_wcte_pmts()\n", + "good_channels = np.asarray(good_slots) * 100 + np.asarray(good_pos)\n", + "print(len(good_channels), \"good WCTE PMT channels\")" + ] + }, + { + "cell_type": "markdown", + "id": "9371ffce", + "metadata": {}, + "source": [ + "In the next cell you decide what momentum to use and it affects the size of the cherencov cone you're looking at" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "59e32af7", + "metadata": {}, + "outputs": [], + "source": [ + "# Here you can use the nominal run momentum.\n", + "p_tank = abs(float(loader.get_vme_analysis_run_info()[\"run_momentum\"])) # MeV/c\n", + "\n", + "\n", + "# Or for a specific particle (pions here) uncomment the next line to use \n", + "# the estimated particle momentum entering the tank found from the beam monitor detectors\n", + "#p_tank = abs(float(loader.get_vme_analysis_scalar_results()['momentum_after_beam_window_mean_pion'])) # MeV/c " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d02cabb5", + "metadata": {}, + "outputs": [], + "source": [ + "# grab one batch to look at\n", + "demo_batch = next(loader.iterate(step_size=\"50 MB\"))\n", + "\n", + "\n", + "events = demo_batch" + ] + }, + { + "cell_type": "markdown", + "id": "1506de28", + "metadata": {}, + "source": [ + "Optional cell next: apply cuts on beam montior detectors" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a5d75c07", + "metadata": {}, + "outputs": [], + "source": [ + "# restrict to pions selected from the beam monitors.\n", + "vme = loader.get_vme_analysis_scalar_results()\n", + "tof_cut = vme['proton_tof_cut'] or 999\n", + "pion_sel = BeamSelection.pion(\n", + " [\"vme_act_eveto\", \"<\", vme['act_eveto_cut']],\n", + " [\"vme_act_tagger\", \"<\", vme['act_tagger_cut']],\n", + " [\"vme_tof_corr\", \"<\", tof_cut],\n", + ")\n", + "\n", + "\n", + "events = demo_batch[pion_sel.mask(demo_batch)]" + ] + }, + { + "cell_type": "markdown", + "id": "3c29cbfd", + "metadata": {}, + "source": [ + "### Build the geometry / timing \n", + "\n", + "`RingGeometry` computes, for each hit, the angle `theta` between the beam\n", + "direction and the vector from the cone apex (the beam entry point) to the PMT,\n", + "and the time residual `delta_t = hit_time - distance / v_g`. For a fixed apex\n", + "these are precomputed once per channel.\n", + "\n", + "PMT positions here come from Dean's **Geometry** package via\n", + "`from_geometry_package`. `place_info=\"est\"` uses the survey\n", + "placements; pass `\"design\"` instead\n", + "for **design** positions.\n", + "\n", + "The apex on default `origin = (0, 0, -1520+188)` is set approximately based on the beam pipe CAD file. \n", + "The cone apex can also be set **per event** later (e.g.\n", + "the particle entry position from the T5 analysis) or for secondary rings -- see the final section." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "62624b12", + "metadata": {}, + "outputs": [], + "source": [ + "# Bundle the beam configuration (apex, axis, particle, momentum) in one object,\n", + "# kept separate from the detector geometry. Momentum at the tank comes from the\n", + "# beam-side analysis or from a set value (defined earlier)\n", + "\n", + "beam = BeamGeometry(\n", + " origin=(0.0, 0.0, -1520.0 + 188.0), # beam entry point, Geometry-package frame (mm)\n", + " direction=(0.0, 0.0, 1.0), # beam travels along +z\n", + " momentum=p_tank,\n", + " particle=\"pion\",\n", + " n=1.33,\n", + ")\n", + "\n", + "ring = RingGeometry.from_geometry_package(\n", + " GEO_FILE, \n", + " place_info=\"est\", # survey/estimated; use \"design\" for design positions\n", + " beam=beam, # apex + axis come from the BeamGeometry\n", + ")\n", + "\n", + "# Alternative without the external package:\n", + "# from analysis_tools import DetectorGeometry\n", + "# ring = RingGeometry(geometry=DetectorGeometry(), beam=beam)\n" + ] + }, + { + "cell_type": "markdown", + "id": "abc68b43", + "metadata": {}, + "source": [ + "### Define the Cherenkov ring selection\n", + "\n", + "`CherenkovRingSelection` is the hit-level analogue of `BeamSelection`: it holds\n", + "the cut values and turns hit arrays into per-event charge sums. The two cuts are:\n", + "\n", + "- a **prompt-time window** `|delta_t - mu| < K` ns, where `mu` is found per event from \n", + " the peak of the time-residual distribution\n", + " (for a single event you can also fit a gaussian to the time residual histogram\n", + " and take the mean and standard deviation of gaussian), and\n", + "- a **Cherenkov-cone angular cut** `theta < angle_cut_deg`.\n", + "\n", + "Derive the cone angle from the particle's Cherenkov\n", + "angle at that momentum, plus a margin (the momentum given to `BeamGeometry` object above). (You can still pass\n", + "a fixed value, e.g. `angle_cut_deg=44.0`, if you prefer.) `describe()` prints the\n", + "configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c16195e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "p = 760 MeV/c -> Expected Cherenkov angle 40.1 deg, acceptance cone angle 45.1 deg\n", + "CherenkovRingSelection\n", + " cone half-angle : theta < 45.1416 deg\n", + " time cut : on\n", + " prompt-time window : |dt - mu| < 3 ns (peak found in [1670, 1770] ns, 100 bins)\n", + " coarse time pre-cut : 1600 < t < 1800 ns\n", + " min valid hits : 10\n" + ] + } + ], + "source": [ + "# Cone half-angle from the beam's Cherenkov angle (+ margin) -- a fixed value can be given as input instead.\n", + "cone_deg = beam.cone_halfangle(margin_deg=5.0)\n", + "print(f\"p = {beam.momentum:.0f} MeV/c -> Expected Cherenkov angle \"\n", + " f\"{beam.cherenkov_angle_deg():.1f} deg, acceptance cone angle {cone_deg:.1f} deg\")\n", + "\n", + "sel = CherenkovRingSelection(\n", + " ring_geometry=ring,\n", + " angle_cut_deg=cone_deg, # Cherenkov angle + margin\n", + " time_window_K=3.0, # prompt-time half-window (ns)\n", + " fit_t_min=1670.0, # bracket the prompt peak for the dt fit\n", + " fit_t_max=1770.0,\n", + " min_hits=10, # This is the minimum number of hits needed for the event to be processed, this is used to determin the status of the event later\n", + " coarse_time_window=(1600.0, 1800.0), # optional pre-cut on calibrated times based on . Note that these values are run dependent and should be re-optimized for other datasets.\n", + " use_gaussian_fit=False, # False for faster over a full run, histogram-peak mu vs fitting a gaussian and finding the mean\n", + ")\n", + "sel.describe()" + ] + }, + { + "cell_type": "markdown", + "id": "638f464e", + "metadata": {}, + "source": [ + "### Inspect a single event\n", + "\n", + "Pass one event record and `do_plot=True` to see the time-residual fit, the\n", + "prompt window, and the `theta`-vs-`delta_t` scatter used for the cuts. This is\n", + "the quickest way to check that the geometry and time window are sensible before\n", + "running over the whole run." + ] + }, + { + "cell_type": "markdown", + "id": "df4e9108", + "metadata": {}, + "source": [ + "process_event_charge returns a \"status\" value for each event, here are the definition of each:\n", + "\n", + "\"no_hits\" — after the channel-quality keep (good-channel cut, and the coarse time window when the time cut is on) the event had no hits left. All output charges are 0.\n", + "\n", + "\"no_geom\" — there were hits, but none had valid geometry (out-of-range slot/pos, e.g. NaN PMT positions). All output charges are 0.\n", + "\n", + "\"few_hits\" — it had valid-geometry hits, but n_valid <= min_hits (default min_hits=10), so it's treated as too sparse to use. All charges zeroed.\n", + "\n", + "\"no_time\" — it passed the hit-count requirement, but no hits fell in the prompt-time window (|Δt − μ| < K), so q_time = q_inside = q_outside = 0. Note q_total is kept here (it's the one failure stage that doesn't zero q_total). Only possible when apply_time_cut=True.\n", + "\n", + "\"ok\" — passed everything; the charge values are real." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a5437ce7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABFcAAAGbCAYAAAABTH+VAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAt8BJREFUeJzs3Xd4FFXbBvB7d7PpnZRNII1QAiGEjkGqRKoUKUpTUASliICi4isdRUWKIAioCCIIIk1RQJAWXhAhEAgtEAgkIYWElCWBtN35/uDLvCzpyW5mN7l/17UXTNkzz2wCM/PsOc+RCYIggIiIiIiIiIiIKkUudQBERERERERERKaMyRUiIiIiIiIioipgcoWIiIiIiIiIqAqYXCEiIiIiIiIiqgImV4iIiIiIiIiIqoDJFSIiIiIiIiKiKmByhYiIiIiIiIioCphcISIiIiIiIiKqAiZXiIiIiIiIiIiqgMkVIjJqMpkMc+fOrfT7u3btimbNmpW53+3btyGTybBhw4ZKH4uIiKiyZDIZJk+eLHUYRmvu3LmQyWRVbufff/+Fubk57ty5o4eoSF8/F0O3WZorV67AzMwMly5dqrZjUs3E5AqRnmzYsAEymazE1z///CN1iDh58iTmzp2LjIyMcr/n7t27eOmll+Do6Ah7e3sMGDAAt27dMlyQZajMORjS6tWrmZAhIqJyqc5rWEJCAubOnYuIiAiDH0sqn376KXbv3l2h9/znP//B8OHD4ePjY5igjEhlPp/aqGnTpujbty9mz54tdShk4phcIdKz+fPnY9OmTUVeDRo0kDo0nDx5EvPmzSv3TV1WVha6deuGY8eO4aOPPsK8efNw/vx5dOnSBffv3zdssCWo6DmUl4+PDx49eoRXXnmlQu9jcoWIiMrLUNew4iQkJGDevHlMrjwhIiIChw4dwltvvWW4oIxIdSRXPv74Yzx69Migx6gOb731Fnbt2oWbN29KHQqZMDOpAyCqaXr37o02bdpIHYZerF69Gjdu3MC///6Ltm3bAnh8fs2aNcOSJUvw6aefShyh/shkMlhaWkodRoU9fPgQ1tbWUodBRERk9H744Qd4e3vjmWee0Vub2dnZsLGx0Vt7psbMzAxmZqb/SBkaGgonJyds3LgR8+fPlzocMlHsuUJUjfLz8+Hs7IzXXnutyDa1Wg1LS0u899574rrc3FzMmTMHDRo0gIWFBby8vPD+++8jNzdX572F47R3796NZs2awcLCAoGBgdi/f7+4z9y5czFjxgwAgJ+fnzhc6fbt2yXG++uvv6Jt27ZiYgUAAgIC0L17d/zyyy9lnm9qaiquXbuGhw8flrlvbm4upk2bBldXV9jZ2aF///6Ij4/X2acy51DoypUr6NatG6ytrVG3bl188cUXOtuLq7mSlJSE1157DfXq1YOFhQU8PDwwYMAA8Xi+vr64fPkyjh07JsbStWtX8f23bt3C0KFD4ezsDGtrazzzzDP4448/isR2584d9O/fHzY2NnBzc8O0adNw4MAByGQyHD16VNyvsH5MeHg4OnfuDGtra3z00UcAgD179qBv377w9PSEhYUF/P39sWDBAmg0Gp1jFbZx8eJFdOnSBdbW1mjQoAF+/fVXAMCxY8fQvn17WFlZoXHjxjh06FCZny0REZWtvNew0q7lhe7evYvXX38d7u7u4n7r168Xtx89elS8dr/22mvisQqvcWFhYRg6dCi8vb3F+4tp06aV2QPh7NmzkMlk2LhxY5FthdetvXv3AgAePHiAqVOnwtfXFxYWFnBzc8Pzzz+Pc+fOlflZnThxAm3btoWlpSX8/f2xdu3aIvvIZDJkZ2dj48aN4vmNGTOm1HZ3796N5557rkg9D19fX7zwwgv466+/0KJFC1haWqJp06bYuXOnzn6FQ8CPHTuGiRMnws3NDfXq1RO3r169GoGBgbCwsICnpycmTZpUpJdSVa/DhfVIrl27hpdeegn29vaoU6cO3nnnHeTk5FTq8xEEAS4uLpg+fbq4TqvVwtHREQqFQuccPv/8c5iZmSErK0snnieV5760UHl+1gBQUFCABQsWwN/fHxYWFvD19cVHH32kc088ffp01KlTB4IgiOvefvttyGQyrFixQlyXnJwMmUyGb775RlynVCrRtWtX7Nmzp9jjE5WLQER68cMPPwgAhEOHDgkpKSk6r9TUVHG/119/XXB0dBRyc3N13r9x40YBgHDmzBlBEARBo9EIPXr0EKytrYWpU6cKa9euFSZPniyYmZkJAwYM0HkvACE4OFjw8PAQFixYICxfvlyoX7++YG1tLR77woULwvDhwwUAwrJly4RNmzYJmzZtErKysoo9H41GI1hYWAgTJkwosu3jjz8WAAhqtbrUz2TOnDkCAOHIkSNlfXzCqFGjBADCiBEjhK+//loYNGiQ0Lx5cwGAMGfOnEqdgyAIQpcuXQRPT0/By8tLeOedd4TVq1cLzz33nABA+PPPP8X9YmJiBADCDz/8IK7r0KGD4ODgIHz88cfCd999J3z66adCt27dhGPHjgmCIAi7du0S6tWrJwQEBIix/PXXX4IgCEJSUpLg7u4u2NnZCf/5z3+EpUuXCsHBwYJcLhd27twpHiMrK0uoX7++YGVlJXz44YfC8uXLhXbt2gnBwcFFPrsuXboIKpVKcHV1Fd5++21h7dq1wu7duwVBEISBAwcKL730krB48WLhm2++EYYOHSoAEN57770SP48ZM2YIK1euFJo2bSooFAph69atgkqlEubOnSssX75cqFu3ruDg4FDmz5mIiMpW1jWsPNdyQXh8falXr57g5eUlzJ8/X/jmm2+E/v37i+0W7jN//nwBgDB+/HjxWDdv3hQEQRDefvttoU+fPsKnn34qrF27Vhg7dqygUCiEIUOGlHke9evXF/r06VNk/WuvvSY4OTkJeXl5giAIwogRIwRzc3Nh+vTpwnfffSd8/vnnQr9+/YSffvqp1PYvXrwoWFlZCd7e3sKiRYuEBQsWCO7u7uI9QaFNmzYJFhYWQqdOncTzO3nyZIntxsfHCwCEFStWFNnm4+MjNGrUSHB0dBQ+/PBDYenSpUJQUJAgl8vF67og/O9er2nTpkKXLl2ElStXCp999pkgCP+75wkNDRVWrlwpTJ48WVAoFELbtm3Fz0QQqn4dLjxOUFCQ0K9fP+Hrr78W76FeeeWVSn8+/fv3F1q3bi0unz9/XgAgyOVyYe/eveL6vn37Cm3atCkSz5PK+7tc3p+1IAjC6NGjBQDCkCFDhFWrVgmvvvqqAEAYOHCguM/OnTsFAEJkZKS4rvDe68nf7e3btwsAhEuXLukcY+HChYJcLhcyMzNL/JyISsPkCpGeFF5wi3tZWFiI+x04cEAAIPz+++867+/Tp49Qv359cXnTpk2CXC4XwsLCdPZbs2aNAED473//K64DIJibmwvR0dHiugsXLggAhJUrV4rrFi9eLAAQYmJiyjyflJQUAYAwf/78IttWrVolABCuXbtWahvlTa5EREQIAISJEyfqrB8xYoROcqWi5yAIj29iAAg//vijuC43N1dQqVTC4MGDxXVPJ1fS09MFAMLixYtLbT8wMFDo0qVLkfVTp04VAOj8/B48eCD4+fkJvr6+gkajEQRBEJYsWSIAEJMkgiAIjx49EgICAopNrgAQ1qxZU+R4Dx8+LLLuzTffFKytrYWcnJwibWzZskVcd+3aNfEG6p9//hHXF/6uPplwIiKiyivtGlbea/nYsWMFDw8PnYdUQRCEYcOGCQ4ODuL14MyZMyX+H17cNWPRokWCTCYT7ty5U+o5zJw5U1AqlUJaWpq4Ljc3V3B0dBRef/11cZ2Dg4MwadKkUtsqzsCBAwVLS0udOK5cuSIoFIoiD9w2NjbC6NGjy9XuoUOHir3/EoTHyRUAwo4dO8R1mZmZgoeHh9CyZUtxXeG9XseOHYWCggJx/b179wRzc3OhR48e4vVdEATh66+/FgAI69evF9dV9TpceG/Vv39/nXOYOHGiAEC4cOFCpT6fxYsXCwqFQkzkrFixQvDx8RHatWsnfPDBB4IgPP7izdHRUZg2bVqReJ5U3t/l8v6sC+8T33jjDZ3jvPfeewIA4fDhw4IgPP45ABBWr14tCIIgZGRkCHK5XBg6dKjg7u4uvm/KlCmCs7OzoNVqddrbsmWLAEA4ffp0uT4zoqdxWBCRnq1atQoHDx7Uee3bt0/c/txzz8HFxQXbtm0T16Wnp+PgwYN4+eWXxXXbt29HkyZNEBAQgNTUVPH13HPPAQCOHDmic9zQ0FD4+/uLy82bN4e9vX2lZ/Yp7BpsYWFRZFthbZKyug/PnTsXgiDoDJUpzp9//gkAmDJlis76qVOnljPa0tna2mLUqFHisrm5Odq1a1fqZ2NlZQVzc3McPXoU6enpFT7mn3/+iXbt2qFjx446cYwfPx63b9/GlStXAAD79+9H3bp10b9/f3E/S0tLjBs3rth2LSwsih1WZmVlJf79wYMHSE1NRadOnfDw4UNcu3ZNZ19bW1sMGzZMXG7cuDEcHR3RpEkTtG/fXlxf+HcpZ4ciIqpNyrqWC4KAHTt2oF+/fhAEQef+oGfPnsjMzCzXsJsnrxnZ2dlITU1Fhw4dIAgCzp8/X+p7X375ZeTn5+sMmfnrr7+QkZGhcx/j6OiI06dPIyEhodznr9FocODAAQwcOBDe3t7i+iZNmqBnz57lbqc4hYX4nZycit3u6emJF198UVy2t7fHq6++ivPnzyMpKUln33HjxkGhUIjLhw4dQl5eHqZOnQq5XK6zn729fZEhwfq4Dk+aNEln+e233wbwv3uqiurUqRM0Gg1OnjwJ4PHQsU6dOqFTp04ICwsDAFy6dAkZGRno1KlTme2V9btckZ914Tk9OWwJAN59910AED9fV1dXBAQE4Pjx4wCA//73v1AoFJgxYwaSk5Nx48YN8dw6duxYZDhT4e9GampqmedHVBwmV4j0rF27dggNDdV5devWTdxuZmaGwYMHY8+ePeI40Z07dyI/P1/npuTGjRu4fPkyXF1ddV6NGjUCANy7d0/nuE9emAo5OTlVKjEA/O/G6+n6LgDEMb1P3pxVxZ07dyCXy3UuwsDjmw19qFevXrEX0NI+GwsLC3z++efYt28f3N3d0blzZ3zxxRdFbrBKcufOnWLjb9Kkibi98E9/f/8i8ZU0u1TdunVhbm5eZP3ly5fx4osvwsHBAfb29nB1dRUTSpmZmTr7Fvd5ODg4wMvLq8g6AJX+HSIiooop61qekpKCjIwMrFu3rsj9QWHi/en7g+LExsZizJgxcHZ2hq2tLVxdXdGlSxcARa8ZTwsODkZAQIDOl0Tbtm2Di4uL+AUQAHzxxRe4dOkSvLy80K5dO8ydO7fMZH1KSgoePXqEhg0bFtmmr3sC4Yl6HE9q0KBBkWtj4T3X03Vx/Pz8dJYLr+lPx2hubo769euL2wvp4zr89Gfk7+8PuVxerjp0xWnVqhWsra3FREphcqVz5844e/YscnJyxG1PfnFUkvL8Lpf3Z114n/j0vZFKpYKjo6PO5/tkMigsLAxt2rRBmzZt4OzsjLCwMKjValy4cKHYBFHh78bTPxui8jL90s5EJmjYsGFYu3Yt9u3bh4EDB+KXX35BQEAAgoODxX20Wi2CgoKwdOnSYtt4+gL85DcoTyrpJqIszs7OsLCwQGJiYpFthes8PT0r1XZ1q+xnM3XqVPTr1w+7d+/GgQMHMGvWLCxatAiHDx9Gy5YtDRFqmYpLaGVkZKBLly6wt7fH/Pnz4e/vD0tLS5w7dw4ffPABtFqtzv4lfR76/h0iIqKKKev/4cL/z0eNGoXRo0cXu2/z5s1LPYZGo8Hzzz+PtLQ0fPDBBwgICICNjQ3u3r2LMWPGFLlmFOfll1/GJ598gtTUVNjZ2eG3337D8OHDdWaNeemll9CpUyfs2rULf/31FxYvXozPP/8cO3fuRO/evcs8hr7VqVMHgH6+MKjql0uGuA5XNSGgVCrRvn17HD9+HNHR0UhKSkKnTp3g7u6O/Px8nD59GmFhYQgICICrq2uZ7RninqI859ixY0d8++23uHXrlpggkslk6NixI8LCwuDp6QmtVltscqXwd8PFxaXSMVLtxuQKkQQ6d+4MDw8PbNu2DR07dsThw4fxn//8R2cff39/XLhwAd27d9dbBr0i7cjlcgQFBeHs2bNFtp0+fRr169eHnZ2dXuLy8fGBVqvFzZs3db6tiIqKKrJvdX+b4O/vj3fffRfvvvsubty4gRYtWmDJkiX46aefSo3Hx8en2PgLh+j4+PiIf165cgWCIOi0FR0dXe4Yjx49ivv372Pnzp3o3LmzuD4mJqbcbRARkeFV9RpWOKOeRqNBaGhopY4VGRmJ69evY+PGjXj11VfF9QcPHix3HC+//DLmzZuHHTt2wN3dHWq1WmeYSyEPDw9MnDgREydOxL1799CqVSt88sknJSZXXF1dYWVlJQ7feFJV7wkCAgIAlHxtjI6OLnItvn79OoDHswmVpvCaHhUVhfr164vr8/LyEBMTU+bPqjJu3Lih04MmOjoaWq1WJ9aK/r516tQJn3/+OQ4dOgQXFxcEBARAJpMhMDAQYWFhCAsLwwsvvKCX+Cvysy68T7xx44bYAxh4POtPRkaG+PkXngPw+Pf5zJkz+PDDDwE8vvf+5ptv4OnpCRsbG7Ru3brIcWNiYiCXy8UeS0QVxWFBRBKQy+UYMmQIfv/9d2zatAkFBQU6Q4KAx9/43L17F99++22R9z969AjZ2dkVPq6NjQ0AFJkWsCRDhgzBmTNndBIsUVFROHz4MIYOHVrm+8s7FXPhTdaT0+QBwPLly4vsW9FzqKyHDx/qTGkIPE602NnZ6QyVsrGxKTaWPn364N9//8WpU6fEddnZ2Vi3bh18fX3RtGlTAEDPnj1x9+5d/Pbbb+J+OTk5xf7cS1L47dCT3wbl5eVh9erV5W6DiIgMr6rXMIVCgcGDB2PHjh24dOlSke0pKSllHqu4a4YgCPjqq6/KHUeTJk0QFBSEbdu2Ydu2bfDw8NBJ7ms0miLDi9zc3ODp6VnscOMnY+vZsyd2796N2NhYcf3Vq1dx4MCBIvuXdA0uTt26deHl5VXsl0YAkJCQgF27donLarUaP/74I1q0aAGVSlVq26GhoTA3N8eKFSt0Ptfvv/8emZmZ6Nu3b7lirIhVq1bpLK9cuRIAdBJXFfl8gMeJidzcXCxfvlynJkmnTp2wadMmJCQklKveSnlU5Gfdp08fAEXvCwt7dz/5+fr5+aFu3bpYtmwZ8vPz8eyzz4rncPPmTfz666945plndHpZFQoPD0dgYKA4HIuoothzhUjP9u3bV6SAKAB06NBB59uMl19+GStXrsScOXMQFBSkk4kHgFdeeQW//PIL3nrrLRw5cgTPPvssNBoNrl27hl9++QUHDhxAmzZtKhRbYZb+P//5D4YNGwalUol+/fqJN2BPmzhxIr799lv07dsX7733HpRKJZYuXQp3d3exiFhpvv76a8ybNw9HjhwptahtixYtMHz4cKxevRqZmZno0KED/v7772J7b1T0HCrr+vXr6N69O1566SU0bdoUZmZm2LVrF5KTk3W+nWvdujW++eYbLFy4EA0aNICbmxuee+45fPjhh/j555/Ru3dvTJkyBc7Ozti4cSNiYmKwY8cOseDdm2++ia+//hrDhw/HO++8Aw8PD2zevFksGlyeb506dOgAJycnjB49GlOmTIFMJsOmTZs4nIeIyMjo4xr22Wef4ciRI2jfvj3GjRuHpk2bIi0tDefOncOhQ4eQlpYG4PEXAo6OjlizZg3s7OxgY2OD9u3bIyAgAP7+/njvvfdw9+5d2NvbY8eOHRUeLvPyyy9j9uzZsLS0xNixY3UKuT548AD16tXDkCFDEBwcDFtbWxw6dAhnzpzBkiVLSm133rx52L9/Pzp16oSJEyeioKAAK1euRGBgIC5evKizb+vWrXHo0CEsXboUnp6e8PPz0ykI+7QBAwZg165dRXqoAI/rq4wdOxZnzpyBu7s71q9fj+TkZPzwww9lfhaurq6YOXMm5s2bh169eqF///6IiorC6tWr0bZtW52i+voSExOD/v37o1evXjh16hR++uknjBgxQmeIeUU/n5CQEJiZmSEqKgrjx48X1xf2+gCgt+QKUP6fdXBwMEaPHo1169aJQ6H//fdfbNy4EQMHDtSpbVgY49atWxEUFCQWqW3VqhVsbGxw/fp1jBgxokgs+fn5OHbsGCZOnKi386NaqHonJyKquUqbihnFTIWo1WoFLy8vAYCwcOHCYtvMy8sTPv/8cyEwMFCwsLAQnJychNatWwvz5s0TMjMzxf0AFDvdoY+PT5Ep+BYsWCDUrVtXkMvl5ZrSOC4uThgyZIhgb28v2NraCi+88IJw48aNcn0m5Z2KWRAeTz88ZcoUoU6dOoKNjY3Qr18/IS4urshUzBU9hy5dugiBgYFF1o8ePVrw8fERl5+eijk1NVWYNGmSEBAQINjY2AgODg5C+/bthV9++UWnnaSkJKFv376CnZ2dAEBnWuabN28KQ4YMERwdHQVLS0uhXbt2wt69e4vEcuvWLaFv376ClZWV4OrqKrz77rvCjh07BAA6UzKWdC6CIAj//e9/hWeeeUawsrISPD09hffff1+cwvHp6ZyLa8PHx0fo27dvkfUl/W4REVHllHQNq8i1PDk5WZg0aZLg5eUlKJVKQaVSCd27dxfWrVuns9+ePXuEpk2bCmZmZjrXuCtXrgihoaGCra2t4OLiIowbN06cKre4qZuLc+PGDfEe58SJEzrbcnNzhRkzZgjBwcGCnZ2dYGNjIwQHB4tT5Jbl2LFjQuvWrQVzc3Ohfv36wpo1a4qd8vfatWtC586dBSsrKwFAmdMOnzt3TgAghIWF6awvvAYeOHBAaN68uWBhYSEEBAQI27dv19mv8F7vzJkzxbb/9ddfCwEBAYJSqRTc3d2FCRMmCOnp6Tr7VPU6XPg5XLlyRRgyZIhgZ2cnODk5CZMnTxYePXqk896Kfj6CIAht27YtMh1xfHy8AEDw8vIqsn9JUzGX93e5vD/r/Px8Yd68eYKfn5+gVCoFLy8vYebMmUJOTk6R46xatUoAIEyYMEFnfWhoqABA+Pvvv4u8Z9++fQKAct/jEhVHJgj8apOIyNgsX74c06ZNQ3x8POrWrSt1OERERDVC9+7d4enpiU2bNonrfH190axZM+zdu1fCyMpn7ty5mDdvHlJSUlh4VY8GDhwImUymMzSMqKJYc4WISGKPHj3SWc7JycHatWvRsGFDJlaIiIj06NNPP8W2bduKTI9MtdfVq1exd+9eLFiwQOpQyMSx5goRkcQGDRoEb29vtGjRApmZmfjpp59w7do1bN68WerQiIiIapT27dsjLy9P6jDIiDRp0gQFBQVSh0E1AJMrREQS69mzJ7777jts3rwZGo0GTZs2xdatW4vMIEVERERERMaJNVeIiIiIiIiIiKqANVeIiIiIiIiIiKqAyRUiIiIiIiIioipgzRUAWq0WCQkJsLOzg0wmkzocIiKiGkMQBDx48ACenp6Qy/mdTll4T0JERGQYhr4nYXIFQEJCAry8vKQOg4iIqMaKi4tDvXr1pA7D6PGehIiIyLAMdU/C5AoAOzs7AI8/ZHt7e4mjIWNQkKdB8h015HIZ5IryZTULbl1H1oy3YLt4DczqNyrXe7QaLbRaAe4+9jAzV1QlZCIio6RWq+Hl5SVea6l0vCepuW7cuIG33noLa9asQcOGDaUOh4io1jH0PQmTK4DY7dbe3p43MgTgcXLloS1gZq6AmbJ8yRVNvhcsXxgEay8vKJwdy3ecfC0K8jSwt2dyhYhqNg5xKR/ek9RcLi4uCA4OhouLC3+2REQSMtQ9CZMrRHqicPeA3bsfSx0GERERGSEfHx989913UodBREQGwuQKkZ4IuTnQJN6FwqMuZBaWUodDZJS0Wi3y8vKkDoMMQKlUQqFgDzyikuTn5yM1NRUuLi5QKpVSh0Nk1DQaDfLz86UOg0yUVPckTK4Q6UlB7G1kTHgFjt9sgrJhgNThEBmdvLw8xMTEQKvVSh0KGYijoyNUKhWHABEVIzIyEq1bt0Z4eDhatWoldThERkkQBCQlJSEjI0PqUMjESXFPwuQKEREZnCAISExMhEKhgJeXF6fkrWEEQcDDhw9x7949AICHh4fEEREZH39/f+zduxf+/v5Sh0JktAoTK25ubrC2tmaynipMynsSJleIiMjgCgoK8PDhQ3h6esLa2lrqcMgArKysAAD37t2Dm5sbhwgRPcXBwQF9+/aVOgwio6XRaMTESp06daQOh0yYVPck/OqQiIgMTqPRAADMzc0ljoQMqTBxxnHyREWlpKRg1apVSElJkToUIqNUeO3glzCkD1LckzC5QqQ3MkCpfPwnERWL3XtrNv58iUoWHx+P6dOnIz4+XupQiIwaryWkD1L8HnFYEJGeKBs2huu+k1KHQUREREaoZcuWyM3NlToMIiIyEPZcISIiyWg0WhTkaQzy0mg4KxEREREZVteuXfHTTz8BADZs2IDQ0NBi9yttGwAEBgbi1KlTBomRqgeTK0R6UnAnBulvjULBnRipQyEyCRqNFimxD5AUozbIKyX2gckkWLRaLTw8PPDgwYMy950zZw68vLxgb2+Phg0bYv369aW2O3XqVDg6OsLd3R3Lli3TZ9hEVAE3btxAaGgobty4IXUoRGSELl++jJCQEADA3Llz8cYbb0gcEVUUhwUR6YmQl4uC6CgIeezyS1QegkZAQZ4WcoUMcoV+c/1ajRYFeVoIGgEwgklrbt++ja5du+L27dvFbv/333/RuHFj2NnZldnWqFGj8P7778PGxgbXr19Hly5d0LZtWwQFBRXZd82aNTh69CiuX7+OzMxMdO3aFc2bN0f37t2rekokoZSUFCQlJUGlUsHV1VXqcKiczMzM4OrqCjMz3n4TEdVE7LlCpGcxMTG4evUqrl69iqSkRKnDITJ6coUcZkr9viqSrJHJZFi1ahV8fX3h6OiItWvX4uTJk2jatCmcnJywYMECcd8xY8Zg4cKF4nJZXXzLa//+/ejVq1e59m3YsCFsbGzE2IHH/+8UZ9OmTXjvvffg5uaGhg0bYty4cfjxxx+L3XfMmDGYMmUKunfvDjs7O/To0QNpaWkAHj/M9+7dG46OjnBxccHw4cMreoqkR0lJScjLy0NSUpLUoVAF+Pn54eeff4afn5/UoRBRBX366afw8fGBvb09QkJCcPHixUq1o9VqMWHCBNjb26Np06Y4d+6cuM3X1xcnTpzA0aNH8emnn2Ljxo2wtbVF7969odVqMWXKFLi4uMDR0RFt27ZFamqqvk6P9ITJFSI9uf///8HNnDkTw4YNw7BhwzBgwEAmWIhMQFhYGK5cuYJdu3Zh6tSpWLJkCU6cOIFTp07h008/xa1btwx6/IokVwDgs88+g42NDRo1aoS6deuWmOC5cuUKmjdvLi4HBQXh8uXLJbb7yy+/YNmyZUhJSYFGo8FXX30FAFiyZAn8/PyQmpqKu3fv4u233y53rKR/KpUK5ubmUKlUUodCFaDRaKBWq8Wp6YnIdAQEBODs2bO4f/8+nn/+ebz66quVaicsLAydO3dGeno6Bg0ahGnTphXZp2vXrvjoo48wevRoZGVlYd++ffjrr79w8uRJ3Lp1C/fv38fatWthaWlZ1dMiPWNyhUhP1P9fK2HUyJFYtmwppk+fjpycHKSnZ0gbGBGV6f3334e1tTW6desGe3t7jBw5Es7OzggICEDz5s0r/Q1VeaSlpSE+Ph7BwcHlfs+HH36IrKws/PPPPxg8eDDMzc2L3S8rKwv29vbisr29PbKyskpsd+jQoWjevDksLS0xePBgXLhwAQCgVCqRmJiIuLg4WFhYoEOHDuWOlfTP1dUVQUFBHBJkYi5cuAAHBwfx3xUR6V9KSgoiIyORkpKi13YHDRoEV1dXKJVKfPTRR7h48WKp19OSBAQEYPjw4VAoFBgxYkS5/z9QKpV48OABrl27BrlcjlatWsHW1rbCxyfDYnKFSE+0dVwxPzMfTo0D4O/vDy+velKHRETl5ObmJv7dysqqyHJlbqBOnDgBR0dHODo6onnz5oiNjRWXHR0dxf3++usvhIaGQiaTISwsDLa2tmI34NLIZDK0b98eCQkJWLduXbH72NraQq1Wi8tqtbrUmzF3d3fx79bW1uJ5z5gxA97e3ujSpQsCAgLw/fffl+cjIKIn+Pn54ZdffuGwICIDMtSwyW+//RaBgYFwcHCASqWCIAi4f/9+hdsp6Tpblu7du+Ott97C+PHj4eHhgffeew/5+fkVPj4ZFpMrRHoiWNvgeJ4ArZW11KEQkYHY2Njg0aNH4nJycnKJ+3bs2BEZGRnIyMjAxYsX4e3tLS5nZGSI+z05JKhTp07IysoSuwGXR0FBAaKjo4vd1rRpU0RGRorLly5dQmBgYLnafZK9vT2++uorxMbGYsOGDXj77bcNPlSKqKZxcnLC0KFD4eTkJHUoRDWWIYZN3r59G1OnTsXGjRuRnp6OxMREyGQyCIKgt2M8rbCm2pOmTZuGiIgInDlzBgcOHMDmzZsNdnyqHCZXiPREps7EYCs5zLLKnkqViP5Hq9GiIF+/L62BpmAODg7GH3/8AbVajVu3bumlB8ehQ4fQo0ePcu//7bffIiMjA1qtFkeOHMHmzZvx3HPPFbvvqFGj8OWXXyIlJQXR0dH49ttvKzVO/I8//sCtW7cgCAIcHBwgk8mgUBjBNExEJuT+/fvYsGFDpb7tJqLyMcSwyaysLMjlcri6uqKgoABz5szRW9slcXNzw507d8QEztmzZ3HmzBkUFBTAzs4OSqWS12EjxOQKkZ7IM9MxwdYMZlnqsncmIsgUMpiZy6HVCCjI0+j1pdUIMDOXQ6Yo+s1PVbzyyivw9/dHvXr1MHz48CrPmhMREYF69erB2dm53O/Zu3cv/P394eDggMmTJ+PLL7/ECy+8AADisKJCEyZMQJcuXdCwYUN06NAB06dPr9Q0zNevX0e3bt1gZ2eHvn37Yvny5fDx8alwO1I6fvw4+vXrB09PT8hkMuzevVtnu0wmK/a1ePHiIm3l5uaiRYsWkMlkiIiI0Nl28eJFdOrUCZaWlvDy8sIXX3xhwLMiU3Lnzh289tpruHPnjtShEFEFNGvWDG+++SaaN28OX19f+Pn5lVjrTF+GDBmCrKwsODk54YUXXkBmZiZef/11ODo6onHjxnj22WcxYsQIg8ZAFScTDNmfyUSo1Wo4ODggMzNTp/Af1V4FeRokxahhZq6AmbJ8Ocjrf+2D0xezceP1t1H32c64efMmpk2bjq1bt6JJkybFHydfi4I8DVR+9jAzZ/aZaq6cnBzExMTAz89Pp7q9RqOFoDHMZUimkEFRgSmZpfDZZ58hJycHc+fOlToUvSju52ws19h9+/bhv//9L1q3bo1BgwZh165dGDhwoLj96fH5+/btw9ixYxEdHY369evrbHvnnXdw48YN7Nu3D+fPn0eLFi0APD7XRo0aITQ0FDNnzkRkZCRef/11LF++HOPHjy9XnMbyeZH+CYIAjUYDhUJRbJd/otqupHsFosqQ4p7ETO8tEhERlZNCIQdqcV7Rz88PrVq1kjqMWqF3796lFgl+enz+nj170K1btyKJlcIpMXfs2FGkLs7mzZuRl5eH9evXw9zcHIGBgYiIiMDSpUvLnVyhmksmk8HMjLfeREQ1lXF/pUdERFSDvfzyy2jYsKHUYdBTkpOT8ccff2Ds2LFF1o8bNw6bNm2CtXXR4uWnTp1C586ddbqL9+zZE1FRUUhPTy/2WLm5uVCr1Tovqplu3ryJ/v374+bNm1KHQkREBsDkCpGeCJZWOJmrhdaC3RiJiEzZxo0bYWdnh0GDBonrBEHAmDFj8NZbb6FNmzbFvi8pKUlnmk3gf9NuljQt6KJFi+Dg4CC+vLy89HQWREREVJ2YXCHSE62rO2arC5DnVEfqUIiIqArWr1+PkSNH6oz5X7lyJR48eICZM2fq9VgzZ85EZmam+IqLi9Nr+2Q8/P398dtvv8Hf31/qUIiIyAAkTa6UVbkfAK5evYr+/fvDwcEBNjY2aNu2LWJjY8XtOTk5mDRpEurUqQNbW1sMHjwYycnJ1XgWRP9PUwAHGQCNRupIiIioksLCwhAVFYU33nhDZ/3hw4dx6tQpWFhYwMzMDA0aNAAAtGnTBqNHjwbwuG7L0/cghctP13QpZGFhAXt7e50X1UyCIKCgoACcS4KIqGaSNLmSnZ2N4OBgrFq1qtjtN2/eRMeOHREQEICjR4/i4sWLmDVrls43SdOmTcPvv/+O7du349ixY0hISNDpxktUXRQJ8djhYg7LlOK7fhMRkfH7/vvv0bp1awQHB+usX7FiBS5cuICIiAhERETgzz//BABs27YNn3zyCQAgJCQEx48fR35+vvi+gwcPonHjxnBycqq+kyCjdP78eSiVSpw/f17qUIiIyAAkLVleVuX+//znP+jTpw+++OILcd2TXSkzMzPx/fffY8uWLXjuuecAAD/88AOaNGmCf/75B88884zhgiciIiKTkZWVhejoaHE5JiYGERERcHZ2hre3N4DHUzRu374dS5YsKfL+wn0K2draAnh8X1KvXj0AwIgRIzBv3jyMHTsWH3zwAS5duoSvvvoKy5YtM9RpkQnx8fHBDz/8AB8fH6lDISIiAzDamitarRZ//PEHGjVqhJ49e8LNzQ3t27fXGToUHh6O/Px8hIaGiusCAgLg7e2NU6dOldg2K/MTERHVLmfPnkXLli3RsmVLAMD06dPRsmVLzJ49W9xn69atEAQBw4cPr9QxHBwc8NdffyEmJgatW7fGu+++i9mzZ3MaZgIA1KlTB2PGjEGdOqzNRkRUE0nac6U09+7dQ1ZWFj777DMsXLgQn3/+Ofbv349BgwbhyJEj6NKlC5KSkmBubg5HR0ed97q7u5dYlR94XJl/3rx5Bj4DIiIqS2xsLFJTUw3StouLS5HeBuXRtWtXvPHGGxg1alSljiuTyRAXFyf2ZiDj0LVr1zJrXYwfP77ciRBfX99i22vevDnCwsIqFSPVbOnp6Th06BBCQ0M5TIzIxAQGBuK7775DSEiI0bVv6PuOu3fvom/fvjh37hzkcsP1zejSpQu+/vprBAUFGewYhma0yRWtVgsAGDBgAKZNmwYAaNGiBU6ePIk1a9agS5culW575syZmD59urisVqs59SERUTWLjY1FkyZN8PDhQ4O0b21tjatXr1YqwVJo7ty5iI+Px3fffafHyB4bM2YMGjRogI8//ljvbROR8YmJicFLL72E8PBwJleITMzly5dNuv2q+OyzzzBhwgQxsTJ+/Hj8/vvvyM7Oho+PDz799FP069dPZ/8lS5ZAo9HgjTfewOeffw6ZTAbgcSLI2tpaXP7oo4/w0UcfAXhcS3Xu3LnYsWNHNZ+h/hhtcsXFxQVmZmZo2rSpzvomTZrgxIkTAB5X3s/Ly0NGRoZO75Xk5OQSq/IDjyvzW1hYGCRuqr00db3RPzUPn7h5SB0KkUlITU3Fw4cPsXjxYr1PTXrz5k3MmDEDqampVUquEBHpS3BwMDIzM2FjYyN1KERE5ZKbm4utW7ciKipKXDd9+nSsXLkSFhYWOHPmDEJDQ3Hr1i3UqVMHf/75J1atWoV//vkHNjY2eP7559G4cWOMHTtWfH9UVFSxvWz69OmDcePG4d69e3Bzc6uW89M3o625Ym5ujrZt2+r8IAHg+vXrYiGw1q1bQ6lU4u+//xa3R0VFITY21mBdtohKJJfjofD4TyIqP39/fwQGBur1VZFkzZkzZ9C8eXPY29vjrbfeEntOHj16FJ9++ik2btwIW1vbEguwr1+/Hl5eXlCpVFi3bl2RbY0aNYKdnR2aN2+Oo0ePAgA2btyIzZs3Y8GCBbC1tcVbb70FAHj77bfh6ekJR0dH9OjRA7GxsZX4RInIGCkUCtjb20OhUEgdChFVkK+vr/gF/5gxYzBlyhR0794ddnZ26NGjB9LS0op9X926dXH9+nUAwKeffgorKyvk5eUBeFwE/dtvv61w+6Xdd8TFxaFPnz5wcnJC06ZNsWfPHgDAjRs34OnpKe7Xo0cPcUIYAPD09MSNGzeKxH/69Gl4enrC2dlZXBcQECB2VJDJZMjLy8Pdu3cBAJs2bcKbb74Jf39/qFQqvPvuu/jxxx/L/HyBx8//rVq10nm2NzWSPgVmZWWJUxoC/6vcX3gzOWPGDGzbtg3ffvstoqOj8fXXX+P333/HxIkTATwuHDd27FhMnz4dR44cQXh4OF577TWEhIRwpiCqdvJ7SfjMwQzmaYapH0FE+peXl4dBgwZhwoQJuH//PgIDA3Hy5EkAj2t0fPTRRxg9ejSysrKwb9++Iu+/dOkSpk6dil9//RUxMTHijVEhlUqFv//+GxkZGXj77bcxbNgw5ObmYvTo0Rg5ciRmzZqFrKwsrFmzBgDw7LPP4urVq0hMTES9evUwZcoUw38IRFQtYmJiMHz4cMTExEgdClGNFXv/IX4Nj0fsfcMMOS70yy+/YNmyZUhJSYFGo8FXX31V7H6dOnUS63CFhYXBw8MDZ8+eFZc7depUofbLuu8YPnw4AgMDkZSUhNWrV2PUqFGIjo5Gw4YNodVqcfPmTWg0Gly7dg3Xr19Hfn4+bt68Ca1Wi4YNGxaJIzIystj1EydOhJWVFdq2bYvnnntOrJNy5coVNG/eXNwvKCioyJCndu3aoW7duhgzZgzu37+vsy0gIAAXL14s9jMxBZImV8qq3P/iiy9izZo1+OKLLxAUFITvvvsOO3bsQMeOHcU2li1bhhdeeAGDBw9G586doVKpsHPnTknOh2o3WW4O2pjLIc/LlToUIiqnU6dOwczMDBMmTIBSqcTkyZPh4VH+oX07duzAoEGD0L59e1hZWenMPAM87uLq5eUFhUKBcePGQSaTFfvNUKFhw4bBwcEBVlZW+OCDD4rcNBGR6SooKEBKSgoKCgqkDoWoRoq9/xA9lx/He9svoOfy4wZNsAwdOhTNmzeHpaUlBg8ejAsXLhS7X6dOnXD8+HFotVpcunQJb775JsLCwnD79m3k5OQgICCgQu2Xdt8RFxeHs2fPYv78+bCwsEDXrl3xwgsvYPv27TqxnD9/Hs2bN0eLFi1w7tw5hIWF6TxfPykjIwO2trZF1q9evRpZWVk4dOgQevToIdZQycrKgr29vbifvb09srKyxOXjx4/jzp07iIiIwMOHDzFmzBiddu3s7JCZmVlsLKZA0por5anc//rrr+P1118vcbulpSVWrVqFVatW6Ts8IiKq4Qp7iBSSyWQVqrafmJioUxD96eLou3fvxvz583Hr1i0AwIMHD4p8S/OkTz75BD/88APu3bsHmUwGtVpd7liIyLg1bNgQhw4dkjoMohrr39tpeJSvAQA8ytfg39tp8K5jbZBjubu7i3+3trbWSSA8qVOnTliyZAkuXLiAwMBAdO3aFQsWLICnp2eJCY3S2i/tviMhIQGurq6wsrIS1/n4+CAhIUGMJSwsDBkZGejYsSNkMhnCwsJw9erVEnvQODg4lHhuCoUC3bt3x/Lly9GwYUP06dMHtra2OvcuarVaJzlTeBxXV1esWLECdevWRU5ODiwtLQE8vk9ycHAo8XMxdiwOQUREtZaHhwfi4+N11j25XPhNTGnvj4uLE5ef/Htubi6GDx+OTz75BPfv30dGRgbc3NzELxWebvvYsWNYvXo1/vzzT2RmZuLff/+t9HkREZFxSklJQWRkJFJSUqQOpcZp5+sMK+XjmkZWSgXa+TqX8Q7Da9asGdLT07F161Z06tQJrVq1woULF3D8+PFSkyslKe2+w9PTEykpKcjJyRHXxcbGirVWCnuunDhxAp06dUKnTp1w4sQJnDhxosRYgoKCSu1xCzzulRcdHQ0AaNq0KSIjI8Vtly5dQmBgYLHvK5x96MnOFlFRUZyKmYiIqLJu3rwpWZshISHIz8/HunXr8Nprr2HdunVITEwUt7u5ueHEiRMQBKHYRMvgwYPRoUMHTJo0Cc2aNcPChQvFbbm5ucjLyxMr3n/11Vc6N9Nubm64ffu2uPzgwQMolUq4uLggOztbpy0iMn3nz5/HM888g3/++UccEk+1T1JSEvLy8pCUlARXV1epw6lRvOtY48DUzvj3dhra+TobrNdKRcjlcjz77LP45ptvsHfvXiiVSjRu3Bjbtm2rVE+20u47vLy80KpVK8yZMwcLFizAP//8g99//x3z5s0D8HjGspSUFISFheHnn38G8Hh49KNHj9CiRYtij/fMM88gISEB6enpcHJyQmZmJv744w/0798flpaW2LVrF44cOYJFixYBAEaNGoUJEyZg+PDhsLGxwdKlS8X6cZcvX0ZBQQGaNWsGtVqNqVOn4vnnnxd72uTl5SE8PBwbN26s8OdiLJhcIdITraMzVjwoQKid6XZlI6pOLi4usLa2xowZMwzSvrW1NVxcXErdx9zcHDt27MAbb7yB9957D8OHD0eHDh3E7UOGDMGPP/4IJycndOzYEXv37tV5f7NmzbB06VK8+OKLyM/Px4IFC8SbAnt7eyxevBg9e/aETCbDhAkT0KBBA/G9r7/+OoYMGQJHR0eMGDECK1aswLPPPgsfHx+4uLjg/fffx08//aTHT4SIpFSvXj0sXbq0QkMPqeZRqVRISkqCSqWSOpQaybuOtVEkVZ7UqVMnHDx4EO3atROXT506hVatWlW4rdLuOwBg69atGD9+PNzc3ODh4YGNGzeKBWnlcjk6dOiA7OxsmJubA3jc00SpVJY4i5mFhQVefvllbN++HePHj4dMJsO3336LiRMnQhAENGjQAFu2bBGTM3379sWECRPQrl07aDQajBs3TizxkZycjLfeegt3796FnZ0dnn/+eZ2ZhPbt24dOnTrpDIkyNTKhrKIntYBarYaDgwMyMzN1CvBQ7VWQp0FSjBpm5gqYKcs3eu7q1asYNmwYli1bCn9/f9y8eRPTpk3H1q1b0aRJk+KPk69FQZ4GKj97mJlzakaquXJychATEwM/Pz9xXC3wuLtqaqphZthycXGBt7e3Qdqm4hX3c+Y1tmL4eRFRbVXSvQJJKz4+Hv369UN4eLg4lMcQunbtihUrVujMNlQVUtyTsOcKkZ7IsrPQ3UIOxSPDTv1GVJN4e3szAUJEtUJmZqZY28CUCzYSUe1Sr149nD9/3uDHOXr0qMGPYWgsaEukJ/K0VMy0N4MyM13qUIiIiMjI3Lx5Ey+88IJB6kwREZH02HOFiIiIiMjAgoKCkJCQUGYtKCIiMk1MrhARUbVhma+aTavVSh0CkdFSKpXw8PCQOgwiIjIQJleIiMjglEolZDIZUlJS4OrqWuy0xmS6BEFAXl4eUlJSIJfLxVkIiOh/7ty5gwULFmDWrFnw8fGROhwiItIzJleI9MXcAlfytVAo+VBB9DSFQoF69eohPj4et2/fljocMhBra2t4e3sbdDYBIlOVk5ODy5cvIycnR+pQiIjIAJhcIdITjbsHpmQUYFkdV6lDITJKtra2aNiwIfLz86UOhQxAoVDAzMyMvZKIStC4cWOcOnVK6jCIiMhAmFwhIqJqo1AooFAopA6DiIiIiIyETCZDXFwc6tWrJ3UoVcJ+u0R6ooi7jUOu5rBMuit1KERERGRkLly4AGdnZ1y4cEHqUIjIRH322WeQyWQ4ceKEuG7MmDGwsLCAra0tbG1tERgYWOL7jx8/ji5dusDW1hZdu3at0HF+/fVXPPPMM7C0tMSYMWOKvCcpKQlDhgyBg4MD6tSpg5kzZ1bqHE0ZkytERERERAamUqkwc+ZMqFQqqUMhIhN09+5d/Pzzz8XOOjZr1ixkZWUhKysLly9fLrENa2trjB8/HrNnz67wcZydnfHee+9h4sSJxb6vf//+6NChAxITExEfH48RI0aU88xqDiZXiIiIiIgMzN3dHTNmzIC7u7vUoRBRBcXExKBv376oU6cOPDw8sGLFCgCPC1VPmjQJKpUK3t7emD9/PrRaLQBg7ty5GDlyJIYOHQo7Ozu0b98eMTExYpuRkZHo3LkznJyc0Lp1a5w9e7bUGN59913MnTu3SjPytWnTBiNHjoS3t3eFj/Pcc89hyJAhcHNzK/Keffv2wcLCAtOnT4e1tTWsrKwQFBRU4jHWr18PLy8vqFQqrFu3TmdbWloaRowYATc3N9SvXx8bN24UtyUnJ6Nnz56wt7dHt27dMGnSJLzxxhvlPX2DY3KFiIiIiMjAHjx4gKNHj+LBgwdSh0JEFVBQUIC+ffuibdu2uHv3LqKiovDss88CABYsWIDLly/j6tWrOHHiBH766Sf8+OOP4nt37dqFiRMnIj09HY0bN8bcuXMBAFlZWejVqxfeeecdpKamYtasWRg0aFCJs4kdPXoUqampePHFF4vdvmzZMtSpUwcdOnTAsWPHKn2uZR2nJP/++y98fX3Ru3dvuLi4oHv37rh69Wqx+166dAlTp07Fr7/+ipiYGJ2hRwDwyiuvwNPTE3Fxcfjzzz8xc+ZMXLx4EQAwceJE1KtXD/fu3cOiRYuwefPmyp2ogTC5QkRERERkYDdu3EC3bt1w48YNqUMhMimJiYmIjIwUl69cuYK4uDgAj3uOnDt3TkxaJicn69Q1ioqKwp07dwAA+fn5OHfuHDIzMwEAKSkpSExMLPP4p0+fxoMHDzB79mxYWlrC3t4erVu3BgBs3boVc+bMgZOTE7y9vfHuu+/i559/Ft/bvXt3dOvWDWZmZhg2bJgY2969exEYGIjBgwdDoVBg4MCBcHNzwz///FPk+AUFBZg2bRqWL19ebHzvvPMOoqOjkZiYiEmTJqF///7iOVdEWccpzd27d7F161ZMmTIFCQkJ6NWrFwYOHAiNRlNk3x07dmDQoEFo3749rKysdIYoJSUl4ejRo1i0aBEsLCwQEBCAESNGYOfOnSgoKMCePXswZ84cWFpa4plnnkG/fv0qHKshMblCpCcalSdevZ+HXJeiXeWIiIiodmvatClu3LiBpk2bSh0KkUlZu3YtevfuLS4PGzYMixcvBgDEx8ejdevWCA8PBwD8+OOP6Natm7jvmDFjsGDBAgBAamoqWrduLfaU+OWXX7B27doyjx8fHw8fHx/I5UUfnRMSEnSG2Pj4+CAhIUFcfnIYoLW1NbKysgAAsbGxOHbsGBwdHcXX1atXdd5baNWqVejYsSOaNWtWbHwtW7aEk5MTzM3NMXLkSISEhOCvv/4q87wqepzSWFlZoWPHjujduzfMzc3x3nvvISkpCdHR0UX2TUxMhJeXl7j85N9jY2ORk5MDV1dX8XNZu3YtkpKSkJqaCo1Gg7p164r7G9vsQpyKmUhflOZI0AKCmVLqSIiIiMjIWFpaokGDBlKHQWRy3nzzTQwePFhc3rp1K+zs7AA8frgODw9Hw4YNAQCvvvoqevToIe67YcMGWFpaAgBcXFwQHh4Of39/AMBLL72EgoKCMo/v5eWFO3fuQBAEyGQynW2enp6IjY0V24yNjYWnp2eZbdatWxc9e/bEb7/9Vua+R44cwfHjx7F9+3YAj3vcDBgwAJ999hnGjRtXZH+5XA5BEMpst6rHeVKzZs10eheVxsPDQ6f2TGEvJODx52Jra4v09PQin3VBQQEUCgUSEhLEhEx8fDwsLCzKddzqwJ4rRHoiT03Bh3YKKDPSpA6FiIiIjExcXBymTJmi8yBBRGXz8PDQKY7atGlT8eHa0tISrVq1EpMt7u7uCA4OFvdt3LgxfHx8AABKpRKtWrWCg4MDAMDV1bXYmXee1q5dO9jZ2WHBggXIycmBWq0We8q8/PLLWLBgAdLT0xEXF4elS5di2LBhZbb5wgsv4Pz589i9ezcKCgrw6NEj7N+/Xxyy9KQNGzbgypUriIiIQEREBDw9PfHDDz9g5MiRAB4Ps8nOzkZBQQG2bduGsLAwhIaGFntcrVaLnJwc5Ofn6/y9PMfRaDTIyclBQUGBzt8BYNCgQbhw4QIOHToEjUaD5cuXQ6VSFZtQHjx4MHbu3IkzZ87g0aNHWLhwobitbt26CAkJwccff4yHDx+ioKAA586dw5UrV2BmZob+/ftj/vz5yM3Nxb///ovff/+9zM+6OjG5QqQnskfZCLVUQJHzSOpQiIiIyMiwoC2RaTIzM8PevXtx8uRJeHh4oHHjxjh16hSAx1MgN27cGAEBAQgJCcGwYcMwevToMtt0cHDAH3/8gZUrV8LNzQ2+vr5FZs0p5OjoCJVKJb4UCgWcnZ1hbW0N4HExW09PT9SpUwdLly7F7t27Ub9+fQBAWFgYbG1txbaOHz8OKysrvPrqqwgLC4OVlZXYK6Ws42zatAlWVlaYNWsWfvrpJ1hZWYmJkTp16uDXX3/F22+/DUdHR+zatQu7du2CQqEocj7NmjXD0qVL8eKLL8LX1xcdOnTQ2b5582bEx8ejfv36cHNzw9SpU/Ho0ePnq9WrV+POnTtwcXHBBx98gJdeesmoeq7IhMr0Gaph1Go1HBwckJmZCXt7e6nDISNQkKdBUowaZuYKmCnLl4O8/tc+OH0xGzdefxt1n+2MmzdvYtq06di6dSuaNGlS/HHytSjI00DlZw8z86L/+RARmTpeYyuGnxcR1VY5OTmIiYmBn5+fOJSHqDTDhw9HUFAQPvrooyLbivt9MvQ1lj1XiIiIiIiIiMioFU57rdVqcejQIezZswf9+/eXOiwRkytERERERAYWGRmJevXqlbvoIxER6crIyEDfvn1ha2uLCRMmYPXq1ZWa3chQOFsQkZ5o7R3xY7YGbW3tpA6FiIiIjIyLiwveeOMNuLi4SB0KEZFJevbZZ3Hr1i2pwygRkytEeiI4OOLHhxq0tOUYeSIiItLl4eGBuXPnSh0GEREZiKTDgo4fP45+/frB09MTMpkMu3fvLnHft956CzKZDMuXL9dZn5aWhpEjR8Le3h6Ojo4YO3YssrKyDBs4UTFkjx6hjVIGeW6O1KEQERGRkcnOzsaZM2eQnZ0tdShERk2r1UodAtUAUvweSdpzJTs7G8HBwXj99dcxaNCgEvfbtWsX/vnnH3h6ehbZNnLkSCQmJuLgwYPIz8/Ha6+9hvHjx2PLli2GDJ2oCHlqMj5zVOJG+n2pQyEiIiIjExUVhXbt2iE8PBytWrWSOhwio2Nubg65XI6EhAS4urrC3NwcMplM6rDIxAiCgLy8PKSkpEAul8Pc3Lzaji1pcqV3797o3bt3qfvcvXsXb7/9Ng4cOIC+ffvqbLt69Sr279+PM2fOoE2bNgCAlStXok+fPvjyyy+LTcYQEREREVW3Jk2a4MKFC2jYsKHUoRAZJblcDj8/PyQmJiIhIUHqcMjEWVtbw9vbG3J59Q3WMeqaK1qtFq+88gpmzJiBwMDAIttPnToFR0dHMbECAKGhoZDL5Th9+jRefPHFYtvNzc1Fbm6uuKxWq/UfPBERERHR/7OyskLz5s2lDoPIqJmbm8Pb2xsFBQXQaDRSh0MmSqFQwMzMrNp7Phl1cuXzzz+HmZkZpkyZUuz2pKQkuLm56awzMzODs7MzkpKSSmx30aJFmDdvnl5jJSIiIiIqyd27d/H1119j8uTJqFu3rtThEBktmUwGpVIJpVIpdShEFSJpQdvShIeH46uvvsKGDRv0nnGaOXMmMjMzxVdcXJxe26dayswMdzUCBIVR5yyJiIhIAhkZGdi+fTsyMjKkDoWIiAzAaJMrYWFhuHfvHry9vWFmZgYzMzPcuXMH7777Lnx9fQEAKpUK9+7d03lfQUEB0tLSoFKpSmzbwsIC9vb2Oi+iqtJ41MPotHzkurpLHQoREZFJS0lJQWRkJFJSUqQORW8CAwMRHR1d7FB3IiIyfUb7Ffsrr7yC0NBQnXU9e/bEK6+8gtdeew0AEBISgoyMDISHh6N169YAgMOHD0Or1aJ9+/bVHjMRERERVV1SUhLy8vKQlJQEV1dXqcMhIiIqk6TJlaysLERHR4vLMTExiIiIgLOzM7y9vVGnTh2d/ZVKJVQqFRo3bgzgcdX1Xr16Ydy4cVizZg3y8/MxefJkDBs2jDMFUbVT3I3Fr3WUSLmXCPj7Sx0OERGRyVKpVEhKSiq1J7KpuXz5MgYNGoSdO3ey9woRUQ0kaXLl7Nmz6Natm7g8ffp0AMDo0aOxYcOGcrWxefNmTJ48Gd27d4dcLsfgwYOxYsUKQ4RLVDqtFo5yGVK0WqkjISIiMmmurq41rseKg4MD+vfvDwcHB6lDISIiA5A0udK1a1cIglDu/W/fvl1knbOzM7Zs2aLHqIiIiIiI9KtevXpYvHix1GEQEZGBGG1BWyIiIiKimuLRo0e4fPkyHj16JHUoRERkAEyuEBEREREZ2NWrV9GsWTNcvXpV6lCIiMgAmFwh0hONmwpvp+cjz9lF6lCIiIjIyDRq1AgnT55Eo0aNpA6FiIgMwGinYiYyORaWuFogQGtuIXUkREREZGRsbW0REhIidRhERGQg7LlCpCfy9DS8ZaOAmTpT6lCIiIjIyCQmJmLhwoVITEyUOhQiIjIAJleI9ESWpcYQawXMHmZJHQoREREZmZSUFKxatQopKSlSh0JERAbAYUFERERERAbWvHlz9lohIqrB2HOFiIiIiIiIiKgKmFwhIiIiIjKwq1evolWrVpyKmYiohmJyhUhPBBtb7HmkgcbKRupQiIiIyMjY2NggJCQENja8TyAiqomYXCHSE62zC1ZmaZDv4Ch1KERERGRkvL29sWrVKnh7e0sdChERGQCTK0T6kpeLBmYyyPLzpI6EiIiIjExubi5u376N3NxcqUMhIiIDYHKFSE8UyYlY46SExX1OsUhEZGyOHz+Ofv36wdPTEzKZDLt379bZLpPJin0tXrxY3Kd///7w9vaGpaUlPDw88MorryAhIUGnnYsXL6JTp06wtLSEl5cXvvjii+o4PTIBly9fhp+fHy5fvlzltlJSUhAZGWnwaZ2r6zhERDUBkytERERU42VnZyM4OBirVq0qdntiYqLOa/369ZDJZBg8eLC4T7du3fDLL78gKioKO3bswM2bNzFkyBBxu1qtRo8ePeDj44Pw8HAsXrwYc+fOxbp16wx+fmT8GjRogIMHD6JBgwZVbispKQl5eXlISkrSQ2TSH4eIqCYwkzoAIiIiIkPr3bs3evfuXeJ2lUqls7xnzx5069YN9evXF9dNmzZN/LuPjw8+/PBDDBw4EPn5+VAqldi8eTPy8vKwfv16mJubIzAwEBEREVi6dCnGjx+v/5Mik2Jvb4/Q0FC9tKVSqZCUlFTk91bfqus4REQ1AXuuEBERET0hOTkZf/zxB8aOHVviPmlpadi8eTM6dOgApVIJADh16hQ6d+4Mc3Nzcb+ePXsiKioK6enpxbaTm5sLtVqt86KaKTk5GUuXLkVycnKV23J1dUVQUBBcXV31EJn0xyEiqgmYXCHSF5kM2VoBkMmkjoSIiKpg48aNsLOzw6BBg4ps++CDD2BjY4M6deogNjYWe/bsEbclJSXB3d1dZ//C5ZKGVSxatAgODg7iy8vLS49nQsYkMTERc+fORWJiotShEBGRATC5QqQnmno+GHA/HznunlKHQkREVbB+/XqMHDkSlpaWRbbNmDED58+fx19//QWFQoFXX30VgiBU+lgzZ85EZmam+IqLi6tK6GTEWrRoAbVajRYtWkgdChERGQBrrhARERH9v7CwMERFRWHbtm3FbndxcYGLiwsaNWqEJk2awMvLC//88w9CQkKgUqmKDPkoXC6pZoWFhQUsLCz0exJERERU7dhzhUhPFIl38Z2TGSxSqj6WmoiIpPH999+jdevWCA4OLnNfrVYL4HHdFAAICQnB8ePHkZ+fL+5z8OBBNG7cGE5OToYJmExGVFQUOnbsiKioKKlDISIiA2ByhUhfCvLhayaHTFMgdSRERPSUrKwsREREICIiAgAQExODiIgIxMbGivuo1Wps374db7zxRpH3nz59Gl9//TUiIiJw584dHD58GMOHD4e/vz9CQkIAACNGjIC5uTnGjh2Ly5cvY9u2bfjqq68wffr0ajlHMm4WFhZo0KABeyoREdVQHBZERERENd7Zs2fRrVs3cbkw4TF69Ghs2LABALB161YIgoDhw4cXeb+1tTV27tyJOXPmIDs7Gx4eHujVqxc+/vhj8WHZwcEBf/31FyZNmoTWrVvDxcUFs2fP5jTMBADw9fUVf9eIiKjmYXKFiIiIaryuXbuWWXh2/PjxJSZCgoKCcPjw4TKP07x5c4SFhVUqRqrZ8vPzkZGRAUdHR3H6biIiqjk4LIiIiIiIyMAiIyPh5uaGyMhIqUMhIiIDYHKFSE+0dVwxKzMfeY7OUodCRERERqZ+/frYs2cP6tevL3UoRERkAEyuEOmJYG2DU3kCtJZWUodCRERERsbR0RH9+/eHo6Oj1KEQEZEBSJpcOX78OPr16wdPT0/IZDLs3r1b3Jafn48PPvgAQUFBsLGxgaenJ1599VUkJCTotJGWloaRI0fC3t4ejo6OGDt2LLKysqr5TIgAmToDw63kMMt6IHUoREREZGRSUlKwdu1apKSkSB0KEREZgKTJlezsbAQHB2PVqlVFtj18+BDnzp3DrFmzcO7cOezcuRNRUVHo37+/zn4jR47E5cuXcfDgQezduxfHjx9nVX6ShDwzA2NtzWCWpZY6FCIiIjIycXFxmDRpEuLi4qQOhYiIDEDS2YJ69+6N3r17F7vNwcEBBw8e1Fn39ddfo127doiNjYW3tzeuXr2K/fv348yZM2jTpg0AYOXKlejTpw++/PJLeHp6GvwciIiIiIjK0qpVKxQUFEgdBhERGYhJ1VzJzMyETCYTx6qeOnUKjo6OYmIFAEJDQyGXy3H69OkS28nNzYVardZ5ERERERERERFVhskkV3JycvDBBx9g+PDhsLe3BwAkJSXBzc1NZz8zMzM4OzsjKSmpxLYWLVoEBwcH8eXl5WXQ2ImIiIiodrtx4wZ69uyJGzduSB0KEREZgEkkV/Lz8/HSSy9BEAR88803VW5v5syZyMzMFF8c+0r6IFhZ41iuFhoLS6lDISIiIiOjUChgb28PhUIhdShERGQAktZcKY/CxMqdO3dw+PBhsdcKAKhUKty7d09n/4KCAqSlpUGlUpXYpoWFBSwsLAwWM9VOWhc3LFAXYJlTHalDISIiIiNTv359bN++XeowiIjIQIy650phYuXGjRs4dOgQ6tTRfWgNCQlBRkYGwsPDxXWHDx+GVqtF+/btqztcqu0KCuAiB2QaFqsjIiIiXRqNBtnZ2dBoNFKHQkREBiBpciUrKwsRERGIiIgAAMTExCAiIgKxsbHIz8/HkCFDcPbsWWzevBkajQZJSUlISkpCXl4eAKBJkybo1asXxo0bh3///Rf//e9/MXnyZAwbNowzBVG1UyTGY2sdc1ikJEsdChERUa2RkpKCyMhIpKSkSB1KqS5cuABbW1tcuHBB6lCIiMgAJE2unD17Fi1btkTLli0BANOnT0fLli0xe/Zs3L17F7/99hvi4+PRokULeHh4iK+TJ0+KbWzevBkBAQHo3r07+vTpg44dO2LdunVSnRIRERERVaPCL95Km8zAGPj6+mLLli3w9fWVOpQaz1QSbkRUs0hac6Vr164QBKHE7aVtK+Ts7IwtW7boMywiIiIiMhEqlQpJSUml1tszBs7Ozhg+fLjUYdQKTybcXF1dpQ6HiGoJo665QkRERERUGldXVwQFBRn9Q3RaWhp++uknpKWlSR1KjadSqWBubm70CTciqlmMfrYgIiIiIiJTd/v2bbzyyisIDw+Hs7Oz1OHUaK6urkafbCOimofJFSI90dT1Ru+UPHzh7iF1KERERGRkWrRogZycHCiVSqlDISIiA2ByhUhf5HLkA4CMo+2IiIhIl1wuh4WFhdRhEBGRgfApkEhP5PcSscTBDOb3WZmeiIiIdN26dQuDBg3CrVu3pA6FiIgMgMkVIj2R5eYi2FwOeX6e1KEQERGRkdFqtcjNzYVWq5U6FCIiMgAOCyIiIiIiMrAGDRrgjz/+kDoMIiIyEPZcISIiIiIiIiKqAiZXiIiIiIgM7Ny5c5DJZDh37pzUoRARkQEwuUKkJ1qnOljyoAD59o5Sh0JERERGxtvbG99++y28vb2lDoWIiAyAyRUiPRFs7bAvRwuNtY3UoRAREZGRcXFxwRtvvAEXFxepQyEiIgNgcoVIT2RZD9DbUg7Fw2ypQyEiIiIjk56ejp07dyI9PV3qUIiIyACYXCHSE3n6fbxrZwalOkPqUIiIiMjIxMTEYPDgwYiJiZE6FCIiMgBOxUxEREREZGDNmzfH/fv3YW9vL3UoRERkAEyuEBEREREZmJmZGZydnaUOg4iIDITDgoiIiIiIDCwmJgajRo3isCAiohqKyRUiPREsLHAhTwut0lzqUIiIiMjI5OfnIz4+Hvn5+VKHQkREBsBhQUR6onXzwLuZBVhWx1XqUIiIiMjINGrUCEePHpU6DCIiMhD2XCHSF60WSgAQtFJHQkRERERERNWIyRUiPVHcjcU+V3NYJidKHQoREREZmYiICNjY2CAiIkLqUIiIyACYXCEiIiIiMjBPT08sWrQInp6eUodCREQGwJorREREREQG5ubmhilTpui93ZSUFCQlJUGlUsHVlXXfiIikwp4rREREREQGplarceDAAajVar22m5SUhLy8PCQlJem13eqSkpKCyMhIpKSkSB0KEVGVMLlCRERERCbBlB/Eo6Oj0atXL0RHR+u1XZVKBXNzc6hUKr22W11MPTlERFSIyRUiPdF41MOw+3nIdXWXOhQiIqIayZQfxJs1a4a4uDg0a9ZMr+26uroiKCjIZIcEmXpyiIioEGuuEOmLmRlStYCg4D8rIiIiQ1CpVGJ9EVNjbm6OevXqSR2G5J6uEVP4IiIydZL2XDl+/Dj69esHT09PyGQy7N69W2e7IAiYPXs2PDw8YGVlhdDQUNy4cUNnn7S0NIwcORL29vZwdHTE2LFjkZWVVY1nQfSYPPUeZtmbQZl+X+pQiIiIaiRT7qURGxuLN998E7GxsVKHIilT7n1ERFQaSZMr2dnZCA4OxqpVq4rd/sUXX2DFihVYs2YNTp8+DRsbG/Ts2RM5OTniPiNHjsTly5dx8OBB7N27F8ePH8f48eOr6xSIRLJHD9HFQg5Fbk7ZOxMREVGNUN46MA8fPsS5c+fw8OHDaorMOHEYEBHVVJKOX+jduzd69+5d7DZBELB8+XJ8/PHHGDBgAADgxx9/hLu7O3bv3o1hw4bh6tWr2L9/P86cOYM2bdoAAFauXIk+ffrgyy+/hKenZ7WdCxERERHVPk/2xCitR01AQADOnDlTjZEZJw4DIqKaymgL2sbExCApKQmhoaHiOgcHB7Rv3x6nTp0CAJw6dQqOjo5iYgUAQkNDIZfLcfr06RLbzs3NhVqt1nkREREREVUUe2IQERFgxMmVwnGY7u66M6+4u7uL25KSkuDm5qaz3czMDM7OzqWO41y0aBEcHBzEl5eXl56jJyIiIqLaoLx1YC5evAhXV1dcvHixmiIjIqLqVKnkyrlz5xAZGSku79mzBwMHDsRHH32EvLw8vQVnKDNnzkRmZqb4iouLkzokqgG0Do74PqsABbb2UodCRFRjxMbGIiwsDAcOHMC5c+eQm5srdUhEleLm5obp06cX+WKQiIhqhkolV958801cv34dAHDr1i0MGzYM1tbW2L59O95//329BFbYtTI5OVlnfXJysrhNpVLh3r17OtsLCgqQlpZWatdMCwsL2Nvb67yIqkqwd8TPj7QosLWTOhQiIpN2+/ZtfPDBB/Dx8YGfnx+6dOmC3r17o02bNnBwcMDzzz+P7du3Q6vVSh0qUbmpVCrMnDmTw4eIiGqoSiVXrl+/jhYtWgAAtm/fjs6dO2PLli3YsGEDduzYoZfA/Pz8oFKp8Pfff4vr1Go1Tp8+jZCQEABASEgIMjIyEB4eLu5z+PBhaLVatG/fXi9xEJWX7GE2QsxlkOc8kjoUIiKTNWXKFAQHByMmJgYLFy7ElStXkJmZKRYM/fPPP9GxY0fMnj0bzZs3Z4FQMhlZWVk4ceIEsrKypA6FiIgMoFKzBQmCIH5bdOjQIbzwwgsAAC8vL6Smppa7naysLERHR4vLMTExiIiIgLOzM7y9vTF16lQsXLgQDRs2hJ+fH2bNmgVPT08MHDgQANCkSRP06tUL48aNw5o1a5Cfn4/Jkydj2LBhnCmIqp38fgoWOChxIyNN6lCIiEyWjY0Nbt26hTp16hTZ5ubmhueeew7PPfcc5syZg/379yMuLg5t27aVIFKiirl+/To6deqE8PBwtGrVSupwiIhIzyqVXGnTpg0WLlyI0NBQHDt2DN988w2Ax8mRpwvQlubs2bPo1q2buDx9+nQAwOjRo7Fhwwa8//77yM7Oxvjx45GRkYGOHTti//79sLS0FN+zefNmTJ48Gd27d4dcLsfgwYOxYsWKypwWERERSWzRokXl3rdXr14GjIRIv5o2bYpr167Bx8dH6lBIQikpKUhKSoJKpeKU1EQ1TKWSK8uWLcOoUaOwe/du/Oc//0GDBg0AAL/++is6dOhQ7na6du0KQRBK3C6TyTB//nzMnz+/xH2cnZ2xZcuW8gdPREREJuHRo0cQBAHW1tYAgDt37mDXrl1o0qQJevbsKXF0ZAqM6UHW0tISjRs3ljQGkl5SUpI4zFHq30ki0q9KJVeCg4N1ZgsqtHjxYpiZVapJIiIiIh0DBgzAoEGD8NZbbyEjIwPt27eHUqlEamoqli5digkTJkgdIhk5Y3qQjY+Px9KlSzF9+nTUq1dP0lhIOiqVSkz4EVHNUqmCtvXr18f9+/eLrM/JyUGjRo2qHBSRSTJT4naBFoKCCUYiIn04d+4cOnXqBOBx71h3d3fcuXMHP/74I4cAU7moVCqYm5sbxYOsWq3GgQMHoFarpQ6FJOTq6oqgoCDJk31EpH+Vegq8ffs2NBpNkfW5ubmIj4+vclBEpkjjURdvpBdgmWv56w4REVHJHj58CDu7x9Pb//XXXxg0aBDkcjmeeeYZ3LlzR+LoyBS4uroazUNs06ZNcfnyZanDICIiA6lQcuW3334T/37gwAE4ODiIyxqNBn///Tf8/Pz0Fx0RERHVWg0aNMDu3bvx4osv4sCBA5g2bRoA4N69e7C3t5c4OiIiIqL/qdCwoIEDB2LgwIGQyWQYPXq0uDxw4EAMGzYMBw8exJIlSwwVK5FRU8TfwZ46SlgmJ0gdChFRjTB79my899578PX1Rfv27RESEgLgcS+Wli1bVqit48ePo1+/fvD09IRMJsPu3bt1tstksmJfixcvBvC41+7YsWPh5+cHKysr+Pv7Y86cOcjLy9Np5+LFi+jUqRMsLS3h5eWFL774ovIfANUoly5dgq+vLy5duiR1KEREZAAV6rmi1WoBAH5+fjhz5gxcXFwMEhSRSRIE2MhlQCkzYBERUfkNGTIEHTt2RGJiIoKDg8X13bt3x4svvlihtrKzsxEcHIzXX38dgwYNKrI9MTFRZ3nfvn0YO3YsBg8eDAC4du0atFot1q5diwYNGuDSpUsYN24csrOz8eWXXwJ4XFOjR48eCA0NxZo1axAZGYnXX38djo6OGD9+fEVPn2oYZ2dnjBo1Cs7OzlKHYpKMaeYnIqLiVKrmSkxMjL7jICIiIipCpVIVKUbarl27CrfTu3dv9O7du9TjPGnPnj3o1q0b6tevDwDo1asXevXqJW6vX78+oqKi8M0334jJlc2bNyMvLw/r16+Hubk5AgMDERERgaVLlzK5YmCm8ODt6emJhQsXSh2GyTKmmZ+IiIpT6WlN/v77b/z999+4d++e2KOl0Pr166scGBEREdVu2dnZ+Oyzz0q837h165ZBjpucnIw//vgDGzduLHW/zMxMnV4Ip06dQufOnWFubi6u69mzJz7//HOkp6fDycmpSBu5ubnIzc0VlzmTTOWYwoP3w4cPce3aNQQEBMDa2lrqcEwOpzAmImNXqeTKvHnzMH/+fLRp0wYeHh6QyWT6jouIiIhquTfeeAPHjh3DK6+8Uq33Gxs3boSdnV2xw4cKRUdHY+XKlWKvFeDxA/7Thf3d3d3FbcUlVxYtWoR58+bpKfLayxQevK9du4bWrVsjPDwcrVq1kjock2NMMz8RERWnUsmVNWvWYMOGDXjllVf0HQ+RydK4e+Ct9HxMrsMLPxGRPuzbtw9//PEHnn322Wo97vr16zFy5EhYWloWu/3u3bvo1asXhg4dinHjxlXpWDNnzsT06dPFZbVaDS8vryq1WRuZwoN3QEAAwsPDERAQIHUopCemMByNiKpPpZIreXl56NChg75jITJt5haILhAgKM3L3peIiMrk5ORU7cU/w8LCEBUVhW3bthW7PSEhAd26dUOHDh2wbt06nW0qlQrJyck66wqXS+pRYWFhAQsLCz1ETsbO2tqaPVZqGFMYjkZE1adCUzEXeuONN7BlyxZ9x0Jk0uRpqXjbVgFlZobUoRAR1QgLFizA7Nmz8fDhw2o75vfff4/WrVvrzE5U6O7du+jatStat26NH374AXK57m1USEgIjh8/jvz8fHHdwYMH0bhx42KHBFHtkpCQgI8//hgJCQlSh0J6olKpYG5ubtTD0Yio+lSq50pOTg7WrVuHQ4cOoXnz5lAqlTrbly5dqpfgiEyJLDsLA6wUuPEoW+pQiIhqhCVLluDmzZtwd3eHr69vkfuNc+fOlbutrKwsREdHi8sxMTGIiIiAs7MzvL29ATwekrN9+3YsWbKkyPsLEys+Pj748ssvkZKSIm4rfLAaMWIE5s2bh7Fjx+KDDz7ApUuX8NVXX2HZsmUVOm+qmdLS0vDTTz9h2LBh8PT0lDoc0gN9D0fjMCMi01ap5MrFixfRokULAMClS5d0trG4LREREenDwIED9dbW2bNn0a1bN3G5sM7J6NGjsWHDBgDA1q1bIQgChg8fXuT9Bw8eRHR0NKKjo1GvXj2dbYIgAAAcHBzw119/YdKkSWjdujVcXFwwe/ZsTsNMAIBmzZrh9u3bUodBRozDjIhMW6WSK0eOHNF3HEREREQ65syZo7e2unbtKiZBSjJ+/PgSEyFjxozBmDFjyjxO8+bNERYWVpkQqZL4bT/VFKYw6xURlaxSNVeIiIiIDKGsBAjR0578tt+YXblyBYGBgbhy5YrUoZCRcnV1RVBQUJWShCkpKYiMjNQZukhE1aNSPVe6detW6vCfw4cPVzogIlMl2Nrj14caBFrbSh0KEZHJCgwMxOzZszFo0CCYm5c8+9qNGzewdOlS+Pj44MMPP6zGCMnYmMq3/fb29ujZsyfs7e2lDoVqMA4tIpJOpZIrhfVWCuXn5yMiIgKXLl3C6NGj9REXkcnROjljTbYGy+wdpA6FiMhkrVy5Eh988AEmTpyI559/Hm3atIGnpycsLS2Rnp6OK1eu4MSJE7h8+TImT56MCRMmSB0ySUzfRUUNpV69epz0gQzOVJKNRDVRpZIrJVW9nzt3LrKysqoUEJHJys1BEzMZ5Hm5UkdCRGSyunfvjrNnz+LEiRPYtm0bNm/ejDt37uDRo0dwcXFBy5Yt8eqrr2LkyJGc3phMSk5ODu7cuQMfHx9YWlpKHQ7VUKaSbCSqiSqVXCnJqFGj0K5dO3z55Zf6bJbIJCjuJWGlkxI30lKlDoWIyOR17NgRHTt2lDoMIr25cuUKWrdujfDwcLRq1UrqcIiISM/0WtD21KlTzMQTERERET2lUaNGCAsLQ6NGjaQOpdZgcVciqk6V6rkyaNAgnWVBEJCYmIizZ89i1qxZegmMiIiIiKimsLW1ZW+sasbirkRUnSrVc8XBwUHn5ezsjK5du+LPP//EnDlz9B0jEREREZFJS0pKwqJFi4x+yuiaRKVSwdzcnMVdiahaVKrnyg8//KDvOIhMn1yODK0AyPU62o6IiIhqgHv37mHp0qXo27cvH/arCYu7ElF1qlJB2/DwcFy9ehUAEBgYiJYtW+olKCJTpKnrjWH387HMzUPqUIiIiMjING/e3OC1P1JSUsRpeJlUICKqXpVKrty7dw/Dhg3D0aNH4ejoCADIyMhAt27dsHXrVv5nTkRERFWmUCiQmJgINzc3nfX379+Hm5sbNBqNRJERGSfWGCEikk6lxi+8/fbbePDgAS5fvoy0tDSkpaXh0qVLUKvVmDJlit6C02g0mDVrFvz8/GBlZQV/f38sWLAAgiCI+wiCgNmzZ8PDwwNWVlYIDQ3FjRs39BYDUXkpEuOx0VkJi5RkqUMhIqoRnrzePyk3Nxfm5ubVHA1R1Vy7dg1t27bFtWvXDHYM1hghIpJOpXqu7N+/H4cOHUKTJk3EdU2bNsWqVavQo0cPvQX3+eef45tvvsHGjRsRGBiIs2fP4rXXXoODg4OYxPniiy+wYsUKbNy4EX5+fpg1axZ69uyJK1eucFpoql4FBairkOGGpkDqSIiITNqKFSsAADKZDN999x1sbW3FbRqNBsePH0dAQIBU4RFVirW1NVq1agVra2uDHYM1RoiIpFOp5IpWq4VSqSyyXqlUQqvVVjmoQidPnsSAAQPQt29fAICvry9+/vln/PvvvwAef6O1fPlyfPzxxxgwYAAA4Mcff4S7uzt2796NYcOG6S0WIiIiqh7Lli0D8Pg6v2bNGigUCnGbubk5fH19sWbNGqnCI6oUb29vrF27VuowiIjIQCo1LOi5557DO++8g4SEBHHd3bt3MW3aNHTv3l1vwXXo0AF///03rl+/DgC4cOECTpw4gd69ewMAYmJikJSUhNDQUPE9Dg4OaN++PU6dOlViu7m5uVCr1TovIiIiMg4xMTGIiYlBly5dcOHCBXE5JiYGUVFROHDgANq3by91mCSRlJQUREZGGrw4rL7l5eUhPj4eeXl5UodCREQGUKnkytdffw21Wg1fX1/4+/vD398ffn5+UKvVWLlypd6C+/DDDzFs2DAEBARAqVSiZcuWmDp1KkaOHAngcdEuAHB3d9d5n7u7u7itOIsWLYKDg4P48vLy0lvMREREpB9HjhyBk5OT1GGQkXmyaKspuXTpEry8vHDp0iWpQyEiIgOo1LAgLy8vnDt3DocOHRKLcjVp0kSnB4k+/PLLL9i8eTO2bNmCwMBAREREYOrUqfD09MTo0aMr3e7MmTMxffp0cVmtVjPBQlWmdXHHhxn5eMWpjtShEBGZrCevz2VZunSpASMhY6VSqcTphk1JgwYNsH//fjRo0EDqUIiIyAAqlFw5fPgwJk+ejH/++Qf29vZ4/vnn8fzzzwMAMjMzERgYiDVr1qBTp056CW7GjBli7xUACAoKwp07d7Bo0SKMHj1avKgmJyfDw8NDfF9ycjJatGhRYrsWFhawsLDQS4xEhQQrK5zNFzDSgoWUiYgq6/z58zrL586dQ0FBARo3bgwAuH79OhQKBVq3bi1FeGQETLVoq729PXr27Cl1GEREZCAVGha0fPlyjBs3Dvb29kW2OTg44M0339Trt0gPHz6EXK4bokKhEIvm+vn5QaVS4e+//xa3q9VqnD59GiEhIXqLg6g8ZJkZeNVaAbMs1vAhIqqsI0eOiK9+/fqhS5cuiI+Px7lz53Du3DnExcWhW7duYrF7IlNx7949rFixAvfu3SuyzVTryBAR0f9UKLly4cIF9OrVq8TtPXr0QHh4eJWDKtSvXz988skn+OOPP3D79m3s2rULS5cuxYsvvgjg8RSNU6dOxcKFC/Hbb78hMjISr776Kjw9PTFw4EC9xUFUHnJ1Bl61UcAs64HUoRAR1QhLlizBokWLdOquODk5YeHChViyZImEkdVMfMA3rISEBMycOVNnQohCplpHhoiI/qdCw4KSk5OLnYJZbMzMTK8X5JUrV2LWrFmYOHEi7t27B09PT7z55puYPXu2uM/777+P7OxsjB8/HhkZGejYsSP2798PS0sOzSAiIjJlarW62PuKlJQUPHjARLa+PfmAb4rDboxdixYtkJ2dXew2U60jQ0RE/1Oh5ErdunVx6dKlEgtxXbx4Uaf2SVXZ2dlh+fLlWL58eYn7yGQyzJ8/H/Pnz9fbcYmIiEh6L774Il577TUsWbIE7dq1AwCcPn0aM2bMwKBBgySOrubhA750TLWODBER/U+FhgX16dMHs2bNQk5OTpFtjx49wpw5c/DCCy/oLTgiIiKqvdasWYPevXtjxIgR8PHxgY+PD0aMGIFevXph9erVUodX47i6uiIoKIgP+QZy/fp1dO3aFdevX5c6FNIDDqMjoqdVqOfKxx9/jJ07d6JRo0aYPHmyWLn/2rVrWLVqFTQaDf7zn/8YJFAiYydY2eBQjgb1LK2kDoWIqEawtrbG6tWrsXjxYty8eRMA4O/vDxsbG4kjI6o4pVKJevXqlTrEnkwHh9ER0dMqlFxxd3fHyZMnMWHCBMycOROCIAB4PDSnZ8+eWLVqFdzd3Q0SKJGx07q44rMHGixzdJY6FCKiGsXGxgbNmzeXOgyiKvHz88NPP/0kdRikJ/oaRpeSkiK2wyQNkWmrUHIFAHx8fPDnn38iPT0d0dHREAQBDRs21KnkT1Qr5efBUw7ICvKljoSIiIiMTEFBAdRqNezt7WFmVuFbcDIy+qqTwx4wRDVHhWquPMnJyQlt27ZFu3btmFghAqBISsCPdcxhkXpP6lCIiIjIyFy8eBF16tTBxYsXpQ6FjIhKpYK5uTkLSRPVAEybExEREREZmJ+fH3bs2AE/Pz+pQyEjwpmiiGoOJleIiIiIiAzMycmJU4gTEdVglR4WRERERERE5ZOamorvvvsOqampUodCREQGwOQKEREREZGBxcbGYty4cYiNjZU6FCIiMgAOCyLSE42XL0JT8rBMVVfqUIiIiMjItGrVCoIgSB0GEREZCHuuEBERERERERFVAZMrRHqiSE7ECkczmN9PkToUIiIiMjLR0dHo27cvoqOjpQ6FiIgMgMkVIn3Jy0VTpRzy/DypIyEiIiIjI5fLYWFhAbmct99ERDURa64QERERERlY/fr1sXPnTqnDICIiA2FyhcjAYmJu6Sw7OTlCpfKQKBoiIiKSglarRX5+PpRKJXuvEBHVQEyuEBlIelo65HIZZs78SGe9paUl9uzZzQQLERFRLRIREYHWrVsjPDwcrVq1kjocIiLSMyZXiPRE6+yCReoCDHBwAgBkZWdDqxUwffp0eHnVAwDExcVj6dKlSE/PYHKFiIioFvH19cWmTZvg6+srdShEopSUFCQlJUGlUsHV1VXqcIhMGpMrRHoi2Nji71wtXrCy1lnv5VUP/v7+EkVFRERExsDZ2RmjRo2SOgzSg5qUkEhKSkJeXh6SkpJM/lyIpMYBn0R6InugRn9LORTZWVKHQkREREYmLS0NP//8M9LS0qQOharoyYSEqVOpVDA3N4dKpZI6FCKTx+QKkZ7IM9Iwxc4MygeZUodCRERERub27dsYMWIEbt++LXUoVEU1KSHh6uqKoKAg9loh0gMOCyIiIiIiMrDg4GBkZWXB0tJS6lCoilxdXZmMIKIimFwhIiIiIjIwhUIBGxsbqcMgIiID4bAgIiIiIiIDu3XrFoYOHYpbt25JHQoRERkAkytEeiJYWOJsnhZacwupQyEiIiIjo9FooFarodFopA7FJKSkpCAyMhIpKSlSh0JEVC5MrhDpidZNhQ8zC5Dn7CJ1KERERGRkGjZsiAMHDqBhw4ZSh2ISatKMPERUOzC5QqQvWi2sZY//JCIiIqLKq0kz8hBR7WD0yZW7d+9i1KhRqFOnDqysrBAUFISzZ8+K2wVBwOzZs+Hh4QErKyuEhobixo0bEkZMtZXibix+czGH5b1EqUMhIiIiI3Pu3DmYmZnh3LlzUodiEjhFMBGZGqNOrqSnp+PZZ5+FUqnEvn37cOXKFSxZsgROTk7iPl988QVWrFiBNWvW4PTp07CxsUHPnj2Rk5MjYeRERERERP/j5eWFVatWwcvLS+pQiIjIAIx6KubPP/8cXl5e+OGHH8R1fn5+4t8FQcDy5cvx8ccfY8CAAQCAH3/8Ee7u7ti9ezeGDRtW7TETERERET3N1dUVb775ZoXfl5KSgqSkJKhUKvbiICIyYkbdc+W3335DmzZtMHToULi5uaFly5b49ttvxe0xMTFISkpCaGiouM7BwQHt27fHqVOnSmw3NzcXarVa50VEREREZCgZGRn47bffkJGRUaH3GVNhV87gQ0RUMqNOrty6dQvffPONWF19woQJmDJlCjZu3AgA4kXG3d1d533u7u6lXoAWLVoEBwcH8cXumURERERkSLdu3cKAAQNw69atCr2vIoVdDZ38MKZEDxGRsTHq5IpWq0WrVq3w6aefomXLlhg/fjzGjRuHNWvWVKndmTNnIjMzU3zFxcXpKWKqzTSe9TA4NQ85rqxqT0RERLqCgoJw7949BAUFVeh9FSnsaujkB2fwISIqmVEnVzw8PNC0aVOddU2aNEFsbCwAiP+xJycn6+yTnJxc6n/6FhYWsLe313kRVZnCDJkCAIVC6kiIiIjIyCiVSri6ukKpVBrsGIZOfnAGn+JxuBQRAUaeXHn22WcRFRWls+769evw8fEB8Li4rUqlwt9//y1uV6vVOH36NEJCQqo1ViJ5SjLm25vBPP2+1KEQEdETjh8/jn79+sHT0xMymQy7d+/W2S6TyYp9LV68WNznk08+QYcOHWBtbQ1HR8dijxMbG4u+ffvC2toabm5umDFjBgoKCgx4ZmRKbt++jTFjxuD27dsGOwaTH9LgcCkiAow8uTJt2jT8888/+PTTTxEdHY0tW7Zg3bp1mDRpEoDHN0NTp07FwoUL8dtvvyEyMhKvvvoqPD09MXDgQGmDp1pHlvMIHSzkkOdyGnAiImOSnZ2N4OBgrFq1qtjtiYmJOq/169dDJpNh8ODB4j55eXkYOnQoJkyYUGwbGo0Gffv2RV5eHk6ePImNGzdiw4YNmD17tkHOiYxbcT0ZcnNzER0djdzcXAkjI0PgcCkiAox8Kua2bdti165dmDlzJubPnw8/Pz8sX74cI0eOFPd5//33kZ2djfHjxyMjIwMdO3bE/v37YWlpKWHkREREZCx69+6N3r17l7j96QeiPXv2oFu3bqhfv764bt68eQCADRs2FNvGX3/9hStXruDQoUNwd3dHixYtsGDBAnzwwQeYO3cuzM3Nq34iZDKe7MlQ2IukcePGOHHihMSRVV1pU0PX1mmjXV1da9X5ElHxjLrnCgC88MILiIyMRE5ODq5evYpx48bpbJfJZJg/fz6SkpKQk5ODQ4cOoVGjRhJFS0RERKYsOTkZf/zxB8aOHVuh9506dQpBQUE6Mxj27NkTarUaly9fLvF9ubm5UKvVOi8yfU/2ZKhp9ThKGwLD4TFEVJsZfXKFiIiIqLps3LgRdnZ2GDRoUIXel5SUpJNYASAul/aguWjRIjg4OIgvLy+vigdNRufJ2ieFCYejR4/C3t4eERERUodXJaUNgeHwGCKqzZhcIdITrYMTvskqQIEtZ58iIjJV69evx8iRI6ttePHMmTORmZkpvuLi4qrluFR9ChMOTZs2xdy5c+Hh4SF1SFVSWtFcFtQlotrMqGuuEJkSwd4BOx5p0dHWTupQiIioEsLCwhAVFYVt27ZV+L0qlQr//vuvzrrk5GRxW0ksLCxgYWFR4eOR8Smp3siT9TgCAwOlCo+IiAyMPVeI9ET2MBudzWWQP3oodShERFQJ33//PVq3bo3g4OAKvzckJASRkZG4d++euO7gwYOwt7dH06ZN9RkmGamy6o2o1WocOnSIdXXIpNW0GkJE+sTkCpGeyO+nYLaDEuaZ6VKHQkRET8jKykJERIRY6yImJgYRERGIjY0V91Gr1di+fTveeOONYtuIjY0V36PRaMT2srKyAAA9evRA06ZN8corr+DChQs4cOAAPv74Y0yaNIk9U2qJsuqNREdH4/nnn0d0dHQ1R0akPyxaTFQyDgsiIiKiGu3s2bPo1q2buDx9+nQAwOjRo8Wplbdu3QpBEDB8+PBi25g9ezY2btwoLrds2RIAcOTIEXTt2hUKhQJ79+7FhAkTEBISAhsbG4wePRrz58830FmRIVRlKuGypuMNDAxETEyMyddcodpNpVKJ/0aISBeTK0RERFSjde3aFYIglLrP+PHjMX78+BK3b9iwQUzElMTHxwd//vlnZUIkI/Hkt/L6LspqYWEBX19fvbZJVN3KSiIS1WYcFkREREREBMNOJRwbG4tJkybpDEcjqgzWPSEyTuy5QqQvSiVu5GshmCmljoSIiIgqwZDfymdnZ+PUqVPIzs4udntVhiRR7fJ0Dyv+7hAZB/ZcIdITjaouJmQUINfFTepQiIiIyMg0adIE586dQ5MmTQAU7X3AQqFUXk/3sKrO3x32miEqGZMrRERERETV7OkHYkMOSaLqUx3JB1dXVwQFBYm9VKrzd4dJQKKSMblCpCeKuNv400UJy6S7UodCRERERubixYvw8PDAxYsXARR9IH76gZmqT1USIrdu3UJ4eDhu3boFQJrkQ1m/O/pM+DAJSFQy1lwh0iNzmUzqEIiIiMgIubq6YtKkSeIDMGddMR5VmSUqPT1d509jnKpYn7Ng8feWqGRMrhARERERGZiHhwc+/vhjvbfLYqZVV5WEiJOTE9LT0+Hk5ATAOJMPxpjwIaqJmFwhIiIiIjKwrKwsREZGIigoCLa2tnprV5+9EmqqshJQVUmI1K9fv6rhGZwxJnyIaiLWXCEiIiIiMrDr16+jQ4cOuH79ul7btbGx0fnTEEx9hhgWYSWi6sDkCpGeaNw9MTYtH7l1OBUzERER6WrSpAkuXbokTsVcVYUJD7VaDQDIzs7WS7vFMfXkBIuwElF14LAgIn0xN8cdjQBBqZQ6EiIiIjIyVlZWCAwM1Ft7hQkPhUJh8MSBqdfskGJYDGvhENU+7LlCpCfytFRMt1VAmZkudShEREQkgdKGz8THx2PGjBmIj4/Xy7EKe2PUrVvX4FM4c5roijP13j5EVHFMrhDpiSw7C32sFFA8eih1KERERCSB0h6oMzMz8dtvvyEzM1Mvx2LCw7hxKBJR7cNhQUREREREelDa8JnAwEBERUVJEBVJgTP0ENU+TK4QEREREekBH6hrHtZOIaLy4rAgIiIiohrK1KfQrUkuX76MBg0a4PLly1KHQhXA2ilEVF5MrhDpiWBnj58falBgYyt1KERERAD4YFgehkxAPdm2o6Mjhg4dCkdHR8njovJj7RQiKi8mV4j0ROvojO+zNSiwc5A6FCIiIgB8MCwPQyagnmzb3NwcI0aMgLm5ueRxUfmxcDARlRdrrhBVQVJSItLTMwAAd6KuIlgpgzw3V9qgiIiI/h9rgJSttCK0+mz79u3buHnzJnJycsr1MzFkXEREpH8m1XPls88+g0wmw9SpU8V1OTk5mDRpEurUqQNbW1sMHjwYycnJ0gVJtUZSUiIGDBiIYcOGYdiwYfh2wXwscVTCPD1V6tCIiIionAzZM+HJttVqNYYPHw61Wi15XIbCoUxEVJuZTHLlzJkzWLt2LZo3b66zftq0afj999+xfft2HDt2DAkJCRg0aJBEUVJtkp6egZycHEyfPh3Lli1Fn969pQ6JiIiIJFRacuGZZ57Bv//+i2eeeUaCyKoHhzIVxYQTUe1hEsmVrKwsjBw5Et9++y2cnJzE9ZmZmfj++++xdOlSPPfcc2jdujV++OEHnDx5Ev/884+EEVNt4uVVD/7+/nB2dpY6FCIiIpJQackFGxsbtG3bFjY2NhJEVj1Y46coJpyIag+TSK5MmjQJffv2RWhoqM768PBw5Ofn66wPCAiAt7c3Tp06VWJ7ubm5UKvVOi8iIiIioqooLbmQmJiIuXPnIjExUYLIqocpDmUyNCaciGoPoy9ou3XrVpw7dw5nzpwpsq2w8vrTU9q5u7uXmh1etGgR5s2bp+9QqZYT5HKkaAQIcoXUoRAREZEESisgnJqaiu+++w6DBw+Gh4eHQY6fkpIiFsFlgsOwyvtZs6g0Ue1h1D1X4uLi8M4772Dz5s2wtLTUW7szZ85EZmam+IqLi9Nb21R7PXBywfC0fOS68ZsJIiKqeUqqHcGaEuUTFBSE+Ph4BAUFGewYHIJSffhZE9HTjDq5Eh4ejnv37qFVq1YwMzODmZkZjh07hhUrVsDMzAzu7u7Iy8tDRkaGzvuSk5NL7XpnYWEBe3t7nRcRERERlaykh0lTesis6YkgDkGpPvysiehpRp1c6d69OyIjIxERESG+2rRpg5EjR4p/VyqV+Pvvv8X3REVFITY2FiEhIRJGTrWRXXoqfnZWwuKe8d9cEhERVVRJD5Om9JApZSLoypUraN68Oa5cuWKwY7DmSfXhZ01ETzPqmit2dnZo1qyZzjobGxvUqVNHXD927FhMnz4dzs7OsLe3x9tvv42QkJAaPc0dGSeZVgtXhQwZWo3UoRAREeldSbUjTKmmhEqlEutkVDc7Ozt07doVdnZ21X5sIiIyPKNOrpTHsmXLIJfLMXjwYOTm5qJnz55YvXq11GERERERkZGRMhHk5eWFFStWSHJsIiIyPJNLrhw9elRn2dLSEqtWrcKqVaukCYiIiIiolqjKbDRVncnGGGfCqUhMOTk5iI+PR7169fQ6UQMRERkHo665QkRERETGoyo1Syry3uIKzxpj4dyKxHTlyhU0bNjQoDVXqHJqeqFjIqoeTK4Q6Um2vSPezchHnpOL1KEQEREZRFWK11bkvcUlLYyxcG5FYmrYsCGOHDmChg0bVkNkVBHGmLgjItNjcsOCiIyVRmmOC/kCtBYWUodCRERkEFWpWVKR9xZXeLY876/uoUMVOafCgrbVyRiHUhkjKQsdE1HNwZ4rRHpi8TALY20UMHuQKXUoREREJq2y09wacw+E5ORkLF68GMnJydV2TGP+PIwJp1UmIn1gcoVITywePcRwawXMsrOkDoWIiMhk6LPehTEOHSqUlJSERYsWVWuiw5g/DyKimobDgoiIiIhIMk/2rqhqzwF9TbVsiOE0wcHBSEtL00tb5SXl1NNERLUNe64QERERkWRK6l0h5QwuHE5DREQVxeQKERERkYmpSVPHllTvQsoEhyGG00RFRSEkJARRUVF6a5OIiIwHkytEepJnYYk/H2mgsbKWOhQiIqrhakPPCinrhRiiwKmlpSUCAwNhaWmptzaJiMh4sOYKkZ7k2NpjaZYGyxycpA6FiIhquNowday+64VIPS2xj48Pvvvuu2o/LhERVQ8mV4j0RF5QAB+FDLL8fKlDISKiGo6FSktWUhJFn4VzKyM/Px9RUVHIy8uDl5cXf35ERDUMkytEemKbmYbvnZW4cf8egACpwyEiIhOm0Wih0WilDsMkJdxNRF5+HhLuJsLZuY643s3VHUlJSXBzdS/2s427/xBn7qSjrY8TvOrof4hvRMQFtGvXFj/+uAkKuZlObFR7pKakisk/F1cXqcMhqlUMfV1lcoWIiIjIyKjvPwLylFKHYZJsLZyQqk6Fra0T1KmPxPXmMht4e/gDgM56AEjMyMFrP/yLXI0WFgo5fnitHTwc9Vsbxc3RE99+8wM863jD1sKpSAxUO9y+fhf5+fnIUd+Fucymwu9PzMjBhfhMBNdz0PvvKFFNp35g2P93mVwhIiIiMjJyuQxmZqY578Dd9BxExGfAw94SieoctKjniLpO1fcQ6ObmAje3snsE3E3PwZGoZHH54f9/o/lQo8XFRDW8XPTbe8XZ2QkvD31Zr22S6XFXueFe6j24ubhV+N/43fQcvPpEEvCnN56p1n9bRKZOLpcZtH0mV4iIiIiMjFwug1xhesmVu+mPMPL7f5DzRNdrS4UcP48PQV0nKwkj03U3/RFGfH8KuRoBAKCUA0ozGXI1AiwVcrTycdL755+SmoKdu3Zg0IuD4erCeiu1laubC1zLkfwrzoWETDzSagEZ8EirxYWETL0nAYlqMkMnV0zvqk1krGQy5AmC1FEQERFJ5nxchk5iBQByNFqcj8uQJqASnI/LEBMrAJCvBV5u640BwZ5YNqylQRJBCQl3MfPj95GQcFfvbevL3fRH2HsxEXfTOWTJGLX0coTl/yf9LBVytPRylDYgItLBnitEeqJ2dkWf1HwsU9WVOhQiIiJJFD78Pd1zxdgeAj0cLGEml6FA+7+eK9vOxCJXI+DApSSD9LQJbt4CaclqvbapT3fTH2H4ulPI0WiNsrcRAXWdrPDz+BCcj8tASy9H/nyIjAyTK0RERESkF08+/Hk4WCIxM0evD4F30x9V+cHybvojTNt6HgVaAQoZMLK9DxyslFh5JBrA/3ra1LYH1yd7HdXWz8AU1HWy4s+FyEhxWBCRnthkpuEbRzNYpN6TOhQiIiLJ1HWywgvNPdDaxwkvNPfQa2Jl+LpTmL/3MoavO1XpoStPJhE0AuDrYovnAtzF4RZKhQxKuQx7LyYi/E663obJRN+MxgsDeyP6ZnSV26qo8gz34ZATIqKqYc8VIj1RFBSgoVKOGwX5UodCRERUKn30AKluT/esOHwtGa+E+Fa4nSeHLhUmEeo6WWFCV38s//sG8jUCZv12Sec9+hgmY2amgEsdF5iZKSrdRmWUd7iPsQ05McXf0Yqo6edHVBsxuUJERERUi5hqbY2WXo4wV8iQ9/+FaNcdv4nnAtxLjb24B9jCJMLha/+bhjn8TjqW/X2jxHaeHCZT2YdiXx8/bPh+U7n315eKDPep6pATfSUMTPV3tLxq+vkR1VZMrhARERHVIqZaW6OukxXe7Owv1kbJ1Qg6sT/9YF/WA+y3x28hR6PF2uPRcLS2LPXYhT1cqvJQrNFokJ2dDRsbGySp8wzWa+Hpz6G4njqGoM+Egan+jpZXTT8/otqKyRUiIiIiE1OVHgLV9bBdWcWdW+G6pp4OYuxKuQweDpbi9qcf7Et7gH1yW54GuPcgp8R4ejRxR2OVXZH3VfShOPLSRXTsGoKdvx3FwpMPDdJroaQER3UM99FnwsDYf0erSt/nxyFGRMaByRUiPXloa4/5mfkY7OAkdShERFSDVbWHQEkP28bwgFbcuQHQWfefvk0x/4/LyNcImLb1fImJlNIeYJ8eYvSkBq62iE7JEpcPXk3GX1eT8fWRaIzp4AulXIZ8rVDhh2IfH1/8+MNmpMkdkaPJ0om1vJ93WT+jkhIc1THDjD4TBsZW/0Xf9Hl+5fn/wBj+bRPVBkyuEOlJgYUljucJeNHKWupQiIioBtNHD4GnH7armrDR18NbcedW+PfCP49dT0H+/ydFCgvbFs72k6PRQql43KOlrpMVlg1rif2XEtGrmYc4VOjwtWTEpz8sNrFiJgMcrJQ664Qn/vzh5G0Aj2cUWjasZYXO1cnRCYMGDsbd9EdYfSKhwkmIJ39GFgoZxnf2L1JzRsoeH/pOiNT0KYf1dX5l/X/A+i5E1YdTMRPpifmjhxhsJYdZ1gOpQyEioqccP34c/fr1g6enJ2QyGXbv3q2zXSaTFftavHixuE9aWhpGjhwJe3t7ODo6YuzYscjKytJp5+LFi+jUqRMsLS3h5eWFL774Qu/nYogpc4t7QCvP9L2A/qZIBoo/t8JeJoWOXU/WWV57/CYAYNmwlo97lWgETN16Dl8fvoGpW89hz4UETNt6HgcuJWHo2pNYeSQauyISdI7rbmeJhq62KBCA8Nj0MuPM1wjYf6liUzXfT7uPn7b8CEvhIX4eH4LZLwRW6EH3yZ9RrkbAyiPRRT7vwgRHRdsGyjddc1kKp+Hmw3v1Kev/g5ISlkSkf0bfc2XRokXYuXMnrl27BisrK3To0AGff/45GjduLO6Tk5ODd999F1u3bkVubi569uyJ1atXw93dXcLIqbaxfJiFCbZmuJGlljoUIiJ6SnZ2NoKDg/H6669j0KBBRbYnJibqLO/btw9jx47F4MGDxXUjR45EYmIiDh48iPz8fLz22msYP348tmzZAgBQq9Xo0aMHQkNDsWbNGkRGRuL111+Ho6Mjxo8fr7dzMcSQiSeHyZj/f8+P8n7brc9aG8Wd2930R9AK/+tlkq8FnvV3xn9v3gcA5P1/YdvH2x7vl6sR8OM/d8T35Gi0mPP7JWiLdlYBAKQ8yEFyBb8b2XMhAXsuPE7SlKdHQFzc/7V353FRlnv/wD8z7CirxCbggqa4IYIaWqbJEa2fmXZOaeaWx7IHy6XIzDKtp7TMTMnUetwqPZQnt7RSUllUJEVAUULEBVTAjX2HuX5/GHcMDDDADLP4eb9evk73dS9zfa8z3nPfX68lA7NDXsaxyFj0921erxdAuVdKjYZWMfp//dzqnd9Y76IHoXeDsQ6Naep+YOzz1xDpE71PrkRFRSEkJAQDBw5EVVUV3nnnHYwaNQoXLlxAu3btAADz58/HgQMHsHPnTtjZ2WHOnDmYMGECjh8/ruPaExERkT4YM2YMxowZ0+B+V1dXpe29e/dixIgR6Nq1KwAgJSUFv/32G06dOoWAgAAAQFhYGJ588kl89tlncHd3x/bt21FRUYHNmzfD3NwcvXv3RmJiIj7//HONJlcA7QyZkNX63ws389VOmGj65a1ubAmZeahSKB9z6updWJjIUF7999wn2QUNT0prKpehqqHMCgBFg3vuszaVo7RKAYH77VP3SmXVCmw9cQXTh3RpsJ18+/XH+Yu3cfZmIR7KLW3RUK6aJaQ3RqejolbsTSVHmtpv7KvXGHvyqLH7gbHPX0OkT/Q+ufLbb78pbW/duhXOzs6Ij4/HsGHDkJ+fj02bNmHHjh144oknAABbtmyBj48PTp48iUceeUQX1SYiIiIDlZOTgwMHDmDbtm1SWWxsLOzt7aXECgAEBQVBLpcjLi4O48ePR2xsLIYNGwZzc3PpmODgYHzyySfIzc2Fg0P9Cc/Ly8tRXl4ubRcU6Kb3Y0JmHsqr/+71AUDthIk2X95u5JYit7i83uSzFdXA1Ee8kF9aKc2ncuTPnHrnm8mB2Y93w/XcknpDgZqjpFZ2p6EUzd6kmziYnN3gi/vNvDJM2XyqyRf8xnpYdHSwwpTAzniip4vSMfvPZjWaHGkqeWLsvRuMPXnUFGOfv4ZIX+h9cqWu/Px8AICjoyMAID4+HpWVlQgKCpKO6dmzJ7y8vBAbG6syuaIvDzJERESkf7Zt2wYbGxul4UPZ2dlwdnZWOs7U1BSOjo7Izs6WjunSpYvSMTVDlLOzs1UmV5YvX45ly5ZpOoRmq/ty/URPl3ov8I3Rxstb3Qlcpz7SCf/54xoqFYC5CRB+KgMV1QL7z97E077u2H8uq941Zj/eDU/0dMG6o5c0WrfaavdkaezF/deTSbi4cylcR8wCHNxUHqduD4ua9q6ZJ8XNzrLR5EhTyRNj791g7MkjItIPBpVcUSgUmDdvHoYOHYo+ffoAuP+wYm5uDnt7e6VjXVxcpIeduvTlQYaMS5W5BU6UK9DBwlLXVSEiolbYvHkzJk+eDEtL7d/PFy1ahAULFkjbBQUF8PT01Prn1tXQy7UuX7LrTuAqgwxy2f1UhkL8PcynWkBlrxRzExl6udtJyQptqd2TpWalIlV6u9nCRHZ/8FVDL/h1e1gc+TMHDu0s1JonZfVEP2TllzXY46Wp5EndhI0mlgjWl2SNsSePiEg/GFRyJSQkBMnJyTh27FirrqMvDzJkXEps7PC/BVVY7dBB11UhIqIWiomJQWpqKn744QelcldXV9y6dUuprKqqCvfu3ZPma3F1dUVOjvLQlJrtunO61LCwsICFhYWmqt8qtXuf6MOLsZ+nvTSvCgBs/+OqNPdKY/On1Jg0sBOy8svqJVZUzZmiKZXVAvPDE1T2OAns3wv7/rtHaWnoumrHbG4CfB2dLs0r09Q8KVn5ZSonsq2hTu8iTc1Nom9znNQswU1EpE0GsxTznDlzsH//fhw9ehQeHh5SuaurKyoqKpCXl6d0fE5OTqMPMra2tkp/iFpLpqiGnQxAdXWTx165chkpKSlITf0Tt3L4Y09EpC82bdoEf39/+Pr6KpUHBgYiLy8P8fHxUtmRI0egUCgwePBg6Zjo6GhUVlZKx0RERKBHjx4qhwTpK00urdwaHR2s8PxAL2m77qS2TfnPqaswk8tgKpcplWsrsVKjoeVur98rwbwdp7En8Qbmhyc02K419atW/D3/japrttWS3M1R0+vlyJ85erP8743cUkz8+v4S3GFHL+H5r0/o7DtNRMZN73uuCCHw2muvYffu3YiMjKw3ltnf3x9mZmY4fPiwtFxiamoqMjIyEBgYqIsq0wPKJvcufnIyR9rtbODhh1Uek3svF3K5DIsWvQMAMJWbwdbGHvsiwtHFu3Mb1paI6MFSVFSES5f+nnfjypUrSExMhKOjI7y87r/AFxQUYOfOnVi1alW98318fDB69GjMmjULGzZsQGVlJebMmYOJEyfC3d0dAPDCCy9g2bJlmDlzJhYuXIjk5GSsWbMGq1evbpsgNaSlk3/W7h3wRE+XVvdUuJFbih9OZUjbpvLmJVgqqoGlPyejWtvZFBUKSyukuVBqhursPnIcCZ+ORZepX0Dm0k1luyZk5kkT91aL+8OMKmutClRbQ8tWN9XjqLFjWjM3Se3eKuYmsnqrOelK7cmaAeWlu3XdO4uIjIveJ1dCQkKwY8cO7N27FzY2NtI8KnZ2drCysoKdnR1mzpyJBQsWwNHREba2tnjttdcQGBjIlYJI7xQVF0OhEFiwYAE8PT2Qee0GNq7/Bnfu3mVyhYhIi06fPo0RI0ZI2zXDg6dNm4atW7cCAMLDwyGEwKRJk1ReY/v27ZgzZw5GjhwJuVyOZ599FmvXrpX229nZ4dChQwgJCYG/vz+cnJywZMkSjS/DrG0tecG+kVuK578+ISUGvo5OR/jLQ1r10lr3pXjyoM7Y8cc1VKoxJKiGNhMrMgBymerPWHskTanc0kSOpaO7otOT82Fm69xgu9Zt+8VP9ULUxdtwt1c9j0vdoVxNDcVp6pjWzE1SOylXUS3w2ohuDc4XU7s+2k5w1B1eZv7XvDj6NGyJiIyD3idX1q9fDwAYPny4UvmWLVswffp0AMDq1aulh5zy8nIEBwfjq6++auOaEqnP09MD3t7eEE2PICIiIg0YPnw4hGj8Tfvll19uNBHi6OiIHTt2NHqNfv36ISYmpkV11BctecGu3eMCuD+cpbXL3dZNNDzj1xGPeHfA6+FnUFktYCIDuji1x6XbRdI52pxPpS4B4JGuHXA8/W69fXUTLmXVCpTIrHHoyyVNTir7n5cDceTPHOSXVuLDA+eldg0/lYEfGklYqdPjSJ1jWrryk6oVpxq7TlvNy9LRwQrhLw9R6lX1oC/NTETaoffJlaYehADA0tIS69atw7p169qgRkRERETGrbkv2H6e9jA3kUmJAAsTWauHgqhK8nR0sMKPf70o55dWQgYZMu4VS5/b0FPjUO8OOHn5rsZ7sng/1B6nrt6TPl8GYN7I7lgfma40ka6liRxdbYG4qF8wYvgTcLBvvG2/ib5cbyLeiiYSVur0ONLmksTNTcq1ZYKjo4MVpgR2Virj0sxEpGl6n1whIiIiIv3W0cEKP9TpHaCJF+WGkjwbo9OlhIa5iQxBPV3wewOrwViayPHiI53hbGOBPYk3W9SzRVWPGFM5EOjthPC/5oUxlQFhL/jDv5MDhj3sjITMPKU5V25n/ImpMybjWGQsHOwbnuC4dtKhNvMmElbqLreszSWJm5OU02aipylcmpmItIHJFSINKXBwwtN3KvCRc8PLIBIRERkrVb0DtKHuEKSKagEfNxscS7utlJSwMJHh5WHe6OVuh7nhZ5TOqSGXAepM4TJvZHesOZyG2imP10Z0R1Z+mXTdKgFk5ZcBUJ1kcLXth5vXbqFdu3aNflbtpIO5iQyTBnaCrZWpWgkrdZIbLR32o2m6TnDoSzsQkfFgcoVIU+RylIj7/0tERETaoWoI0hM9XaS5NGr3FunoYIX9Z7NUJlbM5LJ6k+OO7++On8/eRJUCMJHdn1PlxUc6w7+TA6oUAmFH/15x6sujl7B20gC1e1+YmJjA1ta2yfh0nXRoS0xwEJExYXKFSEOsC/Kwws4U5vfuAN7euq4OERGRUam9skxDQ5BUvajXTcaYm8jwSgM9Wkb1dsPUwC4qExtP9HTBhuh0VP51fKVC4MLNfLUTIVevXcHSD5Zg6ZIP0LlTl0ZjbSzp0BYr7BARUfMxuUKkIaaVFQgwlyOtolzXVSEiIjIqqlaWUXcIUmPzwbwyzFupN0pWfhn8Ozk0OF/J2okD8Np/4lH11/igjdHpeKKnC/5fv6aHBFdVVePO3Tuoqmr5UoFttcIOERE1H8cvEBEREZFeU7WyTHPUzAczJbBzvd4olib3H4fVmVTVv5MDXn28m7Rds4KPOrp5d8P+Pb+im3e3pg9uQGvbgYiItIc9V4iIiIgeQIY0vERbK8u0ZH6TJ3q6SEslt/UqN7pcYYeIiBrH5AoRERHRA8bQhpdoc5LX5k6q2tK6JJ1NxIh/DMPRiGj49uvf4ro+KJPdEhEZGiZXiDSkrJ0N1hZWIcjGTtdVISIiapSq4SX6/qKurZVlWtKDpyV1cXfviOX/+ync3Tu2pJqt+mwiItI+JleINKTC0gr7yhQY0a69rqtCRETUKA4vua8te/A85PQQXpk1WyvXJiIi3WNyhUhDzMrLMNJCDpPSkmafm/rnnzAxlQEAnJyc4OXlpenqISMjA3fu3JG2tfU5RESk/zi85L627MGTn5+P2JMnEPjIENjZsZcrEZGxYXKFSEOsigqwyNYUafm5ap+Tm5sHmRx46aWXUFldAQCwtrZGSkqKRhMfGRkZ8PHxQUnJ34kfbXwOEREZDg4vadsePFeuXsY/J47HschY9Pf109rnEBGRbjC5QqRDxcXFEArg448/hnf3rkhPT0doaCju3Lmj0aTHnTt3UFJSgpUrV8Lb21trn0NERGRI2rIHT+9efXAp5Qo6dHDS2mcQEZHuMLlCpAe6du2K3r17a/1zvL292+RziIiIDEVb9eAxMzODq6ub1j+HiIh0g8kVIiIiIj2jUAgo/poLhIxDRmYGPv1sOd56cxG8PNlrlIiorSkUQqvXZ3KFSEOqTc1woVIBEzNzXVeFiIgMnEIhUFXF5IoxKS4uwYU/U1BcXML/b4mIdIDJFSIDUWzngA/zqrC6w0Mav3bdlX7Ky8thYWEhbata+af2OSkpKRqvExERaY9tByvY2j7Yk80aG38nX5yMi9V1NYiIHlzmlVq9PJMrRHpO1Uo/crkcCsXf/+pVd+UfVecQEZHhMDGRw8RErutqEBERGQ1t/64yuUKkIbZ3b+H3h8yRln0D8PZu1bVq9zRJSUlRWuknKioKa9asqbfyT0xMDHx8fBo9h4iIiHQjKSkJI0aMwNGjR+Hr66vr6hARkYYxuUKkR27fvg25XI4XX3yx3r6alX7S09OVtptzTlPqDj9SNdyIiIiIms/V1RWLFi2Cq6urrqtCRERawOQKkR4pKCiAQqGQepwAaLLXSUvOUUXVUKK6w42IiIioZVxcXBAaGqrrahARkZYwuUKkh2p6nABQu9dJS85pbPhRzXCjO3fuMLlCRETUSoWFhYiPj4e/vz9sbGx0XR0iItIwJleIHkDqDCUiIiIizUlLS8OIESMQHx+PAQMG6Lo6RESkYUyuEDVDdnYWcnPzAABXrlxW2ldk74ipdyvwlpOzDmrWPM0ZSlS7d0tL5mDRl3lc6tZDl3UhIqIHT69evZCWlgYPDw9dV4WIiLSAyRUiNWVnZ2HcuGdQVlamcr/CxBQ3FYAwNWvjmrVcY0OJVPVuae4cLPoyj0tDS1NzThkiImorlpaW6Natm66rQUREWsLkCpGacnPzUFZWhgULFsDT0wOnT8dj+/bt0n6rwgK8bWMCs7x7AFq3FLM+qNu7pSVzsNy5c0flPC61l40GgPLyclhYWKi93dxz6s4nA6DFc8q0pCeOvvTeISIi3cnMzMTKlSsRGhoKT09PXVeHiIg0zGiSK+vWrcPKlSuRnZ0NX19fhIWFYdCgQbquFhkhT08PeHt7IzPzulK5WUUZRliaIK2sVEc10w5NzMHS1LLRcrkcCoVC7e2WntPaWFrSE0dfeu8QEZFuFRYWIjIyErNnz9Z1VYiISAuMIrnyww8/YMGCBdiwYQMGDx6ML774AsHBwUhNTYWzs/7Pf0FkSGrPwaKqR0ljvTIam+ulpqyp7Zac05KlqVVpqCdOY71f1DlHW/PBaKLHDHvdEBFpRq9evXD27FldV4OIiLTEKJIrn3/+OWbNmoUZM2YAADZs2IADBw5g8+bNePvtt3VcOyLjoKrXiareIer0ylA110tNWVPbLTlH3aWp1dWSHjANnaOt+WA00WOGvW6IiIiIiNRj8MmViooKxMfHY9GiRVKZXC5HUFAQYmNjVZ5TXl6O8vJyaTs/Px/A/X9V16Ts7GxkZ2crlbXF8AdNDaF4kOtaXSVQclcBQEAmv78/I+Ma5JAjLfUSiotKkJlxXWn7ZlYOiqqrcfVqJu62P1dvP4B6ZZnXr6NaUY0LFy6gtLxESgKcP39eeqGtW9bUtrbOSUhIgEKhwMyZM+Hm5oZz585h79690jYAZGVlYdOmTTh48CB69OiB1NRUndRVnWtcuXIFABAfH4+ioiK1vjd141HnGk2dk5qaipKSkkbbUZ26qfrc2tdV55p1y9S5Rkvqpq9/7zV1jiHVVVWZq6srXF1doSk1v61CCI1d05jVtJOmn0lI986fP49nn30WP/30U6uH2xIRUfNp+5lEJgz8aefmzZvo2LEjTpw4gcDAQKn8rbfeQlRUFOLi4uqds3TpUixbtqwtq0lERPRAy8zM5BK0arh8+bI0BJKIiIg0Lz09HV27dtX4dQ2+50pLLFq0CAsWLJC2FQoF7t27hw4dOkAmk+mwZm2roKAAnp6eyMzMhK2tra6rYzTYrtrBdtUetq12sF3vE0KgsLAQ7u7uuq6KQXB0dARwf1ienZ2djmvTesb494Ax6T9jiwdgTIbA2OIBjC+m/Px8eHl5Sb+1mmbwyRUnJyeYmJggJydHqTwnJ6fBbs0WFhb1JuG0t7fXVhX1nq2trVH8ZdE3bFftYLtqD9tWO9iuMIokQVuRy++PRbWzszOq740x/j1gTPrP2OIBGJMhMLZ4AOOLqea3VuPX1cpV25C5uTn8/f1x+PBhqUyhUODw4cNKw4SIiIiIiIiIiLTB4HuuAMCCBQswbdo0BAQEYNCgQfjiiy9QXFwsrR5ERERERERERKQtRpFcef7553H79m0sWbIE2dnZ6N+/P3777Te4uLjoump6zcLCAu+//369IVLUOmxX7WC7ag/bVjvYrtQSxva9MbZ4AMZkCIwtHoAxGQJjiwcwvpi0HY/BrxZERERERERERKRLBj/nChERERERERGRLjG5QkRERERERETUCkyuEBERERERERG1ApMrREREREREREStwOSKgYuOjsbYsWPh7u4OmUyGPXv21DsmJSUFTz/9NOzs7NCuXTsMHDgQGRkZ0v7s7GxMmTIFrq6uaNeuHQYMGICffvpJ6Rr37t3D5MmTYWtrC3t7e8ycORNFRUXaDk9nmmpXmUym8s/KlSulY9Rps7Nnz+Kxxx6DpaUlPD098emnn7ZFeDrT2na9evUqZs6ciS5dusDKygre3t54//33UVFRoXSdB61dAc18Z2uUl5ejf//+kMlkSExMVNr3oLWtptr1wIEDGDx4MKysrODg4IBnnnlGaX9GRgaeeuopWFtbw9nZGaGhoaiqqtJydKRv1q1bh86dO8PS0hKDBw/GH3/8oesqqW358uUYOHAgbGxs4OzsjGeeeQapqalKx5SVlSEkJAQdOnRA+/bt8eyzzyInJ0dHNW6eFStWQCaTYd68eVKZIcZz48YNvPjii+jQoQOsrKzQt29fnD59WtovhMCSJUvg5uYGKysrBAUFIS0tTYc1blx1dTXee+89peeCDz/8ELXX69DnmJr6jVGn7vr2jN5YTJWVlVi4cCH69u2Ldu3awd3dHVOnTsXNmzeVrmFIMdU1e/ZsyGQyfPHFF0rl+hSTJt4f9e3+11RMRUVFmDNnDjw8PGBlZYVevXphw4YNSsdoIiYmVwxccXExfH19sW7dOpX709PT8eijj6Jnz56IjIzE2bNn8d5778HS0lI6ZurUqUhNTcW+fftw7tw5TJgwAc899xwSEhKkYyZPnozz588jIiIC+/fvR3R0NF5++WWtx6crTbVrVlaW0p/NmzdDJpPh2WeflY5pqs0KCgowatQodOrUCfHx8Vi5ciWWLl2Kr7/+Wuvx6Upr2/XPP/+EQqHAxo0bcf78eaxevRobNmzAO++8I13jQWxXQDPf2RpvvfUW3N3d65U/iG2riXb96aefMGXKFMyYMQNJSUk4fvw4XnjhBWl/dXU1nnrqKVRUVODEiRPYtm0btm7diiVLlmg9PtIfP/zwAxYsWID3338fZ86cga+vL4KDg3Hr1i1dV00tUVFRCAkJwcmTJxEREYHKykqMGjUKxcXF0jHz58/Hzz//jJ07dyIqKgo3b97EhAkTdFhr9Zw6dQobN25Ev379lMoNLZ7c3FwMHToUZmZm+PXXX3HhwgWsWrUKDg4O0jGffvop1q5diw0bNiAuLg7t2rVDcHAwysrKdFjzhn3yySdYv349vvzyS6SkpOCTTz7Bp59+irCwMOkYfY6pqd8Ydequb8/ojcVUUlKCM2fO4L333sOZM2ewa9cupKam4umnn1Y6zpBiqm337t04efKkymcofYpJE++P+nb/ayqmBQsW4LfffsP333+PlJQUzJs3D3PmzMG+ffukYzQSkyCjAUDs3r1bqez5558XL774YqPntWvXTnz77bdKZY6OjuKbb74RQghx4cIFAUCcOnVK2v/rr78KmUwmbty4oZnK6zFV7VrXuHHjxBNPPCFtq9NmX331lXBwcBDl5eXSMQsXLhQ9evTQbAB6qiXtqsqnn34qunTpIm0/6O0qROva9pdffhE9e/YU58+fFwBEQkKCtO9Bb9uWtGtlZaXo2LGj+L//+78Gz/nll1+EXC4X2dnZUtn69euFra2tUluTcRs0aJAICQmRtqurq4W7u7tYvny5DmvVcrdu3RIARFRUlBBCiLy8PGFmZiZ27twpHZOSkiIAiNjYWF1Vs0mFhYWie/fuIiIiQjz++ONi7ty5QgjDjGfhwoXi0UcfbXC/QqEQrq6uYuXKlVJZXl6esLCwEP/5z3/aoorN9tRTT4mXXnpJqWzChAli8uTJQgjDiqnub4w6ddf3Z3R1fjf/+OMPAUBcu3ZNCGG4MV2/fl107NhRJCcni06dOonVq1dL+/Q5ppa8P+r7/U9VTL179xYffPCBUtmAAQPE4sWLhRCai4k9V4yYQqHAgQMH8PDDDyM4OBjOzs4YPHhwvW5SQ4YMwQ8//IB79+5BoVAgPDwcZWVlGD58OAAgNjYW9vb2CAgIkM4JCgqCXC5HXFxcG0akn3JycnDgwAHMnDlTKlOnzWJjYzFs2DCYm5tLxwQHByM1NRW5ubltF4CeUtWuquTn58PR0VHaZrs2raG2zcnJwaxZs/Ddd9/B2tq63nls28apatczZ87gxo0bkMvl8PPzg5ubG8aMGYPk5GTpmNjYWPTt2xcuLi5SWXBwMAoKCnD+/Pk2jYF0o6KiAvHx8QgKCpLK5HI5goKCEBsbq8OatVx+fj4ASPfn+Ph4VFZWKsXYs2dPeHl56XWMISEheOqpp5TqDRhmPPv27UNAQAD+9a9/wdnZGX5+fvjmm2+k/VeuXEF2drZSTHZ2dhg8eLDexjRkyBAcPnwYFy9eBAAkJSXh2LFjGDNmDADDjKmGOnU3hmf0/Px8yGQy2NvbAzDMmBQKBaZMmYLQ0FD07t273n5Dikmd90dDvP8NGTIE+/btw40bNyCEwNGjR3Hx4kWMGjUKgOZiYnLFiN26dQtFRUVYsWIFRo8ejUOHDmH8+PGYMGECoqKipON+/PFHVFZWokOHDrCwsMArr7yC3bt3o1u3bgDuz8ni7OysdG1TU1M4OjoiOzu7TWPSR9u2bYONjY1StzF12iw7O1vpZQqAtM12Vd2udV26dAlhYWF45ZVXpDK2a9NUta0QAtOnT8fs2bOVfvxrY9s2TlW7Xr58GQCwdOlSvPvuu9i/fz8cHBwwfPhw3Lt3DwDblYA7d+6gurpa5ffAEL8DCoUC8+bNw9ChQ9GnTx8A97/L5ubm0gtUDX2OMTw8HGfOnMHy5cvr7TPEeC5fvoz169eje/fuOHjwIF599VW8/vrr2LZtG4C/7zeG9D18++23MXHiRPTs2RNmZmbw8/PDvHnzMHnyZACGGVMNdepu6M/oZWVlWLhwISZNmgRbW1sAhhnTJ598AlNTU7z++usq9xtSTOq8Pxri/S8sLAy9evWCh4cHzM3NMXr0aKxbtw7Dhg0DoLmYTDVZadIvCoUCADBu3DjMnz8fANC/f3+cOHECGzZswOOPPw4AeO+995CXl4fff/8dTk5O2LNnD5577jnExMSgb9++Oqu/odi8eTMmT56sNA6RWq+pdr1x4wZGjx6Nf/3rX5g1a1Yb186wqWrbsLAwFBYWYtGiRTqsmWFT1a419+HFixdL87Bs2bIFHh4e2Llzp1JikMhYhISEIDk5GceOHdN1VVosMzMTc+fORUREhNH8visUCgQEBODjjz8GAPj5+SE5ORkbNmzAtGnTdFy7lvnxxx+xfft27NixA71790ZiYiLmzZsHd3d3g43pQVFZWYnnnnsOQgisX79e19Vpsfj4eKxZswZnzpyBTCbTdXVaTd33R0MTFhaGkydPYt++fejUqROio6MREhICd3f3ej0TW4M9V4yYk5MTTE1N0atXL6VyHx8fabbn9PR0fPnll9i8eTNGjhwJX19fvP/++wgICJAmBHJ1da03oV5VVRXu3bsHV1fXtglGT8XExCA1NRX//ve/lcrVaTNXV9d6M1DXbLNdVbdrjZs3b2LEiBEYMmRIvclU2a6Na6htjxw5gtjYWFhYWMDU1FTquRYQECA9oLJtG9ZQu7q5uQGA0n3YwsICXbt2le7DbFdycnKCiYmJyu+BoX0H5syZg/379+Po0aPw8PCQyl1dXVFRUYG8vDyl4/U1xvj4eNy6dQsDBgyAqakpTE1NERUVhbVr18LU1BQuLi4GFQ9w/37U2DNhTb0N6XsYGhoq9V7p27cvpkyZgvnz50u9jQwxphrq1N1Qn9FrEivXrl1DRESE1GsFMLyYYmJicOvWLXh5eUn3imvXruGNN95A586dARhWTOq8Pxra/by0tBTvvPMOPv/8c4wdOxb9+vXDnDlz8Pzzz+Ozzz4DoLmYmFwxYubm5hg4cGC9pRAvXryITp06Abg/azdwf2x3bSYmJlLmMjAwEHl5eYiPj5f2HzlyBAqFAoMHD9ZmCHpv06ZN8Pf3h6+vr1K5Om0WGBiI6OhoVFZWSsdERESgR48eSjP3P4gaalfgfo+V4cOHw9/fH1u2bKn33WW7Nq6htl27di2SkpKQmJiIxMRE/PLLLwDur2Dy0UcfAWDbNqahdvX394eFhYXSfbiyshJXr16V7sOBgYE4d+6c0oNXzcNm3YcbMk7m5ubw9/fH4cOHpTKFQoHDhw8jMDBQhzVTnxACc+bMwe7du3HkyBF06dJFab+/vz/MzMyUYkxNTUVGRoZexjhy5EicO3dOuicmJiYiICAAkydPlv7bkOIBgKFDhzb6TNilSxe4uroqxVRQUIC4uDi9jamkpKTRZ1hDjKmGOnU3xGf0msRKWloafv/9d3To0EFpv6HFNGXKFJw9e1bpXuHu7o7Q0FAcPHgQgGHFpM77o6HdzysrK1FZWdnovUJjMbVsDl7SF4WFhSIhIUEkJCQIAOLzzz8XCQkJ0ozbu3btEmZmZuLrr78WaWlpIiwsTJiYmIiYmBghhBAVFRWiW7du4rHHHhNxcXHi0qVL4rPPPhMymUwcOHBA+pzRo0cLPz8/ERcXJ44dOya6d+8uJk2apJOY20JT7SqEEPn5+cLa2lqsX79e5TWaarO8vDzh4uIipkyZIpKTk0V4eLiwtrYWGzdu1Hp8utLadr1+/bro1q2bGDlypLh+/brIysqS/tR4ENtVCM18Z2u7cuVKvdWCHsS21US7zp07V3Ts2FEcPHhQ/Pnnn2LmzJnC2dlZ3Lt3TwghRFVVlejTp48YNWqUSExMFL/99pt46KGHxKJFi9okRtIP4eHhwsLCQmzdulVcuHBBvPzyy8Le3l5pFSl99uqrrwo7OzsRGRmpdG8uKSmRjpk9e7bw8vISR44cEadPnxaBgYEiMDBQh7VuntqrBQlhePH88ccfwtTUVHz00UciLS1NbN++XVhbW4vvv/9eOmbFihXC3t5e7N27V5w9e1aMGzdOdOnSRZSWluqw5g2bNm2a6Nixo9i/f7+4cuWK2LVrl3BychJvvfWWdIw+x9TUb4w6dde3Z/TGYqqoqBBPP/208PDwEImJiUr3itqr4xlSTKrUXS1ICP2KqbXvj0Lo3/2vqZgef/xx0bt3b3H06FFx+fJlsWXLFmFpaSm++uor6RqaiInJFQN39OhRAaDen2nTpknHbNq0SXTr1k1YWloKX19fsWfPHqVrXLx4UUyYMEE4OzsLa2tr0a9fv3pLM9+9e1dMmjRJtG/fXtja2ooZM2aIwsLCtghRJ9Rp140bNworKyuRl5en8hrqtFlSUpJ49NFHhYWFhejYsaNYsWKFNsPSuda265YtW1SeXzdP/KC1qxCa+c7Wpiq5IsSD17aaaNeKigrxxhtvCGdnZ2FjYyOCgoJEcnKy0jFXr14VY8aMEVZWVsLJyUm88cYborKyUpuhkR4KCwsTXl5ewtzcXAwaNEicPHlS11VSW0P35i1btkjHlJaWiv/5n/8RDg4OwtraWowfP14pOa7v6iZXDDGen3/+WfTp00dYWFiInj17iq+//lppv0KhEO+9955wcXERFhYWYuTIkSI1NVVHtW1aQUGBmDt3rvDy8hKWlpaia9euYvHixUov6vocU1O/MerUXd+e0RuLqebZQtWfo0ePGmRMqqhKruhTTJp4f9S3+19TMWVlZYnp06cLd3d3YWlpKXr06CFWrVolFAqFdA1NxCQTQgj1+7kQEREREREREVFtnHOFiIiIiIiIiKgVmFwhIiIiIiIiImoFJleIiIiIiIiIiFqByRUiIiIiIiIiolZgcoWIiIiIiIiIqBWYXCEiIiIiIiIiagUmV4iIiIiIiIiIWoHJFSIiIiIiIiKiVmByhYja3PDhwzFv3rwWnXv48GH4+PigurpaI3V5++238dprr2nkWkRERNR2IiMjIZPJkJeXp+uqKBk2bBh27NjR6DEymQx79uzR6OdOnDgRq1at0ug1iUh9TK4Qkc517twZX3zxhVrHvvXWW3j33XdhYmKikc9+8803sW3bNly+fFkj1yMiIiLNa80/zDRFk4mOffv2IScnBxMnTtTI9Zrj3XffxUcffYT8/Pw2/2wiYnKFiAzIsWPHkJ6ejmeffVZj13RyckJwcDDWr1+vsWsSERHRg2nt2rWYMWMG5PK2f83q06cPvL298f3337f5ZxMRkytEpGXFxcWYOnUq2rdvDzc3t3rdVYcPH45r165h/vz5kMlkkMlkDV4rPDwc//jHP2BpaSmVLV26FP3798d3332Hzp07w87ODhMnTkRhYaF0zH//+1/07dsXVlZW6NChA4KCglBcXCztHzt2LMLDwzUYNREREWnK9OnTERUVhTVr1kjPClevXpX2x8fHIyAgANbW1hgyZAhSU1OVzt+7dy8GDBgAS0tLdO3aFcuWLUNVVRWA+71nAWD8+PGQyWTSdnp6OsaNGwcXFxe0b98eAwcOxO+//95oPW/fvo0jR45g7NixSuVpaWkYNmwYLC0t0atXL0RERNQ7NzMzE8899xzs7e3h6OiIcePGKcVYVVWF119/Hfb29ujQoQMWLlyIadOm4ZlnnlG6Dp9piHSHyRUi0qrQ0FBERUVh7969OHToECIjI3HmzBlp/65du+Dh4YEPPvgAWVlZyMrKavBaMTExCAgIqFeenp6OPXv2YP/+/di/fz+ioqKwYsUKAEBWVhYmTZqEl156CSkpKYiMjMSECRMghJDOHzRoEK5fv670EENERET6Yc2aNQgMDMSsWbOkZwVPT09p/+LFi7Fq1SqcPn0apqameOmll6R9MTExmDp1KubOnYsLFy5g48aN2Lp1Kz766CMAwKlTpwAAW7ZsQVZWlrRdVFSEJ598EocPH0ZCQgJGjx6NsWPHIiMjo8F6Hjt2DNbW1vDx8ZHKFAoFJkyYAHNzc8TFxWHDhg1YuHCh0nmVlZUIDg6GjY0NYmJicPz4cbRv3x6jR49GRUUFAOCTTz7B9u3bsWXLFhw/fhwFBQUqhzINGjQIf/zxB8rLy5vZykTUaoKISEsKCwuFubm5+PHHH6Wyu3fvCisrKzF37lyprFOnTmL16tVNXs/Ozk58++23SmXvv/++sLa2FgUFBVJZaGioGDx4sBBCiPj4eAFAXL16tcHr5ufnCwAiMjJSzciIiIioLT3++ONKzw5CCHH06FEBQPz+++9S2YEDBwQAUVpaKoQQYuTIkeLjjz9WOu+7774Tbm5u0jYAsXv37ibr0Lt3bxEWFtbg/tWrV4uuXbsqlR08eFCYmpqKGzduSGW//vqr0md+9913okePHkKhUEjHlJeXCysrK3Hw4EEhhBAuLi5i5cqV0v6qqirh5eUlxo0bp/R5SUlJTT73EJF2mOowr0NERi49PR0VFRUYPHiwVObo6IgePXq06HqlpaVKQ4JqdO7cGTY2NtK2m5sbbt26BQDw9fXFyJEj0bdvXwQHB2PUqFH45z//CQcHB+l4KysrAEBJSUmL6kVERES6069fP+m/3dzcAAC3bt2Cl5cXkpKScPz4camnCgBUV1ejrKwMJSUlsLa2VnnNoqIiLF26FAcOHEBWVhaqqqpQWlraaM8VVc8pKSkp8PT0hLu7u1QWGBiodExSUhIuXbqk9CwDAGVlZUhPT0d+fj5ycnIwaNAgaZ+JiQn8/f2hUCiUzuEzDZHuMLlCRAbDyckJubm59crNzMyUtmUymfSwYWJigoiICJw4cQKHDh1CWFgYFi9ejLi4OHTp0gUAcO/ePQDAQw89pOUIiIiISNNqPwfUzN1W8xxQVFSEZcuWYcKECfXOU/UPNjXefPNNRERE4LPPPkO3bt1gZWWFf/7zn9IwHVUaek5pSlFREfz9/bF9+/Z6+5r7bMJnGiLd4ZwrRKQ13t7eMDMzQ1xcnFSWm5uLixcvKh1nbm6O6urqJq/n5+eHCxcuNLseMpkMQ4cOxbJly5CQkABzc3Ps3r1b2p+cnAwzMzP07t272dcmIiIi7VP3WaGuAQMGIDU1Fd26dav3p2ZFHzMzs3rXPn78OKZPn47x48ejb9++cHV1bXJuNj8/P2RnZyslWHx8fJCZmak0p9zJkyfr1TEtLQ3Ozs716mhnZwc7Ozu4uLhI88EA93vf1J7DrkZycjI8PDzg5OSkdhsRkWYwuUJEWtO+fXvMnDkToaGhOHLkCJKTkzF9+vR6yxN27twZ0dHRuHHjBu7cudPg9YKDg3Hs2LFm1SEuLg4ff/wxTp8+jYyMDOzatQu3b99WmmwuJiYGjz32mNSVloiIiPRL586dERcXh6tXr+LOnTv1hsM0ZMmSJfj222+xbNkynD9/HikpKQgPD8e7776rdO3Dhw8rJUa6d++OXbt2ITExEUlJSXjhhRea/Ew/Pz84OTnh+PHjUllQUBAefvhhTJs2DUlJSYiJicHixYuVzps8eTKcnJwwbtw4xMTE4MqVK4iMjMTrr7+O69evAwBee+01LF++HHv37kVqairmzp2L3NzceqssxsTEYNSoUWq1DRFpFpMrRKRVK1euxGOPPYaxY8ciKCgIjz76KPz9/ZWO+eCDD3D16lV4e3s32o118uTJOH/+fL0lFhtja2uL6OhoPPnkk3j44Yfx7rvvYtWqVRgzZox0THh4OGbNmtX84IiIiKhNvPnmmzAxMUGvXr3w0EMPNTr3SW3BwcHYv38/Dh06hIEDB+KRRx7B6tWr0alTJ+mYVatWISIiAp6envDz8wMAfP7553BwcMCQIUMwduxYBAcHY8CAAY1+lomJCWbMmKE0vEcul2P37t0oLS3FoEGD8O9//1tp/hcAsLa2RnR0NLy8vDBhwgT4+Phg5syZKCsrg62tLQBg4cKFmDRpEqZOnYrAwEC0b98ewcHBSkObysrKsGfPHj7TEOmITIha65ESEem50NBQFBQUYOPGjRq53q+//oo33ngDZ8+ehakpp6EiIiKilsvOzkbv3r1x5swZpQSOpikUCvj4+OC5557Dhx9+CABYv349du/ejUOHDmntc4moYey5QkQGZfHixejUqZPa3YGbUlxcjC1btjCxQkRERK3m6uqKTZs2qd2zRl3Xrl3DN998g4sXL+LcuXN49dVXceXKFbzwwgvSMWZmZggLC9Po5xKR+thzhYiIiIiISI9lZmZi4sSJSE5OhhACffr0wYoVKzBs2DBdV42I/sLkChERERERERFRK3BYEBERERERERFRKzC5QkRERERERETUCkyuEBERERERERG1ApMrREREREREREStwOQKEREREREREVErMLlCRERERERERNQKTK4QEREREREREbUCkytERERERERERK3w/wElQqtixNywTAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "status : ok\n", + "q_total : 143925.0\n", + "q_time : 130008.0\n", + "q_inside : 124060.0\n", + "q_outside: 5948.0\n" + ] + } + ], + "source": [ + "# grab one event from the example batch (demo_batch) to look at\n", + "res = sel.process_event_charge(event=events[0], event_id=0, do_plot=True) # process_event_charge() applies the full ring selection to a single event. It computes q_total, q_time, q_inside and q_outside \n", + "#using the same vectorised core as process_events(), making it useful for debugging and visualising individual events before processing an entire dataset. \n", + "\n", + "print(\"status :\", res[\"status\"]) # \n", + "print(\"q_total :\", res[\"q_total\"]) # charge of all geometry-valid hits (after the coarse window, when the time cut is on)\n", + "print(\"q_time :\", res[\"q_time\"]) # charge of the hits that also pass the prompt-time window\n", + "print(\"q_inside :\", res[\"q_inside\"]) # charge of the time-passing hits that are inside the cone\n", + "print(\"q_outside:\", res[\"q_outside\"]) # q_time − q_inside" + ] + }, + { + "cell_type": "markdown", + "id": "c710c1d2", + "metadata": {}, + "source": [ + "### Do the analysis over the whole run in batches or on events in a single batch\n", + "\n", + "\n", + "You can iterate the loader and call `sel.process_events` on each batch in a for loop,\n", + "keeping a global event id with `start_index` so ids are unique across batches. Then concatenate\n", + "the per-batch `RingResults`.\n", + "\n", + "`process_events` automatically takes a fast column-wise path when handed an\n", + "awkward batch, and with `use_gaussian_fit=False` it skips the per-event fit (only finds the maximum in time residual distribution for time cuts), so\n", + "the loop runs faster. If it is still slow, the cost is dominated by the number of events; pass\n", + "`max_events=...` while developing, or set `verbose=True` to see progress.\n", + "\n", + "To select a single particle type first (e.g. pions), define a `BeamSelection`\n", + "and mask each batch with it before processing like we did earlier -- see the\n", + "\"Example Using Data Loader\" notebook for how to build the selection." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c529ddda", + "metadata": {}, + "outputs": [], + "source": [ + "# start = time.time()\n", + "# batch_results = []\n", + "# n_seen = 0\n", + "# for batch in loader.iterate(step_size=\"100 MB\"):\n", + "# events = batch #load one batch at the top, read a single one here example_batch\n", + "# # events = batch[pion_sel.mask(batch)] # uncomment to use the pion selection\n", + "# r = sel.process_events(events, start_index=n_seen, verbose=True)\n", + "# batch_results.append(r)\n", + "# n_seen += len(events)\n", + "\n", + "# results = RingResults.concatenate(batch_results)\n", + "# print(f\"Processed {len(results)} events in {time.time() - start:.1f} s\")\n", + "# print(\"rejected at each stage:\", {k: len(v) for k, v in results.fail_ids.items()})" + ] + }, + { + "cell_type": "markdown", + "id": "9f5f13d6", + "metadata": {}, + "source": [ + "Here for the speed, we run the `process_events` on all events in a single batch `demo_batch`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3f24bb6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 1683 events, 1682 ok; rejected: {'no_hits': 1, 'no_geom': 0, 'few_hits': 0, 'no_time': 0}\n" + ] + } + ], + "source": [ + "results = sel.process_events(events, verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "4b75a720", + "metadata": {}, + "source": [ + "### Charge inside vs outside the ring\n", + "\n", + "Events that deposit most of their light inside the Cherenkov cone with little\n", + "outside are track-like; events with a lot of charge outside the cone are\n", + "shower-like (or hard scatters). `classify_charge_topology` splits the events on\n", + "the outside-cone charge and then bins each topology into low / mid / high bands\n", + "by the inside-cone charge percentiles. Adjust the thresholds for your run." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d66a16f2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "track_low : 44\n", + "track_mid : 143\n", + "track_high : 7\n", + "shower_low : 189\n", + "shower_mid : 219\n", + "shower_high : 1053\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "topology = classify_charge_topology(\n", + " results.q_inside,\n", + " results.q_outside,\n", + " outside_track_max=3800.0, # below this outside-charge -> track-like\n", + " outside_shower_min=4000.0, # above this outside-charge -> shower-like\n", + ")\n", + "\n", + "for key in (\"track_low\", \"track_mid\", \"track_high\",\n", + " \"shower_low\", \"shower_mid\", \"shower_high\"):\n", + " print(f\"{key:<12}: {int(topology[key].sum())}\")\n", + "\n", + "ax = plot_inside_vs_outside(\n", + " results.q_inside, results.q_outside, topology=None,\n", + " xlim=(0, 830000), ylim=(0, 320000),\n", + " style=\"regions\", # shaded category regions over the density; \"boundaries\" or \"scatter\" also available\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a92268e1", + "metadata": {}, + "source": [ + "### Per-hit angles and the time residual\n", + "\n", + "Set `return_hits=True` to get, per event, the jagged arrays of `theta` and\n", + "`delta_t` for the geometry-valid hits. These let you make the run-level\n", + "`theta`-vs-`delta_t` distribution (the prompt band you cut on) by simply\n", + "flattening across events with `ak.flatten`. Off by default because keeping every\n", + "hit is memory-heavy on a full run." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5f799386", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_hits = sel.process_events(events, return_hits=True) #need dt and angle before any cuts for single event or pmt as well\n", + "\n", + "theta_deg = np.degrees(ak.to_numpy(ak.flatten(res_hits.theta)))\n", + "delta_t = ak.to_numpy(ak.flatten(res_hits.delta_t))\n", + "fig, ax = plt.subplots(figsize=(7, 5))\n", + "h = ax.hist2d(theta_deg, delta_t, bins=(180, 200),\n", + " range=[(0, 180), (sel.fit_t_min, sel.fit_t_max)], cmap=\"viridis\")\n", + "plt.colorbar(h[3], ax=ax, label=\"hits\")\n", + "ax.axvline(sel.angle_cut_deg, color=\"w\", ls=\":\", lw=1, label=f\"cone {sel.angle_cut_deg:g} deg\")\n", + "ax.set_xlabel(\"theta (deg)\"); ax.set_ylabel(\"delta_t (ns)\")\n", + "ax.set_title(\"Run-level theta vs delta_t (geometry-valid hits)\")\n", + "ax.legend(loc=\"upper right\", fontsize=\"small\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "73252b07", + "metadata": {}, + "source": [ + "To debug, you can also call `sel.get_hit_quantities` on a single event to get `hit_info` which is a dictionary contianing mpmy slot number, pmt position number, charge, time, theta (rad), theta_deg, phi (rad), r (distance between the hit pmt and the origin in mm), tof (ns), delta_t (ns), and status for all hits in that event beofre applying the time and angle cuts." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "8f273b23", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time residual (delta_t) for all the hits in pmt 18 in mpmt 71: [1699.39210833 5009.28261126 5393.48671282]\n" + ] + } + ], + "source": [ + "ev_ID = 0\n", + "\n", + "hit_info = sel.get_hit_quantities(events[ev_ID])\n", + "plt.scatter(\n", + " hit_info[\"theta_deg\"],\n", + " hit_info[\"delta_t\"],\n", + " s=2,\n", + ")\n", + "plt.xlabel(\"theta (deg)\")\n", + "plt.ylabel(\"delta_t (ns)\")\n", + "plt.title(f\"theta angle of hit pmts vs time residual for event {ev_ID}\")\n", + "plt.show() #this plot could tell you if your coarse_time_window selection was correct, as you should see a \"horizontal line\" for all the hits in the promt window\n", + "\n", + "\n", + "#Specific mPMTs:\n", + "mpmts = [21, 33, 105]\n", + "mask = np.isin(hit_info[\"slot\"], mpmts)\n", + "plt.hist(\n", + " hit_info[\"delta_t\"][mask],\n", + " bins=100\n", + ")\n", + "plt.xlabel(\"delta_t (ns)\")\n", + "plt.ylabel(\"number od hits\")\n", + "plt.show()\n", + "\n", + "\n", + "slot = 71\n", + "pos = 18\n", + "#Specific PMT inside one mPMT:\n", + "mask = (\n", + " (hit_info[\"slot\"] == slot)\n", + " & (hit_info[\"pos\"] == pos)\n", + ")\n", + "print(f\"time residual (delta_t) for all the hits in pmt {pos} in mpmt {slot}:\",hit_info[\"delta_t\"][mask])\n" + ] + }, + { + "cell_type": "markdown", + "id": "372a91de", + "metadata": {}, + "source": [ + "### Optional time cut\n", + "\n", + "The prompt-time selection is optional. With `apply_time_cut=False` the coarse\n", + "window, time-of-flight subtraction and per-event prompt fit are all skipped, and\n", + "the charge is split inside/outside the cone using every hit passed in. Use this\n", + "once the timing is handled upstream (e.g. a T5 entry-time tool) and you feed in\n", + "already time-selected hits. Here is the effect on a single batch:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "13056dd2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time cut ON : q_time == q_total? False\n", + "time cut OFF: q_time == q_total? True\n", + "mean q_inside on/off: 230133.08377896613 / 342701.07902554964\n" + ] + } + ], + "source": [ + "r_on = sel.process_events(events, apply_time_cut=True)\n", + "r_off = sel.process_events(events, apply_time_cut=False)\n", + "\n", + "print(\"time cut ON : q_time == q_total?\", np.allclose(r_on.q_time, r_on.q_total))\n", + "print(\"time cut OFF: q_time == q_total?\", np.allclose(r_off.q_time, r_off.q_total))\n", + "print(\"mean q_inside on/off:\", r_on.q_inside.mean(), \"/\", r_off.q_inside.mean())" + ] + }, + { + "cell_type": "markdown", + "id": "4dbae81f", + "metadata": {}, + "source": [ + "### Per-event cone apex (T5 entry position)\n", + "\n", + "The cone apex defaults to the fixed `origin`. When the T5 analysis provides a\n", + "per-event entry position, pass it as `origins` (shape `(n_events, 3)`, in input\n", + "event order) so each particle gets its own apex; angles and time-of-flight are\n", + "then recomputed per hit. A single `(3,)` point applies to all events.\n", + "\n", + "Until that tool is ready, the cell below just demonstrates the API by passing\n", + "the fixed origin for every event (which reproduces the default table path),\n", + "and a shifted apex to show it takes effect." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "14a0da15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fixed origin via origins= reproduces default: True\n", + "shifted apex changes q_inside: True\n" + ] + } + ], + "source": [ + "n_ev = len(events)\n", + "\n", + "# Placeholder for the future T5 tool:\n", + "# entry_positions = t5.get_entry_positions(demo_batch) # (n_ev, 3) mm, event order\n", + "# For now, broadcast the fixed origin to every event:\n", + "entry_positions = np.tile(ring.origin, (n_ev, 1))\n", + "\n", + "r_perorigin = sel.process_events(events, origins=entry_positions)\n", + "r_default = sel.process_events(events)\n", + "print(\"fixed origin via origins= reproduces default:\",\n", + " np.allclose(r_perorigin.q_inside, r_default.q_inside))\n", + "\n", + "\n", + "#use T5.hit_pos_x[0] and y\n", + "# A shifted apex changes the angular split:\n", + "shifted = entry_positions.copy(); shifted[:, 2] += 200.0\n", + "r_shift = sel.process_events(events, origins=shifted)\n", + "print(\"shifted apex changes q_inside:\",\n", + " not np.allclose(r_shift.q_inside, r_default.q_inside))" + ] + }, + { + "cell_type": "markdown", + "id": "84ce0f94", + "metadata": {}, + "source": [ + "### Per-event cone angle (optional)\n", + "\n", + "The selection above uses one Cherenkov cone angle computed from the\n", + "nominal run momentum. If the beam-side analysis gives a **per-event** momentum at the tank or for looking at secondary rings where you know the scattered particle's momentum,\n", + "you can pass a per-event angle so each event uses its own Cherenkov cone. Events\n", + "below threshold get NaN -> no charge counted inside the cone." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "50bd7540", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "per-event angle == nominal: True\n" + ] + } + ], + "source": [ + "# If you have a per-event momentum array p_evt (MeV/c, in event order):\n", + "# cone_evt = cherenkov_cone_halfangle(p_evt, particle=\"pion\", margin_deg=5.0)\n", + "# res = sel.process_events(demo_batch, angle_cut_deg=cone_evt)\n", + "#\n", + "# Demonstrate the API by broadcasting the nominal angle to every event\n", + "# (reproduces the default), then widening it:\n", + "n_ev = len(events)\n", + "res_default = sel.process_events(events)\n", + "res_evt = sel.process_events(events, angle_cut_deg=np.full(n_ev, cone_deg))\n", + "print(\"per-event angle == nominal:\", np.allclose(res_default.q_inside, res_evt.q_inside))" + ] + }, + { + "cell_type": "markdown", + "id": "b3c0a572", + "metadata": {}, + "source": [ + "### Standardised event-level outputs\n", + "\n", + "\n", + "#see how complicated it is, maybe move it back here instead of the \n", + "\n", + "`RingResults` exposes `ring_fraction` (= q_inside / q_total) and\n", + "`outside_fraction` (= q_outside / q_total) per event; Where q_total is the total charge \n", + "without any cuts, so `ring_fraction` is not just `1- outside_fraction` as `q_inside + q_outside = q_time`" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "979eb5ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "inside_cone_fraction (first 5 events): [0.862 0.857 0.84 0.625 0.863]\n", + "outside_cone_fraction (first 5 events): [0.041 0.073 0.107 0.258 0.05 ]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"inside_cone_fraction (first 5 events):\", np.round(results.ring_fraction[:5], 3))\n", + "print(\"outside_cone_fraction (first 5 events):\", np.round(results.outside_fraction[:5], 3))\n", + "\n", + "\n", + "#plot the inside the expected cone fraction and outside for all events in the batch\n", + "fig, ax = plt.subplots(figsize=(7, 4))\n", + "ok = results.q_total > 0 #events that have more than 10 valid-geometry hits and some passed the time cuts too\n", + "ax.hist(results.ring_fraction[ok], bins=50, range=(0, 1), histtype=\"step\", label=\"inside cone fraction\")\n", + "ax.hist(results.outside_fraction[ok], bins=50, range=(0, 1), histtype=\"step\", label=\"outside cone fraction\")\n", + "ax.set_xlabel(\"fraction of total charge\"); ax.set_ylabel(\"events\")\n", + "ax.legend(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c07f13f9", + "metadata": {}, + "source": [ + "### Custom cone apex and axis (secondary rings)\n", + "\n", + "Both the apex (`origins`) and the axis (`beam_directions`) can be overridden,\n", + "per call, as a single vector or a per-event `(n_events, 3)` array. For the\n", + "primary beam ring the axis is `(0, 0, 1)`; for a secondary ring you would put\n", + "the apex at the interaction vertex and the axis along the secondary particle's\n", + "direction. Only `theta` (angle from the axis) enters the inside/outside cut." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "eb0600d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tilting the cone axis changes q_inside: True\n" + ] + } + ], + "source": [ + "# Example: same apex, but tilt the cone axis by 10 deg in x-z, for every event.\n", + "tilt = np.deg2rad(10.0)\n", + "axis = np.array([np.sin(tilt), 0.0, np.cos(tilt)])\n", + "\n", + "res_default = sel.process_events(events)\n", + "res_tilted = sel.process_events(events, beam_directions=axis)\n", + "print(\"tilting the cone axis changes q_inside:\",\n", + " not np.allclose(res_default.q_inside, res_tilted.q_inside))\n", + "\n", + "# For a real secondary ring you would pass per-event arrays, e.g.\n", + "# vertices = ... # (n_events, 3) interaction points (mm)\n", + "# directions = ... # (n_events, 3) secondary particle directions\n", + "# res2 = sel.process_events(demo_batch, origins=vertices, beam_directions=directions)" + ] + }, + { + "cell_type": "markdown", + "id": "ce1e21df", + "metadata": {}, + "source": [ + "### Save the event categories\n", + "\n", + "Save the event ids per category so they can be cross-checked against the beam\n", + "monitor detectors (e.g. confirm the beam PID for each topology band)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "344ee8ea", + "metadata": {}, + "outputs": [], + "source": [ + "np.savez(\n", + " f\"ring_charge_splits_r{run_number}.npz\",\n", + " event_id=results.event_id,\n", + " q_inside=results.q_inside,\n", + " q_outside=results.q_outside,\n", + " track_cuts=topology[\"track_cuts\"],\n", + " shower_cuts=topology[\"shower_cuts\"],\n", + " **{k: np.where(topology[k])[0] for k in\n", + " (\"track_low\", \"track_mid\", \"track_high\",\n", + " \"shower_low\", \"shower_mid\", \"shower_high\")},\n", + ")\n", + "print(\"saved\")" + ] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/analysis_tools/__init__.py b/analysis_tools/__init__.py index 189b575..3578b2e 100644 --- a/analysis_tools/__init__.py +++ b/analysis_tools/__init__.py @@ -12,7 +12,15 @@ from .beam_selection import BeamSelection from .beam_selection import print_cherenkov_thresholds from .beam_selection import SelectionMonitor +from .ring_analysis import RingGeometry +from .ring_analysis import BeamGeometry +from .ring_analysis import load_geometry_package_positions +from .ring_analysis import CherenkovRingSelection +from .ring_analysis import RingResults +from .ring_analysis import classify_charge_topology +from .ring_analysis import plot_inside_vs_outside +from .ring_analysis import cherenkov_angle_deg +from .ring_analysis import cherenkov_cone_halfangle +from .ring_analysis import particle_mass_mev -__all__ = ["CalibrationDBInterface","WaveformProcessingTeststand","WaveformProcessingmPMT","do_pulse_finding", "do_pulse_finding_vect","charge_calculation_mPMT_method","PMTMapping","DetectorGeometry","production_utils","BeamAnalysis", "DetectorDB", "ReadBeamRunInfo", "DataLoader", "Cut", "BeamSelection", "print_cherenkov_thresholds", "SelectionMonitor"] - - +__all__ = ["CalibrationDBInterface","WaveformProcessingTeststand","WaveformProcessingmPMT","do_pulse_finding", "do_pulse_finding_vect","charge_calculation_mPMT_method","PMTMapping","DetectorGeometry","production_utils","BeamAnalysis", "DetectorDB", "ReadBeamRunInfo", "DataLoader", "Cut", "BeamSelection", "print_cherenkov_thresholds", "SelectionMonitor", "RingGeometry", "BeamGeometry", "load_geometry_package_positions", "CherenkovRingSelection", "RingResults", "classify_charge_topology", "plot_inside_vs_outside", "cherenkov_angle_deg", "cherenkov_cone_halfangle", "particle_mass_mev"] \ No newline at end of file diff --git a/analysis_tools/ring_analysis.py b/analysis_tools/ring_analysis.py new file mode 100644 index 0000000..7f89b9f --- /dev/null +++ b/analysis_tools/ring_analysis.py @@ -0,0 +1,1288 @@ +""" +ring_analysis.py +================ + +Standardised, class-based tools for the *tank-side* (mPMT) part of a pion / +single-ring analysis: turn raw hit information (mPMT slot, PMT position, charge, +calibrated time) into per-hit angles relative to the beam, an optional time +residual (hit time minus time-of-flight from the beam entry point), and finally +a split of the deposited charge into the part **inside** the Cherenkov cone and +the part **outside** it. + +The design mirrors the rest of ``analysis_tools``: + +* :class:`RingGeometry` is the geometry / timing. The per-channel angle ``theta`` and time-of-flight + offset ``tof`` depend only on the PMT position, the beam entry point and the + beam direction -- by default all fixed -- so they are **precomputed once** per channel in + the constructor and looked up per hit, but per event beam entry point and the + beam direction can be provided too which makes the anaylsis much slower but comaptible with T5 information + and secondary rings. +* :class:`CherenkovRingSelection` is the hit-level analogue of + :class:`analysis_tools.beam_selection.BeamSelection`: it holds the cut values + and produces per-event quantities. Single events and whole batches go through + the *same* vectorised core (:meth:`CherenkovRingSelection._summarise`), so + there is only one place to change the physics. +* :class:`RingResults` is a small container for the per-event arrays (and, + optionally, the per-event jagged ``theta`` / ``delta_t``), with a + ``concatenate`` helper so you can accumulate results across loader batches. +* :func:`classify_charge_topology` and :func:`plot_inside_vs_outside` are the + common plotting / categorisation helpers used after the event loop. + +Optional time cut +----------------- +The prompt-time selection is optional (``apply_time_cut``). When **on** (default) +each event's charge is restricted to hits in a prompt window ``|delta_t - mu| < K``, +where ``mu`` is found per event from the peak of the time-residual histogram. +When **off**, no coarse time window, no time-of-flight subtraction and no prompt +fit are applied -- the charge is split into inside/outside the cone using all +hits passed in. Turn it off when the timing has already been handled upstream +(e.g. by a T5 beam-monitor entry-time tool) and you pass already time-selected +hits. + +Geometry source +--------------- +PMT positions can come from any source that yields an ``(n_mpmt, n_pmt, 3)`` +array of absolute positions (NaN for missing channels): + +* Dean's ``Geometry`` package (design or survey placements) -- + :meth:`RingGeometry.from_geometry_package` / :func:`load_geometry_package_positions`, +* a raw positions array -- ``RingGeometry(positions=arr)``, +* the in-repo :class:`DetectorGeometry` -- ``RingGeometry(geometry=DetectorGeometry())`` + or simply ``RingGeometry()`` (used as a fallback when nothing else is given). + +Cone apex / origin +------------------ +``theta`` and the time-of-flight are measured from a cone apex (the beam entry +point). It defaults to the fixed ``origin`` and is precomputed per channel for +speed. A per-event apex can be supplied at call time via ``origins`` (e.g. the +particle entry position from T5); that path recomputes angles per hit (still +vectorised) instead of using the per-channel tables. +""" + +from dataclasses import dataclass, field +from typing import Optional, Sequence, Tuple, Dict, Any + +import numpy as np + +try: + import matplotlib.pyplot as plt + _MPL_AVAILABLE = True +except ImportError: + _MPL_AVAILABLE = False + +try: + from scipy.optimize import curve_fit + _SCIPY_AVAILABLE = True +except ImportError: + _SCIPY_AVAILABLE = False + +try: + from .detector_geometry import DetectorGeometry + _HAS_DETECTOR_GEOMETRY = True +except Exception: + DetectorGeometry = None + _HAS_DETECTOR_GEOMETRY = False + + +# Group velocity of light in water, mm/ns. +# This is the value used in the original pion-scattering notebook; it is slightly +# smaller than DetectorGeometry.calc_tof's c/n (which uses n = 1.33) because it is +# a group velocity rather than a phase velocity. Override via RingGeometry(vg=...). +DEFAULT_VG = 2.20027795333758801e8 * 1000 / 1e9 # ~220.03 mm/ns + +# Default beam entry point in WCTE tank coordinates (mm) and beam direction. +# These MUST be checked against the geometry frame you are using + +DEFAULT_ORIGIN = (0.0, 0.0, -1520.0 + 188.0) # = (0, 0, -1332) +DEFAULT_BEAM_DIRECTION = (0.0, 0.0, 1.0) +DEFAULT_PHI_REFERENCE = (1.0, 0.0, 0.0) + +# Per-event status codes +_OK, _NO_HITS, _NO_GEOM, _FEW_HITS, _NO_TIME = 0, 1, 2, 3, 4 +_STATUS_NAME = {_OK: "ok", _NO_HITS: "no_hits", _NO_GEOM: "no_geom", + _FEW_HITS: "few_hits", _NO_TIME: "no_time"} + +# Refractive index of water for the Cherenkov angle (phase index, ~1.33). +DEFAULT_N_INDEX = 1.33 + + +def _unit(vec): + """Normalise a (3,) vector or each row of an (N,3) array.""" + vec = np.asarray(vec, dtype=float) + if vec.ndim == 1: + return vec / np.linalg.norm(vec) + return vec / np.linalg.norm(vec, axis=1, keepdims=True) + + +# ---------------------------------------------------------------------------- +# Cherenkov angle from particle momentum +# ---------------------------------------------------------------------------- +# Local particle masses in MeV/c^2; the table from beam_selection is reused when +# importable so there is a single source of truth. +_LOCAL_MASSES_MEV = { + "electron": 0.511, "muon": 105.66, "pion": 139.57, "kaon": 493.68, + "proton": 938.27, "deuteron": 1876.54, "helium3": 2808.39, +} +_PARTICLE_ALIASES = { + "e": "electron", "e+": "electron", "e-": "electron", "positron": "electron", + "mu": "muon", "mu+": "muon", "mu-": "muon", "muon": "muon", + "pi": "pion", "pi+": "pion", "pi-": "pion", "pion": "pion", + "k": "kaon", "k+": "kaon", "k-": "kaon", "kaon": "kaon", + "p": "proton", "proton": "proton", + "d": "deuteron", "deuteron": "deuteron", + "he3": "helium3", "helium3": "helium3", +} + + +def _particle_masses_mev(): + """Particle masses (MeV); reuses beam_selection's table when available.""" + masses = dict(_LOCAL_MASSES_MEV) + try: + from .beam_selection import _PARTICLE_MASSES + masses.update(_PARTICLE_MASSES) + except Exception: + pass + return masses + + +def particle_mass_mev(particle): + """Resolve a particle name (with common aliases) to a mass in MeV/c^2.""" + key = _PARTICLE_ALIASES.get(str(particle).lower(), str(particle).lower()) + masses = _particle_masses_mev() + if key not in masses: + raise KeyError(f"Unknown particle {particle!r}; known: {sorted(masses)}") + return masses[key] + + +def cherenkov_angle_deg(momentum, particle="pion", n=DEFAULT_N_INDEX, mass=None): + """ + Cherenkov angle (degrees) for a particle of given momentum in a medium of + refractive index ``n``: ``cos(theta_c) = 1 / (n * beta)`` with + ``beta = p / sqrt(p^2 + m^2)``. + + Parameters + ---------- + momentum : float or array + Momentum in MeV/c (scalar nominal value, or per-event array). + particle : str + Particle name/alias (e.g. "pion", "pi+", "muon", "proton"); ignored if + ``mass`` is given. + n : float + Refractive index of the medium (water ~1.33). + mass : float, optional + Particle mass in MeV/c^2; overrides ``particle``. + + Returns + ------- + float or ndarray + Cherenkov angle in degrees. NaN where the particle is below Cherenkov + threshold (``n * beta <= 1``), i.e. no ring is produced. + """ + scalar = np.ndim(momentum) == 0 + p = np.asarray(momentum, dtype=float) + if mass is None: + mass = particle_mass_mev(particle) + E = np.sqrt(p ** 2 + mass ** 2) + beta = np.divide(p, E, out=np.zeros_like(E), where=E > 0) + nbeta = n * beta + with np.errstate(invalid="ignore", divide="ignore"): + cos_c = np.where(nbeta > 0, 1.0 / nbeta, np.inf) + theta = np.where(cos_c < 1.0, np.degrees(np.arccos(np.clip(cos_c, -1.0, 1.0))), np.nan) + return float(theta) if scalar else theta + + +def cherenkov_cone_halfangle(momentum, particle="pion", n=DEFAULT_N_INDEX, + margin_deg=0.0, mass=None): + """ + Convenience: Cherenkov angle plus a margin, for use as the cone half-angle + (``angle_cut_deg``). Returns NaN where below threshold. ``margin_deg`` widens + the cone to catch resolution/scattering (e.g. a few degrees). + """ + return cherenkov_angle_deg(momentum, particle=particle, n=n, mass=mass) + margin_deg + + +# ---------------------------------------------------------------------------- +# Beam configuration +# ---------------------------------------------------------------------------- +@dataclass +class BeamGeometry: + """ + Bundled beam (or secondary-track) configuration, kept separate from the + detector geometry: where the Cherenkov cone apex sits, which way it points, + and optionally the particle/momentum used to derive the cone angle. + + Pass it to :class:`RingGeometry` (``beam=...``) to set the apex/axis, and use + :meth:`cone_halfangle` to get the ``angle_cut_deg`` for + :class:`CherenkovRingSelection`. + + Attributes + ---------- + origin : (3,) cone apex / entry point (mm), in the geometry frame. + direction : (3,) cone axis (need not be normalised). + momentum : float, optional + Momentum in MeV/c (e.g. the estimated momentum at the tank). + particle : str, optional + Particle name/alias (e.g. "pion") used for the mass. + n : float + Refractive index for the Cherenkov angle (water ~1.33). + """ + origin: Any = DEFAULT_ORIGIN + direction: Any = DEFAULT_BEAM_DIRECTION + momentum: Optional[float] = None + particle: Optional[str] = None + n: float = DEFAULT_N_INDEX + + def __post_init__(self): + self.origin = np.asarray(self.origin, dtype=float) + self.direction = np.asarray(self.direction, dtype=float) + + @property + def unit_direction(self): + """The cone axis, normalised.""" + return self.direction / np.linalg.norm(self.direction) + + def cherenkov_angle_deg(self, momentum=None, particle=None, n=None): + """ + Cherenkov angle (degrees) for this configuration; NaN below threshold. + Falls back to the stored ``momentum`` / ``particle`` / ``n`` when the + arguments are not supplied. + """ + p = self.momentum if momentum is None else momentum + part = self.particle if particle is None else particle + nn = self.n if n is None else n + if p is None or part is None: + raise ValueError( + "BeamGeometry needs momentum and particle to compute the " + "Cherenkov angle (set them on the BeamGeometry or pass them in).") + return cherenkov_angle_deg(p, particle=part, n=nn) + + def cone_halfangle(self, margin_deg=0.0, momentum=None, particle=None, n=None): + """Cherenkov angle + ``margin_deg`` (degrees), for use as angle_cut_deg.""" + return self.cherenkov_angle_deg(momentum=momentum, particle=particle, n=n) + margin_deg + + +# ---------------------------------------------------------------------------- +# Geometry / timing backbone +# ---------------------------------------------------------------------------- +def load_geometry_package_positions(geo_file, wcd_index=0, place_info="est", + n_pos_per_slot=19, geo_package_path=None): + """ + Build an ``(n_mpmt, n_pmt, 3)`` array of absolute PMT positions from the + external ``Geometry`` package (the one used in the original notebook). + + Parameters + ---------- + geo_file : str + Path to the ``.geo`` file, e.g. ``.../examples/wcte_bldg157.geo``. + wcd_index : int + Which water Cherenkov detector in the hall to use (0 for WCTE). + place_info : str + Placement set passed to ``pmt.get_placement(place_info=...)``. The + original notebook used ``"est"`` (survey/estimated). Pass the value your + Geometry package exposes for design positions (e.g. ``"design"``) to use + those instead. + n_pos_per_slot : int + Number of PMT positions per mPMT (19 for WCTE). + geo_package_path : str, optional + Directory that *contains* the ``Geometry`` package folder. If given it + is prepended to ``sys.path`` before importing, so you can point at a + checkout (e.g. ``.../SWAN_projects/Geometry``) without installing it or + editing this module. This keeps the personal path in your notebook call + rather than hardcoded in the library. + + Returns + ------- + positions : (n_mpmt, n_pmt, 3) ndarray + Absolute positions in mm; NaN where a placement is missing. + + Notes + ----- + Imports ``Geometry`` lazily, so this module does not require that package + unless this function is called. + """ + if geo_package_path is not None: + import sys + if geo_package_path not in sys.path: + sys.path.insert(0, geo_package_path) + + try: + from Geometry.Device import Device # lazy import; external package + except ModuleNotFoundError as e: + raise ModuleNotFoundError( + "Could not import the 'Geometry' package. Make sure it is importable " + "in this kernel: pass geo_package_path=, or add it to PYTHONPATH / install it, then restart the " + "kernel. (`import Geometry` should succeed on its own first.)" + ) from e + + hall = Device.open_file(geo_file) + wcd = hall.wcds[wcd_index] + n_slots = len(wcd.mpmts) + + positions = np.full((n_slots, n_pos_per_slot, 3), np.nan) + for slot in range(n_slots): + for pos in range(n_pos_per_slot): + try: + placement = wcd.mpmts[slot].pmts[pos].get_placement(place_info=place_info) + if placement is not None and "location" in placement: + positions[slot, pos] = placement["location"] + except (KeyError, ValueError, AttributeError, IndexError): + continue + return positions + + +class RingGeometry: + """ + Per-channel angles relative to the beam and time-of-flight offsets. + + For a fixed cone apex (``origin``) the per-channel ``theta``, ``phi``, + distance ``r`` and time-of-flight ``tof`` are precomputed once in the + constructor and looked up per hit. A per-event apex can instead be passed to + :meth:`lookup` / :meth:`compute` at call time. + + Parameters + ---------- + positions : (n_mpmt, n_pmt, 3) or (n_mpmt*n_pmt, 3) array, optional + Absolute PMT positions (mm), NaN for missing channels. This is the + preferred input -- e.g. from :func:`load_geometry_package_positions`. + geometry : object, optional + Any object exposing ``mpmts_pos`` of shape ``(n_mpmt, n_pmt, 3)`` + (e.g. :class:`DetectorGeometry`). Used if ``positions`` is not given. + beam : BeamGeometry, optional + Bundled beam configuration. If given, its ``origin`` and ``direction`` + set the cone apex/axis (taking precedence over the ``origin`` / + ``beam_direction`` arguments), and it is kept on ``self.beam``. + origin : sequence of 3 floats + Default cone apex / beam entry point, in the same frame as ``positions``. + beam_direction, phi_reference : sequence of 3 floats + Beam axis and transverse reference for ``theta`` / ``phi``. + vg : float + Group velocity of light (mm/ns) for the time-of-flight offset. + tol : float + Numerical tolerance for normalising near-zero vectors. + n_pos_per_slot : int + Used only to reshape a flat ``(n_mpmt*n_pmt, 3)`` positions array. + + If neither ``positions`` nor ``geometry`` is given, falls back to + :class:`DetectorGeometry` (when available). + """ + + def __init__(self, + positions=None, + *, + geometry=None, + beam: "Optional[BeamGeometry]" = None, + origin: Sequence[float] = DEFAULT_ORIGIN, + beam_direction: Sequence[float] = DEFAULT_BEAM_DIRECTION, + phi_reference: Sequence[float] = DEFAULT_PHI_REFERENCE, + vg: float = DEFAULT_VG, + tol: float = 1e-8, + n_pos_per_slot: int = 19): + # Resolve the positions table from whichever source was provided. + if positions is not None: + pos = np.asarray(positions, dtype=float) + if pos.ndim == 2: + pos = pos.reshape(-1, n_pos_per_slot, 3) + self.channel_pos = pos + elif geometry is not None: + self.channel_pos = np.asarray(geometry.mpmts_pos, dtype=float) + else: + if not _HAS_DETECTOR_GEOMETRY: + raise ValueError( + "No positions/geometry given and DetectorGeometry is not " + "available. Pass positions=... (e.g. from " + "load_geometry_package_positions) or geometry=...") + self.channel_pos = np.asarray(DetectorGeometry().mpmts_pos, dtype=float) + + self.n_mpmt, self.n_pmt = self.channel_pos.shape[0], self.channel_pos.shape[1] + self.channel_valid = np.isfinite(self.channel_pos).all(axis=2) + + # A BeamGeometry, if given, supplies the cone apex and axis. + self.beam = beam + if beam is not None: + origin = beam.origin + beam_direction = beam.direction + + self.origin = np.asarray(origin, dtype=float) + bd = np.asarray(beam_direction, dtype=float) + self.beam_direction = bd / np.linalg.norm(bd) + phi_ref = np.asarray(phi_reference, dtype=float) + self.phi_reference = phi_ref / np.linalg.norm(phi_ref) + self.vg = float(vg) + self.tol = float(tol) + + self._build_channel_tables() + + # -- construction from the external Geometry package ------------------- + @classmethod + def from_geometry_package(cls, geo_file, *, wcd_index=0, place_info="est", + n_pos_per_slot=19, geo_package_path=None, **kwargs): + """ + Build a RingGeometry from a ``.geo`` file via the external Geometry + package. ``place_info`` selects survey ("est", the original default) vs + design placements. ``geo_package_path`` (dir containing the ``Geometry`` + package) is prepended to ``sys.path`` if given. Extra kwargs (origin, + beam_direction, vg, ...) are forwarded to ``__init__``. + """ + positions = load_geometry_package_positions( + geo_file, wcd_index=wcd_index, place_info=place_info, + n_pos_per_slot=n_pos_per_slot, geo_package_path=geo_package_path) + return cls(positions=positions, n_pos_per_slot=n_pos_per_slot, **kwargs) + + # -- one-time per-channel precompute (fixed origin) -------------------- + def _build_channel_tables(self): + """Compute theta/phi/r/tof for every channel once, for the fixed origin.""" + flat = self.channel_pos.reshape(-1, 3) + theta, phi, r = self._angles_core(flat, self.origin) + tof = r / self.vg + shape = (self.n_mpmt, self.n_pmt) + self.channel_theta = theta.reshape(shape) + self.channel_phi = phi.reshape(shape) + self.channel_r = r.reshape(shape) + self.channel_tof = tof.reshape(shape) + + def _angles_core(self, positions, origin, beam_direction=None, phi_reference=None): + """ + Vectorised theta/phi/r for (N,3) positions about ``origin`` with cone + axis ``beam_direction``. ``origin`` and ``beam_direction`` may each be + (3,) (one value for all hits) or (N,3) (per-hit). ``theta`` is the angle + from the cone axis; only ``theta`` is used by the inside/outside cut, so + ``phi`` (measured from ``phi_reference``) is informational. + """ + bd = self.beam_direction if beam_direction is None else _unit(beam_direction) + pr = self.phi_reference if phi_reference is None else _unit(phi_reference) + + v = positions - origin + r = np.linalg.norm(v, axis=1) + inv_r = np.where(r > self.tol, 1.0 / np.where(r > self.tol, r, 1.0), 0.0) + u = v * inv_r[:, None] + + def _dot(a, b): # a is (N,3); b is (3,) or (N,3) + return a @ b if np.ndim(b) == 1 else np.einsum("ij,ij->i", a, b) + + cos_theta = np.clip(_dot(u, bd), -1.0, 1.0) + theta = np.arccos(cos_theta) + + sin_theta = np.sin(theta) + cos_alpha = np.clip(_dot(u, pr), -1.0, 1.0) + cos_phi = np.clip(cos_alpha / np.where(sin_theta > self.tol, sin_theta, 1.0), + -1.0, 1.0) + phi = np.arccos(cos_phi) + phi[v[:, 1] < 0] = 2.0 * np.pi - phi[v[:, 1] < 0] + return theta, phi, r + + # -- per-hit lookup ----------------------------------------------------- + def lookup(self, slot_ids, pos_ids, origin=None, beam_direction=None): + """ + Look up per-hit theta/phi/r/tof for arrays of hit ids. + + If both ``origin`` and ``beam_direction`` are None, the precomputed + fixed-apex tables are used (fast). If either is given, the cone apex + (``origin``) and/or axis (``beam_direction``) override the defaults and + the angles are recomputed (still vectorised). Each override may be a + single (3,) value or a per-hit (N,3) array -- e.g. a secondary-ring + vertex and direction. The time-of-flight depends only on the apex. + + Out-of-range or missing-geometry channels are flagged invalid (NaN + results) rather than raising. + + Returns ``theta, phi, r, tof, valid`` (NaN where invalid). + """ + slot_ids = np.asarray(slot_ids).astype(int).ravel() + pos_ids = np.asarray(pos_ids).astype(int).ravel() + + in_range = ( + (slot_ids >= 0) & (slot_ids < self.n_mpmt) & + (pos_ids >= 0) & (pos_ids < self.n_pmt) + ) + s = np.where(in_range, slot_ids, 0) + p = np.where(in_range, pos_ids, 0) + valid = in_range & self.channel_valid[s, p] + + if origin is None and beam_direction is None: + theta = self.channel_theta[s, p] + phi = self.channel_phi[s, p] + r = self.channel_r[s, p] + tof = self.channel_tof[s, p] + else: + positions = self.channel_pos[s, p] + o = self.origin if origin is None else np.asarray(origin, dtype=float) + theta, phi, r = self._angles_core(positions, o, beam_direction=beam_direction) + tof = r / self.vg + + theta = np.where(valid, theta, np.nan) + phi = np.where(valid, phi, np.nan) + r = np.where(valid, r, np.nan) + tof = np.where(valid, tof, np.nan) + return theta, phi, r, tof, valid + + # -- convenience (single set of hits) ---------------------------------- + def compute(self, slot_ids, pos_ids, hit_times=None, origin=None, + beam_direction=None) -> Dict[str, np.ndarray]: + """ + Convenience wrapper around :meth:`lookup`. Returns a dict with + ``theta``, ``phi``, ``r``, ``tof``, ``valid`` and, if ``hit_times`` is + given, ``delta_t`` (= hit_time - tof). ``origin`` / ``beam_direction`` + override the cone apex / axis. + """ + theta, phi, r, tof, valid = self.lookup(slot_ids, pos_ids, origin=origin, + beam_direction=beam_direction) + out = dict(theta=theta, phi=phi, r=r, tof=tof, valid=valid) + if hit_times is not None: + hit_times = np.asarray(hit_times, dtype=float).ravel() + out["delta_t"] = np.where(valid, hit_times - tof, np.nan) + return out + + +# ---------------------------------------------------------------------------- +# Gaussian helpers (used only for the single-event diagnostic plot) +# ---------------------------------------------------------------------------- +def gauss(x, A, mu, sigma): + """A Gaussian, safe against sigma == 0.""" + return A * np.exp(-0.5 * ((x - mu) / np.where(sigma > 0, sigma, 1e-6)) ** 2) + + +def fit_time_residual_gaussian(delta_t, t_min, t_max, n_bins=100, do_fit=True) -> Dict[str, Any]: + """ + Estimate the prompt-peak location of the time-residual (delta_t) histogram + in [t_min, t_max]. ``mu`` is the histogram peak; when ``do_fit`` a Gaussian + is additionally fit (cosmetic, for the diagnostic plot). Never raises. + """ + delta_t = np.asarray(delta_t, dtype=float).ravel() + delta_t = delta_t[np.isfinite(delta_t)] + + edges = np.linspace(t_min, t_max, n_bins + 1) + counts, _ = np.histogram(delta_t, bins=edges) + centers = 0.5 * (edges[:-1] + edges[1:]) + + A_fit = counts.max() if counts.size else 10.0 + mu_fit = centers[int(np.argmax(counts))] if counts.size and counts.max() > 0 else 0.0 + sigma_fit = 1.0 + + if do_fit and _SCIPY_AVAILABLE and counts.size and counts.max() > 0: + try: + popt, _ = curve_fit(gauss, centers, counts, p0=[A_fit, mu_fit, 1.0]) + A_fit, mu_fit, sigma_fit = popt + sigma_fit = max(abs(sigma_fit), 1e-6) + except Exception: + pass + + return dict(A=A_fit, mu=mu_fit, sigma=sigma_fit, + centers=centers, edges=edges, counts=counts) + + +# ---------------------------------------------------------------------------- +# Per-event result container +# ---------------------------------------------------------------------------- +@dataclass +class RingResults: + """ + Per-event quantities produced by :meth:`CherenkovRingSelection.process_events`. + + Attributes + ---------- + q_total : total charge per event (geometry-valid hits; after the coarse + time window too when the time cut is on) + q_time : charge after the prompt-time window (== q_total when the time + cut is off) + q_inside : charge inside the Cherenkov cone (theta < angle_cut) + q_outside : charge outside the cone, == |q_time - q_inside| + event_id : event id for each entry (input order preserved, failures kept) + fail_ids : dict of lists of event ids rejected at each stage + theta : optional per-event jagged array (rad) of the geometry-valid hits + delta_t : optional per-event jagged array (ns); None if not computed + """ + q_total: np.ndarray = field(default_factory=lambda: np.empty(0)) + q_time: np.ndarray = field(default_factory=lambda: np.empty(0)) + q_inside: np.ndarray = field(default_factory=lambda: np.empty(0)) + q_outside: np.ndarray = field(default_factory=lambda: np.empty(0)) + event_id: np.ndarray = field(default_factory=lambda: np.empty(0, dtype=int)) + fail_ids: Dict[str, list] = field(default_factory=dict) + theta: Any = None + delta_t: Any = None + + def __len__(self): + return len(self.q_total) + + @property + def ring_fraction(self): + """q_inside / q_total per event (0 where q_total == 0).""" + qt = self.q_total + return np.divide(self.q_inside, qt, out=np.zeros_like(qt), where=qt > 0) + + @property + def outside_fraction(self): + """q_outside / q_total per event (0 where q_total == 0).""" + qt = self.q_total + return np.divide(self.q_outside, qt, out=np.zeros_like(qt), where=qt > 0) + + @classmethod + def concatenate(cls, results: Sequence["RingResults"]) -> "RingResults": + """Concatenate a sequence of RingResults (e.g. one per loader batch).""" + if not results: + return cls() + merged_fail: Dict[str, list] = {} + for r in results: + for key, ids in r.fail_ids.items(): + merged_fail.setdefault(key, []).extend(ids) + + def cat_jagged(attr): + parts = [getattr(r, attr) for r in results] + if any(p is None for p in parts): + return None + import awkward as ak + return ak.concatenate(parts) + + return cls( + q_total=np.concatenate([r.q_total for r in results]), + q_time=np.concatenate([r.q_time for r in results]), + q_inside=np.concatenate([r.q_inside for r in results]), + q_outside=np.concatenate([r.q_outside for r in results]), + event_id=np.concatenate([r.event_id for r in results]), + fail_ids=merged_fail, + theta=cat_jagged("theta"), + delta_t=cat_jagged("delta_t"), + ) + + +# ---------------------------------------------------------------------------- +# Hit-level Cherenkov-ring selection +# ---------------------------------------------------------------------------- +class CherenkovRingSelection: + """ + Hit-level selection: optional prompt-time window + Cherenkov-cone angular cut. + + Parameters + ---------- + ring_geometry : RingGeometry + Configured geometry/timing backbone (holds the precomputed channel tables). + angle_cut_deg : float or (n_events,) array + Cherenkov cone half-angle in degrees; hits with theta below this are + "inside the ring". May be a single value (e.g. 44) or a per-event array. + Compute it from the particle momentum with + :func:`cherenkov_cone_halfangle` (Cherenkov angle + margin). Can also be + overridden per call in :meth:`process_events` / :meth:`event_charges`. + apply_time_cut : bool + If True (default) apply the prompt-time window (coarse window + per-event + ``|delta_t - mu| < K``). If False, skip all timing: no coarse window, no + TOF subtraction, no prompt fit -- charge is split inside/outside the cone + using every hit passed in. Use False when timing is handled upstream. + time_window_K : float + Half-width (ns) of the prompt-time window. + fit_t_min, fit_t_max : float + Range (ns) over which the per-event prompt peak ``mu`` is found; only + needs to bracket the prompt peak. Used only when ``apply_time_cut``. + n_bins : int + Number of bins used to locate the per-event prompt peak. + min_hits : int + Minimum number of geometry-valid hits required to process an event. + coarse_time_window : (float, float), optional + Optional pre-cut on calibrated hit times, applied only when + ``apply_time_cut`` is True. + use_gaussian_fit : bool + Only affects the single-event diagnostic plot: if True the drawn curve is + a Gaussian fit. The cut always uses the histogram-peak ``mu`` so that the + single-event and batch paths are identical. + """ + + def __init__(self, + ring_geometry: RingGeometry, + angle_cut_deg: float = 44.0, + apply_time_cut: bool = True, + time_window_K: float = 3.0, + fit_t_min: float = 1670.0, + fit_t_max: float = 1770.0, + n_bins: int = 100, + min_hits: int = 10, + coarse_time_window: Optional[Tuple[float, float]] = None, + use_gaussian_fit: bool = False): + self.ring = ring_geometry + self.angle_cut_deg = float(angle_cut_deg) + self.apply_time_cut = bool(apply_time_cut) + self.time_window_K = float(time_window_K) + self.fit_t_min = float(fit_t_min) + self.fit_t_max = float(fit_t_max) + self.n_bins = int(n_bins) + self.min_hits = int(min_hits) + self.coarse_time_window = coarse_time_window + self.use_gaussian_fit = bool(use_gaussian_fit) + + # -- describe ----------------------------------------------------------- + def describe(self): + print("CherenkovRingSelection") + if np.ndim(self.angle_cut_deg) == 0: + print(f" cone half-angle : theta < {self.angle_cut_deg:g} deg") + else: + a = np.asarray(self.angle_cut_deg, dtype=float) + print(f" cone half-angle : per-event array, " + f"theta < [{np.nanmin(a):g}..{np.nanmax(a):g}] deg") + print(f" time cut : {'on' if self.apply_time_cut else 'OFF (timing handled upstream)'}") + if self.apply_time_cut: + print(f" prompt-time window : |dt - mu| < {self.time_window_K:g} ns " + f"(peak found in [{self.fit_t_min:g}, {self.fit_t_max:g}] ns, {self.n_bins} bins)") + if self.coarse_time_window is not None: + lo, hi = self.coarse_time_window + print(f" coarse time pre-cut : {lo:g} < t < {hi:g} ns") + print(f" min valid hits : {self.min_hits}") + + # -- flatten any event source into flat hit arrays + event boundaries --- + def _flatten(self, events, fields, max_events): + slot_f, pos_f, charge_f, time_f = fields + try: + import awkward as ak + is_awkward = isinstance(events, ak.Array) + except ImportError: + ak = None + is_awkward = False + + if is_awkward: + if max_events is not None: + events = events[:max_events] + n_events = len(events) + counts = ak.to_numpy(ak.num(events[slot_f], axis=1)).astype(np.int64) + slot = ak.to_numpy(ak.flatten(events[slot_f])).astype(np.int64) + pos = ak.to_numpy(ak.flatten(events[pos_f])).astype(np.int64) + charge = ak.to_numpy(ak.flatten(events[charge_f])).astype(float) + time = ak.to_numpy(ak.flatten(events[time_f])).astype(float) + else: + slot_l, pos_l, charge_l, time_l, counts_l = [], [], [], [], [] + for i, ev in enumerate(events): + if max_events is not None and i >= max_events: + break + s = np.asarray(ev[slot_f]).astype(np.int64).ravel() + slot_l.append(s) + pos_l.append(np.asarray(ev[pos_f]).astype(np.int64).ravel()) + charge_l.append(np.asarray(ev[charge_f]).astype(float).ravel()) + time_l.append(np.asarray(ev[time_f]).astype(float).ravel()) + counts_l.append(s.size) + n_events = len(counts_l) + counts = np.asarray(counts_l, dtype=np.int64) + cat = lambda L: np.concatenate(L) if L else np.empty(0) + slot, pos, charge, time = cat(slot_l), cat(pos_l), cat(charge_l), cat(time_l) + + ev_idx = np.repeat(np.arange(n_events), counts) if n_events else np.empty(0, dtype=np.int64) + return slot, pos, charge, time, ev_idx, n_events + + # -- get dt and angle ----------------------------------------------------------- + def get_hit_quantities( self, event=None, *, slot_ids=None, pos_ids=None, charges=None, hit_times=None, origin=None, + beam_direction=None, slot_field="hit_mpmt_slot_ids", pos_field="hit_pmt_position_ids", charge_field="hit_pmt_charges", + time_field="hit_pmt_calibrated_times",): + """ + Return hit-level quantities BEFORE any cuts. + This is intended for debugging and visualisation. + Parameters + ---------- + event : awkward record, optional + Single event containing hit branches. + slot_ids, pos_ids, charges, hit_times : array-like, optional + Can be provided directly instead of `event`. + origin : (3,), optional + Event-specific cone apex (e.g. T5 entry position). + beam_direction : (3,), optional + Event-specific beam direction. + Returns + ------- + dict containing: + slot, pos, charge, time, theta (rad), theta_deg, phi (rad), r (mm), tof (ns), delta_t (ns), valid + """ + # Extract hit arrays + if event is not None: + slot = np.asarray(event[slot_field], dtype=np.int64).ravel() + pos = np.asarray(event[pos_field], dtype=np.int64).ravel() + charge = np.asarray(event[charge_field], dtype=float).ravel() + time = np.asarray(event[time_field], dtype=float).ravel() + else: + slot = np.asarray(slot_ids, dtype=np.int64).ravel() + pos = np.asarray(pos_ids, dtype=np.int64).ravel() + charge = np.asarray(charges, dtype=float).ravel() + time = np.asarray(hit_times, dtype=float).ravel() + + # Geometry lookup + theta, phi, r, tof, valid = self.ring.lookup( + slot, + pos, + origin=origin, + beam_direction=beam_direction,) + delta_t = time - tof + + return dict( + slot=slot, + pos=pos, + charge=charge, + time=time, + theta=theta, + theta_deg=np.degrees(theta), + phi=phi, + r=r, + tof=tof, + delta_t=delta_t, + valid=valid,) + + + # -- the single shared core for process_event_charge and process_events functions-------------------------------------------- + def _summarise(self, slot, pos, charge, time, ev_idx, n_events, + apply_time_cut, return_hits, origins=None, beam_directions=None, + angle_cut_deg=None): + """ + Vectorised per-event summary. Both event_charges() and process_events() + call this -- there is only one implementation of the physics. + + ``origins`` / ``beam_directions`` optionally override the cone apex and + axis: each a single (3,) value or a per-event (n_events, 3) array (e.g. + T5 entry positions, or a secondary-ring vertex/direction). When given, + angles/tof are recomputed per hit rather than read from the tables. + + ``angle_cut_deg`` overrides the cone half-angle: a scalar, or a per-event + (n_events,) array (e.g. a per-event Cherenkov angle from the momentum). + + Returns a dict of per-event arrays plus, when requested, per-event jagged + theta / delta_t and the per-event mu (for the single-event plot). + """ + # --- hit-level keep: the coarse time window, only when the time cut is + # on. Channel/data-quality cuts are assumed already applied upstream + # (e.g. by DataLoader); trigger mainboards and bad geometry are + # dropped anyway by the geometry-bounds check in RingGeometry.lookup. + if apply_time_cut and self.coarse_time_window is not None: + lo, hi = self.coarse_time_window + keep = (time > lo) & (time < hi) + slot, pos, charge, time, ev_idx = (slot[keep], pos[keep], charge[keep], + time[keep], ev_idx[keep]) + + n_hits = np.bincount(ev_idx, minlength=n_events) + + # --- resolve cone apex / axis (fixed tables, or recomputed per hit) --- + def _per_hit(arr): + if arr is None: + return None + arr = np.asarray(arr, dtype=float) + return arr if arr.ndim == 1 else arr[ev_idx] + + origin_arg = _per_hit(origins) + beamdir_arg = _per_hit(beam_directions) + + # --- geometry lookup (precomputed tables, or recomputed per hit) --- + theta, _phi, _r, tof, valid = self.ring.lookup( + slot, pos, origin=origin_arg, beam_direction=beamdir_arg) + ev_v = ev_idx[valid] + n_valid = np.bincount(ev_v, minlength=n_events) + + # --- time residual (only if needed) --- + need_dt = apply_time_cut or return_hits + delta_t = (time - tof) if need_dt else None + + # --- per-event prompt peak mu (vectorised histogram + argmax) --- + mu = np.full(n_events, np.nan) + if apply_time_cut: + width = (self.fit_t_max - self.fit_t_min) / self.n_bins + inwin = valid & np.isfinite(delta_t) & \ + (delta_t >= self.fit_t_min) & (delta_t < self.fit_t_max) + bin_idx = np.clip(((delta_t[inwin] - self.fit_t_min) / width).astype(int), + 0, self.n_bins - 1) + counts2d = np.zeros((n_events, self.n_bins), dtype=np.int64) + np.add.at(counts2d, (ev_idx[inwin], bin_idx), 1) + has_peak = counts2d.max(axis=1) > 0 + centers = self.fit_t_min + (np.arange(self.n_bins) + 0.5) * width + mu = np.where(has_peak, centers[counts2d.argmax(axis=1)], np.nan) + + mu_hit = mu[ev_idx] + time_pass = valid & np.isfinite(mu_hit) & \ + (np.abs(delta_t - mu_hit) < self.time_window_K) + else: + time_pass = valid + + n_time = np.bincount(ev_idx[time_pass], minlength=n_events) + + # --- cone half-angle: scalar or per-event array --- + cut = self.angle_cut_deg if angle_cut_deg is None else angle_cut_deg + if np.ndim(cut) == 0: + thr_hit = cut + else: + thr_hit = np.asarray(cut, dtype=float)[ev_idx] + # NaN threshold (e.g. below Cherenkov threshold) -> nothing inside + inside = valid & (np.degrees(theta) < thr_hit) + + # --- per-event charge sums --- + q_total = np.bincount(ev_idx[valid], weights=charge[valid], minlength=n_events) + q_time = np.bincount(ev_idx[time_pass], weights=charge[time_pass], minlength=n_events) + in_and_time = time_pass & inside + q_inside = np.bincount(ev_idx[in_and_time], weights=charge[in_and_time], minlength=n_events) + q_outside = np.abs(q_time - q_inside) + + # --- per-event status (precedence: no_hits > no_geom > few_hits > no_time) --- + status = np.full(n_events, _OK, dtype=np.int8) + if apply_time_cut: + status[n_time == 0] = _NO_TIME + status[n_valid < self.min_hits] = _FEW_HITS + status[(n_hits > 0) & (n_valid == 0)] = _NO_GEOM + status[n_hits == 0] = _NO_HITS + + # Events that never reach the charge step contribute zero charge + # (no_hits / no_geom / few_hits). no_time keeps q_total but has q_time = + # q_inside = q_outside = 0 by construction. + no_charge = (status == _NO_HITS) | (status == _NO_GEOM) | (status == _FEW_HITS) + q_total[no_charge] = 0.0 + q_time[no_charge] = 0.0 + q_inside[no_charge] = 0.0 + q_outside[no_charge] = 0.0 + + out = dict(q_total=q_total, q_time=q_time, q_inside=q_inside, + q_outside=q_outside, status=status, mu=mu, + n_hits=n_hits, n_valid=n_valid, n_time=n_time) + + if return_hits: + import awkward as ak + theta_jag = ak.unflatten(theta[valid], n_valid) + out["theta"] = theta_jag + out["delta_t"] = ak.unflatten(delta_t[valid], n_valid) if need_dt else None + return out + + # -- single event ------------------------------------------------------- + def process_event_charge(self, event=None, *, slot_ids=None, pos_ids=None, + charges=None, hit_times=None, event_id=None, + apply_time_cut=None, origin=None, beam_direction=None, + angle_cut_deg=None, do_plot=False, + slot_field="hit_mpmt_slot_ids", pos_field="hit_pmt_position_ids", + charge_field="hit_pmt_charges", time_field="hit_pmt_calibrated_times"): + """ + Compute (q_total, q_time, q_inside, q_outside) for one event, via the + same core as the batch path. + + Pass an awkward ``event`` record (hit branches read from the standard + field names) or the four hit arrays directly. ``origin`` / ``beam_direction`` + optionally set this event's cone apex / axis (each a (3,) vector, e.g. + its T5 entry position and the particle direction). ``angle_cut_deg`` + overrides the cone half-angle for this event (e.g. its Cherenkov angle). + Returns a dict with keys ``q_total``, ``q_time``, ``q_inside``, + ``q_outside``, ``status`` and the per-hit ``theta`` / ``delta_t``. + """ + atc = self.apply_time_cut if apply_time_cut is None else bool(apply_time_cut) + + if event is not None: + slot = np.asarray(event[slot_field]).astype(np.int64).ravel() + pos = np.asarray(event[pos_field]).astype(np.int64).ravel() + charge = np.asarray(event[charge_field]).astype(float).ravel() + time = np.asarray(event[time_field]).astype(float).ravel() + else: + slot = np.asarray(slot_ids).astype(np.int64).ravel() + pos = np.asarray(pos_ids).astype(np.int64).ravel() + charge = np.asarray(charges, dtype=float).ravel() + time = np.asarray(hit_times, dtype=float).ravel() + + ev_idx = np.zeros(slot.size, dtype=np.int64) + s = self._summarise(slot, pos, charge, time, ev_idx, 1, + apply_time_cut=atc, return_hits=True, + origins=(None if origin is None else np.asarray(origin, float)), + beam_directions=(None if beam_direction is None + else np.asarray(beam_direction, float)), + angle_cut_deg=angle_cut_deg) + + import awkward as ak + theta = ak.to_numpy(s["theta"][0]) if len(s["theta"]) else np.empty(0) + delta_t = (ak.to_numpy(s["delta_t"][0]) if (s["delta_t"] is not None and len(s["delta_t"])) + else np.empty(0)) + res = dict(q_total=float(s["q_total"][0]), q_time=float(s["q_time"][0]), + q_inside=float(s["q_inside"][0]), q_outside=float(s["q_outside"][0]), + theta=theta, delta_t=delta_t, status=_STATUS_NAME[int(s["status"][0])]) + + if do_plot and _MPL_AVAILABLE: + cut0 = self.angle_cut_deg if angle_cut_deg is None else angle_cut_deg + cut0 = float(cut0) if np.ndim(cut0) == 0 else float(np.asarray(cut0).ravel()[0]) + self._plot_time_window(theta, delta_t, float(s["mu"][0]), event_id, atc, + angle_cut_deg=cut0) + return res + + # -- many events -------------------------------------------------------- + def process_events(self, events, max_events=None, start_index=0, + apply_time_cut=None, origins=None, beam_directions=None, + angle_cut_deg=None, return_hits=False, + verbose=False, do_plot=False, + slot_field="hit_mpmt_slot_ids", pos_field="hit_pmt_position_ids", + charge_field="hit_pmt_charges", time_field="hit_pmt_calibrated_times" + ) -> RingResults: + """ + Process an awkward batch (from ``DataLoader.iterate``) or any iterable of + event records and return a :class:`RingResults`. Fully vectorised: the + whole batch goes through one pass of :meth:`_summarise`. + + Parameters + ---------- + return_hits : bool + If True, also return per-event jagged ``theta`` / ``delta_t`` on the + result (aligned to the geometry-valid hits of each event). Off by + default -- materialising every hit is memory-heavy on a full run. + apply_time_cut : bool, optional + Override the selection's default for this call. + origins, beam_directions : (3,) or (n_events, 3) array, optional + Cone apex / axis override. A single value applies to every event; a + per-event array (in input event order and length, before + ``max_events``) gives each event its own apex / axis. Use for T5 + entry positions or secondary-ring vertices and directions. + angle_cut_deg : float or (n_events,) array, optional + Cone half-angle override (e.g. a per-event Cherenkov angle from the + momentum, via :func:`cherenkov_cone_halfangle`). + start_index : int + Added to the within-batch event index to keep ids unique across + successive batches. + """ + atc = self.apply_time_cut if apply_time_cut is None else bool(apply_time_cut) + if do_plot: + print("note: do_plot is ignored by process_events; use event_charges for plots.") + + fields = (slot_field, pos_field, charge_field, time_field) + slot, pos, charge, time, ev_idx, n_events = self._flatten(events, fields, max_events) + + # Trim per-event overrides to the events actually processed. + # A single override is (3,) (1-D); a per-event override is (n_events, 3) + # (2-D) or (n_events,) for angle_cut -- only those need trimming. + def _trim(arr): + if arr is None: + return None + arr = np.asarray(arr, dtype=float) + if arr.ndim == 2 and max_events is not None: + arr = arr[:n_events] + return arr + + origins = _trim(origins) + beam_directions = _trim(beam_directions) + if angle_cut_deg is not None and np.ndim(angle_cut_deg) > 0 and max_events is not None: + angle_cut_deg = np.asarray(angle_cut_deg, dtype=float)[:n_events] + + s = self._summarise(slot, pos, charge, time, ev_idx, n_events, + apply_time_cut=atc, return_hits=return_hits, + origins=origins, beam_directions=beam_directions, + angle_cut_deg=angle_cut_deg) + + event_id = np.arange(n_events) + start_index + status = s["status"] + fail_ids = {name: event_id[status == code].tolist() + for code, name in _STATUS_NAME.items() if code != _OK} + + if verbose: + n_ok = int(np.sum(status == _OK)) + print(f" {n_events} events, {n_ok} ok; " + f"rejected: { {k: len(v) for k, v in fail_ids.items()} }") + + return RingResults( + q_total=s["q_total"], q_time=s["q_time"], + q_inside=s["q_inside"], q_outside=s["q_outside"], + event_id=event_id, fail_ids=fail_ids, + theta=s.get("theta"), delta_t=s.get("delta_t"), + ) + + # -- single-event diagnostic plot -------------------------------------- + def _plot_time_window(self, theta, delta_t, mu, event_id, apply_time_cut, + angle_cut_deg=None): + cut = self.angle_cut_deg if angle_cut_deg is None else angle_cut_deg + cut = float(cut) if np.ndim(cut) == 0 else float(np.asarray(cut).ravel()[0]) + theta_deg = np.degrees(theta) + if apply_time_cut and theta.size and np.isfinite(mu): + K = self.time_window_K + mask = np.abs(delta_t - mu) < K + fig, ax = plt.subplots(1, 2, figsize=(11, 4), constrained_layout=True) + + fit = fit_time_residual_gaussian(delta_t, self.fit_t_min, self.fit_t_max, + self.n_bins, do_fit=self.use_gaussian_fit) + ax[0].bar(fit["centers"], fit["counts"], width=np.diff(fit["edges"]), + align="edge", color="0.85", edgecolor="k", label="dt data") + ax[0].axvspan(mu - K, mu + K, color="C4", alpha=0.18, label=f"mu +/- {K} ns") + if self.use_gaussian_fit: + ax[0].plot(fit["centers"], gauss(fit["centers"], fit["A"], fit["mu"], fit["sigma"]), + "C3-", lw=2, label="gauss fit") + ax[0].axvline(mu, color="C3", ls="--", lw=1) + ax[0].set_xlabel("dt (ns)"); ax[0].set_ylabel("Counts") + ax[0].set_title(f"Event {event_id} : dt histogram" if event_id is not None else "dt histogram") + ax[0].legend(fontsize="small") + + ax[1].scatter(theta_deg, delta_t, s=1, c="0.80", label="all hits") + if mask.any(): + ax[1].scatter(theta_deg[mask], delta_t[mask], s=3, c="C0", + label=f"in window ({int(mask.sum())})") + ax[1].axhspan(mu - K, mu + K, color="C4", alpha=0.10) + ax[1].axvline(cut, color="k", ls=":", lw=1, label=f"cone {cut:g} deg") + ax[1].set_xlim(0, 180) + ax[1].set_xlabel("theta (deg)"); ax[1].set_ylabel("dt (ns)") + ax[1].set_title("theta vs dt (prompt window)") + ax[1].legend(loc="upper right", fontsize="small") + plt.show() + else: + # time cut off: just show the angular distribution of the charge + fig, ax = plt.subplots(figsize=(6, 4)) + ax.hist(theta_deg, bins=60, color="0.7", edgecolor="k") + ax.axvline(cut, color="C3", ls="--", label=f"cone {cut:g} deg") + ax.set_xlabel("theta (deg)"); ax.set_ylabel("hits") + ax.set_title(f"Event {event_id} : theta distribution" if event_id is not None else "theta distribution") + ax.legend(fontsize="small") + plt.show() + + +# ---------------------------------------------------------------------------- +# Topology classification + plotting helpers +# ---------------------------------------------------------------------------- +def classify_charge_topology(q_inside, q_outside, + outside_track_max=3800.0, + outside_shower_min=4000.0, + track_percentiles=(1, 23, 23.1, 96, 96.1, 99.99), + shower_percentiles=(0.1, 13, 28, 99.9999)) -> Dict[str, np.ndarray]: + """ + Split events into track-like and shower-like topologies using the charge + deposited outside the Cherenkov cone, then bin each topology into low / mid / + high bands by the inside-cone charge percentiles. Returns a dict of boolean + masks (``track_low/mid/high``, ``shower_low/mid/high``) plus ``track_cuts`` and + ``shower_cuts``. Adjust thresholds and percentiles for your run. + """ + q_inside = np.asarray(q_inside, dtype=float) + q_outside = np.asarray(q_outside, dtype=float) + + track = q_outside < outside_track_max + shower = q_outside > outside_shower_min + out: Dict[str, np.ndarray] = {} + + vals = q_inside[track]; vals = vals[vals > 0] + if vals.size: + c = np.percentile(vals, track_percentiles) + out["track_low"] = track & (q_inside > c[0]) & (q_inside <= c[1]) + out["track_mid"] = track & (q_inside > c[2]) & (q_inside <= c[3]) + out["track_high"] = track & (q_inside > c[4]) & (q_inside <= c[5]) + out["track_cuts"] = c + else: + for k in ("track_low", "track_mid", "track_high"): + out[k] = np.zeros_like(track) + out["track_cuts"] = np.array([]) + + vals = q_inside[shower]; vals = vals[vals > 0] + if vals.size: + ce = np.percentile(vals, shower_percentiles) + out["shower_low"] = shower & (q_inside > ce[0]) & (q_inside <= ce[1]) + out["shower_mid"] = shower & (q_inside > ce[1]) & (q_inside <= ce[2]) + out["shower_high"] = shower & (q_inside > ce[2]) & (q_inside <= ce[3]) + out["shower_cuts"] = ce + else: + for k in ("shower_low", "shower_mid", "shower_high"): + out[k] = np.zeros_like(shower) + out["shower_cuts"] = np.array([]) + return out + +def plot_inside_vs_outside(q_inside, q_outside, topology=None, + outside_track_max=None, outside_shower_min=None, + xlim=None, ylim=None, bins=300, ax=None, + style="regions", cmap=None): + """ + 2D histogram of charge inside vs outside the Cherenkov cone, with the + track/shower split drawn on top. + + Parameters + ---------- + topology : dict, optional + Output of :func:`classify_charge_topology`. If given, its percentile + bands are drawn as rectangular regions, and its thresholds supply the + track/shower split lines. + outside_track_max, outside_shower_min : float, optional + Track/shower split thresholds on the outside-cone charge. Pass these to + draw the split lines and zone labels **without** computing a full + topology. They override the values found in ``topology``. + bins : int + Number of bins per axis (default 300). + style : {"regions", "boundaries", "scatter"} + How to overlay the topology categories (only used when ``topology`` is + given): shaded rectangles (default), outlines only, or the old scatter. + cmap : str, optional + Colormap for the density. Defaults to "viridis" (visible on sparse + data); when ``topology`` regions are drawn it defaults to "Greys" so the + coloured regions stand out. Pass any name to override. + + Returns the matplotlib Axes. + """ + if not _MPL_AVAILABLE: + raise RuntimeError("matplotlib is required for plot_inside_vs_outside") + from matplotlib.colors import LogNorm + from matplotlib.patches import Rectangle, Patch + + q_inside = np.asarray(q_inside, dtype=float) + q_outside = np.asarray(q_outside, dtype=float) + if ax is None: + _, ax = plt.subplots(figsize=(7, 6)) + + draw_regions = (topology is not None and style in ("regions", "boundaries")) + if cmap is None: + cmap = "Greys" if draw_regions else "viridis" + + h = ax.hist2d(q_inside, q_outside, bins=(bins, bins), norm=LogNorm(), cmap=cmap) + plt.colorbar(h[3], ax=ax, label="counts (log)") + + # Fix the axis limits before drawing regions / labels so they fill the frame. + if xlim is not None: + ax.set_xlim(xlim) + if ylim is not None: + ax.set_ylim(ylim) + x0, x1 = ax.get_xlim() + y0, y1 = ax.get_ylim() + + # Resolve the track/shower thresholds: explicit args win, else topology. + otm = outside_track_max + osm = outside_shower_min + if topology is not None: + if otm is None: + otm = topology.get("outside_track_max") + if osm is None: + osm = topology.get("outside_shower_min") + + if topology is not None and style == "scatter": + overlays = [("track_low", "blue", "track low"), ("track_mid", "green", "track mid"), + ("track_high", "orange", "track high"), ("shower_low", "purple", "shower low"), + ("shower_mid", "pink", "shower mid"), ("shower_high", "magenta", "shower high")] + for key, color, label in overlays: + m = topology.get(key) + if m is not None and np.any(m): + ax.scatter(q_inside[m], q_outside[m], s=0.2, c=color, alpha=0.3, label=label) + ax.legend(fontsize=7, loc="best") + + elif draw_regions: + tcuts = np.asarray(topology.get("track_cuts", []), dtype=float) + scuts = np.asarray(topology.get("shower_cuts", []), dtype=float) + track_bands = [(0, 1, "#1f77b4", "track low"), + (2, 3, "#2ca02c", "track mid"), + (4, 5, "#ff7f0e", "track high")] + shower_bands = [(0, 1, "#9467bd", "shower low"), + (1, 2, "#e377c2", "shower mid"), + (2, 3, "#d62728", "shower high")] + filled = (style == "regions") + handles = [] + + def add_band(cuts, lo_i, hi_i, ylo, yhi, color, label): + if hi_i >= len(cuts): + return + xlo, xhi = cuts[lo_i], cuts[hi_i] + if not (np.isfinite(xlo) and np.isfinite(xhi)) or xhi <= xlo or yhi <= ylo: + return + ax.add_patch(Rectangle( + (xlo, ylo), xhi - xlo, yhi - ylo, + facecolor=(color if filled else "none"), + edgecolor=color, lw=1.4, alpha=(0.16 if filled else 1.0), zorder=3)) + handles.append(Patch(facecolor=color, edgecolor=color, alpha=0.5, label=label)) + + if tcuts.size and otm is not None: + for lo_i, hi_i, color, label in track_bands: + add_band(tcuts, lo_i, hi_i, max(y0, 0.0), otm, color, label) + if scuts.size and osm is not None: + for lo_i, hi_i, color, label in shower_bands: + add_band(scuts, lo_i, hi_i, osm, y1, color, label) + if handles: + ax.legend(handles=handles, fontsize=8, loc="upper right", + framealpha=0.9, title="topology") + + # The track/shower split lines + zone labels (whenever thresholds are known). + if otm is not None: + ax.axhline(otm, color="crimson", ls="--", lw=1.3, zorder=4) + ax.text(x1, otm, " track-like \u2193", color="crimson", fontsize=8, + ha="right", va="top", zorder=4) + if osm is not None and osm != otm: + ax.axhline(osm, color="crimson", ls="--", lw=1.3, zorder=4) + if osm is not None: + ax.text(x1, osm, " shower-like \u2191", color="crimson", fontsize=8, + ha="right", va="bottom", zorder=4) + + ax.set_xlabel("total charge inside Cherenkov cone") + ax.set_ylabel("total charge outside Cherenkov cone") + ax.set_title("Charge deposited in the tank: inside vs outside the ring") + return ax + From ed90fc65dcc5d9ced8cc929284d284a0d698064b Mon Sep 17 00:00:00 2001 From: dtaghayor Date: Tue, 21 Jul 2026 23:40:27 +0200 Subject: [PATCH 2/2] Use extern/Geometry submodule instead of local SWAN path --- .gitignore | 3 + .../Example Ring Angular Analysis.ipynb | 60 ++++++++++--------- 2 files changed, 35 insertions(+), 28 deletions(-) diff --git a/.gitignore b/.gitignore index ddefbcd..ef619cb 100644 --- a/.gitignore +++ b/.gitignore @@ -32,3 +32,6 @@ scripts/batchScripts/ #dirty fix to clean the git repo crossing_muon_study/ + +# analysis output data +analysis_examples/*.parquet diff --git a/analysis_examples/Example Ring Angular Analysis.ipynb b/analysis_examples/Example Ring Angular Analysis.ipynb index daade2d..dfc8b8b 100644 --- a/analysis_examples/Example Ring Angular Analysis.ipynb +++ b/analysis_examples/Example Ring Angular Analysis.ipynb @@ -42,7 +42,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Geometry at: /eos/user/s/staghayo/SWAN_projects/Geometry/Geometry/__init__.py\n" + "Geometry at: /eos/home-i02/s/staghayo/SWAN_projects/analysis_tools_clean/extern/Geometry/Geometry/__init__.py\n" ] } ], @@ -56,7 +56,6 @@ "# then re-run. A live kernel keeps the already-imported modules cached;\n", "# importlib.reload(analysis_tools) does NOT reload its submodules.\n", "import analysis_tools\n", - "\n", "from analysis_tools import (\n", " DataLoader,\n", " BeamSelection,\n", @@ -73,22 +72,20 @@ "# DetectorGeometry is also importable if you prefer the in-repo geometry:\n", "# from analysis_tools import DetectorGeometry\n", "\n", - "\n", - "\n", - "\n", - "#change later\n", - "# The Geometry package must be importable in THIS kernel. Point at the directory\n", - "# that CONTAINS the Geometry/ package folder, then verify before constructing.\n", + "# Use the Geometry package shipped with this repo as the extern/Geometry\n", + "# submodule (run `git submodule update --init --recursive` once to populate it).\n", + "# Point sys.path at the submodule dir that CONTAINS the Geometry/ package folder.\n", "# (Do Kernel -> Restart & Run All after changing paths; edits to imported modules\n", "# are not picked up by a live kernel.)\n", "import sys\n", - "GEO_PKG_DIR = \"/eos/user/s/staghayo/SWAN_projects/Geometry\" # dir containing Geometry/\n", + "from pathlib import Path\n", + "repo_root = Path.cwd().parent # analysis_examples/ -> repo root\n", + "GEO_PKG_DIR = str(repo_root / \"extern\" / \"Geometry\") # dir containing Geometry/\n", "GEO_FILE = f\"{GEO_PKG_DIR}/examples/wcte_bldg157.geo\"\n", - "\n", "if GEO_PKG_DIR not in sys.path:\n", " sys.path.insert(0, GEO_PKG_DIR)\n", "import Geometry # must succeed; check the printed path\n", - "print(\"Geometry at:\", Geometry.__file__)" + "print(\"Geometry at:\", Geometry.__file__) # should be .../extern/Geometry/Geometry/__init__.py" ] }, { @@ -197,13 +194,12 @@ "# restrict to pions selected from the beam monitors.\n", "vme = loader.get_vme_analysis_scalar_results()\n", "tof_cut = vme['proton_tof_cut'] or 999\n", - "pion_sel = BeamSelection.pion(\n", + "pion_sel = BeamSelection.selection(\n", + " \"pion\",\n", " [\"vme_act_eveto\", \"<\", vme['act_eveto_cut']],\n", " [\"vme_act_tagger\", \"<\", vme['act_tagger_cut']],\n", " [\"vme_tof_corr\", \"<\", tof_cut],\n", ")\n", - "\n", - "\n", "events = demo_batch[pion_sel.mask(demo_batch)]" ] }, @@ -283,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "c16195e6", "metadata": {}, "outputs": [ @@ -353,7 +349,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "a5437ce7", "metadata": {}, "outputs": [ @@ -415,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "c529ddda", "metadata": {}, "outputs": [], @@ -445,7 +441,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "3f24bb6a", "metadata": {}, "outputs": [ @@ -477,7 +473,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "d66a16f2", "metadata": {}, "outputs": [ @@ -540,7 +536,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "5f799386", "metadata": {}, "outputs": [ @@ -581,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 14, "id": "8f273b23", "metadata": {}, "outputs": [ @@ -666,7 +662,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "id": "13056dd2", "metadata": {}, "outputs": [ @@ -708,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "id": "14a0da15", "metadata": {}, "outputs": [ @@ -758,7 +754,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 17, "id": "50bd7540", "metadata": {}, "outputs": [ @@ -800,7 +796,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 18, "id": "979eb5ec", "metadata": {}, "outputs": [ @@ -853,7 +849,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 19, "id": "eb0600d4", "metadata": {}, "outputs": [ @@ -894,10 +890,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "344ee8ea", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved\n" + ] + } + ], "source": [ "np.savez(\n", " f\"ring_charge_splits_r{run_number}.npz\",\n",