From 226c123af01a0f4503dd5f944c247bc5a76b11c0 Mon Sep 17 00:00:00 2001 From: Nschanche Date: Mon, 26 Aug 2024 17:57:52 -0400 Subject: [PATCH 1/9] Moved _update_coordinates --- src/lkprf/keplerprf.py | 35 +++++++++++++++++++++++++++++++++++ src/lkprf/prfmodel.py | 34 +--------------------------------- src/lkprf/tessprf.py | 38 +++++++++++++++++++++++++++++++++++++- 3 files changed, 73 insertions(+), 34 deletions(-) diff --git a/src/lkprf/keplerprf.py b/src/lkprf/keplerprf.py index 5b9b0b5..68ed4bf 100644 --- a/src/lkprf/keplerprf.py +++ b/src/lkprf/keplerprf.py @@ -59,3 +59,38 @@ def update_coordinates(self, targets: List[Tuple], shape: Tuple): ) self._update_coordinates(targets=targets, shape=shape) return + + def _update_coordinates(self, targets: List[Tuple], shape: Tuple): + row, column = self._unpack_targets(targets) + # Set the row and column for the model + row, column = np.atleast_1d(row), np.atleast_1d(column) + row = np.min([np.max([row, row**0 * 20], axis=0), row**0 * 1044], axis=0).mean() + column = np.min( + [np.max([column, column**0 * 12], axis=0), column**0 * 1112], axis=0 + ).mean() + + # interpolate the calibrated PRF shape to the target position + min_prf_weight = 1e-6 + rowdim, coldim = shape[0], shape[1] + ref_column = column + 0.5 * coldim + ref_row = row + 0.5 * rowdim + supersamp_prf = np.zeros(self.PRFdata.shape[1:], dtype="float32") + + # Find the 3 measurements nearest the desired locations + # Kepler has 5 measurements, so nearest 3 triangulates the measurement + prf_weights = [ + np.sqrt( + (ref_column - self.crval1p[i]) ** 2 + (ref_row - self.crval2p[i]) ** 2) + for i in range(self.PRFdata.shape[0]) + ] + idx = np.argpartition(prf_weights, 4)[:4] + + for i in idx: + if prf_weights[i] < min_prf_weight: + prf_weights[i] = min_prf_weight + supersamp_prf += self.PRFdata[i] / prf_weights[i] + + + supersamp_prf /= np.nansum(supersamp_prf) * self.cdelt1p[0] * self.cdelt2p[0] + self.interpolate = RectBivariateSpline(self.PRFrow, self.PRFcol, supersamp_prf) + return diff --git a/src/lkprf/prfmodel.py b/src/lkprf/prfmodel.py index 71609a1..42d063f 100644 --- a/src/lkprf/prfmodel.py +++ b/src/lkprf/prfmodel.py @@ -231,39 +231,7 @@ def _prepare_prf(self): self.cdelt2p, ) = (PRFrow, PRFcol, PRFdata, crval1p, crval2p, cdelt1p, cdelt2p) - def _update_coordinates(self, targets: List[Tuple], shape: Tuple): - row, column = self._unpack_targets(targets) - # Set the row and column for the model - row, column = np.atleast_1d(row), np.atleast_1d(column) - row = np.min([np.max([row, row**0 * 20], axis=0), row**0 * 1044], axis=0).mean() - column = np.min( - [np.max([column, column**0 * 12], axis=0), column**0 * 1112], axis=0 - ).mean() - - # interpolate the calibrated PRF shape to the target position - min_prf_weight = 1e-6 - rowdim, coldim = shape[0], shape[1] - ref_column = column + 0.5 * coldim - ref_row = row + 0.5 * rowdim - supersamp_prf = np.zeros(self.PRFdata.shape[1:], dtype="float32") - - # Find the 4 measurements nearest the desired locations - prf_weights = [ - np.sqrt( - (ref_column - self.crval1p[i]) ** 2 + (ref_row - self.crval2p[i]) ** 2) - for i in range(self.PRFdata.shape[0]) - ] - idx = np.argpartition(prf_weights, 4)[:4] - - for i in idx: - if prf_weights[i] < min_prf_weight: - prf_weights[i] = min_prf_weight - supersamp_prf += self.PRFdata[i] / prf_weights[i] - - - supersamp_prf /= np.nansum(supersamp_prf) * self.cdelt1p[0] * self.cdelt2p[0] - self.interpolate = RectBivariateSpline(self.PRFrow, self.PRFcol, supersamp_prf) - return + @abstractmethod def update_coordinates(self, targets, shape): diff --git a/src/lkprf/tessprf.py b/src/lkprf/tessprf.py index 26da9d5..0958f2d 100644 --- a/src/lkprf/tessprf.py +++ b/src/lkprf/tessprf.py @@ -34,7 +34,7 @@ def update_coordinates(self, targets: List[Tuple], shape: Tuple): LKPRFWarning, ) - if ((np.atleast_1d(column) + shape[1]) > 2093).any(): + if ((np.atleast_1d(column) + shape[1]) > 2092).any(): warnings.warn( "`targets` contains collateral pixels: Column(s) > 2093 ", LKPRFWarning, @@ -51,3 +51,39 @@ def update_coordinates(self, targets: List[Tuple], shape: Tuple): ) self._update_coordinates(targets=targets, shape=shape) return + + + def _update_coordinates(self, targets: List[Tuple], shape: Tuple): + row, column = self._unpack_targets(targets) + # Set the row and column for the model. + # Disallows models in the collateral pixels + row, column = np.atleast_1d(row), np.atleast_1d(column) + row = np.min([np.max([row, row**0 * 0], axis=0), row**0 * 2048], axis=0).mean() + column = np.min( + [np.max([column, column**0 * 45], axis=0), column**0 * 2092], axis=0 + ).mean() + + # interpolate the calibrated PRF shape to the target position + min_prf_weight = 1e-6 + rowdim, coldim = shape[0], shape[1] + ref_column = column + 0.5 * coldim + ref_row = row + 0.5 * rowdim + supersamp_prf = np.zeros(self.PRFdata.shape[1:], dtype="float32") + + # Find the 4 measurements nearest the desired locations + prf_weights = [ + np.sqrt( + (ref_column - self.crval1p[i]) ** 2 + (ref_row - self.crval2p[i]) ** 2) + for i in range(self.PRFdata.shape[0]) + ] + idx = np.argpartition(prf_weights, 4)[:4] + + for i in idx: + if prf_weights[i] < min_prf_weight: + prf_weights[i] = min_prf_weight + supersamp_prf += self.PRFdata[i] / prf_weights[i] + + + supersamp_prf /= np.nansum(supersamp_prf) * self.cdelt1p[0] * self.cdelt2p[0] + self.interpolate = RectBivariateSpline(self.PRFrow, self.PRFcol, supersamp_prf) + return From 22737d9398cdc90fd11d62367974a079b80eacf2 Mon Sep 17 00:00:00 2001 From: Nschanche Date: Mon, 26 Aug 2024 18:15:06 -0400 Subject: [PATCH 2/9] Updated Kepler _update_coordinates --- src/lkprf/keplerprf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lkprf/keplerprf.py b/src/lkprf/keplerprf.py index 68ed4bf..45131d2 100644 --- a/src/lkprf/keplerprf.py +++ b/src/lkprf/keplerprf.py @@ -83,7 +83,7 @@ def _update_coordinates(self, targets: List[Tuple], shape: Tuple): (ref_column - self.crval1p[i]) ** 2 + (ref_row - self.crval2p[i]) ** 2) for i in range(self.PRFdata.shape[0]) ] - idx = np.argpartition(prf_weights, 4)[:4] + idx = np.argpartition(prf_weights, 3)[:3] for i in idx: if prf_weights[i] < min_prf_weight: From 11ee3f50e54632da42ca644187a6a01ad1a6b6a3 Mon Sep 17 00:00:00 2001 From: Nschanche Date: Tue, 27 Aug 2024 17:28:13 -0400 Subject: [PATCH 3/9] renamed functions --- src/lkprf/keplerprf.py | 10 +++++++--- src/lkprf/prfmodel.py | 38 +++++++++++++++++++++++++------------- src/lkprf/tessprf.py | 24 ++++++++++++------------ 3 files changed, 44 insertions(+), 28 deletions(-) diff --git a/src/lkprf/keplerprf.py b/src/lkprf/keplerprf.py index 45131d2..87303b9 100644 --- a/src/lkprf/keplerprf.py +++ b/src/lkprf/keplerprf.py @@ -5,6 +5,7 @@ from .utils import channel_to_module_output, LKPRFWarning from .data import get_kepler_prf_file import warnings +from scipy.interpolate import RectBivariateSpline from .prfmodel import PRF @@ -33,7 +34,7 @@ def _get_prf_data(self): module, output = channel_to_module_output(self.channel) return get_kepler_prf_file(module=module, output=output) - def update_coordinates(self, targets: List[Tuple], shape: Tuple): + def check_coordinates(self, targets: List[Tuple], shape: Tuple): row, column = self._unpack_targets(targets) """Check that coordinates are within bounds, raise warnings otherwise.""" if (np.atleast_1d(column) < 12).any(): @@ -57,12 +58,13 @@ def update_coordinates(self, targets: List[Tuple], shape: Tuple): "`targets` contains collateral pixels: Row(s) > 1044)", LKPRFWarning, ) - self._update_coordinates(targets=targets, shape=shape) return - def _update_coordinates(self, targets: List[Tuple], shape: Tuple): + def _prepare_supersamp_prf(self, targets: List[Tuple], shape: Tuple): row, column = self._unpack_targets(targets) # Set the row and column for the model + + # Create one supersampled PRF for each image, used for all targets in the image row, column = np.atleast_1d(row), np.atleast_1d(column) row = np.min([np.max([row, row**0 * 20], axis=0), row**0 * 1044], axis=0).mean() column = np.min( @@ -92,5 +94,7 @@ def _update_coordinates(self, targets: List[Tuple], shape: Tuple): supersamp_prf /= np.nansum(supersamp_prf) * self.cdelt1p[0] * self.cdelt2p[0] + + # Set up the interpolation function self.interpolate = RectBivariateSpline(self.PRFrow, self.PRFcol, supersamp_prf) return diff --git a/src/lkprf/prfmodel.py b/src/lkprf/prfmodel.py index 42d063f..06b942d 100644 --- a/src/lkprf/prfmodel.py +++ b/src/lkprf/prfmodel.py @@ -4,7 +4,6 @@ from typing import Tuple, List import numpy.typing as npt import numpy as np -from scipy.interpolate import RectBivariateSpline class PRF(ABC): @@ -63,11 +62,13 @@ def _evaluate( Parameters ---------- targets : List of Tuples - Pixel coordinates of the targets + Pixel coordinates of the target(s). origin : Tuple - The origin of the image, combined with shape this sets the extent of the image + The (row, column) origin of the image in pixels. + Combined with shape this sets the extent of the image. shape : Tuple - The shape of the image, combined with the origin this sets the extent of the image + The (N_row, N_col) shape of the image. + Combined with the origin this sets the extent of the image. Returns ------- @@ -75,7 +76,8 @@ def _evaluate( Three dimensional array representing the PRF values parametrized by flux and centroids. Has shape (ntargets, shape[0], shape[1]) """ - self.update_coordinates(targets=targets, shape=shape) + + #self.update_coordinates(targets=targets, shape=shape) target_row, target_column = self._unpack_targets(targets) # Integer extent from the PRF model @@ -83,7 +85,7 @@ def _evaluate( c1, c2 = int(np.floor(self.PRFcol[0])), int(np.ceil(self.PRFcol[-1])) # Position in the PRF model for each source position % 1 delta_row, delta_col = ( - np.arange(r1, r2)[:, None] + 0.5 - np.atleast_1d(target_row) % 1, + np.arange(r1, r2)[:, None] + 0.5 - np.atleast_1d(target_row) % 1, np.arange(c1, c2)[:, None] + 0.5 - np.atleast_1d(target_column) % 1, ) @@ -145,7 +147,8 @@ def evaluate( Three dimensional array representing the PRF values parametrized by flux and centroids. Has shape (ntargets, shape[0], shape[1]) """ - self.update_coordinates(targets=targets, shape=shape) + self.check_coordinates(targets=targets, shape=shape) + self._prepare_supersamp_prf(targets=targets, shape=shape) return self._evaluate(targets=targets, shape=shape, origin=origin, dx=0, dy=0) def gradient( @@ -172,7 +175,8 @@ def gradient( This tuple contains two 3D arrays representing the gradient of the PRF values parametrized by flux and centroids. Returns (gradient in row, gradient in column). Each array has shape (ntargets, shape[0], shape[1]) """ - self.update_coordinates(targets=targets, shape=shape) + self.check_coordinates(targets=targets, shape=shape) + self._prepare_supersamp_prf(targets=targets, shape=shape) deriv_col = self._evaluate( targets=targets, shape=shape, origin=origin, dx=0, dy=1 ) @@ -211,8 +215,8 @@ def _prepare_prf(self): ) PRFdata /= PRFdata.sum(axis=(1, 2))[:, None, None] - PRFcol = np.arange(0, np.shape(PRFdata[0])[1] + 0) - PRFrow = np.arange(0, np.shape(PRFdata[0])[0] + 0) + PRFcol = np.arange(0, np.shape(PRFdata[0])[1]) + PRFrow = np.arange(0, np.shape(PRFdata[0])[0]) # Shifts pixels so it is in pixel units centered on 0 PRFcol = (PRFcol - np.size(PRFcol) / 2) * cdelt1p[0] @@ -234,10 +238,18 @@ def _prepare_prf(self): @abstractmethod - def update_coordinates(self, targets, shape): - """Method to update the interpolation function + def check_coordinates(self, targets, shape): + """Method to check if selected pxels contain collatoral pixels Wrap this parent method, use the public method to check that e.g. targets are in bounds. - This method should provide the interpolation function + Provide a warning if pixels are out of bounds """ pass + + @abstractmethod + def _prepare_supersamp_prf(self, targets, shape): + """Method to update the interpolation function + + This method sets up the RectBivariateSpline function to interpolate the supersampled PRF + """ + pass \ No newline at end of file diff --git a/src/lkprf/tessprf.py b/src/lkprf/tessprf.py index 0958f2d..567aebb 100644 --- a/src/lkprf/tessprf.py +++ b/src/lkprf/tessprf.py @@ -5,6 +5,7 @@ from .utils import LKPRFWarning from .data import get_tess_prf_file import warnings +from scipy.interpolate import RectBivariateSpline from .prfmodel import PRF @@ -25,7 +26,7 @@ def __repr__(self): def _get_prf_data(self): return get_tess_prf_file(camera=self.camera, ccd=self.ccd) - def update_coordinates(self, targets: List[Tuple], shape: Tuple): + def check_coordinates(self, targets: List[Tuple], shape: Tuple): row, column = self._unpack_targets(targets) """Check that coordinates are within bounds, raise warnings otherwise.""" if (np.atleast_1d(column) < 45).any(): @@ -34,29 +35,26 @@ def update_coordinates(self, targets: List[Tuple], shape: Tuple): LKPRFWarning, ) - if ((np.atleast_1d(column) + shape[1]) > 2092).any(): + if ((np.atleast_1d(column) + shape[1]) >= 2093).any(): warnings.warn( - "`targets` contains collateral pixels: Column(s) > 2093 ", - LKPRFWarning, - ) - if (np.atleast_1d(row) < 0).any(): - warnings.warn( - "`targets` contains collateral pixels: Row(s) < 0", + "`targets` contains collateral pixels: Column(s) >= 2093 ", LKPRFWarning, ) + if ((np.atleast_1d(row) + shape[0]) > 2048).any(): warnings.warn( "`targets` contains collateral pixels: Row(s) > 2048)", LKPRFWarning, ) - self._update_coordinates(targets=targets, shape=shape) + return - def _update_coordinates(self, targets: List[Tuple], shape: Tuple): + def _prepare_supersamp_prf(self, targets: List[Tuple], shape: Tuple): row, column = self._unpack_targets(targets) # Set the row and column for the model. - # Disallows models in the collateral pixels + + # Create one supersampled PRF for each image, used for all targets in the image row, column = np.atleast_1d(row), np.atleast_1d(column) row = np.min([np.max([row, row**0 * 0], axis=0), row**0 * 2048], axis=0).mean() column = np.min( @@ -70,7 +68,7 @@ def _update_coordinates(self, targets: List[Tuple], shape: Tuple): ref_row = row + 0.5 * rowdim supersamp_prf = np.zeros(self.PRFdata.shape[1:], dtype="float32") - # Find the 4 measurements nearest the desired locations + # Find the 4 measured PRF models nearest the target location prf_weights = [ np.sqrt( (ref_column - self.crval1p[i]) ** 2 + (ref_row - self.crval2p[i]) ** 2) @@ -85,5 +83,7 @@ def _update_coordinates(self, targets: List[Tuple], shape: Tuple): supersamp_prf /= np.nansum(supersamp_prf) * self.cdelt1p[0] * self.cdelt2p[0] + + # Set up the interpolation function self.interpolate = RectBivariateSpline(self.PRFrow, self.PRFcol, supersamp_prf) return From 160ef0de5558f7a43eb8d68cb3dc7b58da9666bb Mon Sep 17 00:00:00 2001 From: Nschanche Date: Thu, 29 Aug 2024 16:52:33 -0400 Subject: [PATCH 4/9] wording update --- docs/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/README.md b/docs/README.md index 80ad89a..e1a6f23 100644 --- a/docs/README.md +++ b/docs/README.md @@ -35,7 +35,7 @@ or ```python import lkprf -prf = lkprf.TESSPRF(camera=1, ccd=1) +prf = lkprf.TESSPRF(camera=1, ccd=1) # Optionally can specify a sector ``` You can then use either the `evaluate` or `gradient` functions to get the estimate of the PRF at a location, as shown below. @@ -44,7 +44,7 @@ You can then use either the `evaluate` or `gradient` functions to get the estima prf.evaluate(targets=[(5, 5)], origin=(0, 0), shape=(11, 11)) ``` -This will return an array with shape `(1, 11, 11)`, which contains an `(11, 11)` image containing one target at location `(row=5, column=5)`. The image origin is at `(row=0, column=0)`. +This will return an array with shape `(1, 11, 11)`, which contains an `(11, 11)` image containing one target at location `(row=5, column=5)`. The image origin is at `(row=0, column=0)`. Note that for Kepler and TESS, an origin of (0,0) contains [collateral](https://heasarc.gsfc.nasa.gov/docs/tess/data-products.html) (non-science) pixels. ```python prf.evaluate(targets=[(5, 5), (9, 9)], origin=(0, 0), shape=(11, 11)) From 44c210e698c333ac9cfaaee1f925c3759258324e Mon Sep 17 00:00:00 2001 From: Nschanche Date: Thu, 12 Sep 2024 09:59:44 -0400 Subject: [PATCH 5/9] Added tutorial notebook --- docs/README.md | 6 +- docs/tutorials/lkprf_TPF_example.ipynb | 642 +++++++++++++++++++++++++ src/lkprf/prfmodel.py | 10 +- 3 files changed, 650 insertions(+), 8 deletions(-) create mode 100644 docs/tutorials/lkprf_TPF_example.ipynb diff --git a/docs/README.md b/docs/README.md index e1a6f23..bdbd6e6 100644 --- a/docs/README.md +++ b/docs/README.md @@ -35,7 +35,7 @@ or ```python import lkprf -prf = lkprf.TESSPRF(camera=1, ccd=1) # Optionally can specify a sector +prf = lkprf.TESSPRF(camera=1, ccd=1) # Optionally specify a sector ``` You can then use either the `evaluate` or `gradient` functions to get the estimate of the PRF at a location, as shown below. @@ -44,7 +44,7 @@ You can then use either the `evaluate` or `gradient` functions to get the estima prf.evaluate(targets=[(5, 5)], origin=(0, 0), shape=(11, 11)) ``` -This will return an array with shape `(1, 11, 11)`, which contains an `(11, 11)` image containing one target at location `(row=5, column=5)`. The image origin is at `(row=0, column=0)`. Note that for Kepler and TESS, an origin of (0,0) contains [collateral](https://heasarc.gsfc.nasa.gov/docs/tess/data-products.html) (non-science) pixels. +This will return an array with shape `(1, 11, 11)`, which contains an `(11, 11)` image containing one target at location `(row=5, column=5)`. The image origin is at `(row=0, column=0)`. Note that for Kepler and TESS, an origin of (0,0) contains [collateral](https://heasarc.gsfc.nasa.gov/docs/tess/data-products.html) (non-science) pixels; however, lkprf will still generate the expected model at this location. ```python prf.evaluate(targets=[(5, 5), (9, 9)], origin=(0, 0), shape=(11, 11)) @@ -82,6 +82,8 @@ Below is an example image for the TES PRF, for Camera 1, CCD 1, with a source at ![TESS PRF Example](images/TESS.png) +For more examples of how to use lkprf to generate TPF-like PRF models, see this [tutorial](tutorials/lkprf_TPF_example.ipynb). + ## Problems with downloading PRF data To use `lkPRF` you will have to be connected to the internet to download the relevant files. After you download the data for a given Camera/CCD/Channel these files will be stored within the package, so you will be able to use the data offline. diff --git a/docs/tutorials/lkprf_TPF_example.ipynb b/docs/tutorials/lkprf_TPF_example.ipynb new file mode 100644 index 0000000..620eb1a --- /dev/null +++ b/docs/tutorials/lkprf_TPF_example.ipynb @@ -0,0 +1,642 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c3ed9395-bec2-43ad-88e3-5fb45cf4b08f", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "c1c6ff8c-c59d-4431-b8de-a2dddb3905a9", + "metadata": {}, + "source": [ + "# lkprf Basics" + ] + }, + { + "cell_type": "markdown", + "id": "b644ac72-dddb-4e13-a56f-2673d28bc2fa", + "metadata": {}, + "source": [ + "Light from sources does not fall cleanly on a single pixel. Instead, the light is distributed across an area of the detector, known as the Point Spread Function (PSF). The PSF is not constant and varies as a function of spacecraft motion, jitter, location on the detector plane, and detector response. Both [Kepler](https://archive.stsci.edu/missions/kepler/commissioning_prfs/) and [TESS](https://archive.stsci.edu/missions/tess/models/prf_fitsfiles/) have measured the PSF of discrete locations on the CCD in order to model the observed light contribution of a source across the pixels (the Pixel Response Function or PRF). To learn more about the PRF measurements, you can refer to [this paper](https://arxiv.org/pdf/1001.0331).\n", + "\n", + "\n", + "In this notebook, we demonstrate how to use lkprf to generate a PRF model based on these engineering files. We will create our PRF for a source observed in a real Target Pixel File (TPF). " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "64193281-f976-4188-91d6-15aa48486a9c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import lkprf\n", + "import lksearch\n", + "import numpy as np\n", + "from astropy.wcs import WCS\n", + "from astropy.io import fits" + ] + }, + { + "cell_type": "markdown", + "id": "5d94623e-89ef-49dd-ba90-a3dad01aeb67", + "metadata": {}, + "source": [ + "In this notebook, we will try to recreate the PRF of a real observed star. To do this, we will start by getting the Target Pixel File for a relatively isolated (low contamination) star. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "be4e36d3-9995-43b8-ba67-2472bf00bb06", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "TESSSearch object containing 14 data products \n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
target_namepipelinemissionsectorexptimedistanceyeardescription
0298896336SPOCTESS26120.00.02020Target pixel files
1298896336SPOCTESS4020.00.02021Target pixel files
2298896336SPOCTESS40120.00.02021Target pixel files
3298896336SPOCTESS4120.00.02021Target pixel files
4298896336SPOCTESS41120.00.02021Target pixel files
...........................
9298896336SPOCTESS5520.00.02022Target pixel files
10298896336SPOCTESS55120.00.02022Target pixel files
11298896336SPOCTESS74120.00.02024Target pixel files
12298896336SPOCTESS75120.00.02024Target pixel files
13298896336SPOCTESS80120.00.02024Target pixel files
\n", + "

