{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Ramp Optimization Examples\n", "\n", "This notebook outlines an example to optimize the ramp settings for a few different types of observations.\n", "\n", "In these types of optimizations, we must consider observations constraints such as saturation levels, SNR requirements, and limits on acquisition time.\n", "\n", "**Note**: The reported acquisition time does not include obsevatory and instrument-level overheads, such as slew times, filter changes, script compilations, etc. It only includes detector readout times (including reset frames)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Import the usual libraries\n", "import numpy as np\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "# Enable inline plotting at lower left\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import pynrc\n", "from pynrc import nrc_utils\n", "from pynrc.nrc_utils import S, jl_poly_fit\n", "from pynrc.pynrc_core import table_filter\n", "\n", "pynrc.setup_logging('WARNING', verbose=False)\n", "\n", "from astropy.table import Table\n", "\n", "# Progress bar\n", "from tqdm.auto import tqdm, trange" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example 1: M-Dwarf companion (imaging vs coronagraphy)\n", "\n", "We want to observe an M-Dwarf companion (K=18 mag) in the vicinity of a brighter F0V (K=13 mag) in the F430M filter. Assume the M-Dwarf flux is not significantly impacted by the brighter PSF (ie., in the background limited regime). In this scenario, the F0V star will saturate much more quickly compared to the fainter companion, so it limits which ramp settings we can use.\n", "\n", "We will test a couple different types of observations (direct imaging vs coronagraphy)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Get stellar spectra and normalize at K-Band\n", "# The stellar_spectrum convenience function creates a Pysynphot spectrum\n", "bp_k = S.ObsBandpass('k')\n", "sp_M2V = pynrc.stellar_spectrum('M2V', 18, 'vegamag', bp_k)#, catname='ck04models')\n", "sp_F0V = pynrc.stellar_spectrum('F0V', 13, 'vegamag', bp_k)#, catname='ck04models')" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Initiate a NIRCam observation\n", "nrc = pynrc.NIRCam(filter='F430M', wind_mode='WINDOW', xpix=160, ypix=160)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BRIGHT1\n", "BRIGHT2\n", "DEEP2\n", "DEEP8\n", "MEDIUM2\n", "MEDIUM8\n", "RAPID\n", "SHALLOW2\n", "SHALLOW4\n", " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "DEEP8 7 4 35.67 142.66 143.80 99.3 0.628 8.277\n", "DEEP8 7 5 35.67 178.33 179.75 111.0 0.628 8.277\n", "DEEP2 8 4 39.57 158.27 159.40 98.5 0.696 7.804\n", "DEEP2 8 5 39.57 197.83 199.25 110.2 0.696 7.804\n", "DEEP8 5 7 24.52 171.64 173.63 101.4 0.432 7.697\n", "MEDIUM8 8 8 21.73 173.87 176.14 100.5 0.383 7.575\n", "MEDIUM8 8 9 21.73 195.61 198.16 106.6 0.383 7.575\n", "MEDIUM2 10 7 25.63 179.44 181.43 98.6 0.451 7.322\n", "... ... ... ... ... ... ... ... ...\n", "RAPID 10 555 2.79 1546.45 1703.96 101.5 0.049 2.458\n", "RAPID 10 556 2.79 1549.24 1707.03 101.6 0.049 2.458\n", "RAPID 10 557 2.79 1552.02 1710.10 101.7 0.049 2.458\n", "RAPID 10 558 2.79 1554.81 1713.17 101.7 0.049 2.458\n", "RAPID 10 559 2.79 1557.60 1716.24 101.8 0.049 2.458\n", "RAPID 10 560 2.79 1560.38 1719.31 101.9 0.049 2.458\n", "RAPID 10 561 2.79 1563.17 1722.38 102.0 0.049 2.458\n", "RAPID 8 1046 2.23 2331.66 2628.51 102.0 0.039 1.990\n", "Length = 55 rows\n" ] } ], "source": [ "# Set some observing constraints\n", "# Let's assume we want photometry on the primary to calibrate the M-Dwarf for direct imaging\n", "# - Set well_frac_max=0.75\n", "# Want a SNR~100 in the F430M filter\n", "# - Set snr_goal=100\n", "res = nrc.ramp_optimize(sp_M2V, sp_bright=sp_F0V, snr_goal=100, well_frac_max=0.75, verbose=True)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "RAPID 10 539 2.79 1501.87 1654.84 100.0 0.049 2.458\n", "RAPID 10 540 2.79 1504.66 1657.91 100.1 0.049 2.458\n", "BRIGHT1 10 145 5.29 767.65 808.80 99.8 0.093 3.509\n", "BRIGHT1 10 146 5.29 772.95 814.38 100.1 0.093 3.509\n", "BRIGHT2 10 93 5.57 518.27 544.66 99.7 0.098 4.270\n", "BRIGHT2 10 94 5.57 523.84 550.52 100.2 0.098 4.270\n", "SHALLOW2 10 20 13.10 261.92 267.60 99.6 0.230 6.089\n", "SHALLOW2 10 21 13.10 275.02 280.98 102.1 0.230 6.089\n", "SHALLOW4 10 16 13.65 218.45 222.99 99.7 0.240 6.675\n", "SHALLOW4 10 17 13.65 232.11 236.93 102.8 0.240 6.675\n", "MEDIUM2 10 7 25.63 179.44 181.43 98.6 0.451 7.322\n", "MEDIUM2 10 8 25.63 205.08 207.35 105.4 0.451 7.322\n", "MEDIUM8 8 8 21.73 173.87 176.14 100.5 0.383 7.575\n", "MEDIUM8 8 9 21.73 195.61 198.16 106.6 0.383 7.575\n", "DEEP2 8 4 39.57 158.27 159.40 98.5 0.696 7.804\n", "DEEP2 8 5 39.57 197.83 199.25 110.2 0.696 7.804\n", "DEEP8 7 4 35.67 142.66 143.80 99.3 0.628 8.277\n", "DEEP8 7 5 35.67 178.33 179.75 111.0 0.628 8.277\n" ] } ], "source": [ "# Print the Top 2 settings for each readout pattern\n", "res2 = table_filter(res, 2)\n", "print(res2)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "MEDIUM8 10 94 104.77 9848.00 9950.36 99.6 0.001 0.998\n", "MEDIUM8 10 96 104.77 10057.53 10162.07 100.7 0.001 0.998\n", "DEEP8 20 14 414.79 5807.03 5822.27 104.6 0.003 1.370\n", "DEEP8 19 14 393.41 5507.69 5522.94 101.2 0.003 1.362\n" ] } ], "source": [ "# Do the same thing, but for coronagraphic mask instead\n", "nrc = pynrc.NIRCam(filter='F430M', image_mask='MASK430R', pupil_mask='CIRCLYOT', \n", " wind_mode='WINDOW', xpix=320, ypix=320)\n", "\n", "# We assume that longer ramps will give us the best SNR for time\n", "patterns = ['MEDIUM8', 'DEEP8']\n", "res = nrc.ramp_optimize(sp_M2V, sp_bright=sp_F0V, snr_goal=100, \n", " patterns=patterns, even_nints=True)\n", "\n", "# Take the Top 2 settings for each readout pattern\n", "res2 = table_filter(res, 2)\n", "print(res2)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "**RESULTS**\n", "\n", "Based on these two comparisons, it looks like direct imaging is much more efficient in getting to the requisite SNR. In addition, direct imaging gives us a photometric comparison source that is inaccessible when occulting the primary with the coronagraph masks. **Of course, this assumes the companion exists in the background limit as opposed to the contrast limit.**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example 2: Exoplanet Coronagraphy\n", "\n", "We want to observe GJ 504 for an hour in the F444W filter using the MASK430R coronagraph. \n", " - What is the optimal ramp settings to maximize the SNR of GJ 504b?\n", " - What is the final background sensitivity limit?" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Get stellar spectra and normalize at K-Band\n", "# The stellar_spectrum convenience function creates a Pysynphot spectrum\n", "bp_k = pynrc.bp_2mass('ks')\n", "sp_G0V = pynrc.stellar_spectrum('G0V', 4, 'vegamag', bp_k)\n", "\n", "# Choose a representative planet spectrum\n", "planet = pynrc.planets_sb12(atmo='hy3s', mass=8, age=200, entropy=8, distance=17.5)\n", "sp_pl = planet.export_pysynphot()\n", "\n", "# Renormalize to F360M = 18.8\n", "bp_l = pynrc.read_filter('F360M') # \n", "sp_pl = sp_pl.renorm(18.8, 'vegamag', bp_l)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Initiate a NIRCam observation\n", "nrc = pynrc.NIRCam(filter='F444W', pupil_mask='CIRCLYOT', image_mask='MASK430R', \n", " wind_mode='WINDOW', xpix=320, ypix=320)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BRIGHT1\n", "BRIGHT2\n", "DEEP2\n", "DEEP8\n", "MEDIUM2\n", "MEDIUM8\n", "RAPID\n", "SHALLOW2\n", "SHALLOW4\n", " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "DEEP2 17 10 344.23 3442.31 3453.20 672.8 0.777 11.448\n", "DEEP2 16 10 322.85 3228.50 3239.39 651.5 0.728 11.446\n", "DEEP2 16 12 322.85 3874.20 3887.27 713.7 0.728 11.446\n", "DEEP2 15 12 301.47 3617.63 3630.70 689.4 0.680 11.440\n", "DEEP2 14 12 280.09 3361.06 3374.13 664.0 0.632 11.431\n", "DEEP8 17 10 350.65 3506.45 3517.34 676.2 0.791 11.402\n", "DEEP8 16 10 329.26 3292.64 3303.53 655.3 0.743 11.401\n", "DEEP8 15 12 307.88 3694.60 3707.67 694.1 0.695 11.398\n", "... ... ... ... ... ... ... ... ...\n", "BRIGHT2 10 162 21.38 3463.69 3640.10 518.1 0.048 8.587\n", "BRIGHT1 10 166 20.31 3371.75 3552.52 463.1 0.046 7.768\n", "BRIGHT1 10 168 20.31 3412.38 3595.32 465.8 0.046 7.768\n", "BRIGHT1 10 170 20.31 3453.00 3638.12 468.6 0.046 7.768\n", "RAPID 10 304 10.69 3249.88 3580.93 358.9 0.024 5.997\n", "RAPID 10 306 10.69 3271.26 3604.48 360.1 0.024 5.997\n", "RAPID 10 308 10.69 3292.64 3628.04 361.2 0.024 5.997\n", "RAPID 9 334 9.62 3213.53 3577.25 331.8 0.022 5.548\n", "Length = 36 rows\n" ] } ], "source": [ "# Set even_nints=True assume 2 roll angles\n", "res = nrc.ramp_optimize(sp_pl, sp_bright=sp_G0V, tacq_max=3600, tacq_frac=0.05, \n", " even_nints=True, verbose=True)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "RAPID 10 304 10.69 3249.88 3580.93 358.9 0.024 5.997\n", "RAPID 10 306 10.69 3271.26 3604.48 360.1 0.024 5.997\n", "BRIGHT1 10 166 20.31 3371.75 3552.52 463.1 0.046 7.768\n", "BRIGHT1 10 168 20.31 3412.38 3595.32 465.8 0.046 7.768\n", "BRIGHT2 10 158 21.38 3378.17 3550.22 511.7 0.048 8.587\n", "BRIGHT2 10 160 21.38 3420.93 3595.16 514.9 0.048 8.587\n", "SHALLOW2 10 68 50.24 3416.65 3490.70 606.1 0.113 10.258\n", "SHALLOW2 10 70 50.24 3517.14 3593.37 615.0 0.113 10.258\n", "SHALLOW4 10 66 52.38 3457.28 3529.15 619.9 0.118 10.434\n", "SHALLOW4 10 68 52.38 3562.04 3636.09 629.2 0.118 10.434\n", "MEDIUM2 10 34 98.35 3343.96 3380.98 638.0 0.222 10.971\n", "MEDIUM2 10 36 98.35 3540.66 3579.86 656.5 0.222 10.971\n", "MEDIUM8 10 32 104.77 3352.51 3387.36 638.0 0.236 10.962\n", "MEDIUM8 10 34 104.77 3562.04 3599.07 657.7 0.236 10.962\n", "DEEP2 17 10 344.23 3442.31 3453.20 672.8 0.777 11.448\n", "DEEP2 16 10 322.85 3228.50 3239.39 651.5 0.728 11.446\n", "DEEP8 17 10 350.65 3506.45 3517.34 676.2 0.791 11.402\n", "DEEP8 16 10 329.26 3292.64 3303.53 655.3 0.743 11.401\n" ] } ], "source": [ "# Take the Top 2 settings for each readout pattern\n", "res2 = table_filter(res, 2)\n", "print(res2)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "t_acq : 3593.36880\n", "t_exp : 3517.14160\n", "t_frame : 1.06904\n", "t_group : 5.34520\n", "t_int : 50.24488\n", "t_int_tot1: 51.33384\n", "t_int_tot2: 51.33384\n" ] } ], "source": [ "# The SHALLOWs, DEEPs, and MEDIUMs are very similar for SNR and efficiency.\n", "# Let's go with SHALLOW2 for more GROUPS & INTS \n", "# MEDIUM8 would be fine as well.\n", "nrc.update_detectors(read_mode='SHALLOW2', ngroup=10, nint=70)\n", "\n", "keys = list(nrc.multiaccum_times.keys())\n", "keys.sort()\n", "for k in keys:\n", " print(\"{:<10}: {: 12.5f}\".format(k, nrc.multiaccum_times[k]))" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Point Source Sensitivity (5-sigma): 21.43 vegamag\n", "Surface Brightness Sensitivity (5-sigma): 22.74 vegamag/arcsec^2\n" ] } ], "source": [ "# Background sensitivity (5 sigma)\n", "sens_dict = nrc.sensitivity(nsig=5, units='vegamag', verbose=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example 3: Single-Object Grism Spectroscopy\n", "\n", "Similar to the above, but instead we want to obtain a slitless grism spectrum of a K=12 mag M0V dwarf. Each grism resolution element should have SNR~100." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# M0V star normalized to K=12 mags\n", "bp_k = S.ObsBandpass('k')\n", "sp_M0V = pynrc.stellar_spectrum('M0V', 12, 'vegamag', bp_k)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "nrc = pynrc.NIRCam(filter='F444W', pupil_mask='GRISMR', wind_mode='STRIPE', ypix=128)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BRIGHT1\n", "BRIGHT2\n", "DEEP2\n", "DEEP8\n", "MEDIUM2\n", "MEDIUM8\n", "RAPID\n", "SHALLOW2\n", "SHALLOW4\n", " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "DEEP2 10 10 123.03 1230.27 1237.08 332.4 0.071 9.449\n", "DEEP8 10 10 127.08 1270.82 1277.64 336.0 0.074 9.399\n", "MEDIUM2 10 10 62.19 621.89 628.71 231.2 0.036 9.219\n", "MEDIUM8 10 10 66.25 662.45 669.27 236.1 0.038 9.127\n", "SHALLOW4 10 10 33.12 331.23 338.04 161.8 0.019 8.802\n", "SHALLOW2 10 10 31.77 317.71 324.52 157.6 0.018 8.746\n", "BRIGHT2 10 12 13.52 162.23 170.41 98.8 0.008 7.567\n", "BRIGHT2 10 13 13.52 175.75 184.61 102.8 0.008 7.567\n", "BRIGHT1 10 15 12.84 192.65 202.87 100.0 0.007 7.021\n", "BRIGHT1 10 16 12.84 205.49 216.40 103.3 0.007 7.021\n", "RAPID 10 42 6.76 283.91 312.52 99.0 0.004 5.599\n", "RAPID 10 43 6.76 290.67 319.96 100.2 0.004 5.599\n", "RAPID 10 44 6.76 297.43 327.41 101.3 0.004 5.599\n", "RAPID 10 45 6.76 304.19 334.85 102.5 0.004 5.599\n" ] } ], "source": [ "# Set a minimum of 10 integrations to be robust against cosmic rays\n", "# Also set a minimum of 10 groups for good ramp sampling\n", "res = nrc.ramp_optimize(sp_M0V, snr_goal=100, nint_min=10, ng_min=10, verbose=True)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "RAPID 10 42 6.76 283.91 312.52 99.0 0.004 5.599\n", "RAPID 10 43 6.76 290.67 319.96 100.2 0.004 5.599\n", "BRIGHT1 10 15 12.84 192.65 202.87 100.0 0.007 7.021\n", "BRIGHT1 10 16 12.84 205.49 216.40 103.3 0.007 7.021\n", "BRIGHT2 10 12 13.52 162.23 170.41 98.8 0.008 7.567\n", "BRIGHT2 10 13 13.52 175.75 184.61 102.8 0.008 7.567\n", "SHALLOW2 10 10 31.77 317.71 324.52 157.6 0.018 8.746\n", "SHALLOW4 10 10 33.12 331.23 338.04 161.8 0.019 8.802\n", "MEDIUM2 10 10 62.19 621.89 628.71 231.2 0.036 9.219\n", "MEDIUM8 10 10 66.25 662.45 669.27 236.1 0.038 9.127\n", "DEEP2 10 10 123.03 1230.27 1237.08 332.4 0.071 9.449\n", "DEEP8 10 10 127.08 1270.82 1277.64 336.0 0.074 9.399\n" ] } ], "source": [ "# Print the Top 2 settings for each readout pattern\n", "res2 = table_filter(res, 2)\n", "print(res2)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "t_acq : 338.04264\n", "t_exp : 331.22530\n", "t_frame : 0.67597\n", "t_group : 3.37985\n", "t_int : 33.12253\n", "t_int_tot1: 33.80374\n", "t_int_tot2: 33.80374\n" ] } ], "source": [ "# Let's say we choose SHALLOW4, NGRP=10, NINT=10\n", "# Update detector readout\n", "nrc.update_detectors(read_mode='SHALLOW4', ngroup=10, nint=10)\n", "\n", "keys = list(nrc.multiaccum_times.keys())\n", "keys.sort()\n", "for k in keys:\n", " print(\"{:<10}: {: 12.5f}\".format(k, nrc.multiaccum_times[k]))" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "F444W SNR for M0V source\n", " Wave SNR Flux (mJy)\n", "--------- --------- ----------\n", " 3.80 9.52 4.54\n", " 3.90 230.66 4.34\n", " 4.00 246.18 4.15\n", " 4.10 235.68 3.97\n", " 4.20 221.71 3.73\n", " 4.30 197.92 3.26\n", " 4.40 184.55 3.19\n", " 4.50 169.03 2.85\n", " 4.60 154.66 2.79\n", " 4.70 139.31 2.63\n", " 4.80 131.21 2.70\n", " 4.90 115.05 2.60\n", " 5.00 57.52 2.38\n", " 5.10 1.30 2.46\n" ] } ], "source": [ "# Print final wavelength-dependent SNR\n", "# For spectroscopy, the snr_goal is the median over the bandpass\n", "snr_dict = nrc.sensitivity(sp=sp_M0V, forwardSNR=True, units='mJy', verbose=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Mock observed spectrum**\n", "\n", "Create a series of ramp integrations based on the current NIRCam settings. The gen_exposures() function creates a series of mock observations in raw DMS format by default. By default, it's point source objects centered in the observing window." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# Ideal spectrum and wavelength solution\n", "wspec, imspec = nrc.calc_psf_from_coeff(sp=sp_M0V, return_hdul=False, return_oversample=False)\n", "\n", "# Resize to detector window\n", "nx = nrc.det_info['xpix']\n", "ny = nrc.det_info['ypix']\n", "\n", "# Shrink/expand nx (fill value of 0)\n", "# Then shrink to a size excluding wspec=0\n", "# This assumes simulated spectrum is centered\n", "imspec = nrc_utils.pad_or_cut_to_size(imspec, (ny,nx))\n", "wspec = nrc_utils.pad_or_cut_to_size(wspec, nx)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Add simple zodiacal background\n", "im_slope = imspec + nrc.bg_zodi()" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "PPC Amps: 0%| | 0/4 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1,1, figsize=(12,3))\n", "ax.imshow(slope_sim, vmin=0, vmax=10)\n", "\n", "fig.tight_layout()" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "ind = wspec>0\n", "\n", "# Estimate background emission and subtract from slope_sim\n", "bg = np.median(slope_sim[:,~ind])\n", "slope_sim -= bg" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ind = wspec>0\n", "plt.plot(wspec[ind], slope_sim[63,ind])" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "# Extract 2 spectral x 5 spatial pixels\n", "\n", "# First, cut out the central 5 pixels\n", "wspec_sub = wspec[ind]\n", "sh_new = (5, len(wspec_sub))\n", "slope_sub = nrc_utils.pad_or_cut_to_size(slope_sim, sh_new)\n", "slope_sub_ideal = nrc_utils.pad_or_cut_to_size(imspec, sh_new)\n", "\n", "# Sum along the spatial axis\n", "spec = slope_sub.sum(axis=0)\n", "spec_ideal = slope_sub_ideal.sum(axis=0)\n", "spec_ideal_rebin = nrc_utils.frebin(spec_ideal, scale=0.5, total=False)\n", "\n", "# Build a quick RSRF from extracted ideal spectral slope\n", "sp_M0V.convert('mjy')\n", "rsrf = spec_ideal / sp_M0V.sample(wspec_sub*1e4)\n", "\n", "# Rebin along spectral direction\n", "wspec_rebin = nrc_utils.frebin(wspec_sub, scale=0.5, total=False)\n", "spec_rebin_cal = nrc_utils.frebin(spec/rsrf, scale=0.5, total=False)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "# Expected noise per extraction element\n", "snr_interp = np.interp(wspec_rebin, snr_dict['wave'], snr_dict['snr'])\n", "_spec_rebin = spec_ideal_rebin / snr_interp\n", "_spec_rebin_cal = _spec_rebin / nrc_utils.frebin(rsrf, scale=0.5, total=False)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1,1, figsize=(12,8))\n", "ax.plot(sp_M0V.wave/1e4, sp_M0V.flux, label='Input Spectrum')\n", "ax.plot(wspec_rebin, spec_rebin_cal, alpha=0.7, label='Extracted Observation')\n", "ax.errorbar(wspec_rebin, spec_rebin_cal, yerr=_spec_rebin_cal, zorder=3,\n", " fmt='none', label='Expected Error Bars', alpha=0.7, color='C2')\n", "\n", "ax.set_ylim([0,10])\n", "ax.set_xlim([3.7,5.1])\n", "\n", "ax.set_xlabel('Wavelength ($\\mu m$)')\n", "ax.set_ylabel('Flux (mJy)')\n", "ax.set_title('Simulated Spectrum')\n", "\n", "ax.legend(loc='upper right');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example 4: Exoplanet Transit Spectroscopy\n", "\n", "Let's say we want to observe an exoplanet transit using NIRCam grisms in the F322W2 filter. \n", "\n", "We assume a 2.1-hour transit duration for a K6V star (K=8.4 mag)." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "nrc = pynrc.NIRCam('F322W2', pupil_mask='GRISM0', wind_mode='STRIPE', ypix=64)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "# K6V star at K=8.4 mags\n", "bp_k = S.ObsBandpass('k')\n", "sp_K6V = pynrc.stellar_spectrum('K6V', 8.4, 'vegamag', bp_k)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "# Constraints\n", "well = 0.5 # Keep well below 50% full\n", "tacq = 2.1*3600. # 2.1 hour transit duration\n", "ng_max = 30 # Transit spectroscopy allows for up to 30 groups per integrations\n", "nint_max = int(1e6) # Effectively no limit on number of integrations\n", "\n", "# Let's bin the spectrum to R~100\n", "# dw_bin is a passable parameter for specifiying spectral bin sizes\n", "R = 100\n", "dw_bin = (nrc.bandpass.avgwave() / 10000) / R" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BRIGHT1\n", "BRIGHT2\n", "DEEP2\n", "DEEP8\n", "MEDIUM2\n", "MEDIUM8\n", "RAPID\n", "SHALLOW2\n", "SHALLOW4\n", " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "BRIGHT1 24 460 16.01 7363.99 7523.08 30955.5 0.494 356.894\n", "BRIGHT1 24 461 16.01 7380.00 7539.44 30989.1 0.494 356.894\n", "BRIGHT1 24 462 16.01 7396.01 7555.79 31022.7 0.494 356.894\n", "BRIGHT1 24 463 16.01 7412.01 7572.15 31056.3 0.494 356.894\n", "BRIGHT1 24 464 16.01 7428.02 7588.50 31089.8 0.494 356.894\n", "BRIGHT2 23 470 15.67 7363.99 7526.54 30623.8 0.484 352.989\n", "BRIGHT2 23 471 15.67 7379.66 7542.56 30656.4 0.484 352.989\n", "BRIGHT2 23 472 15.67 7395.32 7558.57 30688.9 0.484 352.989\n", "... ... ... ... ... ... ... ... ...\n", "SHALLOW2 10 462 16.01 7396.01 7555.79 30678.0 0.494 352.929\n", "SHALLOW2 10 463 16.01 7412.01 7572.15 30711.2 0.494 352.929\n", "SHALLOW2 10 464 16.01 7428.02 7588.50 30744.4 0.494 352.929\n", "RAPID 30 713 10.22 7285.65 7532.24 30585.0 0.315 352.408\n", "RAPID 30 714 10.22 7295.87 7542.81 30606.5 0.315 352.408\n", "RAPID 30 715 10.22 7306.08 7553.37 30627.9 0.315 352.408\n", "RAPID 30 716 10.22 7316.30 7563.94 30649.3 0.315 352.408\n", "RAPID 30 717 10.22 7326.52 7574.50 30670.7 0.315 352.408\n", "Length = 20 rows\n" ] } ], "source": [ "res = nrc.ramp_optimize(sp_K6V, tacq_max=tacq, nint_max=nint_max, \n", " ng_min=10, ng_max=ng_max, well_frac_max=well, \n", " dw_bin=dw_bin, verbose=True)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "RAPID 30 713 10.22 7285.65 7532.24 30585.0 0.315 352.408\n", "RAPID 30 714 10.22 7295.87 7542.81 30606.5 0.315 352.408\n", "BRIGHT1 24 460 16.01 7363.99 7523.08 30955.5 0.494 356.894\n", "BRIGHT1 24 461 16.01 7380.00 7539.44 30989.1 0.494 356.894\n", "BRIGHT2 23 470 15.67 7363.99 7526.54 30623.8 0.484 352.989\n", "BRIGHT2 23 471 15.67 7379.66 7542.56 30656.4 0.484 352.989\n", "SHALLOW2 10 460 16.01 7363.99 7523.08 30611.6 0.494 352.929\n", "SHALLOW2 10 461 16.01 7380.00 7539.44 30644.8 0.494 352.929\n" ] } ], "source": [ "# Print the Top 2 settings for each readout pattern\n", "res2 = table_filter(res, 2)\n", "print(res2)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "# Even though BRIGHT1 has a slight efficiency preference over RAPID \n", "# and BRIGHT2, we decide to choose RAPID, because we are convinced \n", "# that saving all data (and no coadding) is a better option. \n", "# If APT informs you that the data rates or total data shorage is \n", "# an issue, you can select one of the other options.\n", "\n", "# Update to RAPID, ngroup=30, nint=700 and plot PPM\n", "nrc.update_detectors(read_mode='RAPID', ngroup=30, nint=700)\n", "snr_dict = nrc.sensitivity(sp=sp_K6V, dw_bin=dw_bin, forwardSNR=True, units='Jy')\n", "wave = np.array(snr_dict['wave'])\n", "snr = np.array(snr_dict['snr'])\n", "\n", "# Let assume bg subtraction of something with similar noise\n", "snr /= np.sqrt(2.)\n", "ppm = 1e6 / snr\n", "\n", "# NOTE: We have up until now neglected to include a \"noise floor\"\n", "# which represents the expected minimum achievable ppm from\n", "# unknown systematics. To first order, this can be added in \n", "# quadrature to the calculated PPM.\n", "noise_floor = 30 # in ppm\n", "ppm_floor = np.sqrt(ppm**2 + noise_floor**2)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAF2CAYAAACRRcojAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAABUOElEQVR4nO3dd3yV5f3/8dd1VhJGgDBlTxFERcGBWLeitXS4Wm39uSptbbUuXFXAjdWqrVpbnP1aa7XVqkgdddU6QMGBKCBL9ggJhEDWyTnX74/7nHBIzklOTs7O+/l45JFz3+ce1xUO9+dc21hrERERkdziynQCREREpPUUwEVERHKQAriIiEgOUgAXERHJQQrgIiIiOUgBXEREJAd5UnFRY0wf4FbgAGvtwaF9JcBMYCUwArjeWrs59N5UoBjoBrxurX0pFekSERHJFykJ4MARwIvA2Ih9twNvWGufNcZMBu4GzjHGHAocY639tjHGC3xljHnXWrs9RWkTERHJeSmpQrfW/hOobLT7FODD0Ov3Q9sA3wnvt9b6gcXAkalIl4iISL5IVQk8ml7sDuo7gG7GGE9o/+KI43aE9jVRWFho3W53k/09evSgZ8+eUW9aUVFBly5dmuz/enMlewdWQKdeUNw3rnOak8g5paWlMdOdzPskel425ymb85PovbI5T/mWn0Tvlc15yrf8JHqvtOapezfY9AUbbQ/26jegTfcpLS1l69atTfZXVVXVWGuLop5krU3JD3A0MD9iey0wIPS6BCgPvb4FuDHiuJeA70a7ZocOHWxrXXTRRVH3n3zfu7Z6Ri9rX70+7nMSuU9zxo0bl5b7JHpeNucpm/OT6L2yOU/5lp9E75XNecq3/CR6r7Tmaccma6cX22k3Xp6y+wClNkacTWcv9DnAhNDriaFtgJfD+0Ml8tHAu6lOjM/jwm98UF+T6luJiEg+CtQBEDTejNw+Vb3QjwLOAfYyxtwA/A64HrjTGLM3MAy4CsBaO88Y87Yx5nacXuhX2CR2YJs8eXLU/QUeF3VED+CxzknkPsmW6H3yLU/ZnJ9E75XNecq3/CR6r2zOU77lJ9F7pTVPoQCOK74AnuB9tsd6w9gcWo2sY8eOdteuXUm51jmPzuO3689lr32PgNMeSco1W2v8+PHMnz8/I/dOlXzLU77lB/IvT/mWH8i/POVbfiCUp1eeggcP4TfuK7jtxukpuY8xZoG1dny099rtRC4FHjd1eFWFLiIiiQlXocdZAk+2nArgPXr0SNq1CrwuavFCfV3SrtlaU6ZMydi9UyXf8pRv+YH8y1O+5QfyL0/5lh8I5Slche72ZSQNOVWFPn78eJusapgrnvmM85b+jP0H9YZzNfGbiIi00pq58NgkrutwE3dcfVlKbtFcFXo6x4G3WUVFRcM3ucmTJ7epM0WB10Wt9UJ9bbKSJyIi7UnADyS/Cn327NnMnj07vBlzgHpOBfAuXbowa9aspFzL53ZRbT1qAxcRkcSEq9A9ya1CjyygPvzwwxWxjsupNvBkKvC6qVEJXEREEhUqgcc7jCzZ2m0A97ld1AQ9EFAAFxGRBDR0YlMAT6sCj4sa68WqCl1ERBIRdErgJslV6PFqvwE8PIzMrxK4iIgkoKEKXQE8rXzu8DhwlcBFRCQBoSp0lcDTrMDrdgK42sBFRCQRgXAVeh4tZpIqyRwH7nO7qLNeTLAeggFwNV1nXEREJKZQAHcleSY2jQNvQUMbODhDyXwdknJdERFpJ8JV6EkO4BoH3oKGNnBQO7iIiLReKIC7vGoDTyunDTz0R9dkLiIi0lrBeiD5JfB4td8A7gnNhQ4qgYuISOsF6vBbNz5vZvpQtdsA7vM0agMXERFpjUAdfjx4XCYjt2+3AbzA46Iu3IdPQ8lERKSVbH0d9bjxujMTStt1AFcbuIiIJCoY8FOHB59HATytCjxu9UIXEZGEBeszW4WeU+PAkzqRyx6d2FQCFxGR1rH1Tie2ZFehayKXFhR4NA5cREQSFy6Be5Ncha6JXFqwZxW6SuAiItI6NuB3Arh6oaeXhpGJiEib1NfhVy/09HO7DAET7oWuKnQREWkdG0hNFXq82m0AB7CeAueFSuAiItJKqkLPJHc4gKsELiIirRRITS/0eLXvAK4SuIiIJCpUAve4NQ68RckcBw7g83qp93vwaCpVERFprUAdfjrQSePAW5bMceDgjAX3u3x4VAIXEZHWCtY7vdA1Djz9fB4XfnxqAxcRkVYzWo0scwo8LuqMV23gIiLSaibox2896sSWCT6PizqVwEVEJAEm1IktU6uRpb0N3BhzOdAP2AUUANcB3YCZwEpgBHC9tXZzqtNS4HFTh0rgIiLSesb68eNuH6uRGWPGAudaa8eGtp8Dvg9MAt6w1j5rjJkM3A2ck+r0OCVwjwK4iIi0misYmsilnVShjwDWRmyvBI4DTgE+DO17P7SdcgUeFzWqQhcRkQRkOoCnuwr9Y+AOY0whUAuMxwnovYDK0DE7gG7GGI+1tj7y5NLSUsaPH9/kolOmTGkYH94aBR63sya4SuAiItJKTgB3403CRC6zZs2KNUy6R6xz0hrArbXfGGOmADcCpcCXwHZgC9A59LoY2NY4eAP07NmT+fPnJy09Po+LautRCVxERFonGMBgnV7oSejEFqsgaozZGuucTEzkUm6t/Q2AMeavwIM43zAm4JTGJwJz0pGQAo+LGuuF+p3puJ2IiOSLQB1AaDGT9lGFDvAHY8z/cKrQX7DWLjbGXA/caYzZGxgGXJWOhBR4XNQEPaCpVEVEpDUiA3h7mQvdWntklH3lwEXpTktBqArd1teSmT+/iIjkpIDTyluPG7dmYks/X0MVutrARUSkFUIl8KDxYowCeNoVeNzU4lMvdBERaZ1wAHd5M5aE9h3AvS5qCZXArc10ckREJFcE/AAE3ZkL4Dm1nGjS1wN3u6i1XowNQrAeMvgPISIiOSQYCuAm+XFD64HHocAbmkoVnGp0BXAREYlHqAqdFFShaz3wOPjcoTZwUDu4iIjELwuq0Nt1AC/whNrAQT3RRUQkfqESuFUntswo8Dpt4IACuIiIxC9UAs9k02u7DuA+d2QJXFXoIiISp3AAd/kyloR2HcALvO7dAVzTqYqISLzCndhUAs8Mn9tFnUrgIiLSWg0BPHMl8JwaRpbsceBqAxcRkYQEnbnQTQpK4BoHHge1gYuISEJSWIWuceBxcKZSDY8DVwlcRETiFArgxqNObBnhLGaiEriIiLRSqBe6yWAbeDsP4C7qbMRUqiIiIvEIBXCXR73QM8JpA1cVuoiItFK4DdxTkLEktOsA7nIZAm7NhS4iIq3UUAJXFXrmeAqd3yqBi4hIvELLiXrcmRvMlVPDyJI9DhxCHRCCqAQuIiLxC9RRZz14PO6kX1rjwONU4HXjr/Ph1VSqIiISr4CfOjx43cmvyNY48DgVeFz4jVclcBERiZutr8WPB5/bZCwN7T6A+zwu/ManNnAREYmbDfipx40nBSXweLX7AF7gcePHpxK4iIjELVhfl7Iq9Hi1+wDu87ioM16VwEVEJG7BQB1+68GrKvTMKfC4qMMH9XWZToqIiOQI66/DrxJ4Zvk8oRXJVAIXEZE4hdvAFcAzqMDjotZ61AYuIiJxswGnDdyTwSr0nBoHnoqJXBpWJFMJXERE4mTr60LDyJJfDtZELnHyeVzUWAVwERFphaA/1IlNE7lkTIHHRbUCuIiItEa9Hz/ujFaht/sA7vO4qA56QFOpiohIvIKpq0KPV7sP4AUeNzXqxCYiIq0RyPwwsrS3gRtjpgKDga3ACOBCoAiYCawM7bveWrs5HenxeVxUBb3Y+hoyVxEiIiI5JVAfmkq1nfRCN8b0Aa4Delhrg8aYF4FTgW8Bb1hrnzXGTAbuBs5JR5oKGsaBqwQuIiLxMcH2N5VqFVAHFIe2OwFfAqcAH4b2vR/aTotwADf1NWBtum4rIiI5zAT8GZ9KNa0lcGvtjlAV+jPGmI3AOmA50AuoDB22A+hmjPFYa+sjzy8tLWX8+PFNrjtlypSG8eGtVeBxUW69zkbADx5fQtcREZH2wwSdXujJKoHPmjUr1jDpHrHOSXcV+lhgKnCQtbbeGPM7YBqwBegMbMcpnW9rHLwBevbsyfz585OapoaJXMAZSqYALiIiLTDB+qR2YotVEDXGbI11Trqr0PsB5RHBeSNQCMwBJoT2TQxtp4XP46KuIYCrHVxERFrmCoZ7obeTKnTgVeDboZL3dmAMcBlQC9xpjNkbGAZcla4ENXRiA03mIiIicUl2FXoi0t0GHgB+GePti9KZljCfx0WtVQlcRETiZC1um9wq9ERoIhePm1pC7d4qgYuISEuCTitwpnuhK4B7I6rQNZ2qiIi0JFAHkPEq9HYfwH1uF3XhlgRVoYuISEsaAng7m0q1LVKyHrg3sg1cVegiItKCQKgKPUW90LUeeJx8bldEG7hK4CIi0oJQCTxoPBiT/ACu9cDjVOB1axiZiIjELxTAAy5vRpPR7gO4UwIPB/C6zCZGRESyX8APQFABPLPUBi4iIq0SdAK4VQDPrAJNpSoiIq0RqkK3rsx2I2v3AXzPKnSVwEVEpAWBcAk8s4tftfsAbozBegqcDZXARUSkJaESOBmuQs+pYWSpGAcO4HZ7CeLCpRK4iIi0JNyJzZ2aAK5x4K1Q4HVTH/Th01SqIiLSklAANykK4BoH3goFHjd+41MVuoiItCzcic2tNvCM83lc1ONVJzYREWlZKICnqgQeLwVwQkPJVAIXEZF4hJYTNSqBZ57P46LOqAQuIiJxUBV69nAmc/FpKlUREWlZKIC7VIWeeT5PaDIXlcBFRKQloeVEjSezJfCcGkaWqnHgBR43ddajNnAREWlZQye21ARwjQNvhQKVwEVEJF7hAO7ROPCM83lc1FivSuAiItKy0EQu7gxXoSuA45TAq61K4CIiEoegn3pcuD1ajSzjGkrgAfVCFxGRFgTqqMeN153ZEKoAjtOJrTroUQlcRERaFvDjtx4F8Gzg87ioDrrVBi4iIi0L1FGHB6/bZDQZCuDsbgO3KoGLiEgLbMCPn8yXwHNqGFkqx4HX4sUE6iAYBJe+14iISHTB+tS2gWsceCv4PC522NBwgEAduAqTfg8REckPwfo66mzqqtA1DrwVGiZyAXVkExGRZtn62qyoQlcAJ2IudFBHNhERaVa4DdyjAJ55zmpkodYElcBFRKQZNtQG7stwL/QW28CNMd2Bs4B9gSJgDfCctfbzFKctbQo8LmrDbeAqgYuISCwLn8W37gMOMLWMeOtEKLgZ9j8zI0lpNoAbY44GpgPvAwsBP1ACTDfGfGWtvaE1NzPGDAbeBNaGdhWHrnsFMBNYCYwArrfWbm7Ntdsi3AsdUAlcRESiW/gszL4UV6AWDHSs3gizL3Xey0AQjxnAjTEuYIy19pgY7x9vjBljrV3UivtVAj+z1r4RusZNwH+A24E3rLXPGmMmA3cD57Tium2yRyc2TacqIiLRvHkz+Kv33OevdvZnUwC31gaNMQ818/4brb2ZtbYMCAfvAmC8tXa6MeZp4LbQYe8Df4l2fmlpKePHj2+yf8qUKQ3jwxPhUy90ERFpScW61u1vhVmzZsUaJt0j1jkttYHfZIy5Pcr+q6y1N7cmcVGcDTwdet0Lp3QOsAPoZozxWGvrI0/o2bMn8+fPb+NtmyrwuKm1CuAiItKMTr1h56am+7v0b/OlYxVEjTFbY53TUi/063ECayWwM+JneuLJbHAG8Ezo9Ragc+h1MbCtcfBOJQ0jExGRZgXqwVPQdL+3CI6blv700HIAPwX4I3CKtdYV/gGuastNjTHHAB9Ya/2hXXOACaHXE0PbaaOJXEREpFlz/wjbV8MhF1HToS9Ba6jt2A8m/yFjvdCbDeDW2lestZcAbmPM/caYE0L7723jfacAf4rYvh44wRhzA3AqbfyC0Fp7lsDViU1ERCKUrYC3b4ORp8DJd/HBd99haO1TLP7RBxkL3hDnXOjW2jnAHGPMNGPMjdbaI9tyU2vtWY22y4GL2nLNtthzHLhK4CIiEhIMwkuXgLsATvkdGIM/YAFyYzlRY8y+xph/AucDT6Y2SelX4HWrDVxERJpa8Bisfh8m3QrFewHgDwQBsnsudGPMPsaYvwMv44zX3tta+7AxZmhaUpcmPremUhURkUa2r4X/TIehR8OBu6cmqW8ogWf3euCLgPnAHUAtcJYxxgDfwelFnhe8boPfqAQuIiIh1sLLl4MNwuTfg9ldXV7XUALP7rnQnwSeiLI/5vqkqVRRUdEwTi5yvdS2MsbgdnsJGDdulcBFRGThM7D8P3DSndBt8B5vpboKffbs2cyePTu82SXWcS0F8GnW2rWNdxpjvmxD2hLWpUuXWDPVtFmBx0W9KcCtqVRFRNq3nVvg1WthwKFwSNPJVVJdhR5ZQH344YdjFphbuns/Y8w8Y8zLxpg+4Z3W2pgzw+Qqn8eN3/jUBi4i0t79+yqoq4LvPgCupmEyXAL3ZHkv9KnANcBTodd5yymBexXARUTas69egq9ehKOvgZ57Rz0k3Abuy/JObF9aa98BMMaMDu80xnQPLUySNwq8LvwBrzqxiYi0V1XlMOdK6LM/HH5pzMOypRd6S3d3GWOKjDEdABPx+pI0pC2tnKFkqkIXEWm3XvsNVJfD9x4EtzfmYf5AEGPA7cruKvTr2b2ASeTrG1OcrrQr8LqpM15NpSoi0h4tewM+/xtMvAz22r/ZQ+sCwYyXvqHlAH6NtdYdsZCJOxmLmWSjAndoPnSVwEVE2pfaSnj5MugxEo66usXD6wM24+3f0EIbuLX2LmNMR6A2cnnPJCxmkpBUjQMHpw281vrUBi4i0t68MQMq1sGFr0dfMrQRfyCY0h7oSRkHboy5ALgfqDLGnGytnZ+8JLZeKseBN0ynqhK4iEj78c378PEjcNjFMOCQuE7xB2xKq9CTNQ78OKAEOBA4N2mpy0IFXhc1Vr3QRUTaDX+1s9JYt8Fw7A3xnxYI4s1wBzZoOYAvt9bWWmvXAeXhncaYg1KbrPQr8LidAB5QABcRaRfevh3KV8DkP4CvY9yn+QNBvJ4sbwMHhhljvh3l9Q/JsxK5z+2iWiVwEZH2Yf0C+PABOOhcGHpUq06tT3EVerxaCuATgX4R2+HZ2AamJjmZU+B1UR1UG7iISN6rr4MXL4FOfeDEW1p9el0giCcLqtBbCuBXW2v/0XinMebUFKUnY5wSuEclcBGRfPfePbDlSzjrGSiM2ck7Jn8giC8LqtBbSsG/ou201j4PYIzxJT1FGaISuIhIO7D5K3j3btjvDBh5UqtPf+HT9Xy4ooyF6yqYOPMtXvh0fQoSGZ+WSuB3GWPus9aujtwZCtzTgceAFalKXGMpHQfucVMd9EKwHoIBcLmTdm0REckCgXp48ZdOqfukO1t9+gufrue657+gtt5ZzGT99mque/4LAL5/YL/mTm2VZK0Hfgfwf8aYXsB6oB5nWFlP4FJrbdqCN6R4HLjHxS5Cc9/W14KvQ0ruIyIiGTL3j7DhEzj9MejYvdWn3/XaUqr9gT32VfsD3PXa0qQG8HjHgbc0E9sW4CRjzDBgX6AAWAt8ZK0NJi21WaDAE5pKFZxqdAVwEZH8UbYC3r4NRp4C+ybWjWvD9upW7U+1lkrgAIRK2mktbaebb48Aro5sIiJ5Ixh0JmxxF8ApvwOTWA/yvl0LWb+9aT+pvl2L2prChGS+G12WKPC4qbMRJXAREckPCx6D1e/DpFuheK+EL3PymKbnFnndTJ00si2pS1hcJfD2QCVwEZE8tH0t/Gc6DD0aDjwn4cvU1gd4Y/FmenX24XG72Li9hr5di5g6aWRS279bI64Abow5xFr7Uej1AcA4a+1jKU1Zmu3RBq7pVEVEcp+1zjKhNgiTf59w1TnAE+9/wzdlVTxx/sEcPbJX8tLYBvFWoTcMlrPWfg6MTk1yMqdAJXARkfzy+d9h+Rtw3HRnwZIEbams4f63lnPsPr2yJnhDy8uJngucBwwyxhwd3g1kpJE4lePAfZ7QeuCgNnARkVxXuRlevRYGHAqHTGnTpe5+bSm19QFuOGVUkhLXvGSNA38BeAeYAoQHYAeAjW1LXmJSOQ68wONWCVxEJF/8+ypnudDvPgCuxPtrL1y3nX8sWMdF3xrK0J6dkpjA2JI1DrwCqAB+E7nfGHMYMLftycweBR4XdeE/h0rgIiK566sXYfFLcNw06Ll3wpex1nLT7K/o3tHHr44dnsQEJkdLVei/tNY+aIyJ7LBmgP2A8SlNWZqpDVxEJA9UlcOcq6DP/nD4pW261Eufb2DB6m3cedp+FBd6k5TA5GmpCr0q9NsAT0TsT7wvfpZyhpGF28AVwEVEcsrCZ+HNm6FirbN96M/AnXjQraqr545/L2FMv2JOHzcgSYlMrpaq0B8PvbzUWlsZ3m+MWZnoDY0xI4GzgGrgKGAGsByYCawERgDXW2s3J3qPRBR43NRqIhcRkdyz8FmYfanT5h32v7uh60DY/8yELvmnd1awaUcN9599IO4sWPs7mngncrHGmB8AnUPbk4EzWnszY4wbuAeYbK0NGmP+D2eBlNuBN6y1zxpjJgN3k+ZSvqrQRURy1BvT9wze4Gy/eXNCAXxteRV/fnclkw/oy8GDS5KUyOSLN4C/DHwGbAttJ5qjg3Gq4y8xxnQAyoCHgVOA20LHvA/8JcHrJ8zXeDETERHJXgE/fP0afPYU7NgQ/ZiKdQldeuYrSzAGrjt5nzYkMPXiDeDLrbWXhTeMMSMSvN8gYAJwlrW2whjzV6AO6AWEq+h3AN2MMR5rbX3kyaWlpYwf37Tv3JQpUxrGhydqz17oKoGLiGSlzV85QXvhM7CrFDr2goLOUFvZ9Ngu/Vt9+bkry5jzxUYuP37vtC5SMmvWrFjDpHvEOifeAP6aMeZ8dq9Idg5wUeuSBzjBeUloeBrAe8DRwBac6vntQDGwrXHwBujZsyfz589P4LYt87hdGOOi3njxaCpVEZHsUb0NvvinE7g3fAouD+x9Ehz4Exh+PHz5r6Zt4N4iZxhZKwSCzrCxfl2LmHLk0CRnonmxCqLGmK2xzok3gJ8P1OIEWHCGkSViHtDdGOO21gZwSuRf48zsNgFnrfGJwJwEr98mBR439S4fHpXARUQyKxiAle84QXvxy84aFb3HwKQ7nHbtjhEF03A795s3O9XmXfo7wbuV7d/PfLyWxRt38MDZB1LkcycvLykSbwDfaq39f+ENY8yBidzMWltujLkGuM8YUwr0BG4GioA7jTF7A8OAqxK5flv5PC7qjU9t4CIimVK2Aj77G3z+NOxYD4Vd4aD/55S29zog9oIk+5+ZcI9zgIoqP3e/vpRDBpdwyn6JLzmaTvEG8M+NMcewuwp9MvBpIje01v4L+Fej3dUkViWfVAUeF358agMXEUmn2p3O7GmfPeWs221cMOxYOPFWGPlt8BamPAm/f3MZ26rqmDZ5NKYNq5alU7wB/CpgScT2QJySc14p8Lrw13tVAhcRSTVrYc2H8OlTThu2fxeUDHWqvg84C4r7pi0py7dU8n8ffsOPDh7AmH4x1w7JOvEG8OustU+EN4wxx6cmOZnlc7vw16sELiKSFA2zo0W0Sw+a6FSPf/Y3KF8Bvk4w5gcw9icw8LA2rdmdCGstN7+8mCKfmytPHJnWe7dVXAE8MniHdE9+UjKvwOOmrtarAC4i0laNZ0erWAv/+hnYoLM9aCJ860oY/T0oSM8qX9G8vXQL735dyg2njKJHp4KMpSMRLS1m8jdr7dnGmFWADe/GGer1TKoT11gq1wMHOK7+v/SvWwnLl8K9YxLqxSgi0q5VlUPpEnjl6qazo9kgFBTDz/7rVJdnWF19kFteXszQnh35fxMGZzo5DeJdD9xYa2O9hzFmb2vt18aYS6y190fs/4W19qGkpTZO48ePt6kaB87CZ6l5/lcUElH69hbB5D8oiIuINFa9DbYsgdLFod+hn50tLWNhYMb2dKSwRQ+/u5Lb/r2Yx88/mGNG9sp0cqIyxiyw1kZd/bOlxUy+Dv2ODN5n4Qz/yi9v3rxn8IY2zaUrErdo7YT6zEkqteYz1xCoQz9bFjcN1N6O0HOkM6lKz5HQc5RTfV65sen1EpgdLRVKK2v5w5vLOGZkz6wN3i2JtxNbpDeAhMaBZ7VYc+YmOJeuSFyitRPODq1hrCAuqRDrM1dXBb322R2gS5c4gXvnpt3nejs4AXrYcc6xPUc5210GgMu1531OuDkps6Olyt2vLaXaH+CG74zOdFIS1uoAbq0tNcZUtHxkjunSf/c6spFcbvj4EWdYg69j+tMl+ScYhLLlsO4j+HeUdkLV/EgqvXlT9M/cy7/evd0QqI91fvcaBT33iR6oY0nS7Gip8MW6Cp5dsJYLJw5hWM/MdaBrq5Y6sZ1orX09yluxG85z1XHTqPvXr/DZiGp0tw867wVzrnQ+hOPOg4Mvgq7Zubi7ZKnaSli/ANZ+7ATttR9Bzfbmz6lYC2/MgFHfhb4Hpn1ojeQJa53guX4BbPgE1n/SfK3i2c+GStQD4w/UzWnj7GipYK3lptlfUtLBxyXHJbouV3ZoqQR+rzHmyyj798FZwzt/7H8mz3+8hqPWPsRelO3+trjfGc4Dd+4f4YMHnJ9Rk+Gwi2HAIXqwyp6shfKVsO5jWDvPCdpbvtw9dKbnPjD6u9D/EOfz89dToz9QPQXw/h/gvXudh+moybvPS8aDVfJTVbkTpDd84gTt9Z/Ari3Oey4v9BnjjLuu29n03C4DYO9J6U1vBsxeuJH5q7cx89T96FLkzXRy2qSlAP410RcWycsnyOIeJzFz/f58Nu3EPd8YeKjzs30tfPwwLHgCvnoB+h4Eh/0CRn8fPL4MpFgyrq7KWR1p7bxQ0P4IqkKLBxUUQ79xcORUJ1j3Gw9FXfc8/7jp0dsJJ//B6RC09BVY/JLzuZv7IHTqA6O+4wT0QUeAO5FuLJIX6qpg4+cRpesFsO2b0JsGeuwNw49zPoN9D3KCt6egaRs4ZFXbdCpV1wW449+L2bdvMWeMz/2a1Jb+919trV3WeKcx5r0UpSejCrxuav3B2Ad0HeB0zDjqGmcmobl/gucvgtdvhEN+CuMugI55OcdN+xOtl+5+Z8D2NbsD9dp5sHkRBEMr33Yf7pRg+h/sBOye+zh9KJrTUjvhgT92fmp2wLLXnWD+2d+cfhlFJbDPt2HU92DoUc7DWXJbrN7hAb/TuSyyKnzLYrAB57zi/tDvIKeZr9842GssFBZHv0cWt02n2p/+u4KNFTX8/kcH4nblfu1ps+PAs82IESPsMcccA6RmIpe7X1vKH99Zzso7TonvhGAQVrzlVK+veBM8hc5/gkN/Ab1zt2djuxethGLcTifG2h3Otrej88AccAgMONQJ2h1K0pO+uirn8/bVS/D1q06aCoqd9ZFHTXZK7r4O6UlLe5GOoX7RPncuD3Qd5KzKFV6jobCrE6T7HbS7dN25d3LTkofWb6/m2Lvf4YTRvXng7IMynZxmRU7k8vDDDy+31kZtrM+pAJ7SiVyA+99cxu/+8zXLbzsZj7uVrQRblsC8P8Hnf4f6ahhylNNOPuJEtVnmkmAQfjdyd7thJG8HpwZmwCHQa9/sqL6ur4WV/4XFL8KSf0N1uZPO4cc7U1SOOHF3SUzjzRMTq8o5PMlTMOgsxFG3y1lVqy700+T1LqirjHjd6LiyFbtL1JHcPqfzbL+DnJ9uQ9T3JgG/+tsn/Oerzbx11dH061qU6eTErbmJXBTAI8x6dwW3/3sJX940iY4FCT6cq8rhk7/ARw8735pLhjol8rFnQUHn5CZYksNa2PQFLPonLHo++nBCIJtmkIoqUA+r34PFs52fnZudh/+wY52284XPOF8uw3J9psFkfSEJBqCmwpmwpHobVG+PeL0NPvhD9E5fxuV8WYr2XiyeIqcmp6AT+DpHvO7oLKcZVZZ/7nLAvJVl/HDWXH593AguP2HvTCenVRKeia3RRfbHmYFtKbDe5lLkj5MvVOquqw/SMdHmxA4lcMTlMOFXTnvl3D/BK1PhrVucRekPuchpP1VJKPO2Lg8F7edg69dOdeWwY53SUXV50+OzZAapmNweGHq083PyXc6Qta9ecj6HX7/a9Hh/tTNUbb8zcq9EF20ykpcudYLv4COcYXqRQThaYK7e5hxXk+C0FjbotDn7Ojo9u30dnS/pDa87hV53cl57OzZfa3PvmOhfHrP9c5flAkHLTbO/om+XQn5+1LBMJyep4grgxpipwLeBNcATwCXANalLVmYUeJ0OR7X1zXRki5fbC2NOc37WzYe5DzlV7B8+4LSnhqvKNPNWelWscwL2ouecHrwY54F/2C+czmAdu+dHL12Xy1maceBhMOk2uKkbUadv2LEeZg6CksFO1WzJEKfWKPy6c9/MNwEF/M6UnDs2OP9+OzbAf+9sOhlJfbXzZTka44Kibrt/OvVyxjsXdt1zf8NPaH9hF/jDgTEC6wDnb5ssx03L/c9dFnp2/lq+2riD+886kCJfC51Kc0y8JfBO1tpjjDHXWGvfNsYck9JUZUhkCTyp+o+H0x+Fipvhj4c6E3tE8lc7PdnHnJ75h2U+2lnqDPtb9Bys+dDZ128cTLod9v0BFPfd8/h866VrTOyZBgu7OiXw8pWwaSEseXl3r3oAdwF0G7Q7oHcLBfiSIdB1YPSe762p2g7U7w7OO0LBuWK988Vix3pnu3ITrZo76vTHmwbkgs6J1zKkK7Dm2+cuC1RU+7n7taUcPLgb39l/r0wnJ+niDeDhry220XZeKfA6wbO2PkpHkmTo0s/psBLNzk1w5yBn1q1+43b/FOffhy4taipg8ctOFfnK/zo1Hj1HwbE3OLUiLS1lmIUzSLVJrCD07bv2zGeg3gmk5atg2yrnd/lKZ3zxN+85nbUahL4YdBu8O7hXboJPnnA614HzpeHFXzlD77oO3LMUvWO9005vG31h9nZ0/q8U94Nho0Kv+zpDpYr7OtsPTYxdKh5zanL+ZmHpDKz59rnLsPvfXEZ5VR1/mXwIJteaieIQbwAPGGNeBToYYw4BPklhmjImXAJPShV6LLFKQkUlTmlw/QKn00y4FNS57+7hIv3GQd+xTrWeNFVX5bT1LnrOGTMdqHOG4BxxmRO0e++b6RRmTrxByO1xAnK3wUCjijZrYVdpRHBfufv1kn/vnsCmsUAtfDTLed0QnPs6C2KEA3Jx+Kev8/lu6WGb7upmBdacs6J0J0988A0/HD+AMf3y85kZVwC31k43xpwI7A98Zq19I7XJiq6iooIpU6YAqRkHntQ28FhiPXhOvnP3A8Jf4/SKXr9g98+Sl3cf32PviFL6QdB7TOxJPPJt6FDj/BxzvfPlZ9E/nSDi3+X0uB5/Iex3uvM3ysNv3glpaxAyxmk77tTLmZmwsZodMHMg0au7DVzzTXzBOR6qbpYW3PryVxR53Vx54shMJ6XVIseBAzG/fcQ1jMwYMxyoBOqBc4B/WWtXJyGdrZLqYWRzV5bxo1lz+dtFh3L4sB4pu09CQbWq3JmyMzzP8br5u8cqu33QZ789q95LhjlBrbnxq5nOUyL3aJyfsMKuzrjn/U6HQRNbngFNUiNmT+oBcPmi9KdH2qW3l2zh/Cc+5jffHsVFR7bQXJblkjGM7EZgOjAD2BJ6fUFSUpdFfJ4UdWJrLJGSUIcSZ17j4cc529Y6bYgNpfRPnCk2w1WVBV0gULO7LTLMXw2v3+DM3uTxOcE//OMpcIZStbaEFO+a1vW1TimtNvxTGdqu3L1vj+1G71esI2rprkMPuGKx5qPPBupJLRlWVx/kljlfMbRHR849fHCmk5NS8QbwRcB6YB9r7XnGmKtTmKaMKfCkoQ08WcI9i7v0d0qe4ExIsfXr3UF9/mPRz925GR4YF+vCu4N5Q2APB/mC6EF/xZvR1xd+4WJ4+/bdwThQ13K+PIVOj+GC4tDvzk4HqYLOzvzz0VSVKXhnC1VtS4a88Ol67nptKeu3O8+iKd8a0lAoy1fxBvB9gT8ArxtjioDcrpOIoSBdJfBUcbmh1yjn58CfwLL/RK/O7NAdTrrT6VxUX+uMsw3UOgG2vi702h96L/K1f/c59bVOYA74o1dpAwT9zhC6cDAuLI4IzJH7Ojs1BgWdmw/E37yniS5ygTp8SZq98Ol6rnv+C6r9u0cQPTl3DaP7duH7B/bLYMpSK94AfjtwMvAwcBjwn5SlKIMKPGnoxJZOsaozT5oJ+5+RvPs01+552iPJu4+qZ0UkirteW7pH8Aao9ge467WleR3A46pfsNZ+ba39vbW2ylr7Nq2YgjWX7K5CT9E48HTb/0ynw1qXAThjdgekpgPbcdOcQBopVRNdpCM/IpIzavyBhmrzxjbE2J8vmg3Expi/WWvPNsasYnfvIQMUA8+kOnHplrZObOmUjupMTXQhImlWWlnLX+eu5ql5sQdE9c2hVccS0VJJekbo9z3W2vvDO40xv0hZipqR8nHg+VaFnk4KrCKSBos37uCx91bx4mcbqAsEOXafXuzTpzOPv7+Kav/uZ3eR183USbk3BhySPA4cwBjTBRgOLLPW7mhzChOQ6nHggaBl2PX/5ooT9ubS46Kuny4iImkWDFreXrqFR99bxQcryijyujltXD/OnziEYT07Abt7oW/YXk3frkVMnTQyL9q/2zwO3BjzXeBBYBvQ1RhzsbX25RZOyzlul8HjMvnTBi4iksOq6up5bsE6Hn//G1Zu3UWf4kKuOWkfzjpkAF077Dli5fsH9suLgN0a8XZGOxEYZq2tM8YUAL8H8i6Ag9MOnldt4CIiOWZjRTV/+WA1T3+0hopqPwf078LvfzSWb++3F153fo/tbo14A/hqa20dgLW21hizJoVpyqgCj0tt4CIiGfDZ2u08+t4q/v3FRqy1nDSmDxdMHMK4Qd3ycjWxtoo3gA8zxlwBrASGAYMSvaExZi5QE9oMWGuPM8aUADND1x8BXG+t3ZzoPdqiwOOm1q8ALiKSDvWBIK9/tZlH31vFgtXb6Fzg4fzDB3Pu4YMZUNIh08nLavEG8KuA64Fjgc+AK9twz1ettTMa7bsdeMNa+6wxZjJwN86iKWnn87ioCyiAi4ik0o4aP898tJYnPviG9durGVjSgemTR3PG+AF0KsjLqUaSrqVx4GOstYustTtxAngy7GeMuQYoAj621s4BTgFuC73/PvCXJN2r1ZwqdHViExFpq2g9ww8c2JXH3/+Gf8xfy666AIcMKWHa5NEcP6o3bpeqyVujpa85NxtjXoj2hrX2/xK8553W2o+MMW7gXWNMJdALZ7lSgB1AN2OMx1pbH3liaWkp48c37U0/ZcqUhvHhbaVObCIibdd4fvL126u54tnPCFrwuAyTD+jLBROHsF//mMOc25VZs2Yxa9asaG/FXNu6pQBeAXyDM/saQDecRU3eAhIK4Nbaj0K/A8aY/wHH4CxR2hnYjjPL27bGwRugZ8+epHIcOKgTm4hIWwWDljteWdxkfvKghU4FHt688ih6FxdmKHXZKVZB1BizNdY5LQXwG6y160MXOQCYBdxrrb03kQQaY/YBJlprHw3tGgE8D8wBJgBrgYmh7bR74dP1LNqwg7r6IBNnvpU3EwGIiKRKIGhZWbqTRRsq+GLdDhZtqOCrDTvYWdukDAbArtp6Be8kaTaARwTvc4BbgfOttW+14X47gO8YY/rilLTXAk8DrwB3GmP2xunlflUb7pGQcHVPuPp8/fZqrnv+CwAFcRERwB8IsmzzThatr2DRhgoWra9g8cbKhpJ2odfF6L2KOfWgfrz02Qa2V/ubXCPf5ydPp5Y6sblxJm05HDjKWvtNaH+RtbbVy7xYazcAP4jyVjlwUWuvl0ztdTk6ybx8nQJSslc8n7kaf4ClmypDgXoHX26oYMnGyoZROp0KPIzuW8xZhwxkTL9ixvTrwtAeHfGEJlo5aGC3Jmt05/L85NmopSr0d4F64GwgaIwZiNMe/kvg6hSnLa1iLTuX78vRSWa98Ol6rn1+ITV+1fxIekTrXHbt8wtZtXUnJR0LQqXrHSzbXEl90Fkro0uRlzH9ijl/4mD27deF/fp1YVBJB1zN9BoPf3715TR1WgrgdcA7wJns7sgGcFCqEpQpfbsWRV1T1hj4839X8P8mDKbI585AyiTfWGtZUbqT95ZtZeYrS6hp1GlSNT+SSne9tqRJbWONP8jv31wOQPeOPsb068Kx+/RkTN8ujOnXhf7dihKaCa09zk+eTi0F8GnW2v813mmMmZii9GTM1Ekjm1T3FHhcDO7RkTteWcIj763iV8cM50eHDGhYdlQkXpsqanh/+VbeX7GV95dvZfOO2maPX7+9mic//IbvHtCPLh28aUql5KNg0LJ0cyXzVpYxb1U567fXxDx27nXH0bu4QNOW5oi4lxPNBiNGjLDHHHMMkJr1wGO1C320qpy7X1/KR6vK6de1iEuPG85pB/VvaOsRaWxHjZ95K8t5f/lW3lu+leVbdgJQ0tHH4cO6c8TwHkwc3oMfzZobtebH4zLUBy0+j4uT9u3DmeMHcPiw7s1WWYqA0yt88cYdzFtVzryVZXz0TTnbq5zOZP26FlG+q65JCTz83vvXHpvu5EoUkeuBP/zww8uttVHXt86pAJ7q9cCbY63lf8u28rvXl/L5ugqG9OjIZcePYPL+ffVQFWrrA3y6ZntDwF64roJA0FLkdXPIkBKOGN6Dw4d3Z1Sf4j0+L43bI8Hp6HPHqfsxvFcn/jF/LS98toGKaj/9uhZxxvj+nD6uP/27aY5ocQSClq827GDuyjLmrSrjo1Xl7KhxhnANLOnAoUNKOGxodw4dWkL/bh2a/cypujv7NLceuAJ4K1lr+c9Xm7nnP1+zZFMlI3t35vIT9mbSvr1V7ZRHWuqlGwxaFm/a4VSLL3cemtX+AG6XYf/+XRpK2AcO7Npik0tL96rxB3j9q838Y/5a3lvuzOkwcVgPzhjfn0n79qHQqyad9qQ+EGTRhh3MW1nG3JVlzP9mG5WhMddDenTk0CElHDq0hEOHdI85ZEsjH3KHAngKBIOWl7/YyH3/+ZqVW3exf/8uXHHC3hy1d08F8hwXq4Ry1aS96ejz8N7yrXywoozyXXUADO/VqSFgHzq0hOLC1LVZr9tWxXML1vOPBWtZt62a4kIP3z+wH2eOH8CYfpqSMtdFC6yn7L8XC9dVMG9VGfNWljP/m3J21TmfzaE9Ozql61ApWxOk5B8F8BSqDwR5/tP1/P6NZazfXs3Bg7tx1YkjOXRo90wnTRI0ceZbUdulw3oXFzBxmBOwJw7vQZ8u6X9oBoOWuSvLeGb+Wl5ZtIm6+iCj9yrmzPH9+d7YfnTr6Et7mvJZOkqszhfHhVRHLGfsMuB2GfwB5zk9olcnDh3qBOtDhpTQq7MCdr5TAE+Duvogz3y8hvvfWs6Wylq+NaIHV544krEDumY6adJKQ66dQ6z/FW9ccSTDenbKqlqWiio/Ly3cwD/mr2Xhugp8bhcn7NubM8cP4IjhPbTCUxvF22ZsraWqLkBlTT2VNX52hH4725Gvnd97vF/rZ922aqI9jjv63Nx1xgEcMqSEHp0K0pFlySIK4GlUXRfgr3NX89B/V1C+q47jR/XmyhP3ZtRexZlOmjSjPhDkzSVb+Ovc1fxvWfS1A3Khl+5XG3bwjwVreeHT9Wyr8tO3SyGnj+vP6eMG8MmabXnV7pmqUnFdfZBtVXWU7ayjfFcdlzz9Cduqmk4J6nO7GNarU0MQ3llbTyDY/PPUZaBzoZfOhZ6G38Wh1//6dH3UcwywauYpbc6X5CYF8AzYWVvP4++tYtb/VlJZU8939t+Ly0/Ym2E9O2U6aRKhtLKWZz5ew9/mrWFDRQ17dSnkwAFdeWvJlj0mWMm1Xrq19QHeXLyFZz5ey7vLSrHWCR6R8SXX8hSpNT2pwwF5685aync5QblsZx1lu2ojXof31zb04I7H8aN6hwKwp0lgDr8ujtjXweeOWXsTq+kmF744SurkTQBP9TjwVNheVcesd1fy+PvfUFsf4LSD+rPPXp157L1v8qYklGustSxYvY3/+3A1ryzaiD9gOWJ4D35y2CCOH9ULj9uVV710N2yv5qT73o0amDoWuLnu5FGM6NWJEb07U5IjbecTZ74ZdUKSDj43E4f3aAjUW3fWUhkjILtdhm4dfHTv6KN7Jx8lHcOvCxpel3T0ccnTn7KlsunEO8kOrBreJWEaB55ltu6s5aF3VvDE+6sINPqT6z9peuyqreeFz9bz5IerWbKpks6FHk4f15+fHDYo72tGmmvXj9S9o48RvTsxoldnRvTuxPBezusenXxpb/ev8QdYt62KNeVVrCmrYk15tfO6fBdfb94Z87x9+jhfREo6+ugRCsbRgnOXIm9cczikM7Dm0xdHSY68KYHncgAPO+z2N9gUZRrN7h19/O+aY+jga2l2W2mt5Vt28te5q3luwToqa+sZtVcx/2/CIL43tm+7+XvHrp4t5NmfH86yzZUs37KTZZt3smxLJcs272wYWwzQtYOXEb06MbxXZ/aOCPC9OjeddjPeIGStZevOOtaUV7G2vIrVZVUNr9eUV7Fpx54l7CKvm0HdOzCgpAMfrNjKrtr0zSamwCqZogCeRZorCXlchgMGdGXC0O5MGNadcYO6aZKOBNUHgvznq808OXc1H6wow+d28e39+nDOhMEcNLBrVvUiT4fWliKttWyprOXrzZWhoL6T5Vsq+XrzTioi1njuXOhxqt9DAX1LZQ1/+WA1tRH9Bwo8Ls6dMIh+3TqEStDhEnVVkyk9+xQXMrDECdIDSzo0BOyBJR32qAVQdbO0FwrgWSRWSah7Rx9nHjyAD1eU8cV6ZxpOn9vF2IG7A3o8s3q1d1t21PD0R2t5+qM1bNpRQ7+uRZx96EB+ePCAdj8EJxmlyHCpedkWp8QeDvDLt+ykLDSxTXMKvS4GhgLywJKODCwpYmB3Z7t/tw6t+sKqUrG0BwrgWSSekkNljZ/532zjw5VlfLiijEUbKrDWKcmMG9StIaDv378rPk/7WlAl2kP7e2P7Mm9VOU/OXc1rizZRH7QctXdPzjlsEMfs00vjoNOkbGct4299I2oNkwHm/eY4enbSSlciraEAnmVaW3KoqPbz0apyPlxRxgcrtrJkUyXgBP7xg7sxYVh3Jgztzn79ujRZIS2fSinRvvx43YbuHX1s2lFLlyIvZ47vz48PHcTgHh0zmNL2S0OhRJJLATzPlO+qY97KsoYS+rLQUpWdCjwc3BDQe7BscyW/eWFRTveeDc9uVVHt5/sPvh91OI/XbbjtB/sxef++FPnUxJBJapsWSa68CeC5OA48HUora5m3ygnmH64sY2XpLsCptoz2r9ujk48//WQcBR43BV4XBR6X89rjCm27W1XtHM9D2x8IUlHtZ3uVn4pqPxXVdXtsb6/ys6Paz/ZqP9ur6kLHOD/+xuPuGtFMVdkln2p9RDJB48Dbsc07api7soxf//2zhK/hcZlQQA8F9nCQDwX8wob9bt5asqVJb+LwNXoXF7K9qq5h9aRYOhd66FLkpWsHr/O7yEfxHttefvvqEsqjTGmp6lkRyVfNlcDbxyDYdqZ3cSHfG9uP3766NGp7ZI9OPu794Vhq/UFq64PU1gec3/7Q7/C+Ru/XhN/3B9lVW0/5Luf9aMEboD5omTCse0MA7hIKxk6g9jXs71zoadJ2H02h1x21pD910sjE/1giIjlKATyPTZ00MmrAu+GU0XxrRM+k3ae5jkt3n3FA0u4TroZV9ayIiAJ4XktXwIv1RSEVJePvH9hPAVtEBAXwvJeOgKeSsYhI+imAS1KoZCwikl7taxovERGRPKEALiIikoNyqgq9oqKCKVOmAJrIRURE8lPkRC5Al1jHaSIXERGRLNXcRC6qQhcREclBCuAiIiI5SAFcREQkB2UkgBtjiowxC40xd4e2S4wxs4wx1xpjHjXG9M5EukRERHJFpkrgtwKfRmzfDrxhrZ0JvADcnYlEiYiI5Iq0B3BjzDnA+8CqiN2nAB+GXr8f2hYREZEY0joO3BgzGhhlrb3eGLN/xFu9gMrQ6x1AN2OMx1pbH3l+aWkp48c37U0/ZcqUhvHhIiIiuWbWrFnMmjUr2ls9Yp2T1nHgxpjfAG6gDjge8AHPA1cCh1tr1xpjSoDl1tqSxudrHLiIiLQnzY0DT2sJ3Fp7W/i1MaYQ6GStvc8Ysw8wAVgLTATmpDNdIiIiuSYjU6kaY04DjgR8xpizgOuBO40xewPDgKsykS4REZFckZEAbq19Dniu0e6LMpEWERGRXKSJXERERHKQAriIiEgOUgAXERHJQVoPXEREJItoPXAREZEcp/XARURE8owCuIiISA5SABcREclBCuAiIiI5SAFcREQkBymAi4iI5CCNAxcREckiGgcuIiKS4zQOXEREJM8ogIuIiOQgBXAREZEcpAAuIiKSgxTARUREcpACuIiISA7SOHAREZEsonHgIiIiOU7jwEVERPKMAriIiEgOUgAXERHJQQrgIiIiOUgBXEREJAcpgIuIiOQgjQMXERHJIhoHLiIikuM0DlxERCTPKICLiIjkIAVwERGRHKQALiIikoPS2gvdGOMCZgPzAB8wDLgAKAJmAiuBEcD11trN6UybiIhILsnEMLIPrbW3AhhjXgROBb4FvGGtfdYYMxm4GzgnA2kTERHJCWmtQrfWBiOCtwfoDywFTgE+DB32fmhbREREYsjIRC7GmEnA5cDL1tr5xpheQGXo7R1AN2OMx1pbH3leaWkp48c3HQ43ZcqUhgleREREcs2sWbOYNWtWtLd6xDonoxO5GGP+D5gLXAccbq1da4wpAZZba0saH6+JXEREpD3JmolcjDGjjTGR1eOrgKHAHGBCaN/E0LaIiIjEkO4q9FrgQmPMgYAXGAVcCtQBdxpj9sbpmX5VmtMlIiKSU9IawK21K3B6nUdzUSLX9Pv9rFu3jpqamsQTJnmjsLCQ/v374/V6M50UEZGUyqnVyKJZt24dnTt3ZvDgwRhjMp0cySBrLWVlZaxbt44hQ4ZkOjkiIimV8zOx1dTU0L17dwVvwRhD9+7dVRsjIu1CzgdwQMFbGuizICLtRU5VoVdUVDSM9548eTKTJ0/OcIpERESSa/bs2cyePTu82SXWcTlVAu/SpUvDYPdEg/cLn65n4sy3GHLtHCbOfIsXPl3f5nRt3LiRK664gltvvZUbb7yRU089lfvvvz/m8ZWVlVx44YWcd955Cd3vj3/8I4MHD27xuPvuu69V133vvfc46KCDeOedd5q899vf/hZjDNdffz033ngjP/jBD/jwww/ZsmUL5513Hn379mXGjBlce+21nHbaaWzZsoV3332Xo48+mkGDBlFXV7fH9a655hr69u3LI4880qo0iojku8mTJ0dO7FIR80Brbc78jBs3zjb21VdfNdkXy78+WWf3ueEVO+ialxt+9rnhFfuvT9bFfY3Gampq7Pjx4+3atWsb9m3atMkeccQRzZ739ttv23PPPTfh+w4aNCgpxzR27rnn2rfffjvqe4CtrKy01lr71ltv2YMPPtha6+Ql8t9m2rRpdurUqdZaa6dPn24PPvhg++CDDza8v2XLFnv00UfbaP+eydCaz4SISDYD5tsYMTGnqtBbctPsL/lqw46Y73+6Zjt1geAe+6r9Aa7+50Ke/mhN1HNG9y1m+uR9Y17z5ZdfZvDgwfTv379hX+/evXn++ecBeOGFF3jxxRcZOXIkX3zxBQ899BDFxcV7XKOyspIrr7ySoUOHsnnzZkpKSjjjjDP4+c9/znnnncfZZ5/d0HTwxBNP7HHuzp07+eEPf8iRRx7J0qVLOfvsszn++ON59tln2b59OzNmzGCfffbhRz/6EdOmTaO+vh63203nzp25+uqrAbj00kvx+/0MHTqUdevWxcxrpI0bN9KjR/QZ/jZu3Mjw4cMbtqdNm8bFF1/MhRdeSEFBAQ888AAXX3wxd955Z1z3EhGRpvIqgLekcfBuaX88li9fTp8+fZrs79mzJwDdunXjvvvuo0uXLtxzzz08+eST/PKXv9zj2Ntvv53hw4c3BNTHHnuMffbZh6OPPhoAn8/Heeed1yR4A7hcLi6//HKOP/54ysvLmTRpEscffzxnnnkmV199NTNmzADgtddeY+7cubz++usAHH300Zx44omsX7+eZcuW8corrwDw4osvNpvf22+/HZfLxa5du/ao/t6wYQMzZsygqqqK/v37c9lllzW8N2bMGCZMmMCsWbM488wzcbvdDX8fERFJTF4F8OZKygATZ77F+u3VTfb361rEMz+bEOWMlvXv35/m5mfv1KkTN998Mz169OCTTz5h332bpnHhwoVceOGFDdsXXHBB3Pe31vLOO+/w4Ycf4vV6KS0tjXrcwoULqaqqYubMmQAMGDCA0tJSvvzyS0aMGNFw3NChQ5u93/XXX0+nTp2a7A+3gccyffp0Jk2axJo1a7jmmmtYtGhRHLkTEZFYcqoTW1tNnTSSIq97j31FXjdTJ41M+Jo/+MEP+Prrr1m/fndnuKVLl/Ld734XgJ/+9Kd873vf47rrruOEE06Ieo0DDjiAFStWAE5A/vOf/wxA586d2bHDaRJYsyZ6Ff8jjzzChg0buPHGG7nyyiv3eM/tdmOt5dNPP+WAAw6gV69eXHvttVx77bWcf/75jBw5ktGjR/P11183nLNy5coE/xLNGz16NEceeSQ+ny9m1buIiMQvr0rgLfn+gf0AuOu1pWzYXk3frkVMnTSyYX8iOnTowCuvvMI999xDcXExdXV1bNq0iYceegiACy+8kFtuuYVjjjmGBQsWsG3bNr744guefPJJFi5cyAcffMB1113HlVdeyW233cb27ds5+eSTATj11FO5+OKLqa+vp7y8vOH4zz77jIqKCp5++mkmTZrEP//5T6ZOnUpJSQkVFRU899xznHbaaZxyyilcddVVBAIB7rvvPj766COuu+46PB4PNTU1zJw5kwEDBvDKK6/w05/+lAEDBmCt5cknn2TcuHF07ty5IZ/33HMP4PRGv+SSSxqqwEtLS3nyySfZuHEj99xzD1dccUXDOfPnz+fdd99l586d3HHHHTz11FNNznnqqaf48Y9/nPDfX0SkvcrocqKtNWLECHvMMccAu8eBL168mFGjRmU4ZZJN9JkQkVwWOQ784YcfXm6tHRHtuJwK4NHWA9fDWhrTZ0JE8kXWrAcuIiIiyaEALiIikoMUwEVERHKQAriIiEgOUgAXERHJQe0vgC98Fu4dAzO6Or8XPtumy3300UccffTRHH744cyYMYNf/vKXXHLJJQSDQZ599lkGDx7M2WefzbRp0zj77LN59NFHAbj55psxxvCnP/1pj+tt3bqVTp06cfbZZ7N8+fKE07VmzRrOO+88evTowerVqxv233rrrYwdO5aXXnqp2fPHjx9PIBBI+P51dXVcdtlldOjQgRkzZjT8HHbYYSxatIhjjz026tSwIiISp1irnGTjz/Dhw+1FF11kL7roIvvSSy9Za1u58tTnz1h7a29rpxfv/rm1t7O/DaZPn26vvPLKhu0jjzzSzpkzx1pr7VFHHWVnz55trbW2urraFhUV2R07dlhrrR03bpwdOHCgrampaTh3xowZdvTo0Q3nxPL444/bxx9/vNlj3n77bXvEEUfYcePG2erq6ob98ayCFgwGWzymJatWrbLdu3ffY9+zzz5rrXX+Zi2lP1FajUxEctlLL73UEOuAZTYfViMLrwce0yvXwqYvYr+/7mMI1O65z18NL/4KFvwl+jl99oOTZ8adxvr6erZu3Rp1utCtW7dSVFREQUEB4CzyUVVVxSOPPMIvf/lLtmzZgjEmqQt9XHjhhbz//vtcfPHFPPbYY03ev+WWW/D7/QSDQXw+H9OmTeOll17i0ksv5Z133qF379786le/YsiQIWzZsoUjjzyS008/nX/961+8+uqrDB06lNWrV3PPPfdQWFjYbFp+9atf8cADDzTZv3jxYn73u9+x9957s2TJEqZOncqoUaOi7u/Tpw9nnXUW1lrGjh3Lq6++yk033cT3v//9ZP3JREQyKjxRGcDDDz8ccz3wnArgbdY4eLe0vxU++OADZsyYQVlZGb/5zW845JBDGt7729/+xkcffURZWRmvvPIKPp+v4b3p06dz8sknc+GFF/Lggw9yySWX8NZbb7U5PZEefPBBjj76aP785z/zs5/9rGH/a6+9xrx583j55ZcBOPnkk3n99df57ne/2zB16tKlS/nss8+466676NSpEwsXLmTbtm1cfPHFrFy5kqKiImbMmMGf//xnfv3rXze5965duxpWJluwYEHU9F1wwQXcf//9jB8/nnnz5nHhhRfywQcfxNx/7bXXcvXVV3PnnXdy+eWXt6mqX0QkV+VXAG+ppHzvGKhY23R/lwFw/pw23TrcBh7N2WefzXe+852o7+27774cfvjh3HTTTRQVFTW70MfWrVv5yU9+AtCweMrf//53AP7617/GPNfn8/Hcc89x+OGHM3bs2Ib9Cxcu3GP1seHDh/P5559z4oknNuwbO3Ysv/jFLzj99NPx+XzcfvvtLF++HGMMv//97wEoLy+PukIZQMeOHbnvvvsA58tANJHpCKehuf1Aw0xr0ZZyFRFpD/IrgLfkuGkw+1Kn2jzMW+Tsz6Dp06dzxBFH7LEqWDQ9evTg1VdfBWjoAHbeeefFdY+99tqLp59+mh//+MccccQRgLMK2jvvvNNwzLJlyxpWUQtbtWoVhx12GD/96U+ZM2cOM2bM4C9/+QuFhYVcddVVeDweVqxYwYYNG1pMw8iR0Vd9C6/GVlJSwrJlyxq+ZMTaD2CMiSvfIiL5qn0F8P3PdH6/eTNUrIMu/Z3gHd6fgPCKW3V1dQ2rgIU999xzrF69mmeeeYY+ffowfvzu6WzvueceFi5cyJtvvslxxx1HWVlZk3MOOOAABgwYkFC61q5dy5NPPsn27ds55JBDGD16NIcddhjXXXcd7733HgAnnngic+fO5brrrsNay4QJEzjhhBOYM2cOq1ev5k9/+hPnn38+t956KwceeCBr1qzhZz/7Gd26dePee+/l17/+Nb1792bdunXcfPPNe9zf7/fzwAMPUF1dza233srUqVMb2v4XLVrEu+++yxdffMEJJ5zAo48+ym9/+1tGjBjB0qVLeeSRRwCi7q+trW1Yya3x31tEpD3RYiaSd/SZEJF8ocVMRERE8kxOVaFXVFQwZcoUYM9u9iIiIvkicj1woEus4/KiCn2fffZRpyYBnImJlixZoip0EckLeVOFXlpa2mRfYWEhZWVl5NIXkbBo+cl1mcyTtZaysrIWJ5RpjWYnDspR+ZanfMsP5F+e8i0/kB15yqkSeMeOHe2uXbv22Of3+1m3bh01NTUZSlXiNm7cyF577ZXpZCRVpvNUWFhI//798Xq9Sbne+PHjaVzrk+vyLU/5lh/IvzzlW34gfXlqrgSeU23g0Xi9XoYMGZLpZCTknHPOybsPdT7mSUQkG6W1Ct0YM8wY87QxZqox5vfGmGmh/SXGmFnGmGuNMY8aY3on654RHQGy7pxEJHqffMtTNucn0Xtlc57yLT+J3iub85Rv+Un0XtmcpwTvE7MTW7rbwEuAv1tr77LW/hr4kTFmHHA78Ia1dibwAnB3sm6oD0Di52VznrI5P4neK5vzlG/5SfRe2ZynfMtPovfK5jwleJ+usd5IawC31n5srX2x0f13AacAH4b2vR/aFhERkRgy1onNGPMD4Ghr7a+NMbVAb2vtdmOMB/ADXmttfaNzaoBoS0+VAltj3KoLEHM5tgyf04PY6U7mfRI9L5vzlM35SfRe2ZynfMtPovfK5jzlW34SvVc256m5+/QAoq0l7bLWFkU7ISOd2IwxxwDHAJeFdm0BOgPbgWJgW+PgDWCtTd74IBERkRyW9gBujDkF+Bbwa2AvY8wgYA4wAVgLTAxti4iISAxprUIPdVj7LxAeZ9QReBB4CbgTWA0MA6611m5OW8JERERyTNZN5GKMGQbcCnwC9AfKrLU3xzj2x8Bfgc7W2p3pS2X84smPceaBvSS0ORjoaq29IJ3pbI048zQEZzTBx8BY4G/W2pfSnNS4GGNcwGxgHuDD+RJ5gbW2OuKYQpz8rAdGADOttc0v4J5BcebpGqAPsAkYB0yz1i7JQHJbFE9+Io7N+ucCxP1vlDPPhjjzkzPPhTBjTBFOnl631l7V6L3MPhestVn1AxwMfC9i+ytgXJTjRgG3ARbolOl0tyU/wDnA/4vY3j/T6U5Cnh4CLg+9PhBYlul0N5MfF3BDxPaLwI8bHXMtcHXo9X7A/zKd7iTk6RZ2f4n/ITA70+luS35C+3PiudCKf6OceTbEmZ+ceS5EpPl3wF+Au6O8l9HnQtbNhW5jDzVrYIzpAFwN3JTOtCUinvwAPwZKjDGXGmNuB7K21ABx52kzu3tU9gQWpCNtibDWBq21twKERkH0B5Y2OqxhqKO19gvgAGNMcVoT2grx5Mlae6MNPXlw/g2z9nMXT35y6bkAcX/ucubZEGd+cua5AGCMOQdnaPOqGIdk9LmQdQE8Umio2Wu2abXebcAt1tq6DCQrYc3kZxBQbK39A/AE8Koxxp3u9CWimTzdAxxqjLkHmAY8nvbEtZIxZhLwMvCytbbxfLC9gMqI7R2hfVmthTyFj/EB5wI3pDNtiWghP7n6XGguTzn3bGghPznzXDDGjAZGWWufb+awjD4XsjaARww1u7zR/gFAN+BMY8y1od1XGGOiTvaeLWLlJ2QHThsL1mk/KQYGpC91iWkhT08Aj1hrrwB+ADxjjClJY/JazVr7mrX2JGCIMebiRm+HhzqGFYf2ZbUW8hQO3g8Bv7HWrkh7AlspVn5y9bkALf4b5dyzoYX8PEHuPBd+ANSEPk9HAIcYYy5rdExGnwtZuZhJjKFmS4F6a+1a4LyIY+8A7rHZ3VmlufzsAN4EhoaOLQbcOB2LslYceRoAbAwdvg0IkqVfGEPftIdYa8PDF1cBQ0MPlnB+wkMd/2eM2Q/4PLQ/K8WTp1DnnD/itO19aYw5zVr7XKbS3Jw48pOLz4V4Pnc582yIMz8581yw1t4Wfh3qrNbJWntfNj0XsrEXeqyhZqOBcuvMl44xpifwM5yOOLcAf7bWrk9/ipsXT36MMV2A37J7GN1z1tp/ZyK98YgzT0fgTNTzCTAEWGCt/VMGktuiUK/6u3DS6sXpCHUpcAW781OE09t0IzAcuN1mdy/0ePL0PDAG2BA6raO19uBMpLcl8eQndFxOPBcg7n+jnHk2xJmfnHkuhBljTgN+idOz/kGczndZ8VzIugAuIiIiLcvKqgsRERFpngK4iIhIDlIAFxERyUEK4CIiIjlIAVxERCQHKYCLiIjkIAVwERGRHKQALiIZ1da5vbN9bnCRVFEAF8kQY8w9xphtxpifhLZHG2M2htaAxhhzjTHmdWPM4CTc68fGmG1tvU6Ma18W8foUY8yqeNJsjOlgjLkPaOtc2P2NMb8NrYAl0m4ogItkzlSgHngjtH0yUIWz3jrAEuBma+03bb2RtfYpoKKt14nhsoj7zMGZ9jMefwCet9aWtuXm1trVwFxgRluuI5JrNJWqSAYZY54C3rLWPhpaYrECcFtrp4UW5LgBKAKeAd4FRgJ/A94J/R4JnIPzReAvOEtqHoSzUFEAqLTW/jZ0r2+stYMj7n1z5HFAKXAHcC/OAhqjgO+EF2cwxvwBZ47r9ThfNpYBb+EE4vuAJdbavxtj3gH+HXGNyY0XeDDGdAqd3ze8Jrkxpi/Q21r7qTFmArAY2A84PZTfOuAk4HVCpXZr7V9C5xYBK4F+1tpgq/4RRHKUSuAimfUy8J3QohXbcFY3+k7oPWOtDeCs2HSvtfZO4CrgDmttPXAR0AX4GvgGZ4GZauAwa+311tobgW8bY8Y2vmlozeY9jgM+xSn1f2at/RnwBXBC6PhTgBHW2l9Ya28FLPCEtfb/gO3W2hnW2r9H3OJTa+3PI6/RyDCcBSEiSxA/BjqEXl8N1IbuA7AhVLrfH/gg9Hc7MHyitbYaZ6Wu3lHuJZKX1GYkklmv4izpORmnZLkA6GOMOQkn+AEY4OhQqdQP9ASw1lYYY14BfgQUAE8BxwMdItbEXhs+vpH9mzkuvJpSKbvXOt4Xp8QctrKFfC0P/d7KnuslhxXg1BpEOgi4N7RGuSsUlN8zxlxnrZ0XKmWXWWvLjDHfZvdqeGF+nNoKkXZBAVwkg6y124wxXwC/Ag631tpQUL4bOCp02E9xqpovMMZ4gZ9HXOIB4AlgvrX2z6HlNCdELK95LLuDaaTPmzkuWrvaV8CxEdtDI14HQh3vxlprP23mGpHWEtF5LdQBrY+1tj60fOM8Y8xwnKVOq0KHHQx8HHp9CjDTGHNgqMrdAJ3YvTSqSN5TFbpI5r0MLI1ou50DVFhry0LbrwEjjDF34VShdwkFOay1X+K0X78d2n4d+MQYc4cx5hactur1xpgfh877eTPHjQIGARcYY4YCRwKTQ18K5gArjDEPh0rtkdXbc3C+cJxrjDmhmWs0sNZuDKWrf2jXeGBzqKp+B7AJ5/m0L/C/0DH7hfOJ01HuRGBhaPsA4B1rbU28f3SRXKdObCISF2PM4dbaD0Kv3wTOt9auacP19gcuwalRuBp4w1r7cfNnRb1OIfAwcGMyeuyL5AoFcBGJizHmP8CbOG3aW6y1v0/CNffCaQu/A/iFtdafwDX6AdXW2vK2pkcklyiAi4iI5CC1gYuIiOQgBXAREZEcpAAuIiKSgxTARUREcpACuIiISA5SABcREclBCuAiIiI5SAFcREQkB/1/5MRvyNmopRAAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(wave, ppm, marker='o', label='Calculated PPM')\n", "plt.plot(wave, ppm_floor, marker='o', label='PPM + Noise Floor')\n", "plt.xlabel('Wavelength ($\\mu m$)')\n", "plt.ylabel('Noise Limit (PPM)')\n", "plt.xlim([2.4,4.1])\n", "plt.ylim([20,100])\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example 5: Extended Souce\n", "\n", "Expect some faint galaxies of 25 ABMag/arcsec^2 in our field. What is the best we can do with 10,000 seconds of acquisition time? " ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "# Detection bandpass is F200W\n", "nrc = pynrc.NIRCam(filter='F200W')\n", "\n", "# Flat spectrum (in photlam) with ABMag = 25 in the NIRCam bandpass\n", "sp = pynrc.stellar_spectrum('flat', 25, 'abmag', nrc.bandpass)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BRIGHT1\n", "BRIGHT2\n", "DEEP2\n", "DEEP8\n", "MEDIUM2\n", "MEDIUM8\n", "RAPID\n", "SHALLOW2\n", "SHALLOW4\n", " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "MEDIUM8 10 9 1052.20 9469.83 9555.73 10.5 0.020 0.107\n", "MEDIUM8 10 10 1052.20 10522.03 10618.67 11.1 0.020 0.107\n", "DEEP8 8 5 1589.04 7945.21 7988.16 9.5 0.031 0.106\n", "DEEP8 7 6 1374.31 8245.84 8299.53 9.7 0.026 0.106\n", "MEDIUM8 8 11 837.47 9212.15 9319.52 10.2 0.016 0.106\n", "DEEP8 6 8 1159.57 9276.57 9351.73 10.3 0.022 0.106\n", "MEDIUM8 9 10 944.84 9448.36 9544.99 10.4 0.018 0.106\n", "DEEP8 8 6 1589.04 9534.25 9587.94 10.4 0.031 0.106\n", "... ... ... ... ... ... ... ... ...\n", "BRIGHT1 10 49 204.00 9995.93 10511.30 6.6 0.004 0.064\n", "BRIGHT1 10 50 204.00 10199.93 10726.04 6.7 0.004 0.064\n", "BRIGHT1 10 51 204.00 10403.93 10940.77 6.8 0.004 0.064\n", "RAPID 10 91 107.37 9770.46 10736.78 4.9 0.002 0.047\n", "RAPID 10 92 107.37 9877.83 10854.88 5.0 0.002 0.047\n", "RAPID 10 93 107.37 9985.20 10972.98 5.0 0.002 0.047\n", "RAPID 10 94 107.37 10092.56 11091.09 5.0 0.002 0.047\n", "RAPID 10 95 107.37 10199.93 11209.19 5.0 0.002 0.047\n", "Length = 66 rows\n" ] } ], "source": [ "res = nrc.ramp_optimize(sp, is_extended=True, tacq_max=10000, tacq_frac=0.05, verbose=True)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Pattern NGRP NINT t_int t_exp t_acq SNR Well eff \n", "---------- ---- ---- --------- --------- --------- -------- -------- --------\n", "RAPID 10 91 107.37 9770.46 10736.78 4.9 0.002 0.047\n", "RAPID 10 92 107.37 9877.83 10854.88 5.0 0.002 0.047\n", "BRIGHT1 10 47 204.00 9587.94 10081.83 6.5 0.004 0.064\n", "BRIGHT1 10 48 204.00 9791.93 10296.57 6.6 0.004 0.064\n", "BRIGHT2 10 45 214.74 9663.09 10135.52 7.8 0.004 0.077\n", "BRIGHT2 10 46 214.74 9877.83 10360.99 7.9 0.004 0.077\n", "SHALLOW2 10 18 504.63 9083.31 9265.84 9.3 0.010 0.096\n", "SHALLOW2 10 19 504.63 9587.94 9781.20 9.6 0.010 0.096\n", "SHALLOW4 10 18 526.10 9469.83 9652.36 10.1 0.010 0.102\n", "SHALLOW4 10 19 526.10 9995.93 10189.20 10.3 0.010 0.102\n", "MEDIUM2 10 9 987.78 8890.05 8975.94 9.8 0.019 0.103\n", "MEDIUM2 10 10 987.78 9877.83 9974.46 10.4 0.019 0.103\n", "MEDIUM8 10 9 1052.20 9469.83 9555.73 10.5 0.020 0.107\n", "MEDIUM8 10 10 1052.20 10522.03 10618.67 11.1 0.020 0.107\n", "DEEP2 9 5 1739.36 8696.78 8739.74 9.6 0.033 0.103\n", "DEEP2 8 6 1524.62 9147.73 9201.42 9.9 0.029 0.103\n", "DEEP8 8 5 1589.04 7945.21 7988.16 9.5 0.031 0.106\n", "DEEP8 7 6 1374.31 8245.84 8299.53 9.7 0.026 0.106\n" ] } ], "source": [ "# Print the Top 2 settings for each readout pattern\n", "res2 = table_filter(res, 2)\n", "print(res2)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "New Ramp Settings\n", " read_mode : MEDIUM8\n", " nf : 8\n", " nd2 : 2\n", " ngroup : 10\n", " nint : 10\n", "New Detector Settings\n", " wind_mode : FULL\n", " xpix : 2048\n", " ypix : 2048\n", " x0 : 0\n", " y0 : 0\n", "New Ramp Times\n", " t_group : 107.368\n", " t_frame : 10.737\n", " t_int : 1052.203\n", " t_int_tot1 : 1052.203\n", " t_int_tot2 : 1062.940\n", " t_exp : 10522.035\n", " t_acq : 10618.671\n" ] } ], "source": [ "# MEDIUM8 10 10 looks like a good option\n", "nrc.update_detectors(read_mode='MEDIUM8', ngroup=10, nint=10, verbose=True)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "# Calculate flux/mag for various nsigma detection limits\n", "tbl = Table(names=('Sigma', 'Point (nJy)', 'Extended (nJy/asec^2)', \n", " 'Point (AB Mag)', 'Extended (AB Mag/asec^2)'))\n", "tbl['Sigma'].format = '.0f'\n", "for k in tbl.keys()[1:]:\n", " tbl[k].format = '.2f'\n", "\n", "for sig in [1,3,5,10]:\n", " snr_dict1 = nrc.sensitivity(nsig=sig, units='nJy', verbose=False)\n", " snr_dict2 = nrc.sensitivity(nsig=sig, units='abmag', verbose=False)\n", " tbl.add_row([sig, snr_dict1[0]['sensitivity'], snr_dict1[1]['sensitivity'],\n", " snr_dict2[0]['sensitivity'], snr_dict2[1]['sensitivity']])" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Table length=4\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
SigmaPoint (nJy)Extended (nJy/asec^2)Point (AB Mag)Extended (AB Mag/asec^2)
float64float64float64float64float64
11.1032.0531.3027.64
33.3096.5730.1026.44
55.52161.6729.5525.88
1011.14326.9928.7825.11
" ], "text/plain": [ "\n", " Sigma Point (nJy) Extended (nJy/asec^2) Point (AB Mag) Extended (AB Mag/asec^2)\n", "float64 float64 float64 float64 float64 \n", "------- ----------- --------------------- -------------- ------------------------\n", " 1 1.10 32.05 31.30 27.64\n", " 3 3.30 96.57 30.10 26.44\n", " 5 5.52 161.67 29.55 25.88\n", " 10 11.14 326.99 28.78 25.11" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tbl" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": {}, "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.7.9" } }, "nbformat": 4, "nbformat_minor": 1 }