diff --git a/edge_files/graphite_xs.fits b/edge_files/graphite_xs.fits index fd55936..3e234fe 100644 Binary files a/edge_files/graphite_xs.fits and b/edge_files/graphite_xs.fits differ diff --git a/edge_files/silicate_xs.fits b/edge_files/silicate_xs.fits index 272860f..6fd15b5 100644 Binary files a/edge_files/silicate_xs.fits and b/edge_files/silicate_xs.fits differ diff --git a/edge_files/xs_ext_grid.fits b/edge_files/xs_ext_grid.fits index d87b868..d60248a 100644 Binary files a/edge_files/xs_ext_grid.fits and b/edge_files/xs_ext_grid.fits differ diff --git a/ismdust.f90 b/ismdust.f90 index 17286ff..7684bf3 100755 --- a/ismdust.f90 +++ b/ismdust.f90 @@ -10,9 +10,9 @@ subroutine ismdust(ear, ne, param, ifl, photar) implicit none integer,parameter :: num_param = 3 integer,parameter :: ngrain=1 -integer,parameter :: nemod=25800 !Number of elements for each cross section. +integer,parameter :: nemod=25530 !Number of elements for each cross section. integer :: ne, ifl, a -double precision :: msil, mgra, rshift, emod(1:nemod), coemod(nemod) +double precision :: msil, mgra, rshift, emod(nemod), coemod(nemod) double precision :: bxs(0:ngrain,nemod), bener(nemod) double precision :: zfac real :: ear(0:ne), param(num_param), photar(ne) @@ -27,12 +27,9 @@ subroutine ismdust(ear, ne, param, ifl, photar) print *, 'WARNING: If used in conjunction with neutral metal absorption models' print *, '(e.g. TBabs, TBnew), be sure to change abundances to stop' print *, 'from overestimating the ISM metal absorption component.' - print *, '##-------------------------------------------------------------------##' - print *, '!! ISMdust is best as a template for absorption edges, not continuum !!' - print *, '##-------------------------------------------------------------------##' print *, ' ' call read_cross_sections_ismdust(nemod,bxs,ifl,bener) - startup=.false. + startup=.false. endif ! Model parameters msil = param(1) @@ -75,7 +72,7 @@ subroutine read_cross_sections_ismdust(bnene,xs,ifl,ener) character (len=255) :: fgmstr external :: fgmstr !Number of elements for each grain type cross section. -nemax=25800 +nemax=25530 ! Where do we look for the data? ismdust_root = trim(fgmstr('ISMDUSTROOT')) if (ismdust_root .EQ. '') then @@ -98,15 +95,15 @@ subroutine read_cross_sections_ismdust(bnene,xs,ifl,ener) !Read in one energy grid (column 1) colnum=1 do j=1,nemax -call ftgcvd(inunit,colnum,j,felem,1,nulld,ener(j),anynull,status) + call ftgcvd(inunit,colnum,j,felem,1,nulld,ener(j),anynull,status) enddo !Read in the cross section information do i=0,ngrain -colnum=i+2 -do j=1,nemax -call ftgcvd(inunit,colnum,j,felem,1,nulld,xs(i,j),anynull,status) -enddo + colnum=i+2 + do j=1,nemax + call ftgcvd(inunit,colnum,j,felem,1,nulld,xs(i,j),anynull,status) + enddo enddo ! Report on errors (done before closing the file in case the error @@ -116,7 +113,7 @@ subroutine read_cross_sections_ismdust(bnene,xs,ifl,ener) ! the first time it is used. An alternative would be to use xwrite() ! with a low chatter level. ! -! This message could be displayed only once, but it is probaly worth +! This message could be displayed only once, but it is probably worth ! repeating each time it is used. if (status .ne. 0) then write (*,*) 'ERROR: unable to read cross sections from ', filename2 @@ -136,18 +133,17 @@ subroutine extinction_ismdust(msil, mgra, zfac, e1, bnene, coeff, bxs2,ifl,bener integer :: bnene, ifl integer :: i, j double precision :: msil, mgra -double precision :: bener(0:bnene), bxs2(0:ngrain,bnene), e1(0:bnene) +double precision :: bener(bnene), bxs2(0:ngrain,bnene), e1(bnene) double precision :: tau, coeff(bnene) double precision :: zfac real hphoto, gphoto external hphoto, gphoto ! Calculates the optical depth and the extinction coefficient exp(-tau) -e1(0)=(bener(0)*zfac)/1.d3 do i=1,bnene -e1(i)=(bener(i)*zfac)/1.d3 -tau=mgra*bxs2(1,i) + msil*bxs2(0,i) -coeff(i)=dexp(-tau) + e1(i) = (bener(i)*zfac)/1.d3 + tau = msil * bxs2(0,i) + mgra * bxs2(1,i) + coeff(i) = dexp(-tau) enddo end subroutine extinction_ismdust @@ -155,44 +151,32 @@ end subroutine extinction_ismdust subroutine map_to_grid_ismdust(new_en,nne,old_en, one, nflux, old_flu,ifl) ! This routine maps to a given grid implicit none -integer :: i, j, k, one, nne, bmin, bmax,ifl +integer :: i, j, k, one, nne, bmin, bmax, ifl, btemp double precision :: new_en(0:nne) -double precision :: old_en(0:one), old_flu(one) -double precision :: stemp,etemp, s, etemp2 +double precision :: old_en(one), old_flu(one) +double precision :: etemp, s real :: nflux(nne) integer,parameter :: out_unit=20 do i=1,nne -nflux(i)=real(0.d0) -call dbinsrch_ismdust(new_en(i-1),bmin,old_en,one+1) -call dbinsrch_ismdust(new_en(i),bmax,old_en,one+1) -bmin = bmin-1 -bmax = bmax-1 -! Linear interpolation -if (bmin.eq.bmax) then -if(new_en(i).le.old_en(1))then -s=real(old_flu(1)) -else if(new_en(i).gt.old_en(one))then -s=real(old_flu(one)) -else -do j=2,one -if(new_en(i).gt.old_en(j-1).and.new_en(i).le.old_en(j))then -etemp2=(new_en(i)+new_en(i-1))/2 -s=old_flu(j-1)+(old_flu(j)-old_flu(j-1))*(etemp2-old_en(j-1))/(old_en(j)-old_en(j-1)) -endif -enddo -endif -! Average (integral) -else -stemp=0.d0 -etemp=0.d0 -do k=bmin,bmax -stemp=stemp+(old_flu(k))*(old_en(k)-old_en(k-1)) -etemp=etemp+(old_en(k)-old_en(k-1)) -enddo -s=real(stemp/etemp) -endif -nflux(i)=real(s) -enddo + nflux(i)=0. + call dbinsrch_ismdust(new_en(i-1),bmin,old_en,one+1) + call dbinsrch_ismdust(new_en(i),bmax,old_en,one+1) + etemp = (new_en(i)+new_en(i-1))/2 + ! Linear interpolation + if (bmin.eq.bmax) then + if(new_en(i).le.old_en(0)) then + s = real(old_flu(1)) + else if(new_en(i).gt.old_en(one)) then + s = real(old_flu(one)) + else + s = old_flu(bmin) + (old_flu(bmax+1)-old_flu(bmin)) * (etemp-old_en(bmin)) / (old_en(bmax+1)-old_en(bmin)) + endif + else + call dbinsrch_olivine(etemp,btemp,old_en,one+1) + s = old_flu(btemp) + (old_flu(btemp+1)-old_flu(btemp)) * (etemp-old_en(btemp)) / (old_en(btemp+1)-old_en(btemp)) + endif + nflux(i) = real(s) + enddo end subroutine map_to_grid_ismdust ! ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc subroutine dbinsrch_ismdust(e,k,ener,n) @@ -222,4 +206,3 @@ subroutine dbinsrch_ismdust(e,k,ener,n) endif k=klo end subroutine dbinsrch_ismdust - diff --git a/make_xs_ext.py b/make_xs_ext.py index 61bd220..39c83f3 100755 --- a/make_xs_ext.py +++ b/make_xs_ext.py @@ -1,14 +1,26 @@ #! /usr/bin/env python """ - make_xs_ext.py -- A generic python script for making the extinction + make_xs_ext.py -- A generic python script for making the extinction cross-section for use in XSPEC model ISMdust. - - Modify the magic numbers at the beginning of this file to change the + + Modify the magic numbers at the beginning of this file to change the grain size distribution and other dust properties. - + + To remake the silicate cross-sections: + ./make_xs_ext sil + To remake the graphite cross-sections: + ./make_xs_ext gra + + To construct the master extinction file for XSPEC model, run each command + above, individually, and then run: + ./make_xs_ext combine + This will make edge_files/xs_ext_grid.fits from the two existing files: + edge_files/silicate_xs.fits and edge_files/graphite_xs.fits + Created by: Lia Corrales (lia@space.mit.edu) 2015.11.18 + 2016.06.25 -- updated for use with eblur/newdust """ import numpy as np @@ -22,14 +34,13 @@ import os import sys -## Requires installation of github.com/eblur/dust -import dust -import sigma_scat as ss +## Requires installation of github.com/eblur/newdust +import newdust ##-------------- Magic numbers, feel free to change -------------------## ## Silicate grain properties -_amin_s = 0.005 +_amin_s = 0.005 _amax_s = 0.3 # min and max grain radius [um] _p_s = 3.5 # power law slope for grain size distribution _rho_s = 3.8 # dust grain density [g cm^-3] @@ -41,11 +52,11 @@ _p_g = 3.5 # power law slope for grain size distribution _rho_g = 2.2 # dust grain density [g cm^-3] _grafile = 'graphite_xs.fits' -_smooth_graphite_xs = True -# ^ Change to False to remove power law approximation +_smooth_graphite_xs = True +# ^ Change to False to remove power law approximation # on high E side of graphite cross section -_myname = 'lia@space.mit.edu' +_myname = 'liac@umich.edu' _outdir = 'edge_files/' # file output directory ##-------------- Do not change these values --------------------------## @@ -61,22 +72,28 @@ _hc = (_h*_c) / (_keV*_angs) # keV angs -## Final energy grid to use +## Final energy grid to use ## NOTE: ismdust model will break if you change the number of elements in the grid -_dangs = 0.005 -_AGRID = np.arange(1.0,130.0,_dangs) # wavelength [angs] -_EGRID = _hc / (_AGRID[::-1]) # keV -_FINAL_FILE = 'xs_ext_grid.fits' +_FeK = np.arange(1.5, 1.91, 0.005) # 5 eV resolution in Fe K region +_Atemp = np.arange(1.0,130.0, 0.005) # 5 mAngstrom resolution everywhere else +_Etemp = _hc / (_Atemp[::-1]) # keV -print("Creating a final energy grid of length %d" % (len(_EGRID)) ) +# Final energy grid (keV) +_EGRID = np.append(np.append(_Etemp[_Etemp < _FeK[0]], _FeK), + _Etemp[_Etemp > _FeK[-1]]) -_egrid_lores = np.logspace(-1.3, 1.1, 100.0) +_FINAL_FILE = 'xs_ext_grid.fits' +# Low resulotion grids for computing +# This is for computing the cross-sections, then later +# we will interpolate those cross-sections onto _EGRID +_egrid_lores = np.logspace(-1.3, 1.1, 100.0) # Energy grids for particular edges -_ANGSTROMS_OK = np.linspace(22.0, 28.0, 1200) -_ANGSTROMS_FeL = np.linspace(15.0, 21.0, 1200) -_ANGSTROMS_MgSi = np.linspace(5.0, 11.0, 1200) -_ANGSTROMS_CK = np.linspace(35, 48, 2600) +_ANGSTROMS_OK = np.linspace(22.0, 28.0, 1200) # 5 mA resolution +_ANGSTROMS_FeL = np.linspace(15.0, 21.0, 1200) # 5 mA resolution +_ANGSTROMS_MgSi = np.linspace(5.0, 11.0, 1200) # 5 mA resolution +_ANGSTROMS_FeK = np.linspace(1.5, 1.9, 250) # 16 mA resolution +_ANGSTROMS_CK = np.linspace(35, 48, 2600) # 5 mA resolution ##-------------- Supporting structures and functions -----------------## @@ -85,7 +102,7 @@ def __init__(self, filename): data = fits.open(filename)[1].data self.energy = data['energy'] self.tauext = data['ext'] - + def __call__(self, e): result = interp1d(self.energy, self.tauext) return result(e) @@ -100,20 +117,30 @@ def _insert_edge_grid(lores_grid, edge_grid): result = np.append(result, lores_grid[lores_grid > emax]) return result +def _insert_xsect(lores_grid, edge_grid, lores_xsect, edge_xsect): + emin = edge_grid[0] + emax = edge_grid[-1] + + result = np.array([]) + result = np.append(result, lores_xsect[lores_grid < emin]) + result = np.append(result, edge_xsect) + result = np.append(result, lores_xsect[lores_grid > emax]) + return result + def _write_all_xs_fits(filename, egrid, xs_ext, xs_sca, params, clobber=True): - + amin, amax, p, rho, mdust, gtype = params - + col1 = fits.Column(name='energy', format='E', array=egrid) col2 = fits.Column(name='angstroms', format='E', array=_hc/egrid) col3 = fits.Column(name='ext', format='E', array=xs_ext) col4 = fits.Column(name='sca', format='E', array=xs_sca) col5 = fits.Column(name='abs', format='E', array=xs_ext-xs_sca) - + cols = fits.ColDefs([col1,col2,col3,col4,col5]) tbhdu = fits.BinTableHDU.from_columns(cols) #tbhdu.writeto(filename) - + prihdr = fits.Header() prihdr['AMIN'] = "%.3f" % (amin) prihdr['AMAX'] = "%.3f" % (amax) @@ -123,16 +150,11 @@ def _write_all_xs_fits(filename, egrid, xs_ext, xs_sca, params, clobber=True): prihdr['GTYPE'] = gtype prihdr['COMMENT'] = "Created by %s on %s" % (_myname, datetime.date.today()) prihdu = fits.PrimaryHDU(header=prihdr) - + thdulist = fits.HDUList([prihdu, tbhdu]) - thdulist.writeto(filename, clobber=clobber) + thdulist.writeto(filename, overwrite=clobber) return -def _dustspec(params): - amin, amax, p, rho, mdust, gtype = params - radii = dust.Dustdist(rad=np.linspace(amin,amax,_na), p=p, rho=rho) - return dust.Dustspectrum(md=_mdust, rad=radii) - def _tau_scat_E( E, params ): amin, amax, p, rho, mdust, gtype = params result = ss.Kappascat(E=E, dist=_dustspec(params), scatm=ss.makeScatmodel('Mie',gtype)) @@ -145,79 +167,90 @@ def _tau_ext_E( E, params ): ##-------------- Compute silicate values --------------## -def silicate_xs( nproc=4 ): - egrid_sil = np.copy(_egrid_lores) - for edge in [_ANGSTROMS_OK, _ANGSTROMS_FeL, _ANGSTROMS_MgSi]: - egrid_sil = _insert_edge_grid(egrid_sil, _hc/edge[::-1]) - - print(egrid_sil) - +def silicate_xs(): + region_list = [_ANGSTROMS_OK, _ANGSTROMS_FeL, _ANGSTROMS_MgSi, _ANGSTROMS_FeK] + sil_params = [_amin_s, _amax_s, _p_s, _rho_s, _mdust, 'Silicate'] print("Making Silicate cross section with\n\tamin=%.3f\n\tamax=%.3f\n\tp=%.2f\n\trho=%.2f" \ % (_amin_s, _amax_s, _p_s, _rho_s) ) print("Output will be sent to %s" % (_outdir+_silfile)) - - """ - def _tau_sca(E): - result = ss.Kappascat(E=E, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate')) - return result.kappa[0] * _mdust - - def _tau_ext(E): - result = ss.Kappaext(E=E, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate')) - return result.kappa[0] * _mdust - - pool = multiprocessing.Pool(processes=nproc) - sca_sil = pool.map(_tau_sca, egrid_sil) - ext_sil = pool.map(_tau_ext, egrid_sil) - pool.close()""" - - Ksca_sil = ss.Kappascat(E=egrid_sil, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate')) - Kext_sil = ss.Kappaext(E=egrid_sil, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate')) - - sca_sil = Ksca_sil.kappa * _mdust - ext_sil = Kext_sil.kappa * _mdust - + + sil_comp = newdust.graindist.composition.CmSilicate(rho=_rho_s) + sil_gpop = newdust.SingleGrainPop('Powerlaw', sil_comp, 'Mie', + md=_mdust, amin=_amin_s, amax=_amax_s, p=_p_s) + + # do the calculation piece-by-piece + sil_sca_by_reg = [] + sil_ext_by_reg = [] + for reg in region_list: + sil_gpop.calculate_ext(_hc/reg[::-1], unit='kev') + sil_sca_by_reg.append(sil_gpop.tau_sca) + sil_ext_by_reg.append(sil_gpop.tau_ext) + + sil_gpop.calculate_ext(_egrid_lores, unit='kev') + # cobble together the final cross-sections + sca_sil = np.copy(sil_gpop.tau_sca) + egrid_sil = np.copy(_egrid_lores) + for reg, xsect in zip(region_list, sil_sca_by_reg): + sca_sil = _insert_xsect(egrid_sil, _hc/reg[::-1], sca_sil, xsect) + egrid_sil = _insert_edge_grid(egrid_sil, _hc/reg[::-1]) + + ext_sil = np.copy(sil_gpop.tau_ext) + egrid_sil2 = np.copy(_egrid_lores) + for reg, xsect in zip(region_list, sil_ext_by_reg): + ext_sil = _insert_xsect(egrid_sil2, _hc/reg[::-1], ext_sil, xsect) + egrid_sil2 = _insert_edge_grid(egrid_sil2, _hc/reg[::-1]) + _write_all_xs_fits(_outdir+_silfile, egrid_sil, ext_sil, sca_sil, sil_params) return ##-------------- Compute graphite values --------------## -def graphite_xs( nproc=4 ): +def graphite_xs(): egrid_gra = np.copy(_egrid_lores) - egrid_gra = _insert_edge_grid(egrid_gra, _hc/_ANGSTROMS_OK[::-1]) - + egrid_CK = _hc/_ANGSTROMS_CK[::-1] + egrid_gra = _insert_edge_grid(egrid_gra, egrid_CK) + gra_params = [_amin_g, _amax_g, _p_g, _rho_g, _mdust, 'Graphite'] print("Making Graphite cross section with\n\tamin=%.3f\n\tamax=%.3f\n\tp=%.2f\n\trho=%.2f" \ % (_amin_g, _amax_g, _p_g, _rho_g)) print("Output will be sent to %s" % (_outdir+_grafile)) - - """ - def _tau_sca(E): - result = ss.Kappascat(E=E, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite')) - return result.kappa[0] * _mdust - - def _tau_ext(E): - result = ss.Kappascat(E=E, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite')) - return result.kappa[0]] * _mdust - - pool = multiprocessing.Pool(processes=nproc) - sca_gra = pool.map(_tau_sca, egrid_gra) - ext_sil = pool.map(_tau_ext, egrid_gra) - pool.close()""" - - Ksca_gra = ss.Kappascat(E=egrid_gra, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite')) - Kext_gra = ss.Kappaext(E=egrid_gra, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite')) - - sca_gra = Ksca_gra.kappa * _mdust - ext_gra = Kext_gra.kappa * _mdust - + + # Have to do the calculation for each orientation + gra_para = newdust.graindist.composition.CmGraphite(rho=_rho_g, orient='para') + gra_perp = newdust.graindist.composition.CmGraphite(rho=_rho_g, orient='perp') + + gra_gpop_para = newdust.SingleGrainPop('Powerlaw', gra_para, 'Mie', + md=_mdust, amin=_amin_g, amax=_amax_g, p=_p_g) + gra_gpop_perp = newdust.SingleGrainPop('Powerlaw', gra_perp, 'Mie', + md=_mdust, amin=_amin_g, amax=_amax_g, p=_p_g) + + # Follow the graphie grain assumption Draine + # 1/3 parallel and 2/3 perpendicular + orient_frac = [1./3., 2./3.] + + # do the calculation for each orientation + gra_sca, gra_ext = 0.0, 0.0 # lores version + gra_sca_CK, gra_ext_CK = 0.0, 0.0 # hires C K edge region + for f, gp in zip(orient_frac, [gra_gpop_para, gra_gpop_perp]): + gp.calculate_ext(_hc/_ANGSTROMS_CK[::-1], unit='kev') + gra_sca_CK += f * gp.tau_sca + gra_ext_CK += f * gp.tau_ext + gp.calculate_ext(_egrid_lores, unit='kev') + gra_sca += f * gp.tau_sca + gra_ext += f * gp.tau_ext + + # cobble together the final cross-sections + ext_gra = _insert_xsect(_egrid_lores, egrid_CK, gra_ext, gra_ext_CK) + sca_gra = _insert_xsect(_egrid_lores, egrid_CK, gra_sca, gra_sca_CK) + # smooth the xs behavior for energies > esmooth def _smooth_xs(esmooth, xs, pslope): ipow = np.where(egrid_gra >= esmooth)[0] # closest value to the desired esmooth value result = np.copy(xs) result[ipow] = xs[ipow[0]] * np.power(egrid_gra[ipow]/egrid_gra[ipow[0]], pslope) return result - + if _smooth_graphite_xs: ESMOOTH, PSCA, PABS = 1.0, -2.0, -2.9 # determined by hand print("Smoothing Graphite cross section with\n\tp=%.2f (scattering)\n\tp=%.2f (absorption)" % (PSCA,PABS)) @@ -227,7 +260,7 @@ def _smooth_xs(esmooth, xs, pslope): _write_all_xs_fits(_outdir+_grafile, egrid_gra, new_ext_gra, new_sca_gra, gra_params) else: _write_all_xs_fits(_outdir+_grafile, egrid_gra, ext_gra, sca_gra, gra_params) - + return ##-------------- Combine both into one fits file --------------## @@ -235,30 +268,30 @@ def _smooth_xs(esmooth, xs, pslope): def make_xs_fits(clobber=True): sil = Xsect(_outdir+_silfile) gra = Xsect(_outdir+_grafile) - + col1 = fits.Column(name='energy', format='E', array=_EGRID*1.e3) # units of eV col2 = fits.Column(name='sil_ext', format='E', array=sil(_EGRID)) col3 = fits.Column(name='gra_ext', format='E', array=gra(_EGRID)) - + cols = fits.ColDefs([col1,col2,col3]) tbhdu = fits.BinTableHDU.from_columns(cols) #tbhdu.writeto(filename) - + prihdr = fits.Header() prihdr['SIL_FILE'] = "%s" % (_silfile) prihdr['GRA_FILE'] = "%s" % (_grafile) prihdr['COMMENT'] = "Created by %s on %s" % (_myname, datetime.date.today()) prihdu = fits.PrimaryHDU(header=prihdr) - + thdulist = fits.HDUList([prihdu, tbhdu]) - thdulist.writeto(_outdir+_FINAL_FILE, clobber=clobber) + thdulist.writeto(_outdir+_FINAL_FILE, overwrite=clobber) return ##-------------- Main file execution ---------------------------## if __name__ == '__main__': args = sys.argv - print os.environ['PYTHONPATH'] + #print(os.environ['PYTHONPATH']) if 'sil' in args: #print('silicate on') silicate_xs() @@ -267,6 +300,7 @@ def make_xs_fits(clobber=True): graphite_xs() if 'combine' in args: #print('combine on') + print("Creating a final energy grid of length %d" % (len(_EGRID)) ) + # in the past: 25800 + # now (2018.06.24): 25530 make_xs_fits() - - diff --git a/plot_xsects.ipynb b/plot_xsects.ipynb new file mode 100644 index 0000000..b68b9d1 --- /dev/null +++ b/plot_xsects.ipynb @@ -0,0 +1,341 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot cross-sections used in these models\n", + "\n", + "This plots the cross-sections contained in the *edge_files* folder, useful for visualizing the available cross-sections and structure." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import astropy.units as u\n", + "from astropy.io import fits\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ISMdust" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "sil_file = \"edge_files/silicate_xs.fits\"\n", + "sil_data = fits.open(sil_file)[1].data\n", + "\n", + "gra_file = \"edge_files/graphite_xs.fits\"\n", + "gra_data = fits.open(gra_file)[1].data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def plot_all_xsect(ax, data):\n", + " ener = data['energy']\n", + " abso = data['abs']\n", + " scat = data['sca']\n", + " exti = data['ext']\n", + " ax.plot(ener, exti, color='k', label='Extinction')\n", + " ax.plot(ener, abso, color='r', ls=':', label='Absorption')\n", + " ax.plot(ener, scat, color='r', ls='--', label='Scattering')\n", + " ax.legend(loc='upper right')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5,1,'Silicate')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plt.subplot(111)\n", + "plot_all_xsect(ax, sil_data)\n", + "plt.loglog()\n", + "ax.set_title('Silicate')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5,1,'Graphite')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plt.subplot(111)\n", + "plot_all_xsect(ax, gra_data)\n", + "plt.loglog()\n", + "ax.set_title('Graphite')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "** Examine the master fits file **" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "master_file = \"edge_files/xs_ext_grid.fits\"\n", + "master_data = fits.open(master_file)[1].data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ColDefs(\n", + " name = 'energy'; format = 'E'\n", + " name = 'sil_ext'; format = 'E'\n", + " name = 'gra_ext'; format = 'E'\n", + ")" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "master_data.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "energy = master_data['energy'] * u.eV\n", + "sil_ext = master_data['sil_ext']\n", + "gra_ext = master_data['gra_ext']" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'$\\\\tau_{ext}$ ($Md / 10^{-4}$ g cm$^{-2}$)')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(energy.to('keV'), sil_ext, label='Silicate')\n", + "plt.plot(energy.to('keV'), gra_ext, label='Graphite')\n", + "plt.loglog()\n", + "plt.legend(loc='upper right')\n", + "plt.xlabel('keV')\n", + "plt.ylabel(r'$\\tau_{ext}$ ($Md / 10^{-4}$ g cm$^{-2}$)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## OlivineAbs" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "olv_file = \"edge_files/olivine_abs.fits\"\n", + "olv_data = fits.open(olv_file)[1].data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5,1,'Olivine Absorption')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEaCAYAAAA2f6EIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd8VFX6x/HPdyYJoQbpXZAqHQnFsq5dLIhdEDuCDXdXXXd1m79d17Lq7tpQQUQUFbGLrsqqq2KhBUSqSBOJgHQU6cnz+2MGjTEhM2QmM5N53q9XXmbu3Ln3yTXw5Zxzz7kyM5xzzrnyCiS6AOecc5WDB4pzzrmY8EBxzjkXEx4ozjnnYsIDxTnnXEx4oDjnnIsJDxRX6Uj6P0lPhb9vIWmrpGAEn3tE0p/jX+HPzttSkknKqOhzl0XSHySNTnQdLjV4oLiUI+kSSXMlbZO0RtLDkmqXtK+ZfWVmNcysoKzjmtmVZnZr7CsOkXRUODh+F69zlEe4vvyi28zsdjO7PFE1udTigeJSiqQbgH8ANwI5QF/gQOBtSVmJrC0CFwMbw/+tUMnY+nGVjweKSxmSagF/Ba41s7fMbLeZfQmcSyhULijhMz90J0kaKCmv2PvXSZoY/n6spL+Hvz9KUr6kGyStlbRa0qVFPldF0j2SvpL0Tbi7rOo+aq8GnA1cA7SVlFvCbpdJWhU+1w1FPttbUp6kb8Pn+leR906TNF/SZknvSzq4yHtfSvq9pDnA9+Fr8KWkmyUtkLRJ0uOSsiVVB94EmoS7CLdKalK0+zDC8/1W0hxJWyRNkJRd2jVxlY8HikslhwHZwEtFN5rZVkJ/GR5fxucnAu0ltS2y7XzgmVL2b0SoFdQUGAKMkHRA+L1/AO2A7kCb8D5/2ce5zwK2As8Dk4CLStjnaKAtcAJwk6TjwtvvA+4zs1pAa+A5AEntgPHAb4D6wBvAa8VaaoOAU4DaZrYnvG0wcGL4WO2AP5nZ98BJwKpwF2ENM1tVtLgIz3cu0A9oBXQFLtnHNXGVjAeKSyX1gPVF/mIsanX4/VKZ2TbgVUJ/yRIOlg6EgqYku4G/hVtCbxAKhPaSBAwFrjOzjWb2HXA7MHAfp78YmBAey3kGGCQps9g+fzWz781sLvD43jrDdbSRVM/MtprZ1PD284D/mNnbZrYbuAeoSih497rfzFaa2fYi2x4Mb9sI3FbkPGWJ9Hyrwsd+jVDgujThgeJSyXqgXinjAY3D75flGX78C/R84JVw0JRkQ7Hw2gbUIPSv82rAzHDXz2bgrfD2n5HUnFDr4+nwplcJtbROKbbryiLfrwCahL8fQqgl8bmkGZJODW9vEt4PADMrDB+jaSnHLOs8ZYnkfGuKfL/3erk04YHiUskUYCdwZtGN4f7/k4B3IzjGfwmFUndCwVJad9e+rAe2A53MrHb4K8fMSvvL80JCf9Zek7QGWEYoUIp3ezUv8n0LYBWAmS02s0FAA0JdbS+Ef+ZVhMaOAAi3nJoDXxc5TknLiZd4nlL2LSqS87k05oHiUoaZbSE0KP+ApH6SMiW1JDQukQ+Mi+AYe4AXgLuBOsDb+1FHIfAo8G9JDQAkNZV0YikfuShcd/ciX2cBp0iqW2S/P0uqJqkTcCkwIXzsCyTVD593c3jfAkJjKadIOjbcfXYDocD9pIwf4RpJzSTVAf6w9zzAN0BdSTmlfG5/z+fShAeKSylmdhehvwTvAb4FphHqdjnWzHZGeJhngOOA50sZj4nE74ElwFRJ3wLvAO2L7ySpL9ASGGFma4p8TQx/vuj4xQfhbe8C95jZf8Pb+wHzJW0lNEA/0Mx2mNkiQne2PUCo1dQf6G9mu8qo/RlCLbVl4a+/A5jZ54QG3ZeFu/J+0hVWjvO5NCF/wJZz6UPSl8DlZvZOomtxlY+3UJxzzsWEB4pzzrmY8C4v55xzMeEtFOecczHhgeKccy4m0mIFUkn9gf41a9Yc2q5du0SX45xzKWXmzJnrzazElSCKSqsxlNzcXMvLyyt7R+eccz+QNNPMSloh+yfSostLUn9Jo7Zs2ZLoUpxzrtJKi0Axs9fMbFhOTmkrSjjnnCuvtAgU55xz8ZcWgeJdXs45F39pESje5eWcc/GXFoHiLRTnnIu/tAiUWLVQduwuYMnarXy0eD35m0p7yJ9zzqWntJjYWF5/e20BU5ZtYPE337Gn8Md5O31a1aHpAVXZsbuAzk1z6N+1Cc3rVEtgpc45lzgeKBH4evM26teswjEd6tOmQQ0a1sxm5opNvD5nNV9v3k5GQLwxdw13vbWImlUyqFezCq3r1+DgxjXp0KgWHRrXpGXd6gQDSvSP4pxzcZMWM+X3Lr3Spk2boYsXL47LOVZu3Mak+WvI37Sddd/t5ItvvmPZ+u8pCLdoqmYGad+oJgc3rkX7hjWoVTWTmtmZNK1dlezMAJO/WMeMFZtYvXk723cX0rp+ddo3rEm7RjXp1qw2jXKy41K3c86VJdKZ8mkRKHtV9NIre8dcFq7+loWrv2Ph6m9ZsPpbtmzfXeL+zQ6oSos61aiSEWDJuq2s3LgdgGBA9O/amKFHHkSnJn6nmnOuYkUaKN7lFUfZmUE6N82hc9MfQ8DM2PD9Lrbu2MOW7bvJ37Sdb3fs5tCD6tKyXvWffP77nXv44pvveGPuap6e9hWvzF5Fh0Y1OalzY3q1PIDuLWpTLcv/FzrnkoO3UFLE5m27mPjZKl7+9Gtmr9yMWajl0rFxLbo1z6FDo1oc0uIADm5cE8nHapxzseNdXiVI5UApasv23cz6ahMzv9xE3oqNzF/1Ld/t2ANA09pVOalzI87ObUaHRrUSXKlzrjLwQCmiIgblE8nM+Hrzdj5esp63F3zDB1+sY3eB0blpLc4+pBmndW9KnepZiS7TOZeiPFBKUFlaKGXZ+P0uJs7+mhdm5TPv62/JDIpjOzTk7J7N+GX7+mQG02I+q3MuRjxQSpAugVLUwtXf8uLMfF6Z/TXrt+6iXo0szuvVnAv7tkzIrcjnjZxCTtVMRl1U+u/mrj2F/PHluVx/Qjsa51StwOqccyXxu7wcAAc3rsWfTu3I70/qwAeL1jEhbyUPvb+UkR8s45Sujbn08FZ0b167wuqZtnxjmfu8v2gtz8/MZ9O2XYy+uFcFVOWciwUPlDSRGQxwXMeGHNexIV9t2MbYT77kubyVvDp7FX1a1WH4MW04ok29pLhDLBCuIY0az85VCinbmS6puqQnJD0qaXCi60klLepW4y/9OzLl5mP40ykH8+WG77nwsemcPuJj/jt/DYnuBt2baYWeKM6llKQKFEljJK2VNK/Y9n6SFklaIumm8OYzgRfMbChwWoUXWwnUzM7k8l8cxOTfHc3tZ3Rh07bdDBs3k9NHfMwnS9bH9dz7Cq0fWihxrcA5F2tJFSjAWKBf0Q2SgsAI4CSgIzBIUkegGbAyvFtBBdZY6VTJCHJ+nxb874ZfcvfZXVn33U7OHz2NCx+bxryv4/MMmd8+P6fU9/a2UFZv3hGXczvn4iOpAsXMJgPFR217A0vMbJmZ7QKeBQYA+YRCBfbxc0gaJilPUt66deviUXalkREMcE5uc/7326P448kHM/frLZz6wEdcO/5TVmz4PqbnenFWPnsKCkt8b+9tzYu++S6m53TOxVdSBUopmvJjSwRCQdIUeAk4S9LDwGulfdjMRplZrpnl1q9fP76VVhLZmUGGHhnqCrvm6Na8vWANx/3rA+54cyFbd+6J2XlWbym5BZJRZJn/RI/nOOcilwqBUtJtR2Zm35vZpWZ2lZk9vc8D+COA90ut7ExuPLEDk288mgHdmzLyg2Uc+8/3mfjZqv3+i75xkbkvy9eX3OrJCP74v3zbLu/NdC5VpEKg5APNi7xuBqxKUC1pqUGtbO45pxsvXX0Y9WtW4VfjP2XQo1NZtm5r1McqKDT6tKpDMCD+/c4X7Nzz88Ao8lBMNpey1L9zLvmkQqDMANpKaiUpCxgITIzmALF6pny6O6TFAbx6zRHcdkZnFqz6ln73fchD7y9hdyljISUpKDTaNKjBA4N68OlXmxn65EzWFOv6KiySKFc9NZOXP81n157Iz+GcS4ykChRJ44EpQHtJ+ZKGmNkeYDgwCVgIPGdm86M8rnd5xUgwIAb3OZB3bvglx3ZowF1vLWLAgx9HfDdYgRnBgDi5S2NuO6Mz05dv4Ph/fcD46V/90I1WtIXy7fbdXDfhM474x/8Y8d4StnsXmHNJy9fycuXy1rw1/PnVeWz6fhe/OrYtVx/Vmox9LD7Z+ZZJnJvbnL/07wjAig3fc9OLc5mybAOHta7LnWd2ZeWmbQwePY2rjmrNjSe0Z/LidTz20XI+XLyeqplBDjmwNr86pi19DqpbUT+mc2kt0rW8kqqFEi/eQomffp0b8c51v+SUro3519tfcM7IKXxZymC7mbFt1x6qZQV/2HZg3eo8fXkfbj+jC3Pyt3DivZMZ/eEyAI7p0IBAQBzVvgHjhvTh+SsP5bxezfly/TbOGzWVW16dx/cxvOvMOVc+aREoPoYSXznVMrlvYA/uH9SDpWu3cvL9H/6kC2uvnXsKKTSoWiRQAAIBcX6fFrx9/ZEc2rou7y0KzReqkvHTX89eLevwf6d14u3rj+TSw1vy5NQV9LtvMp8sje+sfudcZNIiULyFUjFO69aESdcdSY8Wtbn5pbkMfTKPdd/t/OH9veMf1YoFyl6Nc6ry2MW5PDCoB6d3b0LbBjVL3K9aVga39O/EhGGHEpQ4/9Fp/P31BSXeMVbUIx8s5ayHP9nPn845V5a0CBRvoVScxjlVGXdZH/5yakcmL15Pv3sn886CbwDYtG0XANWrlL7ItST6d2vCvQN7/KwlU1zvVnV489dHckHfFoz+aDlnPfzJPm9lvvPNz5m5YtN+/FTOuUikRaB4C6ViBQLisiNa8fq1R9CwVjaXP5nHLa/O44vwUio5VTNjdq6qWUH+fnoXRl7Yk/xN2zn1gY94Pm9l2R90zsVcWgSKt1ASo13Dmrx8zWEMOaIVT0xZwZVPzQKgbYMaMT/XiZ0a8eavf0HXZjnc+MIcbnpxDjt2+y3GzlWktAgUlzhVMoL8+dSOPHbxj3ccHlAtKy7napxTlacv78vwo9vw7IyVnDdqKqs2b//Zfve+80Vczu9cuvNAcRXi2IMbMvXmY3nist4cUD0+gQKhiZe/PbE9j1zQk6Vrt9L/gY+YumzDT/a5793FcTu/c+ksLQLFx1CSQ6OcbH7ZrmJWfO7XuRGvXHM4OdUyGTx6Go99tJzD24QmQraoU43N4RsE9mXc1BX8avyn8S7VuUrDZ8q7Su27Hbu54bnP+G/4TjOArGCARjnZjL44l3YNS741GaDlTf8B4Ms7T4l7nc4lM58p7xyhxxw/ckFPfntCOwCO79iQ8cP6sn13AWeM+JhJ89ckuELnKg8PFFfpBQJi+DFtmTj8cP5+emd6HngArw0/gjYNa3LFuJk89P4Sf5CXczHggeLSRtdmtWlYK/SAr0Y52UwY1pfTujXhrrcWcfNLc0tdht9vP3YuMmkRKD4o70qSnRnk3vO6/3Cb8WVjZ/Dtjp8/0GvU5GUJqM651JMWgeITG11pAuHbjO86qytTlm7gnIen8HWxuStlrRHmnAtJi0Bxrizn9mrO2Et7s2rzdk4f8TFz87dwcpdGAIybsoIpSzeUcQTnnAeKc2FHtK3Hi1cfRlYwwLkjpzBp/jdUzwrSoFY2F42Zxosz8xNdonNJzQPFuSL2rj/WrmENCgqNBrWyefGqw+jdqg43PP8Z//rvIr8jzLlSpGygSDpI0mOSXkh0La5yaVAzm2eHHcqFfQ/k6qNak1M1k7GX9ua83Obc/78l/PrZ2X7nl3MlSEigSBojaa2kecW295O0SNISSTft6xhmtszMhsS3UpeuqmYFufX0zpyT2xyAzGCAO8/qwu/7dWDiZ6s4/9GpfPPtjgRX6VxySVQLZSzQr+gGSUFgBHAS0BEYJKmjpC6SXi/21aDiS3bpThJXHdWahwYfwudrvuPUBz5i1lf+wC7n9kpIoJjZZGBjsc29gSXhlscu4FlggJnNNbNTi32tjfRckoZJypOUt27duhj+FC5dndylMS9ffThVM4NcMHoaeV8W/1V2Lj0l0xhKU6Doo/byw9tKJKmupEeAHpJuLm0/MxtlZrlmllu/fsWsdOsqv/aNavLCVYfSsFY2F4+ZzptzVye6JOcSLpkCRSVsK/V2GjPbYGZXmllrM7tjnwf2mfIuDkKD931p27AmVz09y9cEc2kvmQIlH2he5HUzYFWCanEuIg1rZTPhih/XBLvzzc89VFzaSqZAmQG0ldRKUhYwEJgYiwP70isunqpkhNYEu+jQAxk5eRk3vTiXgkIPFZd+EnXb8HhgCtBeUr6kIWa2BxgOTAIWAs+Z2fwYnc+7vFxcBQLir6d14lfHtGFC3kqGPzPL1wBzacef2OhcjD320XJufX0Bv2hbj0cu6En1KhmJLsm5cvEnNhbhLRRXkYYc0Yp7zunGJ0s3MHj0NDZ+X/bz652rDNIiUHwMxVW0s3s24+HBh7Bg9bf0f+Aj5q/yf8y4ym+/AkVS9fDM9pTgLRSXCCd0asQLVx5KoRlnPfwJr33mNy26yi2iQJEUkHS+pP9IWgt8DqyWNF/S3ZLaxrfM8vEWikuUrs1qM3H4EXRuksO14z/lzjc/p9DvAHOVVKQtlPeA1sDNQCMza25mDYBfAFOBOyVdEKcanUtp9WtW4ZmhfRnUuwWPfLCU+95dnOiSnIuLSG8/Oc7MfvawbTPbCLwIvCgpM6aVxZCk/kD/Nm3aJLoUl6ayMgLcfkZndu0p5L53F9OhUU1O6tI40WU5F1MRtVBKCpP92SdRvMvLJQNJ3HZGZ7o3r831z33GW/PWJLok52KqzECRdLykRyV1D78eFv+ynKucsjODjLqoJ+0a1uDKp2b6mIqrVCJpoVwN3AhcIOkYoHt8S4o9v8vLJZMGNbN57spDOb9PaEzlj6/M9VBxlUIkgbLOzDab2W+BE4Beca4p5rzLyyWbKhlBbju9M8OPbsP46Ss9VFylEMmg/H/2fmNmN0m6No71OJc2JHHDCe0wjBHvLQXEbad3JhAo6UkOziW/MgPFzF4FkFTPzNab2QPxL8u59CCJ357QHjN46P2lSPD3AR4qLjVFs2rdGOC0eBXiXLqSxI0ntseAh99fioBbPVRcCoomUFL2t9vnobhkJ4nfndgeCIeK4G+neai41BLNWl4pO2Log/IuFewNlSt/2Zqnpn7FXybO86c/upSSFi0U51KFJH7frz2GMfKDZYC3VFzqiKaFcnPcqnDO/UASN/XrwBW/PIinpn7Fn1+dF/UtxRu27uTW1xewu6AwTlU693MRt1DMbJ6kXOCPwIHhzyr0lnWNU33OpaW9oRKQePj9pRSacdvpXSJuqfzt9QW8OnsVuQce4GuGuQoT7bNJnyY0a34ukNB/+kg6HTgFaACMMLP/JrIe52Jt75hKUOLB95ZQWAh3nBlZqOxt0OzyFoqrQNEGyjozm1jek0oaA5wKrDWzzkW29wPuA4LAaDO7s7RjmNkrwCuSDgDuATxQXKWzd/JjICDuf3cxhWb846yuZYZKMPx2gc++dxUo2kC5RdJo4F1g596NZvZSlMcZCzwIPLl3Q/gJkCOA44F8YIakiYTC5Y5in7/MzNaGv/9T+HPOVUqSuP74dgDc/+5iqmUF+b/TOiGVHirf7tgDwMTPVnHmIc0qpE7nog2US4EOQCY/dnkZEFWgmNlkSS2Lbe4NLDGzZQCSngUGmNkdhFozP6HQn6Y7gTfNbFY053cuFV13XFu279rDox8uJzsryE39OpQaKqs2bwfg/UXrMLN9ho9zsRJtoHQzsy5xqQSaAiuLvM4H+uxj/2uB44AcSW3M7JGSdgovtz8MoEWLFjEq1bmKJ4k/nHww23cXMPKDZezcXchfTu1YYvdXjSo//tEe+8mXXHp4q4os1aWpaANlqqSOZrYgDrWU9E+oUjuAzex+4P6yDmpmoyStBvpnZWX1LEd9ziWcJG4d0JnsjCCjP1rO9l0FJQ7Un5PbjLwVm6hXowq3/WchHRrV4tDWdRNUtUsX0cxDATgCmC1pkaQ5kuZKmhOjWvKB5kVeNwNWxejYzlUakvjjKQdz7TFtmJC3ssQZ9RmB0B/txy/pRct61bls7Awmf7EuEeW6NBJtoPQD2hJ6Lkp/QmMb/WNUywygraRWkrKAgUC57ygDX3rFVT57B+qHHRma/Hjbfxb+JFT2fpdTNZNnhvb5IVRen+P/RnPxE1WXl5mtiMVJJY0HjgLqScoHbjGzxyQNByYRurNrjJnNj9H5fHFIV+lI4uaTOrBzdwGjP1pO1awgN5wQWmByb7hIoSdETriiL0PGzuBX4z9l155Cv/PLxUVULRRJT0iqXeT1AeE5JVExs0Fm1tjMMs2smZk9Ft7+hpm1M7PWZnZbtMfdx/m8heIqJUnc0r8TA3s154H/LWHEe0uAnw8+1srO5InLetP3oLrc8PxnjJ/+VcUX6yq9aAflu5rZ5r0vzGyTpB4xrinmvIXiKrNAQNx2Rhd27C7g7kmLqJIRoFbVTCDUQtmrWlYGYy7pxZVPzeTml+aya08hFx/WMjFFu0op2jGUQHhmOgCS6hB9KFU4b6G4yi4YEPec042TuzTi7/9Z+EMLpPj8k+zMICMv7MnxHRtyy8T5jJq8NBHlukoq2jD4J/CJpBcItarPBWLWNRUv3kJx6SAjGODe83qwbVce7y8K3dGVUcIclSoZQR4afAi/mTCb29/4nJ27C7n22LYVXa6rhKJqoZjZk8BZwDfAOuBMMxsXj8JiyVsoLl1kZQR4eHBPWtatBvx0gmNRmcEA953XnTN7NOWfb3/B3ZM+94d5uXKLursqPKkxHhMbnXMxUDUryFu/OZI1W3ZQvZRAgVCL5p5zupGVEWDEe0vZubuQP55ysC/T4vZb0o9/xIJ3ebl0k50ZpGW96mXuFwiI28/oQpWMAKM/Ws7OPYX89bRO/oRIt1+iHZRPSd7l5VzpAgHxf6d1YtiRBzFu6gpufmmuL3vv9ktULRRJ15eweQsw08xmx6Yk51xF2ztJMjsjwP3/W8LOPQXcc043MoJp8W9OFyPRdnnlhr9eC78+hdCSKVdKet7M7oplcbHiXV7OlU0S15/QnqyMAPf89wt2FRRy38AeZHqouAhF+5tSFzjEzG4wsxsIhUt94EjgkhjXFjPe5eVc5IYf05Y/nXIwb8xdw/BnZrFrjz9G2EUm2kBpAewq8no3cKCZbafIExydc6nt8l8cxC39OzJp/jdc46HiIhRtl9czhJ6J8mr4dX9gvKTq+K3EzlUqlx7eioDELRPnc/XTMxkx+BCqZAQTXZZLYtFObLwVGApsJjQYf6WZ/c3MvjezwfEo0DmXOBcf1pJbB3TinYVrueqpWezcU5DoklwS25+JjTOBmXGoJW58UN65/XfhoS2RxJ9emceV42by8AU9yc70lor7ubS4fcMH5Z0rnwv6HsjtZ3ThvUXruGLcTHbs9paK+7m0CBTnXPmd36cF/zirC5MXr2Pok3keKu5nPFCccxE7r1cL/nFmVz5asp7Ln8hj+y4PFfejMgNF0snhr1MkvSzp5IoozDmXnM7t1Zy7zurKx0vXc/mTMzxU3A8iaaH8DegE1AOqhf+bcJIOlvSIpBckXZXoepxLJ+fkNuees7vxydINXDZ2Btt27Ul0SS4JRBIoRwI1gB3A/PAzUcpF0hhJayXNK7a9n6RFkpZIumlfxzCzhWZ2JaGHfOWWtybnXHTO6tmMf53bjWnLN3Dp4x4qLoJAMbNtZnYLsB7YFqPzjgX6Fd0gKQiMAE4COgKDJHWU1EXS68W+GoQ/cxrwEfBujOpyzkXhjB7N+Pd53Znx5UYueXwG3+/0UEln0QzKf2Zmf4rFSc1sMrCx2ObewBIzW2Zmu4BngQFmNtfMTi32tTZ8nIlmdhjgkyqdS5AB3Zty78AezFyxiUsen85WD5W0FU2gjIlbFSFNgZVFXueHt5VI0lGS7pc0EnhjH/sNk5QnKW/dunWxq9Y594PTujXhvoHdmfXVZi4ZM53vduxOdEkuAaKZKR/vR7iVdPxSn/JjZu8D75d1UDMbJWk10D8rK6vnflfnnNunU7s2ISBx7fhPuXjMdJ64rDc1szMTXZarQNG0UOL9CLd8oHmR182AVbE4sM+Ud65inNylMSPO78Fn+Vu49PEZ3v2VZqIJlHi3UGYAbSW1kpQFDAQmxuLAkvpLGrVly5ZYHM45tw/9OjfmgUE9+HTlZi7zgfq0Ek2g3Byrk0oaD0wB2kvKlzTEzPYAw4FJwELgOTObH6tzOucqzsldGnPved3JW7HR56mkEZnFuycreeTm5lpeXl6iy3Aubbw6+2uumzCbPq3qMuaSXlTN8lWKU5GkmWZW5ny/iAflJXUABhC688oIjW9MNLOF+11lBfHl651LjAHdm1JoxvXPfcbQJ/MYfXGuL31fiUXU5SXp94TmhQiYTmi8Q4Se1rjPGe3JwAflnUucM3o0456zu/Hx0vW+SnElF1GXl6QvgE5mtrvY9ixCy7G0jVN9MVGkhTJ08eLFiS7HubT0XN5Kfv/iHI5sW5+RF/pDulJJpF1ekQ7KFwJNStjeOPxeUvMWinOJd25uc+48swsffLGOq56a6Y8TroQiHUP5DfCupMX8OJu9BdAGuDYehTnnKp/zerWgoBD+8PJcrnl6Fg8N7klWhj+WqbKIKFDM7C1J7Qitt9WU0PhJPjDDzJL+nxk+KO9c8ji/TwsKzPjzK/O45plZjDj/EA+VSqLctw1LutTMHo9RPXHltw07lzyenPIlf3l1Pid2asiD5x9CZtBDJVnFegxlX/4ag2M459LMRYe25Jb+HZk0/xt+/eyn7C5I+uFYV4aIurwkzSntLaBh7MpxzqWTSw9vRUGh8ff/LESazX3ndSfDWyopK9JB+YbAicCmYtsFfBLTiuLAx1CcS16X/+IgzOC2NxYSlPjXud08VFJUpIHyOlDDzGYXf0PS+zGtKA7M7DXgtdzc3KGJrsU593OAwyAtAAATP0lEQVRDjzyIAjPufPNzAoJ/ntudYCDe69G6WIs0UEYDU0t6w8zOj105zrl0deUvW1NQaNw9aREBibvP6eahkmIiDZSLgRHhGfNvAW+Z2Zr4leWcS0fXHN2GwkLjn29/QSAg7jqrKwEPlZQR6TyUK+GHBSJPAsZKygHeIxQwH6fCfBTnXPK79ti2FJhx7zuLCUrccWYXD5UUEc0jgDGzz4HPgX9LqgocDZwD/Aso8x7lRPFBeedSy2+Oa0dhoXH//5YQCIjbTu/soZICIr1t+CTgMzP74ZG8ZrYdeCP8ldR8UN651HPd8e3YU2g89P5SMgLibwM6IXmoJLNIWyhnAbdKakiohTIb+Cz834Xe3eWcizVJ3HhiewoKjZGTlxEMiFv6d/RQSWKRjqFcDiDpN0BbYDmh7q5RwEagWbwKdM6lL0ncdFIHCgqN0R8tJyDx51MP9lBJUlGNoQCXmlm3vS8kPQTcGNuSnHPuR5L44ykHs6fQGPPxcjKC4uaTOnioJKFop6N+K6nn3hdmNhNoF9uSIiepuqSZkk5NVA3OufiTQt1dFx16IKMmL+OuSYso78K2LvaibaEMAcZJWgDMBLoAu/f9kZ+TNAY4FVhrZp2LbO8H3AcEgdFmdmcZh/o98Fy053fOpR5J/PW0ThQUGg+HB+qvP76dt1SSSKR3eR0DzDWzLyQdBpwJdAUWAn/Yj/OOBR4EnixyjiAwAjie8LNWJE0kFC53FPv8ZeHzLwCy9+P8zrkUJIlbB3SmoNB44H9LCAbEb45LWCeJKybSFso7wFpJhcA8YA4wN/zfrdGe1MwmS2pZbHNvYImZLQOQ9CwwwMzuINSa+QlJRwPVgY7AdklvmNnP1r+WNAwYBtCiRYtoS3XOJZlAQNx+RhcKCn+c/HjtsW0TXZYj8kD5FaFWwXOEVhduD/QELgEOBhrFoJam/Ph4YQi1UvqUtrOZ/RFA0iXA+pLCJLzfKEmrgf5ZWVk9S9rHOZdaAgFx51ldKbDQMi3BoLj6KJ+4nGgRDcqb2YPA4YAB9xIaN/m1mR1tZrEIEwgthf+zU0dQ21gze72MfV4zs2E5OTn7XZxzLrkEA+Lus7sxoHsT7nprESM/WJroktJexHd5mdl2M/sHcBTQBpguqdQWxH7IB5oXed0MWFXKvlGR1F/SqC1btsTicM65JBEMiH+e043+3Zpwx5ufM/rDZYkuKa1FOij/C0JdWx3C/20AfAfUjWEtM4C2kloBXwMDgZgsje9LrzhXeWUEA/z73G4Uhp/8GAyISw9vleiy0lKkYygfEFpqZTxwv5l9WZ6TShpPqKVTT1I+cIuZPSZpODCJ0J1dY8xsfnnOU+R8vjikc5VYRjDAvQO7s6ewkL++toBgQFx0aMtEl5V2Ig2UqwjNOTkFuEHSBkJ3ec0F5pnZK9Gc1MwGlbI9JRabdM4ln8xggAcGHcI1z8ziL6/OJxgQg/scmOiy0or2Z7appGaE5oF0ATqb2YWxLiwecnNzLS8vL9FlOOfiaNeeQq56aibvfr6WO8/swsDePl2gvCTNNLMyH1ES6RiKrEjymFk+oUH0N0rbxznnEiErI8BDFxzCFeNmcvPLcwkExLm5zcv+oCu3SO/yek/StZJ+EvWSsiQdI+kJQo8JTkp+l5dz6aVKRpBHLujJEW3q8fsX5/DSrPxEl5QWIg2UfkABMF7SKkkLJC0HFgODgH+b2dg41VhuPg/FufSTnRnk0YtyOax1XX77/Ge8OvvrRJdU6UU9hiIpE6gHbDezzXGpKsaK3OU1dPHixYkuxzlXgbbvKuDSsdOZvnwj9w3sQf9uTRJdUsqJdAwl2uXrMbPdZrY6VcIEvIXiXDqrmhVkzCW9yG1Zh99MmM0bc1cnuqRKK+pAcc65VFMtK4PHL+lFj+a1+dX4T3lr3ppEl1QpeaA459JC9SoZjL2sN12b5TD8mVm8veCbRJdU6UQVKJI+iVch8eR3eTnnAGqEQ6VT0xyufnom7y70UImlaFsoP3uYVXidr6TmYyjOub1qZWfy5GW9ObhxLa56ahbvL1qb6JIqjWgDpb2klyX9XdLA8EOuxsahLueci5ucqpmMu6wPbRvWYNi4mUz+Yl2iS6oUog2U5cDtwFJCD9i6HPhrrItyzrl4y6mWyVND+tC6fg2GPpnHx0vWJ7qklBdtoOwysxlm9riZ3Whmg83sybI/5pxzyeeA6lk8fXkfWtWrzpAnZjBl6YZEl5TSog2UX8alijjzQXnnXGnqhEOlRZ1qXDZ2BtOXb0x0SSkrqkAxs+/iVUg8+aC8c25f6taowtOX96VJ7WwueXw6eV96qOwPn4finHNA/ZpVGD+0L41qZXPxmOnMXLEp0SWlHA8U55wLa1Arm/HD+tKgVjaXjJnO7JUps8JUUvBAcc65IhrWyuaZoX04oHoWFz42jTn5HiqRStlAkXSUpA8lPSLpqETX45yrPBrnVGX8sL7UrpbJBaOnMe9rv6EnEgkJFEljJK2VNK/Y9n6SFklaIummMg5jwFZCs/f96TnOuZhqWrsq44f2pWZ2Jhc8No0Fq75NdElJL1EtlLGEHtr1A0lBYARwEtARGCSpo6Qukl4v9tUA+NDMTgJ+j0+udM7FQbMDqjF+aF+qZQYZPHoqn6/xUNmXhASKmU0Git+X1xtYYmbLzGwX8CwwwMzmmtmpxb7Wmllh+HObgCqlnUvSMEl5kvLWrfPlFZxz0WlRtxrjh/WlSkaQwY9O44tvUnL2RIVIpjGUpsDKIq/zw9tKJOlMSSOBccCDpe1nZqPMLNfMcuvXrx+zYp1z6ePAutUZP6wvwYA4/9GpLFrjoVKSZAoUlbCt1OcTm9lLZnaFmZ1nZu/v88A+U945V06t6lXn2WF9yQgEGDhqCvNX+d8nxSVToOQDzYu8bgasSlAtzjn3MwfVr8GEK/pSLSuD8x/1W4qLS6ZAmQG0ldRKUhYwEJgYiwP70ivOuVg5sG6opVKragaDH53GrK98Rv1eibpteDwwhdDzVfIlDTGzPcBwYBKwEHjOzObH6Hze5eWci5nmdaoxYdih1K2RxYWjpzHD1/4CQGalDlNUOrm5uZaXl5foMpxzlcQ33+5g0KNTWb15B2Mu6cWhresmuqS4kDTTzHLL2i+Zurzixlsozrl4aFgrmwnDDqV5napcOnY6Hy5O76kJaREoPobinIuXvasUt6pXgyFP5PHe5+n7jPq0CBRvoTjn4qlujSqMH9qH9g1rMmxcHv+dvybRJSVEWgSKt1Ccc/FWu1oWT13eh05Ncrj66Vm8MXd1okuqcGkRKM45VxFyqmYybkhvujevzbXjP+WlWem1bm1aBIp3eTnnKkrN7EyeuKw3fQ+qw/XPfcaTU75MdEkVJi0Cxbu8nHMVqXqVDB67uBfHd2zIX16dz4j3lpAOUzTSIlCcc66iZWcGeWjwIZzRoyl3T1rEnW99XulDJSPRBVQESf2B/m3atEl0Kc65NJIZDPDPc7pRvUqQkR8s47sde7h1QGeCgZLWwk19adFC8S4v51yiBALi1gGdufqo1jwz7SuumzCb3QWFZX8wBaVFC8U55xJJEr/r14Ga2Zn8463P+X7nHkYMPoTszGCiS4uptGihOOdcMrjqqNbcenpn/rdoLZc8Pp2tO/ckuqSY8kBxzrkKdGHfA/n3ud2Z8eUmzn90Kuu37kx0STGTFoHi81Ccc8nk9B5NGXlBTxat+Y6zH/6ElRu3JbqkmEiLQPFBeedcsjmuY0OeGdqHTdt2c+bDn1SKRwqnRaA451wy6nlgHV686lAyA+K8kVP5ZMn6RJdULh4ozjmXQG0a1OTFqw+jSe1sLnl8Bq/PWZXokvabB4pzziVY45yqPH/FYXRrnsO14z9l7MfLE13SfknZQJEUkHSbpAckXZzoepxzrjxyqmUybkgfjju4If/32gLuSsGlWhISKJLGSForaV6x7f0kLZK0RNJNZRxmANAU2A2k1xrRzrlKKTszyMODD2FQ7xY89P5Sbnj+M3btSZ1Z9YmaKT8WeBB4cu8GSUFgBHA8oYCYIWkiEATuKPb5y4D2wBQzGynpBeDdCqjbOefiKiMY4PYzOtOoVjb/fucLVm3ezsgLcsmplpno0sqUkBaKmU0GNhbb3BtYYmbLzGwX8CwwwMzmmtmpxb7WEgqdTeHPFlRc9c45F1+S+PVxbfn3ed2YtWIzZz78MV9tSP65Ksk0htIUWFnkdX54W2leAk6U9AAwubSdJA2TlCcpb926dbGp1DnnKsAZPZoxbkhv1m/dxRkPfcysrzaV/aEESqZAKWk951JHpMxsm5kNMbNrzWzEPvYbBfwVmJWVlRWDMp1zruL0OaguL119GNWrZDBo1NSkflZ9MgVKPtC8yOtmQOrekO2cczHSun4NXr76MDo3zeHqp2cx8oOlSXkHWDIFygygraRWkrKAgcDEWBzYl15xzqW6ujWq8PTlfTila2PuePNz/vDyvKR7rkqibhseD0wB2kvKlzTEzPYAw4FJwELgOTObH6Pz+eKQzrmUl50Z5IGBPbj6qNaMn/4VF4yexsbvdyW6rB8oGZtN8ZKbm2t5eXmJLsM558rtlU+/5ncvzqFBzSo8elEuBzeuFbdzSZppZrll7ZdMXV5x4y0U51xlc3qPpjx/xaHsLijkrIc/YdL8NYkuKT0CxcdQnHOVUbfmtZk4/AjaNqzJFeNm8sC7ixM6WJ8WgeItFOdcZdWwVjYThvXlzB5N+efbXzD8mU/ZtisxjxZOi0DxFopzrjLLzgzyz3O78YeTO/DGvNWc/fCUhDwFMi0CxTnnKjtJDDuyNWMu7sXKTdvo/+BHfLi4YlcHSYtA8S4v51y6OLpDA14bfgQNa2Zz8ZjpPPT+kgobV0mLQPEuL+dcOmlZrzovXX0YJ3dpzF1vLeKqp2bx3Y7dcT9vopavd845F0fVq2TwwKAedG9em6emrmBPQfxbKWkxsVFSf6B/mzZthi5evDjR5TjnXIXasbuA7Mzgfn/eJzYW4V1ezrl0Vp4wiUZaBIpzzrn480BxzjkXEx4ozjnnYiItAsXnoTjnXPylRaD4oLxzzsVfWgSKc865+PNAcc45FxNpMbFxL0nrgBWlvJ0D7GuQpbT3I91e1ut6wPp9nL+8yvr5YvHZfe0X7XuRbEuVaxiL67ev9/f3d7D4tnhfv9JqiOXnYnkN/XfwRweaWf0yP21m/hUK1VH7836k2yN4nZfIny8Wn93XftG+F8m2VLmGsbh++3p/f38Hi2+L9/VLtWvov4PRf3mX149e28/3I91e1ut4K8/5Iv3svvaL9r1ItqXKNYzF9dvX+/v7OxjJOWMtla6h/w5GKa26vJKZpDyLYK0cVzq/huXj16/80v0aegsleYxKdAGVgF/D8vHrV35pfQ29heKccy4mvIXinHMuJjxQnHPOxYQHinPOuZjwQEkBkg6S9JikFxJdS6qQVF3SE5IelTQ40fWkIv+9Kz9Jp4d/B1+VdEKi64k3D5Q4kzRG0lpJ84pt7ydpkaQlkm7a1zHMbJmZDYlvpckvymt5JvCCmQ0FTqvwYpNUNNfQf+9KFuU1fCX8O3gJcF4Cyq1QHijxNxboV3SDpCAwAjgJ6AgMktRRUhdJrxf7alDxJSetsUR4LYFmwMrwbgUVWGOyG0vk19CVbCzRX8M/hd+v1DISXUBlZ2aTJbUstrk3sMTMlgFIehYYYGZ3AKdWbIWpI5prCeQTCpXZ+D+cfhDlNVxQsdWlhmiuoaSFwJ3Am2Y2q0ILTQD/g5YYTfnxX88Q+suvaWk7S6or6RGgh6Sb411ciintWr4EnCXpYSp+eYxUU+I19N+7qJT2e3gtcBxwtqQrE1FYRfIWSmKohG2lzjA1sw1Apf9l3E8lXksz+x64tKKLSVGlXUP/vYtcadfwfuD+ii4mUbyFkhj5QPMir5sBqxJUS6rza1l+fg3Lz68hHiiJMgNoK6mVpCxgIDAxwTWlKr+W5efXsPz8GuKBEneSxgNTgPaS8iUNMbM9wHBgErAQeM7M5ieyzlTg17L8/BqWn1/D0vnikM4552LCWyjOOediwgPFOedcTHigOOeciwkPFOecczHhgeKccy4mPFCcc87FhAeKcxVAUsviy53vY9/lktoX23avpN/FpzrnYsMDxbnk8yyhmdYASAoAZwMTElaRcxHwQHGugoWfhPippD6S7pY0Q9IcSVeEdxlPkUABjgS+NLMVFV+tc5HzQHGuAoW7sl4ktBJyN2CLmfUCegFDJbUyszlAoaRu4Y8NJBQyziU1DxTnKk594FXgAjObDZwAXCRpNjANqAu0De87HhgoKYPQw66eT0C9zkXFn4fiXMXZQughTIcD8wk9Q+NaM5tUwr7jgf8CHwBzzGxthVXp3H7yFopzFWcXcDqhVsn5hFamvUpSJoCkdpKqA5jZUmADocfHeneXSwkeKM5VoPCTJE8FrgO+IfTc9lnhW4pH8tNeg/FAB+Dliq7Tuf3hy9c755yLCW+hOOeciwkPFOecczHhgeKccy4mPFCcc87FhAeKc865mPBAcc45FxMeKM4552LCA8U551xM/D/GZBzkxbY+RAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "energy = olv_data['energy'] * u.eV\n", + "plt.plot(energy.to('keV'), olv_data['abs'])\n", + "plt.loglog()\n", + "plt.xlabel('keV')\n", + "plt.ylabel(r'$\\tau$ ($Md / 10^{-4}$ g cm$^{-2}$)')\n", + "plt.title('Olivine Absorption')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ8AAAEWCAYAAAC5XZqEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl8VNX5+PHPk30PJGHfRRYxQNjVuuGGLRZcUMRWRUVb6/b9/tS6fOtura1W26r1W/e641IVl69aKy6gqCCIrIKsIWxJIGRfJs/vj3NnMtlgAplJgOf9es1rZu49996TIcyT55xzzxFVxRhjjImkqLaugDHGmIOPBR9jjDERZ8HHGGNMxFnwMcYYE3EWfIwxxkScBR9jjDERZ8HHhI2I3C4iz3uve4tIiYhEh3Dc/4rILeGvYaPr9hURFZGYSF97T0TkZhF5oq3r0R6IyHQRmdPW9TD7xoKP2Wvel8D3IlImIltE5FER6dBUWVXdoKopqurb03lV9deqelfr19gRkeO9IPPbcF1jX3j1yw3epqr3qOqMCFz7GRGp8v5Q8D+m7uV57g56f7iIbBaRa1u3xmZ/ZcHH7BXvS+SPwPVAOnAE0Af4t4jEtWXdQnAhUOg9R1R7zKqa8CfvDwX/Y+a+nExEcoDZwO9V9c+tU0Wzv7PgY1pMRNKAO4CrVPV9Va1W1XXAObgA9Msmjgk0aYnIuSIyv8H+/xaRWd7rwF/N/ixARK4VkW3eX88XBR0XLyL3i8gGEdnqNdkl7qbuScAU4ApggIiMbqLYxSKS1/AvdREZKyLzRWSXd60HgvZNEpGlIrJTRD4RkcOC9q0TkRtEZDFQ6n0G60TkJhFZJiI7RORpEUkQkWTg/4DuQZlH9+AmzBCvd52ILBaRIhGZKSIJzX0mofLq8bqIbBeRtSJydQjHjAU+Am5W1Yd3U26wiPxbRApFZKWInBO0L1NEZnmf+9dA/wbHnuIdUyQifxeRT0VkRtD+i0Vkufc5fyAiffbqAzCtyoKP2RtHAQnAv4I3qmoJ7ovz5D0cPwsYJCIDgradB7zYTPmuuOyqB3AJ8IiIdPT2/REYCOQAh3plbt3Ntc8CSoBXgQ+AC5ooMx4YAJwC3CgiJ3nb/wr8VVXTcF+ArwCIyEDgJeC/gE7Ae8DbDTLAacBEoIOq1njbfgFM8M41EPidqpYCPwXygjKPvODKhXi9c4BTgX7AMGD6bj6TPRKRKOBt4DvcZ3wi8F8iMmE3h40F3gf+W1Wb7a/yAu6/cf/+nXGf1d9F5HCvyCNABdANuNh7+I/NAl4DbgIygZW430///tOBm4EzcZ/V57jPzrQxCz5mb2QB+UFfosE2e/ubpaplwFu4Lxm8IDQYF5SaUg3c6WVY7+GCxyAREeBS3JdboaoWA/cA5+7m8hcCM72+pxeBaSIS26DMHapaqqrfA0/76+nV41ARyVLVElWd522fCryrqv9W1WrgfiCRoC9B4G+qulFVy4O2PextKwR+H3SdPQn1enneud/GBedQXedlVDtFJN/bNgbopKp3qmqVqq4BHmf3n/URQBHuD5LdOQ1Yp6pPq2qNqn4LvA5METdA5SzgVu/fZAnwz6BjfwYsVdV/eb+PfwO2BO3/FfAHVV3u7b8HyLHsp+1Z8DF7Ix/Iaqb/opu3f09epO7L9jzgTS8oNaWgQaArA1Jwf8kmAQv8X5a4v7Q7NXUSEemFy2pe8Da9hcvgJjYoujHo9Xqgu/f6ElyGskJEvhGR07zt3b1yAKhqrXeOHs2cc0/X2ZNQrhf8Bez/vEJ1v6p28B7+PyT64JoCdwZ91jcDXXZznkeAb3D9gB13U64PMK7BuX+By3g7ATE0/qz8ugfvUzdTcvBgjT7AX4POWwgI9T8r0wYs+Ji98SVQiWvKCPCaT34K/CeEc3yIC2A5uCDUXJPb7uQD5cDhQV+W6ara3Bft+bjf+bdFZAuwBhd8Gja99Qp63RvIA1DVVao6Ddc09EfgNe9nzsN9yQHgZWS9gE1B52lq+vgmr9NM2WChXK+1bQTWBn3OHVQ1VVV/tptjfLggsgH4QFxfYXPn/rTBuVNU9XJgO1BD48/KbzPQ0//G+yx6Bu3fCPyqwbkTVfWLUH9wEx4WfEyLqWoRbsDBQyJyqojEikhfXD9KLvBcCOeowbXV3wdk4Nr8W1qPWlzTz4Mi0hlARHrsph/iAq/eOUGPs4CJIpIZVO4WEUny+hwuAmZ65/6liHTyrrvTK+vD9f1MFJETvSa8a3HBeU9fcFeISE8RycBlEf5RZVuBTBFJb+a4vb0e3s+hInJ8KGWDfA3s8gZOJIpItIhki8iY3R3kNQuejftD4T0vWDf0DjBQRM73fpdiRWSMiBzmNY/+C7jd+zcZQv1Riu8CQ0XkdC8TvwKXMfn9L3CTv/9IRNJF5OwW/uwmDCz4mL2iqn/CfWHeD+wCvsL9lXmiqlaGeJoXgZOAV5vpPwrFDcBqYJ6I7MKNrBrUsJCIHAH0BR5R1S1Bj1ne8cH9LZ962/6Da4L60Nt+KrBUREpwgw/OVdUKVV2JG+H3EO5L9ufAz1W1ag91fxGXAa7xHncDqOoKXKf4Gq+5qF5z3D5cDxHpiesz+35PZRtc0+ddJwdY6133CdxAkD0dW4XLkitwWWdig/3FuMEd5+Kyui24zDLeK3IlrtlwC/AMrh/Of2w+Lrj9CSgAhgDzccEYVX3DO9fL3u/HElx2btqY2GJyxkSeiKwDZqjqRxG+7i9xzZQ3RfK6keKNyssFfqGqs9u6PqZ5+8MNb8aYVqKqz++51P7Fa2b9Ctf/dz1uQMG83R5k2lybNLt5/QQrRWS1iNzYxP54cTfGrRaRr7z+BETkZBFZIG5KlwUickLQMZ9451zkPTpH7icyxrShI4EfqWuCPL3BkHbTDkW82c0bt/8D7kbEXNxQzGmquiyozG+AYar6axE5FzhDVaeKyAhgq6rmiUg28IGq9vCO+QS4TlXnY4wxpl1ri8xnLLBaVdd4HZEvA5MblJlM3Y1krwEnioio6sKgu72XAgkiEo8xxpj9Slv0+fSg/g1jucC45sqoao2IFOGmzgi+efEsYGGDkVVPi4gPd3f03dpEWicilwGXASQnJ48aPHjwPv44xhhz8FiwYEG+qjZ5I3dLtEXwkSa2NQwSuy3jjdn/I254pt8vVHWTiKTigs/5wLONTqL6GPAYwOjRo3X+fGulM8aYUInI+j2X2rO2aHbLpf7dyj2pu7O7URnvxrF03LQY/vsU3gAuUNUf/Qeo6ibvuRh3/8TYMNXfGGPMPmqL4PMNbir7fuJm4T2XxhNKzqLuLuYpwMeqquIWKnsXuElV5/oLi5uiPst7HYubqHBJmH8OY4wxeyniwce7k/1K3HT2y4FXVHWpiNwpIpO8Yk/iphdZDfw/wD8c+0rctPm3NBhSHY+bO2oxsAg3x9XjkfupjDHGtMRBPcNBU30+1dXV5ObmUlFR0Ua1MiY0CQkJ9OzZk9jYhitCGBM+IrJAVZtahLFFbIaDBnJzc0lNTaVv3764CXKNaX9UlYKCAnJzc+nXr19bV8eYFrOJRRuoqKggMzPTAo9p10SEzMxMy9DNfsuCTxMs8Jj9gf2emv2ZBR9jjDERZ8GnHcrNzWXy5MkMGDCA/v37c80111BV5ZZq+eSTTzjtNLd686xZs7j33nt3e65bb72Vjz7at1n7r7nmGnr06EFtbW1g2+23387999+/1+ecMmUKa9asAaBv374MHTqUYcOGcdxxx7F+favcwxaSdevW8eKLdYuozp8/n6uvvnqPxx111FFNbo+OjiYnJyfwWLduXch1SUmpW4D1vffeY8CAAWzYsIGHH36Yp59+ejdHGrMfUtWD9jFq1ChtaNmyZY22RVJtba2OGTNGn3rqKVVVramp0Ysvvlivu+46VVWdPXu2Tpw4MWL18fl82qtXLx03bpzOnj07sP22227T++67b6/OuWTJEj399NMD7/v06aPbt29XVdVbb71VZ8yYsU91bonW/jyTk5P3+diPPvpIDznkEF29erWqqpaWlmpOTk6Tx7T176s5+ADztRW+fy3zaWc+/vhjEhISuOiiiwD3l/SDDz7IU089RVlZWb2yzzzzDFdeeSVFRUX07ds3kJmUlZXRq1cvqqurmT59Oq+99hrgMozbbruNkSNHMnToUFasWAFAaWkpF198MWPGjGHEiBG89dZbgWvMnj2b7OxsLr/8cl566aV61//uu+844YQTGDBgAI8/7m6r2rx5M8ceeyw5OTlkZ2fz+eefN/oZX3jhBSZPbjiXrHPkkUeyadOmwPsHHniA7OxssrOz+ctf/hLYftdddzF48GBOPvlkpk2bFsjCHn/8ccaMGcPw4cM566yzAp/Z9OnTufrqqznqqKM45JBDAp/JjTfeyOeff05OTg4PPvhgvczy9ttv5+KLL+b444/nkEMO4W9/+1vg+sFZyp74fD6uv/56xowZw7Bhw/jHP/7RbNnPP/+cSy+9lHfffZf+/fsDkJSURN++ffn6669DvqYx7Z0Ntd6NO95eyrK8Xa16ziHd07jt54c3u3/p0qWMGjWq3ra0tDR69+7N6tWrmzwmPT2d4cOH8+mnnzJ+/HjefvttJkyY0OT9H1lZWXz77bf8/e9/5/777+eJJ57g97//PSeccAJPPfUUO3fuZOzYsZx00kkkJyfz0ksvMW3aNCZPnszNN99MdXV14LyLFy9m3rx5lJaWMmLECCZOnMhLL73EhAkT+J//+R98Pl+jgAkwd+5cpk2b1mg7wPvvv8/pp58OwIIFC3j66af56quvUFXGjRvHcccdh8/n4/XXX2fhwoXU1NQwcuTIwGd25plncumllwLwu9/9jieffJKrrroKcIFxzpw5rFixgkmTJjFlyhTuvfde7r//ft555x3ANWsGW7FiBbNnz6a4uJhBgwZx+eWX7/a+mvLycnJycgDo168fb7zxBk8++STp6el88803VFZW8pOf/IRTTjml0RDpyspKJk+ezCeffELDCW9Hjx7N559/ztixNmuUOTBY5tPOqGqTo5ia2+43depUZs6cCcDLL7/M1KlTmyx35plnAjBq1KhAf8SHH37IvffeS05ODscffzwVFRVs2LCBqqoq3nvvPU4//XTS0tIYN24cH374YeBckydPJjExkaysLMaPH8/XX3/NmDFjePrpp7n99tv5/vvvSU1NbVSHzZs306lT/Ulxx48fT+fOnfnoo48477zzAJgzZw5nnHEGycnJpKSkcOaZZ/L5558zZ86cwLVTU1P5+c9/HjjPkiVLOOaYYxg6dCgvvPACS5cuDew7/fTTiYqKYsiQIWzdurXZzzLYxIkTiY+PJysri86dO+/xuMTERBYtWsSiRYt44403Ap/vs88+S05ODuPGjaOgoIBVq1Y1OjY2NpajjjqKJ598stG+zp07k5fXcApEY/Zflvnsxu4ylHA5/PDDef311+tt27VrFxs3bqR///4UFBQ0edykSZO46aabKCwsZMGCBZxwwglNlouPd8sfRUdHU1NTA7jA9vrrrzNo0KB6ZWfNmkVRURFDhw4FXHNeUlISEydOBBoP9RURjj32WD777DPeffddzj//fK6//nouuOCCeuUSExMb3Z8ye/ZskpOTmT59OrfeeisPPPAA2szsG81tB9e89uabbzJ8+HCeeeaZepmM/2ff0zmCBR8T/Jm1hKry0EMPMWHChN2Wi4qK4pVXXuGkk07innvu4eabbw7sq6ioIDExscXXNqa9ssynnTnxxBMpKyvj2WfdahA+n49rr72W6dOnk5SU1OxxKSkpjB07lmuuuYbTTjuN6OjokK85YcIEHnroocAX8sKFCwF46aWXeOKJJ1i3bh3r1q1j7dq1fPjhh4GmtLfeeouKigoKCgr45JNPGDNmDOvXr6dz585ceumlXHLJJXz77beNrnfYYYc12YSYmJjIX/7yF5599lkKCws59thjefPNNykrK6O0tJQ33niDY445hqOPPpq3336biooKSkpKePfddwPnKC4uplu3blRXV/PCCy/s8WdPTU2luLg45M9qb0yYMIFHH32U6upqAH744QdKS0ubLJuUlMQ777zDCy+8UC8D+uGHH8jOzg5rPet58hSY+9fIXc8cdCz4tDMiwhtvvMGrr77KgAEDGDhwIAkJCdxzzz17PHbq1Kk8//zzzTa5NeeWW26hurqaYcOGkZ2dzS233EJZWRkffPBBIMsBSE5ODnzxA4wdO5aJEydyxBFHcMstt9C9e3c++eQTcnJyGDFiBK+//jrXXHNNo+tNnDixUd+KX7du3Zg2bRqPPPIII0eOZPr06YwdO5Zx48YxY8YMRowYwZgxY5g0aRLDhw/nzDPPZPTo0aSnpwNuIMK4ceM4+eSTG/WbNGXYsGHExMQwfPhwHnzwwRZ9bqGaMWMGQ4YMYeTIkWRnZ/OrX/1qtxlURkYG77//PnfffXdg8MfcuXM56aSTwlK/Jm1fAQU/7rmcMXvJJhZtMLHo8uXLOeyww9qoRgeH8vJyxo8fz9y5c1uUoQUrKSkhJSWFsrIyjj32WB577DFGjhzZyjVtHxYuXMgDDzzAc88912hf2H5f7+oMw86GyY+0/rnNfs0mFjX7rcTERO644w42bdpE79699+ocl112GcuWLaOiooILL7zwgA08APn5+dx1112Ru6Aq+Cqh1he5a5qDjgUf0yb21Pm+J8GzEhzoTj755MhesKbSPde2fHCFMaGyPh9jTH013khECz4mjCz4GGPqC2Q+1uxmwseCjzGmvkDmY8HHhI8FH2NMfdbnYyLAgo8xpr6acveslvmY8LHg0w75Z0yura3l6quvJjs7m6FDhzJmzBjWrl0LuBmqjznmmHrH+WeSbsrxxx9Pw3uaQrFo0SLee++9ZvcvXLiQGTNmAG6W7U6dOjFixAgGDBjAhAkT+OKLL1p8zVDWKQqVf60g//o6LalP3759yc/PB9wkp/369WPhwoW888473Hbbba1Sv3bJMh8TATbUuh2bOXMmeXl5LF68mKioKHJzc0lOTg7sLy4uZuPGjfTq1Yvly5eHpQ6LFi1i/vz5/OxnP2ty/z333MPvfve7wPupU6fy8MMPA26+tjPPPJPZs2c3uhGypqaGmJimf/0mTZrEpEmTWukncPXIysra6+MXL17MlClTmDlzJiNGjCAnJ4dbbrmFG264YbdTHu23rM/HRIAFn935vxthy/ete86uQ+Gnof1Vv3nzZrp160ZUlEtQe/bsWW//Oeecw8yZM7nuuusCSx/474IvLy/noosuYtmyZRx22GGUl5cHjktJSaGkpASA1157jXfeeYdnnnmGV199lTvuuIPo6GjS09P56KOPuPXWWykvL2fOnDncdNNN9abuKS4uZvHixQwfPrzJ+o8fP57LLruMxx57jAcffJDjjz+eo446irlz5zJp0iQGDhzI3XffTVVVFZmZmbzwwgt06dKFZ555hvnz5/Pwww8zffp00tLSmD9/Plu2bOFPf/oTU6ZMAeC+++7jlVdeobKykjPOOIM77rgjxH+E0I9dvnw5F154Ic8991xgOQMR4fjjj+edd97hnHPOCfma+w3LfEwEWLNbO3bOOefw9ttvk5OTw7XXXhuY8NNvypQp/Otf/wLg7bffrre0wKOPPkpSUhKLFy/mf/7nf1iwYMEer3fnnXfywQcf8N133zFr1izi4uK48847mTp1KosWLWo0Z9z8+fP3ONnlyJEjA4vWAezcuZNPP/2Ua6+9lqOPPpp58+axcOFCzj33XP70pz81eQ7/OjzvvPMON954I+CWKVi1ahVff/01ixYtYsGCBXz22WdNHj9+/PjAcgYtPXby5Mk8/PDDHH300fW2+9fXOSBZ5mMiwDKf3QkxQwmXnj17snLlSj7++GM+/vhjTjzxRF599VVOPPFEwE1A2bFjR15++WUOO+ywek1An332GVdffTXgJs8cNmzYHq/3k5/8hOnTp3POOecE1v3ZnabW5Wmo4dyBwQEsNzeXqVOnsnnzZqqqqhotrubX1Do8H374IR9++CEjRowA3Fxvq1at4thjj210fMNmt5Yce9JJJ/HEE08wYcKEevPQHdDr61jmYyLAMp92Lj4+np/+9Kfcd9993Hzzzbz55pv19k+dOpUrrriiyZVBm1t8Lnh78Lo6//u//8vdd9/Nxo0bycnJaXbtIL+m1uVpaOHChfX6e4L7rK666iquvPJKvv/+e/7xj380e66m1uFRVW666abAwm2rV6/mkksu2W1dgs8R6rH+/qvf/OY39bYf0Ovr2AwHJgIs+LRj3377beCv69raWhYvXkyfPn3qlTnjjDP47W9/22iutGOPPTawns2SJUtYvHhxYF+XLl1Yvnw5tbW1gdU2AX788UfGjRvHnXfeSVZWFhs3btztejfNrcvj9+mnn/LYY48FlrVuqKioiB49egDwz3/+s9nzNGXChAk89dRTgb6rTZs2sW3btlY/NioqipdeeomVK1dy6623BrZHfH2dSKr2+get2c2EkTW7tWPbtm3j0ksvpbLSNYOMHTuWK6+8sl6Z1NRUbrjhhkbHXn755Vx00UUMGzaMnJycQGc5wL333stpp51Gr169yM7ODnwJX3/99axatQpV5cQTT2T48OH07t07sMR2wwEHgwcPpqioiOLi4sBy2TNnzmTOnDmUlZXRr18/Xn/99Wan/L/99ts5++yz6dGjB0cccURgGHkoTjnlFJYvX86RRx4JuEEUzz//PJ07d271Y+Pj43nrrbc47rjj6NKlC1dccQWzZ8/mD3/4Q8j13a/4m93sPh8TRraej63ns08efPBBUlNTA/f6HAy2bt3Keeedx3/+85+2rkp4fl8/ux8+vgsyD4Wr9jxQxRxcWms9H2t2M/vk8ssvr9cnczDYsGEDf/7zn9u6GuFjAw5MBFizWxNUtdnOelNfQkIC559/fltXI6LGjBnT1lUAGo8kbDWBAQe14Tm/MVjm00hCQgIFBQXh+49tTCtQVQoKCkhISGj9k1vmYyLAMp8GevbsSW5uLtu3b2/rqhizWwkJCY1mvWgV/olFLfiYMLLg00BsbGyzNzsac1CwzMdEgDW7GWPq8/f52FBrE0ZtEnxE5FQRWSkiq0Xkxib2x4vITG//VyLS19t+sogsEJHvvecTgo4Z5W1fLSJ/ExsxYMzesWW0TQREPPiISDTwCPBTYAgwTUSGNCh2CbBDVQ8FHgT+6G3PB36uqkOBC4Hngo55FLgMGOA9Tg3bD2HMgcym1zER0BaZz1hgtaquUdUq4GVgcoMykwH/fCuvASeKiKjqQlX1z+a4FEjwsqRuQJqqfqlumNqzwOnh/1GMOQBZ5mMioC2CTw9gY9D7XG9bk2VUtQYoAjIblDkLWKiqlV753D2cEwARuUxE5ovIfBvRZkwTLPMxEdAWwaepvpiGN9XstoyIHI5rivtVC87pNqo+pqqjVXX0npYDMOagVO2fXVztRlMTNm0RfHKBXkHvewINF0YJlBGRGCAdKPTe9wTeAC5Q1R+Dygff8NDUOY0xoagJWtrCsh8TJm0RfL4BBohIPxGJA84FZjUoMws3oABgCvCxqqqIdADeBW5S1bn+wqq6GSgWkSO8UW4XAG+F+wcx5oDk7/MBG25twibiwcfrw7kS+ABYDryiqktF5E4RmeQVexLIFJHVwP8D/MOxrwQOBW4RkUXewz8P/uXAE8Bq4Efg/yLzExlzgLHMx0RAm8xwoKrvAe812HZr0OsK4OwmjrsbuLuZc84HDtDVvYyJoJpKiIpxgceCjwkTm+HAGFNfTQXEecud24ADEyYWfIwxdXw1rp8n1h98LPMx4bFXwUdEkr2ZCowxBxL/jNZxFnxMeIUUfEQkSkTOE5F3RWQbsALYLCJLReQ+ERkQ3moaYyLCP9ItPsU9W/AxYRJq5jMb6A/cBHRV1V6q2hk4BpgH3CsivwxTHY0xkeIf6eZvdrOh1iZMQh3tdpKqVjfcqKqFwOvA6yIS26o1M8ZEnj/zCTS7WfAx4RFS5tNU4NmbMsaYds6f+VifjwmzPQYfbw2dx0Ukx3t/WfirZYwJi7JCmPs38DXzt2Kj4GOZjwmPUJrdfgNcBPxORDKAnPBWyRgTNv+5AxY8A1kDYVATS15VW+ZjIiOUZrftqrpTVa8DTgHGhLlOxphw2LYCvn3WvV71QdNlSra655Qu7tkyHxMmoWQ+7/pfqOqNInJVGOtjjAmXOQ9AXAp0HQqr/g2q0HC1+cI17jnLu3vCMh8TJnvMfFT1LQARyfLePxTuShljWpkq/DgbBk6AYedA0UbYtrxxucK1kNIV4lO94yzzMeHRkhkOngpbLYwx4VXwI5Rugz4/gQGnuG2rP2pcrnANZBziJhYFy3xM2LQk+DS1WqgxZn+wfo577ns0pHWH1G6wfWXjcjvWQkY/Cz4m7FoSfJpcltoYsx9YNxeSO0Pmoe59x36wY139MlWlULzZBR//1I02q7UJE8t8jDnQqcL6udD3J3UDDDr2dVlOMH8wyjgEovzBxzIfEx4tCT43ha0Wxpjwyf8Bdm2CvsfUbevYF3bl1d3XA26wAbisyJrdTJiFHHxUdUk4K2KM2Usl2+C5M+G96yF/VeP9P3j39PgHGoALPqgb9ebnH2ZtfT4mAlq0no+IjBaRN0TkWxFZLCLfi8jicFXOGLMHlSXwwtmuWW3BP+HJU2DH+vplfvgAOh8OHXrVbevY1z0H9/sU/giJHd3D3+xmQ61NmLR0MbkXgKeBs4CfA6d5z8aYSPNVw6sXwpbv4Zxn4TdfumDx0jTIXeDKlO+EDV+6+3uCZfRzz4VB/T7bVkCnwe51IPOx4GPCI9QlFfy2q+qssNTEGBM6VXj7GnevzqSH6oLL2c/Aq9PhiRPcPT0S5QLSwAbzuCV3gtikusxHFbYvh+yz3HsbcGDCrKXB5zYReQL4D1Dp36iq/2rVWhljdm/272HRC3D8TTDygrrt/U+A/17q5nD78hHwVcGp90KvsfWPF/FGvK1z74s3Q0URdB7i7fcHH8t8THi0NPhcBAwGYgH/DQAKWPAxJlLmPwWf3eez8kJLAAAgAElEQVSCznE3NN4fnwpHXgFH/Ma9bzh/m1/wcOtty9xz58Pcsw04MGHW0uAzXFWHhqUmxpg9W/EevHstDJgAEx9sPrDA7veBmzx09Ufgq6mb562TBR8TGS0dcDBPRIaEpSbGmN3b+DW8djF0y4Gzn4bolv7t2EDnIa5ZrvBHF3xSukByptsXZc1uJrxa+tt7NHChiKzF9fkIoKo6rNVrZoypk78KXpwKad3gvFfqFnvbF/4mtm3LXPDxj3QDG2ptwq6lwaeJpQ+NMWFVvBWeP9ONXPvl65DSqXXOmzXInTN3vgtAoy+p22fNbibMWtrsdidQpKrrVXU9sAu4rfWrZYwBoLIYXpgCpfnwi1fcvGutJTYBMvrDt89BTUX9e4Es+Jgwa2nwGaaqO/1vVHUHMKJ1q2SMAdxNpK9cAFuXwtn/hB6jWv8aXYZAZREkZrj7gvxsVmsTZi0NPlEi0tH/RkQyaHnTnTFmT1Rh1lXw48fw87/CwFP2fMze8N/XM/hn9Qcw2E2mJsxaGjj+DHwhIq/h7u85B/h9q9fKmIPdx3fBdy/B8TfDyPPDd52u3lihIWfU3y7ish8LPiZMWhR8VPVZEZkPnIAb6Xamqi4LS82MOVh98wR8/mcYeSEc99vwXmvgqXDh2/WXW/CLirHgY8KmxU1mXrCxgGNMOCx/xy2NMPBUmPjAnm8U3VdRUdDv2Gb2RdtQaxM2Le3zMcaEy4av4PVLoPsImPLUvt9Euq+iYuwmUxM2bRJ8RORUEVkpIqtF5MYm9seLyExv/1ci0tfbnikis0WkREQebnDMJ945F3mPzpH5aYzZBxVFsOrf8PZ/wTMTIa17691Euq+irM/HhE/E/7QSkWjgEeBkIBf4RkRmNeg7ugTYoaqHisi5wB+BqUAFcAuQ7T0a+oWqzg/rD2DMvije4tbXWf8lbPjCDaPWWoiKhRG/hONvhOSstq6lYwMOTBi1KPiIyP9rYnMRsEBVF4V4mrHAalVd453zZWAy9fuRJgO3e69fAx4WEVHVUmCOiBzaknob0yZU3dLU67/wAs4XdbNIxyZBzzFuVureR0LP0e0j2wlmzW4mjFqa+Yz2Hm977ycC3wC/FpFXVfVPIZyjBxC0cDy5wLjmyqhqjYgUAZlA/h7O/bSI+IDXgbtVVRsWEJHLgMsAevfuHUJ1jQlRrc+tKuoPNBvmQek2ty8p0wWZMZdA76Og2zCIjm3b+u6JBR8TRi0NPpnASFUtARCR23CZybHAAiCU4NPU8J2GQSKUMg39QlU3iUgqLvicDzzb6CSqjwGPAYwePXpP5zSmedXlsGmB14T2pZt1uqrY7UvvDf3Hu4DT5yjIGhj+kWutLSrKmt1M2LQ0+PQGqoLeVwN9VLVcRCqbOaahXKBX0PueQF4zZXJFJAZIBwp3d1JV3eQ9F4vIi7jmvUbBx5i9Vr7DBRh/M1reQrckAbiZAoad4wJN7yMgvWfb1nUfVftqiZYYomyotQmTlgafF3Fr+rzlvf858JKIJBP6vT/fAANEpB+wCTgXOK9BmVnAhcCXwBTg46aa0Py8ANVBVfNFJBY4DfgoxPoY07RdeUH9NV96q32qGxzQfQQccblrQus1FpIy2rq2rWrKo1/w54IKDu1umY8Jj5bOcHCXiLyHW9dHgF8HjS77RYjnqBGRK4EPgGjgKVVdKiJ3AvNVdRbwJPCciKzGZTzn+o8XkXVAGhAnIqcDpwDrgQ+8wBONCzyPt+RnMwc5VbdmzoYv6kai7dzg9sWluABz+Bkuq+kxCuKS2ra+YfZdbhE1cTbazYTP3sxwsADXv7PXVPU94L0G224Nel0BnN3MsX2bOW0Ypvw1ByxfDWz5rq6/ZsM8KPPGsyR3ckFm3OXQ50joMrTtb/hsA7VE2YADEzYH3/8oc3CqKoPcb1yQ2fAFbPwGqkvdvo59YcApLtD0Pgoy++9/gwPCoMaCjwkjCz7mwFRWWBdo1n8Jmxd5TUgCXbJhxC/cSLTeR7qlqU0jPqzZzYTPHoOPiPzM/xKYATzuNZsZ037s3Bh0f82XsH2F2x4d5/pojrraBZpeYyGxQ9vWdT/hIwqtrWnyvgdj9lUomc+dwExgG5AEtJO5P8xBq7YW8lfWBZoN86DIu285Ps0FmKFnu2HP3Ue65aJNi7ng47PgY8IilOBzLHADsAFYqqp274yJrJoq2PydF2i8R/kOty+li8tojrrKPXc5vG4VTrNPajQa9VmzmwmPPQYfVS0DbhORE4Gy8FfJHPSKt7jBARu/ds95C6Gmwu3L6A+DJ7qBAb2PgIxDbHBAK/PfUudvdjMmHFoy4OA7Vf1P2GpiDk6+atiy2I0+y/3aPRd599dEx0G34TD6EteU1vtISO3StvU9CFTW1AJe8LHMx4RJS4LPU8CkcFXEHCSKt3pBpomsJrU79BoD437lgk234RAT37b1PQiVV7nh1TVEg1a3cW3MgaolwcfaNkzL+KrdLM+BJrSv62YNqJfVjIGeYyG9R9vW1wBQXu2Cj49o1FfexrUxB6qWBB+bAdrsXr2sZr6X1XhfXv6sZqyX1XQdZqPQ2qmyKn/wEbvPx4SNZT5m7+wuq4mK9bKai9yCab3G7vezPB9MyqvqMh+b4cCES0uCz01hq4Vp/0q21QWZjd80yGq6uSAz9jLXfNZtuGU1+7GyKpft1NgMByaMQg4+qroknBUx7YivGrYuCRqB9jXsXO/2Ncxqeo5xWY0Ndz5glHl9PjaxqAmnkIOPiAwGJuOWuFbcAnCzVHV5mOpmIiWkrOZSy2oOEoHRbhoFapmPCY+Qgo+I3ABMA14GvvY298QtJPeyqt4bpvqZ1rbHrGYYjJoeNALNspqDjfX5mEgINfO5BDhctf6gfxF5AFgKWPBpr0q217+vZtO3dVlNSlcXZMbMqLuvJjaxbetr2lxFjf8+nyjEltE2YRJq8KkFuuNWDA3Wzdtn2oN6WY2X2exY5/ZFxbjhzaMuDBqB1suyGtNIRbX7L11LFFJrN5ma8Ag1+PwX8B8RWQV40wfTGzgUuCocFTMhaJjV5C2Eam/6PX9WM/pi13zWPceyGhOSSi/zqSLGmt1M2IQUfFT1fREZCIzFDTgQIBf4RtXy8ojw1bisJvi+moZZzcgLLKsx+8yf+dQQTZRlPiZMWjLUuhaY13C7iFykqk+3aq0OdqqwK89lMpvmeyPQvg3Karq4IGNZjQmDSm+odTUxRGmN+320P2RMK2uNZbTvACz47IvSAhdc8ha6AQF530LJVrcvKga6DoUR57uMpucY6NDbvgxM2FT4g496Xw++aoiJa8MamQNRqEOtFze3C7A57luiYhdsXuQFmYUu0PinpUEgawAcMh66j4AeI13gsazGRJB/SYVqvEX5aqsBCz6mdYWa+XQBJgA7GmwX4ItWrdGBpLrczX/mz2byFkL+KgJztHbo45Z5HjPDPXcbDglpbVplYyqqfaTEx1BT4898qoDkNq2TOfCEGnzeAVJUdVHDHSLySavWaH/lq4atS+uymU0LYdsy8I/HSOnqMpmhZ7tA030EJGe2bZ2NaUJFdS0p8TFUBYKPzXJgWl+oo90u2c2+81qvOvuJWp/LYAKB5luX4fgq3f6EDi7QDPzvuuaztO5tW2djQlRZ4yMlIYaaUq/ZzVfVthUyB6RQ+3yOBOapf3H3g4mqG9IcGBCw0PXZVJW4/bHJbrTZ2EtdkOk+Ajr2swEBZr9VUV1LcnxM3YADG25twiDUZrcLgb+LyErgfeB9Vd0Svmq1oV2b67KZvIXuUV7o9kXHuQEAw6d5gWakGyAQFd22dTamFVXU+EiJj64bcOCz4GNaX6jNbr+GwMzWPwWeEZF0YDYuGM3dL282ra2B1R+5bMaf2RRvdvskGjoPgcET6wJN5yE25NQc8Cqqa8lMjscnFnxM+ITa7PZT4DtVXQGsAB4UkURgPHA28AAwOmy1DJct38PzZ7nXmQOg37Gu2ay7N8Q5Lqlt62dMGyivqiE5Ppoq8f7Qsj4fEwahNrudBdwlIl1wwWcR8J33/F/7ZdYDbhDABc+7PpuE9LaujTERsaPUBZOOyU1n8SWVPpLjY6iM8vf52Gg30/qiQimkqjNUdTTwZ+AHYC0u6/maxjNd7z9SusAhx1ngMQeNyhofpz00h+Pv/4SCksomy5RW1pAcF40vKmiGA2NaWUun17lIVYf734jI34HrW7dKxphweW1BLpt2uvWcPlu1nTNG9Ky331erlFe7zIeoWLdgijW7mTAIKfMJsktERvnfqOoCYGDrVskYEw5FZdU8+O9VDO/VgcTYaL7bWNSoTGmVa2JLiY+hNirWbbSh1iYMWpr5XAw8LyLLgAXAUMB+M43ZD9z97jJ2lFXxzEVjuOPtpSzO3dmoTFml674NZD5gzW4mLFqU+ajqKuAo4D3cfG/LgZ+FoV7GmFaUt7Ocfy3cxAVH9iG7RzrDenZgad4uqn11CxHPXZ3PEX/4DwDpibFotAUfEz4hBR8ROUFEOgGoqk9VX1XVW1T1L6pa0NKLisipIrJSRFaLyI1N7I8XkZne/q9EpK+3PVNEZotIiYg83OCYUSLyvXfM30RsigFj/J6btx5V5eKf9ANgWM90KmtqWbmlOFDmsc/WBF73zkhCJXhiUWNaV6iZz0fA9yKSJyIfisj9InKhiIwQkfiWXFBEooFHcDerDgGmiciQBsUuAXao6qHAg8Afve0VwC3AdU2c+lHgMmCA9zi1JfUy5kC1sbCMF7/awMlDutArw927NqpPRwC+WlsYKFdWVTekuk9mkpvRA2yotQmLUIPP1UAe8DfgbmAlMAp3c2lLh1qPBVar6hpVrQJeBiY3KDMZ+Kf3+jXgRBERVS1V1Tm4IBQgIt2ANFX90pt/7lng9BbWy5h2b9XWYv784Upm/HM+T89dG2g2W5dfynWvfsf4+z/hyTlr8U/DmLujjGmPz0NVuX7CoMB5enZM4tDOKXyycltg29p8t1JufEwUqQmxEG2ZjwmfUKfXeVhEnsQFob/ggtA1eznRaA9gY9D7XGBcc2VUtUZEioBMIH8358xtcM4eTRUUkctwGRK9e/duad2NibiSyhr+7/vNvL9kCx+v3EaUCN07JPDR8q28uSiP/p2SeWtRHjFRQt/MZO56Zxk/bClmQnYXbpu1lF3l1bww4wgO7Zxa77zjB3Xin1+sp7SyhvJqH/kllUw/qi+/Pq4/AOrPfKzPx4RByKPdVLUc+KOIPAr8FvhaRK5U1a9aeM2m+mIaBrFQyuxVeVV9DHgMYPTo0QffLN1mv7GhoIxHP13NW4vyKKvy0aNDIpcf158ZxxxCRnIcby3axG2zlrIsr4jzxvbmqhMOJSslngf+/QMPz17NzPkbyUqJ5/kZ4xjas/GN1OMHdebxz9fyxY8FJMW5edxOHtKFrukJAIgNODBhFOrcbscAhwGDvefOQDEuG2mpXKBX0PueuCa9psrkikgMkA4U0rxc7zy7O6cx+4UVW3bx3JfrmfnNRqKjhNNzenDOmF6M7N2B4HE0k3N6cOJhXfDVKumJsYHt100YxKnZXdm6q4JjBnQiLqbp1vXRfTNIjotm9sptHJLlViod1DUoO4ry9/lY8DGtL9TM51PcXG4vAX9T1XX7cM1vgAEi0g/YBJwLNFyQbhZuGYcvgSnAx7tr4lPVzSJSLCJHAF8BFwAP7UMdjWl1uTvK+GpNIZt2lrM2v5TiihrSE2OJjoLy6lpKKqrZXFTBii3FxEYLU8f04uoTB9AlLaHZc6bEN/1fOLtHOtk9dj9tVFxMFEf2z+KL1flU19SSlRJPVkrd+KGoWJtY1IRPqMHnctwNpROBa0WkAPjeeyxR1TdDvaDXh3Ml8AEQDTylqktF5E5gvqrOAp4EnhOR1biM51z/8SKyDkgD4kTkdOAUVV3m1fEZIBH4P+9hTJtSVT5ZuZ2HZ69mwfodge2dUuPJTI5jWV41tQqJcdEkx0eTmRLH7T8fwqScHmQ0M/FnaxrTtyMfLd9KVU0tg7vW7xOKCgw4sNFupvWFGnweC848RKQnMAwXkM4C3vRGo4XUh6Kq7+FuVA3edmvQ6wrcUg1NHdu3me3zgexQrm9MuNTWKmvyS/hhawlrtpfwr4WbWLO9lF4Zidz408EcP6gTh3ZKISa6pTNbhcfovhkA5BVV8LOh3erti4mJxUcU0Zb5mDAINfjMFpHXgbdUdYOq5uL6Yz4CjhGRf+IWlnsmTPU0pl2qqqllwfodLNlUxLcbdjBvTQE7yur6SEb36cjlU/ozOadHs30vbSm7R1rg9eBuafX2xUZHUUMM0dbnY8Ig1OBzKm5et5e8vpqdQAKu2exD4EFVXRSeKhrTPmzbVcHCjTtZnLuTH7eVsia/hHUFZVTVuHttemUkMn5wZ444JJPDu6fRPT2x2TVz2ov4mGgOyUpmTX5po2Y3F3yiibfRbiYMQr3PpwL4O/B3EYkFsoByVW08M6Ex+7nyKh9L84pYm1/Kyi3FrNhSzKptxWzd5da/iYkSemcmcUhWCscP6syoPh0Z1adjvc76/cljF4xmwfpCDu9eP/OJixGqibGh1iYsWjqrNapaDWwOQ12MaRNbd1WwaONOFqzfwddrC1myqYiaWtd9GR8TxaCuqfzk0CwO755OTq90Du+eTkJsdBvXuvUc2jmFQzunNNoeGx1FNdE21NqERYuDjzH7s/IqHyu27GJJ3i6W5Bbx9bpC1uaXAhAXHcXwXulceuwhjOrdkf6dU+idkUR01ME5R21sdBTVapmPCQ8LPuaAVVRezbK8XSzNK2Kp97x6WwleUkN6Yixj+nbkF+N6M6J3Rw7vnnZAZTT7KpD5WPAxYWDBxxwQthdX1gsySzbtYkNhWWB/l7R4srunc+rhXTm8RzqHd0+jR4fEejMGmPriYqKo0hjUV9Xk/FXG7IsWBR8RORt4X1WLReR3wEjgblX9Niy1M6aB/JLKwCCAlVt2sWJLMRsLy+oNb+6TmcTQHulMHdOLbC/Q7K+DAdpSXLRQQzTqq7bgY1pdSzOfW1T1VRE5GpgA3I9bR6fhrNTG7DVfrbI2v4TV20pYX1DGxh1lgZFn+SV1NzxmJscxuFsqp2Z349DOKWR3T+Ow7mmkJcTu5uwmVP5mN62xm0xN62tp8PF5zxOBR1X1LRG5vXWrZA4WqsqmneWs3lbCuvxSVm4tZlmey2Yqa+qWd+6QFEufjCTGD+rMoK6pDO6axqCuqXRKtWwmnFzwiaHWV431hJnW1tLgs0lE/gGcjFteIZ7QF6QzB6nSyhp+2FrM+oIy71HKj9tdZlNa5QuU65AUy5BuaZx/RB8O65bGwC6p9M5Mqjdjs4mc2Bh3k6llPiYcWhp8zsHNdnCfqu70VhC9vvWrZfYn5VU+cneUkbuznNzCMn7YWsK6glK27qpge3Flvf4YgG7pCfTvlMLZo3sxsEsqA7qk0CcziU4p8TYAoB2JixaqbKi1CZOWBp9aoB/wSxFRYA6uz8cc4Eora1hXUMra/FLW5ZeyzstgNhSWBe7890uNj+GQzin0zUxmTN8MuqYlMLBrKodkJdMrI8mGM+8n/NPrqE0sasKgpcHnWWAXdWvlTAOeo5kZqM3+o9pXy+adFWzcUcbGQtfJn7uj3Htdzvbi+gGmc2o8fTOTOWZAJ/pkJNE7M4meHRPp0SGJLmmWwRwI/H0++MrbuirmANTS4DNIVYcHvZ8tIt+1ZoVM+BSVV7Ox0Ot3KSxlfb573lhYzuai8sDNlwDRUUK39AR6dUxi/KBO9MlMpm9mMn2zkuibmUxyM4uYmQNHYLSbZT4mDFr6DbJQRI5Q1XkAIjIOmNv61TItVVVTy9ZdFeTtLCevqJy8ne715qIKNu0oJ29nOcWV9RcFy0qJp3dGImP6dqRXRg96ZbjspVfHJLqlJ7SbNWdM24iLEXYRg9TaYnKm9YUUfETke0CBWOACEdng7eoNLAtT3UyQqppaNheVs7Gw3HXu7ygPNI3l7ihjW3ElDZfy65gUS7f0RHpnJnFk/0y6d0igd0Yyvb1msuaWYDYG6tbzsWW0TTiE+u1zWlhrYfDVKpuLytlQWEZuoXuu639p3Ofibxbr2TGRYwZ0okeHRLp3SKB7h0T3SE8kMc469s3ei4uOokqjLfMxYRHqej7r/a9FpCMwALeYnN/6RgeZemprlfySSjbuqMtc6jr0y9i0ozwwjT807nPp3iGRHh0SA01jXdOsWcyEl7vPJwaxodYmDFo6t9sM4BqgJ7AIOAL4Ejih9au2f6mtVbaXVNYLLP4msU07ysndWR5Y8dIvIzmOXhluHrKJQ7vRKyOJ3hlJrs+lQwKxFlxMG4rzj3ZTCz6m9bW00f8aYAwwT1XHi8hg4I7Wr1b703RwqXu9aUc5Vb76wSUzOY6eHRM5rFsaJw/pQs+OifTs6A1J7phIUpz1uZj2yz/aLcoyHxMGLf32q1DVChFBROJVdYWIDApLzSKstlbZVhwcXOoHmbydFY2CS1ZKHD06JjGkexqnHN4lEFh6drDgYvZ/sdFuGW1R6/Mxra+l3465ItIBeBP4t4jsAPJav1qRsWlHOb984ivXNLaznGpf/eFiWSnx9OyYSHaPdCZkdw0El17ezZTWoW8OZLHRUdRoNFHqg9paiLJmYNN6WhR8VPUM7+XtIjIbSAfeb/VaRciuimpKKmvI7pHOqdndvGYx1zTWo4ONFjMHt8AMBwC11RBls4ib1rPX7UKq+mlrVqQtHNYtjTev+ElbV8OYdsk1u3l/gPmqIcaCj2k9lkcbY5oUGxOU+diNpqaVWfAxxjQpNsrNag2A3WhqWlmLgo+IfBGuihhj2pfYaKHKMh8TJi3NfBIabhCRY1qpLsaYdiQ6SvAF9/mYg5cqlO+A7Stb7ZQtXlJBRN4AlgJLgK3AE0D/VquRMaZdEBFqo+LcGws+B56aKigrgNLtUJYPpd6jLN9tKy2Akq1Qsg0t2Yr4Kvd8zhZoafBZC9wDZAOjgO4cJDMcGHMwUgkaam3aN191XTCpF0i8YBK8rywfKoqaPE0t0ZTEpFMkaeTTgS2+fuRWD2dLbRrbtSMuBOy7lgafKlX9BvimVa5ujGnXNDrGLaZifT6R56vZQ2bSIMBU7GzyNLVEURaTzq6oDuwgje3anS01A8mrSaZA0wKPQlLJ13QqolPIiE8gKyWerJQ4MlPiyUqJp1tKHENT4nnoD20TfI5rlasaY/YLGhUHPtwXodk3vhooLwwKHP5sJL9xgCndvttgUhGbTnF0B3aSRr52Z5tvIJs0hS3BAQX3XEQyyfFxQYGkLqAMDnrt356WEIOIhP3jaOkMB8Xhqogxph2KivWCj2U+Taoqg9JtLmCUbPNeb4eS7e51yXYv2Gx3HfZoo1MoQkVsOiUxHdkl6RTQje06kLzoFDZVJbPNl0KBplNAqhdMUtDKKDomuYCSlRIfCCrdUuIZ2mBbVko8CbHtb7aWNpn5UkROBf4KRANPqOq9DfbHA8/i+pUKgKmqus7bdxNwCe6/xNWq+oG3fR1Q7G2vUdXREflhjDmARcXGQTUHT5+PqusL8QeMkm31nxu+ripp8jRVMamUxXakKLojO+jC9qgBbIl3wSS3Kpn8oOaunaRQWxFFbLR4QSPOy0Tc65FNbMtIitvv1/OKePARkWjgEeBkIBf4RkRmqWrwctyXADtU9VARORf4IzBVRIYA5wKH4wY7fCQiA1XV5x03XlXzI/bDGHOA88WnQxlQvKWtq7L3an1QVuhlIl6W0uRrL6A0keUpQnlsB4qjO7JT0imgD1tlGJujU9hYlcIWXxr5mh5o7qrEjRJMiY8JBI7M5DiyUuM5JCWesQ22ZUWwuau9aIvMZyywWlXXAIjIy8BkIDj4TAZu916/Bjws7l9lMvCyqlYCa0VktXe+LyNUd2MOKjuS+lKyM4WU9XNh+LltXZ06NVVesAhu2mr8Wku3QVkBorWNTuGTGIqjO7BDOlBAOtt8A8mrGcVmXyoFmk4+6eSre+wghdrKaNITY8lIiqNjchwdk+LISI6lY3IcfZJcNpLhBZPMZBdcbHLi5rVF8OkBbAx6nwuMa66MqtaISBGQ6W2f1+DYHt5rBT4UEQX+oaqPNXVxEbkMuAygd+/e+/aTGHOAS06I5/voIRy5bm54L6TqOtgDfSf+IJJf77WWbkdLthFV2fQw4QpJ8IJJGlt9aWz1DSWftEAQydd0Ckhju6ZDQjoZ8fGBQOIPJpnJcQzwAkxGYF8s6Ymx+31TV3vSFsGnqbyyYS9cc2V2d+xPVDVPRDrj1hpaoaqfNSrsgtJjAKNHj27c+2eMCejZMYnPVg3kyMLnXdNbatfQD66uaCaINHx4+5qYP04RSqPT2CHpbK9NY0tNJttq+7lAgmvmytd0imMy0KQsklPTyEiOC2QnGclxZCbFNgomHZJibZn6NtYWwScX6BX0vieNF6Tzl8kVkRjcukGFuztWVf3P27xZGMYCjYKPMSZ0A7uk8Hz1YG6IB374APoe7d1bUuCGBvuHCpcVNn5f1fTg2JroBMrjMiiL6cjOqA5s0x5sik1lXXkieTWp3hBhl6WURqfRKSmZrukJdEtPoGt6At3TExmWnkCXtAQXXFLibNXg/VBb/It9AwwQkX7AJtwAgvMalJkFXIjry5kCfKyqKiKzgBdF5AHcgIMBwNcikgxEqWqx9/oU4M7I/DjGHLgm5/Tg8U+GsKskkbS3r26yjC8qnvLYjpREp7NT0ijQ/mxlGHmSzMaq1MCoLn/zVzkJUOqOTYyNpndGEr06JdIrI4kRGUnufUYSXVITSEs8uDrhDyYRDz5eH86VwAe4odZPqepSEbkTmK+qs4Angee8AQWFuACFV+4V3OCEGuAKVfWJSBfgDe+XNAZ4UVX32xVWjWkvEmKjeeriI7nqz1dzqGyiUFMpJM09a/Svce0AAAo+SURBVCqFpLpggpsFu1NKPJ3TEuicGk/ntHh6piYwMi2ezOR4kuNjSI6PJiU+htSEWFITYtrl/ScmMkT14O32GD16tM6fP7+tq2FMu1dcUc3c1QXMW1PAnNX5XHXCoYG+k/RE90hLiCUqyrKUA52ILGiN+yitodQYs0epCbGcmt2VU7NbMODAmN2w4R7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiLPgY4wxJuIs+BhjjIk4Cz7GGGMizoKPMcaYiGuT4CMip4rIShFZLSI3NrE/XkRmevu/EpG+Qftu8ravFJEJoZ7TGGNM+xHx4CMi0cAjwE+BIcA0ERnSoNglwA5VPRR4EPijd+wQ4FzgcOBU4O8iEh3iOY0xxrQTbZH5jAVWq+oaVa0CXgYmNygzGfin9/o14EQREW/7y6paqaprgdXe+UI5pzHGmHYipg2u2QPYGPQ+FxjXXBlVrRGRIiDT2z6vwbE9vNd7OicAInIZcJn3tlJEluzFzxBJWf+/vfONkasqw/jvsaWibdMWFzTR2lKCFGhsQYVgsRQ1NFZIimJoiaE2SiKiwgdU4oei4IciCYZEE2mQVExsNIFqVeiflEC1sbYFt2wLFWiXkFqlKSVgCZJ0+/DhnEmmy0yZ3Z29c3b7/pLJ3HvOuec++87deec995z3Aoc6LaIFQmd7CZ3tZSToHAkaAc5pRyedcD5qUOYW2zQrbxTB9e8zFdorgZUAknbY/mRzqZ1nJGiE0NluQmd7GQk6R4JGSDrb0U8nht32A1Pr9j8CHGjWRtJYYBJw+ATHttJnEARBUAidcD7bgbMlnSlpHGkCwdp+bdYCS/P2NcBjtp3LF+fZcGcCZwPbWuwzCIIgKITKh93yPZxvA+uBMcADtndLugPYYXst8CvgN5JeIEU8i/OxuyX9HngGOArcZLsPoFGfLchZ2eY/bzgYCRohdLab0NleRoLOkaAR2qRTKaAIgiAIguqIDAdBEARB5YTzCYIgCCpnVDofSQ9IOthsDY+k+ZJek9SdX8vr6ipJ0zNEjS9K6snlbZn2OFiddVq7Je2W9ERdeWUpj4aosxh7Svpe3We+S1KfpNNyXTH2fBedJdlzkqQ/SdqZP/dldXVLJT2fX0sbHV+Axr46Ow/rJKoWdE6RtEbS05K2SZpVVzfwa9P2qHsB84ALgV1N6ucDf25QPgbYC8wAxgE7gfNK0pjrXgS6CrHlZNIEkI/m/TOqtuVQdJZmz35tryLN9CzOns10lmZP4IfAXXn7dNIEpnHAacC+/D4lb08pSWPeP1KFHVvUeTdwe96eCWwayrU5KiMf25tJH+BAqSxNzxA0VkoLOq8DHrb9Um5/MJdXmvJoCDorZYCf+xJgdd4uzZ711OuslBZ0GpgoScCE3PYosADYaPuw7VeBjaR8kSVprJQWdJ4HbMpt9wDTJX2QQV6bo9L5tMglOcx9VNL5uaxR6p8Pv/PQymikEdLFukHSk0rpgjrJx4Apkh7Peq7P5aXZsplOKMueAEh6P+nL8KFcVJo9gYY6oSx7/hw4l7TovAe42fYxyrJnM40Ap0raIWmrpEUd0ldjJ/AlAEkXAdNIC/oHZctOpNcpgaeAabaPSFoI/IG0YLWV1D9V0UwjwFzbBySdAWyUtCf/aukEY4FPAJ8D3gf8XdJWyrIlNNFp+znKsmeNq4Attmu/REuzZ43+OqEsey4AuoHPAmdlPX+lLHs21Gj7ddIw8QFJM4DHJPXY3tshnSuAeyV1k5zkP0kR2qBseVJGPrZft30kbz8CnCKpi4LS9JxAI7YP5PeDwBpS2Nsp9gPrbL9h+xCwGZhNQbbMNNNZmj1rLOb4oazS7Fmjv87S7LmMNNxq2y8AvaT7FSXZs5nGelvuAx4HLuiQxtp30jLbc4DrSfenehmkLU9K5yPpQ3l8tRY+vgd4hYLS9DTTKGm8pIm5fDxwBdDJzNx/BD4jaWwegrkYeJaCbHkinQXaE0mTgMtImmuUZs+GOgu050ukaJd8f+Ic0uSC9cAVeQbXFJLO9SVpzNrem8u7gLmkSTMdQdLkfO0BfAPYnKOzQV2bo3LYTdJq0myxLkn7gduBUwBs/5KUL+5GSUeBN4HFTtM2Gqb+KUljvjjXZL80Fvit7XXDobEVnbaflbQOeBo4Btxve1c+thJbDkVnHs4oxp652dXABttv1I5zk7RUpekEiro+gTuBVZJ6SMNDP8iRL5LuJH1xAtzRb+iw4xolfRq4T9Ix0o/PFbaHzfm0oPNc4EFJfSQn+PVcN6hrM9LrBEEQBJVzUg67BUEQBJ0lnE8QBEFQOeF8giAIgsoJ5xMEQRBUTjifIAiCoHLC+QTBAJF0tSRLmtnmfqdLuq6dfQZBqYTzCYKBswT4G/nx7m1kOikB6juQNCrX5AUnL7HOJwgGgKQJwL+Ay4G1tmdKmg/8CDgEzAKeBL6aFwUvBO7JdU8BM2xfKeky4N7crUnp7DeSFvL1Ar8GXgW+CJwKjCetgv8p8IV8zE9s/y6f/8fAy8Ac4GFygkpSHrtFtvdK+gpp4WAf8JrtecNhoyBohfg1FQQDYxEpR9xzkg5LujCXXwCcT8pptQWYq/QgtfuAebZ78wryGrcCN9nekh3a/4HbgFttXwkg6WvAJcDHbR+W9GWSc5kNdAHbJdUSds4mOa7DpPQx99u+SNLNwHeAW4DlwALb/5Y0eRhsEwQtE8NuQTAwlpCeV0J+X5K3t9nen1Phd5OG0GYC+2z35jb1zmcLcI+k7wKTbTd7fsvGurQvlwKrbffZfhl4AvhUrttu+z+23yI92GtDLu/JWmrnXCXpBlIalCDoGBH5BEGLSPoAKe39LEkmfYEbeAR4q65pH+l/q1GqeQBsr5D0F2AhsFXS55s0rc+b1rS/fuc/Vrd/LGvB9jclXUwayuuWNMf2KyfoMwiGjYh8gqB1rgEetD3N9nTbU0n3Zy5t0n4PMEPS9Lx/ba1C0lm2e2zfBewgRUn/Ayae4PybgWsljZF0Ouk+0bZWxedz/sP2ctI9qKnvdkwQDBcR+QRB6ywhPVCrnoeAG0lDXcdh+01J3wLWSTrE8Y7iFkmXk6KkZ4BHSVHKUUk7gVWkCQf1rCHdA9pJiri+b/u/A5jyfbek2kMTN+V+gqAjxGy3IBhGJE3IT6MV8Avgeds/67SuIOg0MewWBMPLDfmxw7uBSaTZb0Fw0hORTxAEQVA5EfkEQRAElRPOJwiCIKiccD5BEARB5YTzCYIgCConnE8QBEFQOW8Ds3jOw+pe3cgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sil_wavel = (sil_data['energy'] * u.keV).to('angstrom', equivalencies=u.spectral())\n", + "plt.plot(olv_data['angstroms'], olv_data['abs'], label='OlivineAbs (Rogantini Fe K)')\n", + "plt.plot(sil_wavel, sil_data['abs'], label='ISMdust (Draine Fe K)')\n", + "plt.xlim(1.5, 1.9)\n", + "plt.ylim(0, 0.025)\n", + "plt.xlabel('Angstroms')\n", + "plt.ylabel(r'$\\tau$ abs ($Md / 10^{-4}$ g cm$^{-2}$)')\n", + "plt.title('Olivine Absorption, Fe K edge')\n", + "plt.legend(loc='upper left')\n", + "plt.savefig(\"olivineabs_FeK.pdf\", format='pdf')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:newdust-dev]", + "language": "python", + "name": "conda-env-newdust-dev-py" + }, + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/test.xcm b/test.xcm index f0f7292..f115b34 100644 --- a/test.xcm +++ b/test.xcm @@ -12,8 +12,8 @@ systematic 0 model powerlaw*ismdust 2 0.01 -3 -2 9 10 1 0.01 0 0 1e+20 1e+24 - 1 0.001 0 0 10000 100000 - 1 0.001 0 0 10000 100000 + 0.6 0.001 0 0 10000 100000 + 0.4 0.001 0 0 10000 100000 0 -0.01 -1 0 10 10 pl eemod