From 2c103daa84da7d675cd82f8cde545640e7e8cfcd Mon Sep 17 00:00:00 2001 From: Jay Stephan Date: Wed, 26 Apr 2023 10:18:34 +0100 Subject: [PATCH 1/7] First commit of my atmospheric shift and transmission code for MOSAIC --- scopesim/effects/atmo_disp_shifts_trans.ipynb | 411 ++++++++++++++++++ .../effects/atmo_disp_shifts_trans_utils.py | 221 ++++++++++ scopesim/effects/conf.ini | 51 +++ 3 files changed, 683 insertions(+) create mode 100644 scopesim/effects/atmo_disp_shifts_trans.ipynb create mode 100644 scopesim/effects/atmo_disp_shifts_trans_utils.py create mode 100755 scopesim/effects/conf.ini diff --git a/scopesim/effects/atmo_disp_shifts_trans.ipynb b/scopesim/effects/atmo_disp_shifts_trans.ipynb new file mode 100644 index 00000000..ae2b02a4 --- /dev/null +++ b/scopesim/effects/atmo_disp_shifts_trans.ipynb @@ -0,0 +1,411 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from configobj import ConfigObj\n", + "import numpy as np\n", + "from astropy import units as u\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from astropy.coordinates import Angle\n", + "\n", + "from astroplan import Observer\n", + "from astropy.io import fits\n", + "\n", + "import dispersion_functions as diff_func\n", + "import math\n", + "import matplotlib as mpl\n", + "plt.style.use('bmh')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class AD_simulation:\n", + " def __init__(self):\n", + " self.input={}\n", + " self.output={}\n", + " \n", + " self.config=ConfigObj('conf.ini')\n", + " \n", + " def load_wavelengths(self,start,end,sampling,diameter):\n", + " \"\"\"\n", + " start, end, sampling: microns\n", + " diameter: arcsec\n", + " \"\"\"\n", + " self.output['wavelengths']=np.arange(start,end,sampling)\n", + " self.output['diameter']=diameter\n", + " \n", + " def load_MOSAIC_band(self,regime,band,sampling,res=\"LR\"):\n", + " \"\"\"\n", + " regime: 1) \"VIS\", or 2) \"NIR\"\n", + " band: 1) \"B\", \"G\", \"R\", or \"All\", or 2) \"IY\", \"J\", \"H\", or \"All\"\n", + " sampling: microns\n", + " res: \"LR\" or \"HR\"\n", + " \"\"\"\n", + " wave_min= float(self.config[\"Bands\"][res][regime][band][\"wave_min\"])\n", + " wave_max= float(self.config[\"Bands\"][res][regime][band][\"wave_max\"])\n", + "\n", + " self.output['wavelengths'] = np.arange(wave_min,wave_max,sampling) \n", + " self.output['diameter']=float(self.config[\"Aperture\"][regime+\"_major_axis\"])\n", + " \n", + " def load_HA(self,HA_range,targ_dec):\n", + " self.input['HA_range']=HA_range\n", + " self.input['targ_dec']=targ_dec\n", + "\n", + " #latitude needs to be negative for now\n", + " lat = float(self.config[\"Environment\"][\"latitude\"]) * np.pi/180\n", + " dec = targ_dec*np.pi/180\n", + " \n", + " #Need to check if the target is below the horizon for the given list of HA, and if so remove it.\n", + " LHA_below_horizon=np.rad2deg(np.arccos(-np.tan(lat)*np.tan(dec)))/15 \n", + " if str(LHA_below_horizon) != 'nan': \n", + " print(\"Target goes below Horizon above/below HA of +/- %2.1fh\" % (LHA_below_horizon))\n", + " for val in HA_range.copy(): \n", + " if abs(val) > abs(LHA_below_horizon):\n", + " print(\"At HA %2.2fh, target goes below horizon - removing this from HA range\" % (val))\n", + " HA_range.remove(val) \n", + " if dec > np.pi/2 + lat: #If the target has a too high declination, it will never be seen at Cerro Paranal\n", + " print(\"Target always below Horizon\")\n", + " return\n", + "\n", + " airmasses=1/(np.sin(lat)*np.sin(dec)+np.cos(lat)*np.cos(dec)*np.cos(Angle(HA_range*u.hour).rad))\n", + "\n", + " self.output['meridian_airmass'] = 1/(np.sin(lat)*np.sin(dec)+np.cos(lat)*np.cos(dec)*np.cos(Angle(0*u.hour).rad)) #Lowest airmass the target will be at\n", + "\n", + " para_angles=diff_func.parallatic_angle(np.array(HA_range),dec,lat)\n", + " \n", + " self.output['raw_para_angles']=np.array(para_angles) #actual PAs\n", + " self.output['airmasses']=np.array(airmasses)\n", + " \n", + " def calculate_shifts(self, guide_waveref, aperture_waveref, centring=\"mid HA\"):\n", + " self.input['guide_waveref']=guide_waveref\n", + " self.input['aperture_waveref']=aperture_waveref\n", + "\n", + " airmasses=self.output['airmasses']\n", + " wavelengths=self.output['wavelengths']\n", + "\n", + " #centring refers to the index of the hour angles at which we centre the aperture/guiding on a wavelength\n", + " if centring == \"mid HA\":\n", + " centring_index=int((len(airmasses)-1)/2)\n", + " if type(centring) == int:\n", + " centring_index=centring\n", + "\n", + " self.input['centred_on']=str(self.input['HA_range'][centring_index])+\"h\"\n", + " centre_shift=diff_func.diff_shift(aperture_waveref,airmasses[centring_index],guide_waveref) #shift of the original aperture centre wavelength from guide wavelength\n", + " self.output['centre_shift']=centre_shift\n", + "\n", + " raw_para_angles=self.output['raw_para_angles']\n", + " para_angles=self.output['raw_para_angles'].copy()\n", + " for i in range(0,len(para_angles)): #change in PAs from centring index\n", + " para_angles[i]=para_angles[i]-self.output['raw_para_angles'][centring_index]\n", + " self.input['centred_q']=self.output['raw_para_angles'][centring_index]\n", + " self.output['delta_para_angles']=para_angles\n", + " \n", + " shifts_no_para=[]\n", + " shifts_para=[]\n", + " shifts_para_v2=[]\n", + " for count,airmass in enumerate(airmasses): #for each airmass, calculate AD shift\n", + " shift_vals=diff_func.diff_shift(wavelengths,airmass,guide_waveref)\n", + " shifts_no_para.append(shift_vals-centre_shift)\n", + " \n", + " airmass_shifts=[]\n", + " airmass_shifts_v2=[]\n", + " for i in range(0,len(shift_vals)):\n", + " x=(shift_vals[i])*np.sin(para_angles[count])\n", + " y=(shift_vals[i])*np.cos(para_angles[count])-centre_shift\n", + " \n", + " x_v2=(shift_vals[i])*np.sin(raw_para_angles[count])-centre_shift*np.sin(self.input['centred_q'])\n", + " y_v2=(shift_vals[i])*np.cos(raw_para_angles[count])-centre_shift*np.cos(self.input['centred_q'])\n", + "\n", + " airmass_shifts.append([x,y])\n", + " airmass_shifts_v2.append([x_v2,y_v2])\n", + " \n", + " shifts_para.append(airmass_shifts)\n", + " shifts_para_v2.append(airmass_shifts_v2)\n", + " \n", + " #alternate way of calculating shifts\n", + " #para_shift_v2=np.sqrt(shift_vals**2+centre_shift**2-2*shift_vals*centre_shift*np.cos(para_angles[count])) #Uses cosine rule to evaluate the shift from the aperture centre\n", + " \n", + " self.output['shifts_no_para']=np.array(shifts_no_para)\n", + " #V1 is shifts where y-axis is dispersion direction at centring\n", + " self.output['shifts']=np.array(shifts_para)\n", + " #V2 is shifts where y-axis is PA=0 \n", + " self.output['shifts_v2']=np.array(shifts_para_v2)\n", + " \n", + " def load_PSFs(self):\n", + " all_PSFs=[]\n", + " all_aligned_PSFs=[]\n", + " all_PSFs_totals=[]\n", + " \n", + " zero_shifts=np.zeros(np.shape(self.output['shifts'][0]))\n", + "\n", + " for i in range(0,len(self.output['airmasses'])):\n", + " PSFs,PSFs_totals=diff_func.make_moffat_PSFs(self.output['wavelengths'],self.output['shifts'][i],self.output['airmasses'][i],self.output['diameter'])\n", + " aligned_PSFs,blank=diff_func.make_moffat_PSFs(self.output['wavelengths'],zero_shifts,self.output['airmasses'][i],self.output['diameter'])\n", + " \n", + " all_PSFs.append(PSFs)\n", + " all_aligned_PSFs.append(aligned_PSFs)\n", + " all_PSFs_totals.append(PSFs_totals)\n", + " \n", + " self.output['PSFs']=all_PSFs\n", + " self.output['aligned_PSFs']=all_aligned_PSFs\n", + " self.output['PSFs_totals']=all_PSFs_totals\n", + " \n", + " def load_aperture(self,aperture_type=\"circle\"):\n", + " aperture=diff_func.make_aperture(aperture_type,self.output['diameter'])\n", + " self.output['aperture']=aperture\n", + " \n", + " def calculate_transmissions(self):\n", + " convolved_arrays=self.output['PSFs']*self.output['aperture']\n", + " convolved_aligned_arrays=self.output['aligned_PSFs']*self.output['aperture']\n", + " self.output['PSFs_through_aperture']=convolved_arrays\n", + " self.output['aligned_PSFs_through_aperture']=convolved_aligned_arrays\n", + "\n", + " raw_transmissions=np.sum(convolved_arrays,axis=(-1,-2))/self.output['PSFs_totals']\n", + " no_AD_transmissions=np.sum(convolved_aligned_arrays,axis=(-1,-2))/self.output['PSFs_totals']\n", + " relative_transmissions=raw_transmissions/no_AD_transmissions\n", + "\n", + " self.output['raw_transmissions']=raw_transmissions\n", + " self.output['no_AD_transmissions']=no_AD_transmissions\n", + " self.output['relative_transmissions']=relative_transmissions\n", + "\n", + " relative_integration_transmissions=np.mean(relative_transmissions,axis=0)\n", + " raw_integration_transmissions=np.mean(raw_transmissions,axis=0)\n", + " self.output['raw_integration_transmission']=raw_integration_transmissions\n", + " self.output['relative_integration_transmission']=relative_integration_transmissions\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target goes below Horizon above/below HA of +/- 6.3h\n" + ] + } + ], + "source": [ + "analysis=AD_simulation()\n", + "analysis.load_HA(np.linspace(3,4,3),-10.3)\n", + "analysis.load_MOSAIC_band(\"VIS\",\"B\",.001)\n", + "analysis.calculate_shifts(0.46,0.4,centring=\"mid HA\")\n", + "\n", + "analysis.load_aperture(aperture_type=\"hexagons\")\n", + "analysis.load_PSFs()\n", + "analysis.calculate_transmissions()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=[5,5]) \n", + "weights = np.arange(0, len(analysis.output['wavelengths']))\n", + "norm = mpl.colors.Normalize(vmin=min(weights), vmax=max(weights))\n", + "cmap = mpl.cm.ScalarMappable(norm=norm, cmap='seismic')\n", + "circle1 = plt.Circle((0, 0), analysis.output['diameter']/2, color='black', fill=False, label='Aperture')\n", + "ax.add_patch(circle1) \n", + "plt.axvline(0,color='black',linestyle='--',linewidth=0.7,label=\"AD axis at {}\".format(analysis.input['centred_on']))\n", + "plt.scatter(0,-analysis.output['centre_shift'],label='Guide = {}um'.format(analysis.input['guide_waveref']),color='black',marker='+')\n", + "plt.xlim(-0.75,0.75)\n", + "plt.ylim(-0.75,0.75)\n", + "shifts=analysis.output['shifts']\n", + "for i in range(0,len(shifts[0])):\n", + " xs=[]\n", + " ys=[]\n", + " for o in range(0,len(shifts)):\n", + " xs.append(shifts[o][i][0])\n", + " ys.append(shifts[o][i][1]) \n", + " plt.plot(xs,ys,marker='x',color=cmap.to_rgba(i),label=\"{}um\".format(round(analysis.output['wavelengths'][i],4)))\n", + "plt.legend()\n", + "plt.xlabel(\"x (arcsec)\")\n", + "plt.ylabel(\"y (arcsec)\")\n", + "\n", + "plt.figure(figsize=[7,5])\n", + "plt.ylim(0,1.1) \n", + "plt.plot(analysis.output['wavelengths'],analysis.output['raw_integration_transmission'],label=\"Aperture Centre = {}um\".format(analysis.input['aperture_waveref']))\n", + "plt.xlabel(\"Wavelength (um)\")\n", + "plt.ylabel(\"Relative Mean Integration Transmissions\")\n", + "plt.axhline(y=1,label='No AD Transmission',color='black',linestyle='--')\n", + "plt.axvline(x=analysis.input['guide_waveref'],label=\"Guide = {}um\".format(analysis.input['guide_waveref']),color='black',linewidth=0.5)\n", + "plt.title(\"Dec: {} deg, HA: {}-{}h\".format(analysis.input['targ_dec'],analysis.input['HA_range'][0],analysis.input['HA_range'][-1]))\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(7, 73, 73)\n" + ] + } + ], + "source": [ + "print(np.shape(analysis.output['PSFs'][0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.15680023464656154\n", + "0.19465158916033667\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.imshow(analysis.output['aligned_PSFs'][-1][0])\n", + "plt.figure()\n", + "plt.imshow(analysis.output['PSFs'][-1][0])\n", + "plt.figure()\n", + "plt.imshow(analysis.output['aperture'])\n", + "plt.figure()\n", + "plt.imshow(analysis.output['PSFs_through_aperture'][-1][0])\n", + "\n", + "print(analysis.output['raw_transmissions'][-1][0])\n", + "print(analysis.output['no_AD_transmissions'][-1][0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "astrocondatest", + "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.13" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/scopesim/effects/atmo_disp_shifts_trans_utils.py b/scopesim/effects/atmo_disp_shifts_trans_utils.py new file mode 100644 index 00000000..c6593b15 --- /dev/null +++ b/scopesim/effects/atmo_disp_shifts_trans_utils.py @@ -0,0 +1,221 @@ + +import math +import numpy as np + +from configobj import ConfigObj + +from astropy.modeling.models import Moffat2D +from astropy.modeling.functional_models import Disk2D + +import matplotlib.pyplot as plt + +from astropy.coordinates import Angle +from astropy import units as u + +def calculate_FWHM(wavelength,airmass): + Config = ConfigObj('conf.ini') + + D = float(Config['Parameters']['telescope_diameter']) + L0 = float(Config['Parameters']['wavefront_outer_scale']) + median_seeing = float(Config['Seeing']['median_seeing']) + median_seeing_wl = float(Config['Seeing']['median_seeing_wl']) + + r0=0.1*median_seeing**(-1)*(wavelength/median_seeing_wl)**1.2*airmass**(-0.6) + F_kolb=1/(1+300*(D/L0))-1 + + FWHM_atm=median_seeing*airmass**(0.6)*(wavelength/median_seeing_wl)**(-0.2)*np.sqrt(1+F_kolb*2.183*(r0/L0)**0.356) + FWHM_dl=0.212*wavelength/D + + FWHM_total=np.sqrt(FWHM_atm**2+FWHM_dl**2) + + return FWHM_total + +def make_moffat_PSFs(wavelengths,offsets,airmass,diameter,beta=2.5): + + wavelengths,offsets = np.array(wavelengths),np.array(offsets) + Config = ConfigObj('conf.ini') + scale = float(Config['Sim_Parameters']['scale']) + + boundary=math.ceil(diameter/2/scale) #radius of aperture in pixels + + FWHMs = calculate_FWHM(wavelengths,airmass) + + x = np.arange(-boundary, boundary+1) + y = np.arange(-boundary, boundary+1) + x, y = np.meshgrid(x, y) + + PSFs=np.zeros((len(wavelengths),boundary*2+1,boundary*2+1)) + total_vals=[] + + for count in range(0,len(wavelengths)): + alpha=FWHMs[count]/scale/(2*np.sqrt(2**(1/beta)-1)) + x_pos=offsets[count][0]/scale + y_pos=offsets[count][1]/scale + + Moffat=Moffat2D(1,x_pos,y_pos,alpha,beta) + Moffat_data=Moffat(x,y) + + PSFs[count]=Moffat_data + + moffat_total=(np.pi*alpha**2)/(beta-1) + total_vals.append(moffat_total) + + return PSFs,total_vals + +def parallatic_angle(HA,dec,lat): + HA=Angle(HA*u.hour).rad + q = np.arctan2(np.sin(HA),(np.cos(dec)*np.tan(lat)-np.sin(dec)*np.cos(HA))) + return q + +def diff_shift(wave, airmass, atm_ref_wav): + Lambda0 = atm_ref_wav + wave = wave + + config=ConfigObj('conf.ini') + + T = float(config["Environment"]["temperature"])+273.15 + HR = float(config["Environment"]["humidity"])/100 + P = float(config["Environment"]["pressure"]) + + ZD_deg = airmass_to_zenith_dist(airmass) + ZD = np.deg2rad(ZD_deg) + + # saturation pressure Ps (millibars) + PS = -10474.0 + 116.43*T - 0.43284*T**2 + 0.00053840*T**3 + + # water vapour pressure + Pw = HR * PS + # dry air pressure + Pa = P - Pw + + #dry air density + Da = (1 + Pa * (57.90*1.0e-8 - 0.0009325/T + 0.25844/T**2)) * Pa/T + + #1 - P instead of 1 + Pa here? Why? Makes minimal affect of actual values... + + #water vapour density ? + Dw = (1 + Pw * (1 + 3.7 * 1E-4 * Pw) * (- 2.37321 * 1E-3 + 2.23366/T + - 710.792/T**2 + + 77514.1/T**3)) * Pw/T + + S0 = 1.0/Lambda0 + S = 1.0/wave + + N0_1 = (1.0E-8*((2371.34+683939.7/(130.0-S0**2)+4547.3/(38.9-S0**2))*Da + + (6487.31+58.058*S0**2-0.71150*S0**4+0.08851*S0**6)*Dw)) + + N_1 = 1.0E-8*((2371.34+683939.7/(130.0-S**2)+4547.3/(38.9-S**2))*Da + + (6487.31+58.058*S**2-0.71150*S**4+0.08851*S**6)*Dw) + + DR = np.tan(ZD)*(N0_1-N_1) * u.rad + + return (DR.to(u.arcsec)).value + +def airmass_to_zenith_dist(airmass): + return np.rad2deg(np.arccos(1/airmass)) + +def make_aperture(type,major_axis,hex_rotation=0): + config=ConfigObj('conf.ini') + scale=float(config['Sim_Parameters']['scale']) + boundary=math.ceil(major_axis/2/scale) #radius of aperture in pixels + if type == "circle": + + x = np.arange(-boundary, boundary+1) + y = np.arange(-boundary, boundary+1) + x, y = np.meshgrid(x, y) + + Disk=Disk2D(1,0,0,major_axis/2/scale) + aperture=Disk(x,y) + + return aperture + + if type == "hexagons": + sampling = major_axis/3/scale + aperture_array=np.zeros([boundary*2+1,boundary*2+1]) + + triangle_side=sampling*np.sqrt(3)/3 + core = 2 * triangle_side * np.cos(np.pi/4) + aperture_centre=[boundary,boundary] + alpha = hex_rotation + + centre_0=aperture_centre + centre_1=[centre_0[0]+sampling*np.cos(np.pi/2-alpha),centre_0[1]+sampling-sampling*(1-np.sin(np.pi/2-alpha))] + centre_2=[centre_0[0]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6-alpha),centre_0[1]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6-alpha)] + centre_3=[centre_0[0]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6+alpha),centre_0[1]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6+alpha)] + centre_4=[centre_0[0]-sampling*np.cos(np.pi/2-alpha),centre_0[1]-sampling+sampling*(1-np.sin(np.pi/2-alpha))] + centre_5=[centre_0[0]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6-alpha),centre_0[1]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6-alpha)] + centre_6=[centre_0[0]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6+alpha),centre_0[1]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6+alpha)] + + centres=[centre_0,centre_1,centre_2,centre_3,centre_4,centre_5,centre_6] + + for centre in centres: + if alpha == 0: + P1=[centre[0]+triangle_side*np.cos(np.pi*1/3-alpha),centre[1]+triangle_side*np.sin(np.pi/3-alpha)] + P2=[centre[0]+triangle_side*np.cos(alpha),centre[1]-triangle_side*np.sin(alpha)] + P3=[centre[0]+triangle_side*np.cos(np.pi/3+alpha),centre[1]-triangle_side*np.sin(np.pi/3+alpha)] + P4=[centre[0]-triangle_side*np.cos(np.pi/3-alpha),centre[1]-triangle_side*np.sin(np.pi/3-alpha)] + P5=[centre[0]-triangle_side*np.cos(-alpha),centre[1]-triangle_side*np.sin(-alpha)] + P6=[centre[0]-triangle_side*np.cos(np.pi/3+alpha),centre[1]+triangle_side*np.sin(np.pi/3+alpha)] + + L12_m,L12_c=line(P1,P2) + L23_m,L23_c=line(P2,P3) + L34_m,L34_c=line(P3,P4) + L45_m,L45_c=line(P4,P5) + L56_m,L56_c=line(P5,P6) + L61_m,L61_c=line(P6,P1) + + for y in range(0,len(aperture_array)): + for x in range(0,len(aperture_array)): + if x < centre_0[0] + triangle_side * 2 and x > centre_0[0] - triangle_side * 2 and y < centre_0[1] + sampling and y > centre_0[1] - sampling: + aperture_array[y][x]=1 + elif y < L61_m*x + L61_c and y > L34_m*x + L34_c and y < L12_m*x + L12_c and y > L23_m*x + L23_c and y > L45_m*x + L45_c and y < L56_m*x + L56_c: + aperture_array[y][x]=1 + + elif alpha != np.pi/6 and alpha != -np.pi/6: + P1=[centre[0]+triangle_side*np.cos(np.pi*1/3-alpha),centre[1]+triangle_side*np.sin(np.pi/3-alpha)] + P2=[centre[0]+triangle_side*np.cos(alpha),centre[1]-triangle_side*np.sin(alpha)] + P3=[centre[0]+triangle_side*np.cos(np.pi/3+alpha),centre[1]-triangle_side*np.sin(np.pi/3+alpha)] + P4=[centre[0]-triangle_side*np.cos(np.pi/3-alpha),centre[1]-triangle_side*np.sin(np.pi/3-alpha)] + P5=[centre[0]-triangle_side*np.cos(-alpha),centre[1]-triangle_side*np.sin(-alpha)] + P6=[centre[0]-triangle_side*np.cos(np.pi/3+alpha),centre[1]+triangle_side*np.sin(np.pi/3+alpha)] + + L12_m,L12_c=line(P1,P2) + L23_m,L23_c=line(P2,P3) + L34_m,L34_c=line(P3,P4) + L45_m,L45_c=line(P4,P5) + L56_m,L56_c=line(P5,P6) + L61_m,L61_c=line(P6,P1) + + for y in range(0,len(aperture_array)): + for x in range(0,len(aperture_array)): + if y > centre_0[1] - core and y < centre_0[1] + core and x > centre_0[1] - core and x < centre_0[1] + core: + aperture_array[y][x]=1 + elif y < L61_m*x + L61_c and y > L34_m*x + L34_c and y < L12_m*x + L12_c and y > L23_m*x + L23_c and y > L45_m*x + L45_c and y < L56_m*x + L56_c: + aperture_array[y][x]=1 + + elif alpha == np.pi/6 or alpha == - np.pi/6: + P1=[centre[0]+triangle_side*np.cos(np.pi/3-alpha),centre[1]+triangle_side*np.sin(np.pi/3-alpha)] + P2=[centre[0]+triangle_side*np.cos(alpha),centre[1]-triangle_side*np.sin(alpha)] + P3=[centre[0]+triangle_side*np.cos(np.pi/3+alpha),centre[1]-triangle_side*np.sin(np.pi/3+alpha)] + P4=[centre[0]-triangle_side*np.cos(np.pi/3-alpha),centre[1]-triangle_side*np.sin(np.pi/3-alpha)] + P5=[centre[0]-triangle_side*np.cos(-alpha),centre[1]-triangle_side*np.sin(-alpha)] + P6=[centre[0]-triangle_side*np.cos(np.pi/3+alpha),centre[1]+triangle_side*np.sin(np.pi/3+alpha)] + + L23_m,L23_c=line(P2,P3) + L34_m,L34_c=line(P3,P4) + L56_m,L56_c=line(P5,P6) + L61_m,L61_c=line(P6,P1) + + for y in range(0,len(aperture_array)): + for x in range(0,len(aperture_array)): + if y < centre_0[1] + triangle_side * 2 and y > centre_0[1] - triangle_side * 2 and x < centre_0[0] + sampling and x > centre_0[0] - sampling: + aperture_array[y][x]=1 + elif y < L61_m*x + L61_c and y > L34_m*x + L34_c and y > L23_m*x + L23_c and y < L56_m*x + L56_c and x > centre[0] - sampling/2 and x < centre[0] + sampling/2: + aperture_array[y][x]=1 + + return aperture_array + +def line(A,B): + m=(A[1]-B[1])/(A[0]-B[0]) + c=A[1]-m*A[0] + return m,c diff --git a/scopesim/effects/conf.ini b/scopesim/effects/conf.ini new file mode 100755 index 00000000..b44900ed --- /dev/null +++ b/scopesim/effects/conf.ini @@ -0,0 +1,51 @@ +[Parameters] + telescope_diameter = 39 #m + wavefront_outer_scale = 46 #m + +[Seeing] + median_seeing = .68 #arcsecs + median_seeing_wl = .5 #um + +[Aperture] + VIS_major_axis = .702 #arcsecs, VIS + NIR_major_axis = .570 #arcsecs, NIR + +[Sim_Parameters] + scale=0.01 + +[Environment] + latitude = -24.6272 #deg + temperature = 10 #deg + humidity = 14.5 #% + pressure = 750.0 #mBa + +[Bands] + [[LR]] + [[[VIS]]] + [[[[B]]]] + wave_min= .390 + wave_max= .458 + [[[[G]]]] + wave_min= .450 + wave_max= .591 + [[[[R]]]] + wave_min= .586 + wave_max= .770 + [[[[All]]]] + wave_min= .390 + wave_max= .770 + [[[NIR]]] + [[[[IY]]]] + wave_min= .770 + wave_max= 1.063 + [[[[J]]]] + wave_min= 1.010 + wave_max= 1.395 + [[[[H]]]] + wave_min= 1.420 + wave_max= .857 + [[[[All]]]] + wave_min= .770 + wave_max= 1.857 + + \ No newline at end of file From 330322a08888f38fdd15fb98068e97069c2d2990 Mon Sep 17 00:00:00 2001 From: Jay Stephan Date: Tue, 2 May 2023 13:38:16 +0100 Subject: [PATCH 2/7] Second commit of MOSAIC AD Effects - code altered to fit SCOPESIM purpose Now outputs WLs and trans for individual fibre --- scopesim/effects/atmo_disp_shifts_trans.ipynb | 411 ------------------ scopesim/effects/atmo_disp_shifts_trans.py | 268 ++++++++++++ .../effects/atmo_disp_shifts_trans_utils.py | 190 +++----- scopesim/effects/conf.ini | 51 --- 4 files changed, 325 insertions(+), 595 deletions(-) delete mode 100644 scopesim/effects/atmo_disp_shifts_trans.ipynb create mode 100644 scopesim/effects/atmo_disp_shifts_trans.py delete mode 100755 scopesim/effects/conf.ini diff --git a/scopesim/effects/atmo_disp_shifts_trans.ipynb b/scopesim/effects/atmo_disp_shifts_trans.ipynb deleted file mode 100644 index ae2b02a4..00000000 --- a/scopesim/effects/atmo_disp_shifts_trans.ipynb +++ /dev/null @@ -1,411 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from configobj import ConfigObj\n", - "import numpy as np\n", - "from astropy import units as u\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from astropy.coordinates import Angle\n", - "\n", - "from astroplan import Observer\n", - "from astropy.io import fits\n", - "\n", - "import dispersion_functions as diff_func\n", - "import math\n", - "import matplotlib as mpl\n", - "plt.style.use('bmh')" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "class AD_simulation:\n", - " def __init__(self):\n", - " self.input={}\n", - " self.output={}\n", - " \n", - " self.config=ConfigObj('conf.ini')\n", - " \n", - " def load_wavelengths(self,start,end,sampling,diameter):\n", - " \"\"\"\n", - " start, end, sampling: microns\n", - " diameter: arcsec\n", - " \"\"\"\n", - " self.output['wavelengths']=np.arange(start,end,sampling)\n", - " self.output['diameter']=diameter\n", - " \n", - " def load_MOSAIC_band(self,regime,band,sampling,res=\"LR\"):\n", - " \"\"\"\n", - " regime: 1) \"VIS\", or 2) \"NIR\"\n", - " band: 1) \"B\", \"G\", \"R\", or \"All\", or 2) \"IY\", \"J\", \"H\", or \"All\"\n", - " sampling: microns\n", - " res: \"LR\" or \"HR\"\n", - " \"\"\"\n", - " wave_min= float(self.config[\"Bands\"][res][regime][band][\"wave_min\"])\n", - " wave_max= float(self.config[\"Bands\"][res][regime][band][\"wave_max\"])\n", - "\n", - " self.output['wavelengths'] = np.arange(wave_min,wave_max,sampling) \n", - " self.output['diameter']=float(self.config[\"Aperture\"][regime+\"_major_axis\"])\n", - " \n", - " def load_HA(self,HA_range,targ_dec):\n", - " self.input['HA_range']=HA_range\n", - " self.input['targ_dec']=targ_dec\n", - "\n", - " #latitude needs to be negative for now\n", - " lat = float(self.config[\"Environment\"][\"latitude\"]) * np.pi/180\n", - " dec = targ_dec*np.pi/180\n", - " \n", - " #Need to check if the target is below the horizon for the given list of HA, and if so remove it.\n", - " LHA_below_horizon=np.rad2deg(np.arccos(-np.tan(lat)*np.tan(dec)))/15 \n", - " if str(LHA_below_horizon) != 'nan': \n", - " print(\"Target goes below Horizon above/below HA of +/- %2.1fh\" % (LHA_below_horizon))\n", - " for val in HA_range.copy(): \n", - " if abs(val) > abs(LHA_below_horizon):\n", - " print(\"At HA %2.2fh, target goes below horizon - removing this from HA range\" % (val))\n", - " HA_range.remove(val) \n", - " if dec > np.pi/2 + lat: #If the target has a too high declination, it will never be seen at Cerro Paranal\n", - " print(\"Target always below Horizon\")\n", - " return\n", - "\n", - " airmasses=1/(np.sin(lat)*np.sin(dec)+np.cos(lat)*np.cos(dec)*np.cos(Angle(HA_range*u.hour).rad))\n", - "\n", - " self.output['meridian_airmass'] = 1/(np.sin(lat)*np.sin(dec)+np.cos(lat)*np.cos(dec)*np.cos(Angle(0*u.hour).rad)) #Lowest airmass the target will be at\n", - "\n", - " para_angles=diff_func.parallatic_angle(np.array(HA_range),dec,lat)\n", - " \n", - " self.output['raw_para_angles']=np.array(para_angles) #actual PAs\n", - " self.output['airmasses']=np.array(airmasses)\n", - " \n", - " def calculate_shifts(self, guide_waveref, aperture_waveref, centring=\"mid HA\"):\n", - " self.input['guide_waveref']=guide_waveref\n", - " self.input['aperture_waveref']=aperture_waveref\n", - "\n", - " airmasses=self.output['airmasses']\n", - " wavelengths=self.output['wavelengths']\n", - "\n", - " #centring refers to the index of the hour angles at which we centre the aperture/guiding on a wavelength\n", - " if centring == \"mid HA\":\n", - " centring_index=int((len(airmasses)-1)/2)\n", - " if type(centring) == int:\n", - " centring_index=centring\n", - "\n", - " self.input['centred_on']=str(self.input['HA_range'][centring_index])+\"h\"\n", - " centre_shift=diff_func.diff_shift(aperture_waveref,airmasses[centring_index],guide_waveref) #shift of the original aperture centre wavelength from guide wavelength\n", - " self.output['centre_shift']=centre_shift\n", - "\n", - " raw_para_angles=self.output['raw_para_angles']\n", - " para_angles=self.output['raw_para_angles'].copy()\n", - " for i in range(0,len(para_angles)): #change in PAs from centring index\n", - " para_angles[i]=para_angles[i]-self.output['raw_para_angles'][centring_index]\n", - " self.input['centred_q']=self.output['raw_para_angles'][centring_index]\n", - " self.output['delta_para_angles']=para_angles\n", - " \n", - " shifts_no_para=[]\n", - " shifts_para=[]\n", - " shifts_para_v2=[]\n", - " for count,airmass in enumerate(airmasses): #for each airmass, calculate AD shift\n", - " shift_vals=diff_func.diff_shift(wavelengths,airmass,guide_waveref)\n", - " shifts_no_para.append(shift_vals-centre_shift)\n", - " \n", - " airmass_shifts=[]\n", - " airmass_shifts_v2=[]\n", - " for i in range(0,len(shift_vals)):\n", - " x=(shift_vals[i])*np.sin(para_angles[count])\n", - " y=(shift_vals[i])*np.cos(para_angles[count])-centre_shift\n", - " \n", - " x_v2=(shift_vals[i])*np.sin(raw_para_angles[count])-centre_shift*np.sin(self.input['centred_q'])\n", - " y_v2=(shift_vals[i])*np.cos(raw_para_angles[count])-centre_shift*np.cos(self.input['centred_q'])\n", - "\n", - " airmass_shifts.append([x,y])\n", - " airmass_shifts_v2.append([x_v2,y_v2])\n", - " \n", - " shifts_para.append(airmass_shifts)\n", - " shifts_para_v2.append(airmass_shifts_v2)\n", - " \n", - " #alternate way of calculating shifts\n", - " #para_shift_v2=np.sqrt(shift_vals**2+centre_shift**2-2*shift_vals*centre_shift*np.cos(para_angles[count])) #Uses cosine rule to evaluate the shift from the aperture centre\n", - " \n", - " self.output['shifts_no_para']=np.array(shifts_no_para)\n", - " #V1 is shifts where y-axis is dispersion direction at centring\n", - " self.output['shifts']=np.array(shifts_para)\n", - " #V2 is shifts where y-axis is PA=0 \n", - " self.output['shifts_v2']=np.array(shifts_para_v2)\n", - " \n", - " def load_PSFs(self):\n", - " all_PSFs=[]\n", - " all_aligned_PSFs=[]\n", - " all_PSFs_totals=[]\n", - " \n", - " zero_shifts=np.zeros(np.shape(self.output['shifts'][0]))\n", - "\n", - " for i in range(0,len(self.output['airmasses'])):\n", - " PSFs,PSFs_totals=diff_func.make_moffat_PSFs(self.output['wavelengths'],self.output['shifts'][i],self.output['airmasses'][i],self.output['diameter'])\n", - " aligned_PSFs,blank=diff_func.make_moffat_PSFs(self.output['wavelengths'],zero_shifts,self.output['airmasses'][i],self.output['diameter'])\n", - " \n", - " all_PSFs.append(PSFs)\n", - " all_aligned_PSFs.append(aligned_PSFs)\n", - " all_PSFs_totals.append(PSFs_totals)\n", - " \n", - " self.output['PSFs']=all_PSFs\n", - " self.output['aligned_PSFs']=all_aligned_PSFs\n", - " self.output['PSFs_totals']=all_PSFs_totals\n", - " \n", - " def load_aperture(self,aperture_type=\"circle\"):\n", - " aperture=diff_func.make_aperture(aperture_type,self.output['diameter'])\n", - " self.output['aperture']=aperture\n", - " \n", - " def calculate_transmissions(self):\n", - " convolved_arrays=self.output['PSFs']*self.output['aperture']\n", - " convolved_aligned_arrays=self.output['aligned_PSFs']*self.output['aperture']\n", - " self.output['PSFs_through_aperture']=convolved_arrays\n", - " self.output['aligned_PSFs_through_aperture']=convolved_aligned_arrays\n", - "\n", - " raw_transmissions=np.sum(convolved_arrays,axis=(-1,-2))/self.output['PSFs_totals']\n", - " no_AD_transmissions=np.sum(convolved_aligned_arrays,axis=(-1,-2))/self.output['PSFs_totals']\n", - " relative_transmissions=raw_transmissions/no_AD_transmissions\n", - "\n", - " self.output['raw_transmissions']=raw_transmissions\n", - " self.output['no_AD_transmissions']=no_AD_transmissions\n", - " self.output['relative_transmissions']=relative_transmissions\n", - "\n", - " relative_integration_transmissions=np.mean(relative_transmissions,axis=0)\n", - " raw_integration_transmissions=np.mean(raw_transmissions,axis=0)\n", - " self.output['raw_integration_transmission']=raw_integration_transmissions\n", - " self.output['relative_integration_transmission']=relative_integration_transmissions\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Target goes below Horizon above/below HA of +/- 6.3h\n" - ] - } - ], - "source": [ - "analysis=AD_simulation()\n", - "analysis.load_HA(np.linspace(3,4,3),-10.3)\n", - "analysis.load_MOSAIC_band(\"VIS\",\"B\",.001)\n", - "analysis.calculate_shifts(0.46,0.4,centring=\"mid HA\")\n", - "\n", - "analysis.load_aperture(aperture_type=\"hexagons\")\n", - "analysis.load_PSFs()\n", - "analysis.calculate_transmissions()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAHTCAYAAACEKHSrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACopklEQVR4nOzdd3gU1RoG8Hc3ZdNJL4QUQkgIIKF3CASkiKD0pnSUC4KAogSUphSFixQpohSRIuoVUayIdBBFAUsCCaSRkB5Ib7s794+YMUvOSXaTDTNLvt/z8JjMzux+ebMuHzNnzlEIgiCAEEIIIYQ8dEqpCyCEEEIIaaioESOEEEIIkQg1YoQQQgghEqFGjBBCCCFEItSIEUIIIYRIhBoxQgghhBCJUCNGCCGEECIRasQIIYQQQiRCjRghhBBCiESoESOEmDR/f3/4+/tLXQZpAE6fPg2FQoEVK1ZIXQp5hFAjRhoUhUKh80elUsHNzQ0dOnTAzJkz8cMPP0Cr1UpdplGcOHECL730Evr16wdnZ2coFAr07NmzxuMiIyMxZswYuLu7w8rKCsHBwVi+fDmKior0fu3c3FzMnz8fvXr1QuPGjWFlZQV3d3d07twZmzZtQkFBQV1+NJO1b98+KBQKTJkyhbtPxV/2ffr0qfa5Hn/8cSgUCvj4+ECj0Ri1zvXr1+OJJ56Av78/7Ozs4ODggMceewwLFy5EUlKSwc+XnZ2N+fPnw9/fHyqVCo0bN8a0adNq9VwPOnv2LMzMzKBQKPDaa6/JqjZC9GEudQGESGH58uUAAI1Gg/v37+Pvv//G/v378cEHH6Bz5844ePAgAgMDJa6ybrZt24Zjx47BysoKgYGBuHfvXo3HXL58GeHh4SgrK8OoUaPg4+ODn376CatWrcLJkydx8uRJqFSqGp8nOzsbu3btQqdOnTBkyBC4ubkhJycHP/30ExYsWID3338fly5dgoODgzF+1AYnNjYWJ0+ehEKhQFJSEr777jsMGTLEaM//3nvvwc7ODmFhYfDw8EBZWRmuXr2Kd955B7t378apU6fQvn17vZ4rKysL3bt3R3R0NMLDwzFu3DjcuHEDe/fuxddff41Lly4hICCgVnXm5eVh8uTJsLGxQX5+vsHH12dthOhNIKQBASDw3vapqanC6NGjBQCCn5+fkJGR8ZCrM66LFy8Kf/31l6BWq4W4uDgBgNCjRw/u/mq1WggJCREACMeOHRO3azQaYeTIkQIAYe3atXq9tlqtFkpLS5mPTZgwQQAgrFu3zrAfiMPPz0/w8/MzynPVt7179woAhMmTJ3P3OXXqlABACAsL4+6zePFiAYCwdOlSAYAwbNgwo9ZZVFTE3L5r1y4BgDBo0CC9n+u5554TAAgLFizQ2b5582YBgDBw4MBa1zl16lTByclJWL16tZiHIQytreJ3s3z58lrXTMiDqBEjDUp1jZgglDcdffr0YX44C4IgZGVlCYsXLxZatGghWFlZCQ4ODkJ4eLjw/fffc5/z448/FsLDwwUnJydBpVIJfn5+wrhx44Rff/3VKD+TPvRpxH788UduA3D79m0BgODr6ytotdo61fLFF18IAISZM2fqfYxWqxW2bt0qtGzZUlCpVELjxo2F2bNnC/fv36+2ETt06JDQp08fwdHRUVCpVEKLFi2EN954QyguLmbuf+DAAaFdu3aClZWV4ObmJjzzzDNCcnKyEBYWVu37Rl/GaMTKysoET09PwcnJSSguLhbatWsnmJmZCcnJyXWuryb3798XAAjNmzfXa/+8vDzB2tpasLOzE3Jzc3Ue02g0gr+/vwBAuH37tsG1VLyPPvroIzFXQxqx2tRWuRG7evWq8MQTTwiNGjUSrK2thV69egnnz583+OcghMaIEVKJUqkUx5kcPHhQ57GEhAR06NAB69atg7u7O/7zn/9g7NixiIqKwqBBg7Br1y6d/QVBwJQpUzBu3Dj88ccfGDFiBBYsWICePXvi7NmzOH78uM7+/v7+UCgUiI+Pr9efkefUqVMAgEGDBlV5LCAgAEFBQUhMTERsbGydXuerr74CALRp00bvY+bPn4+5c+fi3r17eO655zBu3Dh8//336N+/P0pLS5nHTJ8+HRMmTMDt27cxcuRIzJkzB87Oznj99dcxaNAglJWV6ey/fv16PPPMM4iPj8fkyZMxdepU/P333+jRowfu379f65/X2L788kukpqZi3LhxUKlUmDJlCjQaDfbs2cPcf8qUKVAoFNi3b1+dX9vQ393PP/+MoqIi9OjRA/b29jqPKZVKDBgwAMC/7z19paenY+bMmXj66afxzDPPGHSsMWq7cuUKunfvjuLiYsyYMQNPPvkkLly4gH79+iEqKqpW9ZCGi8aIEfKAnj17wtzcHOnp6YiPjxfvyJs8eTISEhLwySefYPTo0eL+9+/fR58+ffDiiy9i2LBh8PT0BAC8//77+PDDD9G5c2f88MMPaNSokXiMRqNBenr6Q/25anLz5k0AQPPmzZmPN2/eHNHR0YiOjkazZs30ek61Wo0333wTQPm4sbNnz+L69evo378/Zs6cqddzXLx4EVu2bEGzZs3wyy+/wNnZGQCwevVq9O3bFykpKfDz89M5Zt++fdizZw9GjRqFjz76CFZWVuJjK1aswMqVK7Ft2zbMnz8fQPmYqyVLlsDV1RW///47fHx8AADr1q3DhAkT8PHHH+tVq76uXbvGvfOupka8ouGfPHkyAGDixIlYtGgRdu/ejaVLl0KhUBitzg8++ABJSUnIz8/Hn3/+iR9//BFNmzbFunXr9Dpen/cUAERHRxtU13PPPQetVoudO3cadJyxavv666+xb98+8XcAlI+rmzVrFrZs2YIdO3bUui7SAEl9So6Qhwk1XJqs4O7uLgAQLl++LAiCIFy7dk0AIIwePZq5f8VlknfffVfc1rp1awGA8Pvvv+tV261bt4SoqCju2Kq60OfS5OOPPy4AEE6cOMF8vGJs16FDh/R+3aKiIjHzij+TJk0S8vLy9H6OGTNmCACEPXv2VHms4lLRg5cm27ZtK1hYWAj37t2rcoxarRZcXFyEjh07itveeOMNAYCwcuXKKvvHx8cLZmZmRr00qc8f1qXJ+Ph4QalUCiEhITrbR4wYIQBgXiK/e/euEBUVJdy/f9/gert06aJTU6dOnYRbt27pfXxNY7cqxpw999xzej/n7t27BQDCkSNHxG21uTRZm9oq3m89e/assn9paalgbm4udOjQQe8aCBEEQaAzYoTo4dKlSwDKz36xzmRkZGQAAG7cuAEAKCgowF9//QUPDw+0a9dOr9fQ9yxTRR2bNm2qsn3+/PlwdHTU+3kMIQgCABh0xsXKygpC+VhU3L17Fz/++CMiIiLQsWNHfPfdd3rN//X7778DAMLCwqo81qtXL5ib636MFRYW4vr163B1dWVmBAAqlUr8XQHA1atXAYA5vYefnx98fHyMesl48uTJ3EuFp0+fRt++fZmPffDBB9BqtTpnYoDyy4+ff/45du3aJV5Sq+Dl5QUvL69a1fnzzz8DKL+78Pfff8fSpUvRvn17HDlyhHkJ21APvqdqel/Hx8dj/vz5GD16NMaMGVPn1zektso6duxYZZuFhQU8PDz0ujuZkMqoESPkASUlJcjOzgYAuLm5ASj/iwgon5vrxIkT3GMrbqGvGFPk7e1dLzXev38fK1eurLJ9ypQptW7EKi6d5uTkMB/Pzc3V2c8QCoUC3t7emDx5Mlq0aIGuXbvihRdeqDJOjqWiHg8PjyqPmZmZwcXFRWfbvXv3IAgCMjIymBkZ+hoV26Uau1dBo9Fg7969UCqVePbZZ3UeGzx4MDw8PPDll18iPT0d7u7uRn1tFxcXPP744+jUqRNCQkIwadIkJCQkwNrautrjDH1P1fS+njZtGqytrbF9+/a6/Di1qo117IPMzc2NPqcbefTRYH1CHnDu3Dmo1Wp4eHigadOmAP794N28ebN4hof1Z+/evQAgNkPJycn1UqO/vz/z9esyw3xwcDAA/nidmJgYAEBQUFCtXwMAunTpAkdHR5w+fVqv/SuyT0tLq/KYRqMRm+QH92/Xrl21v6uKMx4AxPnMWK9R3faH6fjx40hOToZWq4W3t7fOxMQWFhZIS0tDWVmZ+B6sD46OjujatSsyMjLw999/17i/oe+pmt7Xv//+O9LT0+Hm5qbz80+dOhVA+bhBhUKBp59+2ui1EVJf6IwYIZVotVqsXr0aADBhwgRxe9euXQGUN2nz5s2r8XlsbW3RunVr/PXXX7h27Rratm1bL/UaU3h4OFavXo3vvvsOEREROo/FxsYiOjoafn5+dZ7gMi8vD7m5uVXuVONp3749fv/9d5w5c6bKa1c0zZXZ2dmhVatW+Pvvv5GdnS0O7q9Ou3btcPToUZw/fx7h4eE6jyUkJODOnTt61Vqf3n//fQDAk08+yTxzV1ZWJk5K/Morrxh10H5lFf+4ePCSMEvXrl1hbW2NCxcuIC8vT+d3rtVq8cMPPwAA91LsgyZNmoTCwsIq22NiYnD27Fm0bdsWHTp00Gs4gLFrI6TWHsI4NEJkA9UM1k9LSxMndPX19a0yoWuvXr0EpVIp7N69m3n8H3/8IaSlpYnfVwz27dq1q5CTk6Ozr1qtFu7evauzTerB+tVN6Dpq1CjmhK4FBQVCVFSUkJCQoLP96tWrzIHyJSUlwqRJkwQAwoQJE/Sq/fz58wIAoVmzZkJWVpa4vaioSOjatStzsH7FgO6nnnqKWUd2drbw22+/id/funVLMDc3F1xdXYXExERxu1arFcaPH89931TML3bq1Cm9fpbaziN2584dwczMTHBycuJOtioIgpjHyZMnxW2GDtaPj4/nzuu1c+dOAYDg4+MjqNVqnceioqKEqKioKsdUTJq6cOFCne3GmNC1Qk2D9Y1VW00TuprS5MJEPuiMGGmQKgbca7VacYmj8+fPo7S0VFziyNXVVeeYQ4cOITw8HNOnT8eWLVvES2xJSUn4448/8Ndff+HSpUvi+JwZM2bg/Pnz2L9/PwIDA/HUU0/Bzc0NycnJOHXqFKZNm6Yz8L9fv35ISEhAXFycURaxPn/+PD744AMA/45di4mJ0VnnsPKAcTMzM+zduxfh4eEYNWoURo0aBV9fX5w8eRJXrlxBjx49sGDBAp3X+OWXX9C3b1+EhYXpXGrct28fdu3ahT59+sDPzw+Ojo64e/cufvjhB6SmpiI4OBgbNmzQ6+fo0aMH5s6di61bt6J169YYNWoULCwscOzYMTg5OTEHok+bNg2//fYbtm/fjmbNmmHgwIHw9fVFdnY24uLicPbsWUydOlWc/qBZs2ZYtWoVlixZgtDQUIwdOxaNGjXCiRMnkJ2djdDQUPzxxx9VXqdiXVJ9zg7VxQcffACNRoNnnnlGZyqOB82YMQM///wz3n//ffHMXkREBD788EPs3bu32jUuK1y9ehUjRoxA9+7dERQUBA8PD2RlZeHnn3/Gn3/+CTs7O3z00UcwMzPTOS4kJAQAdC75AsCaNWtw+vRpbNy4EdeuXUPnzp0RFRWFY8eOwd3dHdu2bTMwDcPJuTZC6IwYaVDwwBQBlpaWgouLi9C+fXthxowZwrfffitoNBru8bm5ucLq1auF9u3bC7a2toKVlZXg7+8vPPHEE8J7770n5OfnVznmwIEDQu/evQUHBwdBpVIJ/v7+woQJE3TOyAhC+b+mAQhxcXFG+Vn1mSqB5e+//xZGjRoluLi4CJaWlkLz5s2FZcuWCYWFhVX25c0Cf/78eWHatGlCy5YtBUdHR/FsTo8ePYT169cLBQUFBv0sFTPrt2jRQrC0tBS8vLz0mln/q6++EoYMGSK4ubkJFhYWgoeHh9CpUydh6dKlzDMk+/fvF9q2bSuoVCrB1dVVmDhxopCcnCy0atVKcHR0rFKTs7Oz4O/vL5SVlen1c9TmjJhGoxF8fHwEAML169erff78/HzB3t5eUKlU4hndyZMnCwCEvXv36lVjQkKCsHDhQqFTp06Cu7u7YG5uLtjZ2Qlt2rQRXnrpJZ0zhpVV957KysoS5s2bJ/j6+goWFhaCp6enMHXqVOHOnTt61VSTms6IGas2OiNG6oNCEB74JwIhhBBRbm4uPDw80LZtW3EaEwD4448/EBoaim3btmH27NkSVkgIMWV01yQhhKB8LrgHlz1Sq9V46aWXUFxcjJEjR+o8dubMGXh4eGDatGkPs0xCyCOGzogRQgiAnTt3YtmyZejfvz98fHzEJZmio6PRvn17XLhwodrxWYQQUhs0WJ8QQlA+v1lYWBguXryI9PR0CIKApk2b4rXXXsOrr75KTRghpF7QGTFCCCGEEInQGDFCCCGEEIlQI0YIIYQQIpEGMUZMq9WitLQUZmZm9bbsByGEEEIIUD55sEajgaWlJZTK6s95NYhGrLS0FBcuXJC6DEIIIYQ0ID169KjxRp8G0YhVLMXRunXrKstyGMuNGzfQokWLenluU0fZsFEufJQNG+XCRrnwUTZsY8eOxZEjR+rt+TUaDf766y+9eo4G0YhVXI40MzOrt0bMzs6u3p7b1FE2bJQLH2XDRrmwUS58lA2bWq1+KLnoMxyKBusbiYeHh9QlyBZlw0a58FE2bJQLG+XCR9mwqVQqqUsQUSNmJLGxsVKXIFuUDRvlwkfZsFEubJQLH2XDVlhYKHUJImrECCGEEEIkQo2YkXh5eUldgmxRNmyUCx9lw0a5sFEufJQNm5yWLKNGzEjUarXUJcgWZcNGufBRNmyUCxvlwkfZsGm1WqlLEFEjZiQZGRlSlyBblA0b5cJH2bBRLmyUCx9lw1ZaWip1CSJqxAghhBBCJEKNmJEEBQVJXYJsUTZslAsfZcNGubBRLnyUDZudnZ3UJYioETOSxMREqUuQLcqGjXLho2zYKBc2yoWPsmGj6SseQcXFxVKXIFuUDRvlwkfZsFEubJQLH2XDRoP1H0HW1tZSlyBblA0b5cJH2bBRLmyUCx9lwyanZZ+oETMSb29vqUuQLcqGjXLho2zYKBc2yoWPsmGjecQeQbdu3ZK6BNmibNgoFz7Kho1yYaNc+CgbtoKCAqlLEFEjRgghhBAiEWrEjIRWuOejbNgoFz7Kho1yYaNc+CgbNpVKJXUJImrECCGEEEIkQo2YkaSlpUldgmxRNmyUCx9lw0a5sFEufJQNW0lJidQliKgRI4QQQgiRCDViRhIYGCh1CbJF2bBRLnyUDRvlwka58FE2bLa2tlKXIKJGzEiSk5OlLkG2KBs2yoWPsmGjXNgoFz7Khk1OKw5QI2YkRUVFUpcgW5QNG+XCR9mwUS5slAsfZcOm0WikLkFEjZiRyGmWXrmhbNgoFz7Kho1yYaNc+CgbNqVSPu2PfCoxcb6+vlKXIFuUDRvlwkfZsFEubJQLH2XDZmNjI3UJIoMbseLiYuTm5ups++STT7B48WKcPHnSaIWZmujoaKlLkC3Kho1y4aNs2CgXNsqFj7Jhy8/Pl7oEkcGN2LPPPot58+aJ32/ZsgXjxo3D22+/jQEDBuCbb74xaoGEEEIIIY8qgxuxX375BYMGDRK/37JlC5555hncv38fI0aMwIYNG4xaoKlwc3OTugTZomzYKBc+yoaNcmGjXPgoGzZLS0upSxAZ3IhlZGTA29sbABAXF4fY2FjMnTsXDg4OmD59Ov766y+jF2kKzM3NpS5BtigbNsqFj7Jho1zYKBc+yobNpAfr29jYICcnBwBw7tw52NnZoWPHjgDK786Q03XXhyklJUXqEmSLsmGjXPgoGzbKhY1y4aNs2Ex6HrHHHnsM27Ztw59//ont27ejb9++UCgUAIDExER4enoa9Hxnz57F0KFD0bhxYygUCnzxxRc1HnPmzBl06NABVlZWCAgIwM6dOw39MQghhBBCJGdwI/b666/jzJkzaNu2La5fv45XXnlFfOzrr79G+/btDXq+goIChIaG4t1339Vr/7i4ODzxxBPo1asXrl69iiVLlmDevHn43//+Z9DrGltAQICkry9nlA0b5cJH2bBRLmyUCx9lwyan6SsMvngcHh6OqKgo/Pbbb2jbtq3OLzk8PBxt27Y16PkGDx6MwYMH673/zp074evri02bNgEAQkJCcOXKFWzYsAEjR4406LWNKS0tDX5+fpK9vpxRNmyUCx9lw0a5sFEufJQNW0lJidQliGo1is/Pz4/5i33++efrXFBNLl26hAEDBuhsGzhwIHbv3o2ysjJYWFhwj+3cubPOcg8Vl1QrCw0NxaFDh3S2TZgwAdevX6+2LrVajXnz5mHOnDnitry8PHTt2rXa4yocPHhQp4n9/vvvsXDhwhqPs7Ozw+XLl3W2LVu2TK8zhAMGDMA777yjsy08PBxpaWk1Hrty5UqMGjVK/D4mJgZPP/00c1+1Wq0zYPTkyZM6l7D37duH9evX1/iagYGBOHbsmM625557DhcuXKjx2EmTJuHVV1/V2daqVasajwOA9957Dz179hS/P3/+vN7v9b///lvn+7feegv79+8HUDWXynr06IFdu3bpbHvqqadw69atGl9z0aJFmDJlivh9amoq+vXrp1e9X3zxBZo3by5+/9lnn2H58uU1Hufh4YGffvpJZ9uCBQvwww8/1HjsyJEjsWrVKp1tTz31FMrKymo8duPGjRg4cKD4/bVr1zBx4sQajwOAn3/+Gfb29uL327Ztw/bt22s8rrafEQAwe/bsOn1GVL7T61H6jHiQoZ8RFf8vPWqfEdXR9zOC9TnzKHxGdOnSRa8x6bzPiKysrBp/v3X5jPjoo49q3K9CrW+nSE9PR0JCAnMdq969e9f2aWuUmpoKDw8PnW0eHh5Qq9XIzMyEl5cX99i0tDQUFhZW+/weHh7IzMxEeno6AKB58+ZITk7Wa8Dj/fv3kZCQgIKCAqhUKri4uOg9ULK0tBSRkZEAAGdnZ2RlZel1rK2tLfLy8nDnzh0A5bMo3717V69jMzIykJqaiuzsbABAy5YtkZycjIyMjBqPLSgowK1bt1BaWgpbW1sUFhbq/bMWFxeLP6uHhwcyMjL0/lnv3bsn7hsQEKD37yY7Oxt37txBXl4ezM3NERQUpHe9JSUliIqKgiAIcHR0RE5Ojt7HFhYWIj4+HgDg7e2N1NRUvY5NS0tDeno6MjMzAQDBwcFISkrS69i8vDzExsaiuLgY1tbWUCqVBv2sFb8bNzc3ZGZm6nWsVqtFTk6OuMCwv7+/3u/DzMxMJCcnIycnB0qlEi1atEBmZmaN/68C5evoRUdHQ61Ww8HBAXl5eQa9Dyv+v/Hy8kJaWppex0r5GVFWVobIyEj6jOCgz4iG8xmRnJxc58+Iml67Lp8RWVlZNe5XweBGLCUlBc8++yxOnTpV5TFBEKBQKOp9Mc0Hz2QJgsDc/iAPD48az4h5enrC1dUVrq6u4jZvb2/xzV4dR0dHnTOFeXl51TaGlVlaWqJly5bi9y4uLnoda2dnB3t7e51jGzdurNexbm5u8PT01PmXp7e3t163O9va2iIwMFD8vrS0VO+f1crKCv7+/jp16HOsl5cXnJyc4OTkpFOvPsc6OzvDx8enyvPpQ6VSISQkRPw+NjZW72NtbGx0fjeenp56Hevh4QF3d3e4u7uL25o0aaLXnT729vY6QwZSU1MN+lkr/2vX1dVV73obNWqERo0aidv0fR+6urrC29tbnBan4tiCgoIaj7W2tkZQUJD4fU3/GKvMyspK53fj4eGh17FSfka0adNGvO2ePiOqos+IhvMZ4e3trdcZMd5nRHZ2Npydnas9ti6fES4uLkhKSqpxXwBQCBVdjJ5GjhyJ06dPIyIiAm3atIFKpaqyT1hYmCFP+W8xCgWOHj1a7enr3r17o127dti8ebO47ejRoxgzZgwKCwuZlybVajXOnDmD0NBQmJmZ1aq2mkRGRur8wsi/KBs2yoWPsmGjXNgoFz7Khm3o0KH46quv6u35NRoNrl+/jrCwsBr/4WLwGbEzZ85gw4YNmDp1aq0LrItu3bpVCe+HH35Ax44dqx0fRgghhBAiNwZPX6FQKKqcvq2L/Px8XLt2DdeuXQNQPj3FtWvXkJiYCACIiIjApEmTxP1nzZqFhIQELFy4EFFRUdizZw92796Nl19+2Wg11YaLi4ukry9nlA0b5cJH2bBRLmyUCx9lw2bSSxyNHj0ax48fN1oBV65cQbt27dCuXTsAwMKFC9GuXTssW7YMQPmYtIqmDACaNm2Kb775BqdPn0bbtm3xxhtvYMuWLZJOXQGAeYmWlKNs2CgXPsqGjXJho1z4KBs2OS1xZPClyTFjxmDmzJnQarUYOnQos9s2ZFLXPn36oLphavv27auyLSwsDL///rver/Ew3L17F46OjlKXIUuUDRvlwkfZsFEubJQLH2XDJqcljmo1oSsAvPvuu9i2bZvOYw/rrklCCCGEkEeBwY3Y3r1766MOk9e0aVOpS5AtyoaNcuGjbNgoFzbKhY+yYTPpJY4mT55cH3WYvMzMTKPexPAooWzYKBc+yoaNcmGjXPgoG7bS0lKpSxDVemZ9AIiOjkZWVhZcXV11JnhriPLy8qQuQbYoGzbKhY+yYaNc2CgXPsqGTa1WS12CqFa3DXz66afw8/NDSEgIevbsiRYtWsDPzw+fffaZseszGfrMNN1QUTZslAsfZcNGubBRLnyUDVtNK/E8TAY3Yt988w3GjRuHRo0aYd26ddi/fz/Wrl2LRo0aYdy4cfj222/ro07Zq7yEAtFF2bBRLnyUDRvlwka58FE2bHZ2dlKXIDK4EVu9ejUGDBiAa9euYdGiRZg4cSJeeeUVXL9+Hf3798ebb75ZH3XKXsUiqKQqyoaNcuGjbNgoFzbKhY+yYZPTJVuDG7Fr165h9uzZVSZDUygUmD17Nq5fv2604gghhBBCHmUGN2JmZmbcuw3KyspkNVvtw1TTKu4NGWXDRrnwUTZslAsb5cJH2bCZ9BJHnTp1wttvv42ioiKd7SUlJdiwYQO6dOlitOJMiZzmJJEbyoaNcuGjbNgoFzbKhY+yYTMzM5O6BJHBjdjKlStx7do1BAQEYN68eVizZg3mzp2LgIAAXL16FStXrqyPOmUvKSlJ6hJki7Jho1z4KBs2yoWNcuGjbNgePJkkJYPva+3Zsyd++OEHLF68GNu2bYMgCFAqlejSpQsOHz6M7t2710edhBBCCCGPnFpNMBIWFoZLly6hsLAQ9+7dg5OTU4M//enn5yd1CbJF2bBRLnyUDRvlwka58FE2bNbW1lKXIKrTyHobGxt4e3s3+CYMAO7duyd1CbJF2bBRLnyUDRvlwka58FE2bGVlZVKXINLrjNj+/fsxZMgQuLi4YP/+/TXuP2nSpDoXZmpyc3OlLkG2KBs2yoWPsmGjXNgoFz7Khk1OSxzp1YhNmTIFP//8M1xcXDBlypRq91UoFA2yEZPTHRhyQ9mwUS58lA0b5cJGufBRNmxyWuJIr0YsLi4OXl5e4tekquDgYKlLkC3Kho1y4aNs2CgXNsqFj7JhM7kljvz8/MTJz/z8/Gr80xBFRUVJXYJsUTZslAsfZcNGubBRLnyUDZtJL3HEcvnyZezcubNB/8IFQZC6BNmibNgoFz7Kho1yYaNc+Cgb+TN4+ooZM2ZArVZj3759AICPP/4YEydOhCAIsLS0xKlTp9CtWzdj1yl7jo6OUpcgW5QNG+XCR9mwUS5slAsfZcNmYWEhdQkig8+InTp1CuHh4eL3q1evxsCBA3Ht2jV0794da9asMWqBpsLBwUHqEmSLsmGjXPgoGzbKhY1y4aNs2MzNazWNar0wuBFLTU0Vx4HdvXsXf//9NyIiItCmTRu8+OKLuHLlitGLNAWJiYlSlyBblA0b5cJH2bBRLmyUCx9lwyanJY4MbsQsLCxQXFwMALhw4QKsrKzQtWtXAICTkxPu379v1AIJIYQQQh5VBjdiLVq0wEcffYS8vDzs3r0bPXr0EK+1JiUlwc3NzehFmgIfHx+pS5AtyoaNcuGjbNgoFzbKhY+yYTPpJY5eeuklHD58GI6Ojjhx4gTmzZsnPnby5Em0adPGqAWaCjndCis3lA0b5cJH2bBRLmyUCx9lwyanmfUNbsRGjx6N8+fPY/369Th9+jSGDh0qPtakSRPMnj3bqAWaCroky0fZsFEufJQNG+XCRrnwUTZsJrfW5IO6devGnKJi5cqVdS7IVMlpuQS5oWzYKBc+yoaNcmGjXPgoG/kz+IzY3bt3cfPmTfF7tVqNt99+G+PGjcOePXuMWpwpCQkJkboE2aJs2CgXPsqGjXJho1z4KBs2e3t7qUsQGdyIPf/889iyZYv4/ZtvvonFixfjhx9+wMyZM3HgwAGjFmgqKjenRBdlw0a58FE2bJQLG+XCR9mw5efnS12CyOBG7Pfff0ffvn3F799//30sWLAA2dnZeO6557Bt2zajFmgqNBqN1CXIFmXDRrnwUTZslAsb5cJH2bDJaekngxuxrKwseHp6AihfTDQlJQVTpkwBAIwcObLBdt80ezEfZcNGufBRNmyUCxvlwkfZsJn0zPqNGjVCeno6AODs2bNwdnbGY489BqB8UGBpaalxKzQRzs7OUpcgW5QNG+XCR9mwUS5slAsfZcNmaWkpdQkigxuxzp0746233sJXX32FzZs3Y8CAAeJjsbGxaNy4sVELNBXx8fFSlyBblA0b5cJH2bBRLmyUCx9lw1ZYWCh1CSKDG7E33ngDsbGxeOqpp5CWloalS5eKj33xxRfo3LmzUQskhBBCCHlUGXyRtG3btkhISMCNGzcQGBioc/159uzZaN68uVELNBXe3t5SlyBblA0b5cJH2bBRLmyUCx9lw2ZlZSV1CSKDz4gBgI2NDdq3b19lEOCQIUMQFBRklMJMjZxWcpcbyoaNcuGjbNgoFzbKhY+yYdNqtVKXINLrjFhiYiK8vLxgYWGBxMTEGvf39fWtc2GmJjs7W7yblOiibNgoFz7Kho1yYaNc+CgbNjndWKhXI9a0aVNcunQJnTt3hr+/f41LJtC8JYQQQgghNdOrEduzZw+aNWsmfk1rV1VFy0jwUTZslAsfZcNGubBRLnyUDZucljjSqxGbPHmy+HXF5K1E161btxrsjQo1oWzYKBc+yoaNcmGjXPgoG7aCggKpSxDVarA+qaqsrEzqEmSLsmGjXPgoGzbKhY1y4aNs2ExusP6DUlNT8b///Q8JCQkoLi7WeUyhUGDz5s1GKc6U2NnZSV2CbFE2bJQLH2XDRrmwUS58lA2bnJY4MriS77//HsOHD6/SgFVoqI2Ym5ub1CXIFmXDRrnwUTZslAsb5cJH2bCZ9BJHixYtQtu2bXHt2jWUlJRAq9Xq/Gmod0zGxcVJXYJsUTZslAsfZcNGubBRLnyUDZucljgy+IzY7du38fnnn6NNmzb1UQ8hhBBCSINh8BmxFi1aIDc3tz5qMWkNdbFzfVA2bJQLH2XDRrmwUS58lA2bSS9xtGrVKqxevRppaWn1UY/JktMsvXJD2bBRLnyUDRvlwka58FE2bCZ91+SQIUPw+++/o1mzZmjbti2cnZ11HlcoFDh27JjRCjQVmZmZcHd3l7oMWaJs2CgXPsqGjXJho1z4KBs2OTWoBjdi+/btw/Lly2FmZoa4uDgkJyfrPE6z7hNCCCGE6MfgRmzlypUYOnQo9u3bBycnp/qoySQFBwdLXYJsUTZslAsfZcNGubBRLnyUDZuc5lczeIxYWloa5s6dS03YA+Lj46UuQbYoGzbKhY+yYaNc2CgXPsqGTU7TVxjciLVr1w5JSUn1UYtJKykpkboE2aJs2CgXPsqGjXJho1z4KBs2OQ3WN7gR++9//4u3334b165dq4dyTJetra3UJcgWZcNGufBRNmyUCxvlwkfZsJmZmUldgsjgMWIzZ85ERkYGOnToAC8vL+Zdk9evXzdagabC09NT6hJki7Jho1z4KBs2yoWNcuGjbNhMeh4xFxcXtG7dGr1790bz5s3h4uKi8+fBxqyhuH37ttQlyBZlw0a58FE2bJQLG+XCR9mwFRQUSF2CyOAzYqdPn66HMgghhBBCGh6Dz4gRNjr9y0fZsFEufJQNG+XCRrnwUTZsKpVK6hJEBjdiP/30Ez799FPx+7S0NDzxxBPw9PTEpEmTUFxcbNQCTYWc7sCQG8qGjXLho2zYKBc2yoWPspE/gxuxZcuWITIyUvz+lVdewblz59C9e3d89tlnWL9+vVELNBXp6elSlyBblA0b5cJH2bBRLmyUCx9lwyanaT0MbsSio6PRvn17AIBarcbRo0fx1ltv4fPPP8eqVatw+PBhg4vYvn07mjZtCisrK3To0AHnzp2rdv+DBw8iNDQUNjY28PLywtSpU5GVlWXw6xJCCCGESMngRiw3NxeOjo4AgN9++w0FBQUYNmwYAKBz585ITEw06PmOHDmC+fPnY+nSpbh69Sp69eqFwYMHc5/n/PnzmDRpEqZPn46///4bn376KX799VfMmDHD0B/FqJo3by7p68sZZcNGufBRNmyUCxvlwkfZsMlpfjWDGzF3d3fExMQAAH788Uf4+fmhSZMmAIC8vDxYWFgY9HwbN27E9OnTMWPGDISEhGDTpk3w8fHBjh07mPv//PPP8Pf3x7x589C0aVP07NkTzz//PK5cuWLoj2JUd+7ckfT15YyyYaNc+CgbNsqFjXLho2zYioqKpC5BZHAjNmjQICxZsgQvvfQSNm7ciKefflp87MaNG/D399f7uUpLS/Hbb79hwIABOtsHDBiAixcvMo/p3r07kpKS8M0330AQBKSlpeGzzz7DkCFDany9vLw85Obmin+MeY24od6koA/Kho1y4aNs2CgXNsqFj7Jhk9NNDAbPI7ZmzRokJibi/fffR+fOnfHaa6+Jjx06dAjdu3fX+7kyMzOh0Wjg4eGhs93DwwOpqanMY7p3746DBw9i7NixKC4uhlqtxrBhw7B169YaX69169Y6C31OnToVc+fOhZeXlzjpnYeHBwRBEAc4Nm/eHElJSSgqKoKVlRV8fHzEM4Lu7u5QKpVITU1FYWEhSkpKkJqaioKCAqhUKvj7++PmzZsAAFdXV1haWuLu3bsAgKZNmyIjIwP5+fmwsLBAYGAgoqKiAADOzs6wtrZGcnIyAMDf3x/Z2dnIzc2FmZkZgoODERUVBUEQ4OjoCHt7e/FfPb6+vsjNzcX9+/ehUCgQEhKCmzdvQqPRwMHBAU5OTkhISAAANGnSBIWFhcjOzgYAtGzZEtHR0VCr1bC3t4erqyvi4uIAAI0bN0ZJSYk4Fq9FixaIjY1FaWkpbG1t4eHhgdjYWACAl5cX1Go1MjIyAJTfJhwbG4vi4mJYW1vD29sbt27dEvMGyu++BYDAwEAkJyeLefv6+iI6OhoA4ObmBnNzc6SkpAAAAgICkJaWhoKCAlhaWiIgIAA3btwAUD7xsEql0sk7MzMTeXl5MDc3R1BQkHjTibOzM2xsbMQ1VP38/HDv3j1u3g4ODuKlcx8fH+Tl5XHzdnZ2Fhfd9fb2RlFRkZi3lZUVYmJiUFZWBjs7O7i5uenkXVpaiszMTABAcHAw4uPjUVJSAltbW3h6eorvWU9PT2i1Wp337J07d8S8mzRpovOeVSgUYt7NmjVDSkoKCgsLoVKp4OfnV23e6enpyM/PZ+ZtZWXFfM8+mLeTkxPs7Ox03rM5OTnIycmBUqlEixYtUFRUhMjISDRq1AiNGjXSyTs/Px/37t2r8p5l5V1cXMx8z9rZ2cHd3Z37ng0KCkJCQgJKSkrEsah1/YyoyLsunxGFhYWIjIx85D4jgoKCkJiYWOvPiIpcHrXPiJCQENy6datOnxEVv79H7TPixo0b0Gq1tf6M0Gg0yMnJqbfPCI1GA30pBEEQ9N67Brm5ubCysoKlpaVe+9+9exfe3t64ePEiunXrJm5fvXo1PvroI/EXWFlkZCT69++PBQsWYODAgUhJScGiRYvQqVMn7N69m/k6arUaZ86cQUBAAJTKf08CqlQqo80lUlZWZvBl2YaCsmGjXPgoGzbKhY1y4aNs2MaNG4ePP/643p5fo9Hg+vXrCAsLg7l59ee8jDqhq4ODg95NGFD+L0AzM7MqZ7/S09OrnCWrsHbtWvTo0QOLFi1CmzZtMHDgQGzfvh179uwRu3Iee3t7ODg4iH+MOaFbxb8mSFWUDRvlwkfZsFEubJQLH2XDZtJLHAFAfHw8PvnkEyQkJFQZ8KZQKLhnph5kaWmJDh064MSJExg+fLi4/cSJE3jqqaeYxxQWFlbpLitWUTfiyT1CCCGEkHpncCP29ddfY8SIEdBoNHB3d69yVkmhUBj0fAsXLsSzzz6Ljh07olu3bti1axcSExMxa9YsAEBERASSk5Oxf/9+AMDQoUMxc+ZM7NixQ7w0OX/+fHTu3BmNGzc29McxGnd3d8leW+4oGzbKhY+yYaNc2CgXPsqGTU5LHBnciC1duhQ9evTAxx9/bJRf8NixY5GVlYVVq1YhJSUFrVu3xjfffAM/Pz8AQEpKis6cYlOmTEFeXh7effddvPTSS3B0dER4eDjeeuutOtdSF4Y2oA0JZcNGufBRNmyUCxvlwkfZyJ/BjVhMTAw+//xzo3bZs2fPxuzZs5mP7du3r8q2uXPnYu7cuUZ7fWNIS0uDi4uL1GXIEmXDRrnwUTZslAsb5cJH2bCZ9BJHfn5+yM/Pr49aCCGEEEIaFIMbsSVLlmDDhg0683GR8rlWCBtlw0a58FE2bJQLG+XCR9mwyWmJI4MvTf7yyy9IT09HYGAg+vbtW+WUp0KhwObNm41WoKlISUkxaFWBhoSyYaNc+CgbNsqFjXLho2zY5LTigMGN2Lvvvit+ffjw4SqPN9RGjM4Q8lE2bJQLH2XDRrmwUS58lA2bITPf1zeDGzE5rc8kJ3K6FVZuKBs2yoWPsmGjXNgoFz7Khq3yKjtSk08lJq5iug1SFWXDRrnwUTZslAsb5cJH2bDZ2NhIXYKIGjEjqVgElVRF2bBRLnyUDRvlwka58FE2bHKa/aFWjdiBAwfQsWNH2NrawszMrMofQgghhBBSM4MbsS+//BJTp05Fu3btUFRUhKlTp2L8+PGwtbVF8+bNsWzZsvqoU/bc3NykLkG2KBs2yoWPsmGjXNgoFz7Khs3S0lLqEkQGN2Lr1q3DwoULsXPnTgDls+IfOHAA0dHR0Gg08PHxMXqRpuDBhcjJvygbNsqFj7Jho1zYKBc+yobNpAfr37x5E/379xfXr1Kr1QAAT09PvPbaa9i4caNxKzQRKSkpUpcgW5QNG+XCR9mwUS5slAsfZcMmp3nEDG7ENBoNLC0toVQqYWtri9TUVPExX19fxMbGGrVAQgghhJBHlcGNWNOmTXH37l0AQGhoqM6krp999hm8vLyMV50JCQgIkLoE2aJs2CgXPsqGjXJho1z4KBs2k56+ol+/fvjxxx8BAC+++CKOHDmCwMBAtGzZEjt37sSsWbOMXqQpSE9Pl7oE2aJs2CgXPsqGjXJho1z4KBu20tJSqUsQGTyKb/Xq1SgpKQEAjB49GmZmZjh48CAUCgVeeeUVTJkyxdg1mgQ5zUkiN5QNG+XCR9mwUS5slAsfZcNWMb5dDgxqxEpLS3HmzBm0aNECDg4OAIARI0ZgxIgR9VKcKZHTrbByQ9mwUS58lA0b5cJGufBRNmwme9ekubk5nnzyScTExNRXPSaLrsPzUTZslAsfZcNGubBRLnyUDZvJjhFTKpVo0qQJcnNz66sek3Xjxg2pS5AtyoaNcuGjbNgoFzbKhY+yYZPTJVuDz81Nnz4d27Ztg0ajqY96CCGEEEIaDIMH61taWuLmzZsICQnBsGHD4OXlJU7uCgAKhQILFiwwapGmwMXFReoSZIuyYaNc+CgbNsqFjXLho2zY5DR2Tq9GLCAgAEePHkVoaCheffVVcTtrFv2G2ohZWVlJXYJsUTZslAsfZcNGubBRLnyUDZucBuvr1YjFx8eLU1bExcXVa0GmKjk5GY0aNZK6DFmibNgoFz7Kho1yYaNc+CgbNjktcWTwpUk/P7/6qIMQQgghpMGRz7k5E+fv7y91CbJF2bBRLnyUDRvlwka58FE2bHKavkLvM2L//e9/4eHhUeN+CoUCmzdvrlNRpig7O1tWv1g5oWzYKBc+yoaNcmGjXPgoGzaTXOLo008/1Wu/htqI0dxqfJQNG+XCR9mwUS5slAsfZcMmpyWO9L40+fPPP0Or1db4p6HOL2ZubvBwuwaDsmGjXPgoGzbKhY1y4aNs2CpPuyU1GiNmJEFBQVKXIFuUDRvlwkfZsFEubJQLH2XDZmdnJ3UJImrEjCQyMlLqEmSLsmGjXPgoGzbKhY1y4aNs2PLy8qQuQUSNGCGEEEKIRPRqxPbu3YtmzZrVdy0mzcnJSeoSZIuyYaNc+CgbNsqFjXLho2zYLCwspC5BpNcovsmTJ9d3HSZPTteb5YayYaNc+CgbNsqFjXLho2zY5HQTA12aNJI7d+5IXYJsUTZslAsfZcNGubBRLnyUDVtRUZHUJYioESOEEEIIkQg1Ykbi6+srdQmyRdmwUS58lA0b5cJGufBRNmzW1tZSlyCiRsxIcnJypC5BtigbNsqFj7Jho1zYKBc+yobNJGfWJ9WjNzsfZcNGufBRNmyUCxvlwkfZsJWVlUldgsjgRqysrAxvvvkmWrZsCVtbW5iZmen8kdOdCA+TUkk9LQ9lw0a58FE2bJQLG+XCR9mwyWmJI4O7poiICLzzzjsYPHgwnn76aahUqvqoy+S0aNFC6hJki7Jho1z4KBs2yoWNcuGjbNjkNK2HwY3YJ598gmXLlmH58uX1UY/JunHjBr3hOSgbNsqFj7Jho1zYKBc+yoYtPz9f6hJEBp+zvHfvHnr37l0ftZg0rVYrdQmyRdmwUS58lA0b5cJGufBRNmyCIEhdgsjgRqx37964du1aPZRi2ho1aiR1CbJF2bBRLnyUDRvlwka58FE2bHJa4sjgRmzLli3YvXs3Pv/8c5SWltZHTSaJ3ux8lA0b5cJH2bBRLmyUCx9lwyanGwsNbsTatm2LW7duYfTo0bCxsYGDg4POn4b6S09MTJS6BNmibNgoFz7Kho1yYaNc+CgbNjktcWRwSzhy5EhZ3fZJCCGEEGKqDG7E9u3bVw9lmD4fHx+pS5AtyoaNcuGjbNgoFzbKhY+yYaMljh5BcroVVm4oGzbKhY+yYaNc2CgXPsqGTU5LHNVqtNrt27exYsUKnDx5EllZWXB1dUX//v2xbNkyNGvWzNg11rvCwkIUFhYCqP1su6WlpcjKyjJmWY8MyoaNcvn3FnIbGxvY2NiI2+/duwcvLy+pypItyoWNcuGjbNjktMSRwY3YjRs30K1bNxQXFyM8PByNGzfG3bt38cknn+D48eO4cOGCSU0el5OTA4VCARcXlzqNfbOxsZHVqU45oWzYKJdygiAgLy8POTk5DfZmH0JIw2VwI7ZkyRK4uLjg9OnTaNKkibg9KSkJ4eHhWLp0Kf73v/8Ztcj6VFZWBldX1zo/D/2FykfZsFEu5RQKBRwcHJCZmSlua9mypYQVyRflwka58FE2bPb29lKXIDJ4jNiZM2ewcuVKnSYMAJo0aYJly5bh1KlTRivuYTDWHaDFxcVGeZ5HEWXDRrnoqvz/YnR0tISVyBflwka58FE2bHIaO2dwI1ZYWAgXFxfmY66urrKam+NhktNyCXJD2bBRLnxyGkgrJ5QLG+XCR9mwyenz1+BGLDg4GAcPHmQ+dvjwYZMaH2ZMZmZmUpcgW5QNG+XC5+DgIHUJskS5sFEufJQNm5xm1je4knnz5mHGjBnIycnB5MmT4eXlhZSUFBw4cABffvklPvjgg/qoU/boL1U+yoaNcuFzdnaWugRZolzYKBc+yobN0tJS6hJEBp8RmzZtGlavXo2TJ09izJgx6NWrF0aPHo0ffvgBq1evxtSpU+ujTtmTat3Ny5cvw9XVFaNGjXqor5uYmAhnZ2f8+eefNe5bn9mUlpZiy5Yt6NWrF7y9vREYGIhBgwbh4MGDRr09ed26dejdu7fRng8wfi4XLlxA37594eXlhXbt2mHv3r16H5udnY1WrVrB2dkZOTk5Rq2rNuLj46UuQZYoFzbKhY+yYauYskoOanVuLiIiArNnz8alS5eQlZUFFxcXdOvWjW49l8DBgwcxc+ZMHDhwAElJSVVuoqgPxm4gSktLa/Wvk9LSUowaNQp//fUXlixZgi5dusDe3h5XrlzBu+++izZt2uCxxx4zaq01KSsrg4WFxUN9TQBISEjA2LFj8eyzz2Lnzp24fPkyFi1aBBcXFwwbNqzG4+fNm4dWrVohJSXlIVRLCCGkQq1n1m/UqBEGDRqEiRMnYtCgQQ2+CZPiL9+CggJ88cUXmDZtGgYMGIBDhw7pPH7+/Hk4Ozvjhx9+QK9eveDl5YX+/fsjMjJSZ7/Lly9jyJAhaNy4MVq3bo3FixejoKBAfDw0NBQbNmzAnDlz4Ofnh/nz56Nt27YAgLCwMDg7O2Po0KEAgKFDhyIiIkLn+adPn445c+ZU+3z61PGgnTt34uLFi/jiiy8wY8YMPPbYY/D398eoUaNw4sQJBAQEACgflLllyxa0a9cOjRs3Rq9evXDs2LEqOZ05cwbh4eHw9vbGwIEDERMTAwA4dOgQ3n77bfz1119wdnaGs7OzmLWzszP27t2LiRMnokmTJtiwYQMA4LvvvtM5O/XWW29VGTRrzPfM3r174e3tjbVr1yI4OBiTJk3CxIkT8e6779Z47J49e5CTk4MXXnihymOsM4E7duxAaGio+P2cOXPwzDPPYOPGjQgODoa/v7/48y5btgwBAQFo1aoVDhw4oPfP4+3trfe+DQnlwka58FE2bFZWVlKXINLrjFhiYiK8vLxgYWGh10ruvr6+dS5MSnO+uIF7hYbdaSJAgAJ1mwrDycYc257W/2aHo0ePonnz5mjevDnGjBmDV199FYsWLaoyJceyZcuwdu1aeHh44I033sCECRPw66+/wsLCApGRkRg9ejQiIiKwZcsWZGZm4tVXX8Urr7yCbdu2ic+xdetWvPzyy3jppZcAADNmzED//v1x9OhRtGjRwuAzWg8+n751VPbpp58iLCwMbdq0qfKYhYWF2OisXr0aX331FTZs2IBmzZrh4sWLmDVrFlxdXdGjRw/xmDfffBNvvPEGXFxc8NJLL2Hu3Ln47rvvMHz4cERFReHkyZM4evQoAN0BsOvWrcPrr7+O1atXw8zMDCdPnsTzzz+PdevWoVu3boiLi8OCBQsAAK+++qp4XOW7dj799FMsXLiw2sw2btyI0aNHMx/79ddf0bdvX51t4eHhOHDgQLVn6W7cuIH169fjxIkTdbqEcfbsWTRu3BjHjx/H5cuXMW/ePPz666/o3r07Tpw4gaNHj+Kll15Cnz599DprW1xc3OD/ccdCubBRLnyUDZtWq5W6BJFejVjTpk1x6dIldO7cGf7+/jXOvaXRaIxSnFTuFaqRWSif5Q94Dhw4IP7F3K9fPxQUFODMmTPo06ePzn6vvPKK+Jf09u3b0bp1axw/fhzDhw/H1q1bMXLkSPznP/8BADRr1gzr1q3Dk08+if/+97/ivxp69+6NuXPnis9Z0ZA7OzvDw8Oj2jpZtwk/+Hz/+c9/9KqjstjYWJ1GiqWgoADbt2/HF198gc6dOwMA/P398fPPP2Pfvn06x7/22mvi9/Pnz8fYsWNRXFwMa2tr2NrawtzcnPmzjhw5Es8884z4/axZszB//nyMHz9efL0lS5ZgxYoVOo2YWq0WG6RBgwahQ4cO1f4sbm5u3MfS09Ph7u5eZX+1Wo2srCx4enpWOaakpAQzZ84U5wWsSyPm5OSEdevWQalUonnz5ti6dSuKiorE5nLBggXYvHkzLl++rFcjlpWVVeP7qiGiXNgoFz7Khk2qcd0sejVie/bsEdeQ3LNnj9EmQa2wfft2rF+/HikpKWjVqhU2bdqEXr16cfcvKSnBqlWrcODAAaSmpqJJkyZYunQppk2bZpR6nGwMHzonCEKdczHkdWNiYvD7779j//79AMpvxR0+fDgOHjxYpRGraECA8r8wAwMDxUn+rl27hri4OHz22WfiPoIgQKvVIiEhAcHBwQAgXoo0lgefT986KtMn85s3b6K4uBgjR47U2V5aWlpl/FirVq3Erys+uDIzM2tsHNq1a6fz/fXr13H16lVs3LhR3KbRaFBcXIzCwkKdNRUr2Nvb13mm5wezqGiAeRmtWrUKQUFBGDNmTJ1eFwBatGgBpfLfkQ5ubm4ICQkRvzczM4OTk5PO7PmEEEL0bMQmT54sfj1lyhSjFnDkyBHMnz8f27dvR48ePfDee+9h8ODBiIyM5F7iHDNmDNLS0rB7924EBgYiPT3dqJPWGXJ5sIIxGjFDHDhwAGq1Wqd5EAQBFhYWuH//PhwdHas9vqJWrVaLKVOm4LnnnquyT+UGhNU8sCiVyipnwFingB98Pn3rqKxZs2Y1zhpd8doff/xxlYVvH7ycWvnyXeV8asL6WRYvXownn3yyyr6Vz+xV/rqulybd3d2Rlpamsy0zMxPm5ubc29fPnTuHyMhIfPnllwD+bdwCAwOxcOFCREREMH+frLtRH7z0qVAoqszTo1Ao9L4c0FDnI6wJ5cJGufBRNmx2dnZSlyAy+NTPtGnT8Prrr6Np06ZVHktISMDKlSuxZ88evZ9v48aNmD59OmbMmAEA2LRpE77//nvs2LEDa9eurbL/d999hzNnziA2Nlb8C8bf39/QH8PoSkpKHtrgP7VajSNHjuCNN96oMi5oypQp+PTTTzFz5kxx26+//io2M/fv38ft27fRvHlzAOUD52/cuCEObNdXxV+8D16GdnFx0WkINBoNIiMja5z6oTZ1jBo1Cm+88Qb++OOPKuPE1Go1SkpKEBwcDJVKhaSkpBovY1bH0tJS70vubdq0QUxMTI0/S+X3TF0vTXbq1AnfffedzrZTp06hbdu23PFhH374oc5KGFevXsXcuXPx9ddfi/9/u7q6Ij09XecfGn/99Ve1dRpDbGwsAgMD6/11TA3lwka58FE2bHKavsLguyb37duHjIwM5mOZmZn48MMP9X6u0tJS/PbbbxgwYIDO9gEDBuDixYvMY7788kt07NgRb7/9Nry9vREUFISXX35Zr6WV8vLykJubK/4pKSnRu9aaPMzlEr7//nvcv38fzz77LFq2bKnzZ9iwYVXuTlu/fj3OnDmDyMhIzJkzB87OzhgyZAgA4MUXX8Svv/6KRYsW4c8//8Tt27fx7bff6oxlYnFzc4O1tTVOnjyJ9PR05ObmAigf+3XixAn88MMPiI6Oxssvvyw+Vp3a1DFr1ix06dIFTz/9ND744AP89ddfiI+Px9GjR/H4448jNjYW9vb2eOGFF7B06VIcPnwYcXFx+OOPP/DBBx/g8OHDNdZVwdfXF4mJifjzzz+RlZVV7Xtn0aJFOHLkCNatW4eoqCjcvHkTn3/+OVavXq2zX+X3jL29PQICAqr9U92ly6lTpyIpKQlLly7FzZs3ceDAARw4cEDnTsjjx4+jS5cu4vdNmzbVee/4+fkBKF89o6Lp69GjBzIzM7FlyxbExcXhgw8+wI8//qh3brUlp/EbckK5sFEufJQNm8kN1tdXdnY2VCqV3vtnZmZCo9FUGUjo4eGB1NRU5jGxsbE4f/48rKyscPToUWRmZmL27NnIzs6u8Uxc69atdbrgqVOnYsGCBdBqteJfrBYWFhAEQbzUqVKpUFZWBq1WC6VSCQsLC3Ffc3NzKBQK8XGtVit+rVAooFKpxIWdK+/74PPWtG/F2RiNRgOFQoEDBw6gZ8+esLCwQGlpKczMzMT/2Z544gls3LgRv/zyi1hnREQEFi9ejLi4OLRq1Qp79uwRny8oKAifffYZ3nrrLQwZMgRarRZ+fn54+umnxVwqxmqVlZWJuVhZWWHVqlV45513sHbtWnTt2hWffvopRowYgT/++AP/+c9/YGZmhpkzZ6J79+7QaDQoKioSxxGVlZWhqKhIPFsTEBCAzz77DOvXr8cTTzwBQRDg7++P4cOHi002K8PDhw/jvffew969e7Fs2TJYWVmhefPmmD59Opo3b46ioiIsWLAALi4ueOedd5CQkAAHBweEhoZizpw5KCoqEn+moqIiWFpawtLSUnyNigz79++PsLAwDBs2DDk5Odi4cSPGjh0LoPzsW0WN1tbW6NGjBz788ENs2rQJW7duhbm5OQIDA/HMM8/oZKhUKlFcXAxBEKq8tx58H1pZWYm/C9a+jRs3xv79+7FixQrs3r0bHh4eWLVqFQYOHCj+HjMzMxETEwO1Ws18H1a8hypyMDc3R7NmzbBmzRps3boVGzZswBNPPIHnn38eBw8ehCAIKC4uhlqthlar1XneivdMUVERFAoFrKysIAgCysrKqrxnK97f+fn5yMjIQIsWLVBcXIzIyEg0atQIjRo1Em8O8fHxQX5+Pu7duwcAaNmyJaKjo6FWq+Hg4ABnZ2fxpgNvb28UFxcjKysLQPklmtjYWJSWlsLOzg7u7u6IjY0FAHh5eUGtVov/yAwKCkJCQgJKSkpgY2MDLy8v3L59G0D555MgCEhPTwcANG/eHElJSSgqKoKVlRV8fHzEqU/c3d2hVCrFz7NmzZohNTUVBQUFUKlU8Pf3x82bNwGUn320tLTE3bt3AZQ3yhkZGcjPz4eFhQUCAwNRVFSEyMhIODs7w9raGsnJyQDKrwpkZ2cjNzcXZmZmCA4ORlRUFARBgKOjI+zt7XHnzh0A5f+oyM3Nxf3796FQKBASEoKbN29Co9HAwcEBTk5OSEhIAFA+LKCwsBDZ2dlV8ra3t4erqyvi4uIAAI0bN0ZJSQkzb1tbW3h4eFSbd2JionhzjLe3N27duiXmDUA80x4YGIjk5GQxb19fXzEXNzc3mJubi/PhBQQEIC0tDQUFBbC0tERAQABu3LgBoPzsvUql0sk7MzMTeXl5MDc3R1BQkDjVj7OzM2xsbJCUlAQA8PPzw71797h5Ozg46Lxn8/LyuHk/+J4tKioS8w4JCcGtW7dQVlYGOzs7uLm56eRdWloqjrsMDg5GfHw8SkpKYGtrC09PT9y+fVt8Pq1Wq/OevXPnjph3kyZNdN6zCoVCzLtZs2ZISUlBYWEhVCoV/Pz8xCEhrLzT09ORn5/PzNvKyor5nn0wbycnJ9jZ2em8Z3NycpCTkwOlUokWLVrgxo0b0Gq1tf6M0Gg0yMnJqbfPCENuWlQIepzKOXv2LE6fPg0AWLFiBWbMmFFl3E5RURGOHTsGGxsbXLlyRa8Xv3v3Lry9vXHx4kV069ZN3L569Wp89NFH4i+wsgEDBuDcuXNITU0Vb8n9/PPPMWrUKBQUFMDa2rrKMWq1GmfOnEFAQIDOgGKVSoX8/HzuIuaGqGjU5OT8+fMYNmwY4uLiJL19WY7ZyAHloqticmig/JZ7Oc3zIxeUCxvlwkfZsI0dOxZHjhypt+fXaDS4fv06wsLCalzXUq8zYqdOncLKlSsBlA+45a0n6efnx53zicXV1RVmZmZVzn6lp6dzb7f18vKCt7e3TmMREhICQRCQlJQkjn1isbe3r7K+X35+vt71VqekpITZBBLKhody4YuNjUXLli2lLkN2KBc2yoWPsmEzuTFir7zyCjIyMsRBu99//z0yMjJ0/uTm5iIuLq7K4PHqWFpaokOHDjhx4oTO9hMnTqB79+7MY3r06IG7d+/qNFDR0dFQKpUPZXkfQgghhBBj0euMmLW1tfgv97i4ODRu3Nhoy7MsXLgQzz77LDp27Ihu3bph165dSExMxKxZswCUj29KTk4W58uaMGEC3njjDUydOhUrV65EZmYmFi1ahGnTpkl6dkGKJY5q0rNnT3GsgZTkmI0cUC58D041QspRLmyUCx9lwyany7UGD9avuLPKWMaOHYusrCysWrUKKSkpaN26Nb755hvxdVJSUnSWVbKzs8OJEycwd+5cdOzYES4uLhgzZgzefPNNo9ZlqId516SpoWzYKBc+Y84L+CihXNgoFz7Khs3k75o8e/YstmzZgqioqCrTRigUCvHOAX3Nnj0bs2fPZj62b9++KttatGhR5XKm1CovV0N0UTZslAtfRkZGtfOmNVSUCxvlwkfZsMlpWg+Db9k6f/48+vXrh5ycHERFRaFFixbw9vZGYmIizM3Na5y4kxBCCCGElDO4EVu+fDmmTp0qzuL95ptv4ty5c/j999+Rn5+PESNGGL1IUyCn681yQ9mwUS58QUFBUpcgS5QLG+XCR9mwyWmJI4Mbsb/++gvDhw8XlzupmLSsTZs2eP3117Fq1SrjVmgijDlL/6OGsmGjXPgqJhQluigXNsqFj7JhM7npKyorLCyEnZ0dlEolVCqVOKsvUD52q2Jm3IaGBl7zUTZslAsfNalslAsb5cJH2bDJabC+wY2Yr6+vuPRBy5Yt8fXXX4uPnTlzxiiz1JsimiGd71HOZt26dbUeF1k5l0OHDsli8Xq5sLGxkboEWaJc2CgXPsqG7cHJ3aVk8N+Qffr0EZc7mjlzJrZv345+/frhiSeewJtvvonx48cbu0aT8LDvfqtYvHvTpk0627/++ms4Ozsb5TWKiorQtGlTBAQEMBdVDw0NhbOzM5ydndG4cWOEhoZi6tSpOHv2rM5+lbNJTEwUj+H9WbdunVHqfxheeOEFfPHFF7U6tnIuw4cPx6+//mqkqkwfzX3ERrmwUS58lA2bnMboGtyIrVy5EvPmzQMAzJo1Cxs2bMD9+/eRnp6O1157TfL5vKQixelfKysrbN68Gffv36+X5//qq68QEhKC4OBgHD9+nLlPREQEoqKi8Msvv2DHjh1o1KgRhg8fjv/+97/iPpWz8fb2RlRUlPhnzpw5aNGihc62F154Qdy/8sLXcmRnZ1frxrdyLtbW1nSLeSWGToHTUFAubJQLH2XDVlBQIHUJIoMaMY1Gg+zsbLi7u4vbFi5ciN9++w1XrlzBihUraF6khygsLAzu7u545513qt3vyy+/RLdu3eDp6YnQ0FC8++67ej3/gQMHMGbMGIwZMwYHDhxg7mNnZwcPDw80adIE3bt3x6ZNm/Dyyy9j7dq1iImJqbK/mZkZPDw8xD+2trYwNzcXv4+JiYGvry9OnjyJ8PBweHp64tKlS4iLi8PEiRMRHBwMHx8f9OvXTzwzWyE0NBQbN27ECy+8AF9fXzz22GM689CVlpbilVdeQUhICLy8vBAaGqqTnbOzM/bt24dx48bB29sbXbp0wS+//ILY2FgMHToUTZo0wYABAxAXFyce8+ClyfPnz6N///5o0qQJ/P39MWjQINy5cwdA+Y0uw4YNg6+vL3x9fTFo0CBcvXoVAPvS5J49e9C+fXt4eHigc+fOVRaodXZ2xv79+/Hss8/C29sbHTt2xLfffsv/hRJCCJEdgxoxQRDQsmVLXLp0qb7qkY1t27ahVatWNf6ZMGECAN3LTBMmTNDrWEMWSGcxMzPD66+/jvfffx/JycnMfa5du4Zp06ZhxIgROH/+PF599VWsXbsWhw4dqva54+Li8Ouvv+Lpp5/G008/jV9++QXx8fF61TVr1iwIgiA2BbVpzlesWIHXX38dP//8M1q1aoWCggI8/vjjOHr0KE6fPo3w8HBMmDABSUlJOsdt27YN7dq1w+nTpzF9+nS8/PLLiI6OBgC89957+Pbbb7Fnzx788ssveO+99+Dr66tz/Pr16zF27FicOXMGQUFBeO6557Bw4ULMnz8fJ0+eBFC+9iqLWq3GM888g+7du+PcuXP4/vvvMXnyZPEO4+eeew6NGzfGjz/+iFOnTuHFF1/kZnP8+HFERERgzpw5uHDhAiZPnowXXngB586d09nv7bffxtNPP41z586hf//+eP7553Hv3j2D85YbDw8PqUuQJcqFjXLho2zYVCqV1CWIDJpZ39zcHJ6enrK626C+5OXlISUlpcb9vL29AejeAZeZmanXsXl5ebUv8B9PPvkkWrdujXXr1mHr1q1VHt++fTt69+6NRYsWAQACAwNx8+ZNbN26VWwiWQ4ePIj+/fvD0dERANCvXz8cPHgQS5curbEmJycnuLm5iUtT1ebuwIiICJ0F5J2dndG6dWvx+6VLl+L48eP49ttvMXPmTHH7448/junTpwMAXnzxRezYsQMXLlxAUFAQkpOT0axZM3Tt2hUKhQI+Pj5VXnfChAkYPnw4AGDevHkYOHAgXn75ZfTr1w8A8Pzzz2Pu3LnMmvPy8pCbm4uBAweiadOmAIDg4GDx8aSkJMydO1ec18fX15fbiL377rsYP368+LMEBgbiypUrePfdd9GrVy9xv/Hjx2PkyJEAIDblv/32G/r37898XlNBd5SyUS5slAsfZSN/Bo8RGzdunLgA96PM3t4eXl5eNf5xdXUFoLuel6urq17H2tvbG6XWFStW4OOPP8aNGzeqPBYdHY0uXbrobOvSpQtiY2PFOeAepNFocPjwYYwePVrcNnr0aBw+fJh7zIMEQRDPBNVmjFfbtm11vi8oKMDy5cvRtWtX+Pv7w8fHBzExMVXOiLVs2VL8WqFQwN3dHRkZGQDKm5Y///wTnTt3xuLFi/HTTz9Ved1WrVqJX1dcgq/8nO7u7iguLkZubm6VY52cnDB+/HiMGjUK48ePx86dO5Gamio+Pnv2bLz44osYPnw4Nm3ahFu3bnF/ft7vreLsHqteW1tb2NnZ6UwpY6rS09OlLkGWKBc2yoWPsmGT07QeBq812bZtWxw5cgTh4eEYMWIEvLy8xL9wKzwKs+vPmTMHc+bMqdWxNV32M7bu3bsjPDyceddq5Yao8rbq/PTTT0hJSRHPxlTQaDT46aef8Pjjj1d7fHZ2NjIzM6tc9jOEra2tzvfLly/HTz/9hFWrViEgIABWVlaYMmVKlfXCHjzDpFAoxDO4oaGhuHr1Kn788UecOXMG06ZNQ1hYGD788EPm8RW5sbbxMty2bRuef/55nDx5EkePHsWaNWvwv//9D506dcLixYsxatQo/PDDD/jxxx+xbt06fPDBB3jyySeZz8X6vT24rbqflxBCiPwZ3IhNmjQJAJCcnFxlsDRQ/heBvmdNHiVSX29evnw5evfujWbNmulsDw4Oxs8//6yz7ZdffkGzZs2486h89NFHGDFiBBYuXKizffPmzThw4ECNjdjOnTuhVCoxZMgQAMbJ5tKlSxg/frzYtOTn5yMxMRE9evQw6HkcHBwwYsQIjBgxAsOGDcPo0aNx7949ODk51bnGCm3atEGbNm2wYMECDBgwQGzEgPJLjIGBgZg9ezamT5+OQ4cOMRuxoKAg/Pzzzxg3bpy47Zdffmkwy5U0b95c6hJkiXJho1z4KBu2B/+xLyWDG7FTp07VRx0mr6ysTNJmrGXLlhg9ejTef/99ne1z5sxBv379sH79enGuqg8++ADr169nPk9mZia+//57HDx4UOeSHFB+WXrcuHHIzMwUL8nm5+cjLS0NZWVlSExMxCeffIKPPvoIy5YtQ0BAAADjZBMQEIDjx49j0KBBUCgUWLNmjcFnfrZv3w4PDw889thjUCqVOHbsGDw8PNCoUaM61VYhISEBH374IQYNGgQvLy/ExMTg9u3bGDduHIqKirB8+XIMGzYMfn5+SE5OxtWrVzFs2DDmc82dOxfTpk1DaGgoevfuje+++w7Hjx/H0aNHjVKr3CUlJYnj7Mi/KBc2yoWPsmErLi6WugSRwY1YWFhYfdRh8uRwOWjJkiVVJhcNDQ3Fnj17sHbtWmzYsAEeHh5YvHgxd6D+xx9/DBsbG+bvuVevXrCzs8ORI0fEy7Zr167F2rVrYWlpCXd3d3Ts2BFffPGFzoByY2SzevVqzJ07F4MGDYKzszNefPFFg292sLW1xZYtWxAbGwulUon27dvjyJEjRpv539raGjExMfj444+RnZ0NDw8PzJgxA1OmTIFarUZ2djb+85//ICMjAy4uLhg0aBAWL17MfK4hQ4Zg7dq12Lp1KxYvXgw/Pz+8++676Nmzp1FqlTvWBMKEcuGhXPgoGzY5XblTCA3glgq1Wo0zZ84gNDS0yuW4rKwsoyzLVFJSIvnlSbmibNgoF12V/1+MjY0Vz6iSf1EubJQLH2XD9tRTT+HYsWP19vwajQbXr19HWFgYzM2rP+dl8Bmx8PBw7mNKpRKOjo7o1KkTpk2b1qBmCqeJbPkoGzbKhY81tQihXHgoFz7Khs3a2lrqEkQGX5PRarW4efMmTp8+jfj4eBQVFSEuLg6nT5/GjRs3cPv2bSxfvhyPPfYYc2b1R5WcboWVG8qGjXLha0ifHYagXNgoFz7Khs1klzgCgNdeew0WFha4dOkSYmNjxeVnLl68CDMzM6xZswZRUVGws7PDa6+9Vh81E0IIIYQ8EgxuxJYsWYJly5ZVmWyya9euWLZsGZYsWYKmTZti0aJFDeoOy5quATdklA0b5cJXeT1b8i/KhY1y4aNs2OQ0PtfgRuzPP//kXnP28fERZ3dv0aIFcnJy6ladCXlwok3yL8qGjXLhM9adrI8ayoWNcuGjbOTP4N+Qh4cHdy6jo0ePit13bm6uuE5hQ1BWViZ1CbJF2bBRLnyVl4Yi/6Jc2CgXPsqGTU5jdA2+NvLcc8/htddeQ05ODkaPHg0PDw+kpaXhyJEj+OSTT/Dmm28CAC5evIg2bdoYvWBCCCGEkEeFwY3YkiVLkJ+fj3feeQcff/wxgPI18FQqFRYvXoyIiAgA5Qssz5gxw7jVypicrjfLDWXDRrnwPbhUFylHubBRLnyUDZtJL3EEAGvWrMErr7yCS5cuITs7Gy4uLujSpYvOen0N7WyY1EscyRllw0a58KWmpsLPz0/qMmSHcmGjXPgoGzY5LXFU61F8jo6OGDx4MCZOnIhBgwYZddFkUySHJY5q6/z583B2dq725opDhw7B39+/Vs9vytnUJ8qFT05z/MgJ5cJGufBRNmxyWuKoVo1YRkYGIiIi0K1bNwQFBeHvv/8GALz33nu4evWqUQs0FVLcAZeWlobFixejQ4cO8PLyQnBwMAYPHoy9e/eisLBQ7+fp3LkzoqKi4ODgUC91GjObCxcuoG/fvvDy8kK7du2wd+9evY/Nzs5Gq1atmE2nIAjYunUrOnXqBE9PT7Ru3RobN240Wt0sdNckH50pZKNc2CgXPsqGTU53kxp8aTIuLg49evRATk4OQkNDcfv2bfHugz/++AM///yzQX85Pioe9ps9Pj4egwcPhoODA1577TW0bNkSGo0Gt27dwsGDB+Hp6YnBgwfr9VyWlpbw8PCot1qNlU1CQgLGjh2LZ599Fjt37sTly5exaNEiuLi4YNiwYTUeP2/ePLRq1QopKSlVHouIiMCpU6ewatUqtGzZErm5ucjKyjJK3Tz0AclX27OvjzrKhY1y4aNs2GxsbKQuQWRwS/jKK6/A0dERMTExOHv2LCqvGd6zZ09cuHDBqAWaiod9vfnll1+GmZkZfvrpJwwfPhzBwcFo2bIlhg0bhiNHjmDQoEEAgMTERDg7O+PPP/8Uj83JyYGzszPOnz8PgH1p8tChQ3jsscfg7e2NZ599FtnZ2VVq+O6773TOTr311ltQq9VV9jNWNnv37oW3tzfWrl2L4OBgTJo0CRMnTsS7775b47F79uxBTk4OXnjhhSqP3bx5E3v27MGBAwcwePBg+Pn54bHHHkOfPn3EfebMmYNnnnlG57iIiAgMHTpU/H7o0KF49dVXERERgaZNmyI4OBj79u1DQUEB5syZA19fX7Rv3x4nTpwAIK8xCnJz8+ZNqUuQJcqFjXLho2zY8vPzpS5BZHAjdvLkSSxfvhyNGzeucmnFy8sLd+/eNVpxhC07OxunTp3CjBkzuHd+1OWy15UrVzB37lxMnz4dZ86cQc+ePfHf//5XZ5+TJ0/i+eefx3PPPYdLly5h48aNOHz4cJX9Kvv000/h4+NT7Z9PP/2Ue/yvv/6Kvn376mwLDw/HtWvXqp2T68aNG1i/fj127NjBPB39/fffw9/fH99//z3atm2L0NBQzJs3D/fu3eM+J8/hw4fh4uKCH3/8ETNnzsTLL7+MqVOnonPnzjh16hTCw8Pxn//8x6BLx4QQQh5dBl+aLC4uhrOzM/OxgoICWV13rYuXXnqJeQmLR6vV1uln9/LyqraJqSw2NhaCICAwMFBne2BgoHiZePr06VixYkWtannvvfcQHh6O+fPni8/7yy+/4OTJk+I+GzduxPz58zF+/HgA5ae/lyxZghUrVuDVV1/Veb6KpXwGDRqEDh06VPvabm5u3MfS09OrLNfh5uYGtVqNrKwseHp6VjmmpKQEM2fOxMqVK9GkSRPEx8dX2Sc+Ph537tzBsWPHsGPHDmg0GixduhRTpkzBsWPHqq33Qa1bt8bLL78MAFiwYAE2b94MFxcXTJ48GQCwaNEi7NmzB3///Tfatm1r0HM3JK6urlKXIEuUCxvlwkfZsFlaWkpdgsjgRiw4OBg//vgjHn/88SqPnT17Fq1btzZKYVLTtymqoFarH/ragQ+e9frxxx+h1Wrx3HPP1WnW4OjoaAwZMkRnW6dOnXQasevXr+Pq1as6A9o1Gg2Ki4tRWFioc/29ok57e3vY29vXuq7Kz1Wh4tI47wzgqlWrEBQUhDFjxnCfU6vVoqSkBDt27BCb2y1btqBv376IiYlB8+bN9a6vVatW4tdmZmZwcnJCSEiIuK2ikczMzKTB+tWQ04eknFAubJQLH2XDJqeTRgZ3DjNnzsTChQvRuHFjTJw4EQBQWlqKzz77DNu3b9drvM6jqKys7KE1YgEBAVAoFIiJidHZXjEo09raWtxW8WarPJavpqV1Ku/Lo9VqsXjxYjz55JNVHrOystL5viKbTz/9FAsXLqz2eTdu3IjRo0czH3N3d0daWprOtszMTJibm3PP0p47dw6RkZH48ssvAfz7swUGBmLhwoWIiIiAh4cHzM3Ndc4wBgUFAQCSkpLQvHlzKBSKKrmwxsM9+B5QKBSwsLDQ+R4oz+9hvmdMzd27dxvUEmn6olzYKBc+yoZNTmN0Df5bYPbs2bh27RoWLFiAl156CUD5IH1BEDBz5kzxEgypP87OzujTpw/ef/99zJw5s9oZgl1cXABAp4GpPHCfJTg4GFeuXNHZ9uD3bdq0QUxMDAICAvSuu66XJjt16oTvvvtOZ9upU6fQtm1bnWansg8//BBFRUXi91evXsXcuXPx9ddfo2nTpgCALl26QK1WIy4uTtx2+/ZtABAXuHd1dRUXtK/w559/cl+XEEII0Uet/jm+a9cuTJs2DV9//TXS0tLg6uqKJ598Et27dzd2fSbjYU9FsGHDBgwePBjh4eF49dVX0apVKyiVSly9ehUxMTEIDQ0FUH52rGPHjti0aRN8fHyQnZ2N1atXV/vczz33HAYNGoQtW7bgiSeewKlTp3QuSwLlY53Gjx8Pb29vPPXUU1Aqlfj7778RFRWFpUuX6uxbkU1dL01OnToVH3zwAZYuXYpJkybh119/xYEDB/D++++L+xw/fhxvvPEGLl++DABiY1Wh4u7P4OBgNGrUCADQp08fhIaGYu7cuVizZg20Wi0WLVqEPn36iGfJevXqha1bt+Ljjz9Gp06d8MknnyAqKqpOK0jQ9BV8D/7eSDnKhY1y4aNs2Ex6+orExESUlZWha9eueOONN7Br1y6sWbMG3bt3h1qtRmJiYn3UKXs1Xe4ztqZNm+L06dPo06cP3njjDfTu3Rv9+vXDrl27MGfOHCxZskTcd+vWrSgrK0O/fv0QERFRpVF6UKdOnbB582bs2rULYWFhOHXqlHj2s0K/fv1w+PBhnD59Gv3798eAAQOwfft2NGnSpMrzGSsbPz8/HDlyBBcuXEBYWBg2bNiAdevW6cwhlpubW+WSbU2USiUOHToEZ2dnPPnkkxg3bhyCgoKwe/ducZ9+/frh5ZdfxooVK9CvXz/k5+dj3Lhxdfp5HvZ7xpRkZGRIXYIsUS5slAsfZcNWWloqdQkihaDPgKBKzMzMcOnSJXTu3LnKY7/99hs6d+4sq6UDgPKxPGfOnEFoaCjMzMx0HsvKyhIv39VFUVGRztgs8i/Kho1y0VX5/8XIyEi0bNlS4orkh3Jho1z4KBu2oUOH4quvvqq359doNLh+/TrCwsJqHAts8Bmx6vo2jUbTYO8Ea6g/tz4oGzbKhY/G3rFRLmyUCx9lwyanuyZrVQnrL5CSkhJ8++23DXbOEhrvw0fZsFEufA/OkUfKUS5slAsfZcNW3U1uD5tejdjKlSthZmYGMzMzKBQKdO3aVfy+4o+NjQ1WrVqFp556qr5rliU53QorN5QNG+XCFxUVJXUJskS5sFEufJQNW15entQliPS6a7Jz586YPXs2BEHA9u3bMWrUqCqLRKtUKjz22GOYMGFCvRRKCCGEEPKo0asRGzx4MAYPHgygfBmjZcuWPTK3xBp4rwIXTczJR9mwUS66Kv+/yJugt6GjXNgoFz7Khk1OKw4Y/DfB3r1766MOySgUijqvE1nxPISNsmGjXP6l1Wp18qC7SdkoFzbKhY+yYZPTYP1a/ZM8Ly8P3377LRISEnRmLQfK/3J5/fXXjVLcw2Bvb4/s7Gw4OzvX6RdDy9XwUTZslEs5rVaL7OxsODg4iNuSk5PFCXfJvygXNsqFj7Jhk9MYXYP/Frh8+TKGDBkizlD+IFNrxCwtLeHg4IB79+5BEIRan6XIz8+HnZ2dkat7NFA2bJQLxP/nHBwcZHWpgBBCHhaDG7EFCxbA29sb3333Hdq0afNIfHhaWlrWeVJXa2trWS2ZICeUDRvlwlexgD3RRbmwUS58lA2bnD57Db4W9+eff+LNN99Ex44dH4kmzFh4ZwgJZcNDufBRNmyUCxvlwkfZsMlpiSODGzE3N7f6qMPk5ebmSl2CbFE2bJQLH2XDRrmwUS58lA2bWq2WugSRwY3Y3LlzsXPnTqNN+/CoeHANS/IvyoaNcuGjbNgoFzbKhY+yYZPTXesGjxHTarW4ceMG2rVrhyFDhlQZW6VQKLBgwQKjFWgqgoODpS5BtigbNsqFj7Jho1zYKBc+yoZNTjdKGdyILVq0SPz6jz/+qPJ4Q23EoqKiEBISInUZskTZsFEufJQNG+XCRrnwUTZsJrfEUWVxcXH1UYfJo0u1fJQNG+XCR9mwUS5slAsfZSN/Bjdifn5+9VGHyXN0dJS6BNmibNgoFz7Kho1yYaNc+CgbNgsLC6lLEMlnjn8TZ29vL3UJskXZsFEufJQNG+XCRrnwUTZsclrVRK9Khg0bpvcTKhQKHDt2rNYFmao7d+6gZcuWUpchS5QNG+XCR9mwUS5slAsfZcP24PKMUtKrEfvjjz/0vtVTTreEEkIIIYTImV6NWHx8fD2XYfp8fX2lLkG2KBs2yoWPsmGjXNgoFz7Khs3a2lrqEkQ0RsxIaPZiPsqGjXLho2zYKBc2yoWPsmEz6Zn1Cdv9+/elLkG2KBs2yoWPsmGjXNgoFz7Khq2srEzqEkSyaMS2b9+Opk2bwsrKCh06dMC5c+f0Ou7ChQswNzdH27Zt67dAPdDYOD7Kho1y4aNs2CgXNsqFj7KRP8kbsSNHjmD+/PlYunQprl69il69emHw4MFITEys9ricnBxMmjQJ/fr1e0iVVo9mLuajbNgoFz7Kho1yYaNc+CgbNjlN6yF5I7Zx40ZMnz4dM2bMQEhICDZt2gQfHx/s2LGj2uOef/55TJgwAd26dXtIlVbv5s2bUpcgW5QNG+XCR9mwUS5slAsfZcOWn58vdQkiSRux0tJS/PbbbxgwYIDO9gEDBuDixYvc4/bu3Yvbt29j+fLlBr1eXl4ecnNzxT8lJSW1qptFo9EY7bkeNZQNG+XCR9mwUS5slAsfZcMmp6WfJJ1aNjMzExqNBh4eHjrbPTw8kJqayjwmJiYGixcvxrlz5wyeGbd169YoLCwUv586dSrmzp0LLy8v3L59W3xtQRCQnp4OAGjevDmSkpJQVFQEKysr+Pj4ICYmBgDg7u4OpVKJ1NRUFBUVoaSkBKmpqSgoKIBKpYK/v7/4rxFXV1dYWlri7t27AICmTZsiIyMD+fn5sLCwQGBgIKKiogAAzs7OsLa2RnJyMgDA398f2dnZyM3NhZmZGYKDgxEVFQVBEODo6Ah7e3vcuXMHQPmtyrm5ubh//z4UCgVCQkJw8+ZNaDQaODg4wMnJCQkJCQCAJk2aoLCwENnZ2QCAli1bIjo6Gmq1Gvb29nB1dRXXFm3cuDFKSkqQlZUFAGjRogViY2NRWloKW1tbeHh4IDY2FgDg5eUFtVqNjIwMAOWr3MfGxqK4uBjW1tbw9vbGrVu3xLwBIC0tDQAQGBiI5ORkMW9fX19ER0cDANzc3GBubo6UlBQAQEBAANLS0lBQUABLS0sEBATgxo0bAAAXFxeoVCqdvDMzM5GXlwdzc3MEBQUhMjJSzNvGxgZJSUkAypfxunfvHjdvBwcH8dK5j48P8vLyuHk7OzuL0794e3ujqKhIzNve3h4xMTEoKyuDnZ0d3NzcdPIuLS1FZmYmACA4OBjx8fEoKSmBra0tPD09xfesp6cntFqtznv2zp07Yt5NmjTRec8qFAox72bNmiElJQWFhYVQqVTw8/OrNu/09HTk5+cz87aysmK+Zx/M28nJCXZ2djrv2ZycHOTk5ECpVKJFixYoLi5GZGQkGjVqhEaNGunknZ+fj3v37lV5z7LyLi4uZr5n7ezs4O7uzn3PBgUFISEhASUlJbCxsTHKZ0RF3nX5jCgqKkJkZOQj9xkRFBSExMTEWn9GVOTyqH1GhISE4NatW3X6jKh4vkftM+LGjRvQarW1/ozQaDTIycmpt88IQxpghVCLtvDAgQM4dOgQEhISqsxOq1AoxGJqcvfuXXh7e+PixYs6lxhXr16Njz76SPwFVtBoNOjatSumT5+OWbNmAQBWrFiBL774AteuXeO+jlqtxpkzZxAQEACl8t+TgCqVCiqVSq9aa1JQUABbW1ujPNejhrJho1z4KBs2yoWNcuGjbNjGjBmDTz75pN6eX6PR4Pr16wgLC6vxpJHBZ8TeeustREREoGXLlggNDa1TI+Pq6gozM7MqZ7/S09OrnCUDyi8tXrlyBVevXsULL7wAANBqtRAEAebm5vjhhx8QHh7OfT17e3uYmZnVut7qJCQk0DISHJQNG+XCR9mwUS5slAsfZcNmckscVbZr1y7MmTMHW7durfOLW1paokOHDjhx4gSGDx8ubj9x4gSeeuqpKvs7ODjgzz//1Nm2fft2/PTTT/jss8/QtGnTOtdECCGEEPKwGNyIpaam6jRNdbVw4UI8++yz6NixI7p164Zdu3YhMTFRvPQYERGB5ORk7N+/H0qlEq1bt9Y53t3dHVZWVlW2P2xNmjSR9PXljLJho1z4KBs2yoWNcuGjbNhMeomjDh066D0GTB9jx47Fpk2bsGrVKrRt2xZnz57FN998Az8/PwBASkpKjXOKyUHlmwCILsqGjXLho2zYKBc2yoWPsmGT092kBjdiGzduxH//+1/89ttvRiti9uzZ4t0ev/32G3r37i0+tm/fPpw+fZp77IoVK6odqP+wVNzlQqqibNgoFz7Kho1yYaNc+CgbttLSUqlLEBl8aXLq1KnIyspC586d4enpCRcXF53HFQoFrl+/brQCCSGEEEIeVQY3Yi4uLnB1da2PWkwa3ZXCR9mwUS58lA0b5cJGufBRNmxyWuLI4EasusuEDVl0dDSCgoKkLkOWKBs2yoWPsmGjXNgoFz7Kho2WOHoEqdVqqUuQLcqGjXLho2zYKBc2yoWPsmF7JJY4ysnJQXR0NHNStMqD7RsKOZ3mlBvKho1y4aNs2CgXNsqFj7JhM3SJxPpkcCVqtRqzZs3C/v37ubd/yum20IeFxs3xUTZslAsfZcNGubBRLnyUDZulpaXUJYgMvjT5zjvv4KuvvsKePXsgCALeffddvPfee+jYsSOaN2+Ob7/9tj7qlL2KhVhJVZQNG+XCR9mwUS5slAsfZcMmp/nVDG7EPvroIyxduhTjx48HAHTp0gUzZszA5cuX4efnh1OnThm9SEIIIYSQR5HBjVhsbCxCQ0OhVJYfWlxcLD42a9YsHDx40HjVmZDGjRtLXYJsUTZslAsfZcNGubBRLnyUDZuVlZXUJYgMbsRsbW1RWloKhUIBZ2dnJCQkiI9ZW1sjKyvLqAWaipKSEqlLkC3Kho1y4aNs2CgXNsqFj7Jh02q1UpcgMrgRa9GihXjNuXv37ti4cSOSkpKQnp6Ot99+G8HBwUYv0hQ01AZUH5QNG+XCR9mwUS5slAsfZcNm0kscjR07FtHR0QCAlStXonfv3uIC3RYWFvj888+NWyEhhBBCyCNKIdRxVrM7d+7g6NGjUCqVePzxx2V5RkytVuPMmTMIDQ2FmZlZvbyGVqsVx80RXZQNG+XCR9mwUS5slAsfZcM2fvx4HD58uN6eX6PR4Pr16wgLC6txzrI6/3Z8fHwwb948vPDCC7Jswh6W2NhYqUuQLcqGjXLho2zYKBc2yoWPsmEz6ekrKnz//feIiIjAzJkzkZiYCAD49ddfkZGRYbTiTImcrjfLDWXDRrnwUTZslAsb5cJH2bDJabC+wWPECgsL8dRTT+HkyZNQKBQAgP/85z/w9fXFhg0b4OPjgw0bNhi9ULmztbWVugTZomzYKBc+yoaNcmGjXPgoG7b6GqZUGwafEVu6dCmuXLmC//3vf8jJydFZOHPAgAH48ccfjVqgqfDw8JC6BNmibNgoFz7Kho1yYaNc+CgbNpVKJXUJIoMbsU8//RRvvPEGhg8fDmtra53HfH19xcuUDQ1dh+ejbNgoFz7Kho1yYaNc+CgbNpMeI5aRkYFWrVqxn0ypRFFRUZ2LIoQQQghpCAxuxLy9vfHnn38yH/vjjz/QtGnTOhdliry8vKQuQbYoGzbKhY+yYaNc2CgXPsqGzaSXOBoxYgRWr16Nq1evitsUCgUSEhLwzjvvYPTo0UYt0FSo1WqpS5AtyoaNcuGjbNgoFzbKhY+yYZPTXZMGN2LLly9H48aN0blzZ3Ts2BEKhQJTp05F69at4e7ujsWLF9dHnbLXUKft0Adlw0a58FE2bJQLG+XCR9mwyWlaD4MbMXt7e1y8eBFvvPEG7Ozs0KxZM9jY2CAiIgJnz56tMoCfEEIIIYSw1XmJI1PwMJY4UqvVNS5j0FBRNmyUCx9lw0a5sFEufJQN2yO1xBEp11Cn7dAHZcNGufBRNmyUCxvlwkfZsMlp+gq92uRp06bp/YQKhQK7d++udUGmqri4WOoSZIuyYaNc+CgbNsqFjXLho2zY5DRYX69GbN++fbC0tISFhUWN+zbURozGxvFRNmyUCx9lw0a5sFEufJQNm5yWONKrEbOzs4NarcZTTz2FadOmITw8vL7rMjne3t5SlyBblA0b5cJH2bBRLmyUCx9lw2Zy84ilpqZix44dSExMxOOPP45mzZrhzTffRFJSUn3XZzJu3boldQmyRdmwUS58lA0b5cJGufBRNmwFBQVSlyDSqxGzsbHB5MmTcfbsWURFRWH06NHYsWMH/P39MWjQIHzyyScoKyur71oJIYQQQh4pBt81GRQUhHXr1uHOnTv44osvYG1tjYkTJ+KZZ56pj/pMBq1wz0fZsFEufJQNG+XCRrnwUTZsKpVK6hJEtZ6+Ijc3FwkJCUhISIBGo4GDg4Mx6yKEEEIIeeQZ3IidOHEC48ePR+PGjbFkyRJ07NgRFy9exPvvv18f9ZmMtLQ0qUuQLcqGjXLho2zYKBc2yoWPsmErKSmRugSRXndNxsfHY+/evfjwww+RmJiIXr16YceOHRg9ejRsbGzqu0ZCCCGEkEeSXo1Ys2bNYG9vj7Fjx2LatGlo3rw5gPKJ4liTxTk7Oxu3ShMQGBgodQmyRdmwUS58lA0b5cJGufBRNmy2trZSlyDS69KkIAjIzc3FBx98gO7du8PNza3aPw1RcnKy1CXIFmXDRrnwUTZslAsb5cJH2bDJacUBvc6ILV++vL7rMHlFRUVSlyBblA0b5cJH2bBRLmyUCx9lw6bRaKQuQUSNmJHIaZZeuaFs2CgXPsqGjXJho1z4KBs2pbLWk0YYnXwqMXG+vr5SlyBblA0b5cJH2bBRLmyUCx9lwyanGw2pETOS6OhoqUuQLcqGjXLho2zYKBc2yoWPsmHLz8+XugQRNWKEEEIIIRKhRsxIGurdovqgbNgoFz7Kho1yYaNc+CgbNktLS6lLEFEjZiTm5nrd99AgUTZslAsfZcNGubBRLnyUDRsN1n8EpaSkSF2CbFE2bJQLH2XDRrmwUS58lA2bnOYRq1UjVlJSgvfeew/jx4/H448/jpiYGADAsWPHEBsba9QCCSGEEEIeVQafs8zMzETfvn3x999/w9PTE2lpacjLywMAfPHFF/j++++xfft2oxcqdwEBAVKXIFuUDRvlwkfZsFEubJQLH2XDZtLTV7zyyiu4f/8+rly5gsTERAiCID7Wt29fnDlzxqgFmgpa4Z6PsmGjXPgoGzbKhY1y4aNs2EpKSqQuQWTwGbHjx4/jrbfeQvv27assEdCkSRMkJSUZrThTUlBQIHUJskXZsFEufJQNG+XCRrnwUTZsclriyOAzYrm5ufDz82M+VlZWBrVaXeeiTJGcboWVG8qGjXLho2zYKBc2yoWPsmEz6bsmmzZtikuXLjEf++WXXxAcHFznokwRXYfno2zYKBc+yoaNcmGjXPgoGzaTHiM2ceJEvPXWWzh27Jg4PkyhUODXX3/F5s2b8eyzzxq9SFNw48YNqUuQLcqGjXLho2zYKBc2yoWPsmGT0xJHBo8Re/XVV3HhwgUMHz4cTk5OAICBAwciKysLgwYNwosvvmj0IgkhhBBCHkUGN2IWFhb45ptvcOTIEXz99ddIS0uDq6srnnzySYwbN05W110fJhcXF6lLqDdaQUBRmRaFZRoUlmpQWKZFQanmn++1KCrToKBM+89j/+5T8V+NWgNV9E2YKQEzhQJmSgWUCgXMlQqdbWZKBcwUEB8v//7ffcz/2UdZaT/x2IrvHzhGn22VX4tVk7LSaykV5WeAjeFRfs/UFWXDRrmwUS58lA2bnMbO1WrtA4VCgXHjxmHcuHHGrsdkqVQqqUuookyjrdQQaVBQqttMVW2aqu5TVFb+37p7dG7iqNz0mYtNY6XmjdMcKpUob/T+eVyhVcPZrgQOVuZwUJnBXmUOByszOKjM4aAyh71V+TZzpXEaP1Mix/+f5IByYaNc+CgbNjmdNDK4ERs1ahSmTZuGQYMGyeoHkdrdu3fh6OhY5+cRBAHFai0KS7UoEBui8jNPhWW6TZPuPlWbrDKNUPML1jMLpQKCIEALQCt9OUahEQCNRij/os4Ka9zDxkL5T7NW3qjZqyo3buawV5mJjzn8s83GQmm0M3dSMNb/T48ayoWNcuGjbNjktMSRwY3YpUuXcPToUXh4eGDy5MmYPHkyWrRoUR+1mRSNVkBusfqBpqnS1xWX9BhnoSpfxisq00jesCgAWFsoYWNpBlsLM/FrGwsz2FoqYWNh9s/3ututLf7dVnGchZkSkZGRaNmyZXlDJpRnpRGEf/4LqLWCuE2rFaDRotLjD3xfeZvO87D2Q/nz/bNN/c+26l+r0j6Vt1VTk7ZSPeoHnqfi9evyOy1vrEuRmleq9zFKBcSGraKJs//na/sHt1Vq4izN6R9XhBDyMBnciN25cwfff/899u3bh02bNuHtt99Gly5dMH36dIwZMwb29vb1UadsRaYV4NVvYlCiEYCf/5S0FnOlQqc5srFUwrZy01Tpa1tLsyqNk80/TZaVhRJKI55Nadq0KYDyS9oVl+saGm3lJvSf5uxeXiHKFObILdEgr1hd/t8SNXL/+Tq3WI28Eg1yS8r/m1ei1ruh0wpATrEaOcVqIEf/GaRVZgrYVzr7VrlZs7f6t7H7t4Ezh52lmdF/pxXvGaKLcmGjXPgoGzY5TV9hcCOmVCoxePBgDB48GPfv38ehQ4ewd+9ezJw5Ey+++CJGjhyJDz/8sD5qlSWVuaK8CasDK3Ol2ATZVmma/m2QHjwD9eCZKUszeZ7NyMzMhI+Pj9RlSEr5z0D/yuO97qfnoJkBuWgFAQWlGuQW/9Owlagrfc1u4vJK1AaN8SvRCCgpKENmQZnexygA2KnMYF9xufSBS6jljds/l1MrmjmVOayruXxK7xk2yoWNcuGjbNhKS/W/wlDfajVYv4KjoyNmz56N2bNn4/z585gwYQIOHDjQoBoxe5U5mjpZAeoSuDayZzZN5WeclFUaK1tLM1iZKx/5M0QVi8ITXYbmolQoYK8qb2oA/Qfglmm0OmfWKpq18rNwuttyS9Ti2Tm1nqffBOCfpk8DQP8PN3OlQhzrZl/pJgUHKzOU5d5Da7U9XG0t4G5rCUdr80f+/xN90P9LbJQLH2XDJqdVgOrUiAHAiRMnsHfvXnzxxRcoLi5G9+7dDX6O7du3Y/369UhJSUGrVq2wadMm9OrVi7nv559/jh07duDatWsoKSlBq1atsGLFCgwcOLCuP0qtuNtZ4r2RIYiOjkZQUDNJapA7c/M6v80eSQ8rFwszJZxtlHC2sdD7mIqbRnKLNf+cefv3MimvicsrUSO/RAN9zw+rtQKyi9TILmJ/IB6NjxO/VioAFxsLuNlawtXW4p8/lnCz/Xebi43FI9+s0f9LbJQLH2XDJqebmWr1G7p9+zb27duHDz/8EMnJyfDy8sKLL76IadOmoXnz5gY915EjRzB//nxs374dPXr0wHvvvYfBgwcjMjISvr6+VfY/e/YsHn/8caxZswaOjo7Yu3cvhg4disuXL6Ndu3a1+XGMIigoSLLXljvKhk3OuSgUClhblI8j9LDXf74djfafy6f/XDZ9sInLq9j2QBNXoq7+8qlWADIKypBRzSVTpQJwsi5v0tz+adQqvq7crFnI9BK+PuT8npES5cJH2bDZ2dlJXYJIIVSsU6SnsLAwnD9/HhYWFhg6dCimTZuGgQMH1noqiy5duqB9+/bYsWOHuC0kJARPP/001q5dq9dztGrVCmPHjsWyZcuYj6vVapw5cwahoaEwMzOrVZ01qbgzkFRF2bBRLv8qVWvF5ux+sRp/xsTDopEbMv8Zr5ZRUIrMgjLcL6775QQna3OdM2qu/zRqYvNmYyHbu0fpPcNGufBRNmxDhw7FV199VW/Pr9FocP36dYSFhdV4VtLgM2J5eXnYtGkTJk6cCGdn51oXCZQPlvvtt9+wePFine0DBgzAxYsX9XoOrVaLvLw8vWrJy8vTaRhVKhVNdkeIDFiaK+FqbglX2/LvVffN0LKlZ5X9SjVaZBWWISO/DJn/NGcZBf98XVjesN0rVFd7efRekRr3itSIySzi7tPI6p9mrdLlUDe7f5s3FxsLWFvUzz/qCCENi8GN2O+//260F8/MzIRGo4GHh4fOdg8PD6Smpur1HP/9739RUFCAMWPG1Lhv69atUVj47wSaU6dOxdy5c+Hl5YXbt2+Lry0IAtLT0wEAzZs3R1JSEoqKimBlZQUfHx/ExMQAANzd3aFUKpGamori4mKUlJQgNTUVBQUFUKlU8Pf3x82bNwEArq6usLS0xN27dwGU31KckZGB/Px8WFhYIDAwEFFRUQAAZ2dnWFtbIzk5GQDg7++P7Oxs5ObmwszMDMHBwYiKioIgCHB0dIS9vT3u3LkDAPD19UVubi7u378PhUKBkJAQ3Lx5ExqNBg4ODnByckJCQgIAoEmTJigsLER2djYAoGXLloiOjoZarYa9vT1cXV0RF1c+Tqdx48YoKSlBVlYWAKBFixaIjY1FaWkpbG1t4eHhgdjYWACAl5cX1Go1MjIyAACNGjVCbGwsiouLYW1tDW9vb9y6dUvMGwDS0tIAAIGBgUhOThbz9vX1RXR0NADAzc0N5ubmSElJAQAEBAQgLS0NBQUFsLS0REBAgLjArYuLC1QqlU7emZmZyMvLg7m5OYKCghAZGSnmbWNjg6SkJACAn58f7t27x83bwcEBiYmJAAAfHx/k5eVx83Z2dkZ8fDwAwNvbG0VFRWLeTk5OiImJQVlZGezs7ODm5qaTd2lpKTIzMwEAwcHBiI+PR0lJCWxtbeHp6Sm+Zz09PaHVanXes3fu3BHzbtKkic57VqFQiHk3a9YMKSkpKCwshEqlgp+fX7V5p6enIz8/n5m3lZUV8z37YN5OTk6ws7PTec/m5OQgJycHSqUSLVq0QGlpKSIjI9GoUSM0atRIJ2/k58P83j14AggP/ec966j+J28f3IqNQ24pYNHIFak5RUjKysX9UkCjskNydh6yi7XILUW1zVrF1B+3s/jNmo050MhSAW8nW1gJpbA308DN1hJBPh7Iz0iGo0oBXy8P8TOiIu+6fEYUFxcjMjLykfuMCAoKQmJiYq0/IypyedQ+I0JCQnDr1q06fUYUFxcjOzv7kfuMuHHjBrRaLfMzIj8/H/fu3avynq2ct1arRU5ODoqLi5nvWTs7O7i7u1f7nk1ISEBJSQlsbGyq9BEajQb6MvjSpDHdvXsX3t7euHjxIrp16yZuX716NT766KMaV40/fPgwZsyYgWPHjqF///7c/SouTQYEBNTbGbHc3Fw4ODgY5bkeNZQNG+XCV9/ZaLQCsot0L3tWfJ2RX4bMwlJkFZTVefEEGwulzg0GOpdA/xm/ZmtppvfAYXrPsFEufJQN25gxY/DJJ5/U2/Mb/dJkQEAAjh49itDQUDRt2rTaDw2FQiF2hTVxdXWFmZlZlbNf6enpVc6SPejIkSOYPn06Pv3002qbsMrs7e3rbYxYUlISXYfnoGzYKBe++s7GTKn4pymyRAhsmftotALuF6uRWVD6z+XPMmTk/3sJtKJ5q26aj8IyLRLuFyPhPn85FStzZZWbCh4cv2avKm/W6D3DRrnwUTZsRUX8s90Pm16NWFhYmNhRh4WFGe22T0tLS3To0AEnTpzA8OHDxe0nTpzAU089xT3u8OHDmDZtGg4fPowhQ4YYpRZCCKnMTKmAi035eLBgN/Y+WkFATrFa94xaQdXxa6XVnForVmuRlFOCpGpWQLA0U8DV1hK2ilIEZCbAw14FTztLeNhbwsPOskFM3UHIo0qvRmzv3r3i1/v27TNqAQsXLsSzzz6Ljh07olu3bti1axcSExMxa9YsAEBERASSk5Oxf/9+AOVN2KRJk7B582Z07dpVPJtmbW2NRo0aGbU2Q/j5+Un22nJH2bBRLnymko1SoYCTtQWcrC3Q3JW9jyAIyCvRVGrSKp9RKxWn5ahuCo9SjYC7ueWNWkxOdpXHzRTlcxpWNGYNrVEzlfeLFCgbNmtra6lLEBk8WH///v0YMmQIXFxcqjyWnZ2N48ePY9KkSXo/39ixY5GVlYVVq1YhJSUFrVu3xjfffCO+eVJSUsRBeADw3nvvQa1WY86cOZgzZ464ffLkyUZvEg1x79492NqyL3E0dJQNG+XC9yhlo1AoyhdZtzJHs6ofmwDKm7X8Ug1zzFrlr3nLVWkEICWvFCmcheEf9UbtUXq/GBtlw1ZWpv8ybvXN4EZs6tSpuHTpErMRi4uLw9SpUw1qxACIyySxPNhcnT592qDnflhyc3OlLkG2KBs2yoWvoWWjqLR8VVNn/r/Ur/zxN5y8myI1rxRp+aVIyytFasV/80oabKPW0N4vhqBs2Ex6iaPqbrIsLi6ut8HwctdQf259UDZslAsfZcNmrzJHMxcbNHOxYT6eX6JGWn5pg2vU6P3CR9mwmdwSR4mJieI8JwBw9epVFBfr3gVUVFSEXbt2MZclagiCg4OlLkG2KBs2yoWPsmGrKRc7lTns/mnWWB7VRo3eL3yUDZucljjSe7D+ypUroVAooFAomJcRK86Ubd682bgVmoioqCiEhIRIXYYsUTZslAsfZcNW11yqa9QqxqlVbs7SxP+WIDWv9mPUzJUKuNtZlDdpdiqxQfO0L2/WnK3r1qjR+4WPsmHLy8uTugSRXo3YmDFj0Lp1awiCgDFjxmDNmjVVFvdWqVRo3bo1/P3966NO2ZNwXlzZo2zYKBc+yoatPnOpPE4t0NW4jZpaK+Bubinu5pYCyK/yeF0bNXq/8FE28qdXIxYSEiJ21Hv37sWTTz7JHKzfkDk6OkpdgmxRNmyUCx9lwyZlLnJu1BwknLpI7uj/JTYLCwupSxAZPFh/8uTJ9VGHyaMlJPgoGzbKhY+yYZNzLtI2aoCb7f1/x6iJ49NU8LSX/mYCKcn5PSOlmpYdephqVUl2djYOHTqEqKioKssEKBQK7N692yjFmZLExERaRoKDsmGjXPgoGzZTzqV+G7Xqx6gpFYCbbfkZNHe7f8+mVdxg4GZrCfNHtFEz5fdMfTK5JY4qS0xMRKdOnVBYWIjCwkK4uroiOzsbGo0GTk5Oks5uTwghxDTVpVGLz8xFTpmC26hpBZTvm89v1FxsLOBhbwlPu4oGTSV+7WZnAUszpVF/XkIqGNyILV68GK1atcLx48dhZ2eHb7/9Fq1bt8b777+PNWvW4Ouvv66POmXPx8dH6hJki7Jho1z4KBu2hpxLdY1aXl4e7O3tdabnSM//t2FL/6cJyyvRMJ9bK0BcauovFFR9bZQ3ahVn0DztLOFeaZyau60lLM3l2ag15PdMdUx6iaNLly7h7bffhpWVFYDyf6VYWlpizpw5SEtLw6JFi3D8+HGjFyp3FR8EpCrKho1y4aNs2CgXtopcappHraBUU96g/XM27d+vS5CeX4acYvZs6wKAzMIyZBaWITK9aqMGAM7W5vD453Kn5z9n1NztLOBpp4K7vSWsJGrU6D3DZtIz66elpcHLywtKpRJmZmY6yyeEhYVhy5YtRi3QVNy/fx+NGzeWugxZomzYKBc+yoaNcmHTNxdbSzM0dbbmLiNVVKbRbdAeOLN2n9OoAUB2kRrZRWpEpRcyH29kZV5+l+c/lzsf/Nraon5mwKf3DJtJrzXp4eGB7OxsAIC/vz+uXLmCvn37AgDi4+NldSfCwySn5RLkhrJho1z4KBs2yoXNWLlYW5jB38ka/k7sRq1YrS2/zFkxPi2/FGl55WfTUvNLkF3Ib9RyitXIKVbjZga7UXNQmTEaNJV4B6itZe0aNXrPyJ/BXVPXrl1x9epVDBs2DCNGjMCqVatQUlICS0tLrF+/HuHh4fVRp+zRzMV8lA0b5cJH2bBRLmwPKxcrcyV8Ha3g62jFfLxUrUV6wYON2r9fZxWUgTe9am6JBrklRbiVxb6bz87S7IFLn7pf21maMZsues+wyelyrcGN2MsvvyyuO7ls2TJERUVh+fLlEAQBvXv3brBLHN28eZPW9OKgbNgoFz7Kho1yYZNLLpbmSjRpZIUmjdiNWplGi4yCMt0GLa8EafllSMsvQWZBGbScTi2/VIP8rCLc5jRqNhbKSvOn/bvmZ3HWXXRvE1zrM2qPqvz8qvPRScXgRqxDhw7o0KEDAMDW1hZffvklcnNzy+9okVGH+bBpNOy7cQhlw0O58FE2bJQLm6nkYmGmRGMHFRo7qJiPq7UCMqs5o5aRXwoNp1ErLNMi7l4x4u4VV3lsnu09PBniaswfxeTJaeknowzoopl7KYPqUDZslAsfZcNGubA9KrmYKxXwtFfB057dqGm0ArIK/z2jlppfivR/7vosv8mgDGrGKTUPO8v6Lt3kyGk8u16VnD171qAn7d27d62KMWXOzs5SlyBblA0b5cJH2bBRLmwNJRczpQLu/wzkf8yz6uNaQUB2YZnOWbSke4XcMW0NmaWlfJpTvRqxPn366HXnhSAIUCgUJnOa2Jji4+NpGQkOyoaNcuGjbNgoFzbKpZxSoYCrrSVcbS3R6p9tkZGR8LCXT9MhF4WF7LtXpaBXI3bq1Kn6roMQQgghpMHRqxELCwur7zpMnre3t9QlyBZlw0a58FE2bJQLG+XCR9mwVawOJAd1WnPh5s2buHDhAgoK2Es+NCRyWsldbigbNsqFj7Jho1zYKBc+yoZNq2UvEC+FWjVi+/fvR5MmTdCyZUv07t0bN2/eBACMGTMG77//vlELNBUVqw2QqigbNsqFj7Jho1zYKBc+yoattLRU6hJEBjdin376KaZMmYL27dvj3Xff1ZmLo3379vjkk0+MWiAhhBBCyKPK4EZs7dq1mDp1Kr788ks899xzOo+FhIQgMjLSaMWZElpGgo+yYaNc+CgbNsqFjXLho2zY5DQBvcGNWFRUFMaNG8d8zNnZGVlZWXUuyhTdunVL6hJki7Jho1z4KBs2yoWNcuGjbNjkNLbd4EbMxsYGOTk5zMeSk5Ph5ORU56JMUVlZmdQlyBZlw0a58FE2bJQLG+XCR9mwmfRg/R49elQZG1Zh37596NOnjzHqMjl2dnZSlyBblA0b5cJH2bBRLmyUCx9lw2ZySxxVtmzZMvTs2ROdO3fGhAkToFAo8Pnnn2P58uU4e/Ysfvnll/qoU/bc3NykLkG2KBs2yoWPsmGjXNgoFz7Khk1OSxwZfEasY8eO+Pbbb5Gfn4+XXnoJgiBgzZo1iI6OxjfffIPWrVvXR52yFxcXJ3UJskXZsFEufJQNG+XCRrnwUTZsJrfE0YP69u2LqKgo3L59G2lpaXB1dUVQUBCAf9ebJIQQQggh1avTzPrNmjVD9+7dxSbs0KFDDfZW2caNG0tdgmxRNmyUCx9lw0a5sFEufJQNm5yWONL7jFhOTg6++OILpKWlISgoCMOGDYNSWd7Hff7551i2bBkiIyPh5+dXb8XKmZxm6ZUbyoaNcuGjbNgoFzbKhY+yYTO5uyZv3bqFFi1aYNq0aVi8eDFGjhyJ/v37Izc3F0OGDMHo0aORkpKCt99+Gzdu3KjvmmUpMzNT6hJki7Jho1z4KBs2yoWNcuGjbNjk1KDqdUbs9ddfR25uLlasWIGOHTsiNjYWq1evRvfu3REZGYkZM2bg7bffhqOjYz2XSwghhBDy6NCrETtz5gxee+01REREiNsCAwMxePBgzJo1C9u3b6+3Ak1FcHCw1CXIFmXDRrnwUTZslAsb5cJH2bDJaX41vS5NZmRkoEePHjrbevbsCQAYO3as8asyQfHx8VKXIFuUDRvlwkfZsFEubJQLH2XDJqfpK/RqxDQaTZU7DCq+l9PCmVIqKSmRugTZomzYKBc+yoaNcmGjXPgoGzY5DdbX+67Jmzdv6iwJoNFoAIA5OL99+/ZGKM202NraSl2CbFE2bJQLH2XDRrmwUS58lA2bmZmZ1CWI9G7EpkyZwtz+7LPPil9XTOZa0aQ1JJ6enlKXIFuUDRvlwkfZsFEubJQLH2XDZnLziO3du7e+6zB5t2/fRsuWLaUuQ5YoGzbKhY+yYaNc2CgXPsqGraCgQOoSRHo1YpMnT67vOgghhBBCGpw6LXFE/kWnf/koGzbKhY+yYaNc2CgXPsqGTaVSSV2CiBoxI5HTHRhyQ9mwUS58lA0b5cJGufBRNvJHjZiRpKenS12CbFE2bJQLH2XDRrmwUS58lA2bnKb1oEaMEEIIIUQi1IgZSfPmzaUuQbYoGzbKhY+yYaNc2CgXPsqGTU7zq1EjZiR37tyRugTZomzYKBc+yoaNcmGjXPgoG7aioiKpSxBRI2YkxcXFUpcgW5QNG+XCR9mwUS5slAsfZcMmp5sYqBEzEmtra6lLkC3Kho1y4aNs2CgXNsqFj7Jhk9MSR9SIGUmTJk2kLkG2KBs2yoWPsmGjXNgoFz7Khk1OSxxRI2YkMTExUpcgW5QNG+XCR9mwUS5slAsfZcMmpyWOqBEjhBBCCJEINWJG4u7uLnUJskXZsFEufJQNG+XCRrnwUTZstMTRI0ihUEhdgmxRNmyUCx9lw0a5sFEufJSN/FEjZiRpaWlSlyBblA0b5cJH2bBRLmyUCx9lw0ZLHBFCCCGEEGrEjKVZs2ZSlyBblA0b5cJH2bBRLmyUCx9lw0ZLHD2CUlJSpC5BtigbNsqFj7Jho1zYKBc+yoZNTisOUCNmBCUlJdi6dausrjnLBWXDRrnwUTZslAsb5cJH2bCVlJQgLi5ONrnIohHbvn07mjZtCisrK3To0AHnzp2rdv8zZ86gQ4cOsLKyQkBAAHbu3PmQKmUrKSnB3r17ZfNLlRPKho1y4aNs2CgXNsqFj7JhKykpwZ07d2STi+SN2JEjRzB//nwsXboUV69eRa9evTB48GAkJiYy94+Li8MTTzyBXr164erVq1iyZAnmzZuH//3vfw+5ckIIIYSQupG8Edu4cSOmT5+OGTNmICQkBJs2bYKPjw927NjB3H/nzp3w9fXFpk2bEBISghkzZmDatGnYsGHDQ66cEEIIIaRuzKV88dLSUvz2229YvHixzvYBAwbg4sWLzGMuXbqEAQMG6GwbOHAgdu/ejbKyMlhYWFQ5RhAEAEBOTg6Uyn97T0tLS6PMrqvVamFjYwOtVguNRlPn53uUUDZslAsfZcNGubBRLnyUDdvDyKXieSv6j+ooBH32qid3796Ft7c3Lly4gO7du4vb16xZgw8//BA3b96sckxQUBCmTJmCJUuWiNsuXryIHj164O7du/Dy8qpyTHFxMS5cuFA/PwQhhBBCCEOPHj1gZWVV7T6SnhGr8OASDIIgVLssA2t/1vYKlpaW6NixIzQajc4+xjojRgghhBBSQRAEaDQaWFpa1rivpI2Yq6srzMzMkJqaqrM9PT0dHh4ezGM8PT2Z+5ubm8PFxYV5jFKpRKNGjYxTNCGEEEJIDVhDpVgkHaxvaWmJDh064MSJEzrbT5w4oXOpsrJu3bpV2f+HH35Ax44d9f6hCSGEEELkQPK7JhcuXIgPPvgAe/bsQVRUFBYsWIDExETMmjULABAREYFJkyaJ+8+aNQsJCQlYuHAhoqKisGfPHuzevRsvv/yyVD8CIYQQQkitSD5GbOzYscjKysKqVauQkpKC1q1b45tvvoGfnx+A8uUZKs8p1rRpU3zzzTdYsGABtm3bhsaNG2PLli0YOXKkVD8CIYQQQkjtCIRp27Ztgr+/v6BSqYT27dsLZ8+e5e577tw5oXv37oKzs7NgZWUlBAcHCxs3btTZp7S0VFi5cqUQEBAgqFQqoU2bNsK3335b3z+G0RmSS2Xnz58XzMzMhNDQ0CqPffbZZ0JISIhgaWkphISECJ9//rmRq65/xs7lr7/+EkaMGCH4+fkJAIR33nnH+EU/JMbOZteuXULPnj0FR0dHwdHRUejXr59w+fLleqi8fhk7l//9739Chw4dhEaNGgk2NjZCaGiosH///nqovP7Vx+dMhcOHDwsAhKeeeso4xT5Exs5l7969AoAqf4qKiuqh+vpVH++Ze/fuCbNnzxY8PT0FlUoltGjRQvj666+NXLkgUCPG8PHHHwsWFhbC+++/L0RGRgovvviiYGtrKyQkJDD3//3334VDhw4Jf/31lxAXFyd89NFHgo2NjfDee++J+7zyyitC48aNha+//lq4ffu2sH37/9u796iY8/8P4M9ppiGXIpLEQbnEEeVSmGXKsaLcT4vUHnIpu+xxWUtolexpLdWyS3Y3ldu67KGNzS526eYyYk3LkqKEKLuybLnE6PX9Y399fqaZkOYz4/J6nDN/fN6fy/v1fp05eXl/PvP+xFL9+vXp9OnTxhpWndU2L1Xu3LlDDg4ONGTIEJ0v+7Fjx0gqlVJkZCTl5ORQZGQkyWQyUqlUIo7EsMTIS1ZWFs2fP5+2b99OLVu2fG0LMTFyM3HiRFq3bh2p1WrKycmhwMBAsrKyoqKiIhFHYlhi5CU1NZWSkpLo/PnzdOnSJVq9ejVJpVLav3+/iCMxPDFyU6WwsJDs7e1pwIABr10hJkZeEhMTydLSkoqLi7U+rxsxclNRUUG9e/cmb29vOnLkCBUWFlJmZiZlZ2cbPH4uxPRwc3OjGTNmaLU5OTlRSEjIC19jzJgxFBAQIGzb2dnR2rVrtY4ZNWoU+fv71y1YI3rZvIwfP55CQ0MpLCxM58s+btw4Gjp0qFabl5cXTZgwwSAxG4MYeXla27ZtX9tCTOzcEBFpNBpq3Lgxbdq0qa7hGo0x8kJE5OrqSqGhoXUJ1ejEyo1GoyGFQkEbNmygSZMmvXaFmBh5SUxMJCsrKwNHanxi5Gb9+vXk4OBAjx49MnS4Okz+sP6rpmq1/+qr9z9rtf/q1Go1jh07BqVSKbRVVFToLOpmYWGBI0eO1D1oI3jZvCQmJiI/Px9hYWF699f0poQXzbWpiZWXN4GxcnP//n08fvwY1tbWdYrXWIyRFyLCoUOHkJubi4EDB9Y5ZmMRMzcRERGwsbHB1KlTDRavsYiZl/LycrRt2xatW7fG8OHDoVarDRa3MYiVm71796Jfv36YOXMmbG1t0a1bN0RGRoqyEr/JH9Z/1dy6dQtPnjzRWcfM1tZWZ/2y6lq3bo2///4bGo0G4eHhmDZtmrDPy8sLMTExGDhwIBwdHXHo0CHs2bPntXntxMvk5eLFiwgJCUFmZiZkMv1ftZKSkpfK9atCrLy8CYyVm5CQENjb22Pw4MF1jtkYxMzL3bt3YW9vj4qKCkilUsTGxuLdd981aPxiEis3R48eRXx8PLKzsw0dslGIlRcnJyds3LgRzs7O+Pfff7FmzRooFAr88ccf6Nixo8HHIQaxclNQUIDDhw/D398fP//8My5evIiZM2dCo9Fg6dKlBh3Dm/uvQB3VdrV/AMjMzER5eTlUKhVCQkLQoUMH+Pn5AQDWrFmD6dOnw8nJCRKJBI6OjggMDERiYqJoYxDDi+blyZMnmDhxIpYtW4ZOnToZ5JqvMjHy8qYQMzcrV67E9u3bkZaW9tzXiLxqxMhL48aNkZ2djfLychw6dAjz5s2Dg4MDPDw8DBm66AyZm7KyMgQEBCAuLg7NmzcXJV5jMfR3pm/fvujbt6+wrVAo0LNnT3z99df46quvDBe4ERg6N5WVlWjRogW+++47SKVS9OrVCzdu3MCqVau4EBPby6z2X6V9+/YAAGdnZ9y8eRPh4eFCIWZjY4Pk5GQ8fPgQpaWlaNWqFUJCQoRzXnW1zUtZWRlOnToFtVqNWbNmAfjvi01EkMlkOHjwIAYNGlTjmxKel+tXhVh5eROInZuoqChERkbit99+Q/fu3cUdjAGJmRczMzN06NABAODi4oKcnBx8/vnnr00hJkZurK2tUVhYiBEjRgjnVVZWAgBkMhlyc3Ph6Ogo4qjqzlh/Z8zMzNCnTx9cvHhRnIGIQKzc2NnZwdzcHFKpVDi3S5cuKCkpwaNHj17o1UUvip8Rq+ZlVvvXh4hQUVGh016/fn3Y29tDo9Fg9+7dGDVqVJ1jNoba5sXS0hJnz55Fdna28JkxYwY6d+6M7OxsuLu7A6j5TQm1ybUpiZWXN4GYuVm1ahWWL1+O/fv3o3fv3qKPxZCM+Z2p6e/Qq0qM3Dg5OekcM3LkSHh6eiI7Oxtt2rQx1vBemrG+M0SE7Oxs2NnZiTIOMYiVG4VCgUuXLglFOwDk5eXBzs7OoEUYAF5HTJ+qn8LGx8fT+fPnac6cOdSwYUMqLCwkIqKQkBB6//33hePXrl1Le/fupby8PMrLy6OEhASytLSkJUuWCMeoVCravXs35efnU0ZGBg0aNIjat29P//zzj7GH99Jqm5fq9P0y5ejRoySVSmnFihWUk5NDK1aseG2XrzBkXioqKkitVpNarSY7OzuaP38+qdVqunjxophDMTgxcvPFF1+QXC6nXbt2af3kvqysTMyhGJQYeYmMjKSDBw9Sfn4+5eTkUHR0NMlkMoqLixNzKAYnRm6qex1/NSlGXsLDw2n//v2Un59ParWaAgMDSSaTvXbr8omRm6tXr1KjRo1o1qxZlJubSykpKdSiRQv67LPPDB4/35rUo7ar/VdWVmLRokW4fPkyZDIZHB0dsWLFCgQHBwvHPHz4EKGhoSgoKECjRo3g7e2NLVu2oEmTJsYe3kurbV5eRP/+/bFjxw6Ehobi008/haOjI3bu3PlazQyJkZcbN27A1dVV2I6KikJUVBSUSiXS0tIMGb6oxMhNbGwsHj16BF9fX632sLAwhIeHGyp0UYmRl3v37uHDDz9EUVERLCws4OTkhK1bt2L8+PFiDEE0YuTmTSBGXu7cuYOgoCCUlJTAysoKrq6uyMjIgJubmxhDEI0YuWnTpg0OHjyIuXPnonv37rC3t8fs2bOxcOFCg8cvISIy+FUZY4wxxthz8TNijDHGGGMmwoUYY4wxxpiJcCHGGGOMMWYiXIgxxhhjjJkIF2KMMcYYYybChRhjjDHGmIlwIcYYY4wxZiJciDHGGGOMmQgXYoy95Xbt2gWJRIKdO3fq7OvRowckEgkOHDigs8/R0RE9e/Y0Rog1mjx5Mtq1a2fSGJ62bds2rF69Wqe9sLAQEokEUVFRdbr+5s2bYWNjg7Kysjpd52Xk5eVBLpfj9OnTRu+bsTcZF2KMveU8PDwgkUiQmpqq1X779m2cPXsWDRs21NlXVFSEgoICeHp6GjPUV15NhZgh3L9/H4sXL8bChQvRuHFjUfp4lk6dOsHf3x9z5841et+Mvcm4EGPsLde8eXN069ZN5x2W6enpkMlkmDp1qk4hVrXNhZjxbNq0CaWlpZg2bZrJYpg1axYyMjJw7Ngxk8XA2JuGCzHGGDw9PZGbm4vi4mKhLS0tDX369IG3tzd+//13rdthaWlpkEqlGDBgAABg2bJlcHd3h7W1NSwtLdGzZ0/Ex8fj6VfZjh49Gm3btkVlZaVO/+7u7lq3OYkIsbGxcHFxgYWFBZo2bQpfX18UFBQ8dywveq6Hhwe6deuGkydPYsCAAWjQoAEcHBywYsUKnRjPnTuHIUOGoEGDBrCxscHMmTOxb98+SCQSoYD18PDAvn37cOXKFUgkEuFTXUxMDNq3b49GjRqhX79+UKlUzx0TAKxfvx4jRoxAkyZNhLaqW54bN27UOV4ikWi9BD08PBwSiQRnzpzBe++9BysrK1hbW2PevHnQaDTIzc3F0KFD0bhxY7Rr1w4rV67UuWavXr3QpUsXfPPNNy8UM2Ps+bgQY4wJM1tPz4qlpqZCqVRCoVBAIpEgMzNTa1/Pnj1hZWUF4L+CIDg4GD/88AOSkpIwduxYfPTRR1i+fLlwzpQpU3D16lUcPnxYq+8LFy4gKysLgYGBQltwcDDmzJmDwYMHIzk5GbGxsTh37hz69++PmzdvPnMstTm3pKQE/v7+CAgIwN69ezFs2DAsWrQIW7duFY4pLi6GUqlEbm4u1q9fj82bN6OsrAyzZs3SulZsbCwUCgVatmyJ48ePC5+nrVu3Dr/++itWr16N77//Hvfu3YO3tzfu3r37zDEVFRXh7NmzBpmBHDduHHr06IHdu3dj+vTp+PLLLzF37lyMHj0aPj4++PHHHzFo0CAsXLgQSUlJOud7eHjgl19+0SqyGWN1QIyxt97t27fJzMyMgoKCiIjo1q1bJJFIaP/+/URE5ObmRvPnzycioqtXrxIAWrBggd5rPXnyhB4/fkwRERHUrFkzqqysJCKix48fk62tLU2cOFHr+AULFpBcLqdbt24REdHx48cJAEVHR2sdd+3aNbKwsNDqd9KkSdS2bVthuzbnKpVKAkAnTpzQOrZr167k5eUlbH/yySckkUjo3LlzWsd5eXkRAEpNTRXafHx8tOKpcvnyZQJAzs7OpNFohPasrCwCQNu3b9c552k7d+4kAKRSqfReNzExUeccABQWFiZsh4WF6c2Ni4sLAaCkpCSh7fHjx2RjY0Njx47VuW5cXBwBoJycnGfGzBh7MTwjxhhD06ZN0aNHD2FGLD09HVKpFAqFAgCgVCqF58L0PR92+PBhDB48GFZWVpBKpTA3N8fSpUtRWlqKv/76CwAgk8kQEBCApKQkYQboyZMn2LJlC0aNGoVmzZoBAFJSUiCRSBAQEACNRiN8WrZsqRWjPrU9t2XLlnBzc9Nq6969O65cuSJsp6eno1u3bujatavWcX5+fi+SWi0+Pj6QSqVafQHQ6k+fGzduAABatGhR6z6rGz58uNZ2ly5dIJFIMGzYMKFNJpOhQ4cOeuOqiuH69et1joUxxrcmGWP/x9PTE3l5ebhx4wZSU1PRq1cvNGrUCMB/hZharcbdu3eRmpoKmUyGd955BwCQlZWFIUOGAADi4uJw9OhRnDx5EkuWLAEAPHjwQOhjypQpePjwIXbs2AEAOHDgAIqLi7VuS968eRNEBFtbW5ibm2t9VCoVbt26VeMYantuVfH3tHr16mnFXFpaCltbW53j9LU9T/X+6tWrB0A7R/pU7a9fv36t+6zO2tpaa1sul6NBgwY615bL5Xj48KHO+VXHPS9mxtiLkZk6AMbYq8HT0xMxMTFIS0tDWloavL29hX1VRVdGRobwEH9VkbZjxw6Ym5sjJSVF6x/z5ORknT66du0KNzc3JCYmIjg4GImJiWjVqpVQyAH//Yqz6pm0qkLlafraDHFuTZo1a6b3ubSSkpJaX+tlNW/eHMB/S4rY2dkJ7VX5rqio0Dq+tLRUtFhu376tFRNjrG54RowxBgAYOHAgpFIpdu3ahXPnzsHDw0PYZ2VlBRcXF2zatAmFhYVatyUlEglkMpnWLbcHDx5gy5YtevsJDAzEiRMncOTIEfz000+YNGmS1rnDhw8HEeH69evo3bu3zsfZ2bnGMdTl3JoolUr8+eefOH/+vFZ71aze06rPphmKk5MTACA/P1+r3dbWFvXr18eZM2e02vfs2WPwGKoUFBTAzMwMnTt3Fq0Pxt4mPCPGGAMAYdmJ5ORkmJmZCc+HVVEqlcJipU8XYj4+PoiJicHEiRMRFBSE0tJSREVF1Tj75Ofnh3nz5sHPzw8VFRWYPHmy1n6FQoGgoCAEBgbi1KlTGDhwIBo2bIji4mIcOXIEzs7O+OCDD/Reuy7n1mTOnDlISEjAsGHDEBERAVtbW2zbtg0XLlwAAJiZ/f//Z52dnZGUlIT169ejV69eMDMzQ+/evWvVnz7u7u6wsLCASqXCyJEjhfaq5+ESEhLg6OiIHj16ICsrC9u2batznzVRqVRwcXFB06ZNReuDsbcJz4gxxgSenp4gIri6usLS0lJrn1KpBBFBLpejf//+QvugQYOQkJCAs2fPYsSIEViyZAl8fX0REhKitw8rKyuMGTMGRUVFUCgU6NSpk84x3377LdauXYuMjAxMmDABPj4+WLp0Ke7du6fzcL0hz9WnVatWSE9PR6dOnTBjxgz4+/tDLpcjIiICALTW9Zo9ezZ8fX2xePFi9O3bF3369Kl1f/rI5XL4+vrqnemKjo5GQEAAVq5ciVGjRuH48eNISUkxSL/VlZeX49ChQ/D39xfl+oy9jSREvBgMY4zVVlBQELZv347S0lLI5XLR+zt16hT69OkDlUoFd3d30fvTJz4+HrNnz8a1a9d4RowxA+FCjDHGniMiIgKtWrWCg4MDysvLkZKSgg0bNiA0NFSYGTOG8ePH4969e6LNeD2LRqNB165dMWnSJOEXsYyxuuNnxBhj7DnMzc2xatUqFBUVQaPRoGPHjoiJicHs2bONGkd0dDTi4+NRVlZm9Bd/X7t2DQEBAfj444+N2i9jbzqeEWOMMcYYMxF+WJ8xxhhjzES4EGOMMcYYMxEuxBhjjDHGTIQLMcYYY4wxE+FCjDHGGGPMRLgQY4wxxhgzES7EGGOMMcZMhAsxxhhjjDET+R+62ltrCMiX/wAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=[5,5]) \n", - "weights = np.arange(0, len(analysis.output['wavelengths']))\n", - "norm = mpl.colors.Normalize(vmin=min(weights), vmax=max(weights))\n", - "cmap = mpl.cm.ScalarMappable(norm=norm, cmap='seismic')\n", - "circle1 = plt.Circle((0, 0), analysis.output['diameter']/2, color='black', fill=False, label='Aperture')\n", - "ax.add_patch(circle1) \n", - "plt.axvline(0,color='black',linestyle='--',linewidth=0.7,label=\"AD axis at {}\".format(analysis.input['centred_on']))\n", - "plt.scatter(0,-analysis.output['centre_shift'],label='Guide = {}um'.format(analysis.input['guide_waveref']),color='black',marker='+')\n", - "plt.xlim(-0.75,0.75)\n", - "plt.ylim(-0.75,0.75)\n", - "shifts=analysis.output['shifts']\n", - "for i in range(0,len(shifts[0])):\n", - " xs=[]\n", - " ys=[]\n", - " for o in range(0,len(shifts)):\n", - " xs.append(shifts[o][i][0])\n", - " ys.append(shifts[o][i][1]) \n", - " plt.plot(xs,ys,marker='x',color=cmap.to_rgba(i),label=\"{}um\".format(round(analysis.output['wavelengths'][i],4)))\n", - "plt.legend()\n", - "plt.xlabel(\"x (arcsec)\")\n", - "plt.ylabel(\"y (arcsec)\")\n", - "\n", - "plt.figure(figsize=[7,5])\n", - "plt.ylim(0,1.1) \n", - "plt.plot(analysis.output['wavelengths'],analysis.output['raw_integration_transmission'],label=\"Aperture Centre = {}um\".format(analysis.input['aperture_waveref']))\n", - "plt.xlabel(\"Wavelength (um)\")\n", - "plt.ylabel(\"Relative Mean Integration Transmissions\")\n", - "plt.axhline(y=1,label='No AD Transmission',color='black',linestyle='--')\n", - "plt.axvline(x=analysis.input['guide_waveref'],label=\"Guide = {}um\".format(analysis.input['guide_waveref']),color='black',linewidth=0.5)\n", - "plt.title(\"Dec: {} deg, HA: {}-{}h\".format(analysis.input['targ_dec'],analysis.input['HA_range'][0],analysis.input['HA_range'][-1]))\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(7, 73, 73)\n" - ] - } - ], - "source": [ - "print(np.shape(analysis.output['PSFs'][0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.15680023464656154\n", - "0.19465158916033667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure()\n", - "plt.imshow(analysis.output['aligned_PSFs'][-1][0])\n", - "plt.figure()\n", - "plt.imshow(analysis.output['PSFs'][-1][0])\n", - "plt.figure()\n", - "plt.imshow(analysis.output['aperture'])\n", - "plt.figure()\n", - "plt.imshow(analysis.output['PSFs_through_aperture'][-1][0])\n", - "\n", - "print(analysis.output['raw_transmissions'][-1][0])\n", - "print(analysis.output['no_AD_transmissions'][-1][0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "astrocondatest", - "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.13" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/scopesim/effects/atmo_disp_shifts_trans.py b/scopesim/effects/atmo_disp_shifts_trans.py new file mode 100644 index 00000000..12f7e456 --- /dev/null +++ b/scopesim/effects/atmo_disp_shifts_trans.py @@ -0,0 +1,268 @@ +import numpy as np +from astropy import units as u + +from astropy.coordinates import Angle + +import atmo_disp_shifts_trans_utils as disp_utils + +import matplotlib.pyplot as plt +import matplotlib as mpl +plt.style.use('bmh') + +class AD_simulation: + """ + Class to quantify atmospheric dispersion effects on a MOSAIC integration. + See .run for inputs and outputs + + Author: Jay Stephan + + Bugs/Issues: + HR is not currently implemented fully + """ + def __init__(self,**kwargs): + params = {'telescope_diameter':39, #m, diameter of telescope (ELT) + 'wavefront_outerscale':46, #m, wavefront out scale for FWHM change with airmass/wavelength + 'median_seeing':.68, #arcsec, median seeing at Paranal + 'median_seeing_wl':.5, #um, wavelength median seeing corresponds to + + 'latitude':-24.6272, #deg, MUST be negative (southern hemisphere) for now + 'temperature':10+273.15, #K, temperature at Paranal + 'humidity':14.5/100, #fraction, relative humidity at Paranal + 'pressure':750, #mbar, pressure at Paranal + + 'LR_VIS_major_axis':.702, #arcsec, major axis of observing modes apertures + 'LR_NIR_major_axis':.57, + 'HR_VIS_major_axis':.700, + 'HR_NIR_major_axis':.57, #This needs to be confirmed, but should be correct + + 'LR_VIS_B':[.390,.458], #um, MOSAIC bands + 'LR_VIS_G':[.450,.591], + 'LR_VIS_R':[.586,.770], + 'LR_VIS_All':[.390,.770], + 'LR_NIR_IY':[.770,1.063], + 'LR_NIR_J':[1.01,1.395], + 'LR_NIR_H':[1.420,1.857], + 'LR_NIR_All':[.770,1.857], + 'HR_VIS_G':[0,0], #HR values need to be confirmed, especially VIS + 'HR_VIS_R':[0,0], + 'HR_VIS_All':[0,0], + 'HR_NIR_J':[0,0], + 'HR_NIR_H':[0,0], + 'HR_NIR_All':[0,0], + + 'sim_scale':.005, #arcsec/pixel, scale to carry out the simulation - smaller is slower, more accurate + 'sim_HA_samples':21, #number of instantaneous snapshots to average over for the integration + 'relative_plate_PA_angle':0, #deg, relative angle of the plate/apertures and PA=0. For PA=0 along semi major axis, set to 90 deg + } + for kwarg in kwargs.items(): + params[kwarg[0]]=kwarg[1] + self.config=params + self.input={} + self.output={} + + def load_MOSAIC_band(self,band,sampling): + """ + Generates wavelengths for the simulation from the chosen band, + and acquires relevant diameter for the band (changes between LR/HR, and VIS/NIR) + """ + self.input['sampling']=sampling + self.input['band']=band + + wave_min,wave_max= self.config[band][0],self.config[band][1] + + self.output['wavelengths'] = np.arange(wave_min,wave_max,sampling) + self.output['major_axis']=self.config[band[0:6]+"_major_axis"] + + def load_HA(self,HA_start,HA_end,declination): + """ + + """ + HA_range=np.linspace(HA_start,HA_end,self.config['sim_HA_samples']) + self.input['HA_range']=HA_range + self.input['targ_dec']=declination + + #latitude needs to be negative for now + lat = self.config['latitude'] * np.pi/180 + dec = declination*np.pi/180 + + #Need to check if the target is below the horizon for the given list of HA, and if so remove it. + LHA_below_horizon=np.rad2deg(np.arccos(-np.tan(lat)*np.tan(dec)))/15 + if str(LHA_below_horizon) != 'nan': + for val in HA_range.copy(): + if abs(val) > abs(LHA_below_horizon): + print("At HA %2.2fh, target goes below horizon - removing this from HA range" % (val)) + HA_range.remove(val) + if dec > np.pi/2 + lat: #If the target has a too high declination, it will never be seen at Cerro Paranal + print("Target always below Horizon") + return + + airmasses=1/(np.sin(lat)*np.sin(dec)+np.cos(lat)*np.cos(dec)*np.cos(Angle(HA_range*u.hour).rad)) + self.output['airmasses']=np.array(airmasses) + + para_angles=disp_utils.parallatic_angle(np.array(HA_range),dec,lat) + self.output['raw_para_angles']=np.array(para_angles) #actual PAs + + def calculate_shifts(self, guide_waveref, aperture_waveref): + """ + + """ + self.input['guide_waveref']=guide_waveref + self.input['aperture_waveref']=aperture_waveref + + airmasses=self.output['airmasses'] + wavelengths=self.output['wavelengths'] + + #centring refers to the index of the hour angles at which we centre the aperture/guiding on a wavelength + centring_index=int((len(airmasses)-1)/2) + + centre_shift=disp_utils.diff_shift(aperture_waveref,airmasses[centring_index],guide_waveref,self.config) #shift of the original aperture centre wavelength from guide wavelength + centring_q=self.output['raw_para_angles'][centring_index] + + raw_para_angles=self.output['raw_para_angles'] + para_angles=self.output['raw_para_angles'].copy() + for i in range(0,len(para_angles)): #change in PAs from centring index + para_angles[i]=para_angles[i]-self.output['raw_para_angles'][centring_index] + + shifts_para=[] + phi=np.deg2rad(self.config['relative_plate_PA_angle']) + for count,airmass in enumerate(airmasses): #for each airmass, calculate AD shift + shift_vals=disp_utils.diff_shift(wavelengths,airmass,guide_waveref,self.config) + airmass_shifts=[] + + for i in range(0,len(shift_vals)): + x=(shift_vals[i])*np.sin(raw_para_angles[count])-centre_shift*np.sin(centring_q) + y=(shift_vals[i])*np.cos(raw_para_angles[count])-centre_shift*np.cos(centring_q) + airmass_shifts.append([x*np.cos(phi)-y*np.sin(phi),y*np.cos(phi)+x*np.sin(phi)]) + + shifts_para.append(airmass_shifts) + + self.output['shifts']=np.array(shifts_para) + centre_shift_para=[-centre_shift*np.sin(centring_q),-centre_shift*np.cos(centring_q)] + centre_shift_para=[centre_shift_para[0]*np.cos(phi)-centre_shift_para[1]*np.sin(phi), + centre_shift_para[1]*np.cos(phi)+centre_shift_para[0]*np.sin(phi)] + self.output['centre_shift']=centre_shift_para + + def load_PSFs(self): + """ + Generates the moffat PSFs - one for + """ + all_PSFs=[] + + for i in range(0,len(self.output['airmasses'])): + PSFs=disp_utils.make_moffat_PSFs(self.output['wavelengths'],self.output['shifts'][i], + self.output['airmasses'][i],self.output['major_axis'],self.config) + all_PSFs.append(PSFs) + + self.output['PSFs']=all_PSFs + + def load_aperture(self,band): + """ + Generates apertures, one for each fibre in the bundle + """ + apertures=disp_utils.make_aperture(band,self.output['major_axis'],self.config['sim_scale']) + self.output['apertures']=apertures + + def calculate_transmissions(self): + """ + Calculates the transmission of the PSFs through the apertures. + """ + apertures_resized = np.repeat(self.output['apertures'][:,np.newaxis], np.shape(self.output['PSFs'])[1], axis=1) + apertures_resized = np.repeat(apertures_resized[:,np.newaxis], np.shape(self.output['PSFs'])[0], axis=1) + + PSFs_through_apertures=apertures_resized*self.output['PSFs'] + self.output['PSFs_through_apertures']=PSFs_through_apertures + + transmissions=np.sum(PSFs_through_apertures,axis=(-1,-2)) + self.output['raw_transmissions']=transmissions + + integration_transmissions=np.mean(transmissions,axis=1) + self.output['raw_integration_transmissions']=integration_transmissions #collapsed along airmass axis + + def plots(self): + """ + Function to illustrate simulation + 1) Transmission vs wavelength curves for individual fibres and entire bundle + 2) Track plot of monochromatic spot PSFs on the aperture over an integration + """ + fig,ax=plt.subplots(figsize=[7,5]) + plt.ylim(0,0.1) + ax.set_ylabel("Individual Fibre Transmission") + for fibre_trans in self.output['raw_integration_transmissions']: + ax.plot(self.output['wavelengths'],fibre_trans,color='black',linewidth=0.5) + ax2=ax.twinx() + ax2.axhline(0,label="Individual Fibre",color='black',linewidth=0.5) + ax2.plot(self.output['wavelengths'],np.sum(self.output['raw_integration_transmissions'],axis=0),label="Bundle = {}um".format(self.input['aperture_waveref']),color='red') + plt.axvline(self.input['guide_waveref'],label="Guide = {}um".format(self.input['guide_waveref']),color='black',linestyle='--',linewidth=0.5) + ax2.set_ylabel("Bundle Transmission") + ax2.set_ylim(0,1) + ax.set_xlabel("Wavelength (um)") + plt.legend() + + fig, ax = plt.subplots(figsize=[5,5]) + weights = np.linspace(0, len(self.output['wavelengths'])-1,4) + norm = mpl.colors.Normalize(vmin=min(weights), vmax=max(weights)) + cmap = mpl.cm.ScalarMappable(norm=norm, cmap='seismic') + circle1 = plt.Circle((0, 0), self.output['major_axis']/2, color='black', fill=False, label='~Aperture') + ax.add_patch(circle1) + plt.axvline(0,color='black',linestyle='--',linewidth=0.7,label="PA = {}".format(self.config['relative_plate_PA_angle'])) + plt.scatter(self.output['centre_shift'][0],self.output['centre_shift'][1],label='Guide = {}um'.format(self.input['guide_waveref']),color='black',marker='+') + plt.xlim(-0.4,0.4) + plt.ylim(-0.4,0.4) + shifts=self.output['shifts'] + for i in weights: + xs,ys=[],[] + for o in range(0,len(shifts)): + xs.append(shifts[o][int(i)][0]) + ys.append(shifts[o][int(i)][1]) + plt.plot(xs,ys,marker='x',color=cmap.to_rgba(int(i)),label="{}um".format(round(self.output['wavelengths'][int(i)],4))) + plt.legend() + plt.xlabel("x (arcsec)") + plt.ylabel("y (arcsec)") + + def run(self,HA_start,HA_end,declination,band,sampling=0.01,guide_waveref=-1,aperture_waveref=-1): + """ + Function to run MOSAIC AD simulation for individual fibre transmission curves + INPUTS: + HA_start,HA_end: float, hours + HA values to start and end the simulated observation at + declination: float, degrees + Declination of the target in the simulated observation + band: string + Which MOSAIC observing band to carry out the simulation in. + Must be in the form "X_X_X", such as "LR_VIS_B" with the following options: + + {LR: {VIS: {B, G, R, All}, NIR: {IY, J, H, All}}, HR: {VIS: {G, R}, NIR: {IY, H}}} + + *HR not currently implemented* + + sampling: float, um + What interval in um to sample the wavelengths at, default 0.01um + guide_waveref, aperture_waveref: float, um + What wavelength to guide the telescope on and centre the apertures on halfway through the integration respectively + defaults (when values set to -1) are wavelengths halfway through the chosen band + + RETURNS: + wavelengths: 1D array of floats, um + wavelength samples the transmissions have been calculated for + fibre_transmissions: 2D array of floats, fraction + transmissions of each of the fibres for each different simulated wavelength. + first axis is the respective fibre, second axis is the wavelength + """ + self.load_HA(HA_start,HA_end,declination) + self.load_MOSAIC_band(band,sampling) + + if guide_waveref==-1 or aperture_waveref ==-1: + band_mid=round((self.output['wavelengths'][0]+self.output['wavelengths'][-1])/2,3) + guide_waveref,aperture_waveref=band_mid,band_mid + self.input['guide_waveref']=guide_waveref + self.input['aperture_waveref']=aperture_waveref + self.calculate_shifts(guide_waveref,aperture_waveref) + + self.load_aperture(band) + self.load_PSFs() + self.calculate_transmissions() + + wavelengths=self.output['wavelengths'] + fibre_transmissions=self.output['raw_integration_transmissions'] + + return wavelengths, fibre_transmissions diff --git a/scopesim/effects/atmo_disp_shifts_trans_utils.py b/scopesim/effects/atmo_disp_shifts_trans_utils.py index c6593b15..79ab8e33 100644 --- a/scopesim/effects/atmo_disp_shifts_trans_utils.py +++ b/scopesim/effects/atmo_disp_shifts_trans_utils.py @@ -1,25 +1,18 @@ - import math import numpy as np -from configobj import ConfigObj - from astropy.modeling.models import Moffat2D -from astropy.modeling.functional_models import Disk2D - -import matplotlib.pyplot as plt from astropy.coordinates import Angle from astropy import units as u +from matplotlib.path import Path -def calculate_FWHM(wavelength,airmass): - Config = ConfigObj('conf.ini') - - D = float(Config['Parameters']['telescope_diameter']) - L0 = float(Config['Parameters']['wavefront_outer_scale']) - median_seeing = float(Config['Seeing']['median_seeing']) - median_seeing_wl = float(Config['Seeing']['median_seeing_wl']) - +def calculate_FWHM(wavelength,airmass,config): + median_seeing=config['median_seeing'] + median_seeing_wl=config['median_seeing_wl'] + L0=config['wavefront_outerscale'] + D=config['telescope_diameter'] + r0=0.1*median_seeing**(-1)*(wavelength/median_seeing_wl)**1.2*airmass**(-0.6) F_kolb=1/(1+300*(D/L0))-1 @@ -30,53 +23,43 @@ def calculate_FWHM(wavelength,airmass): return FWHM_total -def make_moffat_PSFs(wavelengths,offsets,airmass,diameter,beta=2.5): +def make_moffat_PSFs(wavelengths,offsets,airmass,diameter,config,beta=2.5): + scale=config['sim_scale'] wavelengths,offsets = np.array(wavelengths),np.array(offsets) - Config = ConfigObj('conf.ini') - scale = float(Config['Sim_Parameters']['scale']) - boundary=math.ceil(diameter/2/scale) #radius of aperture in pixels - FWHMs = calculate_FWHM(wavelengths,airmass) + FWHMs = calculate_FWHM(wavelengths,airmass,config) x = np.arange(-boundary, boundary+1) y = np.arange(-boundary, boundary+1) x, y = np.meshgrid(x, y) PSFs=np.zeros((len(wavelengths),boundary*2+1,boundary*2+1)) - total_vals=[] - for count in range(0,len(wavelengths)): alpha=FWHMs[count]/scale/(2*np.sqrt(2**(1/beta)-1)) + moffat_total=(np.pi*alpha**2)/(beta-1) x_pos=offsets[count][0]/scale y_pos=offsets[count][1]/scale Moffat=Moffat2D(1,x_pos,y_pos,alpha,beta) Moffat_data=Moffat(x,y) - - PSFs[count]=Moffat_data - - moffat_total=(np.pi*alpha**2)/(beta-1) - total_vals.append(moffat_total) + PSFs[count]=Moffat_data/moffat_total - return PSFs,total_vals + return PSFs def parallatic_angle(HA,dec,lat): HA=Angle(HA*u.hour).rad q = np.arctan2(np.sin(HA),(np.cos(dec)*np.tan(lat)-np.sin(dec)*np.cos(HA))) return q -def diff_shift(wave, airmass, atm_ref_wav): +def diff_shift(wave, airmass, atm_ref_wav,config): + T = config['temperature'] + HR = config['humidity'] + P = config['pressure'] Lambda0 = atm_ref_wav wave = wave - config=ConfigObj('conf.ini') - - T = float(config["Environment"]["temperature"])+273.15 - HR = float(config["Environment"]["humidity"])/100 - P = float(config["Environment"]["pressure"]) - ZD_deg = airmass_to_zenith_dist(airmass) ZD = np.deg2rad(ZD_deg) @@ -90,10 +73,8 @@ def diff_shift(wave, airmass, atm_ref_wav): #dry air density Da = (1 + Pa * (57.90*1.0e-8 - 0.0009325/T + 0.25844/T**2)) * Pa/T - - #1 - P instead of 1 + Pa here? Why? Makes minimal affect of actual values... - #water vapour density ? + #water vapour density Dw = (1 + Pw * (1 + 3.7 * 1E-4 * Pw) * (- 2.37321 * 1E-3 + 2.23366/T - 710.792/T**2 + 77514.1/T**3)) * Pw/T @@ -114,108 +95,51 @@ def diff_shift(wave, airmass, atm_ref_wav): def airmass_to_zenith_dist(airmass): return np.rad2deg(np.arccos(1/airmass)) -def make_aperture(type,major_axis,hex_rotation=0): - config=ConfigObj('conf.ini') - scale=float(config['Sim_Parameters']['scale']) +def line(A,B): + m=(A[1]-B[1])/(A[0]-B[0]) + c=A[1]-m*A[0] + return m,c + +def make_aperture(band,major_axis,scale): + scale=scale boundary=math.ceil(major_axis/2/scale) #radius of aperture in pixels - if type == "circle": - - x = np.arange(-boundary, boundary+1) - y = np.arange(-boundary, boundary+1) - x, y = np.meshgrid(x, y) - - Disk=Disk2D(1,0,0,major_axis/2/scale) - aperture=Disk(x,y) - - return aperture - - if type == "hexagons": - sampling = major_axis/3/scale - aperture_array=np.zeros([boundary*2+1,boundary*2+1]) + if band[0:6]=="LR_VIS" or band[0:6]=="LR_NIR" or band[0:6]=="HR_NIR": + sampling = major_axis/3/scale + triangle_side=sampling*np.sqrt(3)/3 - core = 2 * triangle_side * np.cos(np.pi/4) aperture_centre=[boundary,boundary] - alpha = hex_rotation centre_0=aperture_centre - centre_1=[centre_0[0]+sampling*np.cos(np.pi/2-alpha),centre_0[1]+sampling-sampling*(1-np.sin(np.pi/2-alpha))] - centre_2=[centre_0[0]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6-alpha),centre_0[1]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6-alpha)] - centre_3=[centre_0[0]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6+alpha),centre_0[1]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6+alpha)] - centre_4=[centre_0[0]-sampling*np.cos(np.pi/2-alpha),centre_0[1]-sampling+sampling*(1-np.sin(np.pi/2-alpha))] - centre_5=[centre_0[0]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6-alpha),centre_0[1]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6-alpha)] - centre_6=[centre_0[0]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6+alpha),centre_0[1]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6+alpha)] + centre_1=[centre_0[0],centre_0[1]+sampling] + centre_2=[centre_0[0]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6),centre_0[1]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6)] + centre_3=[centre_0[0]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6),centre_0[1]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6)] + centre_4=[centre_0[0],centre_0[1]-sampling] + centre_5=[centre_0[0]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6),centre_0[1]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6)] + centre_6=[centre_0[0]-np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.cos(np.pi/6),centre_0[1]+np.sqrt((triangle_side*3/2)**2+(sampling/2)**2)*np.sin(np.pi/6)] centres=[centre_0,centre_1,centre_2,centre_3,centre_4,centre_5,centre_6] - for centre in centres: - if alpha == 0: - P1=[centre[0]+triangle_side*np.cos(np.pi*1/3-alpha),centre[1]+triangle_side*np.sin(np.pi/3-alpha)] - P2=[centre[0]+triangle_side*np.cos(alpha),centre[1]-triangle_side*np.sin(alpha)] - P3=[centre[0]+triangle_side*np.cos(np.pi/3+alpha),centre[1]-triangle_side*np.sin(np.pi/3+alpha)] - P4=[centre[0]-triangle_side*np.cos(np.pi/3-alpha),centre[1]-triangle_side*np.sin(np.pi/3-alpha)] - P5=[centre[0]-triangle_side*np.cos(-alpha),centre[1]-triangle_side*np.sin(-alpha)] - P6=[centre[0]-triangle_side*np.cos(np.pi/3+alpha),centre[1]+triangle_side*np.sin(np.pi/3+alpha)] - - L12_m,L12_c=line(P1,P2) - L23_m,L23_c=line(P2,P3) - L34_m,L34_c=line(P3,P4) - L45_m,L45_c=line(P4,P5) - L56_m,L56_c=line(P5,P6) - L61_m,L61_c=line(P6,P1) - - for y in range(0,len(aperture_array)): - for x in range(0,len(aperture_array)): - if x < centre_0[0] + triangle_side * 2 and x > centre_0[0] - triangle_side * 2 and y < centre_0[1] + sampling and y > centre_0[1] - sampling: - aperture_array[y][x]=1 - elif y < L61_m*x + L61_c and y > L34_m*x + L34_c and y < L12_m*x + L12_c and y > L23_m*x + L23_c and y > L45_m*x + L45_c and y < L56_m*x + L56_c: - aperture_array[y][x]=1 - - elif alpha != np.pi/6 and alpha != -np.pi/6: - P1=[centre[0]+triangle_side*np.cos(np.pi*1/3-alpha),centre[1]+triangle_side*np.sin(np.pi/3-alpha)] - P2=[centre[0]+triangle_side*np.cos(alpha),centre[1]-triangle_side*np.sin(alpha)] - P3=[centre[0]+triangle_side*np.cos(np.pi/3+alpha),centre[1]-triangle_side*np.sin(np.pi/3+alpha)] - P4=[centre[0]-triangle_side*np.cos(np.pi/3-alpha),centre[1]-triangle_side*np.sin(np.pi/3-alpha)] - P5=[centre[0]-triangle_side*np.cos(-alpha),centre[1]-triangle_side*np.sin(-alpha)] - P6=[centre[0]-triangle_side*np.cos(np.pi/3+alpha),centre[1]+triangle_side*np.sin(np.pi/3+alpha)] - - L12_m,L12_c=line(P1,P2) - L23_m,L23_c=line(P2,P3) - L34_m,L34_c=line(P3,P4) - L45_m,L45_c=line(P4,P5) - L56_m,L56_c=line(P5,P6) - L61_m,L61_c=line(P6,P1) - - for y in range(0,len(aperture_array)): - for x in range(0,len(aperture_array)): - if y > centre_0[1] - core and y < centre_0[1] + core and x > centre_0[1] - core and x < centre_0[1] + core: - aperture_array[y][x]=1 - elif y < L61_m*x + L61_c and y > L34_m*x + L34_c and y < L12_m*x + L12_c and y > L23_m*x + L23_c and y > L45_m*x + L45_c and y < L56_m*x + L56_c: - aperture_array[y][x]=1 - - elif alpha == np.pi/6 or alpha == - np.pi/6: - P1=[centre[0]+triangle_side*np.cos(np.pi/3-alpha),centre[1]+triangle_side*np.sin(np.pi/3-alpha)] - P2=[centre[0]+triangle_side*np.cos(alpha),centre[1]-triangle_side*np.sin(alpha)] - P3=[centre[0]+triangle_side*np.cos(np.pi/3+alpha),centre[1]-triangle_side*np.sin(np.pi/3+alpha)] - P4=[centre[0]-triangle_side*np.cos(np.pi/3-alpha),centre[1]-triangle_side*np.sin(np.pi/3-alpha)] - P5=[centre[0]-triangle_side*np.cos(-alpha),centre[1]-triangle_side*np.sin(-alpha)] - P6=[centre[0]-triangle_side*np.cos(np.pi/3+alpha),centre[1]+triangle_side*np.sin(np.pi/3+alpha)] - - L23_m,L23_c=line(P2,P3) - L34_m,L34_c=line(P3,P4) - L56_m,L56_c=line(P5,P6) - L61_m,L61_c=line(P6,P1) - - for y in range(0,len(aperture_array)): - for x in range(0,len(aperture_array)): - if y < centre_0[1] + triangle_side * 2 and y > centre_0[1] - triangle_side * 2 and x < centre_0[0] + sampling and x > centre_0[0] - sampling: - aperture_array[y][x]=1 - elif y < L61_m*x + L61_c and y > L34_m*x + L34_c and y > L23_m*x + L23_c and y < L56_m*x + L56_c and x > centre[0] - sampling/2 and x < centre[0] + sampling/2: - aperture_array[y][x]=1 - - return aperture_array - -def line(A,B): - m=(A[1]-B[1])/(A[0]-B[0]) - c=A[1]-m*A[0] - return m,c + apertures=np.zeros((7,boundary*2+1,boundary*2+1)) + for count,centre in enumerate(centres): + P1=[centre[0]+triangle_side*np.cos(np.pi*1/3),centre[1]+triangle_side*np.sin(np.pi/3)] + P2=[centre[0]+triangle_side,centre[1]] + P3=[centre[0]+triangle_side*np.cos(np.pi/3),centre[1]-triangle_side*np.sin(np.pi/3)] + P4=[centre[0]-triangle_side*np.cos(np.pi/3),centre[1]-triangle_side*np.sin(np.pi/3)] + P5=[centre[0]-triangle_side,centre[1]] + P6=[centre[0]-triangle_side*np.cos(np.pi/3),centre[1]+triangle_side*np.sin(np.pi/3)] + + polygon=[P1,P2,P3,P4,P5,P6] + height=boundary*2+1 + width=boundary*2+1 + poly_path=Path(polygon) + + x, y = np.mgrid[:height, :width] + coors=np.hstack((x.reshape(-1, 1), y.reshape(-1,1))) # coors.shape is (4000000,2) + + mask = poly_path.contains_points(coors) + mask=mask.reshape(height, width) + + apertures[count]=mask + + return apertures diff --git a/scopesim/effects/conf.ini b/scopesim/effects/conf.ini deleted file mode 100755 index b44900ed..00000000 --- a/scopesim/effects/conf.ini +++ /dev/null @@ -1,51 +0,0 @@ -[Parameters] - telescope_diameter = 39 #m - wavefront_outer_scale = 46 #m - -[Seeing] - median_seeing = .68 #arcsecs - median_seeing_wl = .5 #um - -[Aperture] - VIS_major_axis = .702 #arcsecs, VIS - NIR_major_axis = .570 #arcsecs, NIR - -[Sim_Parameters] - scale=0.01 - -[Environment] - latitude = -24.6272 #deg - temperature = 10 #deg - humidity = 14.5 #% - pressure = 750.0 #mBa - -[Bands] - [[LR]] - [[[VIS]]] - [[[[B]]]] - wave_min= .390 - wave_max= .458 - [[[[G]]]] - wave_min= .450 - wave_max= .591 - [[[[R]]]] - wave_min= .586 - wave_max= .770 - [[[[All]]]] - wave_min= .390 - wave_max= .770 - [[[NIR]]] - [[[[IY]]]] - wave_min= .770 - wave_max= 1.063 - [[[[J]]]] - wave_min= 1.010 - wave_max= 1.395 - [[[[H]]]] - wave_min= 1.420 - wave_max= .857 - [[[[All]]]] - wave_min= .770 - wave_max= 1.857 - - \ No newline at end of file From 820bb9d484b5cd7d989d37347328f044ec65147f Mon Sep 17 00:00:00 2001 From: Jay Stephan Date: Tue, 2 May 2023 14:43:01 +0100 Subject: [PATCH 3/7] Atmospheric Dispersion MOSAIC changes Cleaned up the code, added more comments for clarity, fixed HR NIR mode --- scopesim/effects/atmo_disp_shifts_trans.py | 47 +++++++++++-------- .../effects/atmo_disp_shifts_trans_utils.py | 4 -- 2 files changed, 27 insertions(+), 24 deletions(-) diff --git a/scopesim/effects/atmo_disp_shifts_trans.py b/scopesim/effects/atmo_disp_shifts_trans.py index 12f7e456..d8681b44 100644 --- a/scopesim/effects/atmo_disp_shifts_trans.py +++ b/scopesim/effects/atmo_disp_shifts_trans.py @@ -1,10 +1,7 @@ import numpy as np from astropy import units as u - from astropy.coordinates import Angle - import atmo_disp_shifts_trans_utils as disp_utils - import matplotlib.pyplot as plt import matplotlib as mpl plt.style.use('bmh') @@ -20,8 +17,9 @@ class AD_simulation: HR is not currently implemented fully """ def __init__(self,**kwargs): + #Simulation parameters for MOSAIC params = {'telescope_diameter':39, #m, diameter of telescope (ELT) - 'wavefront_outerscale':46, #m, wavefront out scale for FWHM change with airmass/wavelength + 'wavefront_outerscale':46, #m, wavefront outer scale for FWHM change with airmass/wavelength. Value to be confirmed. 'median_seeing':.68, #arcsec, median seeing at Paranal 'median_seeing_wl':.5, #um, wavelength median seeing corresponds to @@ -43,17 +41,17 @@ def __init__(self,**kwargs): 'LR_NIR_J':[1.01,1.395], 'LR_NIR_H':[1.420,1.857], 'LR_NIR_All':[.770,1.857], - 'HR_VIS_G':[0,0], #HR values need to be confirmed, especially VIS - 'HR_VIS_R':[0,0], - 'HR_VIS_All':[0,0], - 'HR_NIR_J':[0,0], - 'HR_NIR_H':[0,0], - 'HR_NIR_All':[0,0], + 'HR_VIS_G':[.510,.568], #HR values need to be confirmed, especially VIS + 'HR_VIS_R':[.610,.680], + 'HR_NIR_IY':[.770,.907], + 'HR_NIR_H':[1.523,1.658], + - 'sim_scale':.005, #arcsec/pixel, scale to carry out the simulation - smaller is slower, more accurate + 'sim_scale':.005, #arcsec/pixel, scale to carry out the simulation - smaller is slower, more accurate. Do not put above 0.01 'sim_HA_samples':21, #number of instantaneous snapshots to average over for the integration 'relative_plate_PA_angle':0, #deg, relative angle of the plate/apertures and PA=0. For PA=0 along semi major axis, set to 90 deg } + for kwarg in kwargs.items(): params[kwarg[0]]=kwarg[1] self.config=params @@ -75,7 +73,7 @@ def load_MOSAIC_band(self,band,sampling): def load_HA(self,HA_start,HA_end,declination): """ - + Calculates the airmasses to use in the simulation using the observation parameters (HA and dec) """ HA_range=np.linspace(HA_start,HA_end,self.config['sim_HA_samples']) self.input['HA_range']=HA_range @@ -104,7 +102,7 @@ def load_HA(self,HA_start,HA_end,declination): def calculate_shifts(self, guide_waveref, aperture_waveref): """ - + Calculates shifts of the wavelengths at the different airmasses using Fillipenko """ self.input['guide_waveref']=guide_waveref self.input['aperture_waveref']=aperture_waveref @@ -144,7 +142,7 @@ def calculate_shifts(self, guide_waveref, aperture_waveref): def load_PSFs(self): """ - Generates the moffat PSFs - one for + Generates the shifted moffat PSFs - one for for wavelength at each airmass """ all_PSFs=[] @@ -180,7 +178,7 @@ def calculate_transmissions(self): def plots(self): """ - Function to illustrate simulation + Function to illustrate simulation results 1) Transmission vs wavelength curves for individual fibres and entire bundle 2) Track plot of monochromatic spot PSFs on the aperture over an integration """ @@ -221,22 +219,30 @@ def plots(self): def run(self,HA_start,HA_end,declination,band,sampling=0.01,guide_waveref=-1,aperture_waveref=-1): """ - Function to run MOSAIC AD simulation for individual fibre transmission curves + Function to run MOSAIC AD simulation for individual fibre transmission curves. + Goes through multiple steps: + 1) Finds observation airmasses based on provided hour angles and declination + 2) Generates wavelengths to calculate transmission for based on the chosen MOSAIC observing band + 3) Calculates the shifts of these wavelengths at each airmass + 4) Generates aperture (for each fibre) + 5) Generates PSFs of the shifted moffats + 6) Calculates transmissions using apertures and PSFs + INPUTS: HA_start,HA_end: float, hours HA values to start and end the simulated observation at + declination: float, degrees Declination of the target in the simulated observation + band: string Which MOSAIC observing band to carry out the simulation in. Must be in the form "X_X_X", such as "LR_VIS_B" with the following options: - {LR: {VIS: {B, G, R, All}, NIR: {IY, J, H, All}}, HR: {VIS: {G, R}, NIR: {IY, H}}} - *HR not currently implemented* - sampling: float, um What interval in um to sample the wavelengths at, default 0.01um + guide_waveref, aperture_waveref: float, um What wavelength to guide the telescope on and centre the apertures on halfway through the integration respectively defaults (when values set to -1) are wavelengths halfway through the chosen band @@ -244,6 +250,7 @@ def run(self,HA_start,HA_end,declination,band,sampling=0.01,guide_waveref=-1,ape RETURNS: wavelengths: 1D array of floats, um wavelength samples the transmissions have been calculated for + fibre_transmissions: 2D array of floats, fraction transmissions of each of the fibres for each different simulated wavelength. first axis is the respective fibre, second axis is the wavelength @@ -256,8 +263,8 @@ def run(self,HA_start,HA_end,declination,band,sampling=0.01,guide_waveref=-1,ape guide_waveref,aperture_waveref=band_mid,band_mid self.input['guide_waveref']=guide_waveref self.input['aperture_waveref']=aperture_waveref - self.calculate_shifts(guide_waveref,aperture_waveref) + self.calculate_shifts(guide_waveref,aperture_waveref) self.load_aperture(band) self.load_PSFs() self.calculate_transmissions() diff --git a/scopesim/effects/atmo_disp_shifts_trans_utils.py b/scopesim/effects/atmo_disp_shifts_trans_utils.py index 79ab8e33..fbe0476e 100644 --- a/scopesim/effects/atmo_disp_shifts_trans_utils.py +++ b/scopesim/effects/atmo_disp_shifts_trans_utils.py @@ -1,8 +1,6 @@ import math import numpy as np - from astropy.modeling.models import Moffat2D - from astropy.coordinates import Angle from astropy import units as u from matplotlib.path import Path @@ -73,7 +71,6 @@ def diff_shift(wave, airmass, atm_ref_wav,config): #dry air density Da = (1 + Pa * (57.90*1.0e-8 - 0.0009325/T + 0.25844/T**2)) * Pa/T - #water vapour density Dw = (1 + Pw * (1 + 3.7 * 1E-4 * Pw) * (- 2.37321 * 1E-3 + 2.23366/T - 710.792/T**2 @@ -84,7 +81,6 @@ def diff_shift(wave, airmass, atm_ref_wav,config): N0_1 = (1.0E-8*((2371.34+683939.7/(130.0-S0**2)+4547.3/(38.9-S0**2))*Da + (6487.31+58.058*S0**2-0.71150*S0**4+0.08851*S0**6)*Dw)) - N_1 = 1.0E-8*((2371.34+683939.7/(130.0-S**2)+4547.3/(38.9-S**2))*Da + (6487.31+58.058*S**2-0.71150*S**4+0.08851*S**6)*Dw) From 75bb2845b49da54f0c3971e0ae973c467e2856b6 Mon Sep 17 00:00:00 2001 From: Kieran Leschinski Date: Tue, 2 May 2023 18:17:58 +0200 Subject: [PATCH 4/7] Renamed AO_simulation to AtmosDispFibreCoupling, added code to include it in an Effect object --- scopesim/effects/__init__.py | 3 + ....py => mosaic_atmo_disp_fibre_coupling.py} | 67 ++++++++++++++----- ... mosaic_atmo_disp_fibre_coupling_utils.py} | 1 + .../test_MosaicAtmosDispFibreCoupling.py | 32 +++++++++ 4 files changed, 87 insertions(+), 16 deletions(-) rename scopesim/effects/{atmo_disp_shifts_trans.py => mosaic_atmo_disp_fibre_coupling.py} (88%) rename scopesim/effects/{atmo_disp_shifts_trans_utils.py => mosaic_atmo_disp_fibre_coupling_utils.py} (99%) create mode 100644 scopesim/tests/tests_effects/test_MosaicAtmosDispFibreCoupling.py diff --git a/scopesim/effects/__init__.py b/scopesim/effects/__init__.py index e232667f..59658d69 100644 --- a/scopesim/effects/__init__.py +++ b/scopesim/effects/__init__.py @@ -17,5 +17,8 @@ from .fits_headers import * from .rotation import * +from .mosaic_atmo_disp_fibre_coupling import MosaicAtmosDispFibreCoupling +from . import mosaic_atmo_disp_fibre_coupling_utils + # from . import effects_utils diff --git a/scopesim/effects/atmo_disp_shifts_trans.py b/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py similarity index 88% rename from scopesim/effects/atmo_disp_shifts_trans.py rename to scopesim/effects/mosaic_atmo_disp_fibre_coupling.py index d8681b44..5efe9c36 100644 --- a/scopesim/effects/atmo_disp_shifts_trans.py +++ b/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py @@ -1,12 +1,40 @@ import numpy as np from astropy import units as u from astropy.coordinates import Angle -import atmo_disp_shifts_trans_utils as disp_utils import matplotlib.pyplot as plt import matplotlib as mpl -plt.style.use('bmh') -class AD_simulation: +from . import mosaic_atmo_disp_fibre_coupling_utils as disp_utils +from . import TERCurve + + +class MosaicAtmosDispFibreCoupling(TERCurve): + def __init__(self, **kwargs): + params = {"HA_start": 0, + "HA_end": 0, + "declination": 0, + "band": "HR_NIR_H", + "sampling": 0.01, # um + "guide_waveref": -1, + "aperture_waveref": -1} + + super(TERCurve, self).__init__() + self.meta.update(params) + self.meta.update(kwargs) + + self.coupling_fractions = AtmosDispFibreCoupling(**kwargs) + + def apply_to(self, obj, **kwargs): + + if isinstance(obj, SourceBase): + # return objects are: 1D wavelength, 2D transmission curves + waves, trans_arr = self.coupling_fractions.run() + + + return base + + +class AtmosDispFibreCoupling: """ Class to quantify atmospheric dispersion effects on a MOSAIC integration. See .run for inputs and outputs @@ -16,7 +44,7 @@ class AD_simulation: Bugs/Issues: HR is not currently implemented fully """ - def __init__(self,**kwargs): + def __init__(self, **kwargs): #Simulation parameters for MOSAIC params = {'telescope_diameter':39, #m, diameter of telescope (ELT) 'wavefront_outerscale':46, #m, wavefront outer scale for FWHM change with airmass/wavelength. Value to be confirmed. @@ -46,15 +74,15 @@ def __init__(self,**kwargs): 'HR_NIR_IY':[.770,.907], 'HR_NIR_H':[1.523,1.658], - 'sim_scale':.005, #arcsec/pixel, scale to carry out the simulation - smaller is slower, more accurate. Do not put above 0.01 'sim_HA_samples':21, #number of instantaneous snapshots to average over for the integration 'relative_plate_PA_angle':0, #deg, relative angle of the plate/apertures and PA=0. For PA=0 along semi major axis, set to 90 deg } - for kwarg in kwargs.items(): - params[kwarg[0]]=kwarg[1] - self.config=params + # for kwarg in kwargs.items(): + # params[kwarg[0]]=kwarg[1] + params.update(kwargs) + self.config = params self.input={} self.output={} @@ -182,6 +210,8 @@ def plots(self): 1) Transmission vs wavelength curves for individual fibres and entire bundle 2) Track plot of monochromatic spot PSFs on the aperture over an integration """ + plt.style.use('bmh') + fig,ax=plt.subplots(figsize=[7,5]) plt.ylim(0,0.1) ax.set_ylabel("Individual Fibre Transmission") @@ -217,7 +247,8 @@ def plots(self): plt.xlabel("x (arcsec)") plt.ylabel("y (arcsec)") - def run(self,HA_start,HA_end,declination,band,sampling=0.01,guide_waveref=-1,aperture_waveref=-1): + def run(self, HA_start, HA_end, declination, band, + sampling=0.01, guide_waveref=-1, aperture_waveref=-1): """ Function to run MOSAIC AD simulation for individual fibre transmission curves. Goes through multiple steps: @@ -228,7 +259,8 @@ def run(self,HA_start,HA_end,declination,band,sampling=0.01,guide_waveref=-1,ape 5) Generates PSFs of the shifted moffats 6) Calculates transmissions using apertures and PSFs - INPUTS: + Parameters + ---------- HA_start,HA_end: float, hours HA values to start and end the simulated observation at @@ -247,14 +279,17 @@ def run(self,HA_start,HA_end,declination,band,sampling=0.01,guide_waveref=-1,ape What wavelength to guide the telescope on and centre the apertures on halfway through the integration respectively defaults (when values set to -1) are wavelengths halfway through the chosen band - RETURNS: - wavelengths: 1D array of floats, um - wavelength samples the transmissions have been calculated for + Returns + ------- + wavelengths: 1D array of floats + [um] wavelength samples the transmissions have been calculated for - fibre_transmissions: 2D array of floats, fraction - transmissions of each of the fibres for each different simulated wavelength. - first axis is the respective fibre, second axis is the wavelength + fibre_transmissions: 2D array of floats, + [0..1] Transmissions of each of the fibres for each different + simulated wavelength. First axis is the respective fibre, + second axis is the wavelength """ + self.load_HA(HA_start,HA_end,declination) self.load_MOSAIC_band(band,sampling) diff --git a/scopesim/effects/atmo_disp_shifts_trans_utils.py b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py similarity index 99% rename from scopesim/effects/atmo_disp_shifts_trans_utils.py rename to scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py index fbe0476e..2efa4003 100644 --- a/scopesim/effects/atmo_disp_shifts_trans_utils.py +++ b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py @@ -5,6 +5,7 @@ from astropy import units as u from matplotlib.path import Path + def calculate_FWHM(wavelength,airmass,config): median_seeing=config['median_seeing'] median_seeing_wl=config['median_seeing_wl'] diff --git a/scopesim/tests/tests_effects/test_MosaicAtmosDispFibreCoupling.py b/scopesim/tests/tests_effects/test_MosaicAtmosDispFibreCoupling.py new file mode 100644 index 00000000..1d3c1668 --- /dev/null +++ b/scopesim/tests/tests_effects/test_MosaicAtmosDispFibreCoupling.py @@ -0,0 +1,32 @@ +import pytest +from pytest import approx + +import numpy as np +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from astropy import units as u + +from scopesim.effects import MosaicAtmosDispFibreCoupling +from scopesim import rc + +PLOTS = False + + +class TestInit: + def test_initialises_with_nothing(self): + fc = MosaicAtmosDispFibreCoupling() + assert isinstance(fc, MosaicAtmosDispFibreCoupling) + + def test_get_output_from_fibre_coupling_class(self): + """ + Not sure if this is a worthy test, but it shows me what I want to see + """ + + fc = MosaicAtmosDispFibreCoupling() + wave, trans = fc.coupling_fractions.run(0, 0, 0, "LR_NIR_H", 0.01, -1, -1) + for tran in trans: + assert np.all(tran > 0) + + +class TestApplyTo: + pass From 551a3909bfd82fbae54f14afa254cfb6f4511a98 Mon Sep 17 00:00:00 2001 From: Jay Stephan Date: Thu, 4 May 2023 16:31:52 +0100 Subject: [PATCH 5/7] MOSAIC Atmospheric Dispersion code structure changes 1) Added a class variable containing pd table of fibre dimensions, columns of fibre_id,dx,dy 2) Changed run function's transmission array to a dictionary with keys of fibre_id --- .../effects/mosaic_atmo_disp_fibre_coupling.py | 15 ++++++++++----- .../mosaic_atmo_disp_fibre_coupling_utils.py | 8 ++++++-- 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py b/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py index 5efe9c36..1c3bd643 100644 --- a/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py +++ b/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py @@ -185,8 +185,9 @@ def load_aperture(self,band): """ Generates apertures, one for each fibre in the bundle """ - apertures=disp_utils.make_aperture(band,self.output['major_axis'],self.config['sim_scale']) + apertures,apertures_table=disp_utils.make_aperture(band,self.output['major_axis'],self.config['sim_scale']) self.output['apertures']=apertures + self.apertures_table=apertures_table def calculate_transmissions(self): """ @@ -284,10 +285,10 @@ def run(self, HA_start, HA_end, declination, band, wavelengths: 1D array of floats [um] wavelength samples the transmissions have been calculated for - fibre_transmissions: 2D array of floats, + fibre_transmissions_dic: dictionary, containing 1D arrays of floats [0..1] Transmissions of each of the fibres for each different - simulated wavelength. First axis is the respective fibre, - second axis is the wavelength + simulated wavelength. Dictionary key is the fibre id, {0,1...}. + The 1D array axis is the wavelength """ self.load_HA(HA_start,HA_end,declination) @@ -307,4 +308,8 @@ def run(self, HA_start, HA_end, declination, band, wavelengths=self.output['wavelengths'] fibre_transmissions=self.output['raw_integration_transmissions'] - return wavelengths, fibre_transmissions + fibre_transmissions_dict={} + for count,fibre_transmission in enumerate(fibre_transmissions): + fibre_transmissions_dict[count]=fibre_transmission + + return wavelengths, fibre_transmissions_dict diff --git a/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py index 2efa4003..97481138 100644 --- a/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py +++ b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py @@ -4,7 +4,7 @@ from astropy.coordinates import Angle from astropy import units as u from matplotlib.path import Path - +import pandas as pd def calculate_FWHM(wavelength,airmass,config): median_seeing=config['median_seeing'] @@ -118,6 +118,7 @@ def make_aperture(band,major_axis,scale): centres=[centre_0,centre_1,centre_2,centre_3,centre_4,centre_5,centre_6] apertures=np.zeros((7,boundary*2+1,boundary*2+1)) + apertures_table=[] for count,centre in enumerate(centres): P1=[centre[0]+triangle_side*np.cos(np.pi*1/3),centre[1]+triangle_side*np.sin(np.pi/3)] P2=[centre[0]+triangle_side,centre[1]] @@ -138,5 +139,8 @@ def make_aperture(band,major_axis,scale): mask=mask.reshape(height, width) apertures[count]=mask + apertures_table.append([count,(centre[1]-aperture_centre[1])*scale,(centre[0]-aperture_centre[0])*scale]) - return apertures + apertures_table=pd.DataFrame(apertures_table,columns=['fibre_id','dx','dy']) + + return apertures,apertures_table From b75c894ae6549f5f63af40bfedcebc45655067ab Mon Sep 17 00:00:00 2001 From: Jay Stephan Date: Wed, 10 May 2023 16:53:12 +0100 Subject: [PATCH 6/7] MOSAIC Custom Hexagonal Aperture Implemented code to generate a hexagonal aperture array for an arbitrary number of rings HR_VIS now is working as a 3-layer hexagon array can be made --- .../mosaic_atmo_disp_fibre_coupling.py | 10 ++- .../mosaic_atmo_disp_fibre_coupling_utils.py | 79 ++++++++++++++++++- 2 files changed, 85 insertions(+), 4 deletions(-) diff --git a/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py b/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py index 1c3bd643..744379ff 100644 --- a/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py +++ b/scopesim/effects/mosaic_atmo_disp_fibre_coupling.py @@ -42,7 +42,7 @@ class AtmosDispFibreCoupling: Author: Jay Stephan Bugs/Issues: - HR is not currently implemented fully + HR Wavelength and aperture major axis values need to be confirmed """ def __init__(self, **kwargs): #Simulation parameters for MOSAIC @@ -57,9 +57,15 @@ def __init__(self, **kwargs): 'pressure':750, #mbar, pressure at Paranal 'LR_VIS_major_axis':.702, #arcsec, major axis of observing modes apertures + 'LR_VIS_hexagon_radius': 2, #radius of aperture hexagon array in hexagons 'LR_NIR_major_axis':.57, + 'LR_NIR_hexagon_radius': 2, 'HR_VIS_major_axis':.700, + 'HR_VIS_hexagon_radius': 3, 'HR_NIR_major_axis':.57, #This needs to be confirmed, but should be correct + 'HR_NIR_hexagon_radius': 2, + + 'custom_hexagon_radius': 0, #Change to be non-zero to overide aperture hexagon array 'LR_VIS_B':[.390,.458], #um, MOSAIC bands 'LR_VIS_G':[.450,.591], @@ -185,7 +191,7 @@ def load_aperture(self,band): """ Generates apertures, one for each fibre in the bundle """ - apertures,apertures_table=disp_utils.make_aperture(band,self.output['major_axis'],self.config['sim_scale']) + apertures,apertures_table=disp_utils.make_aperture(band,self.output['major_axis'],self.config) self.output['apertures']=apertures self.apertures_table=apertures_table diff --git a/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py index 97481138..32ac1449 100644 --- a/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py +++ b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py @@ -6,6 +6,7 @@ from matplotlib.path import Path import pandas as pd + def calculate_FWHM(wavelength,airmass,config): median_seeing=config['median_seeing'] median_seeing_wl=config['median_seeing_wl'] @@ -97,7 +98,7 @@ def line(A,B): c=A[1]-m*A[0] return m,c -def make_aperture(band,major_axis,scale): +def make_aperture_old(band,major_axis,scale): scale=scale boundary=math.ceil(major_axis/2/scale) #radius of aperture in pixels @@ -133,7 +134,7 @@ def make_aperture(band,major_axis,scale): poly_path=Path(polygon) x, y = np.mgrid[:height, :width] - coors=np.hstack((x.reshape(-1, 1), y.reshape(-1,1))) # coors.shape is (4000000,2) + coors=np.hstack((x.reshape(-1, 1), y.reshape(-1,1))) mask = poly_path.contains_points(coors) mask=mask.reshape(height, width) @@ -144,3 +145,77 @@ def make_aperture(band,major_axis,scale): apertures_table=pd.DataFrame(apertures_table,columns=['fibre_id','dx','dy']) return apertures,apertures_table + +def make_aperture(band,major_axis,config): + scale=float(config['sim_scale']) + boundary=math.ceil(major_axis/2/scale) #radius of aperture in pixels + + if config['custom_hexagon_radius'] != 0: + radius=config['custom_hexagon_radius'] + else: + radius=config[band[0:6]+"_hexagon_radius"] + sampling = major_axis/(2*radius-1)/scale + triangle_side=sampling*np.sqrt(3)/3 + aperture_centre=[boundary,boundary] + + centres_array=(cube_spiral([0,0],radius-1)) + q_vector=np.array([sampling/2,sampling/np.sqrt(3)*3/2]) + r_vector=np.array([sampling,0]) + + centres_xy_coords=[] + for array_val in centres_array: + xy_vals=np.array(array_val[0]*q_vector+array_val[1]*r_vector) + centres_xy_coords.append(xy_vals) + + apertures=np.zeros((len(centres_array),boundary*2+1,boundary*2+1)) + apertures_table=[] + for count,vals in enumerate(centres_xy_coords): + centre=[vals[1]+aperture_centre[0],vals[0]+aperture_centre[1]] + P1=[centre[0]+triangle_side*np.cos(np.pi*1/3),centre[1]+triangle_side*np.sin(np.pi/3)] + P2=[centre[0]+triangle_side,centre[1]] + P3=[centre[0]+triangle_side*np.cos(np.pi/3),centre[1]-triangle_side*np.sin(np.pi/3)] + P4=[centre[0]-triangle_side*np.cos(np.pi/3),centre[1]-triangle_side*np.sin(np.pi/3)] + P5=[centre[0]-triangle_side,centre[1]] + P6=[centre[0]-triangle_side*np.cos(np.pi/3),centre[1]+triangle_side*np.sin(np.pi/3)] + polygon=[P1,P2,P3,P4,P5,P6] + height=boundary*2+1 + width=boundary*2+1 + poly_path=Path(polygon) + + x, y = np.mgrid[:height, :width] + coors=np.hstack((x.reshape(-1, 1), y.reshape(-1,1))) + + mask = poly_path.contains_points(coors) + mask=mask.reshape(height, width) + + apertures[count]=mask + apertures_table.append([count,(vals[0])*scale,(vals[1])*scale]) + + apertures_table=pd.DataFrame(apertures_table,columns=['fibre_id','dx','dy']) + return apertures,apertures_table + +def cube_direction(direction): + direction_vectors=[[+1,0],[+1,-1],[0,-1],[-1,0],[-1,+1],[0,+1]] + return direction_vectors[direction] +def cube_add(hex,vec): + return [hex[0]+vec[0],hex[1]+vec[1]] +def cube_neighbor(cube,direction): + return cube_add(cube,cube_direction(direction)) +def cube_scale(hex, factor): + return [hex[0]*factor,hex[1]*factor] +def cube_ring(center, radius): + results = [] + hex = cube_add(center, + cube_scale(cube_direction(4), radius)) + for i in range(0,6): + for j in range(0,radius): + results.append(hex) + hex = cube_neighbor(hex, i) + return results +def cube_spiral(center, radius): + results = [center] + for k in range(1,radius+1): + ring_results=cube_ring(center, k) + for i in ring_results: + results.append(i) + return results \ No newline at end of file From 118092576e8dada3b38f955905901747ee7dce4b Mon Sep 17 00:00:00 2001 From: Jay Stephan Date: Thu, 11 May 2023 17:40:49 +0100 Subject: [PATCH 7/7] MOSAIC atmospheric dispersion aperture gaps fix Hexagonal aperture arrays were odd-sized with a central pixel This meant hexagons would leave a gap or overlap due to symmetry Fixed so that the arrays for the aperture and PSF arrays are now even-sized --- .../mosaic_atmo_disp_fibre_coupling_utils.py | 31 +++++++++---------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py index 32ac1449..f82d43fd 100644 --- a/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py +++ b/scopesim/effects/mosaic_atmo_disp_fibre_coupling_utils.py @@ -27,22 +27,22 @@ def make_moffat_PSFs(wavelengths,offsets,airmass,diameter,config,beta=2.5): scale=config['sim_scale'] wavelengths,offsets = np.array(wavelengths),np.array(offsets) - boundary=math.ceil(diameter/2/scale) #radius of aperture in pixels + pixel_radius=math.ceil(diameter/2/scale) #radius of aperture in pixels FWHMs = calculate_FWHM(wavelengths,airmass,config) - x = np.arange(-boundary, boundary+1) - y = np.arange(-boundary, boundary+1) + x = np.arange(0, pixel_radius*2) + y = np.arange(0, pixel_radius*2) x, y = np.meshgrid(x, y) - PSFs=np.zeros((len(wavelengths),boundary*2+1,boundary*2+1)) + PSFs=np.zeros((len(wavelengths),pixel_radius*2,pixel_radius*2)) for count in range(0,len(wavelengths)): alpha=FWHMs[count]/scale/(2*np.sqrt(2**(1/beta)-1)) moffat_total=(np.pi*alpha**2)/(beta-1) x_pos=offsets[count][0]/scale y_pos=offsets[count][1]/scale - Moffat=Moffat2D(1,x_pos,y_pos,alpha,beta) + Moffat=Moffat2D(1,x_pos+pixel_radius-0.5,y_pos+pixel_radius-0.5,alpha,beta) Moffat_data=Moffat(x,y) PSFs[count]=Moffat_data/moffat_total @@ -99,14 +99,13 @@ def line(A,B): return m,c def make_aperture_old(band,major_axis,scale): - scale=scale - boundary=math.ceil(major_axis/2/scale) #radius of aperture in pixels + pixel_radius=math.ceil(major_axis/2/scale) #radius of aperture in pixels if band[0:6]=="LR_VIS" or band[0:6]=="LR_NIR" or band[0:6]=="HR_NIR": sampling = major_axis/3/scale triangle_side=sampling*np.sqrt(3)/3 - aperture_centre=[boundary,boundary] + aperture_centre=[pixel_radius-0.5,pixel_radius-0.5] centre_0=aperture_centre centre_1=[centre_0[0],centre_0[1]+sampling] @@ -118,7 +117,7 @@ def make_aperture_old(band,major_axis,scale): centres=[centre_0,centre_1,centre_2,centre_3,centre_4,centre_5,centre_6] - apertures=np.zeros((7,boundary*2+1,boundary*2+1)) + apertures=np.zeros((7,pixel_radius*2,pixel_radius*2)) apertures_table=[] for count,centre in enumerate(centres): P1=[centre[0]+triangle_side*np.cos(np.pi*1/3),centre[1]+triangle_side*np.sin(np.pi/3)] @@ -129,8 +128,8 @@ def make_aperture_old(band,major_axis,scale): P6=[centre[0]-triangle_side*np.cos(np.pi/3),centre[1]+triangle_side*np.sin(np.pi/3)] polygon=[P1,P2,P3,P4,P5,P6] - height=boundary*2+1 - width=boundary*2+1 + height=pixel_radius*2 + width=pixel_radius*2 poly_path=Path(polygon) x, y = np.mgrid[:height, :width] @@ -148,7 +147,7 @@ def make_aperture_old(band,major_axis,scale): def make_aperture(band,major_axis,config): scale=float(config['sim_scale']) - boundary=math.ceil(major_axis/2/scale) #radius of aperture in pixels + pixel_radius=math.ceil(major_axis/2/scale) #radius of aperture in pixels if config['custom_hexagon_radius'] != 0: radius=config['custom_hexagon_radius'] @@ -156,7 +155,7 @@ def make_aperture(band,major_axis,config): radius=config[band[0:6]+"_hexagon_radius"] sampling = major_axis/(2*radius-1)/scale triangle_side=sampling*np.sqrt(3)/3 - aperture_centre=[boundary,boundary] + aperture_centre=[pixel_radius-0.5,pixel_radius-0.5] centres_array=(cube_spiral([0,0],radius-1)) q_vector=np.array([sampling/2,sampling/np.sqrt(3)*3/2]) @@ -167,7 +166,7 @@ def make_aperture(band,major_axis,config): xy_vals=np.array(array_val[0]*q_vector+array_val[1]*r_vector) centres_xy_coords.append(xy_vals) - apertures=np.zeros((len(centres_array),boundary*2+1,boundary*2+1)) + apertures=np.zeros((len(centres_array),pixel_radius*2,pixel_radius*2)) apertures_table=[] for count,vals in enumerate(centres_xy_coords): centre=[vals[1]+aperture_centre[0],vals[0]+aperture_centre[1]] @@ -178,8 +177,8 @@ def make_aperture(band,major_axis,config): P5=[centre[0]-triangle_side,centre[1]] P6=[centre[0]-triangle_side*np.cos(np.pi/3),centre[1]+triangle_side*np.sin(np.pi/3)] polygon=[P1,P2,P3,P4,P5,P6] - height=boundary*2+1 - width=boundary*2+1 + height=pixel_radius*2 + width=pixel_radius*2 poly_path=Path(polygon) x, y = np.mgrid[:height, :width]