{ "cells": [ { "cell_type": "markdown", "id": "d93903c4-cfae-4d2d-b931-5410915b3e2a", "metadata": {}, "source": [ "# Accretion disk" ] }, { "cell_type": "markdown", "id": "cd9d821a-344a-4190-b089-01cf1dd83f88", "metadata": {}, "source": [ "The file `Bobrikova_compton_slab_I.npz`, which contains the atmosphere data for an accretion powered hot spot, is required for this tutorial to run as intended. Still, in principle one could use any atmosphere, such as a default blackbody atmosphere, which does not require this file.\n", "\n", "In this tutorial we will set up an accretion disk, which is a radiation source separate from the star, and add its contribution to the signal. If you don't want an explanation but just a working example of a star with an accretion disk in X-PSI, you can find it in `/examples/example_modelling_tutorial/TestRun_AMXP.py`. From there you can copy the code and modify it as you wish. \n", "\n", "The accretion disk we will use here ([Mitsuda et al. 1984](https://ui.adsabs.harvard.edu/abs/1984PASJ...36..741M/abstract), [Makishima et al. 1986](https://ui.adsabs.harvard.edu/abs/1986ApJ...308..635M/abstract)) is a superposition of multicolor blackbody rings. It does not include relativistic effects and spectral hardening.\n", "\n", "## Setting up the disk model\n", "\n", "We follow here the description given by Makishima et al. (1986). The disk is parametrized by an inner cut-off radius, $R_\\rm{in}$, a temperature at this radius, $T_\\rm{in}$, and an outer radius, $R_\\rm{out}$. The outer rings will contribute much less to the X-ray spectrum than inner rings due to being much colder, so the exact value of $R_\\rm{out}$ is much less consequential than $R_\\rm{in}$. For each ring, the temperature at some radius $T(r)$ is determined by the (gravitational) energy release associated with accretion towards a central object of mass $M_*$. It is expressed as:\n", "\n", "$$T(r) = \\left(\\frac{3 G \\dot{M} M_*}{8 \\pi \\sigma r^3}\\right)^{1/4},$$\n", "\n", "where $G$ is the gravitational constant, $\\dot{M}$ is the accretion rate and $\\sigma$ is the Stefan-Boltzmann constant. If the accretion and the luminosity from accretion were isotropic, one could thus infer accretion rate if all the other parameters in this equation were known. However, this will not be the case (i.e. not isotropic) in the situations we will be considering so we can not apply this equation for that purpose and we will not be using it at all in the end. Nevertheless, we included it here as it is relevant context for how the temperature is produced and how it is distributed (even if just approximately) in the radial direction.\n", "\n", "The surface area $dA$ of an infinitesimal ring between between $r-dr$ and $r$ is given by $2 \\pi r dr$. The specific luminosity $dL_\\rm{ring}(E)$ (energy/time/energy) of two hemispheres becomes\n", "\n", "$$dL_\\rm{ring}(E) = 4 B(E,T(r)) dA \\int d\\Omega= 8 \\pi B(E,T(r)) r dr \\int d\\Omega = 8 \\pi^2 B(E,T(r)) r dr.$$ \n", "\n", "Here the integral of the solid angle over one hemisphere evaluates to $\\pi$. We multiply by 2 for the two sides of the disk and another factor of 2 appears since we define the $B(E, T)$, as half of the blackbody spectral radiance, \n", "\n", "$$B(E,T) = \\frac{E^3}{c^2h^2}\\left[\\exp{\\left(\\frac{E}{k_\\rm{B}T}\\right)-1}\\right]^{-1}. $$\n", "\n", "Next up, we will provide the python functions involved in computing the radiation from the accretion disk that we will later collect into a python class. Let's start with the definition of $B(E, T)$:" ] }, { "cell_type": "code", "execution_count": 1, "id": "e6c887a5-8168-4455-ada5-287053266ca5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/=============================================\\\n", "| X-PSI: X-ray Pulse Simulation and Inference |\n", "|---------------------------------------------|\n", "| Version: 3.0.4 |\n", "|---------------------------------------------|\n", "| https://xpsi-group.github.io/xpsi |\n", "\\=============================================/\n", "\n", "Check your emcee installation.\n", "Check your installation of emcee if using the EnsembleSampler\n", "Imported PyMultiNest.\n", "Check your UltraNest installation.\n", "Check your installation of UltraNest if using the UltranestSampler\n", "Warning: Cannot import torch and test SBI_wrapper.\n", "Imported GetDist version: 1.5.3\n", "Imported nestcheck version: 0.2.1\n" ] } ], "source": [ "import numpy as np\n", "from xpsi.global_imports import _keV, _k_B, _h_keV\n", "_c = 2.99792458E8\n", "_c_cgs = _c*1E2\n", "\n", "def B_E(self, E, T):\n", " '''\n", " Half the energy radiance of a blackbody. If the the photon energy is much higher than kT, \n", " the radiance is set to zero and ignores a warning.\n", "\n", " parameters:\n", " E in keV\n", " T in keV\n", "\n", " returns:\n", " B_E in keV/s/keV/cm^2/sr (you will integrate over keV)\n", " '''\n", " with np.errstate(over='ignore'):\n", " safe_ET = np.float128(E / T)\n", " exp_safe_ET = np.exp(safe_ET)\n", " B = np.where(np.isinf(exp_safe_ET), 0, E**3 / (_h_keV**3 * _c_cgs**2) / (exp_safe_ET - 1))\n", " return B" ] }, { "cell_type": "markdown", "id": "194a14db-3f7a-4d24-9ad7-d2302363bbdb", "metadata": {}, "source": [ "The specific flux of the disk $f_\\rm{disk}(E)$ (energy/time/length$^2$/energy) is the integral of the contribution of each ring from $R_\\rm{in}$ to $R_\\rm{out}$. This can be conveniently expressed as an integral over $dT$:\n", "\n", "\n", "\\begin{equation}\n", "\\begin{aligned}\n", "f_\\mathrm{disk}(E) &= \\frac{\\cos{i} \\int dL_\\mathrm{ring}}{4\\pi D^2} \\\\\n", "&= \\frac{2 \\pi \\cos{i}}{D^2} \\int_{R_\\mathrm{in}}^{R_\\mathrm{out}} r B(E,T(r)) \\, dr \\\\\n", "&= \\frac{8\\pi R_\\mathrm{in}^2 \\cos{i}}{3 D^2 T_\\mathrm{in}} \n", "\\int_{T_\\mathrm{out}}^{T_\\mathrm{in}} \\Big(\\frac{T}{T_\\mathrm{in}}\\Big)^{-11/3} B(E,T) \\, dT.\n", "\\end{aligned}\n", "\\end{equation}\n", "\n", "Where $D$ is the distance and we introduced $\\cos{i}$ to scale the flux to account for the viewing angle.\n", "\n", "In the code, similar to the approach in Xspec (the diskbb model), we collect the three parameters outside of the integral into a normalisation factor \n", "$$K_\\rm{disk} = R_\\rm{in}^2 \\cos{i} / D^2.$$ " ] }, { "cell_type": "code", "execution_count": 2, "id": "fc36e041-0d65-43b9-b24b-86492d4abf84", "metadata": {}, "outputs": [], "source": [ "def get_k_disk(cos_i, r_in, distance):\n", " \"\"\"\n", " This function calculates the k-disk value for a given set of input parameters.\n", " \n", " Parameters\n", " ----------\n", " cos_i: The cosine inclination angle of the disk\n", " r_in: The inner radius of the disk in kilometers\n", " distance: The distance to the disk (and star) in kiloparsecs\n", " \n", " Returns\n", " -------\n", " k_disk normalisation factor\n", " \n", " \"\"\"\n", "\n", " k_disk = cos_i * (r_in / (distance / 10))**2 # in [km/ 10 kpc]^2\n", " \n", " # K_disk is cos_i*R_in^2/D^2 in (km / 10 kpc)^2.\n", " # (1 km / 10 kpc)^2 = 1.0502650e-35 [ cm/cm ]^2\n", "\n", " k_disk *= 1.0502650e-35 # now k_disk is unitless\n", "\n", " return k_disk" ] }, { "cell_type": "markdown", "id": "8a3cecd6-a245-43b1-b2b7-bd1f4ce0ac40", "metadata": {}, "source": [ "We also define the integrand $l_\\rm{disk}(E,T) = \\frac{1}{T_\\rm{in}}(\\frac{T}{T_\\rm{in}})^{-11/3}B(E,T)$." ] }, { "cell_type": "code", "execution_count": 3, "id": "1f89210d-719b-46c2-96ad-eeb408610830", "metadata": {}, "outputs": [], "source": [ "from scipy.integrate import quad\n", "\n", "def l_disk_integrand(self, T, E, T_in, spectral_radiance):\n", " '''\n", " parameters:\n", " T, T_in in keV\n", " E in keV\n", "\n", " returns:\n", " integrand in spectral radiance units/keV. This integrand will \n", " be integrated over keV.\n", " '''\n", "\n", " integrand = (T/T_in)**(-11/3)*spectral_radiance(E, T)/T_in\n", " return integrand\n", "\n", "def l_disk_integrated(self, E, T_in, T_out, spectral_radiance, epsrel):\n", " '''\n", " parameters:\n", " T, T_in in keV\n", " E in keV\n", "\n", " returns:\n", " disk luminosity [spectral radiance units]. \n", " '''\n", "\n", " integrated,_= quad(self.l_disk_integrand, T_out, T_in, args=(E, T_in, spectral_radiance), epsrel=epsrel)\n", " return integrated" ] }, { "cell_type": "markdown", "id": "b83010a4-0533-4596-806d-f97c2959634b", "metadata": {}, "source": [ "For clarity let's rewrite $f_\\rm{disk}$ in the way it is used in the code:\n", "\n", "$$f_\\rm{disk}(E) = \\frac{8 \\pi}{3} K_\\rm{disk} \\int_{T_\\rm{out}}^{T_\\rm{in}} l_\\rm{disk}(E,T) dT$$" ] }, { "cell_type": "code", "execution_count": 4, "id": "fdc4d3ce-c4b5-4b8a-9acd-83158a369e1c", "metadata": {}, "outputs": [], "source": [ "k_B_over_keV = _k_B / _keV\n", "\n", "def get_f_disk(self, energies, spectral_radiance):\n", " \"\"\" Evaluate f_disk(E). This function also requires the X-PSI parameters T_in and K_disk to be defined.\n", " \n", " Parameters\n", " ----------\n", " energies[keV]\n", " \n", " Returns\n", " -------\n", " f_disk [keV/s/cm^2/keV]\n", " \n", " \"\"\"\n", " \n", " T_in = self['T_in'] # in 10^T K\n", " K_disk = self['K_disk'] # \n", "\n", " T_in_keV = k_B_over_keV * pow(10.0, T_in) \n", " T_out_keV = T_in_keV*1e-1 # hardcode a factor 10 difference\n", " \n", " epsrel = 1e-4 # hardcode precision for integration\n", "\n", " f_disk_array = np.array([])\n", " for energy in energies:\n", " f_disk_value = self.l_disk_integrated(energy, T_in_keV, T_out_keV, spectral_radiance, epsrel) \n", " f_disk_array=np.append(f_disk_array,f_disk_value)\n", " \n", " f_disk_array *=K_disk*8*np.pi/3 # keV/s/cm^2/keV\n", " \n", " return f_disk_array" ] }, { "cell_type": "markdown", "id": "b12b304b-7ded-49c3-9221-e943f59148f3", "metadata": {}, "source": [ "To obtain the photon flux for the disk instead of energy flux, one can divide $f_\\rm{disk}(E)$ by the photon energy. Let's collect these function into an X-PSI compatible class. With initiation of an instance of the class, we initiate the three X-PSI compatible parameters that control the accretion disk. When one calls the instance with an array of energies, photon flux at each energy is returned. " ] }, { "cell_type": "code", "execution_count": 5, "id": "3731186d-5261-4f80-a7da-90119553cd92", "metadata": {}, "outputs": [], "source": [ "from xpsi.ParameterSubspace import ParameterSubspace\n", "from xpsi.Parameter import Parameter, Derive\n", "\n", "class Disk(ParameterSubspace):\n", " \"\"\"\n", " A class representing an accretion disk model compatible with the X-PSI framework.\n", "\n", " This class initializes and manages three X-PSI-compatible parameters that describe \n", " the physical properties of an accretion disk: the inner disk temperature, the inner \n", " disk radius, and the disk normalization. Once instantiated, the class allows for \n", " the computation of the photon flux at specified energy values.\n", "\n", " Parameters\n", " ----------\n", " bounds : dict, optional\n", " A dictionary specifying bounds for each parameter. Keys must include:\n", " - 'T_in': Bounds for the logarithm (base 10) of the inner disk temperature in Kelvin.\n", " - 'R_in': Bounds for the inner disk radius in kilometers.\n", " - 'K_disk': Bounds for the disk normalization.\n", " Default is None, which uses the strict bounds defined in the Parameter objects.\n", " \n", " values : dict, optional\n", " A dictionary specifying initial values for each parameter. Keys must include:\n", " - 'T_in': Initial value for the logarithm (base 10) of the inner disk temperature in Kelvin.\n", " - 'R_in': Initial value for the inner disk radius in kilometers.\n", " - 'K_disk': Initial value for the disk normalization.\n", " Default is None, which sets no initial values.\n", "\n", " Methods\n", " -------\n", " __call__(energies):\n", " Computes and returns the photon flux in photons/s/cm^2/keV for the given array of energy\n", " values in keV.\n", "\n", " Attributes\n", " ----------\n", " inner_temperature : Parameter\n", " The parameter representing the logarithm of the inner disk temperature in Kelvin.\n", " inner_radius : Parameter\n", " The parameter representing the inner disk radius in kilometers.\n", " background_normalisation : Parameter\n", " The parameter representing the disk normalization factor.\n", " disk_flux : ndarray\n", " The computed photon flux as a function of energy after calling the instance.\n", "\n", " Notes\n", " -----\n", " - The `Disk` class is designed for compatibility with the X-PSI (X-ray spectral \n", " fitting) framework, and the parameters follow X-PSI conventions.\n", " - The photon flux is computed based on the provided energy array using the \n", " Planck function, with scaling determined by the disk's physical parameters.\n", " - The call function requires the functions B_E and get_f_disk which have been \n", " defined above in this tutorial.\n", "\n", " Example\n", " -------\n", " >>> bounds = {'T_in': (3., 10.), 'R_in': (0., 1e3), 'K_disk': (0., 1e100)}\n", " >>> values = {'T_in': 6.5, 'R_in': 10., 'K_disk': 1e2}\n", " >>> disk = Disk(bounds=bounds, values=values)\n", " >>> energies = np.linspace(1, 10, 100) # Example energy array\n", " >>> flux = disk(energies)\n", " >>> print(flux)\n", " \"\"\"\n", " \n", " def __init__(self, bounds=None, values=None):\n", "\n", " doc = \"\"\"\n", " Temperature at inner disk radius in log10 Kelvin.\n", " \"\"\"\n", " inner_temperature = Parameter('T_in',\n", " strict_bounds = (3., 10.),\n", " bounds = bounds.get('T_in', None),\n", " doc = doc,\n", " symbol = r'$T_{in}$',\n", " value = values.get('T_in', None))\n", "\n", " doc = \"\"\"\n", " Disk R_in in kilometers.\n", " \"\"\"\n", " inner_radius = Parameter('R_in',\n", " strict_bounds = (0., 1e3),\n", " bounds = bounds.get('R_in', None),\n", " doc = doc,\n", " symbol = r'$R_{in}$',\n", " value = values.get('R_in', None))\n", " \n", " doc = \"\"\"\n", " Disk normalisation cos_i*R_in^2/D^2.\n", " \"\"\"\n", " background_normalisation = Parameter('K_disk',\n", " strict_bounds = (0., 1e100),\n", " bounds = bounds.get('K_disk', None),\n", " doc = doc,\n", " symbol = r'$K_{BB}$',\n", " value = values.get('K_disk', None))\n", " \n", "\n", " super(Disk, self).__init__(inner_temperature, inner_radius, background_normalisation)\n", "\n", "\n", " def __call__(self, energies):\n", " self.disk_flux = self.get_f_disk(energies, self.spectral_radiance)/energies\n", " return self.disk_flux\n", "\n", "Disk.spectral_radiance = B_E\n", "Disk.l_disk_integrand = l_disk_integrand\n", "Disk.l_disk_integrated = l_disk_integrated\n", "Disk.get_f_disk = get_f_disk" ] }, { "cell_type": "markdown", "id": "87665870-b18b-4895-a3ff-e6aa9b7289fb", "metadata": {}, "source": [ "Let's now instantiate this class and use it to make a disk spectrum:" ] }, { "cell_type": "code", "execution_count": 6, "id": "973cdc97-08cd-4be4-8038-7f1d68330094", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating parameter:\n", " > Named \"T_in\" with bounds [3.000e+00, 1.000e+01] and initial value 6.530e+00.\n", " > Temperature at inner disk radius in log10 Kelvin.\n", "Creating parameter:\n", " > Named \"R_in\" with bounds [0.000e+00, 1.000e+03] and initial value 5.500e+01.\n", " > Disk R_in in kilometers.\n", "Creating parameter:\n", " > Named \"K_disk\" with bounds [0.000e+00, 1.000e+100] and initial value 3.472e-37.\n", " > Disk normalisation cos_i*R_in^2/D^2.\n" ] } ], "source": [ "D = 1 #kpc\n", "cos_i = 1 #disk face on\n", "R_in = 55 # km\n", "T_in = 6.53 # log10(K) = 6.53 corresponds to 0.29 keV \n", "K_disk = get_k_disk(cos_i, D, R_in)\n", "\n", "bounds_example = {'T_in': (3., 10.), 'R_in': (0., 1e3), 'K_disk': (0., 1e100)}\n", "values_example = {'T_in': T_in, 'R_in': R_in, 'K_disk': K_disk}\n", "disk_example = Disk(bounds=bounds_example, values=values_example)\n", "\n", "energies_example = np.logspace(-1, 0, 100) # Example energy array in keV\n", "flux_example = disk_example(energies_example)" ] }, { "cell_type": "code", "execution_count": 7, "id": "b0fa1216-b510-493e-9e72-a93c4a95a072", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Photons per second per cm^2: 0.000573\n" ] } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "fig, ax = plt.subplots(1,2,figsize=(7,3))\n", "\n", "ax[0].loglog(energies_example, flux_example)\n", "ax[0].set_ylabel('Photon flux [photons/s/cm^2/keV]')\n", "ax[0].set_xlabel('Energies [keV]')\n", "ax[0].set_title(f'Photon flux at {D} kpc')\n", "\n", "ax[1].loglog(energies_example, flux_example*energies_example)\n", "ax[1].set_ylabel('Energy flux [keV/s/cm^2/keV]')\n", "ax[1].set_xlabel('Energies [keV]')\n", "ax[1].set_title(f'Energy flux at {D} kpc')\n", "\n", "fig.tight_layout()\n", "plt.show()\n", "\n", "print(f'Photons per second per cm^2: {np.sum(flux_example):.3g}')\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "663e93bf-da5d-4444-bada-dce6e13e1ff1", "metadata": {}, "source": [ "## Simulating the flux of a neutron star along with an accretion disk\n", "\n", "Now that we have set up the disk model, let's combine its flux with that from a neutron star. We will set up a star with some parameters based on the well studied accreting millisecond X-ray pulsar SAX J1808.4-3658. Let's start with a regular spacetime." ] }, { "cell_type": "code", "execution_count": 8, "id": "ea507c2a-22ba-4bf5-b7be-7214c1ed6427", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating parameter:\n", " > Named \"frequency\" with fixed value 4.010e+02.\n", " > Spin frequency [Hz].\n", "Creating parameter:\n", " > Named \"mass\" with bounds [1.000e+00, 3.000e+00].\n", " > Gravitational mass [solar masses].\n", "Creating parameter:\n", " > Named \"radius\" with bounds [4.430e+00, 1.600e+01].\n", " > Coordinate equatorial radius [km].\n", "Creating parameter:\n", " > Named \"distance\" with bounds [1.000e-01, 1.000e+00].\n", " > Earth distance [kpc].\n", "Creating parameter:\n", " > Named \"cos_inclination\" with bounds [0.000e+00, 1.000e+00].\n", " > Cosine of Earth inclination to rotation axis.\n" ] } ], "source": [ "from xpsi import Spacetime\n", "from xpsi.global_imports import gravradius\n", "\n", "bounds = dict(distance = (0.1, 1.0), # (Earth) distance\n", " mass = (1.0, 3.0), # mass\n", " radius = (3.0 * gravradius(1.0), 16.0), # equatorial radius\n", " cos_inclination = (0.0, 1.0)) # (Earth) inclination to rotation axis\n", "\n", "spacetime = Spacetime(bounds=bounds, values=dict(frequency=400.9752075))" ] }, { "cell_type": "markdown", "id": "51e5f99c-8cfb-4af2-b178-28466df69c67", "metadata": {}, "source": [ "To keep this tutorial concise, we will import necessary custom classes rather than rewriting them verbatim. They were already set up for the example `TestRun_AMXP.py`, and we will import them from there. Nevertheless, we will describe and highlight notable special features of these custom classes. The first Custom class is the `CustomHotRegion_Accreting`, which provides hot regions that incorporate the Compton slab atmosphere (Bobrikova et al. 2023). This class accepts three atmosphere parameters: $t_\\rm{bb}$, $\\tau$, $t_\\rm{e}$. For this purpose the class function `_HotRegion__compute_cellParamVecs` is overwritten to accept three parameters instead of the standard two for rotation powered millisecond pulsars.\n", "\n", "Here we will use just one circular hot spot so we only have a primary. " ] }, { "cell_type": "code", "execution_count": 9, "id": "6c7b0404-d2ad-4224-b3ff-6acbfb5f5097", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating parameter:\n", " > Named \"super_tbb\" with bounds [1.000e-03, 3.000e-03].\n", " > tbb.\n", "Creating parameter:\n", " > Named \"super_te\" with bounds [4.000e+01, 2.000e+02].\n", " > te.\n", "Creating parameter:\n", " > Named \"super_tau\" with bounds [5.000e-01, 3.500e+00].\n", " > tau.\n", "The default/given atmosphere option is ignored, since using split=True, which only works with numerical 3+2D interpolation.\n", "Creating parameter:\n", " > Named \"super_colatitude\" with bounds [0.000e+00, 3.142e+00].\n", " > The colatitude of the centre of the superseding region [radians].\n", "Creating parameter:\n", " > Named \"super_radius\" with bounds [0.000e+00, 1.571e+00].\n", " > The angular radius of the (circular) superseding region [radians].\n", "Creating parameter:\n", " > Named \"phase_shift\" with bounds [0.000e+00, 1.000e-01].\n", " > The phase of the hot region, a periodic parameter [cycles].\n" ] } ], "source": [ "import os\n", "import sys\n", "from pathlib import Path\n", "\n", "# Get the directory of the current notebook\n", "this_directory = str(Path().resolve()) # Resolves to the current working directory\n", "sys.path.append(this_directory + '/../../examples/examples_modeling_tutorial/modules/') \n", "\n", "from CustomHotRegion_Accreting import CustomHotRegion_Accreting\n", "\n", "\n", "bounds = dict(super_colatitude = (None, None),\n", " super_radius = (None, None),\n", " phase_shift = (0.0, 0.1),\n", " super_tbb = (0.001, 0.003),\n", " super_tau = (0.5, 3.5),\n", " super_te = (40.0, 200.0))\n", "\n", "primary = CustomHotRegion_Accreting(bounds=bounds,\n", " values={},\n", " symmetry=True,\n", " omit=False,\n", " cede=False,\n", " concentric=False,\n", " sqrt_num_cells=50, #100\n", " min_sqrt_num_cells=10,\n", " max_sqrt_num_cells=64, #100\n", " num_leaves=30,\n", " num_rays=200,\n", " split=True,\n", " atm_ext='Num5D',\n", " image_order_limit=3,\n", " prefix='p')\n", "\n", "from xpsi import HotRegions\n", "hot = HotRegions((primary,))" ] }, { "cell_type": "markdown", "id": "a749afbc-b441-4c66-91ae-db92bc903163", "metadata": {}, "source": [ "Before we continue with the photosphere, we must first modify the disk model slightly, such that the flux can be combined with the flux from a star. \n", "\n", "First we will multiply the disk flux with the distance squared in meters. This is to match the emission unit that X-PSI is expecting, which is the total photon emission rate per unit energy (keV). Later, if computing the registered counts, the combined emission (star and disk) will be divided by distance squared (in `Likelihood.py`) to recover the flux. \n", "\n", "We choose to make the modification in the previous function `k_disk`, which will imply this function no longer returns `k_disk`. This is convenient because the distance was one of the function arguments, so it is readily available." ] }, { "cell_type": "code", "execution_count": 10, "id": "b244e879-7e3c-4c64-9e61-1f6cdfd9cb91", "metadata": {}, "outputs": [], "source": [ "def get_k_disk_distance_m_squared(cos_i, r_in, distance):\n", " \"\"\"\n", " This function calculates the k-disk value for a given set of input parameters.\n", " \n", " Parameters\n", " ----------\n", " cos_i: The cosine inclination angle of the disk\n", " r_in: The inner radius of the disk in kilometers\n", " distance: The distance to the disk (and star) in kiloparsecs\n", " \n", " Returns\n", " -------\n", " k_disk times the distance in meters squared\n", " \n", " \"\"\"\n", "\n", " k_disk = cos_i * (r_in / (distance / 10))**2 # in [km/ 10 kpc]^2\n", " \n", " # K_disk is cos_i*R_in^2/D^2 in (km / 10 kpc)^2.\n", " # (1 km / 10 kpc)^2 = 1.0502650e-35 [ cm/cm ]^2\n", "\n", " k_disk *= 1.0502650e-35 # now k_disk is unitless\n", "\n", " # multiplying k_disk by distance squared in meters to match signal units\n", " distance_m = 3.08567758128e19*distance\n", " k_disk_distance_m_squared = k_disk*distance_m**2\n", "\n", " return k_disk_distance_m_squared " ] }, { "cell_type": "markdown", "id": "d156e276-e2c3-4e84-b549-e2dbff7d0adb", "metadata": {}, "source": [ "Since `K_disk` is a parameter which depends solely other parameters, we use a new class to automatically derive it from those parameters. To achieve this we define a new class `k_disk_derive` which is a subclass of `xpsi.Derive`. By using the Derive functionality in X-PSI, we ensure the derived parameter is compatible with parameter sampling. " ] }, { "cell_type": "code", "execution_count": 11, "id": "ae0b1b0c-5167-496b-94ec-2cc786e4e0cb", "metadata": {}, "outputs": [], "source": [ "class k_disk_derive(Derive):\n", " def __init__(self):\n", " pass\n", "\n", " def __call__(self, boundto, caller=None):\n", " # Ensure that self.star and self.disk are defined when we \n", " # call an instance of this class. This ensures parameter \n", " # values are passed along correctly.\n", " return get_k_disk_distance_m_squared(\n", " self.star['cos_inclination'], \n", " self.disk['R_in'], \n", " self.star['distance']\n", " )\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "4b506346-af1b-40b4-9a18-eb80e0414d34", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating parameter:\n", " > Named \"T_in\" with bounds [3.000e+00, 1.000e+01] and initial value 6.530e+00.\n", " > Temperature at inner disk radius in log10 Kelvin.\n", "Creating parameter:\n", " > Named \"R_in\" with bounds [0.000e+00, 1.000e+03] and initial value 5.500e+01.\n", " > Disk R_in in kilometers.\n", "Creating parameter:\n", " > Named \"K_disk\" that is derived from ulterior variables.\n", " > Disk normalisation cos_i*R_in^2/D^2.\n" ] } ], "source": [ "k_disk = k_disk_derive()\n", "values_derive = {'T_in':T_in,'R_in':R_in,'K_disk': k_disk}\n", "bounds_example['K_disk'] = None # we must choose `None` here for the boundaries of the derived parameter. Having any boundaries here is not allowed and could cause conflicts.\n", "disk = Disk(bounds=bounds_example, values=values_derive)" ] }, { "cell_type": "markdown", "id": "3380596b-67c9-4395-ace0-7ae68556818f", "metadata": {}, "source": [ "Now we are ready to create instantiate the custom photosphere. This photosphere accepts a new parameter in the `init` called `disk`, and then creates a private property called `_disk`. To `disk` we will pass the instance of the disk class. The spectrum of the disk will be added to the first time-invariant component of the signal (in this case the only component since we only have one hotspot) like so:\n", "\n", "```\n", "# add time-invariant component to first time-dependent component\n", "if self._disk is not None:\n", " self.disk_spectrum = self._disk(energies)\n", " for i in range(self._signal[0][0].shape[1]):\n", " self._signal[0][0][:,i] += self.disk_spectrum\n", "```\n", "The time-dependent component here has some amount of phase bins (num_leaves) and we add up the disk emission to each component. There is no need to divide the disk emission by the number of phase bins here, which one may think of doing when distributing an emission component along some number of bins such that when summing back later together one conserves the full contribution one started with. The reason why is that the signal will make use of `gsl_interp_eval_integ` (in `synthesise.pyx`) when recording data of photon counts (per second). That function already accounts for phase intervals correctly in the sense that a constant signal with any number of phase bins will integrate up correctly within in phase interval [0,1] to the number one started with. If in any other situation one may be adding a constant component with some count rate to the time dependent count rate of a star (such as by considering it a `background`), one must take care to ensure that the distribution of counts over phase bins is correct.\n", "\n", "Another note is that we insert the disk into the `custom` argument of `xpsi.Photosphere` when calling the `super` function, which will make X-PSI aware of the disk parameters. One could add more components there in the future since custom can be a list of instances." ] }, { "cell_type": "code", "execution_count": 13, "id": "df7764ce-17d7-4af1-8fd8-5b375766679c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating parameter:\n", " > Named \"mode_frequency\" with fixed value 4.010e+02.\n", " > Coordinate frequency of the mode of radiative asymmetry in the\n", "photosphere that is assumed to generate the pulsed signal [Hz].\n", "Creating parameter:\n", " > Named \"mode_frequency\" with fixed value 4.010e+02.\n", " > Coordinate frequency of the mode of radiative asymmetry in the\n", "photosphere that is assumed to generate the pulsed signal [Hz].\n" ] } ], "source": [ "from CustomPhotosphere import CustomPhotosphere_NumA5\n", "from xpsi import Star\n", "\n", "photosphere = CustomPhotosphere_NumA5(hot = hot, elsewhere = None, stokes=False, disk=disk, bounds=None,\n", " values=dict(mode_frequency = spacetime['frequency']))\n", "\n", "photosphere.hot_atmosphere = this_directory+'/../../examples/examples_modeling_tutorial'+'/model_data/Bobrikova_compton_slab_I.npz'\n", "\n", "star = Star(spacetime = spacetime, photospheres = photosphere)" ] }, { "cell_type": "markdown", "id": "2b6899d1-3503-4d19-8876-3d8957c5f2e1", "metadata": {}, "source": [ "Now that we have created the star instance, we can also connect the star (and the disk) to the derived `k_disk`" ] }, { "cell_type": "code", "execution_count": 14, "id": "3e575d29-2544-4d68-88a2-668d1b73ab67", "metadata": {}, "outputs": [], "source": [ "k_disk.star = star\n", "k_disk.disk = disk" ] }, { "cell_type": "markdown", "id": "2df73295-5470-44a1-a458-6ab90e0ab6a5", "metadata": {}, "source": [ "Now, we can make a SAX J1808-like parameter vector." ] }, { "cell_type": "code", "execution_count": 15, "id": "f23ff14d-8929-414c-b5f5-5ad6a025c440", "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "# Star parameters\n", "mass = 1.4\n", "radius = 11.0\n", "distance = 2.7\n", "inclination = 80.\n", "cos_i = math.cos(inclination*math.pi/180.0)\n", "\n", "# Hotspot\n", "phase_shift = 0.226365126031355196E+00\n", "super_colatitude = 0.175993450466385537E+00\n", "super_radius = 30.*math.pi/180\n", "\n", "# Compton slab model parameters\n", "tbb=0.0025\n", "te=100.\n", "tau=2.0\n", "\n", "#Tbb = 1 keV <=> tbb = 0.002 (roughly)\n", "#Te = 50 keV <=> te = 100 (roughly)\n", "\n", "p = [mass, #grav mass\n", " radius, #coordinate equatorial radius\n", " distance, # earth distance kpc\n", " cos_i, #cosine of earth inclination\n", " phase_shift, #phase of hotregion\n", " super_colatitude, #colatitude of centre of superseding region\n", " super_radius, #angular radius superceding region\n", " tbb,\n", " te,\n", " tau,\n", " T_in,\n", " R_in,\n", " ]\n", "\n", "star(p)\n", "star.update()" ] }, { "cell_type": "markdown", "id": "e799d401-a0eb-4701-858d-cf94c06aa644", "metadata": {}, "source": [ "We use `photosphere.integrate()`, to get the incident signal before interstellar absorption or interaction with the telescope." ] }, { "cell_type": "code", "execution_count": 16, "id": "551b348c-ff3b-46d1-b663-456898d40b0a", "metadata": {}, "outputs": [], "source": [ "energies = np.logspace(np.log10(0.15), np.log10(12.0), 40, base=10.0)\n", "photosphere.integrate(energies, threads=1)\n", "StokesI = photosphere.signal[0][0]\n", "phases = np.linspace(0,1,30)" ] }, { "cell_type": "code", "execution_count": 17, "id": "8ef1514b-2a78-4c70-8d25-4b5e4bdc1db5", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from matplotlib.colors import LogNorm\n", "\n", "fig, ax = plt.subplots(1, 2, figsize=(10, 3))\n", "\n", "profile = ax[0].pcolormesh(phases, energies, StokesI, shading='auto', \n", " norm=LogNorm(vmin=StokesI.min(), vmax=StokesI.max()))\n", "ax[0].set_yscale('log')\n", "ax[0].set_title('Photon emission in photons/s/cm^2*m^2') # the meters squared is related to the distance to recover flux, the centimeters squared is for the instrumental effective area\n", "ax[0].set_ylabel('photon energy (keV)')\n", "ax[0].set_xlabel('phase (cycles)')\n", "fig.colorbar(profile, ax=ax[0])\n", "\n", "profile = ax[1].pcolormesh(phases, energies, (energies * StokesI.T).T, shading='auto', \n", " norm=LogNorm(vmin=(energies * StokesI.T).T.min(), \n", " vmax=(energies * StokesI.T).T.max()))\n", "ax[1].set_yscale('log')\n", "ax[1].set_title('(Photon) energy emission in keV/s/cm^2*m^2')\n", "ax[1].set_xlabel('phase (cycles)')\n", "fig.colorbar(profile, ax=ax[1], label=\"Logarithmic Scale\")\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "b95b1a1b-22d6-4f3a-abb9-9c5754a281a9", "metadata": {}, "source": [ "For completeness, here is also the 1D spectrum separately. The star flux is averaged over phase." ] }, { "cell_type": "code", "execution_count": 18, "id": "6adf1d3d-2798-40b1-9da3-c24e6810c75a", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAG9CAYAAAD5ixlRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABb1ElEQVR4nO3dd3hUZcLG4d+kF5JASAg9dDA0qQJKEwiCH0UEERFBQVFRrLCwrHXXRVdRVgW7NJUizQIKKFVEmhQB6YEECCUEEtLLnO+PgWA2lEyYyZlknvu65tqZMyczT1iHeTjnPe9rMQzDQERERMQNeZgdQERERMQsKkIiIiLitlSERERExG2pCImIiIjbUhESERERt6UiJCIiIm5LRUhERETcloqQiIiIuC0VIREREXFbKkIiIiLitlSERERExG2V+iL0/fffU79+ferWrcunn35qdhwRERFxIZbSvOhqTk4OUVFRrFq1iuDgYJo3b87GjRsJDQ01O5qIiIi4gFJ9RGjTpk00bNiQKlWqEBQURM+ePVm2bJnZsURERMRFuHQRWrt2Lb169aJy5cpYLBYWL15cYJ+pU6dSs2ZN/Pz8aNGiBevWrct77sSJE1SpUiXvcdWqVTl+/HhxRBcREZESwKWLUGpqKk2bNuX999+/4vNz587l6aefZsKECWzbto327dvTo0cPYmNjAbjSWT+LxeLUzCIiIlJyeJkd4Fp69OhBjx49rvr822+/zfDhwxkxYgQAkydPZtmyZXzwwQdMnDiRKlWq5DsCdOzYMW655Zarvl5mZiaZmZl5j61WK4mJiZQvX14FSkREpIQwDIMLFy5QuXJlPDyuc8zHKCEAY9GiRXmPMzMzDU9PT2PhwoX59hs9erTRoUMHwzAMIzs726hTp45x7NgxIzk52ahTp46RkJBw1fd46aWXDEA33XTTTTfddCsFt7i4uOv2C5c+InQtCQkJ5ObmEhERkW97REQEJ0+eBMDLy4tJkybRuXNnrFYrY8eOpXz58ld9zfHjx/Pss8/mPU5KSqJ69erExcURHBzsnF9EREREHCo5OZlq1aoRFBR03X1LbBG65H9PWRmGkW9b79696d27d6Fey9fXF19f3wLbg4ODVYRERERKmMIMa3HpwdLXEhYWhqenZ97Rn0tOnz5d4CiRiIiIyJWU2CLk4+NDixYtWLFiRb7tK1asoF27dialEhERkZLEpU+NpaSkcPDgwbzHMTExbN++ndDQUKpXr86zzz7LkCFDaNmyJW3btuXjjz8mNjaWRx991MTUIiIiRWO1WsnKyjI7Rong7e2Np6fnDb+OSxehLVu20Llz57zHlwYyDx06lOnTpzNw4EDOnj3Lq6++Snx8PI0aNWLp0qVERkaaFVlERKRIsrKyiImJwWq1mh2lxChbtiwVK1a8oSluSvVaYzcqOTmZkJAQkpKSNFhaREScxjAMYmNjyc7OLtzcN27OMAzS0tI4ffo0ZcuWpVKlSvmet+f726WPCJllypQpTJkyhdzcXLOjiIiIG8jJySEtLY3KlSsTEBBgdpwSwd/fH7BdJFWhQoUinyZT5byCUaNGsWfPHjZv3mx2FBERcQOX/uHt4+NjcpKS5VJpzM7OLvJrqAiJiIi4CC3nZB9H/HmpCImIiIjbUhESERERh+rUqRNPP/00ADVq1GDy5MmF+jl79nUUDZYWERERp9m8eTOBgYFmx7gqFSERERFxmvDwcLMjXJNOjYmIiEiRpaam8sADD1CmTBkqVarEpEmT8j3/v6e7Xn75ZapXr46vry+VK1dm9OjRV33tadOmERISUmA5LUfSESEREREXYxgG6dnmzGXn7+1p19VYY8aMYdWqVSxatIiKFSvy97//na1bt3LzzTcX2Hf+/Pm88847zJkzh4YNG3Ly5El27Nhxxdd96623mDhxIsuWLaNNmzZF/XWuS0XoCjShooiImCk9O5eoF5eZ8t57Xu1OgE/h6kFKSgqfffYZM2fOpFu3bgDMmDGDqlWrXnH/2NhYKlasSNeuXfH29qZ69eq0bt26wH7jx49nxowZrF69msaNGxf9lykEnRq7Ak2oKCIicn2HDh0iKyuLtm3b5m0LDQ2lfv36V9x/wIABpKenU6tWLR5++GEWLVpETk5Ovn0mTZrERx99xC+//OL0EgQ6IiQiIuJy/L092fNqd9Peu7DsXa60WrVq7Nu3jxUrVvDTTz/x+OOP8+abb7JmzRq8vb0BaN++PUuWLGHevHmMGzfOrtcvChUhERERF2OxWAp9espMderUwdvbm99++43q1asDcO7cOfbv30/Hjh2v+DP+/v707t2b3r17M2rUKBo0aMAff/xB8+bNAWjdujVPPvkk3bt3x9PTkzFjxjj1d3D9P2URERFxSWXKlGH48OGMGTOG8uXLExERwYQJE/DwuPLIm+nTp5Obm8stt9xCQEAAs2bNwt/fn8jIyHz7tW3blh9++IE77rgDLy8vnnnmGaf9DipCIiIiUmRvvvkmKSkp9O7dm6CgIJ577jmSkpKuuG/ZsmV5/fXXefbZZ8nNzaVx48Z89913lC9fvsC+t956K0uWLKFnz554enpe8zL7G2Ex7D3B50aSk5MJCQkhKSmJ4OBgs+OIiEgplZGRQUxMDDVr1sTPz8/sOCXG1f7c7Pn+1lVjIiIi4rZUhERERMRtqQiJiIiI21IREhEREbelInQFU6ZMISoqilatWpkdRURERJxIRegKtMSGiIiIe1AREhEREbelIiQiIiJuS0VIRERE3JaKkIiIiLgtFSERERFxuGHDhtG3b1+zY1yXipCIiIi4rOzsbKe+voqQiIiIFNn8+fNp3Lgx/v7+lC9fnq5duzJmzBhmzJjBN998g8ViwWKxsHr1agD+9re/Ua9ePQICAqhVqxYvvPBCvrLz8ssvc/PNN/P5559Tq1YtfH19ceb68F5Oe2UREREpGsOA7DRz3ts7ACyWQu0aHx/PoEGD+M9//sNdd93FhQsXWLduHQ888ACxsbEkJyczbdo0AEJDQwEICgpi+vTpVK5cmT/++IOHH36YoKAgxo4dm/e6Bw8eZN68eSxYsABPT0/H/45/oSIkIiLiarLT4N+VzXnvv58An8BC7RofH09OTg79+vUjMjISgMaNGwPg7+9PZmYmFStWzPcz//jHP/Lu16hRg+eee465c+fmK0JZWVnMmjWL8PDwG/1trktFSERERIqkadOmdOnShcaNG9O9e3eio6Pp378/5cqVu+rPzJ8/n8mTJ3Pw4EFSUlLIyckhODg43z6RkZHFUoJARUhERMT1eAfYjsyY9d6F5OnpyYoVK/j1119Zvnw57733HhMmTGDjxo1X3P+3337j3nvv5ZVXXqF79+6EhIQwZ84cJk2alG+/wMDCHZFyBBWhK5gyZQpTpkwhNzfX7CgiIuKOLJZCn54ym8Vi4dZbb+XWW2/lxRdfJDIykkWLFuHj41Pge3T9+vVERkYyYcKEvG1Hjx4t7sj5qAhdwahRoxg1ahTJycmEhISYHUdERMQlbdy4kZ9//pno6GgqVKjAxo0bOXPmDDfddBMZGRksW7aMffv2Ub58eUJCQqhTpw6xsbHMmTOHVq1asWTJEhYtWmTq76AiJCIiIkUSHBzM2rVrmTx5MsnJyURGRjJp0iR69OhBy5YtWb16NS1btiQlJYVVq1bRp08fnnnmGZ544gkyMzO58847eeGFF3j55ZdN+x0shjMvzi/hLh0RSkpKKjCQS0RExFEyMjKIiYmhZs2a+Pn5mR2nxLjan5s939+aUFFERETcloqQiIiIuC0VIREREXFbKkIiIiLitlSERERExG2pCImIiLgIXchtH0f8eakIiYiImOzSCutZWVkmJylZ0tLSAPD29i7ya2hCRREREZN5eXkREBDAmTNn8Pb2xsNDxymuxTAM0tLSOH36NGXLls0rkkWhIiQiImIyi8VCpUqViImJMX3trZKkbNmyVKxY8YZeQ0VIRETEBfj4+FC3bl2dHiskb2/vGzoSdImK0BVo9XkRETGDh4eHltgoZlpr7Bq01piIiEjJo7XGRERERApBRUhERETcloqQiIiIuC0VIREREXFbKkIiIiLitlSERERExG2pCImIiIjbUhESERERt6UiJCIiIm5LRUhERETcloqQiIiIuC0VIREREXFbKkIiIiLitlSERERExG2pCImIiIjbUhESERERt6UidAVTpkwhKiqKVq1amR1FREREnMhiGIZhdghXlZycTEhICElJSQQHB5sdR0RERArBnu9vHRESERERt6UiJCIiIm7Ly+wAIgBWq0GuYeBhseBhAYvFYnYkERFxAypC4lBWq0FCSibHzqdz/Fw6J5MyuJCRzYXMHFIyckjJtN0uXLr/l23/y9PjcinysICnxWIrSh4Wgv29KBfgQ9kAH8oFeFMuwIcQf2/b/UDb9rL+3kQE+1EhyBcPDxUrEREpSEVI7GIYBvFJGRxJSOXY+XROXCw8x8/bbvHnM8jKtTrkvXKtBrm2dy3wXFJ6NnGJ6YV6HT9vD2qUD6RG+UAiwwKoWT6QGmG2xxHBvjr6JCLixlSE5KpyrQYxCSnsPpF88ZbEnhPJnEvLvubPeVigYrAfVcr5UzHEn7L+3pTx86KMrxdBF/+3jK8XZfy8CPK9/JyPpwdWw7h4s5Wu3Iv3rVYDwwCrYZBjtZKUns251GzOpWXZ7qdlcS4tm/NpWXnbz6dlcyYlk4xsK3tPXmDvyQsFsvp7exJZPoCaYYE0qhJC8+rlaFothAAffTRERNyB/rYXAHJyreyJT2bX8YuFJz6ZvfEXSM/OLbCvp4eFyPIBVCnrT9Vy/lQO8adKOX+qlPWncll/Kob44e3pGuPws3OtHDuXzpGEVI6cTeVIQioxZ9M4ejaVY+fSSc/OzStJP+w6Cdh+v/oRQTSPLEvz6uVoXr0ckeUDdORIRKQUsnseoSNHjrBu3TqOHDlCWloa4eHhNGvWjLZt2+Ln5+esnKYozfMIGYbBoTOprD+YwLoDCfx2+OwVx+n4e3tyU6UgGlYOoWHlYBpWDqFuRBn8vD1NSO1YWTlWjp1L4+jZNA6eTmF73Hl+jz1HfFJGgX1DA31oVq0szSPL0bpmKM2rl8NT445ERFySPd/fhS5CX331Fe+++y6bNm2iQoUKVKlSBX9/fxITEzl06BB+fn4MHjyYv/3tb0RGRjrkFzFbaStCZy5k8uuhBH45kMAvBxMKfOGH+HvTpGoIURcLT8PKwdQoH+h2X/jxSen8fvQ822LP8XvsOXYdTy4w7ik00IcuDSoQ3bAi7euGlYpiKCJSWji8CDVv3hwPDw+GDRtG7969qV69er7nMzMz2bBhA3PmzGHBggVMnTqVAQMG3Nhv4QJKehHKtRr8dvgsq/edZt2BhAJjZHy8PGhVoxy31gmjfZ1wGlYO1tVVV5CZk8vuE8n8fvQc22LP88vBBJLSL4+T8vf2pEO9MKKjKnJ7gwqUC/QxMa2IiDi8CC1ZsoQ777yzUG+ekJBATExMqVinqyQWIcMw2HEsiW+2H+f7nfGcuZCZ7/moSsG0rxvGrXXCaFUjFH8fHcmwV3aulc1HElm++xQr9pzi+PnLV695elhoXSOU6IYRdIuKoGq5ABOTioi4J6ecGjtz5gzh4eEOCVhSlKQidOhMCt9sP8G3249z5Gxa3vayAd50uymC9vXCubV2ecqX8TUxZeljGAa7TySzfM8plu8+WeCo2y01Q3mgbQ2iG0a4zAByEZHSzilFyMfHh969ezN8+HDuuOMOt7iCxtWL0MmkDL7bcYJvdhxn1/HkvO3+3p50i4qgz82VaV83HB8vfQEXl9izaSzfc5Lle06x5Ugi1oufrgpBvgxqXZ37bqlORHDpuqhARMTVOKUIzZ49m2nTprFy5UoqVqzIgw8+yLBhw6hdu7ZDQrsiVy1Ci7cdZ+7mOH6LOcul//c8PSx0qBtG32ZV6HpTBIG+mhnBbPFJ6Xy1MZbZm+JISLGdovT0sNC9YQRD2tSgTa1Qt/gHhYhIcXNKEbokLi6Ozz//nBkzZnD06FE6dOjAiBEjuPvuu3X5fDF5Zu52Fm07DkCrGuXofXMVejaqqNNeLiorx8qPu08ya8MRNh85l7e9XkQZhrSJ5K7mVSmj4ioi4jBOLUJ/9fPPPzNt2jQWLVqEj48PgwYNYurUqUV9OZfjqkVo85FENh9JpFeTylQL1WDckmTPiWS+2HiURb8fz5usMtDHkwEtq/F4p9pU0GkzEZEbVmxF6JIFCxbwyCOPcP78eXJzC85EXFK5ahGSki85I5sFW48x67ejHD6TCtjGdo1oX5NHOtQiyM/b5IQiIiVXsRShI0eOMG3aNGbMmMGxY8fo3Lkzw4cP59577y1SaFekIiTOZhgGvxxM4O0V+9kWex6wTdb4ROc6DG5THV8vTW8gImIvpxWhjIwMvv76a6ZNm8batWupUqUKw4YN48EHH6RGjRo3mtvlqAhJcTEMg2W7T/GfZXvzjhBVLefPc9H16NO0iia6FBGxg1OK0COPPMK8efPIyMigT58+PPTQQ0RHR5fqq15UhKS45eRa+XrrMd5ZsZ/TFyfDvKlSMH+7oz4d64WX6s+biIijOKUINWnShOHDhzNkyBBCQ0MdEtTVqQiJWdKzcvl8fQwfrjnEhQzbYrhta5VnXI8GNK1W1txwIiIurljGCGVlZRETE0Pt2rXx8ipdl/5OmTKFKVOmkJuby/79+1WExDTnUrOYuvogM349mrfw64AWVXmhVxTBGlAtInJFTi1CaWlpPPnkk8yYMQOA/fv3U6tWLUaPHk3lypUZN25c0ZO7GB0REldx7Fwa76w4wMJtxzAMqBzix5sDmnJrnTCzo4mIuBx7vr/tXnth/Pjx7Nixg9WrV+ebQLFr167MnTvX/rQicl1VywUw6Z6mfD2yLZHlAziRlMHgTzfy4je7SMvKMTueiEiJZXcRWrx4Me+//z633XZbvoGbUVFRHDp0yKHhRCS/ljVC+eGp9gxpEwnAzA1H6fHfdWw5kmhyMhGRksnuInTmzBkqVKhQYHtqaqquaBEpBgE+XvyzbyNmDW9NpRA/jp5NY8BHG5j4w59kZJeeCU1FRIqD3UWoVatWLFmyJO/xpfLzySef0LZtW8clE5Fral83nGXPdKB/i6oYBny05jC93/+FXceTzI4mIlJi2H2518SJE7njjjvYs2cPOTk5/Pe//2X37t1s2LCBNWvWOCOjiFxFsJ83bw1oSveGFRm/8A/2n0qh75T1PHF7HUZ1roO3p93/1hERcSt2/y3Zrl071q9fT1paGrVr12b58uVERESwYcMG6tat64yMInId3aIiWP5MB3o2rkiO1WDyTwe4+4NfOX4+3exoIiIurdCXz7/11ls8//zzV30+OTmZ6OhofvvtN4eFM5sun5eSxjAMvtsZzwuLd5GUnk1YGV8+eaAFzaqXMzuaiEixccrl8y+88ALTpk274nMpKSl0796d5ORk+5KKiENZLBZ6N63M0qfa06BiEAkpmdz78W98v/OE2dFERFxSoYvQrFmzePzxx1m8eHG+7SkpKURHR5OYmMiqVascnU9EiqBKWX/mP9aOLg0qkJlj5YmvtvHuzwco4kTyIiKlVqGLUP/+/Xnvvfe477778gpPSkoKd9xxBwkJCaxevZqIiAinBRUR+5Tx9eLjB1oy/LaaALy9Yj/PzN2uS+xFRP7CrqvGRowYQWJiIn379uWbb77hhRde4OTJk6xZs4ZKlSo5K6OIFJGnh4UX/i+KWuGBvPjNbhZvP0HcuXQ+GtKCsDK+ZscTETGd3VeNjR07lscff5wuXbpw4sQJVq9eTZUqVZyRTUQcZPAtkcx4sDVBfl5sPXqOvlPWs//UBbNjiYiYrtBXjfXr1y/f46VLl9K0adMCJWjhwoWOS2cyXTUmpc3B0ykMn7GZo2fTCPL14v3BzelYL9zsWCIiDuWUq8aCg4MJCQnJuw0aNIioqKh820JCQm44vIg4T50KZVj8+K20rhnKhcwcHpy2iZkbjpgdS0TENIU+IuSOdERISqusHCt/X/QH87ceA2Bkh1qM69FA6wWKSKnglCNClStX5rHHHuPHH38kKyvrhkOKiHl8vDx4s38T/nZHAwA+WnuYScv3m5xKRKT4FboIffXVVwQEBPDkk08SFhbGgAEDmDVrFomJic7MJyJOYrFYeKxTbV7t0xCA91cd5L2fD5icSkSkeBXp1Nju3bv59ttv+eabb9i2bRtt27alT58+9O7dm9q1azsjpyl0akzcxSdrD/Pa0j8BmNDzJh7uUMvkRCIiReeUU2N/1bBhQ8aPH89vv/1GbGwsgwcPZuXKlTRu3JhGjRqxZMmSIgUXEXM83KEWz3WrB8BrS//UAGoRcRsOHSydmprK8uXLCQoKomvXro56WdPoiJC4mzeX7WXKqkMAvHF3Ywa2qm5yIhER+9nz/W3XzNLXExgYyF133eXIlxSRYvR8dH0ysq189ksM4xb+gY+XB3c1q2p2LBERp7Hr1NjUqVPp2rUr99xzDytXrsz3XEJCArVqaVyBSElmsVj4x503cX+b6hgGPDdvB0v/iDc7loiI0xS6CL377ruMGTOGBg0a4OvrS8+ePZk4cWLe87m5uRw9etQpIUWk+FgsFl7t3Yh7WlbFasDo2dv4ac8ps2OJiDhFoU+NffTRR3zyySfcd999ADz++OP07duX9PR0Xn31VacFFJHi5+FhYWK/JmTmWPlm+wke//J3Ph3akg5ajkNESplCHxGKiYmhXbt2eY/btm3LypUr+fjjjxk/frxTwomIeTw9LEwa0JQ7GlYkK9fKwzO3sOHQWbNjiYg4VKGLUFhYGHFxcfm2NWzYkJUrVzJt2jTGjBnj8HAiYi4vTw/eHdSM2xtUIDPHyvAZm9lzItnsWCIiDlPoInTbbbexYMGCAtujoqL4+eef+fHHHx0aTERcg4+XB1MHN6dd7fKkZeUy8ostnE/TMjsiUjoUugiNGzeOpk2bXvG5hg0bsmrVKl588UWHBRMR1+Hn7cnUwc2pHhpAXGI6T87eRq5V6zWLSMmn1eevQRMqiuT3Z3wy/ab+Snp2Lo91qp23aKuIiCtx+hIbIuKebqoUzH/6NwHgg9WHWLJTcwyJSMlmVxEyDIMnn3zSWVlEpATo1bQyj1xclHXM/B3sO3nB5EQiIkVX6CKUm5vL4MGD2bJlizPzuIQpU6YQFRVFq1atzI4i4pLGdq/PrXUuDp6etYWk9GyzI4mIFEmhxghlZGTQr18/4uPjWbVqFWXLli2GaObTGCGRq0tMzaLXe79w/Hw6neuH89nQVnh4WMyOJSLi+DFCXbt25ciRIyxfvtxtSpCIXFtooA8fDWmBr5cHq/adYfJP+82OJCJit0IVoV9//ZVRo0YRHq7p9UXkskZVQnj97sYAvLvyIMt2nzQ5kYiIfQpVhCZPnszzzz/PkiVLnJ1HREqYu5pV5aFbawK21eoPntbgaREpOQpVhEaPHs2nn37Kfffdx8qVK52dSURKmPE9G9CmVigpmTk8MmsryRkaPC0iJUOhrxobPHgws2fPZtCgQc7MIyIlkLenB+/f15xKIX4cPpPKs3N3YNXM0yJSAtg1j1DPnj1ZtGiRs7KISAkWVsaXD+9vgY+XBz/9eYqpqw+aHUlE5Lrsnlm6Xbt2zsghIqVA02pl+VffRgBM/ukAu08kmZxIROTatMSGiDjUPS2r0aNRRXKsBmO+3kl2rtXsSCIiV+Vl7w8YhsH8+fNZtWoVp0+fxmrN/5fcwoULHRZOREqmV/s04rfDZ9kTn8wHqw8xuktdsyOJiFyR3UeEnnrqKYYMGUJMTAxlypQhJCQk301EJDzIl5d7NwTgvZUH2Hsy2eREIiJXVqglNv4qNDSUL774gp49ezork8vQEhsiRWcYBiNnbWX5nlM0qhLMosdvxdtTZ+NFxPkcvsTGX4WEhFCrVq0ihxMR92CxWPjXXY0I8fdm1/FkPl572OxIIiIF2F2EXn75ZV555RXS09OdkUdESpEKQX683DsKgP/+dID9pzTrtIi4FruL0IABAzh37hwVKlSgcePGNG/ePN9NROSv+t5chS4NKpCVa2XM1zvI0VVkIuJC7L5qbNiwYWzdupX777+fiIgILBaLM3KJSClhsVj4d7/GdHt7DTuOJfHpLzE82rG22bFERIAiDJYODAxk2bJl3Hbbbc7K5DI0WFrEcb7eEseY+Tvx8fJg6ej21KlQxuxIIlJKOXWwdLVq1VQKRMRu/VtUpVP9cLJyrIyZv4NcrUUmIi7A7iI0adIkxo4dy5EjR5wQR0RKK4vFwr/vakyQrxfbYs/z+S8xZkcSEbH/1Fi5cuVIS0sjJyeHgIAAvL298z2fmJjo0IBm0qkxEcebsymWcQv/wNfLgx+eak+tcJ0iExHHsuf72+7B0pMnTy5qLhERBraqxpI/4ll3IIGx83cyd2RbPD100YWImMPuI0LuREeERJzj+Pl0ot9eQ2pWLi/+XxQP3VbT7EgiUoo4dbD00qVLWbZsWYHty5cv54cffrD35UTEDVUp68/f77wJgP8s20tcYprJiUTEXdldhMaNG0dubm6B7VarlXHjxjkklIiUfve1rk6bWqFkZFt548e9ZscRETdldxE6cOAAUVFRBbY3aNCAgwcPOiSUiJR+FouFF/+vIRYLfL8znt9jz5kdSUTcUJEWXT18uODiiQcPHiQwMNAhoUTEPURVDqZ/86oA/HvJn2jIoogUN7uLUO/evXn66ac5dOhQ3raDBw/y3HPP0bt3b4eGE5HS77no+vh5e7Dl6DmW7T5pdhwRcTN2F6E333yTwMBAGjRoQM2aNalZsyY33XQT5cuX56233nJGRhEpxSqG+PFI+1oAvP7DXrJytCiriBQfu+cRCgkJ4ddff2XFihXs2LEDf39/mjRpQocOHZyRT0TcwCMda/PVpjiOnE3jy41HefBWXU4vIsWj0PMI3XffffTt25c77rjDbebU0TxCIsXnq42x/H3RH5QN8GbNmM6E+Htf/4dERK7AKfMI1a9fnzfeeIMKFSoQHR3NlClTOHbs2A2HFREBuKdlVepWKMP5tGymrtIVqCJSPApdhF566SW2bt3KwYMH6du3L99++y116tShefPmvPzyy2zbts2ZOUWklPPy9ODvPW2TLE5bf0STLIpIsbB7sHTVqlV5/PHHWbZsGWfOnGHcuHEcOHCALl26EBkZyRNPPMHu3budkVVESrlO9cO5tU55snKtvLlsn9lxRMQN2F2E/iooKIh77rmHL7/8kjNnzvD555/j6enJhg0bHJVPRNyIxWLh7z1vwmKBb3ecYHvcebMjiUgpZ/dVY+np6RiGQUBAAABHjx5l0aJFREVFER0dTZcuXRweUkTcR8PKIfRrVpUFvx/j30v+ZO7INlgsWp1eRJzD7iNCffr0YebMmQCcP3+e1q1bM2nSJPr06cMHH3zg8IAi4n6e714PXy8PNh1JZPmeU2bHEZFSzO4i9Pvvv9O+fXsA5s+fT8WKFTl69CgzZ87k3XffdXhAEXE/lUL8efgvkyxm52qSRRFxDruLUFpaGkFBQQAsX76cfv364eHhQZs2bTh69KjDA4qIe3q0U23CyvgQk5DKVxtjzY4jIqWU3UWoTp06LF68mLi4OJYtW0Z0dDQAp0+f1qSDIuIwZXy9eLprPQAm/7Sf5IxskxOJSGlkdxF68cUXef7556lRowa33HILbdu2BWxHh5o1a+bwgCLivu5tVY3a4YGcS8tm6qpD1/8BERE7FXqJjb86efIk8fHxNG3aFA8PW5fatGkTwcHBNGjQwOEhzaIlNkTM9/Ofpxg+Yws+Xh6sfK4jVcsFmB1JRFycU5bYqFy5Mo899hg//PADoaGhNGvWLK8EAbRu3bpUlSARcQ23N6hA21rlycqxMmn5frPjiEgpU+gi9NVXXxEQEMDo0aMJCwtjwIABzJo1i8TERGfmExE3Z7FYGN/T9o+sb7YfJ/aslt4QEccpdBHq1KkTkyZN4sCBA2zYsIHmzZszZcoUKlWqRKdOnXjnnXc4dEjn8EXE8ZpULUuHeuFYDfh4nf6eERHHKdISGw0bNmT8+PH89ttvxMbGMnjwYFauXEnjxo1p1KgRS5YscXROEXFzj3WsDcDXW45x5kKmyWlEpLQodBE6c+bMFbdHRETw8MMP891335GQkMA///lPfH19HRZQRASgTa1QmlYrS2aOlem/xpgdR0RKiUIXoSpVqtC/f39++OEHrnahWUBAAHfddRddu3Z1WEAREbCNFbp0VGjmhqNc0LxCIuIAhS5CM2bMIDk5mV69elGtWjVeeOEFjQkSkWIVHRVBrfBALmTkaLZpEXGIQhehQYMGsXz5cmJiYnj44Yf58ssvqVevHp07d+bLL78kIyPDmTlvyF133UW5cuXo37+/2VFE5AZ4eFh49OJRoc9+iSEzJ9fkRCJS0tk9WLpatWq89NJLHD58mOXLl1OlShUeeeQRKlWqxOOPP+6MjDds9OjRzJw50+wYIuIAfW+uQsVgP05fyGTR78fNjiMiJVyRrhq7pEuXLnzxxRfMnDkTDw8PPvroI0flcqjOnTvnLRQrIiWbj5cHI9rXBOCjtYfJtdo9Ob6ISJ4iF6EjR47w0ksvUaNGDQYOHEjz5s358ssv7X6dtWvX0qtXLypXrozFYmHx4sUF9pk6dSo1a9bEz8+PFi1asG7duqLGFpFS4N7W1Qnx9yYmIZXlu0+aHUdESjC7ilBGRgazZs3i9ttvp06dOkyfPp2hQ4dy8OBBVqxYwb333mt3gNTUVJo2bcr7779/xefnzp3L008/zYQJE9i2bRvt27enR48exMZeHijZokULGjVqVOB24sQJu/OIiOsr4+vFA20jAfhgzaGrXskqInI9XoXd8ZFHHmHevHlkZGTQp08flixZQnR0NBaL5YYC9OjRgx49elz1+bfffpvhw4czYsQIACZPnsyyZcv44IMPmDhxIgBbt269oQyXZGZmkpl5eaK25ORkh7yuiDjesHY1+GTdYXYeS+LXQ2e5tU6Y2ZFEpAQq9BGh3377jVdeeYUTJ04wd+5cunfvfsMl6HqysrLYunUr0dHR+bZHR0fz66+/Ovz9Jk6cSEhISN6tWrVqDn8PEXGM8mV8GdjS9hn9YLWm8hCRoil0Edq5cydPPfUUoaGhgK2k7Nu3j5ycHKeFS0hIIDc3l4iIiHzbIyIiOHmy8OMCunfvzoABA1i6dClVq1Zl8+bNV9xv/PjxJCUl5d3i4uJuKL+IONeI9rXw9LDwy8EE/jiWZHYcESmB7B4snZaWxvDhwwkICKBhw4Z5Y3VGjx7N66+/7vCAQIEjT4Zh2HU0atmyZZw5c4a0tDSOHTtGq1atrrifr68vwcHB+W4i4rqqhQbQq0klAD5co6NCImI/u4vQ+PHj2bFjB6tXr8bPzy9ve9euXZk7d65Dw4WFheHp6Vng6M/p06cLHCUSEff0aCfbBItLd8UTk5BqchoRKWnsLkKLFy/m/fff57bbbst3VCYqKsrhS274+PjQokULVqxYkW/7ihUraNeunUPfS0RKpgYVg7m9QQUMAz5ee9jsOCJSwthdhM6cOUOFChUKbE9NTS3S4OmUlBS2b9/O9u3bAYiJiWH79u15p9yeffZZPv30Uz7//HP+/PNPnnnmGWJjY3n00Uftfi8RKZ0eu3hUaMHWY5xOdt3lfkTE9dhdhFq1asWSJUvyHl8qP5988glt27a1O8CWLVto1qwZzZo1A2zFp1mzZrz44osADBw4kMmTJ/Pqq69y8803s3btWpYuXUpkZKTd7yUipVOrGqG0iCxHVq6Vz9bHmB1HREoQi2HnTGS//vord9xxB4MHD2b69OmMHDmS3bt3s2HDBtasWUOLFi2clbXYJScnExISQlJSkgZOi7i4n/acYsTMLZTx9WL9uNsJ8fc2O5KImMSe72+7jwi1a9eO9evXk5aWRu3atVm+fDkRERFs2LChVJUgESlZbm9QgXoRZUjJzOHLjUfNjiMiJYTdRWjnzp00btyYGTNmsGvXLvbs2cMXX3xB48aNr7hOWEk0ZcoUoqKirnqZvYi4Hg8PC492tI0V+vyXI2Rk55qcSERKAruLUPfu3Tl8uOCVGQsWLGDw4MEOCWW2UaNGsWfPnqtOvCgirqlX08pUKetPQkom327XWoMicn12F6HHHnuMLl26EB8fn7dt7ty5PPDAA0yfPt2R2URE7OLt6cHgNtUBmL059jp7i4gUoQi9+OKL9O7dm65du5KYmMhXX33Fgw8+yMyZMxkwYIAzMoqIFFr/FlXx8rCwLfY8e09q4WQRuTa7ixDAf//7X5o3b06bNm14+OGHmT17Nnfffbejs4mI2K1CkB9db7LNPD9nk9YLFJFr8yrMTt9++22BbX379mXNmjUMGjQIi8WSt0/v3r0dm1BExE6DbqnOj7tPsvD3Y4zr0QA/b0+zI4mIiyrUPEIeHoU7cGSxWMjNLT1XamgeIZGSyWo1aP+fVRw/n87b9zSlX/OqZkcSkWLk8HmErFZroW6lqQSJSMnl4WHh3lbVAJ0eE5FrK9IYIRERVzegZTU8LLDpSCIHT18wO46IuKhCFaE5c+YU+gXj4uJYv359kQO5Ak2oKFLyVQzx4/YGGjQtItdWqCL0wQcf0KBBA9544w3+/PPPAs8nJSWxdOlS7rvvPlq0aEFiYqLDgxYnTagoUjoMam07Pbbg92Nk5ujUvYgUVKgitGbNGt566y1WrlxJo0aNCA4Opm7dujRu3JiqVatSvnx5hg8fTo0aNdi1axe9evVydm4RkevqWC+cSiF+nEvLZtnuU2bHEREXZPfq82fPnuWXX37hyJEjpKenExYWRrNmzWjWrFmhry4rKXTVmEjJ9/aK/bz78wHa1irP7EfamB1HRIqBPd/fhZpH6K/Kly9Pnz59ihxORKQ4DWxVjfdWHmDD4bPEJKRSMyzQ7Egi4kJK1yEcEZH/UaWsPx3rhQMwR+uPicj/UBESkVJvUGvbQqwLth4jK8dqchoRcSUqQiJS6t3eoALhQb4kpGTx058aNC0il6kIiUip5+3pwT0tbctszN6k02MicpndRSg9Pf2qz8XHx99QGBERZxnY0nZ6bN2BBOIS00xOIyKuwu4i1KxZM37//fcC2+fPn0+TJk0cEkpExNGqlw+gfd0wAOZu1kzTImJjdxHq1q0b7dq14/XXX8cwDFJSUhg2bBhDhw7lxRdfdEbGYqclNkRKp3tb2Y4KzdsSR06uBk2LSBEmVAT48ccfefDBB6lTpw4nTpwgODiYL7/8kqioKGdkNI0mVBQpXbJyrLSd+DNnU7P4eEgLohtWNDuSiDiBPd/fRRosHR0dTb9+/Vi/fj1xcXG8/vrrpa4EiUjp4+PlQf8WGjQtIpfZXYQOHTpE27Zt+f7771m2bBljx46lT58+jB07luzsbGdkFBFxmIGtbAuxrtl/huPnr37xh4i4B7uL0M0330zNmjXZsWMH3bp141//+hcrV65k4cKFtG7d2hkZRUQcplZ4GdrUCsVqwDwNmhZxe3YXoalTpzJnzhzKli2bt61du3Zs27aN5s2bOzKbiIhTXJppet6WOHKtdg+TFJFSxO4iNGTIkCtuDwoK4rPPPrvhQCIizta9YUXKBngTn5TBmv2nzY4jIiaye/X5mTNnXvU5i8Vy1aIkIuIq/Lw9ubt5VT77JYbZm+K4vUGE2ZFExCR2Xz5frly5fI+zs7NJS0vDx8eHgIAAEhMTHRrQTLp8XqT02n/qAtHvrMXb08KWCd0ICfA2O5J7yc0BD0+wWMxOIqWQPd/fdh8ROnfuXIFtBw4c4LHHHmPMmDH2vpyIiCnqRQRRPyKIfacusGzPSe5pWc3sSCVfZgokH4fUM5ByGlITbPdT/3L/0vasC4AFvP3Byw+8A8DbD7z8L/6v3+XnAsOhfJ2Lt9pQNhI87f76Erkih/yXVLduXV5//XXuv/9+9u7d64iXFBFxujubVGLfigss2RmvImQvay6c/hOOb4FjW+D4VjizFwx7Zuw2IDvNdku342yChzeUq2ErRmF1/lKS6kCQJskU+zisUnt6enLixAlHvZyIiNPd2aQSb6/Yz/qDCZxLzaJcoI/ZkVxX0vG/lJ7f4cQ2yE4tuJ9fCARWsB3FCQyDMpfuX7xdeuxfDnKzIScdsjNsZSgnA7LTC/7vhXg4exDOHrLdctLh7AHbbf//vH9INYi8FWrcavvf0Fo6/SbXZHcR+vbbb/M9NgyD+Ph43n//fW699VaHBTPTlClTmDJlCrm5uWZHEREnqh1ehpsqBfNnfDLLdp/k3ouX1Qu2Iz5HfoHdC2H/crhwhX/o+gRBlWZQpSVUaQFVWzr/iIzVasty9uBfytHF++eOQFIc7JxjuwEEVYLIdrZSFHkrhNdXMZJ87B4s7eGR/4p7i8VCeHg4t99+O5MmTaJSpUoODWgmDZYWKf2mrDrIm8v2cVudML4YcYvZccxltULcb7BrIez5xja25xKLJ1SIgqotbMWnaksIq2cb8OwqMlPg2CY4sh6O/mo7gpWblX+fgDBbMarVEerfCcGl5ztLLrPn+7tIi666CxUhkdLv6NlUOr65Gg8LbJ7QlfJlfM2OVLwMw3a6a/dC2L04/5Ef/3JwUy+I6gvV24BPoFkpiyY73fa7Hf0Vjv4CcZttp9X+qmor2+/Y4P9sA7GlVFARchAVIRH30Ou9X/jjeBL/6tuI+9tEmh2neJz8A3bOs5WfpL8sQOsbbCsFjfpBrU7gWYqmFcjJso1tOrIO9i+zHT36qwpRl0tRxcY6hVaCObwIPfvss4V+87fffrvQ+7o6FSER9/DhmkO8/sNe2tYqz+xH2pgdx3kMAw6vgl8mQ8yay9t9ykD9HtCwH9TpAl5uclQsOR72LYE/v7eVI2vO5efKVocGvWzFqNot4GH3QgxiIocXoc6dOxfqjS0WCytXrixcyhJARUjEPcQlptH+P6vwsMBvf+9ChSA/syM5Vm4O7FkM6yfbjgSBbcxPgzuhcX+oG22bs8edpZ+zHSX68zs4+HP+U2gh1aDxAGh6r22wtbg8hxehnTt30rBhQzw9XWhQXDFQERJxH32nrGd73Hle7dOQB9rWMDuOY2SlwrYvYcN7cP7i6S/vAGg+FNo+bjvqIQVlpcGhn22laN8PkJl8+bnKzaDJvbYCGRhmXka5JocXIU9PT06ePEl4eDi1atVi8+bNlC9f3mGBXZWKkIj7+HTdYf615E9a1whl3qNtzY5zY1LPwqaPbbdLExUGhMEtj0Kr4RAQam6+kiQ7A/b/ADvmwMGfLp8+8/CCOl1tR4nq9bDNhi0uw+FLbJQtW5bDhw8THh7OkSNHsFrtmTlURMT19WxciX8t+ZPNRxM5mZRBxZAS+MWWdBx+eQe2fXH51E65GtDuSbh5sE5/FYW3HzS8y3ZLTYBdC2DHbNug6/0/2m6+IdCwDzS9z3Z1nQZZlyiFKkJ33303HTt2pFKlSlgsFlq2bHnV02SHDx92aEARkeJQuaw/LSLLsfXoOZb+Ec9Dt9U0O1LhZaXBr+/ZxgBlp9m2VboZbn0Kovq41lw/JVlgGNwy0nY7s//ixI3zbJM4/j7TdgutDc3uh5vv03IfJUShL5//8ccfOXjwIKNHj+bVV18lKCjoivs99dRTDg1oJp0aE3Ev09bH8Mp3e2gRWY4Fj7UzO871GYZt/p8VL9m+jAGqtYHOf4eaHXRkojhYrXB0ve3U2Z7FkJVi227xhLrdoNkQqNe9dE1DUAI4dR6hBx98kHffffeqRag0UREScS+nkjNoM/FnDAN+HXc7lcu68KmkE9vhx3EQu8H2OLgqRL9quwReBcgcmSm2MvT7LNsM3ZcEhtvGEjV7AMLrmRbPnWhCRQdRERJxP/d8tIFNMYn8486bGNG+ltlxCko5DT+/ahsHhAFe/nDbM7ZxQD4BZqeTSxIOwLZZsH12/qVKqt1iO3XW8C7wLf0HFMyiIuQgKkIi7mfmhiO8+M1umlYryzejXGgh6ZxM2PghrHkTsi7YtjUeAF1fhpCqpkaTa8jNhgMrbMV1/49gXFzM2zvQVoaa3a8B1k6gIuQgKkIi7uf0hQza/PtnrAasG9uZaqEucJRl34+wbDwkXrwYpXIzuOMNqO7mi8SWNBdO2QZY/z4Lzh64vL18HVshajpIA6wdxJ7vb80ZfgVTpkwhKiqKVq1amR1FRIpZhSA/bqlpmydtyR/x5oZJPwcLHobZA20lqEwE9P0ARqxUCSqJgiJsV/I9sRkeWmYrP96BcPYg/PQyvB0FXw20LfmRm212Wrdh9xGh1NRUAgNL2ArERaQjQiLu6cuNR5mwaBeNq4Tw3ZO3mRPi4E/wzZO21eAtHtD2Ceg4VuNKSptrDbBuMtB21VmFBqbFK6mcekQoIiKChx56iF9++aXIAUVEXNkdDSvi6WHhj+NJHElILd43z0yB75+BL+62laDydeCh5RD9T5Wg0si3jO3I0PBl8MQW2xGjwAqQegY2vA9Tb4GPO8HGj20zhovD2V2EZs+eTVJSEl26dKFevXq8/vrrnDhxwhnZRERMUb6ML+1qm3B67OgG+PBW2PK57XHrkTByHVTTaXq3EFYXur0Kz+6BQXOg/p22pTxObIMfxsCk+jBnsO3UWU6W2WlLjSIPlj579iwzZ85k+vTp7Nmzh+7du/PQQw/Ru3dvvLwKNWG1y9OpMRH3NWdTLOMW/sFNlYL54an2zn2z7AxY9ZptdmgM25xAfadArU7OfV9xfakJ8Md82PEVxO+4vN0/1Lbwa9NBtsHzuuosn2K/auy9995jzJgxZGVlERYWxqOPPsq4ceMICHCBqy1ugIqQiPs6l5pFq9d+Isdq8PNzHakdXsY5bxS/AxaOhDN/2h7fPBjumAh+Ic55Pym5Tu2xFaKd8yDl1OXt4Q1shajxAAipYl4+F1IsRejkyZPMnDmTadOmERsby1133cXw4cM5ceIEr7/+OpUqVWL58uVF+gVchYqQiHsb+vkm1uw/w7Pd6jG6S13HvnhuDvzyNqx5w7aieWA49HoXGvR07PtI6ZObA4dX2RZ/3bsEcjIuPmGBGrfZjhTd1BsCQk2NaSanFqGFCxcybdo0li1bRlRUFCNGjOD++++nbNmyefvs3r2bZs2akZVVss9hqgiJuLevt8QxZv5O6kWUYfkzHR33whdOwtfDLi+PcVNv+L93bIt6itgj/bztqrMdcy7/9wTg4Q11o22lqH4P8Hbh5WKcwJ7vb7sH8zz44IPce++9rF+//qrz7NSqVYsJEybY+9IiIi4lOqoif/f8g/2nUth/6gL1Ihxw1dbRDfD1UNupDd9guHOS7ZSGxnhIUfiXhRbDbLfzsbBrgW1M0aldsG+J7eZTBm7qZStFNTuBZ+kYx+sodh8RSktLK/FjfwpLR4REZPj0zfy89zSju9Tl2W43sGCmYdiWyFj+D9upsApRMPALKF/bcWFFLjm1B/742laKkmIvbw8Mty3t0bCfbd0zj9I5r7JTT40lJydf+YUsFnx9ffHx8bHn5VyaipCILNp2jGfm7qB2eCA/PdsRS1GO3GSlwrejYdd82+NG/aH3u+DjHpPTiokMA+I22krR7kWQ9pe5iIIqQ8O+tlJUtWWpOirp1CLk4eFxzb8IqlatyrBhw3jppZfwKOFNU0VIRC5kZNPiXz+RlWPlh6fac1MlO/8uSDgI84bA6T22OWGiX4NbRpaqLx0pIXKz4dAq2L3QNsg68y8HNkKqQVQfaNQPKjcv8f99OnWM0PTp05kwYQLDhg2jdevWGIbB5s2bmTFjBv/4xz84c+YMb731Fr6+vvz9738v8i8hIuIKgvy86VA3nJ/+PMVPe07ZV4T2LoFFj9q+cMpEwIAZENnWeWFFrsXTG+pF227ZGXBopa0U7fsBkuJsM1lveB/KRl48fXYXVGpa4kvR9dh9RKhLly6MHDmSe+65J9/2efPm8dFHH/Hzzz8za9YsXnvtNfbu3evQsMVNR4REBGD2pljGL/yD5tXLsvDxW6//A9ZcWPkv2+XxANXbwoDpWllcXFN2OhxYYTt1tv9HyE67/FzkbfDgEvOyFZFTjwht2LCBDz/8sMD2Zs2asWGD7dK92267jdjY2AL7iIiURJ3qhwOwLe48ialZhAZeYyxkagIsGA6HV9set3nctmyCp7fzg4oUhbc/RPW23bJS4cBy2LXQ9r8VG5mdzunsHsRTtWpVPvvsswLbP/vsM6pVqwbYlt8oV67cjacTEXEBlUL8aVAxCMOAtfvPXH3HU7ttC2QeXg3eAXD3Z7ZZolWCpKTwCbSdEhs4C8YcgvbPm53I6ew+IvTWW28xYMAAfvjhB1q1aoXFYmHz5s3s3buX+fNtV0Rs3ryZgQMHOjysiIhZOjeowN6TF1i17zR9m11hGYNDq2DeA7bxQKG1YOCXEBFV/EFFHMW3jO1WyhVpiY2jR4/y4Ycfsm/fPgzDoEGDBowcOZIaNWo4IaJ5NEZIRC7ZFJPIPR9toGyAN1v/0Q1Pj78MIN32JXw32jY/UOSttvmB3Hh5AxGzOW2MUHZ2NtHR0Xz00UdMnDjxhkK6silTpjBlyhRyc3PNjiIiLqJ59bIE+3lxPi2b7XHnaRFZzjZHy+rXYc3rtp0a9Ye+U8HL19ywIlJodo0R8vb2ZteuXUWbUKwEGTVqFHv27GHz5s1mRxERF+Hl6UGHerZB06v3nYacLFj8+OUSdNuz0O8TlSCREsbuwdIPPPDAFQdLi4iUdp3rVwBg458x8OXdsOMrsHjC/02Gri+V2uUKREozuwdLZ2Vl8emnn7JixQpatmxJYGD+KeLffvtth4UTEXElHeuHU4mzvHr2P3AuDrwD4Z4ZULeb2dFEpIjsLkK7du2iefPmAOzfvz/fc6X9lJmIuLewC3tZEvASodZE0n3D8R86HyrfbHYsEbkBdhehVatWOSOHiIhrO7ACvh5GqDWFfdaqzKz0Jq+pBImUeEU+oX3w4EGWLVtGeno6AEW4Cl9EpGT4fRZ8NRCyUrhQqR0Dsl7i2xhPsnOtZicTkRtkdxE6e/YsXbp0oV69evTs2ZP4+HgARowYwXPPPefwgCIipvrtA/j2CTByoekgAh9ajHdgOS5k5rD16Dmz04nIDbK7CD3zzDN4e3sTGxtLQEBA3vaBAwfy448/OjSciIip1r4FP46z3W/7BPT9AA9vXzpevIx+1b7TJoYTEUewuwgtX76cN954g6pVq+bbXrduXY4ePeqwYCIipjEM+OkVWPlP2+NO4yH6X3DxgpBODWyX0a/ee411x0SkRLC7CKWmpuY7EnRJQkICvr6aSExESjjDsB0F+uXiVCDd/gmdxuWVIIAOdcPwsMC+Uxc4fj7dpKAi4gh2F6EOHTowc+bMvMcWiwWr1cqbb75J586dHRpORKRYWXPh2ydh44e2x3dOgltHF9itbIAPzauXA2DVXp0eEynJ7L58/s0336RTp05s2bKFrKwsxo4dy+7du0lMTGT9+vXOyCgi4ny52bDoUdg1Hywe0GcK3HzfVXfv3KACW46eY/W+09zfJrIYg4qII9l9RCgqKoqdO3fSunVrunXrRmpqKv369WPbtm3Url3bGRlFRJwrJxPmDbWVIA8v6D/tmiUIoFN924Dp9QfPkpGtBZpFSiq7jwgBVKxYkVdeecXRWUREil9WGswdDIdWgqcvDJwF9bpf98eiKgUTEezLqeRMNsUk5i3IKiIlS5GK0Pnz59m0aROnT5/Gas0/odgDDzzgkGAiIk6XkWybKDH2V9u6YYNmQ62OhfpRi8VC5/oVmLM5jlX7TqsIiZRQdheh7777jsGDB5OamkpQUFC+9cUsFouKkIiUDOnn4Yt+cHwr+IbA4K+h+i12vUSni0Vo9b4zvNTLOTFFxLnsHiP03HPP8dBDD3HhwgXOnz/PuXPn8m6JiYnOyCgi4lgZyZdLkH8oDP3W7hIEcGud8nh7WohJSCUmIdUJQUXE2ewuQsePH2f06NFXnEtIRMTlZabAlwMul6Bh3xd5BfkgP29a1QgFYLVmmRYpkewuQt27d2fLli3OyCIi4lxZaTD7Xoj7DfxC4IHFENHwhl6yc33bLNOr9mmWaZGSyO4xQnfeeSdjxoxhz549NG7cGG9v73zP9+7d22HhREQcJjvDdnXYkXXgEwT3L4JKTW/4ZTs3COe1pX/y2+GzpGXlEOBTpGtQRMQkFsMwDHt+wMPj6geRLBYLubmlZz6N5ORkQkJCSEpKIjg42Ow4IlJUOVkw9344sMx2ddiQhVC9jUNe2jAM2v9nFcfOpfPZ0JZ0uSnCIa8rIkVnz/e33afGrFbrVW+lqQSJSCmRmw3zH7SVIC9/uG+uw0oQXL6MHrQavUhJZHcRcgdTpkwhKiqKVq1amR1FRG5Ebg4sfAT2fm+bLHHQV1CzvcPfpnMD2xxCq/aewc6D7CJiskIXoZ49e5KUlJT3+LXXXuP8+fN5j8+ePUtUVJRDw5ll1KhR7Nmzh82bN5sdRUSKypoL34yC3QvBwxsGfgG1b3fKW7WtFYaPlwfHz6dz4HSKU95DRJyj0EVo2bJlZGZm5j1+44038s0blJOTw759+xybTkSkKKxW+O4p2DnHtnbYgOlQL9ppb+fv40nbWuUBrUYvUtIUugj97+FeHf4VEZdkGLD0edg2y7aK/N2fwk3/5/S37XxxEVaNExIpWTRGSERKD8OA5f+ALZ8BFrjrI2h4V7G89e0NbFeLbTlyjuSM7GJ5TxG5cYUuQhaLJd+6Ype2iYi4jPWTYcP7tvu934Mm9xTbW1cvH0Ct8EByrAbrDyQU2/uKyI0p9MxfhmEwbNgwfH19AcjIyODRRx8lMDAQIN/4IRGRYvf7TPjpZdv97v+G5kOKPULn+hU4fCaGVftO06NxpWJ/fxGxX6GL0NChQ/M9vv/++wvso5XnRcQUe5fYBkcD3Po0tB1lSoxO9cP57JcY1uy3XUavo+Yirq/QRWjatGnOzCEiUjRH1sP8h8CwQrP7oevLpkVpVSMUH08PTiVncuRsGjXDAk3LIiKFo8HSIlJynfwDZg+CnAyo3xP+779g4lEYP29Pbq5WFoCNh8+alkNECk9FSERKpsQY+OJuyEyC6u2g/+fgaf6Cp21qhQLwm4qQSImgIiQiJU/KafiiH6ScggoNYdBs8PY3OxUAbS5OrPjb4UTNtyZSAqgIiUjJkpFsOxKUeBjKVretJO9f1uxUeZpVL4ePpwcnkzOITUwzO46IXIeKkIiUHNkZMOc+OLkTAsJgyGIIqmh2qnz8fTxpWi0E0OkxkZJARUhESgZrLix8GI6sA58guH8BlK9tdqor+uvpMRFxbSpCIuL6DAOWPAd/fguePnDvl1D5ZrNTXdXlInRW44REXJyKkIi4vnVvwdZpgAX6fQK1Opqd6JqaVy+Ht6eF+KQM4hLTzY4jItegIiQirm3n17DyX7b7Pd+Ehn1NjVMY/j6eNK1aFtA4IRFXpyIkIq7r6K/wzeO2+22fgNYPm5vHDn89PSYirktFSERcU8IB2xViuVlwU2/o9k+zE9lF44RESgYVIRFxPakJ8GV/SD8HVVpCv4/Bo2T9ddU8sizenhZOJGVw7JzGCYm4qpL1N4uIlH7Z6bb1w84dgbKRMGiOy8wabY8AHy+aXBwntEGnx0RcloqQiLgOqxUWPQrHNoFfCAyeD2XCzU5VZFp3TMT1qQiJiOv4+WXYsxg8vOHeryC8ntmJbsilcUIbNbGiiMtSERIR17Dlc1j/X9v9PlOgxm3m5nGAFpHl8PKwcPx8OnFad0zEJakIiYj5DvwES5633e/0d2g60Nw8DmIbJ6R1x0RcmYqQiJjr5B/w9VAwcqHpfdBxrNmJHErrjom4NhUhETFP8gn48h7ISoEa7aHXf8FiMTuVQ2liRRHXpiIkIubISoWvBsKFExBWHwbOAi8fs1M5nMYJibg2FSERKX5WKyx+DE7uhIAwGDwP/MuZncopAn29aHxxnNDGGJ0eE3E1KkIiUvzW/gf2fGO7TH7gF1CuhtmJnEqnx0Rcl4qQiBSvPd/A6om2+//3NkS2NTdPMcibTyhGRUjE1agIXcGUKVOIioqiVatWZkcRKV3id9hmjgZo8zg0f8DcPMWkZWQ5PD0sxCWmc+ycxgmJuBIVoSsYNWoUe/bsYfPmzWZHESk9Uk7D7PsgOw1qdylxq8nfiEBfLxpXuThOSJfRi7gUFSERcb6cTJgzGJKPQfk60P9z8PQyO1Wx0jghEdekIiQizmUY8P0zlxdSHTQX/MuanarYXVqAVVeOibgWFSERca4N78P2L8HiAf2nQVgdsxOZomWNUDw9LMQmpnH8fLrZcUTkIhUhEXGeAytgxYu2+90nQp0u5uYxURlfLxrljRPS6TERV6EiJCLOcWYfzH8IDKvt6rBbRpqdyHSXTo9pnJCI61AREhHHS0u0LZ+RmQzV20HPSaVuDbGiuDyfkMYJibgKFSERcazcHPh6GJyLgbLVS+0aYkVxaT6ho2fTOKFxQiIuQUVIRBxrxQsQswa8A+He2RAYZnYilxHk502jysGAZpkWcRUqQiLiODu/ht+m2u7f9SFUbGRuHheUN5/QIZ0eE3EFKkIi4hjxO+HbJ2332z8HUb3NzeOitO6YiGtRERKRG5eWCHPvh5x02/IZnSeYnchltaxRDg8LHDmbRnySxgmJmE1FSERujDUXFgyH80ehXA24+1Pw8DQ7lcsK8vP+y3xCOj0mYjYVIRG5MSv/BYdWgpc/DPwCAkLNTuTydHpMxHWoCIlI0e35Fn5523a/z/tQsbG5eUqIyxMr6oiQiNlUhESkaE7vhcWP2e63GQWN+5ubpwRpWSMUDwvEJKRyMinD7Dgibk1FSETsl5EEcwdDVgrUaA/dXjU7UYkS7OdNw8oXxwnp9JiIqVSERMQ+VissehTOHoTgKrYV5T29zE5V4rSsUQ6AbbHnzQ0i4uZUhETEPuvegn1LwdPXtnxGmXCzE5VIN1crC8C2uPOm5hBxdypCIlJ4+5fDqn/b7t85Caq0MDdPCdasmu2I0J8nksnMyTU5jYj7UhESkcI5ewgWjAAMaPkQNB9idqISrVqoP6GBPmTlWtlzItnsOCJuS0VIRK4vKw3mDoHMJKjaGu54w+xEJZ7FYsk7PbZdp8dETKMiJCLXZhiw5Dk4vRsCK8A9M8HLx+xUpYKKkIj5VIRE5Nq2zYIdX4HFA/p/DsGVzE5UaqgIiZhPRUhEri5+Jyx53nb/9n9Azfbm5illml4sQkfPppGYmmVuGBE3pSIkIleWfh7mPQC5mVC3O9z6jNmJSp0Qf29qhQcCsENHhURMoSIkIgUZBnwzCs7FQEh1uOtD8NBfF86g+YREzKW/2USkoA3vw97vwdMH7pmhFeWdqJnGCYmYSkVIRPI7ugFWvGS7f8dEqNLc3Dyl3M0XJ1bcEXcewzBMTiPiflSEROSylDMw/0EwcqHxAGg53OxEpV6DSkH4enmQlJ5NTEKq2XFE3I6KkIjYWHNhwXC4EA9h9eH/JoPFYnaqUs/b04NGVWwr0ev0mEjxUxESEZvVr0PMGvAOtC2m6lvG7ERuQ/MJiZhHRUhE4MAKWPsf2/1e/4Xw+ubmcTMqQiLmUREScXfn42Dhw7b7rUZAkwHm5nFDl4rQn/HJZGRrJXqR4qQiJOLOcrLg66GQfg4qN4Pu/zY7kVuqWs6fsDI+ZOca7NZK9CLFSkVIxJ399BIc3wp+ZWHADPDyNTuRW9JK9CLmUREScVd7l8JvU2337/oQykWam8fN5c0wHXvO3CAibkZFSMQdnY+DxY/Z7rd9Aur3MDeP5E2sqCNCIsVLRUjE3eRm2+YLyjgPlZtDl5fMTiRAk2ohWCxw7Fw6CSmZZscRcRsqQiLuZtVrELcRfENgwDTw8jE7kQDBft7UDrfN3bQ99ry5YUTciIqQiDs5+BP88o7tfu93oVwNU+NIfhowLVL8VIRE3EVyPCwcabvfagQ07GtqHClIRUik+KkIibgDa65t0sS0BIhoDNGvmZ1IruBSEdoRdx6rVSvRixQHFSERd7D2TTiyzraO2IDp4O1ndiK5ggYVg/Dz9uBCZg6HE1LMjiPiFlSEREq7mHWw5g3b/V6TIayOqXHk6rw8PWh8cSX6bRowLVIsVIRESrPUBFgwAgwrNLsfmtxjdiK5Do0TEileKkIipZXVCotGQspJCG8APf5jdiIpBE2sKFK8VIRESqtf37VdLu/lbxsX5BNodiIphJurlwVg78kLpGdpJXoRZ1MREimNYjfCz6/a7vd4AyrcZG4eKbTKIX6EB/mSazXYdSLJ7DgipV6pL0JxcXF06tSJqKgomjRpwtdff212JBHnSj9nW0LDyIVG/aH5A2YnEjvkW4leA6ZFnK7UFyEvLy8mT57Mnj17+Omnn3jmmWdITU01O5aIcxgGfP8MJMVBuZrwf++AxWJ2KrGTBkyLFB8vswM4W6VKlahUqRIAFSpUIDQ0lMTERAIDNV5CSqFtX8DuReDhBf0/A79gsxNJETRTERIpNqYfEVq7di29evWicuXKWCwWFi9eXGCfqVOnUrNmTfz8/GjRogXr1q0r0ntt2bIFq9VKtWrVbjC1iAtKOAA/jLXdv/0fUKWFuXmkyBpXta1Ef/x8OqcvZJgdR6RUM70Ipaam0rRpU95///0rPj937lyefvppJkyYwLZt22jfvj09evQgNjY2b58WLVrQqFGjArcTJ07k7XP27FkeeOABPv74Y6f/TiLFLicT5j8E2WlQsyO0e8rsRHIDgvy8qVtBK9GLFAeLYRgus6CNxWJh0aJF9O3bN2/bLbfcQvPmzfnggw/ytt1000307duXiRMnFup1MzMz6datGw8//DBDhgy55n6ZmZl5j5OSkqhevTpxcXEEB+sUg7iwn16FzR+DXzkYvgKCK5qdSG7Qi4t3sXDbcUbcVpOnu9UzO45IiZKcnEy1atU4f/48ISEh197ZcCGAsWjRorzHmZmZhqenp7Fw4cJ8+40ePdro0KFDoV7TarUa9957r/HSSy9dd9+XXnrJAHTTTTfddNNNt1Jwi4uLu+53v0sPlk5ISCA3N5eIiIh82yMiIjh58mShXmP9+vXMnTuXJk2a5I0/mjVrFo0bNy6w7/jx43n22WfzHp8/f57IyEhiY2Ov3yhLsVatWrF582azYxRQnLmc8V6OeM0beQ17f9ae/Quz76V/sbn7EVd9vkrf56soP6fPl2MZhkGLFi2oXLnydfd16SJ0ieV/Lv81DKPAtqu57bbbsFqthdrX19cXX1/fAttDQkLc8j+kSzw9PV3y9y/OXM54L0e85o28hr0/a8/+9uwbHBzskv99FRd9vkrf56soP6fPl+P5+Pjg4XH9odCmD5a+lrCwMDw9PQsc/Tl9+nSBo0TiPKNGjTI7whUVZy5nvJcjXvNGXsPen7Vnf1f9b8YVueqflT5fRX+NovycPl+OV9g/pxIxWLpFixZMnTo1b1tUVBR9+vQp9GDpokpOTiYkJISkpCS3bdQizqLPl4jz6PNVeKafGktJSeHgwYN5j2NiYti+fTuhoaFUr16dZ599liFDhtCyZUvatm3Lxx9/TGxsLI8++qjTs/n6+vLSSy9d8XSZiNwYfb5EnEefr8Iz/YjQ6tWr6dy5c4HtQ4cOZfr06YBtQsX//Oc/xMfH06hRI9555x06dOhQzElFRESktDG9CImIiIiYxaUHS4uIiIg4k4qQiIiIuC0VIREREXFbKkIiIiLitlSEHOiuu+6iXLly9O/f3+woIiXa999/T/369albty6ffvqp2XFEShV9V+Wnq8YcaNWqVaSkpDBjxgzmz59vdhyREiknJ4eoqChWrVpFcHAwzZs3Z+PGjYSGhpodTaRU0HdVfjoi5ECdO3cmKCjI7BgiJdqmTZto2LAhVapUISgoiJ49e7Js2TKzY4mUGvquys9titDatWvp1asXlStXxmKx5K1E/1dTp06lZs2a+Pn50aJFC9atW1f8QUVKuBv9rJ04cYIqVarkPa5atSrHjx8vjugiLk/fZY7nNkUoNTWVpk2b8v7771/x+blz5/L0008zYcIEtm3bRvv27enRowexsbF5+7Ro0YJGjRoVuJ04caK4fg0Rl3ejn7Urna23WCxOzSxSUjjiu0z+h+GGAGPRokX5trVu3dp49NFH821r0KCBMW7cOLtee9WqVcbdd999oxFFSoWifNbWr19v9O3bN++50aNHG19++aXTs4qUNDfyXabvqsvc5ojQtWRlZbF161aio6PzbY+OjubXX381KZVI6VOYz1rr1q3ZtWsXx48f58KFCyxdupTu3bubEVekRNF3WdGYvvq8K0hISCA3N5eIiIh82yMiIjh58mShX6d79+78/vvvpKamUrVqVRYtWkSrVq0cHVekxCrMZ83Ly4tJkybRuXNnrFYrY8eOpXz58mbEFSlRCvtdpu+q/FSE/uJ/xyEYhmHX2ARd2SJSONf7rPXu3ZvevXsXdyyRUuF6ny99V+WnU2NAWFgYnp6eBY7+nD59ukCzFpGi02dNxHn0+SoaFSHAx8eHFi1asGLFinzbV6xYQbt27UxKJVL66LMm4jz6fBWN25waS0lJ4eDBg3mPY2Ji2L59O6GhoVSvXp1nn32WIUOG0LJlS9q2bcvHH39MbGwsjz76qImpRUoefdZEnEefLycw+aq1YrNq1SoDKHAbOnRo3j5TpkwxIiMjDR8fH6N58+bGmjVrzAssUkLpsybiPPp8OZ7WGhMRERG3pTFCIiIi4rZUhERERMRtqQiJiIiI21IREhEREbelIiQiIiJuS0VIRERE3JaKkIiIiLgtFSERERFxWypCIiKFcPbsWSpUqMCRI0cAWL16NRaLhfPnzzv1fZ9//nlGjx7t1PcQcWcqQiLiUMOGDcNisRS43XHHHWZHuyETJ06kV69e1KhR44Zf69SpU3h7e/PFF19c8fmRI0fSpEkTAMaOHcu0adOIiYm54fcVkYJUhETE4e644w7i4+Pz3WbPnu3U98zKynLaa6enp/PZZ58xYsQIh7xeREQEd955J9OmTbvie82ZM4fhw4cDUKFCBaKjo/nwww8d8t4ikp+KkIg4nK+vLxUrVsx3K1euXN7zFouFTz/9lLvuuouAgADq1q3Lt99+m+819uzZQ8+ePSlTpgwREREMGTKEhISEvOc7derEE088wbPPPktYWBjdunUD4Ntvv6Vu3br4+/vTuXNnZsyYkXcKKzU1leDgYObPn5/vvb777jsCAwO5cOHCFX+fH374AS8vL9q2bXvV3zk9PZ0777yTNm3akJiYCMC0adO46aab8PPzo0GDBkydOjVv/+HDh7Nq1aq8U22XzJ8/n4yMDO6///68bb1793Z6kRRxVypCImKKV155hXvuuYedO3fSs2dPBg8enFcg4uPj6dixIzfffDNbtmzhxx9/5NSpU9xzzz35XmPGjBl4eXmxfv16PvroI44cOUL//v3p27cv27dvZ+TIkUyYMCFv/8DAQO69994CR2KmTZtG//79CQoKumLWtWvX0rJly6v+LklJSURHR5OVlcXPP/9MaGgon3zyCRMmTOC1117jzz//5N///jcvvPACM2bMAKBnz55UrFiR6dOn53utzz//nL59+1K+fPm8ba1btyYuLo6jR49e/w9WROxj3sL3IlIaDR061PD09DQCAwPz3V599dW8fQDjH//4R97jlJQUw2KxGD/88INhGIbxwgsvGNHR0fleNy4uzgCMffv2GYZhGB07djRuvvnmfPv87W9/Mxo1apRv24QJEwzAOHfunGEYhrFx40bD09PTOH78uGEYhnHmzBnD29vbWL169VV/pz59+hgPPfRQvm2rVq0yAGPv3r1G06ZNjX79+hmZmZl5z1erVs346quv8v3MP//5T6Nt27b58kZGRhpWq9UwDMM4fPiwYbFYjGXLluX7uaSkJAO4ZkYRKRodERIRh+vcuTPbt2/Pdxs1alS+fS4NBgbbkZqgoCBOnz4NwNatW1m1ahVlypTJuzVo0ACAQ4cO5f3c/x6l2bdvH61atcq3rXXr1gUeN2zYkJkzZwIwa9YsqlevTocOHa76+6Snp+Pn53fF57p27UqtWrWYN28ePj4+AJw5c4a4uDiGDx+e73f417/+lS//8OHDOXr0KCtXrgRsR4OqVq1K165d872Hv78/AGlpaVfNKCJF42V2ABEpfQIDA6lTp8419/H29s732GKxYLVaAbBarfTq1Ys33nijwM9VqlQp3/v8lWEYWCyWAtv+14gRI3j//fcZN24c06ZN48EHHyzwc38VFhbGuXPnrvjcnXfeyYIFC9izZw+NGzfOyw/wySefcMstt+Tb39PTM+9+3bp1ad++PdOmTcsbz/Tggw/i4ZH/36iXThmGh4dfNaOIFI2KkIi4nObNm7NgwQJq1KiBl1fh/5pq0KABS5cuzbdty5YtBfa7//77GTt2LO+++y67d+9m6NCh13zdZs2aXfVS99dff50yZcrQpUsXVq9eTVRUFBEREVSpUoXDhw8zePDga7728OHDeeyxx+jTpw/Hjh3jwQcfLLDPrl278Pb2pmHDhtd8LRGxn06NiYjDZWZmcvLkyXy3v17xdT2jRo0iMTGRQYMGsWnTJg4fPszy5ct56KGHyM3NverPjRw5kr179/K3v/2N/fv3M2/evLzByH894lOuXDn69evHmDFjiI6OpmrVqtfM0717d3bv3n3Vo0JvvfUWgwcP5vbbb2fv3r0AvPzyy0ycOJH//ve/7N+/nz/++INp06bx9ttv5/vZAQMG4O3tzciRI+nSpcsV5ylat24d7du3zztFJiKOoyIkIg73448/UqlSpXy32267rdA/X7lyZdavX09ubi7du3enUaNGPPXUU4SEhBQ4bfRXNWvWZP78+SxcuJAmTZrwwQcf5F015uvrm2/f4cOHk5WVxUMPPXTdPI0bN6Zly5bMmzfvqvu888473HPPPdx+++3s37+fESNG8OmnnzJ9+nQaN25Mx44dmT59OjVr1sz3cwEBAdx7772cO3fuqllmz57Nww8/fN2cImI/i3GlE+giIqXEa6+9xocffkhcXFy+7V9++SVPPfUUJ06cyBvkfC1Lly7l+eefZ9euXdcsY462ZMkSxowZw86dO+06TSgihaNPlYiUKlOnTqVVq1aUL1+e9evX8+abb/LEE0/kPZ+WlkZMTAwTJ05k5MiRhSpBYJv358CBAxw/fpxq1ao5K34BqampTJs2TSVIxEl0REhESpVnnnmGuXPnkpiYSPXq1RkyZAjjx4/PKxIvv/wyr732Gh06dOCbb76hTJkyJicWETOpCImIiIjb0mBpERERcVsqQiIiIuK2VIRERETEbakIiYiIiNtSERIRERG3pSIkIiIibktFSERERNyWipCIiIi4LRUhERERcVv/D07RQ8++CGAOAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "disk_flux_dist_sq = photosphere.disk_spectrum #m^2*photons/s/cm^2/keV\n", "star_flux_dist_sq = np.mean(photosphere.signal[0][0],axis=1)-disk_flux_dist_sq #subtracting disk from the total to retrieve star flux\n", "\n", "def unit_convert(F, distance):\n", " # assuming the distance is in 10 kpc units, which we use to convert flux to photons/s/cm^2/keV, 3.08e19 is to convert kpc to meter\n", " F_converted = F/(3.08567758128e19*distance)**2\n", " return F_converted\n", "\n", "disk_flux = unit_convert(disk_flux_dist_sq, spacetime['distance'])\n", "star_flux = unit_convert(star_flux_dist_sq, spacetime['distance'])\n", "\n", "fig,ax = plt.subplots()\n", "\n", "ax.loglog(energies, energies*disk_flux, label='disk')\n", "ax.loglog(energies, energies*star_flux, label='star')\n", "ax.set_xlim([0.1,20])\n", "ax.set_ylim([1e-2, 1e0])\n", "ax.set_ylabel('Energy flux (keV/s/cm^2/KeV)')\n", "ax.set_xlabel('Energy (keV)')\n", "ax.legend()\n", "\n", "plt.show()" ] } ], "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.11.9" } }, "nbformat": 4, "nbformat_minor": 5 }