14 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + "TESSSearch object containing 14 data products \n", + " target_name pipeline mission sector exptime distance year \\\n", + "0 298896336 SPOC TESS 26 120.0 0.0 2020 \n", + "1 298896336 SPOC TESS 40 20.0 0.0 2021 \n", + "2 298896336 SPOC TESS 40 120.0 0.0 2021 \n", + "3 298896336 SPOC TESS 41 20.0 0.0 2021 \n", + "4 298896336 SPOC TESS 41 120.0 0.0 2021 \n", + ".. ... ... ... ... ... ... ... \n", + "9 298896336 SPOC TESS 55 20.0 0.0 2022 \n", + "10 298896336 SPOC TESS 55 120.0 0.0 2022 \n", + "11 298896336 SPOC TESS 74 120.0 0.0 2024 \n", + "12 298896336 SPOC TESS 75 120.0 0.0 2024 \n", + "13 298896336 SPOC TESS 80 120.0 0.0 2024 \n", + "\n", + " description \n", + "0 Target pixel files \n", + "1 Target pixel files \n", + "2 Target pixel files \n", + "3 Target pixel files \n", + "4 Target pixel files \n", + ".. ... \n", + "9 Target pixel files \n", + "10 Target pixel files \n", + "11 Target pixel files \n", + "12 Target pixel files \n", + "13 Target pixel files \n", + "\n", + "[14 rows x 8 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Search for TPF data for Kepler 50, a relatively isolated star\n", + "sr = lksearch.TESSSearch('Kepler 50', pipeline='SPOC').cubedata\n", + "sr\n" + ] + }, + { + "cell_type": "markdown", + "id": "291142d8-cfda-4dcc-87d8-87b8a5bb8cee", + "metadata": {}, + "source": [ + "This star has been observed a number of times by TESS. Let's just pick a single sector to model. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "395f57cb-f6fa-4f76-86ff-452d0978ab1c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "pipeline products: 100%|████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:01<00:00, 1.87s/it]\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Local PathStatusMessageURL
0/Users/nthom/.lksearch/cache/mastDownload/TESS...COMPLETENoneNone
\n", + "
" + ], + "text/plain": [ + " Local Path Status Message URL\n", + "0 /Users/nthom/.lksearch/cache/mastDownload/TESS... COMPLETE None None" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fnames = sr[0].download()\n", + "fnames\n" + ] + }, + { + "cell_type": "markdown", + "id": "acc2fe52-f3ef-4bc6-a58d-b93c001b0494", + "metadata": {}, + "source": [ + "Note lksearch will download the data and return a dataframe containing the local file path it is downloaded to. However, it does not read it in to a lightkurve object. We will read it in using the fits file handling package in astropy. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8c1d15fe-c5a5-4350-bcb3-59b73a484f41", + "metadata": {}, + "outputs": [], + "source": [ + "tess_hdulist = fits.open(fnames['Local Path'].values[0])" + ] + }, + { + "cell_type": "markdown", + "id": "209e72fc-053a-48d3-8290-0a68bcc7d498", + "metadata": {}, + "source": [ + "Now that we have our file, we can set up our PRF model. \n", + "To initiate a PRF object, we need to know which camera and CCD (TESS) or channel (Kepler) the target is on. We also can provide the observing Sector for TESS. This is because two sets of PRF engineering models were produced for TESS. Models for early sectors (Sectors 1-3) may optionally want to use the first PRF measurements. By default, the models produced for sectors 4 onwards are used. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4f5efa3b-924e-496d-9bc2-3eeb6870bd6c", + "metadata": {}, + "outputs": [], + "source": [ + "camera = tess_hdulist[0].header['CAMERA']\n", + "ccd = tess_hdulist[0].header['CCD']\n", + "sector = tess_hdulist[0].header['SECTOR'] \n", + "\n", + "\n", + "# initialize the PRF object\n", + "prf_initial = lkprf.TESSPRF(camera=camera, ccd=ccd) #, sector=sector) " + ] + }, + { + "cell_type": "markdown", + "id": "98cc4f73-9386-452a-b750-6eb58079dcaa", + "metadata": {}, + "source": [ + "To produce the model itself, we need three pieces of information: the origin of the cutout (lower left corner), the target object location, and the size of the cutout. These can also be derived from information contained in the TPF. We will use the WCS information contained in the TPF to determine the pixel location of the target. Note that this location is based on the J2000 coordinates, so the location may need to be updated for high proper motion targets. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cd02f187-1d60-4fc4-aaae-392d17cb02bb", + "metadata": {}, + "outputs": [], + "source": [ + "origin_row = tess_hdulist[1].header['2CRV4P'] \n", + "origin_col = tess_hdulist[1].header['1CRV4P'] \n", + "\n", + "\n", + "# get the WCS information\n", + "wcs = WCS(tess_hdulist[2].header)\n", + "# Convert the RA/Dec of the object into pixel coordinates. \n", + "wcs_pix = wcs.all_world2pix(tess_hdulist[0].header['RA_OBJ'] , tess_hdulist[0].header['DEC_OBJ'],0)\n", + "wcs_col = wcs_pix[0]\n", + "wcs_row = wcs_pix[1]\n", + "\n", + "target_col = origin_col + wcs_col\n", + "target_row = origin_row + wcs_row\n", + "\n", + "shape = tess_hdulist[1].data['FLUX'].shape[1:]\n" + ] + }, + { + "cell_type": "markdown", + "id": "6a26cdba-2cd7-42de-82d3-7e1a74364db3", + "metadata": {}, + "source": [ + "Now we have everything we need to create the model. Note the output shape. The first dimension is the number of targets. In this case, we are only modeling a single target, but in practice you may want to model every star contained in the TPF. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a7aeb2c2-0408-4965-a41d-4bbf5eca7cb9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 11, 11)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_prf = prf_initial.evaluate(targets=[(target_row, target_col)], origin=(origin_row, origin_col), shape=shape)\n", + "model_prf.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3bd90ad1-4a9e-4b86-9211-5ec849f05384", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,axs = plt.subplots(1,2,figsize=(8,4))\n", + "\n", + "\n", + "axs[0].imshow(model_prf[0,:,:], origin='lower')\n", + "axs[0].set_title('lkprf model')\n", + "\n", + "# Plot the real data. We randomly select the 100th observation from the TPF data cube\n", + "axs[1].imshow(tess_hdulist[1].data['FLUX'][100,:,:], origin='lower')\n", + "axs[1].set_title('Data')\n", + "\n", + "\n", + "plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "2834c30f-bb2a-42d9-bef7-6648687d162b", + "metadata": {}, + "source": [ + "This looks like a good match! It is clear that the real data does in fact have a few other sources, but overall the modeled PRF matches the observations of the primary star. Let's scale the data a bit so we see the comparison more clearly." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "568686ab-6603-4d67-a51c-96fa1d69e067", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/4003647498.py:4: RuntimeWarning: divide by zero encountered in log10\n", + " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/4003647498.py:4: RuntimeWarning: invalid value encountered in log10\n", + " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/4003647498.py:7: RuntimeWarning: invalid value encountered in log10\n", + " axs[1].imshow(np.log10(tess_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,axs = plt.subplots(1,2,figsize=(8,4))\n", + "\n", + "\n", + "axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "axs[0].set_title('lkprf model')\n", + "\n", + "axs[1].imshow(np.log10(tess_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n", + "axs[1].set_title('Data')\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f436469a-c0ea-4d9c-a92a-adc001985482", + "metadata": {}, + "source": [ + "Great! Now let's check out the same target with Kepler. We follow the same steps as above to initialize our PRF object and evaluate the model at the target location." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9835e700-18ae-4fcb-b4f6-0975f92f2642", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "pipeline products: 100%|████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 2.66it/s]\n", + "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/3836829689.py:30: RuntimeWarning: divide by zero encountered in log10\n", + " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/3836829689.py:30: RuntimeWarning: invalid value encountered in log10\n", + " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/3836829689.py:33: RuntimeWarning: invalid value encountered in log10\n", + " axs[1].imshow(np.log10(kepler_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fnames = lksearch.KeplerSearch('Kepler 50').cubedata[0].download()\n", + "kepler_hdulist = fits.open(fnames['Local Path'].values[0])\n", + "channel = kepler_hdulist[0].header['CHANNEL']\n", + "\n", + "# initialize the PRF object\n", + "prf_initial = lkprf.KeplerPRF(channel=channel) \n", + "\n", + "origin_row = kepler_hdulist[1].header['2CRV4P'] \n", + "origin_col = kepler_hdulist[1].header['1CRV4P'] \n", + "\n", + "\n", + "# get the WCS information\n", + "wcs = WCS(kepler_hdulist[2].header)\n", + "# Convert the RA/Dec of the object into pixel coordinates. \n", + "wcs_pix = wcs.all_world2pix(kepler_hdulist[0].header['RA_OBJ'] , kepler_hdulist[0].header['DEC_OBJ'],0)\n", + "wcs_col = wcs_pix[0]\n", + "wcs_row = wcs_pix[1]\n", + "\n", + "target_col = origin_col + wcs_col\n", + "target_row = origin_row + wcs_row\n", + "\n", + "shape = kepler_hdulist[1].data['FLUX'].shape[1:]\n", + "\n", + "\n", + "# Evaluate the model at our target position\n", + "model_prf = prf_initial.evaluate(targets=[(target_row, target_col)], origin=(origin_row, origin_col), shape=shape)\n", + "\n", + "\n", + "\n", + "# Plot the results\n", + "fig,axs = plt.subplots(1,2,figsize=(8,4))\n", + "\n", + "axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "axs[0].set_title('lkprf model')\n", + "\n", + "axs[1].imshow(np.log10(kepler_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n", + "axs[1].set_title('Data')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "04247d41-8df7-47ee-a9f3-b3e05f0cae94", + "metadata": {}, + "source": [ + "Excellent! This is a good match to the Kepler observations. \n", + "\n", + "While the shape of the PRF looks correct, it is important to remember that the PRF model contains the relative contribution of the pixels and not the flux-weighted values that we see in the observations (try summing the PRF model and the data above to see this). \n", + "\n", + "In order to combine PRF models for a field of stars to recreate a full TPF (or create your own synthetic TPF), you would want to multiply the PRF by the flux for each target in the field. But this is another topic for another tutorial!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/lkprf/prfmodel.py b/src/lkprf/prfmodel.py index 06b942d..11a5500 100644 --- a/src/lkprf/prfmodel.py +++ b/src/lkprf/prfmodel.py @@ -85,8 +85,8 @@ def _evaluate( c1, c2 = int(np.floor(self.PRFcol[0])), int(np.ceil(self.PRFcol[-1])) # Position in the PRF model for each source position % 1 delta_row, delta_col = ( - np.arange(r1, r2)[:, None] + 0.5 - np.atleast_1d(target_row) % 1, - np.arange(c1, c2)[:, None] + 0.5 - np.atleast_1d(target_column) % 1, + np.arange(r1, r2)[:, None] - np.atleast_1d(target_row) % 1, + np.arange(c1, c2)[:, None] - np.atleast_1d(target_column) % 1, ) # prf model for each source, downsampled to pixel grid @@ -215,15 +215,13 @@ def _prepare_prf(self): ) PRFdata /= PRFdata.sum(axis=(1, 2))[:, None, None] - PRFcol = np.arange(0, np.shape(PRFdata[0])[1]) - PRFrow = np.arange(0, np.shape(PRFdata[0])[0]) + PRFcol = np.arange(0.5, np.shape(PRFdata[0])[1] + 0.5) + PRFrow = np.arange(0.5, np.shape(PRFdata[0])[0] + 0.5) # Shifts pixels so it is in pixel units centered on 0 PRFcol = (PRFcol - np.size(PRFcol) / 2) * cdelt1p[0] PRFrow = (PRFrow - np.size(PRFrow) / 2) * cdelt2p[0] - PRFcol += 0.5 - PRFrow += 0.5 ( self.PRFrow, From 212ea4a6c2f2aa6630e7ab651aeac53650c9ef63 Mon Sep 17 00:00:00 2001 From: Nschanche Date: Wed, 18 Sep 2024 11:49:01 -0400 Subject: [PATCH 6/9] Improved tutorial format --- docs/tutorials/lkprf_TPF_example.ipynb | 175 +++++++++++++++---------- 1 file changed, 109 insertions(+), 66 deletions(-) diff --git a/docs/tutorials/lkprf_TPF_example.ipynb b/docs/tutorials/lkprf_TPF_example.ipynb index 620eb1a..e600a58 100644 --- a/docs/tutorials/lkprf_TPF_example.ipynb +++ b/docs/tutorials/lkprf_TPF_example.ipynb @@ -15,7 +15,10 @@ "id": "c1c6ff8c-c59d-4431-b8de-a2dddb3905a9", "metadata": {}, "source": [ - "# lkprf Basics" + "# lkprf Basics\n", + "\n", + "## Author\n", + "Nicole Schanche - TESS Science Support Center" ] }, { @@ -23,12 +26,24 @@ "id": "b644ac72-dddb-4e13-a56f-2673d28bc2fa", "metadata": {}, "source": [ + "## Tutorial Goals\n", + "\n", "Light from sources does not fall cleanly on a single pixel. Instead, the light is distributed across an area of the detector, known as the Point Spread Function (PSF). The PSF is not constant and varies as a function of spacecraft motion, jitter, location on the detector plane, and detector response. Both [Kepler](https://archive.stsci.edu/missions/kepler/commissioning_prfs/) and [TESS](https://archive.stsci.edu/missions/tess/models/prf_fitsfiles/) have measured the PSF of discrete locations on the CCD in order to model the observed light contribution of a source across the pixels (the Pixel Response Function or PRF). To learn more about the PRF measurements, you can refer to [this paper](https://arxiv.org/pdf/1001.0331).\n", "\n", "\n", "In this notebook, we demonstrate how to use lkprf to generate a PRF model based on these engineering files. We will create our PRF for a source observed in a real Target Pixel File (TPF). " ] }, + { + "cell_type": "markdown", + "id": "5660aa20-fad3-4785-b466-57dc107babd4", + "metadata": {}, + "source": [ + "## Imports\n", + "\n", + "This tutorial makes use of a number of packages including [matplotlib](https://matplotlib.org/), [numpy](https://numpy.org/), and [astropy](https://www.astropy.org/). In addition it utilized the [lksearch](https://github.com/lightkurve/lksearch) package, which is designed to search for and download data from the TESS and Kepler/K2 missions. " + ] + }, { "cell_type": "code", "execution_count": 2, @@ -49,12 +64,14 @@ "id": "5d94623e-89ef-49dd-ba90-a3dad01aeb67", "metadata": {}, "source": [ - "In this notebook, we will try to recreate the PRF of a real observed star. To do this, we will start by getting the Target Pixel File for a relatively isolated (low contamination) star. " + "## Step 1: Get a TPF\n", + "\n", + "In this notebook, we will try to recreate the PRF of a real observed star. To do this, we will start by getting the Target Pixel File for a relatively isolated (low contamination) star. We limit the search using `pipeline='SPOC'`, which restricts the search results to files produced by the mission pipeline. As we want to model a PRF, we further restrict data to target pixel files, known generically as 'cubedata' in the lksearch package. For more information on formulating searches, you can check out [this tutorial](https://github.com/lightkurve/lksearch/blob/main/docs/tutorials/Example_searches.ipynb). " ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "be4e36d3-9995-43b8-ba67-2472bf00bb06", "metadata": {}, "outputs": [ @@ -248,13 +265,12 @@ "[14 rows x 8 columns]" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Search for TPF data for Kepler 50, a relatively isolated star\n", "sr = lksearch.TESSSearch('Kepler 50', pipeline='SPOC').cubedata\n", "sr\n" ] @@ -264,12 +280,14 @@ "id": "291142d8-cfda-4dcc-87d8-87b8a5bb8cee", "metadata": {}, "source": [ - "This star has been observed a number of times by TESS. Let's just pick a single sector to model. " + "The search result contains a table showing all of the observations of the target for which SPOC data is available to download. The exptime column indicates the observing cadence by TESS. In this case, the star was in some sectors observed in high cadence (20-second) model. \n", + "\n", + "The model TPF will be different for this target for every observing sector, as the target will fall on different pixels and different camera and CCDs. Let's just pick a single sector to model. In the download command below, we specify the 0th element of the table, corresponding to the 120-second cadence TPF from sector 26. " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "395f57cb-f6fa-4f76-86ff-452d0978ab1c", "metadata": {}, "outputs": [ @@ -277,7 +295,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "pipeline products: 100%|████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:01<00:00, 1.87s/it]\n" + "pipeline products: 100%|██████████████████████████| 1/1 [00:00<00:00, 1.78it/s]\n" ] }, { @@ -324,7 +342,7 @@ "0 /Users/nthom/.lksearch/cache/mastDownload/TESS... COMPLETE None None" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -339,12 +357,12 @@ "id": "acc2fe52-f3ef-4bc6-a58d-b93c001b0494", "metadata": {}, "source": [ - "Note lksearch will download the data and return a dataframe containing the local file path it is downloaded to. However, it does not read it in to a lightkurve object. We will read it in using the fits file handling package in astropy. " + "Note lksearch will download the data and return a dataframe containing the local file path it is downloaded to. However, it does not read it in to a lightkurve object. We will read it in using the fits file handling package in astropy. If you need a refresher on fits file handling, you can see this [astropy tutorial](https://learn.astropy.org/tutorials/FITS-images.html). " ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "8c1d15fe-c5a5-4350-bcb3-59b73a484f41", "metadata": {}, "outputs": [], @@ -357,14 +375,15 @@ "id": "209e72fc-053a-48d3-8290-0a68bcc7d498", "metadata": {}, "source": [ + "## Step 2: Create a PRF model\n", + "\n", "Now that we have our file, we can set up our PRF model. \n", - "To initiate a PRF object, we need to know which camera and CCD (TESS) or channel (Kepler) the target is on. We also can provide the observing Sector for TESS. This is because two sets of PRF engineering models were produced for TESS. Models for early sectors (Sectors 1-3) may optionally want to use the first PRF measurements. By default, the models produced for sectors 4 onwards are used. \n", - "\n" + "To initiate a PRF object, we need to know which camera and CCD (TESS) or channel (Kepler) the target is on. We also can optionally provide the observing Sector for TESS. This is because two sets of PRF engineering models were produced for TESS. The first models were made during commissioning and are used for the early sectors (Sectors 1-3). The commissioning observations were re-run after Sector 3, and these files can be used for subsequent TESS sectors. If the sector is not specified, the models produced for sectors 4 onwards are used. " ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "4f5efa3b-924e-496d-9bc2-3eeb6870bd6c", "metadata": {}, "outputs": [], @@ -383,12 +402,17 @@ "id": "98cc4f73-9386-452a-b750-6eb58079dcaa", "metadata": {}, "source": [ - "To produce the model itself, we need three pieces of information: the origin of the cutout (lower left corner), the target object location, and the size of the cutout. These can also be derived from information contained in the TPF. We will use the WCS information contained in the TPF to determine the pixel location of the target. Note that this location is based on the J2000 coordinates, so the location may need to be updated for high proper motion targets. " + "To produce the model itself, we need three pieces of information:\n", + "- the origin of the cutout (lower left corner),\n", + "- the target object location\n", + "- the size of the cutout\n", + "\n", + "All of this information can be found in the header information containing in the TPF file. We will use the WCS information contained in the TPF to determine the pixel location of the target. Note that this location is based on the J2000 coordinates, so the location may need to be updated for high proper motion targets. " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "cd02f187-1d60-4fc4-aaae-392d17cb02bb", "metadata": {}, "outputs": [], @@ -404,6 +428,8 @@ "wcs_col = wcs_pix[0]\n", "wcs_row = wcs_pix[1]\n", "\n", + "# The wcs_row and wcs_col values are in realtive pixels for the cutout, not the CCD as a whole.\n", + "# We need to add the origin row and column to find the target pixel location on the CCD\n", "target_col = origin_col + wcs_col\n", "target_row = origin_row + wcs_row\n", "\n", @@ -420,7 +446,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "a7aeb2c2-0408-4965-a41d-4bbf5eca7cb9", "metadata": {}, "outputs": [ @@ -430,7 +456,7 @@ "(1, 11, 11)" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -440,17 +466,27 @@ "model_prf.shape" ] }, + { + "cell_type": "markdown", + "id": "fb83cda3-cdb5-480e-8a39-7fe2937358f0", + "metadata": {}, + "source": [ + "## Step 3: Visualize the PRF model\n", + "\n", + "Great! We've created a model of the TPF. Let's plot the model to see how it looks compared to the TPF data. " + ] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "3bd90ad1-4a9e-4b86-9211-5ec849f05384", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1EAAAFbCAYAAAA0gQTlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABuOUlEQVR4nO3de1hU1f4/8PeADhdhIFQYUAS85F1RUERNTUlQ0vzJMTVKRcPyQKl8j5pl4iXDvCCmJMfyVkmaXczUMETRTLyEcrwleUsoHbQMUJTr7N8fHvZxApU9M3tmgPfrefZzmLXX3mvtOcaHz95rr6UQBEEAERERERER1YiVuTtARERERERUmzCJIiIiIiIikoBJFBERERERkQRMooiIiIiIiCRgEkVERERERCQBkygiIiIiIiIJmEQRERERERFJwCSKiIiIiIhIAiZRREREREREEjCJIh0bN26EQqHAr7/+KpZ5e3vj2WefNVkfPvnkE7Rr1w4NGzaEs7OzydqVKj09HQqFAunp6ZKPre57JiIiIqLagUkUWZTz589jwoQJaNWqFT788EOsXbvW3F0iIqJ6pvJGV+Vma2sLDw8PBAcH4/3338ft27f1Ou/hw4cxb9485OfnG7fDRGRyDczdAaIHpaenQ6vVYuXKlWjdurW5u0NERPXYggUL4OPjg7KyMmg0GqSnp2PatGmIj4/Hjh070KVLF0nnO3z4MObPn48JEyZY9EgLIno8JlFkEYqKitCoUSPcuHEDABhciIjI7IYMGQJ/f3/x8+zZs7Fv3z48++yzGD58OH7++WfY2dmZsYdEZC4czkd62bRpExo0aIAZM2YAAH799VcoFAosW7YMK1asgJeXF+zs7NC/f3+cOXNG59gJEybAwcEBly5dwtChQ+Ho6Ijw8HB4e3sjNjYWANC0aVMoFArMmzfvoX2oPE9OTg6effZZODg4oFmzZkhMTAQAnD59GgMHDkSjRo3g5eWF5OTkKue4fPkyRo0aBRcXF9jb26NXr17YtWtXlXq//fYbRowYgUaNGsHV1RXTp09HSUlJtf06evQoQkJC4OTkBHt7e/Tv3x8//vhjjb5XIiKybAMHDsTbb7+Nq1ev4tNPPwUAnDp1ChMmTEDLli1ha2sLtVqNiRMn4s8//xSPmzdvnhgzfXx8xKGCle/GbtiwAQMHDoSrqytsbGzQoUMHrFmzxuTXR0Q1wySKJFu7di0iIiLwxhtvYOnSpTr7Pv74Y7z//vuIiorC7NmzcebMGQwcOBB5eXk69crLyxEcHAxXV1csW7YMYWFhSEhIwP/7f/8PALBmzRp88sknGDly5CP7UlFRgSFDhsDT0xNLliyBt7c3oqOjsXHjRoSEhMDf3x/vvfceHB0dMW7cOFy5ckU8Ni8vD71798aePXvwz3/+E4sWLUJxcTGGDx+Or7/+Wqx37949DBo0CHv27EF0dDTeeust/PDDD5g5c2aV/uzbtw/9+vVDYWEhYmNj8e677yI/Px8DBw7EsWPHJH/XRERkeV566SUAwPfffw8ASE1NxeXLlxEREYFVq1ZhzJgx2LJlC4YOHQpBEAAAI0eOxNixYwEAK1aswCeffIJPPvkETZs2BXA/7nl5eeHNN9/E8uXL4enpiX/+85/ijUEiS7RmzRp06dIFKpUKKpUKgYGB+O6778T9xcXFiIqKQuPGjeHg4ICwsLAqfxPm5OQgNDQU9vb2cHV1xYwZM1BeXq5TJz09Hd27d4eNjQ1at26NjRs3muLyHk0gesCGDRsEAMKVK1fEMi8vLyE0NFQQBEFYuXKloFAohIULF+ocd+XKFQGAYGdnJ/z2229i+dGjRwUAwvTp08Wy8ePHCwCEN954o0r7sbGxAgDh5s2bj+1r5Xneffddseyvv/4S7OzsBIVCIWzZskUsP3/+vABAiI2NFcumTZsmABB++OEHsez27duCj4+P4O3tLVRUVAiCIAgJCQkCAOHzzz8X6xUVFQmtW7cWAAj79+8XBEEQtFqt0KZNGyE4OFjQarVi3bt37wo+Pj7CM888I5ZV9z0TEZFlqPwdffz48YfWcXJyErp16yYIwv3f83/32WefCQCEgwcPimVLly596O/+6s4RHBwstGzZUo8rIDKNHTt2CLt27RJ++eUXITs7W3jzzTeFhg0bCmfOnBEEQRBeffVVwdPTU0hLSxN++uknoVevXkLv3r3F48vLy4VOnToJQUFBwsmTJ4Xdu3cLTZo0EWbPni3WuXz5smBvby/ExMQI586dE1atWiVYW1sLKSkpJr/eB/GdKKqxJUuWYNasWViyZIk4JOHvRowYgWbNmomfe/bsiYCAAOzevRvx8fE6dadMmWKUfr388sviz87Ozmjbti0uXryI559/Xixv27YtnJ2dcfnyZbFs9+7d6NmzJ/r27SuWOTg4YPLkyZg9ezbOnTuHTp06Yffu3XB3d8c//vEPsZ69vT0mT56s8zQqKysLFy5cwJw5c3SGcADAoEGD8Mknn0Cr1cLKig+A65Li4mKUlpbqdaxSqYStra2Re0REpuDg4CDO0vfge1HFxcW4c+cOevXqBQA4ceIEnnrqqcee78FzFBQUoKysDP3798eePXtQUFAAJycnI18B1WWGxCZBEKBQKHTKbGxsYGNjU6XusGHDdD4vWrQIa9aswZEjR9C8eXOsW7cOycnJGDhwIID7w1bbt2+PI0eOoFevXvj+++9x7tw57N27F25ubvD19cXChQsxa9YszJs3D0qlEklJSfDx8cHy5csBAO3bt8ehQ4ewYsUKBAcH63WNxsAkimrkwIED2LVrF2bNmvXQBAoA2rRpU6XsySefxOeff65T1qBBAzRv3tzgftna2opDISo5OTmhefPmVX4BODk54a+//hI/X716FQEBAVXO2b59e3F/p06dcPXqVbRu3brK+dq2bavz+cKFCwCA8ePHP7S/BQUFeOKJJ2pwZVQbFBcXw8fLAZobFXodr1arceXKFSZSRLXQnTt34OrqCgC4desW5s+fjy1btogTJFUqKCio0fl+/PFHxMbGIiMjA3fv3q1yDiZRVFOGxiYHBwfcuXNHpyw2NvaR76kD91+x2LZtG4qKihAYGIjMzEyUlZUhKChIrNOuXTu0aNECGRkZ6NWrFzIyMtC5c2e4ubmJdYKDgzFlyhScPXsW3bp1Q0ZGhs45KutMmzZNr+szFiZRVCMdO3ZEfn4+PvnkE7zyyivw8fEx6Hw2NjZGeSJjbW0tqVz479h0OWi1WgDA0qVL4evrW20dBwcH2don0ystLYXmRgWuZnpD5Sjt33PhbS28/H5FaWkpkyiiWua3335DQUGBuBTH888/j8OHD2PGjBnw9fWFg4MDtFotQkJCxNjwKJcuXcKgQYPQrl07xMfHw9PTE0qlErt378aKFStqdA6iSsaITbm5uVCpVGJ5dU+hKp0+fRqBgYEoLi6Gg4MDvv76a3To0AFZWVlQKpVVZlx2c3ODRqMBAGg0Gp0EqnJ/5b5H1SksLMS9e/fMNkMmkyiqkSZNmuCLL75A3759MWjQIBw6dAgeHh5V6lU+jXnQL7/8Am9vbxP0UhovLy9kZ2dXKT9//ry4v/J/z5w5U+Xx9t+PbdWqFQBApVJVuWNCdZuDowIOjorHV3yAFtLqV0pMTMTSpUuh0WjQtWtXrFq1Cj179qy27ocffoiPP/5YnCHTz88P7777rk59QRAQGxuLDz/8EPn5+ejTpw/WrFmj81T51q1beO211/Dtt9/CysoKYWFhWLlyJW8KUL31ySefALh/N/yvv/5CWloa5s+fj7lz54p1qouHfx/RUOnbb79FSUkJduzYgRYtWojl+/fvN3LPqT4xJDZVThRRE23btkVWVhYKCgrwxRdfYPz48Thw4IDk/tY2fDmDaqx58+bYu3cv7t27h2eeeabKez8AsH37dvz+++/i52PHjuHo0aMYMmSIKbtaI0OHDsWxY8eQkZEhlhUVFWHt2rXw9vZGhw4dxHrXrl3DF198Ida7e/cu1q5dq3M+Pz8/tGrVCsuWLavyGBwAbt68KdOVkLlVCFq9Nqm2bt2KmJgYxMbG4sSJE+jatSuCg4OrDB+qlJ6ejrFjx2L//v3IyMiAp6cnBg8erPPf6JIlS/D+++8jKSkJR48eRaNGjRAcHIzi4mKxTnh4OM6ePYvU1FTs3LkTBw8exOTJk6V/UUR1wL59+7Bw4UL4+PggPDxcHPnw95EOCQkJVY5t1KgRACA/P1+nvLpzFBQUYMOGDUbsOdU3popNSqUSrVu3hp+fH+Li4tC1a1esXLkSarUapaWlVf695+XlQa1WA7g/rP3vs/VVfn5cHZVKZdZ12vgkiiRp3bo1vv/+ewwYMADBwcHYt2+fzp2K1q1bo2/fvpgyZQpKSkqQkJCAxo0bVzsduLm98cYb+OyzzzBkyBC8/vrrcHFxwaZNm3DlyhV8+eWX4nDDyMhIrF69GuPGjUNmZibc3d3xySefwN7eXud8VlZW+OijjzBkyBB07NgRERERaNasGX7//Xfs378fKpUK3377rTkulWSmhQAtpA0VraxfWFioU/6wl3cBID4+HpGRkYiIiAAAJCUlYdeuXVi/fj3eeOONKvU3b96s8/mjjz7Cl19+ibS0NIwbNw6CICAhIQFz5szBc889B+D+MgVubm7Yvn07xowZg59//hkpKSk4fvy4uOjoqlWrMHToUCxbtqzaJ9JEdcV3332H8+fPo7y8HHl5edi3bx9SU1Ph5eWFHTt2wNbWFra2tujXrx+WLFmCsrIyNGvWDN9//73OkhqV/Pz8AABvvfUWxowZg4YNG2LYsGEYPHgwlEolhg0bhldeeQV37tzBhx9+CFdXV1y/ft3Ul011hCGxyaB2tVqUlJTAz88PDRs2RFpaGsLCwgDcH8WTk5ODwMBAAEBgYCAWLVqEGzduiO8YpqamQqVSiTezAwMDsXv3bp02UlNTxXOYC5Mokqxz58747rvvEBQUhGHDhiElJUXcN27cOFhZWSEhIQE3btxAz549sXr1ari7u5uxx9Vzc3PD4cOHMWvWLKxatQrFxcXo0qULvv32W4SGhor17O3tkZaWhtdeew2rVq2Cvb09wsPDMWTIEISEhOicc8CAAcjIyMDChQuxevVq3LlzB2q1GgEBAXjllVdMfYlkIlpoIfXeXeURnp6eOuUPe3m3tLQUmZmZmD17tlhmZWWFoKAgnaepj3L37l2UlZXBxcUFAHDlyhVoNBqd4adOTk4ICAhARkYGxowZg4yMDDg7O4sJFAAEBQXBysoKR48eFdd2I6qLKofnKZVKuLi4oHPnzkhISEBERAQcHR3FesnJyXjttdeQmJgIQRAwePBgfPfdd1VuMvTo0QMLFy5EUlISUlJSoNVqceXKFbRt2xZffPEF5syZg3/9619Qq9WYMmUKmjZtiokTJ5r0mqnuMCQ21dTs2bMxZMgQtGjRArdv30ZycjLS09OxZ88eODk5YdKkSYiJiYGLiwtUKhVee+01BAYGirNXDh48GB06dMBLL72EJUuWQKPRYM6cOYiKihJvKL766qtYvXo1Zs6ciYkTJ2Lfvn34/PPPsWvXLolXZ1wKQc437ane+PXXX+Hj44OlS5fiX//6l7m7Q2QShYWFcHJyQu75Znq9vOvZ7vdqX96t7knUtWvX0KxZMxw+fFjn7tvMmTNx4MABHD169LFt/vOf/8SePXtw9uxZ2Nra4vDhw+jTpw+uXbumc6Pj+eefh0KhwNatW/Huu+9i06ZNVd4BdHV1xfz58422VAERERmHMWJTQUFBjd6JmjRpEtLS0nD9+nU4OTmhS5cumDVrFp555hkA92cK/L//+z989tlnKCkpQXBwMD744ANxqB5wfzbkKVOmID09HY0aNcL48eOxePFiNGjwv2c96enpmD59Os6dO4fmzZvj7bffxoQJEyRdm7HxSRQRkRlJeXnXEIsXL8aWLVuQnp7O2QCJiMgo1q1b98j9tra2SExMRGJi4kPreHl5VRmu93cDBgzAyZMn9eqjXDixBBGRgSrHnUvdpGjSpAmsra2rfbn2wTt61Vm2bBkWL16M77//Hl26dBHLK4971DnVanWViSvKy8tx69atx7ZLRETmY4rYVJ8xiSIiMpAWAiokblIDlVKphJ+fH9LS0v7XrlaLtLS0R75cu2TJEixcuBApKSk67zUBgI+PD9Rqtc45CwsLcfToUZ2XfvPz85GZmSnW2bdvH7RabbWLVRMRkWUwRWyqzzicj4zC29tb1oVsiSyZqWZAiomJwfjx4+Hv74+ePXsiISEBRUVF4mx948aNQ7NmzRAXFwcAeO+99zB37lwkJyfD29tbXLjQwcEBDg4OUCgUmDZtGt555x20adMGPj4+ePvtt+Hh4YERI0YAANq3b4+QkBBERkYiKSkJZWVliI6OxpgxYzgzHxGRBTPX7Hz1BZMoIiIDVQgCKiTeRJBaHwBGjx6NmzdvYu7cudBoNPD19UVKSoq4kntOTo44NT8ArFmzBqWlpfjHP/6hc54HZwCcOXMmioqKMHnyZOTn56Nv375ISUnReW9q8+bNiI6OxqBBg8TFdt9//33J/SciItMxVWyqryxudj6tVotr167B0dHxoSt7ExEZQhAE3L59Gx4eHjpJh1SVMyCd/9kNjhJnQLp9W4t27fNqPAMSmRdjExHJjbGpdrG4J1HXrl2rsm4KEZEccnNz0bx5c3N3g2oBxiYiMhXGptrB4pKoysXr+mIoGqChmXtDRHVROcpwCLt1Fss0ROULuVKPodqj8t9KP5v/hwYKeWOTwt5e1vMDgFBWJnsbACAUl8rfRrlprgWWNXCHTEzRQP4/mcuFMvxQsYOxqZawuCSqcphEAzSUPVARUT313xhhrGFZFcL9TeoxVHuIsUnREA0USnnbspL3/AAgmGhIoqCQ/x+6YLLRlfyPtj5TKEz3JzNjU+1gcUkUEVFto/3vJvUYIiIiuTA2yYtJFBGRgbRQoALS7hxqJdYnIiKSgrFJXkyiiIgMpBXub1KPISIikgtjk7z0nz+RiIiIiIioHuKTKCIiA1XoMWRCan0iIiIpGJvkxSSKiMhADFRERGRpGJvkxSSKiMhAWkEBrcR5lqXWJyIikoKxSV6S34k6ePAghg0bBg8PDygUCmzfvl1nvyAImDt3Ltzd3WFnZ4egoCBcuHDBWP0lIrI4lXf7pG5kHIxLRERVMTbJS3ISVVRUhK5duyIxMbHa/UuWLMH777+PpKQkHD16FI0aNUJwcDCKi4sN7iwRkSWqgJVeGxkH4xIRUVWMTfKSPJxvyJAhGDJkSLX7BEFAQkIC5syZg+eeew4A8PHHH8PNzQ3bt2/HmDFjqhxTUlKCkpIS8XNhYaHULhERUT1m7LgEMDYREdGjGTXdvHLlCjQaDYKCgsQyJycnBAQEICMjo9pj4uLi4OTkJG6enp7G7BIRkeyE/447l7IJHHduEvrEJYCxiYhqP8YmeRk1idJoNAAANzc3nXI3Nzdx39/Nnj0bBQUF4pabm2vMLhERyY7jzi2XPnEJYGwiotqPsUleZp+dz8bGBjY2NubuBhGR3ioEK1QI0u5JVXBVeIvG2EREtR1jk7yM+iRKrVYDAPLy8nTK8/LyxH1ERHWNFgpoYSVx490+U2BcIqL6irFJXkZNonx8fKBWq5GWliaWFRYW4ujRowgMDDRmU0REFoNDJiwX4xIR1VeMTfKSPJzvzp07uHjxovj5ypUryMrKgouLC1q0aIFp06bhnXfeQZs2beDj44O3334bHh4eGDFihDH7TUREBIBxiYiITE9yEvXTTz/h6aefFj/HxMQAAMaPH4+NGzdi5syZKCoqwuTJk5Gfn4++ffsiJSUFtra2xus1EZEF0W/cOQeeGwvjEhFRVYxN8pKcRA0YMADCI75ghUKBBQsWYMGCBQZ1jIiotrg/7lzaEAiOOzcexiUioqoYm+Rl9tn5iIhqO60eq7xrwbt9REQkH8YmeTGJIiIyEIdMEBGRpWFskheTKCIiA1VODSvtGAYqIiKSD2OTvIw6xTkREREREVFdxydRREQGqhAUqBCkvYwrtT4REZEUjE3yYhJFRGSgCj1e3q3gkIlaycrJCVZWSlnbKO7QXNbzA4Dt5ZuytwEAFdfz5G9EYapBNVoTtWMCfO9FMkEr/3f2qFlG9cHYJC8O5yMiMpBWsNJr00diYiK8vb1ha2uLgIAAHDt27KF1z549i7CwMHh7e0OhUCAhIaFKncp9f9+ioqLEOgMGDKiy/9VXX9Wr/0REZBqmjE31Eb8pIiIDVd7tk7pJtXXrVsTExCA2NhYnTpxA165dERwcjBs3blRb/+7du2jZsiUWL14MtVpdbZ3jx4/j+vXr4paamgoAGDVqlE69yMhInXpLliyR3H8iIjIdU8Wm+orD+YiIDKSF9HHklQODCgsLdcptbGxgY2NT7THx8fGIjIxEREQEACApKQm7du3C+vXr8cYbb1Sp36NHD/To0QMAqt0PAE2bNtX5vHjxYrRq1Qr9+/fXKbe3t39oIkZERJbHkNhEj8d0k4jIjDw9PeHk5CRucXFx1dYrLS1FZmYmgoKCxDIrKysEBQUhIyPDKH0pLS3Fp59+iokTJ0Kh0A28mzdvRpMmTdCpUyfMnj0bd+/eNUqbREREtRGfRBERGUi/tTju18/NzYVKpRLLH/YU6o8//kBFRQXc3Nx0yt3c3HD+/HmJPa7e9u3bkZ+fjwkTJuiUv/DCC/Dy8oKHhwdOnTqFWbNmITs7G1999ZVR2iUiIuMzJDbR4zGJIiIykH6rwt+vr1KpdJIoc1q3bh2GDBkCDw8PnfLJkyeLP3fu3Bnu7u4YNGgQLl26hFatWpm6m0REVAOGxCZ6PCZRREQG0kIBLaSOO5dWv0mTJrC2tkZenu6U0Xl5eUZ5V+nq1avYu3dvjZ4uBQQEAAAuXrzIJIqIyEKZIjbVZ0w3iYgMVHm3T+omhVKphJ+fH9LS0sQyrVaLtLQ0BAYGGnwNGzZsgKurK0JDQx9bNysrCwDg7u5ucLtERCQPU8Sm+ozfFBGRgUw1jWxMTAw+/PBDbNq0CT///DOmTJmCoqIicba+cePGYfbs2WL90tJSZGVlISsrC6Wlpfj999+RlZWFixcv6pxXq9Viw4YNGD9+PBo00B2gcOnSJSxcuBCZmZn49ddfsWPHDowbNw79+vVDly5d9Pi2iIjIFEwRm+Li4tCjRw84OjrC1dUVI0aMQHZ2tk6dmqw1mJOTg9DQUNjb28PV1RUzZsxAeXm5Tp309HR0794dNjY2aN26NTZu3KjX92IsHM5HRFRLjB49Gjdv3sTcuXOh0Wjg6+uLlJQUcbKJnJwcWFn9LwBeu3YN3bp1Ez8vW7YMy5YtQ//+/ZGeni6W7927Fzk5OZg4cWKVNpVKJfbu3YuEhAQUFRXB09MTYWFhmDNnjnwXSkREtcKBAwcQFRWFHj16oLy8HG+++SYGDx6Mc+fOoVGjRmK9yMhILFiwQPxsb28v/lxRUYHQ0FCo1WocPnwY169fx7hx49CwYUO8++67AIArV64gNDQUr776KjZv3oy0tDS8/PLLcHd3R3BwsOku+AFMooiIDKQVFNBKXYtDYv1K0dHRiI6Ornbfg4kRAHh7e0MQhMeec/DgwQ+t5+npiQMHDkjuJxERmZchsammaximpKTofN64cSNcXV2RmZmJfv36ieWPWmvw+++/x7lz57B37164ubnB19cXCxcuxKxZszBv3jwolUokJSXBx8cHy5cvBwC0b98ehw4dwooVK8yWRHE4HxGRgbR6DJfgNLJERCQnQ2JTTdcw/LuCggIAgIuLi075o9YazMjIQOfOnXWW8AgODkZhYSHOnj0r1nlwncTKOsZaJ1EffBJFRGQgrWAFrcSXcaXWJyIiksKQ2FTTNQx1jtVqMW3aNPTp0wedOnUSyx+31qBGo6l2DcTKfY+qU1hYiHv37sHOzk7SdRoDkygiIgNVQIEKidPCSq1PREQkhSGxSZ81DKOionDmzBkcOnRIp7yurjXIW6FERERERKS36Oho7Ny5E/v370fz5s0fWffBtQYBQK1WV7sGYuW+R9VRqVRmeQoFMIkiIjJY5ZAJqRsREZFcTBGbBEFAdHQ0vv76a+zbtw8+Pj6PPebvaw0GBgbi9OnTuHHjhlgnNTUVKpUKHTp0EOs8uE5iZR1jrJOoLw7nIyIyUAWkD8+rkKcrREREAEwTm6KiopCcnIxvvvkGjo6O4jtMTk5OsLOzw6VLl5CcnIyhQ4eicePGOHXqFKZPn66z1uDgwYPRoUMHvPTSS1iyZAk0Gg3mzJmDqKgo8V2sV199FatXr8bMmTMxceJE7Nu3D59//jl27dolscfGwySKiMhAnFiCiIgsjSli05o1awDcX1D3QRs2bMCECRNqtNagtbU1du7ciSlTpiAwMBCNGjXC+PHjddaV8vHxwa5duzB9+nSsXLkSzZs3x0cffWS26c0BJlFERAarEKxQITHwSK1PREQkhSli0+PWIqzpWoNeXl7YvXv3I+sMGDAAJ0+elNQ/OTGJIiIykAAFtBKHTAicnY+IiGTE2CQv3golIiIiIiKSgE+iiIgMxOF8RERkaRib5MUkiojIQFpBAa0gbQiE1PpERERSMDbJi0kUEZGBKmCFComjo6XWJyIikoKxSV5MoqjmFHXs7sRjZpQhqine7SOqnsIEccNkv8kVpvnjUmFlgu9Ma6JvTdCaqB0TXI8prsXIbTA2yYtJFBGRgbSwglbi3Tup9YmIiKRgbJIXvykiIiIiIiIJ+CSKiMhAFYICFRKHQEitT0REJAVjk7yYRBERGYjjzomIyNIwNsmLSRQRkYEEwQpaiWtrCFyLg4iIZMTYJC8mUUREBqqAAhWQOGRCYn0iIiIpGJvkxSSKiMhAWkH6EAhTzTBMRET1E2OTvPjMjoiIiIiISAI+iSIiMpBWj3HnUusTERFJwdgkL6N/UxUVFXj77bfh4+MDOzs7tGrVCgsXLoRgitWkiYjMQAuFXhuZBuMSEdVHjE3yMvqTqPfeew9r1qzBpk2b0LFjR/z000+IiIiAk5MTXn/9dWM3R0RkdlyLw7IxLhFRfcTYJC+jJ1GHDx/Gc889h9DQUACAt7c3PvvsMxw7dszYTRERWQQOmbBsjEtEVB8xNsnL6N9U7969kZaWhl9++QUA8J///AeHDh3CkCFDqq1fUlKCwsJCnY2IqDbRQiEualjjTc8hE4mJifD29oatrS0CAgIemQicPXsWYWFh8Pb2hkKhQEJCQpU68+bNg0Kh0NnatWunU6e4uBhRUVFo3LgxHBwcEBYWhry8PL36bw5S4xLA2EREtZ8pY1N9ZPQk6o033sCYMWPQrl07NGzYEN26dcO0adMQHh5ebf24uDg4OTmJm6enp7G7RERUJ2zduhUxMTGIjY3FiRMn0LVrVwQHB+PGjRvV1r979y5atmyJxYsXQ61WP/S8HTt2xPXr18Xt0KFDOvunT5+Ob7/9Ftu2bcOBAwdw7do1jBw50qjXJiepcQlgbCIiokczehL1+eefY/PmzUhOTsaJEyewadMmLFu2DJs2baq2/uzZs1FQUCBuubm5xu4SEZGsBD1e3BX0uNsXHx+PyMhIREREoEOHDkhKSoK9vT3Wr19fbf0ePXpg6dKlGDNmDGxsbB563gYNGkCtVotbkyZNxH0FBQVYt24d4uPjMXDgQPj5+WHDhg04fPgwjhw5IvkazEFqXAIYm4io9jNVbKqvjP5O1IwZM8S7fgDQuXNnXL16FXFxcRg/fnyV+jY2No8M7kRElq5yGITUYwBUGSb2sN+JpaWlyMzMxOzZs8UyKysrBAUFISMjQ49e/8+FCxfg4eEBW1tbBAYGIi4uDi1atAAAZGZmoqysDEFBQWL9du3aoUWLFsjIyECvXr0MatsUpMYlgLGJiGo/Q2ITPZ7Rn0TdvXsXVla6p7W2toZWqzV2U0REFqHy5V2pGwB4enrqDBuLi4urto0//vgDFRUVcHNz0yl3c3ODRqPRu+8BAQHYuHEjUlJSsGbNGly5cgVPPfUUbt++DQDQaDRQKpVwdnY2arumxLhERPWRIbGJHs/oT6KGDRuGRYsWoUWLFujYsSNOnjyJ+Ph4TJw40dhNERFZBEPu9uXm5kKlUonlpn768eDkCl26dEFAQAC8vLzw+eefY9KkSSbti1wYl4ioPuKTKHkZPYlatWoV3n77bfzzn//EjRs34OHhgVdeeQVz5841dlNERBZBnwUKK+urVCqdJOphmjRpAmtr6yqz4uXl5T1y0gipnJ2d8eSTT+LixYsAALVajdLSUuTn5+s8jTJ2u3JiXCKi+siQ2ESPZ/Rndo6OjkhISMDVq1dx7949XLp0Ce+88w6USqWxmyIiqjeUSiX8/PyQlpYmlmm1WqSlpSEwMNBo7dy5cweXLl2Cu7s7AMDPzw8NGzbUaTc7Oxs5OTlGbVdOjEtERGRsRn8SRURU35hqyERMTAzGjx8Pf39/9OzZEwkJCSgqKkJERAQAYNy4cWjWrJn4XlVpaSnOnTsn/vz7778jKysLDg4OaN26NQDgX//6F4YNGwYvLy9cu3YNsbGxsLa2xtixYwEATk5OmDRpEmJiYuDi4gKVSoXXXnsNgYGBtWJSCSKi+orD+eTFJIqIyECmClSjR4/GzZs3MXfuXGg0Gvj6+iIlJUWcbCInJ0dnAoVr166hW7du4udly5Zh2bJl6N+/P9LT0wEAv/32G8aOHYs///wTTZs2Rd++fXHkyBE0bdpUPG7FihWwsrJCWFgYSkpKEBwcjA8++EBy/4mIyHSYRMmLSRQRkYFMGaiio6MRHR1d7b7KxKiSt7c3BEF45Pm2bNny2DZtbW2RmJiIxMTEGveTiIjMi0mUvJhEEREZiIGKiIgsDWOTvJhEEREZSID0GY0e/XyIiIjIMIxN8mISVVcoTHDnQGGaBdgU1tYmaUeoqDBBIyZazPMxQ7aIyDi0BQXQKuSd1c/mRLGs5wfq1h9KpooZCmvTxEChQv64obAyTWwSTBBmTcYUcZaxvFZhEkVEZCAOmSAiIkvD2CQvJlFERAZioCIiIkvD2CQvJlFERAZioCIiIkvD2CQvJlFERAZioCIiIkvD2CQvJlFERAYSBAUEiYFHan0iIiIpGJvkZZqpZoiIiIiIiOoIPokiIjKQFgrJa3FIrU9ERCQFY5O8mEQRERmI486JiMjSMDbJi8P5iIgMVDnuXOpGREQkF1PEpri4OPTo0QOOjo5wdXXFiBEjkJ2drVOnuLgYUVFRaNy4MRwcHBAWFoa8vDydOjk5OQgNDYW9vT1cXV0xY8YMlJeX69RJT09H9+7dYWNjg9atW2Pjxo16fS/GwiSKiMhAlXf7pG5ERERyMUVsOnDgAKKionDkyBGkpqairKwMgwcPRlFRkVhn+vTp+Pbbb7Ft2zYcOHAA165dw8iRI8X9FRUVCA0NRWlpKQ4fPoxNmzZh48aNmDt3rljnypUrCA0NxdNPP42srCxMmzYNL7/8Mvbs2WP4F6UnDucjIjIQZ0AiIiJLY4rYlJKSovN548aNcHV1RWZmJvr164eCggKsW7cOycnJGDhwIABgw4YNaN++PY4cOYJevXrh+++/x7lz57B37164ubnB19cXCxcuxKxZszBv3jwolUokJSXBx8cHy5cvBwC0b98ehw4dwooVKxAcHCypz8bCJ1FERERERCQqLCzU2UpKSmp0XEFBAQDAxcUFAJCZmYmysjIEBQWJddq1a4cWLVogIyMDAJCRkYHOnTvDzc1NrBMcHIzCwkKcPXtWrPPgOSrrVJ7DHJhEEREZSNBjuASfRBERkZwMiU2enp5wcnISt7i4uMe2p9VqMW3aNPTp0wedOnUCAGg0GiiVSjg7O+vUdXNzg0ajEes8mEBV7q/c96g6hYWFuHfvnvQvxwg4nI+IyEACAEGQfgwREZFcDIlNubm5UKlUYrmNjc1jj42KisKZM2dw6NAhaY3WUkyiiIgMpIUCCq7FQUREFsSQ2KRSqXSSqMeJjo7Gzp07cfDgQTRv3lwsV6vVKC0tRX5+vs7TqLy8PKjVarHOsWPHdM5XOXvfg3X+PqNfXl4eVCoV7Ozsan6BRsThfEREBuIU50REZGlMEZsEQUB0dDS+/vpr7Nu3Dz4+Pjr7/fz80LBhQ6SlpYll2dnZyMnJQWBgIAAgMDAQp0+fxo0bN8Q6qampUKlU6NChg1jnwXNU1qk8hznwSRQRkYG0ggIKLmhIREQWxBSxKSoqCsnJyfjmm2/g6OgovsPk5OQEOzs7ODk5YdKkSYiJiYGLiwtUKhVee+01BAYGolevXgCAwYMHo0OHDnjppZewZMkSaDQazJkzB1FRUeIwwldffRWrV6/GzJkzMXHiROzbtw+ff/45du3aJam/xsQnUUREREREJNmaNWtQUFCAAQMGwN3dXdy2bt0q1lmxYgWeffZZhIWFoV+/flCr1fjqq6/E/dbW1ti5cyesra0RGBiIF198EePGjcOCBQvEOj4+Pti1axdSU1PRtWtXLF++HB999JHZpjcH+CSKiMhggqDHy7ucWYKIiGRkitgk1OAAW1tbJCYmIjEx8aF1vLy8sHv37keeZ8CAATh58qS0DsqISRQRkYG42C4REVkaxiZ5MYkiIjIQAxUREVkaxiZ5MYkiIjIQJ5YgIiJLw9gkLyZRREQG4jtRRERkaRib5MXZ+YiIiIiIiCRgEkVEZKD7d/ukLmioX1uJiYnw9vaGra0tAgICqqzy/qCzZ88iLCwM3t7eUCgUSEhIqFInLi4OPXr0gKOjI1xdXTFixAhkZ2fr1BkwYAAUCoXO9uqrr9aov8XFxQ/dd/369Rqdg4iIpDNlbKqPOJxPbgrTjC1VKJWyt2Flby97GwCgsLczSTva/AL527j38D8gjdySaZrhb9dqmerl3a1btyImJgZJSUkICAhAQkICgoODkZ2dDVdX1yr17969i5YtW2LUqFGYPn16tec8cOAAoqKi0KNHD5SXl+PNN9/E4MGDce7cOTRq1EisFxkZqbNmh30Nfx90794dycnJ8PX11Sn/8ssv8eqrr+LmzZs1Oo+lEARAgMz/HZSVy3t+AApbG9nbAAA0bCh7E1YO8sc/AFA4OpikHaHwtuxtaAsKZW+DzI8TS8iLT6KIiAwk6LlJFR8fj8jISERERKBDhw5ISkqCvb091q9fX239Hj16YOnSpRgzZoy46vvfpaSkYMKECejYsSO6du2KjRs3IicnB5mZmTr17O3toVarxU2lUtWozwMGDECvXr3w3nvvAQCKioowYcIEvPTSS3jzzTclXD0REUlhqthUX/FJFBGRgQy521dYqHtH2MbGptqEp7S0FJmZmZg9e7ZYZmVlhaCgIGRkZOjR6+oVFNx/Quvi4qJTvnnzZnz66adQq9UYNmwY3n777Ro9jfrggw8QGhqKl19+GTt37sT169fh4OCAY8eOoVOnTkbrNxER6eKTKHkxiSIiMpQ+t+/+W9/T01OnODY2FvPmzatS/Y8//kBFRQXc3Nx0yt3c3HD+/HmJjVdPq9Vi2rRp6NOnj06C88ILL8DLywseHh44deoUZs2ahezsbHz11Vc1Ou+QIUMwcuRIrFmzBg0aNMC3337LBIqISG4GxCZ6PCZRRERmlJubqzM07mHD7kwhKioKZ86cwaFDh3TKJ0+eLP7cuXNnuLu7Y9CgQbh06RJatWr1yHNeunQJL7zwAjQaDfbs2YMDBw5g+PDhmDp1KhYtWoSGJnhnhoiIyNj4ThQRkaEkz36kAP47ZEKlUulsD0uimjRpAmtra+Tl5emU5+XlQa1WG3wJ0dHR2LlzJ/bv34/mzZs/sm5AQAAA4OLFi489r6+vL3x8fPCf//wHzzzzDN555x3s378fX331FXr27Glwv4mI6CEMiE30eEyiiIgMVLmgodRNCqVSCT8/P6SlpYllWq0WaWlpCAwMNKDvAqKjo/H1119j37598PHxeewxWVlZAAB3d/fH1v3ggw+wZcsWODs7i2W9e/fGyZMn0b17d327TUREj2GK2FSfcTgfEZGBTPXybkxMDMaPHw9/f3/07NkTCQkJKCoqQkREBABg3LhxaNasGeLi4gDcn4zi3Llz4s+///47srKy4ODggNatWwO4P4QvOTkZ33zzDRwdHaHRaAAATk5OsLOzw6VLl5CcnIyhQ4eicePGOHXqFKZPn45+/fqhS5cuj+3zSy+9VG25o6Mj1q1bJ/k7ICKimuHEEvJiEkVEZCh9hkDoEahGjx6NmzdvYu7cudBoNPD19UVKSoo42UROTg6srP43wODatWvo1q2b+HnZsmVYtmwZ+vfvj/T0dADAmjVrANyfivxBGzZswIQJE6BUKrF3714xYfP09ERYWBjmzJlToz5//PHHD92nUCgemmQREZGBTBSb6itZkqjff/8ds2bNwnfffYe7d++idevW2LBhA/z9/eVojojIrPQZAqHvkIno6GhER0dXu68yMark7e0N4TENPW6/p6cnDhw4IKmPD5o6darO57KyMty9exdKpRL29vYmS6IYl4iovjFlbKqPjJ5E/fXXX+jTpw+efvppfPfdd2jatCkuXLiAJ554wthNERGRhfvrr7+qlF24cAFTpkzBjBkzTNYHxiUiovqtrKwMGo0Gd+/eRdOmTaushyiV0ZOo9957D56entiwYYNYVpMXlYmIai2uxSFJmzZtsHjxYrz44otGW+PqURiXiKheYmzC7du38emnn2LLli04duwYSktLIQgCFAoFmjdvjsGDB2Py5Mno0aOH5HMbfXa+HTt2wN/fH6NGjYKrqyu6deuGDz/88KH1S0pKUFhYqLMREdUmUqeQ1edl37qmQYMGuHbtmknakhqXAMYmIqr96ntsio+Ph7e3NzZs2ICgoCBs374dWVlZ+OWXX5CRkYHY2FiUl5dj8ODBCAkJwYULFySd3+hPoi5fvow1a9YgJiYGb775Jo4fP47XX38dSqUS48ePr1I/Li4O8+fPN3Y3iIhMq47dvTOWHTt26HwWBAHXr1/H6tWr0adPH5P0QWpcAhibiKiOqMex6fjx4zh48CA6duxY7f6ePXti4sSJSEpKwoYNG/DDDz+gTZs2NT6/QnjcW8USKZVK+Pv74/Dhw2LZ66+/juPHjyMjI6NK/ZKSEpSUlIifCwsL4enpiQF4Dg0UdWAle4VpMnqFUil7G1b29rK3AQAKezuTtKPNL5C/jXvFsrcBABC0Jmqnbvw2LhfKkI5vUFBQAJVKpfd5CgsL4eTkBM9/x8LKzlbSsdp7xch9Zb7BfbB0D84WCNyfka9p06YYOHAgli9fXqO1pgwlNS4BD49NT9s8L3tsUjSQf+JchW31izobm1BaJnsbChv54x8AKBwdTNKOUHhb9ja0BaZ5sipUVJikHcYmXYxNpmH039Tu7u7o0KGDTln79u3x5ZdfVlvfxsYGNjam+WVORESmpdWaKMF/BKlxCWBsIiKqywoLC7Fv3z60bdsW7du31+scRn8nqk+fPsjOztYp++WXX+Dl5WXspoiILIOg50YmwbhERPUSY5Po+eefx+rVqwEA9+7dg7+/P55//nl06dLlkTfUHsXoT6KmT5+O3r17491338Xzzz+PY8eOYe3atVi7dq2xmyIishCK/25Sj6mbYmJialw3Pj5exp7cx7hERPUTY1OlgwcP4q233gIAfP311xAEAfn5+di0aRPeeecdhIWFST6n0ZOoHj164Ouvv8bs2bOxYMEC+Pj4ICEhAeHh4cZuiojIMnAaWR0nT56sUT2Fid4ZZVwionqJsUlUUFAgrguVkpKCsLAw2NvbIzQ0VO81C2V5e/XZZ5/Fs88+K8epiYgsDwOVjpUrV6Jjx46wtrY2d1dEjEtEVO8wNok8PT2RkZEBFxcXpKSkYMuWLQDuL8Zuaytt8o1KRn8nioio3hEU+m11VLdu3XDr1i0AQMuWLfHnn3+auUdERPUQY5No2rRpCA8PR/PmzeHh4YEBAwYAuD/Mr3PnznqdU/55VImIqF5xdnbG5cuX0bRpU/z6668WMUMfERHVX//85z/Rs2dP5Obm4plnnhGX32jZsiXeeecdvc7JJIqIyECCIH2ZkjqyrEm1wsLC0L9/f7i7u0OhUMDf3/+hQ/suX75s4t4REdUPjE3AU089heeeew7PPfcc/P394e/vr7M/NDRU73MziSIiMhTHnetYu3YtRo4ciYsXL+L1119HZGQkHB0dzd0tIqL6hbEJkZGR+OabbzB//nw0b94cw4cPx/Dhw9G7d2+DJzdiEkVEZCh9xpHX0XHnlUJCQgAAmZmZmDp1KpMoIiJTY2zCuHHjMG7cOJSUlCAtLQ3ffPMNRo0ahYqKCoSGhmL48OEIDg6GnZ2d5HPX7yTKBNPrWploxXuFj6fsbVx6oYnsbQCA/XXT/AfsnqqRvQ1Fzu+ytwEAQmmpSdqh6imE+5vUY+qDDRs2mLsLRmVlo4SVQilrG0JFhaznBwA0ME34F1q4y97G+Sn2srcBALbXGpqkHe+vbsnehqLoruxtAICgNdUvOhO8d1kLx7kxNv2PjY0Nhg4diqFDh+Lf//43jh49ih07duDtt9/GCy+8gIEDB2L27Nno06dPjc/J2fmIiAzFVeGJiMjSMDY9VEBAABYtWoTTp0/j9OnTGDRoEK5fvy7pHPX7SRQREREREdV5+fn5+OKLL3Dp0iXMmDEDLi4uOHHiBNzc3DB9+nTJ52MSRURkKI47JyIiS8PYJDp16hSCgoLg5OSEX3/9FZGRkXBxccFXX32FnJwcfPzxx5LPyeF8RESG4pAJIiKyNIxNopiYGEyYMAEXLlyAra2tWD506FAcPHhQr3MyiSIiMhQD1SN98skn6NOnDzw8PHD16lUAQEJCAr755hsz94yIqA5jbBIdP34cr7zySpXyZs2aQaPRb6IxJlFERIZioHqoNWvWICYmBkOHDkV+fj4q/jvznLOzMxISEszbOSKiuoyxSWRjY4PCwsIq5b/88guaNm2q1zmZRBERGapy3LnUrR5YtWoVPvzwQ7z11luwtrYWy/39/XH69Gkz9oyIqI5jbBINHz4cCxYsQFlZGQBAoVAgJycHs2bNQlhYmF7nZBJFRESyuXLlCrp161al3MbGBkVFRWboERER1TfLly/HnTt34Orqinv37qF///5o3bo1HB0dsWjRIr3OySSKiMhAlQsaSt3qAx8fH2RlZVUpT0lJQfv27U3fISKiesIUsengwYMYNmwYPDw8oFAosH37dp39EyZMgEKh0NlCQkJ06ty6dQvh4eFQqVRwdnbGpEmTcOfOHZ06p06dwlNPPQVbW1t4enpiyZIlkvrp5OSE1NRU7Ny5E++//z6io6Oxe/duHDhwAI0aNZJ20f/FKc6JiAylzzjyepJExcTEICoqCsXFxRAEAceOHcNnn32GuLg4fPTRR+buHhFR3WWC2FRUVISuXbti4sSJGDlyZLV1QkJCsGHDBvGzjY2Nzv7w8HBcv34dqampKCsrQ0REBCZPnozk5GQAQGFhIQYPHoygoCAkJSXh9OnTmDhxIpydnTF58mRJ/e3Tpw/69Okj7SIfgkkUERHJ5uWXX4adnR3mzJmDu3fv4oUXXoCHhwdWrlyJMWPGmLt7RERkgCFDhmDIkCGPrGNjYwO1Wl3tvp9//hkpKSk4fvw4/P39Adx/l3bo0KFYtmwZPDw8sHnzZpSWlmL9+vVQKpXo2LEjsrKyEB8f/8gkasuWLTWOM7m5ucjJyZGUYHE4HxGRgRTQY8iEnm0lJibC29sbtra2CAgIwLFjxx5a9+zZswgLC4O3tzcUCsVDZ8N73DmLi4sRFRWFxo0bw8HBAWFhYcjLy6txn8PDw3HhwgXcuXMHGo0Gv/32GyZNmlTj44mISDpDYlNhYaHOVlJSonc/0tPT4erqirZt22LKlCn4888/xX0ZGRlwdnYWEygACAoKgpWVFY4ePSrW6devH5RKpVgnODgY2dnZ+Ouvvx7a7po1a9C+fXssWbIEP//8c5X9BQUF2L17N1544QV0795dp181wSSKiMhQJpoBaevWrYiJiUFsbCxOnDiBrl27Ijg4GDdu3Ki2/t27d9GyZUssXrz4oXcBa3LO6dOn49tvv8W2bdtw4MABXLt27aHDNv7unXfewZUrVwAA9vb2cHV1lXjVRESkFwNik6enJ5ycnMQtLi5Ory6EhITg448/RlpaGt577z0cOHAAQ4YMEZe70Gg0VeJCgwYN4OLiIq7fpNFo4ObmplOn8vOj1ng6cOAA3nvvPaSmpqJTp05QqVRo06YNOnfujObNm6Nx48aYOHEiWrRogTNnzmD48OGSro3D+YiIaon4+HhERkYiIiICAJCUlIRdu3Zh/fr1eOONN6rU79GjB3r06AEA1e6vyTkLCgqwbt06JCcnY+DAgQCADRs2oH379jhy5Ah69er1yD5v27YNsbGxCAgIwIsvvojnn38eTZo00fs7ICIi+eXm5kKlUomf//4eU009OJyuc+fO6NKlC1q1aoX09HQMGjTI4H4+zvDhwzF8+HD88ccfOHToEK5evYp79+6hSZMm6NatG7p16wYrK/2eKTGJIiIylAEv7/598T8bG5tqg1VpaSkyMzMxe/ZssczKygpBQUHIyMiQ2HjNz5mZmYmysjIEBQWJddq1a4cWLVogIyPjsUnUf/7zH5w9exabN2/GsmXLMG3aNDzzzDMIDw/HiBEjYG9vr1ffiYjoMQyITSqVSieJMpaWLVuiSZMmuHjxIgYNGgS1Wl1lNEV5eTlu3boljqBQq9VVhpBXfn7YKIu/a9KkCUaMGGH4BTyAw/mIiAxlwKrwNR0y8ccff6CioqLaIQ2PGs7wKDU5p0ajgVKphLOzs97tduzYEe+++y4uX76M/fv3w9vbG9OmTatx8CMiIj0YEJvk8ttvv+HPP/+Eu7s7ACAwMBD5+fnIzMwU6+zbtw9arRYBAQFinYMHD4oL5QJAamoq2rZtiyeeeELeDj8Cn0QRERlIn7U1Kusba8hEbdGoUSPY2dlBqVTi9u3b5u4OEVGdZUhsqqk7d+7g4sWL4ucrV64gKysLLi4ucHFxwfz58xEWFga1Wo1Lly5h5syZaN26NYKDgwEA7du3R0hICCIjI5GUlISysjJER0djzJgx8PDwAAC88MILmD9/PiZNmoRZs2bhzJkzWLlyJVasWCGts0bGJ1FERIYy4G5f5ZCJyu1hSVSTJk1gbW1d7ZAGfZ/o1OScarUapaWlyM/P17vdK1euYNGiRejYsSP8/f1x8uRJzJ8/X+8naEREVAMmeBL1008/ie8WAffXBuzWrRvmzp0La2trnDp1CsOHD8eTTz6JSZMmwc/PDz/88INOrNu8eTPatWuHQYMGYejQoejbty/Wrl0r7ndycsL333+PK1euwM/PD//3f/+HuXPnSl4jytj4JIqIyFAmWNBQqVTCz88PaWlp4rhurVaLtLQ0REdHS2y85uf08/NDw4YNkZaWhrCwMABAdnY2cnJyEBgY+Ng2evXqhePHj6NLly6IiIjA2LFj0axZM736S0REEpggNg0YMACC8PCD9uzZ89hzuLi4iAvrPkyXLl3www8/SOuczJhEERHVEjExMRg/fjz8/f3Rs2dPJCQkoKioSJxZb9y4cWjWrJn4XlVpaSnOnTsn/vz7778jKysLDg4OaN26dY3O6eTkhEmTJiEmJgYuLi5QqVR47bXXEBgY+NhJJQBg0KBBWL9+PTp06CDHV0JERPRYxcXFsLW1rXbf9evXxXe0pGASRURkIFOMOweA0aNH4+bNm5g7dy40Gg18fX2RkpIiTgyRk5OjM1XrtWvXxCEWALBs2TIsW7YM/fv3R3p6eo3OCQArVqyAlZUVwsLCUFJSguDgYHzwwQc16vOiRYukXygRERnMVLGpNujevTuSk5Ph6+urU/7ll1/i1Vdfxc2bNyWfk0kUEZGh9Fk8V4/FdgEgOjr6ocP3KhOjSt7e3o8cZlGTcwKAra0tEhMTkZiYWKM+xsTEYOHChWjUqBFiYmIeWTc+Pr5G5yQiIolMGJss3YABA9CrVy/Mnz8fs2bNQlFREaKiovD555/rfbOPSRQRkaFMMO68Njl58qQ4Fe3JkyfN3BsionqKsUn0wQcfIDQ0FC+//DJ27tyJ69evw8HBAceOHUOnTp30OieTKCIiA3HIhK79+/dX+zMREZkOY5OuIUOGYOTIkVizZg0aNGiAb7/9Vu8ECuAU50REhrPABQ0txcSJE6tdD6qoqAgTJ040Q4+IiOoJxibRpUuXEBgYiJ07d2LPnj2YOXMmhg8fjpkzZ+os4isFn0TJTKFUmqSdEnfV4ysZKHvSGtnbAICNha4maSf5P0Nlb8M695rsbQCAoDDR/RChwjTtUJ2xadMmLF68GI6Ojjrl9+7dw8cff4z169ebqWd6srYGFNayNiGUlMh6fgBQaE3zl1JpUzvZ27jy7IeytwEAR4pN8/vvrR/kX/tGeUnef8OVFFblJmlHKK+jf/mT0fj6+iI0NBR79uyBs7MznnnmGQwdOhTjxo1DamqqXkPPmUQRERlKjyETdfVuX6XCwkIIggBBEHD79m2dqWUrKiqwe/duuLqa5oYJEVG9xNgk+uCDD/DSSy/plPXu3RsnT57EtGnT9DonkygiIkPx5d0qnJ2doVAooFAo8OSTT1bZr1AoMH/+fDP0jIionmBsEv09gark6OiIdevW6XVOJlFERIZioKpi//79EAQBAwcOxJdffgkXFxdxn1KphJeXFzw8PMzYQyKiOo6xSfTxxx8/dJ9CoXhokvUoTKKIiAzEGZCq6t+/PwDgypUr8PT01FkEmIiI5MfY9D9Tp07V+VxWVoa7d+9CqVTC3t6eSRQREVkWLy8vAMDdu3eRk5OD0tJSnf1dunQxR7eIiKge+euvv6qUXbhwAVOmTMGMGTP0OieTKCIiks3NmzcRERGB7777rtr9FRWc8ZGIiEyvTZs2WLx4MV588UWcP39e8vEcX0FEZCiuxfFQ06ZNQ35+Po4ePQo7OzukpKRg06ZNaNOmDXbs2GHu7hER1V2MTY/VoEEDXLum33I0fBJFRGQgjjt/uH379uGbb76Bv78/rKys4OXlhWeeeQYqlQpxcXEIDQ01dxeJiOokxqb/+ftNO0EQcP36daxevRp9+vTR65yyP4lavHgxFAqF3nOwExHVCrzTV62ioiJxPagnnngCN2/eBAB07twZJ06cMEufGJeIqN5gbAIAjBgxQmcbOXIk5s2bhy5duui96LusT6KOHz+Of//733xxmIjqNk4j+1Bt27ZFdnY2vL290bVrV/z73/+Gt7c3kpKS4O7ubvL+MC4RUb3B2CTSarVGP6dsT6Lu3LmD8PBwfPjhh3jiiSfkaoaIyOwqh0xI3eqDqVOn4vr16wCA2NhYfPfdd2jRogXef/99vPvuuybtC+MSEdUnjE3yku1JVFRUFEJDQxEUFIR33nnnofVKSkpQUlIifi4sLJSrS0REZGIvvvii+LOfnx+uXr2K8+fPo0WLFmjSpIlJ+1LTuAQwNhER1XYxMTE1rhsfHy/5/LIkUVu2bMGJEydw/Pjxx9aNi4vD/Pnz5egGEZFpcMhEjdnb26N79+4mb1dKXAIYm4ioDqjnsenkyZM1qqdQKPQ6v9GTqNzcXEydOhWpqamwtbV9bP3Zs2frZIqFhYXw9PQ0dreIiGTDGZB0yX33TyqpcQlgbCKi2q++x6aVK1eiY8eOsLa2luX8Rk+iMjMzcePGDZ07jRUVFTh48CBWr16NkpISnYuxsbGBjY2NsbtBRGQ69fxu39/JffdPKqlxCWBsIqI6oJ7Hpm7dukGj0aBp06Zo2bIljh8/jsaNGxvt/EZPogYNGoTTp0/rlEVERKBdu3aYNWuWbNkgEZHZ1PNA9Xf79+83dxd0MC4RUb1Uz2OTs7MzLl++jKZNm+LXX381+gx9Rk+iHB0d0alTJ52yRo0aoXHjxlXKiYjqgvo+ZKImLl68iEuXLqFfv36ws7ODIAgmexLFuERE9VF9j01hYWHo378/3N3doVAo4O/v/9CbZpcvX5Z8flnXiSIiovrtzz//xPPPP4/9+/dDoVDgwoULaNmyJSZNmoQnnngCy5cvN3cXiYioDlq7di1GjhyJixcv4vXXX0dkZCQcHR2Ndn6TJFHp6emmaIaIyDzq+ZCJR5k+fToaNmyInJwctG/fXiwfPXo0YmJizJZEMS4RUZ3H2ISQkBAA99+NnTp1au1LooiI6jQGqof6/vvvsWfPHjRv3lynvE2bNrh69aqZekVEVA8wNok2bNhg9HMyiSIiMlB9H3f+KEVFRbC3t69SfuvWLc5+R0QkI8YmeVmZuwNERLWeoOdWDzz11FP4+OOPxc8KhQJarRZLlizB008/bcaeERHVcYxNsuKTKCIiA/Fu38MtWbIEgwYNwk8//YTS0lLMnDkTZ8+exa1bt/Djjz+au3tERHUWY5O8+CSKiKgWSUxMhLe3N2xtbREQEIBjx449sv62bdvQrl072NraonPnzti9e7fOfoVCUe22dOlSsY63t3eV/YsXL65Rfzt16oRffvkFffv2xXPPPYeioiKMHDkSJ0+eRKtWraR/AURERBaAT6KIiAxlopd3t27dipiYGCQlJSEgIAAJCQkIDg5GdnY2XF1dq9Q/fPgwxo4di7i4ODz77LNITk7GiBEjcOLECXF9pOvXr+sc891332HSpEkICwvTKV+wYAEiIyPFzzWZ4aisrAwhISFISkrCW2+9Jf2CiYhIf5xYQlZMomQmVFSYpB2b3wtkb6PdR1NkbwMA7DSmWYDT47dc2duoqDDu6tgPJZioHaqeiQJVfHw8IiMjERERAQBISkrCrl27sH79erzxxhtV6q9cuRIhISGYMWMGAGDhwoVITU3F6tWrkZSUBABQq9U6x3zzzTd4+umn0bJlS51yR0fHKnUfp2HDhjh16pSkYyyd9vYdaBUNZW1D0Mr/V4xQXCx7GwBg+1uh7G20XWea2GRvotjkfvX64ysZSFtaJnsbgGn+LQMATLFwt1ALswsmUbLicD4iIgMp9NwAoLCwUGcrKSmpto3S0lJkZmYiKChILLOyskJQUBAyMjKqPSYjI0OnPgAEBwc/tH5eXh527dqFSZMmVdm3ePFiNG7cGN26dcPSpUtRXl5e/ZfxNy+++CLWrVtXo7pERGQ8hsQmejw+iSIiMpQBd/s8PT11imNjYzFv3rwq1f/44w9UVFTAzc1Np9zNzQ3nz5+vtgmNRlNtfY1GU239TZs2wdHRESNHjtQpf/3119G9e3e4uLjg8OHDmD17Nq5fv474+PhHXSEAoLy8HOvXr8fevXvh5+eHRo0a6eyvyTmIiEgPfBIlKyZRREQGMmQGpNzcXKhUKrHcnGsnrV+/HuHh4bC1tdUpj4mJEX/u0qULlEolXnnlFcTFxT22v2fOnEH37t0BAL/88ovOPoUphuAQEdVTnJ1PXkyiiIjMSKVS6SRRD9OkSRNYW1sjLy9PpzwvL++h7yqp1eoa1//hhx+QnZ2NrVu3PrYvAQEBKC8vx6+//oq2bds+su7+/fsfez4iIqLahu9EEREZygQLGiqVSvj5+SEtLU0s02q1SEtLQ2BgYLXHBAYG6tQHgNTU1Grrr1u3Dn5+fujatetj+5KVlQUrK6tqZwQkIiILwcV2ZcUnUURExmCCwBMTE4Px48fD398fPXv2REJCAoqKisTZ+saNG4dmzZohLi4OADB16lT0798fy5cvR2hoKLZs2YKffvoJa9eu1TlvYWEhtm3bhuXLl1dpMyMjA0ePHsXTTz8NR0dHZGRkYPr06XjxxRfxxBNPyH/RRESkPyZFsmESRURkIFONOx89ejRu3ryJuXPnQqPRwNfXFykpKeLkETk5ObCy+t8Ag969eyM5ORlz5szBm2++iTZt2mD79u3iGlGVtmzZAkEQMHbs2Cpt2tjYYMuWLZg3bx5KSkrg4+OD6dOn67wnRURElofvRMmLw/mIiAxlwiET0dHRuHr1KkpKSnD06FEEBASI+9LT07Fx40ad+qNGjUJ2djZKSkpw5swZDB06tMo5J0+ejLt378LJyanKvu7du+PIkSPIz8/HvXv3cO7cOcyePdusE2AQEVENmCA2HTx4EMOGDYOHhwcUCgW2b9+u2wVBwNy5c+Hu7g47OzsEBQXhwoULOnVu3bqF8PBwqFQqODs7Y9KkSbhz545OnVOnTuGpp56Cra0tPD09sWTJEmkdlQGTKCIiA1Xe7ZO6ERERycUUsamoqAhdu3ZFYmJitfuXLFmC999/H0lJSTh69CgaNWqE4OBgFD+w4Hd4eDjOnj2L1NRU7Ny5EwcPHsTkyZPF/YWFhRg8eDC8vLyQmZmJpUuXYt68eVWGppsah/MREREREZFkQ4YMwZAhQ6rdJwgCEhISMGfOHDz33HMAgI8//hhubm7Yvn07xowZg59//hkpKSk4fvw4/P39AQCrVq3C0KFDsWzZMnh4eGDz5s0oLS3F+vXroVQq0bFjR2RlZSE+Pl4n2TI1PokiIjIUZ0AiIiJLY0BsKiws1NlKSkokN3/lyhVoNBoEBQWJZU5OTggICEBGRgaA+5MXOTs7iwkUAAQFBcHKygpHjx4V6/Tr1w9KpVKsExwcjOzsbPz111+S+2UsTKKIiAzE4XxERGRpDIlNnp6ecHJyErfKWV+l0Gg0ACBOflTJzc1N3KfRaKosl9GgQQO4uLjo1KnuHA+2YQ4czkdEZCh9niwxiSIiIjkZEJtyc3N1FoLnZEJV8UkUEZGhOJyPiIgsjQGxSaVS6Wz6JFFqtRoAkJeXp1Oel5cn7lOr1bhx44bO/vLycty6dUunTnXneLANc2ASRURERERERuXj4wO1Wo20tDSxrLCwEEePHkVgYCAAIDAwEPn5+cjMzBTr7Nu3D1qtVlzCIzAwEAcPHkRZWZlYJzU1FW3btjXrou9MooiIDMR3ooiIyNKYIjbduXMHWVlZyMrKAnB/MomsrCzk5ORAoVBg2rRpeOedd7Bjxw6cPn0a48aNg4eHB0aMGAEAaN++PUJCQhAZGYljx47hxx9/RHR0NMaMGQMPDw8AwAsvvAClUolJkybh7Nmz2Lp1K1auXGn2Rd/5ThQRkaH4ThQREVkaE8Smn376CU8//bT4uTKxGT9+PDZu3IiZM2eiqKgIkydPRn5+Pvr27YuUlBTY2tqKx2zevBnR0dEYNGgQrKysEBYWhvfff1/c7+TkhO+//x5RUVHw8/NDkyZNMHfuXLNObw4wiSIiMphCEKAQpEUeqfWJiIikMEVsGjBgAIRHHKNQKLBgwQIsWLDgoXVcXFyQnJz8yHa6dOmCH374QVLf5MYkiojIUHwSRUREloaxSVZMooiIDKTPOHK+E0VERHJibJIXJ5YgIiIiIiKSgE+iiIgMxSETRERkaRibZMUkiojIQBwyQUREloaxSV5MooiIDMW7fUREZGkYm2RVv5MoE0wxrL1XLHsbAGCVe032NnyW5snehilVlJbK3oZQUSF7G/cb4m89c+LdvvpDKC+HoFDI24jc5wcgFJfI3gYA4OrvsjfRaqlG9jYAAFby//8CAEJZuQka0crfBpkdY5O86ncSRURkDLzbR0REloaxSVacnY+IiIiIiEgCPokiIjICDoEgIiJLw9gkHyZRRESGEgTp76XxPTYiIpITY5OsmEQRERmIL+8SEZGlYWySF5MoIiJD8eVdIiKyNIxNsmISRURkIIX2/ib1GCIiIrkwNsmLs/MRERERERFJwCdRRESG4pAJIiKyNIxNsjL6k6i4uDj06NEDjo6OcHV1xYgRI5CdnW3sZoiILEbly7tSNzIdxiYiqm8Ym+Rl9CTqwIEDiIqKwpEjR5CamoqysjIMHjwYRUVFxm6KiMgyVE4jK3XTQ2JiIry9vWFra4uAgAAcO3bskfW3bduGdu3awdbWFp07d8bu3bt19k+YMAEKhUJnCwkJ0alz69YthIeHQ6VSwdnZGZMmTcKdO3f06r+5MDYRUb1jwthUHxl9OF9KSorO540bN8LV1RWZmZno169flfolJSUoKSkRPxcWFhq7S0REsjLVNLJbt25FTEwMkpKSEBAQgISEBAQHByM7Oxuurq5V6h8+fBhjx45FXFwcnn32WSQnJ2PEiBE4ceIEOnXqJNYLCQnBhg0bxM82NjY65wkPD8f169fF5CMiIgKTJ09GcnKy9IswE8YmIqpvOMW5vGSfWKKgoAAA4OLiUu3+uLg4ODk5iZunp6fcXSIiMi5Bz02i+Ph4REZGIiIiAh06dEBSUhLs7e2xfv36auuvXLkSISEhmDFjBtq3b4+FCxeie/fuWL16tU49GxsbqNVqcXviiSfEfT///DNSUlLw0UcfISAgAH379sWqVauwZcsWXLt2TfpFWAjGJiKq80wUm+orWZMorVaLadOmoU+fPjp3PR80e/ZsFBQUiFtubq6cXSIisiiFhYU624NPPx5UWlqKzMxMBAUFiWVWVlYICgpCRkZGtcdkZGTo1AeA4ODgKvXT09Ph6uqKtm3bYsqUKfjzzz91zuHs7Ax/f3+xLCgoCFZWVjh69Kjk67UEjE1ERGQoWWfni4qKwpkzZ3Do0KGH1rGxsakydISIqDYxZMjE359wxMbGYt68eVXq//HHH6ioqICbm5tOuZubG86fP19tGxqNptr6Go1G/BwSEoKRI0fCx8cHly5dwptvvokhQ4YgIyMD1tbW0Gg0VYYKNmjQAC4uLjrnqU0Ym4ioPuBwPnnJlkRFR0dj586dOHjwIJo3by5XM0RE5qfPy7j/rZ+bmwuVSiUWm/oP9zFjxog/d+7cGV26dEGrVq2Qnp6OQYMGmbQvpsDYRET1hgGxiR7P6MP5BEFAdHQ0vv76a+zbtw8+Pj7GboKIyKIYMo2sSqXS2R6WRDVp0gTW1tbIy8vTKc/Ly4Nara72GLVaLak+ALRs2RJNmjTBxYsXxXPcuHFDp055eTlu3br1yPNYGsYmIqpvOMW5vIyeREVFReHTTz9FcnIyHB0dodFooNFocO/ePWM3RURkGUzw8q5SqYSfnx/S0tLEMq1Wi7S0NAQGBlZ7TGBgoE59AEhNTX1ofQD47bff8Oeff8Ld3V08R35+PjIzM8U6+/btg1arRUBAgLSLMCPGJiKqdzixhKyMnkStWbMGBQUFGDBgANzd3cVt69atxm6KiMgimOpuX0xMDD788ENs2rQJP//8M6ZMmYKioiJEREQAAMaNG4fZs2eL9adOnYqUlBQsX74c58+fx7x58/DTTz8hOjoaAHDnzh3MmDEDR44cwa+//oq0tDQ899xzaN26NYKDgwEA7du3R0hICCIjI3Hs2DH8+OOPiI6OxpgxY+Dh4WH4l2cijE1EVN/wSZS8jP5OlMCxlEREshg9ejRu3ryJuXPnQqPRwNfXFykpKeLkETk5ObCy+t+9sd69eyM5ORlz5szBm2++iTZt2mD79u3ijHTW1tY4deoUNm3ahPz8fHh4eGDw4MFYuHChzrDCzZs3Izo6GoMGDYKVlRXCwsLw/vvvm/biDcTYRERExiTr7HxERPWCVri/ST1GD9HR0eKTpL9LT0+vUjZq1CiMGjWq2vp2dnbYs2fPY9t0cXGpVQvrEhERTBqb6iMmUUREhtJnHDnjFBERyYmxSVZMooiIDKSAHmtxyNITIiKi+xib5MUkiojIUFyLg4iILA1jk6yYRBERGYirwhMRkaVhbJIXkyi5aStM08zdu/I3ouBDXiIi2SmMvvpI1SaUDWVvAwAUDeX/M0MoLpG9DVMSKrTyt8HJA6Qzyd9ACr6TVIswiSIiMhRf3iUiIkvD2CQrJlFERAZSCAIUEseRS61PREQkBWOTvJhEEREZSvvfTeoxREREcmFskhWTKCIiA/FuHxERWRrGJnkxiSIiMhTHnRMRkaVhbJKV/FMAERERERER1SF8EkVEZCguaEhERJaGsUlWfBJFRGSgygUNpW5ERERyMUVsmjdvHhQKhc7Wrl07cX9xcTGioqLQuHFjODg4ICwsDHl5eTrnyMnJQWhoKOzt7eHq6ooZM2agvLzcGF+BrPgkiojIULzbR0RElsZEsaljx47Yu3ev+LlBg/+lF9OnT8euXbuwbds2ODk5ITo6GiNHjsSPP/4IAKioqEBoaCjUajUOHz6M69evY9y4cWjYsCHeffddyX0xJSZRREQGUmjvb1KPISIikoupYlODBg2gVqurlBcUFGDdunVITk7GwIEDAQAbNmxA+/btceTIEfTq1Qvff/89zp07h71798LNzQ2+vr5YuHAhZs2ahXnz5kGpVErvkIlwOB8RkaEq7/ZJ3YiIiORiQGwqLCzU2UpKSh7azIULF+Dh4YGWLVsiPDwcOTk5AIDMzEyUlZUhKChIrNuuXTu0aNECGRkZAICMjAx07twZbm5uYp3g4GAUFhbi7NmzcnwrRsMkioiIiIiIRJ6ennBychK3uLi4ausFBARg48aNSElJwZo1a3DlyhU89dRTuH37NjQaDZRKJZydnXWOcXNzg0ajAQBoNBqdBKpyf+U+S8bhfEREhuJaHEREZGkMiE25ublQqVRisY2NTbXVhwwZIv7cpUsXBAQEwMvLC59//jns7OwkNl678EkUEZGBKleFl7oRERHJxZDYpFKpdLaHJVF/5+zsjCeffBIXL16EWq1GaWkp8vPzderk5eWJ71Cp1eoqs/VVfq7uPStLwiSKiMhQfCeKiIgsjRli0507d3Dp0iW4u7vDz88PDRs2RFpamrg/OzsbOTk5CAwMBAAEBgbi9OnTuHHjhlgnNTUVKpUKHTp0MKgvcuNwPiIiQwkApM5oxByKiIjkZILY9K9//QvDhg2Dl5cXrl27htjYWFhbW2Ps2LFwcnLCpEmTEBMTAxcXF6hUKrz22msIDAxEr169AACDBw9Ghw4d8NJLL2HJkiXQaDSYM2cOoqKiavz0y1yYRBERGUif4XkczkdERHIyRWz67bffMHbsWPz5559o2rQp+vbtiyNHjqBp06YAgBUrVsDKygphYWEoKSlBcHAwPvjgA/F4a2tr7Ny5E1OmTEFgYCAaNWqE8ePHY8GCBZL6YQ5MooiIiIiISLItW7Y8cr+trS0SExORmJj40DpeXl7YvXu3sbsmOyZRRESGEqDHqvCy9ISIiOg+xiZZMYkiIjKUPi/jcjgfERHJibFJVkyiiIgMpQWg0OMYIiIiuTA2yYpJFBGRgTixBBERWRrGJnlxnSgiIkOZcC2OxMREeHt7w9bWFgEBATh27Ngj62/btg3t2rWDra0tOnfurPPybllZGWbNmoXOnTujUaNG8PDwwLhx43Dt2jWdc3h7e0OhUOhsixcv1qv/RERkIlzDUFZMooiIaomtW7ciJiYGsbGxOHHiBLp27Yrg4GCdRQofdPjwYYwdOxaTJk3CyZMnMWLECIwYMQJnzpwBANy9excnTpzA22+/jRMnTuCrr75CdnY2hg8fXuVcCxYswPXr18Xttddek/VaiYiILBmH81HN8e4EUfUMeHm3sLBQp9jGxuahCwzGx8cjMjISERERAICkpCTs2rUL69evxxtvvFGl/sqVKxESEoIZM2YAABYuXIjU1FSsXr0aSUlJcHJyQmpqqs4xq1evRs+ePZGTk4MWLVqI5Y6OjlCr1dKukfSisJL6EoMebTg0kr0NAFAolSZpxyQamuhabt+WvQmhokL2Nu43ZKIXbEzx94lC/v8ujY4TS8iKT6KIiAxlwJAJT09PODk5iVtcXFy1TZSWliIzMxNBQUFimZWVFYKCgpCRkVHtMRkZGTr1ASA4OPih9QGgoKAACoUCzs7OOuWLFy9G48aN0a1bNyxduhTl5eU1+WaIiMhcOJxPVnwSRURkKANmQMrNzYVKpRKLH/YU6o8//kBFRQXc3Nx0yt3c3HD+/Plqj9FoNNXW12g01dYvLi7GrFmzMHbsWJ0+vf766+jevTtcXFxw+PBhzJ49G9evX0d8fPxjL5OIiMyEs/PJikkUEZGBDJkBSaVS6SQs5lJWVobnn38egiBgzZo1OvtiYmLEn7t06QKlUolXXnkFcXFxD036iIjIvDg7n7w4nI+IyFAmGDLRpEkTWFtbIy8vT6c8Ly/voe8qqdXqGtWvTKCuXr2K1NTUxyZ1AQEBKC8vx6+//irpGoiIyIQ4nE9WTKKIiGoBpVIJPz8/pKWliWVarRZpaWkIDAys9pjAwECd+gCQmpqqU78ygbpw4QL27t2Lxo0bP7YvWVlZsLKygqurq55XQ0REVLtxOB8RkaG0AqCQePdOK/1uX0xMDMaPHw9/f3/07NkTCQkJKCoqEmfrGzduHJo1ayZOTjF16lT0798fy5cvR2hoKLZs2YKffvoJa9euBXA/gfrHP/6BEydOYOfOnaioqBDfl3JxcYFSqURGRgaOHj2Kp59+Go6OjsjIyMD06dPx4osv4oknnpB8DUREZCImik31FZMoIiJDmWga2dGjR+PmzZuYO3cuNBoNfH19kZKSIk4ekZOTAyur/w0w6N27N5KTkzFnzhy8+eabaNOmDbZv345OnToBAH7//Xfs2LEDAODr66vT1v79+zFgwADY2Nhgy5YtmDdvHkpKSuDj44Pp06frvCdFREQWiFOcy4pJFBGRwfQZR65foIqOjkZ0dHS1+9LT06uUjRo1CqNGjaq2vre3N4TH9Lt79+44cuSI5H4SEZG5mS421UdMooiIDMW7fUREZGkYm2Ql28QSiYmJ8Pb2hq2tLQICAnDs2DG5miIiMi+toN9GJsW4RET1CmOTrGRJorZu3YqYmBjExsbixIkT6Nq1K4KDg3Hjxg05miMiInokxiUiIjImWZKo+Ph4REZGIiIiAh06dEBSUhLs7e2xfv36KnVLSkpQWFiosxER1SqCVr+NTEZKXAIYm4ioDmBskpXRk6jS0lJkZmYiKCjof41YWSEoKAgZGRlV6sfFxcHJyUncPD09jd0lIiJ5cUFDiyY1LgGMTURUBzA2ycroSdQff/yBiooKccrdSm5ubuL6Iw+aPXs2CgoKxC03N9fYXSIikhfHnVs0qXEJYGwiojqAsUlWZp+dz8bGBjY2NubuBhGR/jgDUp3D2EREtR5jk6yM/iSqSZMmsLa2Rl5enk55Xl4e1Gq1sZsjIiJ6JMYlIiIyNqMnUUqlEn5+fkhLSxPLtFot0tLSEBgYaOzmiIjMT4Ae487N3en6g3GJiOolxiZZyTKcLyYmBuPHj4e/vz969uyJhIQEFBUVISIiQo7miIjMi0MmLB7jEhHVO4xNspIliRo9ejRu3ryJuXPnQqPRwNfXFykpKVVe6iUiqhO0WgASp4XVchpZU2JcIqJ6h7FJVrJNLBEdHY3o6Gi5Tk9EZDl4t69WYFwionqFsUlWZp+dj4io1mOgIiIiS8PYJCujTyxBRERERERUl/FJFBGRobQCJE9pxAUNiYhIToxNsmISRURkIEHQQhCkvYwrtT4REZEUjE3ysrgkSvjvWMxylHGueiKSRTnKAPzv943BBEH63TuOO69VTBmbFCb4t2GlLZW9DQBQmOCutiCY5lqkTnKmL1Ncj1Yol70NAICp/iA3ye9ThewtlAuMTbWJxSVRt2/fBgAcwm4z94SI6rrbt2/DycnJ8BMJegyZYKCqVUwam0zx9+0NE7RBVJeY8Fc2Y1PtYHFJlIeHB3Jzc+Ho6AiFomZZf2FhITw9PZGbmwuVSiVzD+VVl64FqFvXw2uxTPpciyAIuH37Njw8PIzTCa0WUEi848ohE7UKYxOvxVLVpeup79fC2FS7WFwSZWVlhebNm+t1rEqlqvX/0VWqS9cC1K3r4bVYJqnXYpS7fFRvMDbdx2uxXHXpeurztTA21R4Wl0QREdU6HDJBRESWhrFJVkyiiIgMJGi1ECQOmeAMSEREJCfGJnnViSTKxsYGsbGxsLGxMXdXDFaXrgWoW9fDa7FMFnEtvNtH1bCIf5tGwmuxXHXpengtRsbYJCuFYLR5FImI6pfCwkI4OTlhoM3zaKBQSjq2XCjFvpLPUVBQUGfG/hMRkfkxNplGnXgSRURkVoIAyYvI8P4VERHJibFJVlbm7gAREREREdVeiYmJ8Pb2hq2tLQICAnDs2DFzd0l2TKKIiAwkaAW9NiIiIrmYKjZt3boVMTExiI2NxYkTJ9C1a1cEBwfjxo26vao3kygiIkMJWv02PUi927dt2za0a9cOtra26Ny5M3bv3q3bdUHA3Llz4e7uDjs7OwQFBeHChQs6dW7duoXw8HCoVCo4Oztj0qRJuHPnjl79JyIiEzFRbIqPj0dkZCQiIiLQoUMHJCUlwd7eHuvXr5fhoiwHkygiIgNZ6t2+w4cPY+zYsZg0aRJOnjyJESNGYMSIEThz5oxYZ8mSJXj//feRlJSEo0ePolGjRggODkZxcbFYJzw8HGfPnkVqaip27tyJgwcPYvLkydK/KCIiMhlDYlNhYaHOVlJSUm0bpaWlyMzMRFBQkFhmZWWFoKAgZGRkmOQ6zaVOJFF1YRxmXFwcevToAUdHR7i6umLEiBHIzs42d7eMYvHixVAoFJg2bZq5u6KX33//HS+++CIaN24MOzs7dO7cGT/99JO5u6WXiooKvP322/Dx8YGdnR1atWqFhQsXojZM0nnw4EEMGzYMHh4eUCgU2L59u87+mjxRkUu5UIJyrcRNuB+QahqoAOl3+1auXImQkBDMmDED7du3x8KFC9G9e3esXr0awP3vLCEhAXPmzMFzzz2HLl264OOPP8a1a9fE7/fnn39GSkoKPvroIwQEBKBv375YtWoVtmzZgmvXrhn3i6xD6kJcAhibLFldiU21OS4BdTc2eXp6wsnJSdzi4uKqbeOPP/5ARUUF3NzcdMrd3Nyg0Whkv0azEmq5LVu2CEqlUli/fr1w9uxZITIyUnB2dhby8vLM3TVJgoODhQ0bNghnzpwRsrKyhKFDhwotWrQQ7ty5Y+6uGeTYsWOCt7e30KVLF2Hq1Knm7o5kt27dEry8vIQJEyYIR48eFS5fvizs2bNHuHjxorm7ppdFixYJjRs3Fnbu3ClcuXJF2LZtm+Dg4CCsXLnS3F17rN27dwtvvfWW8NVXXwkAhK+//lpn/+LFiwUnJydh+/btwn/+8x9h+PDhgo+Pj3Dv3j3Z+nTv3j1BrVZXLsQheXNwcKhSFhsbW21bJSUlgrW1dZXrHjdunDB8+PBqj/H09BRWrFihUzZ37lyhS5cugiAIwqVLlwQAwsmTJ3Xq9OvXT3j99dcFQRCEdevWCc7Ozjr7y8rKBGtra+Grr76q2RdVz9SVuCQIjE2Wqi7FptoclwShbsYmtVot5OXlCQUFBeJWXFxcbVu///67AEA4fPiwTvmMGTOEnj17ynaNlqDWJ1E9e/YUoqKixM8VFRWCh4eHEBcXZ8ZeGe7GjRsCAOHAgQPm7orebt++LbRp00ZITU0V+vfvXysD1axZs4S+ffuauxtGExoaKkycOFGnbOTIkUJ4eLiZeqSfvwcqrVYrqNVqYenSpWJZfn6+YGNjI3z22Wey9uXevXs6gUbKlp+fX6XMmIGqYcOGQnJysk5ZYmKi4OrqKgiCIPz4448CAOHatWs6dUaNGiU8//zzgiDc/wPnySefrHLupk2bCh988EHNvqR6pq7GJUFgbLIUdSk21ZW4JAh1JzZJSfD0ucFXV9Tq4Xx1eRxmQUEBAMDFxcXMPdFfVFQUQkNDdf7/qW127NgBf39/jBo1Cq6urujWrRs+/PBDc3dLb71790ZaWhp++eUXAMB//vMfHDp0CEOGDDFzzwxz5coVaDQanX9rTk5OCAgIkP13ga2tLVQqlV6bk5NTlTKzrm5PBqvLcQlgbLIUdSk21dW4BNTe2GRra1vjdpRKJfz8/JCWliaWabVapKWlITAwUI5Lsxi1erHdR43DPH/+vJl6ZTitVotp06ahT58+6NSpk7m7o5ctW7bgxIkTOH78uLm7YpDLly9jzZo1iImJwZtvvonjx4/j9ddfh1KpxPjx483dPcneeOMNFBYWol27drC2tkZFRQUWLVqE8PBwc3fNIJXjruvymOwmTZrA2toaeXl5OuV5eXlQq9XVHqNWqx9Zv/J/8/Ly4O7urlPH19dXrPP3iSvKy8tx69ath7Zbn9XVuAQwNlmSuhSb6mpcAupHbAKAmJgYjB8/Hv7+/ujZsycSEhJQVFSEiIgIc3dNVrU6iaqroqKicObMGRw6dMjcXdFLbm4upk6ditTUVEl3MyyRVquFv78/3n33XQBAt27dcObMGSQlJdW6QAUAn3/+OTZv3ozk5GR07NgRWVlZmDZtGjw8PGrl9dQnD97tGzFiBID/3e2Ljo6u9pjAwECkpaXpvDifmpoq3h308fGBWq1GWlqamDQVFhbi6NGjmDJliniO/Px8ZGZmws/PDwCwb98+aLVaBAQEyHOxZJEYmyxHXYpNjEu13+jRo3Hz5k3MnTsXGo0Gvr6+SElJqZI81jnmHk9oiLo4DjMqKkpo3ry5cPnyZXN3RW9ff/21AECwtrYWNwCCQqEQrK2thfLycnN3scZatGghTJo0Safsgw8+EDw8PMzUI8M0b95cWL16tU7ZwoULhbZt25qpR/rB38ad12SChLpgy5Ytgo2NjbBx40bh3LlzwuTJkwVnZ2dBo9EIgiAIL730kvDGG2+I9X/88UehQYMGwrJly4Sff/5ZiI2NFRo2bCicPn1arLN48WLB2dlZ+Oabb4RTp04Jzz33XJWXnkNCQoRu3boJR48eFQ4dOiS0adNGGDt2rOkuvBapi3FJEBibLE1dik11JS4JQv2NTfVVrX4nqi6NwxQEAdHR0fj666+xb98++Pj4mLtLehs0aBBOnz6NrKwscfP390d4eDiysrJgbW1t7i7WWJ8+fapM5/vLL7/Ay8vLTD0yzN27d2FlpfufvbW1NbRa/RZ+tRQPPlGpVPlEpbb9LniU0aNHY9myZZg7dy58fX2RlZWlc7cvJycH169fF+v37t0bycnJWLt2Lbp27YovvvgC27dv1xmKNXPmTLz22muYPHkyevTogTt37iAlJUXnTv3mzZvRrl07DBo0CEOHDkXfvn2xdu1a0114LVKX4hLA2GSp6lJsqqtxCag/saneMncWZ6jH3ZmtLaZMmSI4OTkJ6enpwvXr18Xt7t275u6aUdTWGZCOHTsmNGjQQFi0aJFw4cIFYfPmzYK9vb3w6aefmrtrehk/frzQrFkzcSrZr776SmjSpIkwc+ZMc3ftsW7fvi2cPHlSOHnypABAiI+PF06ePClcvXpVEISaPVEhMoW6EpcEgbHJUtWl2FSb45IgMDbVZ7U+iRIEQVi1apXQokULQalUCj179hSOHDli7i5JhofM1b9hwwZzd80oamugEgRB+Pbbb4VOnToJNjY2Qrt27YS1a9eau0t6KywsFKZOnSq0aNFCsLW1FVq2bCm89dZbQklJibm79lj79++v9r+R8ePHC4JwfyrZt99+W3BzcxNsbGyEQYMGCdnZ2ebtNNVbdSEuCQJjkyWrK7GpNsclQWBsqs8UglBLloQmIiIiIiKyALX6nSgiIiIiIiJTYxJFREREREQkAZMoIiIiIiIiCZhEERERERERScAkioiIiIiISAImUURERERERBIwiSIiIiIiIpKASRQREREREZEETKKIiIiIiIgkYBJFREREREQkAZMoIiIiIiIiCf4/o80B9kpUQosAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -458,20 +494,19 @@ } ], "source": [ - "fig,axs = plt.subplots(1,2,figsize=(8,4))\n", + "fig,axs = plt.subplots(1,2,figsize=(10,4))\n", "\n", "\n", - "axs[0].imshow(model_prf[0,:,:], origin='lower')\n", + "model = axs[0].imshow(model_prf[0,:,:], origin='lower')\n", "axs[0].set_title('lkprf model')\n", + "fig.colorbar(model, ax = axs[0], label='relative flux')\n", "\n", "# Plot the real data. We randomly select the 100th observation from the TPF data cube\n", - "axs[1].imshow(tess_hdulist[1].data['FLUX'][100,:,:], origin='lower')\n", + "data = axs[1].imshow(tess_hdulist[1].data['FLUX'][100,:,:], origin='lower')\n", "axs[1].set_title('Data')\n", + "fig.colorbar(data, ax = axs[1], label = 'flux (e/s)')\n", "\n", - "\n", - "plt.show()\n", - "\n", - "\n" + "plt.show()\n" ] }, { @@ -479,32 +514,22 @@ "id": "2834c30f-bb2a-42d9-bef7-6648687d162b", "metadata": {}, "source": [ - "This looks like a good match! It is clear that the real data does in fact have a few other sources, but overall the modeled PRF matches the observations of the primary star. Let's scale the data a bit so we see the comparison more clearly." + "This looks like a good match! It is clear that the real data does in fact have a few other sources of flux, but overall the modeled PRF matches the observations of the primary star. Let's scale the data a bit so we see the comparison more clearly. \n", + "\n", + "*Note we add some error handling here. The model contains zero values where no flux is expected, which is invalid when taking the log of the value. " ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "568686ab-6603-4d67-a51c-96fa1d69e067", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/4003647498.py:4: RuntimeWarning: divide by zero encountered in log10\n", - " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", - "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/4003647498.py:4: RuntimeWarning: invalid value encountered in log10\n", - " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", - "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/4003647498.py:7: RuntimeWarning: invalid value encountered in log10\n", - " axs[1].imshow(np.log10(tess_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -512,15 +537,19 @@ } ], "source": [ - "fig,axs = plt.subplots(1,2,figsize=(8,4))\n", + "fig,axs = plt.subplots(1,2,figsize=(10,4))\n", "\n", - "\n", - "axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "# Supress warnings due to taking log of 0. These pixels will be nans, and display as white. \n", + "with np.errstate(invalid='ignore', divide='ignore'):\n", + " model = axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", "axs[0].set_title('lkprf model')\n", + "fig.colorbar(model, ax = axs[0], label='log relative flux')\n", "\n", - "axs[1].imshow(np.log10(tess_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n", + "# Supress warnings due to taking log of 0. These pixels will be nans, and display as white. \n", + "with np.errstate(invalid='ignore'):\n", + " data = axs[1].imshow(np.log10(tess_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n", "axs[1].set_title('Data')\n", - "\n", + "fig.colorbar(data, ax = axs[1], label = 'log flux (e/s)')\n", "\n", "plt.show()" ] @@ -530,12 +559,13 @@ "id": "f436469a-c0ea-4d9c-a92a-adc001985482", "metadata": {}, "source": [ + "## Create a PRF model for Kepler\n", "Great! Now let's check out the same target with Kepler. We follow the same steps as above to initialize our PRF object and evaluate the model at the target location." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "id": "9835e700-18ae-4fcb-b4f6-0975f92f2642", "metadata": {}, "outputs": [ @@ -543,20 +573,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "pipeline products: 100%|████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 2.66it/s]\n", - "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/3836829689.py:30: RuntimeWarning: divide by zero encountered in log10\n", - " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", - "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/3836829689.py:30: RuntimeWarning: invalid value encountered in log10\n", - " axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", - "/var/folders/43/zmh1bgsx5x935k5ctwcdnkxhh20lg4/T/ipykernel_61423/3836829689.py:33: RuntimeWarning: invalid value encountered in log10\n", - " axs[1].imshow(np.log10(kepler_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n" + "pipeline products: 100%|██████████████████████████| 1/1 [00:00<00:00, 2.51it/s]\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzcAAAFbCAYAAADoeHDSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABNmUlEQVR4nO3deXgUZbr38V8nMRuQsAXCEkJYBEEQBNnPiIIiouDM0Tl6UAkqokaRxYW4sKgYt6MselCYGcEFkBeFcRcGBMbDIquIimwBIgq4kUAIgXTX+weTHiNbqquru7rr+7muusZUqu+6OwPcuft56nk8hmEYAgAAAIAIFxPuBAAAAAAgGGhuAAAAAEQFmhsAAAAAUYHmBgAAAEBUoLkBAAAAEBVobgAAAABEBZobAAAAAFGB5gYAAABAVKC5AQAAABAVaG5QwYwZM+TxeLRr1y7/ucaNG+uqq64KWQ6vv/66WrZsqXPOOUfVq1cP2X3NWrp0qTwej5YuXWr6taf6OQMAAMAamhs4ypYtW5Sdna2mTZtq+vTpmjZtWrhTAgC4TPkHUOVHYmKi6tevrz59+mjy5Mk6dOhQQHFXrFihcePG6eDBg8FNGIBfXLgTAH5r6dKl8vl8mjRpkpo1axbudAAALvbYY48pKytLx48f1759+7R06VINHz5czz//vN599121bdvWVLwVK1Zo/Pjxys7OdvTMBCCS0dzAEYqLi1WlShUdOHBAkvhHHwAQdn379lXHjh39X+fm5mrJkiW66qqr1L9/f33zzTdKSkoKY4YAfo9paQjIzJkzFRcXp/vvv1+StGvXLnk8Hj333HN64YUXlJmZqaSkJF188cXavHlzhddmZ2eratWq2rFjh6688kpVq1ZNAwcOVOPGjTV27FhJUlpamjwej8aNG3faHMrj7NmzR1dddZWqVq2qBg0a6KWXXpIkffnll7r00ktVpUoVZWZmatasWSfF2Llzp6677jrVrFlTycnJ6tKliz744IOTrvvuu+90zTXXqEqVKqpTp45GjBih0tLSU+a1evVqXXHFFUpNTVVycrIuvvhi/d///V+lfq4AAGe79NJL9eijj2r37t164403JEmbNm1Sdna2mjRposTERKWnp+uWW27Rzz//7H/duHHj/DUzKyvLP+Wt/NnLV199VZdeeqnq1KmjhIQEtWrVSlOnTg35+wMiHSM3MG3atGm644479NBDD+mJJ56o8L3XXntNhw4dUk5Ojo4ePapJkybp0ksv1Zdffqm6dev6rysrK1OfPn3Uo0cPPffcc0pOTlZ2drZee+01zZ8/X1OnTlXVqlXPOuTv9XrVt29f/eEPf9AzzzyjN998U3fffbeqVKmihx9+WAMHDtSf/vQnvfzyy7r55pvVtWtXZWVlSZL279+vbt266ciRIxo2bJhq1aqlmTNnqn///po3b57++Mc/SpJKSkrUq1cv7dmzR8OGDVP9+vX1+uuva8mSJSfls2TJEvXt21cdOnTQ2LFjFRMT4y9Y//znP9WpUyerP34AQJjddNNNeuihh7Rw4UINGTJEixYt0s6dOzV48GClp6frq6++0rRp0/TVV19p1apV8ng8+tOf/qStW7dq9uzZeuGFF1S7dm1JJz7Mk6SpU6eqdevW6t+/v+Li4vTee+/prrvuks/nU05OTjjfLhBZDOA3Xn31VUOSkZ+f7z+XmZlp9OvXzzAMw5g0aZLh8XiMxx9/vMLr8vPzDUlGUlKS8d133/nPr1692pBkjBgxwn9u0KBBhiRj9OjRJ91/7NixhiTjxx9/PGuu5XGefPJJ/7lff/3VSEpKMjwejzFnzhz/+S1bthiSjLFjx/rPDR8+3JBk/POf//SfO3TokJGVlWU0btzY8Hq9hmEYxsSJEw1Jxty5c/3XFRcXG82aNTMkGZ9++qlhGIbh8/mM5s2bG3369DF8Pp//2iNHjhhZWVnGZZdd5j93qp8zAMAZyv+NXrNmzWmvSU1NNdq3b28Yxol/539v9uzZhiRj+fLl/nPPPvvsaf/tP1WMPn36GE2aNAngHQDuxbQ0VNozzzyje++9V08//bQeeeSRU15zzTXXqEGDBv6vO3XqpM6dO+vDDz886do777wzKHnddttt/v+uXr26WrRooSpVqujPf/6z/3yLFi1UvXp17dy503/uww8/VKdOndSjRw//uapVq+r222/Xrl279PXXX/uvq1evnq699lr/dcnJybr99tsr5LFx40Zt27ZN//3f/62ff/5ZP/30k3766ScVFxerV69eWr58uXw+X1DeM5zj6NGjKioqCug4evRouNMHEKCqVav6V0377XM3R48e1U8//aQuXbpIktavX1+peL+NUVhYqJ9++kkXX3yxdu7cqcLCwiBmDjdwc21iWhoqZdmyZfrggw/04IMP+ucMn0rz5s1POnfuuedq7ty5Fc7FxcWpYcOGlvNKTEz0D+mXS01NVcOGDeXxeE46/+uvv/q/3r17tzp37nxSzPPOO8///fPPP1+7d+9Ws2bNTorXokWLCl9v27ZNkjRo0KDT5ltYWKgaNWpU4p0hEhw9elRZmVW174A3oNenp6crPz9fiYmJQc4MgN0OHz6sOnXqSJJ++eUXjR8/XnPmzPEvjFOuso3J//3f/2ns2LFauXKljhw5clKM1NTU4CSOqOf22kRzg0pp3bq1Dh48qNdff11Dhw71P7cSqISEBMXEWB84jI2NNXXeMAzL9zyd8lGZZ599Vu3atTvlNVWrVrXt/gi9Y8eOad8Br3ava6yUaub+PBcd8imzwy4dO3YsYgsI4FbfffedCgsL/VsW/PnPf9aKFSt0//33q127dqpatap8Pp+uuOKKSo3Y79ixQ7169VLLli31/PPPKyMjQ/Hx8frwww/1wgsvMOoPU9xem2huUCm1a9fWvHnz1KNHD/Xq1UufffaZ6tevf9J15aMXv7V161Y1btw4BFmak5mZqW+//fak81u2bPF/v/x/N2/eLMMwKoze/P61TZs2lSSlpKSod+/edqUNB6pazaOq1Txnv/A3fDJ3PQDneP311yVJffr00a+//qrFixdr/PjxGjNmjP+aU9XD388AKPfee++ptLRU7777rho1auQ//+mnnwY5c7iJW2sTz9yg0ho2bKh//OMfKikp0WWXXVZhictyCxYs0N69e/1ff/7551q9erX69u0bylQr5corr9Tnn3+ulStX+s8VFxdr2rRpaty4sVq1auW/7vvvv9e8efP81x05ckTTpk2rEK9Dhw5q2rSpnnvuOR0+fPik+/344482vROEm9fwBXQAiDxLlizR448/rqysLA0cONA/U+D3MwMmTpx40murVKkiSTp48GCF86eKUVhYqFdffTWImcNt3FqbGLmBKc2aNdPChQvVs2dP9enTR0uWLFFKSkqF7/fo0UN33nmnSktLNXHiRNWqVUsPPPBAGLM+tdGjR2v27Nnq27evhg0bppo1a2rmzJnKz8/X22+/7Z82N2TIEL344ou6+eabtW7dOtWrV0+vv/66kpOTK8SLiYnRX/7yF/Xt21etW7fW4MGD1aBBA+3du1effvqpUlJS9N5774XjrcJmPhnyydyUR7PXAwi9jz76SFu2bFFZWZn279+vJUuWaNGiRcrMzNS7776rxMREJSYm+rcjOH78uBo0aKCFCxcqPz//pHgdOnSQJD388MO6/vrrdc455+jqq6/W5Zdfrvj4eF199dUaOnSoDh8+rOnTp6tOnTr64YcfQv22ESXcWptobmBamzZt9NFHH6l37966+uqr9fHHH/u/d/PNNysmJkYTJ07UgQMH1KlTJ7344ouqV69eGDM+tbp162rFihV68MEHNWXKFB09elRt27bVe++9p379+vmvS05O1uLFi3XPPfdoypQpSk5O1sCBA9W3b19dccUVFWL27NlTK1eu1OOPP64XX3xRhw8fVnp6ujp37qyhQ4eG+i0iRHzyyexnXeZfASDUyqeZxcfHq2bNmmrTpo0mTpyowYMHq1q1av7rZs2apXvuuUcvvfSSDMPQ5Zdfro8++uik6dsXXXSRHn/8cb388sv6+OOP5fP5lJ+frxYtWmjevHl65JFHdN999yk9PV133nmn0tLSdMstt4T0PSN6uLU2eQw7n7CGa+zatUtZWVl69tlndd9994U7HSAkioqKlJqaqoItDQJ6aDOj5V4VFhZWGP0EAMAKt9cmnrkBAAAAEBWYlgYAFrl1XjMAwLncWptobgDAIp8MeV1YQAAAzuXW2kRzg6Bo3LixrRtkAk7m1k/HAADO5dbaxDM3AGCR1zACOgAAsEsoatO4cePk8XgqHC1btrTpHVWO40ZufD6fvv/+e1WrVu20O/kCgBWGYejQoUOqX7++fz8jK3z/Osy+BpGD2gTAbpFam1q3bq1//OMf/q/j4sLbXjiuufn++++VkZER7jQAuEBBQYEaNmwY7jQQAahNAELFCbWpqKiowtcJCQlKSEg45bVxcXFKT08PRVqV4rjmpnxTrIKCgohdXxuh98e6Q2yLveeedrbFliQj1r7Y63Nz7AsewYqKipSRkVFhEz4rvAE8tGn2eoSX3bXp6r7PBT3mbx1JP/UvJcFg2PybhGHjQFlJbXtn55fWsu/vuTcxcv8NiT1s7889/pCdsW38//TYUX0163FH1Kbff5gzduxYjRs37pSv2bZtm+rXr6/ExER17dpVeXl5atSoUUA5B4Pjmpvy4f6UlBSaG1RanCfettixCYm2xZbs/cWAv0NnFqzpRV7jxGH2NYgcdtemuDh7/52JO8e+5sZnd3Nj4+/BsQn2/pIdY2MDYkRyc1Nm78899piNsUvt/7k7oTb9/oOc043adO7cWTNmzFCLFi30ww8/aPz48fqP//gPbd68OWhNmlmOa24AINLwzA0AwGms1KbKfpDTt29f/3+3bdtWnTt3VmZmpubOnatbb73V5N2Dg+YGACzyySOvzH3S5jN5PQAAZoSjNlWvXl3nnnuutm/fbimOFSwFDQAW+YzADgAA7BKO2nT48GHt2LFD9erVC86bCADNDQBEmQkTJqhbt25KTk5W9erVw50OACBK3XfffVq2bJl27dqlFStW6I9//KNiY2N1ww03hC0npqUBgEXeAIb+zV5vxrFjx3Tdddepa9eu+utf/2rbfQAAzhWK2vTdd9/phhtu0M8//6y0tDT16NFDq1atUlpamqk4wURzAwAWOa25GT9+vCRpxowZtt0DAOBsoahNc+bMMXV9KNDcAIBFPsMjn8nNOMqvN7NRGgAAlWWlNkUynrkBAIvKPx0ze0gnNkpLTU31H3l5eWF+NwCAaGClNkUyRm4AwCKvYuQ1+VmR91//W9mN0kaPHq2nn376jDG/+eYbtWzZ0lQeAIDoZKU2RTKaGwAIo8pulDZq1ChlZ2ef8ZomTZoEKSsAACITzQ0AWGQEMK/ZMHl9WlpaWFefAQBEllDUJieiuQEAi5y2WtqePXv0yy+/aM+ePfJ6vdq4caMkqVmzZqpatapt9wUAOIfTalOo0NwAgEVeI0Zew+S8Zou7QJ/JmDFjNHPmTP/X7du3lyR9+umn6tmzp303BgA4htNqU6jQ3ACART555DP50KZP9lWQGTNmsMcNALic02pTqNDcAIBFbh36BwA4l1trE/vcAAAAAIgKjNwAgEWBzWuO/KF/AIBzubU20dwAgEUn5jWbG8o3ez0AAGa4tTbR3ACARb4AdoGOhoc2AQDO5dbaRHMDABa5degfAOBcbq1NNDcAYJFPMa5cbhMA4FxurU00NwiJ/xjwrK3xvx/f3rbY3npHbYttt8yX7f25x/8aa1vsbbkjbYsNOI2nzGdrfJMf3ppyvIq9c/QNG8MfSbf3FzmjoX31IzWl2LbYdjt0OMnW+Id/TrQtdtJe++qetzTyn3dxApobALDIa3jkNfkbmNnrAQAww621ieYGACzyBvDQpjcKhv4BAM7l1tpEcwMAFvmMGPlMzvvxRcFDmwAA53JrbaK5AQCL3PrpGADAudxam2huAMAin8zPU7b38XEAgNu5tTbZuH4KAAAAAIQOIzcAYFFgewnw2RIAwD5urU2m38Hy5ct19dVXq379+vJ4PFqwYEGF7xuGoTFjxqhevXpKSkpS7969tW3btmDlCwCOU74LtNkDwUFdAoCTubU2mX4HxcXFuuCCC/TSSy+d8vvPPPOMJk+erJdfflmrV69WlSpV1KdPHx09GrkbIQLAmfjkCehAcFCXAOBkbq1Npqel9e3bV3379j3l9wzD0MSJE/XII49owIABkqTXXntNdevW1YIFC3T99ddbyxYAHCiQT7ui4dMxp6AuAcDJ3FqbgvoO8vPztW/fPvXu3dt/LjU1VZ07d9bKlStP+ZrS0lIVFRVVOAAgkpQvt2n2gP0CqUsStQlA5HNrbQrqO9i3b58kqW7duhXO161b1/+938vLy1Nqaqr/yMjICGZKAAAXC6QuSdQmAIhUYW/PcnNzVVhY6D8KCgrCnRIAmOIzPAEdcC5qE4BI59baFNSloNPT0yVJ+/fvV7169fzn9+/fr3bt2p3yNQkJCUpISAhmGgAQUr4AhvKjYbnNSBBIXZKoTQAin1trU1DfQVZWltLT07V48WL/uaKiIq1evVpdu3YN5q0AwDF8RkxAB+xHXQLgVm6tTaZHbg4fPqzt27f7v87Pz9fGjRtVs2ZNNWrUSMOHD9cTTzyh5s2bKysrS48++qjq16+va665Jph5A4BjeOWR1+TymWavx+lRlwDgZG6tTaabm7Vr1+qSSy7xfz1y5EhJ0qBBgzRjxgw98MADKi4u1u23366DBw+qR48e+vjjj5WYmBi8rAEA+BfqEgCgnOnmpmfPnjIM47Tf93g8euyxx/TYY49ZSgwAIkUgQ/nRMPTvFNQlADiZW2tTUBcUAAA38sr8UL7XnlQAAJDk3tpEcwMAFrn10zEAgHO5tTbR3ACARV4jRl6TBcHs9QAAmOHW2kRzAwAWGfLIZ3Lo34iCFWkAAM7l1tpEcwO/y2Kusy32wXu72RZbkpRxxLbQ7RrutS22JB3z2ffX8EBxVdtiS9KPsdVti93qoRdsi+0tPWpbbCAQcdu+szW+r0lz22IfrWnvL0Oe068VYZk32d4nDLLq/mxb7DY1vrcttiQdOm7faoI/pthbm3bE17Itdom3mm2xfSU+22K7Cc0NAFjk1qF/AIBzubU20dwAgEU+wyOfYe7Ta7PXAwBghltrE80NAFjkVYy8MvnpmMnrAQAww621ieYGACxy66djAADncmttorkBAIt8ipHP5KddZq8HAMAMt9amyH8HAAAAACBGbgDAMq/hkdfkUL7Z6wEAMMOttYmRGwCwqHxes9kDAAC7hLo2PfXUU/J4PBo+fHjw3kQAGLkBAIsMI0Y+k3sDGFGwlwAAwLlCWZvWrFmjV155RW3btg3o9cFEdQUAi7zyBHQAAGCXUNWmw4cPa+DAgZo+fbpq1Khhwzsxh+YGACzyGYEM/4c7awBANLNSm4qKiiocpaWlp71PTk6O+vXrp969e4fonZ0ZzQ0AAAAAv4yMDKWmpvqPvLy8U143Z84crV+//rTfDweeuQEAi3wBzGs2ez0AAGZYqU0FBQVKSUnxn09ISDjp2oKCAt17771atGiREhMTrSUbRDQ3AGCRTx75TM5TNns9AABmWKlNKSkpFZqbU1m3bp0OHDigCy+80H/O6/Vq+fLlevHFF1VaWqrY2FjziVtEcwMAFrl1LwEAgHPZXZt69eqlL7/8ssK5wYMHq2XLlnrwwQfD0thINDcAYBnT0gAATmN3bapWrZrOP//8CueqVKmiWrVqnXQ+lGhuAMAin8xvfMa0NACAndxam2huAAAAAFi2dOnScKdAcwMAVhkBPLRpRMGnYwAA53JrbaK5AQCLyjc/M/saAADs4tbaRHMDABaxoAAAwGncWpsi/x0AQJiVfzpm9rDDrl27dOuttyorK0tJSUlq2rSpxo4dq2PHjtlyPwCAMzmpNoUSIzcAYJGTNvHcsmWLfD6fXnnlFTVr1kybN2/WkCFDVFxcrOeee86WewIAnMdJtSmUaG7gF9u8iW2xy5JtCy1Japr+o22xu9bcaVtsSfr1eBXbYn+XUN222JJ0sMjO/2PPsTF29Lriiit0xRVX+L9u0qSJvv32W02dOpXmxsEO/aGZrfHjjhr2xT5iW2hJks/GfwqMOPt+LpLUrsZ3tsVulfy9bbEl6RevfbWpdkI122JL0o9H7Mv92NEU22J7SiO/sXACmhsAsMjKQ5tFRUUVzickJCghISFouUlSYWGhatasGdSYAABnc+uCAjxzAwAWWZnXnJGRodTUVP+Rl5cX1Ny2b9+uKVOmaOjQoUGNCwBwNp65AQAExMqnYwUFBUpJ+fc0h9ON2owePVpPP/30GWN+8803atmypf/rvXv36oorrtB1112nIUOGmMoPABDZ3DpyQ3MDABZZKSApKSkVmpvTGTVqlLKzs894TZMm/35u7vvvv9cll1yibt26adq0aaZyAwBEPpobAEBADJlfYcbsY8xpaWlKS0ur1LV79+7VJZdcog4dOujVV19VTAwzkAHAbUJRm5yI5gYAosjevXvVs2dPZWZm6rnnntOPP/57JcH09PQwZgYAgP1obgDAIicN/S9atEjbt2/X9u3b1bBhwwrfM4xo+EwOAFAZTqpNoRT0uQper1ePPvpohd2xH3/8cYoqgKjlpBVpsrOzZRjGKQ+3oi4BcCMn1aZQCvrIzdNPP62pU6dq5syZat26tdauXavBgwcrNTVVw4YNC/btACDs3PrpWKSgLgFwI7fWpqA3NytWrNCAAQPUr18/SVLjxo01e/Zsff7558G+FQA4glsLSKSgLgFwI7fWpqBPS+vWrZsWL16srVu3SpK++OILffbZZ+rbt+8pry8tLVVRUVGFAwAiiWF4AjoQGmbrkkRtAhD53Fqbgj5yM3r0aBUVFally5aKjY2V1+vVhAkTNHDgwFNen5eXp/Hjxwc7DQAAJJmvSxK1CQAiVdBHbubOnas333xTs2bN0vr16zVz5kw999xzmjlz5imvz83NVWFhof8oKCgIdkoAYCufPAEdCA2zdUmiNgGIfG6tTUEfubn//vs1evRoXX/99ZKkNm3aaPfu3crLy9OgQYNOuj4hIUEJCQnBTgMAQsat85ojhdm6JFGbAEQ+t9amoDc3R44cOWk37NjYWPl8vmDfCgAcIZB5ytEwrzlSUJcAuJFba1PQm5urr75aEyZMUKNGjdS6dWtt2LBBzz//vG655ZZg3woAHMGtn45FCuoSADdya20KenMzZcoUPfroo7rrrrt04MAB1a9fX0OHDtWYMWOCfSsAcAS3fjoWKahLANzIrbUp6AsKVKtWTRMnTtTu3btVUlKiHTt26IknnlB8fHywbwUAsMG4ceNOOWWrsLBQN9xwQxgysoa6BADuEfTmBgDcxvjX0L+Zw8mfjv31r39Vjx49tHPnTv+5pUuXqk2bNtqxY0cYMwMAVFa01abKorkBAIsMSYZh8gh30mewadMmNWzYUO3atdP06dN1//336/LLL9dNN92kFStWhDs9AEAlRFttqqygP3MDAG7jk0cek3sDOHkvgRo1amju3Ll66KGHNHToUMXFxemjjz5Sr169wp0aAKCSoq02VRYjNwBgUflDm2YPJ5syZYomTZqkG264QU2aNNGwYcP0xRdfhDstAEAlRWNtqgxGbuBX1DbNttjHatg70Nmv7mbbYmfE/2xbbEnaF5NqW+xSn71/xY8fOce22NV+te/PjPdYcGP7DI88UbTc5hVXXKG1a9dq5syZuvbaa1VSUqKRI0eqS5cuGj9+vB544IFwpxh1yhLt/fNwPMm++IbNH5OWJdkYPN7evY4uTtliW+xasYdtiy1Je8tq2BrfTsWl9i0Wcs5h+/4ueUuDGzvaalNlMXIDAKjA6/Vq06ZNuvbaayVJSUlJmjp1qubNm6cXXnghzNkBAHB6jNwAgEXlD2KafY1TLVq06JTn+/Xrpy+//DLE2QAAAhFttamyaG4AwCI3bZRWu3btcKcAAKgEN9Wm36K5AQCLoq2AxMTEyOM5fX5erzeE2QAAAhFttamyaG4AwKJoe2hz/vz5Fb4+fvy4NmzYoJkzZ2r8+PFhygoAYEa01abKorkBAIuibV7zgAEDTjp37bXXqnXr1nrrrbd06623hiErAIAZ0VabKovmBgBQKV26dNHtt98e7jQAABHu4MGDmj9/vv75z39q9+7dOnLkiNLS0tS+fXv16dNH3bp1Czg2S0EDgEUnPh0zu1FauLM2p6SkRJMnT1aDBg3CnQoAoBKcWJu+//573XbbbapXr56eeOIJlZSUqF27durVq5caNmyoTz/9VJdddplatWqlt956K6B7MHIDABZF20ObNWrUqLCggGEYOnTokJKTk/XGG2+EMTMAQGU5sTa1b99egwYN0rp169SqVatTXlNSUqIFCxZo4sSJKigo0H333WfqHjQ3AGCR8a/D7Guc6oUXXqjQ3MTExCgtLU2dO3dWjRqRu2s5ALiJE2vT119/rVq1ap3xmqSkJN1www264YYb9PPPP5u+B80NAFjkxE/HrMjOzg53CgAAi5xYm87W2Fi9XqK5AQDrnPjxmEmbNm2q9LVt27a1MRMAQFA4vDbNnDlTtWvXVr9+/SRJDzzwgKZNm6ZWrVpp9uzZyszMDCguzQ0AQO3atZPH45FxlqdJPR4Pm3gCACx78sknNXXqVEnSypUr9dJLL+mFF17Q+++/rxEjRuidd94JKC7NDQBYFcDQvxw2LS0/Pz/cKQAAgsnhtamgoEDNmjWTJC1YsED/+Z//qdtvv13du3dXz549A47LUtAAYFH5RmlmDyf54x//qJSUFGVmZmrmzJlKS0tTZmbmKQ8AgPM5vTZVrVrVv2DAwoULddlll0mSEhMTVVJSEnBcmhsAsMj8PgIBfJpms2+++UbFxcWSpPHjx+vw4cNhzggAYIXTa9Nll12m2267Tbfddpu2bt2qK6+8UpL01VdfqXHjxgHHZVoaAFhleMwP5TusuWnXrp0GDx6sHj16yDAMPffcc6pateoprx0zZkyIswMAmObw2vTSSy/pkUceUUFBgd5++23/ymjr1q3TDTfcEHBcmhsAsCiQoXynTUubMWOGxo4dq/fff18ej0cfffSR4uJOLhEej4fmBgAigFNr09/+9jf1799ftWvX1osvvnjS98ePH28pPs0NAEAtWrTQnDlzJJ3YtHPx4sWqU6dOmLMCADjZ1KlTNXXqVO3atUuS1Lp1a40ZM0Z9+/Y97WveeOMN3XXXXbrwwgs1YMAADRgwQC1btgxaTjxzAwBWGQEeDuXz+WhsACDShaA2NWzYUE899ZTWrVuntWvX6tJLL9WAAQP01VdfnfY1S5Ys0Q8//KC77rpL69atU6dOndS8eXONGjVKy5cvl8/nM/9ef4PmBgAscvpDmwAA9wlFbbr66qt15ZVXqnnz5jr33HM1YcIEVa1aVatWrTrj62rUqKEbb7xRc+fO1U8//aTJkyerpKREAwcOVJ06dXTzzTdr3rx5/oVuzKC5AYBgiJJRGwBAFAmwNhUVFVU4SktLz3orr9erOXPmqLi4WF27dq10ivHx8erbt6/+93//VwUFBfr444/VuHFjPf7443r++ecrHaccz9wAgEWBfNrFyA0AwE5WalNGRkaF82PHjtW4ceNO+Zovv/xSXbt21dGjR1W1alXNnz9frVq1qvQ9jx07pvz8fDVt2lRxcXHq2LGjOnbsqMcee0zHjx83lb9EcxNRLu9kbfWIszncLcW22GXVzf/hNKNNYoFtsXsmWZv7eTZbj++3LfaKwqa2xZakcw6cY1vs5AP2/dzLjtv7/ylglmH3PAob4/vi7YstSceq2zfUmZR61LbYktT8nJ9si31efLJtsSXpJ+/3tsWeeKSRbbEl6dDPVWyLnVxmW2h5bIxtVkFBgVJS/v17YUJCwmmvbdGihTZu3KjCwkLNmzdPgwYN0rJly87a4Bw5ckT33HOPZs6cKUnaunWrmjRponvuuUcNGzbUgw8+qHPOMf97BtPSAMCqKFtQQJIOHjyov/zlL8rNzdUvv/wiSVq/fr327t0b5swAAJVioTalpKRUOM7U3MTHx6tZs2bq0KGD8vLydMEFF2jSpElnTS83N1dffPGFli5dqsTERP/53r17+1fvDAQjNwBgmedfh9nXONOmTZvUu3dvpaamateuXRoyZIhq1qypd955R3v27NFrr70W7hQBAGcVntrk8/kq9YzOggUL9NZbb6lLly7yeP5939atW2vHjh0B35+RGwCwKspGbkaOHKns7Gxt27atwqdpV155pZYvXx7GzAAAlRaC2pSbm6vly5dr165d+vLLL5Wbm6ulS5dq4MCBZ33tjz/+eMptB4qLiys0O2bR3ACAVVHW3KxZs0ZDhw496XyDBg20b9++MGQEADAtBLXpwIEDuvnmm9WiRQv16tVLa9as0SeffKLLLrvsrK/t2LGjPvjgA//X5Q3NX/7yF1Orrf0e09IAwCrDc+Iw+xqHSkhIUFFR0Unnt27dqrS0tDBkBAAwLQS16a9//au5+L/x5JNPqm/fvvr6669VVlamSZMm6euvv9aKFSu0bNmygOMycgMAqKB///4VluD0eDzas2ePHnzwQf3nf/5nmLMDAESDHj16aOPGjSorK1ObNm20cOFC1alTRytXrlSHDh0CjsvIDQBYZBgnDrOvcar/+Z//0bXXXqs6deqopKREF198sfbt26euXbtqwoQJ4U4PAFAJkVCbmjZtqunTpwc1pi0jN3v37tWNN96oWrVqKSkpSW3atNHatWvtuBUAhF+UPXOTmpqqRYsW6b333tPkyZN1991368MPP9SyZctUpYp9+0fYiboEwHUcWJuKi4ttvV6yYeTm119/Vffu3XXJJZfoo48+UlpamrZt26YaNWoE+1YA4AxR9sxNQUGBMjIy1KNHD/Xo0SPc6VhGXQLgSg6sTc2aNdO9996rQYMGqV69eqdOwTD0j3/8Q88//7z+8Ic/KDc319Q9gt7cPP3008rIyNCrr77qP5eVlRXs2wCAY3iME4fZ1zhV48aN1aNHD91444269tprI74JoC4BcCMn1qalS5fqoYce0rhx43TBBReoY8eOql+/vhITE/Xrr7/q66+/1sqVKxUXF6fc3NxTrtx5NkGflvbuu++qY8eOuu6661SnTh21b9/+jHPpSktLVVRUVOEAgIjiwKF/K9auXatOnTrpscceU7169XTNNddo3rx5ldqUzYnM1iWJ2gQgCjiwNrVo0UJvv/22tm7dqj//+c/au3ev5s2bp+nTp2vp0qVq0KCBpk+frl27dumuu+5SbGys6XsEvbnZuXOnpk6dqubNm+uTTz7RnXfeqWHDhmnmzJmnvD4vL0+pqan+IyMjI9gpAQBMaN++vZ599lnt2bPHP43r9ttvV926dXXLLbeEOz3TzNYlidoEAHZq1KiRRo0apQULFmjDhg3asmWLPvvsM02ZMkVXXXVVQE1NuaA3Nz6fTxdeeKGefPJJtW/fXrfffruGDBmil19++ZTX5+bmqrCw0H8UFBQEOyUAsFf5vGazh8N5PB5dcsklmj59uv7xj38oKyvrjA2BU5mtSxK1CUAUiNLadDZBb27q1aunVq1aVTh33nnnac+ePae8PiEhQSkpKRUOAIgoDhz6D4bvvvtOzzzzjNq1a6dOnTqpatWqeumll8Kdlmlm65JEbQIQBaK0Np1N0Jub7t2769tvv61wbuvWrcrMzAz2rQDAGRxWQPr3769GjRopMTFR9erV00033aTvv/++0q9/5ZVXdPHFF6tx48Z67bXX9F//9V/asWOH/vnPf+qOO+6wL3GbUJcAuJLDalOoBL25GTFihFatWqUnn3xS27dv16xZszRt2jTl5OQE+1YA4AwOKyCXXHKJ5s6dq2+//VZvv/22duzYoWuvvbbSr3/iiSfUuXNnrVu3Tps3b1Zubm5ENwLUJQCu5LDaFCpBXwr6oosu0vz585Wbm6vHHntMWVlZmjhxogYOHBjsWwGAM1jYS+D3q3AlJCQoISHBUjojRozw/3dmZqZGjx6ta665RsePH9c555xz1tfv2bNHHk/kz7suR10C4EoO3OcmFILe3EjSVVddpauuusqO0AAQVX6/CtfYsWM1bty4oMX/5Zdf9Oabb6pbt25nbGw2bdqk888/XzExMfryyy/PGLNt27ZByy9UqEsA4Czjxo3TmDFjFBNTcSJZYWGh7rjjDs2ePTuguLY0NwDgJlY2SisoKKjwsLrVUZtyDz74oF588UUdOXJEXbp00fvvv3/G69u1a6d9+/apTp06ateunTwejwzj32+q/GuPxyOv1xuUHAEA9nHiJp6/9de//lULFy7UG2+8oSZNmkg6scnnzTffrPT09IDjBv2ZGwBwHQvzmn+/ItfpmpvRo0fL4/Gc8diyZYv/+vvvv18bNmzQwoULFRsbq5tvvrlCs/J7+fn5SktL8//3zp07lZ+f7z/Kv965c6elHxUAIEQc/szNpk2b1LBhQ7Vr107Tp0/X/fffr8svv1w33XSTVqxYEXBcRm4AIAKMGjVK2dnZZ7ym/JMvSapdu7Zq166tc889V+edd54yMjK0atUqde3a9ZSv/e2CAbt371a3bt0UF1exRJSVlWnFihURvbgAAMAZatSooblz5+qhhx7S0KFDFRcXp48++ki9evWyFJfmBgAs8iiAoX+T90hLS/OPrJjl8/kkSaWlpZW6/pJLLtEPP/ygOnXqVDhfWFioSy65hGlpABABQlGbrJoyZYomTZqkG264QevWrdOwYcM0a9YsXXDBBQHHpLmJJGeYUhKU8Hb+ifbZ+9dlRXFz22K3T9hoW2xJ2na8lm2xV+Y3OftFFiT+at//r94EG2PHBDm2g1akWb16tdasWaMePXqoRo0a2rFjhx599FE1bdr0tKM2J6X2r2drfu/nn39WlSpVgp0yJHl8Nt/AxvJh2DzB3WNjL23YvDLUmqONbIt97jkHbIstSbvLzr6yYqD+8X0L22JLUuxBG3+9tfOPTLBjO6g2ncoVV1yhtWvXaubMmbr22mtVUlKikSNHqkuXLho/frweeOCBgOLS3ABAFElOTtY777yjsWPHqri4WPXq1dMVV1yhRx555KyLFfzpT3+SdGLxgOzs7ArXe71ebdq0Sd26dbM1fwCAO5TXlfr160uSkpKSNHXqVF111VW67bbbaG4AIGwCeQjTpk/S27RpoyVLlgT02tTUVEknRm6qVaumpKQk//fi4+PVpUsXDRkyJCh5AgBs5qDadCqLFi065fl+/fqddUuCM6G5AQCrHF5AKuvVV1+VJDVu3Fj33XcfU9AAIJJFcG2qXbt2wK+luQEAi5y+l4BZY8eODXcKAACLnF6bYmJiTvl8Z7lAF6+huQEAqyL407HTmTdvnubOnas9e/bo2LFjFb63fv36MGUFAKg0h9em+fPnV/j6+PHj2rBhg2bOnKnx48cHHJfmBgCscngBMWvy5Ml6+OGHlZ2drb///e8aPHiwduzYoTVr1ignJyfc6QEAKsPhtWnAgAEnnbv22mvVunVrvfXWW7r11lsDimvzAo4AgEjzv//7v5o2bZqmTJmi+Ph4PfDAA1q0aJGGDRumwsLCcKcHAIhiXbp00eLFiwN+Pc0NAFhUPq/Z7OFUe/bs8S/5nJSUpEOHDkmSbrrpJs2ePTucqQEAKikSa1NJSYkmT56sBg0aBByDaWkAYJXDN0ozKz09Xb/88osyMzPVqFEjrVq1ShdccIHy8/Nl2LyZMAAgSBxem2rUqFFhQQHDMHTo0CElJyfrjTfeCDguzQ0AWOXwec1mXXrppXr33XfVvn17DR48WCNGjNC8efO0du1a/0afAACHc3hteuGFFyo0NzExMUpLS1Pnzp1Vo0aNgOPS3ACARU5fbtOsadOmyefzSZJycnJUq1YtrVixQv3799fQoUPDnB0AoDKcXpuys7NtiUtzAwBWOfzTMbNiYmIUE/PvRzKvv/56XX/99WHMCABgmgNr06ZNmyp9bdu2bQO6B80NACAkBQcA4G7t2rWTx+M56/ObHo+HTTwBIGwCWWHGYSM3oSg4AIAQcmBtys/Pt/cGorkBAOscOPRvVigKDgAghBxYm/74xz9q8eLFqlGjhh577DHdd999Sk5ODuo9aG4AwCoHFhCzMjMzw50CACCYHFibvvnmGxUXF6tGjRoaP3687rjjDpobAHAap69IE4jXX39dL7/8svLz87Vy5UplZmZq4sSJysrK0oABA8KdHgDgLJxYm9q1a6fBgwerR48eMgxDzz33nKpWrXrKa8eMGRPQPWhuAAAVTJ06VWPGjNHw4cM1YcIE/zM21atX18SJE2luAAABmTFjhsaOHav3339fHo9HH330keLiTm5HPB4PzQ0AIDimTJmi6dOn65prrtFTTz3lP9+xY0fdd999YcwMABDJWrRooTlz5kg6se3A4sWLVadOnaDeg+YGAKxy4LxmK/Lz89W+ffuTzickJKi4uDgMGQEATHN4bSrfLDrYYs5+CQDgTMrnNZs9nCorK0sbN2486fzHH3+s8847L/QJAQBMi7baVFmM3ABAMERBQSg3cuRI5eTk6OjRozIMQ59//rlmz56tvLw8/eUvfwl3egCAyoqi2lRZNDcAYJXDh/7Nuu2225SUlKRHHnlER44c0X//93+rfv36mjRpkq6//vpwpwcAqIwoq02VRXMTQRauGWdr/A63PW9bbE+pvTMgV/2aZVvsn49XsS22JL37bVvbYiduDO7a8b9Xbbc982UladXsUbbFLioqUuq8R4IWz4nLbQaqrKxMs2bNUp8+fTRw4EAdOXJEhw8fDvoDn6ho9Rv2/XmXpD9c/YxtsWOP2furhDfRY1vssuOxtsWWpC+KG9kW22fzkwUzC7raFvvAjlq2xZakxIP2/WziC20LLe+x4MaLptpkBs/cAAD84uLidMcdd+jo0aOSpOTkZBobAEDEYOQGAKyKsqH/Tp06acOGDcrMzAx3KgCAQDm8NtWoUUMez8kjsx6PR4mJiWrWrJmys7M1ePBgU3FpbgDAomgb+r/rrrs0atQofffdd+rQoYOqVKk4NbNtW/umUgIAgsPptWnMmDGaMGGC+vbtq06dOkmSPv/8c3388cfKyclRfn6+7rzzTpWVlWnIkCGVjktzAwBWOfzTMbPKFw0YNmyY/5zH45FhGPJ4PPJ6veFKDQBQWQ6vTZ999pmeeOIJ3XHHHRXOv/LKK1q4cKHefvtttW3bVpMnT6a5AYCQcngBMSs/Pz/cKQAArHJ4bfrkk0/09NNPn3S+V69eGjXqxCIrV155pUaPHm0qLgsKAIBF0bZRWmZm5hkPAIDzhaI25eXl6aKLLlK1atVUp04dXXPNNfr2228r9dqaNWvqvffeO+n8e++9p5o1a0qSiouLVa1aNVM5MXIDAAAAwLRly5YpJydHF110kcrKyvTQQw/p8ssv19dff33S85q/9+ijj+rOO+/Up59+6n/mZs2aNfrwww/18ssvS5IWLVqkiy++2FROto/cPPXUU/J4PBo+fLjdtwKA8DACPBAW1CUArmChNhUVFVU4SktLT3mLjz/+WNnZ2WrdurUuuOACzZgxQ3v27NG6devOmt6QIUO0bNkyValSRe+8847eeecdJScna9myZbr11lslSaNGjdJbb71l6m3bOnKzZs0avfLKK6ysAyC6OXxeM/6NugTANSzUpoyMjAqnx44dq3Hjxp315YWFJ3Y5LZ9Wdjbdu3dX9+7dTaV4NrY1N4cPH9bAgQM1ffp0PfHEE3bdBgDCzunLbeIE6hIAN7FSmwoKCpSSkuI/n5CQcNbX+nw+DR8+XN27d9f5559fqft5vV4tWLBA33zzjSSpdevW6t+/v2JjY80l/hu2TUvLyclRv3791Lt37zNeV1paetLQFwBEFKalRYTK1iWJ2gQgClioTSkpKRWOyjQ3OTk52rx5s+bMmVOp9LZv367zzjtPN998s39a2o033qjWrVtrx44dJt/sv9kycjNnzhytX79ea9asOeu1eXl5Gj9+vB1pAEBIRNvIjV27RoeTmbokUZsARL5Q1qa7775b77//vpYvX66GDRtW6jXDhg1T06ZNtWrVKv80tp9//lk33nijhg0bpg8++CCgXII+clNQUKB7771Xb775phITE896fW5urgoLC/1HQUFBsFMCAJgwZswYxcTEqF+/fho/frzGjx+vfv36KSYmRjk5OTr33HN15513avr06eFOtVLM1iWJ2gQAlWEYhu6++27Nnz9fS5YsUVZWVqVfu2zZMj3zzDMVns+pVauWnnrqKS1btizgnII+crNu3TodOHBAF154of+c1+vV8uXL9eKLL6q0tLTCPLqEhIRKDXUBgGNF2YICdu0aHS5m65JEbQIQBUJQm3JycjRr1iz9/e9/V7Vq1bRv3z5JUmpqqpKSks742oSEBB06dOik84cPH1Z8fLy5RH4j6CM3vXr10pdffqmNGzf6j44dO2rgwIHauHGjpQeEAMCRouyZm08++eSUz6X06tVLn3zyiaQTu0bv3Lkz1KkFhLoEwJVCUJumTp2qwsJC9ezZU/Xq1fMflVm++aqrrtLtt9+u1atXyzAMGYahVatW6Y477lD//v3NJfIbQR+5qVat2kkrJFSpUkW1atWq9MoJABBJPP86zL7Gqcp3jR4xYkSF81Z3jQ4X6hIANwpFbTKMwD+pmzx5sgYNGqSuXbvqnHPOkSSVlZWpf//+mjRpUsBxbd3nBgBcIcqmpdm1azQAIIQcXpuqV6+uv//979q2bZu2bNkiSTrvvPPUrFkzS3FD0twsXbo0FLcBgLCIttXShgwZolatWunFF1/UO++8I0lq0aKFli1bpm7dukk6sWt0JKMuAYh2kVKbmjdvrubNmwctHiM3AICT2LFrNADA3UaOHFnpa59//vmA7kFzAwBWOXzoPxB27BoNAAghB9amDRs2VOq6U+21Vlk0NwAQDA5vVszYvn27rrzySu3du1ctWrSQdGJTy4yMDH3wwQdq2rRpmDMEAFSKw2rTp59+avs9gr4UNAC4Tfm8ZrOHU5XvGl1QUKD169dr/fr12rNnj7KysjRs2LBwpwcAqIRoq02VxcgN/OJK7PsTnbTf3j76m73ptsX+NraObbElybPrzJtcWVF/6cmbYwXTolVjbI0fMRw49G/FsmXLtGrVqlPuGs1zOJEprthrW+yyBvb+KhFbal/s0l/s3ah1/S8ZtsX+9lBd22JL0nc/1rAtduJ+e6e3nnPYxuB2/tsd7NhRVpsqi+YGACyKlBVpKsuuXaMBAKETbbWpspiWBgCowK5dowEAsBvNDQBYZQR4ONTkyZPVtGlTde3aVYmJiUpMTFT37t3VrFkzS7tGAwBCKMpqU2UxLQ0ALIq2oX+7do0GAIROtNWmyqK5AQCrovShzWDvGg0ACKEorU1nQ3MDAFZFQQEJxa7RAIAQioLaFAiaGwBASHaNBgDAbjQ3AGCRU+c1l5aWqnPnzvriiy+0YcMGtWvX7rTXhmLXaABA6Di1NtmN1dIAwCqHrkjzwAMPqH79+vbfCADgPA6tTXajuQEAizyGEdBhp48++kgLFy7Uc889Z+t9AADO5MTaFApMSwMAqyw8tFlUVFThdEJCghISEiyls3//fg0ZMkQLFixQcnKypVgAgAjl0gUFGLkBAIvK5zWbPSQpIyNDqamp/iMvL89SLoZhKDs7W3fccYc6duwYhHcHAIhEVmpTJGPkBgDCqKCgQCkpKf6vTzdqM3r0aD399NNnjPXNN99o4cKFOnTokHJzc4OaJwAAkYDmBgCssjD0n5KSUqG5OZ1Ro0YpOzv7jNc0adJES5Ys0cqVK09qkjp27KiBAwdq5syZJhMFAEQkl05Lo7kBAItCsdxmWlqa0tLSznrd5MmT9cQTT/i//v7779WnTx+99dZb6ty5s7mbAgAilluXgqa5AQCrHPTpWKNGjSp8XbVqVUlS06ZN1bBhQ3tuCgBwHgfVplCiuQEAi9z66RgAwLncWptobgDAKgd/Ota4cWMZUbBvAQDAJAfXJjuxFDQAAACAqMDIDQAEQTQM5QMAoosbaxPNDQBYZRgnDrOvAQDALi6tTTQ3AGCRWx/aBAA4l1trE80NAFjl0oc2AQAO5tLaRHMDv9VvjrItdpf//h/bYktScUmybbF9sbaFliR99cwI+4KPti80/s3jO3GYfQ1Q7rKY62yNf+S/utgW+5wj9v42FFNmX+xjqfauq7Rr99k33g2U5xx7/xGJ351gW+yEg7aFliTFF9r3ZzLuqH0/97Lj3qDGc2ttYrU0AAAAAFGBkRsAsMqlQ/8AAAdzaW2iuQEAi9z60CYAwLncWptobgDAKpcutwkAcDCX1iaaGwCwyK2fjgEAnMuttYnmBgCscum8ZgCAg7m0NrFaGgAAAICoEPTmJi8vTxdddJGqVaumOnXq6JprrtG3334b7NsAgGOUD/2bPRA61CYAbuPW2hT05mbZsmXKycnRqlWrtGjRIh0/flyXX365iouLg30rAHCG8oc2zR4IGWoTANdxaW0K+jM3H3/8cYWvZ8yYoTp16mjdunX6wx/+EOzbAUDYufWhzUhCbQLgNm6tTbYvKFBYWChJqlmz5im/X1paqtLSUv/XRUVFdqcEAMHl0oc2Ixm1CUDUc2ltsnVBAZ/Pp+HDh6t79+46//zzT3lNXl6eUlNT/UdGRoadKQFA0Ll1XnOkojYBcAO31iZbm5ucnBxt3rxZc+bMOe01ubm5Kiws9B8FBQV2pgQAcDlqEwBEL9umpd199916//33tXz5cjVs2PC01yUkJCghIcGuNADAfj7jxGH2NQg5ahMA13BpbQp6c2MYhu655x7Nnz9fS5cuVVZWVrBvAQDO4tJ5zZGE2gTAdVxam4I+LS0nJ0dvvPGGZs2apWrVqmnfvn3at2+fSkpKgn0rAHAEjwKY1xzupF2G2gTAbUJRm5YvX66rr75a9evXl8fj0YIFC2x4J+YEvbmZOnWqCgsL1bNnT9WrV89/vPXWW8G+FQA4g0v3Eogk1CYArhOC2lRcXKwLLrhAL730kk1vwjxbpqUBgJu4dS+BSEJtAuA2oahNffv2Vd++fc29yGa273MDAAAAIHL8fm+vSFpkxdaloAHAFYwADwAA7GKhNmVkZFTY6ysvLy/k6QeKkRsAsMhjGPKYnPZk9noAAMywUpsKCgqUkpLiPx8pozYSzQ0AWOf712H2NQAA2MVCbUpJSanQ3EQSmhuExKpZo8KdAmAbRm5gVWwze/fdSd5/zLbYR2udY1tsSTrniH1/V7y77Z2dX/ZTvH2xk2wLLUmqWmDfz91j80aRMV774scesy+2cTy4sd1am2huAMAql26UBgBwsBDUpsOHD2v79u3+r/Pz87Vx40bVrFlTjRo1Mnnz4KC5AQAAAGDa2rVrdckll/i/HjlypCRp0KBBmjFjRlhyorkBAKsC2ZQzCob+AQAOFoLa1LNnT8ftI0ZzAwAWsYknAMBp3FqbaG4AwCpGbgAATuPS2kRzAwAWeXwnDrOvAQDALm6tTTQ3AGCVSz8dAwA4mEtrk70LvAMAAABAiDByAwBWsc8NAMBpXFqbaG4AwCK37gINAHAut9YmmhsAsMql85oBAA7m0tpEcwMAVhmSzK4wE/n1AwDgZC6tTTQ3AGCRW4f+AQDO5dbaxGppAAAAAKICIzcAYJWhAOY125IJAAAnuLQ20dwAgFUufWgTAOBgLq1NNDcAYJVPkieA1wAAYBeX1iaaGwCwyK0PbQIAnMuttYnmBgCscunQPwDAwVxam1gtDQAAAEBUYOQGAKxy6adjAAAHc2ltorkBAKtcWkAAAA7m0tpEcwMAVrl0RRoAgIO5tDbR3ACARU5bkaZx48bavXt3hXN5eXkaPXq0bfeENd7a1WyNH3u0zLbYSQfs/aT3eFX7flWpttfe3MuS7Hu0uaSW2d9azUks9NoW+1hVex/59p5j388mLta+2IYvuLGdVptCheYGAKxy4ND/Y489piFDhvi/rlbN3l+eAQAO48DaFAo0NwAQhapVq6b09PRwpwEAQEixFDQAWOUzAjskFRUVVThKS0uDktJTTz2lWrVqqX379nr22WdVVmbftCQAgANZqE2RjJEbALDKwtB/RkZGhdNjx47VuHHjLKUzbNgwXXjhhapZs6ZWrFih3Nxc/fDDD3r++ectxQUARBCmpQEAAhNAAdGJ6wsKCpSSkuI/m5CQcMqrR48eraeffvqMEb/55hu1bNlSI0eO9J9r27at4uPjNXToUOXl5Z02PgAg2gRemyIZzQ0AWGXh07GUlJQKzc3pjBo1StnZ2We8pkmTJqc837lzZ5WVlWnXrl1q0aKFuTwBAJGJkRsAQEB8hkx/2mVyXnNaWprS0tLM3eNfNm7cqJiYGNWpUyeg1wMAIlAIapMT2bagwEsvvaTGjRsrMTFRnTt31ueff27XrQAA/7Jy5UpNnDhRX3zxhXbu3Kk333xTI0aM0I033qgaNWqEO72woi4BQPSzpbl56623NHLkSI0dO1br16/XBRdcoD59+ujAgQN23A4AwsvwBXbYICEhQXPmzNHFF1+s1q1ba8KECRoxYoSmTZtmy/0iBXUJgOs4qDaFki3NzfPPP68hQ4Zo8ODBatWqlV5++WUlJyfrb3/7mx23A4DwKp/XbPawwYUXXqhVq1bp4MGDKikp0ddff63c3FzXLyRAXQLgOg6qTaEU9Obm2LFjWrdunXr37v3vm8TEqHfv3lq5cuVJ15eWlp60zwMARBSX7iUQKczWJYnaBCAKuLQ2Bb25+emnn+T1elW3bt0K5+vWrat9+/addH1eXp5SU1P9x+/3fAAAx3Ppp2ORwmxdkqhNAKKAS2uTbQsKVFZubq4KCwv9R0FBQbhTAgC4HLUJACJT0JeCrl27tmJjY7V///4K5/fv36/09PSTrk9ISHD9XHAAEc5QAHsJ2JIJTsFsXZKoTQCigEtrU9BHbuLj49WhQwctXrzYf87n82nx4sXq2rVrsG8HAOHn0qH/SEFdAuBKLq1NtmziOXLkSA0aNEgdO3ZUp06dNHHiRBUXF2vw4MF23A4Awsvnk2Ry+Uxf5C+3GUmoSwBcx6W1yZbm5r/+67/0448/asyYMdq3b5/atWunjz/++KSHOQEgKgTyaVcUfDoWSahLAFzHpbXJluZGku6++27dfffddoUHAOdwaQGJNNQlAK7i0toU9tXSAAAAACAYbBu5AQDX8BkyvcRMFGyUBgBwMJfWJpobALDIMHwyDHMPYZq9HgAAM9xamxzX3Bj/mutXVFQU5kwARKvyf1+MYM0tNgzzn3ZFwbxmN7G7NpWVHbUlbij4PLG2xi87bt+vKobhsS22JJXF2Tf733vM5tyPe22L7T1m71MRvlj7fjZlx+375d97/MS/A9QmaxzX3Bw6dEiSlJGREeZMAES7Q4cOKTU11XogI4Ch/ygoIG5CbQIQKtQmaxzX3NSvX18FBQWqVq2aPJ6zd95FRUXKyMhQQUGBUlJSQpBh8JB7eJB7eDgpd8MwdOjQIdWvXz84AX0+yWPy07woGPp3E2pTZCD38CD34KA2BYfjmpuYmBg1bNjQ9OtSUlLC/ocyUOQeHuQeHk7JPSifisE1qE2RhdzDg9ytozZZ57jmBgAijkuH/gEADubS2sQ+NwBgkeHzBXQAAGCXUNaml156SY0bN1ZiYqI6d+6szz//PMjvpvIivrlJSEjQ2LFjlZCQEO5UTCP38CD38Ijk3M+qfBdosweiViT/eSf38CD38Ijk3M8qRLXprbfe0siRIzV27FitX79eF1xwgfr06aMDBw7Y8KbOzmMEbb05AHCXoqIipaam6tKEPyvOE2/qtWXGMS0pnavCwkJHzPMGAESHUNemzp0766KLLtKLL74oSfL5fMrIyNA999yj0aNHm87fKp65AQCrDEOS2RVp+FwJAGAjC7Xp93t6JSQknHJ069ixY1q3bp1yc3P952JiYtS7d2+tXLnSdMrBEPHT0gAAAAAET0ZGhlJTU/1HXl7eKa/76aef5PV6Vbdu3Qrn69atq3379oUi1ZMwcgMAFhk+Q4bH3EgMM4IBAHayUpt+v+9PJD2TRHMDAFYZPpkf+me1NACAjSzUpsru+1O7dm3FxsZq//79Fc7v379f6enp5u4dJExLAwCLDJ8R0AEAgF1CUZvi4+PVoUMHLV682H/O5/Np8eLF6tq1a7DfUqVEfHPjpHW1KysvL08XXXSRqlWrpjp16uiaa67Rt99+G+60THvqqafk8Xg0fPjwcKdSaXv37tWNN96oWrVqKSkpSW3atNHatWvDndZZeb1ePfroo8rKylJSUpKaNm2qxx9/3JFTm5YvX66rr75a9evXl8fj0YIFCyp83zAMjRkzRvXq1VNSUpJ69+6tbdu2hSfZICkzSlXmM3kYpeFOGzahLoVXpNUm6pL93FiXpNDVppEjR2r69OmaOXOmvvnmG915550qLi7W4MGDbXhXlWBEsDlz5hjx8fHG3/72N+Orr74yhgwZYlSvXt3Yv39/uFM7oz59+hivvvqqsXnzZmPjxo3GlVdeaTRq1Mg4fPhwuFOrtM8//9xo3Lix0bZtW+Pee+8NdzqV8ssvvxiZmZlGdna2sXr1amPnzp3GJ598Ymzfvj3cqZ3VhAkTjFq1ahnvv/++kZ+fb/y///f/jKpVqxqTJk0Kd2on+fDDD42HH37YeOeddwxJxvz58yt8/6mnnjJSU1ONBQsWGF988YXRv39/IysryygpKQlPwhaUlJQY6enp5VtAmz7S09Mj8n3j9KhL4RVptYm6FBpuqkuGEZ7aNGXKFKNRo0ZGfHy80alTJ2PVqlU2vbuzi+jmplOnTkZOTo7/a6/Xa9SvX9/Iy8sLY1bmHThwwJBkLFu2LNypVMqhQ4eM5s2bG4sWLTIuvvjiiCgghmEYDz74oNGjR49wpxGQfv36GbfcckuFc3/605+MgQMHhimjyvl9EfH5fEZ6errx7LPP+s8dPHjQSEhIMGbPnh2GDK0rKSkxCgsLAzoitXDi9KhL4ROJtYm6FHpuqEuG4e7aFLHT0srX1e7du7f/XLjX1Q5UYWGhJKlmzZphzqRycnJy1K9fvwo/+0jw7rvvqmPHjrruuutUp04dtW/fXtOnTw93WpXSrVs3LV68WFu3bpUkffHFF/rss8/Ut2/fMGdmTn5+vvbt21fhz05qaqo6d+4ccX9vyyUmJvofvDR7JCYmhjt9BBF1KbwisTZRl8IvGuuS5O7aFLGrpZ1pXe0tW7aEKSvzfD6fhg8fru7du+v8888PdzpnNWfOHK1fv15r1qwJdyqm7dy5U1OnTtXIkSP10EMPac2aNRo2bJji4+M1aNCgcKd3RqNHj1ZRUZFatmyp2NhYeb1eTZgwQQMHDgx3aqaUr3nvpPXwgWChLoVPpNYm6lL4UZeiT8Q2N9EiJydHmzdv1meffRbuVM6qoKBA9957rxYtWhSRXb3P51PHjh315JNPSpLat2+vzZs36+WXX3Z8EZk7d67efPNNzZo1S61bt9bGjRs1fPhw1a9f3/G5A4gskVSXpMiuTdQlIPgidlqaE9fVNuvuu+/W+++/r08//VQNGzYMdzpntW7dOh04cEAXXnih4uLiFBcXp2XLlmny5MmKi4uT1+sNd4pnVK9ePbVq1arCufPOO0979uwJU0aVd//992v06NG6/vrr1aZNG910000aMWLEaXcMdqryv5uR/PcWOB3qUnhEcm2iLoUfdSn6RGxz48R1tSvLMAzdfffdmj9/vpYsWaKsrKxwp1QpvXr10pdffqmNGzf6j44dO2rgwIHauHGjYmNjw53iGXXv3v2kpU23bt2qzMzMMGVUeUeOHFFMTMW/rrGxsfL5ImsjyKysLKWnp1f4e1tUVKTVq1c7/u8tcDbUpfCI5NpEXQo/6lIUCveKBlbMmTPHSEhIMGbMmGF8/fXXxu23325Ur17d2LdvX7hTO6M777zTSE1NNZYuXWr88MMP/uPIkSPhTs20SFmRxjBOLBEaFxdnTJgwwdi2bZvx5ptvGsnJycYbb7wR7tTOatCgQUaDBg38S26+8847Ru3atY0HHngg3Kmd5NChQ8aGDRuMDRs2GJKM559/3tiwYYOxe/duwzBOLLlZvXp14+9//7uxadMmY8CAARG95CbwW9QlZ4iU2kRdCg3qkrtEdHNjGM5aV7uydJp1xV999dVwp2ZapBSQcu+9955x/vnnGwkJCUbLli2NadOmhTulSikqKjLuvfdeo1GjRkZiYqLRpEkT4+GHHzZKS0vDndpJPv3001P++R40aJBhGCeW3Xz00UeNunXrGgkJCUavXr2Mb7/9NrxJA0FEXQq/SKpN1CX7UZfcxWMYDtxKFgAAAABMithnbgAAAADgt2huAAAAAEQFmhsAAAAAUYHmBgAAAEBUoLkBAAAAEBVobgAAAABEBZobAAAAAFGB5gYAAABAVKC5AQAAABAVaG4AAAAARAWaGwAAAABR4f8DlOc2t0Hg/CsAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -594,13 +618,18 @@ "\n", "\n", "# Plot the results\n", - "fig,axs = plt.subplots(1,2,figsize=(8,4))\n", + "fig,axs = plt.subplots(1,2,figsize=(10,4))\n", "\n", - "axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", + "# Supress warnings due to taking log of 0. These pixels will be nans, and display as white. \n", + "with np.errstate(invalid='ignore', divide='ignore'):\n", + " model = axs[0].imshow(np.log10(model_prf[0,:,:]), origin='lower')\n", "axs[0].set_title('lkprf model')\n", + "fig.colorbar(model, ax = axs[0], label='log relative flux')\n", "\n", - "axs[1].imshow(np.log10(kepler_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n", + "with np.errstate(invalid='ignore'):\n", + " data = axs[1].imshow(np.log10(kepler_hdulist[1].data['FLUX'][100,:,:]), origin='lower')\n", "axs[1].set_title('Data')\n", + "fig.colorbar(data, ax = axs[1], label = 'log flux (e/s)')\n", "\n", "plt.show()" ] @@ -610,12 +639,26 @@ "id": "04247d41-8df7-47ee-a9f3-b3e05f0cae94", "metadata": {}, "source": [ - "Excellent! This is a good match to the Kepler observations. \n", - "\n", - "While the shape of the PRF looks correct, it is important to remember that the PRF model contains the relative contribution of the pixels and not the flux-weighted values that we see in the observations (try summing the PRF model and the data above to see this). \n", + "Excellent! This is also looks like a good match to the Kepler observations. " + ] + }, + { + "cell_type": "markdown", + "id": "1af29b85-d074-4437-903f-0045cdf7dd7d", + "metadata": {}, + "source": [ + "## Conclusion\n", "\n", - "In order to combine PRF models for a field of stars to recreate a full TPF (or create your own synthetic TPF), you would want to multiply the PRF by the flux for each target in the field. But this is another topic for another tutorial!" + "While the shape of the PRF looks correct, it is important to remember that the PRF model contains the relative contribution of the pixels and not the flux values (in electrons per second) that we see in the observations. To match the flux values seen in a TPF, you would want to multiply the PRF by the expected flux of the target. " ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f56f623f-01f7-4ed6-877c-813bd52bfd3f", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 44224b1a784db519e39454be11e12ed09fe49174 Mon Sep 17 00:00:00 2001 From: Nschanche Date: Wed, 18 Sep 2024 15:54:36 -0400 Subject: [PATCH 7/9] merge with origin main --- src/lkprf/tessprf.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/lkprf/tessprf.py b/src/lkprf/tessprf.py index e162864..72a133a 100644 --- a/src/lkprf/tessprf.py +++ b/src/lkprf/tessprf.py @@ -38,11 +38,8 @@ def check_coordinates(self, targets: List[Tuple], shape: Tuple): LKPRFWarning, ) -<<<<<<< HEAD if ((np.atleast_1d(column) + shape[1]) >= 2093).any(): -======= - if ((np.atleast_1d(column) + shape[1]) > 2092).any(): ->>>>>>> ae1e3117fe90caad5a9e5d6b1c5ae0f47fca7689 + warnings.warn( "`targets` contains collateral pixels: Column(s) >= 2093 ", LKPRFWarning, From 314a471dda7ae8d5ca419401569a836366ccd2f7 Mon Sep 17 00:00:00 2001 From: Nschanche Date: Fri, 20 Sep 2024 14:48:06 -0400 Subject: [PATCH 8/9] Update change file --- CHANGES.rst | 2 ++ docs/README.md | 2 ++ docs/tutorials/lkprf_TPF_example.ipynb | 8 ++++---- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index 90b795a..20d6e47 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -3,6 +3,8 @@ - Added the option to use the initial TESS commissioning PRF files [#9] - Modified tessprf.py and keplerprf.py to use only the closest PRF measurements to create the supersampled PRF [#8] +- Renamed 'update_coordinates' to 'check_coordinates' for Kepler and TESS +- Added a jupyter notebook demo 1.0.3 (2024-07-30) ================== diff --git a/docs/README.md b/docs/README.md index bdbd6e6..3e42511 100644 --- a/docs/README.md +++ b/docs/README.md @@ -82,6 +82,8 @@ Below is an example image for the TES PRF, for Camera 1, CCD 1, with a source at ![TESS PRF Example](images/TESS.png) +### Where can I learn more? + For more examples of how to use lkprf to generate TPF-like PRF models, see this [tutorial](tutorials/lkprf_TPF_example.ipynb). ## Problems with downloading PRF data diff --git a/docs/tutorials/lkprf_TPF_example.ipynb b/docs/tutorials/lkprf_TPF_example.ipynb index e600a58..c63982f 100644 --- a/docs/tutorials/lkprf_TPF_example.ipynb +++ b/docs/tutorials/lkprf_TPF_example.ipynb @@ -28,10 +28,10 @@ "source": [ "## Tutorial Goals\n", "\n", - "Light from sources does not fall cleanly on a single pixel. Instead, the light is distributed across an area of the detector, known as the Point Spread Function (PSF). The PSF is not constant and varies as a function of spacecraft motion, jitter, location on the detector plane, and detector response. Both [Kepler](https://archive.stsci.edu/missions/kepler/commissioning_prfs/) and [TESS](https://archive.stsci.edu/missions/tess/models/prf_fitsfiles/) have measured the PSF of discrete locations on the CCD in order to model the observed light contribution of a source across the pixels (the Pixel Response Function or PRF). To learn more about the PRF measurements, you can refer to [this paper](https://arxiv.org/pdf/1001.0331).\n", + "Light from sources does not fall cleanly on a single pixel. Instead, the light is distributed across an area of the detector, known as the Point Spread Function (PSF). The PSF is not constant and varies as a function of spacecraft motion, jitter, location on the detector plane, and detector response. Both [Kepler](https://archive.stsci.edu/missions/kepler/commissioning_prfs/) and [TESS](https://archive.stsci.edu/missions/tess/models/prf_fitsfiles/) have measured the PSF of discrete locations on the CCD in order to model the observed light contribution of a source across the pixels (the Pixel Response Function or PRF). To learn more about the PRF measurements, you can refer to [Bryson et al, 2010](https://arxiv.org/pdf/1001.0331).\n", "\n", "\n", - "In this notebook, we demonstrate how to use lkprf to generate a PRF model based on these engineering files. We will create our PRF for a source observed in a real Target Pixel File (TPF). " + "In this notebook, we demonstrate how to use lkprf to generate a PRF model based on the engineering files discussed in this paper. We will create our PRF for a source observed in a real [Target Pixel File (TPF)](https://heasarcdev.gsfc.nasa.gov/docs/tess/data-products.html#target-pixel-files-tpfs). " ] }, { @@ -41,7 +41,7 @@ "source": [ "## Imports\n", "\n", - "This tutorial makes use of a number of packages including [matplotlib](https://matplotlib.org/), [numpy](https://numpy.org/), and [astropy](https://www.astropy.org/). In addition it utilized the [lksearch](https://github.com/lightkurve/lksearch) package, which is designed to search for and download data from the TESS and Kepler/K2 missions. " + "This tutorial makes use of a number of packages including [matplotlib](https://matplotlib.org/), [numpy](https://numpy.org/), and [astropy](https://www.astropy.org/). In addition it utilizes the [lksearch](https://github.com/lightkurve/lksearch) package, which is designed to search for and download data from the TESS and Kepler/K2 missions. " ] }, { @@ -378,7 +378,7 @@ "## Step 2: Create a PRF model\n", "\n", "Now that we have our file, we can set up our PRF model. \n", - "To initiate a PRF object, we need to know which camera and CCD (TESS) or channel (Kepler) the target is on. We also can optionally provide the observing Sector for TESS. This is because two sets of PRF engineering models were produced for TESS. The first models were made during commissioning and are used for the early sectors (Sectors 1-3). The commissioning observations were re-run after Sector 3, and these files can be used for subsequent TESS sectors. If the sector is not specified, the models produced for sectors 4 onwards are used. " + "To initiate a PRF object, we need to know which camera and CCD (TESS) or channel (Kepler) the target is on. We also can optionally provide the observing Sector for TESS. This is because two sets of PRF engineering models were produced for TESS. The first models were made during commissioning and are used for the early Sectors (Sectors 1-3). The commissioning observations were re-run after Sector 3, and these files can be used for subsequent TESS sectors. If the sector is not specified, the models produced for Sectors 4 onwards are used. " ] }, { From e0ee75929e88e7c6d507cb4543d6ad41bd6fc923 Mon Sep 17 00:00:00 2001 From: Nschanche Date: Mon, 23 Sep 2024 13:48:52 -0400 Subject: [PATCH 9/9] fixed formatting --- docs/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/README.md b/docs/README.md index 3e42511..d282231 100644 --- a/docs/README.md +++ b/docs/README.md @@ -82,7 +82,7 @@ Below is an example image for the TES PRF, for Camera 1, CCD 1, with a source at ![TESS PRF Example](images/TESS.png) -### Where can I learn more? +## Where can I learn more? For more examples of how to use lkprf to generate TPF-like PRF models, see this [tutorial](tutorials/lkprf_TPF_example.ipynb).