metadata
dict | text
stringlengths 0
40.6M
| id
stringlengths 14
255
|
|---|---|---|
{
"filename": "_maxpoints.py",
"repo_name": "plotly/plotly.py",
"repo_path": "plotly.py_extracted/plotly.py-master/packages/python/plotly/plotly/validators/scatterpolar/stream/_maxpoints.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator):
def __init__(
self, plotly_name="maxpoints", parent_name="scatterpolar.stream", **kwargs
):
super(MaxpointsValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "calc"),
max=kwargs.pop("max", 10000),
min=kwargs.pop("min", 0),
**kwargs,
)
|
plotlyREPO_NAMEplotly.pyPATH_START.@plotly.py_extracted@plotly.py-master@packages@python@plotly@plotly@validators@scatterpolar@stream@_maxpoints.py@.PATH_END.py
|
{
"filename": "cmd_parse.py",
"repo_name": "CadenArmstrong/simuTrans",
"repo_path": "simuTrans_extracted/simuTrans-master/cmd_parse.py",
"type": "Python"
}
|
#!/usr/bin/python
#lc_parse.py use to parse all the command lines for functions realted to run lc function.
import optparse
from fancyfont import colors
import os
tc=colors()
def runcfg():
p = optparse.OptionParser()
p.add_option('--eflag','-e',default=False,action='store_true',help='Creat example.cfg for all the parameter settings')
p.add_option('--infile','-i',default='example.cfg',help='the file to write cfg parameters')
options,arguments=p.parse_args()
return options
class fitlc_parse(object):
def __init__(self):
p=optparse.OptionParser()
p.add_option('--config','-c',default='example.cfg',help='the configuration file for the program')
p.add_option('--plot','-p',default=False,action='store_true',help='enable plotting')
p.add_option('--infile','-i',default='',help='overwrite the input file from configure file')
p.add_option('--outfile','-o',default='',help='overwrite the output file from configure file')
options,arguments=p.parse_args()
#self.cfgfile="example.cfg"
self.infile=options.infile
self.output=options.outfile
self.cfgfile=options.config
self.plot=options.plot
if not os.path.exists(self.cfgfile):
raise IOError, "configuration file %s does not exist" % self.cfgfile
self.mcmc=lambda:None
self.lc=lambda:None
self.params=[]
return
def __str__(self):
strparse=tc.red("Fitting has set up as the following\n")
strparse+=tc.blue("MCMC Params:\n")
for key,value in self.mcmc.__dict__.iteritems():
strparse+=(key+"="+str(value)+"\n")
strparse+=tc.blue("LC Params:\n")
for key,value in self.lc.__dict__.iteritems():
strparse+=(key+"="+str(value)+"\n")
strparse+=tc.blue("Model Params:\n")
for i in xrange(len(self.params)):
strparse+=str(self.params[i])+"\n"
return strparse
|
CadenArmstrongREPO_NAMEsimuTransPATH_START.@simuTrans_extracted@simuTrans-master@cmd_parse.py@.PATH_END.py
|
{
"filename": "kappa-maszcal-vs-profiley.ipynb",
"repo_name": "dylancromer/maszcal",
"repo_path": "maszcal_extracted/maszcal-main/docs/kappa-maszcal-vs-profiley.ipynb",
"type": "Jupyter Notebook"
}
|
```javascript
%%javascript
IPython.OutputArea.prototype._should_scroll = function(lines) {
return false;
}
```
<IPython.core.display.Javascript object>
```python
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
import matplotlib
matplotlib.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
matplotlib.rcParams['text.usetex'] = True
#matplotlib.rcParams['text.latex.unicode'] = True
matplotlib.rcParams['figure.dpi'] = 150
import matplotlib.pyplot as plt
matplotlib.rcParams.update({'figure.autolayout': True})
import seaborn as sns
sns.set(
style='whitegrid',
font_scale=0.9,
rc={'lines.linewidth': 1.4, 'lines.markersize': 1.6},
font='serif',
)
from jupyterthemes import jtplot
jtplot.style(theme='oceans16')
jtplot.style(context='notebook', fscale=1, spines=False, gridlines='--')
from mpl_toolkits import mplot3d
```
```python
from functools import partial
import numpy as np
import projector
import astropy.units as u
import maszcal.lensing
import maszcal.density
import maszcal.cosmology
import maszcal.concentration
```
```python
cosmo = maszcal.cosmology.CosmoParams()
delta = 200
mdef = 'mean'
comoving = True
rho_model = maszcal.density.ProjectorSafeNfwModel(
cosmo_params=cosmo,
delta=delta,
mass_definition=mdef,
comoving=comoving,
)
rho_model_ = maszcal.density.NfwModel(
cosmo_params=cosmo,
delta=delta,
mass_definition=mdef,
comoving=comoving,
)
def rho_func(r, z, mu, con):
mass = np.exp(mu)
return rho_model.rho(r, z, mass, con)
def rho_func_(r, z, mu, con):
mass = np.exp(mu)
return rho_model_.rho(r, z, mass, con)
convergence_model = maszcal.lensing.SingleMassConvergenceModel(
cosmo_params=cosmo,
rho_func=rho_func,
sd_func=lambda rs, func: projector.sd(rs, func, num_points=3000),
comoving=comoving,
)
z = np.array([0.123])
from_arcmin = 2 * np.pi / 360 / 60
thetas = np.logspace(np.log10(0.001*from_arcmin), np.log10(100*from_arcmin), 300)
mu = np.array([np.log(1.23e14)])
con = np.array([2.5])
kappas = convergence_model.kappa(thetas, z, mu, con).squeeze()
```
```python
convergence_model._convergence.sigma_crit(z_lens=z)
```
array([3270.67896785])
```python
import profiley.nfw
nfw = profiley.nfw.NFW(np.exp(mu), con, z, cosmo=convergence_model.astropy_cosmology,
overdensity=delta, background=mdef[0], frame='comoving')
rs = convergence_model.angle_scale_distance(z) * thetas
kappa__ = convergence_model._radius_space_kappa(rs, z, mu, con).squeeze()
kappa_profiley = nfw.convergence(rs, 1100).squeeze()
```
```python
nfw.sigma_crit(zs=1100) * (u.Msun/u.Mpc**2).to(u.Msun/u.pc**2)
```
array([2912.44787876])
```python
rhos_profiley = nfw.density(rs).squeeze()
rhos = rho_func(rs, z, mu, con).squeeze()
rhos_ = rho_func_(rs, z, mu, con).squeeze()
```
```python
to_arcmin = 1/from_arcmin
plt.plot(thetas*to_arcmin, rs**2 * rhos, label='maszcal')
plt.plot(thetas*to_arcmin, rs**2 * rhos_, label='maszcal nonproj')
plt.plot(thetas*to_arcmin, rs**2 * rhos_profiley, label='profiley', linestyle='--')
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\rho$')
plt.legend(loc='best')
plt.xscale('log')
#plt.ylabel(r'$\kappa_{\mathrm{maszcal}}/\kappa_{\mathrm{profiley}}$')
plt.gcf().set_size_inches(5, 4)
```
```python
to_arcmin = 1/from_arcmin
plt.plot(thetas*to_arcmin, thetas*kappas, label='maszcal')
#plt.plot(thetas*to_arcmin, thetas*kappa__, label='maszcal radial')
plt.plot(thetas*to_arcmin, thetas*kappa_profiley, label='profiley', linestyle='--')
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\theta \kappa$')
plt.legend(loc='best')
plt.xscale('log')
#plt.ylabel(r'$\kappa_{\mathrm{maszcal}}/\kappa_{\mathrm{profiley}}$')
plt.gcf().set_size_inches(5, 4)
```
```python
to_arcmin = 1/from_arcmin
plt.plot(thetas*to_arcmin, kappas, label='maszcal')
#plt.plot(thetas*to_arcmin, thetas*kappa__, label='maszcal radial')
plt.plot(thetas*to_arcmin, kappa_profiley, label='profiley', linestyle='--')
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\kappa$')
plt.legend(loc='best')
plt.xscale('log')
#plt.ylabel(r'$\kappa_{\mathrm{maszcal}}/\kappa_{\mathrm{profiley}}$')
plt.gcf().set_size_inches(5, 4)
```
```python
to_arcmin = 1/from_arcmin
plt.plot(thetas*to_arcmin, kappas/kappa_profiley, label='maszcal/profiley')
plt.ylim((0, 2))
#plt.plot(thetas*to_arcmin, thetas*kappa__, label='maszcal radial')
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\kappa$')
plt.legend(loc='best')
plt.xscale('log')
#plt.ylabel(r'$\kappa_{\mathrm{maszcal}}/\kappa_{\mathrm{profiley}}$')
plt.gcf().set_size_inches(5, 4)
```
```python
(kappas/kappa_profiley).mean()
```
0.8890286637706538
```python
cosmo_params = maszcal.cosmology.CosmoParams()
(maszcal.cosmology.SigmaCrit(cosmo_params, comoving=True).sdc(z_source=1100, z_lens=z)
/ maszcal.cosmology.SigmaCrit(cosmo_params, comoving=False).sdc(z_source=1100, z_lens=z))
```
array([0.89047195])
```python
```
```python
```
|
dylancromerREPO_NAMEmaszcalPATH_START.@maszcal_extracted@maszcal-main@docs@kappa-maszcal-vs-profiley.ipynb@.PATH_END.py
|
{
"filename": "Untitled2-checkpoint.ipynb",
"repo_name": "stevepur/DR25-occurrence-public",
"repo_path": "DR25-occurrence-public_extracted/DR25-occurrence-public-main/GKbaseline_kic/.ipynb_checkpoints/Untitled2-checkpoint.ipynb",
"type": "Jupyter Notebook"
}
|
```python
import numpy as np
import requests
import pandas as pd
from cStringIO import StringIO
import matplotlib.pyplot as plt
```
```python
# load the full catalogs
dr25StellarSup = pd.read_csv("../stellarCatalogs/dr25_stellar_updated_feh_all.txt", dtype={"st_quarters":str})
berger2018Stellar = pd.read_csv("../stellarCatalogs/dr25_stellar_supp_gaia.txt", dtype={"st_quarters":str})
berger2019Stellar = pd.read_csv("../stellarCatalogs/dr25_stellar_supp_gaia_logg.txt", dtype={"st_quarters":str})
print("the dr25StellarSup catalog has " + str(len(dr25StellarSup)))
print("the berger2018Stellar catalog has " + str(len(berger2018Stellar)) + " entries = "
+ str(float(len(berger2018Stellar))/len(dr25StellarSup)))
print("the berger2019Stellar catalog has " + str(len(berger2019Stellar)) + " entries = "
+ str(float(len(berger2019Stellar))/len(dr25StellarSup)))
```
the dr25StellarSup catalog has 200038 entries =
the berger2018Stellar catalog has 177911 entries = 0.889386016657
the berger2019Stellar catalog has 154911 entries = 0.774407862506
```python
# load the archive kois
dr25Koi = pd.read_csv("koiCatalogs/dr25_kois_archive.txt", dtype={"kepoi_name":str})
dr25PC = dr25Koi[dr25Koi.koi_pdisposition == "CANDIDATE"]
print("There are " + str(len(dr25PC)) + " PCs")
```
There are 4034 PCs
```python
dr25PCInDr25StellarSup = dr25PC[dr25PC.kepid.isin(dr25StellarSup.kepid)]
print("There are " + str(len(dr25PCInDr25StellarSup)) + " PCs "
+ str(float(len(dr25PCInDr25StellarSup))/len(dr25PC)) + " of all PCs in dr25StellarSup = "
+ str(float(len(dr25PCInDr25StellarSup))/len(dr25StellarSup)) + " of targets")
```
There are 4034 PCs 1.0 of all PCs in dr25StellarSup = 0.020166168428of targets
```python
dr25PCInBerger2018Stellar = dr25PC[dr25PC.kepid.isin(berger2018Stellar.kepid)]
print("There are " + str(len(dr25PCInBerger2018Stellar)) + " PCs "
+ str(float(len(dr25PCInBerger2018Stellar))/len(dr25PC)) + " of all PCs in berger2018Stellar = "
+ str(float(len(dr25PCInBerger2018Stellar))/len(berger2018Stellar)) + " of targets")
```
There are 3642 PCs 0.902825979177 of all PCs in berger2018Stellar = 0.0204709096121 of targets
```python
dr25PCInBerger2019Stellar = dr25PC[dr25PC.kepid.isin(berger2019Stellar.kepid)]
print("There are " + str(len(dr25PCInBerger2019Stellar)) + " PCs "
+ str(float(len(dr25PCInBerger2019Stellar))/len(dr25PC)) + " of all PCs in berger2019Stellar = "
+ str(float(len(dr25PCInBerger2019Stellar))/len(berger2019Stellar)) + " of targets")
```
There are 3188 PCs 0.790282597918 of all PCs in berger2019Stellar = 0.0205795585853 of targets
```python
period_rng = (50, 200)
rp_rng = (1., 2.)
occPcs = dr25PC[(dr25PC.koi_period>=period_rng[0])&(dr25PC.koi_period<=period_rng[1])&(dr25PC.koi_prad>=rp_rng[0])&(dr25PC.koi_prad<=rp_rng[1])]
print("There are " + str(len(occPcs)) + " PCs in " + str(len(dr25StellarSup)) + " observed targets")
```
There are 89 PCs in 200038 observed targets
```python
occPcsInDr25StellarSup = occPcs[occPcs.kepid.isin(dr25StellarSup.kepid)]
print("There are " + str(len(occPcsInDr25StellarSup)) + " in-box PCs "
+ str(float(len(occPcsInDr25StellarSup))/len(occPcs)) + " of all PCs in dr25StellarSup = "
+ str(float(len(occPcsInDr25StellarSup))/len(dr25StellarSup)) + " of targets")
```
There are 89 in-box PCs 1.0 of all PCs in dr25StellarSup = 0.000444915466061 of targets
```python
occPcsInBerger2018Stellar = occPcs[occPcs.kepid.isin(berger2018Stellar.kepid)]
print("There are " + str(len(occPcsInBerger2018Stellar)) + " in-box PCs "
+ str(float(len(occPcsInBerger2018Stellar))/len(occPcs)) + " of all PCs in berger2018Stellar = "
+ str(float(len(occPcsInBerger2018Stellar))/len(berger2018Stellar)) + " of targets")
```
There are 75 in-box PCs 0.842696629213 of all PCs in berger2018Stellar = 0.000421559094154 of targets
```python
occPcsInBerger2019Stellar = occPcs[occPcs.kepid.isin(berger2019Stellar.kepid)]
print("There are " + str(len(occPcsInBerger2019Stellar)) + " in-box PCs "
+ str(float(len(occPcsInBerger2019Stellar))/len(occPcs)) + " of all PCs in berger2019Stellar = "
+ str(float(len(occPcsInBerger2019Stellar))/len(berger2019Stellar)) + " of targets")
```
There are 65 in-box PCs 0.730337078652 of all PCs in berger2019Stellar = 0.000419595767893 of targets
```python
```
```python
```
```python
# restrict to GK dwarfs
dr25StellarSupGK = dr25StellarSup[(dr25StellarSup.radius < 1.3)&(dr25StellarSup.teff >= 3900)&(dr25StellarSup.teff < 6000)]
berger2018StellarGK = berger2018Stellar[(berger2018Stellar.radius < 1.3)&(berger2018Stellar.teff >= 3900)&(berger2018Stellar.teff < 6000)]
berger2019StellarGK = berger2019Stellar[(berger2019Stellar.radius < 1.3)&(berger2019Stellar.teff >= 3900)&(berger2019Stellar.teff < 6000)]
berger2018StellarGKflags = berger2018Stellar[(berger2018Stellar.Evol == 0)&((berger2018Stellar.Bin == 0)|(berger2018Stellar.Bin == 2))&(berger2018Stellar.teff >= 3900)&(berger2018Stellar.teff < 6000)]
berger2019StellarGKflags = berger2019Stellar[(berger2019Stellar.Evol == 0)&((berger2019Stellar.Bin == 0)|(berger2019Stellar.Bin == 2))&(berger2019Stellar.teff >= 3900)&(berger2019Stellar.teff < 6000)]
print("the dr25StellarSupGK catalog has " + str(len(dr25StellarSupGK)))
print("the berger2018StellarGK catalog has " + str(len(berger2018StellarGK)) + " entries = "
+ str(float(len(berger2018StellarGK))/len(dr25StellarSupGK)))
print("the berger2019StellarGK catalog has " + str(len(berger2019StellarGK)) + " entries = "
+ str(float(len(berger2019StellarGK))/len(dr25StellarSupGK)))
print("the berger2019StellarGKflags catalog has " + str(len(berger2019StellarGKflags)) + " entries = "
+ str(float(len(berger2019StellarGKflags))/len(dr25StellarSupGK)))
print("the berger2019StellarGKflags catalog has " + str(len(berger2019StellarGKflags)) + " entries = "
+ str(float(len(berger2019StellarGKflags))/len(dr25StellarSupGK)))
```
the dr25StellarSupGK catalog has 92568
the berger2018StellarGK catalog has 61217 entries = 0.661319246392
the berger2019StellarGK catalog has 67054 entries = 0.724375594158
the berger2019StellarGKflags catalog has 71412 entries = 0.771454498315
```python
occPcsInDr25StellarSupGK = occPcs[occPcs.kepid.isin(dr25StellarSupGK.kepid)]
print("There are " + str(len(occPcsInDr25StellarSupGK)) + " in-box PCs "
+ str(float(len(occPcsInDr25StellarSupGK))/len(occPcs)) + " of all PCs in dr25StellarSup = "
+ str(float(len(occPcsInDr25StellarSupGK))/len(dr25StellarSupGK)) + " of targets")
```
There are 58 in-box PCs 0.651685393258 of all PCs in dr25StellarSup = 0.00062656641604 of targets
```python
occPcsInBerger2018StellarGK = occPcs[occPcs.kepid.isin(berger2018StellarGK.kepid)]
print("There are " + str(len(occPcsInBerger2018StellarGK)) + " in-box PCs "
+ str(float(len(occPcsInBerger2018StellarGK))/len(occPcs)) + " of all PCs in berger2018Stellar = "
+ str(float(len(occPcsInBerger2018StellarGK))/len(berger2018StellarGK)) + " of targets")
```
There are 39 in-box PCs 0.438202247191 of all PCs in berger2018Stellar = 0.000637077935867 of targets
```python
occPcsInBerger2019StellarGK = occPcs[occPcs.kepid.isin(berger2019StellarGK.kepid)]
print("There are " + str(len(occPcsInBerger2019StellarGK)) + " in-box PCs "
+ str(float(len(occPcsInBerger2019StellarGK))/len(occPcs)) + " of all PCs in berger2019Stellar = "
+ str(float(len(occPcsInBerger2019StellarGK))/len(berger2019StellarGK)) + " of targets")
```
There are 34 in-box PCs 0.38202247191 of all PCs in berger2019Stellar = 0.000507054016166 of targets
```python
```
|
stevepurREPO_NAMEDR25-occurrence-publicPATH_START.@DR25-occurrence-public_extracted@DR25-occurrence-public-main@GKbaseline_kic@.ipynb_checkpoints@Untitled2-checkpoint.ipynb@.PATH_END.py
|
{
"filename": "agent.py",
"repo_name": "simonsobs/socs",
"repo_path": "socs_extracted/socs-main/socs/agents/rtsp_camera/agent.py",
"type": "Python"
}
|
# Copyright (C) 2023-2024 Simons Observatory Collaboration
# See top-level LICENSE.txt file for more information.
"""Agent to capture images from cameras which support the RTSP protocol.
"""
import os
import time
from datetime import datetime, timedelta, timezone
import cv2
import ocs
import txaio
from ocs import ocs_agent, site_config
from ocs.ocs_twisted import Pacemaker, TimeoutLock
txaio.use_twisted()
from socs.common.camera import (CircularMediaBuffer, FakeCamera,
MotionDetector, image_read_callback,
image_write_callback, video_write_callback)
class RTSPCameraAgent:
"""Agent to support image capture from RTSP cameras.
This Agent captures images and writes them to a feed, as well as saving frames
to disk. The camera can also be triggered to record....
Args:
agent (OCSAgent): OCSAgent object from :func:`ocs.ocs_agent.init_site_agent`.
directory (str): The path to image storage for this camera.
address (str): The hostname or IP address of the camera.
user (str): The user name for camera access.
password (str): The password for camera access.
seconds (int): The seconds between snapshots.
port (int): The RTSP port to use (default is standard 554).
urlpath (str): The remaining URL for the camera, which might include
options like channel and subtype. This will depend on the manufacturer.
jpeg_quality (int): The JPEG quality for snapshot images (0-100).
max_snapshot_files (int): The maximum number of snapshots to keep.
record_fps (float): The frames per second for recorded video.
record_duration (int): The number of seconds for each recorded video.
max_record_files (int): The maximum number of recordings to keep.
motion_start (str): ISO time (HH:MM:SS+-zz:zz) to start motion detection.
motion_stop (str): ISO time (HH:MM:SS+-zz:zz) to stop motion detection.
disable_motion (bool): If True, disable motion detection.
fake (bool): If True, ignore camera settings and generate fake video
for testing.
Attributes:
agent (OCSAgent): OCSAgent object from :func:`ocs.ocs_agent.init_site_agent`.
log (txaio.tx.Logger): Logger object used to log events within the
Agent.
lock (TimeoutLock): TimeoutLock object used to prevent simultaneous
commands being sent to hardware.
"""
def __init__(
self,
agent,
directory,
address,
user,
password,
seconds=10,
port=554,
urlpath=None,
jpeg_quality=20,
max_snapshot_files=10000,
record_fps=20.0,
record_duration=60,
max_record_files=100,
motion_start=None,
motion_stop=None,
disable_motion=False,
fake=False,
):
self.agent = agent
self.topdir = directory
self.log = agent.log
self.lock = TimeoutLock(default_timeout=5)
self.address = address
self.port = port
self.user = user
self.password = password
self.seconds = seconds
self.urlpath = urlpath
self.fake = fake
self.motion_start = motion_start
self.motion_stop = motion_stop
self.motion_detect = not disable_motion
if self.urlpath is None:
# Try the string for the Dahua cameras at the site
self.urlpath = "/cam/realmonitor?channel=1&subtype=0"
self.connection = f"rtsp://{self.user}:{self.password}"
self.connection += f"@{self.address}:{self.port}{self.urlpath}"
# We will store recordings and snapshots to separate subdirs
if not os.path.isdir(self.topdir):
os.makedirs(self.topdir)
self.img_dir = os.path.join(self.topdir, "snapshots")
self.vid_dir = os.path.join(self.topdir, "recordings")
self.record_duration = record_duration
self.record_fps = record_fps
# Create the image buffer on disk
self.img_buffer = CircularMediaBuffer(
self.img_dir,
"img",
"jpg",
max_snapshot_files,
image_write_callback,
read_callback=image_read_callback,
recent=3,
quality=jpeg_quality,
)
# Create the recording buffer on disk
self.vid_buffer = CircularMediaBuffer(
self.vid_dir,
"vid",
"mp4",
max_record_files,
video_write_callback,
read_callback=None,
recent=0,
fps=record_fps,
)
# Register OCS feed
self.feed_name = f"RTSP_{self.address}"
agg_params = {"frame_length": self.seconds} # [sec]
self.agent.register_feed(
self.feed_name,
record=True,
agg_params=agg_params,
buffer_time=1.0,
)
def _in_motion_time_range(self):
"""Determine if we are in the valid time range for motion detection."""
if self.motion_start is None or self.motion_stop is None:
# We are not using the start / stop time range, so all times are valid
return True
# The current time in UTC
curtime = datetime.now(tz=timezone.utc)
# Convert the start / stop times to datetimes based on today
curdaystr = f"{curtime.year}-{curtime.month:02d}-{curtime.day:02d}"
# The datetimes for start/stop today
def _dt_convert(timestr):
tstr = f"{curdaystr}T{timestr}"
try:
tm = datetime.strptime(tstr, "%Y-%m-%dT%H:%M:%S%z")
except ValueError:
tm = datetime.strptime(tstr, "%Y-%m-%dT%H:%M:%S")
msg = f"Motion time '{timestr}' is not "
msg += "timezone-aware. Assuming UTC."
self.log.warning(msg)
tm = tm.replace(tzinfo=timezone.utc)
return tm
start = _dt_convert(self.motion_start)
stop = _dt_convert(self.motion_stop)
if stop <= start:
# We are starting today and stopping tomorrow
stop += timedelta(days=1)
if curtime > start and curtime < stop:
return True
else:
return False
@ocs_agent.param("test_mode", default=False, type=bool)
def acq(self, session, params=None):
"""acq(test_mode=False)
**Process** - Capture frames from an RTSP camera.
Args:
test_mode (bool): Run the Process loop only once. Meant only
for testing. Default is False.
Notes:
Individual frames are written to a circular disk buffer. Metadata
about the captured images is stored in the session data. The format
of this is::
>>> response.session['data']
{
'address': 'camera-c1.example.org',
'timestamp': 1701983575.123456,
'path': '/ocs/cameras_rtsp/c1/img_2023-12-29T02:44:47+00:00.jpg',
}
"""
pm = Pacemaker(1 / self.seconds, quantize=False)
pmgrab = Pacemaker(self.record_fps, quantize=True)
frames_per_snapshot = int(self.seconds * self.record_fps)
session.set_status("running")
self.is_streaming = True
# Open camera stream
if self.fake:
cap = FakeCamera()
else:
cap = cv2.VideoCapture(self.connection)
if not cap.isOpened():
self.log.error(f"Cannot open RTSP stream at {self.connection}")
return False, "Could not open RTSP stream"
# Tracking state of whether we are currently recording motion detection
detecting = False
detect_start = None
record_frames = int(self.record_fps * self.record_duration)
motion_detector = MotionDetector()
snap_count = 0
while self.is_streaming:
# Use UTC
timestamp = time.time()
data = dict()
for iframe in range(frames_per_snapshot):
pmgrab.sleep()
# Grab an image
_ = cap.grab()
success, image = cap.retrieve()
if not success:
msg = "Failed to retrieve snapshot image from stream"
self.log.error(msg)
return False, "Broken stream"
# Motion detection. We ignore the first few snapshots and also
# any changes that happen while we are already recording.
if snap_count < 4:
skip = True
else:
skip = False
if detecting:
if (snap_count - detect_start) * frames_per_snapshot > record_frames:
# We must have finished recording
detecting = False
skip = False
else:
# We are still recording
skip = True
if self.motion_detect and self._in_motion_time_range():
image, movement = motion_detector.process(image, skip=skip)
if movement:
# Start recording
detecting = True
detect_start = snap_count
rec_stat, rec_msg, _ = self.agent.start(
"record", params={"test_mode": False}
)
if rec_stat != ocs.OK:
self.log.error(f"Problem with motion capture: {rec_msg}")
# Save to circular buffer
self.img_buffer.store(image)
# Get the saved path
path = self.img_buffer.fetch_index(-1)[0]
# Fill data
data = {
"address": self.address,
"timestamp": timestamp,
"path": path,
}
# Update session.data and publish
session.data = data
self.log.debug(f"{data}")
message = {
"block_name": "cameras",
"timestamp": timestamp,
"data": {
"address": self.address,
"path": path,
},
}
session.app.publish_to_feed(self.feed_name, message)
if params["test_mode"]:
break
snap_count += 1
pm.sleep()
# Flush buffer and stop the data stream
self.agent.feeds[self.feed_name].flush_buffer()
# Release stream
cap.release()
return True, "Acquisition finished"
def _stop_acq(self, session, params=None):
"""_stop_acq()
**Task** - Stop task associated with acq process.
"""
if self.is_streaming:
session.set_status("stopping")
self.is_streaming = False
return True, "Stopping Acquisition"
else:
return False, "Acq is not currently running"
def record(self, session, params=None):
"""Record video stream.
**Task** - Record video for fixed timespan.
Parameters:
None
"""
session.set_status("running")
with self.lock.acquire_timeout(0, job="record") as acquired:
if not acquired:
self.log.warn(
"Could not start recording because "
"{} is already running".format(self.lock.job)
)
return False, "Only one simultaneous recording per camera allowed"
pm = Pacemaker(self.record_fps, quantize=True)
# Open camera stream
self.log.info("Recording: opening camera stream")
if self.fake:
cap = FakeCamera()
else:
cap = cv2.VideoCapture(self.connection)
if not cap.isOpened():
self.log.error(f"Cannot open RTSP stream at {self.connection}")
return False, "Cannot connect to camera"
# Total number of frames
total_frames = int(self.record_fps * self.record_duration)
msg = f"Recording: starting {total_frames} frames "
msg += f"({self.record_duration}s at {self.record_fps}fps)"
self.log.info(msg)
frames = list()
for iframe in range(total_frames):
if session.status != "running":
return False, "Aborted recording"
pm.sleep()
# Grab an image
success, image = cap.read()
if not success:
msg = f"Recording: broken stream at frame {iframe}, ending"
self.log.error(msg)
break
frames.append(image)
# Save to circular buffer
self.vid_buffer.store(frames)
# Get the saved path
path = self.vid_buffer.fetch_index(-1)[0]
self.log.info(f"Recording: finished {path}")
# Cleanup
cap.release()
return True, "Recording finished."
def _abort_record(self, session, params):
if session.status == "running":
session.set_status("stopping")
def add_agent_args(parser=None):
"""Create or append agent arguments.
Args:
parser (ArgumentParser): Optional input parser to use. If None,
a new parser will be created.
Returns:
(ArgumentParser): The created or modified parser.
"""
if parser is None:
from argparse import ArgumentParser as A
parser = A()
pgroup = parser.add_argument_group("Agent Options")
pgroup.add_argument(
"--mode",
type=str,
default="acq",
choices=["acq", "test"],
help="Starting action for the Agent.",
)
pgroup.add_argument(
"--directory",
type=str,
required=True,
help="Directory for media buffers (snapshots and recordings)",
)
pgroup.add_argument(
"--address",
type=str,
required=True,
help="Hostname or IP address of camera",
)
pgroup.add_argument(
"--user",
type=str,
required=True,
help="User name for camera access",
)
pgroup.add_argument(
"--password",
type=str,
required=True,
help="Password for camera access",
)
pgroup.add_argument(
"--motion_start",
type=str,
default=None,
required=False,
help="ISO 8601 time (HH:MM:SS+-zz:zz) to begin motion detection",
)
pgroup.add_argument(
"--motion_stop",
type=str,
default=None,
required=False,
help="ISO 8601 time (HH:MM:SS+-zz:zz) to end motion detection",
)
pgroup.add_argument(
"--snapshot_seconds",
type=int,
required=False,
default=10,
help="Number of seconds between snapshots for motion detection",
)
pgroup.add_argument(
"--port",
type=int,
required=False,
default=554,
help="The RTSP port number",
)
pgroup.add_argument(
"--urlpath",
type=str,
default=None,
required=False,
help="The path portion of the URL. Default will use values for Dahua cameras.",
)
pgroup.add_argument(
"--jpeg_quality",
type=int,
required=False,
default=20,
help="The JPEG quality (0-100)",
)
pgroup.add_argument(
"--max_snapshot_files",
type=int,
required=False,
default=17280, # 2 days at 10s per snapshot
help="Maximum number of images to keep in the circular buffer",
)
pgroup.add_argument(
"--record_fps",
type=float,
required=False,
default=20.0,
help="The frames per second for video recording",
)
pgroup.add_argument(
"--record_duration",
type=float,
required=False,
default=60,
help="The length in seconds to record video.",
)
pgroup.add_argument(
"--max_record_files",
type=int,
required=False,
default=120, # Most recent 2 hours of motion capture
help="Maximum number of images to keep in the circular buffer",
)
pgroup.add_argument(
"--fake",
action="store_true",
required=False,
default=False,
help="Use an internal fake camera for acquisition",
)
pgroup.add_argument(
"--disable_motion",
action="store_true",
required=False,
default=False,
help="Disable motion detection",
)
return parser
def main(args=None):
txaio.make_logger()
# Start logging
txaio.start_logging(level=os.environ.get("LOGLEVEL", "info"))
parser = add_agent_args()
args = site_config.parse_args(
agent_class="RTSPCameraAgent", parser=parser, args=args
)
if args.mode == "acq":
init_params = {"test_mode": False}
elif args.mode == "test":
init_params = {"test_mode": True}
agent, runner = ocs_agent.init_site_agent(args)
cam = RTSPCameraAgent(
agent,
args.directory,
args.address,
args.user,
args.password,
seconds=args.snapshot_seconds,
port=args.port,
urlpath=args.urlpath,
jpeg_quality=args.jpeg_quality,
max_snapshot_files=args.max_snapshot_files,
record_fps=args.record_fps,
record_duration=args.record_duration,
max_record_files=args.max_record_files,
fake=args.fake,
motion_start=args.motion_start,
motion_stop=args.motion_stop,
disable_motion=args.disable_motion,
)
agent.register_process("acq", cam.acq, cam._stop_acq, startup=init_params)
agent.register_task(
"record", cam.record, aborter=cam._abort_record
)
runner.run(agent, auto_reconnect=True)
if __name__ == "__main__":
main()
|
simonsobsREPO_NAMEsocsPATH_START.@socs_extracted@socs-main@socs@agents@rtsp_camera@agent.py@.PATH_END.py
|
{
"filename": "phasespace.py",
"repo_name": "jstuecker/adiabatic-tides",
"repo_path": "adiabatic-tides_extracted/adiabatic-tides-main/adiabatic_tides/phasespace.py",
"type": "Python"
}
|
import numpy as np
from scipy.integrate import quad
import scipy.optimize as op
from . import mathtools
from scipy.interpolate import interp1d, NearestNDInterpolator, LinearNDInterpolator
class IsotropicPhaseSpaceSolver():
def __init__(self, profile, rbins=1000, rnorm=None, rmax=None, rmin=None, potential_profile=None, sample_profile_f=False, nbinsE=100, dlog_emin=-5, force_profile_f=False):
"""This is a utility class that enables numerically calculating
distribution functions in arbitrary spherical profiles. It has only
been tested for NFW models. On startup this class precomputes the
distribution functions and later evaluates them through interpolation
The phase space distribution is calculated numerically according to
Eddington inversion
The sampling part is done as explained in Errani & Penarrubia (2020)
(arxiv:1906.01642)
profile : the profile to calculate the distribution function for
rbins : the number of radial bins. Can also be array to set bins directly
rnorm : the radius used for normalizing the distrubtion function.
(rather unimportant usually)
rmax : the maximum radius considered for calculating the distribution function
(Should be way larger than the radius of your profile)
rmin : the minimal radius considered for calculating the distribution function
(Should be very close to zero, necessary for avoiding singularities at 0)
potential_profile : If provided use a different profile to generate the potential
than for evaluating the density.
sample_profile_f : if True, when sampling particles the phase space distriubtion
will use the function p.f_of_e(e) of the profile when sampling particles
instead of the own estimate of f_of_e
force_profile_f : if True, will always consider the function p.f_of_e(e). This is
useful if using a profile with analytically known f_of_e
"""
self.profile = profile
self.sample_profile_f = sample_profile_f
self.force_profile_f = force_profile_f
if potential_profile is None:
potential_profile = profile
self.potential_profile = potential_profile
if rnorm is None:
self.rnorm = self.profile.r0()
else:
self.rnorm = rnorm
if rmax is None:
self.rmax = self.rnorm*10.
else:
self.rmax = rmax
if rmin is None:
self.rmin = self.rmax / 1e8
else:
self.rmin = rmin
if np.issubdtype(type(rbins), np.integer):
self.ri = np.logspace(np.log10(self.rmin), np.log10(self.rmax), rbins)
else:
self.ri = rbins
self.psi = -(self.potential_profile.potential(self.ri) )
self.nu = self.profile.self_density(self.ri) / profile.self_m_of_r(self.rnorm)
def filter_nonequal(*xis):
valid = np.ones_like(xis[0], dtype=np.bool)
for xi in xis:
valid[1:] &= np.abs(xi[1:] - xi[:-1]) >= (np.abs(xi[1:]) + np.abs(xi[:-1])) * 1e-12
xinew = [xi[valid] for xi in xis]
return xinew
self.psi, self.nu = filter_nonequal(self.psi, self.nu)
valid = self.psi[1:] > self.psi[:-1] # some bins might be equal due to roundoff-errors
self.psi = self.psi
self.dndp = np.gradient(self.nu, self.psi, edge_order=2)
self.d2nd2p = np.gradient(self.dndp, self.psi, edge_order=2)
self.psi, self.nu, self.dndp, self.d2nd2p = filter_nonequal(self.psi, self.nu, self.dndp, self.d2nd2p)
self.dlog_emin = dlog_emin
self.eps = 1e-6
self.nbinsE = nbinsE
self._setup_interpolators()
def sample_particles(self, ntot=10000, rmax=None, seed=None, verbose=False, res_of_r=None):
"""Samples particles consistent with the phasespace distribution
ntot : number of particles to sample
rmax : Maximum radius to sample to. This is important for profiles
which diverge M(r -> infty) -> infty
seed : random seed
res_of_r: (optional) a function that returns a resolution weight as a
function of r. The number of particles at radius r will be
proportional to this weight and the mass will be inversely proportional
returns : pos, vel, mass -- the positions, velocities and masses
masses are normalized so that Sum(mass) = M(<rmax)
"""
float_err_handling = np.geterr()
np.seterr(divide="ignore", invalid="ignore")
if seed is not None:
np.random.seed(seed)
if rmax is None:
rmax = self.rnorm
ri, mass = self._sample_r(ntot, rmax=rmax, res_of_r=res_of_r)
ei = self._sample_e_given_r(ri, verbose=verbose)
pos = mathtools.random_direction(ri.shape, 3) * ri[...,np.newaxis]
phi = self.potential_profile.potential(ri)
vi = np.sqrt(2.*(ei-phi))
vel = mathtools.random_direction(ri.shape, 3) * vi[...,np.newaxis]
np.seterr(**float_err_handling)
return pos,vel,mass
# !!! This function is depreceated and can be removed soon:
def sample_test_particles(self, ntot=10000, rmin=None, rmax=None, seed=None, fpow=1.):
"""Samples test tracers that are not following the distribution function
The idea is to have particles which widely span the space of possible
actions/angular momenta/energies. This is useful for setting up mesh-free
interpolators. Particles will be uniform in log(r)
ntot : number of particles to sample
ri : radii of already given particles
rmin : minimal radius
rmax : Maximum radius
seed : random seed
fpow : take this power of the f(E | r) distribution function. Use
0 < fpow < 1 to increase the likelihood to sample unlikely
energies
returns : pos, vel -- the positions and velocities
"""
if seed is not None:
np.random.seed(seed)
if rmin is None:
rmin = self.rmin
if rmax is None:
rmax = self.rmax
ri = 10**np.random.uniform(np.log10(rmin),np.log10(rmax), int(ntot))
ei = self._sample_e_given_r(ri, fpow=fpow)
pos = mathtools.random_direction(ri.shape, 3) * ri[...,np.newaxis]
phi = self.potential_profile.potential(ri)
vi = np.sqrt(2.*(ei-phi))
vel = mathtools.random_direction(ri.shape, 3) * vi[...,np.newaxis]
#mass = np.ones_like(ri) * self.profile.m_of_r(rmax) / len(ri)
return pos,vel#,mass
def _interpolator(self, xi, yi):
ip = interp1d(xi, yi, kind="cubic", fill_value="extrapolate")
return ip
def _interpolate(self, xeval, xi, yi, getip=False):
ip = self._interpolator(xi, yi)
return ip(xeval)
def f_of_e(self, e, interpolate=True, use_profile_f=False):
"""Energy distribution per phase space volume. f(e) = dN/d3x/d3v
e : energy to evaluate the distribution function
interpolate : should be True, unless you are benchmarking the numerics.
If True uses the precomputed interpolators to evalute the
phase space distribution rapidly. If False, calculates the phase
space distribution by numerically solving the integrals.
use_profile_f : instead use the profiles f_of_e. Use this if the profile
has an implemented analytic solution or modifies the behavior of this
function
"""
if use_profile_f or self.force_profile_f:
return self.profile.f_of_e(e)
if interpolate:
return 10.**self.ip_e_logf(e)
# arxiv:1906.01642 eq 3
ip = self._interpolator(self.psi[::-1], self.d2nd2p[::-1])
def integrand(p, ei):
return ip(p) / np.sqrt(ei-p)
if self.potential_profile.potential_zero_at_infty:
emax = 0.
else:
emax = self.potential_profile.potential(self.profile.scale("rmax"))
def integral(ei):
return quad(integrand, -emax, ei, epsrel=self.eps, args=(ei,), full_output=True)[0]
return 1./(np.sqrt(8.) * np.pi**2) * np.vectorize(integral)(-e)
#assert np.min(e[1:] >= e[:-1]) == True
#return 1./(np.sqrt(8.) * np.pi**2) * mathtools.cum_simpson(integrand, ei)
def ntot_of_e(self, e):
"""Numer of particles per energy.
This is proportional to what you would get from a mass-weighted histogram
of particles. Includes the effect of the phase space volume and the distribution function."""
return (4.*np.pi)**2 * self.f_of_e(e) * self._g_of_e(e)
def _setup_interpolators(self):
self.phimin = self.potential_profile.potential(self.rmin)
self.phimax = self.potential_profile.potential(self.rmax)
#n1,n2,n3 = self.nbinsE//4, self.nbinsE//2, self.nbinsE//4
#efac = np.concatenate([np.logspace(-6,-1, n1), np.linspace(0.101,0.899, n2), 1.-np.logspace(-1, -6, n3)])
efac = mathtools.bins_log_lin_log(0., 0.1, 0.9, 1.0, self.nbinsE//4, self.nbinsE//2, self.nbinsE//4, dlogmin=self.dlog_emin)
self.ei = self.phimin + (self.phimax - self.phimin)*efac
self.fi = self.f_of_e(self.ei, interpolate=False)
self.gi = None
self.ei = self.ei[self.fi > 0.]
self.fi = self.fi[self.fi > 0.]
assert np.min(self.fi) > 0.
self.ip_e_logf = self._interpolator(self.ei, np.log10(self.fi))
self.maxLikelihood_of_r = None
def _rapo_zeroL(self, e):
"""Radius at apocenter for zero angular momentum orbits"""
def perifunc(rp, ei):
return self.potential_profile.potential(rp) - ei
def apo_single(ei):
return op.brentq(perifunc, 1e-2*self.rmin, 1e2*self.rmax, args=(ei,))
return np.vectorize(apo_single)(e)
def _g_of_e(self, e, interpolate=True):
"""Phase space volume associated with Energy e"""
if interpolate:
if self.gi is None:
self.gi = self._g_of_e(self.ei, interpolate=False)
return np.interp(e, self.ei, self.gi)
# arxiv:1906.01642 eq 4
def rapo(ei):
return self._rapo_zeroL(ei)
def integrand(r, ei):
de = ei - self.potential_profile.potential(r)
return r**2 * np.sqrt(2.*de)
def integral(ex):
return quad(integrand, self.rmin, rapo(ex), epsrel=self.eps, args=(ex,))[0]
return np.vectorize(integral)(e)
def _likelihood_of_e_given_r(self, e, r, maxnormed=True, use_profile_f=False):
"""The probability distribution of energies, given a radius"""
if maxnormed:
if self.maxLikelihood_of_r is None:
self.maxLikelihood_of_r = np.max(self._likelihood_of_e_given_r(self.ei, self.ri[...,np.newaxis], maxnormed=False,
use_profile_f=use_profile_f), axis=-1)
norm = np.interp(r, self.ri, self.maxLikelihood_of_r)
else:
norm = 1.
de = np.clip(e - self.potential_profile.potential(r), 0., None)
return r**2 * np.sqrt(2.*de) * self.f_of_e(e, use_profile_f=use_profile_f) / norm
def _sample_r(self, ntot=100, rmax=None, res_of_r=None):
"""Sample radii and masses from the density profile,
res_of_r can be a function increasing resolution and decreasing mass"""
if rmax is None:
rmax = self.rnorm
if res_of_r is None:
mofr = self.profile.self_m_of_r(self.ri)
mmax = self.profile.self_m_of_r(rmax)
fsamp = np.random.uniform(0., 1., ntot)
rsamp = np.interp(fsamp, mofr/mmax, self.ri)
mass = np.ones(ntot) * (mmax / ntot)
else:
def dmdr(r):
return 4.*np.pi*self.profile.self_density(r)*r**2 * res_of_r(r)
meff = self.profile.self_m_of_r(self.ri[0]) + mathtools.cum_simpson(dmdr, self.ri)
mmax = np.interp(rmax, self.ri, meff)
fsamp = np.random.uniform(0., 1., ntot)
rsamp = np.interp(fsamp, meff/mmax, self.ri)
mass = mmax / ntot / res_of_r(rsamp)
mass[np.isnan(mass)] = 0.
return rsamp, mass
def sample_r(ntot):
if res_of_r is None:
mmax = self.self_m_of_r(rmax)
fsamp = np.random.uniform(0., 1., ntot)
rsamp = np.interp(fsamp, self.q["mofr"]/mmax, self.ri)
mass = np.ones(ntot) * (mmax / ntot)
else:
def dmdr(r):
return 4.*np.pi*self.self_density(r)*r**2 * res_of_r(r)
meff = self.prof_initial.self_m_of_r(self.ri[0]) + mathtools.cum_simpson(dmdr, self.ri)
mmax = np.interp(rmax, self.ri, meff)
fsamp = np.random.uniform(0., 1., ntot)
rsamp = np.interp(fsamp, meff/mmax, self.ri)
mass = mmax / ntot / res_of_r(rsamp)
return rsamp, mass
rsamp, mass = sample_r(ntot)
def _sample_e_given_r(self, ri, verbose=False, maxiter=10000, fpow=None):
"""Use rejection sampling like in arxiv:1906.01642 to find energies
of particles, when already given their radius
fpow : take a power of the likelihood. Should be None or 1, unless
you know what you are doing
"""
phimax = self.potential_profile.potential(self.rmax)
phii = self.potential_profile.potential(ri)
ei = np.zeros_like(phii)
ileft = np.arange(len(ri))
for i in range(0,maxiter):
esamp = np.random.uniform(phii[ileft], phimax, ileft.shape)
Lsamp = self._likelihood_of_e_given_r(esamp, ri[ileft], use_profile_f=self.sample_profile_f)
if fpow is not None:
Lsamp = Lsamp**fpow
ysamp = np.random.uniform(0., 1.1, ileft.shape) # 10 % buffer
sel_pass = ysamp <= Lsamp
ei[ileft[sel_pass]] = esamp[sel_pass]
ileft = ileft[~sel_pass]
if verbose:
print("iter = %d, left=%d (%.1g %%)" % (i, len(ileft), len(ileft)*100./len(ri)))
if len(ileft) == 0:
break
if i == maxiter-1:
print("Warning couldn't make it after maxiter=%d iterations (%d particles left)" % (maxiter, len(ileft)))
return ei
|
jstueckerREPO_NAMEadiabatic-tidesPATH_START.@adiabatic-tides_extracted@adiabatic-tides-main@adiabatic_tides@phasespace.py@.PATH_END.py
|
{
"filename": "ode.py",
"repo_name": "jax-ml/jax",
"repo_path": "jax_extracted/jax-main/jax/experimental/ode.py",
"type": "Python"
}
|
# Copyright 2018 The JAX Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""JAX-based Dormand-Prince ODE integration with adaptive stepsize.
Integrate systems of ordinary differential equations (ODEs) using the JAX
autograd/diff library and the Dormand-Prince method for adaptive integration
stepsize calculation. Provides improved integration accuracy over fixed
stepsize integration methods.
For details of the mixed 4th/5th order Runge-Kutta integration method, see
https://doi.org/10.1090/S0025-5718-1986-0815836-3
Adjoint algorithm based on Appendix C of https://arxiv.org/pdf/1806.07366.pdf
"""
from functools import partial
import operator as op
import jax
import jax.numpy as jnp
from jax._src import core
from jax import custom_derivatives
from jax import lax
from jax._src.numpy.util import promote_dtypes_inexact
from jax._src.util import safe_map, safe_zip
from jax.flatten_util import ravel_pytree
from jax.tree_util import tree_leaves, tree_map
from jax._src import linear_util as lu
map = safe_map
zip = safe_zip
def ravel_first_arg(f, unravel):
return ravel_first_arg_(lu.wrap_init(f), unravel).call_wrapped
@lu.transformation2
def ravel_first_arg_(f, unravel, y_flat, *args):
y = unravel(y_flat)
ans = f(y, *args)
ans_flat, _ = ravel_pytree(ans)
return ans_flat
def interp_fit_dopri(y0, y1, k, dt):
# Fit a polynomial to the results of a Runge-Kutta step.
dps_c_mid = jnp.array([
6025192743 / 30085553152 / 2, 0, 51252292925 / 65400821598 / 2,
-2691868925 / 45128329728 / 2, 187940372067 / 1594534317056 / 2,
-1776094331 / 19743644256 / 2, 11237099 / 235043384 / 2], dtype=y0.dtype)
y_mid = y0 + dt.astype(y0.dtype) * jnp.dot(dps_c_mid, k)
return jnp.asarray(fit_4th_order_polynomial(y0, y1, y_mid, k[0], k[-1], dt))
def fit_4th_order_polynomial(y0, y1, y_mid, dy0, dy1, dt):
dt = dt.astype(y0.dtype)
a = -2.*dt*dy0 + 2.*dt*dy1 - 8.*y0 - 8.*y1 + 16.*y_mid
b = 5.*dt*dy0 - 3.*dt*dy1 + 18.*y0 + 14.*y1 - 32.*y_mid
c = -4.*dt*dy0 + dt*dy1 - 11.*y0 - 5.*y1 + 16.*y_mid
d = dt * dy0
e = y0
return a, b, c, d, e
def initial_step_size(fun, t0, y0, order, rtol, atol, f0):
# Algorithm from:
# E. Hairer, S. P. Norsett G. Wanner,
# Solving Ordinary Differential Equations I: Nonstiff Problems, Sec. II.4.
y0, f0 = promote_dtypes_inexact(y0, f0)
dtype = y0.dtype
scale = atol + jnp.abs(y0) * rtol
d0 = jnp.linalg.norm(y0 / scale.astype(dtype))
d1 = jnp.linalg.norm(f0 / scale.astype(dtype))
h0 = jnp.where((d0 < 1e-5) | (d1 < 1e-5), 1e-6, 0.01 * d0 / d1)
y1 = y0 + h0.astype(dtype) * f0
f1 = fun(y1, t0 + h0)
d2 = jnp.linalg.norm((f1 - f0) / scale.astype(dtype)) / h0
h1 = jnp.where((d1 <= 1e-15) & (d2 <= 1e-15),
jnp.maximum(1e-6, h0 * 1e-3),
(0.01 / jnp.maximum(d1, d2)) ** (1. / (order + 1.)))
return jnp.minimum(100. * h0, h1)
def runge_kutta_step(func, y0, f0, t0, dt):
# Dopri5 Butcher tableaux
alpha = jnp.array([1 / 5, 3 / 10, 4 / 5, 8 / 9, 1., 1., 0], dtype=dt.dtype)
beta = jnp.array(
[[1 / 5, 0, 0, 0, 0, 0, 0], [3 / 40, 9 / 40, 0, 0, 0, 0, 0],
[44 / 45, -56 / 15, 32 / 9, 0, 0, 0, 0],
[19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729, 0, 0, 0],
[9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656, 0, 0],
[35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0]],
dtype=f0.dtype)
c_sol = jnp.array(
[35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0],
dtype=f0.dtype)
c_error = jnp.array([
35 / 384 - 1951 / 21600, 0, 500 / 1113 - 22642 / 50085, 125 / 192 -
451 / 720, -2187 / 6784 - -12231 / 42400, 11 / 84 - 649 / 6300, -1. / 60.
], dtype=f0.dtype)
def body_fun(i, k):
ti = t0 + dt * alpha[i-1]
yi = y0 + dt.astype(f0.dtype) * jnp.dot(beta[i-1, :], k)
ft = func(yi, ti)
return k.at[i, :].set(ft)
k = jnp.zeros((7, f0.shape[0]), f0.dtype).at[0, :].set(f0)
k = lax.fori_loop(1, 7, body_fun, k)
y1 = dt.astype(f0.dtype) * jnp.dot(c_sol, k) + y0
y1_error = dt.astype(f0.dtype) * jnp.dot(c_error, k)
f1 = k[-1]
return y1, f1, y1_error, k
def abs2(x):
if jnp.iscomplexobj(x):
return x.real ** 2 + x.imag ** 2
else:
return x ** 2
def mean_error_ratio(error_estimate, rtol, atol, y0, y1):
err_tol = atol + rtol * jnp.maximum(jnp.abs(y0), jnp.abs(y1))
err_ratio = error_estimate / err_tol.astype(error_estimate.dtype)
return jnp.sqrt(jnp.mean(abs2(err_ratio)))
def optimal_step_size(last_step, mean_error_ratio, safety=0.9, ifactor=10.0,
dfactor=0.2, order=5.0):
"""Compute optimal Runge-Kutta stepsize."""
dfactor = jnp.where(mean_error_ratio < 1, 1.0, dfactor)
factor = jnp.minimum(ifactor,
jnp.maximum(mean_error_ratio**(-1.0 / order) * safety, dfactor))
return jnp.where(mean_error_ratio == 0, last_step * ifactor, last_step * factor)
def odeint(func, y0, t, *args, rtol=1.4e-8, atol=1.4e-8, mxstep=jnp.inf, hmax=jnp.inf):
"""Adaptive stepsize (Dormand-Prince) Runge-Kutta odeint implementation.
Args:
func: function to evaluate the time derivative of the solution `y` at time
`t` as `func(y, t, *args)`, producing the same shape/structure as `y0`.
y0: array or pytree of arrays representing the initial value for the state.
t: array of float times for evaluation, like `jnp.linspace(0., 10., 101)`,
in which the values must be strictly increasing.
*args: tuple of additional arguments for `func`, which must be arrays
scalars, or (nested) standard Python containers (tuples, lists, dicts,
namedtuples, i.e. pytrees) of those types.
rtol: float, relative local error tolerance for solver (optional).
atol: float, absolute local error tolerance for solver (optional).
mxstep: int, maximum number of steps to take for each timepoint (optional).
hmax: float, maximum step size allowed (optional).
Returns:
Values of the solution `y` (i.e. integrated system values) at each time
point in `t`, represented as an array (or pytree of arrays) with the same
shape/structure as `y0` except with a new leading axis of length `len(t)`.
"""
for arg in tree_leaves(args):
if not isinstance(arg, core.Tracer) and not core.valid_jaxtype(arg):
raise TypeError(
f"The contents of odeint *args must be arrays or scalars, but got {arg}.")
if not jnp.issubdtype(t.dtype, jnp.floating):
raise TypeError(f"t must be an array of floats, but got {t}.")
converted, consts = custom_derivatives.closure_convert(func, y0, t[0], *args)
return _odeint_wrapper(converted, rtol, atol, mxstep, hmax, y0, t, *args, *consts)
@partial(jax.jit, static_argnums=(0, 1, 2, 3, 4))
def _odeint_wrapper(func, rtol, atol, mxstep, hmax, y0, ts, *args):
y0, unravel = ravel_pytree(y0)
func = ravel_first_arg(func, unravel)
out = _odeint(func, rtol, atol, mxstep, hmax, y0, ts, *args)
return jax.vmap(unravel)(out)
@partial(jax.custom_vjp, nondiff_argnums=(0, 1, 2, 3, 4))
def _odeint(func, rtol, atol, mxstep, hmax, y0, ts, *args):
func_ = lambda y, t: func(y, t, *args)
def scan_fun(carry, target_t):
def cond_fun(state):
i, _, _, t, dt, _, _ = state
return (t < target_t) & (i < mxstep) & (dt > 0)
def body_fun(state):
i, y, f, t, dt, last_t, interp_coeff = state
next_y, next_f, next_y_error, k = runge_kutta_step(func_, y, f, t, dt)
next_t = t + dt
error_ratio = mean_error_ratio(next_y_error, rtol, atol, y, next_y)
new_interp_coeff = interp_fit_dopri(y, next_y, k, dt)
dt = jnp.clip(optimal_step_size(dt, error_ratio), min=0., max=hmax)
new = [i + 1, next_y, next_f, next_t, dt, t, new_interp_coeff]
old = [i + 1, y, f, t, dt, last_t, interp_coeff]
return map(partial(jnp.where, error_ratio <= 1.), new, old)
_, *carry = lax.while_loop(cond_fun, body_fun, [0] + carry)
_, _, t, _, last_t, interp_coeff = carry
relative_output_time = (target_t - last_t) / (t - last_t)
y_target = jnp.polyval(interp_coeff, relative_output_time.astype(interp_coeff.dtype))
return carry, y_target
f0 = func_(y0, ts[0])
dt = jnp.clip(initial_step_size(func_, ts[0], y0, 4, rtol, atol, f0), min=0., max=hmax)
interp_coeff = jnp.array([y0] * 5)
init_carry = [y0, f0, ts[0], dt, ts[0], interp_coeff]
_, ys = lax.scan(scan_fun, init_carry, ts[1:])
return jnp.concatenate((y0[None], ys))
def _odeint_fwd(func, rtol, atol, mxstep, hmax, y0, ts, *args):
ys = _odeint(func, rtol, atol, mxstep, hmax, y0, ts, *args)
return ys, (ys, ts, args)
def _odeint_rev(func, rtol, atol, mxstep, hmax, res, g):
ys, ts, args = res
def aug_dynamics(augmented_state, t, *args):
"""Original system augmented with vjp_y, vjp_t and vjp_args."""
y, y_bar, *_ = augmented_state
# `t` here is negatice time, so we need to negate again to get back to
# normal time. See the `odeint` invocation in `scan_fun` below.
y_dot, vjpfun = jax.vjp(func, y, -t, *args)
return (-y_dot, *vjpfun(y_bar))
y_bar = g[-1]
ts_bar = []
t0_bar = 0.
def scan_fun(carry, i):
y_bar, t0_bar, args_bar = carry
# Compute effect of moving measurement time
# `t_bar` should not be complex as it represents time
t_bar = jnp.dot(func(ys[i], ts[i], *args), g[i]).real
t0_bar = t0_bar - t_bar
# Run augmented system backwards to previous observation
_, y_bar, t0_bar, args_bar = odeint(
aug_dynamics, (ys[i], y_bar, t0_bar, args_bar),
jnp.array([-ts[i], -ts[i - 1]]),
*args, rtol=rtol, atol=atol, mxstep=mxstep, hmax=hmax)
y_bar, t0_bar, args_bar = tree_map(op.itemgetter(1), (y_bar, t0_bar, args_bar))
# Add gradient from current output
y_bar = y_bar + g[i - 1]
return (y_bar, t0_bar, args_bar), t_bar
init_carry = (g[-1], 0., tree_map(jnp.zeros_like, args))
(y_bar, t0_bar, args_bar), rev_ts_bar = lax.scan(
scan_fun, init_carry, jnp.arange(len(ts) - 1, 0, -1))
ts_bar = jnp.concatenate([jnp.array([t0_bar]), rev_ts_bar[::-1]])
return (y_bar, ts_bar, *args_bar)
_odeint.defvjp(_odeint_fwd, _odeint_rev)
|
jax-mlREPO_NAMEjaxPATH_START.@jax_extracted@jax-main@jax@experimental@ode.py@.PATH_END.py
|
{
"filename": "_width.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py3/plotly/validators/scatter3d/error_z/_width.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class WidthValidator(_plotly_utils.basevalidators.NumberValidator):
def __init__(self, plotly_name="width", parent_name="scatter3d.error_z", **kwargs):
super(WidthValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "calc"),
min=kwargs.pop("min", 0),
**kwargs,
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py3@plotly@validators@scatter3d@error_z@_width.py@.PATH_END.py
|
{
"filename": "plotting.py",
"repo_name": "3fon3fonov/exostriker",
"repo_path": "exostriker_extracted/exostriker-main/exostriker/lib/dynesty_2_0/plotting.py",
"type": "Python"
}
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
A set of built-in plotting functions to help visualize ``dynesty`` nested
sampling :class:`~dynesty.results.Results`.
"""
import logging
import warnings
import numpy as np
import matplotlib.pyplot as pl
from matplotlib.ticker import MaxNLocator, NullLocator
from matplotlib.colors import LinearSegmentedColormap, colorConverter
from matplotlib.ticker import ScalarFormatter
from scipy.ndimage import gaussian_filter as norm_kde
from scipy.stats import gaussian_kde
from .utils import resample_equal, unitcheck
from .utils import quantile as _quantile
from .utils import get_random_generator, get_nonbounded
from . import bounding
str_type = str
float_type = float
int_type = int
__all__ = [
"runplot", "traceplot", "cornerpoints", "cornerplot", "boundplot",
"cornerbound", "_hist2d"
]
def _make_subplots(fig, nx, ny, xsize, ysize):
# Setting up default plot layout.
if fig is None:
fig, axes = pl.subplots(nx, ny, figsize=(xsize, ysize))
axes = np.asarray(axes).reshape(nx, ny)
else:
fig, axes = fig
try:
axes = np.asarray(axes).reshape(nx, ny)
except ValueError:
raise ValueError("Provided axes do not match the required shape")
return fig, axes
def rotate_ticks(ax, xy):
if xy == 'x':
labs = ax.get_xticklabels()
else:
labs = ax.get_yticklabels()
for lab in labs:
lab.set_rotation(45)
def plot_thruth(ax,
truths,
truth_color,
truth_kwargs,
vertical=None,
horizontal=None):
"""
Plot the thruth line (horizontal or vertical).
truths can be None or one value or a list
"""
if vertical:
func = ax.axvline
elif horizontal:
func = ax.axhline
else:
raise ValueError('vertical or horizontal option must be specified')
if truths is not None:
try:
curt = iter(truths)
except TypeError:
curt = [truths]
for t in curt:
func(t, color=truth_color, **truth_kwargs)
def check_span(span, samples, weights):
"""
If span is a list of scalars, replace it by the list of bounds.
If the input is list of pairs, it is kept intact
"""
for i, _ in enumerate(span):
try:
iter(span[i])
if len(span[i]) != 2:
raise ValueError('Incorrect span value')
except TypeError:
q = [0.5 - 0.5 * span[i], 0.5 + 0.5 * span[i]]
span[i] = _quantile(samples[i], q, weights=weights)
def runplot(results,
span=None,
logplot=False,
kde=True,
nkde=1000,
color='blue',
plot_kwargs=None,
label_kwargs=None,
lnz_error=True,
lnz_truth=None,
truth_color='red',
truth_kwargs=None,
max_x_ticks=8,
max_y_ticks=3,
use_math_text=True,
mark_final_live=True,
fig=None):
"""
Plot live points, ln(likelihood), ln(weight), and ln(evidence)
as a function of ln(prior volume).
Parameters
----------
results : :class:`~dynesty.results.Results` instance
A :class:`~dynesty.results.Results` instance from a nested
sampling run.
span : iterable with shape (4,), optional
A list where each element is either a length-2 tuple containing
lower and upper bounds *or* a float from `(0., 1.]` giving the
fraction below the maximum. If a fraction is provided,
the bounds are chosen to be equal-tailed. An example would be::
span = [(0., 10.), 0.001, 0.2, (5., 6.)]
Default is `(0., 1.05 * max(data))` for each element.
logplot : bool, optional
Whether to plot the evidence on a log scale. Default is `False`.
kde : bool, optional
Whether to use kernel density estimation to estimate and plot
the PDF of the importance weights as a function of log-volume
(as opposed to the importance weights themselves). Default is
`True`.
nkde : int, optional
The number of grid points used when plotting the kernel density
estimate. Default is `1000`.
color : str or iterable with shape (4,), optional
A `~matplotlib`-style color (either a single color or a different
value for each subplot) used when plotting the lines in each subplot.
Default is `'blue'`.
plot_kwargs : dict, optional
Extra keyword arguments that will be passed to `plot`.
label_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_xlabel` and
`~matplotlib.axes.Axes.set_ylabel` methods.
lnz_error : bool, optional
Whether to plot the 1, 2, and 3-sigma approximate error bars
derived from the ln(evidence) error approximation over the course
of the run. Default is `True`.
lnz_truth : float, optional
A reference value for the evidence that will be overplotted on the
evidence subplot if provided.
truth_color : str or iterable with shape (ndim,), optional
A `~matplotlib`-style color used when plotting :data:`lnz_truth`.
Default is `'red'`.
truth_kwargs : dict, optional
Extra keyword arguments that will be used for plotting
:data:`lnz_truth`.
max_x_ticks : int, optional
Maximum number of ticks allowed for the x axis. Default is `8`.
max_y_ticks : int, optional
Maximum number of ticks allowed for the y axis. Default is `4`.
use_math_text : bool, optional
Whether the axis tick labels for very large/small exponents should be
displayed as powers of 10 rather than using `e`. Default is `False`.
mark_final_live : bool, optional
Whether to indicate the final addition of recycled live points
(if they were added to the resulting samples) using
a dashed vertical line. Default is `True`.
fig : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`), optional
If provided, overplot the run onto the provided figure.
Otherwise, by default an internal figure is generated.
Returns
-------
runplot : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`)
Output summary plot.
"""
# Initialize values.
if label_kwargs is None:
label_kwargs = {}
if plot_kwargs is None:
plot_kwargs = {}
if truth_kwargs is None:
truth_kwargs = {}
rstate = get_random_generator()
# Set defaults.
plot_kwargs['linewidth'] = plot_kwargs.get('linewidth', 5)
plot_kwargs['alpha'] = plot_kwargs.get('alpha', 0.7)
truth_kwargs['linestyle'] = truth_kwargs.get('linestyle', 'solid')
truth_kwargs['linewidth'] = truth_kwargs.get('linewidth', 3)
# Extract results.
niter = results['niter'] # number of iterations
logvol = results['logvol'] # ln(prior volume)
logl = results['logl'] - max(results['logl']) # ln(normalized likelihood)
logwt = results['logwt'] - results['logz'][-1] # ln(importance weight)
logz = results['logz'] # ln(evidence)
logzerr = results['logzerr'] # error in ln(evidence)
logzerr[~np.isfinite(logzerr)] = 0.
nsamps = len(logwt) # number of samples
# Check whether the run was "static" or "dynamic".
try:
nlive = results['samples_n']
mark_final_live = False
except KeyError:
nlive = np.ones(niter) * results['nlive']
if nsamps - niter == results['nlive']:
nlive_final = np.arange(1, results['nlive'] + 1)[::-1]
nlive = np.append(nlive, nlive_final)
# Check if the final set of live points were added to the results.
if mark_final_live:
if nsamps - niter == results['nlive']:
live_idx = niter
else:
warnings.warn("The number of iterations and samples differ "
"by an amount that isn't the number of final "
"live points. `mark_final_live` has been disabled.")
mark_final_live = False
# Determine plotting bounds for each subplot.
data = [
nlive,
np.exp(logl),
np.exp(logwt), logz if logplot else np.exp(logz)
]
if kde:
# Derive kernel density estimate.
wt_kde = gaussian_kde(resample_equal(-logvol, data[2],
rstate=rstate)) # KDE
logvol_new = np.linspace(logvol[0], logvol[-1], nkde) # resample
data[2] = wt_kde.pdf(-logvol_new) # evaluate KDE PDF
if span is None:
span = [(0., 1.05 * max(d)) for d in data]
no_span = True
else:
no_span = False
span = list(span)
if len(span) != 4:
raise ValueError("More bounds provided in `span` than subplots!")
for i, _ in enumerate(span):
try:
iter(span[i])
if len(span[i]) != 2:
raise ValueError('Incorrect span value')
except TypeError:
span[i] = (max(data[i]) * span[i], max(data[i]))
if lnz_error and no_span:
if logplot:
# Same lower bound as in ultranest:
# https://github.com/JohannesBuchner/UltraNest/blob/master/ultranest/plot.py#L139.
zspan = (logz[-1] - 10.3 * 3. * logzerr[-1],
logz[-1] + 1.3 * 3. * logzerr[-1])
else:
zspan = (0., 1.05 * np.exp(logz[-1] + 3. * logzerr[-1]))
span[3] = zspan
# Setting up default plot layout.
had_fig = fig or False
fig, axes = _make_subplots(fig, 4, 1, 16, 16)
axes = axes.flatten()
xspan = [ax.get_xlim() for ax in axes]
if had_fig:
yspan = [ax.get_ylim() for ax in axes]
else:
yspan = span
# One exception: if the bounds are the plotting default `(0., 1.)`,
# overwrite them.
xspan = [t if t != (0., 1.) else (0., -min(logvol)) for t in xspan]
yspan = [t if t != (0., 1.) else (None, None) for t in yspan]
# Set up bounds for plotting.
for i in range(4):
if xspan[i][0] is None:
xmin = None
else:
xmin = min(0., xspan[i][0])
if xspan[i][1] is None:
xmax = -min(logvol)
else:
xmax = max(-min(logvol), xspan[i][1])
if yspan[i][0] is None:
ymin = None
else:
ymin = min(span[i][0], yspan[i][0])
if yspan[i][1] is None:
ymax = span[i][1]
else:
ymax = max(span[i][1], yspan[i][1])
axes[i].set_xlim([xmin, xmax])
axes[i].set_ylim([ymin, ymax])
# Plotting.
labels = [
'Live Points', 'Likelihood\n(normalized)', 'Importance\nWeight',
'log(Evidence)' if logplot else 'Evidence'
]
if kde:
labels[2] += ' PDF'
for i, d in enumerate(data):
# Establish axes.
ax = axes[i]
# Set color(s)/colormap(s).
if isinstance(color, str_type):
c = color
else:
c = color[i]
# Setup axes.
if max_x_ticks == 0:
ax.xaxis.set_major_locator(NullLocator())
else:
ax.xaxis.set_major_locator(MaxNLocator(max_x_ticks))
if max_y_ticks == 0:
ax.yaxis.set_major_locator(NullLocator())
else:
ax.yaxis.set_major_locator(MaxNLocator(max_y_ticks))
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
ax.yaxis.set_major_formatter(sf)
ax.set_xlabel(r"$-\ln X$", **label_kwargs)
ax.set_ylabel(labels[i], **label_kwargs)
# Plot run.
if logplot and i == 3:
ax.plot(-logvol, d, color=c, **plot_kwargs)
yspan = [ax.get_ylim() for _ax in axes]
elif kde and i == 2:
ax.plot(-logvol_new, d, color=c, **plot_kwargs)
else:
ax.plot(-logvol, d, color=c, **plot_kwargs)
if i == 3 and lnz_error:
if logplot:
# Same mask as in ultranest:
# https://github.com/JohannesBuchner/UltraNest/blob/master/ultranest/plot.py#L139
mask = logz >= ax.get_ylim()[0] - 10
for s in range(1, 4):
ax.fill_between(-logvol[mask], (logz + s * logzerr)[mask],
(logz - s * logzerr)[mask],
color=c,
alpha=0.2)
else:
for s in range(1, 4):
ax.fill_between(-logvol,
np.exp(logz + s * logzerr),
np.exp(logz - s * logzerr),
color=c,
alpha=0.2)
# Mark addition of final live points.
if mark_final_live:
ax.axvline(-logvol[live_idx],
color=c,
ls="dashed",
lw=2,
**plot_kwargs)
if i == 0:
ax.axhline(live_idx, color=c, ls="dashed", lw=2, **plot_kwargs)
# Add truth value(s).
if i == 3 and lnz_truth is not None:
if logplot:
ax.axhline(lnz_truth, color=truth_color, **truth_kwargs)
else:
ax.axhline(np.exp(lnz_truth),
color=truth_color,
**truth_kwargs)
return fig, axes
def traceplot(results,
span=None,
quantiles=(0.025, 0.5, 0.975),
smooth=0.02,
thin=1,
dims=None,
post_color='blue',
post_kwargs=None,
kde=True,
nkde=1000,
trace_cmap='plasma',
trace_color=None,
trace_kwargs=None,
connect=False,
connect_highlight=10,
connect_color='red',
connect_kwargs=None,
max_n_ticks=5,
use_math_text=False,
labels=None,
label_kwargs=None,
show_titles=False,
title_quantiles=(0.025, 0.5, 0.975),
title_fmt=".2f",
title_kwargs=None,
truths=None,
truth_color='red',
truth_kwargs=None,
verbose=False,
fig=None):
"""
Plot traces and marginalized posteriors for each parameter.
Parameters
----------
results : :class:`~dynesty.results.Results` instance
A :class:`~dynesty.results.Results` instance from a nested
sampling run. **Compatible with results derived from**
`nestle <http://kylebarbary.com/nestle/>`_.
span : iterable with shape (ndim,), optional
A list where each element is either a length-2 tuple containing
lower and upper bounds or a float from `(0., 1.]` giving the
fraction of (weighted) samples to include. If a fraction is provided,
the bounds are chosen to be equal-tailed. An example would be::
span = [(0., 10.), 0.95, (5., 6.)]
Default is `0.999999426697` (5-sigma credible interval) for each
parameter.
quantiles : iterable, optional
A list of fractional quantiles to overplot on the 1-D marginalized
posteriors as vertical dashed lines. Default is `[0.025, 0.5, 0.975]`
(the 95%/2-sigma credible interval).
smooth : float or iterable with shape (ndim,), optional
The standard deviation (either a single value or a different value for
each subplot) for the Gaussian kernel used to smooth the 1-D
marginalized posteriors, expressed as a fraction of the span.
Default is `0.02` (2% smoothing). If an integer is provided instead,
this will instead default to a simple (weighted) histogram with
`bins=smooth`.
thin : int, optional
Thin the samples so that only each `thin`-th sample is plotted.
Default is `1` (no thinning).
dims : iterable of shape (ndim,), optional
The subset of dimensions that should be plotted. If not provided,
all dimensions will be shown.
post_color : str or iterable with shape (ndim,), optional
A `~matplotlib`-style color (either a single color or a different
value for each subplot) used when plotting the histograms.
Default is `'blue'`.
post_kwargs : dict, optional
Extra keyword arguments that will be used for plotting the
marginalized 1-D posteriors.
kde : bool, optional
Whether to use kernel density estimation to estimate and plot
the PDF of the importance weights as a function of log-volume
(as opposed to the importance weights themselves). Default is
`True`.
nkde : int, optional
The number of grid points used when plotting the kernel density
estimate. Default is `1000`.
trace_cmap : str or iterable with shape (ndim,), optional
A `~matplotlib`-style colormap (either a single colormap or a
different colormap for each subplot) used when plotting the traces,
where each point is colored according to its weight. Default is
`'plasma'`.
trace_color : str or iterable with shape (ndim,), optional
A `~matplotlib`-style color (either a single color or a
different color for each subplot) used when plotting the traces.
This overrides the `trace_cmap` option by giving all points
the same color. Default is `None` (not used).
trace_kwargs : dict, optional
Extra keyword arguments that will be used for plotting the traces.
connect : bool, optional
Whether to draw lines connecting the paths of unique particles.
Default is `False`.
connect_highlight : int or iterable, optional
If `connect=True`, highlights the paths of a specific set of
particles. If an integer is passed, :data:`connect_highlight`
random particle paths will be highlighted. If an iterable is passed,
then the particle paths corresponding to the provided indices
will be highlighted.
connect_color : str, optional
The color of the highlighted particle paths. Default is `'red'`.
connect_kwargs : dict, optional
Extra keyword arguments used for plotting particle paths.
max_n_ticks : int, optional
Maximum number of ticks allowed. Default is `5`.
use_math_text : bool, optional
Whether the axis tick labels for very large/small exponents should be
displayed as powers of 10 rather than using `e`. Default is `False`.
labels : iterable with shape (ndim,), optional
A list of names for each parameter. If not provided, the default name
used when plotting will follow :math:`x_i` style.
label_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_xlabel` and
`~matplotlib.axes.Axes.set_ylabel` methods.
show_titles : bool, optional
Whether to display a title above each 1-D marginalized posterior
showing the 0.5 quantile along with the upper/lower bounds associated
with the 0.025 and 0.975 (95%/2-sigma credible interval) quantiles.
Default is `False`.
title_quantiles : iterable, optional
A list of fractional quantiles to use in the title. Default is
`[0.025, 0.5, 0.975]` (median plus 95%/2-sigma credible interval).
title_fmt : str, optional
The format string for the quantiles provided in the title. Default is
`'.2f'`.
title_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_title` command.
truths : iterable with shape (ndim,), optional
A list of reference values that will be overplotted on the traces and
marginalized 1-D posteriors as solid horizontal/vertical lines.
Individual values can be exempt using `None`. Default is `None`.
truth_color : str or iterable with shape (ndim,), optional
A `~matplotlib`-style color (either a single color or a different
value for each subplot) used when plotting `truths`.
Default is `'red'`.
truth_kwargs : dict, optional
Extra keyword arguments that will be used for plotting the vertical
and horizontal lines with `truths`.
verbose : bool, optional
Whether to print the values of the computed quantiles associated with
each parameter. Default is `False`.
fig : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`), optional
If provided, overplot the traces and marginalized 1-D posteriors
onto the provided figure. Otherwise, by default an
internal figure is generated.
Returns
-------
traceplot : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`)
Output trace plot.
"""
# Initialize values.
if title_kwargs is None:
title_kwargs = {}
if label_kwargs is None:
label_kwargs = {}
if trace_kwargs is None:
trace_kwargs = {}
if connect_kwargs is None:
connect_kwargs = {}
if post_kwargs is None:
post_kwargs = {}
if truth_kwargs is None:
truth_kwargs = {}
# Set defaults.
rstate = get_random_generator()
connect_kwargs['alpha'] = connect_kwargs.get('alpha', 0.7)
post_kwargs['alpha'] = post_kwargs.get('alpha', 0.6)
trace_kwargs['s'] = trace_kwargs.get('s', 3)
trace_kwargs['edgecolor'] = trace_kwargs.get('edgecolor', None)
trace_kwargs['edgecolors'] = trace_kwargs.get('edgecolors', None)
truth_kwargs['linestyle'] = truth_kwargs.get('linestyle', 'solid')
truth_kwargs['linewidth'] = truth_kwargs.get('linewidth', 2)
rstate = get_random_generator()
# Extract weighted samples.
samples = results['samples']
logvol = results['logvol']
weights = results.importance_weights()
if kde:
# Derive kernel density estimate.
wt_kde = gaussian_kde(resample_equal(-logvol, weights,
rstate=rstate)) # KDE
logvol_grid = np.linspace(logvol[0], logvol[-1], nkde) # resample
wt_grid = wt_kde.pdf(-logvol_grid) # evaluate KDE PDF
wts = np.interp(-logvol, -logvol_grid, wt_grid) # interpolate
else:
wts = weights
# Deal with 1D results. A number of extra catches are also here
# in case users are trying to plot other results besides the `Results`
# instance generated by `dynesty`.
samples = np.atleast_1d(samples)
if len(samples.shape) == 1:
samples = np.atleast_2d(samples)
else:
assert len(samples.shape) == 2, "Samples must be 1- or 2-D."
samples = samples.T
assert samples.shape[0] <= samples.shape[1], "There are more " \
"dimensions than samples!"
# Slice samples based on provided `dims`.
if dims is not None:
samples = samples[dims]
ndim, nsamps = samples.shape
# Check weights.
if weights.ndim != 1:
raise ValueError("Weights must be 1-D.")
if nsamps != weights.shape[0]:
raise ValueError("The number of weights and samples disagree!")
# Check ln(volume).
if logvol.ndim != 1:
raise ValueError("Ln(volume)'s must be 1-D.")
if nsamps != logvol.shape[0]:
raise ValueError("The number of ln(volume)'s and samples disagree!")
# Check sample IDs.
if connect:
if 'samples_id' in results.keys():
samples_id = results['samples_id']
uid = np.unique(samples_id)
else:
raise ValueError("Sample IDs are not defined!")
try:
ids = connect_highlight[0]
ids = connect_highlight
except:
ids = rstate.choice(uid, size=connect_highlight, replace=False)
# Determine plotting bounds for marginalized 1-D posteriors.
if span is None:
span = [0.999999426697 for i in range(ndim)]
span = list(span)
if len(span) != ndim:
raise ValueError("Dimension mismatch between samples and span.")
check_span(span, samples, weights)
# Setting up labels.
if labels is None:
labels = [r"$x_{" + str(i + 1) + "}$" for i in range(ndim)]
# Setting up smoothing.
if isinstance(smooth, (int_type, float_type)):
smooth = [smooth for i in range(ndim)]
# Setting up default plot layout.
fig, axes = _make_subplots(fig, ndim, 2, 12, 3 * ndim)
# Plotting.
for i, x in enumerate(samples):
# Plot trace.
# Establish axes.
ax = axes[i, 0]
# Set color(s)/colormap(s).
if trace_color is not None:
if isinstance(trace_color, str_type):
color = trace_color
else:
color = trace_color[i]
else:
color = wts[::thin]
if isinstance(trace_cmap, str_type):
cmap = trace_cmap
else:
cmap = trace_cmap[i]
# Setup axes.
ax.set_xlim([0., -min(logvol)])
ax.set_ylim([min(x), max(x)])
if max_n_ticks == 0:
ax.xaxis.set_major_locator(NullLocator())
ax.yaxis.set_major_locator(NullLocator())
else:
ax.xaxis.set_major_locator(MaxNLocator(max_n_ticks))
ax.yaxis.set_major_locator(MaxNLocator(max_n_ticks))
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
ax.yaxis.set_major_formatter(sf)
ax.set_xlabel(r"$-\ln X$", **label_kwargs)
ax.set_ylabel(labels[i], **label_kwargs)
# Generate scatter plot.
ax.scatter(-logvol[::thin],
x[::thin],
c=color,
cmap=cmap,
**trace_kwargs)
if connect:
# Add lines highlighting specific particle paths.
for j in ids:
sel = (samples_id[::thin] == j)
ax.plot(-logvol[::thin][sel],
x[::thin][sel],
color=connect_color,
**connect_kwargs)
# Add truth value(s).
if truths is not None:
plot_thruth(ax,
truths[i],
truth_color,
truth_kwargs,
horizontal=True)
# Plot marginalized 1-D posterior.
ax = axes[i, 1]
# Set color(s).
if isinstance(post_color, str_type):
color = post_color
else:
color = post_color[i]
# Setup axes
ax.set_xlim(span[i])
if max_n_ticks == 0:
ax.xaxis.set_major_locator(NullLocator())
ax.yaxis.set_major_locator(NullLocator())
else:
ax.xaxis.set_major_locator(MaxNLocator(max_n_ticks))
ax.yaxis.set_major_locator(NullLocator())
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
ax.xaxis.set_major_formatter(sf)
ax.set_xlabel(labels[i], **label_kwargs)
# Generate distribution.
s = smooth[i]
if isinstance(s, int_type):
# If `s` is an integer, plot a weighted histogram with
# `s` bins within the provided bounds.
n, b, _ = ax.hist(x,
bins=s,
weights=weights,
color=color,
range=np.sort(span[i]),
**post_kwargs)
x0 = np.array(list(zip(b[:-1], b[1:]))).flatten()
y0 = np.array(list(zip(n, n))).flatten()
else:
# If `s` is a float, oversample the data relative to the
# smoothing filter by a factor of 10, then use a Gaussian
# filter to smooth the results.
bins = int(round(10. / s))
n, b = np.histogram(x,
bins=bins,
weights=weights,
range=np.sort(span[i]))
n = norm_kde(n, 10.)
x0 = 0.5 * (b[1:] + b[:-1])
y0 = n
ax.fill_between(x0, y0, color=color, **post_kwargs)
ax.set_ylim([0., max(y0) * 1.05])
# Plot quantiles.
if quantiles is not None and len(quantiles) > 0:
qs = _quantile(x, quantiles, weights=weights)
for q in qs:
ax.axvline(q, lw=2, ls="dashed", color=color)
if verbose:
print("Quantiles:")
print(labels[i], list(zip(quantiles, qs)))
# Add truth value(s).
if truths is not None:
plot_thruth(ax,
truths[i],
truth_color,
truth_kwargs,
vertical=True)
# Set titles.
if show_titles:
title = None
if title_fmt is not None:
ql, qm, qh = _quantile(x, title_quantiles, weights=weights)
q_minus, q_plus = qm - ql, qh - qm
fmt = "{{0:{0}}}".format(title_fmt).format
title = r"${{{0}}}_{{-{1}}}^{{+{2}}}$"
title = title.format(fmt(qm), fmt(q_minus), fmt(q_plus))
title = "{0} = {1}".format(labels[i], title)
ax.set_title(title, **title_kwargs)
return fig, axes
def cornerpoints(results,
dims=None,
thin=1,
span=None,
cmap='plasma',
color=None,
kde=True,
nkde=1000,
plot_kwargs=None,
labels=None,
label_kwargs=None,
truths=None,
truth_color='red',
truth_kwargs=None,
max_n_ticks=5,
use_math_text=False,
fig=None):
"""
Generate a (sub-)corner plot of (weighted) samples.
Parameters
----------
results : :class:`~dynesty.results.Results` instance
A :class:`~dynesty.results.Results` instance from a nested
sampling run. **Compatible with results derived from**
`nestle <http://kylebarbary.com/nestle/>`_.
dims : iterable of shape (ndim,), optional
The subset of dimensions that should be plotted. If not provided,
all dimensions will be shown.
thin : int, optional
Thin the samples so that only each `thin`-th sample is plotted.
Default is `1` (no thinning).
span : iterable with shape (ndim,), optional
A list where each element is either a length-2 tuple containing
lower and upper bounds or a float from `(0., 1.]` giving the
fraction of (weighted) samples to include. If a fraction is provided,
the bounds are chosen to be equal-tailed. An example would be::
span = [(0., 10.), 0.95, (5., 6.)]
Default is `1.` for all parameters (no bound).
cmap : str, optional
A `~matplotlib`-style colormap used when plotting the points,
where each point is colored according to its weight. Default is
`'plasma'`.
color : str, optional
A `~matplotlib`-style color used when plotting the points.
This overrides the `cmap` option by giving all points
the same color. Default is `None` (not used).
kde : bool, optional
Whether to use kernel density estimation to estimate and plot
the PDF of the importance weights as a function of log-volume
(as opposed to the importance weights themselves). Default is
`True`.
nkde : int, optional
The number of grid points used when plotting the kernel density
estimate. Default is `1000`.
plot_kwargs : dict, optional
Extra keyword arguments that will be used for plotting the points.
labels : iterable with shape (ndim,), optional
A list of names for each parameter. If not provided, the default name
used when plotting will follow :math:`x_i` style.
label_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_xlabel` and
`~matplotlib.axes.Axes.set_ylabel` methods.
truths : iterable with shape (ndim,), optional
A list of reference values that will be overplotted on the traces and
marginalized 1-D posteriors as solid horizontal/vertical lines.
Individual values can be exempt using `None`. Default is `None`.
truth_color : str or iterable with shape (ndim,), optional
A `~matplotlib`-style color (either a single color or a different
value for each subplot) used when plotting `truths`.
Default is `'red'`.
truth_kwargs : dict, optional
Extra keyword arguments that will be used for plotting the vertical
and horizontal lines with `truths`.
max_n_ticks : int, optional
Maximum number of ticks allowed. Default is `5`.
use_math_text : bool, optional
Whether the axis tick labels for very large/small exponents should be
displayed as powers of 10 rather than using `e`. Default is `False`.
fig : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`), optional
If provided, overplot the points onto the provided figure object.
Otherwise, by default an internal figure is generated.
Returns
-------
cornerpoints : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`)
Output (sub-)corner plot of (weighted) samples.
"""
# Initialize values.
if truth_kwargs is None:
truth_kwargs = {}
if label_kwargs is None:
label_kwargs = {}
if plot_kwargs is None:
plot_kwargs = {}
# Set defaults.
plot_kwargs['s'] = plot_kwargs.get('s', 1)
plot_kwargs['edgecolor'] = plot_kwargs.get('edgecolor', None)
plot_kwargs['edgecolors'] = plot_kwargs.get('edgecolors', None)
truth_kwargs['linestyle'] = truth_kwargs.get('linestyle', 'solid')
truth_kwargs['linewidth'] = truth_kwargs.get('linewidth', 2)
truth_kwargs['alpha'] = truth_kwargs.get('alpha', 0.7)
# Extract weighted samples.
samples = results['samples']
logvol = results['logvol']
weights = results.importance_weights()
if kde:
# Derive kernel density estimate.
wt_kde = gaussian_kde(resample_equal(-logvol, weights)) # KDE
logvol_grid = np.linspace(logvol[0], logvol[-1], nkde) # resample
wt_grid = wt_kde.pdf(-logvol_grid) # evaluate KDE PDF
weights = np.interp(-logvol, -logvol_grid, wt_grid) # interpolate
# Deal with 1D results. A number of extra catches are also here
# in case users are trying to plot other results besides the `Results`
# instance generated by `dynesty`.
samples = np.atleast_1d(samples)
if len(samples.shape) == 1:
samples = np.atleast_2d(samples)
else:
assert len(samples.shape) == 2, "Samples must be 1- or 2-D."
samples = samples.T
assert samples.shape[0] <= samples.shape[1], "There are more " \
"dimensions than samples!"
# Slice samples based on provided `dims`.
if dims is not None:
samples = samples[dims]
ndim, nsamps = samples.shape
# Check weights.
if weights.ndim != 1:
raise ValueError("Weights must be 1-D.")
if nsamps != weights.shape[0]:
raise ValueError("The number of weights and samples disagree!")
if ndim == 1:
raise ValueError("cornerpoints does not make sense for 1-D posterior")
# Determine plotting bounds.
if span is not None:
if len(span) != ndim:
raise ValueError("Dimension mismatch between samples and span.")
check_span(span, samples, weights)
# Set labels
if labels is None:
labels = [r"$x_{" + str(i + 1) + "}$" for i in range(ndim)]
# Set colormap.
if color is None:
color = weights
# Setup axis layout (from `corner.py`).
factor = 2.0 # size of side of one panel
lbdim = 0.5 * factor # size of left/bottom margin
trdim = 0.2 * factor # size of top/right margin
whspace = 0.05 # size of width/height margin
plotdim = factor * (ndim - 1.) + factor * (ndim - 2.) * whspace
dim = lbdim + plotdim + trdim # total size
# Initialize figure.
fig, axes = _make_subplots(fig, ndim - 1, ndim - 1, dim, dim)
# Format figure.
lb = lbdim / dim
tr = (lbdim + plotdim) / dim
fig.subplots_adjust(left=lb,
bottom=lb,
right=tr,
top=tr,
wspace=whspace,
hspace=whspace)
# Plot the 2-D projected samples.
for i, x in enumerate(samples[1:]):
for j, y in enumerate(samples[:-1]):
try:
ax = axes[i, j]
except:
ax = axes
# Setup axes.
if span is not None:
ax.set_xlim(span[j])
ax.set_ylim(span[i])
if j > i:
ax.set_frame_on(False)
ax.set_xticks([])
ax.set_yticks([])
continue
if max_n_ticks == 0:
ax.xaxis.set_major_locator(NullLocator())
ax.yaxis.set_major_locator(NullLocator())
else:
ax.xaxis.set_major_locator(
MaxNLocator(max_n_ticks, prune="lower"))
ax.yaxis.set_major_locator(
MaxNLocator(max_n_ticks, prune="lower"))
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
ax.xaxis.set_major_formatter(sf)
ax.yaxis.set_major_formatter(sf)
if i < ndim - 2:
ax.set_xticklabels([])
else:
rotate_ticks(ax, 'x')
ax.set_xlabel(labels[j], **label_kwargs)
ax.xaxis.set_label_coords(0.5, -0.3)
if j > 0:
ax.set_yticklabels([])
else:
rotate_ticks(ax, 'y')
ax.set_ylabel(labels[i + 1], **label_kwargs)
ax.yaxis.set_label_coords(-0.3, 0.5)
# Plot distribution.
in_bounds = np.ones_like(y).astype('bool')
if span is not None and span[i] is not None:
in_bounds *= ((x >= span[i][0]) & (x <= span[i][1]))
if span is not None and span[j] is not None:
in_bounds *= ((y >= span[j][0]) & (y <= span[j][1]))
if isinstance(color, str):
cur_color = color
else:
cur_color = color[in_bounds][::thin]
ax.scatter(y[in_bounds][::thin],
x[in_bounds][::thin],
c=cur_color,
cmap=cmap,
**plot_kwargs)
# Add truth values
if truths is not None:
plot_thruth(ax,
truths[j],
truth_color,
truth_kwargs,
vertical=True)
plot_thruth(ax,
truths[i + 1],
truth_color,
truth_kwargs,
horizontal=True)
return (fig, axes)
def cornerplot(results,
dims=None,
span=None,
quantiles=(0.025, 0.5, 0.975),
color='black',
smooth=0.02,
quantiles_2d=None,
hist_kwargs=None,
hist2d_kwargs=None,
labels=None,
label_kwargs=None,
show_titles=False,
title_quantiles=(0.025, 0.5, 0.975),
title_fmt=".2f",
title_kwargs=None,
truths=None,
truth_color='red',
truth_kwargs=None,
max_n_ticks=5,
top_ticks=False,
use_math_text=False,
verbose=False,
fig=None):
"""
Generate a corner plot of the 1-D and 2-D marginalized posteriors.
Parameters
----------
results : :class:`~dynesty.results.Results` instance
A :class:`~dynesty.results.Results` instance from a nested
sampling run. **Compatible with results derived from**
`nestle <http://kylebarbary.com/nestle/>`_.
dims : iterable of shape (ndim,), optional
The subset of dimensions that should be plotted. If not provided,
all dimensions will be shown.
span : iterable with shape (ndim,), optional
A list where each element is either a length-2 tuple containing
lower and upper bounds or a float from `(0., 1.]` giving the
fraction of (weighted) samples to include. If a fraction is provided,
the bounds are chosen to be equal-tailed. An example would be::
span = [(0., 10.), 0.95, (5., 6.)]
Default is `0.999999426697` (5-sigma credible interval).
quantiles : iterable, optional
A list of fractional quantiles to overplot on the 1-D marginalized
posteriors as vertical dashed lines. Default is `[0.025, 0.5, 0.975]`
(spanning the 95%/2-sigma credible interval).
color : str or iterable with shape (ndim,), optional
A `~matplotlib`-style color (either a single color or a different
value for each subplot) used when plotting the histograms.
Default is `'black'`.
smooth : float or iterable with shape (ndim,), optional
The standard deviation (either a single value or a different value for
each subplot) for the Gaussian kernel used to smooth the 1-D and 2-D
marginalized posteriors, expressed as a fraction of the span.
Default is `0.02` (2% smoothing). If an integer is provided instead,
this will instead default to a simple (weighted) histogram with
`bins=smooth`.
quantiles_2d : iterable with shape (nquant,), optional
The quantiles used for plotting the smoothed 2-D distributions.
If not provided, these default to 0.5, 1, 1.5, and 2-sigma contours
roughly corresponding to quantiles of `[0.1, 0.4, 0.65, 0.85]`.
hist_kwargs : dict, optional
Extra keyword arguments to send to the 1-D (smoothed) histograms.
hist2d_kwargs : dict, optional
Extra keyword arguments to send to the 2-D (smoothed) histograms.
labels : iterable with shape (ndim,), optional
A list of names for each parameter. If not provided, the default name
used when plotting will follow :math:`x_i` style.
label_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_xlabel` and
`~matplotlib.axes.Axes.set_ylabel` methods.
show_titles : bool, optional
Whether to display a title above each 1-D marginalized posterior
showing the 0.5 quantile along with the upper/lower bounds associated
with the 0.025 and 0.975 (95%/2-sigma credible interval) quantiles.
Default is `False`.
title_quantiles : iterable, optional
A list of fractional quantiles to use in the title. Default is
`[0.025, 0.5, 0.975]` (median plus 95%/2-sigma credible interval).
title_fmt : str, optional
The format string for the quantiles provided in the title. Default is
`'.2f'`.
title_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_title` command.
truths : iterable with shape (ndim,), optional
A list of reference values that will be overplotted on the traces and
marginalized 1-D posteriors as solid horizontal/vertical lines.
Individual values can be exempt using `None`. Default is `None`.
truth_color : str or iterable with shape (ndim,), optional
A `~matplotlib`-style color (either a single color or a different
value for each subplot) used when plotting `truths`.
Default is `'red'`.
truth_kwargs : dict, optional
Extra keyword arguments that will be used for plotting the vertical
and horizontal lines with `truths`.
max_n_ticks : int, optional
Maximum number of ticks allowed. Default is `5`.
top_ticks : bool, optional
Whether to label the top (rather than bottom) ticks. Default is
`False`.
use_math_text : bool, optional
Whether the axis tick labels for very large/small exponents should be
displayed as powers of 10 rather than using `e`. Default is `False`.
verbose : bool, optional
Whether to print the values of the computed quantiles associated with
each parameter. Default is `False`.
fig : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`), optional
If provided, overplot the traces and marginalized 1-D posteriors
onto the provided figure. Otherwise, by default an
internal figure is generated.
Returns
-------
cornerplot : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`)
Output corner plot.
"""
# Initialize values.
if quantiles is None:
quantiles = []
if truth_kwargs is None:
truth_kwargs = {}
if label_kwargs is None:
label_kwargs = {}
if title_kwargs is None:
title_kwargs = {}
if hist_kwargs is None:
hist_kwargs = {}
if hist2d_kwargs is None:
hist2d_kwargs = {}
# Set defaults.
hist_kwargs['alpha'] = hist_kwargs.get('alpha', 0.6)
hist2d_kwargs['levels'] = hist2d_kwargs.get('levels', quantiles_2d)
truth_kwargs['linestyle'] = truth_kwargs.get('linestyle', 'solid')
truth_kwargs['linewidth'] = truth_kwargs.get('linewidth', 2)
truth_kwargs['alpha'] = truth_kwargs.get('alpha', 0.7)
# Extract weighted samples.
samples = results['samples']
weights = results.importance_weights()
# Deal with 1D results. A number of extra catches are also here
# in case users are trying to plot other results besides the `Results`
# instance generated by `dynesty`.
samples = np.atleast_1d(samples)
if len(samples.shape) == 1:
samples = np.atleast_2d(samples)
else:
assert len(samples.shape) == 2, "Samples must be 1- or 2-D."
samples = samples.T
assert samples.shape[0] <= samples.shape[1], "There are more " \
"dimensions than samples!"
# Slice samples based on provided `dims`.
if dims is not None:
samples = samples[dims]
ndim, nsamps = samples.shape
# Check weights.
if weights.ndim != 1:
raise ValueError("Weights must be 1-D.")
if nsamps != weights.shape[0]:
raise ValueError("The number of weights and samples disagree!")
# Determine plotting bounds.
if span is None:
span = [0.999999426697 for i in range(ndim)]
span = list(span)
if len(span) != ndim:
raise ValueError("Dimension mismatch between samples and span.")
check_span(span, samples, weights)
# Set labels
if labels is None:
labels = [r"$x_{" + str(i + 1) + "}$" for i in range(ndim)]
# Setting up smoothing.
if isinstance(smooth, (int_type, float_type)):
smooth = [smooth for i in range(ndim)]
# Setup axis layout (from `corner.py`).
factor = 2.0 # size of side of one panel
lbdim = 0.5 * factor # size of left/bottom margin
trdim = 0.2 * factor # size of top/right margin
whspace = 0.05 # size of width/height margin
plotdim = factor * ndim + factor * (ndim - 1.) * whspace # plot size
dim = lbdim + plotdim + trdim # total size
# Initialize figure.
fig, axes = _make_subplots(fig, ndim, ndim, dim, dim)
# Format figure.
lb = lbdim / dim
tr = (lbdim + plotdim) / dim
fig.subplots_adjust(left=lb,
bottom=lb,
right=tr,
top=tr,
wspace=whspace,
hspace=whspace)
# Plotting.
for i, x in enumerate(samples):
ax = axes[i, i]
# Plot the 1-D marginalized posteriors.
# Setup axes
ax.set_xlim(span[i])
if max_n_ticks == 0:
ax.xaxis.set_major_locator(NullLocator())
ax.yaxis.set_major_locator(NullLocator())
else:
ax.xaxis.set_major_locator(MaxNLocator(max_n_ticks, prune="lower"))
ax.yaxis.set_major_locator(NullLocator())
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
ax.xaxis.set_major_formatter(sf)
if i < ndim - 1:
if top_ticks:
ax.xaxis.set_ticks_position("top")
rotate_ticks(ax, 'x')
else:
ax.set_xticklabels([])
else:
rotate_ticks(ax, 'x')
ax.set_xlabel(labels[i], **label_kwargs)
ax.xaxis.set_label_coords(0.5, -0.3)
# Generate distribution.
sx = smooth[i]
if isinstance(sx, int_type):
# If `sx` is an integer, plot a weighted histogram with
# `sx` bins within the provided bounds.
n, b, _ = ax.hist(x,
bins=sx,
weights=weights,
color=color,
range=np.sort(span[i]),
**hist_kwargs)
else:
# If `sx` is a float, oversample the data relative to the
# smoothing filter by a factor of 10, then use a Gaussian
# filter to smooth the results.
bins = int(round(10. / sx))
n, b = np.histogram(x,
bins=bins,
weights=weights,
range=np.sort(span[i]))
n = norm_kde(n, 10.)
b0 = 0.5 * (b[1:] + b[:-1])
n, b, _ = ax.hist(b0,
bins=b,
weights=n,
range=np.sort(span[i]),
color=color,
**hist_kwargs)
ax.set_ylim([0., max(n) * 1.05])
# Plot quantiles.
if quantiles is not None and len(quantiles) > 0:
qs = _quantile(x, quantiles, weights=weights)
for q in qs:
ax.axvline(q, lw=2, ls="dashed", color=color)
if verbose:
print("Quantiles:")
print(labels[i], list(zip(quantiles, qs)))
# Add truth value(s).
if truths is not None:
plot_thruth(ax,
truths[i],
truth_color,
truth_kwargs,
vertical=True)
# Set titles.
if show_titles:
title = None
if title_fmt is not None:
ql, qm, qh = _quantile(x, title_quantiles, weights=weights)
q_minus, q_plus = qm - ql, qh - qm
fmt = "{{0:{0}}}".format(title_fmt).format
title = r"${{{0}}}_{{-{1}}}^{{+{2}}}$"
title = title.format(fmt(qm), fmt(q_minus), fmt(q_plus))
title = "{0} = {1}".format(labels[i], title)
ax.set_title(title, **title_kwargs)
for j, y in enumerate(samples):
if np.shape(samples)[0] == 1:
ax = axes
else:
ax = axes[i, j]
# Plot the 2-D marginalized posteriors.
# Setup axes.
if j > i:
ax.set_frame_on(False)
ax.set_xticks([])
ax.set_yticks([])
continue
elif j == i:
continue
if max_n_ticks == 0:
ax.xaxis.set_major_locator(NullLocator())
ax.yaxis.set_major_locator(NullLocator())
else:
ax.xaxis.set_major_locator(
MaxNLocator(max_n_ticks, prune="lower"))
ax.yaxis.set_major_locator(
MaxNLocator(max_n_ticks, prune="lower"))
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
ax.xaxis.set_major_formatter(sf)
ax.yaxis.set_major_formatter(sf)
if i < ndim - 1:
ax.set_xticklabels([])
else:
rotate_ticks(ax, 'x')
ax.set_xlabel(labels[j], **label_kwargs)
ax.xaxis.set_label_coords(0.5, -0.3)
if j > 0:
ax.set_yticklabels([])
else:
rotate_ticks(ax, 'y')
ax.set_ylabel(labels[i], **label_kwargs)
ax.yaxis.set_label_coords(-0.3, 0.5)
# Generate distribution.
sy = smooth[j]
check_ix = isinstance(sx, int_type)
check_iy = isinstance(sy, int_type)
if check_ix and check_iy:
fill_contours = False
plot_contours = False
else:
fill_contours = True
plot_contours = True
hist2d_kwargs['fill_contours'] = hist2d_kwargs.get(
'fill_contours', fill_contours)
hist2d_kwargs['plot_contours'] = hist2d_kwargs.get(
'plot_contours', plot_contours)
_hist2d(y,
x,
ax=ax,
span=[span[j], span[i]],
weights=weights,
color=color,
smooth=[sy, sx],
**hist2d_kwargs)
# Add truth values
if truths is not None:
plot_thruth(ax,
truths[j],
truth_color,
truth_kwargs,
vertical=True)
plot_thruth(ax,
truths[i],
truth_color,
truth_kwargs,
horizontal=True)
return (fig, axes)
def boundplot(results,
dims,
it=None,
idx=None,
prior_transform=None,
periodic=None,
reflective=None,
ndraws=5000,
color='gray',
plot_kwargs=None,
labels=None,
label_kwargs=None,
max_n_ticks=5,
use_math_text=False,
show_live=False,
live_color='darkviolet',
live_kwargs=None,
span=None,
fig=None):
"""
Return the bounding distribution used to propose either (1) live points
at a given iteration or (2) a specific dead point during
the course of a run, projected onto the two dimensions specified
by `dims`.
Parameters
----------
results : :class:`~dynesty.results.Results` instance
A :class:`~dynesty.results.Results` instance from a nested
sampling run.
dims : length-2 tuple
The dimensions used to plot the bounding.
it : int, optional
If provided, returns the bounding distribution at the specified
iteration of the nested sampling run. **Note that this option and
`idx` are mutually exclusive.**
idx : int, optional
If provided, returns the bounding distribution used to propose the
dead point at the specified iteration of the nested sampling run.
**Note that this option and `it` are mutually exclusive.**
prior_transform : func, optional
The function transforming samples within the unit cube back to samples
in the native model space. If provided, the transformed bounding
distribution will be plotted in the native model space.
periodic : iterable, optional
A list of indices for parameters with periodic boundary conditions.
These parameters *will not* have their positions constrained to be
within the unit cube, enabling smooth behavior for parameters
that may wrap around the edge. Default is `None` (i.e. no periodic
boundary conditions).
reflective : iterable, optional
A list of indices for parameters with reflective boundary conditions.
These parameters *will not* have their positions constrained to be
within the unit cube, enabling smooth behavior for parameters
that may reflect at the edge. Default is `None` (i.e. no reflective
boundary conditions).
ndraws : int, optional
The number of random samples to draw from the bounding distribution
when plotting. Default is `5000`.
color : str, optional
The color of the points randomly sampled from the bounding
distribution. Default is `'gray'`.
plot_kwargs : dict, optional
Extra keyword arguments used when plotting the bounding draws.
labels : iterable with shape (ndim,), optional
A list of names for each parameter. If not provided, the default name
used when plotting will follow :math:`x_i` style.
label_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_xlabel` and
`~matplotlib.axes.Axes.set_ylabel` methods.
max_n_ticks : int, optional
Maximum number of ticks allowed. Default is `5`.
use_math_text : bool, optional
Whether the axis tick labels for very large/small exponents should be
displayed as powers of 10 rather than using `e`. Default is `False`.
show_live : bool, optional
Whether the live points at a given iteration (for `it`) or
associated with the bounding (for `idx`) should be highlighted.
Default is `False`. In the dynamic case, only the live points
associated with the batch used to construct the relevant bound
are plotted.
live_color : str, optional
The color of the live points. Default is `'darkviolet'`.
live_kwargs : dict, optional
Extra keyword arguments used when plotting the live points.
span : iterable with shape (2,), optional
A list where each element is a length-2 tuple containing
lower and upper bounds. Default is `None` (no bound).
fig : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`), optional
If provided, overplot the draws onto the provided figure.
Otherwise, by default an internal figure is generated.
Returns
-------
bounding_plot : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`)
Output plot of the bounding distribution.
"""
# Initialize values.
if plot_kwargs is None:
plot_kwargs = {}
if label_kwargs is None:
label_kwargs = {}
if live_kwargs is None:
live_kwargs = {}
# Check that either `idx` or `it` has been specified.
if (it is None and idx is None) or (it is not None and idx is not None):
raise ValueError("You must specify either an iteration or an index!")
# Set defaults.
plot_kwargs['marker'] = plot_kwargs.get('marker', 'o')
plot_kwargs['linestyle'] = plot_kwargs.get('linestyle', 'None')
plot_kwargs['markersize'] = plot_kwargs.get('markersize', 1)
plot_kwargs['alpha'] = plot_kwargs.get('alpha', 0.4)
live_kwargs['marker'] = live_kwargs.get('marker', 'o')
live_kwargs['linestyle'] = live_kwargs.get('linestyle', 'None')
live_kwargs['markersize'] = live_kwargs.get('markersize', 1)
# Extract bounding distributions.
try:
bounds = results['bound']
except KeyError:
raise ValueError("No bounds were saved in the results!")
nsamps = len(results['samples'])
nonbounded = get_nonbounded(bounds[0].n, periodic, reflective)
if it is not None:
if it >= nsamps:
raise ValueError("The iteration requested goes beyond the "
"number of iterations in the run.")
# Extract bound iterations.
try:
bound_iter = np.array(results['bound_iter'])
except KeyError:
raise ValueError("Cannot reconstruct the bound used at the "
"specified iteration since bound "
"iterations were not saved in the results.")
# Find bound at the specified iteration.
if it == 0:
pidx = 0
else:
pidx = bound_iter[it]
else:
if idx >= nsamps:
raise ValueError("The index requested goes beyond the "
"number of samples in the run.")
try:
samples_bound = results['samples_bound']
except KeyError:
raise ValueError("Cannot reconstruct the bound used to "
"compute the specified dead point since "
"sample bound indices were not saved "
"in the results.")
# Grab relevant bound.
pidx = samples_bound[idx]
# Get desired bound.
bound = bounds[pidx]
# Do we want to show the live points at the specified iteration?
# If so, we need to rewind our bound to check.
# (We could also go forward; this is an arbitrary choice.)
if show_live:
try:
# We can only reconstruct the run if the final set of live points
# were added to the results. This is true by default for dynamic
# nested sampling runs but not guaranteeed for standard runs.
nlive = results['nlive']
niter = results['niter']
if nsamps - niter != nlive:
raise ValueError("Cannot reconstruct bound because the "
"final set of live points are not included "
"in the results.")
# Grab our final set of live points (with proper IDs).
samples = results['samples_u']
samples_id = results['samples_id']
ndim = samples.shape[1]
live_u = np.empty((nlive, ndim))
live_u[samples_id[-nlive:]] = samples[-nlive:]
# Find generating bound ID if necessary.
if it is None:
it = results['samples_it'][idx]
# Run our sampling backwards.
for i in range(1, niter - it + 1):
r = -(nlive + i)
uidx = samples_id[r]
live_u[uidx] = samples[r]
except:
# In the dynamic sampling case, we will show the live points used
# during the batch associated with a particular iteration/bound.
batch = results['samples_batch'][it] # select batch
nbatch = results['batch_nlive'][batch] # nlive in the batch
bsel = results['samples_batch'] == batch # select batch
niter_eff = sum(bsel) - nbatch # "effective" iterations in batch
# Grab our final set of live points (with proper IDs).
samples = results['samples_u'][bsel]
samples_id = results['samples_id'][bsel]
samples_id -= min(samples_id) # re-index to start at zero
ndim = samples.shape[1]
live_u = np.empty((nbatch, ndim))
live_u[samples_id[-nbatch:]] = samples[-nbatch:]
# Find generating bound ID if necessary.
if it is None:
it = results['samples_it'][idx]
it_eff = sum(bsel[:it + 1]) # effective iteration in batch
# Run our sampling backwards.
for i in range(1, niter_eff - it_eff + 1):
r = -(nbatch + i)
uidx = samples_id[r]
live_u[uidx] = samples[r]
rstate = get_random_generator()
# Draw samples from the bounding distribution.
if not isinstance(bound, (bounding.RadFriends, bounding.SupFriends)):
# If bound is "fixed", go ahead and draw samples from it.
psamps = bound.samples(ndraws, rstate=rstate)
else:
# If bound is based on the distribution of live points at a
# specific iteration, we need to reconstruct what those were.
if not show_live:
try:
# Only reconstruct the run if we haven't done it already.
nlive = results['nlive']
niter = results['niter']
if nsamps - niter != nlive:
raise ValueError("Cannot reconstruct bound because the "
"final set of live points are not "
"included in the results.")
# Grab our final set of live points (with proper IDs).
samples = results['samples_u']
samples_id = results['samples_id']
ndim = samples.shape[1]
live_u = np.empty((nlive, ndim))
live_u[samples_id[-nlive:]] = samples[-nlive:]
# Run our sampling backwards.
if it is None:
it = results['samples_it'][idx]
for i in range(1, niter - it + 1):
r = -(nlive + i)
uidx = samples_id[r]
live_u[uidx] = samples[r]
except:
raise ValueError("Live point tracking currently not "
"implemented for dynamic sampling results.")
# Draw samples.
psamps = bound.samples(ndraws, live_u, rstate=rstate)
# Projecting samples to input dimensions and possibly
# the native model space.
if prior_transform is None:
x1, x2 = psamps[:, dims].T
if show_live:
l1, l2 = live_u[:, dims].T
else:
# Remove points outside of the unit cube as appropriate.
sel = [unitcheck(point, nonbounded) for point in psamps]
vsamps = np.array(list(map(prior_transform, psamps[sel])))
x1, x2 = vsamps[:, dims].T
if show_live:
lsamps = np.array(list(map(prior_transform, live_u)))
l1, l2 = lsamps[:, dims].T
# Setting up default plot layout.
fig, axes = _make_subplots(fig, 1, 1, 6, 6)
axes = axes[0, 0]
# Plotting.
axes.plot(x1, x2, color=color, zorder=1, **plot_kwargs)
if show_live:
axes.plot(l1, l2, color=live_color, zorder=2, **live_kwargs)
# Setup axes
if span is not None:
axes.set_xlim(span[0])
axes.set_ylim(span[1])
if max_n_ticks == 0:
axes.xaxis.set_major_locator(NullLocator())
axes.yaxis.set_major_locator(NullLocator())
else:
axes.xaxis.set_major_locator(MaxNLocator(max_n_ticks))
axes.yaxis.set_major_locator(MaxNLocator(max_n_ticks))
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
axes.xaxis.set_major_formatter(sf)
axes.yaxis.set_major_formatter(sf)
if labels is not None:
axes.set_xlabel(labels[0], **label_kwargs)
axes.set_ylabel(labels[1], **label_kwargs)
else:
axes.set_xlabel(r"$x_{" + str(dims[0] + 1) + "}$", **label_kwargs)
axes.set_ylabel(r"$x_{" + str(dims[1] + 1) + "}$", **label_kwargs)
return fig, axes
def cornerbound(results,
it=None,
idx=None,
dims=None,
prior_transform=None,
periodic=None,
reflective=None,
ndraws=5000,
color='gray',
plot_kwargs=None,
labels=None,
label_kwargs=None,
max_n_ticks=5,
use_math_text=False,
show_live=False,
live_color='darkviolet',
live_kwargs=None,
span=None,
fig=None):
"""
Return the bounding distribution used to propose either (1) live points
at a given iteration or (2) a specific dead point during
the course of a run, projected onto all pairs of dimensions.
Parameters
----------
results : :class:`~dynesty.results.Results` instance
A :class:`~dynesty.results.Results` instance from a nested
sampling run.
it : int, optional
If provided, returns the bounding distribution at the specified
iteration of the nested sampling run. **Note that this option and
`idx` are mutually exclusive.**
idx : int, optional
If provided, returns the bounding distribution used to propose the
dead point at the specified iteration of the nested sampling run.
**Note that this option and `it` are mutually exclusive.**
dims : iterable of shape (ndim,), optional
The subset of dimensions that should be plotted. If not provided,
all dimensions will be shown.
prior_transform : func, optional
The function transforming samples within the unit cube back to samples
in the native model space. If provided, the transformed bounding
distribution will be plotted in the native model space.
periodic : iterable, optional
A list of indices for parameters with periodic boundary conditions.
These parameters *will not* have their positions constrained to be
within the unit cube, enabling smooth behavior for parameters
that may wrap around the edge. Default is `None` (i.e. no periodic
boundary conditions).
reflective : iterable, optional
A list of indices for parameters with reflective boundary conditions.
These parameters *will not* have their positions constrained to be
within the unit cube, enabling smooth behavior for parameters
that may reflect at the edge. Default is `None` (i.e. no reflective
boundary conditions).
ndraws : int, optional
The number of random samples to draw from the bounding distribution
when plotting. Default is `5000`.
color : str, optional
The color of the points randomly sampled from the bounding
distribution. Default is `'gray'`.
plot_kwargs : dict, optional
Extra keyword arguments used when plotting the bounding draws.
labels : iterable with shape (ndim,), optional
A list of names for each parameter. If not provided, the default name
used when plotting will be in :math:`x_i` style.
label_kwargs : dict, optional
Extra keyword arguments that will be sent to the
`~matplotlib.axes.Axes.set_xlabel` and
`~matplotlib.axes.Axes.set_ylabel` methods.
max_n_ticks : int, optional
Maximum number of ticks allowed. Default is `5`.
use_math_text : bool, optional
Whether the axis tick labels for very large/small exponents should be
displayed as powers of 10 rather than using `e`. Default is `False`.
show_live : bool, optional
Whether the live points at a given iteration (for `it`) or
associated with the bounding (for `idx`) should be highlighted.
Default is `False`. In the dynamic case, only the live points
associated with the batch used to construct the relevant bound
are plotted.
live_color : str, optional
The color of the live points. Default is `'darkviolet'`.
live_kwargs : dict, optional
Extra keyword arguments used when plotting the live points.
span : iterable with shape (2,), optional
A list where each element is a length-2 tuple containing
lower and upper bounds. Default is `None` (no bound).
fig : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`), optional
If provided, overplot the draws onto the provided figure.
Otherwise, by default an internal figure is generated.
Returns
-------
cornerbound : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`)
Output corner plot of the bounding distribution.
"""
# Initialize values.
if label_kwargs is None:
label_kwargs = {}
if plot_kwargs is None:
plot_kwargs = {}
if live_kwargs is None:
live_kwargs = {}
# Check that either `idx` or `it` is specified.
if (it is None and idx is None) or (it is not None and idx is not None):
raise ValueError("You must specify either an iteration or an index!")
# Set defaults.
plot_kwargs['marker'] = plot_kwargs.get('marker', 'o')
plot_kwargs['linestyle'] = plot_kwargs.get('linestyle', 'None')
plot_kwargs['markersize'] = plot_kwargs.get('markersize', 1)
plot_kwargs['alpha'] = plot_kwargs.get('alpha', 0.4)
live_kwargs['marker'] = live_kwargs.get('marker', 'o')
live_kwargs['linestyle'] = live_kwargs.get('linestyle', 'None')
live_kwargs['markersize'] = live_kwargs.get('markersize', 1)
# Extract bounding distributions.
try:
bounds = results['bound']
except KeyError:
raise ValueError("No bounds were saved in the results!")
nsamps, ndim = results['samples'].shape
if ndim == 1:
raise ValueError('cornerbound does not work for 1-D posteriors')
nonbounded = get_nonbounded(bounds[0].n, periodic, reflective)
if it is not None:
if it >= nsamps:
raise ValueError("The iteration requested goes beyond the "
"number of iterations in the run.")
# Extract bound iterations.
try:
bound_iter = np.array(results['bound_iter'])
except KeyError:
raise ValueError("Cannot reconstruct the bound used at the "
"specified iteration since bound "
"iterations were not saved in the results.")
# Find bound at the specified iteration.
if it == 0:
pidx = 0
else:
pidx = bound_iter[it]
else:
if idx >= nsamps:
raise ValueError("The index requested goes beyond the "
"number of samples in the run.")
try:
samples_bound = results['samples_bound']
except KeyError:
raise ValueError("Cannot reconstruct the bound used to "
"compute the specified dead point since "
"sample bound indices were not saved "
"in the results.")
# Grab relevant bound.
pidx = samples_bound[idx]
# Get desired bound.
bound = bounds[pidx]
# Do we want to show the live points at the specified iteration?
# If so, we need to rewind our bound to check.
# (We could also go forward; this is an arbitrary choice.)
if show_live:
try:
# We can only reconstruct the run if the final set of live points
# were added to the results. This is true by default for dynamic
# nested sampling runs but not guaranteeed for standard runs.
nlive = results['nlive']
niter = results['niter']
if nsamps - niter != nlive:
raise ValueError("Cannot reconstruct bound because the "
"final set of live points are not included "
"in the results.")
# Grab our final set of live points (with proper IDs).
samples = results['samples_u']
samples_id = results['samples_id']
ndim = samples.shape[1]
live_u = np.empty((nlive, ndim))
live_u[samples_id[-nlive:]] = samples[-nlive:]
# Find generating bound ID if necessary.
if it is None:
it = results['samples_it'][idx]
# Run our sampling backwards.
for i in range(1, niter - it + 1):
r = -(nlive + i)
uidx = samples_id[r]
live_u[uidx] = samples[r]
except:
# In the dynamic sampling case, we will show the live points used
# during the batch associated with a particular iteration/bound.
if it is not None:
batch = results['samples_batch'][it] # select batch
else:
batch = results['samples_batch'][idx]
nbatch = results['batch_nlive'][batch] # nlive in the batch
bsel = results['samples_batch'] == batch # select batch
niter_eff = sum(bsel) - nbatch # "effective" iterations in batch
# Grab our final set of live points (with proper IDs).
samples = results['samples_u'][bsel]
samples_id = results['samples_id'][bsel]
samples_id -= min(samples_id) # re-index to start at zero
ndim = samples.shape[1]
live_u = np.empty((nbatch, ndim))
live_u[samples_id[-nbatch:]] = samples[-nbatch:]
# Find generating bound ID if necessary.
if it is None:
it = results['samples_it'][idx]
it_eff = sum(bsel[:it + 1]) # effective iteration in batch
# Run our sampling backwards.
for i in range(1, niter_eff - it_eff + 1):
r = -(nbatch + i)
uidx = samples_id[r]
live_u[uidx] = samples[r]
rstate = get_random_generator()
# Draw samples from the bounding distribution.
if not isinstance(bound, (bounding.RadFriends, bounding.SupFriends)):
# If bound is "fixed", go ahead and draw samples from it.
psamps = bound.samples(ndraws, rstate=rstate)
else:
# If bound is based on the distribution of live points at a
# specific iteration, we need to reconstruct what those were.
if not show_live:
# Only reconstruct the run if we haven't done it already.
nlive = results['nlive']
niter = results['niter']
if nsamps - niter != nlive:
raise ValueError("Cannot reconstruct bound because the "
"final set of live points are not included "
"in the results.")
# Grab our final set of live points (with proper IDs).
samples = results['samples_u']
samples_id = results['samples_id']
ndim = samples.shape[1]
live_u = np.empty((nlive, ndim))
live_u[samples_id[-nlive:]] = samples[-nlive:]
# Run our sampling backwards.
if it is None:
it = results['samples_it'][idx]
for i in range(1, niter - it + 1):
r = -(nlive + i)
uidx = samples_id[r]
live_u[uidx] = samples[r]
# Draw samples.
psamps = bound.samples(ndraws, live_u, rstate=rstate)
# Projecting samples to input dimensions and possibly
# the native model space.
if prior_transform is None:
psamps = psamps.T
if show_live:
lsamps = live_u.T
else:
# Remove points outside of the unit cube.
sel = [unitcheck(point, nonbounded) for point in psamps]
psamps = np.array(list(map(prior_transform, psamps[sel])))
psamps = psamps.T
if show_live:
lsamps = np.array(list(map(prior_transform, live_u)))
lsamps = lsamps.T
# Subsample dimensions.
if dims is not None:
psamps = psamps[dims]
if show_live:
lsamps = lsamps[dims]
ndim = psamps.shape[0]
# Set labels.
if labels is None:
labels = [r"$x_{" + str(i + 1) + "}$" for i in range(ndim)]
# Setup axis layout (from `corner.py`).
factor = 2.0 # size of side of one panel
lbdim = 0.5 * factor # size of left/bottom margin
trdim = 0.2 * factor # size of top/right margin
whspace = 0.05 # size of width/height margin
plotdim = factor * (ndim - 1.) + factor * (ndim - 2.) * whspace
dim = lbdim + plotdim + trdim # total size
# Initialize figure.
fig, axes = _make_subplots(fig, ndim - 1, ndim - 1, dim, dim)
# Format figure.
lb = lbdim / dim
tr = (lbdim + plotdim) / dim
fig.subplots_adjust(left=lb,
bottom=lb,
right=tr,
top=tr,
wspace=whspace,
hspace=whspace)
# Plot the 2-D projected samples.
for i, x in enumerate(psamps[1:]):
for j, y in enumerate(psamps[:-1]):
ax = axes[i, j]
# Setup axes.
if span is not None:
ax.set_xlim(span[j])
ax.set_ylim(span[i])
if j > i:
ax.set_frame_on(False)
ax.set_xticks([])
ax.set_yticks([])
continue
if max_n_ticks == 0:
ax.xaxis.set_major_locator(NullLocator())
ax.yaxis.set_major_locator(NullLocator())
else:
ax.xaxis.set_major_locator(
MaxNLocator(max_n_ticks, prune="lower"))
ax.yaxis.set_major_locator(
MaxNLocator(max_n_ticks, prune="lower"))
# Label axes.
sf = ScalarFormatter(useMathText=use_math_text)
ax.xaxis.set_major_formatter(sf)
ax.yaxis.set_major_formatter(sf)
if i < ndim - 2:
ax.set_xticklabels([])
else:
rotate_ticks(ax, 'x')
ax.set_xlabel(labels[j], **label_kwargs)
ax.xaxis.set_label_coords(0.5, -0.3)
if j > 0:
ax.set_yticklabels([])
else:
rotate_ticks(ax, 'y')
ax.set_ylabel(labels[i + 1], **label_kwargs)
ax.yaxis.set_label_coords(-0.3, 0.5)
# Plot distribution.
ax.plot(y, x, c=color, **plot_kwargs)
# Add live points.
if show_live:
ax.plot(lsamps[j], lsamps[i + 1], c=live_color, **live_kwargs)
return (fig, axes)
def _hist2d(x,
y,
smooth=0.02,
span=None,
weights=None,
levels=None,
ax=None,
color='gray',
plot_datapoints=False,
plot_density=True,
plot_contours=True,
no_fill_contours=False,
fill_contours=True,
contour_kwargs=None,
contourf_kwargs=None,
data_kwargs=None):
"""
Internal function called by :meth:`cornerplot` used to generate a
a 2-D histogram/contour of samples.
Parameters
----------
x : interable with shape (nsamps,)
Sample positions in the first dimension.
y : iterable with shape (nsamps,)
Sample positions in the second dimension.
span : iterable with shape (ndim,), optional
A list where each element is either a length-2 tuple containing
lower and upper bounds or a float from `(0., 1.]` giving the
fraction of (weighted) samples to include. If a fraction is provided,
the bounds are chosen to be equal-tailed. An example would be::
span = [(0., 10.), 0.95, (5., 6.)]
Default is `0.999999426697` (5-sigma credible interval).
weights : iterable with shape (nsamps,)
Weights associated with the samples. Default is `None` (no weights).
levels : iterable, optional
The contour levels to draw. Default are `[0.5, 1, 1.5, 2]`-sigma.
ax : `~matplotlib.axes.Axes`, optional
An `~matplotlib.axes.axes` instance on which to add the 2-D histogram.
If not provided, a figure will be generated.
color : str, optional
The `~matplotlib`-style color used to draw lines and color cells
and contours. Default is `'gray'`.
plot_datapoints : bool, optional
Whether to plot the individual data points. Default is `False`.
plot_density : bool, optional
Whether to draw the density colormap. Default is `True`.
plot_contours : bool, optional
Whether to draw the contours. Default is `True`.
no_fill_contours : bool, optional
Whether to add absolutely no filling to the contours. This differs
from `fill_contours=False`, which still adds a white fill at the
densest points. Default is `False`.
fill_contours : bool, optional
Whether to fill the contours. Default is `True`.
contour_kwargs : dict
Any additional keyword arguments to pass to the `contour` method.
contourf_kwargs : dict
Any additional keyword arguments to pass to the `contourf` method.
data_kwargs : dict
Any additional keyword arguments to pass to the `plot` method when
adding the individual data points.
"""
if ax is None:
ax = pl.gca()
# Determine plotting bounds.
data = [x, y]
if span is None:
span = [0.999999426697 for i in range(2)]
span = list(span)
if len(span) != 2:
raise ValueError("Dimension mismatch between samples and span.")
check_span(span, data, weights)
# The default "sigma" contour levels.
if levels is None:
levels = 1.0 - np.exp(-0.5 * np.arange(0.5, 2.1, 0.5)**2)
# Color map for the density plot, over-plotted to indicate the
# density of the points near the center.
density_cmap = LinearSegmentedColormap.from_list("density_cmap",
[color, (1, 1, 1, 0)])
# Color map used to hide the points at the high density areas.
white_cmap = LinearSegmentedColormap.from_list("white_cmap", [(1, 1, 1),
(1, 1, 1)],
N=2)
# This "color map" is the list of colors for the contour levels if the
# contours are filled.
rgba_color = colorConverter.to_rgba(color)
n_levels = len(levels)
contour_cmap = [list(rgba_color)] * n_levels + [rgba_color]
for i in range(n_levels):
contour_cmap[i][-1] *= float(i) / (n_levels + 1)
# Initialize smoothing.
if isinstance(smooth, (int_type, float_type)):
smooth = [smooth, smooth]
bins = []
svalues = []
for s in smooth:
if isinstance(s, int_type):
# If `s` is an integer, the weighted histogram has
# `s` bins within the provided bounds.
bins.append(s)
svalues.append(0.)
else:
# If `s` is a float, oversample the data relative to the
# smoothing filter by a factor of 2, then use a Gaussian
# filter to smooth the results.
bins.append(int(round(2. / s)))
svalues.append(2.)
# We'll make the 2D histogram to directly estimate the density.
try:
H, X, Y = np.histogram2d(x.flatten(),
y.flatten(),
bins=bins,
range=list(map(np.sort, span)),
weights=weights)
except ValueError:
raise ValueError("It looks like at least one of your sample columns "
"have no dynamic range.")
# Smooth the results.
if not np.all(svalues == 0.):
H = norm_kde(H, svalues)
# Compute the density levels.
Hflat = H.flatten()
inds = np.argsort(Hflat)[::-1]
Hflat = Hflat[inds]
sm = np.cumsum(Hflat)
sm /= sm[-1]
V = np.empty(len(levels))
for i, v0 in enumerate(levels):
try:
V[i] = Hflat[sm <= v0][-1]
except:
V[i] = Hflat[0]
V.sort()
m = (np.diff(V) == 0)
if np.any(m) and plot_contours:
logging.warning("Too few points to create valid contours.")
if np.all(m):
logging.warning('No points at all in the plotted region')
else:
while np.any(m):
V[np.where(m)[0][0]] *= 1.0 - 1e-4
m = (np.diff(V) == 0)
V.sort()
# Compute the bin centers.
X1, Y1 = 0.5 * (X[1:] + X[:-1]), 0.5 * (Y[1:] + Y[:-1])
# Extend the array for the sake of the contours at the plot edges.
H2 = H.min() + np.zeros((H.shape[0] + 4, H.shape[1] + 4))
H2[2:-2, 2:-2] = H
H2[2:-2, 1] = H[:, 0]
H2[2:-2, -2] = H[:, -1]
H2[1, 2:-2] = H[0]
H2[-2, 2:-2] = H[-1]
H2[1, 1] = H[0, 0]
H2[1, -2] = H[0, -1]
H2[-2, 1] = H[-1, 0]
H2[-2, -2] = H[-1, -1]
X2 = np.concatenate([
X1[0] + np.array([-2, -1]) * np.diff(X1[:2]), X1,
X1[-1] + np.array([1, 2]) * np.diff(X1[-2:])
])
Y2 = np.concatenate([
Y1[0] + np.array([-2, -1]) * np.diff(Y1[:2]), Y1,
Y1[-1] + np.array([1, 2]) * np.diff(Y1[-2:])
])
# Plot the data points.
if plot_datapoints:
if data_kwargs is None:
data_kwargs = {}
data_kwargs["color"] = data_kwargs.get("color", color)
data_kwargs["ms"] = data_kwargs.get("ms", 2.0)
data_kwargs["mec"] = data_kwargs.get("mec", "none")
data_kwargs["alpha"] = data_kwargs.get("alpha", 0.1)
ax.plot(x, y, "o", zorder=-1, rasterized=True, **data_kwargs)
# Plot the base fill to hide the densest data points.
if (plot_contours or plot_density) and not no_fill_contours:
ax.contourf(X2,
Y2,
H2.T, [V.min(), H.max()],
cmap=white_cmap,
antialiased=False)
if plot_contours and fill_contours:
if contourf_kwargs is None:
contourf_kwargs = {}
contourf_kwargs["colors"] = contourf_kwargs.get("colors", contour_cmap)
contourf_kwargs["antialiased"] = contourf_kwargs.get(
"antialiased", False)
ax.contourf(X2, Y2, H2.T,
np.concatenate([[0], V, [H.max() * (1 + 1e-4)]]),
**contourf_kwargs)
# Plot the density map. This can't be plotted at the same time as the
# contour fills.
elif plot_density:
ax.pcolor(X, Y, H.max() - H.T, cmap=density_cmap)
# Plot the contour edge colors.
if plot_contours:
if contour_kwargs is None:
contour_kwargs = {}
contour_kwargs["colors"] = contour_kwargs.get("colors", color)
ax.contour(X2, Y2, H2.T, V, **contour_kwargs)
ax.set_xlim(span[0])
ax.set_ylim(span[1])
|
3fon3fonovREPO_NAMEexostrikerPATH_START.@exostriker_extracted@exostriker-main@exostriker@lib@dynesty_2_0@plotting.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "nanograv/PINT",
"repo_path": "PINT_extracted/PINT-master/src/pint/models/__init__.py",
"type": "Python"
}
|
"""Pulsar timing models and tools for working with them.
The primary object for representing a timing model is
:class:`~pint.models.timing_model.TimingModel`. This contains a collection of
components (subclasses of :class:`~pint.models.timing_model.Component`), each of
which should have a collection of parameters (subclasses of
:class:`~pint.models.parameter.Parameter`). These parameters carry values
uncertainties and units and can be "frozen" or "free" to indicate whether
fitters (subclasses of :class:`~pint.fitter.Fitter`) should be allowed to modify
them. Normally timing models are created using
:func:`~pint.models.model_builder.get_model` but it is possible to construct and
modify them as python objects.
Binary models are implemented as Components, but they have somewhat special
handling; they are implemented by deriving from
:class:`~pint.models.stand_alone_psr_binaries.binary_generic.PSR_BINARY`, which
provides some of the infrastructure needed to implement them conveniently.
"""
from pint.models.absolute_phase import AbsPhase
# Import all standard model components here
from pint.models.astrometry import AstrometryEcliptic, AstrometryEquatorial
from pint.models.binary_bt import BinaryBT, BinaryBTPiecewise
from pint.models.binary_dd import BinaryDD, BinaryDDS, BinaryDDGR, BinaryDDH
from pint.models.binary_ddk import BinaryDDK
from pint.models.binary_ell1 import BinaryELL1, BinaryELL1H, BinaryELL1k
from pint.models.chromatic_model import ChromaticCM, ChromaticCMX
from pint.models.cmwavex import CMWaveX
from pint.models.dispersion_model import (
DispersionDM,
DispersionDMX,
DispersionJump,
FDJumpDM,
)
from pint.models.dmwavex import DMWaveX
from pint.models.frequency_dependent import FD
from pint.models.glitch import Glitch
from pint.models.phase_offset import PhaseOffset
from pint.models.piecewise import PiecewiseSpindown
from pint.models.ifunc import IFunc
from pint.models.jump import DelayJump, PhaseJump
from pint.models.model_builder import get_model, get_model_and_toas
from pint.models.noise_model import (
EcorrNoise,
PLRedNoise,
PLDMNoise,
PLChromNoise,
ScaleToaError,
)
from pint.models.solar_system_shapiro import SolarSystemShapiro
from pint.models.solar_wind_dispersion import SolarWindDispersion, SolarWindDispersionX
from pint.models.spindown import Spindown
from pint.models.fdjump import FDJump
# Import the main timing model classes
from pint.models.timing_model import DEFAULT_ORDER, TimingModel
from pint.models.troposphere_delay import TroposphereDelay
from pint.models.wave import Wave
from pint.models.wavex import WaveX
# Define a standard basic model
StandardTimingModel = TimingModel(
"StandardTimingModel",
[AstrometryEquatorial(), Spindown(), DispersionDM(), SolarSystemShapiro()],
)
# BTTimingModel = generate_timing_model("BTTimingModel",
# (Astrometry, Spindown, Dispersion, SolarSystemShapiro, BT))
# DDTimingModel = generate_timing_model("DDTimingModel",
# (Astrometry, Spindown, Dispersion, SolarSystemShapiro, DD))
|
nanogravREPO_NAMEPINTPATH_START.@PINT_extracted@PINT-master@src@pint@models@__init__.py@.PATH_END.py
|
{
"filename": "GimpGradientFile.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/Pillow/py3/PIL/GimpGradientFile.py",
"type": "Python"
}
|
#
# Python Imaging Library
# $Id$
#
# stuff to read (and render) GIMP gradient files
#
# History:
# 97-08-23 fl Created
#
# Copyright (c) Secret Labs AB 1997.
# Copyright (c) Fredrik Lundh 1997.
#
# See the README file for information on usage and redistribution.
#
"""
Stuff to translate curve segments to palette values (derived from
the corresponding code in GIMP, written by Federico Mena Quintero.
See the GIMP distribution for more information.)
"""
from __future__ import annotations
from math import log, pi, sin, sqrt
from ._binary import o8
EPSILON = 1e-10
"""""" # Enable auto-doc for data member
def linear(middle, pos):
if pos <= middle:
if middle < EPSILON:
return 0.0
else:
return 0.5 * pos / middle
else:
pos = pos - middle
middle = 1.0 - middle
if middle < EPSILON:
return 1.0
else:
return 0.5 + 0.5 * pos / middle
def curved(middle, pos):
return pos ** (log(0.5) / log(max(middle, EPSILON)))
def sine(middle, pos):
return (sin((-pi / 2.0) + pi * linear(middle, pos)) + 1.0) / 2.0
def sphere_increasing(middle, pos):
return sqrt(1.0 - (linear(middle, pos) - 1.0) ** 2)
def sphere_decreasing(middle, pos):
return 1.0 - sqrt(1.0 - linear(middle, pos) ** 2)
SEGMENTS = [linear, curved, sine, sphere_increasing, sphere_decreasing]
"""""" # Enable auto-doc for data member
class GradientFile:
gradient = None
def getpalette(self, entries=256):
palette = []
ix = 0
x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
for i in range(entries):
x = i / (entries - 1)
while x1 < x:
ix += 1
x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
w = x1 - x0
if w < EPSILON:
scale = segment(0.5, 0.5)
else:
scale = segment((xm - x0) / w, (x - x0) / w)
# expand to RGBA
r = o8(int(255 * ((rgb1[0] - rgb0[0]) * scale + rgb0[0]) + 0.5))
g = o8(int(255 * ((rgb1[1] - rgb0[1]) * scale + rgb0[1]) + 0.5))
b = o8(int(255 * ((rgb1[2] - rgb0[2]) * scale + rgb0[2]) + 0.5))
a = o8(int(255 * ((rgb1[3] - rgb0[3]) * scale + rgb0[3]) + 0.5))
# add to palette
palette.append(r + g + b + a)
return b"".join(palette), "RGBA"
class GimpGradientFile(GradientFile):
"""File handler for GIMP's gradient format."""
def __init__(self, fp):
if fp.readline()[:13] != b"GIMP Gradient":
msg = "not a GIMP gradient file"
raise SyntaxError(msg)
line = fp.readline()
# GIMP 1.2 gradient files don't contain a name, but GIMP 1.3 files do
if line.startswith(b"Name: "):
line = fp.readline().strip()
count = int(line)
gradient = []
for i in range(count):
s = fp.readline().split()
w = [float(x) for x in s[:11]]
x0, x1 = w[0], w[2]
xm = w[1]
rgb0 = w[3:7]
rgb1 = w[7:11]
segment = SEGMENTS[int(s[11])]
cspace = int(s[12])
if cspace != 0:
msg = "cannot handle HSV colour space"
raise OSError(msg)
gradient.append((x0, x1, xm, rgb0, rgb1, segment))
self.gradient = gradient
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@Pillow@py3@PIL@GimpGradientFile.py@.PATH_END.py
|
{
"filename": "density_estimator_test.py",
"repo_name": "mackelab/sbi",
"repo_path": "sbi_extracted/sbi-main/tests/density_estimator_test.py",
"type": "Python"
}
|
# This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed
# under the Apache License Version 2.0, see <https://www.apache.org/licenses/>
from __future__ import annotations
from typing import Callable, Tuple
import pytest
import torch
from torch import eye, zeros
from torch.distributions import MultivariateNormal
from sbi.neural_nets.embedding_nets import CNNEmbedding
from sbi.neural_nets.estimators.shape_handling import (
reshape_to_sample_batch_event,
)
from sbi.neural_nets.net_builders import (
build_categoricalmassestimator,
build_maf,
build_maf_rqs,
build_mdn,
build_mlp_flowmatcher,
build_mnle,
build_nsf,
build_resnet_flowmatcher,
build_zuko_bpf,
build_zuko_gf,
build_zuko_maf,
build_zuko_naf,
build_zuko_ncsf,
build_zuko_nice,
build_zuko_nsf,
build_zuko_sospf,
build_zuko_unaf,
)
# List of all density estimator builders for testing.
model_builders = [
build_mdn,
build_maf,
build_maf_rqs,
build_nsf,
build_zuko_bpf,
build_zuko_gf,
build_zuko_maf,
build_zuko_naf,
build_zuko_ncsf,
build_zuko_nice,
build_zuko_nsf,
build_zuko_sospf,
build_zuko_unaf,
]
flowmatching_build_functions = [
build_mlp_flowmatcher,
build_resnet_flowmatcher,
]
def get_batch_input(nsamples: int, input_dims: int) -> torch.Tensor:
r"""Generate a batch of input samples from a multivariate normal distribution.
Args:
nsamples (int): The number of samples to generate.
input_dims (int): The dimensionality of the input samples.
Returns:
torch.Tensor: A tensor of shape (nsamples, input_dims)
containing the generated samples.
"""
input_mvn = MultivariateNormal(
loc=zeros(input_dims), covariance_matrix=eye(input_dims)
)
return input_mvn.sample((nsamples,))
def get_batch_context(nsamples: int, condition_shape: tuple[int, ...]) -> torch.Tensor:
r"""Generate a batch of context samples from a multivariate normal distribution.
Args:
nsamples (int): The number of context samples to generate.
condition_shape (tuple[int, ...]): The shape of the condition for each sample.
Returns:
torch.Tensor: A tensor containing the generated context samples.
"""
context_mvn = MultivariateNormal(
loc=zeros(*condition_shape), covariance_matrix=eye(condition_shape[-1])
)
return context_mvn.sample((nsamples,))
@pytest.mark.parametrize(
"theta_or_x_shape, target_shape, event_shape, leading_is_sample",
(
((3,), (1, 1, 3), (3,), False),
((3,), (1, 1, 3), (3,), True),
((1, 3), (1, 1, 3), (3,), False),
((1, 3), (1, 1, 3), (3,), True),
((2, 3), (1, 2, 3), (3,), False),
((2, 3), (2, 1, 3), (3,), True),
((1, 2, 3), (1, 2, 3), (3,), True),
((1, 2, 3), (2, 1, 3), (3,), False),
((3, 5), (1, 1, 3, 5), (3, 5), False),
((3, 5), (1, 1, 3, 5), (3, 5), True),
((1, 3, 5), (1, 1, 3, 5), (3, 5), False),
((1, 3, 5), (1, 1, 3, 5), (3, 5), True),
((2, 3, 5), (1, 2, 3, 5), (3, 5), False),
((2, 3, 5), (2, 1, 3, 5), (3, 5), True),
((1, 2, 3, 5), (1, 2, 3, 5), (3, 5), True),
((1, 2, 3, 5), (2, 1, 3, 5), (3, 5), False),
pytest.param((1, 2, 3, 5), (1, 2, 3, 5), (5), False, marks=pytest.mark.xfail),
pytest.param((1, 2, 3, 5), (1, 2, 3, 5), (3), False, marks=pytest.mark.xfail),
pytest.param((1, 2, 3), (1, 2, 3), (1, 5), False, marks=pytest.mark.xfail),
pytest.param((1, 2, 3), (1, 2, 3), (1, 3), False, marks=pytest.mark.xfail),
pytest.param((1, 2, 3), (2, 1, 3), (3), False, marks=pytest.mark.xfail),
pytest.param((1, 2, 3), (2, 1, 3), (3), True, marks=pytest.mark.xfail),
),
)
def test_shape_handling_utility_for_density_estimator(
theta_or_x_shape: Tuple,
target_shape: Tuple,
event_shape: Tuple,
leading_is_sample: bool,
):
"""Test whether `reshape_to_batch_sample_event` results in expected outputs."""
input = torch.randn(theta_or_x_shape)
output = reshape_to_sample_batch_event(
input, event_shape=event_shape, leading_is_sample=leading_is_sample
)
assert output.shape == target_shape, (
f"Shapes of Output ({output.shape}) and target shape ({target_shape}) do not "
f"match."
)
@pytest.mark.parametrize(
"density_estimator_build_fn", model_builders + flowmatching_build_functions
)
@pytest.mark.parametrize("input_sample_dim", (1, 2))
@pytest.mark.parametrize("input_event_shape", ((1,), (4,)))
@pytest.mark.parametrize("condition_event_shape", ((1,), (7,)))
@pytest.mark.parametrize("batch_dim", (1, 10))
def test_density_estimator_loss_shapes(
density_estimator_build_fn,
input_sample_dim,
input_event_shape,
condition_event_shape,
batch_dim,
):
"""Test whether `loss` of DensityEstimators follow the shape convention."""
density_estimator, inputs, conditions, _ = _build_density_estimator_and_tensors(
density_estimator_build_fn,
input_event_shape,
condition_event_shape,
batch_dim,
input_sample_dim,
)
losses = density_estimator.loss(inputs[0], condition=conditions)
assert losses.shape == (batch_dim,)
@pytest.mark.parametrize("density_estimator_build_fn", model_builders)
@pytest.mark.parametrize("input_sample_dim", (1, 2))
@pytest.mark.parametrize("input_event_shape", ((1,), (4,)))
# This mimics the shape of a 2D image and is used for testing CNN embeddings.
@pytest.mark.parametrize("condition_event_shape", ((2, 1), (2, 7), (7, 2), (7, 7)))
@pytest.mark.parametrize("batch_dim", (1, 10))
def test_density_estimator_log_prob_shapes_with_embedding(
density_estimator_build_fn,
input_sample_dim,
input_event_shape,
condition_event_shape,
batch_dim,
):
"""Test whether `loss` of DensityEstimators follow the shape convention."""
density_estimator, inputs, conditions, _ = _build_density_estimator_and_tensors(
density_estimator_build_fn,
input_event_shape,
condition_event_shape,
batch_dim,
input_sample_dim,
)
log_probs = density_estimator.log_prob(inputs, condition=conditions)
assert log_probs.shape == (input_sample_dim, batch_dim)
@pytest.mark.parametrize("density_estimator_build_fn", model_builders)
@pytest.mark.parametrize("sample_shape", ((), (1,), (2, 3)))
@pytest.mark.parametrize("input_event_shape", ((1,), (4,)))
@pytest.mark.parametrize("condition_event_shape", ((1,), (7,)))
@pytest.mark.parametrize("batch_dim", (1, 10))
def test_density_estimator_sample_shapes(
density_estimator_build_fn,
sample_shape,
input_event_shape,
condition_event_shape,
batch_dim,
):
"""Test whether `sample` of DensityEstimators follow the shape
convention."""
density_estimator, _, conditions, input_event_shape = (
_build_density_estimator_and_tensors(
density_estimator_build_fn,
input_event_shape,
condition_event_shape,
batch_dim,
)
)
samples = density_estimator.sample(sample_shape, condition=conditions)
if density_estimator_build_fn == build_categoricalmassestimator:
# Our categorical is always 1D and does not return `input_event_shape`.
input_event_shape = ()
assert samples.shape == (*sample_shape, batch_dim, *input_event_shape)
@pytest.mark.parametrize("density_estimator_build_fn", model_builders)
@pytest.mark.parametrize("input_event_shape", ((1,), (4,)))
@pytest.mark.parametrize("condition_event_shape", ((1,), (7,)))
@pytest.mark.parametrize("batch_dim", (1, 10))
def test_correctness_of_density_estimator_log_prob(
density_estimator_build_fn,
input_event_shape,
condition_event_shape,
batch_dim,
):
"""Test whether identical inputs lead to identical log_prob values."""
input_sample_dim = 2
density_estimator, inputs, condition, _ = _build_density_estimator_and_tensors(
density_estimator_build_fn,
input_event_shape,
condition_event_shape,
batch_dim,
input_sample_dim,
)
log_probs = density_estimator.log_prob(inputs, condition=condition)
assert torch.allclose(log_probs[0, :], log_probs[1, :], rtol=1e-4)
@pytest.mark.parametrize(
"density_estimator_build_fn", model_builders + flowmatching_build_functions
)
@pytest.mark.parametrize("input_event_shape", ((1,), (4,)))
@pytest.mark.parametrize("condition_event_shape", ((1,), (7,)))
@pytest.mark.parametrize("sample_shape", ((1000,), (500, 2)))
def test_correctness_of_batched_vs_seperate_sample_and_log_prob(
density_estimator_build_fn: Callable,
input_event_shape,
condition_event_shape,
sample_shape,
):
input_sample_dim = 2
batch_dim = 2
density_estimator, inputs, condition, input_event_shape = (
_build_density_estimator_and_tensors(
density_estimator_build_fn,
input_event_shape,
condition_event_shape,
batch_dim,
input_sample_dim,
)
)
# Batched vs separate sampling
samples = density_estimator.sample(sample_shape, condition=condition)
samples = samples.reshape(-1, batch_dim, *input_event_shape) # Flat for comp.
samples_separate1 = density_estimator.sample(
(1000,), condition=condition[0][None, ...]
)
samples_separate2 = density_estimator.sample(
(1000,), condition=condition[1][None, ...]
)
# Check if means are approx. same
samples_m = torch.mean(samples, dim=0, dtype=torch.float32)
samples_separate1_m = torch.mean(samples_separate1, dim=0, dtype=torch.float32)
samples_separate2_m = torch.mean(samples_separate2, dim=0, dtype=torch.float32)
samples_sep_m = torch.cat([samples_separate1_m, samples_separate2_m], dim=0)
assert torch.allclose(
samples_m, samples_sep_m, atol=0.5, rtol=0.5
), "Batched sampling is not consistent with separate sampling."
# Batched vs separate log_prob
log_probs = density_estimator.log_prob(inputs, condition=condition)
log_probs_separate1 = density_estimator.log_prob(
inputs[:, :1], condition=condition[0][None, ...]
)
log_probs_separate2 = density_estimator.log_prob(
inputs[:, 1:], condition=condition[1][None, ...]
)
log_probs_sep = torch.hstack([log_probs_separate1, log_probs_separate2])
assert torch.allclose(
log_probs, log_probs_sep, atol=1e-2, rtol=1e-2
), "Batched log_prob is not consistent with separate log_prob."
def _build_density_estimator_and_tensors(
density_estimator_build_fn: Callable,
input_event_shape: Tuple[int],
condition_event_shape: Tuple[int],
batch_dim: int,
input_sample_dim: int = 1,
):
"""Helper function for all tests that deal with shapes of density
estimators."""
# Use positive random values for continuous dims (log transform)
batch_input = torch.rand((1000, *input_event_shape), dtype=torch.float32) * 10.0
# make last dim discrete for mixed density estimators
batch_input[:, -1] = torch.randint(0, 4, (1000,))
batch_condition = torch.randn((1000, *condition_event_shape))
if len(condition_event_shape) > 1:
embedding_net = CNNEmbedding(condition_event_shape, kernel_size=1)
z_score_y = "structured"
else:
embedding_net = torch.nn.Identity()
z_score_y = "independent"
if density_estimator_build_fn in [build_mnle, build_categoricalmassestimator]:
density_estimator = density_estimator_build_fn(
batch_x=batch_input,
batch_y=batch_condition,
embedding_net=embedding_net,
z_score_y=z_score_y,
)
else:
density_estimator = density_estimator_build_fn(
torch.randn_like(batch_input),
torch.randn_like(batch_condition),
embedding_net=embedding_net,
z_score_y=z_score_y,
)
inputs = batch_input[:batch_dim]
condition = batch_condition[:batch_dim]
inputs = inputs.unsqueeze(0)
inputs = inputs.expand(input_sample_dim, -1, -1)
return density_estimator, inputs, condition, input_event_shape
# separate test cases for mixed density estimation
@pytest.mark.parametrize(
(
"density_estimator_build_fn",
"input_sample_dim",
"input_event_shape",
"condition_event_shape",
"batch_dim",
),
(
(build_mnle, 1, (2,), (7,), 1),
(build_mnle, 1, (2,), (7,), 10),
# Test with 2D condition with embedding net.
[build_mnle, 1, (2,), (7, 7), 10],
[build_mnle, 1, (2,), (2, 7), 10],
[build_mnle, 1, (2,), (7, 2), 10],
[build_categoricalmassestimator, 1, (1,), (7, 7), 10],
[build_categoricalmassestimator, 2, (1,), (7, 7), 10],
pytest.param(
build_mnle,
2,
(1,),
(7,),
10,
marks=pytest.mark.xfail(
reason="Sample dim > 1 not supported for Mixed Density Estimation"
),
),
pytest.param(
build_categoricalmassestimator,
1,
(4,),
(7,),
10,
marks=pytest.mark.xfail(
reason="Event shape > 1 not supported for categorical"
),
),
),
)
@pytest.mark.parametrize("sample_shape", ((10,), (1,)))
def test_mixed_density_estimator(
density_estimator_build_fn,
input_sample_dim,
input_event_shape,
condition_event_shape,
batch_dim,
sample_shape,
):
density_estimator, inputs, conditions, input_event_shape = (
_build_density_estimator_and_tensors(
density_estimator_build_fn,
input_event_shape,
condition_event_shape,
batch_dim,
input_sample_dim,
)
)
# Test losses
losses = density_estimator.loss(inputs[0], condition=conditions)
assert losses.shape == (batch_dim,)
# Test log_prob
log_probs = density_estimator.log_prob(inputs, condition=conditions)
assert log_probs.shape == (input_sample_dim, batch_dim)
# Test samples
samples = density_estimator.sample(sample_shape, condition=conditions)
if density_estimator_build_fn == build_categoricalmassestimator:
# Our categorical is always 1D and does not return `input_event_shape`.
input_event_shape = ()
assert samples.shape == (*sample_shape, batch_dim, *input_event_shape)
|
mackelabREPO_NAMEsbiPATH_START.@sbi_extracted@sbi-main@tests@density_estimator_test.py@.PATH_END.py
|
{
"filename": "test_values.py",
"repo_name": "pandas-dev/pandas",
"repo_path": "pandas_extracted/pandas-main/pandas/tests/series/methods/test_values.py",
"type": "Python"
}
|
import numpy as np
import pytest
from pandas import (
IntervalIndex,
Series,
period_range,
)
import pandas._testing as tm
class TestValues:
@pytest.mark.parametrize(
"data",
[
period_range("2000", periods=4),
IntervalIndex.from_breaks([1, 2, 3, 4]),
],
)
def test_values_object_extension_dtypes(self, data):
# https://github.com/pandas-dev/pandas/issues/23995
result = Series(data).values
expected = np.array(data.astype(object))
tm.assert_numpy_array_equal(result, expected)
def test_values(self, datetime_series):
tm.assert_almost_equal(
datetime_series.values, list(datetime_series), check_dtype=False
)
|
pandas-devREPO_NAMEpandasPATH_START.@pandas_extracted@pandas-main@pandas@tests@series@methods@test_values.py@.PATH_END.py
|
{
"filename": "test_correlation.py",
"repo_name": "astropy/specutils",
"repo_path": "specutils_extracted/specutils-main/specutils/tests/test_correlation.py",
"type": "Python"
}
|
import numpy as np
import astropy.units as u
from astropy import constants as const
from astropy.nddata import StdDevUncertainty
from astropy.modeling import models
from ..spectra.spectrum1d import Spectrum1D
from ..analysis import correlation
def test_autocorrelation():
"""
Test auto correlation
"""
size = 42
# Seed np.random so that results are consistent
np.random.seed(41)
# Create test spectra
spec_axis = np.linspace(5000., 5040., num=size) * u.AA
f1 = np.random.randn(size) * u.Jy
g1 = models.Gaussian1D(amplitude=30 * u.Jy, mean=5020 * u.AA, stddev=2 * u.AA)
flux1 = f1 + g1(spec_axis)
# Observed spectrum must have a rest wavelength value set in.
spec1 = Spectrum1D(spectral_axis=spec_axis,
flux=flux1,
uncertainty=StdDevUncertainty(np.random.sample(size), unit='Jy'),
velocity_convention='optical',
rest_value=5020.*u.AA)
spec2 = Spectrum1D(spectral_axis=spec_axis,
flux=flux1,
uncertainty=StdDevUncertainty(np.random.sample(size), unit='Jy'))
# Get result from correlation
corr, lag = correlation.template_correlate(spec1, spec2)
# Check units
assert corr.unit == u.dimensionless_unscaled
assert lag.unit == u.km / u.s
# Check that lags are symmetrical
midpoint = int(len(lag) / 2)
np.testing.assert_almost_equal(lag[midpoint+1].value, (-(lag[midpoint-1])).value, 2)
# Check position of correlation peak.
maximum = np.argmax(corr)
assert maximum == midpoint
# Test that this works without uncertainty
spec1 = Spectrum1D(spectral_axis=spec_axis,
flux=flux1,
velocity_convention='optical',
rest_value=5020.*u.AA)
corr, lag = correlation.template_correlate(spec1, spec2)
assert corr.unit == u.dimensionless_unscaled
assert lag.unit == u.km / u.s
def test_correlation():
"""
Test correlation when both observed and template spectra have the same wavelength axis
"""
size = 4000
# Seed np.random so that results are consistent
np.random.seed(51)
# Create test spectra
spec_axis = np.linspace(4001., 8000., num=size) * u.AA
# Two narrow Gaussians are offset from each other so
# as to generate a correlation peak at a expected lag.
f1 = np.random.randn(size)*0.5 * u.Jy
f2 = np.random.randn(size)*0.5 * u.Jy
expected_lag = 10000. * u.km/u.s
mean2 = 5000. * u.AA
stdev2 = 30. * u.AA
mean1 = (1 + expected_lag / const.c.to('km/s')) * mean2
stdev1 = (1 + expected_lag / const.c.to('km/s')) * stdev2
rest_value = mean2
g1 = models.Gaussian1D(amplitude=30 * u.Jy, mean=mean1, stddev=stdev1)
g2 = models.Gaussian1D(amplitude=30 * u.Jy, mean=mean2, stddev=stdev2)
flux1 = f1 + g1(spec_axis)
flux2 = f2 + g2(spec_axis)
# Observed spectrum must have a rest wavelength value set in.
spec1 = Spectrum1D(spectral_axis=spec_axis,
flux=flux1,
uncertainty=StdDevUncertainty(np.random.sample(size), unit='Jy'),
velocity_convention='optical',
rest_value=rest_value)
spec2 = Spectrum1D(spectral_axis=spec_axis,
flux=flux2,
uncertainty=StdDevUncertainty(np.random.sample(size), unit='Jy'))
# Get result from correlation
corr, lag = correlation.template_correlate(spec1, spec2)
# Check units
assert corr.unit == u.dimensionless_unscaled
assert lag.unit == u.km / u.s
# Check position of correlation peak.
maximum = np.argmax(corr)
v_fit = _fit_peak(corr, lag, maximum)
# checks against 1.5 * 10**(-decimal)
np.testing.assert_almost_equal(v_fit.value, expected_lag.value, -1)
def _create_arrays(size1, size2):
spec_axis_1 = np.linspace(6050., 6100., num=size1) * u.AA
spec_axis_2 = np.linspace(6000., 6100., num=size2) * u.AA
# Create continuum-subtracted flux arrays with noise.
f1 = np.random.randn(size1) * u.Jy
f2 = np.random.randn(size2) * u.Jy
# Two narrow Gaussians are offset from each other so
# as to generate a correlation peak at a expected lag.
expected_lag = 1000. * u.km/u.s
mean2 = 6050. * u.AA
stdev2 = 5. * u.AA
mean1 = (1 + expected_lag / const.c.to('km/s')) * mean2
stdev1 = (1 + expected_lag / const.c.to('km/s')) * stdev2
rest_value = mean2
g1 = models.Gaussian1D(amplitude=50 * u.Jy, mean=mean1, stddev=stdev1)
g2 = models.Gaussian1D(amplitude=50 * u.Jy, mean=mean2, stddev=stdev2)
flux1 = f1 + g1(spec_axis_1)
flux2 = f2 + g2(spec_axis_2)
return spec_axis_1, spec_axis_2, flux1, flux2, expected_lag, rest_value
def _fit_peak(corr, lag, index_peak):
# Parabolic fit to maximum
n = 3 # points to the left and right of correlation maximum
peak_lags = lag[index_peak - n:index_peak + n + 1].value
peak_vals = corr[index_peak - n:index_peak + n + 1].value
p = np.polyfit(peak_lags, peak_vals, deg=2)
roots = np.roots(p)
return np.mean(roots) * u.km / u.s # maximum lies at mid point between roots
def test_correlation_zero_padding():
"""
Test correlation when observed and template spectra have different sizes
"""
size1 = 51
size2 = 101
# Seed np.random so that results are consistent
np.random.seed(41)
# Create test spectra
spec_axis_1, spec_axis_2, flux1, flux2, expected_lag, rest_value = _create_arrays(size1, size2)
# Observed spectrum must have a rest wavelength value set in.
# Uncertainty is arbitrary.
spec1 = Spectrum1D(spectral_axis=spec_axis_1,
flux=flux1,
uncertainty=StdDevUncertainty(np.random.sample(size1), unit='Jy'),
velocity_convention='optical',
rest_value=rest_value)
spec2 = Spectrum1D(spectral_axis=spec_axis_2,
flux=flux2,
uncertainty=StdDevUncertainty(np.random.sample(size2), unit='Jy'))
# Get result from correlation
corr, lag = correlation.template_correlate(spec1, spec2)
# Check units
assert corr.unit == u.dimensionless_unscaled
assert lag.unit == u.km / u.s
# Check that lags are symmetrical
midpoint = int(len(lag) / 2)
np.testing.assert_almost_equal(lag[midpoint+1].value, (-(lag[midpoint-1])).value, 2)
# Check position of correlation peak.
maximum = np.argmax(corr)
v_fit = _fit_peak(corr, lag, maximum)
# checks against 1.5 * 10**(-decimal)
np.testing.assert_almost_equal(v_fit.value, expected_lag.value, -1)
def test_correlation_random_lines():
"""
Test correlation when observed and template spectra have different sizes, and
there are non-correlated features in the observed and template spectra.
"""
size1 = 51
size2 = 101
# Seed np.random so that results are consistent
np.random.seed(41)
# Create test spectra
spec_axis_1, spec_axis_2, flux1, flux2, expected_lag, rest_value = _create_arrays(size1, size2)
# Add random lines to both spectra to simulate non-correlated spectral features.
#
# The more lines we add, and the larger amplitude they have, the larger the error in correlation
# peak position will be. In this specific case, increasing nlines by 1, or increasing the
# Gaussian amplitudes by a bit, is enough to make the correlation peak move off position.
#
# So we can say generically (as expected anyway) that the presence of non-correlated features
# in observed and template spectra generates an error in the correlation peak position, and
# that error will be larger as these non-correlated features become more predominant in the
# data.
nlines = 20
for i in range(nlines):
mean = (spec_axis_1[-1] - spec_axis_1[0]) * np.random.randn(size1) + spec_axis_1[0]
g1 = models.Gaussian1D(amplitude=10 * u.Jy, mean=mean, stddev=4 * u.AA)
flux1 += g1(spec_axis_1)
for i in range(nlines):
mean = (spec_axis_2[-1] - spec_axis_2[0]) * np.random.randn(size2) + spec_axis_2[0]
g2 = models.Gaussian1D(amplitude=5 * u.Jy, mean=mean, stddev=4 * u.AA)
flux2 += g2(spec_axis_2)
# Observed spectrum must have a rest wavelength value set in.
# Uncertainty is arbitrary.
spec1 = Spectrum1D(spectral_axis=spec_axis_1,
flux=flux1,
uncertainty=StdDevUncertainty(np.random.sample(size1), unit='Jy'),
velocity_convention='optical',
rest_value=rest_value)
spec2 = Spectrum1D(spectral_axis=spec_axis_2,
flux=flux2,
uncertainty=StdDevUncertainty(np.random.sample(size2), unit='Jy'))
# Get result from correlation
corr, lag = correlation.template_correlate(spec1, spec2)
# Check units
assert corr.unit == u.dimensionless_unscaled
assert lag.unit == u.km / u.s
# Check that lags are symmetrical
midpoint = int(len(lag) / 2)
np.testing.assert_almost_equal(lag[midpoint+1].value, (-(lag[midpoint-1])).value, 2)
# Check position of correlation peak.
maximum = np.argmax(corr)
v_fit = _fit_peak(corr, lag, maximum)
# checks against 1.5 * 10**(-decimal)
np.testing.assert_almost_equal(v_fit.value, expected_lag.value, -1)
|
astropyREPO_NAMEspecutilsPATH_START.@specutils_extracted@specutils-main@specutils@tests@test_correlation.py@.PATH_END.py
|
{
"filename": "convnext.py",
"repo_name": "keras-team/keras",
"repo_path": "keras_extracted/keras-master/keras/src/applications/convnext.py",
"type": "Python"
}
|
import numpy as np
from keras.src import backend
from keras.src import initializers
from keras.src import layers
from keras.src import ops
from keras.src import random
from keras.src.api_export import keras_export
from keras.src.applications import imagenet_utils
from keras.src.layers.layer import Layer
from keras.src.models import Functional
from keras.src.models import Sequential
from keras.src.ops import operation_utils
from keras.src.utils import file_utils
BASE_WEIGHTS_PATH = (
"https://storage.googleapis.com/tensorflow/keras-applications/convnext/"
)
WEIGHTS_HASHES = {
"convnext_tiny": (
"8ae6e78ce2933352b1ef4008e6dd2f17bc40771563877d156bc6426c7cf503ff",
"d547c096cabd03329d7be5562c5e14798aa39ed24b474157cef5e85ab9e49ef1",
),
"convnext_small": (
"ce1277d8f1ee5a0ef0e171469089c18f5233860ceaf9b168049cb9263fd7483c",
"6fc8009faa2f00c1c1dfce59feea9b0745eb260a7dd11bee65c8e20843da6eab",
),
"convnext_base": (
"52cbb006d3dadd03f6e095a8ca1aca47aecdd75acb4bc74bce1f5c695d0086e6",
"40a20c5548a5e9202f69735ecc06c990e6b7c9d2de39f0361e27baeb24cb7c45",
),
"convnext_large": (
"070c5ed9ed289581e477741d3b34beffa920db8cf590899d6d2c67fba2a198a6",
"96f02b6f0753d4f543261bc9d09bed650f24dd6bc02ddde3066135b63d23a1cd",
),
"convnext_xlarge": (
"c1f5ccab661354fc3a79a10fa99af82f0fbf10ec65cb894a3ae0815f17a889ee",
"de3f8a54174130e0cecdc71583354753d557fcf1f4487331558e2a16ba0cfe05",
),
}
MODEL_CONFIGS = {
"tiny": {
"depths": [3, 3, 9, 3],
"projection_dims": [96, 192, 384, 768],
"default_size": 224,
},
"small": {
"depths": [3, 3, 27, 3],
"projection_dims": [96, 192, 384, 768],
"default_size": 224,
},
"base": {
"depths": [3, 3, 27, 3],
"projection_dims": [128, 256, 512, 1024],
"default_size": 224,
},
"large": {
"depths": [3, 3, 27, 3],
"projection_dims": [192, 384, 768, 1536],
"default_size": 224,
},
"xlarge": {
"depths": [3, 3, 27, 3],
"projection_dims": [256, 512, 1024, 2048],
"default_size": 224,
},
}
BASE_DOCSTRING = """Instantiates the {name} architecture.
References:
- [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545)
(CVPR 2022)
For image classification use cases, see
[this page for detailed examples](
https://keras.io/api/applications/#usage-examples-for-image-classification-models).
For transfer learning use cases, make sure to read the
[guide to transfer learning & fine-tuning](
https://keras.io/guides/transfer_learning/).
The `base`, `large`, and `xlarge` models were first pre-trained on the
ImageNet-21k dataset and then fine-tuned on the ImageNet-1k dataset. The
pre-trained parameters of the models were assembled from the
[official repository](https://github.com/facebookresearch/ConvNeXt). To get a
sense of how these parameters were converted to Keras compatible parameters,
please refer to
[this repository](https://github.com/sayakpaul/keras-convnext-conversion).
Note: Each Keras Application expects a specific kind of input preprocessing.
For ConvNeXt, preprocessing is included in the model using a `Normalization`
layer. ConvNeXt models expect their inputs to be float or uint8 tensors of
pixels with values in the [0-255] range.
When calling the `summary()` method after instantiating a ConvNeXt model,
prefer setting the `expand_nested` argument `summary()` to `True` to better
investigate the instantiated model.
Args:
include_top: Whether to include the fully-connected
layer at the top of the network. Defaults to `True`.
weights: One of `None` (random initialization),
`"imagenet"` (pre-training on ImageNet-1k), or the path to the weights
file to be loaded. Defaults to `"imagenet"`.
input_tensor: Optional Keras tensor
(i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: Optional shape tuple, only to be specified
if `include_top` is `False`.
It should have exactly 3 inputs channels.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`. Defaults to None.
- `None` means that the output of the model will be
the 4D tensor output of the last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: Optional number of classes to classify images
into, only to be specified if `include_top` is `True`, and
if no `weights` argument is specified. Defaults to 1000 (number of
ImageNet classes).
classifier_activation: A `str` or callable. The activation function to use
on the "top" layer. Ignored unless `include_top=True`. Set
`classifier_activation=None` to return the logits of the "top" layer.
Defaults to `"softmax"`.
When loading pretrained weights, `classifier_activation` can only
be `None` or `"softmax"`.
name: The name of the model (string).
Returns:
A model instance.
"""
class StochasticDepth(Layer):
"""Stochastic Depth module.
It performs batch-wise dropping rather than sample-wise. In libraries like
`timm`, it's similar to `DropPath` layers that drops residual paths
sample-wise.
References:
- https://github.com/rwightman/pytorch-image-models
Args:
drop_path_rate (float): Probability of dropping paths. Should be within
[0, 1].
Returns:
Tensor either with the residual path dropped or kept.
"""
def __init__(self, drop_path_rate, **kwargs):
super().__init__(**kwargs)
self.drop_path_rate = drop_path_rate
def call(self, x, training=None):
if training:
keep_prob = 1 - self.drop_path_rate
shape = (ops.shape(x)[0],) + (1,) * (len(ops.shape(x)) - 1)
random_tensor = keep_prob + random.uniform(shape, 0, 1)
random_tensor = ops.floor(random_tensor)
return (x / keep_prob) * random_tensor
return x
def get_config(self):
config = super().get_config()
config.update({"drop_path_rate": self.drop_path_rate})
return config
class LayerScale(Layer):
"""Layer scale module.
References:
- https://arxiv.org/abs/2103.17239
Args:
init_values (float): Initial value for layer scale. Should be within
[0, 1].
projection_dim (int): Projection dimensionality.
Returns:
Tensor multiplied to the scale.
"""
def __init__(self, init_values, projection_dim, **kwargs):
super().__init__(**kwargs)
self.init_values = init_values
self.projection_dim = projection_dim
def build(self, _):
self.gamma = self.add_weight(
shape=(self.projection_dim,),
initializer=initializers.Constant(self.init_values),
trainable=True,
)
def call(self, x):
return x * self.gamma
def get_config(self):
config = super().get_config()
config.update(
{
"init_values": self.init_values,
"projection_dim": self.projection_dim,
}
)
return config
def ConvNeXtBlock(
projection_dim, drop_path_rate=0.0, layer_scale_init_value=1e-6, name=None
):
"""ConvNeXt block.
References:
- https://arxiv.org/abs/2201.03545
- https://github.com/facebookresearch/ConvNeXt/blob/main/models/convnext.py
Notes:
In the original ConvNeXt implementation (linked above), the authors use
`Dense` layers for pointwise convolutions for increased efficiency.
Following that, this implementation also uses the same.
Args:
projection_dim (int): Number of filters for convolution layers. In the
ConvNeXt paper, this is referred to as projection dimension.
drop_path_rate (float): Probability of dropping paths. Should be within
[0, 1].
layer_scale_init_value (float): Layer scale value.
Should be a small float number.
name: name to path to the keras layer.
Returns:
A function representing a ConvNeXtBlock block.
"""
if name is None:
name = "prestem" + str(backend.get_uid("prestem"))
def apply(inputs):
x = inputs
x = layers.Conv2D(
filters=projection_dim,
kernel_size=7,
padding="same",
groups=projection_dim,
name=name + "_depthwise_conv",
)(x)
x = layers.LayerNormalization(epsilon=1e-6, name=name + "_layernorm")(x)
x = layers.Dense(4 * projection_dim, name=name + "_pointwise_conv_1")(x)
x = layers.Activation("gelu", name=name + "_gelu")(x)
x = layers.Dense(projection_dim, name=name + "_pointwise_conv_2")(x)
if layer_scale_init_value is not None:
x = LayerScale(
layer_scale_init_value,
projection_dim,
name=name + "_layer_scale",
)(x)
if drop_path_rate:
layer = StochasticDepth(
drop_path_rate, name=name + "_stochastic_depth"
)
else:
layer = layers.Activation("linear", name=name + "_identity")
return inputs + layer(x)
return apply
def PreStem(name=None):
"""Normalizes inputs with ImageNet-1k mean and std."""
if name is None:
name = "prestem" + str(backend.get_uid("prestem"))
def apply(x):
x = layers.Normalization(
mean=[0.485 * 255, 0.456 * 255, 0.406 * 255],
variance=[
(0.229 * 255) ** 2,
(0.224 * 255) ** 2,
(0.225 * 255) ** 2,
],
name=name + "_prestem_normalization",
)(x)
return x
return apply
def Head(num_classes=1000, classifier_activation=None, name=None):
"""Implementation of classification head of ConvNeXt.
Args:
num_classes: number of classes for Dense layer
classifier_activation: activation function for the Dense layer
name: name prefix
Returns:
Classification head function.
"""
if name is None:
name = str(backend.get_uid("head"))
def apply(x):
x = layers.GlobalAveragePooling2D(name=name + "_head_gap")(x)
x = layers.LayerNormalization(
epsilon=1e-6, name=name + "_head_layernorm"
)(x)
x = layers.Dense(
num_classes,
activation=classifier_activation,
name=name + "_head_dense",
)(x)
return x
return apply
def ConvNeXt(
depths,
projection_dims,
drop_path_rate=0.0,
layer_scale_init_value=1e-6,
default_size=224,
name="convnext",
include_preprocessing=True,
include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
weights_name=None,
):
"""Instantiates ConvNeXt architecture given specific configuration.
Args:
depths: An iterable containing depths for each individual stages.
projection_dims: An iterable containing output number of channels of
each individual stages.
drop_path_rate: Stochastic depth probability. If 0.0, then stochastic
depth won't be used.
layer_scale_init_value: Layer scale coefficient. If 0.0, layer scaling
won't be used.
default_size: Default input image size.
name: An optional name for the model.
include_preprocessing: boolean denoting whether to
include preprocessing in the model.
When `weights="imagenet"` this should always be `True`.
But for other models (e.g., randomly initialized) you should set it
to `False` and apply preprocessing to data accordingly.
include_top: Boolean denoting whether to include classification
head to the model.
weights: one of `None` (random initialization), `"imagenet"`
(pre-training on ImageNet-1k),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`) to
use as image input for the model.
input_shape: optional shape tuple, only to be specified if `include_top`
is `False`. It should have exactly 3 inputs channels.
pooling: optional pooling mode for feature extraction when `include_top`
is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the last convolutional layer.
- `avg` means that global average pooling will be applied
to the output of the last convolutional layer,
and thus the output of the model will be a 2D tensor.
- `max` means that global max pooling will be applied.
classes: optional number of classes to classify images into,
only to be specified if `include_top` is `True`,
and if no `weights` argument is specified.
classifier_activation: A `str` or callable.
The activation function to use
on the "top" layer. Ignored unless `include_top=True`.
Set `classifier_activation=None` to return the logits
of the "top" layer.
Returns:
A model instance.
"""
if backend.image_data_format() == "channels_first":
raise ValueError(
"ConvNeXt does not support the `channels_first` image data "
"format. Switch to `channels_last` by editing your local "
"config file at ~/.keras/keras.json"
)
if not (weights in {"imagenet", None} or file_utils.exists(weights)):
raise ValueError(
"The `weights` argument should be either "
"`None` (random initialization), `imagenet` "
"(pre-training on ImageNet), "
"or the path to the weights file to be loaded."
)
if weights == "imagenet" and include_top and classes != 1000:
raise ValueError(
'If using `weights="imagenet"` with `include_top=True`, '
"`classes` should be 1000. "
f"Received classes={classes}"
)
# Determine proper input shape.
input_shape = imagenet_utils.obtain_input_shape(
input_shape,
default_size=default_size,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights,
)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if input_tensor is not None:
inputs = operation_utils.get_source_inputs(input_tensor)[0]
else:
inputs = img_input
x = inputs
if include_preprocessing:
channel_axis = (
3 if backend.image_data_format() == "channels_last" else 1
)
num_channels = input_shape[channel_axis - 1]
if num_channels == 3:
x = PreStem(name=name)(x)
# Stem block.
stem = Sequential(
[
layers.Conv2D(
projection_dims[0],
kernel_size=4,
strides=4,
name=name + "_stem_conv",
),
layers.LayerNormalization(
epsilon=1e-6, name=name + "_stem_layernorm"
),
],
name=name + "_stem",
)
# Downsampling blocks.
downsample_layers = []
downsample_layers.append(stem)
num_downsample_layers = 3
for i in range(num_downsample_layers):
downsample_layer = Sequential(
[
layers.LayerNormalization(
epsilon=1e-6,
name=name + "_downsampling_layernorm_" + str(i),
),
layers.Conv2D(
projection_dims[i + 1],
kernel_size=2,
strides=2,
name=name + "_downsampling_conv_" + str(i),
),
],
name=name + "_downsampling_block_" + str(i),
)
downsample_layers.append(downsample_layer)
# Stochastic depth schedule.
# This is referred from the original ConvNeXt codebase:
# https://github.com/facebookresearch/ConvNeXt/blob/main/models/convnext.py#L86
depth_drop_rates = [
float(x) for x in np.linspace(0.0, drop_path_rate, sum(depths))
]
# First apply downsampling blocks and then apply ConvNeXt stages.
cur = 0
num_convnext_blocks = 4
for i in range(num_convnext_blocks):
x = downsample_layers[i](x)
for j in range(depths[i]):
x = ConvNeXtBlock(
projection_dim=projection_dims[i],
drop_path_rate=depth_drop_rates[cur + j],
layer_scale_init_value=layer_scale_init_value,
name=name + f"_stage_{i}_block_{j}",
)(x)
cur += depths[i]
if include_top:
imagenet_utils.validate_activation(classifier_activation, weights)
x = Head(
num_classes=classes,
classifier_activation=classifier_activation,
name=name,
)(x)
else:
if pooling == "avg":
x = layers.GlobalAveragePooling2D()(x)
elif pooling == "max":
x = layers.GlobalMaxPooling2D()(x)
x = layers.LayerNormalization(epsilon=1e-6)(x)
model = Functional(inputs=inputs, outputs=x, name=name)
# Load weights.
if weights == "imagenet":
if include_top:
file_suffix = ".h5"
file_hash = WEIGHTS_HASHES[weights_name][0]
else:
file_suffix = "_notop.h5"
file_hash = WEIGHTS_HASHES[weights_name][1]
file_name = name + file_suffix
weights_path = file_utils.get_file(
file_name,
BASE_WEIGHTS_PATH + file_name,
cache_subdir="models",
file_hash=file_hash,
)
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
## Instantiating variants ##
@keras_export(
[
"keras.applications.convnext.ConvNeXtTiny",
"keras.applications.ConvNeXtTiny",
]
)
def ConvNeXtTiny(
include_top=True,
include_preprocessing=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
name="convnext_tiny",
):
return ConvNeXt(
weights_name="convnext_tiny",
depths=MODEL_CONFIGS["tiny"]["depths"],
projection_dims=MODEL_CONFIGS["tiny"]["projection_dims"],
drop_path_rate=0.0,
layer_scale_init_value=1e-6,
default_size=MODEL_CONFIGS["tiny"]["default_size"],
name=name,
include_top=include_top,
include_preprocessing=include_preprocessing,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
classifier_activation=classifier_activation,
)
@keras_export(
[
"keras.applications.convnext.ConvNeXtSmall",
"keras.applications.ConvNeXtSmall",
]
)
def ConvNeXtSmall(
include_top=True,
include_preprocessing=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
name="convnext_small",
):
return ConvNeXt(
weights_name="convnext_small",
depths=MODEL_CONFIGS["small"]["depths"],
projection_dims=MODEL_CONFIGS["small"]["projection_dims"],
drop_path_rate=0.0,
layer_scale_init_value=1e-6,
default_size=MODEL_CONFIGS["small"]["default_size"],
name=name,
include_top=include_top,
include_preprocessing=include_preprocessing,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
classifier_activation=classifier_activation,
)
@keras_export(
[
"keras.applications.convnext.ConvNeXtBase",
"keras.applications.ConvNeXtBase",
]
)
def ConvNeXtBase(
include_top=True,
include_preprocessing=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
name="convnext_base",
):
return ConvNeXt(
weights_name="convnext_base",
depths=MODEL_CONFIGS["base"]["depths"],
projection_dims=MODEL_CONFIGS["base"]["projection_dims"],
drop_path_rate=0.0,
layer_scale_init_value=1e-6,
default_size=MODEL_CONFIGS["base"]["default_size"],
name=name,
include_top=include_top,
include_preprocessing=include_preprocessing,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
classifier_activation=classifier_activation,
)
@keras_export(
[
"keras.applications.convnext.ConvNeXtLarge",
"keras.applications.ConvNeXtLarge",
]
)
def ConvNeXtLarge(
include_top=True,
include_preprocessing=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
name="convnext_large",
):
return ConvNeXt(
weights_name="convnext_large",
depths=MODEL_CONFIGS["large"]["depths"],
projection_dims=MODEL_CONFIGS["large"]["projection_dims"],
drop_path_rate=0.0,
layer_scale_init_value=1e-6,
default_size=MODEL_CONFIGS["large"]["default_size"],
name=name,
include_top=include_top,
include_preprocessing=include_preprocessing,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
classifier_activation=classifier_activation,
)
@keras_export(
[
"keras.applications.convnext.ConvNeXtXLarge",
"keras.applications.ConvNeXtXLarge",
]
)
def ConvNeXtXLarge(
include_top=True,
include_preprocessing=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
name="convnext_xlarge",
):
return ConvNeXt(
weights_name="convnext_xlarge",
depths=MODEL_CONFIGS["xlarge"]["depths"],
projection_dims=MODEL_CONFIGS["xlarge"]["projection_dims"],
drop_path_rate=0.0,
layer_scale_init_value=1e-6,
default_size=MODEL_CONFIGS["xlarge"]["default_size"],
name=name,
include_top=include_top,
include_preprocessing=include_preprocessing,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
classifier_activation=classifier_activation,
)
ConvNeXtTiny.__doc__ = BASE_DOCSTRING.format(name="ConvNeXtTiny")
ConvNeXtSmall.__doc__ = BASE_DOCSTRING.format(name="ConvNeXtSmall")
ConvNeXtBase.__doc__ = BASE_DOCSTRING.format(name="ConvNeXtBase")
ConvNeXtLarge.__doc__ = BASE_DOCSTRING.format(name="ConvNeXtLarge")
ConvNeXtXLarge.__doc__ = BASE_DOCSTRING.format(name="ConvNeXtXLarge")
@keras_export("keras.applications.convnext.preprocess_input")
def preprocess_input(x, data_format=None):
"""A placeholder method for backward compatibility.
The preprocessing logic has been included in the convnext model
implementation. Users are no longer required to call this method to
normalize the input data. This method does nothing and only kept as a
placeholder to align the API surface between old and new version of model.
Args:
x: A floating point `numpy.array` or a tensor.
data_format: Optional data format of the image tensor/array. Defaults to
None, in which case the global setting
`keras.backend.image_data_format()` is used
(unless you changed it, it defaults to `"channels_last"`).{mode}
Returns:
Unchanged `numpy.array` or tensor.
"""
return x
@keras_export("keras.applications.convnext.decode_predictions")
def decode_predictions(preds, top=5):
return imagenet_utils.decode_predictions(preds, top=top)
decode_predictions.__doc__ = imagenet_utils.decode_predictions.__doc__
|
keras-teamREPO_NAMEkerasPATH_START.@keras_extracted@keras-master@keras@src@applications@convnext.py@.PATH_END.py
|
{
"filename": "test_act.py",
"repo_name": "dylancromer/maszcal",
"repo_path": "maszcal_extracted/maszcal-main/maszcal/data/test/test_act.py",
"type": "Python"
}
|
import numpy as np
import maszcal.cosmology
from maszcal.data.templates import StackedWeakLensingData
class ActTestData(StackedWeakLensingData):
def __init__(self, data_dir='data/test-act/'):
self.cosmology = self._init_cosmology()
thetas, wl_signals, zs, masses = self._load_data(data_dir)
super().__init__(
radial_coordinates=thetas,
redshifts=zs,
stacked_wl_signal=wl_signals,
masses=masses,
)
def _init_cosmology(self):
return maszcal.cosmology.CosmoParams()
def _load_data(self, data_dir):
redshifts, masses = self._get_redshifts_and_masses(data_dir)
thetas = self._get_thetas(data_dir)
kappas = self._get_kappas(data_dir)
return thetas, kappas, redshifts, masses
def _get_redshifts_and_masses(self, data_dir):
bin_0 = np.loadtxt(data_dir + '0ycbin050.txt')
bin_1 = np.loadtxt(data_dir + '1ycbin050075.txt')
bin_2 = np.loadtxt(data_dir + '2ycbin075100.txt')
bin_3 = np.loadtxt(data_dir + '3ycbin100.txt')
#zs, ms = np.concatenate((bin_0, bin_1, bin_2, bin_3), axis=0).T
zs, ms = bin_2.T
return zs, 1e14*ms
def _get_thetas(self, data_dir):
return np.load(data_dir + 'test-act_thetas.npy')
def _get_kappas(self, data_dir):
return np.load(data_dir + 'test-act_filtered-kappas.npy')
|
dylancromerREPO_NAMEmaszcalPATH_START.@maszcal_extracted@maszcal-main@maszcal@data@test@test_act.py@.PATH_END.py
|
{
"filename": "collective_test.py",
"repo_name": "tensorflow/tensorflow",
"repo_path": "tensorflow_extracted/tensorflow-master/tensorflow/dtensor/python/tests/collective_test.py",
"type": "Python"
}
|
# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for DTensor collectives."""
import os
from absl.testing import parameterized
import numpy as np
# pylint: disable=g-direct-tensorflow-import
from tensorflow.dtensor.python import api
from tensorflow.dtensor.python import config
from tensorflow.dtensor.python import d_variable
from tensorflow.dtensor.python import dtensor_device
from tensorflow.dtensor.python import layout as layout_lib
from tensorflow.dtensor.python.tests import test_backend_util
from tensorflow.dtensor.python.tests import test_util
from tensorflow.python.eager.polymorphic_function import polymorphic_function
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gen_array_ops
from tensorflow.python.ops import gen_math_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.platform import test
# pylint: enable=g-direct-tensorflow-import
Layout = layout_lib.Layout
_MESH_DIM_X = 'x'
_MESH_DIM_Y = 'y'
_MESH_DIMS = [_MESH_DIM_X, _MESH_DIM_Y]
class CollectiveTest(test_util.DTensorBaseTest):
def setUp(self):
super(CollectiveTest, self).setUp()
global_ids = test_util.create_device_ids_array((2, 1))
local_ids = np.ravel(global_ids).tolist()
mesh_dict = {
device: layout_lib.Mesh(_MESH_DIMS, global_ids, local_ids,
test_util.create_device_list((2, 1), device))
for device in ('CPU', 'GPU', 'TPU')
}
self.mesh = self.configTestMesh(mesh_dict)
self.fully_replicated_layout_2d = Layout.replicated(self.mesh, rank=2)
self.first_dimension_sharded_layout_2d = Layout.batch_sharded(
self.mesh, _MESH_DIM_X, 2)
self.scalar_layout = Layout.replicated(self.mesh, rank=0)
def testReduceOnBfloat16(self):
self.skipForDeviceType(['GPU'],
'GPUs do not support bfloat16 collective reduce')
self.skipForDeviceType(['TPU'],
'This test only needs to run on 2 cores.',
unless_device_count_equals_to=2)
a = constant_op.constant(
np.array([[1, 2, 3, 4], [5.0, 6.0, 7.0, 8.0]]), dtype=dtypes.bfloat16)
expected_result = math_ops.reduce_sum(a)
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
dtensor_result = math_ops.reduce_sum(sharded_a)
self.assertDTensorEqual(expected_result, self.scalar_layout, dtensor_result)
def testReduceOnInt32(self):
a = constant_op.constant(
np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), dtype=dtypes.int32)
expected_result = math_ops.reduce_sum(a)
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
dtensor_result = math_ops.reduce_sum(sharded_a)
self.assertDTensorEqual(expected_result, self.scalar_layout, dtensor_result)
def testReduceOnInt8(self):
a = constant_op.constant(
np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), dtype=dtypes.int8
)
expected_result = math_ops.reduce_sum(a)
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
dtensor_result = math_ops.reduce_sum(sharded_a)
self.assertDTensorEqual(expected_result, self.scalar_layout, dtensor_result)
def testTwoReducesWithAssign(self):
self.skipForPathways('TODO(b/260775095)')
# FIXME(b/238384852): The purpose of this test is to validate the control
# dependency added by DTensor.
# However, as we have no way of testing the per-device graph
# produced by the DTensor SPMD expansion, we have to use manual logging
# to verify if the results are correct.
# For example, this test is used to check cl/459358521.
# Uses dtypes.float32 to avoid int32 problem with VarHandleOp on GPUs.
a = constant_op.constant(
np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), dtype=dtypes.float32)
b = constant_op.constant(
np.array([[11, 12, 13, 4], [15, 16, 17, 18]]), dtype=dtypes.float32)
expected_result = math_ops.reduce_sum(a) * math_ops.reduce_sum(b)
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
sharded_b = api.relayout(b, self.first_dimension_sharded_layout_2d)
sharded_v = d_variable.DVariable(sharded_b)
@polymorphic_function.function
def func(a, b):
a1 = math_ops.reduce_sum(a, name='reducea')
sharded_v.assign(a)
b1 = math_ops.reduce_sum(b, name='reduceb')
return a1 * b1
with api.default_mesh(self.mesh):
dtensor_result = func(sharded_a, sharded_b)
self.assertDTensorEqual(expected_result, self.scalar_layout, dtensor_result)
@parameterized.named_parameters(
('_all', math_ops.reduce_all),
('_any', math_ops.reduce_any),
)
def testReduceOnBool(self, reduction):
# TODO(b/193531363): Track the work to support int32 reduce.
self.skipForDeviceType(['GPU'],
'GPUs do not support int32 collective reduce')
self.skipForDeviceType(['TPU'],
'This test only needs to run on 2 cores.',
unless_device_count_equals_to=2)
a = constant_op.constant(
np.array([[True, False, False, True], [False, False, False, True]]),
dtype=dtypes.bool)
expected_result = reduction(a)
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
dtensor_result = reduction(sharded_a)
self.assertDTensorEqual(expected_result, self.scalar_layout, dtensor_result)
def testAllToAllOnBool(self):
# TODO(b/193531363): Track the work to support int32 reduce.
self.skipForDeviceType(['GPU'],
'GPUs do not support int32 collective reduce')
self.skipForDeviceType(['TPU'],
'This test only needs to run on 2 cores.',
unless_device_count_equals_to=2)
a = constant_op.constant(
np.array([[True, False, False, True], [False, False, False, True]]),
dtype=dtypes.bool)
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
unsharded_a = api.relayout(sharded_a, self.fully_replicated_layout_2d)
self.assertDTensorEqual(a, self.fully_replicated_layout_2d, unsharded_a)
def testAllToAllOnInt32(self):
# TODO(b/193471732): Tracking the work to do int32 all-concat.
#
# Currently, the test will fail with segfault.
self.skipForDeviceType(['GPU'],
'GPUs do not support int32 StridedSliceXXX Ops')
self.skipForDeviceType(['TPU'],
'This test only needs to run on 2 cores.',
unless_device_count_equals_to=2)
a = constant_op.constant(np.array([[1, 2], [3, 4]]), dtype=dtypes.int32)
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
unsharded_a = api.relayout(sharded_a, self.fully_replicated_layout_2d)
self.assertDTensorEqual(a, self.fully_replicated_layout_2d, unsharded_a)
def testCollectiveOpsOnComplex64(self):
# This functions tests for AllScatter, AllGather, and AllReduce.
a = constant_op.constant(
np.array([[1, 2 + 2j], [3 + 1j, 4 + 5j]]), dtype=dtypes.complex64
)
# Tests AllScatter
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
# Tests AllGather / AllReduce
unsharded_a = api.relayout(sharded_a, self.fully_replicated_layout_2d)
self.assertDTensorEqual(a, self.fully_replicated_layout_2d, unsharded_a)
def testCollectiveOpsOnComplex128(self):
# This function tests for AllScattering, AllReduce, and AllToAll.
self.skipForDeviceType(['TPU'], 'TPU does not support comolex128')
expected_layout = Layout.inner_sharded(self.mesh, 'x', rank=2)
initial_layout = Layout.batch_sharded(self.mesh, 'x', rank=2)
a = constant_op.constant(
np.array([[1, 2 + 2j], [3 + 1j, 4 + 5j]]), dtype=dtypes.complex128)
# Tests AllScatter
sharded_a_initial = api.relayout(a, initial_layout)
# Tests AllToAll / AllReduce
sharded_a = api.relayout(sharded_a_initial, expected_layout)
api.check_layout(sharded_a, expected_layout)
def testNoOpAllToAll(self):
self.skipForDeviceType(['TPU'],
'This test only needs to run on 2 cores.',
unless_device_count_equals_to=2)
a = constant_op.constant(
np.array([[1., 2., 3., 4.], [5.0, 6.0, 7.0, 8.0]]),
dtype=dtypes.float32)
expected_result = a
sharded_a = api.relayout(a, self.first_dimension_sharded_layout_2d)
dtensor_result = api.relayout(sharded_a, self.fully_replicated_layout_2d)
self.assertDTensorEqual(expected_result, self.fully_replicated_layout_2d,
dtensor_result)
# Regression test for b/184401449.
def testDeviceIdTensorOnSplitHost(self):
if not test_util.is_tpu_present():
self.skipTest('This test only runs on TPUs.')
self.skipForDeviceType(['TPU'],
'This test requires 8 TPU cores.',
unless_device_count_equals_to=8)
global_ids = test_util.create_device_ids_array((2, 4))
local_ids = [0, 1, 4, 5, 2, 3, 6, 7] # not sequentially increasing
mesh = layout_lib.Mesh(_MESH_DIMS, global_ids, local_ids,
test_util.create_device_list((2, 4), 'TPU'),
'tpu_mesh')
# This works because on 2x2, global device IDs are equal to physical TPU
# core IDs: both are range(8). So local device IDs happen to be usable here.
# TODO(b/180046115): Add a device.get_tpu_core_ids method and translate
# device IDs to core IDs before setting the list here.
if not config.backend_is_pw():
device = dtensor_device.DTensorDevice(meshes=[mesh])
device.set_tpu_core_ids('tpu_mesh', local_ids)
else:
test_backend_util.config_test_mesh(mesh)
layout_x = Layout.batch_sharded(mesh, _MESH_DIM_X, 2)
layout_y = Layout.batch_sharded(mesh, _MESH_DIM_Y, 2)
# Create a 2x4 batch-sharded d-tensor, with batch IDs in its first column
# and zeros in other columns.
replica_ids = constant_op.constant(
np.array([[0, 0, 0, 0], [1, 0, 0, 0]]), dtype=dtypes.int32
)
replica_ids = api.relayout(replica_ids, layout_x)
# Create a 4x4 y-sharded d-tensor filled with ones.
ones = constant_op.constant(
np.array([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]),
dtype=dtypes.int32,
)
ones = api.relayout(ones, layout_y)
# If `a` has a layout of [x, unsharded], and `b` has a layout of
# [y, unsharded], the matmul will slice `a` to [x, y], do a local matmul,
# and all-reduce to produce a final result with a layout of [x, unsharded].
#
# Because `a` only has non-zero values in its first column, local devices
# must be given a correct device ID tensor (as the first argument of every
# function) to produce correct `begin` values for slicing `a`.
#
# Although this function only contains a single op, running it in op-by-op
# mode doesn't produce the intended effect because the output of
# math_ops.matmul would have a layout of [y, unsharded] instead of
# [x, unsharded].
@polymorphic_function.function
def func(a, b):
return math_ops.matmul(a, b)
dtensor_result = func(replica_ids, ones)
# The correct result is a 2x4 batch-sharded d-tensor, with rows filled with
# batch IDs.
expected_result = [
constant_op.constant(
[loc[_MESH_DIM_X]] * 4, dtype=dtypes.int32, shape=[1, 4])
for loc in mesh.local_device_locations()
]
self.assertEqual(api.fetch_layout(dtensor_result), layout_x)
dtensor_result = [t.numpy() for t in api.unpack(dtensor_result)]
self.assertAllEqual(expected_result, dtensor_result)
def testDifferentShapesBetweenCalls(self):
self.skipForTfrt(
'b/269333905, TFRT cpu fails due to step_id not propagated.'
)
self.skipForDeviceType(
['TPU'],
'Known failure under TPU for legalization requires a static shape.',
)
# The error only happens across the batch, where the value of
# tf.unique are differnet.
def produce_data(inputs, label):
inputs = api.relayout(
inputs, Layout.batch_sharded(self.mesh, _MESH_DIM_X, 1)
)
label = api.relayout(
label, Layout.batch_sharded(self.mesh, _MESH_DIM_X, 1)
)
return inputs, label
@polymorphic_function.function
def train_fn(inputs, label):
inputs, indices = array_ops.unique(inputs)
return math_ops.unsorted_segment_sum(label, indices, len(inputs))
input1, label1 = produce_data([6, 0, 6, 0], [1, 2, 3, 4])
input2, label2 = produce_data([2, 1, 2, 0], [1, 2, 3, 4])
result1 = train_fn(input1, label1)
result2 = train_fn(input2, label2)
self.assertAllEqual(
result1.numpy(),
[
4,
6,
],
)
self.assertAllEqual(
result2.numpy(),
[
4,
2,
4,
],
)
class CollectiveTestWithCustomMesh(test_util.DTensorBaseTest):
# Create two independent global AllReduce ops that should get combined.
def testGlobalAllReduceCombiner(self):
self.skipForDeviceType(['TPU'],
'This test requires 8 TPU cores.',
unless_device_count_equals_to=8)
# Create and use an eight-device mesh just for this test.
global_ids = test_util.create_device_ids_array((8,))
local_ids = np.ravel(global_ids).tolist()
mesh_dict = {
device: layout_lib.Mesh([_MESH_DIM_X], global_ids, local_ids,
test_util.create_device_list((8,), device))
for device in ('CPU', 'GPU', 'TPU')
}
mesh = self.configTestMesh(mesh_dict)
fully_replicated_layout_1d = Layout.replicated(mesh, rank=1)
first_dimension_sharded_layout_2d = Layout.batch_sharded(
mesh, _MESH_DIM_X, 2)
@polymorphic_function.function
def func(a, b):
a = math_ops.reduce_sum(a, axis=[0])
b = math_ops.reduce_sum(b, axis=[0])
# Do something with the results before adding them, to make sure the MLIR
# pass can handle dependent ops sandwiched between two all-reduce ops.
return gen_math_ops.square(a) + gen_math_ops.square(b)
row = constant_op.constant(np.array([[1., 2.0]]), dtype=dtypes.float32)
a = array_ops.repeat(row, repeats=[8], axis=0)
b = gen_array_ops.reverse_v2(a, axis=[1])
expected_result = func(a, b)
a = api.relayout(a, first_dimension_sharded_layout_2d)
b = api.relayout(b, first_dimension_sharded_layout_2d)
dtensor_result = func(a, b)
self.assertDTensorEqual(expected_result, fully_replicated_layout_1d,
dtensor_result)
# Create two independent global AllReduce ops that should get combined.
# Create two independent global AllReduce ops with different reductions, that
# should not get combined
def testGlobalAllReduceCombinerDifferentReduce(self):
self.skipForDeviceType(['TPU'],
'This test requires 8 TPU cores.',
unless_device_count_equals_to=8)
# Create and use an eight-device mesh just for this test.
global_ids = test_util.create_device_ids_array((8,))
local_ids = np.ravel(global_ids).tolist()
mesh_dict = {
device: layout_lib.Mesh([_MESH_DIM_X], global_ids, local_ids,
test_util.create_device_list((8,), device))
for device in ('CPU', 'GPU', 'TPU')
}
mesh = self.configTestMesh(mesh_dict)
fully_replicated_layout_1d = Layout.replicated(mesh, rank=1)
first_dimension_sharded_layout_2d = Layout.batch_sharded(
mesh, _MESH_DIM_X, 2)
@polymorphic_function.function
def func(a, b):
a = math_ops.reduce_sum(a, axis=[0])
b = math_ops.reduce_mean(b, axis=[0])
# Do something with the results before adding them, to make sure the MLIR
# pass can handle dependent ops sandwiched between two all-reduce ops.
return gen_math_ops.square(a) + gen_math_ops.square(b)
row = constant_op.constant(np.array([[1., 2.0]]), dtype=dtypes.float32)
a = array_ops.repeat(row, repeats=[8], axis=0)
b = gen_array_ops.reverse_v2(a, axis=[1])
expected_result = func(a, b)
a = api.relayout(a, first_dimension_sharded_layout_2d)
b = api.relayout(b, first_dimension_sharded_layout_2d)
dtensor_result = func(a, b)
self.assertDTensorEqual(expected_result, fully_replicated_layout_1d,
dtensor_result)
# Create two independent subgroup AllReduce ops that should get combined.
def testSubgroupAllReduceCombiner(self):
self.skipForDeviceType(['TPU'],
'This test requires 8 TPU cores.',
unless_device_count_equals_to=8)
# Create and use an eight-device mesh just for this test.
global_ids = test_util.create_device_ids_array((4, 2))
local_ids = np.ravel(global_ids).tolist()
mesh_dict = {
device: layout_lib.Mesh(_MESH_DIMS, global_ids, local_ids,
test_util.create_device_list((4, 2), device))
for device in ('CPU', 'GPU', 'TPU')
}
mesh = self.configTestMesh(mesh_dict)
fully_sharded_layout_2d = Layout(_MESH_DIMS, mesh)
@polymorphic_function.function
def func(a, b):
a = math_ops.reduce_sum(a, axis=[0])
b = math_ops.reduce_sum(b, axis=[0])
# Do something with the results before adding them, to make sure the MLIR
# pass can handle dependent ops sandwiched between two all-reduce ops.
return gen_math_ops.square(a) + gen_math_ops.square(b)
row = constant_op.constant(np.array([[1., 2.0]]), dtype=dtypes.float32)
a = array_ops.repeat(row, repeats=[8], axis=0)
b = gen_array_ops.reverse_v2(a, axis=[1])
expected_result = func(a, b)
a = api.relayout(a, fully_sharded_layout_2d)
b = api.relayout(b, fully_sharded_layout_2d)
dtensor_result = func(a, b)
self.assertDTensorEqual(expected_result, Layout([_MESH_DIM_Y], mesh),
dtensor_result)
# TODO(b/188605096): also add a MixedPrecisionReduceScatter test
def testMixedPrecisionAllReduce(self):
has_enable_dtensor_mixed_precision_reduce = (
'DTENSOR_ENABLE_MIXED_PRECISION_REDUCE' in os.environ
)
has_dtensor_reduce_in_bfloat16_max_group_size = (
'DTENSOR_REDUCE_IN_BFLOAT16_MAX_GROUP_SIZE' in os.environ
)
if has_dtensor_reduce_in_bfloat16_max_group_size:
old_dtensor_reduce_in_bfloat16_max_group_size = os.environ[
'DTENSOR_REDUCE_IN_BFLOAT16_MAX_GROUP_SIZE']
os.environ['DTENSOR_ENABLE_MIXED_PRECISION_REDUCE'] = ''
os.environ['DTENSOR_REDUCE_IN_BFLOAT16_MAX_GROUP_SIZE'] = '4'
self.skipForDeviceType(['GPU'],
'GPUs do not support bfloat16 reduce')
self.skipForDeviceType(['TPU'],
'This test requires 8 TPU cores.',
unless_device_count_equals_to=8)
# Create and use an 8-device mesh just for this test. Mixed-precision
# AllReduce will be in effect since the reduction will be across 8 devices
# which is larger than the max group size flag value of 4.
global_ids = test_util.create_device_ids_array((8,))
local_ids = np.ravel(global_ids).tolist()
mesh_dict = {
device: layout_lib.Mesh([_MESH_DIM_X], global_ids, local_ids,
test_util.create_device_list((8,), device))
for device in ('CPU', 'GPU', 'TPU')
}
mesh = self.configTestMesh(mesh_dict)
replicated_layout_1d = Layout.replicated(mesh, rank=1)
first_dim_sharded_layout_1d = Layout.batch_sharded(
mesh, _MESH_DIM_X, rank=2)
@polymorphic_function.function
def func(x):
return math_ops.reduce_sum(x, axis=0)
# Reduce across 8 devices.
inp = constant_op.constant(
np.arange(48.).reshape((8, 6)), dtype=dtypes.bfloat16)
expected_result = np.sum(inp, axis=0)
inp_dtensor = api.relayout(inp, first_dim_sharded_layout_1d)
dtensor_result = func(inp_dtensor)
self.assertDTensorEqual(
expected_result, replicated_layout_1d, dtensor_result)
if not has_enable_dtensor_mixed_precision_reduce:
del os.environ['DTENSOR_ENABLE_MIXED_PRECISION_REDUCE']
if has_dtensor_reduce_in_bfloat16_max_group_size:
os.environ['DTENSOR_REDUCE_IN_BFLOAT16_MAX_GROUP_SIZE'] = (
old_dtensor_reduce_in_bfloat16_max_group_size
)
else:
del os.environ['DTENSOR_REDUCE_IN_BFLOAT16_MAX_GROUP_SIZE']
# Create two independent AllReduce ops with indirect dependency, that should
# not get combined.
def testAllReduceCombinerWithIndirectDependency(self):
# The purpose of this test is to validate the depdency check in AllReduce
# AllReduce combiner (dtensor_allreduce_combine_optimization). Specifically,
# the side effects from indirect dependency.
self.skipForPathways('TODO(b/260775095)')
self.skipForDeviceType(['TPU'],
'This test requires 8 TPU cores.',
unless_device_count_equals_to=8)
# Create and use an eight-device mesh just for this test.
global_ids = test_util.create_device_ids_array((8,))
local_ids = np.ravel(global_ids).tolist()
mesh_dict = {
device: layout_lib.Mesh([_MESH_DIM_X], global_ids, local_ids,
test_util.create_device_list((8,), device))
for device in ('CPU', 'GPU', 'TPU')
}
mesh = self.configTestMesh(mesh_dict)
first_dim_sharded_layout_1d = Layout.batch_sharded(
mesh, _MESH_DIM_X, rank=1)
init_value = constant_op.constant(np.ones(32), dtype=dtypes.float32)
init_value = api.relayout(init_value, first_dim_sharded_layout_1d)
# 2nd reduction indrectly depend on the 1st reduction
@polymorphic_function.function
def func(v):
a = math_ops.reduce_sum(v)
v.assign_add(v+a)
b = math_ops.reduce_sum(v)
return b
v = d_variable.DVariable(init_value)
dtensor_result = func(v)
# Replicate the scenario above without using dtensor
expected_result = constant_op.constant(np.ones(32), dtype=dtypes.float32)
expected_result += expected_result + math_ops.reduce_sum(expected_result)
expected_result = math_ops.reduce_sum(expected_result)
self.assertDTensorEqual(
expected_result, Layout.replicated(mesh=mesh, rank=0), dtensor_result
)
if __name__ == '__main__':
test.main()
|
tensorflowREPO_NAMEtensorflowPATH_START.@tensorflow_extracted@tensorflow-master@tensorflow@dtensor@python@tests@collective_test.py@.PATH_END.py
|
{
"filename": "parse_object_list.py",
"repo_name": "yt-project/yt",
"repo_path": "yt_extracted/yt-main/doc/helper_scripts/parse_object_list.py",
"type": "Python"
}
|
import inspect
from textwrap import TextWrapper
import yt
ds = yt.load("RD0005-mine/RedshiftOutput0005")
output = open("source/analyzing/_obj_docstrings.inc", "w")
template = """
.. class:: %(clsname)s%(sig)s:
For more information, see :ref:`%(docstring)s`
(This is a proxy for :class:`~%(clsproxy)sBase`.)
"""
tw = TextWrapper(initial_indent=" ", subsequent_indent=" ", width=60)
def write_docstring(f, name, cls):
for clsi in inspect.getmro(cls):
docstring = inspect.getdoc(clsi.__init__)
if docstring is not None:
break
clsname = name
sig = inspect.formatargspec(*inspect.getargspec(cls.__init__))
sig = sig.replace("**kwargs", "**field_parameters")
clsproxy = f"yt.data_objects.data_containers.{cls.__name__}"
f.write(
template
% dict(
clsname=clsname, sig=sig, clsproxy=clsproxy, docstring="physical-object-api"
)
)
for n, c in sorted(ds.__dict__.items()):
if hasattr(c, "_con_args"):
print(n)
write_docstring(output, n, c)
|
yt-projectREPO_NAMEytPATH_START.@yt_extracted@yt-main@doc@helper_scripts@parse_object_list.py@.PATH_END.py
|
{
"filename": "_xref.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py3/plotly/validators/layout/title/_xref.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class XrefValidator(_plotly_utils.basevalidators.EnumeratedValidator):
def __init__(self, plotly_name="xref", parent_name="layout.title", **kwargs):
super(XrefValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "layoutstyle"),
values=kwargs.pop("values", ["container", "paper"]),
**kwargs,
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py3@plotly@validators@layout@title@_xref.py@.PATH_END.py
|
{
"filename": "dirichlet_stats.py",
"repo_name": "mwalmsley/zoobot",
"repo_path": "zoobot_extracted/zoobot-main/zoobot/tensorflow/stats/dirichlet_stats.py",
"type": "Python"
}
|
import numpy as np
import tensorflow as tf
import tensorflow_probability as tfp
# from zoobot.tensorflow.stats import mixture_stats
def dirichlet_prob_of_answers(concentrations, schema):
# badly named vs posteriors, actually gives predicted vote fractions of answers...
# mean probability (including dropout) of an answer being given.
# concentrations has (batch, answer, ...) shape where extra dims are distributions (e.g. galaxies, answer, model, pass)
p_of_answers = []
for q in schema.questions:
concentrations_by_q = concentrations[:, q.start_index:q.end_index+1, :]
p_of_answers.append(DirichletMultinomialEqualMixture(total_votes=1, concentrations=concentrations_by_q).mean().numpy())
p_of_answers = np.concatenate(p_of_answers, axis=1)
return p_of_answers
class EqualMixture():
def __init__(self):
"""
Mixture of abstract distributions.
Abstract class implementing broadcasting along the final axis (which model) for common funcs e.g. log_prob, mean_log_prob etc
Raises:
NotImplementedError: Abstract class!
"""
raise NotImplementedError
@property
def batch_shape(self):
return self.distributions[0].batch_shape
@property
def event_shape(self):
return self.distributions[0].event_shape
def log_prob(self, x):
log_probs_by_dist = [dist.log_prob(x) for dist in self.distributions]
return tf.transpose(log_probs_by_dist)
def prob(self, x): # just the same, but prob not log prob
return tf.math.exp(self.log_prob(x))
def mean_prob(self, x):
# expected value across all distributions - very handy
prob = self.prob(x)
return tf.reduce_mean(prob, axis=-1)
def mean_log_prob(self, x):
return tf.math.log(self.mean_prob(x))
def mean(self):
# the mean of the mean (expected) value of each distribution
# aka the mean of the expected vote fractions
return tf.reduce_mean([dist.mean() for dist in self.distributions], axis=0)
def mean_cdf(self, x): # as integration is separable
# will fail as cdf is not implemented
return tf.reduce_mean([dist.cdf(x) for dist in self.distributions], axis=0)
def cdf(self, x):
cdf_by_dist = [dist.cdf(x) for dist in self.distributions]
return tf.transpose(cdf_by_dist)
# raise NotImplementedError('Can only be calculated with batch_dim shaped x, unlike .prob etc, needs custom implementation')
class DirichletEqualMixture(EqualMixture):
def __init__(self, concentrations):
"""
Equally-weighted mixture of Dirichlet distributions.
Basically, the Dirichlet version of a Gaussian mixture model.
Useful for combining predictions from multiple models or multiple forward passes (with MC Dropout and augmentations).
Specifically, self.distributions will be a list of tfp.distributions.Dirichlet, each with concentrations (galaxies, answers, specific model_index)
Broadcasting works along galaxies dimension by subclassing ``EqualMixture``.
Args:
concentrations (np.ndarray): predicted dirichlet parameters for one galaxy, of shape (galaxies, answers, models)
"""
# flatten trailing dims (e.g. galaxies, answer, model, pass) to (galaxies, answer, distribution)
concentrations = concentrations.reshape(concentrations.shape[0], concentrations.shape[1], -1)
concentrations = concentrations.astype(np.float32)
self.concentrations = concentrations
self.n_distributions = self.concentrations.shape[2]
self.distributions = [
tfp.distributions.Dirichlet(self.concentrations[:, :, n], validate_args=True)
for n in range(self.n_distributions)
]
# def entropy_estimate(self):
# """
# Returns:
# np.ndarray: midpoint between entropy bounds
# """
# upper = self.entropy_upper_bound()
# lower = self.entropy_lower_bound()
# return lower + (upper-lower)/2. # midpoint between bounds
# def entropy_upper_bound(self):
# """
# Returns:
# np.ndarray: upper bound on entropy. See ``mixture_stats.entropy_upper_bound``.
# """
# return np.array([mixture_stats.entropy_upper_bound(galaxy_conc, weights=np.ones(self.n_distributions)/self.n_distributions) for galaxy_conc in self.concentrations])
# def entropy_lower_bound(self):
# """
# Returns:
# np.ndarray: lower bound on entropy. See ``mixture_stats.entropy_lower_bound``.
# """
# return np.array([mixture_stats.entropy_lower_bound(galaxy_conc, weights=np.ones(self.n_distributions)/self.n_distributions) for galaxy_conc in self.concentrations])
class DirichletMultinomialEqualMixture(EqualMixture):
def __init__(self, total_votes, concentrations, *args, **kwargs):
"""
Mixture of equally-weighted Dirichlet-Multinomial distributions.
Useful for interpreting the aggregate predictions of many models in terms of expected volunteer responses.
Uses the same interface as tfp, but can aggregate across models (by subclassing ``EqualMixture``).
Args:
total_votes (np.ndarray): total votes for some question, of shape (galaxies)
concentrations (np.ndarray): of shape (galaxies, answer, ...). Answers for *one question only* due to total votes. Extra dims flattened.
"""
self.total_votes = np.array(total_votes).astype(np.float32)
# flatten trailing dims (e.g. galaxies, answer, model, pass) to (galaxies, answer, distribution)
concentrations = concentrations.reshape(concentrations.shape[0], concentrations.shape[1], -1)
self.concentrations = concentrations.astype(np.float32)
self.n_distributions = self.concentrations.shape[2]
self.distributions = [
tfp.distributions.DirichletMultinomial(self.total_votes, self.concentrations[:, :, n], validate_args=True)
for n in range(self.n_distributions)
]
def to_beta(self, answer_index, batch_dim):
"""
Convert from Dirichlet (multivariate) to Beta (bivariate) by adding up all the parameters to every answer but one.
E.g. 3-variate dirichlet(concentrations=[2, 3, 6]) converts to bivariate beta(a=2, b=3+6) for ``answer_index=0``
Intuitively, this is like going from "is it a, b, or c?" to "is it a or not-a?"
Args:
answer_index (int): which answer to use as first concentration. Other answers will have concentrations summed.
batch_dim (int): batch dimension i.e. num dirichlet distributions in this mixture.
Returns:
BetaEqualMixture: beta(answer index, not answer index) with a batch dimension of num. dirichlet distributions in this mixture
"""
assert self.batch_shape == 1 # beta uses batch shape for cdf(x), so needs to be able to broadcast, so can only do one galaxy at a time
num_answers = self.concentrations.shape[1]
answer_concentrations = self.concentrations[:, answer_index]
all_concentrations = self.concentrations.reshape(1, num_answers, -1).sum(axis=1)
beta_concentrations = np.stack([answer_concentrations, all_concentrations - answer_concentrations], axis=1)
return BetaEqualMixture(beta_concentrations, batch_dim=batch_dim)
class BetaEqualMixture(DirichletEqualMixture):
def __init__(self, concentrations):
"""
Batch dim is the number of models in the mixture,
Only supports galaxy_dim = 1 i.e. one galaxy at a time.
As with DirichletEqualMixture, self.distributions is list of tfp.distributions.Beta, each with dimension (galaxy, answer)
Only used for calculating confidence intervals for a specific answer - which is currently impractically slow anyway.
Args:
concentrations ([type]): of shape (1, 2, ...) for 1 galaxy, 2 answers, and trailing distibution dims
"""
assert concentrations.shape[0] == 1 # 1 galaxy
assert concentrations.shape[1] == 2 # 2 answers (i.e. "this answer" or "not this answer")
# remaining dimensions assumed to be distributions
concentrations = concentrations.reshape(concentrations.shape[0], concentrations.shape[1], -1)
# print(concentrations.shape)
self.batch_dim = batch_dim
self.concentrations = np.stack([np.squeeze(concentrations) for _ in range(batch_dim)], axis=0).astype(np.float32)
# print(self.concentrations.shape)
assert self.concentrations.ndim == 3
self.n_distributions = self.concentrations.shape[2]
self.distributions = [
tfp.distributions.Beta(
concentration0=self.concentrations[:, 0, n],
concentration1=self.concentrations[:, 1, n],
validate_args=True)
for n in range(self.n_distributions)
]
@property
def standard_sample_grid(self):
return np.linspace(1e-8, 1. - 1e-8, num=self.batch_dim)
def mean_mode(self): # approximate only
assert self.batch_dim >= 50
# print(self.mean_prob(self.standard_sample_grid).shape)
mode_index = np.argmax(self.mean_prob(self.standard_sample_grid))
return self.standard_sample_grid[mode_index] # bit lazy but it works
def confidence_interval(self, interval_width):
assert self.batch_dim >= 50
# dist must be unimodal (though the mode can be at extremes)
cdf = self.mean_cdf(self.standard_sample_grid)
mode = self.mean_mode()
# print(mode)
mode_cdf = self.mean_cdf(mode)[0] # just using the first, batch size broadcasting gives batch_size identical results
# print(mode_cdf)
return confidence_interval_from_cdf(self.standard_sample_grid, cdf, mode_cdf, interval_width)
def cdf(self, x):
# for dist in self.distributions:
# dist_with_batch_matching_x = tfp.distributions.Beta()
# print(x)
cdfs = [dist.cdf(x) for dist in self.distributions]
return tf.transpose(cdfs)
def confidence_interval_from_cdf(x, cdf, mode_cdf, interval_width):
width_per_half = interval_width / 2
lower_index = np.argmin(np.abs(mode_cdf - cdf - width_per_half))
upper_index = np.argmin(np.abs(cdf - mode_cdf - width_per_half))
if mode_cdf < width_per_half: # i.e. if lower interval hits the edge
upper_index = np.argmin(np.abs(cdf - interval_width))
elif 1 - mode_cdf < width_per_half: # i.e. upper interval hits the edge
lower_index = np.argmin(np.abs(1 - cdf - interval_width))
assert np.allclose(cdf[upper_index] - cdf[lower_index], interval_width, atol=.02)
lower = x[lower_index]
upper = x[upper_index]
return lower, upper
# if __name__ == '__main__':
# total_votes = 10
# votes_except_last = np.random.randint(0, int(total_votes/2), size=(10, 2)) # can be no more than half, for convenience
# votes_last = total_votes - votes_except_last.sum(axis=1)
# votes = np.concatenate([votes_except_last, votes_last.reshape(-1, 1)], axis=1)
# concentrations = np.random.rand(10, 3, 2, 5) * 100 + 1 # 10 events/galaxies, 3 possible outcomes/answers, 2 models, 5 forward passes
# mixture = DirichletMultinomialEqualMixture(total_votes=total_votes, concentrations=concentrations)
# print(mixture.mean())
# print(mixture.mean().shape) # taking a mean across distributions. not totally sure this is correct approach
# eval_points_except_last = np.random.rand(*concentrations.shape) / 3
# eval_points_last = 1 - eval_points_except_last.sum(axis=1)
# eval_points = np.concatenate([eval_points_except_last, eval_points_last.reshape(-1, 1)], axis=1)
# mixture = DirichletEqualMixture(concentrations=concentrations)
# print(mixture.cdf(eval_points))
# mixture = tfp.distributions.Beta(5., 6.) # concentrations
# print(mixture.cdf(.5))
# for each galaxy, for each question, for each answer, create a Beta distribution for that answer or not-that-answer
# then get the cdf
# no need for TFP - probably WAY faster in pure python
# I just want the CDF
# # only used for posthoc evaluation, not when training
# def dirichlet_mixture_loss(labels, predictions, question_index_groups): # pasted
# q_losses = []
# for q_n in range(len(question_index_groups)):
# q_indices = question_index_groups[q_n]
# q_start = q_indices[0]
# q_end = q_indices[1]
# q_loss = dirichlet_mixture_loss_per_question(labels[:, q_start:q_end+1], predictions[:, q_start:q_end+1])
# q_losses.append(q_loss)
# total_loss = np.stack(q_losses, axis=1)
# return total_loss # leave the reduce_sum to the estimator
# # this works but is very slow
# # def dirichlet_mixture_loss_per_question(labels_q, predictions_q):
# # n_samples = predictions_q.shape[-1]
# # total_votes = labels_q.sum(axis=1).squeeze()
# # log_probs = []
# # # print(predictions_q.shape,total_votes.shape, n_samples)
# # for n, galaxy in enumerate(predictions_q):
# # mixture = acquisition_utils.dirichlet_mixture(np.expand_dims(galaxy, axis=0), total_votes[n], n_samples)
# # log_probs.append(mixture.log_prob(labels_q[n]))
# # return -np.squeeze(np.array(log_probs)) # negative log prob
# def dirichlet_mixture_loss_per_question(labels_q, concentrations_q):
# n_samples = concentrations_q.shape[-1]
# total_votes = labels_q.sum(axis=1).squeeze()
# mean_log_probs = DirichletMultinomialEqualMixture(total_votes=total_votes, concentrations=concentrations_q).mean_log_prob(labels_q)
# return -np.squeeze(np.array(mean_log_probs)) # negative log prob
# def beta_confidence_interval(concentration0, concentration1, interval_width):
# dist = tfp.distributions.Beta(concentration0, concentration1, validate_args=True, allow_nan_stats=False)
# if concentration0 <= 1:
# mode = 1
# elif concentration1 <= 1:
# mode = 0
# else:
# mode = dist.mode()
# mode_cdf = dist.cdf(mode)
# x = np.linspace(0.001, .999, num=1000)
# cdf = dist.cdf(x)
# return confidence_interval_from_cdf(x, cdf, mode_cdf, interval_width)
|
mwalmsleyREPO_NAMEzoobotPATH_START.@zoobot_extracted@zoobot-main@zoobot@tensorflow@stats@dirichlet_stats.py@.PATH_END.py
|
{
"filename": "_xsrc.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py3/plotly/validators/cone/_xsrc.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class XsrcValidator(_plotly_utils.basevalidators.SrcValidator):
def __init__(self, plotly_name="xsrc", parent_name="cone", **kwargs):
super(XsrcValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "none"),
**kwargs,
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py3@plotly@validators@cone@_xsrc.py@.PATH_END.py
|
{
"filename": "run_test.py",
"repo_name": "phirling/pyc2ray",
"repo_path": "pyc2ray_extracted/pyc2ray-main/test/unit_tests_hackathon/2_multiple_sources/run_test.py",
"type": "Python"
}
|
import sys
sys.path.append("../../../")
import tools21cm as t2c
import pyc2ray as pc2r
import time
import pickle as pkl
import astropy.constants as ac
import astropy.units as u
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--gpu",action='store_true')
parser.add_argument("-numsrc",default=10,type=int,help="Number of sources to read from the test file")
args = parser.parse_args()
# Global parameters
numzred = 5 # Number of redshift slices
num_steps_between_slices = 10 # Number of timesteps between redshift slices
paramfile = "parameters.yml"
N = 250 # Mesh size
t_evol = 5e5
use_octa = args.gpu
r_RT = 100
nsrc = int(args.numsrc)
sim = pc2r.C2Ray_Test(paramfile, N, use_octa)
# Generate redshift list (test case)
zred_array = sim.generate_redshift_array(numzred,t_evol/numzred)
# Read sources and convert to flux
with open("cosmo_sources_sorted.pkl","rb") as f:
sources_list = pkl.load(f)
fgamma = 10 #250
t_s = 3*u.Myr.to('s')
fact = fgamma*sim.cosmology.Ob0/(sim.cosmology.Om0*t_s*ac.m_p.to('Msun').value)
srcpos = sources_list[:nsrc,:3].T
normflux = fact*sources_list[:nsrc,3]/1e48
# Set up density
df = t2c.DensityFile("dens_9.938.dat")
z = 9.938
scaling = (1+z)**3
m_H_cgs = 1.673533927065e-24 # Isotopic mass of hydrogen in grams
ndens = dens = scaling * df.cgs_density / m_H_cgs
sim.ndens = ndens
# Measure time
tinit = time.time()
out_i = 0
# Loop over redshifts
pc2r.printlog(f"Running on {len(normflux):n} sources...",sim.logfile)
pc2r.printlog(f"Raytracing radius: {r_RT:n} grid cells (= {sim.dr_c*u.cm.to('Mpc'):.3f} comoving Mpc)",sim.logfile)
for k in range(len(zred_array)-1):
zi = zred_array[k] # Start redshift
zf = zred_array[k+1] # End redshift
pc2r.printlog(f"\n=================================",sim.logfile)
pc2r.printlog(f"Doing redshift {zi:.3f} to {zf:.3f}",sim.logfile)
pc2r.printlog(f"=================================\n",sim.logfile)
# Compute timestep of current redshift slice
dt = sim.set_timestep(zi,zf,num_steps_between_slices)
# Set redshift to current slice redshift
sim.zred = zi
# Loop over timesteps
for t in range(num_steps_between_slices):
# Write output at each timestep
sim.write_output(out_i)
out_i += 1
tnow = time.time()
pc2r.printlog(f"\n --- Timestep {t+1:n}. Redshift: z = {sim.zred : .3f} Wall clock time: {tnow - tinit : .3f} seconds --- \n",sim.logfile)
pc2r.printlog(f"Mean density is: {sim.ndens.mean():.3e}, mean ionization fraction: {sim.xh.mean():.3e}",sim.logfile)
sim.evolve3D(dt, normflux, srcpos, r_RT, 1000)
# Write final output
sim.write_output(zf)
pc2r.printlog(f"Done. Final time: {time.time() - tinit : .3f} seconds",sim.logfile)
|
phirlingREPO_NAMEpyc2rayPATH_START.@pyc2ray_extracted@pyc2ray-main@test@unit_tests_hackathon@2_multiple_sources@run_test.py@.PATH_END.py
|
{
"filename": "verifyGain.py",
"repo_name": "lsst/cp_verify",
"repo_path": "cp_verify_extracted/cp_verify-main/python/lsst/cp/verify/verifyGain.py",
"type": "Python"
}
|
# This file is part of cp_verify.
#
# Developed for the LSST Data Management System.
# This product includes software developed by the LSST Project
# (http://www.lsst.org).
# See the COPYRIGHT file at the top-level directory of this distribution
# for details of code ownership.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import numpy as np
import lsst.pex.config as pexConfig
import lsst.pipe.base.connectionTypes as cT
from .verifyCalib import CpVerifyCalibConfig, CpVerifyCalibTask, CpVerifyCalibConnections
__all__ = ['CpVerifyGainConnections', 'CpVerifyGainConfig', 'CpVerifyGainTask']
class CpVerifyGainConnections(CpVerifyCalibConnections,
dimensions={"instrument", "detector"},
defaultTemplates={}):
exposure = cT.Input(
name="raw",
doc="Exposure ID of first flat from flat pair.",
storageClass='Exposure',
dimensions=("instrument", "detector", "exposure"),
multiple=True,
deferLoad=True,
)
inputCalib = cT.Input(
name="calib",
doc="Input calib to calculate statistics for.",
storageClass="PhotonTransferCurveDataset",
dimensions=("instrument", "detector", "exposure"),
isCalibration=True
)
class CpVerifyGainConfig(CpVerifyCalibConfig,
pipelineConnections=CpVerifyGainConnections):
"""Inherits from base CpVerifyCalibConfig."""
gainThreshold = pexConfig.Field(
dtype=float,
doc="Maximum percentage difference between gain from flat pairs and nominal amplifier gain.",
default=5.0,
)
noiseThreshold = pexConfig.Field(
dtype=float,
doc="Maximum percentage difference between overscan readout noise and nominal "
"amplifier readout noise.",
default=5.0,
)
def setDefaults(self):
super().setDefaults()
self.stageName = 'GAIN'
class CpVerifyGainTask(CpVerifyCalibTask):
"""Gain from flat pairs verification sub-class. Implements verify method.
"""
ConfigClass = CpVerifyGainConfig
_DefaultName = 'cpVerifyGain'
def detectorStatistics(self, inputCalib, camera=None, exposure=None):
"""Calculate detector level statistics from the calibration.
Parameters
----------
inputCalib : `lsst.ip.isr.IsrCalib`
The calibration to verify.
camera : `lsst.afw.cameraGeom.Camera`, optional
Input camera to get detectors from.
exposure : `lsst.afw.image.exposure.ExposureF`, optional
First flat-field image from pair of flats used to
estimate the gain.
Returns
-------
outputStatistics : `dict` [`str`, scalar]
A dictionary of the statistics measured and their values.
"""
return {}
def amplifierStatistics(self, inputCalib, camera=None, exposure=None):
"""Calculate detector level statistics from the calibration.
Parameters
----------
inputCalib : `lsst.ip.isr.IsrCalib`
The calibration to verify.
camera : `lsst.afw.cameraGeom.Camera`, optional
Input camera to get detectors from.
exposure : `lsst.afw.image.exposure.ExposureF`, optional
First flat-field image from pair of flats used to
estimate the gain.
Returns
-------
outputStatistics : `dict` [`str`, scalar]
A dictionary of the statistics measured and their values.
"""
calibMetadata = inputCalib.getMetadata().toDict()
detId = calibMetadata['DETECTOR']
detector = camera[detId]
# 'DET_SER' is of the form 'ITL-3800C-229'
detVendor = calibMetadata['DET_SER'].split('-')[0]
# Adjust gain estimated from flat pair for flux bias, see DM-35790
if detVendor == 'ITL':
slope = 0.00027 # %/ADU
elif detVendor == 'e2V':
slope = 0.00046 # %/ADU
outputStatistics = {amp.getName(): {} for amp in detector}
for amp in detector:
ampName = amp.getName()
# Flux correction to gain-per-flat-pair method, see DM-35790
correction = 1. - slope*inputCalib.rawMeans[ampName][0]/100
outputStatistics[ampName]['MEAN_FLUX_FLAT_PAIR'] = inputCalib.rawMeans[ampName][0]
outputStatistics[ampName]['GAIN_FROM_FLAT_PAIR'] = inputCalib.gain[ampName]
outputStatistics[ampName]['GAIN_CORRECTION_FACTOR'] = correction
outputStatistics[ampName]['AMP_GAIN'] = amp.getGain()
outputStatistics[ampName]['ISR_NOISE'] = inputCalib.noise[ampName]
outputStatistics[ampName]['AMP_NOISE'] = amp.getReadNoise()
return outputStatistics
def verify(self, calib, statisticsDict, camera=None, exposure=None):
"""Verify that the calibration meets the verification criteria.
Parameters
----------
inputCalib : `lsst.ip.isr.IsrCalib`
The calibration to verify.
statisticsDictionary : `dict` [`str`, `dict` [`str`, scalar]],
Dictionary of measured statistics. The inner dictionary
should have keys that are statistic names (`str`) with
values that are some sort of scalar (`int` or `float` are
the mostly likely types).
camera : `lsst.afw.cameraGeom.Camera`, optional
Input camera to get detectors from.
exposure : `lsst.afw.image.exposure.ExposureF`, optional
First flat-field image from pair of flats used to
estimate the gain.
Returns
-------
outputStatistics : `dict` [`str`, `dict` [`str`, `bool`]]
A dictionary indexed by the amplifier name, containing
dictionaries of the verification criteria.
success : `bool`
A boolean indicating whether all tests have passed.
"""
verifyStats = {}
success = True
calibMetadata = calib.getMetadata().toDict()
detId = calibMetadata['DETECTOR']
detector = camera[detId]
# 'DET_SER' is of the form 'ITL-3800C-229'
detVendor = calibMetadata['DET_SER'].split('-')[0]
# Adjust gain estimated from flat pair for flux bias, see DM-35790
if detVendor == 'ITL':
slope = 0.00027 # %/ADU
elif detVendor == 'e2V':
slope = 0.00046 # %/ADU
for amp in detector:
verify = {}
ampName = amp.getName()
# Gain from a pair of flats and noise from overscan after ISR.
# See DM-35790.
correction = 1. - slope*np.array(calib.rawMeans[ampName][0])/100
gain = correction*calib.gain[ampName]
diffGain = (np.abs(gain - amp.getGain()) / amp.getGain())*100
diffNoise = (np.abs(calib.noise[ampName] - amp.getReadNoise()) / amp.getReadNoise())*100
# DMTN-101: 6.1 and 6.2
# Estimate gain from a pair of flats and compare it with the value
# in the amplifiers.
verify['GAIN_FROM_FLAT_PAIR'] = bool(diffGain < self.config.gainThreshold)
# Check the empirical noise (as oppossed to fitted noise
# from the PTC) calculated from the overscan after ISR.
verify['ISR_NOISE'] = bool(diffNoise < self.config.noiseThreshold)
# Overall success among all tests for this amp.
verify['SUCCESS'] = bool(np.all(list(verify.values())))
if verify['SUCCESS'] is False:
success = False
verifyStats[ampName] = verify
# Loop over amps to make a detector summary.
verifyDetStats = {'GAIN_FROM_FLAT_PAIR': [], 'ISR_NOISE': []}
for amp in verifyStats:
for testName in verifyStats[amp]:
if testName == 'SUCCESS':
continue
verifyDetStats[testName].append(verifyStats[amp][testName])
# VerifyDetStatsFinal has final boolean test over all amps
verifyDetStatsFinal = {}
for testName in verifyDetStats:
testBool = bool(np.all(list(verifyDetStats[testName])))
# Save the tests that failed
if not testBool:
verifyDetStatsFinal[testName] = bool(np.all(list(verifyDetStats[testName])))
return verifyDetStatsFinal, bool(success)
|
lsstREPO_NAMEcp_verifyPATH_START.@cp_verify_extracted@cp_verify-main@python@lsst@cp@verify@verifyGain.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "fchollet/keras",
"repo_path": "keras_extracted/keras-master/keras/api/ops/image/__init__.py",
"type": "Python"
}
|
"""DO NOT EDIT.
This file was autogenerated. Do not edit it by hand,
since your modifications would be overwritten.
"""
from keras.src.ops.image import affine_transform
from keras.src.ops.image import crop_images
from keras.src.ops.image import extract_patches
from keras.src.ops.image import hsv_to_rgb
from keras.src.ops.image import map_coordinates
from keras.src.ops.image import pad_images
from keras.src.ops.image import resize
from keras.src.ops.image import rgb_to_grayscale
from keras.src.ops.image import rgb_to_hsv
|
fcholletREPO_NAMEkerasPATH_START.@keras_extracted@keras-master@keras@api@ops@image@__init__.py@.PATH_END.py
|
{
"filename": "test_bse.py",
"repo_name": "amusecode/amuse",
"repo_path": "amuse_extracted/amuse-main/src/amuse/test/suite/codes_tests/test_bse.py",
"type": "Python"
}
|
from amuse.community.bse.interface import BSE, BSEInterface
from amuse.test.amusetest import TestWithMPI
from amuse.units import units
from amuse.units import constants
from amuse.datamodel import Particles
import numpy
class TestBSEInterface(TestWithMPI):
class state(object):
def __init__(self):
self.type1 = 0.0
self.type2 = 0.0
self.initial_mass1 = 0.0
self.initial_mass2 = 0.0
self.mass1 = 0.0
self.mass2 = 0.0
self.radius1 = 0.0
self.radius2 = 0.0
self.luminosity1 = 0.0
self.luminosity2 = 0.0
self.core_mass1 = 0.0
self.core_mass2 = 0.0
self.core_radius1 = 0.0
self.core_radius2 = 0.0
self.envelope_mass1 = 0.0
self.envelope_mass2 = 0.0
self.envelope_radius1 = 0.0
self.envelope_radius2 = 0.0
self.spin1 = 0.0
self.spin2 = 0.0
self.epoch1 = 0.0
self.epoch2 = 0.0
self.t_ms1 = 0.0
self.t_ms2 = 0.0
self.bse_age = 0.0
self.orbital_period = 0.0
self.eccentricity = 0.0
def test1(self):
print("Test initialization...")
instance = BSEInterface()
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 0.5
alpha1 = 1.0
CElambda = 0.5
ceflag = 0
tflag = 1
ifflag = 0
wdflag = 1
bhflag = 0
nsflag = 1
mxns = 3.0
idum = 29769
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
sigma = 190.0
beta = 1.0/8.0
xi = 1.0
acc2 = 3.0/2.0
epsnov = 0.001
eddfac = 1.0
gamma = -1.0
status = instance.initialize(metallicity,
neta, bwind, hewind, alpha1, CElambda,
ceflag, tflag, ifflag, wdflag, bhflag,
nsflag, mxns, idum, pts1, pts2, pts3,
sigma, beta, xi, acc2, epsnov, eddfac, gamma)
self.assertEqual(status, 0)
instance.stop()
def test2(self):
print("Test basic operations (legacy functions evolve & get_time_step)...")
instance = BSEInterface()
status = instance.initialize(0.02, 0.5, 0.0, 0.5, 1.0, 0.5, 0, 1, 0, 1, 0, 1, 3.0,
29769, 0.05, 0.01, 0.02, 190.0, 1.0/8.0, 1.0, 3.0/2.0, 0.001, 1.0, -1.0)
new_state = self.state()
new_state.mass1 = 3.0
new_state.mass2 = 1.0
new_state.initial_mass1 = 3.0
new_state.initial_mass2 = 1.0
new_state.type1 = 1.0
new_state.type2 = 1.0
new_state.end_time = 1e-06
new_state.orbital_period = 200.0
new_state.eccentricity = 0.5
result = instance.evolve_binary(
new_state.type1, new_state.type2, new_state.initial_mass1, new_state.initial_mass2,
new_state.mass1, new_state.mass2, new_state.radius1, new_state.radius2,
new_state.luminosity1, new_state.luminosity2, new_state.core_mass1,
new_state.core_mass2, new_state.core_radius1, new_state.core_radius2,
new_state.envelope_mass1, new_state.envelope_mass2, new_state.envelope_radius1,
new_state.envelope_radius2, new_state.spin1, new_state.spin2, new_state.epoch1,
new_state.epoch2, new_state.t_ms1, new_state.t_ms2, new_state.bse_age,
new_state.orbital_period, new_state.eccentricity, new_state.end_time
)
updated_state = self.state()
(updated_state.type1, updated_state.type2, updated_state.initial_mass1, updated_state.initial_mass2,
updated_state.mass1, updated_state.mass2, updated_state.radius1, updated_state.radius2,
updated_state.luminosity1, updated_state.luminosity2, updated_state.core_mass1,
updated_state.core_mass2, updated_state.core_radius1, updated_state.core_radius2,
updated_state.envelope_mass1, updated_state.envelope_mass2, updated_state.envelope_radius1,
updated_state.envelope_radius2, updated_state.spin1, updated_state.spin2,
updated_state.epoch1, updated_state.epoch2, updated_state.t_ms1, updated_state.t_ms2,
updated_state.bse_age, updated_state.orbital_period,
updated_state.eccentricity, updated_state.end_time) = result
expected = {
'radius2': '0x1.c6c8a1c793bcep-1',
'luminosity2': '0x1.653b1b2d0333bp-1',
'core_mass2': '0x0.0p+0',
'bse_age': '0x1.0c6f7a0b5ed8dp-20',
'end_time': '0x1.0c6f7a0b5ed8dp-20',
'envelope_mass2': '0x1.0d6fc100ab510p-5',
'mass2': '0x1.0000000000000p+0',
'initial_mass2': '0x1.0000000000000p+0',
'envelope_radius2': '0x1.db27631ba0e5ap-3',
'core_radius2': '0x0.0p+0',
'epoch2': '0x0.0p+0',
't_ms2': '0x1.57d90abe54643p+13',
'spin2': '0x1.07413b0522aebp+10',
}
for x in expected:
# print "'%s' : '%s'," % (x, getattr(updated_state, x).hex())
self.assertAlmostRelativeEqual(float.fromhex(expected[x]), getattr(updated_state, x))
self.assertEqual(updated_state.end_time, 1e-06)
dt = instance.get_time_step(updated_state.type1, updated_state.type2,
updated_state.initial_mass1, updated_state.initial_mass2, updated_state.mass1,
updated_state.mass2, updated_state.t_ms1, updated_state.t_ms2,
updated_state.epoch1, updated_state.epoch2, updated_state.bse_age)
self.assertAlmostEqual(dt, 18.8768, 3)
instance.stop()
def test3(self):
print("Test whether the interface can handle arrays...")
instance = BSEInterface()
status = instance.initialize(0.02, 0.5, 0.0, 0.5, 1.0, 0.5, 0, 1, 0, 1, 0, 1, 3.0,
29769, 0.05, 0.01, 0.02, 190.0, 1.0/8.0, 1.0, 3.0/2.0, 0.001, 1.0, -1.0)
masses1 = [10.0, 5.0, 4.0]
masses2 = [1.0, 1.0, 1.0]
types1 = types2 = [1, 1, 1]
orbital_periods = [100.0, 200.0, 300.0]
eccentricities = [0.5, 0.6, 0.7]
radii1 = luminosity1 = core_mass1 = core_radius1 = envelope_mass1 =\
envelope_radius1 = spin1 = epoch1 = t_ms1 = [0.0, 0.0, 0.0]
radii2 = luminosity2 = core_mass2 = core_radius2 = envelope_mass2 =\
envelope_radius2 = spin2 = epoch2 = t_ms2 = [0.0, 0.0, 0.0]
init_mass1 = masses1
init_mass2 = masses2
bse_age = [0.0, 0.0, 0.0]
end_time = [10.0, 10.0, 10.0]
result = instance.evolve_binary(
types1, types2, init_mass1, init_mass2,
masses1, masses2, radii1, radii2,
luminosity1, luminosity2, core_mass1, core_mass2,
core_radius1, core_radius2, envelope_mass1, envelope_mass2,
envelope_radius1, envelope_radius2, spin1, spin2,
epoch1, epoch2, t_ms1, t_ms2,
bse_age, orbital_periods, eccentricities, end_time
)
self.assertAlmostEqual(result['mass1'][0], 9.977, 2)
self.assertAlmostEqual(result['mass1'][1], 5.0, 2)
self.assertAlmostEqual(result['mass1'][2], 4.0, 2)
instance.stop()
def test4(self):
print("Test large number of particles...")
number_of_particles = 2000
instance = BSEInterface()
status = instance.initialize(0.02, 0.5, 0.0, 0.5, 1.0, 0.5, 0, 1, 0, 1, 0, 1, 3.0,
29769, 0.05, 0.01, 0.02, 190.0, 1.0/8.0, 1.0, 3.0/2.0, 0.001, 1.0, -1.0)
masses1 = [1.0 + ((x / 1.0*number_of_particles) * 10.0) for x in range(1, number_of_particles+1)]
masses2 = [2.0 + ((x / 1.0*number_of_particles) * 5.0) for x in range(1, number_of_particles+1)]
orbital_periods = [100.0 + ((x / 1.0*number_of_particles) * 900.0) for x in range(1, number_of_particles+1)]
eccentricities = [0.5 + ((x / 1.0*number_of_particles) * 0.4) for x in range(1, number_of_particles+1)]
types1 = types2 = [1 for x in range(1, number_of_particles+1)]
radii1 = luminosity1 = core_mass1 = core_radius1 = envelope_mass1 =\
envelope_radius1 = spin1 = epoch1 = t_ms1 =\
radii2 = luminosity2 = core_mass2 = core_radius2 = envelope_mass2 =\
envelope_radius2 = spin2 = epoch2 = t_ms2 =\
bse_age = [0.0 for x in range(1, number_of_particles+1)]
end_time = [1.0 for x in range(1, number_of_particles+1)]
init_mass1 = masses1
init_mass2 = masses2
result = instance.evolve_binary(
types1, types2, init_mass1, init_mass2,
masses1, masses2, radii1, radii2,
luminosity1, luminosity2, core_mass1, core_mass2,
core_radius1, core_radius2, envelope_mass1, envelope_mass2,
envelope_radius1, envelope_radius2, spin1, spin2,
epoch1, epoch2, t_ms1, t_ms2,
bse_age, orbital_periods, eccentricities, end_time
)
self.assertEqual(len(result['mass1']), number_of_particles)
instance.stop()
class TestBSE(TestWithMPI):
def test1(self):
print("Testing evolution of a close binary system...")
instance = BSE()
instance.initialize_code()
instance.parameters.metallicity = 0.001
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 3.0 | units.MSun
stars[1].mass = 0.3 | units.MSun
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.5
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_bse_to_model = instance.particles.new_channel_to(stars)
from_bse_to_model.copy()
from_bse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_bse_to_model_binaries.copy()
previous_type = binary.child1.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (480 | units.Myr):
instance.update_time_steps()
# The next line appears a bit weird, but saves time for this simple test.
current_time = current_time + max(5.0*instance.binaries[0].time_step, 0.3 | units.Myr)
instance.evolve_model(current_time)
from_bse_to_model.copy()
from_bse_to_model_binaries.copy()
if not binary.child1.stellar_type == previous_type:
results.append((binary.age, binary.child1.mass, binary.child1.stellar_type))
previous_type = binary.child1.stellar_type
self.assertEqual(len(results), 6)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Hertzsprung Gap Naked Helium star",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
times = (
284.8516 | units.Myr,
287.0595 | units.Myr,
287.7848 | units.Myr,
331.1454 | units.Myr,
331.3983 | units.Myr,
332.2786 | units.Myr,
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 0)
masses = (
3.000 | units.MSun,
3.000 | units.MSun,
2.999 | units.MSun,
2.956 | units.MSun,
0.888 | units.MSun,
0.707 | units.MSun,
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 2)
instance.stop()
def test2(self):
print("Testing evolution of a wide binary system.")
instance = BSE()
instance.parameters.metallicity = 0.001
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 3.0 | units.MSun
stars[1].mass = 0.3 | units.MSun
orbital_period = 2.0e5 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.5
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_bse_to_model = instance.particles.new_channel_to(stars)
from_bse_to_model.copy()
from_bse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_bse_to_model_binaries.copy()
previous_type = binary.child1.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (335 | units.Myr):
instance.update_time_steps()
# The next line appears a bit weird, but saves time for this simple test.
current_time = current_time + max(2.0*instance.binaries[0].time_step, 0.04 | units.Myr)
instance.evolve_model(current_time)
from_bse_to_model.copy()
from_bse_to_model_binaries.copy()
if not binary.child1.stellar_type == previous_type:
results.append((binary.age, binary.child1.mass, binary.child1.stellar_type))
previous_type = binary.child1.stellar_type
print(results)
self.assertEqual(len(results), 6)
times = (
284.8516 | units.Myr,
287.0595 | units.Myr,
287.7848 | units.Myr,
331.1454 | units.Myr,
332.7407 | units.Myr,
333.4146 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 0)
masses = (
3.000 | units.MSun,
3.000 | units.MSun,
2.999 | units.MSun,
2.956 | units.MSun,
2.919 | units.MSun,
0.928 | units.MSun
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 2)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Second Asymptotic Giant Branch",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
instance.stop()
def test3(self):
print("Testing standard BSE example 2...")
instance = BSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 7.816 | units.MSun
stars[1].mass = 4.387 | units.MSun
orbital_period = 1964.18453 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.0
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_bse_to_model = instance.particles.new_channel_to(stars)
from_bse_to_model.copy()
from_bse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_bse_to_model_binaries.copy()
previous_type1 = binary.child1.stellar_type
previous_type2 = binary.child2.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (170 | units.Myr):
instance.update_time_steps()
# The next line appears a bit weird, but saves time for this simple test.
current_time = current_time + max(2.0*instance.binaries[0].time_step, 0.04 | units.Myr)
instance.evolve_model(current_time)
from_bse_to_model.copy()
from_bse_to_model_binaries.copy()
if not (binary.child1.stellar_type == previous_type1 and binary.child2.stellar_type == previous_type2):
results.append((binary.age, str(binary.child1.stellar_type)+" and "+str(binary.child2.stellar_type)))
previous_type1 = binary.child1.stellar_type
previous_type2 = binary.child2.stellar_type
print('\n'.join(map(str, results)))
self.assertEqual(len(results), 13)
times = (
38.9708 | units.Myr,
39.0897 | units.Myr,
39.1213 | units.Myr,
43.8025 | units.Myr,
43.9923 | units.Myr,
44.0686 | units.Myr,
141.7077 | units.Myr,
142.3448 | units.Myr,
142.7827 | units.Myr,
166.1043 | units.Myr,
166.5795 | units.Myr,
166.9627 | units.Myr,
166.9863 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 0)
types = (
"Hertzsprung Gap and Main Sequence star",
"First Giant Branch and Main Sequence star",
"Core Helium Burning and Main Sequence star",
"First Asymptotic Giant Branch and Main Sequence star",
"Second Asymptotic Giant Branch and Main Sequence star",
"Oxygen/Neon White Dwarf and Main Sequence star",
"Oxygen/Neon White Dwarf and Hertzsprung Gap",
"Oxygen/Neon White Dwarf and First Giant Branch",
"Oxygen/Neon White Dwarf and Core Helium Burning",
"Oxygen/Neon White Dwarf and First Asymptotic Giant Branch",
"Oxygen/Neon White Dwarf and Hertzsprung Gap Naked Helium star",
"Neutron Star and Hertzsprung Gap Naked Helium star",
"Neutron Star and Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(result[1], expected)
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 1.304, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.800, 3)
instance.stop()
def test4(self):
print("Quick testing standard BSE example 2...")
instance = BSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 7.816 | units.MSun
stars[1].mass = 4.387 | units.MSun
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
orbital_period = 1964.18453 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.0
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_bse_to_model = instance.particles.new_channel_to(stars)
from_bse_to_model.copy()
from_bse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_bse_to_model_binaries.copy()
instance.evolve_model(170 | units.Myr)
from_bse_to_model.copy()
from_bse_to_model_binaries.copy()
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 1.304, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.800, 3)
self.assertEqual(str(binary.child1.stellar_type), "Neutron Star")
self.assertEqual(str(binary.child2.stellar_type), "Carbon/Oxygen White Dwarf")
instance.stop()
def test5(self):
print("Testing stellar collision...")
instance = BSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 3.0 | units.MSun
stars[1].mass = 0.3 | units.MSun
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.99
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_bse_to_model = instance.particles.new_channel_to(stars)
from_bse_to_model.copy()
from_bse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_bse_to_model_binaries.copy()
instance.evolve_model(170 | units.Myr)
from_bse_to_model.copy()
from_bse_to_model_binaries.copy()
print(binaries)
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 3.300, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.000, 3)
self.assertEqual(str(binary.child1.stellar_type), "Main Sequence star")
self.assertEqual(str(binary.child2.stellar_type), "Massless Supernova")
instance.stop()
def test6(self):
print("Testing additional parameters for initialization...")
instance = BSE()
instance.initialize_code()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.stop()
instance = BSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
instance.parameters.set_defaults()
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
instance.stop()
def test7(self):
print("Test evolve_model optional arguments: end_time and keep_synchronous")
instance = BSE()
instance.commit_parameters()
stars = Particles(6)
stars.mass = [1.0, 2.0, 3.0, 0.1, 0.2, 0.3] | units.MSun
binaries = Particles(3)
binaries.eccentricity = 0.0
for i in range(3):
binaries[i].child1 = stars[i]
binaries[i].child2 = stars[i+3]
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(
orbital_period,
binaries.child1.as_set().mass,
binaries.child2.as_set().mass
)
binaries.semi_major_axis = semi_major_axis
instance.particles.add_particles(stars)
instance.binaries.add_particles(binaries)
self.assertAlmostEqual(instance.binaries.age, [0.0, 0.0, 0.0] | units.yr)
self.assertAlmostEqual(instance.binaries.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
print("evolve_model without arguments: use shared timestep = min(particles.time_step)")
instance.evolve_model()
self.assertAlmostEqual(instance.binaries.age, [18.8768, 18.8768, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.binaries.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.model_time, 18.8768 | units.Myr, 3)
print("evolve_model with end_time: take timesteps, until end_time is reached exactly")
instance.evolve_model(100 | units.Myr)
self.assertAlmostEqual(instance.binaries.age, [100.0, 100.0, 100.0] | units.Myr, 3)
self.assertAlmostEqual(instance.binaries.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 3)
print("evolve_model with keep_synchronous: use non-shared timestep, particle ages will typically diverge")
instance.evolve_model(keep_synchronous=False)
self.assertAlmostEqual(instance.binaries.age, (100 | units.Myr) + ([550.1565, 58.2081, 18.8768] | units.Myr), 3)
self.assertAlmostEqual(instance.binaries.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 3) # Unchanged!
instance.stop()
def test8(self):
print("Testing adding and removing particles from stellar evolution code...")
instance = BSE()
instance.initialize_code()
stars = Particles(6)
stars.mass = [1.0, 1.0, 1.0, 0.2, 0.2, 0.2] | units.MSun
binaries = Particles(3)
binaries.eccentricity = 0.0
for i in range(3):
binaries[i].child1 = stars[i]
binaries[i].child2 = stars[i+3]
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(
orbital_period,
binaries.child1.as_set().mass,
binaries.child2.as_set().mass
)
binaries.semi_major_axis = semi_major_axis
instance.commit_parameters()
self.assertEqual(len(instance.particles), 0)
self.assertEqual(len(instance.binaries), 0) # before creation
instance.particles.add_particles(stars)
instance.binaries.add_particles(binaries[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEqual(len(instance.binaries), 2) # before remove
self.assertAlmostEqual(instance.binaries.age, 1.0 | units.Myr)
instance.binaries.remove_particle(binaries[0])
self.assertEqual(len(instance.binaries), 1)
instance.evolve_model(2.0 | units.Myr)
self.assertAlmostEqual(instance.binaries[0].age, 2.0 | units.Myr)
instance.binaries.add_particles(binaries[::2])
self.assertEqual(len(instance.binaries), 3) # it's back...
self.assertAlmostEqual(instance.binaries[0].age, 2.0 | units.Myr)
self.assertAlmostEqual(instance.binaries[1].age, 0.0 | units.Myr)
self.assertAlmostEqual(instance.binaries[2].age, 0.0 | units.Myr) # ... and rejuvenated.
instance.evolve_model(3.0 | units.Myr) # The young stars keep their age offset from the old star
self.assertAlmostEqual(instance.binaries.age, [3.0, 1.0, 1.0] | units.Myr)
instance.evolve_model(4.0 | units.Myr)
self.assertAlmostEqual(instance.binaries.age, [4.0, 2.0, 2.0] | units.Myr)
instance.stop()
def test9(self):
print("Testing BSE states")
instance = BSE()
stars = Particles(2)
stars.mass = [1.0, 0.2] | units.MSun
binaries = Particles(1)
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
binaries.semi_major_axis = semi_major_axis
binaries.eccentricity = 0.0
binaries[0].child1 = stars[0]
binaries[0].child2 = stars[1]
print("First do everything manually:", end=' ')
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("ok")
print("initialize_code(), commit_parameters(), "
"and cleanup_code() should be called automatically:", end=' ')
instance = BSE()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.reimers_mass_loss_coefficient = 0.5
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
instance.binaries.add_particles(binaries)
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
print("ok")
|
amusecodeREPO_NAMEamusePATH_START.@amuse_extracted@amuse-main@src@amuse@test@suite@codes_tests@test_bse.py@.PATH_END.py
|
{
"filename": "flows.py",
"repo_name": "PrefectHQ/prefect",
"repo_path": "prefect_extracted/prefect-main/src/prefect/flows.py",
"type": "Python"
}
|
"""
Module containing the base workflow class and decorator - for most use cases, using the [`@flow` decorator][prefect.flows.flow] is preferred.
"""
# This file requires type-checking with pyright because mypy does not yet support PEP612
# See https://github.com/python/mypy/issues/8645
import ast
import asyncio
import datetime
import importlib.util
import inspect
import os
import re
import sys
import tempfile
import warnings
from copy import copy
from functools import partial, update_wrapper
from pathlib import Path
from typing import (
TYPE_CHECKING,
Any,
Awaitable,
Callable,
Coroutine,
Generic,
Iterable,
NoReturn,
Optional,
Tuple,
Type,
TypeVar,
Union,
cast,
overload,
)
from uuid import UUID
import pydantic
from fastapi.encoders import jsonable_encoder
from pydantic.v1 import BaseModel as V1BaseModel
from pydantic.v1.decorator import ValidatedFunction as V1ValidatedFunction
from pydantic.v1.errors import ConfigError # TODO
from rich.console import Console
from typing_extensions import Literal, ParamSpec, TypeAlias
from prefect._internal.concurrency.api import create_call, from_async
from prefect.blocks.core import Block
from prefect.client.schemas.actions import DeploymentScheduleCreate
from prefect.client.schemas.filters import WorkerFilter
from prefect.client.schemas.objects import ConcurrencyLimitConfig, FlowRun
from prefect.client.schemas.objects import Flow as FlowSchema
from prefect.client.utilities import client_injector
from prefect.docker.docker_image import DockerImage
from prefect.events import DeploymentTriggerTypes, TriggerTypes
from prefect.exceptions import (
InvalidNameError,
MissingFlowError,
ObjectNotFound,
ParameterTypeError,
ScriptError,
TerminationSignal,
UnspecifiedFlowError,
)
from prefect.filesystems import LocalFileSystem, ReadableDeploymentStorage
from prefect.futures import PrefectFuture
from prefect.logging import get_logger
from prefect.logging.loggers import flow_run_logger
from prefect.results import ResultSerializer, ResultStorage
from prefect.settings import (
PREFECT_DEFAULT_WORK_POOL_NAME,
PREFECT_FLOW_DEFAULT_RETRIES,
PREFECT_FLOW_DEFAULT_RETRY_DELAY_SECONDS,
PREFECT_TESTING_UNIT_TEST_MODE,
PREFECT_UI_URL,
)
from prefect.states import State
from prefect.task_runners import TaskRunner, ThreadPoolTaskRunner
from prefect.types import BANNED_CHARACTERS, WITHOUT_BANNED_CHARACTERS
from prefect.types.entrypoint import EntrypointType
from prefect.utilities.annotations import NotSet
from prefect.utilities.asyncutils import (
run_sync_in_worker_thread,
sync_compatible,
)
from prefect.utilities.callables import (
get_call_parameters,
parameter_schema,
parameters_to_args_kwargs,
raise_for_reserved_arguments,
)
from prefect.utilities.collections import listrepr, visit_collection
from prefect.utilities.filesystem import relative_path_to_current_platform
from prefect.utilities.hashing import file_hash
from prefect.utilities.importtools import import_object, safe_load_namespace
from ._internal.compatibility.async_dispatch import is_in_async_context
from ._internal.pydantic.v2_schema import is_v2_type
from ._internal.pydantic.v2_validated_func import V2ValidatedFunction
from ._internal.pydantic.v2_validated_func import (
V2ValidatedFunction as ValidatedFunction,
)
T = TypeVar("T") # Generic type var for capturing the inner return type of async funcs
R = TypeVar("R") # The return type of the user's function
P = ParamSpec("P") # The parameters of the flow
F = TypeVar("F", bound="Flow[Any, Any]") # The type of the flow
StateHookCallable: TypeAlias = Callable[
[FlowSchema, FlowRun, State], Union[Awaitable[None], None]
]
logger = get_logger("flows")
if TYPE_CHECKING:
from prefect.client.orchestration import PrefectClient
from prefect.client.types.flexible_schedule_list import FlexibleScheduleList
from prefect.deployments.runner import RunnerDeployment
from prefect.flows import FlowRun
from prefect.runner.storage import RunnerStorage
class Flow(Generic[P, R]):
"""
A Prefect workflow definition.
!!! note
We recommend using the [`@flow` decorator][prefect.flows.flow] for most use-cases.
Wraps a function with an entrypoint to the Prefect engine. To preserve the input
and output types, we use the generic type variables `P` and `R` for "Parameters" and
"Returns" respectively.
Args:
fn: The function defining the workflow.
name: An optional name for the flow; if not provided, the name will be inferred
from the given function.
version: An optional version string for the flow; if not provided, we will
attempt to create a version string as a hash of the file containing the
wrapped function; if the file cannot be located, the version will be null.
flow_run_name: An optional name to distinguish runs of this flow; this name can
be provided as a string template with the flow's parameters as variables,
or a function that returns a string.
task_runner: An optional task runner to use for task execution within the flow;
if not provided, a `ThreadPoolTaskRunner` will be used.
description: An optional string description for the flow; if not provided, the
description will be pulled from the docstring for the decorated function.
timeout_seconds: An optional number of seconds indicating a maximum runtime for
the flow. If the flow exceeds this runtime, it will be marked as failed.
Flow execution may continue until the next task is called.
validate_parameters: By default, parameters passed to flows are validated by
Pydantic. This will check that input values conform to the annotated types
on the function. Where possible, values will be coerced into the correct
type; for example, if a parameter is defined as `x: int` and "5" is passed,
it will be resolved to `5`. If set to `False`, no validation will be
performed on flow parameters.
retries: An optional number of times to retry on flow run failure.
retry_delay_seconds: An optional number of seconds to wait before retrying the
flow after failure. This is only applicable if `retries` is nonzero.
persist_result: An optional toggle indicating whether the result of this flow
should be persisted to result storage. Defaults to `None`, which indicates
that Prefect should choose whether the result should be persisted depending on
the features being used.
result_storage: An optional block to use to persist the result of this flow.
This value will be used as the default for any tasks in this flow.
If not provided, the local file system will be used unless called as
a subflow, at which point the default will be loaded from the parent flow.
result_serializer: An optional serializer to use to serialize the result of this
flow for persistence. This value will be used as the default for any tasks
in this flow. If not provided, the value of `PREFECT_RESULTS_DEFAULT_SERIALIZER`
will be used unless called as a subflow, at which point the default will be
loaded from the parent flow.
on_failure: An optional list of callables to run when the flow enters a failed state.
on_completion: An optional list of callables to run when the flow enters a completed state.
on_cancellation: An optional list of callables to run when the flow enters a cancelling state.
on_crashed: An optional list of callables to run when the flow enters a crashed state.
on_running: An optional list of callables to run when the flow enters a running state.
"""
# NOTE: These parameters (types, defaults, and docstrings) should be duplicated
# exactly in the @flow decorator
def __init__(
self,
fn: Callable[P, R],
name: Optional[str] = None,
version: Optional[str] = None,
flow_run_name: Optional[Union[Callable[[], str], str]] = None,
retries: Optional[int] = None,
retry_delay_seconds: Optional[Union[int, float]] = None,
task_runner: Union[
Type[TaskRunner[PrefectFuture[R]]], TaskRunner[PrefectFuture[R]], None
] = None,
description: Optional[str] = None,
timeout_seconds: Union[int, float, None] = None,
validate_parameters: bool = True,
persist_result: Optional[bool] = None,
result_storage: Optional[Union[ResultStorage, str]] = None,
result_serializer: Optional[ResultSerializer] = None,
cache_result_in_memory: bool = True,
log_prints: Optional[bool] = None,
on_completion: Optional[list[StateHookCallable]] = None,
on_failure: Optional[list[StateHookCallable]] = None,
on_cancellation: Optional[list[StateHookCallable]] = None,
on_crashed: Optional[list[StateHookCallable]] = None,
on_running: Optional[list[StateHookCallable]] = None,
):
if name is not None and not isinstance(name, str):
raise TypeError(
"Expected string for flow parameter 'name'; got {} instead. {}".format(
type(name).__name__,
(
"Perhaps you meant to call it? e.g."
" '@flow(name=get_flow_run_name())'"
if callable(name)
else ""
),
)
)
# Validate if hook passed is list and contains callables
hook_categories = [
on_completion,
on_failure,
on_cancellation,
on_crashed,
on_running,
]
hook_names = [
"on_completion",
"on_failure",
"on_cancellation",
"on_crashed",
"on_running",
]
for hooks, hook_name in zip(hook_categories, hook_names):
if hooks is not None:
try:
hooks = list(hooks)
except TypeError:
raise TypeError(
f"Expected iterable for '{hook_name}'; got"
f" {type(hooks).__name__} instead. Please provide a list of"
f" hooks to '{hook_name}':\n\n"
f"@flow({hook_name}=[hook1, hook2])\ndef"
" my_flow():\n\tpass"
)
for hook in hooks:
if not callable(hook):
raise TypeError(
f"Expected callables in '{hook_name}'; got"
f" {type(hook).__name__} instead. Please provide a list of"
f" hooks to '{hook_name}':\n\n"
f"@flow({hook_name}=[hook1, hook2])\ndef"
" my_flow():\n\tpass"
)
if not callable(fn):
raise TypeError("'fn' must be callable")
self.name = name or fn.__name__.replace("_", "-").replace(
"<lambda>",
"unknown-lambda", # prefect API will not accept "<" or ">" in flow names
)
_raise_on_name_with_banned_characters(self.name)
if flow_run_name is not None:
if not isinstance(flow_run_name, str) and not callable(flow_run_name):
raise TypeError(
"Expected string or callable for 'flow_run_name'; got"
f" {type(flow_run_name).__name__} instead."
)
self.flow_run_name = flow_run_name
default_task_runner = ThreadPoolTaskRunner()
task_runner = task_runner or default_task_runner
self.task_runner = (
task_runner() if isinstance(task_runner, type) else task_runner
)
self.log_prints = log_prints
self.description = description or inspect.getdoc(fn)
update_wrapper(self, fn)
self.fn = fn
# the flow is considered async if its function is async or an async
# generator
self.isasync = asyncio.iscoroutinefunction(
self.fn
) or inspect.isasyncgenfunction(self.fn)
# the flow is considered a generator if its function is a generator or
# an async generator
self.isgenerator = inspect.isgeneratorfunction(
self.fn
) or inspect.isasyncgenfunction(self.fn)
raise_for_reserved_arguments(self.fn, ["return_state", "wait_for"])
# Version defaults to a hash of the function's file
flow_file = inspect.getsourcefile(self.fn)
if not version:
try:
version = file_hash(flow_file)
except (FileNotFoundError, TypeError, OSError):
pass # `getsourcefile` can return null values and "<stdin>" for objects in repls
self.version = version
self.timeout_seconds = float(timeout_seconds) if timeout_seconds else None
# FlowRunPolicy settings
# TODO: We can instantiate a `FlowRunPolicy` and add Pydantic bound checks to
# validate that the user passes positive numbers here
self.retries = (
retries if retries is not None else PREFECT_FLOW_DEFAULT_RETRIES.value()
)
self.retry_delay_seconds = (
retry_delay_seconds
if retry_delay_seconds is not None
else PREFECT_FLOW_DEFAULT_RETRY_DELAY_SECONDS.value()
)
self.parameters = parameter_schema(self.fn)
self.should_validate_parameters = validate_parameters
if self.should_validate_parameters:
# Try to create the validated function now so that incompatibility can be
# raised at declaration time rather than at runtime
# We cannot, however, store the validated function on the flow because it
# is not picklable in some environments
try:
ValidatedFunction(self.fn, config={"arbitrary_types_allowed": True})
except ConfigError as exc:
raise ValueError(
"Flow function is not compatible with `validate_parameters`. "
"Disable validation or change the argument names."
) from exc
# result persistence settings
if persist_result is None:
if result_storage is not None or result_serializer is not None:
persist_result = True
self.persist_result = persist_result
if result_storage and not isinstance(result_storage, str):
if getattr(result_storage, "_block_document_id", None) is None:
raise TypeError(
"Result storage configuration must be persisted server-side."
" Please call `.save()` on your block before passing it in."
)
self.result_storage = result_storage
self.result_serializer = result_serializer
self.cache_result_in_memory = cache_result_in_memory
self.on_completion_hooks = on_completion or []
self.on_failure_hooks = on_failure or []
self.on_cancellation_hooks = on_cancellation or []
self.on_crashed_hooks = on_crashed or []
self.on_running_hooks = on_running or []
# Used for flows loaded from remote storage
self._storage: Optional["RunnerStorage"] = None
self._entrypoint: Optional[str] = None
module = fn.__module__
if module in ("__main__", "__prefect_loader__"):
module_name = inspect.getfile(fn)
module = module_name if module_name != "__main__" else module
self._entrypoint = f"{module}:{fn.__name__}"
@property
def ismethod(self) -> bool:
return hasattr(self.fn, "__prefect_self__")
def __get__(self, instance: Any, owner: Any):
"""
Implement the descriptor protocol so that the flow can be used as an instance method.
When an instance method is loaded, this method is called with the "self" instance as
an argument. We return a copy of the flow with that instance bound to the flow's function.
"""
# if no instance is provided, it's being accessed on the class
if instance is None:
return self
# if the flow is being accessed on an instance, bind the instance to the __prefect_self__ attribute
# of the flow's function. This will allow it to be automatically added to the flow's parameters
else:
bound_flow = copy(self)
bound_flow.fn.__prefect_self__ = instance
return bound_flow
def with_options(
self,
*,
name: Optional[str] = None,
version: Optional[str] = None,
retries: Optional[int] = None,
retry_delay_seconds: Optional[Union[int, float]] = None,
description: Optional[str] = None,
flow_run_name: Optional[Union[Callable[[], str], str]] = None,
task_runner: Union[
Type[TaskRunner[PrefectFuture[R]]], TaskRunner[PrefectFuture[R]], None
] = None,
timeout_seconds: Union[int, float, None] = None,
validate_parameters: Optional[bool] = None,
persist_result: Optional[bool] = NotSet, # type: ignore
result_storage: Optional[ResultStorage] = NotSet, # type: ignore
result_serializer: Optional[ResultSerializer] = NotSet, # type: ignore
cache_result_in_memory: Optional[bool] = None,
log_prints: Optional[bool] = NotSet, # type: ignore
on_completion: Optional[list[StateHookCallable]] = None,
on_failure: Optional[list[StateHookCallable]] = None,
on_cancellation: Optional[list[StateHookCallable]] = None,
on_crashed: Optional[list[StateHookCallable]] = None,
on_running: Optional[list[StateHookCallable]] = None,
) -> "Flow[P, R]":
"""
Create a new flow from the current object, updating provided options.
Args:
name: A new name for the flow.
version: A new version for the flow.
description: A new description for the flow.
flow_run_name: An optional name to distinguish runs of this flow; this name
can be provided as a string template with the flow's parameters as variables,
or a function that returns a string.
task_runner: A new task runner for the flow.
timeout_seconds: A new number of seconds to fail the flow after if still
running.
validate_parameters: A new value indicating if flow calls should validate
given parameters.
retries: A new number of times to retry on flow run failure.
retry_delay_seconds: A new number of seconds to wait before retrying the
flow after failure. This is only applicable if `retries` is nonzero.
persist_result: A new option for enabling or disabling result persistence.
result_storage: A new storage type to use for results.
result_serializer: A new serializer to use for results.
cache_result_in_memory: A new value indicating if the flow's result should
be cached in memory.
on_failure: A new list of callables to run when the flow enters a failed state.
on_completion: A new list of callables to run when the flow enters a completed state.
on_cancellation: A new list of callables to run when the flow enters a cancelling state.
on_crashed: A new list of callables to run when the flow enters a crashed state.
on_running: A new list of callables to run when the flow enters a running state.
Returns:
A new `Flow` instance.
Examples:
Create a new flow from an existing flow and update the name:
>>> @flow(name="My flow")
>>> def my_flow():
>>> return 1
>>>
>>> new_flow = my_flow.with_options(name="My new flow")
Create a new flow from an existing flow, update the task runner, and call
it without an intermediate variable:
>>> from prefect.task_runners import ThreadPoolTaskRunner
>>>
>>> @flow
>>> def my_flow(x, y):
>>> return x + y
>>>
>>> state = my_flow.with_options(task_runner=ThreadPoolTaskRunner)(1, 3)
>>> assert state.result() == 4
"""
new_flow = Flow(
fn=self.fn,
name=name or self.name,
description=description or self.description,
flow_run_name=flow_run_name or self.flow_run_name,
version=version or self.version,
task_runner=task_runner or self.task_runner,
retries=retries if retries is not None else self.retries,
retry_delay_seconds=(
retry_delay_seconds
if retry_delay_seconds is not None
else self.retry_delay_seconds
),
timeout_seconds=(
timeout_seconds if timeout_seconds is not None else self.timeout_seconds
),
validate_parameters=(
validate_parameters
if validate_parameters is not None
else self.should_validate_parameters
),
persist_result=(
persist_result if persist_result is not NotSet else self.persist_result
),
result_storage=(
result_storage if result_storage is not NotSet else self.result_storage
),
result_serializer=(
result_serializer
if result_serializer is not NotSet
else self.result_serializer
),
cache_result_in_memory=(
cache_result_in_memory
if cache_result_in_memory is not None
else self.cache_result_in_memory
),
log_prints=log_prints if log_prints is not NotSet else self.log_prints,
on_completion=on_completion or self.on_completion_hooks,
on_failure=on_failure or self.on_failure_hooks,
on_cancellation=on_cancellation or self.on_cancellation_hooks,
on_crashed=on_crashed or self.on_crashed_hooks,
on_running=on_running or self.on_running_hooks,
)
new_flow._storage = self._storage
new_flow._entrypoint = self._entrypoint
return new_flow
def validate_parameters(self, parameters: dict[str, Any]) -> dict[str, Any]:
"""
Validate parameters for compatibility with the flow by attempting to cast the inputs to the
associated types specified by the function's type annotations.
Returns:
A new dict of parameters that have been cast to the appropriate types
Raises:
ParameterTypeError: if the provided parameters are not valid
"""
def resolve_block_reference(data: Any) -> Any:
if isinstance(data, dict) and "$ref" in data:
return Block.load_from_ref(data["$ref"], _sync=True)
return data
try:
parameters = visit_collection(
parameters, resolve_block_reference, return_data=True
)
except (ValueError, RuntimeError) as exc:
raise ParameterTypeError(
"Failed to resolve block references in parameters."
) from exc
args, kwargs = parameters_to_args_kwargs(self.fn, parameters)
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", category=pydantic.warnings.PydanticDeprecatedSince20
)
has_v1_models = any(isinstance(o, V1BaseModel) for o in args) or any(
isinstance(o, V1BaseModel) for o in kwargs.values()
)
has_v2_types = any(is_v2_type(o) for o in args) or any(
is_v2_type(o) for o in kwargs.values()
)
if has_v1_models and has_v2_types:
raise ParameterTypeError(
"Cannot mix Pydantic v1 and v2 types as arguments to a flow."
)
if has_v1_models:
validated_fn = V1ValidatedFunction(
self.fn, config={"arbitrary_types_allowed": True}
)
else:
validated_fn = V2ValidatedFunction(
self.fn, config=pydantic.ConfigDict(arbitrary_types_allowed=True)
)
try:
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", category=pydantic.warnings.PydanticDeprecatedSince20
)
model = validated_fn.init_model_instance(*args, **kwargs)
except pydantic.ValidationError as exc:
# We capture the pydantic exception and raise our own because the pydantic
# exception is not picklable when using a cythonized pydantic installation
logger.error(
f"Parameter validation failed for flow {self.name!r}: {exc.errors()}"
f"\nParameters: {parameters}"
)
raise ParameterTypeError.from_validation_error(exc) from None
# Get the updated parameter dict with cast values from the model
cast_parameters = {
k: v
for k, v in dict(iter(model)).items()
if k in model.model_fields_set or model.model_fields[k].default_factory
}
return cast_parameters
def serialize_parameters(self, parameters: dict[str, Any]) -> dict[str, Any]:
"""
Convert parameters to a serializable form.
Uses FastAPI's `jsonable_encoder` to convert to JSON compatible objects without
converting everything directly to a string. This maintains basic types like
integers during API roundtrips.
"""
serialized_parameters = {}
for key, value in parameters.items():
# do not serialize the bound self object
if self.ismethod and value is self.fn.__prefect_self__:
continue
if isinstance(value, (PrefectFuture, State)):
# Don't call jsonable_encoder() on a PrefectFuture or State to
# avoid triggering a __getitem__ call
serialized_parameters[key] = f"<{type(value).__name__}>"
continue
try:
serialized_parameters[key] = jsonable_encoder(value)
except (TypeError, ValueError):
logger.debug(
f"Parameter {key!r} for flow {self.name!r} is unserializable. "
f"Type {type(value).__name__!r} and will not be stored "
"in the backend."
)
serialized_parameters[key] = f"<{type(value).__name__}>"
return serialized_parameters
@sync_compatible
async def to_deployment(
self,
name: str,
interval: Optional[
Union[
Iterable[Union[int, float, datetime.timedelta]],
int,
float,
datetime.timedelta,
]
] = None,
cron: Optional[Union[Iterable[str], str]] = None,
rrule: Optional[Union[Iterable[str], str]] = None,
paused: Optional[bool] = None,
schedules: Optional["FlexibleScheduleList"] = None,
concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
parameters: Optional[dict[str, Any]] = None,
triggers: Optional[list[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
description: Optional[str] = None,
tags: Optional[list[str]] = None,
version: Optional[str] = None,
enforce_parameter_schema: bool = True,
work_pool_name: Optional[str] = None,
work_queue_name: Optional[str] = None,
job_variables: Optional[dict[str, Any]] = None,
entrypoint_type: EntrypointType = EntrypointType.FILE_PATH,
) -> "RunnerDeployment":
"""
Creates a runner deployment object for this flow.
Args:
name: The name to give the created deployment.
interval: An interval on which to execute the new deployment. Accepts either a number
or a timedelta object. If a number is given, it will be interpreted as seconds.
cron: A cron schedule of when to execute runs of this deployment.
rrule: An rrule schedule of when to execute runs of this deployment.
paused: Whether or not to set this deployment as paused.
schedules: A list of schedule objects defining when to execute runs of this deployment.
Used to define multiple schedules or additional scheduling options such as `timezone`.
concurrency_limit: The maximum number of runs of this deployment that can run at the same time.
parameters: A dictionary of default parameter values to pass to runs of this deployment.
triggers: A list of triggers that will kick off runs of this deployment.
description: A description for the created deployment. Defaults to the flow's
description if not provided.
tags: A list of tags to associate with the created deployment for organizational
purposes.
version: A version for the created deployment. Defaults to the flow's version.
enforce_parameter_schema: Whether or not the Prefect API should enforce the
parameter schema for the created deployment.
work_pool_name: The name of the work pool to use for this deployment.
work_queue_name: The name of the work queue to use for this deployment's scheduled runs.
If not provided the default work queue for the work pool will be used.
job_variables: Settings used to override the values specified default base job template
of the chosen work pool. Refer to the base job template of the chosen work pool for
entrypoint_type: Type of entrypoint to use for the deployment. When using a module path
entrypoint, ensure that the module will be importable in the execution environment.
Examples:
Prepare two deployments and serve them:
```python
from prefect import flow, serve
@flow
def my_flow(name):
print(f"hello {name}")
@flow
def my_other_flow(name):
print(f"goodbye {name}")
if __name__ == "__main__":
hello_deploy = my_flow.to_deployment("hello", tags=["dev"])
bye_deploy = my_other_flow.to_deployment("goodbye", tags=["dev"])
serve(hello_deploy, bye_deploy)
```
"""
from prefect.deployments.runner import RunnerDeployment
if not name.endswith(".py"):
_raise_on_name_with_banned_characters(name)
if self._storage and self._entrypoint:
return await RunnerDeployment.from_storage(
storage=self._storage,
entrypoint=self._entrypoint,
name=name,
flow_name=self.name,
interval=interval,
cron=cron,
rrule=rrule,
paused=paused,
schedules=schedules,
concurrency_limit=concurrency_limit,
tags=tags,
triggers=triggers,
parameters=parameters or {},
description=description,
version=version,
enforce_parameter_schema=enforce_parameter_schema,
work_pool_name=work_pool_name,
work_queue_name=work_queue_name,
job_variables=job_variables,
) # type: ignore # TODO: remove sync_compatible
else:
return RunnerDeployment.from_flow(
flow=self,
name=name,
interval=interval,
cron=cron,
rrule=rrule,
paused=paused,
schedules=schedules,
concurrency_limit=concurrency_limit,
tags=tags,
triggers=triggers,
parameters=parameters or {},
description=description,
version=version,
enforce_parameter_schema=enforce_parameter_schema,
work_pool_name=work_pool_name,
work_queue_name=work_queue_name,
job_variables=job_variables,
entrypoint_type=entrypoint_type,
)
def on_completion(self, fn: StateHookCallable) -> StateHookCallable:
self.on_completion_hooks.append(fn)
return fn
def on_cancellation(self, fn: StateHookCallable) -> StateHookCallable:
self.on_cancellation_hooks.append(fn)
return fn
def on_crashed(self, fn: StateHookCallable) -> StateHookCallable:
self.on_crashed_hooks.append(fn)
return fn
def on_running(self, fn: StateHookCallable) -> StateHookCallable:
self.on_running_hooks.append(fn)
return fn
def on_failure(self, fn: StateHookCallable) -> StateHookCallable:
self.on_failure_hooks.append(fn)
return fn
def serve(
self,
name: Optional[str] = None,
interval: Optional[
Union[
Iterable[Union[int, float, datetime.timedelta]],
int,
float,
datetime.timedelta,
]
] = None,
cron: Optional[Union[Iterable[str], str]] = None,
rrule: Optional[Union[Iterable[str], str]] = None,
paused: Optional[bool] = None,
schedules: Optional["FlexibleScheduleList"] = None,
global_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
triggers: Optional[list[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
parameters: Optional[dict[str, Any]] = None,
description: Optional[str] = None,
tags: Optional[list[str]] = None,
version: Optional[str] = None,
enforce_parameter_schema: bool = True,
pause_on_shutdown: bool = True,
print_starting_message: bool = True,
limit: Optional[int] = None,
webserver: bool = False,
entrypoint_type: EntrypointType = EntrypointType.FILE_PATH,
):
"""
Creates a deployment for this flow and starts a runner to monitor for scheduled work.
Args:
name: The name to give the created deployment. Defaults to the name of the flow.
interval: An interval on which to execute the deployment. Accepts a number or a
timedelta object to create a single schedule. If a number is given, it will be
interpreted as seconds. Also accepts an iterable of numbers or timedelta to create
multiple schedules.
cron: A cron schedule string of when to execute runs of this deployment.
Also accepts an iterable of cron schedule strings to create multiple schedules.
rrule: An rrule schedule string of when to execute runs of this deployment.
Also accepts an iterable of rrule schedule strings to create multiple schedules.
triggers: A list of triggers that will kick off runs of this deployment.
paused: Whether or not to set this deployment as paused.
schedules: A list of schedule objects defining when to execute runs of this deployment.
Used to define multiple schedules or additional scheduling options like `timezone`.
global_limit: The maximum number of concurrent runs allowed across all served flow instances associated with the same deployment.
parameters: A dictionary of default parameter values to pass to runs of this deployment.
description: A description for the created deployment. Defaults to the flow's
description if not provided.
tags: A list of tags to associate with the created deployment for organizational
purposes.
version: A version for the created deployment. Defaults to the flow's version.
enforce_parameter_schema: Whether or not the Prefect API should enforce the
parameter schema for the created deployment.
pause_on_shutdown: If True, provided schedule will be paused when the serve function is stopped.
If False, the schedules will continue running.
print_starting_message: Whether or not to print the starting message when flow is served.
limit: The maximum number of runs that can be executed concurrently by the created runner; only applies to this served flow. To apply a limit across multiple served flows, use `global_limit`.
webserver: Whether or not to start a monitoring webserver for this flow.
entrypoint_type: Type of entrypoint to use for the deployment. When using a module path
entrypoint, ensure that the module will be importable in the execution environment.
Examples:
Serve a flow:
```python
from prefect import flow
@flow
def my_flow(name):
print(f"hello {name}")
if __name__ == "__main__":
my_flow.serve("example-deployment")
```
Serve a flow and run it every hour:
```python
from prefect import flow
@flow
def my_flow(name):
print(f"hello {name}")
if __name__ == "__main__":
my_flow.serve("example-deployment", interval=3600)
```
"""
from prefect.runner import Runner
if not name:
name = self.name
else:
# Handling for my_flow.serve(__file__)
# Will set name to name of file where my_flow.serve() without the extension
# Non filepath strings will pass through unchanged
name = Path(name).stem
runner = Runner(name=name, pause_on_shutdown=pause_on_shutdown, limit=limit)
deployment_id = runner.add_flow(
self,
name=name,
triggers=triggers,
interval=interval,
cron=cron,
rrule=rrule,
paused=paused,
schedules=schedules,
concurrency_limit=global_limit,
parameters=parameters,
description=description,
tags=tags,
version=version,
enforce_parameter_schema=enforce_parameter_schema,
entrypoint_type=entrypoint_type,
)
if print_starting_message:
help_message = (
f"[green]Your flow {self.name!r} is being served and polling for"
" scheduled runs!\n[/]\nTo trigger a run for this flow, use the"
" following command:\n[blue]\n\t$ prefect deployment run"
f" '{self.name}/{name}'\n[/]"
)
if PREFECT_UI_URL:
help_message += (
"\nYou can also run your flow via the Prefect UI:"
f" [blue]{PREFECT_UI_URL.value()}/deployments/deployment/{deployment_id}[/]\n"
)
console = Console()
console.print(help_message, soft_wrap=True)
try:
loop = asyncio.get_running_loop()
except RuntimeError as exc:
if "no running event loop" in str(exc):
loop = None
else:
raise
try:
if loop is not None:
loop.run_until_complete(runner.start(webserver=webserver))
else:
asyncio.run(runner.start(webserver=webserver))
except (KeyboardInterrupt, TerminationSignal) as exc:
logger.info(f"Received {type(exc).__name__}, shutting down...")
if loop is not None:
loop.stop()
@classmethod
@sync_compatible
async def from_source(
cls: Type["Flow[P, R]"],
source: Union[str, "RunnerStorage", ReadableDeploymentStorage],
entrypoint: str,
) -> "Flow[P, R]":
"""
Loads a flow from a remote source.
Args:
source: Either a URL to a git repository or a storage object.
entrypoint: The path to a file containing a flow and the name of the flow function in
the format `./path/to/file.py:flow_func_name`.
Returns:
A new `Flow` instance.
Examples:
Load a flow from a public git repository:
```python
from prefect import flow
from prefect.runner.storage import GitRepository
from prefect.blocks.system import Secret
my_flow = flow.from_source(
source="https://github.com/org/repo.git",
entrypoint="flows.py:my_flow",
)
my_flow()
```
Load a flow from a private git repository using an access token stored in a `Secret` block:
```python
from prefect import flow
from prefect.runner.storage import GitRepository
from prefect.blocks.system import Secret
my_flow = flow.from_source(
source=GitRepository(
url="https://github.com/org/repo.git",
credentials={"access_token": Secret.load("github-access-token")}
),
entrypoint="flows.py:my_flow",
)
my_flow()
```
Load a flow from a local directory:
``` python
# from_local_source.py
from pathlib import Path
from prefect import flow
@flow(log_prints=True)
def my_flow(name: str = "world"):
print(f"Hello {name}! I'm a flow from a Python script!")
if __name__ == "__main__":
my_flow.from_source(
source=str(Path(__file__).parent),
entrypoint="from_local_source.py:my_flow",
).deploy(
name="my-deployment",
parameters=dict(name="Marvin"),
work_pool_name="local",
)
```
"""
from prefect.runner.storage import (
BlockStorageAdapter,
LocalStorage,
RunnerStorage,
create_storage_from_source,
)
if isinstance(source, (Path, str)):
if isinstance(source, Path):
source = str(source)
storage = create_storage_from_source(source)
elif isinstance(source, RunnerStorage):
storage = source
elif hasattr(source, "get_directory"):
storage = BlockStorageAdapter(source)
else:
raise TypeError(
f"Unsupported source type {type(source).__name__!r}. Please provide a"
" URL to remote storage or a storage object."
)
with tempfile.TemporaryDirectory() as tmpdir:
if not isinstance(storage, LocalStorage):
storage.set_base_path(Path(tmpdir))
await storage.pull_code()
full_entrypoint = str(storage.destination / entrypoint)
flow = cast(
Flow[P, R],
await from_async.wait_for_call_in_new_thread(
create_call(load_flow_from_entrypoint, full_entrypoint)
),
)
flow._storage = storage
flow._entrypoint = entrypoint
return flow
@sync_compatible
async def deploy(
self,
name: str,
work_pool_name: Optional[str] = None,
image: Optional[Union[str, DockerImage]] = None,
build: bool = True,
push: bool = True,
work_queue_name: Optional[str] = None,
job_variables: Optional[dict[str, Any]] = None,
interval: Optional[Union[int, float, datetime.timedelta]] = None,
cron: Optional[str] = None,
rrule: Optional[str] = None,
paused: Optional[bool] = None,
schedules: Optional[list[DeploymentScheduleCreate]] = None,
concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
triggers: Optional[list[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
parameters: Optional[dict[str, Any]] = None,
description: Optional[str] = None,
tags: Optional[list[str]] = None,
version: Optional[str] = None,
enforce_parameter_schema: bool = True,
entrypoint_type: EntrypointType = EntrypointType.FILE_PATH,
print_next_steps: bool = True,
ignore_warnings: bool = False,
) -> UUID:
"""
Deploys a flow to run on dynamic infrastructure via a work pool.
By default, calling this method will build a Docker image for the flow, push it to a registry,
and create a deployment via the Prefect API that will run the flow on the given schedule.
If you want to use an existing image, you can pass `build=False` to skip building and pushing
an image.
Args:
name: The name to give the created deployment.
work_pool_name: The name of the work pool to use for this deployment. Defaults to
the value of `PREFECT_DEFAULT_WORK_POOL_NAME`.
image: The name of the Docker image to build, including the registry and
repository. Pass a DockerImage instance to customize the Dockerfile used
and build arguments.
build: Whether or not to build a new image for the flow. If False, the provided
image will be used as-is and pulled at runtime.
push: Whether or not to skip pushing the built image to a registry.
work_queue_name: The name of the work queue to use for this deployment's scheduled runs.
If not provided the default work queue for the work pool will be used.
job_variables: Settings used to override the values specified default base job template
of the chosen work pool. Refer to the base job template of the chosen work pool for
available settings.
interval: An interval on which to execute the deployment. Accepts a number or a
timedelta object to create a single schedule. If a number is given, it will be
interpreted as seconds. Also accepts an iterable of numbers or timedelta to create
multiple schedules.
cron: A cron schedule string of when to execute runs of this deployment.
Also accepts an iterable of cron schedule strings to create multiple schedules.
rrule: An rrule schedule string of when to execute runs of this deployment.
Also accepts an iterable of rrule schedule strings to create multiple schedules.
triggers: A list of triggers that will kick off runs of this deployment.
paused: Whether or not to set this deployment as paused.
schedules: A list of schedule objects defining when to execute runs of this deployment.
Used to define multiple schedules or additional scheduling options like `timezone`.
concurrency_limit: The maximum number of runs that can be executed concurrently.
parameters: A dictionary of default parameter values to pass to runs of this deployment.
description: A description for the created deployment. Defaults to the flow's
description if not provided.
tags: A list of tags to associate with the created deployment for organizational
purposes.
version: A version for the created deployment. Defaults to the flow's version.
enforce_parameter_schema: Whether or not the Prefect API should enforce the
parameter schema for the created deployment.
entrypoint_type: Type of entrypoint to use for the deployment. When using a module path
entrypoint, ensure that the module will be importable in the execution environment.
print_next_steps_message: Whether or not to print a message with next steps
after deploying the deployments.
ignore_warnings: Whether or not to ignore warnings about the work pool type.
Returns:
The ID of the created/updated deployment.
Examples:
Deploy a local flow to a work pool:
```python
from prefect import flow
@flow
def my_flow(name):
print(f"hello {name}")
if __name__ == "__main__":
my_flow.deploy(
"example-deployment",
work_pool_name="my-work-pool",
image="my-repository/my-image:dev",
)
```
Deploy a remotely stored flow to a work pool:
```python
from prefect import flow
if __name__ == "__main__":
flow.from_source(
source="https://github.com/org/repo.git",
entrypoint="flows.py:my_flow",
).deploy(
"example-deployment",
work_pool_name="my-work-pool",
image="my-repository/my-image:dev",
)
```
"""
if not (
work_pool_name := work_pool_name or PREFECT_DEFAULT_WORK_POOL_NAME.value()
):
raise ValueError(
"No work pool name provided. Please provide a `work_pool_name` or set the"
" `PREFECT_DEFAULT_WORK_POOL_NAME` environment variable."
)
from prefect.client.orchestration import get_client
try:
async with get_client() as client:
work_pool = await client.read_work_pool(work_pool_name)
active_workers = await client.read_workers_for_work_pool(
work_pool_name,
worker_filter=WorkerFilter(status={"any_": ["ONLINE"]}),
)
except ObjectNotFound as exc:
raise ValueError(
f"Could not find work pool {work_pool_name!r}. Please create it before"
" deploying this flow."
) from exc
deployment = await self.to_deployment(
name=name,
interval=interval,
cron=cron,
rrule=rrule,
schedules=schedules,
concurrency_limit=concurrency_limit,
paused=paused,
triggers=triggers,
parameters=parameters,
description=description,
tags=tags,
version=version,
enforce_parameter_schema=enforce_parameter_schema,
work_queue_name=work_queue_name,
job_variables=job_variables,
entrypoint_type=entrypoint_type,
)
from prefect.deployments.runner import deploy
deployment_ids = await deploy(
deployment,
work_pool_name=work_pool_name,
image=image,
build=build,
push=push,
print_next_steps_message=False,
ignore_warnings=ignore_warnings,
)
if print_next_steps:
console = Console()
if (
not work_pool.is_push_pool
and not work_pool.is_managed_pool
and not active_workers
):
console.print(
"\nTo execute flow runs from this deployment, start a worker in a"
" separate terminal that pulls work from the"
f" {work_pool_name!r} work pool:"
)
console.print(
f"\n\t$ prefect worker start --pool {work_pool_name!r}",
style="blue",
)
console.print(
"\nTo schedule a run for this deployment, use the following command:"
)
console.print(
f"\n\t$ prefect deployment run '{self.name}/{name}'\n",
style="blue",
)
if PREFECT_UI_URL:
message = (
"\nYou can also run your flow via the Prefect UI:"
f" [blue]{PREFECT_UI_URL.value()}/deployments/deployment/{deployment_ids[0]}[/]\n"
)
console.print(message, soft_wrap=True)
return deployment_ids[0]
@overload
def __call__(self: "Flow[P, NoReturn]", *args: P.args, **kwargs: P.kwargs) -> None:
# `NoReturn` matches if a type can't be inferred for the function which stops a
# sync function from matching the `Coroutine` overload
...
@overload
def __call__(
self: "Flow[P, Coroutine[Any, Any, T]]", *args: P.args, **kwargs: P.kwargs
) -> Coroutine[Any, Any, T]:
...
@overload
def __call__(
self: "Flow[P, T]",
*args: P.args,
**kwargs: P.kwargs,
) -> T:
...
@overload
def __call__(
self: "Flow[P, Coroutine[Any, Any, T]]",
*args: P.args,
return_state: Literal[True],
**kwargs: P.kwargs,
) -> Awaitable[State[T]]:
...
@overload
def __call__(
self: "Flow[P, T]",
*args: P.args,
return_state: Literal[True],
**kwargs: P.kwargs,
) -> State[T]:
...
def __call__(
self,
*args: "P.args",
return_state: bool = False,
wait_for: Optional[Iterable[PrefectFuture[Any]]] = None,
**kwargs: "P.kwargs",
):
"""
Run the flow and return its result.
Flow parameter values must be serializable by Pydantic.
If writing an async flow, this call must be awaited.
This will create a new flow run in the API.
Args:
*args: Arguments to run the flow with.
return_state: Return a Prefect State containing the result of the
flow run.
wait_for: Upstream task futures to wait for before starting the flow if called as a subflow
**kwargs: Keyword arguments to run the flow with.
Returns:
If `return_state` is False, returns the result of the flow run.
If `return_state` is True, returns the result of the flow run
wrapped in a Prefect State which provides error handling.
Examples:
Define a flow
>>> @flow
>>> def my_flow(name):
>>> print(f"hello {name}")
>>> return f"goodbye {name}"
Run a flow
>>> my_flow("marvin")
hello marvin
"goodbye marvin"
Run a flow with additional tags
>>> from prefect import tags
>>> with tags("db", "blue"):
>>> my_flow("foo")
"""
from prefect.utilities.visualization import (
get_task_viz_tracker,
track_viz_task,
)
# Convert the call args/kwargs to a parameter dict
parameters = get_call_parameters(self.fn, args, kwargs)
return_type = "state" if return_state else "result"
task_viz_tracker = get_task_viz_tracker()
if task_viz_tracker:
# this is a subflow, for now return a single task and do not go further
# we can add support for exploring subflows for tasks in the future.
return track_viz_task(self.isasync, self.name, parameters)
from prefect.flow_engine import run_flow
return run_flow(
flow=self,
parameters=parameters,
wait_for=wait_for,
return_type=return_type,
)
@sync_compatible
async def visualize(self, *args: "P.args", **kwargs: "P.kwargs"):
"""
Generates a graphviz object representing the current flow. In IPython notebooks,
it's rendered inline, otherwise in a new window as a PNG.
Raises:
- ImportError: If `graphviz` isn't installed.
- GraphvizExecutableNotFoundError: If the `dot` executable isn't found.
- FlowVisualizationError: If the flow can't be visualized for any other reason.
"""
from prefect.utilities.visualization import (
FlowVisualizationError,
GraphvizExecutableNotFoundError,
GraphvizImportError,
TaskVizTracker,
VisualizationUnsupportedError,
build_task_dependencies,
visualize_task_dependencies,
)
if not PREFECT_TESTING_UNIT_TEST_MODE:
warnings.warn(
"`flow.visualize()` will execute code inside of your flow that is not"
" decorated with `@task` or `@flow`."
)
try:
with TaskVizTracker() as tracker:
if self.isasync:
await self.fn(*args, **kwargs) # type: ignore[reportGeneralTypeIssues]
else:
self.fn(*args, **kwargs)
graph = build_task_dependencies(tracker)
visualize_task_dependencies(graph, self.name)
except GraphvizImportError:
raise
except GraphvizExecutableNotFoundError:
raise
except VisualizationUnsupportedError:
raise
except FlowVisualizationError:
raise
except Exception as e:
msg = (
"It's possible you are trying to visualize a flow that contains "
"code that directly interacts with the result of a task"
" inside of the flow. \nTry passing a `viz_return_value` "
"to the task decorator, e.g. `@task(viz_return_value=[1, 2, 3]).`"
)
new_exception = type(e)(str(e) + "\n" + msg)
# Copy traceback information from the original exception
new_exception.__traceback__ = e.__traceback__
raise new_exception
@overload
def flow(__fn: Callable[P, R]) -> Flow[P, R]:
...
@overload
def flow(
*,
name: Optional[str] = None,
version: Optional[str] = None,
flow_run_name: Optional[Union[Callable[[], str], str]] = None,
retries: Optional[int] = None,
retry_delay_seconds: Optional[Union[int, float]] = None,
task_runner: Optional[TaskRunner[PrefectFuture[R]]] = None,
description: Optional[str] = None,
timeout_seconds: Union[int, float, None] = None,
validate_parameters: bool = True,
persist_result: Optional[bool] = None,
result_storage: Optional[ResultStorage] = None,
result_serializer: Optional[ResultSerializer] = None,
cache_result_in_memory: bool = True,
log_prints: Optional[bool] = None,
on_completion: Optional[list[StateHookCallable]] = None,
on_failure: Optional[list[StateHookCallable]] = None,
on_cancellation: Optional[list[StateHookCallable]] = None,
on_crashed: Optional[list[StateHookCallable]] = None,
on_running: Optional[list[StateHookCallable]] = None,
) -> Callable[[Callable[P, R]], Flow[P, R]]:
...
def flow(
__fn: Optional[Callable[P, R]] = None,
*,
name: Optional[str] = None,
version: Optional[str] = None,
flow_run_name: Optional[Union[Callable[[], str], str]] = None,
retries: Optional[int] = None,
retry_delay_seconds: Union[int, float, None] = None,
task_runner: Optional[TaskRunner[PrefectFuture[R]]] = None,
description: Optional[str] = None,
timeout_seconds: Union[int, float, None] = None,
validate_parameters: bool = True,
persist_result: Optional[bool] = None,
result_storage: Optional[ResultStorage] = None,
result_serializer: Optional[ResultSerializer] = None,
cache_result_in_memory: bool = True,
log_prints: Optional[bool] = None,
on_completion: Optional[list[StateHookCallable]] = None,
on_failure: Optional[list[StateHookCallable]] = None,
on_cancellation: Optional[list[StateHookCallable]] = None,
on_crashed: Optional[list[StateHookCallable]] = None,
on_running: Optional[list[StateHookCallable]] = None,
):
"""
Decorator to designate a function as a Prefect workflow.
This decorator may be used for asynchronous or synchronous functions.
Flow parameters must be serializable by Pydantic.
Args:
name: An optional name for the flow; if not provided, the name will be inferred
from the given function.
version: An optional version string for the flow; if not provided, we will
attempt to create a version string as a hash of the file containing the
wrapped function; if the file cannot be located, the version will be null.
flow_run_name: An optional name to distinguish runs of this flow; this name can
be provided as a string template with the flow's parameters as variables,
or a function that returns a string.
retries: An optional number of times to retry on flow run failure.
retry_delay_seconds: An optional number of seconds to wait before retrying the
flow after failure. This is only applicable if `retries` is nonzero.
task_runner: An optional task runner to use for task execution within the flow; if
not provided, a `ConcurrentTaskRunner` will be instantiated.
description: An optional string description for the flow; if not provided, the
description will be pulled from the docstring for the decorated function.
timeout_seconds: An optional number of seconds indicating a maximum runtime for
the flow. If the flow exceeds this runtime, it will be marked as failed.
Flow execution may continue until the next task is called.
validate_parameters: By default, parameters passed to flows are validated by
Pydantic. This will check that input values conform to the annotated types
on the function. Where possible, values will be coerced into the correct
type; for example, if a parameter is defined as `x: int` and "5" is passed,
it will be resolved to `5`. If set to `False`, no validation will be
performed on flow parameters.
persist_result: An optional toggle indicating whether the result of this flow
should be persisted to result storage. Defaults to `None`, which indicates
that Prefect should choose whether the result should be persisted depending on
the features being used.
result_storage: An optional block to use to persist the result of this flow.
This value will be used as the default for any tasks in this flow.
If not provided, the local file system will be used unless called as
a subflow, at which point the default will be loaded from the parent flow.
result_serializer: An optional serializer to use to serialize the result of this
flow for persistence. This value will be used as the default for any tasks
in this flow. If not provided, the value of `PREFECT_RESULTS_DEFAULT_SERIALIZER`
will be used unless called as a subflow, at which point the default will be
loaded from the parent flow.
cache_result_in_memory: An optional toggle indicating whether the cached result of
a running the flow should be stored in memory. Defaults to `True`.
log_prints: If set, `print` statements in the flow will be redirected to the
Prefect logger for the flow run. Defaults to `None`, which indicates that
the value from the parent flow should be used. If this is a parent flow,
the default is pulled from the `PREFECT_LOGGING_LOG_PRINTS` setting.
on_completion: An optional list of functions to call when the flow run is
completed. Each function should accept three arguments: the flow, the flow
run, and the final state of the flow run.
on_failure: An optional list of functions to call when the flow run fails. Each
function should accept three arguments: the flow, the flow run, and the
final state of the flow run.
on_cancellation: An optional list of functions to call when the flow run is
cancelled. These functions will be passed the flow, flow run, and final state.
on_crashed: An optional list of functions to call when the flow run crashes. Each
function should accept three arguments: the flow, the flow run, and the
final state of the flow run.
on_running: An optional list of functions to call when the flow run is started. Each
function should accept three arguments: the flow, the flow run, and the current state
Returns:
A callable `Flow` object which, when called, will run the flow and return its
final state.
Examples:
Define a simple flow
>>> from prefect import flow
>>> @flow
>>> def add(x, y):
>>> return x + y
Define an async flow
>>> @flow
>>> async def add(x, y):
>>> return x + y
Define a flow with a version and description
>>> @flow(version="first-flow", description="This flow is empty!")
>>> def my_flow():
>>> pass
Define a flow with a custom name
>>> @flow(name="The Ultimate Flow")
>>> def my_flow():
>>> pass
Define a flow that submits its tasks to dask
>>> from prefect_dask.task_runners import DaskTaskRunner
>>>
>>> @flow(task_runner=DaskTaskRunner)
>>> def my_flow():
>>> pass
"""
if __fn:
if isinstance(__fn, (classmethod, staticmethod)):
method_decorator = type(__fn).__name__
raise TypeError(f"@{method_decorator} should be applied on top of @flow")
return Flow(
fn=__fn,
name=name,
version=version,
flow_run_name=flow_run_name,
task_runner=task_runner,
description=description,
timeout_seconds=timeout_seconds,
validate_parameters=validate_parameters,
retries=retries,
retry_delay_seconds=retry_delay_seconds,
persist_result=persist_result,
result_storage=result_storage,
result_serializer=result_serializer,
cache_result_in_memory=cache_result_in_memory,
log_prints=log_prints,
on_completion=on_completion,
on_failure=on_failure,
on_cancellation=on_cancellation,
on_crashed=on_crashed,
on_running=on_running,
)
else:
return cast(
Callable[[Callable[P, R]], Flow[P, R]],
partial(
flow,
name=name,
version=version,
flow_run_name=flow_run_name,
task_runner=task_runner,
description=description,
timeout_seconds=timeout_seconds,
validate_parameters=validate_parameters,
retries=retries,
retry_delay_seconds=retry_delay_seconds,
persist_result=persist_result,
result_storage=result_storage,
result_serializer=result_serializer,
cache_result_in_memory=cache_result_in_memory,
log_prints=log_prints,
on_completion=on_completion,
on_failure=on_failure,
on_cancellation=on_cancellation,
on_crashed=on_crashed,
on_running=on_running,
),
)
def _raise_on_name_with_banned_characters(name: Optional[str]) -> Optional[str]:
"""
Raise an InvalidNameError if the given name contains any invalid
characters.
"""
if name is None:
return name
if not re.match(WITHOUT_BANNED_CHARACTERS, name):
raise InvalidNameError(
f"Name {name!r} contains an invalid character. "
f"Must not contain any of: {BANNED_CHARACTERS}."
)
return name
# Add from_source so it is available on the flow function we all know and love
flow.from_source = Flow.from_source
def select_flow(
flows: Iterable[Flow[P, R]],
flow_name: Optional[str] = None,
from_message: Optional[str] = None,
) -> Flow[P, R]:
"""
Select the only flow in an iterable or a flow specified by name.
Returns
A single flow object
Raises:
MissingFlowError: If no flows exist in the iterable
MissingFlowError: If a flow name is provided and that flow does not exist
UnspecifiedFlowError: If multiple flows exist but no flow name was provided
"""
# Convert to flows by name
flows_dict = {f.name: f for f in flows}
# Add a leading space if given, otherwise use an empty string
from_message = (" " + from_message) if from_message else ""
if not Optional:
raise MissingFlowError(f"No flows found{from_message}.")
elif flow_name and flow_name not in flows_dict:
raise MissingFlowError(
f"Flow {flow_name!r} not found{from_message}. "
f"Found the following flows: {listrepr(flows_dict.keys())}. "
"Check to make sure that your flow function is decorated with `@flow`."
)
elif not flow_name and len(flows_dict) > 1:
raise UnspecifiedFlowError(
(
f"Found {len(flows_dict)} flows{from_message}:"
f" {listrepr(sorted(flows_dict.keys()))}. Specify a flow name to select a"
" flow."
),
)
if flow_name:
return flows_dict[flow_name]
else:
return list(flows_dict.values())[0]
def load_flow_from_entrypoint(
entrypoint: str,
use_placeholder_flow: bool = True,
) -> Flow[P, Any]:
"""
Extract a flow object from a script at an entrypoint by running all of the code in the file.
Args:
entrypoint: a string in the format `<path_to_script>:<flow_func_name>` or a module path
to a flow function
use_placeholder_flow: if True, use a placeholder Flow object if the actual flow object
cannot be loaded from the entrypoint (e.g. dependencies are missing)
Returns:
The flow object from the script
Raises:
FlowScriptError: If an exception is encountered while running the script
MissingFlowError: If the flow function specified in the entrypoint does not exist
"""
if ":" in entrypoint:
# split by the last colon once to handle Windows paths with drive letters i.e C:\path\to\file.py:do_stuff
path, func_name = entrypoint.rsplit(":", maxsplit=1)
else:
path, func_name = entrypoint.rsplit(".", maxsplit=1)
try:
flow: Flow[P, Any] = import_object(entrypoint) # pyright: ignore[reportRedeclaration]
except AttributeError as exc:
raise MissingFlowError(
f"Flow function with name {func_name!r} not found in {path!r}. "
) from exc
except ScriptError:
# If the flow has dependencies that are not installed in the current
# environment, fallback to loading the flow via AST parsing.
if use_placeholder_flow:
flow: Optional[Flow[P, Any]] = safe_load_flow_from_entrypoint(entrypoint)
if flow is None:
raise
else:
raise
if not isinstance(flow, Flow): # pyright: ignore[reportUnnecessaryIsInstance]
raise MissingFlowError(
f"Function with name {func_name!r} is not a flow. Make sure that it is "
"decorated with '@flow'."
)
return flow
def serve(
*args: "RunnerDeployment",
pause_on_shutdown: bool = True,
print_starting_message: bool = True,
limit: Optional[int] = None,
**kwargs: Any,
) -> None:
"""
Serve the provided list of deployments.
Args:
*args: A list of deployments to serve.
pause_on_shutdown: A boolean for whether or not to automatically pause
deployment schedules on shutdown.
print_starting_message: Whether or not to print message to the console
on startup.
limit: The maximum number of runs that can be executed concurrently.
**kwargs: Additional keyword arguments to pass to the runner.
Examples:
Prepare two deployments and serve them:
```python
import datetime
from prefect import flow, serve
@flow
def my_flow(name):
print(f"hello {name}")
@flow
def my_other_flow(name):
print(f"goodbye {name}")
if __name__ == "__main__":
# Run once a day
hello_deploy = my_flow.to_deployment(
"hello", tags=["dev"], interval=datetime.timedelta(days=1)
)
# Run every Sunday at 4:00 AM
bye_deploy = my_other_flow.to_deployment(
"goodbye", tags=["dev"], cron="0 4 * * sun"
)
serve(hello_deploy, bye_deploy)
```
"""
from prefect.runner import Runner
if is_in_async_context():
raise RuntimeError(
"Cannot call `serve` in an asynchronous context. Use `aserve` instead."
)
runner = Runner(pause_on_shutdown=pause_on_shutdown, limit=limit, **kwargs)
for deployment in args:
runner.add_deployment(deployment)
if print_starting_message:
_display_serve_start_message(*args)
try:
asyncio.run(runner.start())
except (KeyboardInterrupt, TerminationSignal) as exc:
logger.info(f"Received {type(exc).__name__}, shutting down...")
async def aserve(
*args: "RunnerDeployment",
pause_on_shutdown: bool = True,
print_starting_message: bool = True,
limit: Optional[int] = None,
**kwargs: Any,
) -> None:
"""
Asynchronously serve the provided list of deployments.
Use `serve` instead if calling from a synchronous context.
Args:
*args: A list of deployments to serve.
pause_on_shutdown: A boolean for whether or not to automatically pause
deployment schedules on shutdown.
print_starting_message: Whether or not to print message to the console
on startup.
limit: The maximum number of runs that can be executed concurrently.
**kwargs: Additional keyword arguments to pass to the runner.
Examples:
Prepare deployment and asynchronous initialization function and serve them:
```python
import asyncio
import datetime
from prefect import flow, aserve, get_client
async def init():
await set_concurrency_limit()
async def set_concurrency_limit():
async with get_client() as client:
await client.create_concurrency_limit(tag='dev', concurrency_limit=3)
@flow
async def my_flow(name):
print(f"hello {name}")
async def main():
# Initialization function
await init()
# Run once a day
hello_deploy = await my_flow.to_deployment(
"hello", tags=["dev"], interval=datetime.timedelta(days=1)
)
await aserve(hello_deploy)
if __name__ == "__main__":
asyncio.run(main())
"""
from prefect.runner import Runner
runner = Runner(pause_on_shutdown=pause_on_shutdown, limit=limit, **kwargs)
for deployment in args:
await runner.add_deployment(deployment)
if print_starting_message:
_display_serve_start_message(*args)
await runner.start()
def _display_serve_start_message(*args: "RunnerDeployment"):
from rich.console import Console, Group
from rich.table import Table
help_message_top = (
"[green]Your deployments are being served and polling for"
" scheduled runs!\n[/]"
)
table = Table(title="Deployments", show_header=False)
table.add_column(style="blue", no_wrap=True)
for deployment in args:
table.add_row(f"{deployment.flow_name}/{deployment.name}")
help_message_bottom = (
"\nTo trigger any of these deployments, use the"
" following command:\n[blue]\n\t$ prefect deployment run"
" [DEPLOYMENT_NAME]\n[/]"
)
if PREFECT_UI_URL:
help_message_bottom += (
"\nYou can also trigger your deployments via the Prefect UI:"
f" [blue]{PREFECT_UI_URL.value()}/deployments[/]\n"
)
console = Console()
console.print(Group(help_message_top, table, help_message_bottom), soft_wrap=True)
@client_injector
async def load_flow_from_flow_run(
client: "PrefectClient",
flow_run: "FlowRun",
ignore_storage: bool = False,
storage_base_path: Optional[str] = None,
use_placeholder_flow: bool = True,
) -> Flow[P, Any]:
"""
Load a flow from the location/script provided in a deployment's storage document.
If `ignore_storage=True` is provided, no pull from remote storage occurs. This flag
is largely for testing, and assumes the flow is already available locally.
"""
deployment = await client.read_deployment(flow_run.deployment_id)
if deployment.entrypoint is None:
raise ValueError(
f"Deployment {deployment.id} does not have an entrypoint and can not be run."
)
run_logger = flow_run_logger(flow_run)
runner_storage_base_path = storage_base_path or os.environ.get(
"PREFECT__STORAGE_BASE_PATH"
)
# If there's no colon, assume it's a module path
if ":" not in deployment.entrypoint:
run_logger.debug(
f"Importing flow code from module path {deployment.entrypoint}"
)
flow = await run_sync_in_worker_thread(
load_flow_from_entrypoint,
deployment.entrypoint,
use_placeholder_flow=use_placeholder_flow,
)
return flow
if not ignore_storage and not deployment.pull_steps:
sys.path.insert(0, ".")
if deployment.storage_document_id:
storage_document = await client.read_block_document(
deployment.storage_document_id
)
storage_block = Block._from_block_document(storage_document)
else:
basepath = deployment.path
if runner_storage_base_path:
basepath = str(basepath).replace(
"$STORAGE_BASE_PATH", runner_storage_base_path
)
storage_block = LocalFileSystem(basepath=basepath)
from_path = (
str(deployment.path).replace("$STORAGE_BASE_PATH", runner_storage_base_path)
if runner_storage_base_path and deployment.path
else deployment.path
)
run_logger.info(f"Downloading flow code from storage at {from_path!r}")
await storage_block.get_directory(from_path=from_path, local_path=".")
if deployment.pull_steps:
run_logger.debug(
f"Running {len(deployment.pull_steps)} deployment pull step(s)"
)
from prefect.deployments.steps.core import run_steps
output = await run_steps(deployment.pull_steps)
if output.get("directory"):
run_logger.debug(f"Changing working directory to {output['directory']!r}")
os.chdir(output["directory"])
import_path = relative_path_to_current_platform(deployment.entrypoint)
run_logger.debug(f"Importing flow code from '{import_path}'")
flow = await run_sync_in_worker_thread(
load_flow_from_entrypoint,
str(import_path),
use_placeholder_flow=use_placeholder_flow,
)
return flow
def load_placeholder_flow(entrypoint: str, raises: Exception) -> Flow[P, Any]:
"""
Load a placeholder flow that is initialized with the same arguments as the
flow specified in the entrypoint. If called the flow will raise `raises`.
This is useful when a flow can't be loaded due to missing dependencies or
other issues but the base metadata defining the flow is still needed.
Args:
entrypoint: a string in the format `<path_to_script>:<flow_func_name>`
or a module path to a flow function
raises: an exception to raise when the flow is called
"""
def _base_placeholder():
raise raises
def sync_placeholder_flow(*args: "P.args", **kwargs: "P.kwargs"):
_base_placeholder()
async def async_placeholder_flow(*args: "P.args", **kwargs: "P.kwargs"):
_base_placeholder()
placeholder_flow = (
async_placeholder_flow
if is_entrypoint_async(entrypoint)
else sync_placeholder_flow
)
arguments = load_flow_arguments_from_entrypoint(entrypoint)
arguments["fn"] = placeholder_flow
return Flow(**arguments)
def safe_load_flow_from_entrypoint(entrypoint: str) -> Optional[Flow[P, Any]]:
"""
Load a flow from an entrypoint and return None if an exception is raised.
Args:
entrypoint: a string in the format `<path_to_script>:<flow_func_name>`
or a module path to a flow function
"""
func_def, source_code = _entrypoint_definition_and_source(entrypoint)
path = None
if ":" in entrypoint:
path = entrypoint.rsplit(":")[0]
namespace = safe_load_namespace(source_code, filepath=path)
if func_def.name in namespace:
return namespace[func_def.name]
else:
# If the function is not in the namespace, if may be due to missing dependencies
# for the function. We will attempt to compile each annotation and default value
# and remove them from the function definition to see if the function can be
# compiled without them.
return _sanitize_and_load_flow(func_def, namespace)
def _sanitize_and_load_flow(
func_def: Union[ast.FunctionDef, ast.AsyncFunctionDef], namespace: dict[str, Any]
) -> Optional[Flow[P, Any]]:
"""
Attempt to load a flow from the function definition after sanitizing the annotations
and defaults that can't be compiled.
Args:
func_def: the function definition
namespace: the namespace to load the function into
Returns:
The loaded function or None if the function can't be loaded
after sanitizing the annotations and defaults.
"""
args = func_def.args.posonlyargs + func_def.args.args + func_def.args.kwonlyargs
if func_def.args.vararg:
args.append(func_def.args.vararg)
if func_def.args.kwarg:
args.append(func_def.args.kwarg)
# Remove annotations that can't be compiled
for arg in args:
if arg.annotation is not None:
try:
code = compile(
ast.Expression(arg.annotation),
filename="<ast>",
mode="eval",
)
exec(code, namespace)
except Exception as e:
logger.debug(
"Failed to evaluate annotation for argument %s due to the following error. Ignoring annotation.",
arg.arg,
exc_info=e,
)
arg.annotation = None
# Remove defaults that can't be compiled
new_defaults: list[Any] = []
for default in func_def.args.defaults:
try:
code = compile(ast.Expression(default), "<ast>", "eval")
exec(code, namespace)
new_defaults.append(default)
except Exception as e:
logger.debug(
"Failed to evaluate default value %s due to the following error. Ignoring default.",
default,
exc_info=e,
)
new_defaults.append(
ast.Constant(
value=None, lineno=default.lineno, col_offset=default.col_offset
)
)
func_def.args.defaults = new_defaults
# Remove kw_defaults that can't be compiled
new_kw_defaults: list[Any] = []
for default in func_def.args.kw_defaults:
if default is not None:
try:
code = compile(ast.Expression(default), "<ast>", "eval")
exec(code, namespace)
new_kw_defaults.append(default)
except Exception as e:
logger.debug(
"Failed to evaluate default value %s due to the following error. Ignoring default.",
default,
exc_info=e,
)
new_kw_defaults.append(
ast.Constant(
value=None,
lineno=default.lineno,
col_offset=default.col_offset,
)
)
else:
new_kw_defaults.append(
ast.Constant(
value=None,
lineno=func_def.lineno,
col_offset=func_def.col_offset,
)
)
func_def.args.kw_defaults = new_kw_defaults
if func_def.returns is not None:
try:
code = compile(
ast.Expression(func_def.returns), filename="<ast>", mode="eval"
)
exec(code, namespace)
except Exception as e:
logger.debug(
"Failed to evaluate return annotation due to the following error. Ignoring annotation.",
exc_info=e,
)
func_def.returns = None
# Attempt to compile the function without annotations and defaults that
# can't be compiled
try:
code = compile(
ast.Module(body=[func_def], type_ignores=[]),
filename="<ast>",
mode="exec",
)
exec(code, namespace)
except Exception as e:
logger.debug("Failed to compile: %s", e)
else:
return namespace.get(func_def.name)
def load_flow_arguments_from_entrypoint(
entrypoint: str, arguments: Optional[Union[list[str], set[str]]] = None
) -> dict[str, Any]:
"""
Extract flow arguments from an entrypoint string.
Loads the source code of the entrypoint and extracts the flow arguments
from the `flow` decorator.
Args:
entrypoint: a string in the format `<path_to_script>:<flow_func_name>`
or a module path to a flow function
"""
func_def, source_code = _entrypoint_definition_and_source(entrypoint)
path = None
if ":" in entrypoint:
path = entrypoint.rsplit(":")[0]
if arguments is None:
# If no arguments are provided default to known arguments that are of
# built-in types.
arguments = {
"name",
"version",
"retries",
"retry_delay_seconds",
"description",
"timeout_seconds",
"validate_parameters",
"persist_result",
"cache_result_in_memory",
"log_prints",
}
result: dict[str, Any] = {}
for decorator in func_def.decorator_list:
if (
isinstance(decorator, ast.Call)
and getattr(decorator.func, "id", "") == "flow"
):
for keyword in decorator.keywords:
if keyword.arg not in arguments:
continue
if isinstance(keyword.value, ast.Constant):
# Use the string value of the argument
result[cast(str, keyword.arg)] = str(keyword.value.value)
continue
# if the arg value is not a raw str (i.e. a variable or expression),
# then attempt to evaluate it
namespace = safe_load_namespace(source_code, filepath=path)
literal_arg_value = ast.get_source_segment(source_code, keyword.value)
cleaned_value = (
literal_arg_value.replace("\n", "") if literal_arg_value else ""
)
try:
evaluated_value = eval(cleaned_value, namespace) # type: ignore
result[cast(str, keyword.arg)] = str(evaluated_value)
except Exception as e:
logger.info(
"Failed to parse @flow argument: `%s=%s` due to the following error. Ignoring and falling back to default behavior.",
keyword.arg,
literal_arg_value,
exc_info=e,
)
# ignore the decorator arg and fallback to default behavior
continue
if "name" in arguments and "name" not in result:
# If no matching decorator or keyword argument for `name' is found
# fallback to the function name.
result["name"] = func_def.name.replace("_", "-")
return result
def is_entrypoint_async(entrypoint: str) -> bool:
"""
Determine if the function specified in the entrypoint is asynchronous.
Args:
entrypoint: A string in the format `<path_to_script>:<func_name>` or
a module path to a function.
Returns:
True if the function is asynchronous, False otherwise.
"""
func_def, _ = _entrypoint_definition_and_source(entrypoint)
return isinstance(func_def, ast.AsyncFunctionDef)
def _entrypoint_definition_and_source(
entrypoint: str,
) -> Tuple[Union[ast.FunctionDef, ast.AsyncFunctionDef], str]:
if ":" in entrypoint:
# Split by the last colon once to handle Windows paths with drive letters i.e C:\path\to\file.py:do_stuff
path, func_name = entrypoint.rsplit(":", maxsplit=1)
source_code = Path(path).read_text()
else:
path, func_name = entrypoint.rsplit(".", maxsplit=1)
spec = importlib.util.find_spec(path)
if not spec or not spec.origin:
raise ValueError(f"Could not find module {path!r}")
source_code = Path(spec.origin).read_text()
parsed_code = ast.parse(source_code)
func_def = next(
(
node
for node in ast.walk(parsed_code)
if isinstance(
node,
(
ast.FunctionDef,
ast.AsyncFunctionDef,
),
)
and node.name == func_name
),
None,
)
if not func_def:
raise ValueError(f"Could not find flow {func_name!r} in {path!r}")
return func_def, source_code
|
PrefectHQREPO_NAMEprefectPATH_START.@prefect_extracted@prefect-main@src@prefect@flows.py@.PATH_END.py
|
{
"filename": "example-checkpoint.ipynb",
"repo_name": "arsenefer/PWF_reconstruction",
"repo_path": "PWF_reconstruction_extracted/PWF_reconstruction-main/.ipynb_checkpoints/example-checkpoint.ipynb",
"type": "Jupyter Notebook"
}
|
# Using PWF_reconstruction
```python
import numpy as np
import matplotlib.pyplot as plt
from PWF_reconstruction.recons_PWF import PWF_semianalytical, cov_matrix
```
We will use a dummy event to illustrate the package.
```python
x_ants = np.array([[6062., 3499.99975586, 1025.68994141],
[8660., -2000.00024414, 981.16998291],
[6928., -1000.00024414, 991.2800293],
[8660., -1000.00024414, 961.09997559],
[7794., -500.00036621, 975.90997314],
[7794., 499.99975586, 988.53997803],
[6928., 999.99975586, 982.96002197],
[6928., 1999.99975586, 994.59997559],
[6062., 2499.99975586, 998.46002197]])
t_ants = np.array([-8.41008848e-06, 1.11909904e-05, 6.03631933e-06, 8.25434167e-06, 5.65372435e-06, 2.69038597e-06, 7.60043411e-08, -2.87709951e-06,-5.44485484e-06])
k = np.array([ 0.38488077, -0.88474286, -0.26286282])
theta, phi = 74.76, 113.51
```
We can run a reconstruction on this event. We see that the prediction is close to the target values : $\theta= 74.76$° and $\phi = 113.51$°.
```python
theta_pred, phi_pred = PWF_semianalytical(x_ants, t_ants)
print('θ_pred =', np.round(theta_pred*180/np.pi, 2), '°')
print("ϕ_pred =", np.round(phi_pred*180/np.pi, 2), '°')
```
θ_pred = 74.96 °
ϕ_pred = 113.17 °
## Estimating the uncertainty on $\theta$ and $\phi$
With that prediction, we can estimate the covariance of our estimator. This matrix describe how the estimator is distributed.
We have to estimate the noise on the antenna timing measurements.
```python
sigma = np.sqrt(1.51e-8**2 + 1e-8**2)
```
```python
Sigma = cov_matrix(theta_pred, phi_pred, x_ants, sigma)
print(Sigma)
```
[[ 1.43976243e-05 -2.91488780e-06]
[-2.91488780e-06 1.83092418e-05]]
We can visualise this distribution with the `plot_distribs` function in `visualisation`
```python
from PWF_reconstruction.visualisation import plot_distribs
```
```python
plot_distribs(np.array([]), np.array([]), Sigma, theta_pred, phi/180*np.pi, theta/180*np.pi, phi_pred)
```
|
arseneferREPO_NAMEPWF_reconstructionPATH_START.@PWF_reconstruction_extracted@PWF_reconstruction-main@.ipynb_checkpoints@example-checkpoint.ipynb@.PATH_END.py
|
{
"filename": "plot_radial_profiles.py",
"repo_name": "andizq/discminer",
"repo_path": "discminer_extracted/discminer-main/_mining/plot_radial_profiles.py",
"type": "Python"
}
|
from discminer.plottools import (get_discminer_cmap, make_substructures,
make_up_ax, mod_minor_ticks, mod_major_ticks,
use_discminer_style, mod_nticks_cbars)
from discminer.rail import Rail, Contours
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import FormatStrFormatter
from scipy.signal import savgol_filter
from scipy.interpolate import interp1d
from astropy import units as u
from astropy.io import fits
import json
import copy
from utils import (init_data_and_model,
get_noise_mask,
get_1d_plot_decorators,
load_moments,
load_disc_grid,
add_parser_args,
make_1d_legend,
MEDIUM_SIZE)
from argparse import ArgumentParser
use_discminer_style()
parser = ArgumentParser(prog='plot radial profiles', description='Compute radial profiles from moment maps and residuals.')
args = add_parser_args(parser, moment=True, kernel=True, kind=True, surface=True, writetxt=True, mask_minor=True, mask_major=True, Rinner=True, Router=True, sigma=True, smooth=True)
#**********************
#JSON AND PARSER STUFF
#**********************
with open('parfile.json') as json_file:
pars = json.load(json_file)
meta = pars['metadata']
best = pars['best_fit']
custom = pars['custom']
Mstar = best['velocity']['Mstar']
vsys = best['velocity']['vsys']
vel_sign = best['velocity']['vel_sign']
Rout = best['intensity']['Rout']
incl = best['orientation']['incl']
gaps = custom['gaps']
rings = custom['rings']
Rmax = 1.1*Rout*u.au #Max model radius, 10% larger than disc Rout
clabel, clabel_res, clim0, clim0_res, clim1, clim1_res, unit = get_1d_plot_decorators(args.moment)
#*******************
#LOAD DATA AND MODEL
#*******************
datacube, model = init_data_and_model()
noise_mean, mask = get_noise_mask(datacube, thres=2)
vchannels = datacube.vchannels
model.make_model()
#*************************
#LOAD DISC GEOMETRY
R, phi, z = load_disc_grid()
R_s = R[args.surface]*u.m.to('au')
phi_s = phi[args.surface]
#*************************
#LOAD MOMENT MAPS
moment_data, moment_model, residuals, mtags = load_moments(args, mask=mask)
ref_surf = mtags['ref_surf']
tag_base = mtags['base']
#**************************
#ABSOLUTE RESIDUALS
if args.moment=='velocity':
residuals_abs = np.abs(moment_data-vsys) - np.abs(moment_model-vsys)
#**************************
#MAKE PLOTS
beam_au = datacube.beam_size.to('au').value
R_prof = np.arange(args.Rinner*beam_au, args.Router*Rout, beam_au/4.0) #changed to beam/4 from beam/5 before
xlim0, xlim1 = 0.5*R_prof[0], 1.05*R_prof[-1]
def writetxt(arr, tag=''):
if tag!='': tag = '_'+tag
arr = np.asarray(arr).T
np.savetxt('radial_profile_%s%s.dat'%(args.moment, tag), arr, fmt='%.6f', header='R[au] attribute stddev')
def get_normalisation(mask_ang, component='z'):
"""
mask_ang : +- mask around disc minor axis
component : velocity component to get normalisation for
"""
if component=='phi':
div_factor = 4*np.sin(np.pi/2 - np.radians(mask_ang)) * np.abs(np.sin(incl))/(2*np.pi - 4*np.radians(mask_ang))
elif component=='z':
div_factor = -np.cos(np.abs(incl))
else: return comp
return div_factor
def make_savgol(prof):
try:
ysav = savgol_filter(prof, 9, 3)
ysav_deriv = savgol_filter(prof, 9, 3, deriv=1)
except np.linalg.LinAlgError:
ysav = prof
ysav_deriv = None
return ysav, ysav_deriv
def make_basic_layout(ax):
ax.set_xlim(xlim0, xlim1)
ax.set_xlabel('Radius [au]', fontsize=MEDIUM_SIZE-1)
mod_major_ticks(ax, axis='x', nbins=10)
mod_minor_ticks(ax)
ax.axhline(0, lw=2, ls='--', color='0.7')
def make_profile(ax, R_prof, ysav, y, yerr, kind='data', perr='bar', **kwargs):
if kind=='data':
label = 'Data'
color = 'tomato'
zorder = 9
lw = 3.5
elif kind=='residuals':
label = 'Residuals'
color = '0.1'
zorder = 9
lw = 3.5
elif kind=='model':
label = 'Model'
color = 'dodgerblue'
zorder = 8
lw = 3.5
elif kind=='vphi':
label = r'$\Delta\upsilon_\phi$'
color = 'dodgerblue'
zorder = 9
lw = 3.0
elif kind=='vz':
label = r'$\upsilon_{\rm z}$'
color = 'k'
zorder = 8
lw = 3.0
elif kind=='vr':
label = r'$\upsilon_{\rm R}$'
color = '#FFB000'
zorder = 7
lw = 3.0
else:
raise ValueError(kind)
ax.plot(R_prof, ysav, c=color, lw=lw, label=label, zorder=zorder)
if kind!='model':
if perr=='bar':
ax.errorbar(R_prof, y, yerr=yerr, c=color,
elinewidth=1.2, capsize=1.8, linestyle='none',
marker='o', ms=6.5, markeredgewidth=1.7, markerfacecolor='0.8',
alpha=0.7, zorder=zorder)
elif perr=='fill':
ax.fill_between(R_prof, y+yerr, y-yerr, color=color, alpha=0.15, zorder=zorder)
else:
raise ValueError(perr)
if args.writetxt: writetxt([R_prof, y, yerr], tag=kind)
#*************
#MAIN BODY
#*************
kw_ylabel = dict(fontsize=MEDIUM_SIZE-2, labelpad=0)
if args.moment=='velocity':
mask_ang = args.mask_minor #+-mask around disc minor axis
#*******************
#VELOCITY COMPONENTS
#*******************
"""
if args.surface in ['low', 'lower']:
mask_r = mask | (np.abs(phi_s) < np.radians(args.mask_major)) | (np.abs(phi_s) > np.radians(180-args.mask_major))
moment_data = np.where(mask_r, np.nan, moment_data)
if args.moment=='velocity':
pass
moment_data = np.where(np.abs(moment_data-vsys)>5, np.nan, moment_data)
"""
if args.kernel in ['doublebell', 'doublegaussian']:
mask_map_ref = np.abs((moment_data-vsys)/(np.cos(model.projected_coords['phi'][args.surface])*np.sin(incl)))
else:
mask_map_ref = None
kw_avg = dict(surface=ref_surf, av_func=np.nanmean, mask_ang=mask_ang, sigma_thres=args.sigma, mask_from_map=mask_map_ref)
#VZ
rail_vz = Rail(model, residuals, R_prof)
vel_z, vel_z_error = rail_vz.get_average(tag='vz', **kw_avg)
div_factor_z = get_normalisation(mask_ang, component='z')
vel_z /= div_factor_z
vel_z_error /= div_factor_z
#DVPHI
rail_phi = Rail(model, residuals_abs, R_prof)
vel_phi, vel_phi_error = rail_phi.get_average(**kw_avg)
div_factor_phi = get_normalisation(mask_ang, component='phi')
vel_phi /= div_factor_phi
vel_phi_error /= div_factor_phi
#VPHI
rail_phi = Rail(model, np.abs(moment_data-vsys), R_prof)
vel_rot, vel_rot_error = rail_phi.get_average(tag=tag_base+'_vphi_data', plot_diagnostics=True, forward_error=True, **kw_avg)
vel_rot /= div_factor_phi
vel_rot_error = vel_phi_error
#VR
mask_r = mask | (np.abs(phi_s) < np.radians(args.mask_major)) | (np.abs(phi_s) > np.radians(180-args.mask_major))
moment_data_r = np.where(mask_r, np.nan, moment_data)
f_vp = interp1d(R_prof, vel_rot)
f_vz = interp1d(R_prof, vel_z)
R_interp = np.where((R_s>R_prof[0]) & (R_s<R_prof[-1]), R_s, R_prof[0])
vr = -1/(np.sin(phi_s)*np.sin(incl)) * (moment_data_r - vsys - vel_sign*f_vp(R_interp)*np.cos(phi_s)*np.sin(incl) + f_vz(R_interp)*np.cos(incl))
rail_vr = Rail(model, vr, R_prof)
vel_r, vel_r_error = rail_vr.get_average(mask_ang=0.0, surface=ref_surf, av_func=np.nanmedian)
#SAVE 3D VELOCITIES IN ONE FILE
header = 'radius[au] v_rot[m/s] v_phi[m/s] dv_phi_rot[m/s] v_r[m/s] dv_r[m/s] v_z[m/s] dv_z[m/s]'
vel_arr = [R_prof, vel_rot, vel_phi, vel_phi_error, vel_r, vel_r_error, vel_z, vel_z_error]
vel_arr_t = np.asarray(vel_arr).T
np.savetxt('%s_%s_%s_radial_profile_3D_velocities.txt'%(meta['disc'], meta['mol'], args.kernel), vel_arr_t, fmt='%.6f',
header=header, footer=str(meta['log_file']) + ' --mask_minor ' + str(args.mask_minor) + ' --mask_major ' + str(args.mask_major) + ' --Rinner ' + str(args.Rinner) + ' --Router ' + str(args.Router))
#PLOT 3D VELOCITIES
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(11,4))
ysav_phi, ysav_phi_deriv = make_savgol(vel_phi)
make_profile(ax, R_prof, ysav_phi, vel_phi, vel_phi_error, kind='vphi', perr='fill')
ax.scatter(R_prof, vel_phi, ec='dodgerblue', fc='none', s=25, zorder=12)
ysav_z, ysav_z_deriv = make_savgol(vel_z)
make_profile(ax, R_prof, ysav_z, vel_z, vel_z_error, kind='vz', perr='fill')
ax.scatter(R_prof, vel_z, ec='k', fc='none', s=25, zorder=11)
ysav_r, ysav_r_deriv = make_savgol(vel_r)
make_profile(ax, R_prof, ysav_r, vel_r, vel_r_error, kind='vr', perr='fill')
ax.scatter(R_prof, vel_r, ec='#FFB000', fc='none', s=25, zorder=10)
#DECORATIONS
make_basic_layout(ax)
ax.set_ylabel(r'$\delta\upsilon$ [km/s]', fontsize=MEDIUM_SIZE, labelpad=10)
ax.set_ylim(clim0_res, clim1_res)
make_1d_legend(ax, fontsize=MEDIUM_SIZE+1)
make_substructures(ax, gaps=gaps, rings=rings, label_gaps=True, label_rings=True)
plt.savefig('velocity_components_%s.png'%tag_base, bbox_inches='tight', dpi=200)
plt.show()
#*******************
#ROTATION CURVE
#*******************
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(11,4))
#DATA CURVE
ysav_rot, ysav_rot_deriv = make_savgol(vel_rot)
make_profile(ax, R_prof, ysav_rot, vel_rot, vel_rot_error, kind='data')
#MODEL CURVE
rail_phi = Rail(model, np.abs(moment_model-vsys), R_prof)
#vel_phi, _ = rail_phi.get_average(mask_ang=mask_ang, surface=ref_surf)
vel_phi, _ = rail_phi.get_average(surface=ref_surf, av_func=np.nanmean, mask_ang=mask_ang, sigma_thres=np.inf,
mask_from_map=mask_map_ref, tag=tag_base+'_vphi_model', plot_diagnostics=True)
div_factor_model = get_normalisation(mask_ang, component='phi')
vel_phi /= div_factor_model
ysav_phi, ysav_phi_deriv_mod = make_savgol(vel_phi)
make_profile(ax, R_prof, ysav_phi, vel_phi, _, kind='model')
#PERFECT KEPLERIAN
coords = {'R': R_prof*u.au.to('m')}
velocity_upper = model.get_attribute_map(coords, 'velocity', surface=ref_surf) * vel_sign
ax.plot(R_prof, velocity_upper, c='k', lw=2.5, ls='--', label=r'Keplerian (%.2f Msun)'%Mstar, zorder=13)
#DECORATIONS
make_basic_layout(ax)
ax.set_ylabel(r'Rotation velocity [km/s]', fontsize=MEDIUM_SIZE, labelpad=10)
ax.set_ylim(clim0, 1.2*np.nanmax(vel_phi))
make_1d_legend(ax, fontsize=MEDIUM_SIZE-3)
make_substructures(ax, gaps=gaps, rings=rings, label_gaps=True, label_rings=True)
plt.savefig('rotation_curve_%s.png'%tag_base, bbox_inches='tight', dpi=200)
plt.show()
"""
#Data rotation curve - perfect_Keplerian
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(14,4))
ax.plot(R_prof, vel_rot-velocity_upper, c='k', lw=2.5, ls='--', label=r'Keplerian (%.2f Msun)'%Mstar, zorder=13)
plt.show()
"""
else:
mask_ang = args.mask_minor
if args.surface in ['low', 'lower']:
mask_r = mask | (np.abs(phi_s) < np.radians(args.mask_major)) | (np.abs(phi_s) > np.radians(180-args.mask_major)) | (moment_data>40)
moment_data = np.where(mask_r, np.nan, moment_data)
if args.kernel in ['doublebell', 'doublegaussian']:
mask_map_ref = moment_data
else:
mask_map_ref = None
#*****************
#ABSOLUTE PROFILES
#*****************
kw_avg = dict(surface=ref_surf, av_func=np.nanmedian, mask_ang=mask_ang, sigma_thres=args.sigma, mask_from_map=mask_map_ref, plot_diagnostics=True)
fig, ax = plt.subplots(ncols=1, nrows=2, figsize=(11,6))
#DATA CURVE
rail_phi = Rail(model, moment_data, R_prof)
vel_phi, vel_phi_error = rail_phi.get_average(**kw_avg)
ysav_phi, ysav_phi_deriv = make_savgol(vel_phi)
make_profile(ax[0], R_prof, ysav_phi, vel_phi, vel_phi_error, kind='data')
#MODEL CURVE
rail_phi = Rail(model, moment_model, R_prof)
vel_phi, vel_phi_error = rail_phi.get_average(**kw_avg)
ysav_phi, ysav_phi_deriv = make_savgol(vel_phi)
make_profile(ax[0], R_prof, ysav_phi, vel_phi, vel_phi_error, kind='model')
#RESIDUALS
rail_phi = Rail(model, residuals, R_prof)
vel_phi, vel_phi_error = rail_phi.get_average(**kw_avg)
ysav_phi, ysav_phi_deriv = make_savgol(vel_phi)
make_profile(ax[1], R_prof, ysav_phi, vel_phi, vel_phi_error, kind='residuals')
#***********
#DECORATIONS
#***********
ax[0].set_ylim(clim0, clim1)
ax[1].set_ylim(clim0_res, clim1_res)
#fmt (Homogenise fmt for both panels)
#******
ticks = ax[1].get_yticks()
makeint = False
for tick in ticks:
if str(tick)[-2:] != '.0':
break
else:
makeint = True
#ftick = round(ticks[0], 2)
ftick = round(clim0_res, 2)
ftick = int(ftick) if makeint else ftick
ftick_res = str(ftick)
isfloat = isinstance(ftick, float)
#lfmt = len(str(ftick))
lfmt = 5
if isfloat:
if abs(ftick)<0.2 and lfmt<5: #e.g. -0.1
ftick_res += '0'
lfmt+=1
ndec = len(str(ftick).split('.')[-1])
ndec_res = len(str(ftick_res).split('.')[-1])
cfmt = '%'+'%d.%df'%(lfmt+ndec, ndec)
cfmt_res = '%'+'%d.%df'%(lfmt+ndec_res, ndec_res)
print (ndec_res, ftick_res)
else:
cfmt = cfmt_res = '%'+'%dd'%lfmt
#******
#Axes
#****
for axi in ax:
make_basic_layout(axi)
axi.tick_params(which='both', labelsize=MEDIUM_SIZE-3)
ax[0].yaxis.set_major_formatter(FormatStrFormatter(cfmt))
ax[1].yaxis.set_major_formatter(FormatStrFormatter(cfmt_res))
ax[0].set_xlabel(None)
ax[1].set_xlabel('Radius [au]', fontsize=MEDIUM_SIZE-2)
ax[0].set_ylabel(clabel, **kw_ylabel)
ax[1].set_ylabel('Residuals', **kw_ylabel) #+clabel_res.split('residuals')[-1] #--> unit
make_1d_legend(ax[0], ncol=2)
make_substructures(ax[0], gaps=gaps, rings=rings, label_gaps=True, label_rings=True)
make_substructures(ax[1], gaps=gaps, rings=rings)
plt.savefig('radial_profile_%s.png'%tag_base, bbox_inches='tight', dpi=200)
plt.show()
|
andizqREPO_NAMEdiscminerPATH_START.@discminer_extracted@discminer-main@_mining@plot_radial_profiles.py@.PATH_END.py
|
{
"filename": "cli__binary-install-cuda.md",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/catboost/docs/en/_includes/work_src/reusage-code-examples/cli__binary-install-cuda.md",
"type": "Markdown"
}
|
{% note info %}
Only CUDA {{ cuda_version__compiled-packages }} is officially supported in compiled command-line packages for Windows. [Вuild the binary from a local copy](../../../concepts/cli-installation.md) if GPU support is required and the installed version of CUDA differs from {{ cuda_version__compiled-packages }}. {{ product }} should work fine with CUDA {{ cuda_version__compiled-packages }} and later versions.
All necessary CUDA libraries are statically linked to the Linux and macOS binaries of the {{ product }} command-line version, therefore, the only installation necessary is the appropriate version of the CUDA driver.
{% endnote %}
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@catboost@docs@en@_includes@work_src@reusage-code-examples@cli__binary-install-cuda.md@.PATH_END.py
|
{
"filename": "pebblo.py",
"repo_name": "langchain-ai/langchain",
"repo_path": "langchain_extracted/langchain-master/libs/community/langchain_community/document_loaders/pebblo.py",
"type": "Python"
}
|
"""Pebblo's safe dataloader is a wrapper for document loaders"""
import logging
import os
import uuid
from importlib.metadata import version
from typing import Any, Dict, Iterable, Iterator, List, Optional
from langchain_core.documents import Document
from langchain_community.document_loaders.base import BaseLoader
from langchain_community.utilities.pebblo import (
BATCH_SIZE_BYTES,
PLUGIN_VERSION,
App,
Framework,
IndexedDocument,
PebbloLoaderAPIWrapper,
generate_size_based_batches,
get_full_path,
get_loader_full_path,
get_loader_type,
get_runtime,
get_source_size,
)
logger = logging.getLogger(__name__)
class PebbloSafeLoader(BaseLoader):
"""Pebblo Safe Loader class is a wrapper around document loaders enabling the data
to be scrutinized.
"""
_discover_sent: bool = False
def __init__(
self,
langchain_loader: BaseLoader,
name: str,
owner: str = "",
description: str = "",
api_key: Optional[str] = None,
load_semantic: bool = False,
classifier_url: Optional[str] = None,
*,
classifier_location: str = "local",
anonymize_snippets: bool = False,
):
if not name or not isinstance(name, str):
raise NameError("Must specify a valid name.")
self.app_name = name
self.load_id = str(uuid.uuid4())
self.loader = langchain_loader
self.load_semantic = os.environ.get("PEBBLO_LOAD_SEMANTIC") or load_semantic
self.owner = owner
self.description = description
self.source_path = get_loader_full_path(self.loader)
self.docs: List[Document] = []
self.docs_with_id: List[IndexedDocument] = []
loader_name = str(type(self.loader)).split(".")[-1].split("'")[0]
self.source_type = get_loader_type(loader_name)
self.source_path_size = get_source_size(self.source_path)
self.batch_size = BATCH_SIZE_BYTES
self.loader_details = {
"loader": loader_name,
"source_path": self.source_path,
"source_type": self.source_type,
**(
{"source_path_size": str(self.source_path_size)}
if self.source_path_size > 0
else {}
),
}
# generate app
self.app = self._get_app_details()
# initialize Pebblo Loader API client
self.pb_client = PebbloLoaderAPIWrapper(
api_key=api_key,
classifier_location=classifier_location,
classifier_url=classifier_url,
anonymize_snippets=anonymize_snippets,
)
self.pb_client.send_loader_discover(self.app)
def load(self) -> List[Document]:
"""Load Documents.
Returns:
list: Documents fetched from load method of the wrapped `loader`.
"""
self.docs = self.loader.load()
# Classify docs in batches
self.classify_in_batches()
return self.docs
def classify_in_batches(self) -> None:
"""
Classify documents in batches.
This is to avoid API timeouts when sending large number of documents.
Batches are generated based on the page_content size.
"""
batches: List[List[Document]] = generate_size_based_batches(
self.docs, self.batch_size
)
processed_docs: List[Document] = []
total_batches = len(batches)
for i, batch in enumerate(batches):
is_last_batch: bool = i == total_batches - 1
self.docs = batch
self.docs_with_id = self._index_docs()
classified_docs = self.pb_client.classify_documents(
self.docs_with_id,
self.app,
self.loader_details,
loading_end=is_last_batch,
)
self._add_pebblo_specific_metadata(classified_docs)
if self.load_semantic:
batch_processed_docs = self._add_semantic_to_docs(classified_docs)
else:
batch_processed_docs = self._unindex_docs()
processed_docs.extend(batch_processed_docs)
self.docs = processed_docs
def lazy_load(self) -> Iterator[Document]:
"""Load documents in lazy fashion.
Raises:
NotImplementedError: raised when lazy_load id not implemented
within wrapped loader.
Yields:
list: Documents from loader's lazy loading.
"""
try:
doc_iterator = self.loader.lazy_load()
except NotImplementedError as exc:
err_str = f"{self.loader.__class__.__name__} does not implement lazy_load()"
logger.error(err_str)
raise NotImplementedError(err_str) from exc
while True:
try:
doc = next(doc_iterator)
except StopIteration:
self.docs = []
break
self.docs = list((doc,))
self.docs_with_id = self._index_docs()
classified_doc = self.pb_client.classify_documents(
self.docs_with_id, self.app, self.loader_details
)
self._add_pebblo_specific_metadata(classified_doc)
if self.load_semantic:
self.docs = self._add_semantic_to_docs(classified_doc)
else:
self.docs = self._unindex_docs()
yield self.docs[0]
@classmethod
def set_discover_sent(cls) -> None:
cls._discover_sent = True
def _get_app_details(self) -> App:
"""Fetch app details. Internal method.
Returns:
App: App details.
"""
framework, runtime = get_runtime()
app = App(
name=self.app_name,
owner=self.owner,
description=self.description,
load_id=self.load_id,
runtime=runtime,
framework=framework,
plugin_version=PLUGIN_VERSION,
client_version=Framework(
name="langchain_community",
version=version("langchain_community"),
),
)
return app
def _index_docs(self) -> List[IndexedDocument]:
"""
Indexes the documents and returns a list of IndexedDocument objects.
Returns:
List[IndexedDocument]: A list of IndexedDocument objects with unique IDs.
"""
docs_with_id = [
IndexedDocument(pb_id=str(i), **doc.dict())
for i, doc in enumerate(self.docs)
]
return docs_with_id
def _add_semantic_to_docs(self, classified_docs: Dict) -> List[Document]:
"""
Adds semantic metadata to the given list of documents.
Args:
classified_docs (Dict): A dictionary of dictionaries containing the
classified documents with pb_id as key.
Returns:
List[Document]: A list of Document objects with added semantic metadata.
"""
indexed_docs = {
doc.pb_id: Document(page_content=doc.page_content, metadata=doc.metadata)
for doc in self.docs_with_id
}
for classified_doc in classified_docs.values():
doc_id = classified_doc.get("pb_id")
if doc_id in indexed_docs:
self._add_semantic_to_doc(indexed_docs[doc_id], classified_doc)
semantic_metadata_docs = [doc for doc in indexed_docs.values()]
return semantic_metadata_docs
def _unindex_docs(self) -> List[Document]:
"""
Converts a list of IndexedDocument objects to a list of Document objects.
Returns:
List[Document]: A list of Document objects.
"""
docs = [
Document(page_content=doc.page_content, metadata=doc.metadata)
for i, doc in enumerate(self.docs_with_id)
]
return docs
def _add_semantic_to_doc(self, doc: Document, classified_doc: dict) -> Document:
"""
Adds semantic metadata to the given document in-place.
Args:
doc (Document): A Document object.
classified_doc (dict): A dictionary containing the classified document.
Returns:
Document: The Document object with added semantic metadata.
"""
doc.metadata["pebblo_semantic_entities"] = list(
classified_doc.get("entities", {}).keys()
)
doc.metadata["pebblo_semantic_topics"] = list(
classified_doc.get("topics", {}).keys()
)
return doc
def _add_pebblo_specific_metadata(self, classified_docs: dict) -> None:
"""Add Pebblo specific metadata to documents."""
for doc in self.docs_with_id:
doc_metadata = doc.metadata
if self.loader.__class__.__name__ == "SharePointLoader":
doc_metadata["full_path"] = get_full_path(
doc_metadata.get("source", self.source_path)
)
else:
doc_metadata["full_path"] = get_full_path(
doc_metadata.get(
"full_path", doc_metadata.get("source", self.source_path)
)
)
doc_metadata["pb_checksum"] = classified_docs.get(doc.pb_id, {}).get(
"pb_checksum", None
)
class PebbloTextLoader(BaseLoader):
"""
Loader for text data.
Since PebbloSafeLoader is a wrapper around document loaders, this loader is
used to load text data directly into Documents.
"""
def __init__(
self,
texts: Iterable[str],
*,
source: Optional[str] = None,
ids: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
metadatas: Optional[List[Dict[str, Any]]] = None,
) -> None:
"""
Args:
texts: Iterable of text data.
source: Source of the text data.
Optional. Defaults to None.
ids: List of unique identifiers for each text.
Optional. Defaults to None.
metadata: Metadata for all texts.
Optional. Defaults to None.
metadatas: List of metadata for each text.
Optional. Defaults to None.
"""
self.texts = texts
self.source = source
self.ids = ids
self.metadata = metadata
self.metadatas = metadatas
def lazy_load(self) -> Iterator[Document]:
"""
Lazy load text data into Documents.
Returns:
Iterator of Documents
"""
for i, text in enumerate(self.texts):
_id = None
metadata = self.metadata or {}
if self.metadatas and i < len(self.metadatas) and self.metadatas[i]:
metadata.update(self.metadatas[i])
if self.ids and i < len(self.ids):
_id = self.ids[i]
yield Document(id=_id, page_content=text, metadata=metadata)
def load(self) -> List[Document]:
"""
Load text data into Documents.
Returns:
List of Documents
"""
documents = []
for doc in self.lazy_load():
documents.append(doc)
return documents
|
langchain-aiREPO_NAMElangchainPATH_START.@langchain_extracted@langchain-master@libs@community@langchain_community@document_loaders@pebblo.py@.PATH_END.py
|
{
"filename": "chidist_plotter.py",
"repo_name": "htjb/maxsmooth",
"repo_path": "maxsmooth_extracted/maxsmooth-master/maxsmooth/chidist_plotter.py",
"type": "Python"
}
|
"""
This function allows the user to produce plots of the chi squared
distribution as a function of the available discrete sign spaces for the
constrained derivatives. This can be used to identify whether or not the
problem is `ill defined`, see the ``maxsmooth`` paper for a definition,
and if it can be solved using the sign sampling approach.
It can also be used to determine whether or not the 'cap' and maximum allowed
increase on the value of chi squared during the directional exploration
are sufficient to identify the global minimum for the problem.
The function is reliant on the output of the ``maxsmooth`` smooth() function.
The required outputs can be saved when running smooth()
using the 'data_save = True' kwarg.
"""
import numpy as np
import os
from itertools import product
import matplotlib.pyplot as plt
class chi_plotter(object):
r"""
**Parameters:**
N: **int**
| The number of terms in the DCF.
**Kwargs:**
fit_type: **Default = 'qp-sign_flipping'**
| This kwarg is the same as for the smooth() function.
Here it allows the files to be read from the base
directory.
base_dir: **Default = 'Fitted_Output/'**
| The location of the outputted
data from ``maxsmooth``. This must be a string and end in '/'
and must contain the files 'Output_Evaluations/' and
'Output_Signs/' which can be obtained by running smooth() with
data_save=True.
chi: **Default = None else list or numpy array**
| A list of
chi squared evaluations. If provided then this is used
over outputted data in the base directory. It must have the
same length as the ouputted signs in the file 'Output_Signs/'
in the base directory. It must also be ordered correctly
otherwise the returned graph will not be correct. A correct
ordering is one for which each entry in the array corresponds
to the correct sign combination in 'Output_Signs/'.
Typically this will not be needed but if the chi squared
evaluation in 'Output_Evaluations/' in the base directory
is not in the desired parameter space this can be useful.
For example the built in logarithmic model calculates
chi squared in logarithmic space. To plot the distribution
in linear space we can calculate
chi squared in linear space using a function for the model
and the tested parameters which are found in
'Output_Parameters/' in the base directory.
**constraints: Default = 2 else an integer less than or equal**
**to N - 1**
| The minimum constrained derivative order which is set by default
to 2 for a Maximally Smooth Function. Used here to determine
the number of possible sign combinations available.
zero_crossings: **Default = None else list of integers**
| Allows you to
specify if the conditions should be relaxed on any
of the derivatives between constraints and the highest order
derivative. e.g. a 6th order fit with just a constrained 2nd
and 3rd order derivative would have a zero_crossings = [4, 5].
Again this is used in determining the possible sign
combinations available.
plot_limits: **Default = False**
| Determines whether the limits on
the directional exploration are plotted on top of the
chi squared distribution.
cap: **Default = (len(available_signs)//N) + N else an integer**
| Determines the maximum number of signs explored either side of
the minimum chi squared value found after the
decent algorithm has terminated when running smooth(). Here
it is used when plot_limits=True.
chi_squared_limit: **Default = 2 else float or int**
| The prefactor on the maximum allowed increase in chi squared
during the directional exploration which is defaulted at 2.
If this value multiplied by the minimum chi squared
value found after the descent algorithm is exceeded then the
exploration in one direction is stopped and started in the
other. For more details on this and 'cap' see the ``maxsmooth``
paper. Again this is used here
when plot_limits=True.
"""
def __init__(self, N, **kwargs):
self.N = N
if self.N % 1 != 0:
raise ValueError('N must be an integer or whole number float.')
for keys, values in kwargs.items():
if keys not in set([
'chi', 'base_dir',
'zero_crossings', 'constraints',
'fit_type', 'chi_squared_limit', 'cap', 'plot_limits']):
raise KeyError("Unexpected keyword argument in chi_plotter().")
self.base_dir = kwargs.pop('base_dir', 'Fitted_Output/')
if type(self.base_dir) is not str:
raise KeyError("'base_dir' must be a string ending in '/'.")
elif self.base_dir.endswith('/') is False:
raise KeyError("'base_dir' must end in '/'.")
if not os.path.exists(self.base_dir):
raise Exception(
"'base_dir' must exist and contain the outputted"
+ " evaluations and sign combinations from a maxsmooth fit."
+ " These can be obtained by running maxsmooth with"
+ " 'data_save=True'.")
else:
if not os.path.exists(self.base_dir + 'Output_Evaluation/'):
raise Exception(
"No 'Output_Evaluation/' directory found in"
+ " 'base_dir'.")
if not os.path.exists(self.base_dir + 'Output_Signs/'):
raise Exception(
"No 'Output_Signs/' directory found in"
+ " 'base_dir'.")
self.chi = kwargs.pop('chi', None)
self.constraints = kwargs.pop('constraints', 2)
if type(self.constraints) is not int:
raise TypeError("'constraints' is not an integer")
if self.constraints > self.N-1:
raise ValueError(
"'constraints' exceeds the number" +
" of derivatives.")
self.zero_crossings = kwargs.pop('zero_crossings', None)
if self.zero_crossings is not None:
for i in range(len(self.zero_crossings)):
if type(self.zero_crossings[i]) is not int:
raise TypeError(
"Entries in 'zero_crossings'" +
" are not integer.")
if self.zero_crossings[i] < self.constraints:
raise ValueError(
'One or more specified derivatives for' +
' zero crossings is less than the minimum' +
' constrained' +
' derivative.\n zero_crossings = '
+ str(self.zero_crossings)
+ '\n' + ' Minimum Constrained Derivative = '
+ str(self.constraints))
self.fit_type = kwargs.pop('fit_type', 'qp-sign_flipping')
if self.fit_type not in set(['qp', 'qp-sign_flipping']):
raise KeyError(
"Invalid 'fit_type'. Valid entries include 'qp'\n" +
"'qp-sign_flipping'")
self.chi_squared_limit = kwargs.pop('chi_squared_limit', None)
self.cap = kwargs.pop('cap', None)
if self.chi_squared_limit is not None:
if isinstance(self.chi_squared_limit, int) or \
isinstance(self.chi_squared_limit, float):
pass
else:
raise TypeError(
"Limit on maximum allowed increase in chi squared" +
", 'chi_squared_limit', is not an integer or float.")
if self.cap is not None:
if type(self.cap) is not int:
raise TypeError(
"The cap on directional exploration" +
", 'cap', is not an integer.")
self.plot_limits = kwargs.pop('plot_limits', False)
if type(self.plot_limits) is not bool:
raise TypeError(
"Boolean keyword argument with value "
+ " 'plot_limits' is not True or False.")
self.plot()
def plot(self):
def signs_array(nums):
return np.array(list(product(*((x, -x) for x in nums))))
if self.zero_crossings is not None:
possible_signs = signs_array([1]*(
self.N-self.constraints-len(self.zero_crossings)))
else:
possible_signs = signs_array([1]*(self.N-self.constraints))
plt.figure()
j = np.arange(0, len(possible_signs), 1)
if self.chi is None:
chi = np.loadtxt(
self.base_dir + 'Output_Evaluation/'
+ str(self.N) + '_' + str(self.fit_type) + '.txt')
signs = np.loadtxt(
self.base_dir + 'Output_Signs/'
+ str(self.N) + '_' + str(self.fit_type) + '.txt')
if len(signs) != len(possible_signs):
index = []
for p in range(len(signs)):
for i in range(len(possible_signs)):
if np.all(signs[p] == possible_signs[i]):
index.append(i)
index, chi = zip(*sorted(zip(index, chi)))
plt.plot(index, chi, ls='-')
else:
plt.plot(j, chi, marker='.', ls='-')
else:
chi = self.chi
signs = np.loadtxt(
self.base_dir + 'Output_Signs/'
+ str(self.N) + '_' + str(self.fit_type) + '.txt')
if len(signs) != len(possible_signs):
index = []
for p in range(len(signs)):
for i in range(len(possible_signs)):
if np.all(signs[p] == possible_signs[i]):
index.append(i)
index, chi = zip(*sorted(zip(index, chi)))
plt.plot(index, chi, marker='.', ls='-')
else:
plt.plot(j, chi, marker='.', ls='-')
if self.cap is None:
self.cap = (len(possible_signs)//self.N) + self.N
if self.chi_squared_limit is None:
self.chi_squared_limit = 2*min(chi)
for i in range(len(chi)):
if chi[i] == min(chi):
plt.plot(i, chi[i], marker='*')
if self.plot_limits is True:
plt.vlines(
i + self.cap, min(chi), max(chi), ls='--',
label='Cap On Exp.', color='k', alpha=0.5)
plt.vlines(
i - self.cap, min(chi), max(chi),
ls='--', color='k', alpha=0.5)
if self.plot_limits is True:
min_chi = np.load(
self.base_dir + str(self.N) +
'_'+self.fit_type+'_minimum_chi_post_descent.npy')
plt.hlines(
self.chi_squared_limit*min_chi, 0, len(possible_signs),
ls='-.', label=r'Max. Increase\n' +
' in $\chi^2$', # noqa: W605
color='k', alpha=0.5)
plt.xlim([j[0], j[-1]])
plt.grid()
plt.yscale('log')
plt.ylabel(r'$\chi^2$')
plt.xlabel('Sign Combination')
plt.tight_layout()
plt.savefig(self.base_dir + 'chi_distribution.pdf')
plt.close()
|
htjbREPO_NAMEmaxsmoothPATH_START.@maxsmooth_extracted@maxsmooth-master@maxsmooth@chidist_plotter.py@.PATH_END.py
|
{
"filename": "_xpad.py",
"repo_name": "plotly/plotly.py",
"repo_path": "plotly.py_extracted/plotly.py-master/packages/python/plotly/plotly/validators/contour/colorbar/_xpad.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class XpadValidator(_plotly_utils.basevalidators.NumberValidator):
def __init__(self, plotly_name="xpad", parent_name="contour.colorbar", **kwargs):
super(XpadValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "colorbars"),
min=kwargs.pop("min", 0),
**kwargs,
)
|
plotlyREPO_NAMEplotly.pyPATH_START.@plotly.py_extracted@plotly.py-master@packages@python@plotly@plotly@validators@contour@colorbar@_xpad.py@.PATH_END.py
|
{
"filename": "convenience.py",
"repo_name": "timstaley/voevent-parse",
"repo_path": "voevent-parse_extracted/voevent-parse-master/src/voeventparse/convenience.py",
"type": "Python"
}
|
"""Convenience routines for common actions on VOEvent objects"""
from __future__ import absolute_import
from collections import OrderedDict
from copy import deepcopy
import astropy.time
import iso8601
import lxml
import pytz
from voeventparse.misc import (Position2D)
from orderedmultidict import omdict as OMDict
def get_event_time_as_utc(voevent, index=0):
"""
Extracts the event time from a given `WhereWhen.ObsDataLocation`.
Returns a datetime (timezone-aware, UTC).
Accesses a `WhereWhere.ObsDataLocation.ObservationLocation`
element and returns the AstroCoords.Time.TimeInstant.ISOTime element,
converted to a (UTC-timezoned) datetime.
Note that a packet may include multiple 'ObsDataLocation' entries
under the 'WhereWhen' section, for example giving locations of an object
moving over time. Most packets will have only one, however, so the
default is to access the first.
This function now implements conversion from the
TDB (Barycentric Dynamical Time) time scale in ISOTime format,
since this is the format used by GAIA VOEvents.
(See also http://docs.astropy.org/en/stable/time/#time-scale )
Other timescales (i.e. TT, GPS) will presumably be formatted as a
TimeOffset, parsing this format is not yet implemented.
Args:
voevent (:class:`voeventparse.voevent.Voevent`): Root node of the VOevent
etree.
index (int): Index of the ObsDataLocation to extract an ISOtime from.
Returns:
:class:`datetime.datetime`: Datetime representing the event-timestamp,
converted to UTC (timezone aware).
"""
try:
od = voevent.WhereWhen.ObsDataLocation[index]
ol = od.ObservationLocation
coord_sys = ol.AstroCoords.attrib['coord_system_id']
timesys_identifier = coord_sys.split('-')[0]
if timesys_identifier == 'UTC':
isotime_str = str(ol.AstroCoords.Time.TimeInstant.ISOTime)
return iso8601.parse_date(isotime_str)
elif (timesys_identifier == 'TDB'):
isotime_str = str(ol.AstroCoords.Time.TimeInstant.ISOTime)
isotime_dtime = iso8601.parse_date(isotime_str)
tdb_time = astropy.time.Time(isotime_dtime, scale='tdb')
return tdb_time.utc.to_datetime().replace(tzinfo=pytz.UTC)
elif (timesys_identifier == 'TT' or timesys_identifier == 'GPS'):
raise NotImplementedError(
"Conversion from time-system '{}' to UTC not yet implemented"
)
else:
raise ValueError(
'Unrecognised time-system: {} (badly formatted VOEvent?)'.format(
timesys_identifier
)
)
except AttributeError:
return None
def get_event_position(voevent, index=0):
"""Extracts the `AstroCoords` from a given `WhereWhen.ObsDataLocation`.
Note that a packet may include multiple 'ObsDataLocation' entries
under the 'WhereWhen' section, for example giving locations of an object
moving over time. Most packets will have only one, however, so the
default is to just return co-ords extracted from the first.
Args:
voevent (:class:`voeventparse.voevent.Voevent`): Root node of the
VOEvent etree.
index (int): Index of the ObsDataLocation to extract AstroCoords from.
Returns:
Position (:py:class:`.Position2D`): The sky position defined in the
ObsDataLocation.
"""
od = voevent.WhereWhen.ObsDataLocation[index]
ac = od.ObservationLocation.AstroCoords
ac_sys = voevent.WhereWhen.ObsDataLocation.ObservationLocation.AstroCoordSystem
sys = ac_sys.attrib['id']
if hasattr(ac.Position2D, "Name1"):
assert ac.Position2D.Name1 == 'RA' and ac.Position2D.Name2 == 'Dec'
posn = Position2D(ra=float(ac.Position2D.Value2.C1),
dec=float(ac.Position2D.Value2.C2),
err=float(ac.Position2D.Error2Radius),
units=ac.Position2D.attrib['unit'],
system=sys)
return posn
def _get_param_children_as_omdict(subtree_element):
elt = subtree_element
omd = OMDict()
if elt.find('Param') is not None:
for p in elt.Param:
omd.add(p.attrib.get('name'), p.attrib)
return omd
def get_grouped_params(voevent):
"""
Fetch grouped Params from the `What` section of a voevent as an omdict.
This fetches 'grouped' Params, i.e. those enclosed in a Group element,
and returns them as a nested dict-like structure, keyed by
GroupName->ParamName->AttribName.
Note that since multiple Params may share the same ParamName, the returned
data-structure is actually an
`orderedmultidict.omdict <https://github.com/gruns/orderedmultidict>`_
and has extra methods such as 'getlist' to allow retrieval of all values.
Args:
voevent (:class:`voeventparse.voevent.Voevent`): Root node of the VOevent etree.
Returns (orderedmultidict.omdict):
Mapping of ``ParamName->Attribs``.
Typical access like so::
foo_val = top_params['foo']['value']
# If there are multiple Param entries named 'foo':
all_foo_vals = [atts['value'] for atts in top_params.getlist('foo')]
"""
groups_omd = OMDict()
w = deepcopy(voevent.What)
lxml.objectify.deannotate(w)
if w.find('Group') is not None:
for grp in w.Group:
groups_omd.add(grp.attrib.get('name'),
_get_param_children_as_omdict(grp))
return groups_omd
def get_toplevel_params(voevent):
"""
Fetch ungrouped Params from the `What` section of a voevent as an omdict.
This fetches 'toplevel' Params, i.e. those not enclosed in a Group element,
and returns them as a nested dict-like structure, keyed like
ParamName->AttribName.
Note that since multiple Params may share the same ParamName, the returned
data-structure is actually an
`orderedmultidict.omdict <https://github.com/gruns/orderedmultidict>`_
and has extra methods such as 'getlist' to allow retrieval of all values.
Any Params with no defined name (technically off-spec, but not invalidated
by the XML schema) are returned under the dict-key ``None``.
Args:
voevent (:class:`voeventparse.voevent.Voevent`): Root node of the VOevent etree.
Returns (orderedmultidict.omdict):
Mapping of ``ParamName->Attribs``.
Typical access like so::
foo_val = top_params['foo']['value']
# If there are multiple Param entries named 'foo':
all_foo_vals = [atts['value'] for atts in top_params.getlist('foo')]
"""
result = OrderedDict()
w = deepcopy(voevent.What)
lxml.objectify.deannotate(w)
return _get_param_children_as_omdict(w)
def pull_astro_coords(voevent, index=0):
"""
Deprecated alias of :func:`.get_event_position`
"""
import warnings
warnings.warn(
"""
The function `pull_astro_coords` has been renamed to
`get_event_position`. This alias is preserved for backwards
compatibility, and may be removed in a future release.
""",
FutureWarning)
return get_event_position(voevent, index)
def pull_isotime(voevent, index=0):
"""
Deprecated alias of :func:`.get_event_time_as_utc`
"""
import warnings
warnings.warn(
"""
The function `pull_isotime` has been renamed to
`get_event_time_as_utc`. This alias is preserved for backwards
compatibility, and may be removed in a future release.
""",
FutureWarning)
return get_event_time_as_utc(voevent, index)
def pull_params(voevent):
"""
Attempts to load the `What` section of a voevent as a nested dictionary.
.. warning:: Deprecated due to `Missing name attributes` issues.
`Param` or `Group` entries which are missing the `name` attribute
will be entered under a dictionary key of ``None``. This means that if
there are multiple entries missing the `name` attribute then earlier
entries will be overwritten by later entries, so you will not be able
to use this convenience routine effectively.
Use :func:`get_grouped_params` and :func:`get_toplevel_params`
instead.
Args:
voevent (:class:`voeventparse.voevent.Voevent`): Root node of the VOevent etree.
Returns:
dict: Mapping of ``Group->Param->Attribs``.
Access like so::
foo_param_val = what_dict['GroupName']['ParamName']['value']
.. note::
Parameters without a group are indexed under the key 'None' - otherwise,
we might get name-clashes between `params` and `groups` (unlikely but
possible) so for ungrouped Params you'll need something like::
what_dict[None]['ParamName']['value']
"""
import warnings
warnings.warn(
"""
The function `pull_params` has been deprecated in favour of the split
functions `get_toplevel_params` and `get_grouped_params`, due to
possible name-shadowing issues when combining multilevel-nested-dicts
(see docs for details).
This alias is preserved for backwards compatibility, and may be
removed in a future release.
""",
FutureWarning)
result = OrderedDict()
w = deepcopy(voevent.What)
lxml.objectify.deannotate(w)
if w.countchildren() == 0:
return result
toplevel_params = OrderedDict()
result[None] = toplevel_params
if w.find('Param') is not None:
for p in w.Param:
toplevel_params[p.attrib.get('name')] = p.attrib
if w.find('Group') is not None:
for g in w.Group:
g_params = {}
result[g.attrib.get('name')] = g_params
if hasattr(g, 'Param'):
for p in g.Param:
g_params[p.attrib.get('name')] = p.attrib
return result
def prettystr(subtree):
"""Print an element tree with nice indentation.
Prettyprinting a whole VOEvent often doesn't seem to work, probably for
issues relating to whitespace cf.
http://lxml.de/FAQ.html#why-doesn-t-the-pretty-print-option-reformat-my-xml-output
This function is a quick workaround for prettyprinting a subsection
of a VOEvent, for easier desk-checking.
Args:
subtree(:class`lxml.etree.ElementTree`): A node in the VOEvent element tree.
Returns:
str: Prettyprinted string representation of the raw XML.
"""
subtree = deepcopy(subtree)
lxml.objectify.deannotate(subtree)
lxml.etree.cleanup_namespaces(subtree)
return lxml.etree.tostring(subtree, pretty_print=True).decode(
encoding="utf-8")
|
timstaleyREPO_NAMEvoevent-parsePATH_START.@voevent-parse_extracted@voevent-parse-master@src@voeventparse@convenience.py@.PATH_END.py
|
{
"filename": "objects.Plot.label.ipynb",
"repo_name": "mwaskom/seaborn",
"repo_path": "seaborn_extracted/seaborn-master/doc/_docstrings/objects.Plot.label.ipynb",
"type": "Jupyter Notebook"
}
|
```python
import seaborn.objects as so
from seaborn import load_dataset
penguins = load_dataset("penguins")
```
Use strings to override default labels:
```python
p = (
so.Plot(penguins, x="bill_length_mm", y="bill_depth_mm")
.add(so.Dot(), color="species")
)
p.label(x="Length", y="Depth", color="")
```
Pass a function to *modify* the default label:
```python
p.label(color=str.capitalize)
```
Use this method to set the title for a single-axes plot:
```python
p.label(title="Penguin species exhibit distinct bill shapes")
```
When faceting, the `title` parameter will modify default titles:
```python
p.facet("sex").label(title=str.upper)
```
And the `col`/`row` parameters will add labels to the title for each facet:
```python
p.facet("sex").label(col="Sex:")
```
If more customization is needed, a format string can work well:
```python
p.facet("sex").label(title="{} penguins".format)
```
```python
p
```
When adding labels for each layer, the `legend=` parameter sets the title for the legend:
```python
(
so.Plot(penguins, x="species")
.add(so.Line(color="C1"), so.Agg(), y="bill_length_mm", label="length")
.add(so.Line(color="C2"), so.Agg(), y="bill_depth_mm", label="depth")
.label(legend="Measurement")
)
```
```python
```
|
mwaskomREPO_NAMEseabornPATH_START.@seaborn_extracted@seaborn-master@doc@_docstrings@objects.Plot.label.ipynb@.PATH_END.py
|
{
"filename": "_showexponent.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/validators/histogram2dcontour/colorbar/_showexponent.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator):
def __init__(
self,
plotly_name="showexponent",
parent_name="histogram2dcontour.colorbar",
**kwargs
):
super(ShowexponentValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "colorbars"),
role=kwargs.pop("role", "style"),
values=kwargs.pop("values", ["all", "first", "last", "none"]),
**kwargs
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@validators@histogram2dcontour@colorbar@_showexponent.py@.PATH_END.py
|
{
"filename": "batch_decomposition.py",
"repo_name": "mriener/gausspyplus",
"repo_path": "gausspyplus_extracted/gausspyplus-master/gausspyplus/gausspy_py3/batch_decomposition.py",
"type": "Python"
}
|
# @Author: Robert Lindner
# @Date: Nov 10, 2014
# @Filename: batch_decomposition.py
# @Last modified by: riener
# @Last modified time: 18-05-2020
import pickle
import multiprocessing
import signal
import sys
import numpy as np
from .gp import GaussianDecomposer
from tqdm import tqdm
from concurrent.futures import ProcessPoolExecutor, as_completed
# With Python 3.8 the start method for multiprocessing defaults to 'spawn' for
# MacOS systems. Here we change it back to 'fork' for compatibility reasons.
if sys.version_info[:2] >= (3, 8):
multiprocessing.set_start_method('fork', force=True)
def init_worker():
"""Worker initializer to ignore Keyboard interrupt."""
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
def init(*args):
global agd_object, science_data_path, ilist, agd_data
if args:
[agd_object, agd_data, ilist] = args[0]
else:
[agd_object, science_data_path, ilist] = pickle.load(
open('batchdecomp_temp.pickle', 'rb'), encoding='latin1')
agd_data = pickle.load(open(science_data_path, 'rb'), encoding='latin1')
if ilist == None:
ilist = np.arange(len(agd_data['data_list']))
def decompose_one(i):
if agd_data['data_list'][i] is not None:
if 'signal_ranges' in list(agd_data.keys()):
signal_ranges = agd_data['signal_ranges'][i]
noise_spike_ranges = agd_data['noise_spike_ranges'][i]
else:
signal_ranges, noise_spike_ranges = (None for _ in range(2))
# TODO: what if idx keyword is missing or None?
result = GaussianDecomposer.decompose(
agd_object,
agd_data['x_values'],
agd_data['data_list'][i],
agd_data['error'][i] * np.ones(len(agd_data['x_values'])),
idx=agd_data['index'][i],
signal_ranges=signal_ranges,
noise_spike_ranges=noise_spike_ranges)
return result
else:
return None
def parallel_process(array, function, n_jobs=16, use_kwargs=False, front_num=1):
"""A parallel version of the map function with a progress bar.
Args:
array (array-like): An array to iterate over.
function (function): A python function to apply to the elements of array
n_jobs (int, default=16): The number of cores to use
use_kwargs (boolean, default=False): Whether to consider the elements of array as dictionaries of
keyword arguments to function
front_num (int, default=3): The number of iterations to run serially before kicking off the parallel job.
Useful for catching bugs
Returns:
[function(array[0]), function(array[1]), ...]
"""
# We run the first few iterations serially to catch bugs
if front_num > 0:
front = [function(**a) if use_kwargs else function(a) for a in array[:front_num]]
# If we set n_jobs to 1, just run a list comprehension. This is useful for benchmarking and debugging.
if n_jobs == 1:
return front + [function(**a) if use_kwargs else function(a) for a in tqdm(array[front_num:])]
# Assemble the workers
with ProcessPoolExecutor(max_workers=n_jobs) as pool:
# Pass the elements of array into function
if use_kwargs:
futures = [pool.submit(function, **a) for a in array[front_num:]]
else:
futures = [pool.submit(function, a) for a in array[front_num:]]
kwargs = {
'total': len(futures),
'unit': 'it',
'unit_scale': True,
'leave': True
}
# Print out the progress as tasks complete
for f in tqdm(as_completed(futures), **kwargs):
pass
out = []
# Get the results from the futures.
for i, future in tqdm(enumerate(futures)):
try:
out.append(future.result())
except Exception as e:
out.append(e)
return front + out
def func(use_ncpus=None):
# Multiprocessing code
ncpus = multiprocessing.cpu_count()
if use_ncpus is None:
use_ncpus = int(0.75 * ncpus)
# p = multiprocessing.Pool(ncpus, init_worker)
print('using {} out of {} cpus'.format(use_ncpus, ncpus))
try:
results_list = parallel_process(ilist, decompose_one, n_jobs=use_ncpus)
except KeyboardInterrupt:
print("KeyboardInterrupt... quitting.")
quit()
return results_list
# def func(use_ncpus=None):
# # Multiprocessing code
# ncpus = multiprocessing.cpu_count()
# if use_ncpus is None:
# use_ncpus = int(0.75 * ncpus)
# # p = multiprocessing.Pool(ncpus, init_worker)
# print(('using {} out of {} cpus'.format(use_ncpus, ncpus)))
# p = multiprocessing.Pool(use_ncpus, init_worker)
# kwargs = {
# 'total': len(ilist),
# 'unit': 'it',
# 'unit_scale': True,
# 'leave': True
# }
# try:
# # results_list = p.map(decompose_one, tqdm(ilist))
# # results_list = tqdm(p.map(decompose_one, ilist), total=len(ilist))
# results_list = tqdm(p.imap(decompose_one, ilist), **kwargs)
#
# except KeyboardInterrupt:
# print("KeyboardInterrupt... quitting.")
# p.terminate()
# quit()
# p.close()
# del p
# return results_list
|
mrienerREPO_NAMEgausspyplusPATH_START.@gausspyplus_extracted@gausspyplus-master@gausspyplus@gausspy_py3@batch_decomposition.py@.PATH_END.py
|
{
"filename": "subplot.py",
"repo_name": "matplotlib/matplotlib",
"repo_path": "matplotlib_extracted/matplotlib-main/galleries/examples/subplots_axes_and_figures/subplot.py",
"type": "Python"
}
|
"""
=================
Multiple subplots
=================
Simple demo with multiple subplots.
For more options, see :doc:`/gallery/subplots_axes_and_figures/subplots_demo`.
.. redirect-from:: /gallery/subplots_axes_and_figures/subplot_demo
"""
import matplotlib.pyplot as plt
import numpy as np
# Create some fake data.
x1 = np.linspace(0.0, 5.0)
y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)
x2 = np.linspace(0.0, 2.0)
y2 = np.cos(2 * np.pi * x2)
# %%
# `~.pyplot.subplots()` is the recommended method to generate simple subplot
# arrangements:
fig, (ax1, ax2) = plt.subplots(2, 1)
fig.suptitle('A tale of 2 subplots')
ax1.plot(x1, y1, 'o-')
ax1.set_ylabel('Damped oscillation')
ax2.plot(x2, y2, '.-')
ax2.set_xlabel('time (s)')
ax2.set_ylabel('Undamped')
plt.show()
# %%
# Subplots can also be generated one at a time using `~.pyplot.subplot()`:
plt.subplot(2, 1, 1)
plt.plot(x1, y1, 'o-')
plt.title('A tale of 2 subplots')
plt.ylabel('Damped oscillation')
plt.subplot(2, 1, 2)
plt.plot(x2, y2, '.-')
plt.xlabel('time (s)')
plt.ylabel('Undamped')
plt.show()
# %%
# .. tags::
#
# component: subplot
# plot-type: line
# level: beginner
|
matplotlibREPO_NAMEmatplotlibPATH_START.@matplotlib_extracted@matplotlib-main@galleries@examples@subplots_axes_and_figures@subplot.py@.PATH_END.py
|
{
"filename": "hetdex_fits.py",
"repo_name": "HETDEX/elixer",
"repo_path": "elixer_extracted/elixer-main/elixer/hetdex_fits.py",
"type": "Python"
}
|
try:
from elixer import global_config as G
except:
import global_config as G
try:
from hetdex_api.shot import get_fibers_table as hda_get_fibers_table
except:
log.error("Unable to import get_fibers_table",exc_info=True)
import numpy as np
import tables
from astropy.io import fits as pyfits
from astropy.coordinates import Angle
from astropy.stats import biweight
from astropy.stats import sigma_clipped_stats
import os.path as op
import tarfile as tar
#log = G.logging.getLogger('hetdex_logger')
#log.setLevel(G.logging.DEBUG)
log = G.Global_Logger('hetdex_logger')
log.setlevel(G.LOG_LEVEL)
class HetdexFits:
'''A single HETDEX fits file ... 2D spectra, expected to be science file'''
#needs open with basic validation
#
def __init__(self,fn=None,e_fn=None,fe_fn=None,dither_index=-1,panacea=False,hdf5=False,empty=False):
"""
empty ... if True, don't attempt to read and populate, just return an empty HetdexFits
"""
self.okay = True
self.filename = fn
self.multiframe = None #multiframe (panacea) style name for HDF5 index etc
self.err_filename = e_fn
self.fe_filename = fe_fn
self.panacea = panacea
self.hdf5 = hdf5
# if HDF5, this must be a panacea style
# since the panacea flag is used elsewhere and this is decoupled from the actual FITS format
# set the panasea flag to True
if hdf5:
self.panacea = True
self.tel_ra = None
self.tel_dec = None
self.parangle = None
self.ifuid = None # reminder this is the cable
self.ifuslot = None # reminder this is the position (slot) on the fplane
self.side = None
self.amp = None
self.specid = None
self.obs_date = None
self.obs_ymd = None
self.mjd = None
self.obsid = None
self.expid = None
self.imagetype = None
#self.exptime = None #don't need these right now
#self.dettemp = None #don't need these right now
self.data = None
self.data_sky = None #sky NOT subtracted
self.err_data = None
self.fe_data = None #fiber extracted counts
self.wave_data = None #matched wavelengths
self.trace_data = None
self.fiber_to_fiber = None
self.error_analysis = None
self.pixflat_data = None
self.fiber_centers = None
self.fe_crval1 = None
self.fe_cdelt1 = None
#self.relflux_virus = [] #relative through put for each dither
self.calfib = None #calibrated, rectified (see G.CALFIB_WAVEGRID) (local sky subtraction)
self.calfibe = None
self.ffsky_calfib = None #fullfrield sky version of calfib
self.fiber_chi2 = None #fiber profile chi2
self.fiber_rms = None
self.calfib_noise_est = None
self.dither_index = dither_index
self.ampname = None #specifically, Header keyword (or could come from AMPLIFIE)
#build basic info from filename
#determine if 'cure'-style fits or panacea fits
#stupid simple just for now
#even for annulus, go ahead an read. Don't know if we are going to want the fits files, but may as well get them
if empty: #don't build this up yet
return
if self.hdf5:
self.read_hdf5()
elif "multi_" in self.filename: # example: multi_020_095_004_LU.fits
self.read_panacea_fits()
else:
self.read_fits(use_cosmic_cleaned=G.PreferCosmicCleaned)
self.read_efits(use_cosmic_cleaned=G.PreferCosmicCleaned)
self.read_fefits()
def build_calfib_noise_estimate(self):
try:
#todo: should we perform some sigma clipping?
#bw_mean = biweight.biweight_location(sigma_clipped_stats)
#bw_std = biweight.biweight_scale(self.calfib,axis=0)
mean, median, std = sigma_clipped_stats(self.calfib,axis=0, sigma=3.0)
#todo: check the means? should be close to zero?
self.calfib_noise_est = std
except:
self.calfib_noise_est = np.zeros(len(G.CALFIB_WAVEGRID))
def read_fits(self,use_cosmic_cleaned=False):
if not self.filename:
return None
if not op.exists(self.filename):
log.error("Error. FITS file does not exist: " + self.filename)
return None
try:
f = pyfits.open(self.filename)
except:
log.error("could not open file " + self.filename, exc_info=True)
return None
c = None
try:
if use_cosmic_cleaned:
base = op.basename(self.filename)
if base[0] != 'c':
path = op.dirname(self.filename)
cosmic = op.join(path,"c"+base)
log.info("Attempting to open cosmic cleaned version of file: " + cosmic)
c = pyfits.open(cosmic)
except:
log.error("could not open file " + cosmic, exc_info=True)
c = None
if c is not None:
self.data = np.array(c[0].data)
else:
self.data = np.array(f[0].data)
#clean up any NaNs
self.data[np.isnan(self.data)] = 0.0
try:
self.tel_ra = float(Angle(f[0].header['TELRA']+"h").degree) #header is in hour::mm:ss.arcsec
self.tel_dec = float(Angle(f[0].header['TELDEC']+"d").degree) #header is in deg:hh:mm:ss.arcsec
self.parangle = f[0].header['PARANGLE']
except:
log.error("Cannot translate RA and/or Dec from FITS format to degrees in " + self.filename, exc_info=True)
try:
self.ampname = f[idx].header['AMPNAME']
except:
log.info("FITS keyword [AMPNAME] not found. Trying alternate [AMPLIFIE] in " + self.filename)
try:
self.ampname = f[idx].header['AMPLIFIE']
except:
log.info("FITS keyword [AMPLIFIE] not found in " + self.filename)
self.ampname = None
try:
self.ifuid = str(f[0].header['IFUID']).zfill(3)
self.ifuslot = str(f[0].header['IFUSLOT']).zfill(3)
self.side = f[0].header['CCDPOS']
self.specid = str(f[0].header['SPECID']).zfill(3)
self.obs_date = f[0].header['DATE-OBS']
if '-' in self.obs_date: #expected format is YYYY-MM-DD
self.obs_ymd = self.obs_date.replace('-','')
self.mjd = f[0].header['MJD']
self.obsid = f[0].header['OBSID']
self.imagetype = f[0].header['IMAGETYP']
#self.exptime = f[0].header['EXPTIME']
#self.dettemp = f[0].header['DETTEMP']
except:
log.error("Cannot read expected keywords in fits header: " + self.filename,exc_info=True)
self.okay = False
try:
f.close()
except:
log.error("could not close file " + self.filename, exc_info=True)
if c is not None:
try:
c.close()
except:
log.error("could not close file cosmic file version of " + self.filename, exc_info=True)
return
def read_efits(self,use_cosmic_cleaned=False):
if self.err_filename is None:
return None
try:
f = pyfits.open(self.err_filename)
except:
log.error("could not open file " + self.err_filename, exc_info=True)
return None
c = None
try:
if use_cosmic_cleaned:
#for simplicity, using self.filename instead of self.err_filename
#since will assume err_filename = "e." + self.filename
base = op.basename(self.filename)
if base[0] != 'c':
path = op.dirname(self.err_filename)
cosmic = op.join(path, "e.c" + base)
log.info("Attempting to open cosmic cleaned version of file: " + cosmic)
c = pyfits.open(cosmic)
except:
log.error("could not open file " + cosmic, exc_info=True)
c = None
if c is not None:
self.err_data = np.array(c[0].data)
else:
self.err_data = np.array(f[0].data)
# clean up any NaNs
self.err_data[np.isnan(self.err_data)] = 0.0
try:
f.close()
except:
log.error("could not close file " + self.err_filename, exc_info=True)
if c is not None:
try:
c.close()
except:
log.error("could not close file cosmic file version of " + self.filename, exc_info=True)
return
def read_fefits(self):
if self.fe_filename is None:
return None
try:
f = pyfits.open(self.fe_filename)
except:
log.error("could not open file " + self.fe_filename, exc_info=True)
return None
try:
self.fe_data = np.array(f[0].data)
# clean up any NaNs
self.fe_data[np.isnan(self.fe_data)] = 0.0
self.fe_crval1 = f[0].header['CRVAL1']
self.fe_cdelt1 = f[0].header['CDELT1']
except:
log.error("could not read values or data from file " + self.fe_filename, exc_info=True)
try:
f.close()
except:
log.error("could not close file " + self.fe_filename, exc_info=True)
return
def read_hdf5(self):
if not self.filename:
self.okay = False
return None
try:
log.debug("Reading HDF5 file: %s" %(self.filename))
with tables.open_file(self.filename, mode="r") as h5_multifits:
fibers_table = h5_multifits.root.Data.Fibers
images_table = h5_multifits.root.Data.Images
shots_table = h5_multifits.root.Shot
# try: #not necessary ... this is also in the survey h5, no need to repeatedly get it here
# self.relflux_virus = h5_multifits.root.Astrometry.NominalVals.cols.relflux_virus[:] #relative through put for each dither
# except:
# log.info("Exception in HetdexFits getting relative throughputs.",exc_info=True)
# self.relflux_virus = None
# set the query values needed shortly ...
q_expnum = int(self.expid)
q_multiframe = self.multiframe
#########################################
#shot info
#########################################
#should only be one shot ...
rows = shots_table.read(0)
if (rows is None) or (rows.size != 1):
self.okay = False
if (rows is None):
reason = "(rows is None)"
else:
reason = f"(rows size is {rows.size}, expected 1)"
log.error("Problem loading multi-fits HDF5 equivalant. Bad Shot table." + reason)
return
row = rows[0]
self.tel_ra = row['ra'] #assuming decimal degrees, but is that true? (was not for FITS header)
self.tel_dec = row['dec']
self.parangle = row['pa']
self.obs_date = row['date']
self.obs_ymd = row['date']
self.mjd = row['mjd']
self.obsid = int(row['obsid'])
#don't currently need time, pressure, etc
#########################################
#Amp info (big images)
#########################################
rows = images_table.read_where("(multiframe==q_multiframe) & (expnum==q_expnum)")
if (rows is None):
self.okay = False
log.error("Problem loading multi-fits HDF5 equivalant. Bad Images table (0 rows returned).")
elif (rows.size != 1):
self.okay = False
log.error("Problem loading multi-fits HDF5 equivalant. Bad Images table "
"(%d rows returned. Expected 1.) %s expn %d" %(rows.size, q_multiframe, q_expnum))
return
row = rows[0]
# use the cleaned image
self.data = row['clean_image']
self.data[np.isnan(self.data)] = 0.0 # clean up any NaNs
if self.data.shape != (1032, 1032):
log.error(
"ERROR!! Unexpected data shape for [clean_image]. Expected (1032,1032), got (%d,%d)" % (
self.data.shape))
# get the error
self.err_data = row['error']
self.err_data[np.isnan(self.err_data)] = 0.0
if self.err_data.shape != (1032, 1032):
log.error("ERROR!! Unexpected data shape for [error]. Expected (1032,1032), got (%d,%d)"
% (self.err_data.shape))
self.err_data = np.full(self.data.shape,0.0)
# with the sky NOT subtracted (the raw image)
self.data_sky = row['image']
self.data_sky[np.isnan(self.data_sky)] = 0.0 # clean up any NaNs
if self.data_sky.shape != (1032, 1032):
log.error("ERROR!! Unexpected data shape for [0] (data_sky). Expected (1032,1032), got (%d,%d)"
% (self.data_sky.shape))
#temp:
# im_max = np.max(self.data_sky)
# im_min = np.min(self.data_sky)
# num_zero = len(np.where(self.data_sky==0)[0])
# num_not_zero = len(np.where(self.data_sky != 0)[0])
# frac = num_zero/(num_not_zero+num_zero)
#
# print(q_multiframe,q_expnum,im_min,im_max,num_zero,num_not_zero,frac)
#########################################
#fiber info (and amp, etc)
#!!! For compatibility with the older organization
# this is the image data,etc for a single fiber
# There will be redundant data
#########################################
# if need to use Data.FiberIndex table
# know that FiberIndex table is supposed to be in the same order as Fibers
# so the indices should match up (FiberIndex has same number of rows but
# less data than Fibers, so it is faster to query w/o an indexed column)
# so ...
# mf = fiber_index_table.col('multiframe') #this will be in b'xxxx' format
# idx = np.where(mf == b'q_multiframe') #these will be for ALL expIDs as well though
# rows = fiber_table.read_coordinates(idx[0]) # again, note you'll get ALL 3 expIDs
use_hdf5 = True #load from the hdf5 directly if fibers table fails
# some of the info can now come through hetdex_api and have extra corrections applied to it
if G.LOAD_SPEC_FROM_HETDEX_API:
try:
hda_fibers_table = hda_get_fibers_table(shot=int(str(self.obs_date) + str(self.obsid).zfill(3)), coords=None,
ifuslot=None, multiframe=self.multiframe,
expnum=int(self.expid), radius=None,
survey="hdr" + G.HDR_Version,
astropy=True, verbose=False, rawh5=False)
except:
hda_fibers_table = None
log.warning("Exception loading fibers table from hetdex_api. Will use hdf5 files directly.",
exc_info=True)
else:
hda_fibers_table = None
if hda_fibers_table is not None: #use the astropy table from hetdex api
try:
def get_field(field_name,shape,logname_info="unsp"):
try:
data = np.array(hda_fibers_table[field_name])
size = np.size(data)
s = np.shape(data)
nans = np.count_nonzero(np.isnan(data))
infs = np.count_nonzero(np.isinf(data))
if log.logger.level <= 10: # ie. only bother with this if debug
zeros = np.count_nonzero(data == 0)
if zeros > size / 10:
# not as important ... can just be masked data
log.debug(
f"Warning! {logname_info} : Large number of 0's in {field_name}. {zeros} / {size}")
if nans > size / 10:
log.info(
f"Warning! {logname_info} : Large number of NaNs in {field_name}. {nans} / {size}")
if infs > size / 10:
log.info(
f"Warning! {logname_info} : Large number of INFs in {field_name}. {infs} / {size}")
if s != shape:
log.info(
f"Warning! {logname_info} : Unexpected shape for {field_name}. Got {s}. Expected {shape}.")
data = np.nan_to_num(data)
return data
except ValueError as ve:
if "no field" in str(ve): # these are generally expected
log.debug(f"Exception retrieving field: {logname_info} : {field_name}")
raise ve
return np.full(shape, 0)
except:
log.error(f"Exception retrieving field: {logname_info} : {field_name}", exc_info=True)
return np.full(shape, 0)
self.fe_data = get_field('sky_subtracted',(112,1032),self.multiframe) # np.zeros()
self.wave_data = get_field('wavelength',(112,1032),self.multiframe)#np.array(hda_fibers_table['wavelength']) #np.zeros((112, 1032))
self.trace_data = get_field('trace',(112,1032),self.multiframe)#np.array(hda_fibers_table['trace']) #np.zeros((112, 1032))
self.fiber_to_fiber = get_field('fiber_to_fiber',(112,1032),self.multiframe) #np.array(hda_fibers_table['fiber_to_fiber']) #np.zeros((112, 1032))
self.calfib = get_field('calfib',(112,len(G.CALFIB_WAVEGRID)),self.multiframe)#np.array(hda_fibers_table['calfib']) #np.zeros((112, len(G.CALFIB_WAVEGRID)))
self.calfibe = get_field('calfibe',(112,len(G.CALFIB_WAVEGRID)),self.multiframe)#np.array(hda_fibers_table['calfibe']) #np.zeros((112, len(G.CALFIB_WAVEGRID)))
if G.HDR_Version_float < 3.0:
self.ffsky_calfib = get_field('spec_fullsky_sub',(112,len(G.CALFIB_WAVEGRID)),self.multiframe)#np.array(hda_fibers_table['calfib_ffsky']) #np.zeros((112, len(G.CALFIB_WAVEGRID)))
else:
self.ffsky_calfib = get_field('calfib_ffsky',(112,len(G.CALFIB_WAVEGRID)),self.multiframe)#np.array(hda_fibers_table['calfib_ffsky']) #np.zeros((112, len(G.CALFIB_WAVEGRID)))
self.fiber_chi2 = get_field('chi2',(112,1032),self.multiframe)#np.array(hda_fibers_table['chi2']) #np.zeros((112, 1032))
self.fiber_rms = get_field('rms',(112,1032),self.multiframe)#np.array(hda_fibers_table['rms']) #np.zeros((112, 1032))
#change from flux density back into flux over x2AA for consistency
self.calfib *= G.FLUX_WAVEBIN_WIDTH
self.calfibe *= G.FLUX_WAVEBIN_WIDTH
self.ffsky_calfib *= G.FLUX_WAVEBIN_WIDTH
use_hdf5 = False
except:# Exception as e:
#print(e)
log.warning("Exception loading fiber data from hetdex_api fiber table. "
"Will attemp to use hdf5 directly.",exc_info=True)
try:
if hda_fibers_table is not None:
del hda_fibers_table
except:
pass
if use_hdf5: #pull directly from the h5 files
try:
directquery = 'multiframe' in fibers_table.colindexes.keys()
#log.debug("read_hdf5, Fibers table has multiframe index. Will use direct query.")
except:
directquery = False
#log.debug("read_hdf5, Fibers table missing multiframe index. Will use indirect query via FiberIndex table.")
if directquery: #other table read and try to match up indexes as above comment
rows = fibers_table.read_where("(multiframe==q_multiframe) & (expnum==q_expnum)")
else:
mfcol = h5_multifits.root.Data.FiberIndex.col('multiframe')
mfidx = np.where(mfcol==q_multiframe.encode()) #encode because in b'xxx' format
try: #if the expnum col exists, get it also
#and then get the indices for matches vs the multiframe AND the expnum
expcol = h5_multifits.root.Data.FiberIndex.col('expnum')
expidx = np.where(expcol==q_expnum)
joinidx = np.intersect1d(mfidx,expidx)
rows = fibers_table.read_coordinates(joinidx)
except: #expnum col does not exist so query all multiframe, then trim to expnum
allexp = fibers_table.read_coordinates(mfidx[0],field='expnum')
allrows = fibers_table.read_coordinates(mfidx[0])
idx = np.where(allexp==q_expnum)
rows = allrows[idx[0]]
###
#rows = fibers_table.read_where("(multiframe==q_multiframe) & (expnum==q_expnum)",field=expnum)
#expect there to be 112 fibers (though maybe fewer if some are dead)
if (rows is None) or (rows.size == 0):
self.okay = False
log.error(f"Problem loading multi-fits HDF5 equivalant. No fibers found. {q_multiframe} expnum ({q_expnum})")
return
# todo: maybe build up the arrays, as if they were read from a multi-fits file?
# that is, for each row, starting with index 0, build up the equivalent arrays for:
# sky_subtracted (fe_data) 112,1032
# wavelength (wave_data) 112,1032
# trace (trace_data) 112,1032
# fiber_to_fiber (fiber_to_fiber) 112,1032
# error_analysis (error_analysis) 3,1032 ???
#
# this way, all the downstream code stays the same, even if this is duplicate data
# (and, as a future todo: re-organize the code so this is not necessary)
#incase something goes wrong, we want something here, not just None or empty lists
self.fe_data = np.zeros((112,1032))
self.wave_data = np.zeros((112, 1032))
self.trace_data = np.zeros((112, 1032))
self.fiber_to_fiber = np.zeros((112, 1032))
self.calfib = np.zeros((112, len(G.CALFIB_WAVEGRID)))
self.calfibe = np.zeros((112, len(G.CALFIB_WAVEGRID)))
self.ffsky_calfib = np.zeros((112, len(G.CALFIB_WAVEGRID)))
self.fiber_chi2 = np.zeros((112, 1032))
self.fiber_rms = np.zeros((112, 1032))
# self.fe_data = [[]]*112
# self.wave_data = [[]]*112
# self.trace_data = [[]]*112
# self.fiber_to_fiber = [[]]*112
# self.calfib = [[]]*112
# self.calfibe = [[]]*112
#todo: figure out what to do with error analysis
#self.error_analysis = np.zeros((3, 1032))
def get_field(row, field_name, shape,logname_info="unsp"):
try:
data = row[field_name]
size = np.size(data)
s = np.shape(data)
nans = np.count_nonzero(np.isnan(data))
infs = np.count_nonzero(np.isinf(data))
if log.logger.level <= 10: #ie. only bother with this if debug
zeros = np.count_nonzero(data==0)
if zeros > size/10:
#not as important ... can just be masked data
log.debug(f"Warning! {logname_info} : Large number of 0's in {field_name}. {zeros} / {size}")
if nans > size/10:
log.info(f"Warning! {logname_info} : Large number of NaNs in {field_name}. {nans} / {size}")
if infs > size/10:
log.info(f"Warning! {logname_info} : Large number of INFs in {field_name}. {infs} / {size}")
if s != shape:
log.info(f"Warning! {logname_info} : Unexpected shape for {field_name}. Got {s}. Expected {shape}.")
data = np.nan_to_num(data)
return data
except ValueError as ve:
if "no field" in str(ve): #these are generally expected
log.debug(f"Exception retrieving field: {logname_info} : {field_name}")
raise ve
return np.full(shape,0)
except:
log.error(f"Exception retrieving field: {logname_info} : {field_name}",exc_info=True)
return np.full(shape,0)
for row in rows:
#at some point this changes to fibidx
try:
idx = row['fibidx'] # fibnum is 0-111 so, just like an index
except:
idx = row['fibnum'] # fibnum is 0-111 so, just like an index
logname_info = f"{op.basename(self.filename)}::{self.multiframe}"
# self.fe_data[idx] = row['sky_subtracted']
# self.wave_data[idx] = row['wavelength']
# self.trace_data[idx] = row['trace']
# self.fiber_to_fiber[idx] = row['fiber_to_fiber']
#
# self.calfib[idx] = row['calfib']
# self.calfibe[idx] = row['calfibe']
self.fe_data[idx] = get_field(row,'sky_subtracted',np.shape(self.fe_data[idx]),f"{logname_info}_{idx}")
self.wave_data[idx] = get_field(row,'wavelength',np.shape(self.wave_data[idx]),f"{logname_info}_{idx}")
self.trace_data[idx] = get_field(row,'trace',np.shape(self.trace_data[idx]),f"{logname_info}_{idx}")
self.fiber_to_fiber[idx] = get_field(row,'fiber_to_fiber',np.shape(self.fiber_to_fiber[idx]),f"{logname_info}_{idx}")
self.calfib[idx] = get_field(row,'calfib',np.shape(self.calfib[idx]),f"{logname_info}_{idx}")
self.calfibe[idx] = get_field(row,'calfibe',np.shape(self.calfibe[idx]),f"{logname_info}_{idx}")
#temporary 7% correction for hdr3
try:
if "/hdr3/" in h5_multifits.filename:
if (self.amp in ['RU','LL'] and (0 <= idx <= 11)) or \
(self.amp in ['LU','RL'] and (100 <= idx <= 111)):
log.info(f"*** HDR3 correction: Adjusting calfibe by x1.07: {q_multiframe} {idx+1}")
self.calfibe[idx] *= 1.07
except:
pass
try: #in HDR3 the name is new
#self.ffsky_calfib[idx] = row['calfib_ffsky']
self.ffsky_calfib[idx] = get_field(row,'calfib_ffsky',np.shape(self.ffsky_calfib[idx]),f"{logname_info}_{idx}")
except:
try: #HDR2
#self.ffsky_calfib[idx] = row['spec_fullsky_sub']
self.ffsky_calfib[idx] = get_field(row,'spec_fullsky_sub',np.shape(self.ffsky_calfib[idx]),f"{logname_info}_{idx}")
except:
pass #older versions may not have this column
try:
# self.fiber_chi2[idx] = row['chi2']
# self.fiber_rms[idx] = row['rms']
self.fiber_chi2[idx] = get_field(row,'chi2',np.shape(self.fiber_chi2[idx]),f"{logname_info}_{idx}")
self.fiber_rms[idx] = get_field(row,'rms',np.shape(self.fiber_rms[idx]),f"{logname_info}_{idx}")
except:
pass #older versions may not have these columns
#todo: deal with AMP vs AMPNAME (for flip_amp() ... the pixel flats issue)
# self.ampname
#
# try:
# self.ampname = f[idx].header['AMPNAME']
# except:
# log.info("FITS keyword [AMPNAME] not found. Trying alternate [AMPLIFIE] in " + self.filename)
# try:
# self.ampname = f[idx].header['AMPLIFIE']
# except:
# log.info("FITS keyword [AMPLIFIE] not found in " + self.filename)
# self.ampname = None
except:
log.error("Could not process HDF5 multi-fits equivalent: %s" %(self.filename),exc_info=True)
self.okay = False
return None
return None
#not used at this level ("noise" on an amp)
#self.build_calfib_noise_estimate()
def read_panacea_fits(self):
#this represents one AMP
#15+ hdus, different header keys
if not self.filename:
self.okay = False
return None
tarfile = None
file = None
if not op.exists(self.filename):
# todo: try to find .tar file and load that way
log.info("%s does not exist. Looking for tar file ..." %(self.filename))
tar_fn = self.filename.split("/exp")[0] + ".tar"
fits_fn = ""
try:
if op.exists(tar_fn):
if tar.is_tarfile(tar_fn):
tarfile = tar.open(name=tar_fn)
#search for name first? or just try to extract it ... just extract ... if not there it will throw
#an exception and it will be trapped
#todo: if the naming of the path becomes irregular
#todo: then substring search for the "exp01/virus/multi_xxx.fits" part (should still be exactly one match)
#todo: and return the entire string in which it matches as the fits_fn
#fqdn = tarfile.getnames() # list of all conents (as full paths) includes directories
# remember, no leading '/' in tarfile contents
# fits_fn = "exp" + self.filename.split("/exp")[1]
# i.e. = "exp01/virus/multi_038_096_014_RU.fits"
fits_fn = "virus" + self.filename.split("/virus/virus")[1]
# ie. = "virus0000001/exp01/virus/multi_038_096_014_RU.fits"
file = tarfile.extractfile(fits_fn)
# remember do not close the tarfile until we are done
else:
log.info("Could not open tarfile:fits (%s: %s)" %(tar_fn,fits_fn))
except:
log.error("Error. Could not open tarfile:fits (%s: %s)" %(tar_fn,fits_fn), exc_info=True)
tarfile = None
file=None
if file == None:
log.error("Error. FITS file does not exist: " + self.filename)
try:
if tarfile:
tarfile.close()
except:
log.error("could not close tar file ", exc_info=True)
return None
else:
file = self.filename
try:
log.info("Loading %s ..." %self.filename)
f = pyfits.open(file) #file maybe a file name or a .tar file object
except:
log.error("could not open file " + self.filename, exc_info=True)
try:
if tarfile:
tarfile.close()
except:
log.error("could not close tar file ", exc_info=True)
return None
try:
#build idx
#the position of each extention within the multi-frame panacea FITS is not fixed,
#so need to build the index (dictionary) for each one we load
hdu_idx = {}
for i in range(len(f)):
try:
if f[i].header['EXTNAME'] in hdu_idx:
log.warning("WARNING! Duplicate frame 'EXTNAME' found. ['%s'] at index %d and %d in file: %s"
%(f[i].header['EXTNAME'],hdu_idx[f[i].header['EXTNAME']], i,self.filename))
else:
hdu_idx[f[i].header['EXTNAME']] = i
except:
pass
#use the cleaned image for display
self.data = np.array(f[hdu_idx['clean_image']].data)
self.data[np.isnan(self.data)] = 0.0 # clean up any NaNs
if self.data.shape != (1032,1032):
log.error("ERROR!! Unexpected data shape for [clean_image]. Expected (1032,1032), got (%d,%d)" %(self.data.shape))
#with the sky NOT subtracted
try:
self.data_sky = np.array(f[0].data)
self.data_sky[np.isnan(self.data_sky)] = 0.0 # clean up any NaNs
except: #error, but not fatal, just keep going
log.error("Could not load sky NOT subtracted fits data from multi*fits")
if self.data_sky.shape != (1032,1032):
log.error("ERROR!! Unexpected data shape for [0] (data_sky). Expected (1032,1032), got (%d,%d)"
%(self.data_sky.shape))
#get error equivalent
self.err_data = np.array(f[hdu_idx['error']].data)
if self.err_data.shape != (1032, 1032):
print("TEMPORARY!!! using [1] for ['error'] frame until name correctd.")
self.err_data = np.array(f[1].data)
self.err_data[np.isnan(self.err_data)] = 0.0
if self.err_data.shape != (1032,1032):
log.error("ERROR!! Unexpected data shape for [error]. Expected (1032,1032), got (%d,%d)"
%(self.err_data.shape))
#get fe equivalent
self.fe_data = np.array(f[hdu_idx['sky_subtracted']].data)
self.fe_data[np.isnan(self.fe_data)] = 0.0
if self.fe_data.shape != (112,1032):
log.error("ERROR!! Unexpected data shape for [sky_subtracted]. Expected (112,1032), got (%d,%d)"
%(self.fe_data.shape))
# get fe equivalent (need also the matching wavelengths)
self.wave_data = np.array(f[hdu_idx['wavelength']].data)
self.wave_data[np.isnan(self.wave_data)] = 0.0
if self.wave_data.shape != (112,1032):
log.error("ERROR!! Unexpected data shape for [wavelength]. Expected (112,1032), got (%d,%d)"
%(self.wave_data.shape))
self.trace_data = np.array(f[hdu_idx['trace']].data)
self.trace_data[np.isnan(self.trace_data)] = 0.0
if self.trace_data.shape != (112,1032):
log.error("ERROR!! Unexpected data shape for [trace]. Expected (112,1032), got (%d,%d)"
%(self.trace_data.shape))
self.fiber_to_fiber = np.array(f[hdu_idx['fiber_to_fiber']].data)
self.fiber_to_fiber[np.isnan(self.fiber_to_fiber)]
if self.fiber_to_fiber.shape != (112,1032):
log.error("ERROR!! Unexpected data shape for [fiber_to_fiber]. Expected (112,1032), got (%d,%d)"
%(self.fiber_to_fiber.shape))
#[0] = wavelength, [1] = empirical? [2] = expected or estimated?
self.error_analysis = np.array(f[hdu_idx['error_analysis']].data)
self.error_analysis[np.isnan(self.error_analysis)]
if self.error_analysis.shape != (3,512):
log.error("ERROR!! Unexpected data shape for [error_analysis]. Expected (3,512), got (%d,%d)"
%(self.error_analysis.shape))
#note: (this is done by IFU in build_fibers for each fiber that is constructed)
#closest thing to error is the error_analysis * fiber_to_fiber (for the fiber in question)
#take spectra ("clean image") and divide by fiber_to_fiber for the fiber in question
#note fiber to fiber is the deviation from the average of fibers
#when getting the data for a fiber, need to interpolate the error_analysis to be on same grid
# as the wave_data for that fiber and then do the multiply and divide as needed
# get fiber centers
# the fits representation is backward (with grid x,y: 1,112 and 2,112 (i.e at the top) == fiber 1))
self.fiber_centers = np.array(f[hdu_idx['ifupos']].data)
if self.fiber_centers.shape != (112, 2):
log.error("ERROR!! Unexpected data shape for [ifupos]. Expected (112,2), got (%d,%d)"
% (self.fiber_centers.shape))
#self.pixflat_data = np.array(f[hdu_idx['flat_image']].data)
#self.pixflat_data[np.isnan(self.pixflat_data)] = 0.0
self.panacea = True
#most complete header in the raw image
#todo: at some point in late 2017, the 'image' header was dropped ... as this becomes common,
#todo: should stop trying to read the 'image' header and just always assume the 0th is PRIMARY?
#todo: (is always TRUE ... or at least always after a re-reduction?)
try:
idx = hdu_idx['image']
except:
log.debug("[image] header not found. Will assume 0th header is the PRIMARY.")
idx = 0
except:
log.error("Cannot read fits header. Missing expected keywords. " + self.filename, exc_info=True)
self.okay = False
try:
if tarfile:
tarfile.close()
except:
log.error("could not close tar file ", exc_info=True)
return
try:
self.tel_ra = float(f[idx].header['RA']) * 15.0 # header is in decimal hours
self.tel_dec = float(f[idx].header['DEC']) # header is in decimal degs
self.parangle = f[idx].header['PA']
except:
log.error("Non-fatal: Cannot translate RA and/or Dec from FITS format to degrees in " + self.filename, exc_info=True)
#might be okay, depeding on if the individual emission lines have the weighted RA and Dec Specified
try: #reminder not the same as AMP (LU, RU, LL, LR) ... can be UL, etc ... used in flip_amp() in hetdex
self.ampname = f[idx].header['AMPNAME']
except:
log.info("FITS keyword [AMPNAME] not found. Trying alternate [AMPLIFIE] in " + self.filename)
try:
self.ampname = f[idx].header['AMPLIFIE']
except:
log.info("FITS keyword [AMPLIFIE] not found in " + self.filename)
self.ampname = None
try:
self.ifuid = str(f[idx].header['IFUSID']).zfill(3)
self.ifuslot = str(f[idx].header['IFUSLOT']).zfill(3)
self.specid = str(f[idx].header['SPECID']).zfill(3)
self.amp = f[idx].header['AMP']
self.side = f[idx].header['AMP'][0] #the L or R ... probably don't need this anyway
#self.exptime = f[idx].header['EXPTIME']
except:
try:
if tarfile:
tarfile.close()
except:
log.error("could not close tar file ", exc_info=True)
log.error("Cannot read fits header. Missing expected keywords. Will attempt to pull from filename." + self.filename, exc_info=True)
#try to get info from the filename
self.parse_panacea_fits_name(self.filename)
return
try:
if tarfile:
tarfile.close()
except:
log.error("could not close tar file ", exc_info=True)
try:
f.close()
except:
log.error("could not close file " + self.filename, exc_info=True)
return
def parse_panacea_fits_name(self,name):
if name is not None:
if "multi_" in name: #multi_037_073_031_LL.fits
toks = name.split("_") #multi_fits_basename = "multi_" + self.specid + "_" + self.ifu_slot_id + "_" + self.ifu_id + "_"
if len(toks) == 5:
try:
self.specid = toks[1].zfill(3)
self.ifuslot = toks[2].zfill(3)
self.ifuid = toks[3].zfill(3)
self.amp = toks[4][0:2]
self.side =toks[4][0]
except:
log.error("Cannot parse panaces fits filename: %s" %name,exc_info=True)
self.okay = False
def cleanup(self):
#todo: close fits handles, etc
pass
|
HETDEXREPO_NAMEelixerPATH_START.@elixer_extracted@elixer-main@elixer@hetdex_fits.py@.PATH_END.py
|
{
"filename": "gwfastGlobals.py",
"repo_name": "CosmoStatGW/gwfast",
"repo_path": "gwfast_extracted/gwfast-master/gwfast/gwfastGlobals.py",
"type": "Python"
}
|
#
# Copyright (c) 2022 Francesco Iacovelli <francesco.iacovelli@unige.ch>, Michele Mancarella <michele.mancarella@unige.ch>
#
# All rights reserved. Use of this source code is governed by the
# license that can be found in the LICENSE file.
##############################################################################
# DIRECTORIES
##############################################################################
import os
import numpy as np
dirName = os.path.dirname( os.path.dirname(os.path.abspath(__file__)))
"""
Path to the ``gwfast`` directory.
:type: str
"""
detPath=os.path.join(dirName, 'psds')
"""
Path to the ``./psds`` directory, containing the provided detector PSDs.
:type: str
"""
WFfilesPath = os.path.join(dirName, 'WFfiles')
"""
Path to the ``./WFfiles`` directory, containing files needed for the waveform evaluation.
:type: str
"""
##############################################################################
# PHYSICAL CONSTANTS
##############################################################################
# See http://asa.hmnao.com/static/files/2021/Astronomical_Constants_2021.pdf
GMsun_over_c3 = 4.925491025543575903411922162094833998e-6 # seconds
"""
Geometrized solar mass :math:`G \, {\\rm M}_{\odot} / c^3`, in seconds (:math:`\\rm s`).
:type: float
"""
GMsun_over_c2 = 1.476625061404649406193430731479084713e3 # meters
"""
Geometrized solar mass :math:`G \, {\\rm M}_{\odot} / c^2`, in meters (:math:`\\rm m`).
:type: float
"""
uGpc = 3.085677581491367278913937957796471611e25 # meters
"""
Gigaparsec (:math:`\\rm Gpc`) in meters (:math:`\\rm m`).
:type: float
"""
uMsun = 1.988409902147041637325262574352366540e30 # kg
"""
Solar mass (:math:`{\\rm M}_{\odot}`) in kilograms (:math:`\\rm kg`).
:type: float
"""
uAU = 149597870.7 # km
"""
Astronomical unit (:math:`\\rm A.U.`) in kilometers (:math:`\\rm km`).
:type: float
"""
GMsun_over_c2_Gpc = GMsun_over_c2/uGpc # Gpc
"""
Geometrized solar mass :math:`G \, {\\rm M}_{\odot} / c^2`, in gigaparsec (:math:`\\rm Gpc`).
:type: float
"""
REarth = 6371.00 # km
"""
Average Earth radius, in kilometers (:math:`\\rm km`).
:type: float
"""
siderealDay = 23.9344696 # hours
"""
Sidereal day, in hours (:math:`\\rm hr`).
:type: float
"""
clight = 2.99792458e5 # km/s
"""
Speed of light in vacuum (:math:`c`), in kilometers per second (:math:`\\rm km / s`).
:type: float
"""
clightGpc = clight/3.0856778570831e+22
"""
Speed of light in vacuum (:math:`c`), in gigaparsecs per second (:math:`\\rm Gpc / s`).
:type: float
"""
gravConst = 6.67430e-11
"""
Gravitational constant (:math:`G`), in cubic meters per kilogram per square second (:math:`\\rm m^3\, kg^{-1}\, s^{-2}`).
:type: float
"""
# ISCO frequency coefficient for a Schwarzschild BH
f_isco=1./(np.sqrt(6.)*6.*2.*np.pi*GMsun_over_c3)
"""
ISCO frequency coefficient for a Schwarzschild BH, in :math:`\\rm Hz`.
:type: float
"""
# limit of the quasi-Keplerian approximation, as in arXiv:2108.05861 (see also arXiv:1605.00304), more conservative than the Schwarzschild ISCO
f_qK = 2585. # Hz
"""
Coefficient for the limit of the quasi-Keplerian approximation, in :math:`\\rm Hz`, as in `arXiv:2108.05861 <https://arxiv.org/abs/2108.05861>`_ (see also `arXiv:1605.00304 <https://arxiv.org/abs/1605.00304>`_). This is more conservative than two times the Schwarzschild ISCO.
:type: float
"""
##############################################################################
# POSITIONS OF DETECTORS
# See https://iopscience.iop.org/article/10.3847/1538-4357/ac4164
##############################################################################
detectors = { 'L1': { 'lat':30.563,
'long':-90.774,
'xax':242.71636956358617,
'shape':'L',
},
'H1': { 'lat':46.455,
'long':-119.408,
'xax':170.99924234706103,
'shape':'L',
},
'Virgo': {'lat':43.631,
'long':10.504,
'xax':115.56756342034298,
'shape':'L',
},
'KAGRA': {'lat':36.412,
'long':137.306,
'xax':15.396,
'shape':'L',
},
'LIGOI': {'lat':19.613,
'long':77.031,
'xax':287.384,
'shape':'L',
},
'ETS': { 'lat': 40.+31./60.,
'long': 9.+25./60.,
'xax':0. ,
'shape':'T',
},
'ETMR': {'lat': 50.+43./60.+23./3600.,
'long': 5.+55./60.+14./3600.,
'xax':0. ,
'shape':'T',
},
'ETSL': { 'lat': 40.+31./60.,
'long': 9.+25./60.,
'xax':45. ,
'shape':'L',
},
'ETMRL45d': {'lat': 50.+43./60.+23./3600.,
'long': 5.+55./60.+14./3600.,
'xax':90. ,
'shape':'L',
},
'ETMRLpar': {'lat': 50.+43./60.+23./3600.,
'long': 5.+55./60.+14./3600.,
'xax':45. ,
'shape':'L',
},
'CE1Id':{'lat':43.827,
'long':-112.825,
'xax':-45.,
'shape':'L',
},
'CE2NM':{'lat':33.160,
'long':-106.480,
'xax':-105.,
'shape':'L',
},
'CE2NSW':{'lat':-34.,
'long':145.,
'xax':0.,
'shape':'L',
},
}
"""
Pre-defined detector locations and orientations.
:type: dict(dict, dict, ...)
"""
|
CosmoStatGWREPO_NAMEgwfastPATH_START.@gwfast_extracted@gwfast-master@gwfast@gwfastGlobals.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "davidharvey1986/pyRRG",
"repo_path": "pyRRG_extracted/pyRRG-master/unittests/bugFixPyRRG/lib/python3.7/site-packages/pkg_resources/extern/__init__.py",
"type": "Python"
}
|
import sys
class VendorImporter:
"""
A PEP 302 meta path importer for finding optionally-vendored
or otherwise naturally-installed packages from root_name.
"""
def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
self.root_name = root_name
self.vendored_names = set(vendored_names)
self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
@property
def search_path(self):
"""
Search first the vendor package then as a natural package.
"""
yield self.vendor_pkg + '.'
yield ''
def find_module(self, fullname, path=None):
"""
Return self when fullname starts with root_name and the
target module is one vendored through this importer.
"""
root, base, target = fullname.partition(self.root_name + '.')
if root:
return
if not any(map(target.startswith, self.vendored_names)):
return
return self
def load_module(self, fullname):
"""
Iterate over the search path to locate and load fullname.
"""
root, base, target = fullname.partition(self.root_name + '.')
for prefix in self.search_path:
try:
extant = prefix + target
__import__(extant)
mod = sys.modules[extant]
sys.modules[fullname] = mod
return mod
except ImportError:
pass
else:
raise ImportError(
"The '{target}' package is required; "
"normally this is bundled with this package so if you get "
"this warning, consult the packager of your "
"distribution.".format(**locals())
)
def install(self):
"""
Install this importer into sys.meta_path if not already present.
"""
if self not in sys.meta_path:
sys.meta_path.append(self)
names = 'packaging', 'pyparsing', 'six', 'appdirs'
VendorImporter(__name__, names).install()
|
davidharvey1986REPO_NAMEpyRRGPATH_START.@pyRRG_extracted@pyRRG-master@unittests@bugFixPyRRG@lib@python3.7@site-packages@pkg_resources@extern@__init__.py@.PATH_END.py
|
{
"filename": "_gridcolor.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py3/plotly/validators/layout/ternary/caxis/_gridcolor.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator):
def __init__(
self, plotly_name="gridcolor", parent_name="layout.ternary.caxis", **kwargs
):
super(GridcolorValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "plot"),
**kwargs,
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py3@plotly@validators@layout@ternary@caxis@_gridcolor.py@.PATH_END.py
|
{
"filename": "src_offsets_rotated.py",
"repo_name": "askap-craco/CELEBI",
"repo_path": "CELEBI_extracted/CELEBI-main/localise/src_offsets_rotated.py",
"type": "Python"
}
|
#####################################################################################
# GENERAL PYTHON IMPORTS
#####################################################################################
import argparse
import glob
import os
import re
import sys
import math
from itertools import dropwhile, islice
import matplotlib.pyplot as plt
import numpy as np
from astropy import constants as const
from astropy import units as u
from astropy.io import fits
from astropy.coordinates import SkyCoord as sc
#####################################################################################
# SET UP ARGUEMENTS
#####################################################################################
# Set up parser with description string
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description="""\
PURPOSE: Continuum source position offset calculator and plotter
This script calculates the offsets between continuum field source positions from ASKAP and
one or more source catalogues and their uncertainties.
INPUT:
File: containing the source positions from ASKAP
File: containing the ASKAP source names
File: containing relevant jmfit filenames
File(s): containing catalogue source positions for comparison
Notes on file formats:
txt files with comma separated values as follows
ASKAP: RA(hms),RA_err(ms),Dec(dms),Dec_err(mas)
NVSS: RA(hms),RA_err(ms),Dec(dms),Dec_err(arcsec)
SUMSS: RA(hms),RA_err(arcsec),Dec(dms),Dec_err(arcsec)
FIRST: RA(hms),Dec(dms),Fpeak(mJy/bm),rms(mJy/bm),Maj("),Min("),PA(deg),fMaj("),fMin(")
VLASS: RA(hms),RA_err(ms),Dec(dms),Dec_err(mas)
OUTPUT:
Plot: source offsets (ASKAP vs. Catalogue) with weighted mean
File: .dat file containing the source offsets and uncertainties to be used for
weighted_multi_image_fit.py infile1 infile2 ...
e.g. python multi_image_fit.py 190102.dat 190608.dat 190711.dat
Infiles have: one column per source, rows are ra_offset, dec_offset, ra_err, dec_err
Please use simple text file with numbers and whitespace separation
Revision history:
Written by Cherie Day on 5 June, 2020
Python version: 3.7.0
Modified by AB on March 14, 2023
""",
)
parser.add_argument(
"--askappos",
type=str,
default=None,
help="The file containing the ASKAP continuum source positions",
)
parser.add_argument(
"--askapnames",
type=str,
default=None,
help="The file containing the ASKAP continuum source names",
)
parser.add_argument(
"--jmfitnames",
type=str,
default=None,
help="The file containing the list of jmfit files",
)
parser.add_argument(
"--fieldfits",
type=str,
default=None,
help="The FITS image of the field",
)
parser.add_argument(
"--first",
type=str,
default=None,
help="The file containing the FIRST catalogue sources if use",
)
parser.add_argument(
"--nvss",
type=str,
default=None,
help="Set if the NVSS catalogue is being used",
)
parser.add_argument(
"--racs",
type=str,
default=None,
help="Set if the RACS catalogue is being used",
)
parser.add_argument(
"--sumss",
type=str,
default=None,
help="Set if the SUMSS catalogue is being used",
)
parser.add_argument(
"--vlass",
type=str,
default=None,
help="Set if the VLASS catalogue is being used",
)
parser.add_argument(
"--frbtitletext",
type=str,
default=None,
help="The name of the ASKAP FRB field being compared",
)
args = parser.parse_args()
print(f"\nArguments specified: {args}\n")
#####################################################################################
# CATCH ERRORS
#####################################################################################
if len(sys.argv) < 2:
parser.print_usage()
sys.exit()
if args.askappos is None:
parser.error(
"You must specify a text file containing the ASKAP source information"
)
if args.askapnames is None:
parser.error("You must specify a text file containing the ASKAP names")
if (
(args.first is None)
and (args.nvss is None)
and (args.sumss is None)
and (args.vlass is None)
and (args.racs is None)
):
parser.error(
"You must specify one or more text files containing the catalogue source information"
)
if args.frbtitletext is None:
parser.error("You must specify a title for the plots")
#####################################################################################
# GLOBAL PARAMETER DEFINITIONS
#####################################################################################
# Get file name variables for ASKAP file and any catalogue files selected
askap_posfile = str(args.askappos)
if args.first is not None:
first_posfile = str(args.first)
if args.nvss is not None:
nvss_posfile = str(args.nvss)
if args.racs is not None:
racs_posfile = str(args.racs)
if args.sumss is not None:
sumss_posfile = str(args.sumss)
if args.vlass is not None:
vlass_posfile = str(args.vlass)
np.set_printoptions(precision=15)
# Set up colour dictionary with colourblind friendly scheme
col_bank = {
"1": "#40004b",
"2": "#543005",
"3": "#9970ab",
"4": "#bf812d",
"5": "#8c510a",
"6": "#003c30",
"7": "#a6dba0",
"8": "#5aae61",
"9": "#1b7837",
"10": "#00441b",
"11": "#af8dc3",
"12": "#7fbf7b",
"13": "#008837",
"14": "#7b3294",
"15": "#a6611a",
"16": "#018571",
}
RAD_IN_ARCSEC = 180.0*3600/np.pi
#####################################################################################
# DEFINE FUNCTIONS USED FOR OFFSET AND UNCERTAINTY CALCULATIONS
#####################################################################################
def is_comment(s):
"""
function to check is a line is a comment
Parameters
----------
s : str
Line in a file being read
Returns
----------
True
if a line starts with #
"""
return s.startswith("#")
def grabsrcinfo(infofile):
"""
This function reads a file containing source information
and returns each line as a list entry
Parameters
----------
infofile : str
File containing source information
Returns
----------
list
a list of strings
"""
source_info = []
with open(infofile) as info:
# Ignore comments and add each line into a list
for currentline in dropwhile(is_comment, info):
source_info.append(currentline)
return source_info
def getradec(src_info, first=False):
"""
This function takes a list of source information,
grabs the positions, and converts them to arcseconds.
Parameters
----------
src_info : list
List containing source information
first : boolean
True if FIRST catalogue; default False
Returns
----------
dict of lists
ra_arcsec : list with the RAs for each source in arcsecond
dec_arcsec : list with the Decs for each source in arcsecond
dec_radian : list of Decs for each source in radians
"""
pos_dict = {}
# Extract positions in hms and dms
ra_hms = [src_info[i].split(",")[0] for i in np.arange(len(src_info))]
print(ra_hms)
try:
ra_hms = [
(
ra.split(":")[0]
+ "h"
+ ra.split(":")[1]
+ "m"
+ ra.split(":")[2]
+ "s"
)
for ra in ra_hms
]
except:
ra_hms = ra_hms
print(ra_hms)
if first is True:
dec_dms = [src_info[i].split(",")[1] for i in np.arange(len(src_info))]
else:
dec_dms = [src_info[i].split(",")[2] for i in np.arange(len(src_info))]
try:
dec_dms = [
(
dec.split(":")[0]
+ "d"
+ dec.split(":")[1]
+ "m"
+ dec.split(":")[2]
+ "s"
)
for dec in dec_dms
]
except:
dec_dms = dec_dms
# Convert RA, Dec into arcsec
ra_arcsec = [
(sc(ra, dec, frame="icrs").ra.arcsec)
for ra, dec in zip(ra_hms, dec_dms)
]
dec_arcsec = [
(sc(ra, dec, frame="icrs").dec.arcsec)
for ra, dec in zip(ra_hms, dec_dms)
]
# Convert Dec to radians
dec_rad = [
(sc(ra, dec, frame="icrs").dec.radian)
for ra, dec in zip(ra_hms, dec_dms)
]
# Add positions to dictionary
pos_dict["ra_arc"] = ra_arcsec
pos_dict["dec_arc"] = dec_arcsec
pos_dict["dec_rad"] = dec_rad
return pos_dict
def getfirst_unc(src_info):
"""
This function takes a list of FIRST source information
and determines the 90% uncertainty in RA and Dec using the
following empirical expressions from the FIRST catalogue:
unc(90% confidence) = Size (1/SNR + 1/20) arcsec
SNR = (Fpeak-0.25) / RMS
It then converts these uncertainties to 60% to match
the other catalogue and fitted uncertainties
Parameters
----------
src_info : list
List containing source information
Returns
----------
dict of lists
ra_unc_arcsec : list with the RA uncertainty for each source in arcsecond
dec_unc_arcsec : list with the Dec uncertainty for each source in arcsecond
"""
first_unc_dict = {}
# Grab all the relevant values from the source info
# Peak flux density: mJy/beam
pflux = [
#np.
float(src_info[i].split(",")[2]) for i in np.arange(len(src_info))
]
# Flux denisity RMS: mJy/beam
rms = [
#np.
float(src_info[i].split(",")[3]) for i in np.arange(len(src_info))
]
# Measured major axis: arcsec
fmaj = [
#np.
float(src_info[i].split(",")[7]) for i in np.arange(len(src_info))
]
# Measured minor axis: arcsec
fmin = [
#np.
float(src_info[i].split(",")[8]) for i in np.arange(len(src_info))
]
# Measured position angle: degrees
fpa = [
#np.
float(src_info[i].split(",")[9]) for i in np.arange(len(src_info))
]
# Project FWHM major and minor axes onto RA, Dec axes
ra_proj = [
np.sqrt(
(np.cos(fpa[i] * np.pi / 180) ** 2 / fmaj[i] ** 2)
+ (np.sin(fpa[i] * np.pi / 180) ** 2 / fmin[i] ** 2)
)
** (-1)
for i in np.arange(len(fpa))
]
dec_proj = [
np.sqrt(
(np.sin(fpa[i] * np.pi / 180) ** 2 / fmaj[i] ** 2)
+ (np.cos(fpa[i] * np.pi / 180) ** 2 / fmin[i] ** 2)
)
** (-1)
for i in np.arange(len(fpa))
]
# Calculate the SNR
snr = [(pflux[i] - 0.25) / rms[i] for i in np.arange(len(pflux))]
# Derive the 90% confidence uncertainties for RA and Dec in arcsec
ra_unc_arcsec_90 = [
ra_proj[i] * ((1 / snr[i]) + (1 / 20.0))
for i in np.arange(len(ra_proj))
]
dec_unc_arcsec_90 = [
dec_proj[i] * ((1 / snr[i]) + (1 / 20.0))
for i in np.arange(len(dec_proj))
]
# Convert to 60% confidence uncertainties for RA and Dec in arcsec
ra_unc_arcsec = np.array(ra_unc_arcsec_90) / 1.645
dec_unc_arcsec = np.array(dec_unc_arcsec_90) / 1.645
first_unc_dict["ra_unc_arcsec"] = ra_unc_arcsec
first_unc_dict["dec_unc_arcsec"] = dec_unc_arcsec
return first_unc_dict
def getradec_unc(
src_info,
dec_rad,
askap=False,
first=False,
nvss=False,
sumss=False,
vlass=False,
racs=False,
):
"""
This function takes a list of source information,
grabs the positional uncertainties, and converts them to arcseconds.
If first=True, calls getfirst_unc(src_info) to derive the RA, Dec 90%
uncertainties.
Parameters
----------
src_info : list
List containing source information
dec_rad : list
List of Declinations (floats) in radians
askap : boolean
True if ASKAP source; default False
first : boolean
True if FIRST catalogue; default False
nvss : boolean
True if NVSS catalogue; default False
sumss : boolean
True if SUMSS catalogue; default False
vlass : boolean
True if VLASS sources; default False
Returns
----------
dict of lists
ra_unc_arcsec : list with the RA uncertainties for each source in arcsecond
dec_unc_arcsec : list with the Dec uncertainties for each source in arcsecond
"""
unc_dict = {}
# Extract the uncertainties in the default unit of the source info and convert to arcsec if needed
# ASKAP or NVSS
if (askap is True) or (nvss is True) or (vlass is True) or (racs is True):
# TEMP: RA_err expected to be arcseconds
ra_unc_arcsec = [
#np.
float(src_info[i].split(",")[1])
for i in np.arange(len(src_info))
]
"""
# NVSS default RA_err unit: s
ra_unc_s = [np.float(src_info[i].split(',')[1]) for i in np.arange(len(src_info))]
print(ra_unc_s)
# Convert to arcsec: s * 15cos(dec_rad)
ra_unc_arcsec = [ra_unc_s[i] * 15 * np.cos(dec_rad[i]) for i in np.arange(len(ra_unc_s))]
print(15*np.cos(dec_rad))
print(ra_unc_arcsec)
"""
### Old: RA_err default unit: ms
### ra_unc_ms = [np.float(src_info[i].split(',')[1]) for i in np.arange(len(src_info))]
### Convert to arcsec: ms * 15cos(dec_rad) / 1000
### ra_unc_arcsec = [ra_unc_ms[i] * 15 * np.cos(dec_rad[i]) / 1000. for i in np.arange(len(ra_unc_ms))]
if (askap is True) or (vlass is True):
# Dec_err default unit: mas
# dec_unc_mas = [np.float(src_info[i].split(',')[3]) for i in np.arange(len(src_info))]
# dec_unc_arcsec = [dec_unc_mas[i]/1000. for i in np.arange(len(src_info))]
dec_unc_arcsec = [
#np.
float(src_info[i].split(",")[3])
for i in np.arange(len(src_info))
]
if (nvss is True) or (sumss is True) or (racs is True):
# Dec_err default unit: arcsec
dec_unc_arcsec = [
#np.
float(src_info[i].split(",")[3])
for i in np.arange(len(src_info))
]
if first is True:
ra_unc_arcsec = getfirst_unc(src_info)["ra_unc_arcsec"]
dec_unc_arcsec = getfirst_unc(src_info)["dec_unc_arcsec"]
print(ra_unc_arcsec)
print(dec_unc_arcsec)
# Add uncertainties to dictionary
unc_dict["ra_unc_arcsec"] = ra_unc_arcsec
unc_dict["dec_unc_arcsec"] = dec_unc_arcsec
return unc_dict
def getoffsets(ra_arcsec1, dec_arcsec1, ra_arcsec2, dec_arcsec2, dec2_rad):
"""
This function determines the offset between two source positions
Parameters
----------
ra_arcsec1 : list
List containing source 1's RA
dec_arcsec1 : list
List containing source 1's Dec
ra_arcsec2 : list
List containing source 2's RA
dec_arcsec2 : list
List containing source 2's Dec
dec_ra : list
List containing source 2's Dec in radians
Returns
----------
dict of lists
ra_offset_arcsec : list with the RA uncertainties for each source in arcsecond
dec_offset_arcsec : list with the Dec uncertainties for each source in arcsecond
"""
offsets_dict = {}
# Calculate the RA, Dec offsets
ra_offset_arcsec = [
(ra2 - ra1) * np.cos(dec)
for ra2, ra1, dec in zip(ra_arcsec2, ra_arcsec1, dec2_rad)
]
dec_offset_arcsec = [
dec2 - dec1 for dec2, dec1 in zip(dec_arcsec2, dec_arcsec1)
]
offsets_dict["ra_offset_arcsec"] = ra_offset_arcsec
offsets_dict["dec_offset_arcsec"] = dec_offset_arcsec
return offsets_dict
def gettotaloffsetunc(
ra_unc_arcsec1, dec_unc_arcsec1, ra_unc_arcsec2, dec_unc_arcsec2
):
"""
This function determines the total uncertainty in the offset between two source positions
Parameters
----------
ra_unc_arcsec1 : list
List containing source 1's RA uncertainty in arcsec
dec_unc_arcsec1 : list
List containing source 1's Dec uncertainty in arcsec
ra_unc_arcsec2 : list
List containing source 2's RA uncertainty in arcsec
dec_unc_arcsec2 : list
List containing source 2's Dec uncertainty in arcsec
Returns
----------
dict of lists
ra_offset_unc_arcsec : list with the RA uncertainties for each source in arcsecond
dec_offset_unc_arcsec : list with the Dec uncertainties for each source in arcsecond
"""
offset_unc_dict = {}
# Calculate total offset uncertainty
totra_unc = [
np.sqrt(ra_unc2 ** 2 + ra_unc1 ** 2)
for ra_unc2, ra_unc1 in zip(ra_unc_arcsec2, ra_unc_arcsec1)
]
totdec_unc = [
np.sqrt(dec_unc2 ** 2 + dec_unc1 ** 2)
for dec_unc2, dec_unc1 in zip(dec_unc_arcsec2, dec_unc_arcsec1)
]
offset_unc_dict["totra_unc"] = totra_unc
offset_unc_dict["totdec_unc"] = totdec_unc
return offset_unc_dict
#--------------------------------------------------------------------
# Astro utility functions
#--------------------------------------------------------------------
def stringToRad(posstr, was_hms):
posstr = posstr.strip()
if was_hms and "h" in posstr:
posstr = posstr.replace("h", ":")
posstr = posstr.replace("m", ":")
posstr = posstr.replace("s", "")
if not was_hms and "d" in posstr:
posstr = posstr.replace("d", ":")
posstr = posstr.replace("'", ":")
posstr = posstr.replace("\"", "")
splits = posstr.split(':')
try:
d = int(splits[0])
m = 0
s = 0
negmult = 1.0
if len(splits) > 1 and len(splits[1].strip()) > 0:
m = int(splits[1])
if len(splits) > 2 and len(splits[2].strip()) > 0:
s = float(splits[2])
if posstr[0] == "-":
d = -d
negmult = -1.0
radval = d + m/60.0 + s/3600.0
radval *= math.pi/180.0
radval *= negmult
if was_hms:
radval *= 180.0/12.0
except ValueError:
print("Bad position string", posstr)
radval = -999
return(radval)
def posdiff(targetrarad, targetdecrad, calrarad, caldecrad):
sinsqdecdiff = math.sin((targetdecrad-caldecrad)/2.0)
sinsqdecdiff = sinsqdecdiff*sinsqdecdiff
sinsqradiff = math.sin((targetrarad-calrarad)/2.0)
sinsqradiff = sinsqradiff*sinsqradiff
return(2*math.asin(math.sqrt(sinsqdecdiff + math.cos(targetdecrad)*math.cos(caldecrad)*sinsqradiff)))
def posradians2string(rarad, decrad):
rah = rarad * 12 / math.pi
rhh = int(rah)
rmm = int(60*(rah - rhh))
rss = 3600*rah - (3600*rhh + 60*rmm)
decd = decrad * 180 / math.pi
decformat = "+%02d:%02d:%010.7f"
if decd < 0:
decd = -decd
decformat = '-' + decformat[1:]
ddd = int(decd)
dmm = int(60*(decd - ddd))
dss = 3600*decd - (3600*ddd + 60*dmm)
rastring = "%02d:%02d:%011.8f" % (rhh,rmm,rss)
decstring = decformat % (ddd, dmm, dss)
return(rastring, decstring)
class AstroObsResult:
def __init__(self, obj, exp, lines, isexp):
self.object = obj
self.experiment = exp
self.isexploratory = isexp
self.gategain = -1.0
self.lowerlimit = True
self.mjd = float(lines[0].split()[3][:-1])
self.raerrmas = float(lines[10].split()[-1])
self.raerrhhh = float(lines[11].split()[-1])
self.decerrmas = float(lines[12].split()[-1])
self.snr = float(lines[4].split()[-1])
self.flux = float(lines[3].split()[-1])
self.ra = lines[7].split()[-1]
self.dec = lines[8].split()[-1]
self.rarad = 0
self.decrad = 0
if self.snr != 0.0:
self.rarad = stringToRad(self.ra, True)
self.decrad = stringToRad(self.dec, False)
tempsplit = lines[9].split()
self.fitmin = float(tempsplit[1].split('x')[0])
self.fitmaj = float(tempsplit[1].split('x')[1])
self.fitpa = float(tempsplit[3])
self.hasbeam = False
if len(tempsplit) > 6 and "x" in tempsplit[6]:
self.hasbeam = True
self.beammin = float(tempsplit[6].split('x')[0])
self.beammaj = float(tempsplit[6].split('x')[1])
self.beampa = float(tempsplit[8])
self.beamparad = math.pi*self.beampa/180.0
def updateRA(self, newrarad, newraraderr=-1):
self.rarad = newrarad
newra, xxx = posradians2string(newrarad, 1)
self.ra = newra
if newraraderr > 0:
self.raerrmas = newraraderr*180*60*60*1000/math.pi
self.raerrhms = self.raerrmas/(15*math.cos(self.decrad))
def updateDec(self, newdecrad, newdecraderr=-1):
self.decrad = newdecrad
xxx, newdec = posradians2string(1, newdecrad)
self.dec = newdec
if newdecraderr > 0:
self.decerrmas = newdecraderr*180*60*60*1000/math.pi
def write(self, outputfile, overwrite=False):
if os.path.exists(outputfile) and not overwrite:
print("%s exists and overwrite is False - aborting" % outputfile)
sys.exit()
output = open(outputfile, "w")
output.write("Pulsar %s: MJD %.4f: Frequency X, pol ?.:\n" % (self.object, self.mjd))
output.write("%s%s\n" % ("Centre RA:".ljust(22), self.ra))
output.write("%s%s\n" % ("Centre Dec:".ljust(22), self.dec))
output.write("%s%.4f\n" % ("Flux (mJy):".ljust(22), self.flux))
output.write("%s%.4f\n" % ("S/N:".ljust(22), self.snr))
output.write("%s%.4f\n" % ("RA offset (mas)".ljust(22), 0.0))
output.write("%s%.4f\n" % ("Dec offset (mas)".ljust(22), 0.0))
output.write("%s%s\n" % ("Actual RA:".ljust(22), self.ra))
output.write("%s%s\n" % ("Actual Dec:".ljust(22), self.dec))
output.write("%s%.4fx%.4f at %.2f degrees\n" % ("Fit:".ljust(22), self.fitmin, self.fitmaj, self.fitpa))
output.write("%s%.4f\n" % ("Est. RA error (mas):".ljust(22), self.raerrmas))
output.write("%s%.4f\n" % ("Est. RA error (hms):".ljust(22), self.raerrhms))
output.write("%s%.4f\n" % ("Est. Dec error (mas):".ljust(22), self.decerrmas))
output.close()
#######################################################
# CALCULATING THE WEIGHTED MEAN POSITIONAL OFFSET
#######################################################
def weighted_avg_and_std(offsetval, weights):
"""
Return the weighted average and standard deviation.
values, weights -- Numpy ndarrays with the same shape.
Parameters
----------
offsetval : list
List containing the offsets
weights : list
List containing the weights for the offsets
Returns
----------
lists
wt_average : list containing the weighted average of the offsets
std : list containing the weighted standard deviation of the offsets
"""
# Define the number of points in the offset array
npoints = len(offsetval)
# Calculate the weighted average
wt_average = np.average(offsetval, weights=weights ** 2)
# Calculate the variance and standard deviation (fast and numerically precise method)
variance = np.average((offsetval - wt_average) ** 2, weights=weights ** 2)
# Standard deviation in an average-weighted point about the mean; i.e., the standard
# deviation of the points about the mean
std = np.sqrt(variance)
# The error in the mean
std_mean = std / np.sqrt(npoints - 1)
return (wt_average, std_mean)
def plotter(
ra_offsets,
dec_offsets,
ra_offset_unc,
dec_offset_unc,
wavg_ra_offset,
wavg_dec_offset,
wavg_ra_offset_unc,
wavg_dec_offset_unc,
catname,
):
"""
Plot the RA, Dec offsets and the derived weighted mean offset for a given comparison
Parameters
----------
ra_offsets : list
List containing the RA offsets
dec_offsets : list
List containing the Dec offsets
ra_offset_unc : list
List containing the RA offset uncertainties
dec_offset_unc : list
List containing the Dec offset uncertainties
wavg_ra_offset : float
Weighted average RA offset
wavg_dec_offset : float
Weighted average Dec offset
wavg_ra_offset_unc : float
Weighted average RA offset uncertainty
wavg_dec_offset_unc : float
Weighted average Dec offset uncertainty
catname : str
Name of the catalogue being used for comparison
Returns
----------
plot
RA, Dec offsets for each source in the comparison
Weighted average RA, Dec offset for all sources in comparison
"""
print(
f"RA weighted mean offset: {wavg_ra_offset:0.2f} +/- {wavg_ra_offset_unc:0.2f}"
)
print(
f"Dec weighted mean offset: {wavg_dec_offset:0.2f} +/- {wavg_dec_offset_unc:0.2f}"
)
plt.figure(figsize=(11, 11))
plt.title(
fr"{args.frbtitletext} field source offsets (arcsec) from the {catname} catalogue positions: "
+ "\n"
r"RA weighted mean offset: "
+ f"{wavg_ra_offset:0.2f}"
+ r" +/- "
+ f"{wavg_ra_offset_unc:0.2f}"
+ "\n"
r"Dec weighted mean offset: "
+ f"{wavg_dec_offset:0.2f}"
+ r" +/- "
+ f"{wavg_dec_offset_unc:0.2f}"
)
for n in np.arange(len(ra_offsets)):
plt.errorbar(
ra_offsets[n],
dec_offsets[n],
yerr=dec_offset_unc[n],
xerr=ra_offset_unc[n],
fmt="k.",
elinewidth=2,
ecolor=col_bank[f"{n%16+1}"],
capsize=2,
label=askap_names[n],
)
plt.errorbar(
wavg_ra_offset,
wavg_dec_offset,
xerr=wavg_ra_offset_unc,
yerr=wavg_dec_offset_unc,
fmt="kx",
elinewidth=2.5,
capsize=2,
label="Weighted Mean Offset",
)
plt.xlabel("RA offset [arcsec]")
plt.ylabel("Dec offset [arcsec]")
plt.legend()
plt.savefig(f"{args.frbtitletext}_field_offsets_from_{catname}.png")
#######################################################
# BOOTSTRAPPING
#######################################################
def bootstrap(data, samp_size, num_trials):
boot_mean = []
boot_68 = []
n = 0
while n < num_trials:
samp = np.random.choice(data, size=samp_size, replace=True)
samp_mean = np.mean(samp)
boot_mean.append(samp_mean)
n += 1
mean_boot_mean = np.mean(boot_mean)
# add histogram
# bin histogram in 5% increments and then take bin with hightest value --> call this the most probable value
# show median and mode and their +/- confidence intervals
return mean_boot_mean
#######################################################
# CALCULATING THE CHI-SQUARED AND REDUCED CHI-SQUARED
#######################################################
def chi_sq(meas, model, err, num_srcs):
"""
Return the chi-squared value for a given set of measurements and model.
meas, model -- Numpy arrays with the same shape
err, deg_free -- floats
"""
deg_free = num_srcs - 1
print("Number of degrees of freedom: ", deg_free)
chi_squared = np.sum(((meas - model) / err) ** 2)
chisq_red = chi_squared / deg_free
return (chi_squared, chisq_red)
# ----------------------------------------------------------------------------------------------------------
#
# Calculate offsets along beam axes
#
# ----------------------------------------------------------------------------------------------------------
def rotated_offsets(catnameref, refras, refdecs, sigmarefras, sigmarefdecs, jmfitnamefile, frbfitsfile):
'''
This function calculates offsets long the the synthesized beam axes
Written by AB based on AD's hardcoded script
Inputs -
Name of reference catalogue
List of reference RAs in arcsec
List of reference DECs in arcsec
Uncertainties on reference RAs in arcsec
Uncertainties on reference DECs in arcsec
Filename of list of relevant jmfit files
Fits image containing the FRB - required to get the synthesized beam
Returns -
Chi-squared of fit
DoF of fit
Writes to disk -
Offsets along the beam axes and associated uncertainties
'''
#--- Reading BPA from the FRB FITS file
frbfits = fits.open(frbfitsfile)
frbhdr = frbfits[0].header
frbbpa = frbhdr['BPA']
print("BPA from %s is %.2f deg"%(frbfitsfile,frbbpa))
posangle = frbbpa*np.pi/180
frbfits.close()
#--- Reading list of field sources
reflines = open(jmfitnamefile).readlines()
nrefsrcs = len(reflines)
print("Found %d sources"%(nrefsrcs))
#print(refras,refdecs,sigmarefras,sigmarefdecs)
#--- Initializing necessary lists and parameters
xoffsets = []
yoffsets = []
totalxuncertainties = []
totalyuncertainties = []
dof = 0
chisq = 0
#---Looping over field sources
for isrc in range(0,nrefsrcs):
#--- Reading details of the field source
askapfile = reflines[isrc].split('\n')[0]
askapresult = AstroObsResult("src"+str(isrc), "CRAFT", open(askapfile).readlines(), False)
#--- Reading details of the same source from the reference catalogue
raref = refras[isrc]/RAD_IN_ARCSEC
decref = refdecs[isrc]/RAD_IN_ARCSEC
sigmararef = sigmarefras[isrc]
sigmadecref = sigmarefdecs[isrc]
#--- Calculating offsets and associated uncertainties
raraddiff = posdiff(raref, decref, askapresult.rarad, decref)
if(askapresult.rarad > raref):
raraddiff = -raraddiff
decraddiff = posdiff(raref, decref, raref, askapresult.decrad)
if(askapresult.decrad > decref):
decraddiff = -decraddiff
xdiff = raraddiff*np.sin(posangle) + decraddiff*np.cos(posangle)
ydiff = raraddiff*np.cos(posangle) - decraddiff*np.sin(posangle)
deltapa = posangle - np.pi*askapresult.fitpa / 180.0
xuncertainty = np.sqrt((askapresult.fitmaj*np.cos(deltapa))**2 + (askapresult.fitmin*np.sin(deltapa))**2) / (2350 * askapresult.snr)
yuncertainty = np.sqrt((askapresult.fitmaj*np.sin(deltapa))**2 + (askapresult.fitmin*np.cos(deltapa))**2) / (2350 * askapresult.snr)
rauncertainty = askapresult.raerrmas/1000.
decuncertainty = askapresult.decerrmas/1000.
xoffsigma = (180*60*60/np.pi) * xdiff / np.sqrt(xuncertainty**2 + sigmararef**2)
# Just using RA uncertainty from reference, since beam is pretty circular
yoffsigma = (180*60*60/np.pi) * ydiff / np.sqrt(yuncertainty**2 + sigmararef**2)
# Just using RA uncertainty from reference, since beam is pretty circular
print (isrc, raraddiff*180*60*60/np.pi, decraddiff*180*60*60/np.pi, rauncertainty, decuncertainty, \
xdiff*180*60*60/np.pi, ydiff*180*60*60/np.pi, xuncertainty, yuncertainty, \
np.sqrt(rauncertainty**2 + decuncertainty**2)/np.sqrt(xuncertainty**2 + yuncertainty**2), \
xoffsigma, yoffsigma)
#--- Appending results to the list of offsets
xoffsets.append(xdiff*180*60*60*1000/np.pi)
yoffsets.append(ydiff*180*60*60*1000/np.pi)
chisq += xoffsigma**2 + yoffsigma**2
dof += 2
totalxuncertainties.append(1000*np.sqrt(xuncertainty**2 + sigmararef**2))
totalyuncertainties.append(1000*np.sqrt(yuncertainty**2 + sigmararef**2))
print("For the case of zero offset, chi squared is", chisq, "for", dof, "degrees of freedom")
#--- Writing the offsets to the output file
output = open("askap2"+catnameref+"_rotated_offsets.dat","w")
for i in range(len(xoffsets)):
output.write(str(xoffsets[i]) + " ")
output.write("\n")
for i in range(len(yoffsets)):
output.write(str(yoffsets[i]) + " ")
output.write("\n")
for i in range(len(totalxuncertainties)):
output.write(str(totalxuncertainties[i]) + " ")
output.write("\n")
for i in range(len(totalyuncertainties)):
output.write(str(totalyuncertainties[i]) + " ")
output.write("\n")
output.close()
#--- Work done! Now return the chi-squared and the DoF in case it is useful
return(chisq,dof)
#-----------------------------------------------------------------------------------
# The main script starts here
#####################################################################################
# DETERMINE OFFSETS AND UNCERTAINTIES
#####################################################################################
# Grab all the source info and put in a list
askap_srcinfo = grabsrcinfo(askap_posfile)
if args.first is not None:
first_srcinfo = grabsrcinfo(first_posfile)
if args.nvss is not None:
nvss_srcinfo = grabsrcinfo(nvss_posfile)
if args.racs is not None:
racs_srcinfo = grabsrcinfo(racs_posfile)
if args.sumss is not None:
sumss_srcinfo = grabsrcinfo(sumss_posfile)
if args.vlass is not None:
vlass_srcinfo = grabsrcinfo(vlass_posfile)
# Extract the positions in arcsec and radians
askap_radec = getradec(askap_srcinfo)
askap_ra_arcsec = askap_radec["ra_arc"]
askap_dec_arcsec = askap_radec["dec_arc"]
askap_dec_rad = askap_radec["dec_rad"]
if args.first is not None:
first_radec = getradec(first_srcinfo, first=True)
first_ra_arcsec = first_radec["ra_arc"]
first_dec_arcsec = first_radec["dec_arc"]
first_dec_rad = first_radec["dec_rad"]
if args.nvss is not None:
nvss_radec = getradec(nvss_srcinfo)
nvss_ra_arcsec = nvss_radec["ra_arc"]
nvss_dec_arcsec = nvss_radec["dec_arc"]
nvss_dec_rad = nvss_radec["dec_rad"]
if args.racs is not None:
racs_radec = getradec(racs_srcinfo)
racs_ra_arcsec = racs_radec["ra_arc"]
racs_dec_arcsec = racs_radec["dec_arc"]
racs_dec_rad = racs_radec["dec_rad"]
if args.sumss is not None:
sumss_radec = getradec(sumss_srcinfo)
sumss_ra_arcsec = sumss_radec["ra_arc"]
sumss_dec_arcsec = sumss_radec["dec_arc"]
sumss_dec_rad = sumss_radec["dec_rad"]
if args.vlass is not None:
vlass_radec = getradec(vlass_srcinfo)
vlass_ra_arcsec = vlass_radec["ra_arc"]
vlass_dec_arcsec = vlass_radec["dec_arc"]
vlass_dec_rad = vlass_radec["dec_rad"]
# Get uncertainties for RA and Dec in arcsec
askap_radec_unc = getradec_unc(askap_srcinfo, askap_dec_rad, askap=True)
askap_ra_unc_arcsec = askap_radec_unc["ra_unc_arcsec"]
askap_dec_unc_arcsec = askap_radec_unc["dec_unc_arcsec"]
if args.first is not None:
first_radec_unc = getradec_unc(first_srcinfo, first_dec_rad, first=True)
first_ra_unc_arcsec = first_radec_unc["ra_unc_arcsec"]
first_dec_unc_arcsec = first_radec_unc["dec_unc_arcsec"]
if args.nvss is not None:
nvss_radec_unc = getradec_unc(nvss_srcinfo, nvss_dec_rad, nvss=True)
nvss_ra_unc_arcsec = nvss_radec_unc["ra_unc_arcsec"]
nvss_dec_unc_arcsec = nvss_radec_unc["dec_unc_arcsec"]
if args.racs is not None:
racs_radec_unc = getradec_unc(racs_srcinfo, racs_dec_rad, racs=True)
racs_ra_unc_arcsec = racs_radec_unc["ra_unc_arcsec"]
racs_dec_unc_arcsec = racs_radec_unc["dec_unc_arcsec"]
if args.sumss is not None:
sumss_radec_unc = getradec_unc(sumss_srcinfo, sumss_dec_rad, sumss=True)
sumss_ra_unc_arcsec = sumss_radec_unc["ra_unc_arcsec"]
sumss_dec_unc_arcsec = sumss_radec_unc["dec_unc_arcsec"]
if args.vlass is not None:
vlass_radec_unc = getradec_unc(vlass_srcinfo, vlass_dec_rad, vlass=True)
vlass_ra_unc_arcsec = vlass_radec_unc["ra_unc_arcsec"]
vlass_dec_unc_arcsec = vlass_radec_unc["dec_unc_arcsec"]
# Determine the offsets and their total uncertainties between the ASKAP and catalogue source positions,
# and save the offsets and uncertainties to a .dat file for use with weighted_multi_image_fit.py
if args.first is not None:
# Offsets
askap2first_offsets = getoffsets(
askap_ra_arcsec,
askap_dec_arcsec,
first_ra_arcsec,
first_dec_arcsec,
first_dec_rad,
)
askap2first_offsets_ra = askap2first_offsets["ra_offset_arcsec"]
askap2first_offsets_dec = askap2first_offsets["dec_offset_arcsec"]
# Total uncertainties
askap2first_offsets_unc = gettotaloffsetunc(
askap_ra_unc_arcsec,
askap_dec_unc_arcsec,
first_ra_unc_arcsec,
first_dec_unc_arcsec,
)
askap2first_offsets_unc_ra = askap2first_offsets_unc["totra_unc"]
askap2first_offsets_unc_dec = askap2first_offsets_unc["totdec_unc"]
# Format into strings
offsets_ra_first_str = " ".join(
[
str(askap2first_offsets_ra[i])
for i in np.arange(len(askap2first_offsets_ra))
]
)
offsets_dec_first_str = " ".join(
[
str(askap2first_offsets_dec[i])
for i in np.arange(len(askap2first_offsets_dec))
]
)
offsets_ra_unc_first_str = " ".join(
[
str(askap2first_offsets_unc_ra[i])
for i in np.arange(len(askap2first_offsets_unc_ra))
]
)
offsets_dec_unc_first_str = " ".join(
[
str(askap2first_offsets_unc_dec[i])
for i in np.arange(len(askap2first_offsets_unc_dec))
]
)
# Save to .dat file
offset_unc_out = open("askap2first_offsets_unc.dat", "w")
offset_unc_out.write(f"{offsets_ra_first_str}\n")
offset_unc_out.write(f"{offsets_dec_first_str}\n")
offset_unc_out.write(f"{offsets_ra_unc_first_str}\n")
offset_unc_out.write(f"{offsets_dec_unc_first_str}\n")
offset_unc_out.close()
if args.nvss is not None:
# Offsets
askap2nvss_offsets = getoffsets(
askap_ra_arcsec,
askap_dec_arcsec,
nvss_ra_arcsec,
nvss_dec_arcsec,
nvss_dec_rad,
)
askap2nvss_offsets_ra = askap2nvss_offsets["ra_offset_arcsec"]
askap2nvss_offsets_dec = askap2nvss_offsets["dec_offset_arcsec"]
# Total uncertainties
askap2nvss_offsets_unc = gettotaloffsetunc(
askap_ra_unc_arcsec,
askap_dec_unc_arcsec,
nvss_ra_unc_arcsec,
nvss_dec_unc_arcsec,
)
askap2nvss_offsets_unc_ra = askap2nvss_offsets_unc["totra_unc"]
askap2nvss_offsets_unc_dec = askap2nvss_offsets_unc["totdec_unc"]
# Format into strings
offsets_ra_nvss_str = " ".join(
[
str(askap2nvss_offsets_ra[i])
for i in np.arange(len(askap2nvss_offsets_ra))
]
)
offsets_dec_nvss_str = " ".join(
[
str(askap2nvss_offsets_dec[i])
for i in np.arange(len(askap2nvss_offsets_dec))
]
)
offsets_ra_unc_nvss_str = " ".join(
[
str(askap2nvss_offsets_unc_ra[i])
for i in np.arange(len(askap2nvss_offsets_unc_ra))
]
)
offsets_dec_unc_nvss_str = " ".join(
[
str(askap2nvss_offsets_unc_dec[i])
for i in np.arange(len(askap2nvss_offsets_unc_dec))
]
)
# Save to .dat file
offset_unc_out = open("askap2nvss_offsets_unc.dat", "w")
offset_unc_out.write(f"{offsets_ra_nvss_str}\n")
offset_unc_out.write(f"{offsets_dec_nvss_str}\n")
offset_unc_out.write(f"{offsets_ra_unc_nvss_str}\n")
offset_unc_out.write(f"{offsets_dec_unc_nvss_str}\n")
offset_unc_out.close()
if args.racs is not None:
# Offsets
askap2racs_offsets = getoffsets(
askap_ra_arcsec,
askap_dec_arcsec,
racs_ra_arcsec,
racs_dec_arcsec,
racs_dec_rad,
)
askap2racs_offsets_ra = askap2racs_offsets["ra_offset_arcsec"]
askap2racs_offsets_dec = askap2racs_offsets["dec_offset_arcsec"]
# Total uncertainties
askap2racs_offsets_unc = gettotaloffsetunc(
askap_ra_unc_arcsec,
askap_dec_unc_arcsec,
racs_ra_unc_arcsec,
racs_dec_unc_arcsec,
)
askap2racs_offsets_unc_ra = askap2racs_offsets_unc["totra_unc"]
askap2racs_offsets_unc_dec = askap2racs_offsets_unc["totdec_unc"]
# Format into strings
offsets_ra_racs_str = " ".join(
[
str(askap2racs_offsets_ra[i])
for i in np.arange(len(askap2racs_offsets_ra))
]
)
offsets_dec_racs_str = " ".join(
[
str(askap2racs_offsets_dec[i])
for i in np.arange(len(askap2racs_offsets_dec))
]
)
offsets_ra_unc_racs_str = " ".join(
[
str(askap2racs_offsets_unc_ra[i])
for i in np.arange(len(askap2racs_offsets_unc_ra))
]
)
offsets_dec_unc_racs_str = " ".join(
[
str(askap2racs_offsets_unc_dec[i])
for i in np.arange(len(askap2racs_offsets_unc_dec))
]
)
# Save to .dat file
offset_unc_out = open("askap2racs_offsets_unc.dat", "w")
offset_unc_out.write(f"{offsets_ra_racs_str}\n")
offset_unc_out.write(f"{offsets_dec_racs_str}\n")
offset_unc_out.write(f"{offsets_ra_unc_racs_str}\n")
offset_unc_out.write(f"{offsets_dec_unc_racs_str}\n")
offset_unc_out.close()
if args.sumss is not None:
# Offsets
askap2sumss_offsets = getoffsets(
askap_ra_arcsec,
askap_dec_arcsec,
sumss_ra_arcsec,
sumss_dec_arcsec,
sumss_dec_rad,
)
askap2sumss_offsets_ra = askap2sumss_offsets["ra_offset_arcsec"]
askap2sumss_offsets_dec = askap2sumss_offsets["dec_offset_arcsec"]
# Total uncertainties
askap2sumss_offsets_unc = gettotaloffsetunc(
askap_ra_unc_arcsec,
askap_dec_unc_arcsec,
sumss_ra_unc_arcsec,
sumss_dec_unc_arcsec,
)
askap2sumss_offsets_unc_ra = askap2sumss_offsets_unc["totra_unc"]
askap2sumss_offsets_unc_dec = askap2sumss_offsets_unc["totdec_unc"]
# Format into strings
offsets_ra_sumss_str = " ".join(
[
str(askap2sumss_offsets_ra[i])
for i in np.arange(len(askap2sumss_offsets_ra))
]
)
offsets_dec_sumss_str = " ".join(
[
str(askap2sumss_offsets_dec[i])
for i in np.arange(len(askap2sumss_offsets_dec))
]
)
offsets_ra_unc_sumss_str = " ".join(
[
str(askap2sumss_offsets_unc_ra[i])
for i in np.arange(len(askap2sumss_offsets_unc_ra))
]
)
offsets_dec_unc_sumss_str = " ".join(
[
str(askap2sumss_offsets_unc_dec[i])
for i in np.arange(len(askap2sumss_offsets_unc_dec))
]
)
# Save to .dat file
offset_unc_out = open("askap2sumss_offsets_unc.dat", "w")
offset_unc_out.write(f"{offsets_ra_sumss_str}\n")
offset_unc_out.write(f"{offsets_dec_sumss_str}\n")
offset_unc_out.write(f"{offsets_ra_unc_sumss_str}\n")
offset_unc_out.write(f"{offsets_dec_unc_sumss_str}\n")
offset_unc_out.close()
if args.vlass is not None:
# Offsets
askap2vlass_offsets = getoffsets(
askap_ra_arcsec,
askap_dec_arcsec,
vlass_ra_arcsec,
vlass_dec_arcsec,
vlass_dec_rad,
)
askap2vlass_offsets_ra = askap2vlass_offsets["ra_offset_arcsec"]
askap2vlass_offsets_dec = askap2vlass_offsets["dec_offset_arcsec"]
# Total uncertainties
askap2vlass_offsets_unc = gettotaloffsetunc(
askap_ra_unc_arcsec,
askap_dec_unc_arcsec,
vlass_ra_unc_arcsec,
vlass_dec_unc_arcsec,
)
askap2vlass_offsets_unc_ra = askap2vlass_offsets_unc["totra_unc"]
askap2vlass_offsets_unc_dec = askap2vlass_offsets_unc["totdec_unc"]
# Format into strings
offsets_ra_vlass_str = " ".join(
[
str(askap2vlass_offsets_ra[i])
for i in np.arange(len(askap2vlass_offsets_ra))
]
)
offsets_dec_vlass_str = " ".join(
[
str(askap2vlass_offsets_dec[i])
for i in np.arange(len(askap2vlass_offsets_dec))
]
)
offsets_ra_unc_vlass_str = " ".join(
[
str(askap2vlass_offsets_unc_ra[i])
for i in np.arange(len(askap2vlass_offsets_unc_ra))
]
)
offsets_dec_unc_vlass_str = " ".join(
[
str(askap2vlass_offsets_unc_dec[i])
for i in np.arange(len(askap2vlass_offsets_unc_dec))
]
)
# Save to .dat file
offset_unc_out = open("askap2vlass_offsets_unc.dat", "w")
offset_unc_out.write(f"{offsets_ra_vlass_str}\n")
offset_unc_out.write(f"{offsets_dec_vlass_str}\n")
offset_unc_out.write(f"{offsets_ra_unc_vlass_str}\n")
offset_unc_out.write(f"{offsets_dec_unc_vlass_str}\n")
offset_unc_out.close()
# Weight the RA and Dec offsets by their total errors
if args.first is not None:
raweight_first = 1.0 / np.array(askap2first_offsets_unc_ra)
decweight_first = 1.0 / np.array(askap2first_offsets_unc_dec)
if args.nvss is not None:
raweight_nvss = 1.0 / np.array(askap2nvss_offsets_unc_ra)
decweight_nvss = 1.0 / np.array(askap2nvss_offsets_unc_dec)
if args.racs is not None:
raweight_racs = 1.0 / np.array(askap2racs_offsets_unc_ra)
decweight_racs = 1.0 / np.array(askap2racs_offsets_unc_dec)
if args.sumss is not None:
raweight_sumss = 1.0 / np.array(askap2sumss_offsets_unc_ra)
decweight_sumss = 1.0 / np.array(askap2sumss_offsets_unc_dec)
if args.vlass is not None:
raweight_vlass = 1.0 / np.array(askap2vlass_offsets_unc_ra)
decweight_vlass = 1.0 / np.array(askap2vlass_offsets_unc_dec)
# Calculate the weighted mean offset in RA and Dec
if args.first is not None:
wmean_raoffset_first, wmean_raoffsetunc_first = weighted_avg_and_std(
askap2first_offsets_ra, raweight_first
)
wmean_decoffset_first, wmean_decoffsetunc_first = weighted_avg_and_std(
askap2first_offsets_dec, decweight_first
)
if args.nvss is not None:
wmean_raoffset_nvss, wmean_raoffsetunc_nvss = weighted_avg_and_std(
askap2nvss_offsets_ra, raweight_nvss
)
wmean_decoffset_nvss, wmean_decoffsetunc_nvss = weighted_avg_and_std(
askap2nvss_offsets_dec, decweight_nvss
)
if args.racs is not None:
wmean_raoffset_racs, wmean_raoffsetunc_racs = weighted_avg_and_std(
askap2racs_offsets_ra, raweight_racs
)
wmean_decoffset_racs, wmean_decoffsetunc_racs = weighted_avg_and_std(
askap2racs_offsets_dec, decweight_racs
)
if args.sumss is not None:
wmean_raoffset_sumss, wmean_raoffsetunc_sumss = weighted_avg_and_std(
askap2sumss_offsets_ra, raweight_sumss
)
wmean_decoffset_sumss, wmean_decoffsetunc_sumss = weighted_avg_and_std(
askap2sumss_offsets_dec, decweight_sumss
)
if args.vlass is not None:
wmean_raoffset_vlass, wmean_raoffsetunc_vlass = weighted_avg_and_std(
askap2vlass_offsets_ra, raweight_vlass
)
wmean_decoffset_vlass, wmean_decoffsetunc_vlass = weighted_avg_and_std(
askap2vlass_offsets_dec, decweight_vlass
)
# Grab ASKAP source names
askap_names = grabsrcinfo(args.askapnames)
askap_names = [askap_names[s].strip("\n") for s in np.arange(len(askap_names))]
# Plot the comparisons and save the plots
if args.first is not None:
plotter(
askap2first_offsets_ra,
askap2first_offsets_dec,
askap2first_offsets_unc_ra,
askap2first_offsets_unc_dec,
wmean_raoffset_first,
wmean_decoffset_first,
wmean_raoffsetunc_first,
wmean_decoffsetunc_first,
catname="FIRST",
)
if args.nvss is not None:
plotter(
askap2nvss_offsets_ra,
askap2nvss_offsets_dec,
askap2nvss_offsets_unc_ra,
askap2nvss_offsets_unc_dec,
wmean_raoffset_nvss,
wmean_decoffset_nvss,
wmean_raoffsetunc_nvss,
wmean_decoffsetunc_nvss,
catname="NVSS",
)
if args.racs is not None:
plotter(
askap2racs_offsets_ra,
askap2racs_offsets_dec,
askap2racs_offsets_unc_ra,
askap2racs_offsets_unc_dec,
wmean_raoffset_racs,
wmean_decoffset_racs,
wmean_raoffsetunc_racs,
wmean_decoffsetunc_racs,
catname="racs",
)
if args.sumss is not None:
plotter(
askap2sumss_offsets_ra,
askap2sumss_offsets_dec,
askap2sumss_offsets_unc_ra,
askap2sumss_offsets_unc_dec,
wmean_raoffset_sumss,
wmean_decoffset_sumss,
wmean_raoffsetunc_sumss,
wmean_decoffsetunc_sumss,
catname="SUMSS",
)
if args.vlass is not None:
plotter(
askap2vlass_offsets_ra,
askap2vlass_offsets_dec,
askap2vlass_offsets_unc_ra,
askap2vlass_offsets_unc_dec,
wmean_raoffset_vlass,
wmean_decoffset_vlass,
wmean_raoffsetunc_vlass,
wmean_decoffsetunc_vlass,
catname="VLASS",
)
# Calculate the numbers of 'points' of measurement; i.e., the number of sources
# num_sources = len(askapnames)
# Two test models:
# Test 1: A zero offset in position
# pos_model_zero_ra = np.zeros(np.shape(ra_offset))
# pos_model_zero_dec = np.zeros(np.shape(ra_offset))
# chi_sq_zero_ra, chisq_red_zero_ra = chi_sq(ra_offset, pos_model_zero_ra, totra_err, num_sources)
# chi_sq_zero_dec, chisq_red_zero_dec = chi_sq(dec_offset, pos_model_zero_dec, totdec_err, num_sources)
# Test 2: Offsets given by the above weighted mean offsets
# pos_model_wm_ra = np.full(np.shape(ra_offset),wmean_raoffset)
# pos_model_wm_dec = np.full(np.shape(dec_offset),wmean_decoffset)
# chi_sq_wm_ra, chisq_red_wm_ra = chi_sq(ra_offset, pos_model_wm_ra, totra_err, num_sources)
# chi_sq_wm_dec, chisq_red_wm_dec = chi_sq(dec_offset, pos_model_wm_dec, totdec_err, num_sources)
# print("chi-squared, reduced chi-squared RA (zero offset model): ", chi_sq_zero_ra, chisq_red_zero_ra)
# print("chi-squared, reduced chi-squared Dec (zero offset model): ", chi_sq_zero_dec, chisq_red_zero_dec)
# print("chi-squared, reduced chi-squared RA (weighted mean offset model): ", chi_sq_wm_ra, chisq_red_wm_ra)
# print("chi-squared, reduced chi-squared Dec (weighted mean offset model): ", chi_sq_wm_dec, chisq_red_wm_dec)
# Calculate the numbers of 'points' of measurement; i.e., the number of sources
# num_sources = len(askapnames)
# Two test models:
# Test 1: A zero offset in position
# pos_model_zero_ra = np.zeros(np.shape(ra_offset))
# pos_model_zero_dec = np.zeros(np.shape(ra_offset))
# chi_sq_zero_ra, chisq_red_zero_ra = chi_sq(ra_offset, pos_model_zero_ra, totra_err, num_sources)
# chi_sq_zero_dec, chisq_red_zero_dec = chi_sq(dec_offset, pos_model_zero_dec, totdec_err, num_sources)
# Test 2: Offsets given by the above weighted mean offsets
# pos_model_wm_ra = np.full(np.shape(ra_offset),wmean_raoffset)
# pos_model_wm_dec = np.full(np.shape(dec_offset),wmean_decoffset)
# chi_sq_wm_ra, chisq_red_wm_ra = chi_sq(ra_offset, pos_model_wm_ra, totra_err, num_sources)
# chi_sq_wm_dec, chisq_red_wm_dec = chi_sq(dec_offset, pos_model_wm_dec, totdec_err, num_sources)
# print("chi-squared, reduced chi-squared RA (zero offset model): ", chi_sq_zero_ra, chisq_red_zero_ra)
# print("chi-squared, reduced chi-squared Dec (zero offset model): ", chi_sq_zero_dec, chisq_red_zero_dec)
# print("chi-squared, reduced chi-squared RA (weighted mean offset model): ", chi_sq_wm_ra, chisq_red_wm_ra)
# print("chi-squared, reduced chi-squared Dec (weighted mean offset model): ", chi_sq_wm_dec, chisq_red_wm_dec)
#--------------------------------------------------------------------------------------------------------------
# Alright, now calculate offsets along the beam axes
if args.first is not None:
dummyres = rotated_offsets('first',first_ra_arcsec,first_dec_arcsec,first_ra_unc_arcsec,first_dec_unc_arcsec,args.jmfitnames,args.fieldfits)
print(dummyres)
if args.nvss is not None:
dummyres = rotated_offsets('nvss',nvss_ra_arcsec,nvss_dec_arcsec,nvss_ra_unc_arcsec,nvss_dec_unc_arcsec,args.jmfitnames,args.fieldfits)
print(dummyres)
if args.racs is not None:
dummyres = rotated_offsets('racs',racs_ra_arcsec,racs_dec_arcsec,racs_ra_unc_arcsec,racs_dec_unc_arcsec,args.jmfitnames,args.fieldfits)
print(dummyres)
if args.sumss is not None:
dummyres = rotated_offsets('sumss',sumss_ra_arcsec,sumss_dec_arcsec,sumss_ra_unc_arcsec,sumss_dec_unc_arcsec,args.jmfitnames,args.fieldfits)
print(dummyres)
if args.vlass is not None:
dummyres = rotated_offsets('vlass',racs_ra_arcsec,racs_dec_arcsec,racs_ra_unc_arcsec,racs_dec_unc_arcsec,args.jmfitnames,args.fieldfits)
print(dummyres)
|
askap-cracoREPO_NAMECELEBIPATH_START.@CELEBI_extracted@CELEBI-main@localise@src_offsets_rotated.py@.PATH_END.py
|
{
"filename": "disc_launch.py",
"repo_name": "FabioRigamonti/pyADfit",
"repo_path": "pyADfit_extracted/pyADfit-main/tests/disc_launch.py",
"type": "Python"
}
|
import numpy as np
import yaml
import pandas as pd
from disc_fit import analysis,calling_all
import os
import matplotlib.pyplot as plt
def read_data(input_path):
"""
Reads in data from a text file. USER DEFINED.
Parameters
----------
input_path : str
Path to the input file.
Returns
-------
xdata : np.ndarray
Array of x-data.
ydata : np.ndarray
Array of y-data.
yerr : np.ndarray
Array of y-errors.
"""
xdata,ydata,yerr = np.loadtxt(input_path,unpack=True,usecols=[0,1,2])
indsort = np.argsort(xdata)
xdata = xdata[indsort]
ydata = ydata[indsort]
yerr = yerr[indsort]
xdata = 1e15*xdata
ydata = 1e45*ydata
yerr = 1e45*yerr
return xdata,ydata,yerr
def read_yaml(file_path):
'''
Function
----------------------------------------------------------------------
----------------------------------------------------------------------
read yaml (i.e. configuration) file
Parameters:
file_path: str
absolute path to read
Returns:
'''
with open(file_path, "r") as f:
return yaml.safe_load(f)
def read_config_and_launch(config_path,read_data):
"""
This function reads in a YAML configuration file and launches the
parameter estimation process.
Parameters
----------
config_path : str
Path to the YAML configuration file.
read_data: function
A user defined function that takes in a file path and returns xdata, ydata, and yerr.
Returns
-------
post_df : pandas.DataFrame
Posterior samples from the MCMC sampler.
best : dict
Best-fit parameters and their uncertainties.
"""
config_path = './config.yaml'
config = read_yaml(config_path)
if config['Hyperparameter_estimator']['raynest']['use'] == True:
hyperpar_dict = config['Hyperparameter_estimator']['raynest']
which_sampler ='raynest'
elif config['Hyperparameter_estimator']['CPnest']['use'] == True:
hyperpar_dict = config['Hyperparameter_estimator']['CPnest']
which_sampler ='CPnest'
elif config['Hyperparameter_estimator']['nessai']['use'] == True:
hyperpar_dict = config['Hyperparameter_estimator']['nessai']
which_sampler ='nessai'
else:
print('Not using Nested Sampling, no other estimator is available, exiting')
exit()
fitting_parameters = config['Parameters']
hyperparameter_disc_model = config['Hyperparameter_disc_model']
names = []
LaTex_names = []
bounds = []
vary = []
value = []
for k in fitting_parameters:
names.append(fitting_parameters[k]['name'])
LaTex_names.append(fitting_parameters[k]["LaTex_name"])
bounds.append(fitting_parameters[k]["bounds"])
vary.append(fitting_parameters[k]["vary"])
value.append(fitting_parameters[k]["value"])
variable_quantities = {names[i]:bounds[i] for i in range(0,len(names)) if vary[i]==True}
fixed_quantities = {names[i]:value[i] for i in range(0,len(names)) if vary[i]==False}
variable_LaTex = {names[i]:LaTex_names[i] for i in range(0,len(names)) if vary[i]==True}
fixed_LaTex = {names[i]:LaTex_names[i] for i in range(0,len(names)) if vary[i]==False}
names_hyp = []
value_hyp = []
for k in hyperparameter_disc_model:
names_hyp.append(hyperparameter_disc_model[k]['name'])
value_hyp.append(hyperparameter_disc_model[k]["value"])
hyperpar_disc_dict = {names_hyp[i]:value_hyp[i] for i in range(0,len(names_hyp))}
input_path = config['Settings']['input_path']
output_path = config['Settings']['output_path']
xdata,ydata,yerr = read_data(input_path)
if os.path.exists(output_path+"posterior.csv"):
print('Parameter estimation file already exists, plotting diagnostics')
post_df = pd.read_csv(output_path+"posterior.csv")
best = analysis(post_df,xdata,ydata,yerr,output_path,fixed_quantities,\
variable_LaTex,hyperpar_disc_dict)
else:
post_df,best = calling_all(xdata,ydata,yerr,output_path,hyperpar_dict,\
variable_quantities,fixed_quantities,variable_LaTex,\
hyperpar_disc_dict,which_sampler)
return post_df,best
if __name__=='__main__':
config_path = './config.yaml'
post_df,best = read_config_and_launch(config_path,read_data)
plt.show()
|
FabioRigamontiREPO_NAMEpyADfitPATH_START.@pyADfit_extracted@pyADfit-main@tests@disc_launch.py@.PATH_END.py
|
{
"filename": "python__eval-metrics__return-value__div.md",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/catboost/docs/en/_includes/work_src/reusage/python__eval-metrics__return-value__div.md",
"type": "Markdown"
}
|
A dictionary of calculated metrics in the following format:
```
metric -> array of shape [(ntree_end – ntree_start) / eval_period]
```
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@catboost@docs@en@_includes@work_src@reusage@python__eval-metrics__return-value__div.md@.PATH_END.py
|
{
"filename": "_title.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/validators/choropleth/colorbar/_title.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class TitleValidator(_plotly_utils.basevalidators.TitleValidator):
def __init__(
self, plotly_name="title", parent_name="choropleth.colorbar", **kwargs
):
super(TitleValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
data_class_str=kwargs.pop("data_class_str", "Title"),
data_docs=kwargs.pop(
"data_docs",
"""
font
Sets this color bar's title font. Note that the
title's font used to be set by the now
deprecated `titlefont` attribute.
side
Determines the location of color bar's title
with respect to the color bar. Note that the
title's location used to be set by the now
deprecated `titleside` attribute.
text
Sets the title of the color bar. Note that
before the existence of `title.text`, the
title's contents used to be defined as the
`title` attribute itself. This behavior has
been deprecated.
""",
),
**kwargs
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@validators@choropleth@colorbar@_title.py@.PATH_END.py
|
{
"filename": "gp_pyaneti_quasiperiodic_activity.py",
"repo_name": "LucaMalavolta/PyORBIT",
"repo_path": "PyORBIT_extracted/PyORBIT-main/pyorbit/models/gp_pyaneti_quasiperiodic_activity.py",
"type": "Python"
}
|
from pyorbit.subroutines.common import *
from pyorbit.models.abstract_model import *
from pyorbit.keywords_definitions import *
from scipy.linalg import cho_factor, cho_solve, lapack, LinAlgError
from scipy import matrix, spatial
try:
import pyaneti
except:
pass
class GP_Pyaneti_QuasiPeriodicActivity(AbstractModel):
''' Three parameters out of four are the same for all the datasets, since they are related to
the properties of the physical process rather than the observed effects on a dataset
From Grunblatt+2015, Affer+2016
- theta: is usually related to the rotation period of the star( or one of its harmonics);
- lambda: is the correlation decay timescale, and it can be related to the lifetime of the active regions.
- omega: is the length scale of the periodic component, and can be linked to the size evolution of the active regions;
- h: represents the amplitude of the correlations '''
default_common = 'activity'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
try:
import pyaneti
except (ModuleNotFoundError,ImportError):
print("ERROR: pyaneti not installed, this will not work")
quit()
self.model_class = 'gp_pyaneti_quasiperiodic_activity'
self.internal_likelihood = True
self.delayed_lnlk_computation = True
self.list_pams_common = OrderedSet([
'Prot', # Rotational period of the star
'Pdec', # Decay timescale of activity
'Oamp', # Granulation of activity
])
self.list_pams_dataset = OrderedSet([
'rot_amp', # Amplitude of the covariance matrix
'con_amp' # Amplitude of the first derivative of the covariance matrix
])
self.internal_parameter_values = None
self._dist_t1 = None
self._dist_t2 = None
self._added_datasets = 0
self.dataset_ordering = {}
self.inds_cache = None
self._original_x0 = []
self._dataset_x0 = []
self._dataset_e2 = []
self._dataset_names = {}
self._dataset_nindex = []
self.use_derivative_dict = {}
self.internal_coefficients = []
self._dataset_ej2 = []
self._dataset_res = []
self._added_datasets = 0
self._n_cov_matrix = 0
self.pi2 = np.pi * np.pi
def initialize_model(self, mc, **kwargs):
if kwargs.get('hyperparameters_condition', False):
self.hyper_condition = self._hypercond_01
else:
self.hyper_condition = self._hypercond_00
if kwargs.get('rotation_decay_condition', False):
self.rotdec_condition = self._hypercond_02
else:
self.rotdec_condition = self._hypercond_00
if kwargs.get('halfrotation_decay_condition', False):
self.halfrotdec_condition = self._hypercond_03
else:
self.halfrotdec_condition = self._hypercond_00
for common_ref in self.common_ref:
if mc.common_models[common_ref].model_class == 'activity':
self.use_stellar_rotation_period = getattr(mc.common_models[common_ref], 'use_stellar_rotation_period', False)
break
for keyword in keywords_stellar_rotation:
self.use_stellar_rotation_period = kwargs.get(keyword, self.use_stellar_rotation_period)
if self.use_stellar_rotation_period:
self.list_pams_common.update(['rotation_period'])
self.list_pams_common.discard('Prot')
for common_ref in self.common_ref:
if mc.common_models[common_ref].model_class == 'activity':
self.use_stellar_activity_decay = getattr(mc.common_models[common_ref], 'use_stellar_activity_decay', False)
break
for keyword in keywords_stellar_activity_decay:
self.use_stellar_activity_decay = kwargs.get(keyword, self.use_stellar_activity_decay)
if self.use_stellar_activity_decay:
self.list_pams_common.update(['activity_decay'])
self.list_pams_common.discard('Pdec')
def initialize_model_dataset(self, mc, dataset, **kwargs):
""" when reloading the .p files, the object is not reinitialized, so we have to skip the
incremental addition of datasets if they are already present """
if dataset.name_ref in self._dataset_names:
return
self._dataset_nindex.append([self._n_cov_matrix,
self._n_cov_matrix+dataset.n])
self.internal_coefficients.append([0.00, 0.00])
self._original_x0.append(dataset.x0)
self._dataset_x0 = np.append(self._dataset_x0, dataset.x0)
self._dataset_e2 = np.append(self._dataset_e2, dataset.e**2)
self._dataset_names[dataset.name_ref] = self._added_datasets
self._n_cov_matrix += dataset.n
self._added_datasets += 1
self._dataset_ej2 = self._dataset_e2 * 1.
self._dataset_res = self._dataset_e2 * 0.
self._fake_jitter = np.zeros(self._added_datasets)
if 'derivative'in kwargs:
use_derivative = kwargs['derivative'].get(dataset.name_ref, False)
elif dataset.name_ref in kwargs:
use_derivative = kwargs[dataset.name_ref].get('derivative', False)
else:
if dataset.kind == 'H-alpha' or \
dataset.kind == 'S_index' or \
dataset.kind == 'Ca_HK' or \
dataset.kind == 'FWHM':
use_derivative = False
else:
use_derivative = True
if not use_derivative:
self.fix_list[dataset.name_ref] = {'rot_amp': [0., 0.]}
return
## WHICH ONE SHOULD I KEEP???
#def common_initialization_with_dataset(self, dataset):
# self.define_kernel(dataset)
# return
#def define_kernel(self):
# # Prot, Pdec, Oamp
# return
def add_internal_dataset(self, parameter_values, dataset):
if self.use_stellar_rotation_period:
parameter_values['Prot'] = parameter_values['rotation_period']
if self.use_stellar_activity_decay:
parameter_values['Pdec'] = parameter_values['activity_decay']
self.internal_parameter_values = parameter_values
d_ind = self._dataset_names[dataset.name_ref]
d_nstart, d_nend = self._dataset_nindex[d_ind]
self._dataset_ej2[d_nstart:d_nend] = self._dataset_e2[d_nstart:d_nend] + dataset.jitter**2.0
self._dataset_res[d_nstart:d_nend] = dataset.residuals
self.internal_coefficients[d_ind] = [parameter_values['con_amp'], parameter_values['rot_amp']]
def lnlk_compute(self):
if not self.hyper_condition(self.internal_parameter_values):
return -np.inf
if not self.rotdec_condition(self.internal_parameter_values):
return -np.inf
if not self.halfrotdec_condition(self.internal_parameter_values):
return -np.inf
self._gp_pams = np.empty(2*self._added_datasets + 3)
for l_dataset in range(0, self._added_datasets):
self._gp_pams[2*l_dataset], self._gp_pams[2*l_dataset+1], = self.internal_coefficients[l_dataset]
self._gp_pams[-3] = self.internal_parameter_values['Pdec']
self._gp_pams[-2] = self.internal_parameter_values['Oamp']
self._gp_pams[-1] = self.internal_parameter_values['Prot']
kernel_name = 'MQ' + repr(self._added_datasets)
fake_ljitter = np.zeros(self._n_cov_matrix)
fake_jitter = np.zeros(1)
output = pyaneti.nll_gp(self._gp_pams,
kernel_name,
self._dataset_x0,
self._dataset_res,
np.sqrt(self._dataset_ej2),
fake_jitter, fake_ljitter)
#print(output)
#cov_matrix = self._compute_cov_matrix()
return output[0]
#cov_matrix = self._compute_cov_matrix(add_diagonal_errors=True)
#chi2 = np.dot(_3res,np.matmul(inv_M,_3res))
#
# try:
# alpha = cho_solve(cho_factor(cov_matrix), self._3res)
# (s, d) = np.linalg.slogdet(cov_matrix)
#
# return -0.5 * (self.n * np.log(2 * np.pi) +
# np.dot(self._3res, alpha) + d)
# except:
# return -np.inf
def sample_predict(self, dataset, x0_input=None, return_covariance=False, return_variance=False):
dataset_index = self._dataset_names[dataset.name_ref]
if x0_input is None:
faster_computation = False
t_predict = dataset.x0
l_nstart, l_nend = self._dataset_nindex[dataset_index]
else:
faster_computation = True
t_predict = x0_input
l_nstart, l_nend = len(x0_input)*dataset_index, len(x0_input)*(dataset_index+1)
kernel_name = 'MQ' + repr(self._added_datasets)
cov_matrix = pyaneti.covfunc(kernel_name,self._gp_pams,self._dataset_x0,self._dataset_x0)
if faster_computation:
Ks = self._compute_cov_Ks(t_predict)
else:
Ks = cov_matrix - np.diag(self._dataset_ej2)
alpha = cho_solve(cho_factor(cov_matrix), self._dataset_res)
mu = np.dot(Ks, alpha).flatten()
(s, d) = np.linalg.slogdet(cov_matrix)
B = cho_solve(cho_factor(cov_matrix), Ks.T)
KsB_dot_diag = np.diag(np.dot(Ks, B))
B = None
Ks = None
if faster_computation:
Kss = self._compute_cov_diag(t_predict)
else:
Kss = np.diag(cov_matrix)
cov_matrix = None
std = np.sqrt(np.array(Kss - KsB_dot_diag).flatten())
Kss = None
if return_covariance:
print('Covariance matrix output not implemented - ERROR')
quit()
if return_variance:
return mu[l_nstart:l_nend], std[l_nstart:l_nend]
else:
return mu[l_nstart:l_nend]
def sample_conditional(self, dataset, x0_input=None):
val, std = self.sample_predict(dataset, x0_input)
return val
@staticmethod
def _hypercond_00(parameter_values):
#Condition from Rajpaul 2017, Rajpaul+2021
return True
@staticmethod
def _hypercond_01(parameter_values):
# Condition from Rajpaul 2017, Rajpaul+2021
# Taking into account that Pdec^2 = 2*lambda_2^2
return parameter_values['Pdec']**2 > (3. / 2. / np.pi) * parameter_values['Oamp']**2 * parameter_values['Prot']**2
@staticmethod
def _hypercond_02(parameter_values):
#Condition on Rotation period and decay timescale
return parameter_values['Pdec'] > 2. * parameter_values['Prot']
@staticmethod
def _hypercond_03(parameter_values):
#Condition on Rotation period and decay timescale
return parameter_values['Pdec'] > 0.5 * parameter_values['Prot']
|
LucaMalavoltaREPO_NAMEPyORBITPATH_START.@PyORBIT_extracted@PyORBIT-main@pyorbit@models@gp_pyaneti_quasiperiodic_activity.py@.PATH_END.py
|
{
"filename": "Likelihood_assessment.ipynb",
"repo_name": "jan-rybizki/Galaxia_wrap",
"repo_path": "Galaxia_wrap_extracted/Galaxia_wrap-master/notebook/Likelihood_assessment.ipynb",
"type": "Jupyter Notebook"
}
|
```python
import numpy as np
import os, sys
path = os.path.abspath('../library/')
if path not in sys.path:
sys.path.append(path)
from cumhpx import do_likelihood, local_normalisation
name = 'raster_0.7_1.0'
```
```python
print(local_normalisation(name, verbose = True))
outputDir = '../output/%s_0.001' %name
fSample = 0.001
print(do_likelihood(outputDir,fSample= fSample))
```
## Local normalisation, compare to Czekaj+14 table 7 ##
popid= 0 1.4 Msun/pc^3*10^-3
popid= 1 3.6 Msun/pc^3*10^-3
popid= 2 2.7 Msun/pc^3*10^-3
popid= 3 2.2 Msun/pc^3*10^-3
popid= 4 3.8 Msun/pc^3*10^-3
popid= 5 3.7 Msun/pc^3*10^-3
popid= 6 7.1 Msun/pc^3*10^-3
popid= 7 1.2 Msun/pc^3*10^-3
popid= 8 13.8 Msun/pc^3*10^-6
## total sum of stars: 25.6
thindisc WD 10.7 Msun/pc^3*10^-3 3.3 mact
thick disc WD 2.7 Msun/pc^3*10^-3 0.9 mact
####################################
(25.62421405098059, 4.2276952630326, 310064)
GDR2mock
nstar before cleaning: 1426412
nstar after g-band cleaning: 1096050
nstar before cleaning: 1096050
nstar after rp-band cleaning: 799610
799610
after smc cut: 799299
after lmc cut: 797728
GDR2
nstar before cleaning: 1253908
nstar after g-band cleaning: 1105846
nstar before cleaning: 1105846
nstar after rp-band cleaning: 930066
930066
after smc cut: 928633
after lmc cut: 919108
hpx 2055 is empty
hpx 2064 is empty
hpx 2065 is empty
hpx 2066 is empty
hpx 2067 is empty
hpx 2068 is empty
hpx 2069 is empty
hpx 2070 is empty
hpx 2071 is empty
hpx 2072 is empty
hpx 2073 is empty
hpx 2080 is empty
hpx 2081 is empty
hpx 2082 is empty
hpx 2088 is empty
hpx 2112 is empty
hpx 2336 is empty
hpx 2338 is empty
hpx 2344 is empty
hpx 2346 is empty
likelihood: -329392.34911536257
total diff: 141726
too many: 10173, too little: -131553
hpx 2055 is empty
hpx 2064 is empty
hpx 2065 is empty
hpx 2066 is empty
hpx 2067 is empty
hpx 2068 is empty
hpx 2069 is empty
hpx 2070 is empty
hpx 2071 is empty
hpx 2072 is empty
hpx 2073 is empty
hpx 2080 is empty
hpx 2081 is empty
hpx 2082 is empty
hpx 2088 is empty
hpx 2112 is empty
hpx 2336 is empty
hpx 2338 is empty
hpx 2344 is empty
hpx 2346 is empty
hpx 2055 is empty
hpx 2064 is empty
hpx 2065 is empty
hpx 2066 is empty
hpx 2067 is empty
hpx 2068 is empty
hpx 2069 is empty
hpx 2070 is empty
hpx 2071 is empty
hpx 2072 is empty
hpx 2073 is empty
hpx 2080 is empty
hpx 2081 is empty
hpx 2082 is empty
hpx 2088 is empty
hpx 2112 is empty
hpx 2336 is empty
hpx 2338 is empty
hpx 2344 is empty
hpx 2346 is empty
797728 919108
/home/rybizki/anaconda3/lib/python3.6/site-packages/healpy/pixelfunc.py:304: RuntimeWarning: invalid value encountered in less_equal
return np.absolute(m - badval) <= atol + rtol * np.absolute(badval)
/home/rybizki/anaconda3/lib/python3.6/site-packages/healpy/projaxes.py:1053: RuntimeWarning: invalid value encountered in less
result.data[result.data<0]=0.0
/home/rybizki/anaconda3/lib/python3.6/site-packages/healpy/projaxes.py:1054: RuntimeWarning: invalid value encountered in greater
result.data[result.data>1]=1.0
(797728, -329392.34911536257, 10173, 131553)
/home/rybizki/anaconda3/lib/python3.6/site-packages/matplotlib/colors.py:1031: RuntimeWarning: invalid value encountered in less_equal
mask |= resdat <= 0
```python
name_comp = 'raster_0.7_1.0'
compDir = '../output/%s_0.001/GDR2mock_20.7Gmag.fits' %name_comp
fSample = 0.0025
do_likelihood(outputDir,fSample= fSample, comp_file = compDir, savefile=False)
```
GDR2mock
nstar before cleaning: 1506672
nstar after g-band cleaning: 1161038
nstar before cleaning: 1161038
nstar after rp-band cleaning: 844364
844364
after smc cut: 844040
after lmc cut: 842305
GDR2
nstar before cleaning: 1426412
nstar after g-band cleaning: 1096050
nstar before cleaning: 1096050
nstar after rp-band cleaning: 799610
799610
after smc cut: 799299
after lmc cut: 797728
hpx 2055 is empty
hpx 2064 is empty
hpx 2065 is empty
hpx 2066 is empty
hpx 2067 is empty
hpx 2068 is empty
hpx 2069 is empty
hpx 2070 is empty
hpx 2071 is empty
hpx 2072 is empty
hpx 2073 is empty
hpx 2080 is empty
hpx 2081 is empty
hpx 2082 is empty
hpx 2088 is empty
hpx 2112 is empty
hpx 2336 is empty
hpx 2338 is empty
hpx 2344 is empty
hpx 2346 is empty
likelihood: -2818.5104063285876
total diff: 44683
too many: 44630, too little: -53
hpx 2055 is empty
hpx 2064 is empty
hpx 2065 is empty
hpx 2066 is empty
hpx 2067 is empty
hpx 2068 is empty
hpx 2069 is empty
hpx 2070 is empty
hpx 2071 is empty
hpx 2072 is empty
hpx 2073 is empty
hpx 2080 is empty
hpx 2081 is empty
hpx 2082 is empty
hpx 2088 is empty
hpx 2112 is empty
hpx 2336 is empty
hpx 2338 is empty
hpx 2344 is empty
hpx 2346 is empty
hpx 2055 is empty
hpx 2064 is empty
hpx 2065 is empty
hpx 2066 is empty
hpx 2067 is empty
hpx 2068 is empty
hpx 2069 is empty
hpx 2070 is empty
hpx 2071 is empty
hpx 2072 is empty
hpx 2073 is empty
hpx 2080 is empty
hpx 2081 is empty
hpx 2082 is empty
hpx 2088 is empty
hpx 2112 is empty
hpx 2336 is empty
hpx 2338 is empty
hpx 2344 is empty
hpx 2346 is empty
842305 797728
/home/rybizki/anaconda3/lib/python3.6/site-packages/healpy/pixelfunc.py:304: RuntimeWarning: invalid value encountered in less_equal
return np.absolute(m - badval) <= atol + rtol * np.absolute(badval)
/home/rybizki/anaconda3/lib/python3.6/site-packages/healpy/projaxes.py:1053: RuntimeWarning: invalid value encountered in less
result.data[result.data<0]=0.0
/home/rybizki/anaconda3/lib/python3.6/site-packages/healpy/projaxes.py:1054: RuntimeWarning: invalid value encountered in greater
result.data[result.data>1]=1.0
/home/rybizki/anaconda3/lib/python3.6/site-packages/matplotlib/colors.py:1031: RuntimeWarning: invalid value encountered in less_equal
mask |= resdat <= 0
(842305, -2818.5104063285876, 44630, 53)
```python
```
|
jan-rybizkiREPO_NAMEGalaxia_wrapPATH_START.@Galaxia_wrap_extracted@Galaxia_wrap-master@notebook@Likelihood_assessment.ipynb@.PATH_END.py
|
{
"filename": "test_visualisations_profiles.py",
"repo_name": "n-claes/legolas",
"repo_path": "legolas_extracted/legolas-master/tests/pylbo_tests/test_visualisations_profiles.py",
"type": "Python"
}
|
import numpy as np
import pylbo
def test_plot_equilibrium_profile(ds_v112):
p = pylbo.plot_equilibrium(ds_v112)
assert p is not None
p.draw()
def test_plot_continuum_profile(ds_v112):
p = pylbo.plot_continua(ds_v112)
assert p is not None
p.draw()
def test_plot_equilibrium_balance(ds_v112):
p = pylbo.plot_equilibrium_balance(ds_v112)
assert p is not None
p.draw()
def test_plot_matrices(ds_v100):
p = pylbo.plot_matrices(ds_v100)
assert p is not None
p.draw()
def test_plot_equilibrium_profile_no_bg(ds_v200_tear_nobg):
p = pylbo.plot_equilibrium(ds_v200_tear_nobg)
assert p is None
def test_plot_equilibrium_balance_no_bg(ds_v200_tear_nobg):
p = pylbo.plot_equilibrium_balance(ds_v200_tear_nobg)
assert p is None
def test_plot_equilibrim_balance(ds_v200_mri_efs):
p = pylbo.plot_equilibrium_balance(ds_v200_mri_efs)
assert p is not None
p.draw()
def test_plot_equilibrium_balance_hd(ds_v200_hd_khi):
p = pylbo.plot_equilibrium_balance(ds_v200_hd_khi)
assert p is not None
p.draw()
def test_eq_balance(monkeypatch, ds_v200_mri_efs):
monkeypatch.setitem(
ds_v200_mri_efs.equilibria, "v01", np.ones_like(ds_v200_mri_efs.grid_gauss)
)
balance = pylbo.get_equilibrium_balance(ds_v200_mri_efs)
assert balance.get("continuity", None) is not None
assert balance.get("induction 1", None) is not None
|
n-claesREPO_NAMElegolasPATH_START.@legolas_extracted@legolas-master@tests@pylbo_tests@test_visualisations_profiles.py@.PATH_END.py
|
{
"filename": "test_aperturedb.py",
"repo_name": "langchain-ai/langchain",
"repo_path": "langchain_extracted/langchain-master/libs/community/tests/integration_tests/vectorstores/test_aperturedb.py",
"type": "Python"
}
|
"""Test ApertureDB functionality."""
import uuid
import pytest
from langchain_tests.integration_tests.vectorstores import VectorStoreIntegrationTests
from langchain_community.vectorstores import ApertureDB
class TestApertureStandard(VectorStoreIntegrationTests):
@pytest.fixture
def vectorstore(self) -> ApertureDB:
descriptor_set = uuid.uuid4().hex # Fresh descriptor set for each test
return ApertureDB(
embeddings=self.get_embeddings(), descriptor_set=descriptor_set
)
|
langchain-aiREPO_NAMElangchainPATH_START.@langchain_extracted@langchain-master@libs@community@tests@integration_tests@vectorstores@test_aperturedb.py@.PATH_END.py
|
{
"filename": "gaussian_streaming_model_fftw.py",
"repo_name": "sfschen/velocileptors",
"repo_path": "velocileptors_extracted/velocileptors-master/velocileptors/LPT/gaussian_streaming_model_fftw.py",
"type": "Python"
}
|
import numpy as np
from scipy.interpolate import InterpolatedUnivariateSpline as Spline
from scipy.signal import tukey
from velocileptors.Utils.spherical_bessel_transform import SphericalBesselTransform
from velocileptors.Utils.loginterp import loginterp
from velocileptors.LPT.velocity_moments_fftw import VelocityMoments
class GaussianStreamingModel(VelocityMoments):
'''
Class to calculate the redshift space correlation function
using the Gaussian streaming model.
Inherits the VelocityMoments class which itself inherits the CLEFT class.
Assumes third_order = True. Simply set b3 = 0 if not using third-order bias.
'''
def __init__(self, *args, kmin = 3e-3, kmax=0.5, nk = 100, kswitch=1e-2, jn = 5, cutoff=20, **kw):
'''
Same keywords and arguments as the other two classes for now.
'''
# Setup ffts etc.
VelocityMoments.__init__(self, *args, third_order=True, **kw)
self.kmin, self.kmax, self.nk = kmin, kmax, nk
self.kv = np.logspace(np.log10(kmin), np.log10(kmax), nk); self.nk = nk
self.kint = np.logspace(-5,3,4000)
self.plin = loginterp(self.k, self.p)(self.kint)
self.sph_gsm = SphericalBesselTransform(self.kint,L=3,fourier=True)
self.rint = np.logspace(-3,5,4000)
self.rint = self.rint[(self.rint>0.1)*(self.rint<600)] #actual range of integration
self.window = tukey(4000)
self.weight = 0.5 * (1 + np.tanh(3*np.log(self.kint/kswitch)))
self.weight[self.weight < 1e-3] = 0
self.pars = np.array([0,0,0,0, 0,0,0,0, 0])
self.peft = None
self.veft = None
self.s0eft = None
self.s2eft = None
self.setup_velocity_moments()
#self.setup_config_vels()
def setup_velocity_moments(self):
self.make_ptable(kmin = self.kmin, kmax = self.kmax, nk = self.nk)
self.make_vtable(kmin = self.kmin, kmax = self.kmax, nk = self.nk)
self.make_spartable(kmin = self.kmin, kmax = self.kmax, nk = self.nk)
self.make_stracetable(kmin = self.kmin, kmax = self.kmax, nk = self.nk)
self.convert_sigma_bases(basis='Legendre')
def compute_cumulants(self, b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog):
'''
Calculate velocity moments and turn into cumulants.
'''
# Compute each moment
self.pars = np.array([b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog])
self.kv = self.pktable[:,0]
self.pzel = self.pktable[:,-1]
self.peft = self.pktable[:,1] + b1*self.pktable[:,2] + b1**2*self.pktable[:,3]\
+ b2*self.pktable[:,4] + b1*b2*self.pktable[:,5] + b2**2 * self.pktable[:,6]\
+ bs*self.pktable[:,7] + b1*bs*self.pktable[:,8] + b2*bs*self.pktable[:,9]\
+ bs**2*self.pktable[:,10] + b3*self.pktable[:,11] + b1*b3*self.pktable[:,12] + alpha* self.kv**2 * self.pzel
_integrand = loginterp(self.kv, self.peft)(self.kint) #at some point turn into theory extrapolation
_integrand = self.weight * _integrand + (1-self.weight) * ((1+b1)**2 * self.plin)
qint, xi = self.sph_gsm.sph(0,_integrand*self.window)
self.xieft = np.interp(self.rint, qint, xi)
self.vkeft = self.vktable[:,1] + b1*self.vktable[:,2] + b1**2*self.vktable[:,3]\
+ b2*self.vktable[:,4] + b1*b2*self.vktable[:,5] \
+ bs*self.vktable[:,7] + b1*bs*self.vktable[:,8] + b3 * self.vktable[:,11]\
+ alpha_v * self.kv * self.pzel
_integrand = loginterp(self.kv, self.vkeft)(self.kint)
_integrand = self.weight * _integrand + (1-self.weight) * (-2 * (1+b1) * self.plin/self.kint)
qint, xi = self.sph_gsm.sph(1,_integrand*self.window)
self.veft = np.interp(self.rint, qint, xi)
self.s0keft = self.s0[:,1] + b1*self.s0[:,2] + b1**2*self.s0[:,3]\
+ b2*self.s0[:,4] \
+ bs*self.s0[:,7] \
+ alpha_s0 * self.pzel
self.s2keft = self.s2[:,1] + b1*self.s2[:,2] + b1**2*self.s2[:,3]\
+ b2*self.s2[:,4] \
+ bs*self.s2[:,7] \
+ alpha_s2 * self.pzel
_integrand = loginterp(self.kv, self.s0keft)(self.kint)
_integrand = self.weight * _integrand + (1-self.weight) * (-2./3 * self.plin/self.kint**2)
qint, xi = self.sph_gsm.sph(0,_integrand * self.window)
self.s0eft = np.interp(self.rint, qint, xi)
_integrand = loginterp(self.kv, self.s2keft)(self.kint)
_integrand = self.weight * _integrand + (1-self.weight) * (-4./3 * self.plin/self.kint**2)
qint2, xi = self.sph_gsm.sph(2,_integrand * self.window); xi *=-1
self.s2eft = np.interp(self.rint, qint2, xi)
self.s0eft += (self.Xddot + self.Xloopddot + 2*b1*self.X10ddot + 2*bs*self.Xs2ddot)[-1] + s2fog #add in 0-lag term
def compute_xi_rsd(self, sperp_obs, spar_obs, f, b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog, apar=1.0, aperp=1.0, rwidth=100, Nint=10000, update_cumulants=False, toler=1e-5):
'''
Compute the redshift-space xi(sperpendicular,sparallel).
'''
# define "true" coordinates using A-P parameters.
spar = spar_obs * apar
sperp = sperp_obs * aperp
# If cumulants have already been computed for same parameters, skip this step:
pars_new = np.array([b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog])
if update_cumulants or (self.peft is None) or (not np.allclose(self.pars,pars_new)):
self.compute_cumulants(b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog)
# definte integration coords
ys = np.linspace(-rwidth,rwidth,Nint) # this z - s_par
rs = np.sqrt( (spar - ys)**2 + sperp**2 )
mus = (spar - ys)/rs
xi_int = 1 + np.interp(rs, self.rint, self.xieft)
v_int = f*( np.interp(rs, self.rint, self.veft) * mus ) / xi_int
s_int = f**2 * ( np.interp(rs, self.rint, self.s0eft) + 0.5 * (3*mus**2 - 1) * np.interp(rs, self.rint, self.s2eft) )/xi_int - v_int**2
# Need to deal with s_int < 0, since it's not allowed but can be induced by ct's
# As a rought patch just kill s_int where it's smaller than some fraction of max
smax = np.max(s_int)
siis = s_int < (toler * smax)
s_int[siis] = toler * smax
integrand = xi_int * np.exp( -0.5 * (ys - v_int)**2 / s_int ) / np.sqrt(2*np.pi*s_int)
integrand[np.isnan(integrand)] = 0.
return np.trapz(integrand, x=ys) - 1
def compute_xi_ell(self, s, f, b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog, apar=1.0, aperp=1.0, rwidth=100, Nint=10000, ngauss=4, update_cumulants=False):
'''
Compute the redshift-space correlation function multipoles
'''
# Compute the cumulants
#self.compute_cumulants(b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog)
# Compute each moment
nus, ws = np.polynomial.legendre.leggauss(2*ngauss)
L0 = np.polynomial.legendre.Legendre((1))(nus)
L2 = np.polynomial.legendre.Legendre((0,0,1))(nus)
L4 = np.polynomial.legendre.Legendre((0,0,0,0,1))(nus)
nus_calc = nus[:ngauss]
xi0, xi2, xi4 = 0,0,0
for ii, nu in enumerate(nus_calc):
xi_nu = self.compute_xi_rsd(s*np.sqrt(1-nu**2),s*nu, f, b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog, apar=apar, aperp=aperp, rwidth=rwidth, Nint=Nint, update_cumulants=update_cumulants)
xi0 += xi_nu * L0[ii] * 1 * ws[ii]
xi2 += xi_nu * L2[ii] * 5 * ws[ii]
xi4 += xi_nu * L4[ii] * 9 * ws[ii]
return xi0, xi2, xi4
def compute_xi_real(self, rr, b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog):
'''
Compute the real-space correlation function at rr.
'''
# This is just the zeroth moment:
self.kv = self.pktable[:,0]
self.pzel = self.pktable[:,-1]
self.peft = self.pktable[:,1] + b1*self.pktable[:,2] + b1**2*self.pktable[:,3]\
+ b2*self.pktable[:,4] + b1*b2*self.pktable[:,5] + b2**2 * self.pktable[:,6]\
+ bs*self.pktable[:,7] + b1*bs*self.pktable[:,8] + b2*bs*self.pktable[:,9]\
+ bs**2*self.pktable[:,10] + b3*self.pktable[:,11] + b1*b3*self.pktable[:,12] + alpha* self.kv**2 * self.pzel
_integrand = loginterp(self.kv, self.peft)(self.kint) #at some point turn into theory extrapolation
_integrand = self.weight * _integrand + (1-self.weight) * ((1+b1)**2 * self.plin)
qint, xi = self.sph_gsm.sph(0,_integrand)
xir = Spline(qint,xi)(rr)
return xir
|
sfschenREPO_NAMEvelocileptorsPATH_START.@velocileptors_extracted@velocileptors-master@velocileptors@LPT@gaussian_streaming_model_fftw.py@.PATH_END.py
|
{
"filename": "_weight.py",
"repo_name": "plotly/plotly.py",
"repo_path": "plotly.py_extracted/plotly.py-master/packages/python/plotly/plotly/validators/surface/legendgrouptitle/font/_weight.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class WeightValidator(_plotly_utils.basevalidators.IntegerValidator):
def __init__(
self,
plotly_name="weight",
parent_name="surface.legendgrouptitle.font",
**kwargs,
):
super(WeightValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "style"),
extras=kwargs.pop("extras", ["normal", "bold"]),
max=kwargs.pop("max", 1000),
min=kwargs.pop("min", 1),
**kwargs,
)
|
plotlyREPO_NAMEplotly.pyPATH_START.@plotly.py_extracted@plotly.py-master@packages@python@plotly@plotly@validators@surface@legendgrouptitle@font@_weight.py@.PATH_END.py
|
{
"filename": "setup.py",
"repo_name": "D4san/MultiREx-public",
"repo_path": "MultiREx-public_extracted/MultiREx-public-main/setup.py",
"type": "Python"
}
|
#########################################
# __ __ _ _ _ ___ ___ #
# | \/ |_ _| | |_(_) _ \ __|_ __ #
# | |\/| | || | | _| | / _|\ \ / #
# |_| |_|\_,_|_|\__|_|_|_\___/_\_\ #
# Planetary spectra generator #
#########################################
import setuptools
with open('README.md', 'r') as fh:
long_description = fh.read()
setuptools.setup(
# ######################################################################
# BASIC DESCRIPTION
# ######################################################################
name='multirex',
author='David Duque-Castaño and Jorge I. Zuluaga',
author_email='dsantiago.duque@udea.edu.co',
description='Massive planetary spectra generator',
long_description=long_description,
long_description_content_type='text/markdown',
url='https://pypi.org/project/multirex',
keywords='exoplanets astrobiology astronomy spectroscopy',
license='MIT',
# ######################################################################
# CLASSIFIER
# ######################################################################
classifiers=[
'Programming Language :: Python :: 3',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
],
version='0.2.1',
# ######################################################################
# FILES
# ######################################################################
package_dir={'': '.'},
packages=setuptools.find_packages(where='.'),
# ######################################################################
# ENTRY POINTS
# ######################################################################
entry_points={
'console_scripts': ['install=pryngles.install:main'],
},
# ######################################################################
# TESTS
# ######################################################################
test_suite='nose.collector',
tests_require=['nose'],
# ######################################################################
# DEPENDENCIES
# ######################################################################
install_requires=['numpy','taurex','matplotlib','tqdm','pandas','gdown','pyarrow'],
# ######################################################################
# OPTIONS
# ######################################################################
include_package_data=True,
package_data={'': ['data/*.*', 'tests/*.*']},
#scripts=['multirex/scripts/imultirex','multirex/scripts/multirex-test.py'],
)
|
D4sanREPO_NAMEMultiREx-publicPATH_START.@MultiREx-public_extracted@MultiREx-public-main@setup.py@.PATH_END.py
|
{
"filename": "rgbtools.py",
"repo_name": "solerjuan/astroHOG",
"repo_path": "astroHOG_extracted/astroHOG-master/rgbtools.py",
"type": "Python"
}
|
# This file is part of AstroHOG
#
# Copyright (C) 2013-2017 Juan Diego Soler
import sys
import numpy as np
from astropy.io import fits
import matplotlib
#matplotlib.use('Agg') # Must be before importing matplotlib.pyplot or pylab!
import matplotlib.pyplot as plt
#sys.path.append('/disk2/soler/PYTHON/astroHOG/')
#from astrohog import *
from astropy.convolution import convolve_fft
from astropy.convolution import Gaussian2DKernel
from astropy.wcs import WCS
from reproject import reproject_interp
import imageio
SMALLER_SIZE=6
from matplotlib.colors import LinearSegmentedColormap
cdict1 = {'red': ((0.00, 0.0, 0.0),
(0.01, 0.0, 0.0),
(0.02, 0.0, 0.0),
(0.03, 0.0, 0.0),
(0.04, 0.0, 0.0),
(1.0, 1.0, 1.0)),
'green': ((0.0, 0.0, 0.0),
(1.0, 0.0, 0.0)),
'blue': ((0.0, 0.0, 0.0),
(1.0, 0.0, 0.0))
}
COcolort=LinearSegmentedColormap('COcmap', cdict1)
plt.register_cmap(cmap=COcolort)
cdict2 = {'red': ((0.0, 0.0, 0.0),
(1.0, 0.0, 0.0)),
'green': ((0.0, 0.00, 0.0),
(0.0, 0.01, 0.0),
(0.0, 0.02, 0.0),
(0.0, 0.03, 0.0),
(0.0, 0.04, 0.0),
(1.0, 1.00, 1.0)),
'blue': ((0.0, 0.00, 0.0),
(0.0, 0.01, 0.0),
(0.0, 0.02, 0.0),
(0.0, 0.03, 0.0),
(0.0, 0.04, 0.0),
(1.0, 1.00, 1.0))
}
HIcolort=LinearSegmentedColormap('COcmap', cdict2)
plt.register_cmap(cmap=HIcolort)
# -----------------------------------------------------------------------------------------------------------
def tealct():
return HIcolort
# -----------------------------------------------------------------------------------------------------------
def redct():
return COcolort
# -----------------------------------------------------------------------------------------------------------
def rgbcube(cube, zmin, zmax, autoscale=False, minref=None, maxref=None, ksz=1, EquiBins=True, minauto=0.2, maxauto=0.975):
nbins=1000
sz=np.shape(cube)
cube[np.isnan(cube).nonzero()]=0.
rgb=np.zeros([sz[1],sz[2],3])
channels=zmax-zmin+1
indexes=np.arange(zmin,zmax)
pitch=int(channels/3.)
meanI=cube[zmin:zmax].mean(axis=(1,2))
cumsumI=np.cumsum(meanI)
binwd=np.max(cumsumI)/3.
# ------------------------------------------------------------------------------------
firstb=np.max((cumsumI < binwd).nonzero())
if (EquiBins):
tempcube=cube[zmin:zmin+firstb-1,:,:]
else:
tempcube=cube[zmin:zmin+pitch-1,:,:]
tempcube[np.isnan(tempcube).nonzero()]=0.
if (minref):
tempcube[(tempcube<minref).nonzero()]=0.
tempmap=tempcube.mean(axis=0)
hist, bin_edges = np.histogram(tempmap, density=True, bins=nbins)
bin_centres=0.5*(bin_edges[0:np.size(bin_edges)-1]+bin_edges[1:np.size(bin_edges)])
chist=np.cumsum(hist)
cond=(chist < minauto*chist[np.size(chist)-1]).nonzero()
if (np.size(cond)==0):
mini=np.min(bin_centres)
else:
mini=np.max(bin_edges[cond])
cond=(chist > maxauto*chist[np.size(chist)-1]).nonzero()
if (np.size(cond)==0):
maxi=np.max(bin_centres)
else:
maxi=np.min(bin_edges[cond])
if(autoscale):
tempmap[(tempmap < mini).nonzero()]=mini
tempmap[(tempmap > maxi).nonzero()]=maxi
red=(tempmap-np.min(tempmap))/(np.max(tempmap)-np.min(tempmap))
# ------------------------------------------------------------------------------------
secondb=np.max((cumsumI < 2.*binwd).nonzero())
if (EquiBins):
tempcube=cube[zmin+firstb:zmin+secondb,:,:]
else:
tempcube=cube[zmin+pitch:zmin+2*pitch-1,:,:]
tempcube[np.isnan(tempcube).nonzero()]=0.
if (minref):
tempcube[(tempcube<minref).nonzero()]=0.
tempmap=tempcube.mean(axis=0)
hist, bin_edges = np.histogram(tempmap, density=True, bins=nbins)
bin_centres=0.5*(bin_edges[0:np.size(bin_edges)-1]+bin_edges[1:np.size(bin_edges)])
chist=np.cumsum(hist)
cond=(chist < minauto*chist[np.size(chist)-1]).nonzero()
if (np.size(cond)==0):
mini=np.min(bin_centres)
else:
mini=np.max(bin_edges[cond])
cond=(chist > maxauto*chist[np.size(chist)-1]).nonzero()
if (np.size(cond)==0):
maxi=np.max(bin_centres)
else:
maxi=np.min(bin_edges[cond])
if(autoscale):
tempmap[(tempmap < mini).nonzero()]=mini
tempmap[(tempmap > maxi).nonzero()]=maxi
green=(tempmap-np.min(tempmap))/(np.max(tempmap)-np.min(tempmap))
# ------------------------------------------------------------------------------------
if (EquiBins):
tempcube=cube[zmin+secondb+1:zmax,:,:]
else:
tempcube=cube[zmin+2*pitch:zmax,:,:]
tempcube[np.isnan(tempcube).nonzero()]=0.
if (minref):
tempcube[(tempcube<minref).nonzero()]=0.
tempmap=tempcube.mean(axis=0)
hist, bin_edges = np.histogram(tempmap, density=True, bins=nbins)
bin_centres=0.5*(bin_edges[0:np.size(bin_edges)-1]+bin_edges[1:np.size(bin_edges)])
chist=np.cumsum(hist)
cond=(chist < minauto*chist[np.size(chist)-1]).nonzero()
if (np.size(cond)==0):
mini=np.min(bin_centres)
else:
mini=np.max(bin_edges[cond])
cond=(chist > maxauto*chist[np.size(chist)-1]).nonzero()
if (np.size(cond)==0):
maxi=np.max(bin_centres)
else:
maxi=np.min(bin_edges[cond])
if(autoscale):
tempmap[(tempmap < mini).nonzero()]=mini
tempmap[(tempmap > maxi).nonzero()]=maxi
blue=(tempmap-np.min(tempmap))/(np.max(tempmap)-np.min(tempmap))
rgb[:,:,0]=red
rgb[:,:,1]=green
rgb[:,:,2]=blue
return rgb;
# -----------------------------------------------------------------------------------------------------------
def rgbmovie(cube, zmin, zmax, logscale=False, minref=0., maxref=0.45, ksz=1, group=2, prefix='frame', hdr=0, duration=0.5):
sz=np.shape(cube)
rgb=np.zeros([sz[1],sz[2],3])
k=0
images=[]
for i in range(zmin, zmax):
tempmap=cube[i-1-group/2:i-1+group/2,:,:].mean(axis=0)
if(group==0):
tempmap=cube[i-1,:,:]
if(ksz > 1):
inmap=convolve_fft(tempmap, Gaussian2DKernel(ksz))
else:
inmap=tempmap
if(logscale):
inmap=np.log10(np.copy(inmap))
inmap[np.isinf(inmap).nonzero()]=minref
inmap[(inmap < minref).nonzero()]=minref
inmap[(inmap > maxref).nonzero()]=maxref
red=(inmap-np.min(inmap))/(np.max(inmap)-np.min(inmap))
tempmap=cube[i-group/2:i+group/2,:,:].sum(axis=0)/float(group+1)
if(group==0):
tempmap=cube[i,:,:]
if(ksz > 1):
inmap=convolve_fft(tempmap, Gaussian2DKernel(ksz))
else:
inmap=tempmap
if(logscale):
inmap=np.log10(np.copy(inmap))
inmap[np.isinf(inmap).nonzero()]=minref
inmap[(inmap < minref).nonzero()]=minref
inmap[(inmap > maxref).nonzero()]=maxref
green=(inmap-np.min(inmap))/(np.max(inmap)-np.min(inmap))
tempmap=cube[i+1-group/2:i+1+group/2,:,:].sum(axis=0)/float(group+1)
if(group==0):
tempmap=cube[i+1,:,:]
if(ksz > 1):
inmap=convolve_fft(tempmap, Gaussian2DKernel(ksz))
else:
inmap=tempmap
if(logscale):
inmap=np.log10(np.copy(inmap))
inmap[np.isinf(inmap).nonzero()]=minref
inmap[(inmap < minref).nonzero()]=minref
inmap[(inmap > maxref).nonzero()]=maxref
blue=(inmap-np.min(inmap))/(np.max(inmap)-np.min(inmap))
rgb[:,:,0]=red
rgb[:,:,1]=green
rgb[:,:,2]=blue
fig = plt.figure(figsize=(1.5, 3.0), dpi=300)
plt.rc('font', size=SMALLER_SIZE)
if(hdr):
ax1=plt.subplot(1,1,1, projection=WCS(hdr))
im=ax1.imshow(rgb, origin='lower', interpolation='none')
ax1.coords.grid(color='white')
ax1.coords['glon'].set_axislabel('Galactic Longitude')
ax1.coords['glat'].set_axislabel('Galactic Latitude')
else:
ax1=plt.subplot(1,1,1)
im=ax1.imshow(rgb, origin='lower', interpolation='none')
rgb=rgbcube(cube1, zmin1, zmax1, minref=minrm1, EquiBins=False)
ax1.set_title('Projected HI')
#plt.show()
plt.savefig(prefix+'_'+str(k)+'.png', bbox_inches='tight')
plt.close()
images.append(imageio.imread(prefix+'_'+str(k)+'.png'))
k+=1
imageio.mimsave(prefix+'.gif', images, duration=duration)
#import pdb; pdb.set_trace()
|
solerjuanREPO_NAMEastroHOGPATH_START.@astroHOG_extracted@astroHOG-master@rgbtools.py@.PATH_END.py
|
{
"filename": "basic_growth.ipynb",
"repo_name": "miosta/drift_composition",
"repo_path": "drift_composition_extracted/drift_composition-main/examples/basic_growth.ipynb",
"type": "Jupyter Notebook"
}
|
# Basic Model
Build a single steady disc model and compute the composition using the default abundances
```python
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.style.use('seaborn-talk')
```
### Define constants describing the disc model
```python
Mdot_gas = 1e-8
Mdot_dust = 1e-9
Stokes = 0.01
T = lambda R: 150*(R/Rau)**-0.5
alpha = lambda R: 1e-3
```
### Build a grid and the background disc model
```python
from drift_composition.planet_growth import seed_mass, Planet, PlanetEnv, mass_growth
from drift_composition.constants import Mearth, Msun, Rau, yr
from drift_composition.grid import Grid
from drift_composition.disc import DiscModel
from drift_composition.molecule import get_molecular_properties
grid = Grid(0.1*Rau, 30*Rau, 512)
DM = DiscModel(grid, Mdot_gas, alpha, T)
DM.compute_dust_surface_density(Mdot_dust, Stokes)
```
```python
f, ax = plt.subplots(2, figsize=(10, 8), sharex=True)
ax[0].loglog(grid.Rc/Rau, DM.Sigma_gas, label='Gas')
ax[0].loglog(grid.Rc/Rau, DM.Sigma_dust, label='Dust')
ax[0].set_ylabel('Surface density [g cm^-2]')
ax[0].legend()
ax[1].loglog(grid.Rc/Rau, T(grid.Rc))
ax[1].set_xlabel('Radius [AU]')
ax[1].set_ylabel('Temperature [K]')
ax[0].legend()
f.tight_layout()
```
### Compute the chemical structure
```python
species, abundances = get_molecular_properties()
DM.compute_chemistry(species, abundances )
```
```python
f, ax = plt.subplots(2, figsize=(10, 8), sharex=True)
ax[0].loglog(grid.Rc/Rau, DM.Sigma_gas, label='Gas', c='k')
ax[0].loglog(grid.Rc/Rau, DM.Sigma_dust, label='Dust', c='k', ls='--')
for spec in ['H2O', 'CO', 'CO2']:
l,= ax[0].loglog(grid.Rc/Rau, DM.Sigma_mol[spec][:,0], label=f'{spec} (gas)')
ax[0].loglog(grid.Rc/Rau, DM.Sigma_mol[spec][:,1], label=f'{spec} (ice)', ls='--', c=l.get_color())
ax[0].set_ylabel('Surface density [g cm^-2]')
ax[0].legend(ncol=2)
ax[0].set_ylim(ymin=1e-3)
columns = DM.compute_elemental_column()
C2O = columns['C']/columns['O']
columns = DM.compute_elemental_column(dust=None)
C2O_ice = columns['C']/columns['O']
plt.figure()
ax[1].semilogx(grid.Rc/Rau, C2O[:,0], label='gas')
ax[1].semilogx(grid.Rc/Rau, C2O[:,1], label='ice+dust')
ax[1].semilogx(grid.Rc/Rau, C2O_ice[:,1], label='ice only')
ax[1].set_xlabel('Radius [AU]')
ax[1].set_ylabel('C/O ratio')
ax[1].legend()
f.tight_layout()
```
<Figure size 748.8x514.8 with 0 Axes>
```python
species, abundances = get_molecular_properties()
f_comp = dict(zip([spec.name for spec in species],np.zeros((len(species),2))))
grid = Grid(0.1*Rau, 30*Rau, 512)
planet_ini = Planet(0.0001*Mearth/Msun, 0.0001*Mearth/Msun, 1e-10, f_comp, 70.0*Rau)
print(planet_ini.f_comp)
p_env = PlanetEnv(grid, alpha(grid.Rc), 2.35, 1.0)
dt = 10000
Nt = int(1e2)
masses = []
mcs = []
mgs = []
mco_g = []
mco_d = []
rr = []
print(p_env.temp(T(grid.Rc),planet_ini.dist), planet_ini.mass)
import drift_composition.planet_migration as mig
flaring = 0
gas_slope = 0.5
planet = planet_ini
for kk in range(Nt):
planet = mass_growth(planet, p_env, DM, T(grid.Rc), dt)
#print( mig.a_dot_typeI(planet, p_env, DM, T(grid.Rc), flaring, gas_slope)/yr)
planet.dist = mig.mig_planet(planet, p_env, DM, T(grid.Rc), flaring, gas_slope, dt)
masses.append(planet.mass)
mcs.append(planet.mc)
mgs.append(planet.mg)
mco_g.append(planet.f_comp['CO'][0])
mco_d.append(planet.f_comp['CO'][1])
rr.append(planet.dist)
#help(planet)
#print(planet.mass)
#print(planet.f_comp['CO'])
```
{'H2O': array([0., 0.]), 'CO2': array([0., 0.]), 'CO': array([0., 0.]), 'C': array([0., 0.]), 'N2': array([0., 0.]), 'NH3': array([0., 0.]), 'Ar': array([0., 0.]), 'Kr': array([0., 0.]), 'Xe': array([0., 0.])}
27.462150906018667 3.0035054610980103e-10
-1.5688261497808893 1.8513386096447627e-10
-1.5688261497808895 8.899066009538952e-10
-1.5688261497808893 2.8972777897650596e-09
-1.5688261497808893 7.308498793814251e-09
-1.5688261497808893 1.552011647704675e-08
-1.568826149780889 2.9129871199318332e-08
-1.568826149780889 5.001148379292642e-08
-1.568826149780889 8.024404018713736e-08
-1.5688261497808893 1.2231266875981156e-07
-1.568826149780889 1.7913165841076865e-07
-1.5688261497808889 2.542855415151749e-07
-1.568826149780889 3.522439074635856e-07
-1.5688261497808889 4.786972167593158e-07
-1.5688261497808889 6.410001458742132e-07
-1.5688261497808893 8.487842647331062e-07
-1.568826149780889 1.1148202509202135e-06
-1.5688261497808886 1.4562665404309576e-06
-1.568826149780889 1.8965435823511831e-06
-1.5688261497808889 2.4682756477948638e-06
-1.568826149780889 3.218171910361024e-06
-1.5688261497808889 4.21570257871457e-06
-1.5688261497808895 5.569897217413358e-06
-1.568826149780889 7.465564573100885e-06
-1.5688261497808893 1.1294699406716115e-05
-9.531072441578188e-06
-9.029352894164351e-06
-6.638714837753468e-07
-3.434970287121717e-07
-2.3295321824632735e-07
-1.7473775267662838e-07
-1.3980186226361852e-07
-1.1814683940092121e-07
-1.0107006604802288e-07
-8.830647666010754e-08
-7.840517291131443e-08
-7.050040059599996e-08
-6.502451715667858e-08
-5.949242875318935e-08
-5.482785404839911e-08
-5.084156938239324e-08
-4.739565310953921e-08
-4.438720300708711e-08
-4.173788500471495e-08
-3.938701401832461e-08
-3.728684848702912e-08
-3.5399314152578386e-08
-3.369367501128906e-08
-3.2144846652415486e-08
-3.12273725852156e-08
-2.9892497401287e-08
-2.8667068265123043e-08
-2.7538155008915417e-08
-2.649478709340423e-08
-2.5527595920466255e-08
-2.4628532732158724e-08
-2.379064409511465e-08
-2.3007891707426663e-08
-2.2275006644993045e-08
-2.1587370605087434e-08
-2.0940918487862455e-08
-2.0332057972881716e-08
-1.9757602729417667e-08
-1.9214716638134448e-08
-1.8700866962817094e-08
-1.8213784840332782e-08
-1.7751431788401267e-08
-1.7311971188305655e-08
-1.6893743901229506e-08
-1.6495247335670358e-08
-1.6115117409216006e-08
-1.5752112948294165e-08
-1.5405102149939417e-08
-1.507305079445127e-08
-1.475501195033521e-08
-1.4450116955670315e-08
-1.439132580762094e-08
-1.4101128118271934e-08
-1.3822402671414702e-08
-1.3554482361870658e-08
-1.3296750823509475e-08
-1.304863769533375e-08
-1.2809614407860563e-08
-1.2579190424284052e-08
-1.2356909880165096e-08
-1.21423485732082e-08
-1.193511126129987e-08
-1.1734829232597832e-08
-1.1541158116241175e-08
-1.1353775906334322e-08
-1.1172381175352701e-08
-1.0996691456118939e-08
-1.0826441774080824e-08
-1.0661383313850529e-08
-1.0501282205891655e-08
-1.0345918420911077e-08
-1.019508476096382e-08
-1.0048585937542965e-08
-9.906237728028655e-09
-9.767866202834677e-09
-9.633307016435096e-09
```python
import matplotlib.pyplot as plt
plt.plot(np.arange(Nt)*dt, np.array(masses)*Msun/Mearth, 'k-', label='total')
plt.plot(np.arange(Nt)*dt, np.array(mcs)*Msun/Mearth, 'g:', label='core')
plt.plot(np.arange(Nt)*dt, np.array(mgs)*Msun/Mearth, 'b-.', label='gas')
plt.plot(np.arange(Nt)*dt, np.array(mco_g)*Msun/Mearth, 'c--', label='CO gas')
plt.plot(np.arange(Nt)*dt, np.array(mco_d)*Msun/Mearth, 'm--', label='CO dust')
plt.yscale('log')
plt.xlabel("time [yr]")
plt.ylabel("mass [M_Earth]")
plt.legend()
plt.show()
```
```python
plt.plot(np.arange(Nt)*dt, (np.array(rr))/Rau, 'k-', label='total')
```
[<matplotlib.lines.Line2D at 0x7f0293d0d0a0>]
```python
```
```python
```
|
miostaREPO_NAMEdrift_compositionPATH_START.@drift_composition_extracted@drift_composition-main@examples@basic_growth.ipynb@.PATH_END.py
|
{
"filename": "targets.py",
"repo_name": "ML4GW/aframe",
"repo_path": "aframe_extracted/aframe-main/aframe/targets.py",
"type": "Python"
}
|
from typing import Literal
import luigi
from luigi.contrib.s3 import S3Target
from luigi.format import BaseWrapper, WrappedFormat
from aframe.config import s3
from aframe.parameters import PATH_LIKE
# format for writing h5 files to s3
# via bytes streams
class BytesFormat(WrappedFormat):
input = "bytes"
output = "bytes"
wrapper_cls = BaseWrapper
Bytes = BytesFormat()
# law targets are currently not
# passing format correctly so do this for now
class LawS3Target(S3Target):
optional = False
def complete(self):
return self.exists()
class LawLocalTarget(luigi.LocalTarget):
optional = False
def complete(self):
return self.exists()
# use s3 if path starts with s3://,
# otherwise use a local target
def s3_or_local(path: PATH_LIKE, format: Literal["hdf5", "txt"] = "hdf5"):
format = Bytes if format == "hdf5" else None
path = str(path)
if path.startswith("s3://"):
return LawS3Target(
path,
client=s3().client,
ContentType="application/octet-stream",
format=format,
)
else:
return LawLocalTarget(path, format=format)
|
ML4GWREPO_NAMEaframePATH_START.@aframe_extracted@aframe-main@aframe@targets.py@.PATH_END.py
|
{
"filename": "prop_savestate.py",
"repo_name": "ajeldorado/falco-python",
"repo_path": "falco-python_extracted/falco-python-master/falco/proper/prop_savestate.py",
"type": "Python"
}
|
# Copyright 2016, 2017 California Institute of Technology
# Users must agree to abide by the restrictions listed in the
# file "LegalStuff.txt" in the PROPER library directory.
#
# PROPER developed at Jet Propulsion Laboratory/California Inst. Technology
# Original IDL version by John Krist
# Python translation by Navtej Saini, with Luis Marchen and Nikta Amiri
import falco.proper as proper
import numpy as np
def prop_savestate(wf):
"""Write out the current wavefront state to a file for the current wavelength.
Parameters
----------
wf : obj
WaveFront class object
Returns
-------
None
"""
if proper.save_state == False:
return
statefile_lam = str(int(wf.lamda*1.e15)).strip() + proper.statefile
np.savez(statefile_lam, total_original_pupil = proper.total_original_pupil, wf = wf)
proper.save_state_lam.append(wf.lamda)
return
|
ajeldoradoREPO_NAMEfalco-pythonPATH_START.@falco-python_extracted@falco-python-master@falco@proper@prop_savestate.py@.PATH_END.py
|
{
"filename": "distribution.py",
"repo_name": "pymc-devs/pymc",
"repo_path": "pymc_extracted/pymc-main/pymc/distributions/distribution.py",
"type": "Python"
}
|
# Copyright 2024 The PyMC Developers
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import contextvars
import functools
import re
import sys
import types
import warnings
from abc import ABCMeta
from collections.abc import Callable, Sequence
from functools import singledispatch
from typing import Any, TypeAlias
import numpy as np
from pytensor import tensor as pt
from pytensor.compile.builders import OpFromGraph
from pytensor.graph import FunctionGraph, clone_replace, node_rewriter
from pytensor.graph.basic import Apply, Variable
from pytensor.graph.rewriting.basic import in2out
from pytensor.graph.utils import MetaType
from pytensor.tensor.basic import as_tensor_variable
from pytensor.tensor.random.op import RandomVariable
from pytensor.tensor.random.rewriting import local_subtensor_rv_lift
from pytensor.tensor.random.utils import normalize_size_param
from pytensor.tensor.rewriting.shape import ShapeFeature
from pytensor.tensor.utils import _parse_gufunc_signature
from pytensor.tensor.variable import TensorVariable
from pymc.distributions.shape_utils import (
Dims,
Shape,
_change_dist_size,
convert_dims,
convert_shape,
convert_size,
find_size,
rv_size_is_none,
shape_from_dims,
)
from pymc.logprob.abstract import MeasurableOp, _icdf, _logcdf, _logprob
from pymc.logprob.basic import logp
from pymc.logprob.rewriting import logprob_rewrites_db
from pymc.printing import str_for_dist
from pymc.pytensorf import (
collect_default_updates_inner_fgraph,
constant_fold,
convert_observed_data,
floatX,
)
from pymc.util import UNSET, _add_future_warning_tag
from pymc.vartypes import continuous_types, string_types
__all__ = [
"Continuous",
"DiracDelta",
"Discrete",
"Distribution",
"SymbolicRandomVariable",
]
DIST_PARAMETER_TYPES: TypeAlias = np.ndarray | int | float | TensorVariable
vectorized_ppc: contextvars.ContextVar[Callable | None] = contextvars.ContextVar(
"vectorized_ppc", default=None
)
PLATFORM = sys.platform
class _Unpickling:
pass
class DistributionMeta(ABCMeta):
"""
DistributionMeta class.
Notes
-----
DistributionMeta currently performs many functions, and will likely be refactored soon.
See issue below for more details
https://github.com/pymc-devs/pymc/issues/5308
"""
def __new__(cls, name, bases, clsdict):
rv_op = clsdict.setdefault("rv_op", None)
rv_type = clsdict.setdefault("rv_type", None)
if isinstance(rv_op, RandomVariable):
if rv_type is not None:
assert isinstance(rv_op, rv_type)
else:
rv_type = type(rv_op)
clsdict["rv_type"] = rv_type
new_cls = super().__new__(cls, name, bases, clsdict)
if rv_type is not None:
# Create dispatch functions
size_idx: int | None = None
params_idxs: tuple[int] | None = None
if issubclass(rv_type, SymbolicRandomVariable):
extended_signature = getattr(rv_type, "extended_signature", None)
if extended_signature is not None:
[_, size_idx, params_idxs], _ = (
SymbolicRandomVariable.get_input_output_type_idxs(extended_signature)
)
class_change_dist_size = clsdict.get("change_dist_size")
if class_change_dist_size:
@_change_dist_size.register(rv_type)
def change_dist_size(op, rv, new_size, expand):
return class_change_dist_size(rv, new_size, expand)
class_logp = clsdict.get("logp")
if class_logp:
@_logprob.register(rv_type)
def logp(op, values, *dist_params, **kwargs):
if isinstance(op, RandomVariable):
rng, size, *dist_params = dist_params
elif params_idxs:
dist_params = [dist_params[i] for i in params_idxs]
[value] = values
return class_logp(value, *dist_params)
class_logcdf = clsdict.get("logcdf")
if class_logcdf:
@_logcdf.register(rv_type)
def logcdf(op, value, *dist_params, **kwargs):
if isinstance(op, RandomVariable):
rng, size, *dist_params = dist_params
elif params_idxs:
dist_params = [dist_params[i] for i in params_idxs]
return class_logcdf(value, *dist_params)
class_icdf = clsdict.get("icdf")
if class_icdf:
@_icdf.register(rv_type)
def icdf(op, value, *dist_params, **kwargs):
if isinstance(op, RandomVariable):
rng, size, *dist_params = dist_params
elif params_idxs:
dist_params = [dist_params[i] for i in params_idxs]
return class_icdf(value, *dist_params)
class_moment = clsdict.get("moment")
if class_moment:
warnings.warn(
"The moment() method is deprecated. Use support_point() instead.",
DeprecationWarning,
)
clsdict["support_point"] = class_moment
class_support_point = clsdict.get("support_point")
if class_support_point:
@_support_point.register(rv_type)
def support_point(op, rv, *dist_params):
if isinstance(op, RandomVariable):
rng, size, *dist_params = dist_params
return class_support_point(rv, size, *dist_params)
elif params_idxs and size_idx is not None:
size = dist_params[size_idx]
dist_params = [dist_params[i] for i in params_idxs]
return class_support_point(rv, size, *dist_params)
else:
return class_support_point(rv, *dist_params)
# Register the PyTensor rv_type as a subclass of this PyMC Distribution type.
new_cls.register(rv_type)
return new_cls
class _class_or_instancemethod(classmethod):
"""Allow a method to be called both as a classmethod and an instancemethod.
Priority is given to the instancemethod.
This is used to allow extracting information from the signature of a SymbolicRandomVariable
which may be provided either as a class attribute or as an instance attribute.
Adapted from https://stackoverflow.com/a/28238047
"""
def __get__(self, instance, type_):
descr_get = super().__get__ if instance is None else self.__func__.__get__
return descr_get(instance, type_)
class SymbolicRandomVariable(MeasurableOp, OpFromGraph):
"""Symbolic Random Variable.
This is a subclasse of `OpFromGraph` which is used to encapsulate the symbolic
random graph of complex distributions which are built on top of pure
`RandomVariable`s.
These graphs may vary structurally based on the inputs (e.g., their dimensionality),
and usually require that random inputs have specific shapes for correct outputs
(e.g., avoiding broadcasting of random inputs). Due to this, most distributions that
return SymbolicRandomVariable create their these graphs at runtime via the
classmethod `cls.rv_op`, taking care to clone and resize random inputs, if needed.
"""
extended_signature: str = None
"""Numpy-like vectorized signature of the distribution.
It allows tokens [rng], [size] to identify the special inputs.
The signature of a Normal RV with mu and scale scalar params looks like
`"[rng],[size],(),()->[rng],()"`
"""
inline_logprob: bool = False
"""Specifies whether the logprob function is derived automatically by introspection
of the inner graph.
If `False`, a logprob function must be dispatched directly to the subclass type.
"""
_print_name: tuple[str, str] = ("Unknown", "\\operatorname{Unknown}")
"""Tuple of (name, latex name) used for for pretty-printing variables of this type"""
@_class_or_instancemethod
@property
def signature(cls_or_self) -> None | str:
# Convert "expanded" signature into "vanilla" signature that has no rng and size tokens
extended_signature = cls_or_self.extended_signature
if extended_signature is None:
return None
# Remove special tokens
special_tokens = r"|".join((r"\[rng\],?", r"\[size\],?"))
signature = re.sub(special_tokens, "", extended_signature)
# Remove dandling commas
signature = re.sub(r",(?=[->])|,$", "", signature)
return signature
@_class_or_instancemethod
@property
def ndims_params(cls_or_self) -> Sequence[int] | None:
"""Number of core dimensions of the distribution's parameters."""
signature = cls_or_self.signature
if signature is None:
return None
inputs_signature, _ = _parse_gufunc_signature(signature)
return [len(sig) for sig in inputs_signature]
@_class_or_instancemethod
@property
def ndim_supp(cls_or_self) -> int | None:
"""Number of support dimensions of the RandomVariable.
(0 for scalar, 1 for vector, ...)
"""
signature = cls_or_self.signature
if signature is None:
return None
_, outputs_params_signature = _parse_gufunc_signature(signature)
return max(len(out_sig) for out_sig in outputs_params_signature)
@_class_or_instancemethod
def _parse_extended_signature(cls_or_self) -> tuple[tuple[str, ...], tuple[str, ...]] | None:
extended_signature = cls_or_self.extended_signature
if extended_signature is None:
return None
fake_signature = extended_signature.replace("[rng]", "(rng)").replace("[size]", "(size)")
return _parse_gufunc_signature(fake_signature)
@_class_or_instancemethod
@property
def default_output(cls_or_self) -> int | None:
extended_signature = cls_or_self.extended_signature
if extended_signature is None:
return None
_, [_, candidate_default_output] = cls_or_self.get_input_output_type_idxs(
extended_signature
)
if len(candidate_default_output) == 1:
return candidate_default_output[0]
else:
return None
@staticmethod
def get_input_output_type_idxs(
extended_signature: str | None,
) -> tuple[tuple[tuple[int], int | None, tuple[int]], tuple[tuple[int], tuple[int]]]:
"""Parse extended_signature and return indexes for *[rng], [size] and parameters as well as outputs."""
if extended_signature is None:
raise ValueError("extended_signature must be provided")
fake_signature = extended_signature.replace("[rng]", "(rng)").replace("[size]", "(size)")
inputs_signature, outputs_signature = _parse_gufunc_signature(fake_signature)
input_rng_idxs = []
size_idx = None
input_params_idxs = []
for i, inp_sig in enumerate(inputs_signature):
if inp_sig == ("size",):
size_idx = i
elif inp_sig == ("rng",):
input_rng_idxs.append(i)
else:
input_params_idxs.append(i)
output_rng_idxs = []
output_params_idxs = []
for i, out_sig in enumerate(outputs_signature):
if out_sig == ("rng",):
output_rng_idxs.append(i)
else:
output_params_idxs.append(i)
return (
(tuple(input_rng_idxs), size_idx, tuple(input_params_idxs)),
(tuple(output_rng_idxs), tuple(output_params_idxs)),
)
def rng_params(self, node) -> tuple[Variable, ...]:
"""Extract the rng parameters from the node's inputs."""
[rng_args_idxs, _, _], _ = self.get_input_output_type_idxs(self.extended_signature)
return tuple(node.inputs[i] for i in rng_args_idxs)
def size_param(self, node) -> Variable | None:
"""Extract the size parameter from the node's inputs."""
[_, size_arg_idx, _], _ = self.get_input_output_type_idxs(self.extended_signature)
return node.inputs[size_arg_idx] if size_arg_idx is not None else None
def dist_params(self, node) -> tuple[Variable, ...]:
"""Extract distribution parameters from the node's inputs."""
[_, _, param_args_idxs], _ = self.get_input_output_type_idxs(self.extended_signature)
return tuple(node.inputs[i] for i in param_args_idxs)
def __init__(
self,
*args,
extended_signature: str | None = None,
**kwargs,
):
"""Initialize a SymbolicRandomVariable class."""
if extended_signature is not None:
self.extended_signature = extended_signature
if "signature" in kwargs:
self.extended_signature = kwargs.pop("signature")
warnings.warn(
"SymbolicRandomVariables signature argument was renamed to extended_signature."
)
if "ndim_supp" in kwargs:
# For backwards compatibility we allow passing ndim_supp without signature
# This is the only variable that PyMC absolutely needs to work with SymbolicRandomVariables
self.ndim_supp = kwargs.pop("ndim_supp")
if self.ndim_supp is None:
raise ValueError("ndim_supp or signature must be provided")
kwargs.setdefault("inline", True)
kwargs.setdefault("strict", True)
super().__init__(*args, **kwargs)
def update(self, node: Apply) -> dict[Variable, Variable]:
"""Symbolic update expression for input random state variables.
Returns a dictionary with the symbolic expressions required for correct updating
of random state input variables repeated function evaluations. This is used by
`pytensorf.compile_pymc`.
"""
return collect_default_updates_inner_fgraph(node)
def batch_ndim(self, node: Apply) -> int:
"""Return the number of dimensions of the distribution's batch shape."""
out_ndim = max(getattr(out.type, "ndim", 0) for out in node.outputs)
return out_ndim - self.ndim_supp
@_change_dist_size.register(SymbolicRandomVariable)
def change_symbolic_rv_size(op: SymbolicRandomVariable, rv, new_size, expand) -> TensorVariable:
extended_signature = op.extended_signature
if extended_signature is None:
raise NotImplementedError(
f"SymbolicRandomVariable {op} without signature requires custom `_change_dist_size` implementation."
)
size = op.size_param(rv.owner)
if size is None:
raise NotImplementedError(
f"SymbolicRandomVariable {op} without [size] in extended_signature requires custom `_change_dist_size` implementation."
)
params = op.dist_params(rv.owner)
if expand:
new_size = tuple(new_size) + tuple(size)
return op.rv_op(*params, size=new_size)
class Distribution(metaclass=DistributionMeta):
"""Statistical distribution."""
# rv_op and _type are set to None via the DistributionMeta.__new__
# if not specified as class attributes in subclasses of Distribution.
# rv_op can either be a class (see the Normal class) or a method
# (see the Censored class), both callable to return a TensorVariable.
rv_op: Any = None
rv_type: MetaType | None = None
def __new__(
cls,
name: str,
*args,
rng=None,
dims: Dims | None = None,
initval=None,
observed=None,
total_size=None,
transform=UNSET,
default_transform=UNSET,
**kwargs,
) -> TensorVariable:
"""Add a tensor variable corresponding to a PyMC distribution to the current model.
Note that all remaining kwargs must be compatible with ``.dist()``
Parameters
----------
cls : type
A PyMC distribution.
name : str
Name for the new model variable.
rng : optional
Random number generator to use with the RandomVariable.
dims : tuple, optional
A tuple of dimension names known to the model. When shape is not provided,
the shape of dims is used to define the shape of the variable.
initval : optional
Numeric or symbolic untransformed initial value of matching shape,
or one of the following initial value strategies: "support_point", "prior".
Depending on the sampler's settings, a random jitter may be added to numeric, symbolic
or support_point-based initial values in the transformed space.
observed : optional
Observed data to be passed when registering the random variable in the model.
When neither shape nor dims is provided, the shape of observed is used to
define the shape of the variable.
See ``Model.register_rv``.
total_size : float, optional
See ``Model.register_rv``.
transform : optional
See ``Model.register_rv``.
**kwargs
Keyword arguments that will be forwarded to ``.dist()`` or the PyTensor RV Op.
Most prominently: ``shape`` for ``.dist()`` or ``dtype`` for the Op.
Returns
-------
rv : TensorVariable
The created random variable tensor, registered in the Model.
"""
try:
from pymc.model import Model
model = Model.get_context()
except TypeError:
raise TypeError(
"No model on context stack, which is needed to "
"instantiate distributions. Add variable inside "
"a 'with model:' block, or use the '.dist' syntax "
"for a standalone distribution."
)
if not isinstance(name, string_types):
raise TypeError(f"Name needs to be a string but got: {name}")
dims = convert_dims(dims)
if observed is not None:
observed = convert_observed_data(observed)
# Preference is given to size or shape. If not specified, we rely on dims and
# finally, observed, to determine the shape of the variable.
if kwargs.get("size") is None and kwargs.get("shape") is None:
if dims is not None:
kwargs["shape"] = shape_from_dims(dims, model)
elif observed is not None:
kwargs["shape"] = tuple(observed.shape)
rv_out = cls.dist(*args, **kwargs)
rv_out = model.register_rv(
rv_out,
name,
observed=observed,
total_size=total_size,
dims=dims,
transform=transform,
default_transform=default_transform,
initval=initval,
)
# add in pretty-printing support
rv_out.str_repr = types.MethodType(str_for_dist, rv_out)
rv_out._repr_latex_ = types.MethodType(
functools.partial(str_for_dist, formatting="latex"), rv_out
)
return rv_out
@classmethod
def dist(
cls,
dist_params,
*,
shape: Shape | None = None,
**kwargs,
) -> TensorVariable:
"""Create a tensor variable corresponding to the `cls` distribution.
Parameters
----------
dist_params : array-like
The inputs to the `RandomVariable` `Op`.
shape : int, tuple, Variable, optional
A tuple of sizes for each dimension of the new RV.
**kwargs
Keyword arguments that will be forwarded to the PyTensor RV Op.
Most prominently: ``size`` or ``dtype``.
Returns
-------
rv : TensorVariable
The created random variable tensor.
"""
if "initval" in kwargs:
raise TypeError(
"Unexpected keyword argument `initval`. "
"This argument is not available for the `.dist()` API."
)
if "dims" in kwargs:
raise NotImplementedError("The use of a `.dist(dims=...)` API is not supported.")
size = kwargs.pop("size", None)
if shape is not None and size is not None:
raise ValueError(
f"Passing both `shape` ({shape}) and `size` ({size}) is not supported!"
)
shape = convert_shape(shape)
size = convert_size(size)
# `ndim_supp` may be available at the class level or at the instance level
ndim_supp = getattr(cls.rv_op, "ndim_supp", getattr(cls.rv_type, "ndim_supp", None))
if ndim_supp is None:
# Initialize Ops and check the ndim_supp that is now required to exist
ndim_supp = cls.rv_op(*dist_params, **kwargs).owner.op.ndim_supp
create_size = find_size(shape=shape, size=size, ndim_supp=ndim_supp)
rv_out = cls.rv_op(*dist_params, size=create_size, **kwargs)
_add_future_warning_tag(rv_out)
return rv_out
@node_rewriter([SymbolicRandomVariable])
def inline_symbolic_random_variable(fgraph, node):
"""Expand a SymbolicRV when obtaining the logp graph if `inline_logprob` is True."""
op = node.op
if op.inline_logprob:
return clone_replace(op.inner_outputs, dict(zip(op.inner_inputs, node.inputs)))
# Registered before pre-canonicalization which happens at position=-10
logprob_rewrites_db.register(
"inline_SymbolicRandomVariable",
in2out(inline_symbolic_random_variable),
"basic",
position=-20,
)
@singledispatch
def _support_point(op, rv, *rv_inputs) -> TensorVariable:
raise NotImplementedError(f"Variable {rv} of type {op} has no support_point implementation.")
def support_point(rv: TensorVariable) -> TensorVariable:
"""Choose a representative point/value that can be used to start optimization or MCMC sampling.
The only parameter to this function is the RandomVariable
for which the value is to be derived.
"""
return _support_point(rv.owner.op, rv, *rv.owner.inputs).astype(rv.dtype)
def _moment(op, rv, *rv_inputs) -> TensorVariable:
warnings.warn(
"The moment() method is deprecated. Use support_point() instead.",
DeprecationWarning,
)
return _support_point(op, rv, *rv_inputs)
def moment(rv: TensorVariable) -> TensorVariable:
warnings.warn(
"The moment() method is deprecated. Use support_point() instead.",
DeprecationWarning,
)
return support_point(rv)
class Discrete(Distribution):
"""Base class for discrete distributions."""
def __new__(cls, name, *args, **kwargs):
if kwargs.get("transform", None):
raise ValueError("Transformations for discrete distributions")
return super().__new__(cls, name, *args, **kwargs)
class Continuous(Distribution):
"""Base class for continuous distributions."""
class DiracDeltaRV(SymbolicRandomVariable):
name = "diracdelta"
extended_signature = "[size],()->()"
_print_name = ("DiracDelta", "\\operatorname{DiracDelta}")
def do_constant_folding(self, fgraph: "FunctionGraph", node: Apply) -> bool:
# Because the distribution does not have RNGs we have to prevent constant-folding
return False
@classmethod
def rv_op(cls, c, *, size=None, rng=None):
size = normalize_size_param(size)
c = pt.as_tensor(c)
if rv_size_is_none(size):
out = c.copy()
else:
out = pt.full(size, c)
return cls(inputs=[size, c], outputs=[out])(size, c)
class DiracDelta(Discrete):
r"""
DiracDelta log-likelihood.
Parameters
----------
c : tensor_like of float or int
Dirac Delta parameter. The dtype of `c` determines the dtype of the distribution.
This can affect which sampler is assigned to DiracDelta variables, or variables
that use DiracDelta, such as Mixtures.
"""
rv_type = DiracDeltaRV
rv_op = DiracDeltaRV.rv_op
@classmethod
def dist(cls, c, *args, **kwargs):
c = pt.as_tensor_variable(c)
if c.dtype in continuous_types:
c = floatX(c)
return super().dist([c], **kwargs)
def support_point(rv, size, c):
if not rv_size_is_none(size):
c = pt.full(size, c)
return c
def logp(value, c):
return pt.switch(
pt.eq(value, c),
pt.zeros_like(value),
-np.inf,
)
def logcdf(value, c):
return pt.switch(
pt.lt(value, c),
-np.inf,
0,
)
class PartialObservedRV(SymbolicRandomVariable):
"""RandomVariable with partially observed subspace, as indicated by a boolean mask.
See `create_partial_observed_rv` for more details.
"""
def create_partial_observed_rv(
rv: TensorVariable,
mask: np.ndarray | TensorVariable,
) -> tuple[
tuple[TensorVariable, TensorVariable], tuple[TensorVariable, TensorVariable], TensorVariable
]:
"""Separate observed and unobserved components of a RandomVariable.
This function may return two independent RandomVariables or, if not possible,
two variables from a common `PartialObservedRV` node
Parameters
----------
rv : TensorVariable
mask : tensor_like
Constant or variable boolean mask. True entries correspond to components of the variable that are not observed.
Returns
-------
observed_rv and mask : Tuple of TensorVariable
The observed component of the RV and respective indexing mask
unobserved_rv and mask : Tuple of TensorVariable
The unobserved component of the RV and respective indexing mask
joined_rv : TensorVariable
The symbolic join of the observed and unobserved components.
"""
if not mask.dtype == "bool":
raise ValueError(
f"mask must be an array or tensor of boolean dtype, got dtype: {mask.dtype}"
)
if mask.ndim > rv.ndim:
raise ValueError(f"mask can't have more dims than rv, got ndim: {mask.ndim}")
antimask = ~mask
can_rewrite = False
# Only pure RVs can be rewritten
if isinstance(rv.owner.op, RandomVariable):
ndim_supp = rv.owner.op.ndim_supp
# All univariate RVs can be rewritten
if ndim_supp == 0:
can_rewrite = True
# Multivariate RVs can be rewritten if masking does not split within support dimensions
else:
batch_dims = rv.type.ndim - ndim_supp
constant_mask = getattr(as_tensor_variable(mask), "data", None)
# Indexing does not overlap with core dimensions
if mask.ndim <= batch_dims:
can_rewrite = True
# Try to handle special case where mask is constant across support dimensions,
# TODO: This could be done by the rewrite itself
elif constant_mask is not None:
# We check if a constant_mask that only keeps the first entry of each support dim
# is equivalent to the original one after re-expanding.
trimmed_mask = constant_mask[(...,) + (0,) * ndim_supp]
expanded_mask = np.broadcast_to(
np.expand_dims(trimmed_mask, axis=tuple(range(-ndim_supp, 0))),
shape=constant_mask.shape,
)
if np.array_equal(constant_mask, expanded_mask):
mask = trimmed_mask
antimask = ~trimmed_mask
can_rewrite = True
if can_rewrite:
masked_rv = rv[mask]
fgraph = FunctionGraph(outputs=[masked_rv], clone=False, features=[ShapeFeature()])
unobserved_rv = local_subtensor_rv_lift.transform(fgraph, masked_rv.owner)[masked_rv]
antimasked_rv = rv[antimask]
fgraph = FunctionGraph(outputs=[antimasked_rv], clone=False, features=[ShapeFeature()])
observed_rv = local_subtensor_rv_lift.transform(fgraph, antimasked_rv.owner)[antimasked_rv]
# Make a clone of the observedRV, with a distinct rng so that observed and
# unobserved are never treated as equivalent (and mergeable) nodes by pytensor.
_, size, *inps = observed_rv.owner.inputs
observed_rv = observed_rv.owner.op(*inps, size=size)
# For all other cases use the more general PartialObservedRV
else:
# The symbolic graph simply splits the observed and unobserved components,
# so they can be given separate values.
dist_, mask_ = rv.type(), as_tensor_variable(mask).type()
observed_rv_, unobserved_rv_ = dist_[~mask_], dist_[mask_]
observed_rv, unobserved_rv = PartialObservedRV(
inputs=[dist_, mask_],
outputs=[observed_rv_, unobserved_rv_],
ndim_supp=rv.owner.op.ndim_supp,
)(rv, mask)
[rv_shape] = constant_fold([rv.shape], raise_not_constant=False)
joined_rv = pt.empty(rv_shape, dtype=rv.type.dtype)
joined_rv = pt.set_subtensor(joined_rv[mask], unobserved_rv)
joined_rv = pt.set_subtensor(joined_rv[antimask], observed_rv)
return (observed_rv, antimask), (unobserved_rv, mask), joined_rv
@_logprob.register(PartialObservedRV)
def partial_observed_rv_logprob(op, values, dist, mask, **kwargs):
# For the logp, simply join the values
[obs_value, unobs_value] = values
antimask = ~mask
# We don't need it to be completely folded, just to avoid any RVs in the graph of the shape
[folded_shape] = constant_fold([dist.shape], raise_not_constant=False)
joined_value = pt.empty(folded_shape)
joined_value = pt.set_subtensor(joined_value[mask], unobs_value)
joined_value = pt.set_subtensor(joined_value[antimask], obs_value)
joined_logp = logp(dist, joined_value)
# If we have a univariate RV we can split apart the logp terms
if op.ndim_supp == 0:
return joined_logp[antimask], joined_logp[mask]
# Otherwise, we can't (always/ easily) split apart logp terms.
# We return the full logp for the observed value, and a 0-nd array for the unobserved value
else:
return joined_logp.ravel(), pt.zeros((0,), dtype=joined_logp.type.dtype)
@_support_point.register(PartialObservedRV)
def partial_observed_rv_support_point(op, partial_obs_rv, rv, mask):
# Unobserved output
if partial_obs_rv.owner.outputs.index(partial_obs_rv) == 1:
return support_point(rv)[mask]
# Observed output
else:
return support_point(rv)[~mask]
|
pymc-devsREPO_NAMEpymcPATH_START.@pymc_extracted@pymc-main@pymc@distributions@distribution.py@.PATH_END.py
|
{
"filename": "_labelssrc.py",
"repo_name": "plotly/plotly.py",
"repo_path": "plotly.py_extracted/plotly.py-master/packages/python/plotly/plotly/validators/icicle/_labelssrc.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class LabelssrcValidator(_plotly_utils.basevalidators.SrcValidator):
def __init__(self, plotly_name="labelssrc", parent_name="icicle", **kwargs):
super(LabelssrcValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "none"),
**kwargs,
)
|
plotlyREPO_NAMEplotly.pyPATH_START.@plotly.py_extracted@plotly.py-master@packages@python@plotly@plotly@validators@icicle@_labelssrc.py@.PATH_END.py
|
{
"filename": "readSNdata.py",
"repo_name": "fforster/surveysim",
"repo_path": "surveysim_extracted/surveysim-master/readSNdata.py",
"type": "Python"
}
|
import re, os, sys
import numpy as np
import pandas as pd
from collections import defaultdict
from constants import *
def readSNdata(project, SNname, maxairmass = 1.7):
#########################
# Observational data
#########################
# make sure to return numpy arrays and not pandas data frames
#############################################################
# DES SNe
# -----------------------------
if project == 'DES':
DESdir = "%s/../LCs/DES" % (os.environ["SURVEYSIM_PATH"])
dirs = os.listdir(DESdir)
SNe = defaultdict(list)
zSNe = {}
# read data
for SN in dirs:
if SN[:3] == 'DES' and SN[-3:] != 'txt':
SNe[SN] = defaultdict(list)
# read redshift
info = open("%s/%s/%s.info" % (DESdir, SN, SN), 'r')
zcmb = float(re.findall("Zcmb:\s(.*)\n", info.read())[0])
zSNe[SN] = float(zcmb)
name = SN
# read photometry
for f in os.listdir("%s/%s" % (DESdir, SN)):
# extract band
band = f[-1]
# loop among allowed bands
if band in ['u', 'g', 'r', 'i', 'z']:
SNe[SN][band] = defaultdict(list)
# extract data
mjd, mag, e_mag = np.loadtxt("%s/%s/%s.out_DES%s" % (DESdir, SN, SN, band)).transpose()
SNe[SN][band]["MJD"] = mjd
SNe[SN][band]["mag"] = mag
SNe[SN][band]["e_mag"] = e_mag
#SNname = "DES15X2mku"
#SNname = "DES13C2jtx"
#SNname = "DES15S2eaq"
#SNname = "DES15X1lzp"
#SNname = "DES15E2avs"
for SN in SNe.keys():
if SN != SNname:
continue
zcmb = zSNe[SN]
fixz = True
for band in SNe[SN].keys():
mjd = SNe[SN][band]["MJD"]
mag = SNe[SN][band]["mag"]
e_mag = SNe[SN][band]["e_mag"]
#if SNname == "DES15X2mku":
# mask = (mjd > 57300) & (mjd < 57500)
#elif SNname == "DES13C2jtx":
# mask = (mjd > 56450) & (mjd < 56700)
#elif SNname == "DES15S2eaq":
# mask = (mjd > 57200) & (mjd < 57500)
#elif SNname == "DES15X1lzp":
# mask = (mjd > 57300) & (mjd < 57500)
if "mask" in locals():
mjd = mjd[mask]
mag = mag[mask]
e_mag = e_mag[mask]
flux = mag2flux(mag)
e_flux = mag2flux(mag + e_mag) - flux
filters = np.array(map(lambda i: band, mjd))
if "sn_mjd" not in locals():
sn_mjd = np.array(mjd, dtype = float)
sn_flux = flux
sn_e_flux = e_flux
sn_filters = filters
else:
sn_mjd = np.hstack([sn_mjd, mjd])
sn_flux = np.hstack([sn_flux, flux])
sn_e_flux = np.hstack([sn_e_flux, e_flux])
sn_filters = np.hstack([sn_filters, filters])
maskg = sn_filters == 'g'
texp0 = sn_mjd[maskg][1 + np.argmax(np.diff(np.abs(sn_flux[maskg])))]
#if np.argmax(sn_flux[maskg]) == 0:
# texp0 = sn_mjd[maskg][np.argmax(sn_flux[maskg])]
#if SNname == "DES15X2mku":
# texp0 = 57325
#elif SNname == "DES13C2jtx":
# texp0 = 56550
#elif SNname == "DES15S2eaq":
# texp0 = 57275
#elif SNname == "DES15X1lzp":
# texp0 = 57320
# HiTS SNe
# -----------------------------------------------------------------
elif project == "HiTS":
#SNname = "SNHiTS15A"
#SNname = "SNHiTS15P"
#SNname = "SNHiTS15D"
#SNname = "SNHiTS15aw"
#SNname = "SNHiTS15K"
#SNname = "SNHiTS14B"
#SNname = "SNHiTS15B"
#(MJDs, MJDrefs, airmass, ADUs, e_ADUs, mags, sn_filters) \
# = .loadtxt("../HiTS/LCs/%s.txt" % SNname, usecols = (0, 1, 2, 5, 6, 7, 10), dtype = str).transpose()
df = pd.read_table("%s/../LCs/HiTS/LCs/%s.dat" % (os.environ["SURVEYSIM_PATH"], SNname), sep = "\s+", comment = "#")
sn_mjd = np.array(df["MJD"])
sn_mjdref = np.array(df["MJDref"])
airmass = np.array(df["airmasssci"])
sn_adu = np.array(df["ADU"])
sn_e_adu = np.array(df["e_ADU"])
sn_mag = np.array(df["mag"])
sn_filters = np.array(df["band"], dtype = str)
sn_flux = np.array(sn_adu)
sn_e_flux = np.array(sn_e_adu)
mask = (airmass <= maxairmass)
sn_mjd = sn_mjd[mask]
sn_mjdref = sn_mjdref[mask]
sn_adu = sn_adu[mask]
sn_e_adu = sn_e_adu[mask]
sn_mag = sn_mag[mask]
sn_flux = sn_flux[mask]
sn_e_flux = sn_e_flux[mask]
sn_filters = np.array(sn_filters)[mask]
maskg = (sn_filters == 'g')
if np.sum(maskg) > 0:
idxmax = np.argmax(sn_adu[maskg])
factorg = mag2flux(sn_mag[maskg][idxmax]) / sn_adu[maskg][idxmax]
sn_flux[maskg] = sn_flux[maskg] * factorg
sn_e_flux[maskg] = sn_e_flux[maskg] * factorg
maskr = sn_filters == 'r'
if np.sum(maskr) > 0:
factorr = mag2flux(sn_mag[maskr][-1]) / sn_adu[maskr][-1]
sn_flux[maskr] = sn_flux[maskr] * factorr
sn_e_flux[maskr] = sn_e_flux[maskr] * factorr
#texp0 = 57077.
if SNname == "SNHiTS14B":
sn_mjdref = np.hstack([sn_mjdref, sn_mjdref[-1], sn_mjdref[-1]])
sn_mjd = np.hstack([sn_mjd, sn_mjd[0] + 9.01680793, sn_mjd[0] + 23.85])
sn_flux = np.hstack([sn_flux, mag2flux(22.34), mag2flux(22.9)])
sn_e_flux = np.hstack([sn_e_flux, sn_e_flux[-1], sn_e_flux[-1]])
sn_filters = np.hstack([sn_filters, 'g', 'g'])
elif SNname == "SNHiTS14Q":
sn_mjdref = np.hstack([sn_mjdref, sn_mjdref[-1]])
sn_mjd = np.hstack([sn_mjd, sn_mjdref[-1] + 23.996])
sn_flux = np.hstack([sn_flux, mag2flux(23.218)])
sn_e_flux = np.hstack([sn_e_flux, mag2flux(23.218 - 0.12) - mag2flux(23.218)])
sn_filters = np.hstack([sn_filters, 'g'])
mask = sn_filters == 'g'
texp0 = sn_mjd[mask][np.argmax(np.diff(sn_flux[mask]))]
texp0 = sn_mjd[mask][0] + 3.#np.argmax(np.diff(sn_flux[mask]))]
if SNname == "SNHiTS14A":
zcmb = 0.2175
fixz = True
elif SNname == "SNHiTS14Y":
zcmb = 0.108
fixz = True
elif SNname == "SNHiTS14C":
zcmb = 0.084
fixz = True
elif SNname == "SNHiTS14D":
zcmb = 0.135
fixz = True
elif SNname == "SNHiTS15B":
zcmb = 0.23
fixz = True
elif SNname == "SNHiTS15J":
zcmb = 0.108
fixz = True
elif SNname == "SNHiTS15L":
zcmb = 0.15
fixz = True
elif SNname == "SNHiTS15O":
zcmb = 0.142
fixz = True
elif SNname == "SNHiTS15U":
zcmb = 0.308
fixz = True
elif SNname == "SNHiTS15ad":
zcmb = 0.055392
fixz = True
elif SNname == "SNHiTS15al":
zcmb = 0.2
fixz = True
elif SNname == "SNHiTS15aw":
zcmb = 0.0663
fixz = True
elif SNname == "SNHiTS15aq":
zcmb = 0.11
fixz = True
elif SNname == "SNHiTS15be":
zcmb = 0.151
fixz = True
elif SNname == "SNHiTS15bs":
zcmb = 0.07
fixz = True
elif SNname == "SNHiTS15by":
zcmb = 0.0524
fixz = True
elif SNname == 'SNHiTS15ck':
zcmb = 0.042
fixz = True
else:
zcmb = 0.2
fixz = False
elif project == "PTF":
df = pd.read_table("%s/../LCs/PTF/LCs/%s.dat" % (os.environ["SURVEYSIM_PATH"], SNname), sep = "\s*\t\s*", comment = "#", engine = "python")
JD0 = float(re.findall('.*?=(\d+.\d+).*?', df.columns[0])[0])
MJDref = JD0 - 2400000.5 # in this case it is the explosion date minus 50 days
df = df.rename(columns = {df.columns[0]: "MJD"})
df["MJD"] = df["MJD"] + MJDref
#df = df[(df['family'] == 'PTF') | ((df["family"] == "SDSS") & (df["band"] == 'g'))]
df = df[(df["family"] == "SDSS") & ((df["band"] == 'g') | (df["band"] == 'r'))]
sn_mjd = np.array(df["MJD"])
sn_mjdref = np.array(MJDref * np.ones_like(sn_mjd)) - 1000. # assume reference was taken 1000 days into the past
sn_mag = np.array(df["mag"])
sn_e_mag = np.array(df["mag-err"])
sn_filters = np.array(df["band"], dtype = str)
sn_flux = mag2flux(sn_mag)
sn_e_flux = mag2flux(sn_mag) - mag2flux(sn_mag + sn_e_mag)
if SNname == "SN2013fs":
zcmb = 0.011855
fixz = True
texp0 = MJDref
elif project == "Kepler":
filename = "%s/../LCs/Kepler/%s.txt" % (os.environ["SURVEYSIM_PATH"], SNname)
# find reference magnitude
data = open(filename, 'r')
line1 = data.readline()
refmag = float(re.findall("flux.*(\d\d.\d\d)", line1)[0])
refflux = mag2flux(refmag)
print("Reference flux: %f" % refflux)
df = pd.read_table(filename, sep = "\s+", comment = "#")
sn_mjd = np.array(df["KJD"]) + 54832.5 # see Zheng 2016
sn_mjdref = sn_mjd[0] - 1000
texp0 = sn_mjd[0]
sn_flux = np.array(df.flux) * refflux # normalization to make SN appear close and make redshift correction negligible
sn_e_flux = np.ones_like(sn_flux) * np.std(sn_flux[sn_mjd < sn_mjd[0] + 20])
#sn_e_flux = np.array(df["LC_err"]) * 1e-25 # normalization to make SN appear close and make redshift correction negligible
sn_filters = np.array(list(map(lambda x: "Kepler", sn_flux)), dtype = str)
fixz = True
if SNname[:6] == 'ksn11a':
zcmb = 0.051
elif SNname[:6] == 'ksn11d':
zcmb = 0.087
elif project == "ROTSEIII":
df = pd.read_table("%s/../LCs/ROTSEIII/%s.txt" % (os.environ["SURVEYSIM_PATH"], SNname), sep = "\s+", comment = "#")
from datetime import datetime
from astropy.time import Time
import calendar
year = df.year
month = df.month
daysf = df.day
days = np.array(daysf, dtype = int)
hours = np.array(24. * (daysf - days), dtype = int)
minutes = np.array(60. * (24. * (daysf - days) - hours), dtype = int)
seconds = np.array(60. * (60. * (24. * (daysf - days) - hours) - minutes), dtype = int)
# dictionary to convert month to number
month2n = {}
for idx in range(1, 13):
month2n[calendar.month_abbr[idx]] = idx
sn_mjd = np.array(list(map(lambda yy, mm, dd, hh, mmm, ss: Time(datetime(yy, month2n[mm], dd, hh, mmm, ss), scale = "utc").mjd, year, month, days, hours, minutes, seconds)))
sn_mjdref = sn_mjd[0] - 1000.
texp0 = np.array(max(sn_mjd[df.date < 0])) # maximum MJD which has an explosion date less than zero
sn_maglim = df.maglim
sn_flux = mag2flux(df.mag)
mask = np.isnan(sn_flux)
sn_e_flux = mag2flux(df.mag - df.e_mag) - mag2flux(df.mag) # normalization to make SN appear close and make redshift correction negligible
# take into account non-detections
sn_flux[mask] = 0
sn_e_flux[mask] = mag2flux(sn_maglim[mask])
sn_filters = np.array(list(map(lambda x: "ROTSEIII", sn_flux)), dtype = str)
fixz = False
if SNname == "SN2006bp":
zcmb = 0.003510
#fixz = True
elif project == "PanSTARRS1":
df = pd.read_table("%s/../LCs/PanSTARRS1/%s.txt" % (os.environ["SURVEYSIM_PATH"], SNname), sep = "\s+", comment = "#")
mask = (df.band == 'u') | (df.band == 'g') | (df.band == 'r') | (df.band == 'i') | (df.band == 'z')
df = df[mask]
sn_mjd = np.array(df.MJD)
sn_mjdref = sn_mjd[0] - 1000.
texp0 = np.array(min(sn_mjd[np.array(df.phase) > 0])) # maximum MJD which has an explosion date less than zero
mask = np.isnan(df.e_mag)
nmask = np.invert(mask)
sn_mag = np.array(df.mag, dtype = float)
sn_e_mag = np.array(df.e_mag, dtype = float)
sn_flux = mag2flux(sn_mag)
sn_e_flux = np.zeros_like(sn_flux)
sn_e_flux[nmask] = mag2flux(sn_mag[nmask] - sn_e_mag[nmask]) - mag2flux(sn_mag[nmask]) # normalization to make SN appear close and make redshift correction negligible
sn_e_flux[mask] = sn_flux[mask]
sn_flux[mask] = 0
sn_filters = df.band
fixz = True
if SNname == "PS1-13arp":
zcmb = 0.1665
elif project == "Swift":
df = pd.read_table("%s/../LCs/Swift/%s.dat" % (os.environ["SURVEYSIM_PATH"], SNname), sep = "\s+", comment = "#")
# correct to AB magnitudes, see https://swift.gsfc.nasa.gov/analysis/uvot_digest/zeropts.html
Vega2AB = {"V": -0.01, "B": -0.13, "U": 1.02, "UVW1": 1.51, "UVM2": 1.69, "UVW2": 0.8}
for band in Vega2AB.keys():
df.Mag[df.Filter == band] += Vega2AB[band]
sn_mjd = np.array(df["MJD[days]"])
sn_mjdref = sn_mjd[0] - 1000
texp0 = sn_mjd[0]
sn_flux = np.array(mag2flux(df.Mag))
sn_e_flux = np.array(np.abs(mag2flux(df.Mag - df.MagErr) - mag2flux(df.Mag + df.MagErr)))
sn_filters = np.array(df.Filter, dtype = str)
mask = np.isfinite(sn_flux)
sn_mjd = sn_mjd[mask]
sn_flux = sn_flux[mask]
sn_e_flux = sn_e_flux[mask]
sn_filters = sn_filters[mask]
if SNname == "ASASSN-14jb":
df = pd.read_table("%s/../LCs/Swift/%s_ASASSN.dat" % (os.environ["SURVEYSIM_PATH"], SNname), sep = "\s+", comment = "#")
MJDextra = np.array(df.HJD - 2400000.5)
fluxextra = np.array(df["flux(mJy)"] * 1e-26) # 1 Jy = 1e-23 erg/s/cm2/Hz
e_fluxextra = np.array(df["flux_err"] * 1e-26)
filtersextra = np.array(list(map(lambda x: 'V', MJDextra)), dtype = str)
sn_mjd = np.hstack([sn_mjd, MJDextra])
sn_flux = np.hstack([sn_flux, fluxextra])
sn_e_flux = np.hstack([sn_e_flux, e_fluxextra])
sn_filters = np.hstack([sn_filters, filtersextra])
idx = np.argsort(sn_mjd)
sn_mjd = sn_mjd[idx]
sn_flux = sn_flux[idx]
sn_e_flux = sn_e_flux[idx]
sn_filters = sn_filters[idx]
fixz = True
if SNname == "ASASSN-14jb":
zcmb = 0.006031
else:
print("Define observations...")
sys.exit()
return sn_mjd, sn_mjdref, sn_flux, sn_e_flux, sn_filters, fixz, zcmb, texp0
if __name__ == "__main__":
project = sys.argv[1]
SNname = sys.argv[2]
print(readSNdata(project, SNname))
|
fforsterREPO_NAMEsurveysimPATH_START.@surveysim_extracted@surveysim-master@readSNdata.py@.PATH_END.py
|
{
"filename": "_hovertext.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/validators/box/_hovertext.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class HovertextValidator(_plotly_utils.basevalidators.StringValidator):
def __init__(self, plotly_name="hovertext", parent_name="box", **kwargs):
super(HovertextValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
array_ok=kwargs.pop("array_ok", True),
edit_type=kwargs.pop("edit_type", "style"),
role=kwargs.pop("role", "info"),
**kwargs
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@validators@box@_hovertext.py@.PATH_END.py
|
{
"filename": "test_logarithmic.py",
"repo_name": "waynebhayes/SpArcFiRe",
"repo_path": "SpArcFiRe_extracted/SpArcFiRe-master/scripts/SpArcFiRe-pyvenv/lib/python2.7/site-packages/astropy/units/tests/test_logarithmic.py",
"type": "Python"
}
|
# coding: utf-8
# Licensed under a 3-clause BSD style license - see LICENSE.rst
"""
Test the Logarithmic Units and Quantities
"""
from __future__ import (absolute_import, unicode_literals, division,
print_function)
from ...extern import six
from ...extern.six.moves import zip
import pickle
import itertools
import pytest
import numpy as np
from numpy.testing.utils import assert_allclose
from ...tests.helper import assert_quantity_allclose
from ... import units as u, constants as c
lu_units = [u.dex, u.mag, u.decibel]
lu_subclasses = [u.DexUnit, u.MagUnit, u.DecibelUnit]
lq_subclasses = [u.Dex, u.Magnitude, u.Decibel]
pu_sample = (u.dimensionless_unscaled, u.m, u.g/u.s**2, u.Jy)
class TestLogUnitCreation(object):
def test_logarithmic_units(self):
"""Check logarithmic units are set up correctly."""
assert u.dB.to(u.dex) == 0.1
assert u.dex.to(u.mag) == -2.5
assert u.mag.to(u.dB) == -4
@pytest.mark.parametrize('lu_unit, lu_cls', zip(lu_units, lu_subclasses))
def test_callable_units(self, lu_unit, lu_cls):
assert isinstance(lu_unit, u.UnitBase)
assert callable(lu_unit)
assert lu_unit._function_unit_class is lu_cls
@pytest.mark.parametrize('lu_unit', lu_units)
def test_equality_to_normal_unit_for_dimensionless(self, lu_unit):
lu = lu_unit()
assert lu == lu._default_function_unit # eg, MagUnit() == u.mag
assert lu._default_function_unit == lu # and u.mag == MagUnit()
@pytest.mark.parametrize('lu_unit, physical_unit',
itertools.product(lu_units, pu_sample))
def test_call_units(self, lu_unit, physical_unit):
"""Create a LogUnit subclass using the callable unit and physical unit,
and do basic check that output is right."""
lu1 = lu_unit(physical_unit)
assert lu1.physical_unit == physical_unit
assert lu1.function_unit == lu1._default_function_unit
def test_call_invalid_unit(self):
with pytest.raises(TypeError):
u.mag([])
with pytest.raises(ValueError):
u.mag(u.mag())
@pytest.mark.parametrize('lu_cls, physical_unit', itertools.product(
lu_subclasses + [u.LogUnit], pu_sample))
def test_subclass_creation(self, lu_cls, physical_unit):
"""Create a LogUnit subclass object for given physical unit,
and do basic check that output is right."""
lu1 = lu_cls(physical_unit)
assert lu1.physical_unit == physical_unit
assert lu1.function_unit == lu1._default_function_unit
lu2 = lu_cls(physical_unit,
function_unit=2*lu1._default_function_unit)
assert lu2.physical_unit == physical_unit
assert lu2.function_unit == u.Unit(2*lu2._default_function_unit)
with pytest.raises(ValueError):
lu_cls(physical_unit, u.m)
def test_predefined_magnitudes():
assert_quantity_allclose((-21.1*u.STmag).physical,
1.*u.erg/u.cm**2/u.s/u.AA)
assert_quantity_allclose((-48.6*u.ABmag).physical,
1.*u.erg/u.cm**2/u.s/u.Hz)
assert_quantity_allclose((0*u.M_bol).physical, c.L_bol0)
assert_quantity_allclose((0*u.m_bol).physical,
c.L_bol0/(4.*np.pi*(10.*c.pc)**2))
def test_predefined_reinitialisation():
assert u.mag('ST') == u.STmag
assert u.mag('AB') == u.ABmag
assert u.mag('Bol') == u.M_bol
assert u.mag('bol') == u.m_bol
def test_predefined_string_roundtrip():
"""Ensure roundtripping; see #5015"""
with u.magnitude_zero_points.enable():
assert u.Unit(u.STmag.to_string()) == u.STmag
assert u.Unit(u.ABmag.to_string()) == u.ABmag
assert u.Unit(u.M_bol.to_string()) == u.M_bol
assert u.Unit(u.m_bol.to_string()) == u.m_bol
def test_inequality():
"""Check __ne__ works (regresssion for #5342)."""
lu1 = u.mag(u.Jy)
lu2 = u.dex(u.Jy)
lu3 = u.mag(u.Jy**2)
lu4 = lu3 - lu1
assert lu1 != lu2
assert lu1 != lu3
assert lu1 == lu4
class TestLogUnitStrings(object):
def test_str(self):
"""Do some spot checks that str, repr, etc. work as expected."""
lu1 = u.mag(u.Jy)
assert str(lu1) == 'mag(Jy)'
assert repr(lu1) == 'Unit("mag(Jy)")'
assert lu1.to_string('generic') == 'mag(Jy)'
with pytest.raises(ValueError):
lu1.to_string('fits')
lu2 = u.dex()
assert str(lu2) == 'dex'
assert repr(lu2) == 'Unit("dex(1)")'
assert lu2.to_string() == 'dex(1)'
lu3 = u.MagUnit(u.Jy, function_unit=2*u.mag)
assert str(lu3) == '2 mag(Jy)'
assert repr(lu3) == 'MagUnit("Jy", unit="2 mag")'
assert lu3.to_string() == '2 mag(Jy)'
lu4 = u.mag(u.ct)
assert lu4.to_string('generic') == 'mag(ct)'
assert lu4.to_string('latex') == ('$\\mathrm{mag}$$\\mathrm{\\left( '
'\\mathrm{ct} \\right)}$')
assert lu4._repr_latex_() == lu4.to_string('latex')
class TestLogUnitConversion(object):
@pytest.mark.parametrize('lu_unit, physical_unit',
itertools.product(lu_units, pu_sample))
def test_physical_unit_conversion(self, lu_unit, physical_unit):
"""Check various LogUnit subclasses are equivalent and convertible
to their non-log counterparts."""
lu1 = lu_unit(physical_unit)
assert lu1.is_equivalent(physical_unit)
assert lu1.to(physical_unit, 0.) == 1.
assert physical_unit.is_equivalent(lu1)
assert physical_unit.to(lu1, 1.) == 0.
pu = u.Unit(8.*physical_unit)
assert lu1.is_equivalent(physical_unit)
assert lu1.to(pu, 0.) == 0.125
assert pu.is_equivalent(lu1)
assert_allclose(pu.to(lu1, 0.125), 0., atol=1.e-15)
# Check we round-trip.
value = np.linspace(0., 10., 6)
assert_allclose(pu.to(lu1, lu1.to(pu, value)), value, atol=1.e-15)
# And that we're not just returning True all the time.
pu2 = u.g
assert not lu1.is_equivalent(pu2)
with pytest.raises(u.UnitsError):
lu1.to(pu2)
assert not pu2.is_equivalent(lu1)
with pytest.raises(u.UnitsError):
pu2.to(lu1)
@pytest.mark.parametrize('lu_unit', lu_units)
def test_container_unit_conversion(self, lu_unit):
"""Check that conversion to logarithmic units (u.mag, u.dB, u.dex)
is only possible when the physical unit is dimensionless."""
values = np.linspace(0., 10., 6)
lu1 = lu_unit(u.dimensionless_unscaled)
assert lu1.is_equivalent(lu1.function_unit)
assert_allclose(lu1.to(lu1.function_unit, values), values)
lu2 = lu_unit(u.Jy)
assert not lu2.is_equivalent(lu2.function_unit)
with pytest.raises(u.UnitsError):
lu2.to(lu2.function_unit, values)
@pytest.mark.parametrize(
'flu_unit, tlu_unit, physical_unit',
itertools.product(lu_units, lu_units, pu_sample))
def test_subclass_conversion(self, flu_unit, tlu_unit, physical_unit):
"""Check various LogUnit subclasses are equivalent and convertible
to each other if they correspond to equivalent physical units."""
values = np.linspace(0., 10., 6)
flu = flu_unit(physical_unit)
tlu = tlu_unit(physical_unit)
assert flu.is_equivalent(tlu)
assert_allclose(flu.to(tlu), flu.function_unit.to(tlu.function_unit))
assert_allclose(flu.to(tlu, values),
values * flu.function_unit.to(tlu.function_unit))
tlu2 = tlu_unit(u.Unit(100.*physical_unit))
assert flu.is_equivalent(tlu2)
# Check that we round-trip.
assert_allclose(flu.to(tlu2, tlu2.to(flu, values)), values, atol=1.e-15)
tlu3 = tlu_unit(physical_unit.to_system(u.si)[0])
assert flu.is_equivalent(tlu3)
assert_allclose(flu.to(tlu3, tlu3.to(flu, values)), values, atol=1.e-15)
tlu4 = tlu_unit(u.g)
assert not flu.is_equivalent(tlu4)
with pytest.raises(u.UnitsError):
flu.to(tlu4, values)
def test_unit_decomposition(self):
lu = u.mag(u.Jy)
assert lu.decompose() == u.mag(u.Jy.decompose())
assert lu.decompose().physical_unit.bases == [u.kg, u.s]
assert lu.si == u.mag(u.Jy.si)
assert lu.si.physical_unit.bases == [u.kg, u.s]
assert lu.cgs == u.mag(u.Jy.cgs)
assert lu.cgs.physical_unit.bases == [u.g, u.s]
def test_unit_multiple_possible_equivalencies(self):
lu = u.mag(u.Jy)
assert lu.is_equivalent(pu_sample)
class TestLogUnitArithmetic(object):
def test_multiplication_division(self):
"""Check that multiplication/division with other units is only
possible when the physical unit is dimensionless, and that this
turns the unit into a normal one."""
lu1 = u.mag(u.Jy)
with pytest.raises(u.UnitsError):
lu1 * u.m
with pytest.raises(u.UnitsError):
u.m * lu1
with pytest.raises(u.UnitsError):
lu1 / lu1
for unit in (u.dimensionless_unscaled, u.m, u.mag, u.dex):
with pytest.raises(u.UnitsError):
lu1 / unit
lu2 = u.mag(u.dimensionless_unscaled)
with pytest.raises(u.UnitsError):
lu2 * lu1
with pytest.raises(u.UnitsError):
lu2 / lu1
# But dimensionless_unscaled can be cancelled.
assert lu2 / lu2 == u.dimensionless_unscaled
# With dimensionless, normal units are OK, but we return a plain unit.
tf = lu2 * u.m
tr = u.m * lu2
for t in (tf, tr):
assert not isinstance(t, type(lu2))
assert t == lu2.function_unit * u.m
with u.set_enabled_equivalencies(u.logarithmic()):
with pytest.raises(u.UnitsError):
t.to(lu2.physical_unit)
# Now we essentially have a LogUnit with a prefactor of 100,
# so should be equivalent again.
t = tf / u.cm
with u.set_enabled_equivalencies(u.logarithmic()):
assert t.is_equivalent(lu2.function_unit)
assert_allclose(t.to(u.dimensionless_unscaled, np.arange(3.)/100.),
lu2.to(lu2.physical_unit, np.arange(3.)))
# If we effectively remove lu1, a normal unit should be returned.
t2 = tf / lu2
assert not isinstance(t2, type(lu2))
assert t2 == u.m
t3 = tf / lu2.function_unit
assert not isinstance(t3, type(lu2))
assert t3 == u.m
# For completeness, also ensure non-sensical operations fail
with pytest.raises(TypeError):
lu1 * object()
with pytest.raises(TypeError):
slice(None) * lu1
with pytest.raises(TypeError):
lu1 / []
with pytest.raises(TypeError):
1 / lu1
@pytest.mark.parametrize('power', (2, 0.5, 1, 0))
def test_raise_to_power(self, power):
"""Check that raising LogUnits to some power is only possible when the
physical unit is dimensionless, and that conversion is turned off when
the resulting logarithmic unit (such as mag**2) is incompatible."""
lu1 = u.mag(u.Jy)
if power == 0:
assert lu1 ** power == u.dimensionless_unscaled
elif power == 1:
assert lu1 ** power == lu1
else:
with pytest.raises(u.UnitsError):
lu1 ** power
# With dimensionless, though, it works, but returns a normal unit.
lu2 = u.mag(u.dimensionless_unscaled)
t = lu2**power
if power == 0:
assert t == u.dimensionless_unscaled
elif power == 1:
assert t == lu2
else:
assert not isinstance(t, type(lu2))
assert t == lu2.function_unit**power
# also check we roundtrip
t2 = t**(1./power)
assert t2 == lu2.function_unit
with u.set_enabled_equivalencies(u.logarithmic()):
assert_allclose(t2.to(u.dimensionless_unscaled, np.arange(3.)),
lu2.to(lu2.physical_unit, np.arange(3.)))
@pytest.mark.parametrize('other', pu_sample)
def test_addition_subtraction_to_normal_units_fails(self, other):
lu1 = u.mag(u.Jy)
with pytest.raises(u.UnitsError):
lu1 + other
with pytest.raises(u.UnitsError):
lu1 - other
with pytest.raises(u.UnitsError):
other - lu1
def test_addition_subtraction_to_non_units_fails(self):
lu1 = u.mag(u.Jy)
with pytest.raises(TypeError):
lu1 + 1.
with pytest.raises(TypeError):
lu1 - [1., 2., 3.]
@pytest.mark.parametrize(
'other', (u.mag, u.mag(), u.mag(u.Jy), u.mag(u.m),
u.Unit(2*u.mag), u.MagUnit('', 2.*u.mag)))
def test_addition_subtraction(self, other):
"""Check physical units are changed appropriately"""
lu1 = u.mag(u.Jy)
other_pu = getattr(other, 'physical_unit', u.dimensionless_unscaled)
lu_sf = lu1 + other
assert lu_sf.is_equivalent(lu1.physical_unit * other_pu)
lu_sr = other + lu1
assert lu_sr.is_equivalent(lu1.physical_unit * other_pu)
lu_df = lu1 - other
assert lu_df.is_equivalent(lu1.physical_unit / other_pu)
lu_dr = other - lu1
assert lu_dr.is_equivalent(other_pu / lu1.physical_unit)
def test_complicated_addition_subtraction(self):
"""for fun, a more complicated example of addition and subtraction"""
dm0 = u.Unit('DM', 1./(4.*np.pi*(10.*u.pc)**2))
lu_dm = u.mag(dm0)
lu_absST = u.STmag - lu_dm
assert lu_absST.is_equivalent(u.erg/u.s/u.AA)
def test_neg_pos(self):
lu1 = u.mag(u.Jy)
neg_lu = -lu1
assert neg_lu != lu1
assert neg_lu.physical_unit == u.Jy**-1
assert -neg_lu == lu1
pos_lu = +lu1
assert pos_lu is not lu1
assert pos_lu == lu1
def test_pickle():
lu1 = u.dex(u.cm/u.s**2)
s = pickle.dumps(lu1)
lu2 = pickle.loads(s)
assert lu1 == lu2
def test_hashable():
lu1 = u.dB(u.mW)
lu2 = u.dB(u.m)
lu3 = u.dB(u.mW)
assert hash(lu1) != hash(lu2)
assert hash(lu1) == hash(lu3)
luset = {lu1, lu2, lu3}
assert len(luset) == 2
class TestLogQuantityCreation(object):
@pytest.mark.parametrize('lq, lu', zip(lq_subclasses + [u.LogQuantity],
lu_subclasses + [u.LogUnit]))
def test_logarithmic_quantities(self, lq, lu):
"""Check logarithmic quantities are all set up correctly"""
assert lq._unit_class == lu
assert type(lu()._quantity_class(1.)) is lq
@pytest.mark.parametrize('lq_cls, physical_unit',
itertools.product(lq_subclasses, pu_sample))
def test_subclass_creation(self, lq_cls, physical_unit):
"""Create LogQuantity subclass objects for some physical units,
and basic check on transformations"""
value = np.arange(1., 10.)
log_q = lq_cls(value * physical_unit)
assert log_q.unit.physical_unit == physical_unit
assert log_q.unit.function_unit == log_q.unit._default_function_unit
assert_allclose(log_q.physical.value, value)
with pytest.raises(ValueError):
lq_cls(value, physical_unit)
@pytest.mark.parametrize(
'unit', (u.mag, u.mag(), u.mag(u.Jy), u.mag(u.m),
u.Unit(2*u.mag), u.MagUnit('', 2.*u.mag),
u.MagUnit(u.Jy, -1*u.mag), u.MagUnit(u.m, -2.*u.mag)))
def test_different_units(self, unit):
q = u.Magnitude(1.23, unit)
assert q.unit.function_unit == getattr(unit, 'function_unit', unit)
assert q.unit.physical_unit is getattr(unit, 'physical_unit',
u.dimensionless_unscaled)
@pytest.mark.parametrize('value, unit', (
(1.*u.mag(u.Jy), None),
(1.*u.dex(u.Jy), None),
(1.*u.mag(u.W/u.m**2/u.Hz), u.mag(u.Jy)),
(1.*u.dex(u.W/u.m**2/u.Hz), u.mag(u.Jy))))
def test_function_values(self, value, unit):
lq = u.Magnitude(value, unit)
assert lq == value
assert lq.unit.function_unit == u.mag
assert lq.unit.physical_unit == getattr(unit, 'physical_unit',
value.unit.physical_unit)
@pytest.mark.parametrize(
'unit', (u.mag(), u.mag(u.Jy), u.mag(u.m), u.MagUnit('', 2.*u.mag),
u.MagUnit(u.Jy, -1*u.mag), u.MagUnit(u.m, -2.*u.mag)))
def test_indirect_creation(self, unit):
q1 = 2.5 * unit
assert isinstance(q1, u.Magnitude)
assert q1.value == 2.5
assert q1.unit == unit
pv = 100. * unit.physical_unit
q2 = unit * pv
assert q2.unit == unit
assert q2.unit.physical_unit == pv.unit
assert q2.to_value(unit.physical_unit) == 100.
assert (q2._function_view / u.mag).to_value(1) == -5.
q3 = unit / 0.4
assert q3 == q1
def test_from_view(self):
# Cannot view a physical quantity as a function quantity, since the
# values would change.
q = [100., 1000.] * u.cm/u.s**2
with pytest.raises(TypeError):
q.view(u.Dex)
# But fine if we have the right magnitude.
q = [2., 3.] * u.dex
lq = q.view(u.Dex)
assert isinstance(lq, u.Dex)
assert lq.unit.physical_unit == u.dimensionless_unscaled
assert np.all(q == lq)
def test_using_quantity_class(self):
"""Check that we can use Quantity if we have subok=True"""
# following issue #5851
lu = u.dex(u.AA)
with pytest.raises(u.UnitTypeError):
u.Quantity(1., lu)
q = u.Quantity(1., lu, subok=True)
assert type(q) is lu._quantity_class
def test_conversion_to_and_from_physical_quantities():
"""Ensures we can convert from regular quantities."""
mst = [10., 12., 14.] * u.STmag
flux_lambda = mst.physical
mst_roundtrip = flux_lambda.to(u.STmag)
# check we return a logquantity; see #5178.
assert isinstance(mst_roundtrip, u.Magnitude)
assert mst_roundtrip.unit == mst.unit
assert_allclose(mst_roundtrip.value, mst.value)
wave = [4956.8, 4959.55, 4962.3] * u.AA
flux_nu = mst.to(u.Jy, equivalencies=u.spectral_density(wave))
mst_roundtrip2 = flux_nu.to(u.STmag, u.spectral_density(wave))
assert isinstance(mst_roundtrip2, u.Magnitude)
assert mst_roundtrip2.unit == mst.unit
assert_allclose(mst_roundtrip2.value, mst.value)
def test_quantity_decomposition():
lq = 10.*u.mag(u.Jy)
assert lq.decompose() == lq
assert lq.decompose().unit.physical_unit.bases == [u.kg, u.s]
assert lq.si == lq
assert lq.si.unit.physical_unit.bases == [u.kg, u.s]
assert lq.cgs == lq
assert lq.cgs.unit.physical_unit.bases == [u.g, u.s]
class TestLogQuantityViews(object):
def setup(self):
self.lq = u.Magnitude(np.arange(10.) * u.Jy)
self.lq2 = u.Magnitude(np.arange(5.))
def test_value_view(self):
lq_value = self.lq.value
assert type(lq_value) is np.ndarray
lq_value[2] = -1.
assert np.all(self.lq.value == lq_value)
def test_function_view(self):
lq_fv = self.lq._function_view
assert type(lq_fv) is u.Quantity
assert lq_fv.unit is self.lq.unit.function_unit
lq_fv[3] = -2. * lq_fv.unit
assert np.all(self.lq.value == lq_fv.value)
def test_quantity_view(self):
# Cannot view as Quantity, since the unit cannot be represented.
with pytest.raises(TypeError):
self.lq.view(u.Quantity)
# But a dimensionless one is fine.
q2 = self.lq2.view(u.Quantity)
assert q2.unit is u.mag
assert np.all(q2.value == self.lq2.value)
lq3 = q2.view(u.Magnitude)
assert type(lq3.unit) is u.MagUnit
assert lq3.unit.physical_unit == u.dimensionless_unscaled
assert np.all(lq3 == self.lq2)
class TestLogQuantitySlicing(object):
def test_item_get_and_set(self):
lq1 = u.Magnitude(np.arange(1., 11.)*u.Jy)
assert lq1[9] == u.Magnitude(10.*u.Jy)
lq1[2] = 100.*u.Jy
assert lq1[2] == u.Magnitude(100.*u.Jy)
with pytest.raises(u.UnitsError):
lq1[2] = 100.*u.m
with pytest.raises(u.UnitsError):
lq1[2] = 100.*u.mag
with pytest.raises(u.UnitsError):
lq1[2] = u.Magnitude(100.*u.m)
assert lq1[2] == u.Magnitude(100.*u.Jy)
def test_slice_get_and_set(self):
lq1 = u.Magnitude(np.arange(1., 10.)*u.Jy)
lq1[2:4] = 100.*u.Jy
assert np.all(lq1[2:4] == u.Magnitude(100.*u.Jy))
with pytest.raises(u.UnitsError):
lq1[2:4] = 100.*u.m
with pytest.raises(u.UnitsError):
lq1[2:4] = 100.*u.mag
with pytest.raises(u.UnitsError):
lq1[2:4] = u.Magnitude(100.*u.m)
assert np.all(lq1[2] == u.Magnitude(100.*u.Jy))
class TestLogQuantityArithmetic(object):
def test_multiplication_division(self):
"""Check that multiplication/division with other quantities is only
possible when the physical unit is dimensionless, and that this turns
the result into a normal quantity."""
lq = u.Magnitude(np.arange(1., 11.)*u.Jy)
with pytest.raises(u.UnitsError):
lq * (1.*u.m)
with pytest.raises(u.UnitsError):
(1.*u.m) * lq
with pytest.raises(u.UnitsError):
lq / lq
for unit in (u.m, u.mag, u.dex):
with pytest.raises(u.UnitsError):
lq / unit
lq2 = u.Magnitude(np.arange(1, 11.))
with pytest.raises(u.UnitsError):
lq2 * lq
with pytest.raises(u.UnitsError):
lq2 / lq
with pytest.raises(u.UnitsError):
lq / lq2
# but dimensionless_unscaled can be cancelled
r = lq2 / u.Magnitude(2.)
assert r.unit == u.dimensionless_unscaled
assert np.all(r.value == lq2.value/2.)
# with dimensionless, normal units OK, but return normal quantities
tf = lq2 * u.m
tr = u.m * lq2
for t in (tf, tr):
assert not isinstance(t, type(lq2))
assert t.unit == lq2.unit.function_unit * u.m
with u.set_enabled_equivalencies(u.logarithmic()):
with pytest.raises(u.UnitsError):
t.to(lq2.unit.physical_unit)
t = tf / (50.*u.cm)
# now we essentially have the same quantity but with a prefactor of 2
assert t.unit.is_equivalent(lq2.unit.function_unit)
assert_allclose(t.to(lq2.unit.function_unit), lq2._function_view*2)
@pytest.mark.parametrize('power', (2, 0.5, 1, 0))
def test_raise_to_power(self, power):
"""Check that raising LogQuantities to some power is only possible when
the physical unit is dimensionless, and that conversion is turned off
when the resulting logarithmic unit (say, mag**2) is incompatible."""
lq = u.Magnitude(np.arange(1., 4.)*u.Jy)
if power == 0:
assert np.all(lq ** power == 1.)
elif power == 1:
assert np.all(lq ** power == lq)
else:
with pytest.raises(u.UnitsError):
lq ** power
# with dimensionless, it works, but falls back to normal quantity
# (except for power=1)
lq2 = u.Magnitude(np.arange(10.))
t = lq2**power
if power == 0:
assert t.unit is u.dimensionless_unscaled
assert np.all(t.value == 1.)
elif power == 1:
assert np.all(t == lq2)
else:
assert not isinstance(t, type(lq2))
assert t.unit == lq2.unit.function_unit ** power
with u.set_enabled_equivalencies(u.logarithmic()):
with pytest.raises(u.UnitsError):
t.to(u.dimensionless_unscaled)
def test_error_on_lq_as_power(self):
lq = u.Magnitude(np.arange(1., 4.)*u.Jy)
with pytest.raises(TypeError):
lq ** lq
@pytest.mark.parametrize('other', pu_sample)
def test_addition_subtraction_to_normal_units_fails(self, other):
lq = u.Magnitude(np.arange(1., 10.)*u.Jy)
q = 1.23 * other
with pytest.raises(u.UnitsError):
lq + q
with pytest.raises(u.UnitsError):
lq - q
with pytest.raises(u.UnitsError):
q - lq
@pytest.mark.parametrize(
'other', (1.23 * u.mag, 2.34 * u.mag(),
u.Magnitude(3.45 * u.Jy), u.Magnitude(4.56 * u.m),
5.67 * u.Unit(2*u.mag), u.Magnitude(6.78, 2.*u.mag)))
def test_addition_subtraction(self, other):
"""Check that addition/subtraction with quantities with magnitude or
MagUnit units works, and that it changes the physical units
appropriately."""
lq = u.Magnitude(np.arange(1., 10.)*u.Jy)
other_physical = other.to(getattr(other.unit, 'physical_unit',
u.dimensionless_unscaled),
equivalencies=u.logarithmic())
lq_sf = lq + other
assert_allclose(lq_sf.physical, lq.physical * other_physical)
lq_sr = other + lq
assert_allclose(lq_sr.physical, lq.physical * other_physical)
lq_df = lq - other
assert_allclose(lq_df.physical, lq.physical / other_physical)
lq_dr = other - lq
assert_allclose(lq_dr.physical, other_physical / lq.physical)
@pytest.mark.parametrize('other', pu_sample)
def test_inplace_addition_subtraction_unit_checks(self, other):
lu1 = u.mag(u.Jy)
lq1 = u.Magnitude(np.arange(1., 10.), lu1)
with pytest.raises(u.UnitsError):
lq1 += other
assert np.all(lq1.value == np.arange(1., 10.))
assert lq1.unit == lu1
with pytest.raises(u.UnitsError):
lq1 -= other
assert np.all(lq1.value == np.arange(1., 10.))
assert lq1.unit == lu1
@pytest.mark.parametrize(
'other', (1.23 * u.mag, 2.34 * u.mag(),
u.Magnitude(3.45 * u.Jy), u.Magnitude(4.56 * u.m),
5.67 * u.Unit(2*u.mag), u.Magnitude(6.78, 2.*u.mag)))
def test_inplace_addition_subtraction(self, other):
"""Check that inplace addition/subtraction with quantities with
magnitude or MagUnit units works, and that it changes the physical
units appropriately."""
lq = u.Magnitude(np.arange(1., 10.)*u.Jy)
other_physical = other.to(getattr(other.unit, 'physical_unit',
u.dimensionless_unscaled),
equivalencies=u.logarithmic())
lq_sf = lq.copy()
lq_sf += other
assert_allclose(lq_sf.physical, lq.physical * other_physical)
lq_df = lq.copy()
lq_df -= other
assert_allclose(lq_df.physical, lq.physical / other_physical)
def test_complicated_addition_subtraction(self):
"""For fun, a more complicated example of addition and subtraction."""
dm0 = u.Unit('DM', 1./(4.*np.pi*(10.*u.pc)**2))
DMmag = u.mag(dm0)
m_st = 10. * u.STmag
dm = 5. * DMmag
M_st = m_st - dm
assert M_st.unit.is_equivalent(u.erg/u.s/u.AA)
assert np.abs(M_st.physical /
(m_st.physical*4.*np.pi*(100.*u.pc)**2) - 1.) < 1.e-15
class TestLogQuantityComparisons(object):
def test_comparison_to_non_quantities_fails(self):
lq = u.Magnitude(np.arange(1., 10.)*u.Jy)
# On python2, ordering operations always succeed, given essentially
# meaningless results.
if not six.PY2:
with pytest.raises(TypeError):
lq > 'a'
assert not (lq == 'a')
assert lq != 'a'
def test_comparison(self):
lq1 = u.Magnitude(np.arange(1., 4.)*u.Jy)
lq2 = u.Magnitude(2.*u.Jy)
assert np.all((lq1 > lq2) == np.array([True, False, False]))
assert np.all((lq1 == lq2) == np.array([False, True, False]))
lq3 = u.Dex(2.*u.Jy)
assert np.all((lq1 > lq3) == np.array([True, False, False]))
assert np.all((lq1 == lq3) == np.array([False, True, False]))
lq4 = u.Magnitude(2.*u.m)
assert not (lq1 == lq4)
assert lq1 != lq4
with pytest.raises(u.UnitsError):
lq1 < lq4
q5 = 1.5 * u.Jy
assert np.all((lq1 > q5) == np.array([True, False, False]))
assert np.all((q5 < lq1) == np.array([True, False, False]))
with pytest.raises(u.UnitsError):
lq1 >= 2.*u.m
with pytest.raises(u.UnitsError):
lq1 <= lq1.value * u.mag
# For physically dimensionless, we can compare with the function unit.
lq6 = u.Magnitude(np.arange(1., 4.))
fv6 = lq6.value * u.mag
assert np.all(lq6 == fv6)
# but not some arbitrary unit, of course.
with pytest.raises(u.UnitsError):
lq6 < 2.*u.m
class TestLogQuantityMethods(object):
def setup(self):
self.mJy = np.arange(1., 5.).reshape(2, 2) * u.mag(u.Jy)
self.m1 = np.arange(1., 5.5, 0.5).reshape(3, 3) * u.mag()
self.mags = (self.mJy, self.m1)
@pytest.mark.parametrize('method', ('mean', 'min', 'max', 'round', 'trace',
'std', 'var', 'ptp', 'diff', 'ediff1d'))
def test_always_ok(self, method):
for mag in self.mags:
res = getattr(mag, method)()
assert np.all(res.value ==
getattr(mag._function_view, method)().value)
if method in ('std', 'ptp', 'diff', 'ediff1d'):
assert res.unit == u.mag()
elif method == 'var':
assert res.unit == u.mag**2
else:
assert res.unit == mag.unit
def test_clip(self):
for mag in self.mags:
assert np.all(mag.clip(2. * mag.unit, 4. * mag.unit).value ==
mag.value.clip(2., 4.))
@pytest.mark.parametrize('method', ('sum', 'cumsum', 'nansum'))
def test_only_ok_if_dimensionless(self, method):
res = getattr(self.m1, method)()
assert np.all(res.value ==
getattr(self.m1._function_view, method)().value)
assert res.unit == self.m1.unit
with pytest.raises(TypeError):
getattr(self.mJy, method)()
def test_dot(self):
assert np.all(self.m1.dot(self.m1).value ==
self.m1.value.dot(self.m1.value))
@pytest.mark.parametrize('method', ('prod', 'cumprod'))
def test_never_ok(self, method):
with pytest.raises(ValueError):
getattr(self.mJy, method)()
with pytest.raises(ValueError):
getattr(self.m1, method)()
class TestLogQuantityUfuncs(object):
"""Spot checks on ufuncs."""
def setup(self):
self.mJy = np.arange(1., 5.).reshape(2, 2) * u.mag(u.Jy)
self.m1 = np.arange(1., 5.5, 0.5).reshape(3, 3) * u.mag()
self.mags = (self.mJy, self.m1)
def test_power(self):
assert np.all(np.power(self.mJy, 0.) == 1.)
assert np.all(np.power(self.m1, 1.) == self.m1)
assert np.all(np.power(self.mJy, 1.) == self.mJy)
assert np.all(np.power(self.m1, 2.) == self.m1 ** 2)
with pytest.raises(u.UnitsError):
np.power(self.mJy, 2.)
def test_not_implemented_with_physical_unit(self):
with pytest.raises(u.UnitsError):
np.square(self.mJy)
assert np.all(np.square(self.m1) == self.m1 ** 2)
|
waynebhayesREPO_NAMESpArcFiRePATH_START.@SpArcFiRe_extracted@SpArcFiRe-master@scripts@SpArcFiRe-pyvenv@lib@python2.7@site-packages@astropy@units@tests@test_logarithmic.py@.PATH_END.py
|
{
"filename": "get_standard.py",
"repo_name": "plazar/coast_guard",
"repo_path": "coast_guard_extracted/coast_guard-master/get_standard.py",
"type": "Python"
}
|
#!/usr/bin/env python
import sys
import utils
import toas
arf = utils.ArchiveFile(sys.argv[1])
print toas.get_standard(arf, analytic=False)
|
plazarREPO_NAMEcoast_guardPATH_START.@coast_guard_extracted@coast_guard-master@get_standard.py@.PATH_END.py
|
{
"filename": "config.py",
"repo_name": "langchain-ai/langchain",
"repo_path": "langchain_extracted/langchain-master/libs/langchain/langchain/schema/runnable/config.py",
"type": "Python"
}
|
from langchain_core.runnables.config import (
EmptyDict,
RunnableConfig,
acall_func_with_variable_args,
call_func_with_variable_args,
ensure_config,
get_async_callback_manager_for_config,
get_callback_manager_for_config,
get_config_list,
get_executor_for_config,
merge_configs,
patch_config,
)
__all__ = [
"EmptyDict",
"RunnableConfig",
"ensure_config",
"get_config_list",
"patch_config",
"merge_configs",
"acall_func_with_variable_args",
"call_func_with_variable_args",
"get_callback_manager_for_config",
"get_async_callback_manager_for_config",
"get_executor_for_config",
]
|
langchain-aiREPO_NAMElangchainPATH_START.@langchain_extracted@langchain-master@libs@langchain@langchain@schema@runnable@config.py@.PATH_END.py
|
{
"filename": "emulator.ipynb",
"repo_name": "Harry45/DESEMU",
"repo_path": "DESEMU_extracted/DESEMU-main/emulator.ipynb",
"type": "Jupyter Notebook"
}
|
```python
import os
import sys
# sys.path.append('/home/harry/Documents/Oxford/Projects/DESEMU/reference/jax-cosmo/jax_cosmo-master/')
from classy import Class # pylint: disable-msg=E0611
from ml_collections.config_dict import ConfigDict
import numpy as np
import jax_cosmo as jc
import jax
import pandas as pd
import scipy.stats as ss
from jax import grad, jit, vmap, jacfwd, hessian
import matplotlib.pylab as plt
import torch
from torchemu.gaussianprocess import GaussianProcess
from config import get_config
import pickle
plt.rc('text', usetex=True)
plt.rc('font',**{'family':'sans-serif','serif':['Palatino']})
figSize = (12, 8)
fontSize = 20
```
```python
def delete_module(class_module: Class):
"""Deletes the module to prevent memory overflow.
Args:
module (Class): A CLASS module
"""
class_module.struct_cleanup()
class_module.empty()
del class_module
```
```python
def get_config(experiment) -> ConfigDict:
config = ConfigDict()
config.logname = "des-analysis"
config.experiment = experiment
# cosmological parameters
config.cosmo = cosmo = ConfigDict()
cosmo.names = ["sigma8", "Omega_cdm", "Omega_b", "h", "n_s"]
# neutrino settings
config.neutrino = neutrino = ConfigDict()
neutrino.N_ncdm = 1.0
neutrino.deg_ncdm = 3.0
neutrino.T_ncdm = 0.71611
neutrino.N_ur = 0.00641
neutrino.fixed_nm = 0.06
# CLASS settings
config.classy = classy = ConfigDict()
classy.bbn = '/home/harry/Desktop/class/bbn/sBBN.dat'
classy.output = "mPk"
classy.Omega_k = 0.0
classy.k_max_pk = 50
classy.k_min_pk = 1e-4
classy.z_max_pk = 3.0
classy.nk = 30
classy.nz = 20
# priors
config.priors = {
"sigma8": {
"distribution": "uniform",
"loc": 0.6,
"scale": 0.4,
"fiducial": 0.8,
},
"Omega_cdm": {
"distribution": "uniform",
"loc": 0.07,
"scale": 0.43,
"fiducial": 0.2,
},
"Omega_b": {
"distribution": "uniform",
"loc": 0.028,
"scale": 0.027,
"fiducial": 0.04,
},
"h": {"distribution": "uniform", "loc": 0.64, "scale": 0.18, "fiducial": 0.7},
"n_s": {"distribution": "uniform", "loc": 0.87, "scale": 0.2, "fiducial": 1.0},
}
# emulator settings
config.emu = emu = ConfigDict()
emu.nlhs = 1000
emu.jitter = 1e-10
emu.lr = 0.01
emu.nrestart = 5
emu.niter = 1000
return config
```
```python
def class_args(config: ConfigDict) -> dict:
"""Generates CLASS arguments to be passed to classy to compute the different quantities.
Args:
config (ConfigDict): A configuration file containing the parameters.
Returns:
dict: A dictionary to input to class
"""
dictionary = dict()
dictionary['output'] = config.classy.output
dictionary['P_k_max_1/Mpc'] = config.classy.k_max_pk
dictionary['z_max_pk'] = config.classy.z_max_pk
dictionary['Omega_k'] = config.classy.Omega_k
dictionary['sBBN file'] = config.classy.bbn
return dictionary
```
```python
def neutrino_args(config: ConfigDict) -> dict:
"""Generates a dictionary for the neutrino settings.
Args:
config (ConfigDict): The main configuration file
Returns:
dict: A dictionary with the neutrino parameters.
"""
dictionary = dict()
dictionary['N_ncdm'] = config.neutrino.N_ncdm
dictionary['deg_ncdm'] = config.neutrino.deg_ncdm
dictionary['T_ncdm'] = config.neutrino.T_ncdm
dictionary['N_ur'] = config.neutrino.N_ur
dictionary['m_ncdm'] = config.neutrino.fixed_nm / config.neutrino.deg_ncdm
return dictionary
```
```python
def class_compute(config: ConfigDict, cosmology: dict) -> Class:
"""Pre-computes the quantities in CLASS.
Args:
config (ConfigDict): The main configuration file for running Class
cosmology (dict): A dictionary with the cosmological parameters
Returns:
Class: A CLASS module
"""
# generates the dictionaries to input to Class
arg_class = class_args(config)
arg_neutrino = neutrino_args(config)
# Run Class
class_module = Class()
class_module.set(arg_class)
class_module.set(arg_neutrino)
class_module.set(cosmology)
class_module.compute()
return class_module
```
```python
cfg = get_config('test')
```
```python
cosmo = {'sigma8': 0.857570, 'Omega_cdm': 0.217284, 'Omega_b': 0.038872, 'h': 0.711447, 'n_s': 1.001982}
kgrid = np.geomspace(cfg.classy.k_min_pk, cfg.classy.k_max_pk, cfg.classy.nk)
zgrid = np.linspace(0.0, cfg.classy.z_max_pk, cfg.classy.nz)
```
```python
def calculate_linear_pk_class(cosmology, cfg):
"""
Calculate the linear matter power spectrum using CLASS
"""
cmodule = class_compute(cfg, cosmology)
# calculate the linear matter power spectrum
kvalues = np.geomspace(cfg.classy.k_min_pk, cfg.classy.k_max_pk, cfg.classy.nk)
class_pklin = []
for kvalue in kvalues:
class_pklin.append(cosmology['h']**3 * cmodule.pk_lin(cosmology['h']*kvalue, 0.0))
class_pklin = np.array(class_pklin)
delete_module(cmodule)
return class_pklin
```
```python
class_pklin = calculate_linear_pk_class(cosmo, cfg)
```
# JAX Cosmo
```python
def calculate_linear_pk_jax(cosmology, kvalues):
"""
Calculate the linear matter power spectrum using JAX cosmo
"""
jax_pklin = []
for kvalue in kvalues:
jax_pklin.append(jc.power.linear_matter_power(cosmology, kvalue, a=1.0))
return jax_pklin
pklin_jit = jit(calculate_linear_pk_jax)
```
```python
jcosmo = jc.Cosmology(sigma8=0.857570, Omega_c=0.217284, Omega_b=0.038872, h=0.711447, n_s=1.001982,
w0=-1., Omega_k=0., wa=0.)
```
```python
%%capture
jax_pklin = pklin_jit(jcosmo, kgrid)
```
```python
jax_pklin_np = np.concatenate([jax_pklin])
```
# Comparison
```python
plt.figure(figsize = (8,6))
plt.loglog(kgrid, jax_pklin_np, lw = 2, label = 'Jax Cosmo')
plt.loglog(kgrid, class_pklin, lw = 2, linestyle = '--', label = 'Class')
plt.xlim(min(kgrid), max(kgrid))
plt.legend(loc = 'best',prop={'family':'sans-serif', 'size':15})
plt.ylabel(r'$P_{l}(k,0)$', fontsize = fontSize)
plt.xlabel(r'$k\;[\textrm{Mpc}^{-1}]$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.show()
```
# Decompose the linear matter power spectrum
```python
def calculate_quantities(cosmology, cfg):
"""
Calculate the linear matter power spectrum at redshift 0 and the growth factor as a function of redshift
"""
kgrid = np.geomspace(cfg.classy.k_min_pk, cfg.classy.k_max_pk, cfg.classy.nk)
zgrid = np.linspace(0.0, cfg.classy.z_max_pk, cfg.classy.nz)
cmodule = class_compute(cfg, cosmology)
class_pklin_z0 = []
multiplying_factor = []
# note that JAX cosmo computes everything with a factor h inside
# which is why we are including the factor h here
for kvalue in kgrid:
class_pklin_z0.append(cosmology['h']**3 * cmodule.pk_lin(cosmology['h']*kvalue, 0))
class_pklin_z0 = np.array(class_pklin_z0)
for redshift in zgrid:
factor = cosmology['h']**3 * cmodule.pk_lin(cosmology['h']*kgrid[0], redshift)
multiplying_factor.append(factor / class_pklin_z0[0])
multiplying_factor = np.array(multiplying_factor)
delete_module(cmodule)
return class_pklin_z0, multiplying_factor
```
```python
def calculate_pklin_redshift(cosmology, cfg, redshift):
"""
Calculate the linear matter power spectrum at any given redshift
"""
kgrid = np.geomspace(cfg.classy.k_min_pk, cfg.classy.k_max_pk, cfg.classy.nk)
cmodule = class_compute(cfg, cosmology)
class_pklin = []
for kvalue in kgrid:
class_pklin.append(cosmology['h']**3 * cmodule.pk_lin(cosmology['h']*kvalue, redshift))
class_pklin = np.array(class_pklin)
delete_module(cmodule)
return class_pklin
```
```python
%%time
class_pklin_z0, multiplying_factor = calculate_quantities(cosmo, cfg)
```
CPU times: user 14.4 s, sys: 20.2 ms, total: 14.4 s
Wall time: 2.54 s
```python
plt.figure(figsize = (14, 6))
plt.subplot(121)
plt.plot(zgrid, multiplying_factor, lw =2)
plt.ylabel(r'$G(\theta, z)$', fontsize = fontSize)
plt.xlabel(r'$z$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.ylim(0, 1)
plt.xlim(min(zgrid), max(zgrid))
plt.subplot(122)
plt.loglog(kgrid, class_pklin_z0, lw = 2)
plt.xlim(min(kgrid), max(kgrid))
plt.ylabel(r'$P_{l}(k,0)$', fontsize = fontSize)
plt.xlabel(r'$k\;[\textrm{Mpc}^{-1}]$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.3, hspace=None)
plt.show()
```
# Any Redshift
```python
testredshift = 1.0
```
```python
class_pklin_z = calculate_pklin_redshift(cosmo, cfg, redshift=testredshift)
class_pklin_prod = class_pklin_z0 * np.interp(testredshift, zgrid, multiplying_factor)
```
```python
plt.figure(figsize=(8,6))
plt.loglog(kgrid, class_pklin_z, lw = 2, label = 'CLASS')
plt.loglog(kgrid, class_pklin_prod, lw = 2, linestyle = '--', label = r'Product of $G(\theta, z=1)P_{l}(\theta, k,z=0)$')
plt.xlim(min(kgrid), max(kgrid))
plt.legend(loc = 'best',prop={'family':'sans-serif', 'size':15})
plt.ylabel(r'$P_{l}(k,0)$', fontsize = fontSize)
plt.xlabel(r'$k\;[\textrm{Mpc}^{-1}]$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.show()
```
# Generate Training Set
```python
import pandas as pd
import scipy.stats
```
```python
lhs = pd.read_csv('data/lhs_1000.csv', index_col=0)
```
```python
lhs.head()
```
<div>
<style scoped>
.dataframe tbody tr th:only-of-type {
vertical-align: middle;
}
.dataframe tbody tr th {
vertical-align: top;
}
.dataframe thead th {
text-align: right;
}
</style>
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th></th>
<th>V1</th>
<th>V2</th>
<th>V3</th>
<th>V4</th>
<th>V5</th>
</tr>
</thead>
<tbody>
<tr>
<th>1</th>
<td>0.409403</td>
<td>0.707022</td>
<td>0.458449</td>
<td>0.696310</td>
<td>0.386550</td>
</tr>
<tr>
<th>2</th>
<td>0.399692</td>
<td>0.428306</td>
<td>0.845907</td>
<td>0.282958</td>
<td>0.316863</td>
</tr>
<tr>
<th>3</th>
<td>0.264020</td>
<td>0.819791</td>
<td>0.263440</td>
<td>0.769574</td>
<td>0.183617</td>
</tr>
<tr>
<th>4</th>
<td>0.315184</td>
<td>0.867452</td>
<td>0.182386</td>
<td>0.270367</td>
<td>0.815225</td>
</tr>
<tr>
<th>5</th>
<td>0.754065</td>
<td>0.470705</td>
<td>0.166511</td>
<td>0.343403</td>
<td>0.658752</td>
</tr>
</tbody>
</table>
</div>
```python
def generate_cosmo_priors(cfg):
"""Generates the entity of each parameter by using scipy.stats function.
Args:
dictionary (dict): A dictionary with the specifications of the prior.
Returns:
dict: the prior distribution of all parameters.
"""
dictionary = dict()
for name in cfg.cosmo.names:
param = cfg.priors[name]
specs = (param.loc, param.scale)
dictionary[name] = getattr(ss, param.distribution)(*specs)
return dictionary
```
```python
def generate_inputs(lhs, priors, save= False):
"""
Generate the input training points (the cosmologies). This essentially scales the latin hypercube samples
according to the prior range of the cosmological parameters.
"""
cosmologies = {}
for i, p in enumerate(priors):
cosmologies[p] = priors[p].ppf(lhs.iloc[:,i].values)
cosmologies = pd.DataFrame(cosmologies)
if save:
os.makedirs('data', exist_ok=True)
cosmologies.to_csv('data/cosmologies.csv')
return cosmologies
```
```python
cosmo_priors = generate_cosmo_priors(cfg)
# cosmologies = generate_inputs(lhs, cosmo_priors, save = False)
```
```python
cosmologies = pd.read_csv('data/cosmologies.csv', index_col = 0)
```
```python
cosmologies.head()
```
<div>
<style scoped>
.dataframe tbody tr th:only-of-type {
vertical-align: middle;
}
.dataframe tbody tr th {
vertical-align: top;
}
.dataframe thead th {
text-align: right;
}
</style>
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th></th>
<th>sigma8</th>
<th>Omega_cdm</th>
<th>Omega_b</th>
<th>h</th>
<th>n_s</th>
</tr>
</thead>
<tbody>
<tr>
<th>0</th>
<td>0.763761</td>
<td>0.374019</td>
<td>0.040378</td>
<td>0.765336</td>
<td>0.947310</td>
</tr>
<tr>
<th>1</th>
<td>0.759877</td>
<td>0.254172</td>
<td>0.050839</td>
<td>0.690932</td>
<td>0.933373</td>
</tr>
<tr>
<th>2</th>
<td>0.705608</td>
<td>0.422510</td>
<td>0.035113</td>
<td>0.778523</td>
<td>0.906723</td>
</tr>
<tr>
<th>3</th>
<td>0.726073</td>
<td>0.443004</td>
<td>0.032924</td>
<td>0.688666</td>
<td>1.033045</td>
</tr>
<tr>
<th>4</th>
<td>0.901626</td>
<td>0.272403</td>
<td>0.032496</td>
<td>0.701813</td>
<td>1.001750</td>
</tr>
</tbody>
</table>
</div>
```python
def generate_outputs(cosmologies, cfg, save = False):
ncosmo = cosmologies.shape[0]
record_pklin = []
record_gf = []
for i in range(ncosmo):
cosmology = dict(cosmologies.iloc[i])
train_pklin, train_gf = calculate_quantities(cosmology, cfg)
record_pklin.append(train_pklin)
record_gf.append(train_gf)
record_pklin = pd.DataFrame(record_pklin)
record_gf = pd.DataFrame(record_gf)
if save:
os.makedirs('data', exist_ok=True)
record_pklin.to_csv('data/pklin.csv')
record_gf.to_csv('data/gf.csv')
return record_pklin, record_gf
```
```python
%%time
# record_pklin, record_gf = generate_outputs(cosmologies, cfg, save=True) # this should be done once
# this took about 1 hour
```
```python
record_pklin = pd.read_csv('data/pklin.csv', index_col=0)
record_gf = pd.read_csv('data/gf.csv', index_col = 0 )
```
```python
record_pklin.head()
```
<div>
<style scoped>
.dataframe tbody tr th:only-of-type {
vertical-align: middle;
}
.dataframe tbody tr th {
vertical-align: top;
}
.dataframe thead th {
text-align: right;
}
</style>
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th></th>
<th>0</th>
<th>1</th>
<th>2</th>
<th>3</th>
<th>4</th>
<th>5</th>
<th>6</th>
<th>7</th>
<th>8</th>
<th>9</th>
<th>...</th>
<th>20</th>
<th>21</th>
<th>22</th>
<th>23</th>
<th>24</th>
<th>25</th>
<th>26</th>
<th>27</th>
<th>28</th>
<th>29</th>
</tr>
</thead>
<tbody>
<tr>
<th>0</th>
<td>131.445968</td>
<td>201.760798</td>
<td>309.614593</td>
<td>474.847080</td>
<td>727.277316</td>
<td>1110.629576</td>
<td>1686.057567</td>
<td>2531.627176</td>
<td>3730.727684</td>
<td>5330.572047</td>
<td>...</td>
<td>118.263062</td>
<td>43.401857</td>
<td>15.162146</td>
<td>5.090355</td>
<td>1.654540</td>
<td>0.523642</td>
<td>0.162088</td>
<td>0.049241</td>
<td>0.014719</td>
<td>0.004337</td>
</tr>
<tr>
<th>1</th>
<td>487.772462</td>
<td>743.862127</td>
<td>1133.846530</td>
<td>1726.266292</td>
<td>2621.222199</td>
<td>3957.890703</td>
<td>5912.218508</td>
<td>8667.205058</td>
<td>12325.786242</td>
<td>16717.196546</td>
<td>...</td>
<td>79.993508</td>
<td>27.648291</td>
<td>9.193537</td>
<td>2.961906</td>
<td>0.929661</td>
<td>0.285503</td>
<td>0.086076</td>
<td>0.025541</td>
<td>0.007471</td>
<td>0.002156</td>
</tr>
<tr>
<th>2</th>
<td>108.107721</td>
<td>162.923525</td>
<td>245.485314</td>
<td>369.710123</td>
<td>556.181295</td>
<td>834.668196</td>
<td>1246.424207</td>
<td>1843.920417</td>
<td>2684.034096</td>
<td>3802.660875</td>
<td>...</td>
<td>105.901752</td>
<td>38.851374</td>
<td>13.517810</td>
<td>4.507275</td>
<td>1.451882</td>
<td>0.454627</td>
<td>0.139055</td>
<td>0.041701</td>
<td>0.012297</td>
<td>0.003573</td>
</tr>
<tr>
<th>3</th>
<td>51.563186</td>
<td>82.277781</td>
<td>131.258554</td>
<td>209.284397</td>
<td>333.269242</td>
<td>529.226999</td>
<td>835.669259</td>
<td>1305.675276</td>
<td>2003.269165</td>
<td>2983.381997</td>
<td>...</td>
<td>129.215736</td>
<td>49.719024</td>
<td>18.177218</td>
<td>6.377798</td>
<td>2.164260</td>
<td>0.714557</td>
<td>0.230606</td>
<td>0.073010</td>
<td>0.022739</td>
<td>0.006981</td>
</tr>
<tr>
<th>4</th>
<td>318.827723</td>
<td>501.501366</td>
<td>788.460400</td>
<td>1238.201521</td>
<td>1939.421478</td>
<td>3021.143607</td>
<td>4656.975309</td>
<td>7047.633228</td>
<td>10352.551881</td>
<td>14518.223204</td>
<td>...</td>
<td>135.719182</td>
<td>48.823120</td>
<td>16.864521</td>
<td>5.636024</td>
<td>1.833043</td>
<td>0.582858</td>
<td>0.181837</td>
<td>0.055811</td>
<td>0.016887</td>
<td>0.005042</td>
</tr>
</tbody>
</table>
<p>5 rows × 30 columns</p>
</div>
```python
record_gf.head()
```
<div>
<style scoped>
.dataframe tbody tr th:only-of-type {
vertical-align: middle;
}
.dataframe tbody tr th {
vertical-align: top;
}
.dataframe thead th {
text-align: right;
}
</style>
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th></th>
<th>0</th>
<th>1</th>
<th>2</th>
<th>3</th>
<th>4</th>
<th>5</th>
<th>6</th>
<th>7</th>
<th>8</th>
<th>9</th>
<th>10</th>
<th>11</th>
<th>12</th>
<th>13</th>
<th>14</th>
<th>15</th>
<th>16</th>
<th>17</th>
<th>18</th>
<th>19</th>
</tr>
</thead>
<tbody>
<tr>
<th>0</th>
<td>1.0</td>
<td>0.824241</td>
<td>0.682947</td>
<td>0.570414</td>
<td>0.480844</td>
<td>0.409225</td>
<td>0.351530</td>
<td>0.304637</td>
<td>0.266167</td>
<td>0.234311</td>
<td>0.207693</td>
<td>0.185261</td>
<td>0.166205</td>
<td>0.149894</td>
<td>0.135837</td>
<td>0.123642</td>
<td>0.113001</td>
<td>0.103662</td>
<td>0.095425</td>
<td>0.088124</td>
</tr>
<tr>
<th>1</th>
<td>1.0</td>
<td>0.847581</td>
<td>0.718381</td>
<td>0.610835</td>
<td>0.522128</td>
<td>0.449162</td>
<td>0.389058</td>
<td>0.339345</td>
<td>0.297994</td>
<td>0.263376</td>
<td>0.234197</td>
<td>0.209433</td>
<td>0.188277</td>
<td>0.170084</td>
<td>0.154345</td>
<td>0.140649</td>
<td>0.128665</td>
<td>0.118125</td>
<td>0.108811</td>
<td>0.100543</td>
</tr>
<tr>
<th>2</th>
<td>1.0</td>
<td>0.816190</td>
<td>0.671178</td>
<td>0.557389</td>
<td>0.467854</td>
<td>0.396889</td>
<td>0.340104</td>
<td>0.294188</td>
<td>0.256670</td>
<td>0.225698</td>
<td>0.199882</td>
<td>0.178169</td>
<td>0.159752</td>
<td>0.144008</td>
<td>0.130454</td>
<td>0.118706</td>
<td>0.108461</td>
<td>0.099477</td>
<td>0.091555</td>
<td>0.084538</td>
</tr>
<tr>
<th>3</th>
<td>1.0</td>
<td>0.812879</td>
<td>0.666402</td>
<td>0.552156</td>
<td>0.462674</td>
<td>0.391998</td>
<td>0.335591</td>
<td>0.290073</td>
<td>0.252937</td>
<td>0.222318</td>
<td>0.196820</td>
<td>0.175390</td>
<td>0.157224</td>
<td>0.141704</td>
<td>0.128346</td>
<td>0.116773</td>
<td>0.106683</td>
<td>0.097836</td>
<td>0.090038</td>
<td>0.083131</td>
</tr>
<tr>
<th>4</th>
<td>1.0</td>
<td>0.847620</td>
<td>0.718441</td>
<td>0.610905</td>
<td>0.522202</td>
<td>0.449235</td>
<td>0.389128</td>
<td>0.339411</td>
<td>0.298055</td>
<td>0.263432</td>
<td>0.234249</td>
<td>0.209481</td>
<td>0.188321</td>
<td>0.170125</td>
<td>0.154383</td>
<td>0.140684</td>
<td>0.128697</td>
<td>0.118156</td>
<td>0.108839</td>
<td>0.100569</td>
</tr>
</tbody>
</table>
</div>
# Emulator
```python
inputs = torch.from_numpy(cosmologies.values)
outputs_pklin = torch.from_numpy(record_pklin.values)
outputs_gf = torch.from_numpy(record_gf.values[:,1:])
```
```python
def save_pkl(file: dict, folder_name: str, file_name: str) -> None:
"""Stores a list/dict/class in a folder.
Args:
file (list): Quantity to store.
folder_name (str): The name of the folder.
file_name (str): The name of the file.
"""
# create the folder if it does not exist
os.makedirs(folder_name, exist_ok=True)
# use compressed format to store data
with open(folder_name + "/" + file_name + ".pkl", "wb") as f:
pickle.dump(file, f)
def load_pkl(folder_name: str, file_name: str) -> dict:
"""Reads a list from a folder.
Args:
folder_name (str): The name of the folder.
file_name (str): The name of the file.
Returns:
dict: the dictionary with all the quantities.
"""
with open(folder_name + "/" + file_name + ".pkl", "rb") as f:
file = pickle.load(f)
return file
```
```python
def train_gps(configs, cosmologies, outputs, prewhiten, ylog, fname='pklin'):
nout = outputs.shape[1]
record = []
for i in range(nout):
# optimise for the kernel parameters
gpmodule = GaussianProcess(configs, inputs, outputs[:,i], prewhiten=prewhiten, ylog=ylog)
parameters = torch.randn(6)
opt_params = gpmodule.optimisation(parameters, niter=configs.emu.niter, lrate=configs.emu.lr, nrestart = configs.emu.nrestart)
# save the gps and quantities
save_pkl(gpmodule, 'gps', fname+f'_{i}')
record.append(gpmodule)
return record
```
```python
def save_quantities(gps, fname):
for i, gpmodule in enumerate(gps):
# record all quantities to be used for Jax
quantities = {}
quantities['hyperparams'] = gpmodule.opt_parameters.data.numpy()
quantities['cholfactor'] = gpmodule.chol_train.data.numpy()
quantities['meanparams'] = gpmodule.mean_train.data.numpy()
quantities['alpha'] = gpmodule.alpha.data.numpy()
quantities['ystd'] = gpmodule.ystd.data.numpy()
quantities['ymean'] = gpmodule.ymean.data.numpy()
quantities['xtrain'] = gpmodule.xtrain.data.numpy()
save_pkl(quantities, 'quantities', fname+f'_{i}')
```
```python
%%time
# gps_pklin = train_gps(cfg, inputs, outputs_pklin, True, True, 'pklin') # this is done once
# CPU times: user 10h 24min 47s, sys: 7min 8s, total: 10h 31min 56s
# Wall time: 1h 19min 28s
```
CPU times: user 10h 24min 47s, sys: 7min 8s, total: 10h 31min 56s
Wall time: 1h 19min 28s
```python
%%time
# gps_gf = train_gps(cfg, inputs, outputs_gf, True, False, 'gf') # this is done once
# CPU times: user 6h 38min 19s, sys: 1min 34s, total: 6h 39min 54s
# Wall time: 50min 18s
```
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
Not using log transformation
CPU times: user 6h 38min 19s, sys: 1min 34s, total: 6h 39min 54s
Wall time: 50min 18s
```python
# save_quantities(gps_pklin, 'pklin')
# save_quantities(gps_gf, 'gf')
```
# Testing
We just need to load the trained GPs before making predictions
```python
loaded_gps_pklin = [load_pkl('gps/', f'pklin_{i}') for i in range(cfg.classy.nk)]
loaded_gps_gf = [load_pkl('gps/', f'gf_{i}') for i in range(cfg.classy.nz-1)]
```
```python
ndim = 5
ntest = 25
test_samples = pd.DataFrame(np.random.uniform(0, 1, (ntest, ndim)), columns=[f'V{i+1}' for i in range(ndim)])
cosmo_priors = generate_cosmo_priors(cfg)
test_cosmo = generate_inputs(test_samples, cosmo_priors, save=False)
```
```python
test_cosmo.head()
```
<div>
<style scoped>
.dataframe tbody tr th:only-of-type {
vertical-align: middle;
}
.dataframe tbody tr th {
vertical-align: top;
}
.dataframe thead th {
text-align: right;
}
</style>
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th></th>
<th>sigma8</th>
<th>Omega_cdm</th>
<th>Omega_b</th>
<th>h</th>
<th>n_s</th>
</tr>
</thead>
<tbody>
<tr>
<th>0</th>
<td>0.705508</td>
<td>0.178396</td>
<td>0.041769</td>
<td>0.756473</td>
<td>1.053305</td>
</tr>
<tr>
<th>1</th>
<td>0.946655</td>
<td>0.080980</td>
<td>0.041294</td>
<td>0.806770</td>
<td>0.885890</td>
</tr>
<tr>
<th>2</th>
<td>0.925953</td>
<td>0.336557</td>
<td>0.028025</td>
<td>0.799644</td>
<td>1.007255</td>
</tr>
<tr>
<th>3</th>
<td>0.858123</td>
<td>0.166238</td>
<td>0.047028</td>
<td>0.813817</td>
<td>1.060033</td>
</tr>
<tr>
<th>4</th>
<td>0.821082</td>
<td>0.316000</td>
<td>0.034845</td>
<td>0.719551</td>
<td>0.935759</td>
</tr>
</tbody>
</table>
</div>
```python
def interpolate_1d(fine_x, coarse_x, coarse_y, xlog=False, ylog=False):
if xlog:
fine_x = np.log(fine_x)
coarse_x = np.log(coarse_x)
if ylog:
coarse_y = np.log(coarse_y)
ypred = np.interp(fine_x, coarse_x, coarse_y)
if ylog:
ypred = np.exp(ypred)
return ypred
```
```python
def calculate_accuracy(gps_pklin, gps_gf, testcosmo, cfg, use_interp: bool):
# coarse and fine grid for wavenumber
kgrid = np.geomspace(cfg.classy.k_min_pk, cfg.classy.k_max_pk, cfg.classy.nk)
kfine = np.geomspace(cfg.classy.k_min_pk, cfg.classy.k_max_pk, 1000)
# coarse and fine grid for redshift
zgrid = np.linspace(0.0, cfg.classy.z_max_pk, cfg.classy.nz)
zfine = np.linspace(0.0, cfg.classy.z_max_pk, 1000)
ntest = testcosmo.shape[0]
record = {'class_pklin': [],
'class_gf': [],
'gp_pklin': [],
'gp_gf': [],
'delta_pklin': [],
'delta_gf': []
}
for i in range(ntest):
cosmo_dict = dict(testcosmo.iloc[i])
cosmo_tensor = torch.tensor(testcosmo.iloc[i].values).view(-1)
pklin_class, gf_class = calculate_quantities(cosmo_dict, cfg)
pklin_gp = [gps_pklin[j].prediction(cosmo_tensor).item() for j in range(cfg.classy.nk)]
gf_gp = [1] + [gps_gf[j].prediction(cosmo_tensor).item() for j in range(cfg.classy.nz-1)]
if use_interp:
pklin_class = interpolate_1d(kfine, kgrid, pklin_class, xlog=True, ylog=True)
pklin_gp = interpolate_1d(kfine, kgrid, pklin_gp, xlog=True, ylog=True)
gf_gp = interpolate_1d(zfine, zgrid, gf_gp, xlog=False, ylog=False)
gf_class = interpolate_1d(zfine, zgrid, gf_class, xlog=False, ylog=False)
record['class_pklin'].append(pklin_class)
record['class_gf'].append(gf_class)
record['gp_pklin'].append(np.array(pklin_gp))
record['gp_gf'].append(np.array(gf_gp))
record['delta_pklin'].append((pklin_class - pklin_gp)/pklin_class)
record['delta_gf'].append((gf_class - gf_gp)/gf_class)
record['testcosmo'] = testcosmo
save_pkl(record, 'data', 'accuracy')
return record
```
```python
%%time
# record = calculate_accuracy(loaded_gps_pklin, loaded_gps_gf, test_cosmo, cfg, use_interp=True)
```
CPU times: user 1h 7min 21s, sys: 1.86 s, total: 1h 7min 23s
Wall time: 11min 23s
```python
record = load_pkl('data', 'accuracy')
```
```python
record.keys()
```
dict_keys(['class_pklin', 'class_gf', 'gp_pklin', 'gp_gf', 'delta_pklin', 'delta_gf', 'testcosmo'])
```python
delta_pklin = np.vstack(record['delta_pklin'])
delta_gf = np.vstack(record['delta_gf'])
mean_delta_pklin = np.mean(delta_pklin, axis = 0)*100
std_delta_pklin = np.std(delta_pklin, axis = 0)*100
mean_delta_gf = np.mean(delta_gf, axis = 0)*100
std_delta_gf = np.std(delta_gf, axis = 0)*100
```
```python
kfine = np.geomspace(cfg.classy.k_min_pk, cfg.classy.k_max_pk, 1000)
zfine = np.linspace(0.0, cfg.classy.z_max_pk, 1000)
```
```python
plt.figure(figsize = (22,6))
plt.subplot(121)
plt.fill_between(kfine, mean_delta_pklin + 3 * std_delta_pklin, mean_delta_pklin - 3 * std_delta_pklin, alpha = 0.3, color = 'g')
plt.ylim(-2, 2)
plt.xlim(min(kfine), max(kfine))
plt.ylabel(r'$\frac{\Delta P_{l}}{P_{l}}\times 100$', fontsize = fontSize)
plt.xlabel(r'$k\;[\textrm{Mpc}^{-1}]$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.xscale('log')
plt.subplot(122)
plt.fill_between(zfine, mean_delta_gf + 3 * std_delta_gf, mean_delta_gf - 3 * std_delta_gf, alpha = 0.3, color = 'g')
plt.ylim(-0.02, 0.02)
plt.xlim(min(zfine), max(zfine))
plt.ylabel(r'$\frac{\Delta G}{G}\times 100$', fontsize = fontSize)
plt.xlabel(r'$z$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
# plt.savefig('plots/emu_accuracy.pdf', bbox_inches = 'tight')
plt.show()
```
# GP Implementation in $\texttt{Numpy}$
If we are able to do this with $\texttt{numpy}$, it should be the same for Jax using $\texttt{jax.numpy}$.
```python
def pairwise_distance_numpy(arr1: np.ndarray, arr2: np.ndarray) -> np.ndarray:
sqr_a = np.broadcast_to(np.sum(np.power(arr1, 2), axis=1, keepdims=True), (arr1.shape[0], arr2.shape[0]))
sqr_b = np.broadcast_to(np.sum(np.power(arr2, 2), axis=1, keepdims=True), (arr2.shape[0], arr1.shape[0])).T
dist = sqr_a - 2 * arr1 @ arr2.T + sqr_b
return dist
```
```python
def compute_numpy(arr1: np.ndarray, arr2: np.ndarray, hyper: np.ndarray) -> np.ndarray:
_, ndim = arr1.shape
arr2 = arr2.reshape(-1, ndim)
hyper = hyper.reshape(1, ndim + 1)
arr1 = arr1 / np.exp(hyper[:, 1:])
arr2 = arr2 / np.exp(hyper[:, 1:])
dist = pairwise_distance_numpy(arr1, arr2)
kernel = np.exp(hyper[:, 0]) * np.exp(-0.5 * dist)
return kernel
```
```python
def xtransform_numpy(xtest: np.ndarray, cholfactor: np.ndarray, meanparams: np.ndarray):
xtest = xtest.reshape(1, -1)
xtest_trans = np.linalg.inv(cholfactor) @ (xtest - meanparams).T
xtest_trans = xtest_trans.T
return xtest_trans
```
```python
def prediction_numpy(xtest: np.ndarray, quantities: list, cosmo_priors: dict, ylog: bool = True):
logpdf = calculate_cosmo_pdf(cosmo_priors, xtest)
if not np.isfinite(logpdf):
raise ValueError('The cosmological parameter lies outside the prior volume.')
# the cosmologies are fixed and the cholesky factor is the same for all
xtest = xtransform_numpy(xtest, quantities[0]['cholfactor'], quantities[0]['meanparams'])
ngps = len(quantities)
predictions = []
for i in range(ngps):
kstar = compute_numpy(quantities[i]['xtrain'], xtest, quantities[i]['hyperparams'])
pred = kstar.T @ quantities[i]['alpha']
pred = pred * quantities[i]['ystd'] + quantities[i]['ymean']
if ylog:
pred = np.exp(pred).reshape(-1)
predictions.append(pred.item())
return predictions
```
```python
def calculate_cosmo_pdf(cosmo_priors: dict, point: np.ndarray):
logpdf = 0.0
for i, key in enumerate(cosmo_priors.keys()):
logpdf += cosmo_priors[key].logpdf(point[i])
return logpdf
```
Quantities we need to predict the different functions.
```python
quantities_pklin = [load_pkl('quantities', f'pklin_{i}') for i in range(cfg.classy.nk)]
quantities_gf = [load_pkl('quantities', f'gf_{i}') for i in range(cfg.classy.nz-1)]
```
The test point we want to use for this check.
```python
testpoint = test_cosmo.iloc[0].values
testpoint_pt = torch.from_numpy(testpoint)
testpoint_dict = dict(test_cosmo.iloc[0])
```
Make sure that the point lies within the prior volume - this is also tested within the prediction function
```python
calculate_cosmo_pdf(cosmo_priors, testpoint)
```
8.696415555672518
```python
calculate_cosmo_pdf(cosmo_priors, testpoint+1)
```
-inf
The linear matter power spectrum and the growth factor using $\texttt{numpy}$ or $\texttt{jax.numpy}$ (should be the same approach).
```python
%%time
pklin_np = prediction_numpy(testpoint, quantities_pklin, cosmo_priors, ylog=True)
gf_np = [1.0] + prediction_numpy(testpoint, quantities_gf, cosmo_priors, ylog=False)
```
CPU times: user 27.9 ms, sys: 36.1 ms, total: 63.9 ms
Wall time: 10 ms
The linear matter power spectrum and the growth factor using $\texttt{pyTorch}$.
```python
%%time
pklin_pt = [gps_pklin[j].prediction(testpoint_pt).item() for j in range(cfg.classy.nk)]
gf_pt = [1.0] + [gps_gf[j].prediction(testpoint_pt).item() for j in range(cfg.classy.nz-1)]
```
CPU times: user 11.5 ms, sys: 0 ns, total: 11.5 ms
Wall time: 11.2 ms
The linear matter power spectrum and the growth factor using $\texttt{CLASS}$.
```python
%%time
pklin_class, gf_class = calculate_quantities(testpoint_dict, cfg)
```
CPU times: user 19.1 s, sys: 16 ms, total: 19.1 s
Wall time: 3.48 s
```python
plt.figure(figsize = (20,8))
plt.subplot(121)
plt.loglog(kgrid, pklin_pt, lw = 3, label = 'PyTorch')
plt.loglog(kgrid, pklin_np, lw = 3, linestyle = '--', label = 'Numpy')
plt.loglog(kgrid, pklin_class, lw = 3, linestyle = ':', label = 'CLASS')
plt.xlim(min(kgrid), max(kgrid))
plt.legend(loc = 'best',prop={'family':'sans-serif', 'size':15})
plt.ylabel(r'$P_{l}(k,0)$', fontsize = fontSize)
plt.xlabel(r'$k\;[\textrm{Mpc}^{-1}]$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.subplot(122)
plt.plot(zgrid, gf_pt, lw = 3, label = 'PyTorch')
plt.plot(zgrid, gf_np, lw = 3, linestyle = '--', label = 'Numpy')
plt.plot(zgrid, gf_class, lw = 3, linestyle = ':', label = 'CLASS')
plt.xlim(min(zgrid), max(zgrid))
plt.legend(loc = 'best',prop={'family':'sans-serif', 'size':15})
plt.ylabel(r'$G(z)$', fontsize = fontSize)
plt.xlabel(r'$z$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.show()
```
# GP Implementation in $\texttt{jax.numpy}$
```python
import jax.numpy as jnp
import jax.scipy.stats as jss
from scipy import interpolate
from jax.config import config; config.update("jax_enable_x64", True)
```
We need a dictionary of priors defined outside the function, for the latter to be differentiable.
```python
COSMO_PRIORS = {'sigma8': {'distribution': 'uniform', 'loc': 0.6, 'scale': 0.4},
'Omega_cdm': {'distribution': 'uniform', 'loc': 0.07, 'scale': 0.43},
'Omega_b': {'distribution': 'uniform', 'loc': 0.028, 'scale': 0.027},
'h': {'distribution': 'uniform', 'loc': 0.64, 'scale': 0.18},
'n_s': {'distribution': 'uniform', 'loc': 0.87, 'scale': 0.2}
}
```
```python
def pairwise_distance_jax(arr1: jnp.ndarray, arr2: jnp.ndarray) -> jnp.ndarray:
sqr_a = jnp.broadcast_to(jnp.sum(jnp.power(arr1, 2), axis=1, keepdims=True), (arr1.shape[0], arr2.shape[0]))
sqr_b = jnp.broadcast_to(jnp.sum(jnp.power(arr2, 2), axis=1, keepdims=True), (arr2.shape[0], arr1.shape[0])).T
dist = sqr_a - 2 * arr1 @ arr2.T + sqr_b
return dist
```
```python
def compute_jax(arr1: jnp.ndarray, arr2: jnp.ndarray, hyper: jnp.ndarray) -> jnp.ndarray:
_, ndim = arr1.shape
arr2 = arr2.reshape(-1, ndim)
hyper = hyper.reshape(1, ndim + 1)
arr1 = arr1 / jnp.exp(hyper[:, 1:])
arr2 = arr2 / jnp.exp(hyper[:, 1:])
dist = pairwise_distance_jax(arr1, arr2)
kernel = jnp.exp(hyper[:, 0]) * jnp.exp(-0.5 * dist)
return kernel
```
```python
def xtransform_jax(xtest: jnp.ndarray, cholfactor: jnp.ndarray, meanparams: jnp.ndarray):
xtest = xtest.reshape(1, -1)
xtest_trans = jnp.linalg.inv(cholfactor) @ (xtest - meanparams).T
xtest_trans = xtest_trans.T
return xtest_trans
```
```python
def convert_dict_nparray_jaxarray(dictionary):
record = {}
for key in dictionary:
record[key] = jnp.asarray(dictionary[key])
return record
```
```python
def calculate_cosmo_logpdf_jax(testpoint: dict):
"""Generates the entity of each parameter by using scipy.stats function.
Args:
dictionary (dict): A dictionary with the specifications of the prior.
Returns:
dict: the prior distribution of all parameters.
"""
logpdf = jnp.zeros(1)
for key in testpoint:
function = getattr(getattr(jss, COSMO_PRIORS[key]['distribution']), 'logpdf')
logpdf += function(testpoint[key], COSMO_PRIORS[key]['loc'], COSMO_PRIORS[key]['scale'])
return logpdf
```
```python
def jaxarray_to_dict(point: jnp.ndarray) -> dict:
keys = COSMO_PRIORS.keys()
param = {}
for i, key in enumerate(keys):
param[key] = point[i]
return param
```
```python
def prediction_jax(xtest: jnp.ndarray, quantities: list):
# the cosmologies are fixed and the cholesky factor is the same for all
xtest_trans = xtransform_jax(xtest, quantities[0]['cholfactor'], quantities[0]['meanparams'])
ngps = len(quantities)
predictions = []
for i in range(ngps):
kstar = compute_jax(quantities[i]['xtrain'], xtest_trans, quantities[i]['hyperparams'])
pred = kstar.T @ quantities[i]['alpha']
pred = pred * quantities[i]['ystd'] + quantities[i]['ymean']
predictions.append(pred)
predictions = jnp.asarray(predictions).reshape(-1)
return predictions
```
```python
def prediction_pklin_jax(xtest: jnp.ndarray, quantities: list):
ypred = prediction_jax(xtest, quantities)
return jnp.exp(ypred)
```
```python
def prediction_gf_jax(xtest: jnp.ndarray, quantities: list):
ypred = prediction_jax(xtest, quantities)
return jnp.concatenate([jnp.ones(1), ypred])
```
Check that the log-prior is fully differentiable.
```python
jacobian_prior = jit(jacfwd(calculate_cosmo_logpdf_jax))
```
```python
point = jaxarray_to_dict(test_cosmo.iloc[0].values)
```
```python
calculate_cosmo_logpdf_jax(point)
```
DeviceArray([8.69641556], dtype=float64)
```python
jacobian_prior(point)
```
{'Omega_b': DeviceArray([0.], dtype=float64),
'Omega_cdm': DeviceArray([0.], dtype=float64),
'h': DeviceArray([0.], dtype=float64),
'n_s': DeviceArray([0.], dtype=float64),
'sigma8': DeviceArray([0.], dtype=float64)}
The stored quantities are in ordinary numpy arrays. We need jax numpy arrays.
### Predict the Power Spectrum with JAX
```python
point_jax = jnp.array(test_cosmo.iloc[0].values)
```
```python
pklin_jax_0 = prediction_pklin_jax(point_jax, quantities_pklin)
gf_jax_0 = prediction_gf_jax(point_jax, quantities_gf)
```
```python
plt.figure(figsize = (20,8))
plt.subplot(121)
plt.loglog(kgrid, pklin_pt, lw = 3, label = 'PyTorch')
plt.loglog(kgrid, pklin_np, lw = 3, linestyle = '--', label = 'Numpy')
plt.loglog(kgrid, pklin_class, lw = 3, linestyle = ':', label = 'CLASS')
plt.scatter(kgrid, pklin_jax_0, label = 'JAX')
plt.xlim(min(kgrid), max(kgrid))
plt.legend(loc = 'best',prop={'family':'sans-serif', 'size':15})
plt.ylabel(r'$P_{l}(k,0)$', fontsize = fontSize)
plt.xlabel(r'$k\;[\textrm{Mpc}^{-1}]$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.subplot(122)
plt.plot(zgrid, gf_pt, lw = 3, label = 'PyTorch')
plt.plot(zgrid, gf_np, lw = 3, linestyle = '--', label = 'Numpy')
plt.plot(zgrid, gf_class, lw = 3, linestyle = ':', label = 'CLASS')
plt.scatter(zgrid, gf_jax_0, label = 'JAX')
plt.xlim(min(zgrid), max(zgrid))
plt.legend(loc = 'best',prop={'family':'sans-serif', 'size':15})
plt.ylabel(r'$G(z)$', fontsize = fontSize)
plt.xlabel(r'$z$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.show()
```
Jacobian of the linear matter power spectrum.
```python
jacobian_pklin = jit(jacfwd(prediction_pklin_jax))
```
```python
%%time
jac_pklin = jacobian_pklin(point_jax, quantities_pklin)
```
CPU times: user 7.34 ms, sys: 89 µs, total: 7.42 ms
Wall time: 3.57 ms
Finite difference using CLASS.
```python
point_fd = test_cosmo.iloc[0]
eps = 1E-3
jac_class = {}
for i, key in enumerate(point_fd.keys()):
point_fd_p = point_fd.copy()
point_fd_n = point_fd.copy()
point_fd_p[i] += eps
point_fd_n[i] -= eps
pklin_class_p, gf_class_p = calculate_quantities(dict(point_fd_p), cfg)
pklin_class_n, gf_class_n = calculate_quantities(dict(point_fd_n), cfg)
jac_class[key] = (pklin_class_p - pklin_class_n) / (2*eps)
```
```python
labels = [r'$\sigma_{8}$', r'$\Omega_{c}$', r'$\Omega_{b}$', r'$h$', r'$n_{s}$']
plt.figure(figsize = (24, 12))
for i, key in enumerate(point_fd.keys()):
spline = interpolate.splrep(np.log(kgrid), jac_pklin[:,i])
ynew = interpolate.splev(np.log(kfine), spline)
spline_class = interpolate.splrep(np.log(kgrid), jac_class[key])
ynew_class = interpolate.splev(np.log(kfine), spline_class)
plt.subplot(2, 3, i+1)
plt.plot(kfine, ynew, lw = 5, label = 'JAX Cosmo', c = 'k')
plt.plot(kfine, ynew_class, lw = 5, linestyle = '--', label = 'CLASS', c = 'y')
plt.xlim(min(kgrid), max(kgrid))
plt.ylabel(r'$\frac{\partial P_{l}(k,0)}{\partial \theta_{i}}$', fontsize = fontSize)
plt.xlabel(r'$k\;[\textrm{Mpc}^{-1}]$', fontsize = fontSize)
plt.tick_params(axis='x', labelsize=fontSize)
plt.tick_params(axis='y', labelsize=fontSize)
plt.legend(loc = 'center right',prop={'family':'sans-serif', 'size':20})
plt.xscale('log')
plt.ticklabel_format(axis='y', style='sci', scilimits=(0,4))
plt.subplots_adjust(wspace=0.25, hspace=0.25)
plt.show()
```
|
Harry45REPO_NAMEDESEMUPATH_START.@DESEMU_extracted@DESEMU-main@emulator.ipynb@.PATH_END.py
|
{
"filename": "TestRun_PolNum_split_1spot.py",
"repo_name": "xpsi-group/xpsi",
"repo_path": "xpsi_extracted/xpsi-main/examples/examples_modeling_tutorial/TestRun_PolNum_split_1spot.py",
"type": "Python"
}
|
'''
Test script with the polarized 3+2 numerical atmosphere applied to a one-spot model.
Prequisities:
Before running the script, add the atmosphere data to the model_data subdirectory:
Bobrikova_compton_slab_I.npz and Bobrikova_compton_slab_Q.npz. See the
example script in xpsi/examples/produce_atmos_lookuptable for producing these files
from those provided in https://github.com/AnnaBobrikova/ComptonSlabTables.
'''
import os
import numpy as np
import math
from matplotlib import pyplot as plt
import xpsi
from xpsi.global_imports import _c, gravradius, _keV, _k_B, _h_keV
np.random.seed(xpsi._rank+10)
print('Rank reporting: %d' % xpsi._rank)
this_directory = os.path.dirname(os.path.abspath(__file__))
bounds = dict(distance = (0.1, 1.0), # (Earth) distance
mass = (1.0, 3.0), # mass
radius = (3.0 * gravradius(1.0), 16.0), # equatorial radius
cos_inclination = (0.0, 1.0)) # (Earth) inclination to rotation axis
spacetime = xpsi.Spacetime(bounds=bounds, values=dict(frequency=400.9752075))
from xpsi.Parameter import Parameter
from modules.CustomHotRegion_Accreting import CustomHotRegion_Accreting
bounds = dict(super_colatitude = (None, None),
super_radius = (None, None),
phase_shift = (0.0, 0.1),
super_tbb = (0.001, 0.003),
super_tau = (0.5, 3.5),
super_te = (40.0, 200.0))
primary = CustomHotRegion_Accreting(bounds=bounds,
values={},
symmetry=True,
omit=False,
cede=False,
concentric=False,
sqrt_num_cells=32, #100
min_sqrt_num_cells=10,
max_sqrt_num_cells=64, #100
num_leaves=100,
num_rays=200,
split=True,
image_order_limit=3,
prefix='p')
from xpsi import HotRegions
hot = HotRegions((primary,))
use_elsewhere = False #True
if use_elsewhere:
bounds=dict(elsewhere_temperature = (3.0, 7.5))
elsewhere = xpsi.Elsewhere(bounds=bounds,
values={},
sqrt_num_cells=512,
num_rays=512,
atm_ext="BB")
else:
elsewhere = None
from modules.CustomPhotosphere import CustomPhotosphere_NumA5
bounds = dict(spin_axis_position_angle = (None, None))
photosphere = CustomPhotosphere_NumA5(hot = hot, elsewhere = elsewhere, stokes=True, bounds=bounds,
values=dict(mode_frequency = spacetime['frequency']))
photosphere.hot_atmosphere = this_directory+'/model_data/Bobrikova_compton_slab_I.npz'
photosphere.hot_atmosphere_Q = this_directory+'/model_data/Bobrikova_compton_slab_Q.npz'
photosphere['mode_frequency'] == spacetime['frequency']
star = xpsi.Star(spacetime = spacetime, photospheres = photosphere)
print("Parameters of the star:")
print(star.params, len(star.params))
# SAX J1808-like
mass = 1.4
radius = 12.0
distance = 3.5
inclination = 10.0 #60.0
cos_i = math.cos(inclination*math.pi/180.0)
chi0 = 0.0
# Hotspot
phase_shift = 0.0
super_colatitude = 105.0*math.pi/180.0 #45.0*math.pi/180.0
super_radius = 1.0*math.pi/180.0 #15.5*math.pi/180.0
# Compton slab model parameters
tbb=0.002 #0.0012
te=100.0 # 50.0
tau=1.6 #1.0
#Tbb = 1 keV <=> tbb = 0.002 (roughly)
#Te = 50 keV <=> te = 100 (roughly)
p = [mass, #grav mass
radius, #coordinate equatorial radius
distance, # earth distance kpc
cos_i, #cosine of earth inclination
chi0, #spin axis position angle
phase_shift, #phase of hotregion
super_colatitude, #colatitude of centre of superseding region
super_radius, #angular radius superceding region
tbb,
te,
tau
]
print(len(p))
# elsewhere
elsewhere_T_keV = 0.4 # keV
from modules.helper_functions import get_T_in_log10_Kelvin
elsewhere_T_log10_K = get_T_in_log10_Kelvin(elsewhere_T_keV)
if use_elsewhere:
p.append(elsewhere_T_log10_K)
star(p)
star.update()
#start = time.time()
#To get the incident signal before interstellar absorption or operating with the telescope:
energies = np.logspace(np.log10(0.15), np.log10(12.0), 400, base=10.0)
photosphere.integrate(energies, threads=1) # the number of OpenMP threads to use
#end = time.time()
#print("Time spent in integration:",end - start)
#exit()
# print("Bolometric profiles for I, Q, and U:")
# print(repr(np.sum(photosphere.signal[0][0], axis=0)))
# print(repr(np.sum(photosphere.signalQ[0][0], axis=0)))
# print(repr(np.sum(photosphere.signalU[0][0], axis=0)))
StokesI = photosphere.signal[0][0]
StokesQ = photosphere.signalQ[0][0]
StokesU = photosphere.signalU[0][0]
# from modules.CustomInterstellar import CustomInterstellar
#Uncomment the following code (and download the required input table) if want to add interstellar attenuation to the modeled signal:
#column_density = 1.17 #10^21 cm^-2
#interstellar = CustomInterstellar.from_SWG(this_directory+'/model_data/tbnew0.14.txt', bounds=(None, None), value=column_density)
#interstellar(energies, StokesI)
#interstellar(energies, StokesQ)
#interstellar(energies, StokesU)
plt.plot(energies[0:50],np.sum(StokesI,axis=1)[0:50])
#print(energies[0:130])
print(np.sum(StokesI,axis=1)[0:130])
plt.ylabel('Flux [?]')
plt.xlabel('Energy [keV]')
# plt.ylim(0.0,8.0e31)
#plt.savefig("figs/spectrum_after_ism.png")
#exit()
k_B_over_keV = _k_B / _keV
from scipy.integrate import quad
_c_cgs = _c*1E2
class CustomBackground_DiskBB(xpsi.Background):
""" The background injected to generate synthetic data. """
def __init__(self, bounds=None, values=None, interstellar = None):
self.interstellar = interstellar
doc = """
Temperature at inner disk radius in log10 Kelvin.
"""
inner_temperature = xpsi.Parameter('T_in',
strict_bounds = (3., 10.),
bounds = bounds.get('T_in', None),
doc = doc,
symbol = r'$T_{in}$',
value = values.get('T_in', None))
doc = """
Disk R_in in kilometers.
"""
inner_radius = xpsi.Parameter('R_in',
strict_bounds = (0., 1e3),
bounds = bounds.get('R_in', None),
doc = doc,
symbol = r'$R_{in}$',
value = values.get('R_in', None))
doc = """
Disk normalisation cos_i*R_in^2/D^2 in (km / 10 kpc)^2.
"""
background_normalisation = xpsi.Parameter('K_disk',
strict_bounds = (0., 1e8),
bounds = bounds.get('K_disk', None),
doc = doc,
symbol = r'$K_{BB}$',
value = values.get('K_disk', None))
super(CustomBackground_DiskBB, self).__init__(inner_temperature, inner_radius, background_normalisation)
def __call__(self, energy_edges, phases, interstellar = None):
pass #Do nothing, since not needed in this example.
def get_f_disk(self, energies, spectral_radiance, attenuate = False):
""" Evaluate f_disk(energies).
f_disk(E) = 4/3*pi * K_disk * l_disk(b_E/B_E, E)
Ref: Mitsuda et al. 1984, Makishima et al. 1986
But note that Mitsuda et al. 1984 has an extra factor here because they
don't have it in the definition for b_E/B_E.
parameters
energies[keV]
spectral_radiance can be: b_E or B_E
attenuate determines whether to apply interstellar medium attenuation.
returns
f_disk [photons/s/cm^2/keV] or [keV/s/cm^2/keV]
"""
T_in = self['T_in']
K_disk = self['K_disk']
# KbT in keV
T_in_keV = k_B_over_keV * pow(10.0, T_in)
T_out_keV = T_in_keV*1e-1
epsrel = 1e-4
f_disk_array = np.array([]) #photons/s/cm^2/sr or keV/s/cm^2/sr
for energy in energies:
f_disk_value = self.l_disk(energy, T_in_keV, T_out_keV, spectral_radiance, epsrel)
f_disk_array=np.append(f_disk_array,f_disk_value)
# K_disk is cos_i*R_in^2/D^2 in (km / 10 kpc)^2.
# (1 km / 10 kpc)^2 = 1.0502650e-35 [ cm/cm ]
f_disk_array *=K_disk*4*np.pi/3*1.0502650e-35 # photons/s/cm^2/energy_bin
#print("f_disk_array:",f_disk_array)
#exit()
# Apply Interstellar if not None
if self.interstellar is not None and attenuate:
self.interstellar(energies, f_disk_array) # bkg is overwritten here
return f_disk_array
def b_E(self, E, T):
'''
photon radiance of a blackbody
parameters:
E in keV
T in keV
returns:
b_E in photons/s/keV/cm^2/sr
'''
b = 2*E**2/(_h_keV**3*_c_cgs**2)/(np.exp(E/T)-1)
return b
def B_E(self, E, T):
'''
Energy radiance of a blackbody.
parameters:
E in keV
T in keV
returns:
B_E in keV/s/keV/cm^2/sr (you will integrate over keV)
'''
B = 2*E**3/(_h_keV**3*_c_cgs**2)/(np.exp(E/T)-1)
return B
def l_disk_integrand(self, T, E, T_in, spectral_radiance):
'''
parameters:
T, T_in in keV
E in keV
returns:
integrand in spectral radiance units/keV. This integrand will
be integrated over keV.
'''
# print('T: ', T)
# print('E:', E)
# print('T_in: ', T_in)
# print('(T/T_in)**(-11/3)', (T/T_in)**(-11/3))
# print('spectral_radiance(E, T)/T_in', spectral_radiance(E, T)/T_in)
integrand = (T/T_in)**(-11/3)*spectral_radiance(E, T)/T_in
return integrand
def l_disk(self, E, T_in, T_out, spectral_radiance, epsrel):
'''
parameters:
T, T_in in keV
E in keV
returns:
disk luminosity [spectral radiance units].
'''
disk_luminosity,_= quad(self.l_disk_integrand, T_out, T_in, args=(E, T_in, spectral_radiance), epsrel=epsrel)
return disk_luminosity
from xpsi import Derive
def get_k_disk(cos_i, r_in, distance):
"""
This function calculates the k-disk value for a given set of input parameters.
Args:
cos_i: The cosine inclination angle of the disk, can be a scalar or a tuple.
r_in: The inner radius of the disk in kilometers, can be a scalar or a tuple.
distance: The distance to the disk in kiloparsecs, can be a scalar or a tuple.
Returns:
A tuple containing the k-disk values for each element in the input parameters.
Raises:
ValueError: If the input tuples have different lengths.
"""
if isinstance(cos_i, tuple) and isinstance(r_in, tuple) and isinstance(distance, tuple):
if len(cos_i) != len(r_in) or len(cos_i) != len(distance):
raise ValueError("Input tuples must have the same length.")
# Use a loop instead of recursion
k_disk_values = []
for c, r, d in zip(cos_i, r_in, distance):
k_disk_values.append(c * (r / (d / 10))**2)
return tuple(k_disk_values)
else:
# return cos_i * (r_in / (distance / 10))**2
# scaling k_disk further to match signal units
distance_m = 3.08567758128e19*distance
return cos_i * (r_in / (distance / 10))**2 * distance_m**2
class k_disk_derive(Derive):
def __init__(self):
pass
def __call__(self, boundto, caller = None):
# ref is a reference to another hot region object
return get_k_disk(self.star['cos_inclination'], self.background['R_in'], self.star['distance'])
#An example of how to add disk background to StokesI:
add_disk_bkg = True
if add_disk_bkg:
star = xpsi.Star(spacetime = spacetime, photospheres = photosphere)
# from modules.CustomBackground_DiskBB import CustomBackground_DiskBB, k_disk_derive
k_disk = k_disk_derive()
T_in = get_T_in_log10_Kelvin(0.25) #(0.29)
R_in = 30.0 #55.0
values = {'T_in':T_in,'R_in':R_in,'K_disk': k_disk}
background = CustomBackground_DiskBB(bounds={}, values=values)#, interstellar = interstellar)
k_disk.star = star
k_disk.background = background
spectral_radiance = background.B_E
distance_m = 3.08567758128e19*distance
#Converting to photosphere.signal units
bkg = background.get_f_disk(energies, spectral_radiance)*distance_m**2/energies
#interstellar(energies, bkg)
for ip in range(len(hot.phases_in_cycles[0])):
StokesI[:,ip] = StokesI[:,ip] + bkg
def get_photosphere_stokes_1spot():
#Return signal from the spot to ixpeobssim
return hot.phases_in_cycles[0], energies, StokesI, StokesQ, StokesU
|
xpsi-groupREPO_NAMExpsiPATH_START.@xpsi_extracted@xpsi-main@examples@examples_modeling_tutorial@TestRun_PolNum_split_1spot.py@.PATH_END.py
|
{
"filename": "calculator.py",
"repo_name": "NannyML/nannyml",
"repo_path": "nannyml_extracted/nannyml-main/nannyml/data_quality/range/calculator.py",
"type": "Python"
}
|
# Author: James Nesfield <jamesnesfield@live.com>
#
# License: Apache Software License 2.0
"""Continuous numerical variable range monitor to ensure range supplied is within training bounds."""
from typing import Any, Dict, List, Optional, Union
import numpy as np
import pandas as pd
from pandas import MultiIndex
from nannyml.base import AbstractCalculator, _list_missing, _split_features_by_type
from nannyml.chunk import Chunker
from nannyml.exceptions import InvalidArgumentsException
from nannyml.thresholds import Threshold, calculate_threshold_values, ConstantThreshold
from nannyml.usage_logging import UsageEvent, log_usage
from .result import Result
"""
Values Out Of Range Data Quality Module.
"""
class NumericalRangeCalculator(AbstractCalculator):
"""NumericalRangeCalculator ensures the monitoring data set numerical ranges match the reference data set ones."""
def __init__(
self,
column_names: Union[str, List[str]],
normalize: bool = True,
timestamp_column_name: Optional[str] = None,
chunk_size: Optional[int] = None,
chunk_number: Optional[int] = None,
chunk_period: Optional[str] = None,
chunker: Optional[Chunker] = None,
threshold: Threshold = ConstantThreshold(lower=None, upper=0),
):
"""Creates a new NumericalRangeCalculator instance.
Parameters
----------
column_names: Union[str, List[str]]
A string or list containing the names of features in the provided data set.
Missing Values will be calculated for each entry in this list.
normalize: bool, default=True
Whether to provide the missing value ratio (True) or the absolute number of missing values (False).
timestamp_column_name: str
The name of the column containing the timestamp of the model prediction.
chunk_size: int
Splits the data into chunks containing `chunks_size` observations.
Only one of `chunk_size`, `chunk_number` or `chunk_period` should be given.
chunk_number: int
Splits the data into `chunk_number` pieces.
Only one of `chunk_size`, `chunk_number` or `chunk_period` should be given.
chunk_period: str
Splits the data according to the given period.
Only one of `chunk_size`, `chunk_number` or `chunk_period` should be given.
chunker : Chunker
The `Chunker` used to split the data sets into a lists of chunks.
threshold: Threshold, default=StandardDeviationThreshold
The threshold you wish to evaluate values on. Defaults to a StandardDeviationThreshold with default
options. The other available value is ConstantThreshold.
Examples
--------
>>> import nannyml as nml
>>> reference_df, analysis_df, _ = nml.load_synthetic_car_price_dataset()
>>> feature_column_names = [col for col in reference_df.columns if col not in [
... 'fuel','transmission','timestamp', 'y_pred', 'y_true']]
>>> calc = nml.NumericalRangeCalculator(
... column_names=feature_column_names,
... timestamp_column_name='timestamp',
... ).fit(reference_df)
>>> res = calc.calculate(analysis_df)
>>> res.filter(period='analysis').plot().show()
"""
super(NumericalRangeCalculator, self).__init__(
chunk_size, chunk_number, chunk_period, chunker, timestamp_column_name
)
if isinstance(column_names, str):
self.column_names = [column_names]
elif isinstance(column_names, list):
for el in column_names:
if not isinstance(el, str):
raise InvalidArgumentsException(
f"column_names elements should be either a column name string or a list of strings, found\n{el}"
)
self.column_names = column_names
else:
raise InvalidArgumentsException(
"column_names should be either a column name string or a list of columns names strings, "
"found\n{column_names}"
)
self.result: Optional[Result] = None
# threshold strategy is the same across all columns
self.threshold = threshold
self._upper_alert_thresholds: Dict[str, Optional[float]] = {column_name: 0 for column_name in self.column_names}
self._lower_alert_thresholds: Dict[str, Optional[float]] = {column_name: 0 for column_name in self.column_names}
self.lower_threshold_value_limit: float = 0
self.upper_threshold_value_limit: Optional[float] = None
self.normalize = normalize
if self.normalize:
self.data_quality_metric = 'out_of_range_values_rate'
self.upper_threshold_value_limit = 1
else:
self.data_quality_metric = 'out_of_range_values_count'
self.upper_threshold_value_limit = np.nan
# object tracks values as list [min,max]
self._reference_value_ranges: Dict[str, list] = {column_name: list() for column_name in self.column_names}
def _calculate_out_of_range_stats(self, data: pd.Series, lower_bound: float, upper_bound: float):
# to do make this calc out of range stats
count_tot = data.shape[0]
count_out_of_range = ((data < lower_bound) | (data > upper_bound)).sum()
if self.normalize:
count_out_of_range = count_out_of_range / count_tot
return count_out_of_range
@log_usage(UsageEvent.DQ_CALC_VALUES_OUT_OF_RANGE_FIT, metadata_from_self=['normalize'])
def _fit(self, reference_data: pd.DataFrame, *args, **kwargs):
"""Fits the drift calculator to a set of reference data."""
if reference_data.empty:
raise InvalidArgumentsException('data contains no rows. Please provide a valid data set.')
_list_missing(self.column_names, reference_data)
# All provided columns must be continuous
# We do not make int categorical
continuous_column_names, categorical_column_names = _split_features_by_type(reference_data, self.column_names)
if not set(self.column_names) == set(continuous_column_names):
raise InvalidArgumentsException(
f"Specified columns_names for NumericalRangeCalculator must all be continuous. "
f"Categorical columns found: {categorical_column_names}"
)
for col in self.column_names:
self._reference_value_ranges[col] = [reference_data[col].min(), reference_data[col].max()]
self.result = self._calculate(data=reference_data)
self.result.data[('chunk', 'period')] = 'reference'
return self
@log_usage(UsageEvent.DQ_CALC_VALUES_OUT_OF_RANGE_RUN, metadata_from_self=['normalize'])
def _calculate(self, data: pd.DataFrame, *args, **kwargs) -> Result:
"""Calculates methods for both categorical and continuous columns."""
if data.empty:
raise InvalidArgumentsException('data contains no rows. Please provide a valid data set.')
_list_missing(self.column_names, data)
chunks = self.chunker.split(data)
rows = []
for chunk in chunks:
row = {
'key': chunk.key,
'chunk_index': chunk.chunk_index,
'start_index': chunk.start_index,
'end_index': chunk.end_index,
'start_datetime': chunk.start_datetime,
'end_datetime': chunk.end_datetime,
'period': 'analysis',
}
for column_name in self.column_names:
for k, v in self._calculate_for_column(chunk.data, column_name).items():
row[f'{column_name}_{k}'] = v
rows.append(row)
result_index = _create_multilevel_index(
column_names=self.column_names,
)
res = pd.DataFrame(rows)
res.columns = result_index
res = res.reset_index(drop=True)
if self.result is None:
self._set_metric_thresholds(res)
res = self._populate_alert_thresholds(res)
self.result = Result(
results_data=res,
column_names=self.column_names,
data_quality_metric=self.data_quality_metric,
timestamp_column_name=self.timestamp_column_name,
chunker=self.chunker,
)
else:
# TODO: review subclassing setup => superclass + '_filter' is screwing up typing.
# Dropping the intermediate '_filter' and directly returning the correct 'Result' class works OK
# but this causes us to lose the "common behavior" in the top level 'filter' method when overriding.
# Applicable here but to many of the base classes as well (e.g. fitting and calculating)
res = self._populate_alert_thresholds(res)
self.result = self.result.filter(period='reference')
self.result.data = pd.concat([self.result.data, res], ignore_index=True)
return self.result
def _calculate_for_column(self, data: pd.DataFrame, column_name: str) -> Dict[str, Any]:
result = {}
value_range = self._reference_value_ranges[column_name]
value = self._calculate_out_of_range_stats(data[column_name], value_range[0], value_range[1])
result['value'] = value
return result
def _set_metric_thresholds(self, result_data: pd.DataFrame):
for column_name in self.column_names:
(
self._lower_alert_thresholds[column_name],
self._upper_alert_thresholds[column_name],
) = calculate_threshold_values( # noqa: E501
threshold=self.threshold,
data=result_data.loc[:, (column_name, 'value')],
lower_threshold_value_limit=self.lower_threshold_value_limit,
upper_threshold_value_limit=self.upper_threshold_value_limit,
logger=self._logger,
)
def _populate_alert_thresholds(self, result_data: pd.DataFrame) -> pd.DataFrame:
for column_name in self.column_names:
result_data[(column_name, 'upper_threshold')] = self._upper_alert_thresholds[column_name]
result_data[(column_name, 'lower_threshold')] = self._lower_alert_thresholds[column_name]
result_data[(column_name, 'alert')] = result_data.apply(
lambda row: True
if (
row[(column_name, 'value')]
> (
np.inf
if row[(column_name, 'upper_threshold')] is None
else row[(column_name, 'upper_threshold')] # noqa: E501
)
or row[(column_name, 'value')]
< (
-np.inf
if row[(column_name, 'lower_threshold')] is None
else row[(column_name, 'lower_threshold')] # noqa: E501
)
)
else False,
axis=1,
)
return result_data
def _create_multilevel_index(
column_names,
):
chunk_column_names = ['key', 'chunk_index', 'start_index', 'end_index', 'start_date', 'end_date', 'period']
chunk_tuples = [('chunk', chunk_column_name) for chunk_column_name in chunk_column_names]
column_tuples = [
(column_name, 'value')
for column_name in column_names
# for el in ['value', 'upper_threshold', 'lower_threshold', 'alert']
]
tuples = chunk_tuples + column_tuples
return MultiIndex.from_tuples(tuples)
|
NannyMLREPO_NAMEnannymlPATH_START.@nannyml_extracted@nannyml-main@nannyml@data_quality@range@calculator.py@.PATH_END.py
|
{
"filename": "_tickfont.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/validators/layout/ternary/caxis/_tickfont.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator):
def __init__(
self, plotly_name="tickfont", parent_name="layout.ternary.caxis", **kwargs
):
super(TickfontValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
data_class_str=kwargs.pop("data_class_str", "Tickfont"),
data_docs=kwargs.pop(
"data_docs",
"""
color
family
HTML font family - the typeface that will be
applied by the web browser. The web browser
will only be able to apply a font if it is
available on the system which it operates.
Provide multiple font families, separated by
commas, to indicate the preference in which to
apply fonts if they aren't available on the
system. The Chart Studio Cloud (at
https://chart-studio.plotly.com or on-premise)
generates images on a server, where only a
select number of fonts are installed and
supported. These include "Arial", "Balto",
"Courier New", "Droid Sans",, "Droid Serif",
"Droid Sans Mono", "Gravitas One", "Old
Standard TT", "Open Sans", "Overpass", "PT Sans
Narrow", "Raleway", "Times New Roman".
size
""",
),
**kwargs
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@validators@layout@ternary@caxis@_tickfont.py@.PATH_END.py
|
{
"filename": "_tokenizer.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/setuptools/py3/setuptools/_distutils/_vendor/packaging/_tokenizer.py",
"type": "Python"
}
|
import contextlib
import re
from dataclasses import dataclass
from typing import Dict, Iterator, NoReturn, Optional, Tuple, Union
from .specifiers import Specifier
@dataclass
class Token:
name: str
text: str
position: int
class ParserSyntaxError(Exception):
"""The provided source text could not be parsed correctly."""
def __init__(
self,
message: str,
*,
source: str,
span: Tuple[int, int],
) -> None:
self.span = span
self.message = message
self.source = source
super().__init__()
def __str__(self) -> str:
marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^"
return "\n ".join([self.message, self.source, marker])
DEFAULT_RULES: "Dict[str, Union[str, re.Pattern[str]]]" = {
"LEFT_PARENTHESIS": r"\(",
"RIGHT_PARENTHESIS": r"\)",
"LEFT_BRACKET": r"\[",
"RIGHT_BRACKET": r"\]",
"SEMICOLON": r";",
"COMMA": r",",
"QUOTED_STRING": re.compile(
r"""
(
('[^']*')
|
("[^"]*")
)
""",
re.VERBOSE,
),
"OP": r"(===|==|~=|!=|<=|>=|<|>)",
"BOOLOP": r"\b(or|and)\b",
"IN": r"\bin\b",
"NOT": r"\bnot\b",
"VARIABLE": re.compile(
r"""
\b(
python_version
|python_full_version
|os[._]name
|sys[._]platform
|platform_(release|system)
|platform[._](version|machine|python_implementation)
|python_implementation
|implementation_(name|version)
|extra
)\b
""",
re.VERBOSE,
),
"SPECIFIER": re.compile(
Specifier._operator_regex_str + Specifier._version_regex_str,
re.VERBOSE | re.IGNORECASE,
),
"AT": r"\@",
"URL": r"[^ \t]+",
"IDENTIFIER": r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b",
"VERSION_PREFIX_TRAIL": r"\.\*",
"VERSION_LOCAL_LABEL_TRAIL": r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*",
"WS": r"[ \t]+",
"END": r"$",
}
class Tokenizer:
"""Context-sensitive token parsing.
Provides methods to examine the input stream to check whether the next token
matches.
"""
def __init__(
self,
source: str,
*,
rules: "Dict[str, Union[str, re.Pattern[str]]]",
) -> None:
self.source = source
self.rules: Dict[str, re.Pattern[str]] = {
name: re.compile(pattern) for name, pattern in rules.items()
}
self.next_token: Optional[Token] = None
self.position = 0
def consume(self, name: str) -> None:
"""Move beyond provided token name, if at current position."""
if self.check(name):
self.read()
def check(self, name: str, *, peek: bool = False) -> bool:
"""Check whether the next token has the provided name.
By default, if the check succeeds, the token *must* be read before
another check. If `peek` is set to `True`, the token is not loaded and
would need to be checked again.
"""
assert (
self.next_token is None
), f"Cannot check for {name!r}, already have {self.next_token!r}"
assert name in self.rules, f"Unknown token name: {name!r}"
expression = self.rules[name]
match = expression.match(self.source, self.position)
if match is None:
return False
if not peek:
self.next_token = Token(name, match[0], self.position)
return True
def expect(self, name: str, *, expected: str) -> Token:
"""Expect a certain token name next, failing with a syntax error otherwise.
The token is *not* read.
"""
if not self.check(name):
raise self.raise_syntax_error(f"Expected {expected}")
return self.read()
def read(self) -> Token:
"""Consume the next token and return it."""
token = self.next_token
assert token is not None
self.position += len(token.text)
self.next_token = None
return token
def raise_syntax_error(
self,
message: str,
*,
span_start: Optional[int] = None,
span_end: Optional[int] = None,
) -> NoReturn:
"""Raise ParserSyntaxError at the given position."""
span = (
self.position if span_start is None else span_start,
self.position if span_end is None else span_end,
)
raise ParserSyntaxError(
message,
source=self.source,
span=span,
)
@contextlib.contextmanager
def enclosing_tokens(
self, open_token: str, close_token: str, *, around: str
) -> Iterator[None]:
if self.check(open_token):
open_position = self.position
self.read()
else:
open_position = None
yield
if open_position is None:
return
if not self.check(close_token):
self.raise_syntax_error(
f"Expected matching {close_token} for {open_token}, after {around}",
span_start=open_position,
)
self.read()
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@setuptools@py3@setuptools@_distutils@_vendor@packaging@_tokenizer.py@.PATH_END.py
|
{
"filename": "state.py",
"repo_name": "glue-viz/glue",
"repo_path": "glue_extracted/glue-main/glue/viewers/image/state.py",
"type": "Python"
}
|
import uuid
from collections import defaultdict
from glue.core import BaseData, Data
from glue.config import colormaps
from glue.viewers.matplotlib.state import (MatplotlibDataViewerState,
MatplotlibLayerState,
DeferredDrawCallbackProperty as DDCProperty,
DeferredDrawSelectionCallbackProperty as DDSCProperty)
from glue.core.state_objects import StateAttributeLimitsHelper
from glue.utils import defer_draw, view_shape
from echo import delay_callback
from glue.core.data_combo_helper import ManualDataComboHelper, ComponentIDComboHelper
from glue.core.exceptions import IncompatibleDataException
from glue.viewers.common.stretch_state_mixin import StretchStateMixin
from glue.core.units import find_unit_choices
__all__ = ['ImageViewerState', 'ImageLayerState', 'ImageSubsetLayerState', 'AggregateSlice']
def get_sliced_data_maker(x_axis=None, y_axis=None, slices=None, data=None,
target_cid=None, reference_data=None, transpose=False):
"""
Convenience function for use in exported Python scripts.
"""
if reference_data is None:
reference_data = data
def get_array(bounds=None):
full_bounds = list(slices)
full_bounds[y_axis] = bounds[0]
full_bounds[x_axis] = bounds[1]
if isinstance(data, BaseData):
array = data.compute_fixed_resolution_buffer(full_bounds, target_data=reference_data,
target_cid=target_cid, broadcast=False)
else:
array = data.data.compute_fixed_resolution_buffer(full_bounds, target_data=reference_data,
subset_state=data.subset_state, broadcast=False)
if transpose:
array = array.transpose()
return array
return get_array
class AggregateSlice(object):
def __init__(self, slice=None, center=None, function=None):
self.slice = slice
self.center = center
self.function = function
def __gluestate__(self, context):
state = dict(slice=context.do(self.slice),
center=self.center,
function=context.do(self.function))
return state
@classmethod
def __setgluestate__(cls, rec, context):
return cls(slice=context.object(rec['slice']),
center=rec['center'],
function=context.object(rec['function']))
class ImageViewerState(MatplotlibDataViewerState):
"""
A state class that includes all the attributes for an image viewer.
"""
x_att = DDCProperty(docstring='The component ID giving the pixel component '
'shown on the x axis')
y_att = DDCProperty(docstring='The component ID giving the pixel component '
'shown on the y axis')
x_att_world = DDSCProperty(docstring='The component ID giving the world component '
'shown on the x axis', default_index=-1)
y_att_world = DDSCProperty(docstring='The component ID giving the world component '
'shown on the y axis', default_index=-2)
aspect = DDSCProperty(0, docstring='Whether to enforce square pixels (``equal``) '
'or fill the axes (``auto``)')
reference_data = DDSCProperty(docstring='The dataset that is used to define the '
'available pixel/world components, and '
'which defines the coordinate frame in '
'which the images are shown')
slices = DDCProperty(docstring='The current slice along all dimensions')
color_mode = DDSCProperty(0, docstring='Whether each layer can have '
'its own colormap (``Colormaps``) or '
'whether each layer is assigned '
'a single color (``One color per layer``)')
dpi = DDCProperty(72, docstring='The resolution (in dots per inch) of density maps, if present')
def __init__(self, **kwargs):
super(ImageViewerState, self).__init__()
self.limits_cache = {}
# NOTE: we don't need to use StateAttributeLimitsHelper here because
# we can simply call reset_limits below when x/y attributes change.
# Using StateAttributeLimitsHelper makes things a lot slower.
self.ref_data_helper = ManualDataComboHelper(self, 'reference_data')
self.xw_att_helper = ComponentIDComboHelper(self, 'x_att_world',
numeric=False, datetime=False, categorical=False)
self.yw_att_helper = ComponentIDComboHelper(self, 'y_att_world',
numeric=False, datetime=False, categorical=False)
self.add_callback('reference_data', self._reference_data_changed, priority=1000)
self.add_callback('layers', self._layers_changed, priority=1000)
self.add_callback('x_att', self._on_xatt_change, priority=500)
self.add_callback('y_att', self._on_yatt_change, priority=500)
self.add_callback('x_att_world', self._on_xatt_world_change, priority=1000)
self.add_callback('y_att_world', self._on_yatt_world_change, priority=1000)
aspect_display = {'equal': 'Square Pixels', 'auto': 'Automatic'}
ImageViewerState.aspect.set_choices(self, ['equal', 'auto'])
ImageViewerState.aspect.set_display_func(self, aspect_display.get)
ImageViewerState.color_mode.set_choices(self, ['Colormaps', 'One color per layer'])
self.update_from_dict(kwargs)
def reset_limits(self):
if self.reference_data is None or self.x_att is None or self.y_att is None:
return
nx = self.reference_data.shape[self.x_att.axis]
ny = self.reference_data.shape[self.y_att.axis]
with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'):
self.x_min = -0.5
self.x_max = nx - 0.5
self.y_min = -0.5
self.y_max = ny - 0.5
# We need to adjust the limits in here to avoid triggering all
# the update events then changing the limits again.
self._adjust_limits_aspect()
@property
def _display_world(self):
return getattr(self.reference_data, 'coords', None) is not None
def _reference_data_changed(self, *args, force=False):
# This signal can get emitted if just the choices but not the actual
# reference data change, so we check here that the reference data has
# actually changed
if self.reference_data is not getattr(self, '_last_reference_data', None) or force:
self._last_reference_data = self.reference_data
# Note that we deliberately use nested delay_callback here, because
# we want to make sure that x_att_world and y_att_world both get
# updated first, then x_att and y_att can be changed, before
# subsequent events are fired.
with delay_callback(self, 'x_att', 'y_att'):
with delay_callback(self, 'x_att_world', 'y_att_world', 'slices'):
if self._display_world:
self.xw_att_helper.pixel_coord = False
self.yw_att_helper.pixel_coord = False
self.xw_att_helper.world_coord = True
self.yw_att_helper.world_coord = True
else:
self.xw_att_helper.pixel_coord = True
self.yw_att_helper.pixel_coord = True
self.xw_att_helper.world_coord = False
self.yw_att_helper.world_coord = False
self._update_combo_att()
self._set_default_slices()
# We need to make sure that we update x_att and y_att
# at the same time before any other callbacks get called,
# so we do this here manually.
self._on_xatt_world_change()
self._on_yatt_world_change()
def _layers_changed(self, *args):
# The layers callback gets executed if anything in the layers changes,
# but we only care about whether the actual set of 'layer' attributes
# for all layers change.
layers_data = self.layers_data
layers_data_cache = getattr(self, '_layers_data_cache', [])
if layers_data == layers_data_cache:
return
self._update_combo_ref_data()
self._set_reference_data()
self._update_syncing()
self._layers_data_cache = layers_data
def _update_syncing(self):
# If there are multiple layers for a given dataset, we disable the
# syncing by default.
layer_state_by_data = defaultdict(list)
for layer_state in self.layers:
if isinstance(layer_state.layer, BaseData):
layer_state_by_data[layer_state.layer].append(layer_state)
for data, layer_states in layer_state_by_data.items():
if len(layer_states) > 1:
for layer_state in layer_states:
# Scatter layers don't have global_sync so we need to be
# careful here and make sure we return a default value
if getattr(layer_state, 'global_sync', False):
layer_state.global_sync = False
def _update_combo_ref_data(self):
self.ref_data_helper.set_multiple_data(self.layers_data)
def _update_combo_att(self):
with delay_callback(self, 'x_att_world', 'y_att_world'):
if self.reference_data is None:
self.xw_att_helper.set_multiple_data([])
self.yw_att_helper.set_multiple_data([])
else:
self.xw_att_helper.set_multiple_data([self.reference_data])
self.yw_att_helper.set_multiple_data([self.reference_data])
def _update_priority(self, name):
if name == 'layers':
return 3
elif name == 'reference_data':
return 2
elif name.endswith(('_min', '_max')):
return 0
else:
return 1
@defer_draw
def _on_xatt_change(self, *args):
if self.x_att is not None:
if self._display_world:
self.x_att_world = self.reference_data.world_component_ids[self.x_att.axis]
else:
self.x_att_world = self.x_att
@defer_draw
def _on_yatt_change(self, *args):
if self.y_att is not None:
if self._display_world:
self.y_att_world = self.reference_data.world_component_ids[self.y_att.axis]
else:
self.y_att_world = self.y_att
@defer_draw
def _on_xatt_world_change(self, *args):
if self.x_att_world is not None:
with delay_callback(self, 'y_att_world', 'x_att'):
if self.x_att_world == self.y_att_world:
if self._display_world:
world_ids = self.reference_data.world_component_ids
else:
world_ids = self.reference_data.pixel_component_ids
if self.x_att_world == world_ids[-1]:
self.y_att_world = world_ids[-2]
else:
self.y_att_world = world_ids[-1]
if self._display_world:
index = self.reference_data.world_component_ids.index(self.x_att_world)
self.x_att = self.reference_data.pixel_component_ids[index]
else:
self.x_att = self.x_att_world
@defer_draw
def _on_yatt_world_change(self, *args):
if self.y_att_world is not None:
with delay_callback(self, 'x_att_world', 'y_att'):
if self.y_att_world == self.x_att_world:
if self._display_world:
world_ids = self.reference_data.world_component_ids
else:
world_ids = self.reference_data.pixel_component_ids
if self.y_att_world == world_ids[-1]:
self.x_att_world = world_ids[-2]
else:
self.x_att_world = world_ids[-1]
if self._display_world:
index = self.reference_data.world_component_ids.index(self.y_att_world)
self.y_att = self.reference_data.pixel_component_ids[index]
else:
self.y_att = self.y_att_world
def _set_reference_data(self):
if self.reference_data is None:
for layer in self.layers:
if isinstance(layer.layer, BaseData):
self.reference_data = layer.layer
return
def _set_default_slices(self):
# Need to make sure this gets called immediately when reference_data is changed
if self.reference_data is None:
self.slices = ()
else:
self.slices = (0,) * self.reference_data.ndim
@property
def numpy_slice_aggregation_transpose(self):
"""
Returns slicing information usable by Numpy.
This returns two objects: the first is an object that can be used to
slice Numpy arrays and return a 2D array, and the second object is a
boolean indicating whether to transpose the result.
"""
if self.reference_data is None:
return None
slices = []
agg_func = []
for i in range(self.reference_data.ndim):
if i == self.x_att.axis or i == self.y_att.axis:
slices.append(slice(None))
agg_func.append(None)
else:
if isinstance(self.slices[i], AggregateSlice):
slices.append(self.slices[i].slice)
agg_func.append(self.slices[i].function)
else:
slices.append(self.slices[i])
transpose = self.y_att.axis > self.x_att.axis
return slices, agg_func, transpose
@property
def wcsaxes_slice(self):
"""
Returns slicing information usable by WCSAxes.
This returns an iterable of slices, and including ``'x'`` and ``'y'``
for the dimensions along which we are not slicing.
"""
if self.reference_data is None:
return None
slices = []
for i in range(self.reference_data.ndim):
if i == self.x_att.axis:
slices.append('x')
elif i == self.y_att.axis:
slices.append('y')
else:
if isinstance(self.slices[i], AggregateSlice):
slices.append(self.slices[i].center)
else:
slices.append(self.slices[i])
return slices[::-1]
def flip_x(self):
"""
Flip the x_min/x_max limits.
"""
with delay_callback(self, 'x_min', 'x_max'):
self.x_min, self.x_max = self.x_max, self.x_min
def flip_y(self):
"""
Flip the y_min/y_max limits.
"""
with delay_callback(self, 'y_min', 'y_max'):
self.y_min, self.y_max = self.y_max, self.y_min
class BaseImageLayerState(MatplotlibLayerState):
_viewer_callbacks_set = False
_image_cache = None
_pixel_cache = None
def get_sliced_data_shape(self, view=None):
if (self.viewer_state.reference_data is None or
self.viewer_state.x_att is None or
self.viewer_state.y_att is None):
return None
x_axis = self.viewer_state.x_att.axis
y_axis = self.viewer_state.y_att.axis
shape = self.viewer_state.reference_data.shape
shape_slice = shape[y_axis], shape[x_axis]
if view is None:
return shape_slice
else:
return view_shape(shape_slice, view)
def get_sliced_data(self, view=None, bounds=None):
full_view, agg_func, transpose = self.viewer_state.numpy_slice_aggregation_transpose
x_axis = self.viewer_state.x_att.axis
y_axis = self.viewer_state.y_att.axis
# For this method, we make use of Data.compute_fixed_resolution_buffer,
# which requires us to specify bounds in the form (min, max, nsteps).
# We also allow view to be passed here (which is a normal Numpy view)
# and, if given, translate it to bounds. If neither are specified,
# we behave as if view was [slice(None), slice(None)].
def slice_to_bound(slc, size):
min, max, step = slc.indices(size)
n = (max - min - 1) // step
max = min + step * n
return (min, max, n + 1)
if bounds is None:
# The view should be that which should just be applied to the data
# slice, not to all the dimensions of the data - thus it should have at
# most two dimensions
if view is None:
view = [slice(None), slice(None)]
elif len(view) == 1:
view = view + [slice(None)]
elif len(view) > 2:
raise ValueError('view should have at most two elements')
full_view[x_axis] = view[1]
full_view[y_axis] = view[0]
else:
full_view[x_axis] = bounds[1]
full_view[y_axis] = bounds[0]
for i in range(self.viewer_state.reference_data.ndim):
if isinstance(full_view[i], slice):
full_view[i] = slice_to_bound(full_view[i], self.viewer_state.reference_data.shape[i])
# We now get the fixed resolution buffer
if isinstance(self.layer, BaseData):
image = self.layer.compute_fixed_resolution_buffer(full_view, target_data=self.viewer_state.reference_data,
target_cid=self.attribute, broadcast=False, cache_id=self.uuid)
else:
image = self.layer.data.compute_fixed_resolution_buffer(full_view, target_data=self.viewer_state.reference_data,
subset_state=self.layer.subset_state, broadcast=False, cache_id=self.uuid)
# We apply aggregation functions if needed
if agg_func is None:
if image.ndim != 2:
raise IncompatibleDataException()
else:
if image.ndim != len(agg_func):
raise ValueError("Sliced image dimensions ({0}) does not match "
"aggregation function list ({1})"
.format(image.ndim, len(agg_func)))
for axis in range(image.ndim - 1, -1, -1):
func = agg_func[axis]
if func is not None:
image = func(image, axis=axis)
if image.ndim != 2:
raise ValueError("Image after aggregation should have two dimensions")
# And finally we transpose the data if the order of x/y is different
# from the native order.
if transpose:
image = image.transpose()
return image
class ImageLayerState(BaseImageLayerState, StretchStateMixin):
"""
A state class that includes all the attributes for data layers in an image plot.
"""
attribute = DDSCProperty(docstring='The attribute shown in the layer')
v_min = DDCProperty(docstring='The lower level shown')
v_max = DDCProperty(docstring='The upper level shown')
attribute_display_unit = DDSCProperty(docstring='The units to use to define the levels')
percentile = DDSCProperty(docstring='The percentile value used to automatically '
'calculate levels; "Custom" for manually set levels')
contrast = DDCProperty(1, docstring='The contrast of the layer')
bias = DDCProperty(0.5, docstring='A constant value that is added to the '
'layer before rendering')
cmap = DDCProperty(docstring='The colormap used to render the layer')
global_sync = DDCProperty(False, docstring='Whether the color and transparency '
'should be synced with the global '
'color and transparency for the data')
stretch_global = DDCProperty(True, docstring='Calculate automatic levels for rendering '
'stretch from the full data cube or only the '
'current layer (slice)')
def __init__(self, layer=None, viewer_state=None, **kwargs):
self.uuid = str(uuid.uuid4())
super(ImageLayerState, self).__init__(layer=layer, viewer_state=viewer_state)
self.attribute_lim_helper = StateAttributeLimitsHelper(self, attribute='attribute',
percentile='percentile',
lower='v_min', upper='v_max',
display_units='attribute_display_unit')
self.attribute_att_helper = ComponentIDComboHelper(self, 'attribute',
numeric=True, categorical=False)
percentile_display = {100: 'Min/Max',
99.5: '99.5%',
99: '99%',
95: '95%',
90: '90%',
'Custom': 'Custom'}
ImageLayerState.percentile.set_choices(self, [100, 99.5, 99, 95, 90, 'Custom'])
ImageLayerState.percentile.set_display_func(self, percentile_display.get)
self.setup_stretch_callback()
def format_unit(unit):
if unit is None:
return 'Native units'
else:
return unit
ImageLayerState.attribute_display_unit.set_display_func(self, format_unit)
self.add_callback('attribute', self._update_attribute_display_unit_choices, priority=10000)
self._update_attribute_display_unit_choices()
self.add_callback('global_sync', self._update_syncing)
self.add_callback('layer', self._update_attribute)
self.add_callback('stretch_global', self._set_global_stretch, priority=0)
self._update_syncing()
if layer is not None:
self._update_attribute()
self.update_from_dict(kwargs)
if self.cmap is None:
self.cmap = self.layer.style.preferred_cmap or colormaps.members[0][1]
def _update_attribute(self, *args):
if self.layer is not None:
self.attribute_att_helper.set_multiple_data([self.layer])
self.attribute = self.layer.main_components[0]
def _update_priority(self, name):
if name == 'layer':
return 3
elif name == 'attribute':
return 2
elif name == 'global_sync':
return 1.5
elif name.endswith(('_min', '_max')):
return 0
else:
return 1
def _update_syncing(self, *args):
if self.global_sync:
self._sync_color.enable_syncing()
self._sync_alpha.enable_syncing()
else:
self._sync_color.disable_syncing()
self._sync_alpha.disable_syncing()
def _get_image(self, view=None):
return self.layer[self.attribute, view]
def _set_global_stretch(self, stretch_global=True):
if stretch_global:
self.viewer_state.remove_callback('slices', self._update_slice_subset)
self.attribute_lim_helper.set_slice(None)
else:
self.viewer_state.add_callback('slices', self._update_slice_subset)
self.attribute_lim_helper.set_slice(self.viewer_state.numpy_slice_aggregation_transpose[0])
def _update_slice_subset(self, slices):
"""
Select a subset slice for determining image levels.
Parameters
----------
slices : iterable of :class:`slice` or `None`
An iterable containing :class:`slice` objects that can instantiate
a :class:`~glue.core.subset.SliceSubsetState` and has to be consistent
with the shape of `self.data`; `None` to unslice
- will be used via helper property.
"""
self.attribute_lim_helper.set_slice(self.viewer_state.numpy_slice_aggregation_transpose[0])
def flip_limits(self):
"""
Flip the image levels.
"""
self.attribute_lim_helper.flip_limits()
def reset_contrast_bias(self):
with delay_callback(self, 'contrast', 'bias'):
self.contrast = 1
self.bias = 0.5
def _update_attribute_display_unit_choices(self, *args):
# NOTE: only Data and its subclasses support specifying units
if self.layer is None or self.attribute is None or not isinstance(self.layer, Data):
ImageLayerState.attribute_display_unit.set_choices(self, [])
return
component = self.layer.get_component(self.attribute)
if component.units:
c_choices = find_unit_choices([(self.layer, self.attribute, component.units)])
else:
c_choices = ['']
ImageLayerState.attribute_display_unit.set_choices(self, c_choices)
self.attribute_display_unit = component.units
class ImageSubsetLayerState(BaseImageLayerState):
"""
A state class that includes all the attributes for subset layers in an image plot.
"""
# TODO: we can save memory by not showing subset multiple times for
# different image datasets since the footprint should be the same.
def __init__(self, *args, **kwargs):
self.uuid = str(uuid.uuid4())
super(ImageSubsetLayerState, self).__init__(*args, **kwargs)
def _get_image(self, view=None):
return self.layer.to_mask(view=view)
|
glue-vizREPO_NAMEgluePATH_START.@glue_extracted@glue-main@glue@viewers@image@state.py@.PATH_END.py
|
{
"filename": "Modifiable.py",
"repo_name": "dokester/BayesicFitting",
"repo_path": "BayesicFitting_extracted/BayesicFitting-master/BayesicFitting/source/Modifiable.py",
"type": "Python"
}
|
import numpy as numpy
from .Tools import setAttribute as setatt
__author__ = "Do Kester"
__year__ = 2023
__license__ = "GPL3"
__version__ = "3.2.0"
__url__ = "https://www.bayesicfitting.nl"
__status__ = "Perpetual Beta"
# * This file is part of the BayesicFitting package.
# *
# * BayesicFitting is free software: you can redistribute it and/or modify
# * it under the terms of the GNU Lesser General Public License as
# * published by the Free Software Foundation, either version 3 of
# * the License, or ( at your option ) any later version.
# *
# * BayesicFitting is distributed in the hope that it will be useful,
# * but WITHOUT ANY WARRANTY; without even the implied warranty of
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# * GNU Lesser General Public License for more details.
# *
# * The GPL3 license can be found at <http://www.gnu.org/licenses/>.
# *
# * 2019 - 2023 Do Kester
class Modifiable( object ):
"""
Class adjoint to Model which implements the modifiable behaviour of some Models.
In the inhertance list is should be *before* Model as it changes the behaviour of Model.
"""
def __init__( self, modifiable=True ) :
"""
Constructor for Modifiable
Parameters
----------
modifiable: bool
True if the Model is to be considered modifiable.
"""
setatt( self, "modifiable", modifiable )
def isModifiable( self ) :
return self.modifiable
def vary( self, location=None, rng=None, **kwargs ) :
"""
Vary the structure of a Modifiable Model
Default implementation: does nothing.
Parameters
----------
location : int
index of the item to be modified; otherwise random
rng : RNG
random number generator
kwargs : keyword arguments
for specific implementations
"""
return True
|
dokesterREPO_NAMEBayesicFittingPATH_START.@BayesicFitting_extracted@BayesicFitting-master@BayesicFitting@source@Modifiable.py@.PATH_END.py
|
{
"filename": "_textfont.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py3/plotly/validators/histogram2dcontour/_textfont.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator):
def __init__(
self, plotly_name="textfont", parent_name="histogram2dcontour", **kwargs
):
super(TextfontValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
data_class_str=kwargs.pop("data_class_str", "Textfont"),
data_docs=kwargs.pop(
"data_docs",
"""
color
family
HTML font family - the typeface that will be
applied by the web browser. The web browser
will only be able to apply a font if it is
available on the system which it operates.
Provide multiple font families, separated by
commas, to indicate the preference in which to
apply fonts if they aren't available on the
system. The Chart Studio Cloud (at
https://chart-studio.plotly.com or on-premise)
generates images on a server, where only a
select number of fonts are installed and
supported. These include "Arial", "Balto",
"Courier New", "Droid Sans", "Droid Serif",
"Droid Sans Mono", "Gravitas One", "Old
Standard TT", "Open Sans", "Overpass", "PT Sans
Narrow", "Raleway", "Times New Roman".
lineposition
Sets the kind of decoration line(s) with text,
such as an "under", "over" or "through" as well
as combinations e.g. "under+over", etc.
shadow
Sets the shape and color of the shadow behind
text. "auto" places minimal shadow and applies
contrast text font color. See
https://developer.mozilla.org/en-
US/docs/Web/CSS/text-shadow for additional
options.
size
style
Sets whether a font should be styled with a
normal or italic face from its family.
textcase
Sets capitalization of text. It can be used to
make text appear in all-uppercase or all-
lowercase, or with each word capitalized.
variant
Sets the variant of the font.
weight
Sets the weight (or boldness) of the font.
""",
),
**kwargs,
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py3@plotly@validators@histogram2dcontour@_textfont.py@.PATH_END.py
|
{
"filename": "metrics.py",
"repo_name": "astrockragh/Mangrove",
"repo_path": "Mangrove_extracted/Mangrove-main/dev/metrics.py",
"type": "Python"
}
|
from torch import sqrt, sum, square, no_grad, vstack, std, IntTensor
from torch.cuda import FloatTensor
import numpy as np
##################################################
### Could be defined in loop ####
### different funcs to calculate metrics ####
##################################################
mus, scales = np.array([-1.1917865, 1.7023178, -0.14979358, -2.5043619]), np.array([0.9338901, 0.17233825, 0.5423821, 0.9948792]) ### training set mus/sigs to scale back
def scatter(loader, model, n_targ):
model.eval()
correct = 0
with no_grad():
for dat in loader:
out = model(dat)
correct += sum(square(out - dat.y.view(-1,n_targ)))
return sqrt(correct/len(loader.dataset)).cpu().detach().numpy()
def test_multi(loader, model, targs, l_func, scale):
model.eval()
n_targ=len(targs)
outs = []
ys = []
if scale:
sca=FloatTensor(scales[targs])
ms=FloatTensor(mus[targs])
with no_grad(): ##this solves it!!!
for data in loader:
if l_func in ["L1", "L2", "SmoothL1"]:
out = model(data)
if l_func in ["Gauss1d", "Gauss2d", "GaussNd"]:
out, var = model(data)
if l_func in ["Gauss2d_corr, Gauss4d_corr"]:
out, var, rho = model(data)
if scale:
ys.append(data.y.view(-1,n_targ)*sca+ms)
outs.append(out*sca+ms)
else:
ys.append(data.y.view(-1,n_targ))
outs.append(out)
outss=vstack(outs)
yss=vstack(ys)
return std(outss - yss, axis=0).cpu().detach().numpy(), yss.cpu().detach().numpy(), outss.cpu().detach().numpy()
def test_multi_varrho(loader, model, targs, l_func, scale):
'''This one is the most updated'''
model.eval()
n_targ=len(targs)
outs = []
ys = []
vars = []
rhos = []
if scale:
sca=FloatTensor(scales[targs])
ms=FloatTensor(mus[targs])
with no_grad():
for data in loader:
rho = IntTensor(0)
var = IntTensor(0)
if l_func in ["L1", "L2", "SmoothL1"]:
out = model(data)
if l_func in ["Gauss1d", "Gauss2d", "GaussNd"]:
out, var = model(data)
if l_func in ["Gauss2d_corr", "Gauss4d_corr"]:
out, var, rho = model(data)
if scale:
ys.append(data.y.view(-1,n_targ)*sca+ms)
outs.append(out*sca+ms)
else:
ys.append(data.y.view(-1,n_targ))
outs.append(out)
vars.append(var)
rhos.append(rho)
outss=vstack(outs)
yss=vstack(ys)
vars = vstack(vars)
rhos = vstack(rhos)
return std(outss - yss, axis=0).cpu().detach().numpy(), yss.cpu().detach().numpy(), outss.cpu().detach().numpy(), vars, rhos
|
astrockraghREPO_NAMEMangrovePATH_START.@Mangrove_extracted@Mangrove-main@dev@metrics.py@.PATH_END.py
|
{
"filename": "data_inspect_2458141.ipynb",
"repo_name": "HERA-Team/H1C_IDR3_Notebooks",
"repo_path": "H1C_IDR3_Notebooks-main/data_inspect/data_inspect_2458141.ipynb",
"type": "Jupyter Notebook"
}
|
```python
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.ticker import FormatStrFormatter
import matplotlib.patches as mpatches
import matplotlib.gridspec as gridspec
import numpy as np
from pyuvdata import UVCal, UVData
import os
import sys
import glob
import uvtools as uvt
from astropy.time import Time
from astropy.coordinates import EarthLocation, AltAz, Angle
from astropy.coordinates import SkyCoord as sc
import pandas
import warnings
import copy
from hera_notebook_templates import utils_h1c as utils
import hera_qm
from hera_mc import cm_hookup
import h5py
import importlib
from scipy import stats
import yaml
from IPython.display import display, HTML
#warnings.filterwarnings('ignore')
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
display(HTML("<style>.container { width:100% !important; }</style>"))
```
<style>.container { width:100% !important; }</style>
```python
# If you want to run this notebook locally, copy the output of the next cell into the first few lines of this cell.
# JD = 2458045
# data_path = "/lustre/aoc/projects/hera/H1C_IDR3/IDR3_2/2458045"
# flag_yaml_path = "/lustre/aoc/projects/hera/H1C_IDR3/IDR3_2/h1c_idr3_software/hera_pipelines/pipelines/h1c/idr3/v2/a_priori_flags"
# os.environ["JULIANDATE"] = str(JD)
# os.environ["DATA_PATH"] = data_path
# os.environ["PATH_TO_A_PRIORI_FLAGS"] = flag_yaml_path
```
```python
#get data location
JD = os.environ['JULIANDATE']
data_path = os.environ['DATA_PATH']
flag_yaml_path = os.environ['PATH_TO_A_PRIORI_FLAGS']
print(f'JD = {JD}')
print(f'data_path = "{data_path}"')
print(f'flag_yaml_path = "{flag_yaml_path}"')
```
JD = 2458141
data_path = "/lustre/aoc/projects/hera/H1C_IDR3/IDR3_2/2458141"
flag_yaml_path = "/lustre/aoc/projects/hera/H1C_IDR3/IDR3_2/h1c_idr3_software/hera_pipelines/pipelines/h1c/idr3/v2/a_priori_flags"
```python
utc = Time(JD, format='jd').datetime
print(f'Date: {utc.month}-{utc.day}-{utc.year}')
```
Date: 1-22-2018
```python
# Load in data
HHfiles, uvdx, uvdy = utils.load_data(data_path,JD)
ex_ants = utils.read_a_priori_ant_flags(f'{flag_yaml_path}/{JD}.yaml')
uv = UVData()
unread = True
readInd=0
while unread and readInd<len(HHfiles):
try:
uv.read(HHfiles[readInd])
unread = False
except:
readInd += 1
continue
ants = uv.antenna_numbers
use_ants = [ant for ant in ants if ant not in ex_ants]
uvd = UVData()
uvd.read(HHfiles, ant_str='auto')
uvd.select(antenna_nums=use_ants)
lsts = uvd.lst_array
uvdx.select(antenna_nums=use_ants)
uvdy.select(antenna_nums=use_ants)
```
73 sum files found between JDs 2458141.12564 and 2458141.66251
## Sky Coverage Map
Map of the sky (made using the Haslam 408MHz map). The RA/DEC range covered by this night of observation is shaded based on a 12 degree FWHM of the beam. Horizontal dashed lines represent the stripe that HERA can observe, while the shaded region is what was observed on this night. Vertical lines represent the beginning and ending LSTs of this observation. Selected sources are labelled, sources included are those in the GLEAM 4Jy catalog with a flux >10.9 Jy. Note that the map is clipped at the northern horizon.
```python
sources = utils.gather_source_list()
utils.plot_sky_map(uvd,dec_pad=55,ra_pad=55,clip=False,sources=sources)
```
## LST Coverage
Shows the LSTs (in hours) and JDs for which data is collected. Green represents data, red means no data.
```python
utils.plot_lst_coverage(uvd)
```
## Autocorrelations for a single file
This plot shows autocorrelations for one timestamp of each antenna that is active and each polarization. For each node, antennas are ordered by SNAP number, and within that by SNAP input number. The antenna number label color corresponds to the a priori status of that antenna.
```python
### plot autos
utils.plot_autos(uvdx, uvdy)
```
## Waterfalls of Autocorrelation Amplitudes for each Antenna and Each polarization
These plots show autocorrelation waterfalls of each antenna that is active and whose status qualifies for this notebook. For each node, antennas are ordered by SNAP number, and within that by SNAP input number. The antenna number label color corresponds to the a priori status of that antenna.
```python
utils.plot_wfs(uvd, pol = 0)
```
```python
utils.plot_wfs(uvd, pol = 1)
```
## Correlation Metrics
The first plot shows the correlation metric (described below) for a set of baseline types, as calculated at several times throughout the night. It is expected that longer baselines (darker color) will exhibit lower values than the short baselines.
The matrices show the phase correlation between antennas. Using the even and odd visibilities, each pixel is calculated as (even/abs(even)) * (conj(odd)/abs(odd)), and then averaged across time and frequency. If the phases are noise-like, this value will average down to zero. If the antennas are well correlated, the phases should not be noise-like, and this value should average to 1. The lines denoting node boundaries are intended to help confirm that inter-node correlations are functioning - if they aren't, this plot will appear block-diagonal.
This metric has shown to be LST locked - when comparing to other nights, be sure to compare for the same LST. It is expected that some LSTs will look much better or worse than others.
Note: Within each node, the order of antennas is determined by snap, and within that by snap input number.
```python
badAnts = []
badAnts = utils.plotNodeAveragedSummary(uvd,HHfiles,JD,use_ants,mat_pols=['xx','yy','xy','yx'])
```
## Antenna Positions
Antennas outlined in black here have been identified by the correlation matrix as bad antennas. Antennas with a colorful outline correspond to their status as identified by ant_metrics (see above plot). Faded antennas are those not meeting the apriori status requirement for this notebook run. Gold stars are node box locations.
```python
uvd1 = UVData()
uvd1.read(HHfiles[readInd], skip_bad_files=True)
utils.plot_antenna_positions(uvd1, badAnts=badAnts,use_ants=use_ants)
```
## Mean-Subtracted Waterfalls
Here the mean value in each frequency bin has been subtracted out. This effectively subtracts out the bandpass shape, making time variations more visible.
```python
utils.plot_wfs(uvd,0,mean_sub=True,jd=JD)
utils.plot_wfs(uvd,1,mean_sub=True,jd=JD)
```
```python
```
|
HERA-TeamREPO_NAMEH1C_IDR3_NotebooksPATH_START.@H1C_IDR3_Notebooks-main@data_inspect@data_inspect_2458141.ipynb@.PATH_END.py
|
{
"filename": "make_predictions.sync-checkpoint.ipynb",
"repo_name": "JulioHC00/PEPITA",
"repo_path": "PEPITA_extracted/PEPITA-main/notebooks/tois/.ipynb_checkpoints/make_predictions.sync-checkpoint.ipynb",
"type": "Jupyter Notebook"
}
|
```python
## Generate predictions for the radius ratio precision of TESS Objects of Interest (TOIs)
```
## Load required packages
```python
import pandas as pd
import lightkurve as lk
import numpy as np
from IPython.display import display
```
## Select only planet candidates
```python
# Read TOIs table from the Nasa Exoplanet Archive (NEA)
nea_tois = pd.read_csv("nea_tois.csv", header=90)
nea_tois = nea_tois[nea_tois["tfopwg_disp"] == "PC"] # Only want planet candidates
print(f"Initial number of PC is {len(df)}")
nea_tois.dropna(axis=0, subset=["st_logg", "st_rad"], inplace=True) # Only keep if there are values for stellar logg and stellar radius
```
|
JulioHC00REPO_NAMEPEPITAPATH_START.@PEPITA_extracted@PEPITA-main@notebooks@tois@.ipynb_checkpoints@make_predictions.sync-checkpoint.ipynb@.PATH_END.py
|
{
"filename": "core.py",
"repo_name": "AstarVienna/skycalc_ipy",
"repo_path": "skycalc_ipy_extracted/skycalc_ipy-main/skycalc_ipy/core.py",
"type": "Python"
}
|
# -*- coding: utf-8 -*-
"""
Based on the skycalc_cli package, but heavily modified.
The original code was taken from ``skycalc_cli`` version 1.1.
Credit for ``skycalc_cli`` goes to ESO
"""
import warnings
import hashlib
import json
from os import environ
from datetime import datetime
from pathlib import Path
from collections.abc import Mapping
from importlib import import_module
import httpx
from astropy.io import fits
from astar_utils import get_logger
CACHE_DIR_FALLBACK = ".astar/skycalc_ipy"
logger = get_logger(__name__)
def get_cache_dir() -> Path:
"""Establish the cache directory.
There are three possible locations for the cache directory:
1. As set in `os.environ["SKYCALC_IPY_CACHE_DIR"]`
2. As set in the `scopesim_data` package.
3. The `data` directory in this package.
"""
try:
dir_cache = Path(environ["SKYCALC_IPY_CACHE_DIR"])
except KeyError:
try:
sim_data = import_module("scopesim_data")
dir_cache = Path(getattr(sim_data, "dir_cache_skycalc"))
except (ImportError, AttributeError):
dir_cache = Path.home() / CACHE_DIR_FALLBACK
if not dir_cache.is_dir():
dir_cache.mkdir(parents=True)
return dir_cache
class ESOQueryBase:
"""Base class for queries to ESO skycalc server."""
REQUEST_TIMEOUT = 2 # Time limit (in seconds) for server response
BASE_URL = "https://etimecalret-002.eso.org/observing/etc"
def __init__(self, url, params):
self.url = url
self.params = params
def _send_request(self) -> httpx.Response:
try:
with httpx.Client(base_url=self.BASE_URL,
timeout=self.REQUEST_TIMEOUT) as client:
response = client.post(self.url, json=self.params)
response.raise_for_status()
except httpx.RequestError as err:
logger.exception("An error occurred while requesting %s.",
err.request.url)
raise err
except httpx.HTTPStatusError as err:
logger.error("Error response %s while requesting %s.",
err.response.status_code, err.request.url)
raise err
return response
def get_cache_filenames(self, prefix: str, suffix: str) -> str:
"""Produce filename from hass of parameters.
Using three underscores between the key-value pairs and two underscores
between the key and the value.
"""
akey = "___".join(f"{k}__{v}" for k, v in self.params.items())
ahash = hashlib.sha256(akey.encode("utf-8")).hexdigest()
fname = f"{prefix}_{ahash}.{suffix}"
return fname
class AlmanacQuery(ESOQueryBase):
"""
A class for querying the SkyCalc Almanac.
Parameters
----------
indic : dict, SkyCalcParams
A dictionary / :class:``SkyCalcParams`` object containing the following
keywords: ``ra``, ``dec``, ``date`` or ``mjd``
- ``ra`` : [deg] a float in the range [0, 360]
- ``dec`` : [deg] a float in the range [-90, 90]
And either ``data`` or ``mjd``:
- ``date`` : a datetime string in the format 'yyyy-mm-ddThh:mm:ss'
- ``mjd`` : a float with the modified julian date. Note that ``mjd=0``
corresponds to the date "1858-11-17"
"""
def __init__(self, indic):
# FIXME: This basically checks isinstance(indic, ui.SkyCalc), but we
# can't import that because it would create a circual import.
# TODO: Find a better way to do this!!
if hasattr(indic, "defaults"):
indic = indic.values
super().__init__("/api//skycalc_almanac", {})
# Left: users keyword (skycalc_cli),
# Right: skycalc Almanac output keywords
self.alm_parameters = {
"airmass": "target_airmass",
"msolflux": "sun_aveflux",
"moon_sun_sep": "moon_sun_sep",
"moon_target_sep": "moon_target_sep",
"moon_alt": "moon_alt",
"moon_earth_dist": "moon_earth_dist",
"ecl_lon": "ecl_lon",
"ecl_lat": "ecl_lat",
"observatory": "observatory",
}
# The Almanac needs:
# coord_ra : float [deg]
# coord_dec : float [deg]
# input_type : ut_time | local_civil_time | mjd
# mjd : float
# coord_year : int
# coord_month : int
# coord_day : int
# coord_ut_hour : int
# coord_ut_min : int
# coord_ut_sec : float
self._set_date(indic)
self._set_radec(indic, "ra")
self._set_radec(indic, "dec")
if "observatory" in indic:
self.params["observatory"] = indic["observatory"]
def _set_date(self, indic):
if "date" in indic and indic["date"] is not None:
if isinstance(indic["date"], str):
isotime = datetime.strptime(indic["date"], "%Y-%m-%dT%H:%M:%S")
else:
isotime = indic["date"]
updated = {
"input_type": "ut_time",
"coord_year": isotime.year,
"coord_month": isotime.month,
"coord_day": isotime.day,
"coord_ut_hour": isotime.hour,
"coord_ut_min": isotime.minute,
"coord_ut_sec": isotime.second,
}
elif "mjd" in indic and indic["mjd"] is not None:
updated = {
"input_type": "mjd",
"mjd": float(indic["mjd"]),
}
else:
raise ValueError("No valid date or mjd given for the Almanac")
self.params.update(updated)
def _set_radec(self, indic, which):
try:
self.params[f"coord_{which}"] = float(indic[which])
except KeyError as err:
logger.exception("%s coordinate not given for the Almanac.", which)
raise err
except ValueError as err:
logger.exception("Wrong %s format for the Almanac.", which)
raise err
def _get_jsondata(self, file_path: Path):
if file_path.exists():
return json.load(file_path.open(encoding="utf-8"))
response = self._send_request()
if not response.text:
raise ValueError("Empty response.")
jsondata = response.json()["output"]
# Use a fixed date so the stored files are always identical for
# identical requests.
jsondata["execution_datetime"] = "2017-01-07T00:00:00 UTC"
try:
json.dump(jsondata, file_path.open("w", encoding="utf-8"))
# json.dump(self.params, open(fn_params, 'w'))
except (PermissionError, FileNotFoundError) as err:
# Apparently it is not possible to save here.
raise err
return jsondata
def __call__(self):
"""
Query the ESO Skycalc server with the parameters in self.params.
Returns
-------
almdata : dict
Dictionary with the relevant parameters for the date given
"""
cache_dir = get_cache_dir()
cache_name = self.get_cache_filenames("almanacquery", "json")
cache_path = cache_dir / cache_name
jsondata = self._get_jsondata(cache_path)
# Find the relevant (key, value)
almdata = {}
for key, value in self.alm_parameters.items():
prefix = value.split("_", maxsplit=1)[0]
if prefix in {"sun", "moon", "target"}:
subsection = prefix
elif prefix == "ecl":
subsection = "target"
else:
subsection = "observation"
try:
almdata[key] = jsondata[subsection][value]
except (KeyError, ValueError):
logger.warning("Key '%s/%s' not found in Almanac response.",
subsection, value)
return almdata
def query(self):
"""Deprecated feature.
.. deprecated:: v0.4.0
This method is deprecated, Class is now callable, use that instead.
"""
warnings.warn("The .query() method is deprecated and will be removed "
"in a future release. Please simply call the instance.",
DeprecationWarning, stacklevel=2)
return self()
class SkyModel(ESOQueryBase):
"""
Class for querying the Advanced SkyModel at ESO.
Contains all the parameters needed for querying the ESO SkyCalc server.
The parameters are contained in :attr:`.params` and the returned FITS file
is in :attr:`.data` in binary form. This must be saved to disk before it
can be read with the :meth:`.write` method.
Parameter and their default values and comments can be found at:
https://www.eso.org/observing/etc/bin/gen/form?INS.MODE=swspectr+INS.NAME=SKYCALC
"""
def __init__(self):
self.data = None
self.data_url = "/tmp/"
self.deleter_script_url = "/api/rmtmp"
self._last_status = ""
self.tmpdir = ""
params = {
# Airmass. Alt and airmass are coupled through the plane parallel
# approximation airmass=sec(z), z being the zenith distance
# z=90-Alt
"airmass": 1.0, # float range [1.0,3.0]
# Season and Period of Night
"pwv_mode": "pwv", # string grid ['pwv','season']
# integer grid [0,1,2,3,4,5,6] (0=all year, 1=dec/jan,2=feb/mar...)
"season": 0,
# third of night integer grid [0,1,2,3] (0=all year, 1,2,3 = third
# of night)
"time": 0,
# Precipitable Water Vapor PWV
# mm float grid [-1.0,0.5,1.0,1.5,2.5,3.5,5.0,7.5,10.0,20.0]
"pwv": 3.5,
# Monthly Averaged Solar Flux
"msolflux": 130.0, # s.f.u float > 0
# Scattered Moon Light
# Moon coordinate constraints: |z - zmoon| <= rho <= |z + zmoon|
# where rho = moon/target separation, z = 90-target altitude and
# zmoon = 90-moon altitude.
# string grid ['Y','N'] flag for inclusion of scattered moonlight.
"incl_moon": "Y",
# degrees float range [0.0,360.0] Separation of Sun and Moon as
# seen from Earth ("moon phase")
"moon_sun_sep": 90.0,
# degrees float range [0.0,180.0] Moon-Target Separation ( rho )
"moon_target_sep": 45.0,
# degrees float range [-90.0,90.0] Moon Altitude over Horizon
"moon_alt": 45.0,
# float range [0.91,1.08] Moon-Earth Distance (mean=1)
"moon_earth_dist": 1.0,
# Starlight
# string grid ['Y','N'] flag for inclusion of scattered starlight
"incl_starlight": "Y",
# Zodiacal light
# string grid ['Y','N'] flag for inclusion of zodiacal light
"incl_zodiacal": "Y",
# degrees float range [-180.0,180.0] Heliocentric ecliptic
# longitude
"ecl_lon": 135.0,
# degrees float range [-90.0,90.0] Ecliptic latitude
"ecl_lat": 90.0,
# Molecular Emission of Lower Atmosphere
# string grid ['Y','N'] flag for inclusion of lower atmosphere
"incl_loweratm": "Y",
# Emission Lines of Upper Atmosphere
# string grid ['Y','N'] flag for inclusion of upper stmosphere
"incl_upperatm": "Y",
# Airglow Continuum (Residual Continuum)
# string grid ['Y','N'] flag for inclusion of airglow
"incl_airglow": "Y",
# Instrumental Thermal Emission This radiance component represents
# an instrumental effect. The emission is provided relative to the
# other model components. To obtain the correct absolute flux, an
# instrumental response curve must be applied to the resulting
# model spectrum See section 6.2.4 in the documentation
# http://localhost/observing/etc/doc/skycalc/
# The_Cerro_Paranal_Advanced_Sky_Model.pdf
# string grid ['Y','N'] flag for inclusion of instrumental thermal
# radiation
"incl_therm": "N",
"therm_t1": 0.0, # K float > 0
"therm_e1": 0.0, # float range [0,1]
"therm_t2": 0.0, # K float > 0
"therm_e2": 0.0, # float range [0,1]
"therm_t3": 0.0, # float > 0
"therm_e3": 0.0, # K float range [0,1]
# Wavelength Grid
"vacair": "vac", # vac or air
"wmin": 300.0, # nm float range [300.0,30000.0] < wmax
"wmax": 2000.0, # nm float range [300.0,30000.0] > wmin
# string grid ['fixed_spectral_resolution','fixed_wavelength_step']
"wgrid_mode": "fixed_wavelength_step",
# nm/step float range [0,30000.0] wavelength sampling step dlam
# (not the res.element)
"wdelta": 0.1,
# float range [0,1.0e6] RESOLUTION is misleading, it is rather
# lam/dlam where dlam is wavelength step (not the res.element)
"wres": 20000,
# Convolve by Line Spread Function
"lsf_type": "none", # string grid ['none','Gaussian','Boxcar']
"lsf_gauss_fwhm": 5.0, # wavelength bins float > 0
"lsf_boxcar_fwhm": 5.0, # wavelength bins float > 0
"observatory": "paranal", # paranal
}
super().__init__("/api/skycalc", params)
def fix_observatory(self):
"""
Convert the human readable observatory name into its ESO ID number.
The following observatory names are accepted: ``lasilla``, ``paranal``,
``armazones`` or ``3060m``, ``highanddry`` or ``5000m``
"""
# FIXME: DO WE ALWAYS WANT TO RAISE WHEN IT'S NOT ONE OF THOSE???
if self.params["observatory"] not in {
"paranal",
"lasilla",
"armazones",
"3060m",
"5000m",
}:
return # nothing to do
if self.params["observatory"] == "lasilla":
self.params["observatory"] = "2400"
elif self.params["observatory"] == "paranal":
self.params["observatory"] = "2640"
elif (
self.params["observatory"] == "3060m"
or self.params["observatory"] == "armazones"
):
self.params["observatory"] = "3060"
elif (
self.params["observatory"] == "5000m"
or self.params["observatory"] == "highanddry"
):
self.params["observatory"] = "5000"
else:
raise ValueError(
"Wrong Observatory name, please refer to the documentation."
)
return # for consistency
def __getitem__(self, item):
return self.params[item]
def __setitem__(self, key, value):
self.params[key] = value
if key == "observatory":
self.fix_observatory()
def _retrieve_data(self, url):
try:
self.data = fits.open(url)
# Use a fixed date so the stored files are always identical for
# identical requests.
self.data[0].header["DATE"] = "2017-01-07T00:00:00"
except Exception as err:
logger.exception(
"Exception raised trying to get FITS data from %s", url)
raise err
def write(self, local_filename, **kwargs):
"""Write data to file."""
try:
self.data.writeto(local_filename, **kwargs)
except (IOError, FileNotFoundError):
logger.exception("Exception raised trying to write fits file.")
def getdata(self):
"""Deprecated feature.
.. deprecated:: v0.4.0
This method is deprecated, just use the .data attribute instead.
"""
warnings.warn("The .getdata method is deprecated and will be removed "
"in a future release. Use the identical .data attribute "
"instead.", DeprecationWarning, stacklevel=2)
return self.data
def _delete_server_tmpdir(self, tmpdir):
try:
with httpx.Client(base_url=self.BASE_URL,
timeout=self.REQUEST_TIMEOUT) as client:
response = client.get(self.deleter_script_url,
params={"d": tmpdir})
deleter_response = response.text.strip().lower()
if deleter_response != "ok":
logger.error("Could not delete server tmpdir %s: %s",
tmpdir, deleter_response)
except httpx.HTTPError:
logger.exception("Exception raised trying to delete tmp dir %s",
tmpdir)
def _update_params(self, updated: Mapping) -> None:
par_keys = self.params.keys()
new_keys = updated.keys()
self.params.update((key, updated[key]) for key in par_keys & new_keys)
logger.debug("Ignoring invalid keywords: %s", new_keys - par_keys)
def __call__(self, **kwargs):
"""Send server request."""
if kwargs:
logger.info("Setting new parameters: %s", kwargs)
self._update_params(kwargs)
self.fix_observatory()
cache_dir = get_cache_dir()
cache_name = self.get_cache_filenames("skymodel", "fits")
cache_path = cache_dir / cache_name
if cache_path.exists():
self.data = fits.open(cache_path)
return
response = self._send_request()
try:
res = response.json()
status = res["status"]
tmpdir = res["tmpdir"]
except (KeyError, ValueError) as err:
logger.exception(
"Exception raised trying to decode server response.")
raise err
self._last_status = status
if status == "success":
try:
# retrive and save FITS data (in memory)
self._retrieve_data(
self.BASE_URL + self.data_url + tmpdir + "/skytable.fits")
except httpx.HTTPError as err:
logger.exception("Could not retrieve FITS data from server.")
raise err
try:
self.data.writeto(cache_path)
# with fn_params.open("w", encoding="utf-8") as file:
# json.dump(self.params, file)
except (PermissionError, FileNotFoundError):
# Apparently it is not possible to save here.
pass
self._delete_server_tmpdir(tmpdir)
else: # print why validation failed
logger.error("Parameter validation error: %s", res["error"])
def call(self):
"""Deprecated feature.
.. deprecated:: v0.4.0
This method is deprecated, just call the instance instead.
"""
warnings.warn("The .call() method is deprecated and will be removed "
"in a future release. Please simply call the instance.",
DeprecationWarning, stacklevel=2)
self()
def callwith(self, newparams):
"""Deprecated feature.
.. deprecated:: v0.4.0
This method is deprecated, just call the instance instead.
"""
warnings.warn("The .callwith(args) method is deprecated and will be "
"removed in a future release. Please simply call the "
"instance with optional kwargs instead.",
DeprecationWarning, stacklevel=2)
self(**newparams)
def printparams(self, keys=None):
"""
List the values of all, or a subset, of parameters.
Parameters
----------
keys : sequence of str, optional
List of keys to print. If None, all keys will be printed.
"""
for key in keys or self.params.keys():
print(f" {key}: {self.params[key]}")
|
AstarViennaREPO_NAMEskycalc_ipyPATH_START.@skycalc_ipy_extracted@skycalc_ipy-main@skycalc_ipy@core.py@.PATH_END.py
|
{
"filename": "README.md",
"repo_name": "spedas/pyspedas",
"repo_path": "pyspedas_extracted/pyspedas-master/pyspedas/projects/rbsp/README.md",
"type": "Markdown"
}
|
## Van Allen Probes (RBSP)
The routines in this module can be used to load data from the Van Allen Probes (RBSP) mission.
### Instruments
- Electric and Magnetic Field Instrument Suite and Integrated Science (EMFISIS)
- Electric Field and Waves Suite (EFW)
- Radiation Belt Storm Probes Ion Composition Experiment (RBSPICE)
- Energetic Particle, Composition, and Thermal Plasma Suite (ECT)
- Relativistic Proton Spectrometer (RPS)
### Examples
Get started by importing pyspedas and tplot; these are required to load and plot the data:
```python
import pyspedas
from pytplot import tplot
```
#### Electric and Magnetic Field Instrument Suite and Integrated Science (EMFISIS)
```python
emfisis_vars = pyspedas.rbsp.emfisis(trange=['2018-11-5/10:00', '2018-11-5/15:00'], datatype='magnetometer', level='l3', time_clip=True)
tplot(['Mag', 'Magnitude'])
```
#### Electric Field and Waves Suite (EFW)
```python
efw_vars = pyspedas.rbsp.efw(trange=['2015-11-5', '2015-11-6'], level='l3')
tplot(['efield_in_inertial_frame_spinfit_mgse', 'spacecraft_potential'])
```
#### Radiation Belt Storm Probes Ion Composition Experiment (RBSPICE)
```python
rbspice_vars = pyspedas.rbsp.rbspice(trange=['2018-11-5', '2018-11-6'], datatype='TOFxEH', level='l3')
tplot('rbspa_rbspice_l3_TOFxEH_proton_omni_spin')
# calculate the pitch angle distributions
from pyspedas.rbsp.rbspice_lib.rbsp_rbspice_pad import rbsp_rbspice_pad
rbsp_rbspice_pad(probe='a', datatype='TOFxEH', level='l3')
tplot('rbspa_rbspice_l3_TOFxEH_proton_omni_0-1000keV_pad_spin')
```
#### Energetic Particle, Composition, and Thermal Plasma Suite (ECT)
```python
mageis_vars = pyspedas.rbsp.mageis(trange=['2018-11-5', '2018-11-6'], level='l3', rel='rel04')
tplot('I')
hope_vars = pyspedas.rbsp.hope(trange=['2018-11-5', '2018-11-6'], datatype='moments', level='l3', rel='rel04')
tplot('Ion_density')
rept_vars = pyspedas.rbsp.rept(trange=['2018-11-5', '2018-11-6'], level='l3', rel='rel03')
```
#### Relativistic Proton Spectrometer (RPS)
```python
rps_vars = pyspedas.rbsp.rps(trange=['2018-11-5', '2018-11-6'], datatype='rps', level='l2')
tplot('DOSE1')
```
|
spedasREPO_NAMEpyspedasPATH_START.@pyspedas_extracted@pyspedas-master@pyspedas@projects@rbsp@README.md@.PATH_END.py
|
{
"filename": "concept_shallot.md",
"repo_name": "dmvandamt/beyonce",
"repo_path": "beyonce_extracted/beyonce-main/concept_shallot.md",
"type": "Markdown"
}
|
# Concept Shallot Explorer
The Shallot Explorer is a module of the BeyonCE (Beyond Common Eclipsers) package used to explore the large parameter space of eclipsing disc systems. From a light curve we have the hard limit of the duration of the eclipse, $\Delta_\mathrm{ecl}$. From there we can think of infinite discs (projected ellipses) that have intercepts with the beginning and end of the eclipse.
The Shallot Explorer produces a 3-D grid with the centre of the projected ellipse (this is also the centre of the disc as we assume it is azimuthally symmetric) at a location $\delta x$, $\delta y$ and we have a third dimension called the radius factor $f_R$.
It is important to realise that all the "spatial" dimensions obtained from the Shallot Explorer are converted to the temporal domain, and to generalise the grid we express the dimensions in units of $\Delta_\mathrm{ecl}$.
## Grid Visualisation
### Dimensions
1. The grid has an $x$ dimension corresponding to $\delta x$, which is the shift that the centre of the projected ellipse has w.r.t. the centre of the eclipse.
2. The grid has a $y$ dimension corresponding to $\delta y$, which is the shift that the centre of the projected ellipse has w.r.t. the centre of the eclipse. This is commonly known as the impact parameter.
3. The grid has a $z$ dimension corresponding to $f_R$, the radius factor.
This factor stems from the fact that for any given ($\delta x, \delta y$) there is an infinite number of ellipses that intersect at the boundaries ($\pm \frac{\Delta_\mathrm{ecl}}{2}, 0$). If we find start the smallest disc radius, we can describe the rest of the ellipses by scaling the radius (which in turn affects the inclination of the disc) by some factor $f_R > 1$. It should also be noted that one can scale the radius of the disc in the direction of the semi-major axis or the semi-minor axis of the projected ellipse.
###
|
dmvandamtREPO_NAMEbeyoncePATH_START.@beyonce_extracted@beyonce-main@concept_shallot.md@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "aewallin/allantools",
"repo_path": "allantools_extracted/allantools-master/allantools/__init__.py",
"type": "Python"
}
|
__all__ = [
'__version__',
'adev',
'oadev',
'mdev',
'pdev',
'hdev',
'ohdev',
'calc_hdev_phase',
'tdev',
'totdev',
'mtotdev',
'calc_mtotdev_phase',
'ttotdev',
'htotdev',
'calc_htotdev_freq',
'theo1',
'mtie',
'mtie_phase_fast',
'tierms',
'frequency2phase',
'phase2frequency',
'phase2radians',
'frequency2fractional',
'three_cornered_hat_phase',
'noise',
'gradev',
'gcodev',
'trim_data',
'edf_simple',
'edf_greenhall',
'edf_totdev',
'edf_mtotdev',
'confidence_interval',
'confidence_interval_noiseID',
'autocorr_noise_id',
'Dataset',
'Noise',
'Plot',
'psd2allan',
'tau_generator',
'tau_reduction'
]
from .allantools import __version__
from .allantools import frequency2phase
from .allantools import phase2frequency
from .allantools import phase2radians
from .allantools import frequency2fractional
from .allantools import three_cornered_hat_phase
from .allantools import adev
from .allantools import oadev
from .allantools import mdev
from .allantools import pdev
from .allantools import hdev
from .allantools import ohdev
from .allantools import calc_hdev_phase
from .allantools import tdev
from .allantools import totdev
from .allantools import ttotdev
from .allantools import mtotdev
from .allantools import calc_mtotdev_phase
from .allantools import htotdev
from .allantools import calc_htotdev_freq
from .allantools import theo1
from .allantools import mtie
from .allantools import mtie_phase_fast
from .allantools import tierms
from .allantools import gradev
from .allantools import gcodev
from .allantools import trim_data
from .allantools import psd2allan
from .allantools import tau_generator
from .allantools import tau_reduction
# ci.py contains functions for confidence intervals
from .ci import edf_simple
from .ci import edf_greenhall
from .ci import edf_totdev
from .ci import edf_mtotdev
from .ci import confidence_interval
from .ci import autocorr_noise_id
from .ci import confidence_interval_noiseID
# noise generation
from . import noise
from .dataset import Dataset
from .plot import Plot
from .noise_kasdin import Noise
# realtime statistics
from .realtime import oadev_realtime
from .realtime import ohdev_realtime
from .realtime import tdev_realtime
# ITU masks for TDEV and MTIE
from . import mask
# end of file __init__.py
|
aewallinREPO_NAMEallantoolsPATH_START.@allantools_extracted@allantools-master@allantools@__init__.py@.PATH_END.py
|
{
"filename": "prompts.py",
"repo_name": "langchain-ai/langchain",
"repo_path": "langchain_extracted/langchain-master/libs/langchain/langchain/chains/hyde/prompts.py",
"type": "Python"
}
|
# flake8: noqa
from langchain_core.prompts.prompt import PromptTemplate
web_search_template = """Please write a passage to answer the question
Question: {QUESTION}
Passage:"""
web_search = PromptTemplate(template=web_search_template, input_variables=["QUESTION"])
sci_fact_template = """Please write a scientific paper passage to support/refute the claim
Claim: {Claim}
Passage:"""
sci_fact = PromptTemplate(template=sci_fact_template, input_variables=["Claim"])
arguana_template = """Please write a counter argument for the passage
Passage: {PASSAGE}
Counter Argument:"""
arguana = PromptTemplate(template=arguana_template, input_variables=["PASSAGE"])
trec_covid_template = """Please write a scientific paper passage to answer the question
Question: {QUESTION}
Passage:"""
trec_covid = PromptTemplate(template=trec_covid_template, input_variables=["QUESTION"])
fiqa_template = """Please write a financial article passage to answer the question
Question: {QUESTION}
Passage:"""
fiqa = PromptTemplate(template=fiqa_template, input_variables=["QUESTION"])
dbpedia_entity_template = """Please write a passage to answer the question.
Question: {QUESTION}
Passage:"""
dbpedia_entity = PromptTemplate(
template=dbpedia_entity_template, input_variables=["QUESTION"]
)
trec_news_template = """Please write a news passage about the topic.
Topic: {TOPIC}
Passage:"""
trec_news = PromptTemplate(template=trec_news_template, input_variables=["TOPIC"])
mr_tydi_template = """Please write a passage in Swahili/Korean/Japanese/Bengali to answer the question in detail.
Question: {QUESTION}
Passage:"""
mr_tydi = PromptTemplate(template=mr_tydi_template, input_variables=["QUESTION"])
PROMPT_MAP = {
"web_search": web_search,
"sci_fact": sci_fact,
"arguana": arguana,
"trec_covid": trec_covid,
"fiqa": fiqa,
"dbpedia_entity": dbpedia_entity,
"trec_news": trec_news,
"mr_tydi": mr_tydi,
}
|
langchain-aiREPO_NAMElangchainPATH_START.@langchain_extracted@langchain-master@libs@langchain@langchain@chains@hyde@prompts.py@.PATH_END.py
|
{
"filename": "nifs_main_LP.py",
"repo_name": "jlwalsh12/NIFS-reduction-pipeline",
"repo_path": "NIFS-reduction-pipeline_extracted/NIFS-reduction-pipeline-master/py_scripts/nifs_main_LP.py",
"type": "Python"
}
|
"""
Created on June 11 2018
Author: Jonelle Walsh, Anil Seth, Richard McDermid, etc.
See setup_pipeline.pdf for installation instructions, and
additional_info_nifspipeline_v4.pdf for useage instructions.
To run, go to the rootdir (see below), open pyraf, then type:
---> pyexecute("[pyscriptpath (see below)]/nifs_main_LP.py")
Pieces of the code cannot yet deal with more than 1 observational
setup at a time. If needing to reduce more than 1 observational setup,
create a datadir (see below) holding raw files for 1 observational
setup, and a separate datadir (see below) holding raw files for a
different observational setup. Run the code separately on each
datadir.
The code calls PyRAF/IRAF and tasks within the Gemini data reduction
package. Thus this code must be run with Python 2.7. The code has been
tested with Gemini IRAF package version 1.14 and IRAF 2.16 on NIFS
data with the K grating and HK filter centered on 2.2 microns.
"""
################################################################################
################################################################################
# EDIT BELOW
#give the location of where IDL lives on your computer
idlpath = '/Applications/exelis/idl85/bin/idl'
#enter the location of the data reduction python scripts
#pyscriptspath = '/Users/jlwalsh/Data/LP_2016/nifs_reduction_info/'+\
# 'full_reduce/nifs_pipeline_v4/py_scripts/'
pyscriptspath = '/Users/jlwalsh/Dropbox/LP_reduction_pipeline/py_scripts/'
#directory where anil_ArXe_K.dat and kurucz star files are located.
#refdir = '/Users/jlwalsh/Data/LP_2016/nifs_reduction_info/'+\
# 'full_reduce/nifs_pipeline_v4/ref_files/'
refdir = '/Users/jlwalsh/Dropbox/LP_reduction_pipeline/ref_files/'
#location of the main directory. make sure to include the / at the end
#of the string. NEEDS TO EXIST before running pipeline.
rootdir = '/Users/jlwalsh/Data/LP_2016/nifs_data/2016b/'
#directory where the raw data is stored. make sure to include the / at
#the end of the string. inside of this directory, must have
#subdirectories holding the raw data broken up by date
#(datadir+20160920/). datadir and the subdirectories NEED TO EXIST
#before running pipeline.
datadir = 'raw_data/'
#directory that will hold the reduced data. make sure to include the /
#at the end of the string. will be created by the pipeline if doesn't
#already exist.
reducedir = 'nifs_pipeline_v4/reduced_data/'
#provide the dates for which you want to reduce data. enter as a
#string and use a yyyymmdd format. a single date or multiple dates can
#be entered. (e.g., dates = ['20121227'] or dates =
#['20121227','20121230'])
dates = ['20160921']
#galaxies observed during ANY of the dates listed above. use full name
#and lower case (e.g., ngc, ugc, pgc, ic, mrk). this will be used to
#name the directoires.
#galaxies = ['ngc7242','ugc11537','pgc12557'] #for 20160921
galaxies = ['ugc11537']
#tellurics observed during ANY of the dates listed above. use full
#name and lower case (e.g., hip, hd, hr). will be used to name the
#directories.
tellurics = ['hip105437','hip95793','hd203769','hip10559','hip18769'] #for 20160921
#you can chose to do some parts of the reduction and not others. to do
#the step enter 'yes', to skip the step enter 'no'.
reduce_sortfiles = 'yes' #create directory structure and sort files
reduce_daycals = 'no' #reduce daycals
reduce_tellurics = 'no' #reduce telluric stars
reduce_galaxies = 'no' #basic reduction of galaxy exposures
reduce_combine_gal = 'no' #merge galaxy cubes
reduce_psf = 'no' #reduce psf star observations
reduce_combine_psf = 'no' #merge psf cubes
reduce_fluxcal = 'no' #flux calibrate the merged galaxy and sky cubes
reduce_measurelsf = 'no' #measure the line-spread function from the
#merged sky cube
#do you want to do the wavelength calibration interactively, or accept
#the default fits? Set to 'yes' to do interactively.
flinter_arc = 'no'
#do you want to do the s-distortion calibration interactively, or
#accept the default fits? Set to 'yes' to do interactively?
flinter_sdist = 'no'
#do you want to determine the 2D to 3D spatial/spectral transformation
#interactively, or accept the default fitting function? Set to 'yes'
#to do interactively.
flinter_nsfitcoords = 'no'
#do you want to extract 1D spectra interactively (for tellurics), or
#accept the (x,y) pixel with the maximum value in the collapsed data
#cube? Set to 'yes' to do interactively.
flinter_extract = 'no'
#do you want to apply the telluric correction interactively
#(extracting a 1D spectrum, searching for values of the shift/scale
#applied to the telluric)? Set to 'yes' to do interactively.
flinter_telluric = 'no'
#clean cosmic rays and bad negataive pixels. probably can leave the
#numbers below unchanged, but be sure to check the masks in
#rootdir+reducedir+[galaxies]+[dates]+[setup]+'clean/masks_lacosmic/'
#and +'clean/masks_negpix/'. cosmic rays/bad pixels should not have
#been identified on top of any real signal. for parameters below,
#larger numbers correspond to being more conservative
sigclip_in = 10.0 #LA COSMIC sigclip
sigfrac_in = 3.0 #LA COSMIC sigfrac
objlim_in = 5.0 #LA COSMIC objlim
nsigneg_in = 5.0 #XZAP nsigneg (sigma for finding negative pixels)
#do you want to generate barycentric or heliocentric wavelengths, or
#no correction? for corr_type, options are 'none', 'bary', or
#'helio'. note, if no correction is applied, spectra are still sampled
#to the same starting/ending wavelength with the same delta lambda
#when a single merged cube is created.
corr_type = 'none'
# STOP EDITTING
################################################################################
################################################################################
# Import some useful python utilities.
import sys
sys.path.append(pyscriptspath)
import os
import glob
import astropy.io.fits as pyfits
import numpy as np
import time
import subprocess
import pidly
idl = pidly.IDL(idlpath)
from nifs_checkdaycal_LP import nifs_checkdaycal_LP
from nifs_checktel_LP import nifs_checktel_LP
from nifs_checkgal_LP import nifs_checkgal_LP
from nifs_checkpsf_LP import nifs_checkpsf_LP
from nifs_checkdata_LP import nifs_checkdata_LP
from nifs_basecalib_LP import nifs_basecalib_LP
from nifs_telluric_LP import nifs_telluric_LP
from nifs_galaxy_LP import nifs_galaxy_LP
from nifs_checkdata_merged_LP import nifs_checkdata_merged_LP
from nifs_refwave_LP import nifs_refwave_LP
from nifs_getoffmethod_LP import nifs_getoffmethod_LP
from nifs_merge_LP import nifs_merge_LP
from nifs_psf_LP import nifs_psf_LP
from nifs_findtelluric_fluxcalib_LP import nifs_findtelluric_fluxcalib_LP
from nifs_worktelluric_fluxcalib_LP import nifs_worktelluric_fluxcalib_LP
################################################################################
# Check that the user has selected at least one data reduction task to
# complete.
if reduce_sortfiles.lower() == 'no' and reduce_daycals.lower() == 'no' and \
reduce_tellurics.lower() == 'no' and reduce_galaxies.lower() == 'no' and \
reduce_combine_gal.lower() == 'no' and reduce_psf.lower() == 'no' and \
reduce_combine_psf.lower() == 'no' and reduce_fluxcal.lower() == 'no' and \
reduce_measurelsf.lower() == 'no':
sys.exit('You need to set one of the reduction steps to "yes".')
################################################################################
# Run the IDL tasks to write important info to text files, create
# directory structure, and sort files.
if reduce_sortfiles.lower() == 'yes':
print('')
print('Gathering info...')
print('')
idl.pro('setup_writeinfo', rootdir, rootdir+datadir, dates)
print('')
print('Setting up directories...')
print('')
idl.pro('setup_makedirectories', rootdir, rootdir+datadir,
rootdir+reducedir, dates, galaxies, tellurics)
################################################################################
# Check the daycal/telluric/galaxy/sky/psf lists that were created
# above and allow user to modify the lists if needed. At this time,
# also create a telluric correction list for each of the galaxy and
# psf exposures. Create a file that lists each telluric star and their
# flux density for flux calibration.
if reduce_daycals.lower() == 'yes':
nifs_checkdaycal_LP(rootdir, reducedir, datadir, dates)
if reduce_tellurics.lower() == 'yes':
nifs_checktel_LP(rootdir, reducedir, datadir, dates)
if reduce_galaxies.lower() == 'yes':
nifs_checkgal_LP(rootdir, reducedir, datadir, galaxies, dates)
if reduce_psf.lower() == 'yes':
nifs_checkpsf_LP(rootdir, reducedir, datadir, galaxies, dates)
################################################################################
# Start the real work.
#loop over each night to reduce the daycals and the tellurics
for a in range(len(dates)):
if reduce_daycals.lower() == 'yes' or reduce_tellurics.lower() == 'yes':
os.chdir(rootdir+reducedir+'daycals/'+dates[a])
obs_setups = sorted(glob.glob('*'), key=os.path.basename)
for b in range(len(obs_setups)):
#work on the baseline calibrations
workdir = rootdir+reducedir+'daycals/'+dates[a]+'/'+\
obs_setups[b]+'/'
os.chdir(workdir)
#the names of the daycal lists
flatlist = 'flatlist'
flatdarklist = 'flatdarklist'
arcdarklist = 'arcdarklist'
ronchilist = 'ronchilist'
ronchidarklist = 'ronchidarklist'
arclist = sorted(glob.glob('arclist*'), key=os.path.basename)
darklist = sorted(glob.glob('darklist*'), key=os.path.basename)
####################################################################
if reduce_daycals.lower() == 'yes':
print('')
print('Starting the baseline calibrations '+\
'for %s and %s' % (dates[a], obs_setups[b]))
print('')
#check to see if outputs of data reduction already
#exist. if so, ask the user whether to proceed. if the
#user does want to proceed, delete the previous
#outputs and start over.
nifs_checkdata_LP(workdir,'basecalib*log*')
#for HK, K grating centered on 2.20 microns
if obs_setups[b] == 'hk_2.20':
arcfileref = '/anil_ArXe_K.dat'
#for HK, K-long grating centered on 2.30 microns
elif obs_setups[b] == 'hk_2.30':
arcfileref = '/anil_ArXe_KL.dat'
#have the pipeline quit if one of these two setups
#were not used.
else:
sys.exit('Pipeline is not written or tested for '+\
'your observational setup.')
#if refdir is too long, pyraf won't be able to find
#the reference file, so temporarily copy the arc line
#list to the working directory
tmp=subprocess.call(['cp',refdir+arcfileref,workdir],
stderr=open(os.devnull,'w'))
#reduce the baseline calibrations
nifs_basecalib_LP(workdir, dates[a], flatlist, flatdarklist,
arclist, arcdarklist, ronchilist,
ronchidarklist, darklist, refdir,
flinter_arc, flinter_sdist, obs_setups[b])
#remove the copy of the arc line list now that the
#daycals have been reduced
tmp=subprocess.call(['rm',workdir+arcfileref],
stderr=open(os.devnull,'w'))
####################################################################
if reduce_tellurics.lower() == 'yes':
os.chdir(rootdir+reducedir+'tellurics/'+dates[a]+'/'+\
obs_setups[b]+'/')
telluric_stars = sorted(glob.glob('*'), key=os.path.basename)
for c in range(len(telluric_stars)):
workdir = rootdir+reducedir+'tellurics/'+dates[a]+'/'+\
obs_setups[b]+'/'+telluric_stars[c]+'/'
caldir = rootdir+reducedir+'daycals/'+dates[a]+'/'+\
obs_setups[b]+'/'
print('')
print('Starting the '+\
'telluric %s for %s and %s' % (telluric_stars[c], \
dates[a], \
obs_setups[b]))
print('')
os.chdir(workdir)
#check to see if outputs of data reduction already
#exist. if so, ask the user whether to proceed. if
#the user does want to proceed, delete the
#previous outputs and start over.
nifs_checkdata_LP(workdir,'telluric*log*')
#the names of the telluric and sky lists
telluriclist = sorted(glob.glob('telluriclist*'),
key=os.path.basename)
skylist = sorted(glob.glob('skylist_*'),
key=os.path.basename)
skylistshort = sorted(glob.glob('skylistshort_*'),
key=os.path.basename)
#remind the user to open a ds9 window if needed
if flinter_extract == 'yes':
response = \
raw_input('Need to have a DS9 window open. Hit '+\
'any key to continue. ')
#only HK, K grating centered on 2.20 microns and
#HK, K long grating centered on 2.30 microns is
#supported. have the pipeline quit if one of these
#two setups were not used.
if obs_setups[b] != 'hk_2.20' and \
obs_setups[b] != 'hk_2.30':
sys.exit('Pipeline is not written or tested for '+\
'your observational setup.')
#reduce the telluric stars
nifs_telluric_LP(workdir, caldir, dates[a], flatlist,
arclist, ronchilist, telluriclist, skylist,
skylistshort, flinter_nsfitcoords,
flinter_extract, obs_setups[b])
#remove absorption lines from the telluric star
#and correct for the blackbody shape. the output
#1D spectrum is ready to be fed into nftelluric to
#make the telluric correction.
telluric_file = sorted(glob.glob('gxtfbrsn*.fits'),
key=os.path.basename)
idl.pro('fit_telluric_richard',workdir,telluric_file,
refdir,obs_setups[b])
################################################################################
#loop over each galaxy to reduce the galaxy exposures and merge cubes
for a in range(len(galaxies)):
for b in range(len(dates)):
#dates contains all the days data are to be reduced, but this
#galaxy may not have been observed on this date. check here.
if os.path.isdir(rootdir+reducedir+galaxies[a]+'/'+dates[b]):
os.chdir(rootdir+reducedir+galaxies[a]+'/'+dates[b])
obs_setups = sorted(glob.glob('*'), key=os.path.basename)
for c in range(len(obs_setups)):
workdir = rootdir+reducedir+galaxies[a]+'/'+dates[b]+'/'+\
obs_setups[c]+'/'
caldir = rootdir+reducedir+'daycals/'+dates[b]+'/'+\
obs_setups[c]+'/'
teldir = rootdir+reducedir+'tellurics/'+dates[b]+'/'+\
obs_setups[c]+'/'
#the names of the daycal lists. re-search for arclist
#and darklist in case the user made changes.
flatlist = 'flatlist'
ronchilist = 'ronchilist'
os.chdir(caldir)
arclist = sorted(glob.glob('arclist*'), key=os.path.basename)
darklist = sorted(glob.glob('darklist*'), key=os.path.basename)
#the names of the galaxy, sky, and telluric correction
#lists
os.chdir(workdir)
gallist = 'gallist'
skylist = 'skylist'
skylistshort = 'skylistshort'
telcorrlist = 'telcorrlist'
################################################################
if reduce_galaxies.lower() == 'yes':
print('')
print('Starting the '+\
'galaxy %s for %s and %s' % (galaxies[a], \
dates[b], obs_setups[c]))
print('')
#check to see if outputs of data reduction already
#exist. if so, ask the user whether to proceed. if
#the user does want to proceed, delete the
#previous outputs and start over.
nifs_checkdata_LP(workdir,galaxies[a]+'*log*')
#remind the user to open a ds9 window if needed
if flinter_telluric == 'yes':
response = \
raw_input('Need to have a DS9 window open. Hit '+\
'any key to continue. ')
#only HK, K grating centered on 2.20 microns and
#HK, K long grating centered on 2.30 microns is
#supported. have the pipeline quit if one of these
#two setups were not used.
if obs_setups[b] != 'hk_2.20' and \
obs_setups[b] != 'hk_2.30':
sys.exit('Pipeline is not written or tested for '+\
'your observational setup.')
#reduce the galaxy exposures
nifs_galaxy_LP(workdir, caldir, teldir, dates[b], flatlist,
arclist, ronchilist, darklist, telcorrlist,
galaxies[a], gallist, skylist, skylistshort,
sigclip_in, sigfrac_in, objlim_in,
nsigneg_in, rootdir, reducedir,
obs_setups[c], flinter_nsfitcoords,
flinter_telluric)
################################################################
if reduce_combine_gal.lower() == 'yes':
os.chdir(rootdir+reducedir+galaxies[a]+'/merged/')
obs_setups = sorted(glob.glob('*'), key=os.path.basename)
for b in range(len(obs_setups)):
#set the working directory
workdir = rootdir+reducedir+galaxies[a]+'/merged/'+obs_setups[b]+'/'
#may have a combined cube from another night, but now have
#an additional night and want to combine
#everything. remove any files that are not
#'image_catfbrsn*.fits' and atfbrsn*.fits and start the
#process over, but check with the user first.
nifs_checkdata_merged_LP(workdir,galaxies[a]+'*log*')
#check that at least one atbrsn*.fits file exists
os.chdir(workdir)
gal_images = sorted(glob.glob('image_catfbrsn*.fits'),
key=os.path.basename)
if len(gal_images) == 0:
sys.exit('Cannot find any image_catfbrsn*.fits '+\
'files in '+workdir+'.')
np.savetxt('gal_fileorder_for_offsetfiles.txt',
np.column_stack([gal_images]),fmt="%s")
#get the galaxy exposure file names (atfbrsn*.fits) from
#the image file names
gal_exps = []
for c in range(len(gal_images)):
gal_exps.append( (gal_images[c])[7:] )
#get the sky exposure names, if they exist
sky_exps = sorted(glob.glob('atfbrsn*_*.fits'),
key=os.path.basename)
if len(sky_exps) > 0:
np.savetxt('sky_fileorder_for_offsetfiles.txt',
np.column_stack([sky_exps]),fmt="%s")
#get the reference wavelength, which includes making a
#barycentric or heliocentric correction (if the user
#wants). even if no correction is done, the spectra are
#all sampled to the same starting/ending wavelength with
#the same delta lambda when creating a single merged
#cube. after a correction is applied (if any) determine
#the minimum, maximum, and wavelength scale for the
#spectra.
refwave_gal = nifs_refwave_LP(workdir, gal_exps[0], idlpath,
corr_type)
#determine the spatial offsets from the collapsed galaxy
#cubes using the first file as the reference
idl.pro('find_offsets_lp', workdir, gal_images)
#set the method for determining offsets between cubes
#(spaxel with maximum value, fitting 2D Gaussian,
#cross-correlating the collapsed cubes)
offsetresult = nifs_getoffmethod_LP(workdir, len(gal_images))
#merge galaxy exposures
nifs_merge_LP(workdir, gal_exps, galaxies[a], offsetresult[0],
offsetresult[1], refwave_gal, 'gal')
#merge sky exposures using the galaxy spaital offsets and
#the galaxy reference wavelength array
if len(sky_exps) > 0:
nifs_merge_LP(workdir, sky_exps, galaxies[a], offsetresult[0],
offsetresult[1], refwave_gal, 'sky')
################################################################################
#reduce psf star
if reduce_psf.lower() == 'yes':
for a in range(len(dates)):
#dates contains all the days data are to be reduced, but this
#psf may not have been observed on this date. check that here.
if os.path.isdir(rootdir+reducedir+'psfs/'+dates[a]):
os.chdir(rootdir+reducedir+'psfs/'+dates[a])
obs_setups = sorted(glob.glob('*'),key=os.path.basename)
for b in range(len(obs_setups)):
for c in range(len(galaxies)):
#a psf may or may not exist for each galaxy, so check.
if os.path.isdir(rootdir+reducedir+'psfs/'+dates[a]+\
'/'+obs_setups[b]+'/psf_'+\
galaxies[c]):
#set the psf work directory
workdir = rootdir+reducedir+'psfs/'+dates[a]+'/'+\
obs_setups[b]+'/psf_'+galaxies[c]+'/'
caldir = rootdir+reducedir+'daycals/'+dates[a]+'/'+\
obs_setups[b]+'/'
teldir = rootdir+reducedir+'tellurics/'+dates[a]+\
'/'+obs_setups[b]+'/'
#the names of the daycal lists; ; re-search for
#arclist and darklist in case the user made changes
flatlist = 'flatlist'
ronchilist = 'ronchilist'
os.chdir(caldir)
arclist = sorted(glob.glob('arclist*'),
key=os.path.basename)
#the names of the psf, sky, and telluric correction
#lists
os.chdir(workdir)
psflist = 'psflist'
skylist = 'skylist'
skylistshort = 'skylistshort'
telcorrlist = 'telcorrlist'
gpr = galaxies[c]
opr = obs_setups[b]
dpr = dates[a]
print('Starting the psf for %s for %s and %s' \
% (gpr,dpr,opr))
#check to see if outputs of data reduction
#already exist. if so, ask the user
#whether to proceed. if the user does want
#to proceed, delete the previous outputs
#and start over.
nifs_checkdata_LP(workdir,'psf_'+galaxies[c]+\
'*log*')
#only HK, K grating centered on 2.20 microns and
#HK, K long grating centered on 2.30 microns is
#supported. have the pipeline quit if one of these
#two setups were not used.
if obs_setups[b] != 'hk_2.20' and \
obs_setups[b] != 'hk_2.30':
sys.exit('Pipeline is not written or tested'+\
' for your observational setup.')
#reduce the psf exposures
nifs_psf_LP(workdir, caldir, teldir, dates[a],
flatlist, arclist, ronchilist,
telcorrlist, galaxies[c], psflist,
skylist, skylistshort, sigclip_in,
sigfrac_in, objlim_in, nsigneg_in,
rootdir, reducedir, obs_setups[b],
flinter_nsfitcoords, flinter_telluric)
#for this single night/observational setup
#combine into a single psf cube
#check that at least one atbrsn*.fits file exists
os.chdir(workdir)
psf_images = \
sorted(glob.glob('image_catfbrsn*.fits'),
key=os.path.basename)
if len(psf_images) == 0:
sys.exit('Cannot find any '+\
'image_catfbrsn*.fits '+\
'files in '+workdir+'.')
np.savetxt('psf_fileorder_for_offsetfiles.txt',
np.column_stack([psf_images]),fmt="%s")
#get the psf exposure file names (atfbrsn*.fits)
#from the image file names
psf_exps = []
for d in range(len(psf_images)):
psf_exps.append( (psf_images[d])[7:] )
#get the reference wavelength, which
#includes making a barycentric or
#heliocentric correction (if the user
#wants). even if no correction is done,
#the spectra are all sampled to the same
#starting/ending wavelength with the same
#delta lambda when creating a single
#merged cube. after a correction is
#applied (if any) determine the minimum,
#maximum, and wavelength scale for the
#spectra.
refwave_psf = nifs_refwave_LP(workdir, psf_exps[0],
idlpath, corr_type)
#determine the spatial offsets from the collapsed
#psf cubes using the first file as the reference
idl.pro('find_offsets_lp', workdir, psf_images)
#set the method for determining offsets between
#cubes (spaxel with maximum value, fitting 2D
#Gaussian, cross-correlating the collapsed cubes)
offsetresult = nifs_getoffmethod_LP(workdir,
len(psf_images))
#merge psf exposures
nifs_merge_LP(workdir, psf_exps, galaxies[c],
offsetresult[0], offsetresult[1],
refwave_psf, 'psf')
################################################################################
#merge psf star observations
if reduce_combine_psf.lower() == 'yes':
os.chdir(rootdir+reducedir+'psfs/merged')
obs_setups = sorted(glob.glob('*'),key=os.path.basename)
for a in range(len(obs_setups)):
for b in range(len(galaxies)):
#a psf may or may not exist for each galaxy, so check.
if os.path.isdir(rootdir+reducedir+'psfs/merged/'+\
obs_setups[a]+'/psf_'+galaxies[b]):
#set the working directory
workdir = rootdir+reducedir+'psfs/merged/'+obs_setups[a]+\
'/psf_'+galaxies[b]+'/'
#may have a combined cube from another night, but now
#have an additional night and want to combine
#everything. remove any files that are not
#'image_catfbrsn*.fits' and atfbrsn*.fits and start
#the process over, but check with the user first.
nifs_checkdata_merged_LP(workdir,galaxies[b]+'_psf*log*')
#check that at least one atbrsn*.fits file exists
os.chdir(workdir)
psf_images = sorted(glob.glob('image_catfbrsn*.fits'),
key=os.path.basename)
if len(psf_images) == 0:
sys.exit('Cannot find any image_catfbrsn*.fits '+\
'files in '+workdir+'.')
np.savetxt('psf_fileorder_for_offsetfiles.txt',
np.column_stack([psf_images]),fmt="%s")
#get the psf exposure file names (atfbrsn*.fits) from
#the image file names
psf_exps = []
for c in range(len(psf_images)):
psf_exps.append( (psf_images[c])[7:] )
#get the reference wavelength, don't make a
#barycentric or heliocentric correction. determine the
#minimum, maximum, and wavelength scale for the
#spectra.
refwave_psf = nifs_refwave_LP(workdir, psf_exps[0], idlpath,
corr_type)
#determine the spatial offsets from the collapsed psf
#cubes using the first file as the reference
idl.pro('find_offsets_lp', workdir, psf_images)
#set the method for determining offsets between cubes
#(spaxel with maximum value, fitting 2D Gaussian,
#cross-correlating the collapsed cubes)
offsetresult = nifs_getoffmethod_LP(workdir, len(psf_images))
#merge psf exposures
nifs_merge_LP(workdir, psf_exps, galaxies[b], offsetresult[0],
offsetresult[1], refwave_psf, 'psf')
################################################################################
#flux calibrate the merged galaxy cube and the sky cube
if reduce_fluxcal.lower() == 'yes':
for a in range(len(galaxies)):
os.chdir(rootdir+reducedir+galaxies[a]+'/merged')
obs_setups = sorted(glob.glob('*'),key=os.path.basename)
for b in range(len(obs_setups)):
workdir = rootdir+reducedir+galaxies[a]+'/merged/'+obs_setups[b]+'/'
#need to track down one of the telluric stars used for the
#galaxy.
telstar_result = nifs_findtelluric_fluxcalib_LP(rootdir+reducedir,
workdir,
galaxies[a],
obs_setups[b])
telstar_calib_dir = telstar_result[0]
date_telstar = telstar_result[1]
telstar_calib_file = 'N'+date_telstar+telstar_result[2]
telstar_name = (telstar_calib_dir.split('/'))[-2]
#work with the telluric star. need to telluric correct the
#telluric star and then generate a cube.
nifs_worktelluric_fluxcalib_LP(telstar_calib_dir,
telstar_calib_file, galaxies[a],
date_telstar, flinter_telluric)
#only HK, K grating centered on 2.20 microns and HK, K
#long grating centered on 2.30 microns is supported. have
#the pipeline quit if one of these two setups were not
#used.
if obs_setups[b] != 'hk_2.20' and obs_setups[b] != 'hk_2.30':
sys.exit('Pipeline is not written or tested'+\
' for your observational setup.')
#determine the multiplicative conversion factor to convert
#from counts/s to ergs/s/cm^2/A. then apply to the merged
#galaxy and sky cubes.
idl.pro('measurephot_calibcube', telstar_calib_dir, 'catfbrsn'+\
telstar_calib_file+'.fits', rootdir, reducedir,
galaxies[a], obs_setups[b], telstar_name)
################################################################################
#measure the LSF from the merged sky cube for each
#galaxy/observational setup
if reduce_measurelsf.lower() == 'yes':
for a in range(len(galaxies)):
os.chdir(rootdir+reducedir+galaxies[a]+'/merged')
obs_setups = sorted(glob.glob('*'),key=os.path.basename)
for b in range(len(obs_setups)):
workdir = rootdir+reducedir+galaxies[a]+'/merged/'+obs_setups[b]+'/'
os.chdir(workdir)
sky_flux = glob.glob(galaxies[a]+'_sky_combined_flux.fits')
sky_noflux = glob.glob(galaxies[a]+'_sky_combined.fits')
if len(sky_flux) == 1 and len(sky_noflux) == 1:
skycube = galaxies[a]+'_sky_combined_flux.fits'
if len(sky_flux) == 0 and len(sky_noflux) == 1:
skycube = galaxies[a]+'_sky_combined.fits'
if len(sky_flux) == 0 and len(sky_noflux) == 0:
sys.exit('There is no merged sky cube in '+workdir+\
' from which to measure the LSF.')
print('')
print('Measuring the LSF as a function of spatial location from'+\
' the merged sky cube...')
#only HK, K grating centered on 2.20 microns and HK, K
#long grating centered on 2.30 microns is supported. have
#the pipeline quit if one of these two setups were not
#used.
if obs_setups[b] != 'hk_2.20' and obs_setups[b] != 'hk_2.30':
sys.exit('Pipeline is not written or tested'+\
' for your observational setup.')
#fit Gaussians to the sky lines
idl.pro('measure_lsf_lp',workdir,skycube,refdir,galaxies[a],
obs_setups[b])
print('The LSF map is called '+\
'%s_fullskycube_fwhm_med.fits in %s ' % (galaxies[a],workdir))
################################################################################
sys.exit('Done.')
|
jlwalsh12REPO_NAMENIFS-reduction-pipelinePATH_START.@NIFS-reduction-pipeline_extracted@NIFS-reduction-pipeline-master@py_scripts@nifs_main_LP.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "astrorama/SourceXtractorPlusPlus",
"repo_path": "SourceXtractorPlusPlus_extracted/SourceXtractorPlusPlus-master/SEImplementation/python/sourcextractor/config/__init__.py",
"type": "Python"
}
|
# -*- coding: utf-8 -*-
# Copyright © 2019-2022 Université de Genève, LMU Munich - Faculty of Physics, IAP-CNRS/Sorbonne Université
#
# This library is free software; you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the Free
# Software Foundation; either version 3.0 of the License, or (at your option)
# any later version.
#
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from .argv import *
from .compat import *
from .measurement_images import (ByKeyword, ByPattern, FitsFile, ImageGroup, MeasurementGroup,
MeasurementImage, DataCubeSlice)
from .model_fitting import (ComputeGraphModel, ConstantModel, ConstantParameter, DeVaucouleursModel,
DependentParameter, ExponentialModel, FluxParameterType, FreeParameter,
PointSourceModel, Range, RangeType, SersicModel, Unbounded,
get_flux_parameter, get_pos_parameters, get_position_angle,
get_separation_angle, get_world_parameters,
get_world_position_parameters, pixel_to_world_coordinate,
print_model_fitting_info, radius_to_wc_angle, ModelFitting)
|
astroramaREPO_NAMESourceXtractorPlusPlusPATH_START.@SourceXtractorPlusPlus_extracted@SourceXtractorPlusPlus-master@SEImplementation@python@sourcextractor@config@__init__.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "pmelchior/scarlet",
"repo_path": "scarlet_extracted/scarlet-master/scarlet/lite/__init__.py",
"type": "Python"
}
|
from .initialization import *
from .models import *
from .parameters import *
from .utils import *
from .measure import *
from . import display
|
pmelchiorREPO_NAMEscarletPATH_START.@scarlet_extracted@scarlet-master@scarlet@lite@__init__.py@.PATH_END.py
|
{
"filename": "read_spectrum.py",
"repo_name": "tomasstolker/species",
"repo_path": "species_extracted/species-main/species/read/read_spectrum.py",
"type": "Python"
}
|
"""
Module with reading functionalities for spectral libraries.
"""
import os
from configparser import ConfigParser
from typing import List, Optional
import h5py
import numpy as np
from typeguard import typechecked
from species.core.box import PhotometryBox, SpectrumBox, create_box
from species.data.spec_data.add_spec_data import add_spec_library
from species.phot.syn_phot import SyntheticPhotometry
from species.read.read_filter import ReadFilter
class ReadSpectrum:
"""
Class for reading spectral library data from the database.
"""
@typechecked
def __init__(self, spec_library: str, filter_name: Optional[str] = None) -> None:
"""
Parameters
----------
spec_library : str
Name of the spectral library ('irtf', 'spex', 'kesseli+2017',
'bonnefoy+2014', 'allers+2013', or 'vega').
filter_name : str, None
Filter name for the wavelength range. Full spectra
are read if the argument is set to ``None``.
Returns
-------
NoneType
None
"""
self.spec_library = spec_library
self.filter_name = filter_name
if filter_name is None:
self.wavel_range = None
else:
transmission = ReadFilter(filter_name)
self.wavel_range = transmission.wavelength_range()
config_file = os.path.join(os.getcwd(), "species_config.ini")
config = ConfigParser()
config.read(config_file)
self.database = config["species"]["database"]
self.data_folder = config["species"]["data_folder"]
@typechecked
def get_spectrum(
self, sptypes: Optional[List[str]] = None, exclude_nan: bool = True
) -> SpectrumBox:
"""
Function for selecting spectra from the database.
Parameters
----------
sptypes : list(str), None
Spectral types to select from a library. The spectral types
should be indicated with two characters (e.g. 'M5', 'L2',
'T3'). All spectra are selected if set to ``None``. For
each object in the ``spec_library``, the requested
``sptypes`` are first compared with the optical spectral
type and, if not available, secondly the near-infrared
spectral type.
exclude_nan : bool
Exclude wavelength points for which the flux is NaN.
Returns
-------
species.core.box.SpectrumBox
Box with the spectra.
"""
with h5py.File(self.database, "a") as hdf5_file:
if f"spectra/{self.spec_library}" not in hdf5_file:
add_spec_library(
self.data_folder, hdf5_file, self.spec_library, sptypes
)
list_wavelength = []
list_flux = []
list_error = []
list_name = []
list_simbad = []
list_sptype = []
list_parallax = []
list_spec_res = []
with h5py.File(self.database, "r") as hdf5_file:
for item in hdf5_file[f"spectra/{self.spec_library}"]:
dset = hdf5_file[f"spectra/{self.spec_library}/{item}"]
wavelength = dset[:, 0] # (um)
flux = dset[:, 1] # (W m-2 um-1)
error = dset[:, 2] # (W m-2 um-1)
if exclude_nan:
nan_index = np.isnan(flux)
wavelength = wavelength[~nan_index]
flux = flux[~nan_index]
error = error[~nan_index]
if self.wavel_range is None:
wl_index = np.arange(0, len(wavelength), 1)
else:
wl_index = (
(flux > 0.0)
& (wavelength > self.wavel_range[0])
& (wavelength < self.wavel_range[1])
)
count = np.count_nonzero(wl_index)
if count > 0:
index = np.where(wl_index)[0]
if index[0] > 0:
wl_index[index[0] - 1] = True
if index[-1] < len(wl_index) - 1:
wl_index[index[-1] + 1] = True
list_wavelength.append(wavelength[wl_index])
list_flux.append(flux[wl_index])
list_error.append(error[wl_index])
attrs = dset.attrs
if "name" in attrs:
if isinstance(dset.attrs["name"], str):
list_name.append(dset.attrs["name"])
else:
list_name.append(dset.attrs["name"].decode("utf-8"))
else:
list_name.append("")
if "simbad" in attrs:
if isinstance(dset.attrs["simbad"], str):
list_simbad.append(dset.attrs["simbad"])
else:
list_simbad.append(dset.attrs["simbad"].decode("utf-8"))
else:
list_simbad.append("")
if "sptype" in attrs:
if isinstance(dset.attrs["sptype"], str):
list_sptype.append(dset.attrs["sptype"])
else:
list_sptype.append(dset.attrs["sptype"].decode("utf-8"))
else:
list_sptype.append("None")
if "parallax" in attrs:
list_parallax.append(
(dset.attrs["parallax"], dset.attrs["parallax_error"])
)
else:
list_parallax.append((np.nan, np.nan))
if "spec_res" in attrs:
list_spec_res.append(dset.attrs["spec_res"])
else:
list_spec_res.append(np.nan)
else:
list_wavelength.append(np.array([]))
list_flux.append(np.array([]))
list_error.append(np.array([]))
list_name.append("")
list_simbad.append("")
list_sptype.append("None")
list_parallax.append((np.nan, np.nan))
list_spec_res.append(np.nan)
spec_box = SpectrumBox()
spec_box.spec_library = self.spec_library
if sptypes is not None:
spec_box.wavelength = []
spec_box.flux = []
spec_box.error = []
spec_box.name = []
spec_box.simbad = []
spec_box.sptype = []
spec_box.parallax = []
spec_box.spec_res = []
for item in sptypes:
for i, spec_item in enumerate(list_sptype):
if item == spec_item[:2]:
spec_box.wavelength.append(list_wavelength[i])
spec_box.flux.append(list_flux[i])
spec_box.error.append(list_error[i])
spec_box.name.append(list_name[i])
spec_box.simbad.append(list_simbad[i])
spec_box.sptype.append(list_sptype[i])
spec_box.parallax.append(list_parallax[i])
spec_box.spec_res.append(list_spec_res[i])
else:
spec_box.wavelength = list_wavelength
spec_box.flux = list_flux
spec_box.error = list_error
spec_box.name = list_name
spec_box.simbad = list_simbad
spec_box.sptype = list_sptype
spec_box.parallax = list_parallax
spec_box.spec_res = list_spec_res
return spec_box
@typechecked
def get_flux(self, sptypes: Optional[List[str]] = None) -> PhotometryBox:
"""
Function for calculating the average flux density for the
``filter_name``.
Parameters
----------
sptypes : list(str), None
Spectral types to select from a library. The spectral types
should be indicated with two characters (e.g. 'M5', 'L2',
'T3'). All spectra are selected if set to ``None``.
Returns
-------
species.core.box.PhotometryBox
Box with the synthetic photometry.
"""
spec_box = self.get_spectrum(sptypes=sptypes, exclude_nan=True)
n_spectra = len(spec_box.wavelength)
filter_profile = ReadFilter(filter_name=self.filter_name)
mean_wavel = filter_profile.mean_wavelength()
wavelengths = np.full(n_spectra, mean_wavel)
filters = np.full(n_spectra, self.filter_name)
synphot = SyntheticPhotometry(filter_name=self.filter_name)
phot_flux = []
for i in range(n_spectra):
flux = synphot.spectrum_to_flux(
wavelength=spec_box.wavelength[i],
flux=spec_box.flux[i],
error=spec_box.error[i],
)
phot_flux.append(flux)
phot_flux = np.asarray(phot_flux)
return create_box(
boxtype="photometry",
name=spec_box.name,
sptype=spec_box.sptype,
wavelength=wavelengths,
flux=phot_flux,
app_mag=None,
abs_mag=None,
filter_name=filters,
)
@typechecked
def get_magnitude(self, sptypes: Optional[List[str]] = None) -> PhotometryBox:
"""
Function for calculating the apparent magnitude for the
specified ``filter_name``.
Parameters
----------
sptypes : list(str), None
Spectral types to select from the library. The spectral
types should be indicated with two characters (e.g. 'M5',
'L2', 'T3'). All spectra are selected if set to ``None``.
Returns
-------
species.core.box.PhotometryBox
Box with the synthetic photometry.
"""
spec_box = self.get_spectrum(sptypes=sptypes, exclude_nan=True)
n_spectra = len(spec_box.wavelength)
filter_profile = ReadFilter(filter_name=self.filter_name)
mean_wavel = filter_profile.mean_wavelength()
wavelengths = np.full(n_spectra, mean_wavel)
filters = np.full(n_spectra, self.filter_name)
synphot = SyntheticPhotometry(filter_name=self.filter_name)
app_mag = []
abs_mag = []
for i in range(n_spectra):
if np.isnan(spec_box.parallax[i][0]):
app_tmp = (np.nan, np.nan)
abs_tmp = (np.nan, np.nan)
else:
app_tmp, abs_tmp = synphot.spectrum_to_magnitude(
spec_box.wavelength[i],
spec_box.flux[i],
error=spec_box.error[i],
parallax=(
float(spec_box.parallax[i][0]),
float(spec_box.parallax[i][1]),
),
)
app_mag.append(app_tmp)
abs_mag.append(abs_tmp)
return create_box(
boxtype="photometry",
name=spec_box.name,
sptype=spec_box.sptype,
wavelength=wavelengths,
flux=None,
app_mag=np.asarray(app_mag),
abs_mag=np.asarray(abs_mag),
filter_name=filters,
)
|
tomasstolkerREPO_NAMEspeciesPATH_START.@species_extracted@species-main@species@read@read_spectrum.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py3/plotly/validators/layout/scene/camera/projection/__init__.py",
"type": "Python"
}
|
import sys
from typing import TYPE_CHECKING
if sys.version_info < (3, 7) or TYPE_CHECKING:
from ._type import TypeValidator
else:
from _plotly_utils.importers import relative_import
__all__, __getattr__, __dir__ = relative_import(
__name__, [], ["._type.TypeValidator"]
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py3@plotly@validators@layout@scene@camera@projection@__init__.py@.PATH_END.py
|
{
"filename": "zhaires.py",
"repo_name": "grand-mother/grand",
"repo_path": "grand_extracted/grand-main/grand/simu/shower/zhaires.py",
"type": "Python"
}
|
"""
Extract informations from ZHAires simulation
"""
from __future__ import annotations
from datetime import datetime
from logging import getLogger
from pathlib import Path
import re
from typing import Any, Dict, Optional
import h5py
import numpy
from grand.simu.shower.gen_shower import CollectionEntry, FieldsCollection, ShowerEvent
from grand.basis.type_trace import ElectricField
from grand.simu.shower.pdg import ParticleCode
from grand.geo.coordinates import ECEF, LTP, Geodetic
from grand.geo.coordinates import (
CartesianRepresentation,
SphericalRepresentation,
)
__all__ = ["InvalidAntennaName", "ZhairesShower"]
logger = getLogger(__name__)
class InvalidAntennaName(ValueError):
pass
class ZhairesShower(ShowerEvent):
@classmethod
def check_dir(cls, path: Path) -> bool:
try:
_ = path.glob("*.sry").__next__()
except StopIteration:
return False
return True
@classmethod
def _from_dir(cls, path: Path) -> ZhairesShower:
"""
Extract informations about ZHAires simulation from xxx.sry file
@note:
Zhaires has a fixed coordinate frame at a location with 'NWU'
orientation at the sea level:
- 'N' is the magnetic north,
- 'W' is 90 deg west from 'N',
- 'U' is upward towards zenith.
:param cls: class dict
:param path (TBD): path of simulation
"""
def parse_primary(string: str) -> ParticleCode:
return {"Proton": ParticleCode.PROTON, "Iron": ParticleCode.IRON}[string.strip()]
def parse_quantity(string: str):
words = string.split()
return float(words[0])
def parse_frame_location(string: str):
lat, lon = string.split("Long:")
lat_f = parse_quantity(lat[:-2])
lon_f = parse_quantity(lon[:-3])
# Rk. Based on shower-event.py, reference of height is wrt ellipsoid instead of geoid.
geodetic = Geodetic(latitude=lat_f, longitude=lon_f, height=0, reference="ELLIPSOID")
return ECEF(geodetic)
def parse_date(string: str) -> datetime:
return datetime.strptime(string.strip(), "%d/%b/%Y")
def parse_frame_direction(string: str):
inp["_origin"] = inp["frame"]
string = string.strip()
if string == "Local magnetic north":
return "NWU"
else:
raise NotImplementedError(string)
def parse_geomagnet_intensity(string: str): # -> u.Quantity:
return float(string.split()[0]) * 1e-3 # uT --> nT
def parse_geomagnet_angles(string: str) -> CartesianRepresentation:
intensity = inp["geomagnet"]
inclination, _, _, declination, _ = string.split()
theta = 90 + float(inclination) # deg
inp["_declination"] = float(declination) # deg
# phi=0 because x-axis is parallel to the magnetic north.
spherical = SphericalRepresentation(theta=theta, phi=0, r=intensity)
return CartesianRepresentation(spherical)
def parse_maximum(string: str) -> CartesianRepresentation:
"""
@note:
Xmax is given as CartesianRepresentation defined in the shower frame.
Later (below) Xmax is saved wrt LTP frame making it independent of shower info.
"Previously: Dirty hack by OMH for now" -> not necessary now. RK.
"""
_, _, *xyz = string.split()
x, y, z = map(float, xyz)
try:
inp_file = path.glob("*.inp").__next__()
logger.info(f"reading groundaltitude from : {inp_file}")
with open(inp_file, encoding="UTF-8") as f:
for line in f:
if "GroundAltitude" in line:
ground_alt = float(line.split()[1]) # m
inp["ground_alt"] = ground_alt
except StopIteration as parse_maximum_exit:
raise FileNotFoundError(path / "*.inp") from parse_maximum_exit
return CartesianRepresentation(x=1000 * x, y=1000 * y, z=1000 * z) # RK. km --> m
if not path.exists():
raise FileNotFoundError(path)
inp: Dict[str, Any] = {}
try:
sry_path = path.glob("*.sry").__next__()
except StopIteration as from_dir_exit:
raise FileNotFoundError(path / "*.sry") from from_dir_exit
else:
print(sry_path)
print(type(sry_path))
converters = (
("(Lat", "frame", parse_frame_location),
("Date", "_obstime", parse_date),
("Primary particle", "primary", parse_primary),
("Primary energy", "energy", parse_quantity),
("Primary zenith angle", "zenith", parse_quantity),
("Primary azimuth angle", "azimuth", parse_quantity),
("Zero azimuth direction", "frame", parse_frame_direction),
(
"Geomagnetic field: Intensity:",
"geomagnet",
parse_geomagnet_intensity,
),
("I:", "geomagnet", parse_geomagnet_angles),
)
# deprecated 19.04.08:
# ("Location of max.(Km)", "maximum", parse_maximum)
# so check is present before add it
with sry_path.open() as f:
sry_all = f.read()
# now add the wright tuple element
if sry_all.find("Pos. Max.") > 0:
converters += (("Pos. Max.", "maximum", parse_maximum),)
else:
converters += (("Location of max.(Km)", "maximum", parse_maximum),)
i = 0
tag, k, convert = converters[i]
with sry_path.open() as f:
for line in f:
start = line.find(tag)
if start < 0:
continue
inp[k] = convert(line[start + len(tag) + 1 :])
i = i + 1
try:
tag, k, convert = converters[i]
except IndexError:
# end of list converters
break
origin = inp.pop("_origin")
declination = inp.pop("_declination")
obstime = inp.pop("_obstime")
orientation = inp["frame"]
try:
ground_alt = inp["ground_alt"]
except:
parse_maximum()
# RK. x, y and z are given in ECEF.
ecef = ECEF(
x=origin[0][0],
y=origin[1][0],
z=origin[2][0],
)
inp["frame"] = LTP(
location=ecef,
orientation=orientation,
declination=declination,
obstime=obstime,
)
inp["core"] = LTP(x=0, y=0, z=ground_alt, frame=inp["frame"])
# RK. Save Xmax in LTP frame. It will be easier to convert to antenna frame.
# But it takes more space (about 8 times/antenna).
Xmax = inp["maximum"]
inp["maximum"] = LTP(x=Xmax.x, y=Xmax.y, z=Xmax.z, frame=inp["frame"]) # RK
# Positions are in LTP frame with origin at shower core. Usually shower frame has 'NWU' orientation,
# where N=magnetic north. Defined in ..../grand/tests/simulation/data/zhaires/*.sry file.
positions = {}
ant_file = path / "antpos.dat" # Ex: 1 A0 0.00000E+00 2.70450E+02 2.90000E+03
if ant_file.exists():
pattern = re.compile("A([0-9]+)$")
with ant_file.open() as f:
for line in f:
if not line:
continue
words = line.split()
match = pattern.search(words[1])
if match is None:
raise InvalidAntennaName(words[1])
antenna = int(match.group(1))
positions[antenna] = CartesianRepresentation(
x=float(words[2]), # m, # x-coordinate from shower core.
y=float(words[3]), # m, # y-coordinate from shower core.
z=float(words[4]), # m, # z-coordinate from shower core.
)
# print("### Warning: Forcing antenna height = 0m")
# RK. Note: this is time consuming but useful.
# CartesianRepresentation~200Bytes/antenna, LTP~900Bytes/antenna.
# positions[antenna] = LTP(
# x = float(words[2]), #* u.m, # x-coordinate in LTP frame.
# y = float(words[3]), #* u.m, # y-coordinate in LTP frame.
# z = float(words[4]), #* u.m, # z-coordinate in LTP frame.
# frame = inp['frame']
# )
fields: Optional[FieldsCollection] = None
raw_fields = {}
for field_path in path.glob("a*.trace"):
# Example field_path => ..../grand/tests/simulation/data/zhaires/a1.trace
# => time [ns] Ex [uVm] Ey [uVm] Ez [uVm]
# => -1.1463000E+04 -5.723E-05 -1.946E-04 4.324E-04
antenna = int(field_path.name[1:].split(".", 1)[0])
# logger.debug(f"Loading trace for antenna {antenna}")
data = numpy.loadtxt(field_path)
t = data[:, 0] * 1.0e-9 # ns --> s
Ex = data[:, 1] # uVm
Ey = data[:, 2] # uVm
Ez = data[:, 3] # uVm
electric = ElectricField(
t, CartesianRepresentation(x=Ex, y=Ey, z=Ez), positions[antenna]
)
raw_fields[antenna] = CollectionEntry(electric)
if raw_fields:
fields = FieldsCollection()
for key in sorted(raw_fields.keys()):
fields[key] = raw_fields[key]
return cls(fields=fields, **inp)
@classmethod
def _from_datafile(cls, path: Path):
with h5py.File(path, "r") as fd:
if not "RunInfo.__table_column_meta__" in fd["/"]:
return super()._from_datafile(path)
last_name = ""
for name in fd["/"].keys():
last_name = name
if not name.startswith("RunInfo"):
break
event = fd[f"{last_name}/EventInfo"]
antennas = fd[f"{last_name}/AntennaInfo"]
traces = fd[f"{last_name}/AntennaTraces"]
fields = FieldsCollection()
pattern = re.compile("([0-9]+)$")
for tag, x, y, z, *_ in antennas:
tag = tag.decode()
# TODO: mypy indicate type error ... disable
antenna = int(pattern.search(tag)[1]) # type: ignore[index]
r = CartesianRepresentation(x=float(x), y=float(y), z=float(z)) # RK
tmp = traces[f"{tag}/efield"][:]
efield = tmp.view("f4").reshape(tmp.shape + (-1,))
t = numpy.asarray(efield[:, 0], "f8") * 1.0e-9 # ns --> s
Ex = numpy.asarray(efield[:, 1], "f8") # uV/m
Ey = numpy.asarray(efield[:, 2], "f8") # uV/m
Ez = numpy.asarray(efield[:, 3], "f8") # uV/m
E = CartesianRepresentation(x=Ex, y=Ey, z=Ez)
fields[antenna] = CollectionEntry(electric=ElectricField(t=t, E=E, r=r))
primary = {
"Fe^56": ParticleCode.IRON,
"Gamma": ParticleCode.GAMMA,
"Proton": ParticleCode.PROTON,
}[event[0, "Primary"].decode()]
geomagnet = SphericalRepresentation(
theta=float(90 + event[0, "BFieldIncl"]), # deg
phi=0, # deg
r=float(event[0, "BField"]) * 1e3, # uT --> nT
)
try:
latitude = event[0, "Latitude"] # deg
longitude = event[0, "Longitude"] # deg
declination = event[0, "BFieldDecl"] # deg
obstime = datetime.strptime(event[0, "Date"].strip(), "%d/%b/%Y")
except ValueError:
frame = None
else:
geodetic = Geodetic(latitude=latitude, longitude=longitude, height=0.0)
origin = ECEF(geodetic)
frame = LTP(
location=origin,
orientation="NWU",
declination=declination,
obstime=obstime,
)
return cls(
energy=float(event[0, "Energy"]) * 1.0e9, # EeV --> GeV
zenith=(180 - float(event[0, "Zenith"])), # deg,
azimuth=-float(event[0, "Azimuth"]), # deg,
primary=primary,
frame=frame,
core=LTP(x=0, y=0, z=event["GroundAltitude"], frame=frame),
geomagnet=CartesianRepresentation(geomagnet),
maximum=LTP(
x=event[0, "XmaxPosition"][0],
y=event[0, "XmaxPosition"][1],
z=event[0, "XmaxPosition"][2],
frame=frame,
), # RK TODO: Check if x,y,z are defined in frame.
fields=fields,
)
|
grand-motherREPO_NAMEgrandPATH_START.@grand_extracted@grand-main@grand@simu@shower@zhaires.py@.PATH_END.py
|
{
"filename": "strategy_gather_test.py",
"repo_name": "tensorflow/tensorflow",
"repo_path": "tensorflow_extracted/tensorflow-master/tensorflow/python/distribute/strategy_gather_test.py",
"type": "Python"
}
|
# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for common methods in strategy classes."""
from absl.testing import parameterized
from tensorflow.python.data.ops import dataset_ops
from tensorflow.python.distribute import central_storage_strategy
from tensorflow.python.distribute import combinations
from tensorflow.python.distribute import distribute_lib
from tensorflow.python.distribute import mirrored_strategy
from tensorflow.python.distribute import strategy_combinations
from tensorflow.python.distribute import test_util
from tensorflow.python.distribute import tpu_strategy
from tensorflow.python.distribute.collective_all_reduce_strategy import CollectiveAllReduceStrategy
from tensorflow.python.eager import def_function
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors
from tensorflow.python.framework import indexed_slices
from tensorflow.python.framework import test_util as tf_test_util
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gradients_impl
from tensorflow.python.platform import test
from tensorflow.python.util import nest
@tf_test_util.with_eager_op_as_function
@combinations.generate(
combinations.combine(
strategy=[
strategy_combinations.default_strategy,
strategy_combinations.one_device_strategy,
strategy_combinations.one_device_strategy_gpu,
strategy_combinations.central_storage_strategy_with_two_gpus,
strategy_combinations.central_storage_strategy_with_gpu_and_cpu,
strategy_combinations.mirrored_strategy_with_one_cpu,
strategy_combinations.mirrored_strategy_with_one_gpu,
strategy_combinations.mirrored_strategy_with_two_gpus,
strategy_combinations.mirrored_strategy_with_two_cpus,
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
strategy_combinations.multi_worker_mirrored_2x2_gpu,
strategy_combinations.multi_worker_mirrored_2x1_cpu,
strategy_combinations.multi_worker_mirrored_2x1_gpu,
],
mode=['eager'],
pure_eager=[True, False]) + combinations.combine(
strategy=[
strategy_combinations.tpu_strategy,
strategy_combinations.tpu_strategy_packed_var,
strategy_combinations.tpu_strategy_one_step,
strategy_combinations.cloud_tpu_strategy,
],
mode=['eager'],
pure_eager=[False]))
class GatherTest(test.TestCase, parameterized.TestCase):
def _gather_same_shape_and_verify(self, value_on_replica, axis, pure_eager,
strategy):
distributed_values = strategy.experimental_distribute_values_from_function(
lambda _: array_ops.identity(value_on_replica))
def run():
return strategy.gather(distributed_values, axis=axis)
if not pure_eager:
run = def_function.function(run)
all_results = [
value_on_replica for _ in range(strategy.num_replicas_in_sync)
]
expected_result = array_ops.concat(all_results, axis=axis)
self.assertAllEqual(expected_result, run().numpy())
def testGatherPerReplicaDense1D0Axis(self, strategy, pure_eager):
"""A DistributedValues object with two tensors of shape [3] on each replica gathers to a tensor of [6]."""
single_value = constant_op.constant([1, 2, 3])
axis = 0
self._gather_same_shape_and_verify(single_value, axis, pure_eager, strategy)
def testGatherPerReplicaDense2D0Axis(self, strategy, pure_eager):
"""A DistributedValues object with two tensors of [1, 3] on each replica gathers along 0th dim to a tensor of [2, 3]."""
single_value = constant_op.constant([[1, 2, 3]])
axis = 0
self._gather_same_shape_and_verify(single_value, axis, pure_eager, strategy)
def testGatherPerReplicaDense2D1Axis(self, strategy, pure_eager):
"""A DistributedValues object with two tensors of [1, 3] on each replica gathers along 1st dim to a tensor of [1, 6]."""
single_value = constant_op.constant([[1, 2, 3]])
axis = 1
self._gather_same_shape_and_verify(single_value, axis, pure_eager, strategy)
def testGatherPerReplicaDense3D0Axis(self, strategy, pure_eager):
"""A DistributedValues object with two tensors of [1, 2, 2] on each replica gathers along 0th dim to a tensor of [2, 2, 2]."""
single_value = constant_op.constant([[[1, 2], [1, 2]]])
axis = 0
self._gather_same_shape_and_verify(single_value, axis, pure_eager, strategy)
def testGatherPerReplicaDense3D1Axis(self, strategy, pure_eager):
"""A DistributedValues object with two tensors of [1, 2, 2] on each replica gathers along 1nd dimension to a tensor of [1, 4, 2]."""
single_value = constant_op.constant([[[1, 2], [1, 2]]])
axis = 1
self._gather_same_shape_and_verify(single_value, axis, pure_eager, strategy)
def testGatherPerReplicaDense3D2Axis(self, strategy, pure_eager):
"""A DistributedValues object with two tensors of [1, 2, 2] on each replica gathers along 2nd dimension to a tensor of [1, 2, 4]."""
single_value = constant_op.constant([[[1, 2], [1, 2]]])
axis = 2
self._gather_same_shape_and_verify(single_value, axis, pure_eager, strategy)
def testGatherDiffShapeAtAxis0(self, strategy, pure_eager):
"""Different `Axis`-th (0) dimension: shape [1, 1], [2, 1] -> [3, 1]."""
def value_fn(ctx):
return constant_op.constant(
1, shape=(ctx.replica_id_in_sync_group + 1, 1))
distributed_values = strategy.experimental_distribute_values_from_function(
value_fn)
axis = 0
def run():
return strategy.gather(distributed_values, axis=axis)
if not pure_eager:
run = def_function.function(run)
expected_result = constant_op.constant(
1, shape=(sum(range(strategy.num_replicas_in_sync + 1)), 1))
self.assertAllEqual(expected_result, run().numpy())
def testGatherDiffShapeAtAxis1(self, strategy, pure_eager):
"""Different `Axis`-th (non-0) dimension: shape [1, 1], [1, 2] -> [1, 3]."""
def value_fn(ctx):
return constant_op.constant(
1, shape=(1, ctx.replica_id_in_sync_group + 1))
distributed_values = strategy.experimental_distribute_values_from_function(
value_fn)
axis = 1
def run():
return strategy.gather(distributed_values, axis=axis)
if not pure_eager:
run = def_function.function(run)
expected_result = constant_op.constant(
1, shape=(1, sum(range(strategy.num_replicas_in_sync + 1))))
self.assertAllEqual(expected_result, run().numpy())
def testGatherRaiseDiffShapeAtNonAxis(self, strategy, pure_eager):
"""Different at non-`axis`-th dimension : [1, 1], [1, 2], 0th -> raise error."""
if isinstance(strategy, CollectiveAllReduceStrategy
) and _get_num_replicas_per_client(strategy) > 1:
self.skipTest('b/167331966')
if strategy.num_replicas_in_sync <= 1:
self.skipTest('Test for more than 1 replica only.')
def value_fn(ctx):
return constant_op.constant(
1, shape=(1, ctx.replica_id_in_sync_group + 1))
distributed_values = strategy.experimental_distribute_values_from_function(
value_fn)
axis = 0
def run():
return strategy.gather(distributed_values, axis=axis)
if not pure_eager:
run = def_function.function(run)
if isinstance(strategy, CollectiveAllReduceStrategy):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r'Shape mismatch'):
run()
elif isinstance(strategy,
(mirrored_strategy.MirroredStrategy,
central_storage_strategy.CentralStorageStrategy)):
with self.assertRaisesRegex((errors.InvalidArgumentError, ValueError),
r'Dimension \d in both shapes must be equal'):
run()
def testGatherRaiseSparse(self, strategy, pure_eager):
dense_shape = [5, 2]
t0 = _make_indexed_slices(
values=[[1., 2.]], indices=[2], dense_shape=dense_shape)
def run(value):
return strategy.gather(value, axis=0)
with self.assertRaisesRegex(
NotImplementedError,
r'gather does not support IndexedSlices'):
if pure_eager:
run(t0)
else:
def_function.function(run)(t0)
def testGatherRaiseDifferentRank(self, strategy, pure_eager):
"""Different rank: [1,], [1, 2] -> raise error."""
if strategy.num_replicas_in_sync <= 1:
self.skipTest('Test for more than 1 replicas.')
if isinstance(strategy, CollectiveAllReduceStrategy
) and _get_num_replicas_per_client(strategy) > 1:
self.skipTest('b/167331966')
def value_fn(ctx):
return array_ops.ones(shape=(range(1, ctx.replica_id_in_sync_group + 2)))
distributed_values = strategy.experimental_distribute_values_from_function(
value_fn)
axis = 0
def run():
return strategy.gather(distributed_values, axis=axis)
if not pure_eager:
run = def_function.function(run)
if isinstance(strategy, CollectiveAllReduceStrategy):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r'Shape mismatch'):
run()
elif isinstance(
strategy,
(mirrored_strategy.MirroredStrategy,
central_storage_strategy.CentralStorageStrategy)):
if pure_eager:
with self.assertRaises(errors.InvalidArgumentError) as e:
run()
# Different error message depending on whether collective ops is used.
self.assertRegexMatch(
str(e.exception),
['Ranks of all input tensors should match', 'Shape mismatch'])
else:
with self.assertRaises((errors.InvalidArgumentError, ValueError)) as e:
run()
self.assertRegexMatch(
str(e.exception),
[r'Shape must be rank \d but is rank \d', 'Shape mismatch'])
elif _is_tpu_strategy(strategy) and pure_eager:
with self.assertRaisesRegex(ValueError,
r'Dimension \d in both shapes must be equal'):
run()
else:
with self.assertRaisesRegex(ValueError,
r'Shape must be rank \d but is rank \d'):
run()
# Ideally, here we should split them into another test class, AllGatherTest.
# But doing that makes two initialize_tpu_system() calls and one of them times
# out, on Kokoro. Integrating two into one avoids it.
def _all_gather_same_shape_and_verify(self, value_on_replica, axis,
pure_eager, strategy):
per_replica_value = strategy.experimental_distribute_values_from_function(
lambda _: array_ops.identity(value_on_replica))
def replica_fn(per_replica_value):
ctx = distribute_lib.get_replica_context()
local_value = array_ops.identity(per_replica_value)
return ctx.all_gather(local_value, axis=axis)
if not pure_eager:
replica_fn = def_function.function(replica_fn)
result = strategy.experimental_local_results(
strategy.run(replica_fn, args=(per_replica_value,)))
all_value = [value_on_replica for _ in range(strategy.num_replicas_in_sync)]
expect = array_ops.concat(all_value, axis=axis)
expected_result = [expect] * _get_num_replicas_per_client(strategy)
self.assertAllClose(expected_result, result)
def testAllGatherPerReplicaDense1D0Axis(self, strategy, pure_eager):
"""all_gather(..., axis=0,...) a DistributedValues with a Tensor of shape (3,) on two replica returns a PerReplica of tensor(s) with shape (6,)."""
single_value = constant_op.constant([1, 2, 3], dtype=dtypes.float32)
axis = 0
self._all_gather_same_shape_and_verify(single_value, axis, pure_eager,
strategy)
def testAllGatherPerReplicaDense2D0Axis(self, strategy, pure_eager):
"""all_gather(..., axis=0,...) a DistributedValues with a Tensor of shape (1,3) on two replica returns PerReplica of tensor(s) with shape (2,3)."""
single_value = constant_op.constant([[1, 2, 3]])
axis = 0
self._all_gather_same_shape_and_verify(single_value, axis, pure_eager,
strategy)
def testAllGatherPerReplicaDense2D1Axis(self, strategy, pure_eager):
"""all_gather(..., axis=1,...) a DistributedValues with a Tensor of shape (1,3) on two replica returns PerReplica of tensor(s) with shape (1,6)."""
single_value = constant_op.constant([[1, 2, 3]])
axis = 1
self._all_gather_same_shape_and_verify(single_value, axis, pure_eager,
strategy)
def testAllGatherPerReplicaDense3D0Axis(self, strategy, pure_eager):
"""all_gather(..., axis=0,...) a DistributedValues with a Tensor of shape (1,2,2) on two replica returns PerReplica of tensor(s) with shape (2,2,2)."""
single_value = constant_op.constant([[[1, 2], [1, 2]]])
axis = 0
self._all_gather_same_shape_and_verify(single_value, axis, pure_eager,
strategy)
def testAllGatherPerReplicaDense3D1Axis(self, strategy, pure_eager):
"""all_gather(..., axis=1,...) a DistributedValues with a Tensor of shape (1,2,2) on two replica returns PerReplica of tensor(s) with shape (1,4,2)."""
single_value = constant_op.constant([[[1, 2], [1, 2]]])
axis = 1
self._all_gather_same_shape_and_verify(single_value, axis, pure_eager,
strategy)
def testAllGatherPerReplicaDense3D2Axis(self, strategy, pure_eager):
"""all_gather(..., axis=2,...) a DistributedValues with a Tensor of shape (1,2,2) on two replica returns PerReplica of tensor(s) with shape (1,2,4)."""
single_value = constant_op.constant([[[1, 2], [1, 2]]])
axis = 2
self._all_gather_same_shape_and_verify(single_value, axis, pure_eager,
strategy)
def testAllGatherDiffValueTPU(self, strategy, pure_eager):
# Test for TPU only since it can't be tested via testAllGatherDiffShape*
if not _is_tpu_strategy(strategy):
self.skipTest('Test for TPU only. For other strategies case already'
' covered in other tests')
data = [[1], [2], [3], [4], [5], [6], [7], [8]]
axis = 0
dataset = dataset_ops.DatasetV2.from_tensor_slices(data).batch(8)
input_iterator = iter(strategy.experimental_distribute_dataset(dataset))
@def_function.function
def replica_fn(per_replica_value):
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(array_ops.identity(per_replica_value), axis=axis)
result = strategy.experimental_local_results(
strategy.run(replica_fn, args=(next(input_iterator),)))
expected_result = [data] * _get_num_replicas_per_client(strategy)
self.assertAllClose(expected_result, result)
def testAllGatherDiffShapeAtAxis0(self, strategy, pure_eager):
"""Different `Axis==0`-th dimension: shape [1, 1], [2, 1] -> [3, 1]."""
if _is_tpu_strategy(strategy):
self.skipTest('TPU does not support all_gather different shapes')
def value_fn(ctx):
return constant_op.constant(
1, shape=(ctx.replica_id_in_sync_group + 1, 1))
per_replica_value = strategy.experimental_distribute_values_from_function(
value_fn)
expect = constant_op.constant(
1, shape=(sum(range(strategy.num_replicas_in_sync + 1)), 1))
def run(value):
value_identity = array_ops.identity(value)
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(value_identity, axis=0)
if not pure_eager:
run = def_function.function(run)
expected_result = [expect] * _get_num_replicas_per_client(strategy)
result = strategy.experimental_local_results(
strategy.run(run, args=(per_replica_value,)))
self.assertAllEqual(expected_result, result)
def testAllGatherDiffShapeAtAxis1(self, strategy, pure_eager):
"""Different `Axis`-th (not 0th) dimension: shape [1, 1], [1, 2] -> [1, 3]."""
if _is_tpu_strategy(strategy):
self.skipTest('TPU does not support all_gather different shapes')
def value_fn(ctx):
return constant_op.constant(
1, shape=(1, ctx.replica_id_in_sync_group + 1))
per_replica_value = strategy.experimental_distribute_values_from_function(
value_fn)
expect = constant_op.constant(
1, shape=(1, sum(range(strategy.num_replicas_in_sync + 1))))
def run(value):
value_identity = array_ops.identity(value)
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(value_identity, axis=1)
if not pure_eager:
run = def_function.function(run)
expected_result = [expect] * _get_num_replicas_per_client(strategy)
result = strategy.experimental_local_results(
strategy.run(run, args=(per_replica_value,)))
self.assertAllEqual(expected_result, result)
def testAllGatherNest(self, strategy, pure_eager):
if _is_tpu_strategy(strategy):
self.skipTest('TPU does not support all_gather different shapes')
axis = 1
def value_fn(ctx):
value = constant_op.constant(
1, shape=(1, ctx.replica_id_in_sync_group + 1))
return value
per_replica_value = strategy.experimental_distribute_values_from_function(
value_fn)
expect_1 = constant_op.constant(
1, shape=(1, sum(range(strategy.num_replicas_in_sync + 1))))
expected_per_replica_1 = [expect_1] * _get_num_replicas_per_client(strategy)
value_2 = constant_op.constant([[[1, 2], [1, 2]]])
expect_2 = array_ops.concat(
[value_2 for _ in range(strategy.num_replicas_in_sync)], axis=axis)
expected_per_replica_2 = [expect_2] * _get_num_replicas_per_client(strategy)
def run(value):
value_1 = array_ops.identity(value)
value_3 = array_ops.identity(value_2)
ctx = distribute_lib.get_replica_context()
return ctx.all_gather([value_1, value_3], axis=axis)
if not pure_eager:
run = def_function.function(run)
result = strategy.run(run, args=(per_replica_value,))
self.assertAllEqual(expected_per_replica_1,
strategy.experimental_local_results(result[0]))
self.assertAllEqual(expected_per_replica_2,
strategy.experimental_local_results(result[1]))
def testAllGatherNest1D0Axis(self, strategy, pure_eager):
"""all_gather(..., axis=0,...) a nest of DistributedValues."""
single_value = constant_op.constant([1, 2, 3])
axis = 0
def run():
value_identity = array_ops.identity(single_value)
ctx = distribute_lib.get_replica_context()
return ctx.all_gather([value_identity, value_identity], axis=axis)
if not pure_eager:
run = def_function.function(run)
all_value = [single_value for _ in range(strategy.num_replicas_in_sync)]
expect = array_ops.concat(all_value, axis=axis)
expected_per_replica = [expect] * _get_num_replicas_per_client(strategy)
result = strategy.run(run)
for gathered_result in result:
self.assertAllEqual(expected_per_replica,
strategy.experimental_local_results(gathered_result))
def testAllGatherRaiseDiffShapeAtNonAxis(self, strategy, pure_eager):
"""Different at non-`axis`-th dimension : [2, 1], [1, 1], all_gather(...axis=1...) -> raise error."""
if _is_tpu_strategy(strategy):
self.skipTest('TODO(b/169108777): raise a clear error message in xla.')
if isinstance(strategy, CollectiveAllReduceStrategy
) and _get_num_replicas_per_client(strategy) > 1:
self.skipTest('b/167331966')
if strategy.num_replicas_in_sync <= 1:
self.skipTest('Test for more than 1 replica only.')
def value_fn(ctx):
return constant_op.constant(
1, shape=(1, ctx.replica_id_in_sync_group + 1))
per_replica_value = strategy.experimental_distribute_values_from_function(
value_fn)
def run(value):
value_identity = array_ops.identity(value)
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(value_identity, axis=0)
if not pure_eager:
run = def_function.function(run)
if isinstance(strategy, CollectiveAllReduceStrategy):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r'Shape mismatch'):
strategy.run(run, args=(per_replica_value,))
elif isinstance(strategy,
(mirrored_strategy.MirroredStrategy,
central_storage_strategy.CentralStorageStrategy)):
with self.assertRaisesRegex((errors.InvalidArgumentError, ValueError),
r'Dimension \d in both shapes must be equal'):
strategy.run(run, args=(per_replica_value,))
def testAllGatherRaiseSparse(self, strategy, pure_eager):
dense_shape = [5, 2]
t0 = _make_indexed_slices(
values=[[1., 2.]], indices=[2], dense_shape=dense_shape)
def replica_fn(value):
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(value, axis=0)
with self.assertRaisesRegex(
NotImplementedError,
r'all_gather does not support IndexedSlices'):
if not pure_eager:
strategy.run(def_function.function(replica_fn), args=(t0,))
else:
strategy.run(replica_fn, args=(t0,))
def testAllGatherRaiseDifferentRank(self, strategy, pure_eager):
"""Different rank: [1,], [1, 2] -> raise error."""
if _is_tpu_strategy(strategy):
self.skipTest('TODO(b/169108777): raise a clear error message in xla.')
if strategy.num_replicas_in_sync <= 1:
self.skipTest('Test for more than 1 replicas.')
if isinstance(strategy, CollectiveAllReduceStrategy
) and _get_num_replicas_per_client(strategy) > 1:
self.skipTest('b/167331966')
def value_fn(ctx):
return array_ops.ones(shape=(range(1, ctx.replica_id_in_sync_group + 2)))
per_replica_value = strategy.experimental_distribute_values_from_function(
value_fn)
def run(value):
value_identity = array_ops.identity(value)
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(value_identity, axis=0)
if not pure_eager:
run = def_function.function(run)
if isinstance(strategy, CollectiveAllReduceStrategy):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r'Shape mismatch'):
strategy.run(run, args=(per_replica_value,))
elif isinstance(strategy,
(mirrored_strategy.MirroredStrategy,
central_storage_strategy.CentralStorageStrategy)):
if pure_eager:
with self.assertRaises(errors.InvalidArgumentError) as e:
strategy.run(run, args=(per_replica_value,))
# Different error message depending on whether collective ops is used.
self.assertRegexMatch(
str(e.exception),
['Ranks of all input tensors should match', 'Shape mismatch'])
else:
with self.assertRaises((errors.InvalidArgumentError, ValueError)) as e:
strategy.run(run, args=(per_replica_value,))
self.assertRegexMatch(
str(e.exception),
[r'Shape must be rank \d but is rank \d', 'Shape mismatch'])
else:
with self.assertRaisesRegex(ValueError,
r'Dimension \d in both shapes must be equal'):
strategy.run(run, args=(per_replica_value,))
def testAllGatherGradient(self, strategy, pure_eager):
if pure_eager:
self.skipTest('`tf.gradients` is not supported with eager execution '
'without using tf.functions.')
def all_gather_fn(value):
axis = 1
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(array_ops.identity(value), axis)
gradient_comp = sum(range(1, strategy.num_replicas_in_sync + 1))
gradient = [[gradient_comp], [gradient_comp]]
grads_for_all_replicas = [gradient] * _get_num_replicas_per_client(strategy)
@def_function.function
def step(c):
x = constant_op.constant([[3.], [5.]])
mid = all_gather_fn(x)
y = mid * c
return gradients_impl.gradients_v2(y, [x])[0]
def value_fn(ctx):
x = [1., 2., 3., 4., 5., 6., 7., 8.]
return array_ops.constant([x[ctx.replica_id_in_sync_group]])
per_replica_value = strategy.experimental_distribute_values_from_function(
value_fn)
result = strategy.experimental_local_results(
strategy.run(step, args=(per_replica_value,)))
self.assertAllEqual(grads_for_all_replicas, result)
def testAllGatherGradientNest(self, strategy, pure_eager):
if pure_eager:
self.skipTest('`tf.gradients` is not supported with eager execution '
'without using tf.functions.')
def all_gather_fn(value):
axis = 1
ctx = distribute_lib.get_replica_context()
return ctx.all_gather(array_ops.identity(value), axis)
gradient_comp = sum(range(1, strategy.num_replicas_in_sync + 1))
gradient = [[gradient_comp], [gradient_comp]]
grads_for_all_replicas = [gradient] * _get_num_replicas_per_client(strategy)
@def_function.function
def step(c):
x = constant_op.constant([[3.], [5.]])
y = constant_op.constant([[2.], [4.]])
mid = all_gather_fn([x, y])
y = mid * c
return gradients_impl.gradients_v2(y, [x])[0]
def value_fn(ctx):
x = [1., 2., 3., 4., 5., 6., 7., 8.]
return array_ops.constant([x[ctx.replica_id_in_sync_group]])
per_replica_value = strategy.experimental_distribute_values_from_function(
value_fn)
result = strategy.experimental_local_results(
strategy.run(step, args=(per_replica_value,)))
self.assertAllEqual(grads_for_all_replicas, result)
def _make_indexed_slices(values, indices, dense_shape):
tensor = indexed_slices.IndexedSlices(
values=constant_op.constant(values),
indices=constant_op.constant(indices),
dense_shape=constant_op.constant(dense_shape))
return tensor
def _get_num_replicas_per_client(strategy):
if isinstance(strategy, CollectiveAllReduceStrategy):
resolver = strategy.cluster_resolver
return max(nest.flatten(resolver.num_accelerators())[0], 1)
else:
return strategy.num_replicas_in_sync
def _is_tpu_strategy(strategy):
return isinstance(strategy,
(tpu_strategy.TPUStrategy, tpu_strategy.TPUStrategyV1,
tpu_strategy.TPUStrategyV2))
if __name__ == '__main__':
test_util.main()
|
tensorflowREPO_NAMEtensorflowPATH_START.@tensorflow_extracted@tensorflow-master@tensorflow@python@distribute@strategy_gather_test.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "plotly/plotly.py",
"repo_path": "plotly.py_extracted/plotly.py-master/packages/python/plotly/plotly/validators/violin/unselected/marker/__init__.py",
"type": "Python"
}
|
import sys
from typing import TYPE_CHECKING
if sys.version_info < (3, 7) or TYPE_CHECKING:
from ._size import SizeValidator
from ._opacity import OpacityValidator
from ._color import ColorValidator
else:
from _plotly_utils.importers import relative_import
__all__, __getattr__, __dir__ = relative_import(
__name__,
[],
[
"._size.SizeValidator",
"._opacity.OpacityValidator",
"._color.ColorValidator",
],
)
|
plotlyREPO_NAMEplotly.pyPATH_START.@plotly.py_extracted@plotly.py-master@packages@python@plotly@plotly@validators@violin@unselected@marker@__init__.py@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/graph_objs/indicator/delta/__init__.py",
"type": "Python"
}
|
import sys
if sys.version_info < (3, 7):
from ._decreasing import Decreasing
from ._font import Font
from ._increasing import Increasing
else:
from _plotly_utils.importers import relative_import
__all__, __getattr__, __dir__ = relative_import(
__name__,
[],
["._decreasing.Decreasing", "._font.Font", "._increasing.Increasing"],
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@graph_objs@indicator@delta@__init__.py@.PATH_END.py
|
{
"filename": "_family.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py3/plotly/validators/histogram2dcontour/colorbar/title/font/_family.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class FamilyValidator(_plotly_utils.basevalidators.StringValidator):
def __init__(
self,
plotly_name="family",
parent_name="histogram2dcontour.colorbar.title.font",
**kwargs,
):
super(FamilyValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "colorbars"),
no_blank=kwargs.pop("no_blank", True),
strict=kwargs.pop("strict", True),
**kwargs,
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py3@plotly@validators@histogram2dcontour@colorbar@title@font@_family.py@.PATH_END.py
|
{
"filename": "_border.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/graph_objs/pointcloud/marker/_border.py",
"type": "Python"
}
|
from plotly.basedatatypes import BaseTraceHierarchyType as _BaseTraceHierarchyType
import copy as _copy
class Border(_BaseTraceHierarchyType):
# class properties
# --------------------
_parent_path_str = "pointcloud.marker"
_path_str = "pointcloud.marker.border"
_valid_props = {"arearatio", "color"}
# arearatio
# ---------
@property
def arearatio(self):
"""
Specifies what fraction of the marker area is covered with the
border.
The 'arearatio' property is a number and may be specified as:
- An int or float in the interval [0, 1]
Returns
-------
int|float
"""
return self["arearatio"]
@arearatio.setter
def arearatio(self, val):
self["arearatio"] = val
# color
# -----
@property
def color(self):
"""
Sets the stroke color. It accepts a specific color. If the
color is not fully opaque and there are hundreds of thousands
of points, it may cause slower zooming and panning.
The 'color' property is a color and may be specified as:
- A hex string (e.g. '#ff0000')
- An rgb/rgba string (e.g. 'rgb(255,0,0)')
- An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
- An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
- A named CSS color:
aliceblue, antiquewhite, aqua, aquamarine, azure,
beige, bisque, black, blanchedalmond, blue,
blueviolet, brown, burlywood, cadetblue,
chartreuse, chocolate, coral, cornflowerblue,
cornsilk, crimson, cyan, darkblue, darkcyan,
darkgoldenrod, darkgray, darkgrey, darkgreen,
darkkhaki, darkmagenta, darkolivegreen, darkorange,
darkorchid, darkred, darksalmon, darkseagreen,
darkslateblue, darkslategray, darkslategrey,
darkturquoise, darkviolet, deeppink, deepskyblue,
dimgray, dimgrey, dodgerblue, firebrick,
floralwhite, forestgreen, fuchsia, gainsboro,
ghostwhite, gold, goldenrod, gray, grey, green,
greenyellow, honeydew, hotpink, indianred, indigo,
ivory, khaki, lavender, lavenderblush, lawngreen,
lemonchiffon, lightblue, lightcoral, lightcyan,
lightgoldenrodyellow, lightgray, lightgrey,
lightgreen, lightpink, lightsalmon, lightseagreen,
lightskyblue, lightslategray, lightslategrey,
lightsteelblue, lightyellow, lime, limegreen,
linen, magenta, maroon, mediumaquamarine,
mediumblue, mediumorchid, mediumpurple,
mediumseagreen, mediumslateblue, mediumspringgreen,
mediumturquoise, mediumvioletred, midnightblue,
mintcream, mistyrose, moccasin, navajowhite, navy,
oldlace, olive, olivedrab, orange, orangered,
orchid, palegoldenrod, palegreen, paleturquoise,
palevioletred, papayawhip, peachpuff, peru, pink,
plum, powderblue, purple, red, rosybrown,
royalblue, rebeccapurple, saddlebrown, salmon,
sandybrown, seagreen, seashell, sienna, silver,
skyblue, slateblue, slategray, slategrey, snow,
springgreen, steelblue, tan, teal, thistle, tomato,
turquoise, violet, wheat, white, whitesmoke,
yellow, yellowgreen
Returns
-------
str
"""
return self["color"]
@color.setter
def color(self, val):
self["color"] = val
# Self properties description
# ---------------------------
@property
def _prop_descriptions(self):
return """\
arearatio
Specifies what fraction of the marker area is covered
with the border.
color
Sets the stroke color. It accepts a specific color. If
the color is not fully opaque and there are hundreds of
thousands of points, it may cause slower zooming and
panning.
"""
def __init__(self, arg=None, arearatio=None, color=None, **kwargs):
"""
Construct a new Border object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.pointcloud.marker.Border`
arearatio
Specifies what fraction of the marker area is covered
with the border.
color
Sets the stroke color. It accepts a specific color. If
the color is not fully opaque and there are hundreds of
thousands of points, it may cause slower zooming and
panning.
Returns
-------
Border
"""
super(Border, self).__init__("border")
if "_parent" in kwargs:
self._parent = kwargs["_parent"]
return
# Validate arg
# ------------
if arg is None:
arg = {}
elif isinstance(arg, self.__class__):
arg = arg.to_plotly_json()
elif isinstance(arg, dict):
arg = _copy.copy(arg)
else:
raise ValueError(
"""\
The first argument to the plotly.graph_objs.pointcloud.marker.Border
constructor must be a dict or
an instance of :class:`plotly.graph_objs.pointcloud.marker.Border`"""
)
# Handle skip_invalid
# -------------------
self._skip_invalid = kwargs.pop("skip_invalid", False)
self._validate = kwargs.pop("_validate", True)
# Populate data dict with properties
# ----------------------------------
_v = arg.pop("arearatio", None)
_v = arearatio if arearatio is not None else _v
if _v is not None:
self["arearatio"] = _v
_v = arg.pop("color", None)
_v = color if color is not None else _v
if _v is not None:
self["color"] = _v
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@graph_objs@pointcloud@marker@_border.py@.PATH_END.py
|
{
"filename": "setup_package.py",
"repo_name": "D-arioSpace/astroquery",
"repo_path": "astroquery_extracted/astroquery-main/astroquery/ipac/ned/setup_package.py",
"type": "Python"
}
|
# Licensed under a 3-clause BSD style license - see LICENSE.rst
import os
def get_package_data():
paths_core = [os.path.join('data', 'keywords_dict.json'),
]
paths_test = [os.path.join('data', '*.xml'),
os.path.join('data', '*.fits'),
os.path.join('data', '*.html'),
]
return {'astroquery.ipac.ned': paths_core,
'astroquery.ipac.ned.tests': paths_test,
}
|
D-arioSpaceREPO_NAMEastroqueryPATH_START.@astroquery_extracted@astroquery-main@astroquery@ipac@ned@setup_package.py@.PATH_END.py
|
{
"filename": "tight_layout.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/matplotlib/py2/matplotlib/tight_layout.py",
"type": "Python"
}
|
"""
This module provides routines to adjust subplot params so that subplots are
nicely fit in the figure. In doing so, only axis labels, tick labels, axes
titles and offsetboxes that are anchored to axes are currently considered.
Internally, it assumes that the margins (left_margin, etc.) which are
differences between ax.get_tightbbox and ax.bbox are independent of axes
position. This may fail if Axes.adjustable is datalim. Also, This will fail
for some cases (for example, left or right margin is affected by xlabel).
"""
import warnings
import matplotlib
from matplotlib.transforms import TransformedBbox, Bbox
from matplotlib.font_manager import FontProperties
rcParams = matplotlib.rcParams
def _get_left(tight_bbox, axes_bbox):
return axes_bbox.xmin - tight_bbox.xmin
def _get_right(tight_bbox, axes_bbox):
return tight_bbox.xmax - axes_bbox.xmax
def _get_bottom(tight_bbox, axes_bbox):
return axes_bbox.ymin - tight_bbox.ymin
def _get_top(tight_bbox, axes_bbox):
return tight_bbox.ymax - axes_bbox.ymax
def auto_adjust_subplotpars(
fig, renderer, nrows_ncols, num1num2_list, subplot_list,
ax_bbox_list=None, pad=1.08, h_pad=None, w_pad=None, rect=None):
"""
Return a dict of subplot parameters to adjust spacing between subplots.
Note that this function ignores geometry information of subplot
itself, but uses what is given by the *nrows_ncols* and *num1num2_list*
parameters. Also, the results could be incorrect if some subplots have
``adjustable=datalim``.
Parameters
----------
nrows_ncols : Tuple[int, int]
Number of rows and number of columns of the grid.
num1num2_list : List[int]
List of numbers specifying the area occupied by the subplot
subplot_list : list of subplots
List of subplots that will be used to calculate optimal subplot_params.
pad : float
Padding between the figure edge and the edges of subplots, as a
fraction of the font size.
h_pad, w_pad : float
Padding (height/width) between edges of adjacent subplots, as a
fraction of the font size. Defaults to *pad*.
rect : Tuple[float, float, float, float]
[left, bottom, right, top] in normalized (0, 1) figure coordinates.
"""
rows, cols = nrows_ncols
font_size_inches = (
FontProperties(size=rcParams["font.size"]).get_size_in_points() / 72)
pad_inches = pad * font_size_inches
if h_pad is not None:
vpad_inches = h_pad * font_size_inches
else:
vpad_inches = pad_inches
if w_pad is not None:
hpad_inches = w_pad * font_size_inches
else:
hpad_inches = pad_inches
if len(num1num2_list) != len(subplot_list) or len(subplot_list) == 0:
raise ValueError
if rect is None:
margin_left = margin_bottom = margin_right = margin_top = None
else:
margin_left, margin_bottom, _right, _top = rect
if _right:
margin_right = 1 - _right
else:
margin_right = None
if _top:
margin_top = 1 - _top
else:
margin_top = None
vspaces = [[] for i in range((rows + 1) * cols)]
hspaces = [[] for i in range(rows * (cols + 1))]
union = Bbox.union
if ax_bbox_list is None:
ax_bbox_list = []
for subplots in subplot_list:
ax_bbox = union([ax.get_position(original=True)
for ax in subplots])
ax_bbox_list.append(ax_bbox)
for subplots, ax_bbox, (num1, num2) in zip(subplot_list,
ax_bbox_list,
num1num2_list):
if all([not ax.get_visible() for ax in subplots]):
continue
tight_bbox_raw = union([ax.get_tightbbox(renderer) for ax in subplots
if ax.get_visible()])
tight_bbox = TransformedBbox(tight_bbox_raw,
fig.transFigure.inverted())
row1, col1 = divmod(num1, cols)
if num2 is None:
# left
hspaces[row1 * (cols + 1) + col1].append(
_get_left(tight_bbox, ax_bbox))
# right
hspaces[row1 * (cols + 1) + (col1 + 1)].append(
_get_right(tight_bbox, ax_bbox))
# top
vspaces[row1 * cols + col1].append(
_get_top(tight_bbox, ax_bbox))
# bottom
vspaces[(row1 + 1) * cols + col1].append(
_get_bottom(tight_bbox, ax_bbox))
else:
row2, col2 = divmod(num2, cols)
for row_i in range(row1, row2 + 1):
# left
hspaces[row_i * (cols + 1) + col1].append(
_get_left(tight_bbox, ax_bbox))
# right
hspaces[row_i * (cols + 1) + (col2 + 1)].append(
_get_right(tight_bbox, ax_bbox))
for col_i in range(col1, col2 + 1):
# top
vspaces[row1 * cols + col_i].append(
_get_top(tight_bbox, ax_bbox))
# bottom
vspaces[(row2 + 1) * cols + col_i].append(
_get_bottom(tight_bbox, ax_bbox))
fig_width_inch, fig_height_inch = fig.get_size_inches()
# margins can be negative for axes with aspect applied. And we
# append + [0] to make minimum margins 0
if not margin_left:
margin_left = max([sum(s) for s in hspaces[::cols + 1]] + [0])
margin_left += pad_inches / fig_width_inch
if not margin_right:
margin_right = max([sum(s) for s in hspaces[cols::cols + 1]] + [0])
margin_right += pad_inches / fig_width_inch
if not margin_top:
margin_top = max([sum(s) for s in vspaces[:cols]] + [0])
margin_top += pad_inches / fig_height_inch
if not margin_bottom:
margin_bottom = max([sum(s) for s in vspaces[-cols:]] + [0])
margin_bottom += pad_inches / fig_height_inch
if margin_left + margin_right >= 1:
margin_left = 0.4999
margin_right = 0.4999
warnings.warn('The left and right margins cannot be made large '
'enough to accommodate all axes decorations. ')
if margin_bottom + margin_top >= 1:
margin_bottom = 0.4999
margin_top = 0.4999
warnings.warn('The bottom and top margins cannot be made large '
'enough to accommodate all axes decorations. ')
kwargs = dict(left=margin_left,
right=1 - margin_right,
bottom=margin_bottom,
top=1 - margin_top)
if cols > 1:
hspace = (
max(sum(s)
for i in range(rows)
for s in hspaces[i * (cols + 1) + 1:(i + 1) * (cols + 1) - 1])
+ hpad_inches / fig_width_inch)
# axes widths:
h_axes = (1 - margin_right - margin_left - hspace * (cols - 1)) / cols
if h_axes < 0:
warnings.warn('tight_layout cannot make axes width small enough '
'to accommodate all axes decorations')
kwargs["wspace"] = 0.5
else:
kwargs["wspace"] = hspace / h_axes
if rows > 1:
vspace = (max(sum(s) for s in vspaces[cols:-cols])
+ vpad_inches / fig_height_inch)
v_axes = (1 - margin_top - margin_bottom - vspace * (rows - 1)) / rows
if v_axes < 0:
warnings.warn('tight_layout cannot make axes height small enough '
'to accommodate all axes decorations')
kwargs["hspace"] = 0.5
else:
kwargs["hspace"] = vspace / v_axes
return kwargs
def get_renderer(fig):
if fig._cachedRenderer:
renderer = fig._cachedRenderer
else:
canvas = fig.canvas
if canvas and hasattr(canvas, "get_renderer"):
renderer = canvas.get_renderer()
else:
# not sure if this can happen
warnings.warn("tight_layout : falling back to Agg renderer")
from matplotlib.backends.backend_agg import FigureCanvasAgg
canvas = FigureCanvasAgg(fig)
renderer = canvas.get_renderer()
return renderer
def get_subplotspec_list(axes_list, grid_spec=None):
"""Return a list of subplotspec from the given list of axes.
For an instance of axes that does not support subplotspec, None is inserted
in the list.
If grid_spec is given, None is inserted for those not from the given
grid_spec.
"""
subplotspec_list = []
for ax in axes_list:
axes_or_locator = ax.get_axes_locator()
if axes_or_locator is None:
axes_or_locator = ax
if hasattr(axes_or_locator, "get_subplotspec"):
subplotspec = axes_or_locator.get_subplotspec()
subplotspec = subplotspec.get_topmost_subplotspec()
gs = subplotspec.get_gridspec()
if grid_spec is not None:
if gs != grid_spec:
subplotspec = None
elif gs.locally_modified_subplot_params():
subplotspec = None
else:
subplotspec = None
subplotspec_list.append(subplotspec)
return subplotspec_list
def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
pad=1.08, h_pad=None, w_pad=None, rect=None):
"""
Return subplot parameters for tight-layouted-figure with specified padding.
Parameters
----------
fig : Figure
axes_list : list of Axes
subplotspec_list : list of `.SubplotSpec`
The subplotspecs of each axes.
renderer : renderer
pad : float
Padding between the figure edge and the edges of subplots, as a
fraction of the font size.
h_pad, w_pad : float
Padding (height/width) between edges of adjacent subplots. Defaults to
*pad_inches*.
rect : Tuple[float, float, float, float], optional
(left, bottom, right, top) rectangle in normalized figure coordinates
that the whole subplots area (including labels) will fit into.
Defaults to using the entire figure.
"""
subplot_list = []
nrows_list = []
ncols_list = []
ax_bbox_list = []
subplot_dict = {} # Multiple axes can share same subplot_interface (e.g.,
# axes_grid1); thus we need to join them together.
subplotspec_list2 = []
for ax, subplotspec in zip(axes_list,
subplotspec_list):
if subplotspec is None:
continue
subplots = subplot_dict.setdefault(subplotspec, [])
if not subplots:
myrows, mycols, _, _ = subplotspec.get_geometry()
nrows_list.append(myrows)
ncols_list.append(mycols)
subplotspec_list2.append(subplotspec)
subplot_list.append(subplots)
ax_bbox_list.append(subplotspec.get_position(fig))
subplots.append(ax)
if (len(nrows_list) == 0) or (len(ncols_list) == 0):
return {}
max_nrows = max(nrows_list)
max_ncols = max(ncols_list)
num1num2_list = []
for subplotspec in subplotspec_list2:
rows, cols, num1, num2 = subplotspec.get_geometry()
div_row, mod_row = divmod(max_nrows, rows)
div_col, mod_col = divmod(max_ncols, cols)
if (mod_row != 0) or (mod_col != 0):
raise RuntimeError("")
rowNum1, colNum1 = divmod(num1, cols)
if num2 is None:
rowNum2, colNum2 = rowNum1, colNum1
else:
rowNum2, colNum2 = divmod(num2, cols)
num1num2_list.append((rowNum1 * div_row * max_ncols +
colNum1 * div_col,
((rowNum2 + 1) * div_row - 1) * max_ncols +
(colNum2 + 1) * div_col - 1))
kwargs = auto_adjust_subplotpars(fig, renderer,
nrows_ncols=(max_nrows, max_ncols),
num1num2_list=num1num2_list,
subplot_list=subplot_list,
ax_bbox_list=ax_bbox_list,
pad=pad, h_pad=h_pad, w_pad=w_pad)
if rect is not None:
# if rect is given, the whole subplots area (including
# labels) will fit into the rect instead of the
# figure. Note that the rect argument of
# *auto_adjust_subplotpars* specify the area that will be
# covered by the total area of axes.bbox. Thus we call
# auto_adjust_subplotpars twice, where the second run
# with adjusted rect parameters.
left, bottom, right, top = rect
if left is not None:
left += kwargs["left"]
if bottom is not None:
bottom += kwargs["bottom"]
if right is not None:
right -= (1 - kwargs["right"])
if top is not None:
top -= (1 - kwargs["top"])
#if h_pad is None: h_pad = pad
#if w_pad is None: w_pad = pad
kwargs = auto_adjust_subplotpars(fig, renderer,
nrows_ncols=(max_nrows, max_ncols),
num1num2_list=num1num2_list,
subplot_list=subplot_list,
ax_bbox_list=ax_bbox_list,
pad=pad, h_pad=h_pad, w_pad=w_pad,
rect=(left, bottom, right, top))
return kwargs
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@matplotlib@py2@matplotlib@tight_layout.py@.PATH_END.py
|
{
"filename": "CHIMERA_TRANSMISSION_DEMO_WASP43b_JWST-checkpoint.ipynb",
"repo_name": "mrline/CHIMERA",
"repo_path": "CHIMERA_extracted/CHIMERA-master/docs/notebooks/.ipynb_checkpoints/CHIMERA_TRANSMISSION_DEMO_WASP43b_JWST-checkpoint.ipynb",
"type": "Jupyter Notebook"
}
|
# JWST Transmission/Transit Chemically Consistent Tutorial
Welcome to the JWST transmission spectrum model/retrieval tutorial!
For this particular setup, the atmosphere is parameterized within the "chemically-consistent" framework as described in Kreidberg et al. 2015. The atmospheric composition is parameterized with only a metalicity and carbon-to-oxygen ratio assumed to be in thermochemical equilibrium along the temperature-pressure profile. Originally this code would compute the gas and condensate phase mixing ratios by calling the NASA CEA routine. However, in order to remove fortran dependencies, a finely sampled pre-computed, interpolateable chemistry grid was instead produced with CEA as a function of temperature (T from 400K - 3400K in 100K increments), pressure ($log_{10}(P)$ from -7.0 (0.1$\mu$bar) - 2.4 (316 bar) in 0.1 increments), metallicity ($[M/H]$ from -2.0 (0.01$\times$) to 3.0 (1000$\times$)), and C/O ($log_{10}(C/O)$ from -2.0 (0.01) to 0.3 (2) awkwardly spaced to better sample the transition about C/O=1). All elemental abundances are scaled with respect to the Lodders 2009 solar abundance pattern. A pseudo-hack rainout approximation is made to the gas phase abundances of TiO, VO, Na, K, and FeH. In this hack, these species are set to 0 abundance at levels above where they first fall below some critical value ($10^{-8}$). This is to mimic the loss of these species from the gas phase into the condensate phase. In no case are we accounting for the loss of elemental abundances.
The 3-parameter temperature profile parameterization utilizes the Guillot 2010/Parmentier et al. 2014 analytic formulism (see Line et al. 2013a for implementation details).
The transmission spectrum routine closely follows the equations (and figure) in Tinetti et al. 2012 (as described in the tutorial text). Instead of using line-by-line, or "sampled" cross-sections, this implementation uses the "correlated-K" method (see Lacis & Oinas 1990, or more recently Amundsen et al. 2017). Correlated-K is advantageous as it preserves the wavelength bin"integrated" precision as line-by-line but with far less demanding computation. We include as correlated-K line opacites H2O, CH4, CO, CO2, NH3, HCN, H2S, C2H2, Na, K, TiO, VO, FeH and as continuum gas opacities H2-H2, H2-He CIA, and the H- bound free and free free (e.g., Arcangeli et al. 2018). See the "opacity" tutorial for more details on correlated-K.
To handle the effects of disequilibrium chemistry due to vertical mixing, we apply the "quench-pressure" approximation. We include a quench pressure parameter for the carbon-system and one for the nitrogen system (as in Morley et al. 2017 for GJ436b, and Kreidberg et al. 2018 for WASP-107b). The carbon quench pressure fixes the H2O, CO, and CH4 abundances above the quench pressure level to their abundances at the quench pressure level. Similarly, the nitrogen quench pressure fixes the N2, NH3, and HCN abundances above the quench pressure to their values at the quench pressure level. This is indeed a kludge, and a better implementation would be to use the timescale/eddy mixing prescription described in Zahnle & Marley 2015. Regardless, any non-full kinetics approach is a kludge anyway (not to mention the 1D nature of the problem...).
There are two different cloud prescriptions built in. The first is the Ackerman & Marley 2001 "eddy-sed" approach that self-consistently computes the vertical particle size distribution given a sedimentation factor, $f_{sed}$ and an eddy mixing factor (K$_{zz}$) from some cloud base pressure and intrinsic condensate mixing ratio. The classic "power-law haze" and "grey cloud" prescripton is also included.
Finally, if one doesn't like the "chemically-consistent" concept, they can use the "gas_scale" array to switch off or scale the abundances each opacity source.
This specific notebook goes through the steps to generate the forward model, and illustrate how to actually perform the retrieval. However, the retrievals are bust run on a compute cluster or a node with more than 4 cores. We will first creat a fake dataset at an R=100 to emulate what we might expect from JWST.
Note, this particular version does not include marginilzation over spots (e.g., Iyer & Line 2019). However, this can be trivially implemented in the fx_trans rouutine in fm.py. Simply add in the "rackham" formula along with a grid of stellar spectral models, say, drawn from pysynphot (or whatever your favorite stellar model generator is). Interpolate over this grid of stellar models using standard built in python linear interpolators.
Software Requirements: This runs in the python 3 anaconda environment. It is also crucial that anaconda numba is installed as many of the routines are optimized using numba's "@jit" decorator (http://numba.pydata.org/).
## Import Routines
This first segment loads in the routines from fm.py and the correlated-K coefficients. The JWST xsecs (really, correlated-K) are at an R=100 < 20 microns (> 500 cm-1) and R=50 > 20 microns (<500 cm-1).
Note that the "core" set of routines are all in fm.py. The thermal emission radiative transfer solver is toonpy.py and the incident stellar flux solver is toonpy_solar.py If you want to know more about what is in the sausage, look into these routines. Note...these *are not sampled cross-sections* so each resolution element at that R is correctly computed and matches line-by-line when binned to that same R.
Note that the "core" set of routines are all in fm.py. If you want to know more about what is in the sausage, look into fm.py.
```python
#import all of the functions in fm, namely, the CK-coefficients (may take a minute)
from chimera import *
%matplotlib notebook
```
## Make Stellar
```python
stellar_file = 'sum_star.h5'
temp = 5000
logmh = 0
logg = 4.0
stellar_db = 'phoenix'
make_stellar(temp,logmh,logg,stellar_db,stellar_file)
```
## Load Opacities
```python
#preload CK-coeffs--a giant array/variable to be passed--inputs are lower wavenumber, upper wavenumber
#between 50 and 30000 cm-1 with R = 100 > 500 cm-1 (<20 um) and R=50 <500 cm-1 (>20 um)
#to convert between microns and wavenumbers-- wavelength [um] = 10,000/wavenumber [cm-1]
#make sure xsec wavenumber/wavelength range is *larger* than data wavelength range
wnomin = 750
wnomax = 15000
observatory='JWST'
directory = os.path.join(os.getcwd(),'..','..','ABSCOEFF_CK')
xsecs=xsects(wnomin, wnomax, observatory, directory,stellar_file=stellar_file)
```
## Setup Atmospheric Parameters to Generate a Spectrum
This segement defines the various atmospheric quantities and assignes them values for the generation of a simple transmission spectrum. A description of each parameter along with a reasonable range of values is given as a comment following the assigned value. All of the parameters are then put into the parameter "state-vector" array, x.
```python
#setup "input" parameters. We are defining our 1D atmosphere with these
#the parameters
#planet/star system params--xRp is the "Rp" free parameter, M right now is fixed, but could be free param
Rp=1.036 #Planet radius in Jupiter Radii--this will be forced to be 10 bar radius--arbitrary (scaling to this is free par)
Rstar=0.667 # #Stellar Radius in Solar Radii
M =2.034 #Mass in Jupiter Masses
D=0.01526 #semimajor axis in AU
#TP profile params (3--Guillot 2010, Parmentier & Guillot 2013--see Line et al. 2013a for implementation)
Tirr=1400 #Irradiation temperature as defined in Guillot 2010
logKir=-1.5 #TP profile IR opacity (log there-of) controlls the "vertical" location of the gradient
logg1=-0.7 #single channel Vis/IR (log) opacity. Controls the delta T between deep T and TOA T
Tint=200 #interior temperature...this would be the "effective temperature" if object were not irradiated
#Composition parameters---assumes "chemically consistent model" described in Kreidberg et al. 2015
logMet=0.0 #. #Metallicity relative to solar log--solar is 0, 10x=1, 0.1x = -1: valid range is -1.5 - 3.0
logCtoO=-0.26 #log C-to-O ratio: log solar is -0.26: valid range is -1.0 - 0.3
logPQCarbon=-5.5 #CH4, CO, H2O Qunech pressure--forces CH4, CO, and H2O to constant value at quench pressure value: valid range -6.0 - 1.5
logPQNitrogen=-5.5 #N2, NH3 Quench pressure--forces N2 and NH3 to ""
#Ackerman & Marley 2001 Cloud parameters--physically motivated with Mie particles
logKzz=7 #log Kzz (cm2/s)--valid range: 2 - 11 -- higher values make larger particles
fsed=2.0 #sediminetation efficiency--valid range: 0.5 - 5--lower values make "puffier" more extended cloud
logPbase=-1.0 #cloud base pressure--valid range: -6.0 - 1.5
logCldVMR=-5.5 #cloud condensate base mixing ratio (e.g, see Fortney 2005)--valid range: -15 - -2.0
#simple 'grey+rayleigh' parameters just in case you don't want to use a physically motivated cloud
#(most are just made up anyway since we don't really understand all of the micro-physics.....)
logKcld = -40 #uniform in altitude and in wavelength "grey" opacity (it's a cross-section)--valid range: -50 - -10
logRayAmp = -30 #power-law haze amplitude (log) as defined in des Etangs 2008 "0" would be like H2/He scat--valid range: -30 - 3
RaySlope = 0 #power law index 4 for Rayleigh, 0 for "gray". Valid range: 0 - 6
#10 bar radiuss scaling param (only used in transmission)
xRp=0.991
#stuffing all variables into state vector array
x=np.array([Tirr, logKir,logg1,Tint, logMet, logCtoO, logPQCarbon,logPQNitrogen, Rp*xRp, Rstar, M, logKzz, fsed,logPbase,logCldVMR, logKcld, logRayAmp, RaySlope])
#gas scaling factors to mess with turning on various species
#set to "0" to turn off a gas. Otherwise keep set at 1
#thermochemical gas profile scaling factors
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#H2O CH4 CO CO2 NH3 N2 HCN H2S PH3 C2H2 C2H6 Na K TiO VO FeH H H2 He e- h- mmw
gas_scale=np.array([1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1., 1., 1.]) #can be made free params if desired (won't affect mmw)#can be made free params if desired (won't affect mmw)
```
## Generate Model Atmosphere & Transmission Spectrum
Here we call the forward model routine "fx" (think F(x)) from fm.py. fx controls the input values and calls the relevent functions to compute the transmission spectrum. The inputs into fx are the parameter state vector, "x", the data wavelength grid, "wlgrid", the gas scaling factors (for turning off particular gases), "gas_scale", and the correlated-K tables, "xsects". Fx then returns the simulated model spectrum ($(R_p/R_{\star})^2$) at the native CK-table resolution, "y_mod", the native wavenumber grid, "wno", the data wavelength grid binned model spectrum, "y_binned". The "atm" array contains the generated temperature-pressure profile and gas mixing ratio profiles generated under the chemically consistent assumption.
```python
#calling forward model, fx. This will produce the (Rp/Rstar)^2 spectrum....
wlgrid=-1 #this is just a flag to let the wl binning routine to know that we are creating fake data
y_binned,y_mod,wno,atm=fx_trans(x,wlgrid,gas_scale, xsecs) #returns binned model spectrum, higher res model spectrum, wavenumber grid, and vertical abundance profiles from chemistry
print('DONE')
```
DONE
## Generate Simulated Data
```python
err_ppm=30. #error bar in ppm (just constant here)
err=np.ones(len(wno))*err_ppm*1E-6 #this would be a good spot to put pandexo generated error bars
#though they would have to be binned/interpolated to the model wavenumber grid
y_meas = np.random.normal(y_mod, err) #adding gaussian noise
np.savetxt('simulated_trans_JWST.txt',np.array([1E4/wno, y_meas, err]).T) #saveing as txt file (wl [um], Depth, err)
```
## Plotting the Model Atmosphere & Transmission Spectrum
Self-explanatory...
## Plot Model Atmosphere
Spaghetti plot of the model atmosphere.
```python
from matplotlib.pyplot import *
from matplotlib.ticker import FormatStrFormatter
%matplotlib notebook
#unpacking variables
#P is in bars
#T is in K
#H2O, CH4,CO,CO2,NH3,Na,K,TiO,VO,C2H2,HCN,H2S,FeH,H2,He are gas mixing ratio profiles
#qc is the condensate abundance profile given an "f_sed" value and cloud base pressure
#r_eff is the effective cloud droplet radius given (see A&M 2001 or Charnay et al. 2017)
#f_r is the mixing ratio array for each of the cloud droplet sizes.
P,T, H2O, CH4,CO,CO2,NH3,Na,K,TiO,VO,C2H2,HCN,H2S,FeH,H2,He,H,e, Hm,qc,r_eff,f_r=atm
fig2, ax1=subplots()
#feel free to plot whatever you want here....
ax1.semilogx(H2O,P,'b',ls='--',lw=2,label='H2O')
ax1.semilogx(CH4,P,'black',ls='--',lw=2,label='CH4')
ax1.semilogx(CO,P,'g',ls='--',lw=2,label='CO')
ax1.semilogx(CO2,P,'orange',ls='--',lw=2,label='CO2')
ax1.semilogx(NH3,P,'darkblue',ls='--',lw=2,label='NH3')
ax1.semilogx(Na,P,'b',lw=2,label='Na')
ax1.semilogx(K,P,'g',lw=2,label='K')
ax1.semilogx(TiO,P,'k',lw=2,label='TiO')
ax1.semilogx(VO,P,'orange',lw=2,label='VO')
ax1.semilogx(qc,P,'gray',lw=1,ls='--',label='Cond. VMR.') #<---- A&M Cloud Condensate VMR profile (not droplets)
ax1.set_xlabel('Mixing Ratio',fontsize=20)
ax1.set_ylabel('Pressure [bar]',fontsize=20)
ax1.semilogy()
ax1.legend(loc=4,frameon=False)
ax1.axis([1E-9,1,100,1E-7])
#plotting TP profile on other x-axis
ax2=ax1.twiny()
ax2.semilogy(T,P,'r-',lw='4',label='TP')
ax2.set_xlabel('Temperature [K]',color='r',fontsize=20)
ax2.axis([0.8*T.min(),1.2*T.max(),100,1E-6])
for tl in ax2.get_xticklabels(): tl.set_color('r')
ax2.legend(loc=1,frameon=False)
savefig('./plots/atmosphere_transmission_JWST_CC.pdf',fmt='pdf')
show()
#close()
```
<IPython.core.display.Javascript object>
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA8AAAALQCAYAAABfdxm0AAAgAElEQVR4XuydBdgc1dmG7yEQKF4opdBixYqnuLtbcIcEbynuHtxdKliCuwd3byHYjxRoKRQv0FKsJBCY/3ozs/vNt1mZ2Z3ZMzP7nOvKBd/ukffcz+zuPHPMQ0kEREAEREAEREAEREAEREAEREAEeoCA1wN9VBdFQAREQAREQAREQAREQAREQAREABlgXQQiIAIiIAIiIAIiIAIiIAIiIAI9QUAGuCdkVidFQAREQAREQAREQAREQAREQARkgHUNiIAIiIAIiIAIiIAIiIAIiIAI9AQBGeCekFmdFAEREAEREAEREAEREAEREAERkAHWNSACIiACIiACIiACIiACIiACItATBGSAe0JmdVIEREAEREAEREAEREAEREAEREAGWNeACIiACIiACIiACIiACIiACIhATxCQAe4JmdVJERABERABERABERABERABERABGWBdAyIgAiIgAiIgAiIgAiIgAiIgAj1BQAa4J2RWJ0VABERABERABERABERABERABGSAdQ2IgAiIgAiIgAiIQBcJ+LANcHmLJlfz4P4uhtWwqaLFmwdmikEERCC/BGSA86uNIhMBEciQgA+zAm9l2ESl6ks9GNqFdtSECIhAQQikYSh9uAjYMdLl4z04PAkCH34DnA9MECn3ArCGBx9XXksj3iRxKa8IiIAIZElABjhLuqpbBEQgtwRkgHMrjQLLkIAPfwdmD5t434NfZNicqm5AIA1D2akB9uEQ4ISaEB8D1vPg8+jracSri0EEREAE8kJABjgvSigOERCBrhKQAe4qbjWWEwIywPkQoo6hPBi4tia6jzwY3SjiTgywD6cC+9fUfQewqQff1Lbpw2TAdDWv7w7sF3ktN1O286GyohABEcgrARngvCqjuERABDIl4MOExB/92oTghrGS/gJsETPArzz4NGZeZROBTAnIAGeKN3bldQzwzl4wpTl2ascA+zAA+FPN1Glr8ypgiAdj4wbgB9Otj5UBjktM+URABPJCQAY4L0ooDhEQgdwS8IM1vMMjAT7iwYq5DViBiUADAjLA+bg0XBhgHwaGRnfjGgrnAXt64CehIwOchJbyioAI5ImADHCe1FAsIiACuSQgA5xLWRRUGwRkgNuAlkGRbhvgcArzzcBqNd051oMj2+miDHA71FRGBEQgDwRkgPOggmIQARHINQEZ4FzLo+ASEJABTgArw6zdNMA+/Bi4E1gy0iUb7d3bg3Pa7aYMcLvkVE4ERMA1ARlg1wqofREQgdwTyNoA+zANsBQwA/ATgo1vPgFe9ODlNAH5YN/7iwFzAj8HfgD+ATzswX+ateXDpMAywDzAFMBnwBvAox58m1acPkwPLBHGNxXwL+B14M9eEG/HyQ/6sEC4sY+1YX3/EHgi7TXbPkwCLBv252ch82c8eLhRR8Iy8wJzAz8FJgf+F2E+qh3mZTLAPiwU8rHPjW3SZNfJ5XG4hJvgLRrqbwbRdj228k958H7HF1iLCrplgP3gO+We8FqvRGXrfHfwWp9D3LQXMsBZXyWqXwREICsCMsBZkVW9IiACpSGQhQEOjahtrrUvsHjNOZxRdh8AtkbvbC8wQK1uSs1o2VEmlTTubFAfJrIRH4JzP39Zp5IxwMXAwR58GX0/NOhH2U1zaDRqi5t5OCaM8fsYMd4PrBLJN5FtvuODGZJhwJoEm5TVJjOoZwFnJNmsp1JJ2I8DgG2abIBmBvsp648H97bqi71fZzOiOT34ux9ssmbHzGwQPjCIVneHB+vWcJ4N2AxYO3wAMHGT9k0vm9J6sgd2bmvDVCe+ON2yPFd6Aatq6sRAJzFMfvDAoN51bJs42XW8a/gQp7Yv0zV6gBE+wNkj3ADKHgA1Si8CJwLXJV0XGxdsNwywH3zO76v5vNvDtc09uC1urI3yJdGz07ZUXgREQATSJCADnCZN1SUCIlBKAmkb4HD06QZgkQTA3gHW9eClFmZnPONghhG4HVg6Rnv/B6zoBaO7Zu5slM2OR7HR4lbpamBbD5qaYB/GM8Chuf49wS61rdLzwFpeMGIXK/mwNXA+YKO9cdM1wFAPzGw2TPUMcDhKfinB9NN6qZ8B9oO4/hs3sEg+Y324Byc1KlsWAxw+CLLPjc1CaJTqGmAfVgWuIJhdEDc9BGzktadL0zayNsA+zE/wAMdGgCvpC2B9Dx6JC6DFda9doNMAqTpEQAS6TkAGuOvI1aAIiEDRCKRpgMNRTjOUNq01mmwKrhk7m/psu7XaCJXdxEa/p+0GdiUPnmtidmoN8Cnh9NuK+bURIDvGyUZTfxROh56xpr6RHqznw+zA0wRTtC1ZjM8A/w5fszqnrCl7gAentbhxrjXANuppZ6BW+moMng0NoXGytYs2/Tqa/gos5wWxNE1+sMnP0XUy2fRtm1ptI95mVO2BRK0uNk15dQ++a8Lcjq/ZMfL+luGu4Tb12ZIZ21GhtlOH5viV6AiwD/b6uIcOkfReGJ+VN92M9a+AOWquCytySCMTXBIDbMeQmfGtXMdm/O1z8G44pXxmghkE09eOAPvBzAU7+qd2VsE/gVdCfWxK/yBgphoNXrU2vWCKdGopSwPsB58XW/Mbffhin6k1m313JO2cRoCTElN+ERCBvBCQAc6LEopDBEQgtwTSMsB+YK7spj06mmqG8ggbramdbhlOYTQDGz225E1gYQ/MDI+X6kwdNVNlN8K2RtemMfebSh1Oxd4pHB21adKVZNOQbfruwoBNw94HuCG6BjecUmrx/S5S7mvrXzPDUGcEuBLjx+H0Vpt6Wh1FDnew3SucHm0PByrpWq/FeczhyK+N/FWSbf5jI82nefB2FGDIYj2CjYFmibxneW3qdN1Ux2CaoTZDZWtJrdz1tVO2bRZAtP3QAJtJuRW4ydZtNjL3PthU6f3D6ewThEEZr0XrTYf2YdrIFGwz9JW+fRSuPW/UtfHOsHY4BbrC1PSzafAnesHDoqiw9rn6OPqwwoflgQdrZhbYyP5xXmB++6Uw/7nAgpE37LrftBGkdl7PygATjO7a1HhbE11J9pBgNS942JNakgFODaUqEgER6DIBGeAuA1dzIiACxSOQogE2c7N+hMAIYOdW61n9YAqzGdBKanh0SR0DbGVs05u1vWA9YN3kB2uRT4+8WTGlNkq2rAc2GtmorK0nNONYSb/xghG3RvlrR4Atn5lfG9G1UdlG5awNM4fRkTwb1bJNfsZL4Rrc1yJmwB4CbOgFo2MNkw/TAY8Dc4WZbF3w3Laut0E7tSPAls24Le+BTV1vmcI12j9NsgFTHRM13prd2oY7MbBWVyflkximBtexhTDEg8taAg1iNRP4t8g0YDPPu3pwYQv9rdzd4cyJStZVvMBIp5IyMsA2s+PX4QySSpxmes38mglONSXRM9WGVZkIiIAIdEhABrhDgCouAiJQfgJpGGA/mF5pU5wryUZ+l2q1XjY0HTbKZ1No7ebWkk37ncmDb2rpNzAONtplo8wNkw+24ZKZ0NopzTbluuFuxWF8Ni31iUjlNuJp05rrpjojwJZvEw9ubHU1+YFJN7NeSXd5waZR4yU/GCm0keNK2tMDG91rmfxg5NuYV34n/+DBbg3aqWeAV/bA1pBmmvxgtM822bJka5WnbLYLcicG1hropHwSw9TgOr7MgyFxgfrBZllnRvLb5mn7xSnvgy0LsAcetkzAUsPrLE59tXkyMsC1zdgyAntA9Gk7MbYqk0TPVnXpfREQARHoJgEZ4G7SVlsiIAKFJJCSAb4E2D4CwEZlbCQ0VvJhO8A2VaqkuuXrGAdbO2pTkpsecWSV+jASWCfShh07ZMczNU3h1GGbkm1H9Vj6m9c3ejpe2ToG2I57sgcELVN4pqmtX67skGyjejN6YNN5q8kPjIvd+FfWDttI7C/jPHCoVOIHI34rhX+/7wW7OtfrT60B/ovX/8zVlv1qN0MdI2XrVW0X67qpEwMbXiNmCm1tuKWGTBpwir1pUgMDPK8HtvY7VvKD471surgl20F9hkZLBxrEG/3M2hrwqePsxB4nuC4ZYHvgtmqcz36cmGvzyAC3Q01lREAE8kBABjgPKigGERCBXBNIyQCbAatssGPGzDbriX2mrR+UjU6ntWN67MigfqmOcXjEgxXjAPaD0TIbNauko7z6m0eNV50fjG5XTOwXXpPdlusY4IM8sLXEsVLNqKeV2dgLpkZXkx8csxR9wBB79K9SiR+MmtvxTpVkBvqtOsxrDXDDDalidXB8TW1ttq0ptgcMlTW/lVy24ZHtvl1JO3pgxq1uKrABft0LNgCLlcIN3KJT1m/y+q+lb1mPD9vSf7p1aqP6GRlgW6tfu6GdHZFlJrjlZnEtgYx/XcZ+oJG0buUXAREQgSwJyABnSVd1i4AIlIJApwbYDzYdim649GfAdgpOkmzdq61nrKS66z3rGOA/evDbOA35wSZZUVNt54VeF7OsTZNeIcxro7IDGp2hWscA27FLsY9m8eHg8JzWSmgneXBINE4/6If1p5Js06iWU6xr+rpFTTuNRt1rDXDDdckxWc4angdsR/fMV8fUNKtmf6//Wu5+eQtsgK/xEnxm/GCqtK2xrySbDn92HP6RPLaj+uWRv229vmndccrIAB8fTtk/tCZAO9fYTHCqU6E1AtzxZaAKREAEHBGQAXYEXs2KgAgUh0AKBrj2aKI0Ol93TWIdA2y75dbeENdtv84N7RpecJZoy1TvbN9Gm3vVyWtTmG1ac6zkByN5dh5sJV3i9T+GyKZz11uXG6v+JpnqPhCo05bt0h1d7x2rXT84bsrO87UjlWpHemPVATTcIM0qKLABPsfrv567KY8613Jcfs3yJZqp0KyirAywB4f7cKydDV3Tvp0fbht59ds5uxMoMsCd0FNZERABlwRkgF3SV9siIAKFIJCCAR4M3JJyZx/3YLnaOusY4OPtpjhO253c0HZogCf3wI5PipV8sJHR6I7Wt3iwYbRwnWnSsepukWknDy6uw7zWbM/ZaMfoRvX7MD3wQDji20msTfUusAGOfR2HRr92On8nTCtlW24mF7eRLA1w2H8799rOv46ml0MTbJvddZw6+b7ouHFVIAIiIAIdEJAB7gCeioqACPQGgRQMsJ0hGmsqcQKiT3hgI8v9UkEN8GRJNheqY4Bv9mCjKAgf7rCjnxLwjJO17hTYOiPA7Rjg2iOy7Fxf25TsLsDWcdqZwv+1nZ5rzrmtnV0gAxyMdJ9Pg1274wjdIE8iE96snawNcGiCzQCbEY4mO/vY1jJ3bIJlgDu4klRUBETAKQEZYKf41bgIiEARCKRggG0n4egZouNN2U2LQ0ENcBZToG3HbNs5u5LsTN7H0uJcY7Y7GgEOj1yyI2sqyXbstunndgxT0+QHJt/MfiXl2QDXrstuuBN6J9exgfAD4xcdAd3O67+etxXaTN/vhgEOOdRuVGUv207adrzZvzrppAxwJ/RUVgREwCUBGWCX9NW2CIhAIQikYIDnBWzkpZLqTl9OA0YnxqGTG9oOp0BnsQmW7Sp9QIRp3enLKTHv1ADXmrVdPLgwTmw+7ET/vFkb4NeAucPY/uXBz+LEGZqx2nOZszTAdmazjQJXUmrTl+P2t1m+bhngkLvtAWAbZEWT6WgjwbHX3tf2p5PvizQYqg4REAERaJeADHC75FROBESgZwikYIBtQyPbfMY2ObJkZ4pO58HnaUMsqAE+2IOT47KIeQzSBsDNkTqv82DzuG0kydfpFGgfrqrZFTz2iLgfHHkUPV+6lQG2ncTnCPuX6Bzf0Ew9DSwWlrczpidttNt3HcNk67Zt/XYlZWmA7Uiu6EZkT3uwRBJds8zbTQMc6nZQuMFatFuvhybYjk9KnGSAEyNTAREQgZwQkAHOiRAKQwREIL8EOjXA4Q3oteHRNpWO7uXBOWn3uqAG+EWv7wzhpkh8+DHBqNXEYUY7cskM40fRgj5MSXDsi52ha+l/Zvw6GfFqFFgKBvhOYK1I/bHWRPvB2cDv0v/M5VYG2DZCsqOVLH3qwXRJrkE/WJe8TqTM7B78o1UdPkwdrmOeNJI3SwNs9zdm7Coj1Had/NoDOxLIeeq2AQ6/g2xGRO1522+E06ETm2AZYOeXkQIQARFok4AMcJvgVEwERKB3CKRkgGs3KzJzNsgLNjdKLRXUAFv/N/FinNPrB2fc7hsBdrfX3zxW3/KDHZt3iOS92oOtUoMdVpSCAb6S/nEt4sFzreL04VTAzjeOplYG+HFgmbDAD+EI7phWbVXe9+EY4IhI/r29GOfrNjiaJzMDHBo+i9PirSRbA27TfsfG7W9W+VwY4JCJfXbsMxRNfwdsGUKi7yIZ4KyuDtUrAiKQNQEZ4KwJq34REIHCE0jDAIc3n7UjfXY257oevBMXkg+TA4M9MNM0XiqwAbZdaZfzwEak6iYf1g2nNU8YybCWB3c3YDELYGsdJ4m8bzf/dp6r7bIcK/nwK2B6Dx5p0E6na4APpP8U8JbTtX0YAgwHan/HWxlgW1ts64YraR0P7LqMlXxYAXg4ktlM03zNpvP7sF6o24CaRrI2wDZCbubup5F2r7Zzlj34JlaHgw21ZgIWSMKpVd2uDHD4PbQ3YMdERdOb4UiwzSiIlWSAY2FSJhEQgRwSkAHOoSgKSQREIF8EUjTANh3zL8DMkR7a0Ta2/vViL1gnPF4KTe+KZnzDadRfevCLBnkTHYsTraOTG9oON8H6jGBqs5ngvYDrowbVB5s2a6/bLsKVqc8WehyjaCO+tQ8LbB2rbQp0Z6PRQB9mDY9R2tiMAXBCo/OUUxgBnh2w9ZhRg2jm9kAvmMZdTT78PByB3TV80a6Z6DTmVga4lodNHT8uvC5t92kbFa6kr+q0b/cN9lBhrki+Z2zHbS94PRqrrXm3EWoz+Na3is6VPJkaYGskNOy29rgyFd5eNtbW5xs8sHXM9T5z9lldk+B8aZvyfY0H26T1zeTSAIdc9mD8JRg2ld12h471QK6T74u0OKoeERABEWiHgAxwO9RURgREoKcIpGWAwxvPBcx4Mb6BtTWKZiBsJMY2xzKjNxVg5mi2mpG+hpsXFXQEeAvARuYqv0lmhO0IIONgo3dL2VTdmovOjnKxEeN/t7oYfdgvXPtom5FFk40C2kZJZgLt/23EcFrAdu02Qx5NDY1lpwY4vC5sPbiZkmj6FjCzbqNydj3YdWCbO0U52ZTWKyKFWhlgq8cMoI2Ot0pX1jN9PqzB+KPudv3atG27fi0+e8izCFAZrbep1w/VTJ/O3ACHbO36GlHz8MTeMr62JthGsb8imF1huo8b8a+BU5dFK4CN3ndtgEMuvwPOq4nxrdAE/7NV32SAWxHS+yIgAnklIAOcV2UUlwiIQG4IpGmAwxtPG7Gzc2qjGx8l6e/LHpiRHi8V1ADb6NwuwLlArUmt180XbHQuyTmmPqwWMp8hCehI3v298ddOjns7JQNsDG4A1o8Zn43S2ZRwe0gSPd+4qQEO410YuLXOQ5japhuaPj9Yh31anSnY9cK3M7A3Cg3+sZEMXTHAkT7bQ5boyHVM1OOyneeN/4AiSfl+efNggEMuvw2Pi4reD74dmmD7b8MkA9y2/CooAiLgmIAMsGMB1LwIiED+CaRtgCs99oPNiGx00syZjT41S3Yz+gDBRlH3NlrDWlQDbFOR/WCk98iQR+16UWNjuz/bWbJnesFRUomSH6wFHhqa7YVamG3bKMmm9t4LXNVibXJHa4Aj14P9JtuonB1ZU3eKO/BeOOJ7kq27bVfvcAdpGxm1hzD2MMVG2iermYbddNQzfKhwEmCGul6ykWZ7qPFHu16TGKZ2+9XCsNk1tVnI2I5Eiq4lry1qU8H/D7Dp0zb9ueWmZEkuxrwYYIvZB5tO/4eahxk2AmzToW1EuG5KomcSNsorAiIgAlkTkAHOmrDqFwEREIEWBPzgRtymi84ZnhVsR/jYlFybAmzr8v6axfE9roRptV7YD46uWdKONwpHOG1KtE0Pf8rrv0a17S6ExymZ4bYRYVuraiOwNg3W1tTaRlzG3I5O6nryg/WyZipturNNybapumb+7Vqw82xtunFukg+/BJYOpw1b7Dal+DUPns1NkDWBhOvq7RqzBw3G2B6OmP62DtrOSn7Vgy+yij8NA5xVbHHrlQGOS0r5REAE8kZABjhviigeERABESg5gVYGuOTdV/dEwJ5g2IZal0dQ7OyBzSQoTJIBLoxUClQERKCGgAywLgkREAEREIGuEpAB7ipuNZZDAnUM8MHAtTWhftRol+pud8kPpsdHdxu3EHYPl3BUwmm4prvb8ao9ERABEWhGQAZY14cIiIAIiEBXCcgAdxW3GsshgToGuF6UuTGURYs3h5IrJBEQgRwRkAHOkRgKRQREQAR6gYAMcC+orD42I1A0Q1m0eHX1iYAIiIBGgHUNiIAIiIAI5IaADHBupFAgjggUzVAWLV5HsqpZERCBghDQCHBBhFKYIiACIlAWAjLAZVFS/RABERABERCB4hGQAS6eZopYBERABApNQAa40PIpeBEQAREQAREoNAEZ4ELLp+BFQAREoHgEZICLp5kiFgEREAEREIGyEJABzrmSPiwCrAYsDiwBzAiM8WCSZqH7sF14RMG8wLfAn4HjPHiyUTkflgYOB5YEBgKvAud7cGmTMr8AjgHWBKYB3gGuAU7Iy/ENOZfYzoOMrbEPEwDLAOsBKwCzAVMB7wH3ASd78JY0zo/qSfRtotv9wCrh+zN48FG9vPoMd1/3dvX1YWJgD2ALYC6Cz/b7wOPAkV7w//2SD/OE37crApMDfwcuAc724IcG18TUwFHAhsDPCK6dW4BhHvy3+8SK1WI7+vrw8/C3dA2C//8OeAO4GjjHgzENtFoXOAAYBNj92fPAqR6MbPLdkPiaKJYC2UXrw6TA6uHv6WLArMCA8HN1I3CGB1810Er3WNlJk1rNSTXWPVZq6HNfkQxwziXygxuVwTVhNjXAPpwB7AN8A9xLYJbt5tn03tSDm+vcWNnN0fXhTdijwKdhGbt5OtODfeuUmR14Kjwb8OXQMC8K/DJ8faVGP/Q5x97V8JJo7MMcwN/CAO0GeRTBja89ILEbrS+Btb3gJrr25lkad1XZoLEk+ja40RoKDA+qGvcZrmuA/cDg6DPcZY3b0deHnwL2UGOB0JDa96gl+3zba8vVfob94MHkAwQ37U8DbwPLh6bWbtbtu92ukWryYdrwu3hO4B/h98V8gP0z87ykB//uMrJCNZdUXz94mPEE8JOQuZlYO0N32fChhX03r+wFpjiq1Z72IAMYG14bZpLNnP0I2MuDc+p8pye+JgoFP+NgfdgJuDBs5pXwHmZKgsGAKYDX7EGzBx/XaKV7rIy1Sav6pBrrHist8vmvRwY45xr5cFB4w/MMYP/s6X1DA+zDyuFNkt3ULOWFZsmHpYCHQ1M8mwefVbruw48JRg1tJHFjD24Kb9ynD0cj7KbMfrAfqvkReCS8AbMn2nuFZSYErgtHG47xYFjOETsPL4nGPthDh/PDEXZ7UDEuhaNJfwTMLNko/BzRGyxp7E7mJPrWucGdDvgr8CwwNzBLPQMsfYujbzjCYAbJzMvxNjrrBaan8lm2B4hfeMFDyMpr9r1qN+P2+d/XgzPDz72NAttDTvt+38ELHpRUkw+XAdsSfKdvXmnHD8yUjT5f5sEQd/Ty33LSz68fsLaHUecBe3vwfaiVPfQw82sPI/ppFZpmM2CW1x4cj3sgEr5us7bst3neyu955Lc28TWRf+LdizCcKWefQ3vIX3mwbNxnAO4Afm2j9h5sFfks6h6rexJ13FJSjXWP1THywlQgA1wYqao3QvaEv5kBti/ttW0E2IOzam6G7OmyPWXe34PTI1/oNuXqFOBWDzaoKWM/5PaDPtILpt1WbshsupCNQtiT0ZmjI70+mHF+l2Dq0PS1T7oLhrzr4frBKE7Lae61gfnBSL89ILGbpRU9sAcUFb2kcdeVrN9gEn19uBLYCJg/fLDVyABL34Lo68MOwMXAjR5sEidsHzYNHyy+6AXTY6vJD27SnwNe9oLR48pn3qY72ywRM1UzefCvyHs2/dq+o23Zys+j78WJp5fztPr8+sGDCxt5/1ktVx/2NrMF/MGD3SJ62ENN+9umslueqL42m8tGHM/zgocWFX0TXxO9rFvSvoeDBvbwwUbip/SCpWT246x7rKQwc5q/kcaNwtU9Vk6FbDMsGeA2wbkq1uzHN/xw2pouu7mxGx5bFxr9IV0OsFHDRzywNWSVH9LKSO62HlxRU8bWAn8evvbjyrpeH462dWp2I+cF04j6JT+YqmdPSu1pto08K8Uk0OoGq1k1fvBQwh5ObOUF682kcUzu3coWV18fbP3g3cARHhznB1NeGxlgfYa7JWCLdlrp68NfwiULS1dG+lqF7gf7MNiaw3HXQp3v2zfDpSc2u8euE7tR3z5cH/yAB6vWKWMm3Mz49h6MaBWD3q9+l7Z6CG0PHWyvjmYG+Hgv2G+j8v38T3uQ3GDqu+2zYQ8r/ukFa1QrZRJfE9IwPoFw7ejXYYkZPfhQ91jx+RUhZz2NW8Wte6xWhIrzvgxwcbSq/Og1/PH1g5EBW2/0iResMeuX/GAdko3KfuYFT/4rddp0aFvrO58XbHxVW86mXtva3kEevGhvRtZF/c6D39cpc6qNNIdTwGzkWSkmgVY30I2q8YPNOz4g0L7flHU/mPIujWNqkGW2OPqGP8w2JXI0sJCNPrQwwNI3S9ES1N3iIaWtK7SHlHZjbZ9H29hw/cgGgjYLx/ZTqP0OfsGuA2AdD+6s876t/bbR5A08uDX8jrYZQLY0xTZROrBOmd+F03TP8oI9I5RiEGj1+fWDhwk2rfzc8Pdv3OZk4bpvmwJtGxcu6AVLG+x1uw4qS5Im94Jro1b/T8I1xVN74QNpHxJfEzG6pywhAT+YdfNSuIHZFE0GLKcAACAASURBVDbLTfdY5bo86mncrIe6xyqX/jLABdOzxc2V3UjZzc/zHixcr2sRI2RTer70wTZ8qIzwTuXBF3V+fG3TLJsavb4Ht4c/2jblzqbeDfbgtjpl7MbLbsBsF8X9CobZabitbrAaBefD1gQj+HazZDMAxu00Ko2dyjle43H09YMlCrbxXHUGRSMDLH2Lo68fGF7bkd8eVNr0SjOh0WQPOE+rNaw+/IdgrwZ7GPJ/db5vbVqtTZ3d0wuMl33uK2tRG22gZJsr2iaLN3mwcb4o5jeaVp/fcP2o7chvG43ZxmP2W2kPn20Glu3NYQ+NbRrtuOTDggQPlvs9mK65KOx6sQfcZpzNlFm5xNdEfqnmLzI/2BzLZrfd7gUPqYy57rHyJ1XbEdXTuFllusdqG3UuC8oA51KWxkG1MMC2UYOtGXzCC3acrHfzbdOibbfgypQem6pVOW5jouhmLJEfaDNVZq6q02r94EgH28xjNS/YzbT2Lq6yu+IFHuxaMMxOw211g9VA15nCGy3befS3HtiGWJUbLGnsVNHxPhutplDawyubyn6FF2xqVtGx7hRoP5huqc9wTjRu8R1tx8XdFe70axtbnRZuamczc+who82WsV2eaz/Dtv5wIvvO9YLdm2u/b21a9GHAoR6caG/6weZYdoTezh5cVKeMTYs2o3avF0y3V4pBIM73c7j7ti1BMf6Rj/C4TcmOjh5VFx5dZpuive+BTXceL/nB5ll2/F112rwfrElNdE3E6J6yBJ8d20fFjp6yzekWi8x80z1WSa6QRho36p4PuscqifaVbsgAF0zQFjdXlRHAx73gaXO9H9LK+qSKATYzXFkr3MgAm6m2L/6oAbYdE2136FW9YL1v7Q3ZzsAF9k8GONlFFucGK1pjOLXd1oDaecK3eMEOpNG7LmmcTIJMc7f4DNs0djO/ttb3VzU7ATcywNI3U8WSVd5C33XCG2urtN/usvaCH4wI2+7B73nBDde4FDE7tru7rfet/b613aQPrTHAZm7N5O7kBZtu1ZYxc2YmWQY4gcStvp/DEV0b4bXNx2zTSdt3w0aAbYq6PZywWVbLVHT0A2NrBref5jXf4WaQ7WieegY49jWRoJs9mzU8a9t424wL28W7uoQrMgKoe6wCXyHNNK7XLd1jFVjsJqHLABdMV02BLphgbYTb6gar5sbIRgBsWrqN4NhN1OpecP5zNWmKbBsiZFikxWfYlgvYqOCOHlxSo2MjA6xlDBnqlbTqFvraub2V3dnHmz0Trv220WD7ba6O9rYz3VVToJMqFy9/C33t+9jWcNvD4UW9YKp79LvYljXY8obqww9NgY7HvRu5/GAE3syvbUg23vItTYHuhgrZttFK49rW/WCWhe6xspXFSe0ywE6wt99oix/fuJtg/dcLnm6OS36wKYsdnaNNsNqXJrWScQ1weJ6oTbPbLFxDZkcfmZbjJWmcmjwdV9TiM2w7pptJeiz4aPZLdl6l7fBuZ4Ta9MfDveChhz7DHauSXgUt9LUba9vx19Jc0bNHI9/HdlyRbWRno4S2Ttj0TbzhkR/swaBNsNKTtvJ72WwjyspJC3/3giVC/VJ48207On/oBUsXtAlWyvq0W50PtnzIvnd/RXCetj2E7PcdnGATLN1jtStEhuXiaBxtXvdYGYqRg6plgHMgQpIQWtxc/SjcTbLVMUiPerBC5Iar2REq9vTLpmzZtWI7UNqutParEPcYpH67ESfpa6/mTWCAbZ2vra+29djLecGZzHWTH4w6mbGqd9SVNO7ixRbDAFc/my3C2tALNjGyz6P07aKGzZpq9fmNnBO7pBcciVRN4Q2XzeCw4+eqG14lOAbpl5X1pQmOQdrBC274lWIQaPH53RK4yvZj8IIlKf1SZDZOv3Pe/eChSKtjkN7xgqUR41I710SM7vVkFh9sd/YHw9MubPO4zbxgCnutfrrHKugVElfjmu9j3WMVVO84YcsAx6GUozwxbq7siIy1gH28YAQgenNla1lsTdKBHtgxRZUfUjsi42TbQdoLNmKJlrH1pPaDcKcHtn6tUmZxgps3M10zV3YcDn+Ypw/PLfwfMJ0H3+UIYe5DaaVxyPgE4BDgndD82n8bJj84BkUa50D9OPrWC7PFMUjSNwfahp/NVpucmdm0zc0O8eCkmu9b27zQRqHMBNsDRxvpN7NjszyutZkeXrAbcPQ72nbjt52GX/WCnYcr39EzhPs72EY+tit89QGZH8wksJHIaW1TRA8+ygm+3IfRwgCvFBopO8poBjtpoUarVQg2jXzdC0YaK1rZUYK/tU3QvGA376i+dkTVGcDvvciu4e1cE7mH6yDA8LNgG9OZdveEp12M+9w1+B7WPZYDnTppMqnG4Xeu7rE6gV6AsjLABRCp5sew1c1VZWdPO25hqcoUOx+WAh4iOBpnNi84QqHy42tnAr9FcCTSxl5geCvnFtp6mLqbXUV2pqz+aPtgO5vajdpGwHEeHFEwxM7DbWWQ/OB4HFtHZjety9ebRlnbCT8491kaO1d33Oeq6We4yY1X3TXA4WdV+uZA21CLVt/R8xIcZWTHz9kmguPWiYbnxNqNuO0Cfr4Hu0e+o22WxuvhGbL7emDHHlkZ21zJNruy7/fxNrvyg2PRbHPEG4EtKrv8+8HGPvYw1HYa3zYn6AoRRgsDPEk4xd2msNuOz7tEjqOzKc93AwsAx3tweETfuQE799seVthSFjsqy/S1adS25KFyhrtdA5Xf7bauiUJA7lKQ4bmudoa2Pei3B09remAP7hsmP9hYzj5zusfqkk6dNNOmxrrH6gR6QcrKAOdcKD8YdY2aSDtH0m6wbKfYSjq25lzBytov+yK3L2qbTmc7fk4QTu2xm6F+yQ/OgbwunOps0yk/DXcQtR/ec7xgLVltmcqPs40i2NmEr9qRAcAvw9Fh+yEfN2VaqekPamyNwzVINtpjn127MbLpz/XSRZX1oZU3pbGbq7Cdz3C9SJuNAFt+6VscfX3Yw75XwweS9jm2ja9sN2Dbm8E+3/bdWTt6aLsA2+ihTcO02Tc2bdbWnNpIr02Ft4eXP0QphGvezEzNTrB79KjwfNr5w79tGrZ91ys1IJD08+sHs6jMVNnDYDt1wZibZvaQwqbamr4reIHm1eRDZaTXTLD9btso5Oph2epDj5oyia8JCd2Pud3XVGbK3Rwu96qHaP+aHfl1j1WQC8kP7l1ja6x7rIIIm0KYMsApQMyyCj+YKtdqfdb2Hoyo+WG0cjaCMA/BFGS7CbIR2XGb5jS4wbYbMHsqbZvtmGn+azgS0bD98Gy0Y+zJKcEoo02rs42ZTqjdjThLTkWuO4nGPqwYjuS36vJ410RokqRxK3Ipv59E32ZNtzLA0jdl4WJW166+fmBu9gdsOYmNHJpBtdkzpzUahfKDKc62/4J9D0welrHdws+qt2YxvCbMVFsZM2a2PMU22boVGBadCRSzuz2XrR19fbBp6aat7btgzM3M2tGB9pDZtOq3U38Fqg/rAQcQlLdkm5+d6sFtTX63E18TPSdi43ueo+xzEIOHzZqzGTjVFF4XuseKAc9lFh8Saax7LJdqdbdtGeDu8lZrIiACIiACIiACIiACIiACIiACjgjIADsCr2ZFQAREQAREQAREQAREQAREQAS6S0AGuLu81ZoIiIAIiIAIiIAIiIAIiIAIiIAjAjLAjsCrWREQAREQAREQAREQAREQAREQge4SkAHuLm+1JgIiIAIiIAIiIAIiIAIiIAIi4IiADLAj8GpWBERABERABERABERABERABESguwRkgLvLW62JgAiIgAiIgAiIgAiIgAiIgAg4IiAD7Ai8mhUBERABERABERABERABERABEeguARng7vJWayIgAiIgAiIgAiIgAiIgAiIgAo4IyAA7Al/T7LTAccBgwP7/Q+Ak4I/5CE9RiIAIiIAIiIAIiIAIiIAIiEDxCcgAu9dwcuBp4P3QBP8TmAGYCHjUfXiKQAREQAREQAREQAREQAREQATKQaDXDPAiwGrA4sASwIzAGGCSFnLa+4cAWwIzA/8B7gaOBN7r8FI4GhgCzB3G0mF1iYu/EpaYL3FJFSgCAelbBJXaj1H6ts+uCCWlbxFUaj9G6ds+uyKUlL5FUKmzGKVxZ/ycle41A3xLOM04CryVATbz+wCwdDg1+TFg1tBEfwIsBbzZgYIvAy8AXwAbhv+9AzgC+LqDeuMW1Yc3Lqli5pO+xdQtbtTSNy6pYuaTvsXULW7U0jcuqWLmk77F1C1J1NI4Ca0c5e01A3wQMCnwTPjvoxgjwMeEZvQpYHXgq1C/fYHTw2nKK0Q0nQawf82Smd2PwwzfAKbDtcC54aj0eYC1t3kXrhV9eLsA2WET0tch/C40LX27ANlhE9LXIfwuNC19uwDZYRPS1yH8LjUtjbsEOu1mes0A1/LzWxhgW4drRnVqYGHg+ZoKXgQWBBYFng3fOwoY1kKoS4GhYR4bgf4UmAUYG762CXA9MH3EKKetfaU+fXizIpuPeqVvPnTIKgrpmxXZfNQrffOhQ1ZRSN+syOajXumbDx2yjEIaZ0k3w7plgJuvAV4JeDCc4jxHHR1smrKNENs6XjO+liYI/zWT7QfA/ll6O/y3YqTAPMCr4TRrG63OMunDmyVd93VLX/caZBmB9M2Srvu6pa97DbKMQPpmSdd93dLXvQZZRyCNsyacUf0ywM0N8N7AmeFo7GZ1NFgHGAnY2mJbv9tOuhww82vrir8PK9gAuBn4KWDrjLNM+vBmSdd93dLXvQZZRiB9s6Trvm7p616DLCOQvlnSdV+39HWvQdYRSOOsCWdUvwxwcwN8BrBPaIJtzW9tWijcwOo5wHaYbidZHXYM0iXAWeEa4AuBvwBbx6yw8gGszT5v+IJNs26UBoZvfBuzLWUrFgHpWyy9kkYrfZMSK1Z+6VssvZJGK32TEitWfulbLL3aibZdjScOZ4IOaKdRlemcgAxwcwN8AbAzcDxweB3cNi36b8Ab4TFG7SqyCnASsABgG3PdGB6xFHcX6KYGeOKJ7XOmJALJCEzo+8zybfPnIu9NNBFjJrBZ/w6S78MPNfFNMBC8+l9rY8b2fw400YCJmMBzFLsDXHlp8vvvYWxltwPbAdCDgZVbiLwEqTh6nkCr6/Tb77/Ft++gME04wYQMmED3sj1/4QiACMQgMGZM9X6k131YDFrZZOl18K02wbKR2J2A48KdoGtVmDM0v50a4GzUhdETTzzxxKNHj86qftVbZgLvvAOz2N5sTdKf/wxL2JHaDtLX78Ktdix3JG36BUw0Rd1gpjxxSr789svqe0/u8CRLzWSnmCl1k8C118IWW/S1OP/88NJL3YxAbYlAawKXXgpDK1tV2hSvRWDUqL5yi16wKM9+WNn7EkYMHsGQQUNaV6wcIiACPU9gkkkmYUzggu2oVSUHBGSA3U+BzlJ2GeAs6Za97pIZ4KlPmprPx3xeVe2x7R9j2ZmXLbuKueufDHDuJFFAdQjIAOuyEAERyIqADHBWZOPXKwPsfhOs+GolzykDnJyZSlQIlMwAT3PyNHw2+rOqvo8MfYTlZ1leeneZgAxwl4GrubYIyAC3hU2FREAEYhCQAY4BKeMsMsDpHINkRyG1Ovs3YynrVi8D7IJ6WdosmQGe7tTp+PR/duR2kB4a8hArzho9fawswuW7HzLA+dZH0QUEZIB1JYiACGRFQAY4K7Lx65UBbm6AbWuWj4GpgIWB52vQvggs2KXzeuOr2pdTBrgdaioTECiZAZ7+tOn5+Gv7OAfpge0eYOXZVpbaXSYgA9xl4GquLQIywG1hUyEREIEYBGSAY0DKOIsMcHMDbPhtA6zDgCeB1YHKzsx2LNLpwOPAchnr1G71MsDtklO50hngGU6fgY++sk3Wg3TvNvey2uyrSekuE5AB7jJwNdcWARngtrCpkAiIQAwCMsAxIGWcpdcM8Do1uznb9rW2E7Sdw1tJxwJ3RP62HdoeBizvh8BjgG2Na3//G1gS+HvGOrVbvQxwu+RUrnQG+Bdn/IL3v3y/quxdW9/FmnOsKaW7TKDWAM83H7z8cpeDUHMi0IKADLAuEREQgawIyABnRTZ+vb1mgO1Qg+Et8GwPjKjJ8yPgEGArYCbAdtK5OzTT78bH3fWcMsBdR16iBks2BXrmM2fm3S/6Pq53bnUna825VokEK0ZXZICLoVOvRykD3OtXgPovAtkRkAHOjm3cmnvNAMflUpZ8MsBlUdJFP0pmgGc9a1b++fk/qyRHbjmSdeaySSFK3SQgA9xN2mqrXQIywO2SUzkREIFWBGSAWxHK/n0Z4OwZu2xBBtgl/aK3XTID/Muzf8lb/32rqsptW9zGenOvV3SVChe/DHDhJOvJgGWAe1J2dVoEukJABrgrmJs2IgPsXoMsI5ABzpJu2evOuwH+7gt44/z+KvxqXxgwcV1l5jhnDt787M3qe7dsfguDfzW47Crmrn8ywLmTRAHVIfDSSzByZN8bP/sZbG8LpMI0/Pnh/TbVW3eudVlg+gXEUgREQARaEpABboko8wwywJkjdtqADLBT/AVvPO8GOCHeuc+bmzf+/Ua11E2b3cSG82yYsBZl75SADHCnBFVeBERABESgyARkgN2rJwPsXoMsI5ABzpJu2esumQGe5/x5eO3T16qq3bDpDWw878ZlVzF3/ZMBzp0kCkgEREAERKCLBGSAuwi7QVMywO41yDICGeAs6Za97jgG+KmnYEk7CSz/ab7fz8ern7xaDfTaTa5ls/k2y3/gJYtQBrhkgqo7IiACIiACiQjIACfClUlmGeBMsOamUhng3EhRwEBKZoDn//38vPLJK1Uhrtn4Gjaff/MCClPskGWAi62fohcBERABEeiMgAxwZ/zSKC0DnAbF/NYhA5xfbfIfWckM8IJ/WJCXPn6pyv2qja5iywW2zL8OJYtQBrhkgqo7IiACIiACiQjIACfClUlmGeBMsOamUhng3EhRwEBKZoAH/XEQL/7rxaoQV2x4BVsvuHUBhSl2yDLAxdZP0YuACIiACHRGQAa4M35plJYBToNifuuQAc6vNvmPLO8G+JsP4b7l+nNc6wWYaPK6bBf+08I8/9Hz1fcu2+Aytl1o2/zrULIIZYBLJmhJu3PTTXDggX2dm39+uOWWvr83uGYDXv745eoLp6x2ChvNs1FJaahbIiACaRKQAU6TZnt1yQC3x60opWSAi6JUHuPMuwH++l24deb+5Db9Aiaaoi7NRS5YhOc+fK763qUbXMp2C22XR/KljkkGuNTylqZzl14KQ4f2dWeRRWDUqL6/F71gUZ798NnqCyMGj2DIoCGl6b86IgJFI+B5ySzNLLPMwttvvz3u32yzzdavuxNMMAE//vGPWXjhhdl1113ZeON0T4yQAXZ/dSW7WtzHqwhaE5gasH+WXh84cODAMWPGtC6lHCJQS6BkBnixCxdj1Ad9d7DDBw9n6KDIHa6ugK4QkAHuCmY10iEBGeAOAaq4CHSZwNDoE6uw7ccff5w333yThRZaiEGDBvWL6Cc/+QmnnXZa1QBPNtlkbLLJJuPyfPfdd/z1r3/l+eeDWWMHHXQQJ510Umo9kgFODWXbFckAt40utwWPAoZVohswYABjx47NbbAKLMcESmaAl7hoCZ5+/+kq8IvWu4gdF94xxwKUMzQZ4HLqWrZeyQCXTVH1pxcJmCm+9NJLGTZsGEcdZbfH46fKCHBlRDiaY8SIEWy//fbY6PILL7zAggsumApGGeBUMHZUiQxwR/hyWVgjwLmUpYBBlcwAL3nRkvzl/b9UhbhwvQvZaeGdCihMsUOWAS62fr0SvQxwryitfpaZQKcG2NisvPLKPPTQQxx77LEcfvjhqeCSAU4FY0eVyAB3hC/3hbUGOPcS5TjAkhngpS9emqfee6oK/IJ1L2DnRXbOsQDlDE0GuJy6lq1XMsBlU7RH+jN6NLz5ZvE7O/vsMMkkHfcjDQO83377ccYZZ7DLLrvwpz/9qeOYrAIZ4FQwdlSJDHBH+HJfWAY49xLlOMCSGeBlL1mWJ959ogr8j+v8kV0X3TXHApQzNBngcupatl7JAJdN0R7pzyuvgG1ZXvT08ssw33wd9yINA2zG98ILL2SPPfbgnHPO6TgmGeBUEHZciQxwxwhzXYEMcK7lyXlwJTPAyw1fjsffebwK/fdr/57fLvbbnItQvvBkgMunaRl7JANcRlV7oE8ywP1E7tQAjx49mnnmmWfcRllmgnfaKZ1lUxoBdv9ZlAF2r0GWEcgAZ0m37HWXzACvMGIFHv3no1XVzl/7fHZbbLeyq5i7/skA504SBVSHgAywLotCEpABTsUA2y7Qr732Gocccgh33HEH00477bjdpKeaaqpULgsZ4FQwdlSJDHBH+HJfWAY49xLlOMCSGeAVR6zII/98pAr83LXOZffFd8+xAOUMTQa4nLqWrVcywGVTtEf6IwPctgFudIVMP/303HjjjSyzzDKpXUQywKmhbLsiGeC20RWioAxwIWTKaZAlM8ArX7oyD739UBX22WuezZ5L7JlT+OUNSwa4vNqWqWcywGVSs4f6IgPctgGOngNsR4hOPfXULLzwwmy44YZMOumkqV5EMsCp4myrMhngtrAVppAMcGGkymGgJTPAq1y2Cg++9WAV9FlrnMVeS+6VQ/DlDum662Dzzfv6aPuc2H4nSiKQJwIywHlSQ7HEJiAD3LYBrncOcGzuCTPKACcElkF2GeAMoOaoShngHIlRuFBKZoBXu3w17v/H/VUZzlzjTPZecu/CyVL0gGWAi65gb8QvA9wbOpeulzLAMsClu6iz6ZAMcDZc81KrDHBelChiHCUzwKtfvjr3/eO+qhKnr346+y61bxGVKXTMMsCFlq9ngpcB7hmpy9VRGWAZ4HJd0Zn1RgY4M7TOKp4asH+WXh84cODAMWPGOAtGDReYQMkM8JpXrMk9b95TFeS01U5jv6X3K7BAxQxdBriYuvVa1DLAvaZ4Sfo7ejS8+WbxOzP77DDJJB33o9NjkDoOoEEFmgKdFdn49coAx2dVlJxHAcMqwdpC/rFjxxYldsWZJwJ5N8DffgYvHdOf2KATYUD9H821rlyLu/9+dzX/KauewgHLHJAn4j0RiwxwT8hc+E4+/TRcfXVfN2aaCfaNTBg546kzePfzd6sZtlxgSxb/+eKF77c6IAJlIiADXCY10+2LDHC6PPNQm0aA86BCGWLIuwFOyHjtK9fmrr/fVS118qonc+AyByasRdk7JSAD3ClBlRcBERABEYhDQAY4DqXezCMDXG7dtQa43Ppm27uSGeB1r1qXO/52R5XZiaucyMHLHpwtQ9U+HgEZYF0UIiACIiACvUxAU6Ddqy8D7F6DLCOQAc6SbtnrfvddmHnm5r186ilYcslCkFjv6vUY+cbIaqwnrHwChyx3SCFiL1OQMsBlUlN9EQEREAERSEpABjgpsfTzywCnzzRPNcoA50mNosVSMgO8/tXrc/sbt1dVOH7l4zl0uUOLpkrh45UBLryE6oAIiIAIiEAHBGSAO4CXUlEZ4JRA5rQaGeCcClOIsEpmgDe4ZgNuff3WKvrjVjqOw5Y/rBBSlClIGeAyqam+iIAIiIAIJCUgA5yUWPr5ZYDTZ5qnGmWA86RG0WIpmQHe8NoNueW1W6oqHLPiMRyxwhFFU6Xw8coAF15CdUAEREAERKADAjLAHcBLqagMcEogc1qNDHBOhSlEWHk3wN/8Cx7doD/KVe6HCSeri3ejazfi5tdurr539IpHc+QKRxZCijIFKQNcJjXL25c774Rjj+3r369+BcOH9/29/a3b89qnr1VfOGL5I1h7zrXLC0Q9EwERSI2ADHBqKNuuSAa4bXS5LahjkHIrTcECy7sB/vpduLVmk65Nv4CJpqgLepPrNuHGv95YfW/YCsM4akU7NlupmwRkgLtJW221S+DSS2Ho0L7SiywCo0b1/b3oBYvy7IfPVl8YMXgEQwYNabc5lRMBEeghAjLA7sWWAXavQdoR2B39sEqlAwYMYOzYsWm3ofp6gUDJDPCm12/KDa/eUFXuyOWP5OiVju4FJXPVRxngXMmhYBoQkAHWpSECIpAVARngrMjGr1cGOD6rouTUCHBRlMp7nCUzwJtdvxnXv3p9lbpNWTxmpWPyrkLp4pMBLp2kpeyQDHApZVWnRCAXBGSA3csgA+xegywj0BrgLOmWve6SGeDNb9ic6165rqra4csdzrErRxb5lV3PnPRPBjgnQiiMpgRkgHWBiIAIZEVABjgrsvHrlQGOz6qIOWWAi6haXmIumQHe4oYtuPaVa6t0D1vuMI5b+bi80O6ZOGSAe0bqQndUBrjQ8il4Ecg1ARlg9/LIALvXIMsIZICzpFv2uktmgLe8cUuuefmaqmqHLnsox69yfNlVzF3/ZIBzJ4kCqkNABliXhQiIQFYEZICzIhu/Xhng+KyKmFMGuIiq5SXmkhngrW7ciqtfvrpK95BlD+GEVU7IC+2eiUMGuGekLnRHZYALLZ+CF4FcE5ABdi+PDLB7DdKOQJtgpU20V+srpAH+HCaasq5i29y0DVe+dGX1vYOWOYiTVj2pV9V11u9aAzzvvPDKK87CUcMiUJeADLAuDBEQgawIyABnRTZ+vTLA8VkVJaeOQSqKUnmPs2QGeNubt+WK/7uiSv3ApQ/k5NVOzrsKpYtPBrh0kpayQ5ddBkMix/rqHOBSyqxOiYATAjLATrD3a1QG2L0GaUegEeC0ifZqfSUzwNvdvB2X/9/lVTUPWPoATlntlF5V11m/ZYCdoVfDCQjIACeApawiIAKJCMgAJ8KVSWYZ4Eyw5qZSrQHOjRQFDKRkBnjILUO47MXLqkLsv9T+nLr6qQUUptghywAXW79eiV4GuFeUVj9FoPsEZIC7z7y2RRlg9xpkGYEMcJZ0y153yQzwMvU85QAAIABJREFU0FuGcumLl1ZV22+p/Tht9dPKrmLu+icDnDtJFFAdAjLAuixEQASyIiADnBXZ+PXKAMdnVZScmgJdFKXyHmfJDPD2t27PiBdGVKnvu+S+nL7G6XlXoXTxyQCXTtJSdkgGuJSyqlMikAsCMsDuZZABdq9B2hFoE6y0ifZqfSUzwDvcugPDXxheVXOfJffhjDXO6FV1nfVbBtgZejWcgIAMcAJYyioCIpCIgAxwIlyZZJYBzgSr00o1AuwUf4kaj2OAn3wSllrKTafH/Bue3at/24tfCBP+qG48O966I5e8cEn1vb2X2Jsz1zzTTew93KoMcA+LX6CuP/YY/OlPfQHPOiscd1zf30c8eARv/fet6gu7LrIry82yXIF6qFBFQARcEZABdkW+r10ZYPcaZBmB1gBnSbfsdefdACfkv9NtO3Hx8xdXS+21xF6cteZZCWtR9k4JyAB3SlDlRUAEREAEikxABti9ejLA7jXIMgIZ4Czplr3ukhngnW/bmYuev0gG2PF1KwPsWAA1LwIiIAIi4JSADLBT/OMalwF2r0HaEWgKdNpEe7W+khngXW7fhQufu7Cq5p6L78nZa53dq+o667cMsDP0algEREAERCAHBGSA3YsgA+xeg7Qj0CZYaRPt1fpKZoB3vX1XLnjugqqaeyy+B+esdU6vquus3zLAztCrYREQAREQgRwQkAF2L4IMsHsNLIJ+pjUS0mzA2wlD1AhwQmDK3oBAyQzwb0b+hj8927erze6L7c65a58r+btMQAa4y8DVnAiIgAiIQK4IyAC7l0MG2L0GFQO8I7BYTTifAN93EKLWAHcAr+eLlswA/3bkb/njs3+syvq7xX7HeWuf1/MydxuADHC3ias9ERABERCBPBGQAXavRi8a4EWA1YDFgSWAGYExwCQt5LD3DwG2BGYG/gPcDRwJvNehlDYCPBSYtcN6rLhGgFOAqCqAvBvg0Z/AX+y5USQtcw1MOGld+Xa7Yzf+MOoP1fd2W3Q3zl/nfEndZQIywF0GrubaIvDgg3BWZJP42WeHMyOnpu13z3787T9/q9Ztu8qv8stV2mpLhURABHqLgAywe7170QDfAgyuQd/KAJv5fQBYGvgQeCw0q2aibZTWDkJ9swM5zQAfHNZlmrwEHAs82UadWgPcBjQVqUPgvfdgppmao3F5DvDX78Kt9iwqkjb9HCaasm7Mv7vjd/x+1O+r7/120d/y+3X6/tY10B0CMsDd4axWOiNw2WUwZEhfHQsvDM8+2/f3YhcuxqgPRlVfGDF4BEMGRQp01rxKi4AIlJiADLB7cXvRAB8E2BDRM+G/j2KMAB8DHAE8BawOfBVKty9wOvAosEJEzmkA+9csfQF8HGZYC5gCeA2YCtgF2ApYE7gv4WWiEeCEwJS9AQEZYF0aGRCQAc4AqqpMnYAMcOpIVaEIiEBIQAbY/aXQiwa4lrrfwgBPFBpVM5YLA8/XVPAisCCwKFB5PtxoU6to0UvDac+NrgIz1aNDw93ulaI1wO2SUzkomQHe/c7dOf+ZvinPv1nkN/xh3b4p0ZK8OwRkgLvDWa10RkAGuDN+Ki0CItCYgAyw+6tDBhhaGeCVgAfDKc5z1JHMRoZthPjocDdnyzJB+K+Zwj8A9q9ROg1YH5gr4WWiEeCEwJS9AYGSGeA97tyD857p2/Rq10V25Y/r9m2KpeugOwRkgLvDWa10RkAGuDN+Ki0CIiADnOdrQAa4tQHeG7CtL64HNqsj5jrASMDWFm+Yoti25thS0l01tAY4RRF6uqqSGeA979qTc5/uO/Zol4V34U/r9R2L1NNad7HzMsBdhK2m2iYgA9w2OhUUARFoQUAjwO4vERng1gb4DGCf0ATbmt/atBDwAvAcYDtMt5NsHbGZaDvz19YA7xr+s826bk9YoUaAEwJT9gYESm6Ad154Zy5Y7wLJ32UCMsBdBq7m2iIgA9wWNhUSARGIQUAGOAakjLPIALc2wHaHvDNwPHB4HT1sWrSdhfAGMHebel0NLAdMB3we7gJt7dnU6zjplQaZ5pl44om90aNtKbGSCCQkEMcAP/EELG2boztICXeB3uuuvTjn6XOqge706524cP0LHQTe203KAPe2/kXpvQxwUZRSnCJQPAIywO41kwFubYDtDnkn4LhwJ+ha1eYMzW8nBrjTK0EGuFOCKj8+gfffh1/8ojmZAhngve/em7P/crYMsONrXQbYsQBqPhYBGeBYmJRJBESgDQIywG1AS7mIDHBrA9yNKdApy1qtTrtAZ0W2F+otuQHe8dc7ctH6F/WCkrnqowxwruRQMA0IyADr0hABEciKgAxwVmTj1ysD3NoAu9oEK76KjXPKAKdBsVfrKJkB3ufufTjrL2dV1dxh0A5cPPjiXlXXWb9lgJ2hV8MJCMgAJ4ClrCIgAokIyAAnwpVJZhng1gY47jFIdhTSsExUar9SGeD22alkyQzwvvfsy5l/tg3dg7T9oO25ZPAl0rnLBGSAuwxczbVFQAa4LWwqJAIiEIOADHAMSBlnkQFubYAHAh+HuzMvDDxfo8mLwILA4sAzGeuVtHoZ4KTElL+PQMkM8H737McZf7YVDTLALi9zGWCX9NV2XAIywHFJKZ8IiEBSAjLASYmln18GuLUBNuq2AdZhwJPA6sDXoRR2LJIdYfR4uItz+gp1VqMMcGf8ert0yQ3w0EFDGT54eG9r7KD3MsAOoKvJxARkgBMjUwEREIGYBGSAY4LKMFsvGuB1anZzXoLABD8d4XwscEfk70mAhwHL+yHwGDBL+Pe/gSWBv2eoU7tVywC3S07lII4BfvxxWGYZN7QSHoO0/737c/pT9rwqSEMWGsKIDUa4ib2HW5UB7mHxC9R1GeACiaVQRaBgBGSA3QvWiwZ4KNBq2Gd7oPbO+EfAIcBWwEzAZ8DdoZl+172UdSOQAc6pMIUIK+8GePQn8OQ2/VEufxNMOFldvAfcewCnPXWaDLDji08G2LEAaj4Wgfvvh1NP7cs6xxxw/vl9f+9x5x688R87/TBI+y+1P6vNvlqsupVJBESgtwnIALvXvxcNsHvq3YtABrh7rMvXUt4NcELitQZ4u4W249INLk1Yi7J3SkAGuFOCKi8CIiACIlBkAjLA7tWTAXavQZYRyABnSbfsdZfMAB9434Gc+mTfkI4MsJsLWAbYDXe1KgIiIAIikA8CMsDudZABdq9BlhHIAGdJt+x1l8wAH3TfQZzy5ClV1bZdcFsu2/CysquYu/7JAOdOEgUkAiIgAiLQRQIywF2E3aApGWD3GmQZgQxwlnTLXnfJDPDB9x/MyU+cXFVtmwW34fINLy+7irnrnwxw7iRRQCIgAiIgAl0kIAPcRdgywO5hO4hABtgB9NI0KQNcGinz1BEZ4DypoVhEQAREQAS6TUAGuNvEx29PI8DuNcgyAhngLOmWve44Bvixx2DZZQtB4pD7D+GkJ06qxrr1AltzxUZXFCL2MgUpA1wmNdUXERABERCBpARkgJMSSz+/DHD6TPNUowxwntQoWiwffAA//3nzqF0a4DH/gRcO7B/fIufChHZi2fjp0AcO5cTHT5QBdnwdygA7FkDNxyLw1FNw8cV9WWeeGY48su/v4x49jrf/+3b1hR1+vQNLz7R0rLqVSQREoLcJyAC7118G2L0GWUYgA5wl3bLXnXcD/PW7cOvM/VXY9HOYaMpYBnirBbbiyo2uLLuKueufDHDuJFFAdQhcfjlst13fG7/+NTz3XN/fi124GKM+GFV9YcTgEQwZNEQsRUAERKAlARnglogyzyADnDlipw3IADvFX/DGS2aAD3vgME54/ISqKDLAbq5PGWA33NVqMgIywMl4KbcIiEB8AjLA8VlllVMGOCuy+ahXBjgfOhQzipIb4C3n35KrNr6qmNoUOGoZ4AKL10OhywD3kNjqqgh0mYAMcJeB12lOBti9BllGIAOcJd2y110yA3z4g4dz/GPHV1XbYv4tuHrjq8uuYu76JwOcO0kUUB0CMsC6LERABLIiIAOcFdn49coAx2dVxJwywEVULS8xl8wAH/HgERz32HEywI6vLxlgxwKo+VgEZIBjYVImERCBNgjIALcBLeUiMsApA81BdVMD9s/S6wMHDhw4ZsyYHISlEApHII4BfvRRWG45N11LuAlWrQHefL7NuWaTa9zE3sOtygD3sPgF6npSAzx88HCGDhpaoB4qVBEQAVcEZIBdke9rVwbYvQZpR3AUMKxS6YABAxg7dmzabai+XiDw4Ycw44zNe1ogA3zkQ0dy7KPHVvsjA+zmIpYBdsNdrSYjIAOcjJdyi4AIxCcgAxyfVVY5ZYCzIuuuXo0Au2NfrpZLboA3m28zrt3k2nJpVoDeyAAXQCSFiAywLgIREIGsCMgAZ0U2fr0ywPFZFTGn1gAXUbW8xFwyAzzsoWEc8+gxVbqbzrsp1216XV5o90wcMsA9I3WhOyoDXGj5FLwI5JqADLB7eWSA3WuQZQQywFnSLXvdH30EM8zQvJcFmgItA5yPC1YGOB86KIrmBGSAdYWIgAhkRUAGOCuy8euVAY7Pqog5ZYCLqFpeYi65Ad5k3k24ftPr80K7Z+KQAe4ZqQvdURngQsun4EUg1wRkgN3LIwPsXoMsI5ABzpJu2esumQE+6uGjOPqRo6uqyQC7uYBlgN1wV6vJCMgAJ+Ol3CIgAvEJyADHZ5VVThngrMjmo14Z4HzoUMwo4hjgRx6B5Zd307+ExyDVGuCN59mYGza7wU3sPdyqDHAPi1+grssAF0gshSoCBSMgA+xeMBlg9xpkGYEMcJZ0y173v/4FP/tZ814WyAAf/fDRHPWInRIWJBlgNxewDLAb7mo1GQEZ4GS8lFsERCA+ARng+KyyyikDnBXZfNQrA5wPHYoZRd4N8DcfwcNr92e76qMw0eR1edca4I3m2YgbN7uxmNoUOGoZ4AKL10OhjxwJRx7Z1+Ff/Qquuqrv721u2oZXP3m1+sJRKx7F+nOv30OE1FUREIF2CcgAt0suvXIywOmxzGNNMsB5VKUoMcUxwA8/DCusUIgeHfPIMQx7eFg1VhlgN7LJALvhrlZFQAREQATyQUAG2L0OMsDuNcgyAhngLOmWve6PP4bpp2/eSxngsl8FqfdPBjh1pKpQBERABESgQARkgN2LJQPsXoO0I5gasH+WXh84cODAMWPGpN2G6usFAiU3wBv+akNu2vymXlAyV32UAc6VHApGBERABESgywRkgLsMvE5zMsDuNUg7AtvlpzrPc8CAAYwdOzbtNlRfLxAomQE+9pFjOfLhvkV9MsBuLmIZYDfc1aoIiIAIiEA+CMgAu9dBBti9BmlHoBHgtIn2an1xDPBDD8GKKxaCUK0B3uBXG3Dz5jcXIvYyBSkDXCY11RcREAEREIGkBGSAkxJLP78McPpM81Sj1gDnSY2ixfLJJ/DTnzaPukAG+LhHj+OIh46o9kcG2M0FKQPshrtaFQEREAERyAcBGWD3OsgAu9cgywhkgLOkW/a64xjgBx+ElVZyQ+Lb/8KrJ/dve4FhMGCSuvHUGuDBcw/mli1ucRN7D7cqA9zD4heo688/D3atVtKMM8Iee/T9fd7T5/H+F+9XX9hk3k1YZMZFCtRDhSoCIuCKgAywK/J97coAu9cgywhkgLOkW/a6826Av34Xbp25vwqbfgETTVFXmeMfPZ7DHzq8+p4MsJsLWAbYDXe1mozAFVfAttv2lfn1r+G55/r+XuzCxRj1wajqC8MHD2fooKHJGlFuERCBniQgA+xedhlg9xpkGYEMcJZ0y173p5/CdNM17+UDD8DKK7sh0aEBXn/u9bl1i1vdxN7DrcoA97D4Beq6DHCBxFKoIlAwAjLA7gWTAXavQZYRyABnSbfsdZfMAJ/w2Akc9uBhVdVkgN1cwDLAbrir1WQEZICT8VJuERCB+ARkgOOzyiqnDHBWZN3Vq12g3bEvV8sywOXSMye9kQHOiRAKoykBGWBdICIgAlkRkAHOimz8emWA47MqSk6dA1wUpfIeZxwDfP/9sMoqbnry9Ttw6yz9226yBrh2BHi9udbjti1vcxN7D7cqA9zD4heo6zLABRJLoYpAwQjIALsXTAbYvQZpR6AR4LSJ9mp9//43/OQnzXtfIAN84mMncuiDh1b7IwPs5sK+/nrYbLO+tuedF155xU0salUEGhGQAda1IQIikBUBGeCsyMavVwY4Pqsi5tQa4CKqlpeY4xjg++6DVVd1E3HCEWAZYDcy1bYqA5wPHRRFcwIywLpCREAEsiIgA5wV2fj1ygDHZ1XEnDLARVQtLzH/5z8w7bTNoymQAT7p8ZM45IFDqv1Zd651uX3L2/NCu2fikAHuGakL3VEZ4ELLp+BFINcEZIDdyyMD7F6DLCOQAc6SbtnrjmOA770XVlvNDYmEI8AywG5k0ghwPrgrimQEZICT8VJuERCB+ARkgOOzyiqnDHBWZPNRrwxwPnQoZhSffQbTTNM89gIZ4JMfP5mDHzhYI8COr0aNADsWQM3HIiADHAuTMomACLRBQAa4DWgpF5EBThloDqrTJlg5EKEUIcgAl0LGvHVCBjhviiieegRkgHVdiIAIZEVABjgrsvHrlQGOz6ooOXUMUlGUynuccQzwPffA6qu76UnCKdC1I8DrzLkOI7ca6Sb2Hm5VBriHxS9Q12WACySWQhWBghGQAXYvmAywew3SjkAjwGkT7dX6/vtf+PGPm/e+QAb4lCdO4aD7D6r2RwbYzYUtA+yGu1pNRkAGOBkv5RYBEYhPQAY4PquscsoAZ0U2H/VqDXA+dChmFJ9/DlPb85Qm6e67YY013PQv4QiwDLAbmWpblQHOhw6KojkBGWBdISIgAlkRkAHOimz8emWA47MqYk4Z4CKqlpeY826A//c+3LNEf1rrvgYTTV6XYK0BXnvOtbljqzvyQrtn4pAB7hmpC93Rm26CPffs68L884M976ukda5ahxc/erH69xlrnMFm821W6D4reBEQge4QkAHuDudmrcgAu9cgywhkgLOkW/a6v/gCppqqeS/vugvWXLMQJE594lQOvP/AaqwywG5kkwF2w12tioAIiIAI5IOADLB7HWSA3WuQdgRaA5w20V6tTwa4V5XPtN8ywJniVeUiIAIiIAI5JyAD7F4gGWD3GqQdgXaBTptor9b35Zcw5ZQaAe5V/TPqtwxwRmBVrQiIgAiIQCEIyAC7l0kG2L0GaUegEeC0ifZqfXEM8J13wlprFYJQ7RToteZYizu3vrMQsZcpSBngMqmpvoiACIiACCQlIAOclFj6+WWA02eapxq1BjhPahQtlq++gimmaB71HXfA2msXomenPXkaB9x3QDVWGWA3sskAu+GuVkVABERABPJBQAbYvQ4ywO41SDsCjQCnTbRX6/v6a5i8/o7KVSQjR8I66xSCkAxwPmSSAc6HDopCBERABETADQEZYDfco63KALvXIO0ItAY4baK9Wt///geTTda89y4N8HdfwN8v6h/fXLvDgIF1Y641wGvOsSZ3bX1Xr6rrrN8ywM7Qq+EEBP76V7BN7itpuulg2237/r7y/67kX1//q/rCGrOvwXw/nS9BC8oqAiLQqwRkgN0rLwPsXoO0I9AIcNpEe7W+OAb49tth3XXdEPr6n3DrrP3b3vTLhucAn/7k6ex/3/7V/DLAbmSTAXbDXa0mI3DFFf0N76BB8PzzfXUsduFijPpgVPWF4YOHM3TQ0GSNKLcIiEBPEpABdi+7DLB7DaIRrALcC7wL1NzZtxWo1gC3hU2FxhH45huYdNLmMG67DdZbzw0wGWA33DtsVQa4Q4Aq3hUCMsBdwaxGRKAnCcgAu5ddBti9BpUIZgSeBl4C5unAAGsEOD+aFjuS0aPhRz+SAS62irmLXgY4d5IooDoEZIB1WYiACGRFQAY4K7Lx6+01A7wIsBqwOLAEYKZzDDBJC2T2/iHAlsDMwH+Au4Ejgffi426YcwDwIDASsEWXNo+q3RFgrQFOQRBVAcQxwLfeCuuv7wbXV2/DbbP1bzvBFGhbs3f3NvYxVuomARngbtJWW+0SkAFul5zKiYAItCIgA9yKUPbv95oBvgUYXIO1lQE28/sAsDTwIfBYaE7NRH8CLAW82aFUJwMLALad7rAODbBGgDsUQ8VDAmPGwCQtng3dcgsMrv1IdYlgPQO82VcwYf2Nu8546gz2u3e/anAywF3SqaYZGWA33NVqMgIywMl4KbcIiEB8AjLA8VlllbOVAbZRyTwlH7B1su2mgwBb1PhM+O+jGCPAxwBHAE8BqwNfhY3vC5wOPAqsEAloGsD+NUtfAB+HGcz0/gn4dWiobQS3kxHgaLtaA9zulaJy8O23MPHEzUncfDNssIEbWjLAbrh32KoMcIcAVbwrBGSAu4JZjYhATxKQAXYveysD/ANgpjMPyWK1WGy6cFrJ6ms2AjxRaFRtVHVhILIH5LgQXgQWBBYFng2D6jcFuUGgl4Ym9xfAc8BmwMOR8p0YYI0Ap3V19Ho9330HA+sfKVRFc9NNsOGGbkh1aIBXn3117tnmHjex93CrMsA9LH6Bui4DXCCxFKoIFIyADLB7weIa4Ir5dBmxCwO8Urg216Y4z1Gn8zYybCPERwNmfC1NEP5rxsoeLNg/Gzq7Gfg+ktnKW1/ttV2ASxJC1xrghMCUvQGBsWNhInsG1CTdeCNstJEbhDLAbrh32KoMcIcAVbwrBGSAu4JZjYhATxKQAXYve1wDbJG2yptlb2yk1oUB3hs4E7g+HKWt7aNNX7aNq2xtcTvDYFMAs9RUulu4TnkN4H3gs4RgNQKcEJiyNyDw/fcw4YTN8dxwA2y8sRuEMsBuuHfYqgxwhwBVvCsEZIC7glmNiEBPEpABdi97K1Nro5SWzIDadqvvOAjZdkP+RySObk6BPgPYJzTBtua3Ni0EvBBOY7YdptNI7awBfqVBw/NMPPHE3mjbzVdJBJIS+OEHGNDi43bddbDppklrTid/hwZ4tV+uxr3b2rHbSt0kIAPcTdpqq10CMsDtklM5ERCBVgRkgFsRyv79IhhgGyF9y5EBvgDYGTgeOLyOHDYt+m/AG8DcKcklA5wSSFXTIQHfhwlsRn6TdO21sJktYXeQEhrgM586k33v7XuOJQPsQDObTnN9/0tm3nnhlUaP8NyEqFZFABlgXQQiIAJZEZABzops/HplgJtvgnUhsBNwXLgTdC3ZOUPzm6YBjq9e65zaBbo1I+VoRsBr8RVxzTWw+eZuGNY1wF/DhLbR+/hJBtiNTLWtygDnQwdF0ZyADLCuEBEQgawIyABnRTZ+vXEMcGUXaFdToF2OALuYAh1fvdY5ZYBbM1KOTgzw1VfDFlu4YSgD7IZ7h63KAHcIUMW7QkAGuCuY1YgI9CQBGWD3srcywG9HjkFaBvjAQcg/B56IxGFGPK3U6hikrDfBSqsfjeqRAc6acNnrtynQNhW6UbrqKthySzcUZIDdcO+wVRngDgGqeFcIyAB3BbMaEYGeJCAD7F72VgbYfYTZRtDKAMc9BsmOQhqWbaht1S4D3BY2FaoSsE2wbDOsRunKK2GrrdwAMwM8smbp/SafNZwCfdafz2Kfe2xPuyBpDbAb2WSA3XBXq8kI2LO97bfvK7PQQvD0031/L33x0jz74bPVFy5c70K2W2i7ZI0otwiIQE8SkAF2L7sMcPM1wAOBj4GpgIWB52skexFYEFgceMa9nONFIAOcQ1EKFZIdg2THITVKNkyy9daF6JIMcD5kkgHOhw6KQgREQAREwA0BGWA33KOtygA3N8DGyjbAOgx4Elgd+DoEaNvJng48DiznXsq6EcgA51SYwoQ1cCB8913jcC+7DLbdthDdqTXAq/5yVe7b9r5CxF6mIGWAy6Sm+iICIiACIpCUgAxwUmLp5+/UANshoZNFwvoKaDJfMv0OJKxxnZrdnJcI1xZHJjZxLHBHpN5JgIcBy/sh8BhgG3PZ3/8GlgT+njCObmWXAe4W6bK2M/HE8O23jXt36aWwXTGm/Z3957PZ+x5b1h8kGWA3F60MsBvualUEREAERCAfBGSA3evQqQHeAbCjgizZPEnboOp9991qGMFQYHiL+GzVz4iaPD8CDgFsseNMwGfA3aGZfjfH/ZUBzrE4hQhtkklgzJjGoY4YAUOGFKIrMsD5kEkGOB86KAoREAEREAE3BGSA3XCPttqpATZTeHxYoY2i2mioUn4IyADnR4tiRjLppPDNN41jv+SS/jvF5LiXMsD5EEcGOB86KAoREAEREAE3BGSA3XBP0wDvCZwVTiO+EdjMfZcUQYSADLAuh84ITDYZ/O9/jeu4+GLYwSaC5D/VGuBVZluF+7e7P/+BlyxCGeCSCaruiIAIiIAIJCIgA5wIVyaZOx0BNsN7jQxwJtqkUakMcBoUe7mOKaaAr2xpf4N00UWw445uCH33Jbx3S/+2Z9kSJpiwbjwywG5kqm1VBjgfOiiK5gT+8Q940ra+DNOPfwzr2C4iYbrrb3fx729sG5AgLfWLpZh9mtmFVQREQARaEpABboko8wydGuCFwqOB7DxdmwK9VOYRq4EkBGSAk9BS3vEJTDklfPllYzIXXAA77+yG3Ff/gNtqbjg3+x9MaEv2x08ywG5kqm1VBjgfOiiK5gTshLfoBveDBsHzkYMQF7twMUZ9MKpayfDBwxk6yLYZURIBERCB5gRkgN1fIZ0aYOvBG8AcwFhg+nCDKPc9UwRGQAZY10FnBKaeGj7/vHEdf/wj7LprZ220W/rLN+F2++qJpAQGeOXZVuaB7R5ot3WVa5OADHCb4FSsqwRkgLuKW42JQE8RkAF2L3caBvgA4ORwGvRpwEHuu6UIQgIywLoUOiMwzTTwmW163iD94Q/wm9901ka7pesZ4M2/gQF2ctn46Zy/nMNed+9VfUMGuF3wnZWTAe6Mn0rKClTrAAAgAElEQVR3h4AMcHc4qxUR6EUCMsDuVU/DAE8APB7uAG1HIW0DXOu+a4pAI8C6BjomMO208J//NK7m/PNht906bqatCmSA28LmupAMsGsF1H4cAjLAcSgpjwiIQDsEZIDboZZumTQMsEX0M+BmYIlwJPjicFT4zXTDVW0JCWgEOCEwZa8hMN108OmnjbGcey7svrsbbDLAbrh32KoMcIcAVbwrBGSAu4JZjYhATxKQAXYvexoG+MiwGzbv8HfAFKEJtpdfCTfJ+hhospNOXRDHuMdT+AhkgAsvoeMOTD89fGwf3wbpnHNgjz3cBPnl3+H2Ofu3rSnQbrRI0KoMcAJYyuqMgAywM/RqWARKT0AG2L3EaRjgHyKGt9KjaL22Q3Q7aUA7hVSmHwEZYF0QnRGYYQb46KPGdZx1FuzVt662s8YSlq5rgEfDgInrVqQ1wAn5ZpRdBjgjsKo2VQIywKniVGUiIAIRAjLA7i+HrAxwJz2zmMw0ywB3QjEoKwPcOcPeruHnP4cPPmjM4IwzYJ993DCSAXbDvcNWZYA7BKjiXSEgA9wVzGpEBHqSgAywe9nTMsBp90QGuH2iUwP2z9LrAwcOHDhmzJj2a1PJ3iYw00zw3nuNGZx6Kuy/vxtGX/wNRs7Vv+3N448ArzTrSjw45EE3sfdwqzLAPSx+gbouA1wgsRSqCBSMgAywe8HSMMArZNSNRzKqt+zVHgUMq3RywIABjB1rRzQriUAbBGaZBd55p3HBU06BA+wkNAeprgEeAwMG1g3m3L+cy55371l9TwbYgWaADLAb7mo1GYErr4Rt7EyLMA0aBM8/3/f3YhcuxqgPRlVfGD54OEMHDU3WiHKLgAj0JAEZYPeyp2GA3fdCEUQJaARY10N6BGabDd5+u3F9J54IBx+cXntJapIBTkIrN3llgHMjhQJpQkAGWJeHCIhAVgRkgLMiG79eGeD4rIqYU2uAi6hanmKeYw54s8lpZscfD4ce6ibiL96AkXP3b3uLb2GCierGoxFgNzLVtioDnA8dFEVzAjLAukJEQASyIiADnBXZ+PXKAMdnVcScMsBFVC1PMc81F/ztb40jOvZYOPxwNxHLALvh3mGrMsAdAlTxrhCQAe4KZjUiAj1JQAbYvewywO41yDICGeAs6fZC3fPMA6+91rinRx0Fw6pLzrtLpK4B/g4mmLBuHBoB7q48jVqTAc6HDoqiOQEZYF0hIiACWRGQAc6KbPx6ZYDjsypiThngIqqWp5jnmw9efbVxREceCUcf7SZiGWA33DtsVQa4Q4Aq3hUCMsBdwaxGRKAnCcgAu5ddBti9BllGIAOcJd1eqHvBBeGllxr39LDD4Ljj3JD44Xv4/uv+bU84BXj1v9ZqR4BXnHVFHhrykJvYe7hVGeAeFr9AXf/2Wxg9ui/gCSaAySfv+/urb7/ie/sOCtOPJvoRAxvsQF+gbitUERCBLhCQAe4C5BZNZG2AfwH8GJgKmCBhdx9NmF/ZxycgA6yrojMCdvbHiy82ruOQQ+CEEzpro0ulz3v6PPa4a49qazLAXQJf04wMsBvualUEREAERCAfBGSA3euQtgG2xXdbAVsDSwBTtNlFH6i/kK/NCnu0mAxwjwqfWrcXWQSee65xdQceCCefnFpzWVYkA5wl3fh1ywDHZ6WcIiACIiAC5SMgA+xe0zQNsBnea4CZw251UrcZ4AHu8RQ+AhngwkvouAOLLw7PPNM4iP32g9NOcxxkvOZlgONxyjqXDHDWhFW/CIiACIhAngnIALtXpxOTGo1+VWAkYAdwWp1mYCt12/9XUrS96Ov2fu17MsCdXx8ywJ0z7O0alloK/vznxgz23hvOPLMQjGSA8yGTDHA+dFAUIiACIiACbgjIALvhHm01DQM8PfAyMG3E+H4M3AV8CeweNmiG9xhgSmBGYKnIaLG99wlwAVDZVcLR1rLuRekwgqkB+2fp9YEDBw4cM2ZMh1WqeM8SWHZZeOKJxt3fYw8455xC4JEBzodMMsD50EFRiIAIiIAIuCEgA+yGe9oG+ETgoND8Wt0jQtP7DTAL8FbEANeO6q4MWPnFwvKPAOsDX7lHU9gIjgKqB7MOGDCAsWPHFrYzCtwxgRVWgEeb7Ee3225w/vlugvzuK/jk8bDt8FneDKs33AVaBtiNTLWtygDnQwdF0ZzABx/03wB/iilg6aX7yjz17lN8MeaL6gvz/3R+fj7lz4VVBERABFoSkAFuiSjzDGmMANvI7TRhpHamiE2HrqRWBtjy2WZXNvI7NDTB9wFrZt7z8jagEeDyatv9nq28MjzU5Kig/2fvPMCcqp42/oNlF+nSkQ6KSO8IgqAfvQhKE1CKCthQESv2LupfEUWxIxYsgFTpCEgVECnSbIggXXovy/fMJdlkd1Nukntzk92Z59kHNjlnZs47d3Pz3jNn5vbb4b33ou+XWDy0Ab6vktp2j2QlwM5Ew7RVJcCmodKBDiKgfYAdBF9NKwIZHAElwM4HOFICXAlY71qGpDHL89GfQiTAMlxaJMm37KtdJHgA8LHz8MS9B3oGOO5D6PACWrSAOXP8O9GvH3z4oTNO+iLAPdOWFvC49s7ydxg43X0iA7QNkjNhUwLsDO5qNTQElACHhpeOVgQUAfMIKAE2j5VdIyMlwD2AL13O7QTS5v+Y2QF2r03SoIU8yzfYX4C6di06E+lVApyJgm3LUtu0gRkz/Kvu2xdGjbLFdFClB9fDtKqphykBDgqb0wOUADsdAbVvBgElwGZQ0jGKgCIQDgJKgMNBzdo5kRJg2U6RCjhCWn2lLktLpL9dLsuYXMDJAEv4Cyjr0lcBkN9VwkdACXD42OlMQeC662CqFHj3IzffDJ9/7gxWSoCdwT1Cq0qAIwRQp0cFASXAUYFZjSgCmRIBJcDOhz1SAvwY8IKLsEoP4JvSLKkQIBWhRYQAS8XofQGWPRlo7xrbBZjgPERx7YES4LgOXww4f8MNMHGif0d69IAxY5xx9OCvMK1aatu6A+xMLEKwqgQ4BLB0qGMIKAF2DHo1rAhkeASUADsf4kgJ8GDgfy7C+g3QM82SsgNSDdpNgGsBawMsW7aShEQLWZbd5ZHOQxTXHigBjuvwxYDzXbrA+PH+HenaFb791hlHD66DadW9bGeBnsl+fdEzwM6EKa1VJcCxEQf1IjACSoD1ClEEFAG7EFACbBey5vVGSoClcvMnLsIqfX9l9zatHADyucbImeFA35anuSpACwF+HBhqfik60gcCSoD1sogMge7d4Rt5tuVHZIf4u+8isxHu7LQEOEtW6OFuI55eqRLgcIG2dp4SYGvxVG32IKAE2B5cVasioAiAEmDnr4JICXAjYKGL3G4C0vQkMRYojTqlOrSQ2veBu/wsOxHYBeR3jb0HeNd5iOLOA22DFHchi2GH5YyvfBP0J3JGeLKcXHBADqyF6TU8hkMkwE3LNGV+3/kOOJ65TSoBztzxj5fVKwGOl0ipn4pA/CGgBNj5mEVKgIWsyple0XMWyA2cTrOs14AHXK8dBC4D9vtYuhDe4a7XhSy3BOY6D1HcefAM8LTb64SEBM6eldCoKAJhICBVnkeP9j+xdWuYLskfDsiBNTC9phcBToAe/q/1tDvASoAdiBmgBNgZ3NVqaAgoAQ4NLx2tCCgC5hFQAmweK7tGRkqAxa81gFSiEdLaCkjbNLQ+sMz1voyX/8tZ4a1ei+oHvANkc5HpY0ARr/PDdq0/I+rVHeCMGFWn1tS/P3z0kX/rzZvDbCkA74CkI8DZoMcZv44oAXYgRj5MKgGOjTioF4ERUAKsV4gioAjYhYASYLuQNa/XCgIsRbCkGJYQ4LeBQT7MLwAau14Xm1KpZiNwCJB2R1It2u2L6JHWSvebX4aO9IOAngHWSyMyBO66C0YGqEXXtCnMdyiN+MBqmC519dyfLEqAIwt2dGYrAY4OzmolMgSUAEeGn85WBBQB/wgoAXb+6rCCALt3eGU1UvCqhI9ev1WBxa4UaRnnTXbT/v8PoDZw1Hl44t4DJcBxH0KHF3DvvfC2PNfyI1ddBYvlT9sB2f8LzJCPCpdkTYTuaU9geN7WHWAHYuTDpBLg2IiDehEYASXAeoUoAoqAXQgoAbYLWfN6rSDAYu0GIKvLrGwH/efDBdkBlgrQxVzvyU6vW9x+SIuk64Bt5pegIwMgoARYL4/IEHjgAXjjDf866tWD5csjsxHu7HQEOAm6n/KrTQlwuEBbO08JsLV4qjZ7EFACbA+uqlURUAS0CnQsXANWEWCza8kD3Al0cKU+y3lV2TWWc8TSa0Wq7fjvY2LWSuYep2eAM3f8rV39o4/CK6/411mrFqxaZa1Ns9r2r4IZdTyjsyoBNgudk+OUADuJvto2i4ASYLNI6ThFQBEIFQHdAQ4VMevHR5sAW78C1ZgWAa0CrdeEdQg8+SS88IJ/fVWqwK+/WmcvFE37f4YZdb0IcHboftKvhrQ7wE3KNGFBXylPoBJNBJQARxNttRUuAkqAw0VO5ykCikAwBJQAB0PI/veVANuPcbQt6A5wtBHPyPaefx6eesr/Ci+/HDZvdgaBc6fg+PYL9ffOu05U5JWaer7l3RXvcve0u1PeVALsTNiUADuDu1oNDYEjR2D3bs+cpCQoXdrz+7ZD2zgln0EuKZKrCHmz5w3NiI5WBBSBTImAEmDnw64E2PkY2OmBngG2E93MoFvSnyUN2p+ULQtbtsQFEkqAYyNMSoBjIw7qhSKgCCgCioAzCCgBdgZ3b6tKgJ2PgZ0eKAG2E93MoHvYMBgsXc78SPHi8O+/cYGEEuDYCJMS4NiIg3qhCCgCioAi4AwCSoCdwT3aBDgbUBAo4OoVLEWv9gNnnF9+hvdACXCGD7HNC3znHRg40L+RQoVg716bnbBGvRJga3CMVIsS4EgR1PmKgCKgCCgC8YyAEmDno2fXDnBNoC8grY+qAwlpliqVnqXl0SJX5edfnIciw3igZ4AzTChjYCEffggDBvh3JG9eOHQoBhwN7oIS4OAYRWOEEuBooKw2FAFFQBFQBGIVASXAzkfGagJcCXjPRXxldcH0u3sBCxG+A9joPCRx74FWgY77EMbQAkaPhr7yLMuPZM8OJ/1XXo6hlaAEODaioQQ4NuKgXigCioAioAg4g4ASYGdw97YajKCG4mF/4C0gyUV83eTWrcNty9/rUk7xHuCjUIzq2HQI6A6wXhTWIfDVV9CzZ2B9ycmQxcqPEpPunzkKhze5bGeBLNkgvySc+BYlwCZxtXnYt9/CjTd6jFSuDOvX22xU1SsCISKwfz/8/bdnUo4cUEke8btk877NHD9zPOX30vlKUzCnnPZSUQQUAUUgMAJKgJ2/Qqz61no78G4a4uvWLdtDchtx50nmA8oCF7mW7ybEMl7+LzvBHzoPTYbwQM8AZ4gwOriICROgU6fADpw6BdIjJNqydzHMllMWLknMC139p2MrAY52gHzbUwIcG3FQLwIjkLYPcI0asHq1Z069D+uxcsfKlBdGdRxF35oBsmUUcEVAEVAEXAgoAXb+UrCCAMszUbktSLErEdF5FPgAGAOsAeTMr7fImeAawE2A7BzndpFfmXva9Z5DzUWdD4qFHigBthDMTKlq+nRo2zbw0g8fhjx5og/PnkUw52ovApwPuh7064cS4OiHyJdFJcCxEQf1QgmwXgOKgCLgDAJKgJ3B3duqFQT4e6CNF4FdCEjOpNneKCVdRFm2cmQHWHyaBrR3Hp649EBToOMybDHq9A8/QLNmgZ3bswcKF47+AvYshDlNvAjwxdBVisz7FiXA0Q+REuDYwFy9CB0B3QEOHTOdoQgoAuYQUAJsDic7R0VKgAsBO4GsLid/BuQbaahVcSQdWgph1XIR4LNAcWCfnYvPoLq1CFYGDawjy1qyBBo1Cmz6n3+gVKnou7fnR5jT1GM3qQB0+U8JcPQjEZJF3QEOCS4d7BACSoAdAl7NKgKZAAElwM4HOVICLIcDx7mWIbu39QEhweFIPeAnL11dge/CURRnc7oADwOXATmB7cDXwHOudPBQl6M7wKEipuP9I7BqFdSpExih33+Hy+TyjbLsng9zr/UYzV4QOvt/ZqY7wFGOjx9zSoBjIw7qRWAElADrFaIIKAJ2IaAE2C5kzeuNlABL1ebhrtTl3wCvGonmnfAaKW2QKrr0DQLeDktLfE36P6CAqwXUMdcu+PsuEnxvhEvRM8ARApjpp2/YAFWqBIZh3TqoWjX6UO2eB3Plz8cl2QtB571+/VACHP0Q+bKoBDg24qBeKAHWa0ARUAScQUAJsDO4e1uNlAA/BLziIqyTgCDlYoMuWHZ8r3fpexR4LeiM0AbIVlYL1071la40a2m/5K5I7U+bvD8E6AGUBvYDM4CnXDu2oXkRfPQwoDlQLfjQdCN0BzgM0HSKHwT+/DP47u7y5VBPEjiiLLt+gB+8zidnLwyd9ygBjnIYQjWnBDhUxHS8EwjoDrATqKtNRSBzIKAE2Pk4R0qApYrz5y7COhboHuGSJPW3m0tfb+DLCPWlnT4R6JjmxWAEWMjvXOAq13lnKfIlbZwk3Vu2mxoCf1rop+yiTwBmAeHsAOsZYAuDkelV7dwJxeU4fgBZsACaeBWjihZou+bCD/KcyCUXFYVOu/xaH7liJHdNuyvl/SZlmrCg74Joeat2XAgoAdZLIR4QUAIcD1FSHxWB+ERACbDzcYuUAAv5W+wirCuABhEuaSkgO7NynliqQsvvVsojrnO24qv8yLflYARYzuI+6fKlpavFk/g0GHgd+BHwqsRjpDPLTyA5DKTdqpLWUYmANFSVFOi7fbSPMoNFqh3gLFmyJf3xx17Kl5eXVRSBEBE4eBDy5w88SVoltW4domILhu+cDfPkT9IlFxWDTlKTz7coAbYAcwtUKAG2AERVYTsCSoBth1gNKAKZFgElwM6HPlICLPP/BqQErPT6lfRg/99AA69Xtpn+cVWBlhZKostuEaIdiAALIRWiKuyxNvBLGoekx3F1oK5X8a9UO7B+FjAa6JvmPakilMOlayjwHvB0GACkIsCQkFSw4HAmTuxI48bScUpFEQgBgdOnIXv2wBO++w5uuCEEpRYN3TkL5rXyKMtRHG7w331NCbBFuEeoRglwhADq9KggoAQ4KjCrEUUgUyKgBNj5sEdKgGUFsjv6rGvXdgzQK8xlfeHqHyykVHZdRafdEowAS4nZH1wpzr7K3Mra3b4K8RWRllDutlD+/E8G5Mef9AE+AfICUhgrFElDwBOAoSQlJfDRRy3p1StIQaNQLOnYjI/A+fOQmAjn5PmWH/niC7hJTkNEWXbMgPnSgtwlOUrADVJE3bcoAY5yfPyYUwIcG3FQLwIjoARYrxBFQBGwCwElwHYha16vFQRYtoeWATVcJPh/gKQahyJSSEsKaomsc6VBh9pLOBR77rHBCLBUopaCVHK+Wc4mp5V2wFRAzhZbuQUmBHiUK5X6YIgLS7cDLATYLY8/3oDnnmtE1qxWhD5Ez3R4fCKQJw8clQx9P/LBB9C/f/TXtmM6zG/rsZuzFFwvSSS+RQlw9EPky6IS4NiIg3oRGAElwHqFKAKKgF0IKAG2C1nzeq1iQUWB711pwkIqVwKyEzkzwE6n7JLKwUEZJ9WZxRdJMZZvtLvNLyGikcEI8BvA/S4SLGd+04qQ/tXAKtcawnFGdpGl//FfLgykuJacLZbzz2ZJ9Xo/hitBQhZvAizjuna9nNGj25Ajh2R4qygCQRAoWhT2+K+uzJtvwn33RR/Gf7+HBe29CHBpuH6rEuDoRyIki0qAQ4JLBzuEgBJgh4BXs4pAJkBACbDzQQ5GgKXNj1mRasm3A+6KOUIuD7jOxkqPYCn8JK/lAy53EUb3WPFDWgtJ8Sc5kysiqcV2SzAC/AEgW1svAk/4cEbSon8HZH3SvzgceQno7DpHfdZ1plqqX78FnDCp0C8BTkhIzHLunJhILfXrF2PSpBsoViyXSRM6LNMiUK4c/C1H/f3Iiy/CY49FH55/p8KC6zx2c5WBjv79TLsDfHXpq/nxFqlhpxJNBJQARxNttRUuAkqAw0VO5ykCikAwBJQAB0PI/veDEWA5pyokMVTx1utvfrAxcnjVbglGgD8E+gEvuM46p/Wngov8RkKA7VzjyezZs2d/881lDBw4l3PnUoeiVKk8TJ3aierVC9vpg+qOdwSqVYNff/W/CiG/QoKjLdsnw49eXc1yl4cO/juSKQGOdoB821MCHBtxUC8CI6AEWK8QRUARsAsBJcB2IWter10E2LwH6UeKT8LUYoEARyMFOhKsgs01CPDJkyeZPftvunadwqFD7g32C1Nz507k66/b067dpcF06fuZFYGGDWGZHPP3I/fcA29JwkKU5fQBOCwJGMlwPhmyJkFBKcjuW5QARzk+fswpAY6NOKgXgRHYuxf++MMzJmdOqCGHnlyydvdajp321Ki8tMClFMlVRGFVBBQBRSAoAkqAg0Jk+wAzBNh2J3wYiBUC7FQRLKswTyHAonDDhn20bz+BLVsOpdIvBbEWLepBw4bSiUpFEUiDQMuWMHu2f1huuQU+kaLlsS1KgGMjPkqAYyMO6oUioAgoAoqAMwgoAXYGd2+rwQhwUwddXBAF28FSoM22QZLzyuH07LV7iakIsBjbu/c4N9wwicWLPf1Sb7yxIl991Z4sWYJdDna7q/pjEoFOnWDCBP+ude0KwmpiXJQAx0aAlADHRhzUC0VAEVAEFAFnEFAC7AzuoRBg5z2014NgBDgJkPK3UrirtqtKtbdHa4DqgFRuXmGvq2FpT0eARcupU2fp128WX3yxgSuvvIR587ppReiw4M0kk3r3hs8/97/YNm1g2rSYB0MJcGyESAlwbMRBvVAEFAFFQBFwBgElwM7grgTYg0AwAiwjpQDW48ASoCXgPvQjbZGkXdEi4GrnQ+nTA58EWEaeP3+e4cNX0b37FVoJOkaDFzNu3X03vPuuf3euvhp+jP1qykqAY+OKUgIcG3FQLxQBRUARUAScQUAJsDO4Z2YC3C5NNecrXQW3lnuB8ryrp7H7JWnvNB+QsTuBhUAZ1+//AQ0Ar1IZzgfVywO/BNiMl6dPnyMpKRq1yMx4o2McQ+CRR+DVV/2br14d1kgyRGyLEuDYiI8S4NiIg3qhCCgCioAi4AwCSoCdwT0zE+C+wKggsN8CfJpmTA5gCNDT1a9X+hvPcJHpbc6H0a8HYRPgHTuO0qTJ1zz/fCN69KgUw0tU12xH4OWXA/f5LVMmcJ9guxw8cxRO7YMsCZAlK2TNDhcV8mtNCbBdgQhNrxLg0PDS0c4gcPw47N/vsZ2YCEWLen7ffXQ3Z5LPpLyQ/6L85ErK5YyzalURUATiCgElwM6HS6seOR8DOz0IiwAfO3aaJk2+YdWq3YZvzz57FU8+2VCLZNkZqVjWLenPkgbtT/Llg4MHo7+CLZ/D0t4eu/lrQ5uflQBHPxIhWVQCHBJcOtghBLQPsEPAq1lFIBMgoATY+SArAXY+BnZ6EDIBPncumc6dJzNpUuqs7ptuqsRHH7Xioouy2emv6o5FBMaMgZtu8u+ZVA8/exayZo2u9399CsskYcMlBepCa/+16HQHOLrh8WdNCXBsxEG9CIyAEmC9QhQBRcAuBJQA24Wseb1KgM1jFY8jQybAZ88mM2jQD7zzzup0623UqAQTJnSkcOGc8YiF+hwuAt9/D+3bB54tO8CyExxN+fMT+Ok2j8WC9aHVT349UAIczeD4t6UEODbioF4oAdZrQBFQBJxBQAmwM7h7Ww1GgM+5Bku15PLAPw64LAWn/vLyQ7cgzQchZALsVv3226sYNGgeyckSeo+UL5+PqVM7UalSQfNe6Mj4RmDxYmjcOPAatm6F0qWju84/PoTlAzw2CzWEllKs3bcoAY5uePxZUwIcG3FQL5QA6zWgCCgCziCgBNgZ3EMhwMlexLOcgwR4i5cfWpbY/HUTNgEWE9Om/cWNN07h6FFPoQ95PV++7Iwf34FmzeTZhEqGR2D9eqhaNfAypQq0VIOOpvz+Pqy4w2OxcCNoIV3JlABHMwyh2lICHCpiOt4JBDQF2gnU1aYikDkQUALsfJyD7QALAXZvASoBdj5eoXoQEQEWY2vX7qV9++/Ytu1IKtvZsmVl5Mjm9OsXZdITKgI6PnIE/v0XSpYMrGfePLjmmshthaLht3dhpVdxrsJXQwv//Yh1BzgUcO0bqwTYPmxVs3UIKAG2DkvVpAgoAqkRUALs/BVhhgCLl0KClQA7H69QPYiYAIvBXbuO0aHDBFas2JXO/sMP1+Pll5uQNWuwSylU13V8zCBw4gTkDHLue+xY6NIlui5vfht+vtdjs8g10HyeXx+UAEc3PP6sKQGOjTioF4ERUAKsV4gioAjYhYASYLuQNa83GGvxToGWQ4D/mldt2chSwEKXNiHimgJtHlpLCLCYO378DL17T2P8+N/TWe/UqQKff96WnDkTzXumI+MLgVy55CLw7/N778Htt0d3TZvehFX3e2wWbQbN5igBjm4UQramBDhkyHSCAwgoAXYAdDWpCGQSBJQAOx9oMwRYSKeMS10NKfq+u31QAmwee4MAz5snxaySqVWrFjmD7eQF0C0FsR5/fCFDhy5PN6pu3aLMmNGFggVzmPdOR8YPAmXKwD8BauC98AI8/nh017PxdfjlQY/NYi3h/2YqAY5uFEK2pgQ4ZMh0ggMIKAF2AHQ1qQhkEgSUADsfaLMEWDwNNtbO1XiTcCXA5pE+mZSUlP3555/nxIkTZMuWjapVq1KvXj2KFy9uXkuakR9/vI477piNtExyS/PmZZg2rROJiRqesIGN5Yl16sCqVf49HDQIhg2L7go2vAqrH/HYvKQNXDtNCXB0oxCyNSXAIUOmExxAQAmwA6CrSUUgkyCgBNj5QAcjtR6G47yv4oGmQIcWB2MHeIlo41IAACAASURBVOnSpSxfvpxduzxneEuUKGEQ4SpVqhjEOFT54Yd/6Nx5EgcPnqJy5YIsXtyDiy++KFQ1Oj5eEGjZEmbP9u9tr17w2WfRXc36obBmiMdm8fZwzRQlwNGNQsjWlACHDJlOcAABJcAOgK4mFYFMgoASYOcDHYwAj3LexXQe3BKDPsWSSxcD8iOyOSkpKenUqVOcP3+e7du3s2LFCtavX2+kRItcddVVtGjRIiz/N236j1tumcGYMe0oV85tMixVOinWEejZE776yr+XrVvD9OnRXcWvL8LaJzw2S3aEJhOVAEc3CiFbUwIcMmQ6wQEElAA7ALqaVAQyCQJKgJ0PdDAC7LyH6kGoCDwDPO2elJCQwNmzZ1PpOHr0KKtWrTJ+evXqRcGCBY33d+/ejbxXvnx5smQxd2kIsTY7NtSF6PgYQuDee+Htt/07VKtW4BRpO5ay7jlYl3KpQ6lOcPV4JcB2YG2hTiXAFoKpqmxDQAmwbdCqYkUg0yOgBNj5S8Acy3HeT/XAPAI+d4B9TU9LXseOHcuGDRsMQizp0TVq1ED+SMOVgwdP8swzS3jxxcbkypUUrhqdFwsIvPRS4CJXxYrBzp3R9XTtU/Dr8x6bpW+Exl+bJsBNyjRhQd8F0fVZraEEWC+CeEBACXA8REl9VATiEwElwM7HTQmw8zGw0wPTbZCEDM+aNcvYFT59+rThU2JiItWrVzfIcNGiRUPy88yZc7RpM565c/+hdu2iTJlyA8WL5w5Jhw6OIQRGjYJbb/XvUNasINdNQhSLoK1+DDa87PGpTE9o9KUS4Bi6bHy5ogQ4xgOk7hkIKAHWC0ERUATsQkAJsF3ImterBNg8VvE40jQBdi9OzguvXbvWOCu8d+/elDXXrFmTjh07msJAyHT//rOQatFuKVkyD1On3kCNGkVM6dBBMYbAjBnQpk1gp2QHWHaCoyWHf4Mjf8D5c3D+LOQoAYXqKwGOFv5h2lECHCZwOi2qCGzfnvpUR968cM01HhcW/L2AgycPprxQ65JalM5XOqo+qjFFQBGITwSUADsfNyXAzsfATg8MAvzLL79wySWXcPHF5gtVCYndunWrQYQ3btxoFMpq2LCh4aucKZa2Snny5PHp+z//HKZmzc84cOBkqvdz507km2+uo23b8nauWXXbgcDq1SDnfAOJtEkKNsYO30zqHLliJHdNuytltKZAmwTO4mFKgC0GVNUpAoqAIqAIxBUCSoCdD5cSYOdjYKcHBgGW3dtff/2Vvn37ct9991GhQoWQbB4+fJjs2bMbPyJr1qxh8uTJVKpUyUiPLl26dLpCWJs376ddu+/480/PE3KZmzVrFt566/+4++4gZCokD3Ww7Qjs3h18d3fatOC7xLY76t+AEmAHwfcyrQQ4NuKgXigCioAioAg4g4ASYGdw97aqBNj5GNjpwcnExMTsZ86cSbEhFZs7dOjA/fffT5MmTcKq4Dx16lR+/vnnFJ1FihShfv36VKtWjaQkT7GrffuOc8MNk1i06N90a7z//jq89lpTEhKy2rl+1W0VAtI2S2J77px/jR99BLfdZpVFy/UoAbYc0rAUKgEOCzadpAgoAoqAIpBBEFAC7HwglQA7HwM7PTiZNWvW7O6ev2kN1a5d2yDC3bp1S0VczTi0a9cuIz1azgu72yzJDrHsNrds2ZKsUhQJOHXqLLfdNpMvv9yYTu3111/GF1+01QrRZgCPhTElS8K/6R9mpLj21FPw7LOx4KlPH95d8S53T7s75T1NgXYmVEqAncFdrSoCioAioAjEBgJKgJ2PgxJg52NgpwcGAZZd33MBdu6KFy/OwIEDuf322ylQoEBI/shZ4NWrVxtk+MCBA5QrV47evXun6JCzxCLPPruEZ59dmk533bpSIboTxYrlCsmuDnYAgauugqXpY5jiSZ8+8OmnDjhmzqQSYHM42T1KCbDdCKt+RUARUAQUgVhGQAmw89FRAux8DOz0wDgD/NtvvzFixAg++OADDh065Ndejhw5jHPCgwYN4vLLLw/JLyG6f/75p3FOuFSpUsbcI0eO8Omnn1KrVi1kt3n8+C3GbvCZM8mpdJcunYfvv+9E1aqFQ7Kpg6OMQM+e8NVX/o02bQrz50fPqbPH4HwyZE2ELPKTFbL4/0hTAhy90ASypAQ4NuKgXgRGQJ4Znz3rGSMfLV4nfDh97jTuB7wyKlvWbCRkjWIbOA2gIqAIxC0CSoCdD50SYOdjYKcHqdoguQnpm2++yV9//RXQbvv27RkyZAhXya5fmLJw4UJ++OEHY3ZCQgJVq1Yla9ZS9OmzhIMHT6XSmjdvEuPGdaBFi7JhWtNptiMwZAgMHerfTNmysGWL7W6kGFjcA7Z+7bFX5TGo8aJf+0qAoxcaJcCxgbV6ET4C2gc4fOx0piKgCARGQAmw81eIEmDnY2C1B9LryN3vaHNSUlKS9Pb1FkmHnjJlCm+88QZCUv3J8OHDuffee8P2T4pvSfVpSY/eKT1iXVKgQBEmTz7NvHmnOXfOcwleeeUlLFnS06gUrRKDCLz3Htx5p3/HsmWDkyflaUd0nF/YBbaN99iq+jRUf0YJcHTQD9uK7gCHDZ1OjCICSoCjCLaaUgQyGQJKgJ0PuDIN52NgtQfCAJ52K5WdV3eRKl+GVq5cybBhw/j2229TjcubNy/bt2/32+s3FKclTezff/81iPD69euN88gJCdmYNasUCxfuMVSVKpWHZctuonjx3KGo1rHRRGDGjOBtjv75R4IZHa9+vB62T/LYqv4CVH1cCXB00A/bihLgsKHTiVFEQAlwFMFWU4pAJkNACbDzAVcC7HwMrPYg6A6wL4NCduWc8Pvvv8/Bgwd54IEH+N///ufTt23btnH69GkuvfTSkH0/duwYq1atQnaHGza8mj59pjNjxt+8/35Z6tevQvny5cNqzRSyIzohdAQ2boTKlQPPkzPAchY4GjK/HeyY5rFU8xWo/LAS4GhgH4ENJcARgKdTo4aAEuCoQZ0hDUnxURHvc+JpF/rMM8/w7LPP8vTTTyP/d8umTZuYNGkSs2bN4vfff2f37t3kz5/fOJImnTuuvvrqgJjJRsPbb7/N3Llzjc2HxMREo0CpHG2TGi+FChXKkJjH06KUADsfLSXAzsfATg9SnQE2Y+jo0aOMHj3a+KAsU6aMzykDBgzgo48+4oYbbjCIciTnhJOTz7Ns2SZmz/7WsCVVqOvVq2e0U5IPCJUYQuD4ccgVpFr3Bx9A//7RcfqHlrBrtsdW7TfgivuVAEcH/bCtKAEOGzqdGEUElABHEewMaCoSAlyyZEmDuEom3pVXXmmQ3w0bNhhHykSvHF8TIutLXnnlFR5//HEj065ixYpUr17d2LBYtmyZQaQvvvhiI+OvRYsWGRD1+FmSEmDnY6UE2PkY2OlByAQ4mDN79uyhdOnSeJ8rbtCgAYMHDzYIcTY5BxqiSGXqJUuWsGbNmhS98sSyWrVq1KhRm+Tk3JQtmy9ErTrcFgRKl4Zt2/yrfuAB8JM5YLk/c66BPQs8auuOgMs9fX7T2tMiWJZHICyFSoDDgk0nRRkBJcBRBjyDmYuEALds2ZJbbrmFzp07k+RVelwy9O644w6jqOjatWupnCYjS+q2CDEWwvz555/Trl27FFSFEEtWnxQ3le9Xixcvpm7duhkM9fhZjhJg52OlBNj5GNjpgeUE2J2y48tpSbGRD99bb72V3LlDP8srTynlQ13OCgvRdsvEiXl5990badiwuJ1YqW4zCMhT4zlz/I+UG+7UqWY0RT5m1lWwz6svcf0P4DL/u89KgCOH3AoNSoCtQFF12I2AEmC7Ec7Y+iMhwIGQadWqlZEaLd/FJHXaLVu3bjV2fOV71Pz582nSpIlPNS+88AJPPvmkQZ7dO8oZOxKxuTolwM7HRQmw8zGw0wPLCfDLL7/M0KFDOXz4sF+/JcXm9ttv55577qFEiRIhr0/OzPzzzz98/PH3HDmyj7feykFiYja++KIt9epdZKRJ58mTJ2S9OsECBO65B0aM8K/ossvg998tMGRCxYy6sP9nz8AGn0L5Pn4nKgE2gWkUhigBjgLIaiJiBJQARwxhplZgFwF++OGHee2115CjaLIj7Bb36926deObb77xi73UX5HNCkmx/v7772nbtm2mjpNTi1cC7BTyHrt2E2DJh5VtuwKAMBax96Pzy840HlhOgAU5Ib8ff/wx0k9YiKo/kXToHj16GOeEa9SoERLo33yzie7dp5It23nOnr1wmWbNep6nn04mS5bTXHHFFcZZYTmn7L7RhGRAB4eHgJBfIcH+JGtWkLPC2bOHpz+UWdOqw8F1nhlXjYGyPZQAh4KhA2OVADsAupoMGQElwCFDphO8ELCLAHfp0oXx48fz1FNPGQW03FK1alWjy8bEiRPp2LFjwFhIIS35/jZw4ECjWJZK9BFQAhx9zNNatIMAS5UcyUPsAFwJeFcyOg/4OiRaE6jucu4Q4NXbxHmQ4tgDWwiwGw9pryQfxK+//rqRthxImjdvzqOPPkqzZs1MwXnkyGm6dZtsVIh2S548yXTpcooyZZJTXitSpIhBhKXQg/dZGVNGdFDoCEj6c7DiGevXB68WHbrl9DOmXgGHN3tebzwOSnf2q1l3gK0APXIdSoAjx1A12I+AEmBrMd67N3x9cqIqRw7f8/ftk0rL4enOmTN4XcfwNJPyYD6cKtD+bP75559UqVLFqJUiLSzr1KljDJW0ZyFUYku6dEgRrUDyxRdf0KtXLxo3bszChQvDXaLOiwABJcARgGfRVKsJsBDfVwB3xaK0+uVjKsGH7/WBZVIxHhB2UxrYadEaM5uasNogRQKSfOjKh6hUJpw8ebLfsv99+/Zl1KhRpk2dPZvMwIFzef/9NanmFC0qRDgHl1xyhLNnzxjvZc+e3Sj4IIWzVGxEQApgSSGsQCLpV9262eiES/Wk8nBsi8dOk0lQUp67+RYlwPaHxIwFJcBmUNIxTiOgBNjaCLi6AoWlVBKP7vZT37BwYRASHI7IEVqv7kPhqPA7J5TMtLRtkHwplQ2Ha6+9lkWLFnHjjTfy9ddfpwyT6s7FihUzfhdyHGwzYObMmbRu3drIpNso7Q1Voo6AEuCoQ57OoJUE+BNADuCJTvfzOLd++d39ui8CLI79BNRzzX0IeMN5eOLSA2kml1IZQaoFygdntOS3335j2LBhfPrpp5w8eTKVWSm4IE8vQxEh1//73woefjh95nyDBoV47rnybNq0hv3799O/f3+KF79QKEtsy00gq6TkqliHQHIy5M0Lx4751/noo/Dyy9bZ9KdpQgk4scPz7rUz4ZKWfu2mJcBNyzRlft/59vupFlIhoARYL4h4QEAJsLVRyqwEuE8f/3UpVq9ebXS/MEOA77zzTt577z3Kly9vZNxJLRS37Nq1i0suuSTlu49sCASSGTNm0KZNGypVqmS0V1KJPgJKgKOPeVqLVhFg2fUV0iriJrtbAelRchy4w+s9fwT4QeBV1/wfAG1SFt71EfUdYF9u7tu3j5EjRzJixAijorPszk71Ux34+PHjSCsk9we4L31jx26mV69pnDp1LtXbZcvmZdq0TuTKddxoz+SWKVOmIOlCkiJUu3ZtcgXrXxse1plzVqNGsGSJ/7W3agUzZtiPzfhCcOo/j51m86FoU792lQDbHxIzFpQAm0FJxziNgBJgayOQWQmwFSnQzz33nEGSixYtauwAXybFJr3EOwVa6rKUKlUqYPCkRVLv3r01BdraSzwkbUqAQ4LLlsFWEGA5hLDcy7v9wJ3AONdrZQB3nqK/FGgZWhFw52KccKVRR2/r0hZ4HVdq6xlgM6uTndjPPvvMKIIlDd19yVtvvcVDDz1knEl58MEHjbQcX7Jo0XY6dpzI/v2pd5bz57+IiRM70qTJhQ/95ORkRKeQahHZBZedZzkrLFWpQ0lNMrPGTDcmWCVoyUnbvVsOQdkLzbe54azXTnTLZVDI9zUmjigBtjccZrUrATaLlI5zEgElwNaiH8ntIJ5ToCMlwO+8845RrCpfvnxGe6OaNaVkTnqR7ziymzthwgSuv/76gMGTdpXSM1iLYFl7jYeiTQlwKGjZM9aKb6jfA21c7gn5bQh490ExS4BFhfTWkQayQpSlKNZ6e5adabQ6ToCDIS3p2RUqVODvvz3Frjp06GAQ4kaNGqUjq5s376dNm/Fs2XKB3LolKSmB0aPb0L37BfIseiXlWlKFduzwpMnKLrMUfkjbQD6Yn/q+FwKffAK33RYYEjkrHKQQR8SYfpUI572ekbX5BfL7/nIgtpQAR4y4JQqUAFsCoyqxGQElwNYCrEWw0uMpvXylkrO/FOgvv/zS2BjIkSOH0ftXvhP5E9k8kIKkobRBkqw8yc5TiT4CSoCjj3lai5ESYCGrkoPorux8KzA6jZFQCLAUwpKCWEKAuwLfOQ9RXHsQ8wRYCjlIqyRf0qBBA4MIS0l/2cV1y549x2jffgIrVuxKN+3991swYEDqlkvS706IsBDic+fO0bRpU6655pq4Dqyjzq9eDbVqBXZh8mS47jr73JSyn/98C+dOQfIpOHcSyvaE7AX92lQCbF84QtGsBDgUtHSsUwj88QfM9yoRIEcuO3XyeDNx00T2HfdUX2pSpgmXF7zcKXfVbowhEGkbpGnTphnffaSOiRzpatnSf30LWfqWLVuM7Dnp8ys7xU2aNPGJyAsvvMCTTz5pjJW2SVonxZkLRwmwM7h7W42UALcGprkUHgQKuao4e9sIhQBPBtq7CLA0G33XeYji2oOYJ8CvvPKK0c9OzrD4k8svvxxp8n7zzTcb1Z5Fjh07Tc+e3zN58p8p0woUuIglS3pSsaKnOIS3zmPHjvHLL78Y6dh58khbati8eTOrVq0y0qMvvfRSTY82c7lLrKQvxZkLFbh9ipTWlBKbMSRKgGMjGEqAYyMO6oUioAjYh0AkBHjx4sW0aNHCILNjx44NmtLsXoV04njggQfInz8/cs7Xe3dXHv7L+4888gjZsmUzOnf4O5ZmHyqq2Y2AEmDnr4VICXA/4AMXYZ0NCCFOK6EQ4C+Ani59j7laKjmPUnx5EBNFsEKBTCoYSjP2d999l4MH5TmKb5Hzu4MHDzaqPQuBPXcumfvu+4F33llN9uwJzJnTlcaNA/e/S6tZbhJ//fWX8bJUVaxbt65xxkZSjlQCICD9B1et8j8gWoWwQgjSO8vfYeD0gSkztAp0COBZOFQJsIVgqipFQBGISQQiIcBCYOW7ULly5fzu5MpRrn795Ct4annxxReNlGohvLLLW716dWODYenSpUi7JDlLLJl30gZJxTkElAA7h73bcqQE+FHgJRdhHQP08rGkUAjwN67UZ0mBFt2vOQ9R3HngaBukSNA6cuQIH3/8sdFGSSoZ+hO5OUjxhnvuuYdChQrxxhsrKVUqD926+S6eFcgnqVYtDeWlHYH0zxORp6Ny05BdYXdvvUjWlSHn9u8PH33kf2myQ3zggIAZM8tXAhwboUhLgKUz2q+/xoZv6oUioAgoAlYgEAkBNlOoU9orSbtJX7Ju3TpjU2Hu3LlGDZTExESDTMuOsBTAKlKkiBVLVB0RIKAEOALwLJoaKQGWNOXhLgI8CfA6IZPiYSgEWNofyeFMIcADgI8tWmdmUhN3O8Bpg+NO+3n11VeNHnn+RJ6AShqPFSJPSNeuXWucFZa2TSJSMGvAALkMVdIhIDfeW24JDMyKFVC3bsyApwQ4NkKhBDg24qBeKAKKgCKgCDiDgBJgZ3D3thopAe4OyM6vEFZhKrV9LMksARZfpIp0Ppc+qeM+xXmI4tqDmD8DHAhdaR8wc+ZMhg4dyoIF0lI6tXz77bd07Sq10gLLc88toU2bctSrd6FRfDCbsvssRFjOHstOsIi0c5IUIukrnDdv3mBqMv77W7ZA+fKB1/n66zB4cMxgoQQ4NkKhBDg24qBeKAKKgCKgCDiDgBJgZ3D3thopAZZSsD+7FJ4DirmqQnvbMEuAmwLzXBOFUBcHdjsPUVx7ENcE2Bt5IZ9SMGvSJEk0wGidtHHjxlTVoX1F6s03f+b+++eRM2c2xo7tQNu2QUibn3AvW7bMIOOSmiTnaurXr0+ZMmUyb9EsqcJcujRs3+7/D6RjR5g40Z4/oPPJF/RmyWpavxJg01DZOlAJsK3wqnJFQBFQBBSBGEdACbDzAYqUAMsKJF/U3XtEzp8+n2ZZZgmwVJN2n8rfBFR2Hp649CDuU6ADoS6N3iU1WloZ3eInBffHH3/kiSeeoHHjuxg6dDvC1UQSErLw3nst6Nfvwq5uKPLHH3+waNEitm7dmjKtcOHCxjlh2SV2V6cORWfcj73pJhgjCSB+RPqGSPPHrOZJqmlMds+HuddC1iRIyAk5S0C7wAdJlQCbRtfWgUqAbYVXlVuEgFyn3jWGqlWDxYs9yq/59BpW7fQUAhzZbiQ3Vb/JIuuqRhFQBDIyAkqAnY+uFQR4JHC7aykngQbAWq+lmSHAdwNvu+YIXdEK0OFfG3FbBCv8Jaee2bZtW6ZPnw7IGdX0z1GeeqohzzxzVVi7t1JFUdKj5bywnFUWkYrRUlgiKSnJqiXEh54PPoDb3X/6flyWnsE1UvdltmRxO6bD/LYeVTlLwvXbAqpWAmwJ8hErUQIcMYSqIAoIfPkl3Hyzx5B8jMnHmVvqfViPlTtWpvw+quMo+tbsGwXP1IQioAjEOwJKgJ2PoBUEWPrO/A7It3/3OV5pZTTLtbxABFjmCNl90jVW5h8CSgNHnIcnLj3I0DvAwSIiRbOkjdEFSXAVFa+Tblr//tV5993mZMsW3u6knAkWW0KGpaJit27dUmzIGeKSJUtm/AbzmzZBpUqBQ/LSSzBkSLCwhf7+tu9gYWfPvDwV4LrfAuoZsXwE90yXun0XRNsghQ67FTOUAFuBouqwGwElwHYjrPoVgcyLgBJg52NvBQGWVTwCvOwqXiU6ZRdXqhZJWyNJkR7vWqq8LpWIKgItXW2TSrmIswyR9/sA0g9YJXIEMswZYLNQ3HXXXYwcKUkJ3iKZ9c3SqejQ4VK++qo9OXMmmlWfbpwU6pL2SfJhJvLff/8xYsQIo1CW9BSuXbs2uXLlClt/TE+U3PJixcBVNdunrw0awNKl1i/jr89gmXxUuCR/TWjzS0A7aQnwNWWvYV4fd9kB611Ujb4RUAKsV0Y8IKAEOB6ipD4qAvGJgBJg5+NmFQGWlUhDst5pSLB7hd52XCcyjbfcr8tr8n9Jg77PeVgyjAeZjgBLO6Mvv/zSqBz922/eO4INASksnnrH98ori/H9950pWDCHJUEXm1Ko6/jx44a+hIQEqlSpYpwVLlGiRFhp15Y4ZpeSPn3gs8/8a8+SBXbsuECUrZTfR8KKuzwaCzeGFoFbYikBtjIA4etSAhw+djozeggoAY4e1mpJEchsCCgBdj7iVhJg0fWUK51ZWIab1Moq/ZFeNwmW930V0HIeofjzIFOnQLvDde7cOcaNG8cLL7zAr7+6iyNVBSQ7P/WOr/SEnzfvJipXDt4myczlcPbsWdavX2+kR//7778pU6SvcOfOQrbdNePMaIvxMePHQ5cugZ386CO47TZrF7LhNVj9sEfnJa3g2hkBbSgBtjYE4WpTAhwucjovmggoAY4m2mpLEchcCCgBdj7eVhJg92qudJFgrwo1KQv1JsXuFyVV+nFgifNwZAgPMn0RLO8oJicnM2XKFIMIr1wpBUvKAVKoJGeqYGfJcoQHHsjHa69Z27dWCLAQYSHhiYmJDB482PhXRIhytmzZ4vuiO3IEChWC06f9r6NDB3C1r7JssWufhl+f86gr1RmuHqcE2DKA7VOkBNg+bFWzdQgoAbYOS9WkCCgCqRFQAuz8FWEHAXavShquNgcaA3LOV7a9pOjVPld/XyG8M4HAvUucxygaHki5Ykkfly1KOUwqubtvAF+GYVx3gH2AJmd1Z8+ezfPPP8+iRVKzrR8gUHkke/ZkZs7sQdOmcrlaK5ISLRWky5UTAg7ij5xVvvjii4306Msuuyx+06PbtIEZAXZfc+SAffsgZ+qHDhEhvOpB2PS6R0W5PtBQTmH4F90BjghxyyYrAbYMSlVkIwJKgG0EV1UrApkcASXAzl8AdhJg51cXPx5I0a+fgUXAAeAG4BWgh6uQWLgryXRngM0AdaFP8GssXCi12FKfTc2bN4ktW/pToIA1Z4L9+bNz504+kDZCLsmfP79RNKtWrVpGW6W4Eik6dpfXeVxfzkuqdKdO1i1r+R3wx/sefRXugnrvKAG2DmHbNCkBtg1aVWwhAkqALQRTVSkCikAqBJQAO39BZEYCLD1xWgD1AUnXLg6ccu28BoqI7MxKPxchpdKmaT8g215y7nm7DaGcBpwAvHq9mLKiO8CmYILZsxfTvfsM9u/PZ8yQek3ffnsdXboIMfbI4cOHjZ6/Vp/dlYrRkh69evVqo5K0iKREV6tWjUaNGlluzyQsoQ/bvh1KBdk1v+46mDw5dN3+Ziy5Gf72SpCo9BDUelUJsHUI26ZJCbBt0KpiCxFQAmwhmKpKEVAElADH2DUQKQFuBzzvtSbZudwaY2tM685EoGOaF4MRYCG/c4GrgJ2AlJst6yLRewEpMfynxeuWFPF1wO0h6tUzwCEAduLEGdq1G8O8eXsZObI5d9zh7iHsUfLkk08yfPhw7r33XuMMb4ECBUKwEHyoVK5et26dQYYlTVqkV69elC8vpwjiROrUgVWr/DubkABClK2qBr2gA/w7xWOv+gtQVUoJ+Je0KdDXlr2WH/r8ECcAZxw3lQBnnFhm5JWMGQM33eRZYY0asHq15/d6H9Zj5Q6pK3FBRnUcRd+aUl9CRRFQBBSBwAjoDrDzV0ikBFjKsA51LWMTUNn5JQX1QHoWy2HEFa6fXSZ2gKXazpOANDSV/sVHXVakYpIclaGaGwAAIABJREFURPwRaOplWRhSMJZ02NUj2ZfD0uD0Q6ABEIBV+Fyr7gAHvQRSDzh3LpkZM7bQrt2l6Wbu37+fsmXLckSKPQF58uThvvvuM4iwpC1bKXIueNu2bWzcuJGWLVumnAleuHChsQNdp04d8uW7sFsdc/Lqq/CI/GkFEBnz0EPWuD6nKeyRPzuX1HkLKt4TULcSYGugj1SLEuBIEdT50UBACXA0UFYbikDmREAJsPNxj5QAPwhI3qFUd57qY2fV+RUG90B8D7QDLCV797gqJtUGfkmjcg1QHajrOscrb6fahfXjwmhXOeK0b8vu9DfAnfJQObj76UYoAQ4DNH9TnnjiCV588cV0b+fNm9cgwvfff7/lRNjbmBDfN954g5MnTxqE+IorrjCKZgkpl99jRnbuvJAGfe6cf5cqVYL16y/kmkcq02vBAa/tmAajobzUkfMvSoAjBd2a+UqArcFRtdiLgBJge/HNTNqPHTtm1PyYPHkyGzZs4MCBA+TKlcu4n7do0YJ+/fpRurScrINnnnmGZ599lqefftr4vz9x3//lwXkgkYf4Ymfv3r1UrFiRTZtkr0rFaQSUADsdAYj0m+jNwGcuAvw14JUw5PziTHoQjABfC0iepKQ4X+ZDp+wMyw7xsy7iK0OkD7L8BJJkQH68pTsgpWzvcP1rcgmphmkKdDio+Zlz55138t57i4F6gNQqS93uR4jwoEGDDCIsFZ2tFmnjJDcsSY/++++/U9QXKlTIIMI1atQge/bsVpsNT5+c850qz8ECyNKl0EASGyKUyZfC0b88Sq6eAKWuD6hUCXCEmFs0XQmwRUCqGlsRUAJsK7yZRvmyZcvo1KkTUvgyZ86cNGjQgKJFi3Lo0CHjvi7EVO7hU6dOpXnz5pYT4L59+/LZZ58ZnSeUAMfOZacE2PlYREqAmwDzXQRY/m3m/JJC9iAYAR4EDAPGAt18aJdz0PKtX84WyxnocKU/8LZrV1geJoQrugMcLnI+5s2b9w+tWo3jzBl5VvEP8DFwPN1ISU0WEixk2K405T179hg3zDVr1hgp0SINGzY00qVjQr77DjoHqdnWvz94Vb8O2+/xheDUf57pzX6AovKsyr8oAQ4bbUsnKgG2FE5VZhMCSoBtAjYTqV27dq1BeE+cOMEjjzyC1BORnV+3yAPuiRMn8vDDDyPZZkJWrdwBnjt3rkGqBwwYYOxAKwGOnYtPCbDzsYiUAGcD5AytnHeVc7HS6/fCN/P4kWAEWPrx3u8iwXLmN63UACQXU87qSoXpcET0Sir53cAkLwWSTypFtsIVbYMULnKS6/7Lbpo2/YYjRzy7vnnznuDwYbkkDvrULAWyhgwZwt13321bOyOpGC0kWMhw9+7dU6pFyxNmSa2SdKesWYMlIEQAjL+pp09DiRIXev76E+kFvHUrFCoUmQNbv4HT++HMYTh9CCrcDrnKBNSpBDgyyK2arQTYKiRVj50IyGkN78L1RYrAbbd5LH66+lN2HpGamBek3eXtqF5UTkOpKAIYO66SoSUFLoXUSkqzP5HdYKn/UbVqVcsIsJDu6tWrk5SUZJDsyy+/XAlwDF2YSoCdD0akBFhWIM035byqEElJ3ZXiTfEkwQiwNGuV3Vk5CPqEj4VJWvTvwG9A6v455lGQ3FZf396lorZUmw4m6/0MqJQ9e/Yscn5UJXQEVqzYSZs23/Hff9KNyiPFi+egZs3lTJ/+uXGT8yUlSpRg5MiRXCdpwTaJ2PY+Bzx27FjjfJGkZUvBrNq1a5M7d26brPtRe//98OabgW0+9RQ8KycGoitv//Q29864N8WoVoGOLv5ua998A93lsIdLqlSBX391xhe1qggoAoqAHQjMmDGDNm3aULJkSbZs2WK0ODQjVu0AP/roo7z66qvMnz/fOF9crlw5JcBmAhClMUqAowR0ADNWEGAphSvteqSfrvTGvRrY6PzSTHsQjAALoe8HvOCqBJ1WcQUX+Y2EAJt21s9AJcCRIuhn/saN/xkp0Nu2XagC7ZaiRXPyzju1+PbbN/lWtrR8yA8//MC11wZOy7XKbSHDcqNbuXIlx49fSNGWXeAqVaoYZ4XlJhyVolnr1kH1ILsgUj1bdoHz5LFq+ab0KAE2BZPtg5QA2w6xGlAEYg4BOesarsiD3Bw5cvicvm/fPr8PooPZkzO53inJwcaH8v4999zDiBEjjKNRUsjSrFhBgCX1Wh6C9+7dm48//tioH6IE2GwEojNOCXB0cA5kxQoCLPobuVJ3JRVaDubdB4xxfnmmPAhGgKORAm3K0TAGaQp0GKClnbJt22FathzHpk3yfMcjF1+cne+/70TevAd46qmnmDBhQsqbUtlx1qxZFlgPTcXZs2eNXWBJj94ufXddUrlyZbp27RqasnBHN2oES6SNdQD53//ggQfCtRDWPCXAYcFm+SQlwJZDqgoVgZhHIJIHsEIk5ViRLylcuDBCgsORYJWWw9HpntO4cWMWL17M559/zs03S71YcxIpAZZzxVIb5K+//jIKaBYsWFAJsDnoozpKCXBU4fZpzAoCLIWwRKSJquQ+yraOkMptwGRX2yBpI5R6Cy342r2afAYfHMGIYAQ4WkWwIliC36lKgC1Cde/e47RuPZ5Vq3an0pgzZzYmTLieli3Lsnz5ch5//HHmzJljENC6daUzVno5evRoVFKTd+zYYfjx66+/0qxZM6MYh4iQ5MOHDyPnlW2RKVOgQ4fAqi+5BLZsgShWsFYCbEu0Q1aqBDhkyHSCIhD3CGQ2AlypUiWDgEoqdKtWrUzHz02AzU5Iewxr+PDhRjHOUaNGGUW1RHQH2Cya0RunBDh6WPuzZAUBlvK4aQ9CuvUGblDmf/0yz9yBicgxDEaAzbZBklZI/qscRO5nOBqUAIeDmp85hw6dokOHCfz4o2dnVYYmJmZlzJh2dOly4Qi4pB9J8QlfIjer+vXrU6RIEaO/cM2aNS300LcqSYmW80dSDENk9erVTJo0icsuu8xIj65QoYK16dHJySDrknToQPL++zBggO3rdxtQAhw1qAMaUgIcG3FQLxSBaCKQ2QiwFKPcvHlz2ARYCmgF+n4wevRoI3zeBFgKaUm2l6Q/y5EotygBjuaVbs6WEmBzONk5ykoCLLp8Ed5wbIieBDsX7qU7GAEW1iA72PmA2q4dbW/X1gDCduoDK6Lks1kzSoDNImVy3IkTZ+jadQrff+/Vg9Y4b5uFDz5oyW23VQuoafz48XTp0iVljFRxfuGFF7j0UkmgiI5IavZS6cfrkvz58xu71bVq1bKucnXaHiK+lla+PGzcCC5ibnr1yWchSwJkCe2jRQmwaYRtHagE2FZ4VbkiEJMIZDYC7EQKtBTdlPu7POSWHWglwDH5p2A4pQTY+diE9g3St7+yA2y1xBIBlrVJAazHATnYKE1Xj7kWLO2LXgcWuYp/WY1DpPqUAEeKoI/5Z86co2/fGYwZk77W27Bh1zJokO9uWJJ6XK1aNSMtylsSExORghnSB1DIaDRk//79Rnq03CjdVcJll1jaMMhNNOI2SmfPQsWK8FfqBwXp1vb66zDYV3exAChseA3WDIGk/JBUAIq3gTpBKk9Lk22tAh2NSyuoDSXAQSHSATGAgLRA8v5ouuIKmDrV49gN39zAut2eLJdXmr9C58pB+qDHwLqcciGzFcEaOHAg77zzTlSLYMlDhosvvthov+Qtco//6aefjAfckoEmMnXq1KgcxXLqeot1u0qAnY+QFQTYrrRfu/qktEtTzflK1871cq9wPA987/X7RYDkk8hYafy30NW2SH6Xol9yuPIP58OZzgMlwDYFJTn5PAMHzmHkSEkASC0LFtxIkyal0r0uxLdp06bs2SMJBelFzuRKUY4777wTIcXRkDNnzhh9CoUM79q1i/Lly9OrV68U02lbLYXk03vvwZ3SIS2ASCXo336DYsXMq179KGx4xTO+9I3Q+Oug89/66S3umyH1+S6ItkEKCpktA5QA2wKrKrUYgbRJLHKqZY3Xx329D+uxcsfKFKujOo6ib80LZy5VFIHp06fTtm3bqLZBCmWX/cCBAwZZVnEGASXAzuDubdUKAuz8KkLzQO5Qo4JMuQX4NM0YqcE/BOgJCLs5AMxwkWkp+BWLogTYxqgIOXziiUW89NJPKVYefLAur77a1O+ZWimAJUUqpD+fFKLyJdKw/rXXXjN2YkO5oUWyVFmLVI2WnV/pYSxy5MgRPvzwQ+NpsqRI58snpwBCEOk/Xa4c7NoVeJIU6hgV7E/SS8Wy2+CvTzwvXH4P1H0rqGNpCfD/lfs/5vaeG3SeDrAWASXA1uKp2uxBQAmwPbhmFq1yT5WMr/Xr1yOFreThtj+R7wJyflfaFkZaBdqXDT0DHHtXnRJg52OSGQmw86hHzwMlwFHA+pVXfuLRRxdy1101GTGimSnSKinIL730Em+99RayC+tLpIfw66+/bpzNdUKkhYNUtBYRIl6xYkWjaJb0EzRNzKX/oZl2R8uWwZWSUGFC5reHHV4JGtWfh6pPBJ2oBDgoRFEZoAQ4KjCrkQgRUAIcIYA63ThiJC2JJAX50UcfNY45efcdFpI8ZcoUHnzwQR577DGjarMS4Mxx4SgBdj7OSoCdj4GdHigBthNdL92zZ/9Ns2ZljGJYociff/5p3BjHjRvnc5oQzT59+hiFstw7s6Hoj2Ss9BOUKpaSHr1FWha5pFChQilFs9yVpf3aOX0aqlW7kOYcSOrVAyHBWbMGd3lGfdjvVW+u/gdwWf+g85QAB4UoKgOUAEcFZjUSIQJKgCMEUKcbCMiD5M6dO7N7925y5sxpEOKiRYty6NAhVq5cabwuZEjO5Eq7QiXAmePCUQLsfJxD+7buvL/qQWgIKAEODS/HRi9atIjBgwcbZNOXlCxZ0mhsH62zwWl9kAIm4tuaNWs4ffq00VZJ/JWiGkFlxgxo0yboMD7+GG69Nfi4SWXh2FbPuCYToWTHoPOUAAeFKCoDlABHBWY1EiECSoAjBFCnpyAgR5/ef/99Y7d3w4YNyPnb3LlzG1lVrVu3pl+/fsZZYRElwJnjwlEC7HyclQA7HwM7PVACbCe6JnX/9tt+hg37meHD/4+kJP/dvWTH9auvvmLIkCHGeSBvefPNN7nvPk8BJ5OmLR926tQpgwRLSleTJk1S9E+bNo2yZcsaN/SEBB9r7NABpkwJ7E/Bghd6B19yif9x58/Dt7ng3AnPmBZLoHDDoGtVAhwUoqgMUAIcFZjVSIQIKAGOEECdrggoAn4RUALs/MWhBNj5GNjpgRJgO9E1oXvLloM0afIN27cfoUOHSxk7tkNAEiwqT5w4wbBhw3j55ZeRJ8cVKlTg119/JWi6sQl/7BiyY8cOo1iWSJ48eahTp47xI0+4U+SPP6BKFZCU6EDSvDnMnOk/FfrMURibJ7WG6/6APMH7KCsBtiP6oetUAhw6Zjoj+ggoAY4+5mpREcgsCCgBdj7SSoCdj4GdHigBthPdILqF9DZp8jVbthxKGXnddUKCryN79mxBPZO2RFI5sl27dnSQHVQfIpWa3cQzqEKbBghJX758OatWreLYsQstsqWadOXKlY2iWaVKlbpQNOuxx+Dll4N78eqr8NBDvscd+QOmVEj9XtfDkJiGFPuYPXzZcAbNHJTyjlaBDh4KO0YoAbYDVdVpNQJKgK1GVPUpAoqAGwElwM5fC1YQ4HM2LOM8EJwh2GA4g6lUAuxgQBct2k7r1uM5dix1led27cozfnwHUyQ4mPuDBg1i7NixSIp0ly5dzFdnDqY4jPfPnj1rnG+Ss8LSUsktPXv2NHaxOXoUKlaEHTsCa8+WDZYsASmMlVZ2L4C513hezZYbul14CBBM0hLgZuWaMaf3hSrXKtFDQAlw9LBWS+EjECoB/rTjp/Sp2Sd8gzpTEVAEMg0CSoCdD7UVBDjZhmUIAfZ/WNIGgxlUpRJghwMrJLhNm/EcPZqaBLdtW47x4zty0UXhP+eRFguSaixnh0VatGjBiBEjkD7CTsvOnTsNIrx161buvvtuY0dYZPfw4RQd5NmF9evnpZfCL79ITnXqIX+PgSU3eV7LWxHabzK1XCXApmCyfZASYNshVgMWIKAE2AIQVYUioAj4REAJsPMXhlUEWAhrKLpkfFrxnq8E2JprQwmwNThGpGXx4n9p3XpcOhLcunVZJky4PiwSLKS3cePGLF26NJVvck74kUceMQppmarQHNHKgk8WP93kV/4//M03afHJJ1Rdvz745N69YfTo1OM2vAarH/a8VrQZNDO3i6sEODjk0RihBDgaKKuNSBFQAhwpgjpfEVAE/CGgBNj5ayMU0urP2/mAL0Lrb7zs7OYHpGrNRa5BMv8gsNZr0rXOwxP3HigBjpEQLlkiJHg8R46kLgLVsmVZJk7sSI4ciSF5evDgQbp3785MKRjlQ8qVK2fsBrdt2zYkvXYOlrPCkydP5p+1a7njvfe4+JDnbLRfu198ATd57fj+PAg2D/cML9cbGqYhyX6UKQG2M7rmdSsBNo+VjnQOASXAzmGvlhWBjI6AEmDnI2wFAQ53FUlAc+Ax4CoXiX4JeDJchTovHQJKgGPooli2bAetWo3j8OHUJLhFizJMmnR9yCT4/PnzjB8/HjkH/O+///pc6fXXX28Q4RIlSsQMEvv37+eP0aOp+8ADZJW2RoHkootg7ly4Sj4igIVdYds4z4zKQ6CmfGwEFyXAwTGKxgglwNFAWW1EioAS4EgR1PmKgCLgDwElwM5fG04SYPfqxYfXgMEuEjwUeNx5aOLWg4sB+RHZnJSUlCS9W1ViA4GfftpJy5Zj05HgVq3KGiTYTHXotCuRStDPPfec0Trp3Ln0Neny5cvH8OHD6d27t6NFstL6fe7pp0l47rnggSlQ4EJRLCmgNesq2OeV9l13BFx+d3AdgBJgUzDZPkgJsO0QqwELEFACbAGIqkIRUAR8IqAE2PkLIxYIsBuFScB1LhIsO8PznIcnLj14Bnja7XlCQgJSnVcldhBYvlxI8DgOHUr9YEJaJI0bF7xPsL+VSK/gO++8k0WLFvkc0r59ez744AMuueSS2ABDyPq118LChcH9KVsW5Lxz0k44vAmO/gXHtkD5W6Gwa3c4iBYlwMFhjsYIJcDRQFltRIrAqlUgJzDcUrw4PPig5/dhS4ex7fC2lBd6VO1BvRI+KtdH6ojOVwQUgQyHgBJg50MaSwS4EiCVcSQnUs4VN3Menrj0QHeA4yBsK1fuokWLsRw8mJoEd+5cga+/vo5s2S5UTQ5VJC36s88+46GHHmLv3r3ppufPn5+3334baU1k9OZ1Wv75B2rUgINSAiCwnKpShaSlS8mStjJ0sImu99MS4OblmzO712yTs3WYVQikJcBVq8K6dVZpVz2KgCKgCCgCikBsI6AE2Pn4xMA34FQgbACuAKSvSznA83jVeazi0QM9AxzDUZOd4ObNx6YqjNWwYXFmzuxCnjxyRD58kXO2cjb4888/T6ekY8eOTJgwITYIsHg3fjx06WJqsVsrVeLgZ59Ro25dU+O9BykBDhkyWyYoAbYFVlWqCCgCioAiECcIKAF2PlCxRoAnAB1du8Bdge+chyiuPVACHOPhkxZJUhjr2LEzNG1akilTOkVMfr2XPGnSJAYMGMCePXuMlwsUKMD69espVqxYbCHzxBPw4oumfNrZpg2XfP89ZMmC7Hib3clWAmwKXtsHKQG2HWI1oAgoAoqAIhDDCCgBdj44sUaA5cRNTxcBHgS87TxEce2BEuA4CN/8+f8wbNjPfPVVe3LmDK0dkpnl7du3j3vuuYevv/6ar776ymifFHMi1aD79oXPPjPn2sMPw9ChbNq8mWXLllGvXj2uuOIK5My7P1ECbA5au0cpAbYbYdWvCCgCioAiEMsIKAF2PjqxRoDnAtL/V84BDwFedR6iuPZACXBch89a5xcvXsxVV13ld8f0+PHj5MyZ01qjoWg7fRratYM5c8zNuvNOvmjQgD+3bDHG586dmzp16hg/eXycE1YCbA5Wu0cpAbYbYdWvCCgCsYTAsWPHjAKUkydPZsOGDRw4cIBcuXIZD21btGhBv379KF26dDqXp02bxieffMLSpUuRB9l58+alSpUqdOvWjf79+5OYaP0D81jCLSP7ogTY+ejGEgGW4k07gOwuWPoDnzgPUVx7oAQ4rsN3wfnk5PNkzWrvn+rRo0e58soradu2LS+99JJzN9bDh6FpU1i92lTkznTpwuIBA1i5Zg3yJUMka9asVKpUydgVli8V7hRpJcCmILV9kBJg2yFWA4qAIhAjCEiGUqdOndi5c6fxgLlBgwYULVqUQ4cOsWLFCqNYZfbs2Zk6dSrNm0sDFDh58iS9evVi3Lhxxv1L7s1ly5ZFanssXLiQEydOULlyZYQglylTJkZWqm6EgoAS4FDQsmesvd+qQ/P5Y+AW1xTZAb4SWBmaCh2dBgElwHF+SZw8eZYePabStGkpBg2qY8tq5BztTTfdZKRHi1x99dVGunRx6fvhhOzYAQ0bglSINiNt23Lu66/ZuHUry5cvZ9u2C7XzxH95Su6WN5e9yf0z70/5XatAmwHX+jFKgK3HVDVaj8CsWfB0SkNBuPTS1G2Rbp10Kxv3bUwx/GSTJ2lboa31jqjGuEVg7dq1BuEVwvrII4/w5JNPGju/bklOTmbixIk8/PDDPPHEE/SVY0BgEGYpVFm9enXjXiwPdN1y8OBB7rjjDr755huDFK9evZp8+fLFLUaZ1XElwM5HPhYIsPxlvwBc74JDfNoJlHAenrj3QAlwHIfw8OFTXH/9RObNu0DoRo9uQ+/eVSxf0bvvvsvdd9+dSq88oZYb7zXXXGO5PVMKN2yARo1MtUcy9DVuDFOmwMUXs2vXLuPJunw5qFatmvG2PFEf9vUwXt/6Ov/xn/GaEmBTkbB8kBJgyyFVhTYgIM8De0pFEpfIR8natZ7f631Yj5U7PM/oP+34KX1q9rHBE1UZjwjIg+UaNWqwbt06nnnmGZ72fpqSZkGyGywPbqtWrWrcd3v06GEUqpS5hQoVSrd8Ic6tW7dm9uzZBhkeOXJkPEKUqX1WAux8+K0gwOGkKWcDJOW5sqvdkSDh9kV2f+8B3nUenrj3QAlwnIbw1KmzNG78FStX7k5ZQUJCFiZMuJ7rrrvU0lV9+OGHDBw4kNNyBtdLJJX4xRdfNJ5Oy/+jLgsXQosWcCp1r2S/ftSsCTNmQNGi6YZIGtrMmTON1//kT5aznFLlSjG7t/YBjnZclQBHG3G1Fw4CSoDDQU3nuBGYMWMGbdq0oWTJkmzZsoVs2eRrb3CpX7++8QBXHkzfeeedfids3LjRSIMWIvXvv/8aHR5U4gcBJcDOx8oKAiw9e4W0hiPepFfmy+/S+shcU9BwLGauOUqA4zjeQ4f+xJAhC1Ot4KKLsjFzZmeaNCll6crkhtu1a1e2bt2aTm+HDh349NNPyZ8/v6U2TSmbOvVCj2CzJLhCBZg9G9Kci5J1ffH9F5zZe4YsrmdtJ7OdpF3TdtSuXdvZ4l+mgMg4g5QAZ5xYZuSVKAHOyNG1f23SeWHEiBHcf//9vPHGG6YMSqGrwoULG+d+//vvv6D33Fq1ahkp0HJWuHPnzqZs6KDYQEAJsPNxcJoAu0mv/CtE+nXgCeCM89BkCA+UAMdxGCWF6qGHFvD666mPwufNm8SCBd2pWbOIpauTG64U3pg+fXo6veXKlWP8+PHIDTfqMn8+tG8Dx06aMy09joVlNWmSarycAX525rPUox61qEVOLlS8TkpKYvDgwUYhEhX7EVACbD/GaiFyBJQAR46ht4a9x/aGrTB3Um5yJObwOX/f8X1GP/hwJGdiTnIlec7khqPD35zGjRsjnRc+//xzbr75ZlOq58yZY1SFvvTSS/njjz+CzpHq0R9//LFxfvj5558POl4HxA4CSoCdj4VVBDjclZwApNyrtD+SVOq/w1Wk81IQkNRy+RHZnJSUlHTK7O6ZghhzCMiN/bbbZjJq1K+pfCtSJCeLFvWgQgVrd2XlbJFUgX7qqafSfakQgihpWbfeemv0cRrdDQaOhaMmTUs/4FdegcGDIcuFjznvIljZyEa3wt1omq2p8ZRddr/dIl885Pyw2ZQ1kx7pMBcCSoD1UogHBJQAWxulLM+G/3VzRJsR3F0/dZ0Kt3eFXyuMkOBw5OmmT/PMNc+EMzXoHClctWnTJiQVulWrVkHHywApbNW9e3caNmzIkiVLgs4ZMmQIQ4cO1XPAQZGKvQFKgJ2PSfifSB7fw6nBfhY4DBxxHoIM54F8mqfUrkxISODsWYFbJV4ROHs2ma5dJzNxYuonwuXK5WPp0p4ULWr9E2x5Et2zZ0+jRUNakTPBL7/8cnTPBf/QAn6eA0OB/SFEslMn+OQTyJcvFQEWDVIEa9bNszhz5oyxCywiu+CStpYjRw4jNbpu3bpcfLH7eVIIdnWoXwSUAOvFEQ8IKAG2NkqZjQBLj9/NmzeHRIDdBbCkcrT0/g0mjz76KK+88opxVlgeTqvEDwJKgJ2PlRUE2PlVqAfeCOgOcAa8HqQdUps245k//0JFaLfUrl2U+fNvJE+eCwTOStm+fTs33nijzyfR0qZBUrukr2FUZEIJOLEDhI8LCd4VglU5Fzx+PMOOzmHwrMEpE31Vgf7rr7+YPHmy0aPRLZdffjlSmKR8+fIpPYVDsK5D0yDw9dfQo4fnxapVYd06hUkRiC0EghHguh/U5eedP6c4rVWgA8cvsxHgSFKg5V7z559/Bv2DuO222/jkk080BTooUrE3QAmw8zFRAux8DOz0QM8A24lulHVLW6Rrr/2WVas8laHFhVatyjJlyg0kJiZY7pHsjsqO75tvvplOt1SOfvvtty23mU7hqf0wvqDnZeGmI6+AdZvM286RgxkP3kCbhDEpc1qUb8GsXrMr48RuAAAgAElEQVTS6ZA08N9++82oxCmE2C1SZVPS06RIiUr4CCgBDh87nRk9BJQAW4t1ZiPAcn985513QiqCJRlXRYoUMV0Eq2bNmqxZs0aLYFl7qUZFmxLgqMAc0IgSYOdjYKcHSoDtRNcB3bt3H6NhwzFs2eLZoRQ3eveuzKeftrFth1KeMt9+++0p6fQVKlQwUrQKFvQipnbhsWchzPEqaJU1CVr9Cx07gbRKCkFG1oVBreF0NvBHgL3VSVVOIcLyJUNaQUlFz8TERGOI9BaWm5hKaAgoAQ4NLx3tDAJKgK3FPbMVwZJikm3btg25DZIcu/n555+DtkHasGEDVapUMYo3ShukqNyLrb0kMrU2JcDOh18JsPMxsNMDJcB2ouuQ7t9/P8BVV41h3z6pIeeRxx67khdfvNo2r+bOnWu0WpBz5dJXV0hwVOT392CFVz/Ei6tB27Vw/Dj06QPjxoXkxori0K0rVKjjewfYlzLpkbxnzx7jy4yIFCeTM1eSAl6vXj2k4IngohIcASXAwTHSEc4joATY+RjEswdyj6hWrRrr16/nmWee4emnU0qzpFvW4cOH2bZtm0Fox4wZw0033USxYsVYt24dhQoVSjdespSkx/CsWbMYMGAA77//fjxDlSl9VwLsfNidJMB1gHLAKWAjELzmu/N4xZsHSoDjLWIm/f3pp51ce+03nDjhKXBWoMBFbNhwiy1Fsdxubdy4kf3799OoUSOTnlowbMVA+P0dj6IyPaCRK5VZ2l8MGwYPPwznzpk2djQRRne/grulunYYxHX37t188MEHyBcRkdy5cxtFs+rUqUPevHlN+5EZByoBzoxRj781KwGOv5jFmsfSo1cqOku2kBSsknZFuXJ5ilYKSZ4yZQoPPvggjz32GH379jWW0LFjR6MWRY0aNfjqq6+MB6xuOXjwoFH0SgpmlS5d2shO0kKNsRb54P4oAQ6Okd0jrCDAkgNY3MvRrUCgb6IdgLeAUmkWJyXvBgAb7F50JtKvBDgDB3vq1D/p2HEiycnnKVMmLzNmdOaKK6KQkhwAU3c/xiyu1kOWwD/nGtizwKOqxotQ5bHUqiUV+sYbYefO0Ew2bAgffwxeXzDMKjhy5IiRqiY/R49e6M8k65YvK02aNKFo0aJmVWWqcUqAM1W443axSoDjNnQx5bj0ApbMKXloKhlDQojl3iCFFleuXGm8LmRo6tSpNGvWzPD9xIkTRheGiRMnGkdvrrzySqM1nzx8XrhwIcePH0eqTE+bNo1y5WQfSSXeEFAC7HzErCDAjwPPuZayHSgrGYJ+ltYNkK0bsevL9jHgGsBTWtF5jOLNA60CHW8Ri8DfDz9cy7vvrmbatE5ccknuCDRFPlV2Q++9917jhj18+HBrziPLDu93ReCUV5/HJhOhZMf0Du/aBd27wwIvsmxmWdIC6ckn4ZFHwHW+18w095hz584hO+NyVviff/4xXu7du7d+MfEDohLgUK4uHesUAkqAnUI+49mVB6SSpiy7vXJ298CBA0bWUMWKFWndujX9+vVLOV7jvXohxVJ/Q44cST2KPHnyGGnS3bp1M1Kf3e37Mh5iGX9FSoCdj7EVBHgFIOnMQnqf9SLDaVeXH5CSqvm8CLLbvpswy+/S56Wi1JhxHp649ED7AMdl2MJ3+vTpcyQlOXv+VMivpGVJWrDI4MGD+d///hc5CT65ByaWhOQzHoCu+wPyXOobMOl5/cQT8MoroQNavfqF3eC6dUOf65ohT/PlzNe1116bsvb58+cbT/TlrLCv81xhG4vTiUqA4zRwmczttAQ4bbsubYOUyS4IXa4iYCECSoAtBDNMVZES4Bz8P3vXAeZE1UUPLCzSQTpKld4VpEqV3rsgiBRRrIB0BAHpVVCkShf4aVKkd1g6Su9FRaVXQfou/N+ZZDLZsLtpM5lkc6/ffrLJe/fdd95sMmduA+4CiGtd/00AB6Kx5WsAJGcku1z3IoCfATCJsSGALNZ5fL8XgBEe7inYp4kHONivABP2zwrRKvlVl2fO05AhQ7wnwRGPgX+PA7cOAHeOAEXHAnHUj5xoNrtsmaVA1l1+PLkhceMCXboA/fsDOvQ4ZhupMWPGKDlgFPZ3JBFmb2F6yoNRhAAH46kH3p537wZ+sCs9wPp3w9iD3Cp9N/fFH3f+sP3+UdGPUDaLcUUIAw9BsVgQEASiQ0AIsPnXhrcEuDiAPdZtMAkupuovZwDQbcM1TwMoCUDt5cLYzU0ASKApbPCZz3x4At4CyQEO+CP0bgMbNvyJt9/Ogrhxvf1Tj9mOBQsWKDlLalEo201i37745hs1Q8K7vbg9+9w5oFEj4MgRt6ciRw5g6lSgAjMyPBfmRLOX8L59+5TewqokT55cKZjFwln2RVE8XylwZgoBDpyzEksFAUFAEBAE9EdACLD+mLqr0du74ncAzLd6dRkKTVIbleSxFrdSQ52bAVjkMNCeTHMcc4kZDi3iOQJCgD3HLqBnRkQ8Q69eYRg5cj969iyOoUPt+ugatLOffvpJyX1VC2Gpy5AA92WOrRnCVkkdOwI//ujZ6u3bA4MGAWnTejbfbhard7LoyYEDB5SQaErJkiVRrVo1r3UHkgIhwIF0WmKrICAICAKCgN4ICAHWG1H39XlLgL8AMNZKgFcAaBCNCe0BqI3K7gFgqVqtf4s2iRVk2GiTBJjVole5vyWZYYeAEOAgvBz+++8JWrZcjeXLtc5iM2ZUR+vWBQxHY+bMmWjTps0L6wwbNgw9WGTKLNm4Ef+2aorkl2+7b0HSpJYCWZ076xIWHR4ejmPHjilkuEGDBkiVylK5++LFi7h+/bpS5CS+B8W43N+YOTOEAJuDu6wqCAgCgoAg4B8ICAE2/xy8JcA9AQyxEta5LH4azZZmWt8jsV1uzfmNauhqANWt+j4DMNF8iALaAiHAAX18nhm/a9dFlC+/AOHhlh61lPjx42LjxiYoV86x+5hna8Q0a+rUqUqFSkf59ttv0alTJ/0XdFHjuE1D8KzPV+i4Ryta4OJUy7BXXgEGDmSJZ496Bztba+HChUo16YQJE+L1119HsWLFkDIlawfGLhECHLvOU3YjCAgCgoAg4B4CQoDdw8uI0d4SYBarGmwlrAsBNI/GSCa/5bCO6wrg22jGzQHQwjqOjT49KOVqBEwBpVOKYAXUcRljLNsjffjh+kjK06RJiAMHWuHVV5Mas6id1gkTJuDTTz+NtA575K5fvx6VK1c2fP2oFhi9azS6buiKEn8D01YA+a97aEbBgsDIkYDOocu7du1ScoXZH1IVFsti0azXXnvN+2JiHm5X72lCgPVGVPQJAoKAICAIBBICQoDNPy1vCTC9tN9ZCSubb1aKYkvpAVyyvk4PcGkAe6PZOvOJmVfMcewvbFdz0XywAsQCaYMUIAdltJldumzBmDGRW2oXL54e27c3Q4IE8YxeXukF7OjxTZs2LQ4dOoQMGTI4X/+vRcCDi0Dq0kDKIkBIqPM5MYwYtWsUum3opowIDQemHXsNLVdeANg6yROpUgUYMQIoUsST2VHOYRGxs2fPKj2Fz58/bxuTM2dOpchYbBBn7WViwx5lD4KAICAICAKCQHQICAE2/9rwlgAz53eJdRs3AaSJYkttAagVaNgLhH2A7Zp6RpqxBgArwpAAM1bye/MhCjgLxAMccEdmjMEshFWnzlKsWaO16uBKH31UGJMmVTFmUQetgwYNeqEAVvny5bFx40bEi+eEhG+uAlzZaNEY8hJQZCSQm8/cPBN7AkwN1XNUx5pCI4B27YD9rOHngcSJA7z3nqVQViZ9w8tv3rypEGE+MGBf4RIlSigGsrUS30ufns8WA08cCTAd6p4U6g68nYvFgYRAWJgl0EOVLFmA7+3uSL5c9yXO3dLqLHQq2QmVskXlAwikXYutgoAg4AsEhAD7AuWY1/CWALOt0VnrEiStNQGsc1gyDEAZK6nlv2PqK8L2SDmtY6OqFG0+YoFlgeQAB9Z56W7t7duPUKzYHPz+uxZWy0WmTauGtm0L6r6eo0J6NOvWrYtVqyLXs+vTpw8GMp82OnkWDixOCYSzu5pVyv4MZIquzp7zrURJgFusASIigHHjgD59AGt1ZufaHEa89BLA/OaePYHkfMannzx58kQJf1YLY5EQL1++HJkyZVLCo/Ply4eQkBD9FjRYkxBggwEW9bogsGAB0Ix3IVYpUAA4elT7vdiUYvjtshZhM6v+LLQqHF0ZFF1MEiWCgCAQSxAQAmz+QXpLgLkDklbm91IXXU1M8FNdTl0AqM9QSZBjyv9lL2DepVMPx7In8AHzIQpoC4QAB/Tx6WP8kSPXUbLkXDx8qIX6JkgQgh07mqNYMeO9iPRWsqjT339rXc1I6FjwKXfu3FFv8vYhYM3rkd9rcAVImM5jUKIlwKpGhhx//DGwYYPHa4AVnbt1s+hJFlNbdM+X2LJlC3bs2GHrucw+wuwpzJ9kBq3pubUvzhQCrCeaossoBIQAG4Ws6BUEBAEhwOZfA3oQYCbVsVgVSSv1Mbz5MAA2zlRjAvk6G1+yt290pWdqA2ArJQp18O7xsfkQBbQFQoAD+vj0M37u3BNKayR7yZw5KX777T2kTp1Iv4Wi0bR7926UK1cObAGUPHlyzJgxQ2kBFK2cmQD8aldEK8lrQF0t3NATg50SYCp9/hxYt85CYo8d82QZyxx6gT/7zNKDOE1UmSGeq+bMe/fuKf2E2Urpv/8sXnI+VMibNy8aNmzo1x5hIcDenb3M9g0CQoB9g7OsIggEIwJCgM0/dT0IMCvTHAKgunJUD66qm8SYwnZJfWPY8jQAbCDK8YwrKm4+PAFpgeQAB+SxGW90x46b8d13kYMqKlfOgrVrGyEkJK7hBowaNQoLFiwA2/1ky5Yt5vV2tgAuzNPGZH0PKD3bKxtdIsDqCgyLnjUL6NsXuKTW8PNg+YQJgQ8+ALp2BTJn9kBBzFMiIiJw6tQpJVf4woULyJ49O95jTrJV+L6/hUcLAdb9MhCFBiAgBNgAUEWlICAIKAgIATb/QtCDAHMX9PSuBZDXbkuqR5gvsVAWqztrjUkj753hz/8AUPuzjADAFksi7iMgVaDdxywoZjx9GoFKlRZix46LkfY7aNBb+OqrkoZj8Pz5c6WAU2ioC9Wcl2cF7l/QbHpzIpCzg1c2ukWA1ZXu3wfGjgWGDQOsnlaPjGDBrxYtgB49gLz2H5MeaYty0tWrV5WwaLXCNr3EEydORIECBZRc4TQGeKI9sV4IsCeoyRxfIyAE2NeIy3qCQPAgIATY/LPWiwBzJ/EBsOJzXQBZrFs7BYBunJ+dbFVtp6QOKwdgh/nwBKQF4gEOyGPzjdGXL/+HokXn4PLl+7YF48WLi3Pn2iFLFn2LN3m8o//+AFZkjzy95hEghXdFu0buHInuG7vb9CpVoFkEyxW5dg0YMACYPNlSNMtTYdVohn736gUUK+apFpfmMeycfZdVodedRJh513HjGu/xj85IIcAuHZ8MMhkBRwKcP3/krAgpgmXyAcnygkAAIyAE2PzD05MAe7ObhGzNaacgcslabzQH91zJAQ7u849y9zt2/IPy5Rfg2bPnSJMmIWbNqoEaNRwIp5m4nfsR2NdesyBBGqDhFSCOd6TNkQDXyFEDq1tEzot2uu3Tpy2VnpctczrU6YDKlS1EuGJFJvA6He7uAHrc//jjD+zbtw9nzpwBf6ewUBYLZhUvXlwJw/K1CAH2NeKynicICAH2BDWZExUC9+/fx5QpU7BixQqcOHECt2/fBosX5smTB1WqVMEHH3yAzFGkyKxevRrTp08HH2beuHFD+ezOnz8/mjZtivbt29s6A9ivyUiglStXKj/Hjx9Xik8mSJAAhQsXRtu2bdGqVSulXoSIuQgIATYXf64ufwXmn4HeFogHWG9EY6G+gQN3Y/v2fzB7dg1kyMAMBHPl999/V/raJkqUCNj5LnBhvmZQ5qbAWwu8NlAXAqxasWOHJa93716v7ULx4kDv3kCdOoBBntk7d+7gt99+UwpnPXjwQOnB/OWXXyIhc5R9LEKAfQy4LOcRAkKAPYJNJjkgsGfPHqUw4eXLl5Xvt5IlSyJdunT4999/ldoN169fVwgqCWtlPhQF8OjRI6WWw+LFixWyyh7wWbNmxa1btxAWFoaHDx8q7e9IkLOwQbWdtGzZEnPnzlXIMSN+SKz/+ecf7Nq1S0mRady4Mf73v//5XW2IYLtwhACbf+JCgM0/A70tkBxgvRGNhfoiIp4pX6xx45r7EcAv5kGDBmHatGkYMmQIupFULs0APLqqoV58MpDjQ69PQVcCTGvoUV28GPjqK+Cs2g7dCzPz5AE+/RRgESudewmrVrEKN70CrBxdpgzbs1uEfYV5o8R8YbXfsBc7iXGqEGCjkBW9eiIgBFhPNINT15EjRxTCS8Lao0cP9O3bV/H8qkJCumzZMnTv3h19+vRB69atlbdImJcuXYpChQopZJXV/VXhw8wOHTooBSVJitkXnp0VVOnYsSNeeeUVxav88ssv214n2SbBvnv3LiZPnowPP/T+OzU4T1WfXQsB1gdHb7SYe/frjeUyNzoExAMs10ZAIEDS++mnn+LxY0u3M35ZXziyGkm2ORTkqnMWSMpW496JIwGumbMmVr27yjulnM2c4CVLgKFDgUMsiO+l8AaJBbM++QQoXNhLZc6nX7p0CVOnTlUG8kuZPZuLFSsW6ebJuRbXRwgBdh0rGWkeAkKAzcM+NqzMlBOGHR89ehT9+/dHv379ot0WvcEMVeYDSBLe5s2bKxFRnJs6deoX5pE4V69eHRs2bFDIMIsduiJDhw5F7969UaFCBbCfvIh5CAgBNg97dWWzCHBOa7Es9kLh3e9Ja6Xo2+ZDYooFLPrVBUARAOyVMgAAPbneiuQAe4ugzDcMAfawZYiWvaz+tjpqpGVBeaskygzU+1OXHFnDCLBqKz3Ca9daiHBYmD64lS5tIcKNGwMJEuij00ELvRNqT2F6F1TJmTOncj45cuTQNWdMCLAhxyhKdUZACLDOgAaZurVr16JGjRp49dVXlVoMTDtxRVibgd7aCRMm4OOPP452ysmTJ5UwaBKpixcvuvTAkiHTtWrVQq5cuXCa9SxETENACLBp0NsW1oMAZwVQyW4rPwF4Es3WuN5IAB0BOFa0YVnaLwDMNB8Wn1tQE0BZaz/lsQAme0GAxQPs8+OLXQsuWHAK58/fQe/exrdGatCggRICpsrqHvFRo9BTDdDsrYGSM3QBeMTOEeixsYdNl24e4Kis27nTQoRX6eBhpn56Adq1Az76CHDWQ9lDtOhVOHfunHLzxf+r0qxZM6VytF4yb57Fwa1KwYLAkSN6aRc9goA+CAgB1gdHm5ZH1z1XGC8JEC+aegWPbjAfxTPd8RIB8bSQZM+URD3r888/x/jx49G5c2eMGTPGJdUsdMV2dUxPunnzJlKmTBnjPEbrMASaucKNGjVyugbtoV3lypXDtm3bnI6XAcYhIATYOGxd1awHASZh+9y64G8Aisew+FAA2h2o9qml2sFPsQ8A6HPHG7UhRQFUsdpZAkBGqxfaWTlUvs/exM2tXtpb1t7HX1t7GLuKubNxf1ofAnjqAZYcYGcIy/tRInD9+gN8+ulGLFp0RskN3rGjOUqV4p+HcXLs2DEUJANiGfh4wM3JQBL7v8RSc4BsLXUxwJEA18pZCyvfXamL7miVkNmxhzDvpp9F1wbdDRNYvbNmTYCegerVgZAQNya7PpQ3X/TQszjZRx99ZGubxGrSSZMmtfUadl2jNtKRABcqBBw+7IkmmSMIGIfAwoXAO+9o+qUNkpdYz/PidrPYeCDXp1EbsCQN8Jgk2AMp0A8o5OmtVszrvfXWW9i5cyfmzJkDFqZyRTZu3KhUhX7ttdciPYSMbi7zfJlKxPzhgQMHxrjE06dPlZBseo5Hjx6tFEEUMQ8BIcDmYa+u7MUnks14Vn95zfoIjv18o0tGyAXghF3lace1SX752gMAdDdcNAgeupvqOehmGHZMBJjvbQJQGsBlAIxvpOebZJ+PNUsBOK+Tvd4SYPEA63QQwaTm0aNw5Mo1DX//fc+27Zw5U+LQoVZIlIgtvo2TN954AwcPHkSC+MA7JYHOTXOhSLqrwNO7QMOrwEtpdFncFAKsWk6P6siRwMyZwJPoAmTc3GbWrECHDkDbtkAafTBytIB5bGrLDHqIx44di3v37iFTpkxKeDRD8ELcJOFCgN08ZxluCgJCgHWGPcgIMAtXnTp1CgyFrlatmktgsrAVI25KlSqlVG12Jr169cKwYcNcygPu2bMnhg8fDvaD54NnpeOCiGkICAE2DXrbwt4SYGbnX7NqI4FlM9EL0WxrEgCWnVNjVRgbSE9vOID3WfjO7r3x1jBpIxCiB5p/+futP1dc8AB/A6AvgN0AqgL4z2oYH6GNBrAdQHk7Y1l6Tyu/F/Uu7tphZz/CWwJsr0tygI24gmKpzuHD96Jnz8i5qx07voGxY+0zHPTfPAuEDBjAtHeL8On32dMnEOffY8DLb+i2oKkEWN3FpUsAw+EmTQLuM+tDBwkNBZo2tXiFS5XSJV86KqvYPmnNmjVKH0uSYQormvIBBvsK21cijWlXQoB1OHNRYTgCjBAdMkRbht1mpkzRfv9s9Wc4e0ur/t6tdDdUzm5pYyMSBQJBRoDZ45d5tu4QYLUAFitHs/evM1FJLXOFmTMcncyfPx8tWrRQ2i2x+BX1i5iLgBBgc/Hn6t4SYJI+tZQciXD6aLbEOD0STZUUrgdQw2HsbABqnAh7oDD20sPEDreA5RoxeYDp/uLe6Fnl3fhBB+0M3isEoBgAhoBTIoUhR2PNLACWmveRxVsCLB5gt45fBqsIhIc/w1tvzcfevQxy0GTr1ndQvnwmw4Ci95ckyl7YqofeRT3FLwiwuqFbt4Dx44HvvwdueBi+FxU4xKxVK0uS7auv6gmfTRdbKLGnMH/oDabQS8yCL45FzaIyQAiwIcciSgUB/0YgyAiwNyHQ2bNnx/nzzoMK27Vrh+nTp8cYAs1K0bVr10ZERISSK1y/fn3/vk6CxDohwOYftLcEuJU1X5Ukkl7QitFsibm26uMsjmXV450OY3mHTfJHmziGiYEMmTZanBFg7mmzNcQ5ql4s9AzTQ2xfuZkFvhyLfDnugy6UqJICvSXAkgNs9BUTi/WfPn0LRYrMBkOiVcmWLTmOHHkfSZKEGrJzhtmyBy17AqvCdg18uq2n+BUBVjfGFlDsJcw2FiycpZcwV/jtty1kuEEDIEkSvTTb9PCGih4OFs36888/lb6SGTJkUN4nSWY/YXocHEUIsO5HIQoFAf9HIMiKYH322Wf44Ycf3CqCdf36daRNm9blIlhFihTB4cOHoy2CtXfvXrz99ttg9A5zhdu0aeP/10mQWCgE2PyD9pYAd7aGAJNELgXQOJotdQUwwvreJQDRuSaOAaDbh/pYbGqhDyByRoA7AfgWwCIATaOwpxYAVtJhbnEDHez1lgCLB1iHQwhmFd9++yu+/HJrJAg6dCiMiRNZO84YYT9g+xAuV3Og3LFGLwJMwq6Kmh/L1+xft/83x3Jc3LiWZ2IMH+aP4xhWgoo7eTLizp+POHqFR/PDNHFihNerB7z3HuJXqaIUziJ5ZfsjRxvU30lcVfLKsSS00Y3lFzl1sY8zx7Kn5YoVK3DhwgUlnL1ixYp45ZVXbJgJAXbnqpWxgoAgEIgIMF2kZs2abrdBYg92Rtc4a4PEVJT8+fMrn9Nsg5QqVapIMDGKitWeb926pVShZjVqEf9BQAiw+WfhLQHuDWCQlbCy/RFzeaOSnwEw7oJ3jgz9bevCOBLP730AkTMCzPr1/OQgCY6qbF5ha/uiAwBYYdoToXtG9S6vBrACAHOmWS3HFS/48WgWzRsvXrw4P//8c6SbV/aAY34KhSGMmzfTwW0Rx5tc9gBlc3YKnyKuW7cu2hthhu2wLD/l8ePH+OWXX6LUyRezZMkC9rujhIeHY8mSJdHawD56DCdShfks0d2MZ8yYUbnhVoU5NdT/AtkAlCet9sUpWIDi0aNHUdrML5c6derY9C5atOgFUqCukSJFikgtCbi327dvR2lDkiRJlKb3qixduhTXrqlp9ZHPgx+YrVtrUfPLly/HpUuXosSCPQdZvVcVngUJSVQ4cAyfVqtkbtWq1QgLO2TzAtOZSEmXLhFeeikeSFbp3aPweuAXcXTnwdwktdgGK1yyZUNUNjx58gQjR45UyBOFZ1i1alWbTY5zGPrFdhGUsLAw7NixI1ob+NSb18XwHcOxfNNyvI23lXlxERfx4kbuzfjee+8hK4tLsUDA/v1g38TohOfGvyUK98XziE4aN26s3KxQeGPCULTopH7FiijM6tH0Cp9w5c8/WlUvvsGw6JYtcbVaNUyKoQ0Gb5zUvyN6JWLKL+PDCp4VhX2Ex40b98K6HTp0QLp06ZTXhQC7cV4yVBAQBAISAX5nscMBP+9Z56Jfv37R7uPu3bv4+++/le+IefPmKfm66dOnx9GjR5GaLfAchA9QmXKyfv16JfJm8mR2ztSEETllypRR7g+crR2Q4MYCo4UAm3+I3hLg7gCGWYktGUxUHlLukvm/aa3j2gOYHs3W1TxgktI+ANg2yWhxRoBZ9oI2D7ba5GgPiSsrYZyxVq/2xN4KdrnU9vNZUMxyNx6zREuAQ0JC4vTtyyhtTfS+uVU188klm6xT7t+/j1GjRkVrNcvxq7koLM8/xL7aiMMs5oI2adLE9qp9waQXDiNHDuXLQxXqpf6ohCTcnlCSgJHkRyUkUO3b8zKwCG/yebMflfALiyRRFZIHkoiohIWDOnXisx6LTJ06VfnSikpIJLt162Z7a9asWUroaVRCAvzVV1/Z3uKX6tmzWsEWxzlff/21jWyS3JPURiesPBnKwkuAQvpI/qKTrrN0HB8AACAASURBVF27KoWSKKtWrVJa60Qn06ZOxN8Xmf4PpRUEv8CjExJrPsCgbN26NcaehmwVQQ8kCfCKTStQValjF7W0atVKqZJJMYsA161b1/Ig6flz/DNvHu4MHYq8J08iRI82SnbbvpgxI44ULozjBQviQeLEtvPnkLJly6JCBX4sQbl21Rss9SGJqoa/lyhRQgmzo/ABhkqW+VCDwl6WxJUPhiiOBLhwYT5AiPZI5A1BQBAQBAISAX438gEhH6wzpYftitTvQ26IJJkPp/k92bt3b9v9SL169ZQoGt4n8YE/K0qrwvsOfv/x4T5ThxgCrX62cgwfoPO7k73cu3TpEuN9WECCGkuMFgJs/kF6S4A7AGDpOZLIvdY2QY674l+uStA4ju7Ek9FsnWHG7ObNcey5q4ZNG4mUMwI81dqbmJ7uyEzSYlVOK/n1hgAbtb9H8ePHT0DPm/0NKz80Sf4oJHwHDtB5bRHHG1wSB9UjRq+u/VjH8fTwqOSBpFMdG9VNMz2q9BhT+DQzJht4A62O5XgWTbIXe/3JkiWLNJZPUKk/KhtIKBmiqQpbFtBbHBUOCRMmjKSXXy72xNpeP8mhvb1//PEHVDJgP47/JlFVMeO6fApMnKOyge1m1LPg+5cvX7Z5rB3Pj7rVM+Z7/FJkmGpUejmWXnbVNvaA5dhFi05j9GiNsDLyt1mzPBg5so4tnJdfxqreqK4hemnVNjl8yh2lDde2Ic7+T5Ewzh1sPPIUy38DFv2WGJ988gm6d+czthevSz44IHYU6lQ991HZQC87xw7bMQz9N/VHAljyUt/O9jZm1p8Z6drnOat6eb7qWURlA0PP1LG8bhwftNifNT3mKg4ME47uOuMcjnMMl8bly4gzfTriTp2KOBd17hBHHNlbmPnCtWsDUeTtRvqD8/IXIcBeAijTBQFBIGAQYC/gRo0a4erVq0o0FAkx75X4sJAPhPk6ydDKlSttDxL5nfbuu+9i2bJlyncBHzLyu5/hzIx44n0bo/gYoWR//0BQGjRooMzjWvaOA3vA+JA+JgdFwIAbwIYKATb/8LwlwHSlrLVug3fXTEKwxJBqwko2ajOBWwBejOfQxrLXLuNXSUpj6imsJ3LOCLAvQqD13I+9LmmDZBSyQaD32bPnKF/+f9ixQyNcDIcOC2uOMmW0nE6vodj3MXCOEf8W2XYSqDAIypf+nj17vFavKiAB7rWJz9UsUjtXbfzS3BKmHzDCBzRMLWB49IYN+pudMiXwzjtKvrBRLZWEAOt/bKJRfwT27wfsI0szZgS+YblLqwzcNhAX/tW6PrZ9vS1KZyqtvyGiMeARYA0FRtHQ28voKqZE8cFs7ty5Ub16dTBKiQ+hHYWkmFWe+T1448YNJE2aVAmTbtq0qRL6rEZi2c9j5M62GNJbOJYPx6OLHgt4sANkA0KAzT8obwkwYxDte6Z8bvUIqzuji+aUtT8wiSZzW2MqFMU7bZYR5VjmDPvi7tQZAfZ1ESw9rwohwHqiGYS6zpy5hcKFI1eFzpUrJQ4daoWECS15wF4J3crLswAP/rap6T4fGL06rpIjzqfnqjfUq3WYTxE2FL03s2yBRerkqoMVzfmRFKBy5oyln/CsWQDbKuktmTMDjRsDTD8oUUK3/sJCgPU+KNFnBAILF1qeBanCFP5jLNNplWJTiuG3y2rnQ2BW/VloVZiNMUQEAUFAEIgZASHA5l8h3hJg7iDMGvpMXfcBfAKA+cAkx0wCbWjdJokmvx3mRrNt9hBWkx85lhVjSJ6NFmcE2NU2SHw2HH2VA6N3EbV+IcDm4B6rVh01aj+6ddsWaU/du7+J4cPZBtxLuXMMWM2OZ5rsSjkFBd9qpjzt1lNiHQFWwWGuLYt1zZ4NrFwJRJPz7hWWmTJFJsPWitae6BQC7AlqMsfXCAgB9jXisp4gEDwICAE2/6z1IMDM2WXuLomk2sPXcWd8neSWCZeWBMcXheVt1eJY9wCwYorWb8Q4rJwRYFb7YVne5ADeYAqqgymHARQCwJLG+40z0yPNQoA9gk0m2SMQEfEMpUvPw759rGUH5MnzMqZPr45SpTJ6D9SJ4cAhu36/iTID9f7Uzdtob+CQsCH4arNWGKxu7rpY3iz6ys3eb84EDTdvAgsWWMjwXpZlMEAYqqd6hkuWBNwkw0KADTgTUak7AkKAdYdUFAoCgoAVASHA5l8KehBg7oI9PejpVUmwujN7UvwugAUxbJmxiLWtOtiXx7imo5GNcEaAOZoFsHjnvAtQSsjS001hW6TRAHawcKr5x/mCBUKA/fBQAtGk48dvoHjxn9CxY1F8/XUppR2SLrKhLHCdfz5Wyfkx8Cbr6ukvg7cPRp8tLC5vkVhJgO1hO30amDPH8vPXX/oDSo0kw40aWcKkS5VyiQzPnat0YrKJVIE25mhEq3cIOBLgfPnYwkzTKSHQ3uErswWBYEZACLD5p68XAaaX9AcA7aLYEj2+PQB8F8N2MwH4XWnNaRGOj76Hjne4sU+PfTXnElbSvc9O7UB2bbH7/SV2WwHAscx5Ztg3yyjz95sASgI4551ZhswWAmwIrMGp9Pr1B0iTJpF+m394FViqpvxb1ZZfCbxiaaWltzgS4Hq562FZs2V6L+N/+tg+aft2i1d40SLgv/+MsfGVVzQyXLp0tGRYCLAx8ItWfREQAqwvnqJNEBAENASEAJt/NehFgNWd5KZjxUoO+RpzeH+2y+2NbscfAvjY7s1mAE4bBA9DrWc40d0GgNYfxTI4obU1Ez3ZJOy3rRWwSaa1Cj4GGe2hWiHAHgIn03yAwLkfgX1ab2XESwI0ug6E8HmT/hK0BNgeSva5XrbMQoZZRVrn3sK2pVgyV/UMs5+zXZi0EGD9r23RqD8CQoD1x1Q0CgKCgAUBIcDmXwl6E2DzdyQW2CMgBFiuB/9FYGst4NJqzb7MTYC3Fhpm76Dtg9B3ixb8ETQe4OgQvXQJYEIuq0jbl7fV+wQyZIhEhuf+L0RCoPXGWPTpjoAQYN0hFYWCgCBgRUAIsPmXghBg88/ASAuEABuJruhWEHj+/DmuXLmPDBmSuI7I03vAktTAsyfanNLz8CRjI5w8eVLpk3jnzh3l5/3330ccNiD2UhwJcP089bH0naVeao0F09mK6vBhi1d4/nzgiqXYmSGSKhXO56uNbmF1sR5VcR9JIDnAhiAtSr1EQAiwlwDKdEFAEIgWASHA5l8c3t9Vmr8HsSB6BIQAy9VhKAInT97EJ59sxD//3MPRo61dL451YSGw067JZtz4QMPruHD5DrJmzRrJ5n///RfJkiXzeh8Dtw3E11u/tukRAhwFpBERwM6dllzhJUuAy/Zt3r0+gkgKHiEBNuFtHHi1LvrurQMwbFpEEPATBIQA+8lBiBmCQCxEQAiw+YcqBNj8MzDSAiHARqIbxLqfPIlA//67wB7BT58+U5Do3780+vUr7RoqO5sDF/6njc1QDai4FiS7KVKwA5omFy5cQObMmV3TG8MoRwLcIE8D/PwOSxSIRIkA84PtyTBDpo2UN98E6tUD6tYFChQwpBWWkeaL7tiFgBDg2HWeshtBwJ8QEAJs/mkYSYB5x8rWQOz9+zKApNbtRlUp2nwkYqcFQoBj57mavqtnz56jTJl52LNH8xCyNdKpU22QJQtbZscgEY+AJWmBcLb7tsqbk4CcH+HZs2eIFy+eElatyuHDh1GoEFtteyffbPsG/bb2sykRAuwGniTDu3ZZPMOLFwNGk+Fs2SxEmD9lywLx47thrAwVBLxHwJEA580LnDih6ZU2SN5jLBoEgWBFQAiw+SevNwGmvhYAugIo6LA9vse72pAott0AwOfW128BaGw+NLHCAiHAseIY/XMThw5dQ9Gic0AyrErjxrmwaBELwccg//wCbLcfEwdocBFImAEREREKAbaX48ePIx+bcHopjgS4Yd6GWNJ0iZdag3A6yfDu3RoZvnjRWBAYEVCzpoUMV68OJHfygMVYa0R7kCDAZz1Nm2qblT7AQXLwsk1BwAcICAH2AchOltCTADOBaz6At6xrqrp5d2z/76gIcGprK6EEVpJMz/Eu8+EJeAuEAAf8Efr3Bj7/fBPGjz8YychNm5qiUqUYQpbvHAPOTgD+/hl4dBVIUxaosl3RcffuXSR3IDh//vknsmRh223vZMDWAei/rb9NiRBg7/BUZpMM79mjkeF//tFBaQwq6AmuUEHzDusQGm+swaI9UBEQAhyoJyd2CwL+j4AQYPPPSC8CTPK7B8ArVrJrT3q5S/X36DzAHDMPAPv/csz3ADqZD0/AWyAEOOCP0L83cOvWQ+TKNR03bz60GZo/fyocOvQ+4sWLG7PxzyKAGztZRhpIV14Ze/nyZWR0KIZ0/fp1pE7NZ2TeiSMBbpS3ERY3XeydUpmtIUAyvG+fhQzz528ftEcvUsRChuvUAd54I1K/YTkaQcAbBIQAe4OezBUEBIGYEBACbP71oQcBpkd3P4AidkT3GoDJALZYQ543WLcaEwFmsBGr4nDMSQAFzIcn4C0QAhzwR+j/G5g8+TA6dFD/xC32fvddJXz++RtuG3/u3DnkzJkz0rwHDx4gYcKEbutynNB/a38M2DbA9rIQYK8hjV4BH2qoZJjVpP/808DFrKrTpgVq1LCES1epAqRMafyaskKsRWDDBqBHD2172bNb0t9VafFzC5y8zlsViwyoMAB1cteJtXjIxtxDQG3dx6KOf/zxxwvFHamtf//+GDBgAIYOHYqePXvaFlBf79evnzImOlHXsK+ZwbFjxozBjh07cPToUVy7dg2PHj1C+vTpUaFCBXTv3h358+d3bzMyWncEhADrDqnbCvUgwO2tZFdNBGRjzfcB3Ldaw9jFP6z/jokA827lpt04unxuu70jmWCPgBBguR4MRyAi4hmKFfsJzAlWJUWKBDh7th1Sp07k1voseFWEXj2rxI0bF+Hh4br0Ae63pR++2f6NTXfjfI2xqMkit+yTwR4gQDJ8/DiwfDmwYoWFGBstISFAqVIWMswfFlHToZe00WaLfkFAEIgdCNj3rv/6668VousoRhFgRkzdv39fKR75yisMzORH8HGcOXMGoaGhWLZsGWrwYaGIaQgIATYNetvCehDg0wDosiG5DQNQiZlhdltzlQBzyl8AXpU8YN0uDCHAukEpimJCICzsH5QrZ9fWCMCHHxbC5MlV3QJu165dKFOmjG1O0qRJlbxgPcSRADfJ1wQLmyzUQ7XocAOBJd9fwrovVqIuVqAyNuIlPHZjtodDGVavkuG33wZ06CvtoSUyTRAQBIIAARJgPsBlUUeSHdaySOkQlWIUAd65cyeKFi2qrGsvEydOxCeffKKkGf31118I4YNCEVMQEAJsCuyRFvWWAGcDcN6qkQSYMY+HHbblDgHeaCXQ1NUGwGzzIQo4C9hEVW2kejo0NDT08WMf3GAGHExisN4IvPvuSsyff8qmlg63fftaolix9C4vtXHjRlRh+KpV0qVLhytXrrg8P6aBX2/5GgO3D7QNEQKsC6xuK5kzB2jVyjItEe7jo6zrMabCCmDlSuDGDbf1uT2BVcbZWkklxOxvI95ht2GUCYKAIBA9AiTACRIkQLt27TBhwgT06dMHAwdq3z+caRQBjulcmGLEVCO9uivINeAZAkKAPcNNz1neEmD7vN2zAPJEYZw7BJgZNg2tHuAvAYzTc7NBoosJI7Zmp3zCxxBSEUHAaAT++ececueehgcPtOvtzTfTY8+eFogbNw5w81cgaQ4gVH0+86JFmzZtQuXKlQ0hwH0398WgsEE23U3zN8WCxguMhkX0OyBgT4D51uuvAwcOAIiIsLRXYpg0w6XPnPENdqwwrpLhihWBxIl9s66sIggIArEWAZUAnz9/Hq+99poSekwv8Msvv2zbsxkEOE+ePDh9+jTOnj2LHDlyxFr8/X1jQoDNPyFvCfBnrHdjJazLreTVcVfuEGB6fFta9fUFMMR8iALOAvEAB9yRxR6Dhw/fi549mQmhyZQpVdH+g4LAskyWtkfpKgKv1geyNAMSaDcDnLF9+3aUL2+pCE3hzcLNm2ppAO9w6rO5DwaHDbYpeSf/O/hf48hh296tILNdQSBaAuw4+fRpLW941y5LtXCjJUECgNefSogdCrIZvbzoFwQEgdiBgEqAWYDq888/x/jx49G7d28MHqx9B/maAM+ePRvvv/8+cuXKhZMnTyoh2iLmICAE2Bzc7Vf1lgCzbB1JKu9M2MbovSi25A4BXgagrniAdbswJAdYNyhFkSsIPHkSgUKFZuH06Vt2JPYlnNlTFKn2l46sotZxIHm+SK8ZmQP81aavMGSH9kytWYFmmN+IrctFfImAywTY3qhr14BVqyze4fXrgQcPfGMyPSQsFsMfEuNE7hV1842Rsoog4P8IXL/u+d9skiTxkTBh/Cg3eePGA4+fjSVKFA+JE4caAp49Ab506ZLiBY4fP75SETpVqlTKmkYT4JEjRyqhziyIRcLLfzP/d8WKFUqOsIh5CAgBNg97dWVvCbB9Bei1AGp5SYAZCKe2U2Il6Z/MhyigLRACHNDHF5jGb9x4AVWqWKorJ00aigEDSuOzsssQ/4z25BtJcwK1T7+Qe7l//34UL17ctnG2P2IbJD2k96beGLpjqE1V8wLNMa8Rn9uJ+BIBjwiwvYEPHwKbNlm8w6tXA5cu+cZ8eofLlQOqVbP8sJWI5A77BnsTVjl6FJhn9/HALludO2uGjN83HhfvXrS90CR/E7yRwf3WbyZszZQl48QZ5fG648e/jU8/fT3K+WnS/IAbN7Q+9O4s0q9fKfTvrxVddGeus7H2BJhjO3bsiO+++05pd8S2RxRnBNjZGur7jm2Q1NeZTsS0IlUyZcqEOXPmRIqycnUNGacvAkKA9cXTE23eEuB6ANj2iMK7EFZwdhRXPcBJrG2PWJaOHuUK1qrSnuxL5lgQEAIsV4IpCDRtugLx44dg1KjyyJAhCbAqP/DvCc2WvN2B14e/YNvBgwfxxhvaTSQraD59+lSXPfTa2AvDdg6z6WpRsAV+aijP2HQB1w0ljgSYx/3bb24osB/KsOgjRyxEmD8MlX5m34TAQ72uTGN7EZUMM2/dLrfPlekyxr8RWLQIaMoqJ1ZhrbQTdh9hxaYUw2+XtQt3Vv1ZaFXYWt3Nv7dminXBToAvX76M7NmzK1Wh6QVmqyJnBLhw4cKR2gI6HtysWbOUl6IjwOr4O3fuKD2Bv/nmG7DQ5KBBg/DVV1+Zch3IohYEhACbfyV4S4BZ3lV9/E7SSteN462MqwS4A4AJVkgeWSsZPzEfooC2QAhwQB9f4Br/9GmEQoAVuXsWWJkr8maq7ALSlHphg8yXYqEQhorxRoH/Z8iWHtJjQw+M2DXCpqploZaY02COHqpFhxsI6EqAHde9fRvYsMFChtesARg67QthLh0jF1RCzH9LixFfIG/YGkKA9YU22Akw0ezcuTPGjh2L7t27Y/jw4U4JcL9+/ZQx0Ynaa9gZAVbn82FyqVKlcODAAezduxdvvvmmvocs2lxGQAiwy1AZNtBbAkzD2PaooNVruwZAbQdrXSHALNx0BIClYzfAdkjVDNt18CgWAhw8Z+2/Oz0xAjjUQ7PvpfRAg4tAHN8W4Oi+oTtG7hpps+O9Qu9hdgPptObrC2f2bOB9JrhYxSsPcEzG0xPM8tKqd3jfPt8U0qJN7PdJr7BKiF+NKjjK18jLeu4gIATYHbScjxUCDKWlH73ALD5FL/APP/yAAQMGKCHRDI1WRfUM602AqZ95wSTgffv2VTzCIuYgIATYHNztV9WDAKueW7VEJ1vwaL1GAGcEmFVFWPxK7X1CPXUArDYfnoC3QAhwwB9hLNjAulLAzT3aRnJ8BBSf5PONdVvfDaN2a3loDFdk2KKIbxFwJMCsxfLrrz6w4fp1SwEtEuK1a4FbWqE2w1dnvjDJcPXqlh7EL71k+JKygHcIOBLgfPmA48c1nRIC7R6+wVwEyx6pLl26YMyYMejatSsSJ07scwI8Y8YMtG3bFh06dMDEiRPdO0QZrRsCQoB1g9JjRXoQ4HgATgPICoD6SGDZXLMXgAuImQBXB8A70rx2O+CtUAmPdyQT7REQAizXg7kIPLgELFMDOyymXMrzCzK+4RgoYryZXdd3xejdo20LvV/4fcysP9P4hWWFSAiYRoDtrWDPYXqEVe+w0ojYR5IwoaWitEqIc+eWYlo+gt6dZYQAu4OWjHVEwLEIlvr+tWvXkC1bNuXXVq1aYdKkST71ALdu3RrMHaYnmCRcxBwEhACbg7v9qnoQYOpjPfVtABLakWAS4f0AfgfQ3LooX+sNgAmBVawhzypp5v/vAChmnWM+OoFvgRDgwD/DwN7BmQnAr58qe7j1X0L0XVIXU7cUx759LVGkSFqf7q3Lui4Ys2eMbc3WRVpjRr0ZPrVBFgP8ggA7HsSVKxavMAkxvcT//uu7o8qcWQuVfvttIAUzgkTMRkAIsNknENjrR0eAuatu3bph1KhRYJeDhw8f6kqAw8LCwLZLjRo1UupoqML8X5LtTp06IUGCBDh9+jRYFVrEHASEAJuDuxEEmDrp0mFTTbVRokps+Z490VZDpdXX+Dv/fRdAIwBazXbz8Ql0C4QAB/oJBrr9m6sAVzZidlhRdJlbGzfusdg7UKbMKwgLawa1iIcvtvnlui/x7Z5vbUu1KdIG0+tN98XSsoYdAixc2rq19oLPQqBdPQVWHd+9WwuVPswyFz4SFs4qUQKoWtVCilmkRopp+Qj8yMsIATYF9lizaEwE+Pr164oXmP15KXrmAM+cORNt2rRRqkyz1y97Dt+4cUOpAs1K1CRe9AA3tS9xHmtQD5yNCAE2/6z08gCrO8lnDX/Ob31BJbuOpNuRBJ8C0BiAXZMB88EJUAvoPlBdCKdDQ0NDHz9+HKBbEbMDGoEnt4ElaYHn4Ri4tDK+Xhy5rt2cOTXRsiU/MjThDcGxY8eUIiH8CQkJibENhDv4dF7bGWP3jrVNaVukLabVm+aOChmrAwJ+T4Ad93j5ssUrvG6d5f83b+qAgosq6A1Wi2mRFNNbLOITBIQA+wTmWLtITASYm+7RowdGjLB0JdCTALO41o8//oht27bh999/V8hvaGgosmbNikqVKuGLL75Ajhw5Yi3ugbIxIcDmn5TeBJg7ok56cj8HUBJA/Gi2SRJ8EMB4ACzF6qPmjeaDbrAFrJnPQmSKkECEh4cbvKSoFwSiQOCPOcBuS1/MR0/iIX+Pbvj92su2genTJ8apU22RPHkC22uOfYDZBunJE326oXVa2wnj9o6zrdXu9Xb4se6PcnQ+RiDgCLA9PswdZr4wyTB/6Cnma76SPHksnmGSYeYRJ07sq5WDbh0hwEF35LJhQcBnCAgB9hnU0S5kBAG2X4zh0CTBTDRIBSAUwA0AVwHstv7bfBRilwXiAY5d5xm4uwlrAvy92Gb/ygutUae3GhxiefnjjwtjwgSWA7CIIwGmF5gEmA9yvJWOazriu33f2dR88PoHmFp3qrdqZb6bCMycCbRpo03yuxBod/Zz5w6webNGiC+w7qOPJDTUUlFaDZcuVEiKaekIvbsEeGa9mXi/iF1/Lx1tEVWCgCAQuxAQAmz+eRpNgM3fYXBbIDnAwX3+5u3+2VNgSWrgKVP7rVJiGmp3TIFVq1gXT5OdO5ujdGlLpWhWyEyXLl2k9xnGpVbN9GZDX6z5At/v+96m4sM3PsTkOpO9USlzPUDAkQAXKwbsZ7nEQJfnz4HTpzUyvHUr8PCh73bFvxuVDFepAqT1bZE5323UNyu5S4DZUo2t1UQEAUFAEHCGgBBgZwgZ/763BDgpAEs9d4ucB2DJ6hfxBwSEAPvDKQSjDcz/PfI1cHEVcP8PCwINLuHPq4mQP/8MPHigheXnz58KBw60QmhoCJ4/f44UKVLg7l2NOK9fvx5VeEPvpXy2+jP8sP8Hm5YORTtgYm3pg+glrG5Pj7UE2BGJR4+AsDALIWaFafsmsm6j5sGE11/XwqXLlAHoMRZxGQEhwC5DJQMFAUHATQSEALsJmAHDvSXAHwJQ7yCfAsjIbicG2CkqPUNACLBnuMksvRCgV+zuKeDmXiC7pfTv6NH70bUru6ZpMnjwW+jdm9kSUCpXHrDryzphwgR8/PHHXlv0yapPMPFXjfB+UuwT/FBLI8ReLyAKXEIgaAiwIxr//KMV09qwAbh92yW8dBnEXOGKFbXew1IExymsQoCdQiQDBAFBwEMEhAB7CJyO07wlwOzpO8hqz04AZXW0TVR5j4AQYO8xFA06IxAe/gzFi/+Egwev2TQnSBCCo0dbI2fOlGjWrBkWLFhge69z584YM0br3+upOR/98hGmHJhim/7Zm5/h+5paSLSnemWeewjMmAG0bavNiTUh0O7AwMJZjPtWi2nt3Qs882EdSBLg6tUtPxUqSDGtKM5OCLA7F7SMFQQEAXcQEALsDlrGjPWWAH8KgHeQrOi8EEBzY8wUrR4iIATYQ+BkmrEI/PrrFZQoMRfPnmmd0ipVyoyNG5ugb9++GDx4sM2AOnXqYMWKFV4b1H5Fe/x4UKv6/EXxLzCuhlYV2usFRIFLCDgSYLa63bfPpamxdxC9wfbFtP76y3d7ZWh0uXJAjRoWQpw3rxTTArByJdChg3YMuXJZjkiVmnNr4sjVI7bfx1Yfi8b52M1RRBAQBASBmBEQAmz+FeItAW4IgGVeeRe7zNr+yPxdiQUqAkKA5VrwWwQ6d96CsWN/i2Tf9OnVEDfuAbRubQmXpuTJkwcnT570eh/tlrfD9EPTbXo6leiEb6t/67VeUeAeAkKAneDFtIEzZ7S+w1u2AA8euAeyN6MzZdK8w+xBnCyZN9pkriAgCAgCgoADAkKAzb8kvCXAuQCcshLgwwDeMH9LQW+BtEEK+ksgMAD4778nSkGsv/660pkeCAAAIABJREFUZzOYPYFnzSqA+vUr2V5jK6QbN24gZcqUXm2szfI2mHlopk3HlyW/xOhqo73SKZPdR2D6dKBdO22eeICdYPj4MbBzp5Y/fOiQ+6B7OiNePKB0aY0QFyki3mFPsZR5goAgIAhYERACbP6l4C0B5g74bVwIABOYsgC4aP62gtqC/gD6qQiwf2p4uFZxN6iRkc0bj8CzcCDiARDfNa/RqlXnUbv20kh2tW2bD3PnNsRj3vhbhTnBTZs29cr+95e9j9mHZ9t0dCvdDSOqjPBKp0x2HwFHAly8OMAUWBEXEbhyBdi4UfMQX9Ny6V3U4Pmw9Om1QlqszJ4qlee6ZKYgIAgIAkGKgBBg8w9eDwLMZ/lTrV5gulfsnu2bv8EgtEA8wEF46H6z5avbgM1vA6lLAumrAhmqWv4dg7z33mr89NMJZcQXX7yBIUPeQqNGdbGOBYKswpDoGYyd9UJaLW2FOUfm2DT0KNMDwyoP80KjTPUEASHAnqAWzRwWzjpyRCPDO3YAT57ouEAMquLEAfj0Qs0dZjWzkBDfrC2rCAKCgCAQwAgIATb/8PQgwNzFLwBqWUlwLwDiVjH/bGmB5AD7xzkEjxWHvwKOD9H2m/INoEbkPF9HMG7deoj69Zdj0KAyKFcuk/L2d999h44dO9qGpk+fHhcvXgTDoT2Vlj+3xNyjc23Te73VC0PetrPVU8Uyzy0Epk0DPvhAmyIeYLfgi3nw/fvA1q1auPTp0zoqd6Lq5ZeBqlWB2rUtIdPiHfYd9rKSICAIBBQCQoDNPy69CHASALMANLCS4I0A6FrZYv4Wg9oCIcBBffwmbH7tm8CtX7WF8/UAirjvZT179ixyseyqnbA38Ouvv+7xpt5d8i7mH5tvm/9V2a8wqJLaxc1jtTLRTQQcCXCJEsCePW4qkeGuIXDhQuTew3fvujbP21F8UMXc4Tp1LIRYKkt7i6jMFwQEgViEgBBg8w9TDwKsllWlLlaFTmolwdwdq9uwOBaTlLRKN873zarSEkrtHCdnI4QAO0NI3tcPgcc3gSVp7P78AVTaBKTXClq5s1iOHDlw/vx52xS2Rurdm63HPZNmi5thwXGtv3Dfcn3xTcVvPFMmszxGQAiwx9B5N/HpU8uThrVrLT8HDninz53Z2bNbiDB/2HIpQQJ3ZpsyloW42QpJFTq47YrT46cjP+HafS3/unqO6siXJp8ptsqigoAgEFgICAE2/7z0IMAsfqU187TsyV6v43vOds25nCPJRM6Qivp9yQH2DDeZ5S0CFxYCO9/RtIQkBBrfBkI8u9n94osv8P333yNFihSoWrUq2rRpg+oMrfRQmi5qikUnFtlm9yvfD/0rsGaciC8REALsS7RjWOvqVYt3eM0ay/9v3vSNYUmSWAppkQzXrAmkTeubdd1cZdEiwL7uHp3YJyylChQpOqUoDlzWHiLMqj8LrQq3cnMVGR5bEYjDHHlA+f76448/lP87Sv/+/TFgwAAMHToUPXv2jK1QyL6iQEAIsPmXhVEE2JudCQH2Bj1AqkB7h5/M9hSBfR2Ac5O12RmqAxXXeKoNp06dwq+//o2wsGeYMKEKQkI8z/+lEY0XNsaSk0ts9vQv3x/9KtgKpntsp0x0D4EffwTat9fmSAi0e/gZMjoiAvjtN807zLLcLLBltJAk8AJQvcOFCvlNmyUhwEYffuzWrxJg7vLrr79WiK4Q4Nh95u7sTgiwO2gZM1YvAqy3deIB9hxR8QB7jp3M9AaBlfmAuyc1DUVGAPm6eaTx+fPnmDjxELp02YZHj8IxePBb6N075mrSzhZquKAhlp7SWi4NrDgQfcr1cTZN3tcZAUcCXLIksHu3zouIOu8QoDeYrZbUcGm2XvKFZMpkIcPMHa5YEXjpJV+sGuUaQoBNgz5WLEwCzKKN8eLFA8nOn3/++UIve/EAx4qj9mgTQoA9gk3XSXoQYPb+NUIuGKE0yHRKDnCQHbhp2310Dfg5XeTlq+4FUhf3yKRPP92ICRPYYtwi8eLFxc6dzVG8eAaP9HFS/f/Vx/LTy23zB1cajN5lPc8p9tiQIJ8oBDjALoDnzy2tlkiGGS69cyfgi97yiRIBlStbyDBDpTNm9ClwQoB9CnesW4wEOEGCBGjXrh0mTJiAPn36YODAgZH2KQQ41h27yxsSAuwyVIYN1IMAG2acKPYaASHAXkMoClxC4K/FwI4m2tB4SSz5v3HjuTTdcdDOnRdRrtz/8OyZVkLgtddS4ODBVkiaNNQjnXXn18UvZ9ixzSJD3x6Knm9J3pVHYHoxaepU4MMPNQXiAfYCTDOmspL05s0aIf7rL99YUbQoUL8+0LgxkCeP4WsKATYc4li9gEqAWcjxtddeQ2hoqOIFfpnV1KwSHQG+fPky5syZg1WrVuHcuXO4fv26Mq906dLo1asX3nzzzViNXTBsTgiw+acsBNj8MzDSAiHARqIrujUEfv0cODNe+z1DNaDiWq8Q6tdvJ775JnJsbJs2BTB9umeFsGrPq41VZ1fZbBpeeTi6l+nulY0y2X0EHAlwqVLArl3u65EZfoAAvcPsNbx6taVkcliYb7zDBQpYiDB/8uc3BAghwIbAGjRKVQL86NEjfP755xg/frzSxYDdDJwR4EmTJuHjjz8GOyGQPCdLlkwhwgcPHkT8+PGxcuVKpTCkSOAiIATY/LMTAmz+GehtgeQA642o6HOOwOpCwJ2j2rjCg4H83oUXh4c/Q9my87Fnz+VI69eufRu5cj3C6NGjndtlN6Lm3JpYc04ryjWyykh0Ld3VLR0y2HsEhAB7j6HfarhzB1i3zkKGSYpv3TLeVJZnVslwwYK6FdESAuz90bGOmq+Ki3tvbWQNqVIBbGftqdgT4EuXLilEluSVFaFTUTmA6DzAR48eBetgFGJRODtZt24d6tati0yZMuHs2bOwL7TlqZ0yzxwEhACbg7v9qkKAzT8DvS2QKtB6Iyr6Ykbg8S1gieUL3SZVdgBpyniN3O+/30GRIrNx794TO10PET/+BOzbtwZFihRxeY3qP1XHuvPrbONHVx2NL0t96fJ8GagPAkKA9cHR77WwsjSrm5EM8+f4ceNNzpVLI8P8bLC2ovFkYSHAnqAWec71637b5crp5q5dA9Kwrb2HYk+AqaJjx4747rvvlHZHbHtE8SQHuGXLlpg7dy6OHDmCgnzgIxKQCAgBNv/YPCXAhQEw/oJd31Nbt3EDAEvAbgBw0PytBa0F4gEO2qM3aeOX1gBba2qLK/1/7wAhnuXqOu5izpzjaNXKsZ3SZWTLtgoHDuyJsr9iVEhUmVMFG3/faHtrTNUx6Fyqs0mgBe+yU6YAH32k7V9CoIPkWvj9d2DVKuCXX4CtW4GnT43d+GuvaWSY+cNukmFnBPiNyW/g4BXtVkf6AL94nEKAE4Ah0BTm9WbPnl2pCk0vcOrUqWMkwI8fP8batWuxb98+JQf4yRPLQ2CGQZP8LlmyBA0bNjT2b0i0G4aAEGDDoHVZsbsE+A0A3wJ4y8kKOwHQtfKry5bIQCMQkBxgI1AVnZERODoQOPq19ho9v/QA6yQMBXvvvdWYO9euxZKi+wDq1XuIpUt/dikUrNKsStjy5xabVeOqj8MXJb7QyUpR4yoCjgS4dGlLYWGRIELg3j1gwwYLGSYpJlMyUrJm1chw8eIukWF3CfDs+rPxXuH3jNxFwOkWAqwRYB5e586dMXbsWHTv3h3Dhw+PMQSaoc4smhWdzJw5E++//37AXRNisAUBIcDmXwnuEOB6AObx3ADYz1PLtDrq4mOvdwEsM3+bQWWBeICD6rj9YLNhjYG/l2iG5O4IFB2rq2H//fcEJUr8hBMnHHMKl2PEiLro1s15v+HyM8tj+4XtNrt+qPkDPnnzE13tFGXOEZg8GejQQRsnBNg5ZrF6BBNF9+2zhEmTELPlkpHCXsONGgFNmgAsQR5NoqcQYO8PQQhwZAJ85coVxQvM/sD0Av/www8YMGCAEhLN0GgKH/jmy5cPp06dQocOHZQfzkmSJInyoJeFtDh+xowZaN26tfeHJBpMQUAIsCmwR1rUVQLMngMHrORX+Ru1anGcr/UssZBkkuCi1tBo83cbHBZIDnBwnLP/7PJZBHD3FHDrV8tPxtpAxmq623f27G0ULcp8YPvQyQjEjTsVW7ZMR7ly5WJc863pb2Hn35qrcVKtSfiomF0sru4Wi8KoEHAkwGXKADv0CxgQ0AMdAbZVUkOl2W7p8WPjdsTewu+8A7RpAzjkUwoB9h52KYIVmQAT0S5dumDMmDHo2rUrEidO/AIBPnnypEKAixUrhv37979wCM2aNcOCBQuEAHt/eZqqQQiwqfAri7tKgLcC4N2lPfHlXShDnP+26nnVSnaZ+Gc/jrc2Md+Zmo9DbLJAPMCx6TRlL5EQWLHiHOrVcwwquYc0aebi8OEwZMiQIVrESk0rhT3/7LG9P7XOVHzwxgeCsI8RmDQJ+PhjbVEhwD4+gEBa7v59S6j0zz8Dy5cD7EFslBQrBrRtCzRvDqRIASHARgEdHHodi2Cpu7527RqyZcum/NqqVSuw5ZG9B3jXrl0oU6YM6tevj6VLl0YC6/bt20prpFu3bgkBDvDLSAiw+QfoCgEuAIAxSSS1HM//jwEwBMBthy2QfPUCoPYWUce/btVh/o790wIWFGNZQDY0vAlgBoB+ACK8NFdygL0EUKb7HwJ9++7AoEEakbVYuBTlysXDxo0blVYTUUnxqcWx/5L2RH163elo83ob/9tgLLfIkQC/9ZalfayIIBAjAvQEb9wILF4MLFsGsOWSEZIgAdCwIba91hYVB1XCc1h64bDb0okT2oKORbAkB9iIwwhcndERYO6IKTujRo1CwoQJ8fDhw0gEmASZD3IZ8vzrr78iZ86cCggspsWc34ULFyq/Swh04F4btFwIsPnn5woBJhHjD4Xkl1VjfnBiOjO8Jth5ggey4rv52/VLC/hwYK8V0ynWytrTAEwCYEkKcU/EA+weXjI6wBCIiHiGmjWXYP36CwBYGXOxrfB8o0aNMH/+/ChJcNEpRXHgMjM5LCJVW805eCHA5uAeq1ZlRVyGR5MM00tmUL/hC8iMOXFbY05Ia7yUNxsOH9ZQLPFjCRy6csj2Ah+otSjUIlbBLJvxHIGYCDCrOtMLfJ8RDvR+2OUA8/cPP/wQU6dOVQhypUqVlP+HhYUhIiICtWvXBgtgCQH2/Gz8YaYQYPNPwRUCvBIAe5yQ/NLt4mpzTz7T51jOY/NNuz4p5m/cRQuYv1wFQHEAJQBkBMCEJBYCi0n4Pj3hzQFkBsDKPWsBsFTuPw4T5wJgjjXXUoUPGYYBSAvgPxdtVYdJDrCbgMnwwEPg1q2HaNjwZ5w6NQpXr2o3odwJQ8eYIxUaGrkN0+uTX490wzqnwRy0LNQy8DYf4BZPnAh8Yld7TDzAAX6gZpvPdkpsq0QyzFDpG+zIaIBUrGgJkWbrmUSJDFhAVMYmBGIiwNxnjx49MGLECGXLjgSYRHfcuHGYNm0afv/9dyRPnhyVK1fG4MGDFeLLwllCgAP7ahECbP75uUKAzwNgwgKJLDO36KV0RdoDmGydR1dNdlcm+dkYJhuy+rW9OCPAJL+bAJRm6zcAfBCQ1Uqi2euhFABiqgrr3M8B0NfutdcAnANQAcA2NzERD7CbgMnwwEWAPRIrVKighJHZC5+SL168GAkYzmiVwpMK48hVrcLsvIbz0Lwgn1GJ+BIBRwJctiywXSvO7UtTZK3YhkB4uCWengm8JMNXr+q/w2TJgGbNLGTYxZZK+hshGgUBQSCQERACbP7puUKAmZOa0kpk6QV1tbcvPZpqwh2TdV42f7tuW9ADAB/1ch/8ueKCB/gbK5ndDYC5vaoHl32RRwPgrV55O0tIqDtbQ8bVlxNb57GN1Hy3rdYmSA6wF+DJVCcIhN8H/pwPpCgAJM8PxE9qCmRbt25FrVq18ODBg0jrMxSaFTNVKTixII5dO2b7/X+N/od3Crxjis3BvOiECcCnn2oICAEO5qvBwL1HRFgaTNMzvGQJcOmS/ovly2epIP3ee0C6dPrrF42CgCAQKxEQAmz+sbpCgMMBpQoEPcA5APzhotn0+NKLSWExp6gr07iozE+GEYOYPMDc4zUA9MK+YUtM1IxnBlEhAMUA/GZ9OSoCTNLN5BC6p/7n5t7FA+wmYDLcQwRu7AXWl9QmJ8kB1D4FxA3xUKHn05gfVbNmTfz3n+V50wcffIN+/Trh1Vc1Up5/Qn6cuK5VsVnQeAGa5m/q+aIy0yMEHAkwu1dtczfOxaOVZVLQIsB+PLt3W8gwf/5xzETyEpl48YDatYGuXQGWNRcRBAQBQSAGBIQAm395uEKAn1nNJPljKPRfLpqdxY4sc67v74pdNNSNYc4IcEUAm60hznxY4CgMc6aHeIBdUTC9Q6AlB9iNA5WhXiBwfhqw166NULI8QO2TXij0birbR1SvXh1VqnTB6tXJkSfPywgLa4YkSSy5wHl/yItTN07ZFlnUZBEa52vs3aIy220EfvgB+OwzbZoQYLchlAneIEAyvGcPMHMm8L//AffueaPtxbkMaejZE6hRA4jjyi2WvsuLNkFAEPB/BIQAm39Grnw6CwHWzskZAe4E4FsAiwBE5VqqBYBFxZhb3MCqlkWwclu9wupKnwMY7mERLPEAm/93FRwW/NYJOD1O22umxkBZXvrmyPPnz9G9+zqMGqWFOdep8xqWLq2HkJC4yD0+N87cPGMzbknTJWiYt6E5xgbxqo4EuHx5Sw0jEUHA5wiwCi/Do2fM0P8iLFTIQoSbNAHoIRYRBAQBQcCKgBBg8y8FIcDunYEzAsz+yMznJQlmzq+jFAbAkrXsxaJWfWaoNKtrfw/gRzqqALANEguIudoG6Xg028ibIEGCOOwfJyII6I7ApsrAVdZ7s0rB/kBBtWOa7qs5VXjv3hMUKzYHZ85Ebk/evn0hTJ5cBbnG58K5W2pWBrD0naWon6e+U70yQF8EhADri6do0wmB8+ctXuFZs4C//9ZJKct/ZmfjV6B1azb/1E+vaBIEBIGARUAIsPlHJwTYvTNwRoBZIZvVrwcD6BOFaoZFnwVANxS9vqpUYyV8APkBsOjYDGvLJOZOuyJCgF1BScboi8CyTMADu1y6txYBmc0NKT579jZKlpyLW7ciP/Tp3bsEpidpiitPWMfOIsveWYZ6eRyLvOsLkWh7EYHx44HPGeNiFfEAy1XiVwiweNamTfh7wHSk2bUMLyllP3QQFsnq3Bn4+GOAlaRFBAFBIGgREAJs/tG7SoBJ/CgsyqTdQcZsf3q7Ak6cz5Y+rqynavXHxhjOCPBU1t8BMMihrZG6p5xW8utIgI26EqQKtFHIBrve8IfAQodemDUOASkZ5GCubN/+N6pUWYwnTyI/P4rT6Ws8T6G1S1rUYBEaFzKXsJuLlDmrOxLgChWALVvMsUVWFQSiQ4CR0e0b30JzzEcbzEAxW91KLzFLntzSCLtjR6kc7SWUMl0QCFQEhACbf3KuEFLmAJP4caxKhF213F6/O3M51h+TZpwRYE9CoF3F0pNxQoA9QU3mOEfg3xPAKgYs2EmTu6a1QnI0eOnSs2jceAWePbP72Ok4BEiphUdn250N68evR44cUdWrcw6BjPAMge+/B774QpsrBNgzHGWWsQiQADe2ez5WN+sRLK8/A5gzB7jJQC0vheHQ7CXMytHZWF9URBAQBIIFASHA5p+0OwSY1roy3n5X9qTXnbn+WjXaGQH2pAiWkVeBEGAj0Q1m3f/8AmyvqyHwUlqg4VW/QuTHH4+gffv1mk2dhgAp7PKD5wLJryXHrFmzUK+ehEL76vAcCXDFisBm1s4XEQT8CAFHApwnD3CSRe6fPAF++QVh/dui9PG7CHHn0X5U+wsJAd59Fxg6FHjlFT9CQEwRBAQBoxAQAmwUsq7rdYWUqh5g17V6N1L1NPtj2yRnBNjVNkhsheSLakFCgL27FmV2dAicGgscYL03q6QuDVTd6Xd4DRu2F716hVns6jQYSHFHs5H115mRD6BHjx4YNGgQ4km1VsPP8LvvLNGfqggBNhxyWcADBKIlwFZdr09+HbdOHUKXXcAHB4BE4R4sYj8laVJgyBBLjjBJsYggIAjEWgSEAJt/tK4QYPap9fYZpyc79ceYIGcEmA1HrwFIDoDVnQ86bPwwgEIAigPY7wkobs4RAuwmYDLcRQT2fwac/UEbnPU9oPRsFyf7bhhbI3XtuhVjxvwGdB4MJLcjwD+lBM5pHuHy5cvjxx9/lJBog4/HkQBXqqTUHBIRBPwKAVcI8KErbOoApL4PbL5TDwUXbQPu2H3GeLKjN98EpkwBihTxZLbMEQQEgQBAQAiw+YfkCgE230r/scAZAaalLID1FYBdAKoCuG81n22RRgPYAaCsj7YkBNhHQAfdMltqAJfXats2uQVSTPgzD7hNmzWYnepdIPm/2tCfWgDnGHt72fZaggQJ8NVXX6F79+7gv0X0R0AIsP6Yikb9EXCHAHP1nxr8hBZZ61jI65gxwGXtc8Vt6+gB7tQJGDAASJzY7ekyQRAQBPwbASHA5p+PEOCYz6CWQzXnElZv+D67aQMBrLL7nY3+tgLgWH4DMv4yi/V3Vs4oCUBrRmrsNSAE2Fh8g1f7qoLAv8e0/ZecBWRv5bd4PH0agWT90+JR6C3NxjkfAOdfBTAcgFYdmgNy5cqFiRMnohLdkyK6IjBunOXeXhXxAOsKryjTCQFHApw7N3DqlKa8yKQiOHyVQV0WUQhwoRaWXx4/BmbPBkaMAM558XWfOTMwYQJQi7ciIoKAIBBbEBACbP5JCgGO+QxaW3vyxjSqDYCZDgMSAugF4F0AmQAwzpLusr4A/vbhsQsB9iHYQbXUkjTA4xt2LGYDkL6yX0OQYVRGXLlv55WZ3R6d61XHkiWd8ddff0Vp+9ixY9HRPmHVr3cYGMaNHWtph6rK228DGzcGhu1iZfAg8PPPQKNG2n6dEeC5Defi3YL8yrcT9hQmkx42DDjomBHlBpYsR80nRxkzujFJhgoCgoC/IiAE2PyTEQJs/hkYaYEQYCPRDVbdEU+ABQ7hwTWPAikK+DUi6Uelx9X7WqXqTxJPxA9dO+DevXvo168fxo0bh2fPWPPPIgkTJsSJEyeQNWtWv95XoBnnSIArVwY2bAi0XYi9sR0BRwKcKxdw+rS268KTCuPI1SO2F6IkwOq7z58D69dbiPBWBoh5IMmSWSpFf/SRFMnyAD5fT4kTx3J7zToUjhIeHo5mzZphyZIlyJkzJ7Zs2YJXpAK4r4/I1PWEAJsKv7K4EGDzz8BIC4QAG4lusOp+cAlYxtBhuy/2hteBl1L7NSJpR6bF9QfXbTZueX8LKmStYPv94MGD+Oijj7B/v6U+3bBhw5Tq0CL6IvDtt8CXrIhgFSHA+uIr2vRBYOlSoGFDTZdXBNjepD17LNWef/nFM0NLlABmzQLokhbxWwSiI8BPnz5VyO/PP/+M3LlzY/Pmzcgonn2/PUejDBMCbBSyrusVAuw6VoE4UghwIJ5aINj8LBx4dA14dAV4eBnIWAOIE9evLU89IjVuPmQavkW2td6GclnKRbI5IiICU6ZMwdy5c5Wn8vHjx/frPQWicY4EuEoVi3NMRBDwJwQcCXDOnMCZM5qFhSYWwtFrR20vzGs4D80LNnd9C2vWAJ98AvzJRhtuSvLkFgJd1lf1NN20T4YjKgJM8vvOO+9g6dKlyJMnj/Idkz59ekErCBEQAmz+oQsBNv8MjLRACLCR6IrugELg5eEv4/Yjre3R9tbbUTbLizeQ+/dfRmhoCAoXThvl/hgyXa1aNXTo0AEtWrRAiPTsdOs6YIHcLl20KUKA3YJPBvsIgWXLgAYNtMV0J8BU/eAB8M03wKhRAPOF3ZGXXgIWLgTq1HFnloz1EQKOBJjkt0mTJli+fDny5cuneH7TpUvnI2tkGX9DQAiw+SciBNj8MzDSAiHARqIrugMKgRTDUuDfx1obpB1tdqBM5jKR9kDyW6XKYjB9a82aRihZ8sWiM19++SW+pRsTQIECBZRQ6Zo1a9qe+AcUKCYY60iAq1YF1q0zwRBZUhCIAQGfEGB1/SNHgA8/BPbude9M+PBt2jTg/ffdmyejDUfAngA/efJEIb8rVqxQvjM2bdqEtGmjfsBquGGygF8gIATY/GMQAmz+GRhpgRBgI9EV3QGFQPJhyXH38V2bzTvb7kTpTKVtv6vk999/HyuvJU4cHytWNEClSpltY5gnXKxYsUjFsvhm2bJlMXz4cJQqVSqgMDHD2NGjga5dtZWFAJtxCrKmMwQcCXCOHMDZs9osr0OgHQ2gB5g9hHv2BO5qn1PO7FTeHzky8h+VS5NkkJEIqAT48ePHaNSoEVauXIlChQop5Dd1av+ul2EkLqLbgoAQYPOvBCHA5p+BkRYIATYSXdEdUAgkG5oM957cs9m8q+0ulMqkEdZ69ZZixYrzkfaUIEEIFi2qizp1XlNet/f+RrX5+vXrY8iQIcibN29AYeNLYx0JcLVqwFo2iRMRBPwIgadPLRHKFEaExI0LJEmiGXj/yX1EPI+wVflNGD8hQkNCvd/BpUuWRtmLFrmnq1s3YPhwi7F+Is+eP8PNB1rdBT8xyyUzUiVKhbhe1LVQCXCtWrWwatUqFClSBBs3bkSqVKlcWl8GxW4EhACbf77+80lpPhax0QIhwLHxVGVPHiGQdGhS/PfkP9vc3e12o+SrJW2/P3jwFI0aLcfatZGL0sSLFxezZ9dA8+Z5lZvd1atXo1evXjh6VCuAY29Q3Lhx0aZNG/Tv3x+vvspq2SL2CDDdkffqqlSvznBzwUgQEAQiIbBqFfDpp8CFC64D07o1MHUqEC+e63MMHHn9/nWkHRWYob7Xul5DmsRpPEZHJcBUwH8fOXJECX8WEQSiEZfkAAAgAElEQVSIgBBg868DIcDmn4GRFggBNhLdYNV9fTcQfg8ITQnETwEkzADEt3ON+CkuSYYkwf2n923W7Wm3ByVeLRHJ2idPItCixSosXmxX7tXqAZo0qQo+/LCwMp7Volkpum/fvvjrr7+i3DG/4L744gv07NkTKVOm9FNUfG+WEGDfYy4rBigC9+8Dn30GzJzp+gZYFGvBAjYyd32OQSOFAANlypTBzp07kT9/fmzbtk08wAZda4GmVgiw+ScmBNj8MzDSAiHARqIbrLo3VwOu2PWteX0kkNcuqdNPcUk8JDEePLXGNALY+8FeFH+l+AvWhoc/w4cfrseMGcdeeG/UqPLo0uVN2+uPHj3CxIkTMXjwYNy8GXWoX4oUKRSP8eeff46EfnBTavbxMF2xe3fNiho1gNWrzbZK1hcE/BSB58+B3r3ZmNx1Axs1soRQmxwOLQQYuHPnDipVqoQDBw6gaNGiSvXnZMmSuX6WMjJWIiAE2PxjFQJs/hkYaYEQYCPRDVbd60oAN/dpuy8+Fcjxgd+jkWhwIjwMf2izc98H+/DmKxqZtd/As2fP0bnzFnz33YEX9vXVVyUxcGCZSFWf//33X4wcOVKpDv1ATRx0mElv8Lhx4/weJ6MNFAJsNMKiP1Yi4Fg+3dkmWR26bVtnowx9XwgwlLSZGzduoHz58jhx4oRSMHHt2rVIlCiRodiLcv9GQAiw+ecjBNj8M9DbghQA+EM5HRoaGsoqhCKCgG4I/JIbuGcXIvzWYiBzI93UG6Uo4eCEeBT+yKZ+f/v9KJaxWLTL8calX7+dGDhwzwtj2rUrCIZEMz/YXi5fvoxvvvkGU6dOVcKkVWFe8MmTJ5ErVy6jthcwekeMAHr00MytWRNguqOIICAIOEFgzhygTRvXegbTy3jsGJApk2mwShEsCwGmXLp0SSG/v//+u9JHni2RQkN1KJpm2unKwt4gIATYG/T0mSsEWB8c/UlLfwD9VINCQkIQHh7uT/aJLYGOwNKMwMPL2i4qrgMyVPX7XTkS4F/b/4qiGYs6tXvUqP3o1m3bC+Nq186OBQvqIFGi+C+8d+bMGfTp0weLrJVcmzdvjnnz5jldKxgGOBLgWrWAlSuDYeeyx0BC4Pp14MABEhjLD7MXKlTQdhB2IUypKRCH/8WJg8LpCiNdknTGb5FPi5o0AR5q0SzRLsoS66wwZ3IotPGg+N8K9n2AVev+z955QElRdFH4AhtYcs4gSM4KkvzJiqDkIFlABAVRAckCJoKAIFEEQQEVJWeJgiBBARGQIDnDknNcdpf/vGZmJ+zk6Z7u2b11zh7YnepXr77q7unbVfXeqVOnULlyZZw/fx5NmjTBvHnzIM9oLImPAAWw/mNOAaz/GKjtAWeA1SZKe7YE5qcHHt+0/O3lzUCWyoan5KsAlo5Nm/YvunRZB1kabV0qVsyODRuaIyIivgiWejt37sRHH32kLI12FgF0+vTpOHbsmJJiKUuW4IyY6s3gS6YWSXVqLhTA3tBj3UARkH3pcm6aS548tgGZi35dFIeuHor7fP7r89GsWLPAuLdt21Pnblrdh521bICl0IGBYqxWHAlg8fDQoUOoWrUqrly5gnbt2mHmzJk222mM1Qt6oxUBCmCtyHpulwLYc1bBWJN7gINx1Izu85xwIDbK4mWdXUCGMkb3Gv4IYOnckiVH0arVr3j40LKiomfPshgzprrPDzCyPaFAgQI4d+6cEiDr7bffRu/evRN0+iQKYMNfKnQQTydOZXm+uchKYuuA70UmFcHha4fjPl/w+gI0LRbArSCyvPmll4DLl12PlwGWQifGE8qZABYWe/bsQY0aNZQAWd26dcOkSZMSI6JE3WcKYP2HnwJY/zHQ0gMKYC3pJkbbsdHAHLvZzroHgbRFDU8j+dDkeBRj2Q/v6RJo645t2XIO9esvxs2bj9CyZRHMnl0XSZP6fhuVvcIieq2L7Avr0KED+vXrh2effdbwXL11UILZDhhgOapePWD5cm+tsD4JaEtg9WpAIpSbi6T0PnvW8nvhSYVx5JolFkLABbC4IhdOgwbuQXAptHtGKtdwJYClqT///BO1atXCvXv3lFR5X3zxhcoe0JyRCVAA6z86vj+56e87PXBPgALYPSPW8IbA4zvAfLsUDg1PASmf8caKLnXVEMDi+MGDVzFixA5Mm/YKwsNDfO6LBEcpXLgwjh496tCG7A1r06aNkkKpSJEiPrdjtAMpgI02IvTHEYE1a4A6dSyf5MwJnDvnXAAvbL4QTYo2CTzMdu0ACY7lrsyYAXTo4K4WPycBEggAAQrgAEB20wQFsP5joKUHFMBa0k2Mth9eBhbZBXppchlIntnwNNQSwGp2VMTviBEj8MMPPzgNViczCQ0bNkSfPn3w4osvqtm8LrZkokPSmppL/frAsmW6uMJGScApgbVrAZk4NZccOYDz5y2/F5pYCEevW15eLWq+CI2LNg480evXgeLFgYsXXbctm5hPnAAYdCnwY8QWScCOAAWw/qcEBbD+Y6ClBxTAWtJNjLbvngKW5bPt+et3gNBUhqcRKAG8b98V/PbbafToUdbjvcGnT5/GqFGj8N1338FV2rJKlSope4RFEAdr9NDhw4GBAymADX/BJHIH160DXrEKbp8tGxBpFfy+4MSCOHb9WBylxS0Wo1GRRvpQ83QptHTq5Zf18ZGtkgAJxBGgANb/ZKAA1n8MtPSAAlhLuonR9u3DwAq75bgtHwNJfV8KHCiMgRDAFy7cRcWKs3H27B106VIaEye+FC9XsKv+Sq7IMWPGYMqUKbh//77Tqvnz51ciS9eX6dMgK/YCWLYwLl0aZJ2guwmewG+/AbVqWbqZNavtJGuBCQVw/MbxuApLWixBwyIN9ePiyVLo9u2BmTP185EtkwAJKAQogPU/ESiA9R8DLT2gANaSbmK0fXM/sLKkbc9bxQZFnkmtBfCdO1GoWnUO9uyxRGWtW/dZzJlTD6lShXl1tkiKjHHjxinRQW/fvu3w2NWrV6O29RpNr1rQr/KwYcCgQZb2KYD1Gwu27JzAhg1Pgyybi2Qou3TJ8nv+Cflx4saJuD8sbbkUDQp7EJBKK+iyFLpYMVsn7dtKnfrp55LUmIUESEA3AhTAuqGPa5gCWP8x0NIDCmAt6SZG29d3A6utUh4lCQFaPQ4KEloL4EWLjqBp0/ibWcuUyYoVKxoje3bvl4mL+JVl0TLbe9YqBG3JkiWxd+9ej5dYG2mA7AVww4aSYspIHtIXEgB+/x2oWdNCIlMm4MoVy+/Pjn8WJ2+ejPvDspbLUL+wzisy5M2SXGCuyty5QPPmHGISIAEdCVAA6wjf1DQFsP5joKUHFMBa0k2Mtq/uANZWsPQ8WQTQwvlSXSMh0loAS1/nzz+MN95YiUePYmy6nidPaqxc2RTFi2fyCcnjx4+xYMECfPnll9i9ezdmzZqFdrLk0UGR9BpSv0qVKoYUyEOHAoMHWxxv1AhYvNgnLDyIBDQjsGkTUL26xXzGjMDVq5bf847Li9O3Tsf9YXmr5ahXqJ5m/nhk+L//ns4CuypccuERSlYiAS0JUABrSdcz2xTAnnEKplrpAMiPlMNhYWFhroLqBFPH6KsBCFzZCqyrbHEkNA3w+i0DOObehUAIYPFi69bzaNhwCa5de2DjVNq04Vi0qCFq1szj3lknNSR10qZNm5Ro0JIv2FGpXLkytm7dinLlyqFXr15o2rQpQkKMs0ebAtjn4eeBASSweTNQtaqlwfTpAVllbC7PjHsGZ26dift9RasVqFuobgA9dNJUmTLA7t3O/QgNfRrNSxQ9CwmQgC4EKIB1wW7TKAWw/mOgtgefAvjEbFQixUZHR6vdBu0lVgLR94G7J4Enj4HYx8CTJ0Cm8kFBI1ACWGAcPXoDr766EMeP37RhExKSFNOnv4L27Utowkxmf+1TJeXJkwfvv/8+3nrrLaSXp3idy5AhwMcfW5xo3BhYtEhnp9g8CdgR2LIFqFLF8se0aYGbVpdznrF5cPb22bgKK1uvxKsFX9Wf41dfAb16ufZj2jSgUyf9faUHJJBICVAA6z/wFMD6j4HaHnAGWG2itJcgCARSAAuwK1fuo0GDxfjrL6vcKSaSAwdWxOef/w9Jk6p7C27WrBkWLlzocLxSpEiBDh064IMPPkDhwoV1G9PPPwc+iXtFBzRpAjhxWTcf2TAJbNsG/O9/Fg4SP8o6Hl3usblx7va5uAqr2qxCnQJ19Ad34QKQK9fTl5POimyfmDVLf1/pAQkkUgIUwPoPvLpPX/r3hx7YEuAeYJ4RJGAiEDEsAg+jH8bx+Lvz3yibo6ymfB48eKzsCV648Gi8dlq0KIwZM+ogIiJUNR++/vprjB49GqdOnXJp87XXXkP37t1Rq1atgO8TthfATZsCCxaohoCGSEAVAn/9BVSqZDGVKhVw547l95xf5cSFOxfi/rC6zWrULlBblbb9NiK5ftevd26mbFng77/9boYGSIAEfCNAAewbNzWPogBWk6bxbFEAG29M6JFOBPQQwNLV2Ngn6Nt3E8aMif/AWbFidixd2ghZsqRUjYpseVi8eLEihHfs2OHSbrFixRQh3LZtW8gMcSDKZ58Bn8pGDVOhAA4EdbbhLQG5dCpYxfuTy+PePYuV7GOy4+Ldi3F/WNt2LWrlt0oc7G2Data332dgb1s6I2o+aVI1W6UtEiABDwlQAHsISsNqFMAawjWAaQpgAwwCXTAGAb0EsLn3U6fuRbduvyEmxnZp4kcfVcCwYVabDVXCJQGz/vrrLyWfsCyLjomxjUxt3UyGDBnw6aefKnuFtS4ifkUEm0uzZhI9W+tWaZ8EvCPw4AFw5gyQLNlTnShx5PJYxa+TAFjRsdGIfRKr/ORMnRMpw9R7keWdt3a1ZVO9vFlyVY4fB5591q9meDAJkIBvBCiAfeOm5lEUwGrSNJ4tCmDjjQk90omA3gJYur127Sm8/voy3L4dpVB4+eVnsHJlE4SGJtOUiuQQluXR3377LW7cuOGwrQkTJlAAazoKNE4CASJw+DBQpIjrxpYtA+rrnLc4QDjYDAkYjQAFsP4jQgGs/xho6QEFsJZ0E6Ptx3eAB7LvLSmQJCmQNAxImTsoSBhBAAuo/fuvoF69xUiZMhRbt7ZCunTJA8bv3r17+PHHHzF+/HgcOnQort00adLg3LlzSC2RfjQuEgBL9gGby+uvA/PmadwozZNAYiIgmR9SpgSinr5oc1i++ALo3z8xUQlIX5Mk8e6x+plnnlFiNshPvnz5UK1aNWzcuNGhrwcOHMDEiROxfv16nD9/HqGhocox9erVQ48ePZApk2955gMCho3YEKAA1v+E8O5K1d9feuAdAQpg73ixtjsCZxcDm5tYaqUuCNQ/4u4oQ3xuFAEsMC5duocHD6KRN29aXdjExsZi3bp1yvLo1atX48MPP8SYMWMc+rJv3z4sX74cnTt3RubMmf32V1IgyRZFc6EA9hspDZBAfAKlSgH79jkn07Yt8OOPJKcyAYm0b1+2bNmC48ePo3Tp0njuuedsPhbRag5c6EoAjxw5EgMHDlS2skgU/1KlSiEqKkrZ5nLp0iWkS5cO8+bNUwIbshifAAWw/mNEAaz/GKjtAdMgqU2U9iwEziwEtjSzEsCFgPqHg4KQfRqknZ134oUcLxjS9zNnbiNjxuRImTJMc//+++8/pE2bFjly5HDYVseOHTFjxgyEh4ejdevWShol+4c4b5wcPBgYOtRyRPPmwNy53lhgXRIgAbcEWrUC5sxxXq1iReDPP92aYQX/CYgonjVrFj755BMl1oKj8vjxY0UkSzBCyd1uXWTFjszwSh53WcFTt27duI9FEIuAHjBggDIjvHXrVrzwgjG/1/wnmXAsUADrP5YUwPqPgdoeyN01LstmsmTJIFFhWUhAFQJnFgBbXreYSlMEqPefKqa1NhLoPMC+9ufGjYeoWHG2skR6+fLGyJlT+2XJzny9cuUKcufOjUePHtlUqVq1qiKEGzZsiBCJDuRFsRfALVq4fk73wjSrkgAJmAnY7zWwJ1OgAHA0fno2AlSfgCcC2Fmrp0+fVmZ8ZbZXlkbLvddRGTp0KAYPHgyJ7L9///6Ap7dTn1rCtkgBrP/4UgDrPwZqe8AZYLWJ0p6FAAWwpmfD48cxqFNnITZsOKO0kyNHKkUElymTVdN2nRkfPny4suzOWZGZim7duqFTp06QSNKelEGDgGHDLDUpgD2hxjqBJiDbZ48cAeT9sfmnXLmnUaGl7Dy/UxEZyZIkQ7KkyVAwQ0FEhEYE2k3n7U2cCHzwgfPP06UDnATEM04nEoYnnghgZ3uA+/btiy+//BLNmzfHXBdLZWQGWZZQy97gX3/9FZLrncW4BCiA9R8bCmD9x0BLD7gHWEu6idE2BbCmo/7hh79j7NhdNm2kSBGC2bProlGjgpq27cj43r17MXbsWPzyyy/KDISzEhERoeQSljRKJUuWdOmn6Onhwy1VWrYEfvkl4F1jgyTgksDZs7Zpj6Ty7duAOU5c+NBwRMVYroldb+9CmexljENVLqrWrV37I9d0aKhxfE6gnvgjgEuUKAEJfrVkyRJlxY2r0rNnTyWuw3vvvacEy2IxLgEKYP3HhgJY/zHQ0gMKYC3pJkbbZ+YDW5pbes4l0KqeBUeOXEfduotw7NhNG7sSWHTkyKro3bucLkvbJMiKpFCaPHkyLl686LLPNWrUUJZH169fH7IFw7589BEgAWjNRbYq/vyzqhhpjAT8JhAZKSswbM1cvw6kT//0byGfhyDmiSW39p539qB0ttJ+t6uagXXrgFdecW1OruWs2q0ukWB7165dU61LgTSUMWNGJJUE0CoUXwWwvHQUoSQ53SWVXa5cuVx689NPP+GNN95A5cqVsXnzZhU8pwmtCFAAa0XWc7sUwJ6zCsaaFMDBOGpG9jmeAC4K1DtoZI/jfAuWPcDXrj1A06ZLsWnTuXhc33qrJCZPfhlhYdrmDXY2oPJAtnDhQiWN0vbt212Ou8xcyAyy/UOkvQCWSarZs4PiFKKTiYjAlStAliy2Hb58GTAHQk/yme3j076u+1AiSwnjENq9GyjjZkZ6/36geHHNfJYYAlnsIWrWmrqGL1++rErUe/HKVwEsLx6zZcumdEziMISFuQ6KuGbNGtSpUwdFihSBBDdkMS4BCmD9x4YCWP8x0NIDCmAt6SZG2xTAARn1qKgYdOmyDjNm7I/XXo0aubFgQQNkyKDvfkMRwLLMTlJvyP4z+9K1a1dlxti+DBgAjBhh+SsFcEBOKTbiJQHZHmu/rf3CBSB7diD2SSySfW77EurguwdRNHNRL1vRsPqZM8Azz7huQPLNVqummRMUwE/R+iqAZbVNdjnhADx8+FCJxO+qSEq7V199FUWLFsXBg8HxYlqzk8/ghimA9R8gCmD9x0BtDxgES22itGchEMQC2H7P3t+d/0bZHGUNO7qy7G3UqB3o3z/+UrZChdJjxYomKFjQtB5Tx15ERkZiypQpyo/MmpiL7FuTiKT2pX9/Wc5t+WubNsBPP+nYATZNAg4I3LkDpElj+8Hp00/3BT+OeYywobazcYffO4xCGQsZh+X9+0DKlK79WbgQaGKV111l7ymA/RPA1kugz5w5o0Tkd1UkRVK7du24BFrl81gLcxTAWlD1ziYFsHe8gqE20yAFwygFq48JSAAbLmiNk3Ni0aIjaNt2JR48sE1nlj59cixa1ADVq9vmjNTr1JIlejIbLMujJSL02rVrHbrSvftDTJiQPO6ztm2BH3/Uy2u2SwKOCTx8CETYLbI4dgzInx+4//g+Ug63FZcnPjiBfOnzGQunLJl1sDojzsmZM4H27TXzmQLYPwEsRxcvXlyZzV28eDEaNWrkcqwkV7DcfxkES7NTWjXDFMCqofTZEAWwz+gMeyBngA07NAnAsSAOgmX4qK0uTo+//76IBg0WIzLynk2tkJCkmDq1Fjp2dB15OZBnnsxc37lzB2nsp89MTtSosQMbN5aPc6lw4e1YujSdkuuShQSMQiAmBrBPcS2rSosWBW49vIV0I+Wr1lLO9DiD3Gldz9AFvG+yhttVqqNJk4Bu3TRzi0Gw/BfAvXv3xpgxY7xKg7RixQrUrVtXs3GlYf8JUAD7z9BfCxTA/hI09vHcA2zs8Qk+74I4DVIwC2A5Uc6du4P69Rdjzx7LMmPzCSRpklq3NtD+QydndkxMDDJkmI7bt9+xqvEDgPZK8BaJHl27dm3Voq8G3wVGj41EQASwCGFz2bMHKF0auHb/GjJ9mcnG1chekciW6mnAIsMU2QMse4GdFdmM36+fYdxNqI74ugdYeJw8eVIJaiVxFjZu3IiqVas6xDR06FAMHjxYqSvbT9SKYJ1Qx0TvflEA6z0CAAWw/mOgpQcUwFrSTYy2zywEtjSz9DyI0iCFDQnD41hLsKZgWQJtfZrdvRuFNm1+xbJlx+P+XK5cNmzc2AIpUhg/n+e6devwyit7APSx6tYsCRMT93vBggWVfMLy0JjanHQ1MV5r7LPuBFKkAB48sLixYwdQrhxw8e5FZB/zNDiRuVztcxUZU2TU3WcbByTCs6tgSIMGAUOGGMvnBOiNPwJYcHz11Vfo1asX0qdPD9nnaz27Ky8V5fN+/fohJCRESX9UoUKFBEgxYXWJAlj/8aQA1n8M1PaAS6DVJkp7FgLxBHBhoN6hoCBkL4D/efsfPJ/9+aDw3drJmJhYDBiwGV9+uRO5cqXGjh1tkD17qqDohyyPbtXqHObOtV4qOhPAm/H8F/HbsWNHZT9bgQIFgqJ/dDJhEUiXDrh1y9KnLVuA//0POHvrLPKMs917f6v/LaQJt4uapTcOEUKi2p2V7t2BceP09jLBt++vABZAw4YNwyeffAIRvDLLW6pUKUiQrD///BOSLilt2rSYM2eOspKGxfgEKID1HyMKYP3HQG0PGARLbaK0ZyFwdhGwuanl9zQUwHqdHt9/vw9lymTFc8/ZJSvVyyEP2+3VS2Y0LJXDwn5GVFQbp0cnSZIE9erVQ/fu3VGzZk3I7ywkEAgCksJW8gGby4YNQI0awIkbJ5B/Qn4bF+59dA8pQlMEwi3P23j5ZWD9euf133oLmD7dc3us6RMBNQSwNLxv3z4l9dz69etx4cIFhIaGIl++fMqMsATACtacyz5BDfKDKID1H0A+Seg/Bmp7wBlgtYnSnoXAg0vADVnCCkCESEhKIPP/goJQ6JBQRMdaIikH6wywp7AfP45BaKhtrlJPj9Wy3ocfAmPHWlp4441oVKkyAxMmTMD+/fHzHlv78u+//6JkSeME/NKSE23rTyBXLuD8eYsfq1YBMsF2+OphFPm6iI2DUYOiEJrMYNsQJGrw0qXOQTZvDsydqz9oekACiYwABbD+A04BrP8YaOkB9wBrSZe2g4qAvQDe/c5uPJftuaDqg6fO3r//GDVrzkOTJgXRp085Q82a9uxpu+qyY0fgu+8AWR4tQV5ECC9dulT53bpUqVIFf/zxh6cIWI8E/CYgK++PW7bbY/FiQDTlvkv7UGpKqTj7SZAEMR/HGOo6U5yTHGOzZzvnIJGCV6zwmxMNkAAJeEeAAtg7XlrUpgDWgqpxbFIAG2cs6InOBEI+D0HME0tI14QqgGNjn6BFi+VYsOCIQrxjxxL45ptaCAszxmxwjx7A+PGWk8HRKkyJfPr1119j+vTpuGXahLlgwQI0bWq1/N7qfLp+/bqSe5iFBNQkUKqULDu1WBQt2bo1sPP8TpSfbknllTwkOR4MtIqWpaYT/tjq2hWYMsW5hWrVgI0b/WmBx5IACfhAgALYB2gqH0IBrDJQA5jjEmgDDAJdMB4BewG85509KJ2ttPEc9dOjgQM3Y/jw7TZWqlfPjYULGyBDhgg/rft/uL0A7tQJmDbNsd27d+/ihx9+wJIlS7By5Uolyql9kVyjxYsXR7p06ZR9cE2aNFH2xrGQgL8E7GNIyXZZeWGz5cwWVJlRJc582vC0uNn/pr/NqX98nz7A6NHO7ZYtC/z9t/rt0iIJkIBLAhTA+p8gFMD6j4HaHjAIltpEaS9BEEj2eTLEPomN68veLntRKqtlGWOC6CSAUaN2oH//P2C3ghgFC6bHihWNUaiQvjOlEnh2wgQL7c6dgW+/9Z3+6tWr8eqrr8YZyJkzpxI5unPnzsiY0WBpaXzvJo/UgYAEUJY0SBERgKREkj3BEhn6XtQ9HL9xHA+jH+JR9CPlvlItbzUdPHTT5GefAZ/KI4GTUrgwcCg4ovgbDy49IgHfCVAA+85OrSMpgNUi6Z8dyWzeC4BsSJTcCp8BcPGt5bIxzgD7NxY8OoESSPpZUjyBZV/pv13+RcmsCTOg0uLFR5V8wQ8eWIJ+ybCmT59cmQmuUcM2hUsgh/yDD4CJEy0tvv02MHWq7x6I+BURbF8iIiLQtm1bZVa4WLFivjfAI0kgWAmMGQP07u3c+5w5gXPngrV39JsEgpYABbD+Q0cBrP8YiAevAZD1VBJeV5LyyeOgrwLYukfcA2yM8U04XkgU5Zj7ErEIUMRkEiAsbVD0LzEJYBmQXbsuon79xYiMvGczPiEhSTF1ai107KiP+H//fWDSJItL77zjepuiq5Przp07KFGiBM6cOePyHKxduzZ69uyJV155xXiBioLi6qGTQUlA3ix16eLc9bRpgZsGXLodlLDpNAl4ToAC2HNWWtWkAHZPtiyAWgAk4kUFADkAPAKQ3M2h8vkAAK1Ms7rXAcg0xccAXL1yPQVgph8CmDPA7seUNXwlcH4lsKmu5egUuYFGrsWHr02pfVySz2xvd/u67kOJLCXUbsZQ9s6du4MGDRZj9+7L8fzq27ccvviiKpImDezXwHvvAV9/bXFHns+/+cZ3bNHR0Vi8eDHGjRuHbdu2uTQkM8EyIywzwzJDzEICCZqARO2SSNDOSh55KGcAACAASURBVNKkQHT005R2LCRAAgEjQAEcMNROG+Jdz/0YLAHQ0K6aOwEs4leyz78IIBLAZgB5TSL6CoBKAKySK9hY91cAcw+w+zFlDV8JXFgNbLTst0SKXECjs75aC+hx9gJ4f9f9KJ6leEB90KOxu3ej0LbtSixdeixe85Im6ccfX0OKFIELGtWtGzB5ssUVCVRr/bs/jP7++2+MHz8ec+fOxePHj52aypQpE7p06YJu3bohW7Zs/jTJY0nAuASWLwcaNHDt3927QMqUxu0DPSOBBEiAAlj/QaUAdj8G/QCkALDT9HPRgxngzwEMBvAngFcA3DU18yGAMQAkmaWziBn+CmDOALsfU9bwlUDkWuD32pajI3IAjc/7ai1gx0lO2aSfJ7Vp78C7B1Asc+LYGxoTE6sExho9On7E17Jls2LZssbIkSNVQMbj3XdtZ3zld+sZYTWciIyMxOTJk/HNN9/g2rVrTk3OnDkT7du3V6NJ2iAB4xHYtAmoXt21X+fPAzlkYRsLCZBAoAhQAAeKtPN2KIC9HwPZ+OhqBlimUmS9oQjRMgB22zWxF4CEnn1Btuk5aJ4C2Psx4RGBIhC5Dvhd3umYSkR2oPGFQLXuczsSpVWiQFuXg+8eRNHMRX22GYwHTp/+L7p2/Q3R0ZZo2NKPXLlSY+3aZihaVPuoyfapSWVG2HpPsJpcHzx4gJ9++gljx47Ff//9Z2NaZn5PnTqF8PBwNZukrQREICYGuH0buHPn6b+ShatIEeDCnQu4/uA6UoWlQsrQlEgdnhqSC9hwZc8e4PnnXbsl14V0ioUESCBgBCiAA4baaUMUwN6PgTsBXAPABtMS5wIOzMvMsMwQO4v07K8A5hJo78eUR3hK4OJ6YMPLltrJswJNZFGEsUtMbAxChtjmkE2MAlhGaf3602jWbBlu3pT3eE9L4cIZ8OefrZUo0VoX2fNrHfVZ9gRbR4XWon1ZAbBmzRpFCK9du1ZpYsiQIRg0aJDD5i5cuIC0adMiJZeGajEcQWNTXsxI0DZzqVYN2LgRGPDbAIzYOiLu761LtsbsJrON168TJ4D8+V379ddfgCQ8ZiEBEggYAQrggKF22hAFsPdj4E4A9wAwFsB8AM0dmJcIQisAyN7ixg4+91cAcwm092PKIzwlcOl3YH1NS+3wzEDT+AGWPDUXqHrRsdEIHWK7z/W/bv+hSKbEOfNx6NA11Ku3GMeP30SGDMmxfXsbFCiQPiDDIWmPpk2zNCUCwzovsNZOHDhwABMmTMCwYcMge4Edlddffx3r16/H22+/jffffx+SW5gl8RH44QfAeoW8TKb+8w/wwaoPMHGHJZdX5zKd8W19P5JZa4X26lUgc2bX1tesAV6xWtWjlS+0SwIkEEeAAlj/k4EC2PsxcCeAvwLQ0ySCZc+vfSltSnf0DwCJMC1FNt+ZZ4tXAlgGYAqAKAAHvXcx7gimQfIDHg91QODSJmC91Z6y8ExAU4nrZuzyOOYxwoaG2Th5qNshFM5U2NiOa+jd1av30arVrxg8uCKqVs2tYUu2pjt3BqZPt/xN8gKPHx+w5t02dPLkSRQoUACxsU+XiYeGhqJ169bo1asXSpbUJ3WUW6dZQRMCS5YAja1eU8tk6rFjQMelHTFjz4y4NntW7ImvastXv8FKVBTgbon//PlAs2YGc5zukEDCJkABrP/4UgB7PwbuBLC8Bu4MYBgAR+vrROgeBXBEVh6amhdF8bsDV06boke78/KAkwpFw8PDkzx8+NDd8fycBDwjcPkP4Der+G1h6YFmkuHL2CUqJgrhQ233eh5+7zAKZSxkbMc19k6WBicJcAqUTp2A776zdKx7d2CcZD83SPnwww+VpdKOiuQT7t27N1566aWAczMInkTlxoYNwEsvWbqcMSMgk6rN5zfH/IOyyOtpGVRlEIbUHGJMNpLuy9UzgCzHkIuShQRIIGAEKIADhtppQxTA3o+BOwEsi/vk22SoKRK0fQsFTeLXWgB774XtERTA/hLk8Z4RuLIVWFfZUjc0HfD6Dc+O1bHWo+hHSD7Mdn/r0fePokAGR9v0dXTUQE0/fhyDHj1+R+/eLyBfPtlZoU556y3g++8ttnr0AJzoTXUa9NJKmzZt8PPPP7s8qnTp0ooQbtGihTJDzJIwCezdCzz3nKVvkjZXJlXr/FwLv534Le6D0bVGo9eLvYwJQZbvX3ARqHDkSKBvX2P6HqReNW/eHPPnz8fnn3+OwYMl7Ivz8scff6BatWrIlSsXTp8+jaRykgFKGrfp06dj3rx5kG0bt27dUrZsVKxYEW+++Sbq1asXpHTothCgANb/PKAA9n4M3AlgX5ZAe++FZ0dwCbRnnFjLUwJX/gTWSXprUwlNA7x+y9Ojdav3MPohIoZF2LR/7P1jyJ/BTYAY3TzWt2GZGZZo0VOn7kXmzBFYurQxKlVSJ1VKx47ADMvqUfTsCXxlsNWjhw8fVmaBZ82aBVcraOShtXv37ujcubMSNIslYRGQDEG5ctn2SWaAay98AbsiLUkcvmvwHTo+39GYnZdl+/v3O/etXz9ghCWglzE7EVxeLV++HA0aNEDhwoVx6NAhl86/8847+Pbbb9GvXz+MMI2DCOHXXnsNBw8eREREBCpXroyMGTMqAnn79u3K9oymTZsqEe5FSLEEHwEKYP3HjALY+zFwJ4D9DYLlvUfOj6AAVpMmbQFXtwNrK1pIhKQEmpvTXBsX0P3H95FyeEobB098cAL50uczrtM6ejZ27N/48MONcR6EhyfDzJmvomVL/4OGvfkmMHOmpXO9egGjR+vYWRdNX7lyRcknPGnSJFwV5eOkpE6dWgmYJWI4d+7A7ac2JrWE49WjRzJTY9sfyRpUd21+nLhxIu6DRc0XoXFRRzEtDcBCQlf/8YdzR2RT/rcGDOBlAHS+uiCztzly5FDuGTt37sQLL0jWy/glKioKko7txo0b2LdvH0qUKKHM9D733HNKijZZYSK5zNOntwQoFEHdsmVL7N27F40bN8aiRYt8dZPH6UiAAlhH+KamKYC9HwN3AtjTNEiSCukT75v36ggKYK9wsbJbAtd2AmvKW6oliwBa3Hd7mN4V7kXdQ6ovJNacpZzsfhJ50+XV2zXDtR8VFYPy5X/C3r3xg5t99tmLGDy4kl/7XyWqrkTXNZfevYEvvzQcBhuHJJ/wDz/8gDFjxuDoUQnh4LjI/mGpw5JwCKRJ8zQPsLls3gw02JoBNx5atn783v53VM9rFRzQSN2XKF4SzctZadoUWLDASB4nCF8kery8OOvRo4fTmAJLlixRRKwI3t27dyv97tKlC6ZOnYpXXnkFq1atilsSbQ1FhLUE5Lt48SLmzJmjCGWW4CJAAaz/eFEAez8G7gSwhJqVvDCyHq4MgKd3NUvZC6AUAFERO71v3qsjKIC9wsXKbglc3wWstnqbnTQcaGn8IGt3o+4i9Repbbp3qvspPJPuGbddTowVbt9+hBYtlmP1asnKZlvati2G6dNfQXi4bV5lTzm1awf8+KOldp8+wKhRnh6tbz1ZerhixQqMHj0am0UJWZVkyZLhxIkTyJMnj75OsnVVCTz7LHDypMXkwkWxaPZvCJ5AHgWelj3v7EHpbJLgwYDFftO9vYvVqwO/O4rBacC+BJFLO3bsQIUKFZQZ3nPnzkHuD/alWbNmWLhwoXI/kSjz165dU/YCy7YLWf5ctGhRpz2WmeF3330X5cqVg7TFElwEKID1Hy8KYO/HwJ0AFosSAGsggG0AJMHePVMzkhZJpge2AKjifdNeH0EB7DUyHuCSwPXdwGp5r2MqSUKAVo8ND+32o9tIO8J2j+aZHmeQOy2XqzobvOjoWHTvvgGTJ++JV6Vy5ZxYvLghMmVK4fXYv/EG8NNPlsMk/o7E4Qm2InvxZLZXHmBFGEuqpNmzZzvshjzQSrAsRw/BwdbvxOZv+fLATqtX1eOm3ESPi7Y5s0/3OI08aQ364kMuMFdLLEqVAiTalxblSSzw6JoWlrW3GZ4RSPI0IJWvpUiRIpB4AmvWrFFmdK2LLHUWcSzLoM+ePassmV6wYAEkB7n1jLCztmXZtOwLlngNMiMs/2cJHgIUwPqPFQWw+zGoaxfNuQKgvPq1fuUm+Q9+tTIlu4ZkA53UjQQgUwUy1SS/y7eBbKI85r5pv2tQAPuNkAZsCNz4F1hlPdORBGj9NF+qkcuth7eQbqRtJOOzPc8iVxq7CDdG7oQOvsnD1cSJu9Gz5++IjbXMeIkr+fOnw6+/NkHhwhm88qxtW8BaJwZ7DB6Z9R03bpwSmfX55593yOKLL77Ad999hz59+qB9+/YMXOPVGaNv5bp1gZUrLT70/Pw4xsbaRo+/M+AOUoXZbrHQ12ur1iWw0oABzt3JkQOQaF9alIdXgEVZtLCsvc0ml4Hkmf1qZ+jQoUoU6DfeeEPZQmFd5H7QqVMn1KpVC2vXrlU+GjRoEIYNG4a33npLiQDtrki+8uPHj+O3335TUrOxBA8BCmD9x4oC2P0YdABgFbPU4QFvArAK66LUkZCz8q3TGoBMM8mGodUmMX3WfbOq1KAAVgUjjcQRiLoBnFv+9M248nY8KZC3peEB3XhwAxlG2Qq18x+eR47U6kQ2NjwAPx1cseI4WrZcgXv3bGf706dPjkWLGqB6dc9nv9q0AayzDMmz+fDhfjpo4MNl/3DevHlx+bLsjAGyZs2Knj17Knv9GDnawANncu3ttwFJlWsuDd7bgmWZLAu4UoamxN2PDBwIUJJuu8rzGxICSLQvU/odVUckkQtgCWT17LPPImXKlLh06RJSpLCsmKlZsyZ+//13RRiLQJbStWtXTJkyBQMGDMBwD26KlSpVwl9//cV9wKqetIExRgEcGM6uWqEA1n8MtPSAAlhLurQdNASuP7iOjKNsl4hF9opEtlTZgqYPeju6d+9l1Ku3GOfOWUUEAhAamhTffvsKOnQo4ZGLrVoBc+ZYqn70ETBsmEeHBmUl8149e+fTpEmj7OGTyNGyFJLFmASGDAE+/tji2/Nt5mN3weZxf5Bc4pJT3LBlxQqgfn3X7kmEcy2W0CZyASzQq1atqsQLkNzireTmB5lwP6/EChARJMI4VaqnqwfMAbD69+8PWTXirkhOYNmKMXfuXEjuYZbgIUABrP9YUQDrPwZaekABrCVd2g4aAlfvX0XmL22Xs13sdRFZU2UNmj4YwdELF+6ifv3F+OefS/Hc+eijChgypDKSJnX9tdKyJTB3ruXwQYMAERkJtciePtnb56yEh4cry6d79+6N/PmZl9po54Gk7JLUXeaSvfF4RJaWbIdPS9VnqmJTh01Gc9vij2xglo3MrsrBg4CLgEs+d44CGNOmTVNSpNWtW1cJoCflyy+/RN++fdGmTRsll6+5mJdAd+zYUdky4a7I/UK2YHAJtDtSxvucAlj/MaEA1n8MtPSAAlhLurQdNAQu37uMrKNtxe7l3peROaV/e7yCBoCKjt67F4U2bVZi6VLbMAY5cqTCnj3tkDmz68BYkrFj3jyLQ4MHA59LUrgEWmQf9fr16zFixAjlX2cladKkyixOv379lCA4LMYg8NtvQK1aFl/C6/XHoxcsUdtaFG+BOc2sljQYw22LF6dPA3ndpHuTKNASDVrtksiDYAnOmzdvKis8YmJicOHCBWTOnBmlS5fGv//+q6Q5qlOnThz1+fPnK/cA+XzPnvjBB62H5/r168iUKZMSBEvylcv/WYKHAAWw/mNFAaz/GGjpAQWwlnRpO2gIXLp7CdnG2C4zvdLnCjKl4EODL4MYExOLvn034auvdimHp0gRgs2bW6FMGfcz6rJSb/58S6uffAJ8+qkvXgTfMTt37sTIkSOxaNEi5cHVWZGH4oEDB6Jy5crB18kE5rFs3V66FMidG8iVC0if9S7uJDmHC3cuIPJOpBJHoEa+Gsbt9cOHQISEJHFRZE8Cc8lqNobmVSCSF7h69eooUaKEEgtAlkJbR4aXNEg5c+bEo0ePcODAARQrVsypT5MnT0a3bt3wwgsvQO4rLMFFgAJY//GiANZ/DLT0gAJYS7q0HTQElAfVr2wDXl3rew0ZIryLYBw0HQ6Qo1Om7EH37r9j/vz6aNDANjKuMxeaNQMWLrR8KuJXRHBiKpIaRZZBSgCcx4+dpxGT/cESYZqFBPwikDYtcPu2cxPjxwMffOBXEzzYOYFly5ahYcOGkD271apVU16C9ejRA2PHjo13kCyXlmXTkjZJZohlZYh9kbRHJUuWxMWLF232FnMMgocABbD+Y0UBrP8YaOkBBbCWdGk7aAicv30eucbapjy63vc60kfY5vMMmg4ZyFEJipUrV2qPPWraFFi0yFL9s89sgwx5bCgBVJQZIHkInjp1Ku7ejR9JWPYMyt5BFhLwi0ChQsBRF4G6gj0XmV9wtD9YXnJJnl9zvl6Z6d21axfKlCkTr3HJ7ytbIM6cOYMWLVpAguilT2/5npKXZ/L3vXv3okGDBlgqyxNYgo4ABbD+Q0YBrP8YaOkBBbCWdBOj7fvngGUSqOcJoCzhfAI0uw6EpjE0jbO3ziLPONtUPbf630KacGP7bWioHjgny3w3bTprkyapcWNgyRLLwRIASwJhJeYi+/lkSeP48eOVh2Qp8nD8999/I0kSfk0n5nNDlb7XqAFs3OjcVOvWtsm5VWmURqwJvPfee/j666+VPxUtWhQHJfCYk3Ly5Em89tprOHToECIiIlClShVkzJgRp0+fVtIexcbGolGjRsrsr3zOEnwEKID1HzN+s+o/Blp6QAGsJd3EaFsE8BJJa21Vmt0EwtIamsbpm6eRd7xtIJg7A+4gVdjT9BMs2hD49NOt+OyzP2EdIbpRo6d7Ks1l6FBg4EBt2g82q/fv31eWP44aNUoRxLJs0lGRh2AJfFOvXj0K5GAbZD38bdcO+PFH5y1XrQpsMnAkaz2YqdympCuSJdBShg0bho8k/5uLEhUVhenTp2PevHnYv38/bt++rQS6qlChghI1XmZ/WYKXAAWw/mNHAaz/GGjpAQWwlnQTo+3754EltkuJ0ewGEJbO0DRO3jiJZyc8a+PjvY/uIUWo64jFhu6UwZ374YcDaN9+VZyXLVoUxsyZr6J58xAsX25xfvhwYMAAg3cmwO49fPgQkh7J0eyvzKpLbtEtW7bg+eefx+DBgxWh7GivYIDdZnNGJSBiy1Ve2Xz5gBMnjOo9/SKBBEeAAlj/IaUA1n8MtPSAAlhLuonR9v0LwJKctj2XJdBhxt5Le+z6MRScWNDG7wcDHyB5SPLEOIqa9/nkyZsoXPh7PH4ca9PWiy/mQKpULbB2bbK4v8tzef/+mruUYBrYuHEjasiSVqsiAXEkh2jTpk1tosommE4boCOxscC6f/dix+GzwPUC6Ns5H8JDwg3gmQcufPMN8O67ziuGhgISLdpBwCUPrLMKCZCAlwQogL0EpkF1CmANoBrIJAWwgQYjQbjyIBJYbBtNGU2vAuEZDd29I9eOoPCkwjY+Rg2KQmiyUEP7HczOTZ26F926/YaYGNt0PxERzfHggWU/9siRQN++wdzTwPr+0ksvYcOGDQ4blb2Fn376KZo1a8YZYRWH5eRJoEQJ4H6VnkClp1G5kyZJiq4vdMWk1yap2JJGplasAOrXd208MhLIZpsqTiNvaJYEEj0BCmD9TwEKYP3HQG0PZC2qeT3q4bCwsDDJKcdCAqoQeHARWJzd1lSTK0ByY+fTPXT1EIp+XdTG7+jB0UiW1DITqQofGrEhsGbNSbz++nLcuRNl9fcmACzL0UeNAvr0IThPCMjy59mzZ2Po0KGQaLDOSunSpZV9hhJIh0G0PCHruk5UlOS6BmJa1AMK/RpXeVCVQRhSc4j/DWhtYc8e4PnnXbeyYwdQrpzWntA+CZAAAApg/U8DCmD9x0BtDz4FEJdVU5KsR0dHq90G7SVWAg8uAYvtZgmaXAaSZzY0kYNXDqL45OI2PsZ8HKPM4rBoS2DfviuoW3cRzp69Y2qoKYB8cY1++SXQu7e2PiQ06zExMZg/fz6GDBniMppspUqVMHz4cFSvXj2hIQh4fwoXBo689gyQ7kxc27MazUK70u0C7ovXDV67BmRy85Jy7lygeXOvTfMAEiAB7wlQAHvPTO0jKIDVJqq/Pc4A6z8GCdcDh0ugrwHhGQzd532X9qHUlFI2Pj75xHZprqE7EOTORUbeRf36i7Fr1yUAzQBYInLXrn0Sq1bl5UylD2Ms6VAWLVqkCOF///3XqYWXX35ZmREuX768D63wECHQqM0VLC2UxQbGvq77UCJLCeMDkpR16dIBt28793XYMMBNZGLjd5QekkBwEKAA1n+cKID1HwMtPeAeYC3pJkbbQRoFes/FPXh+qmUJYLIkyRD9MVdGBPIUvncvCm3arMTSpc/ZCGBgA9q1e4hp02ojLIxL0n0ZExHCS5YsUSJCu8ovOmvWLLSTlDgsXhPoNGI1vnv0atxxSWIiEPXpbYQkDfHali4HlC0L/POP86bffBP4/ntdXGOjJJDYCFAA6z/iFMD6j4GWHlAAa0k3Mdq+dxZYaglgpCB4/RYQmsbQNP6J/Adlvy0b52No0lBEDbbel2po9xOMczExsciX7xbOnrWOGr4ewG5Ur54bixY1RPr0jMzt64DL0uiff/4Zn3zyCU5K5CarkjZtWuVv6dMbO2K7r33X+riOM4dixunBFgF89kU8+HorwoMkEDRatADmzXOOqUoV4I8/tMZI+yRAAtwDbIhzgALYEMOgmRMPw8PCwh/eOgfIXkdlv6Pp37j/yylg/bckQBKeFpqNSLAbvncaWGpZvvpUAN8BQlMZumc7z+9E+emW5Z+S/kjSILEEnoBk8Nm40brdpwJYSsWK2bFtW2suh/ZzWKKiovD9998rS6MvXLigWJPAWQMHDvTTcuI9vN5PjfHr8SUWAH99gL+HjodMrAZFGTQIkGXOzkr27IDpXAmK/tBJEghiApwB1n/wqHT0HwMtPXgYHoLwh7O8bUJEsFkwm/4fTzjbi2Y7cZ0kGZChHFBmNJAil7cOsL5RCdw9CSyzRPBV3Gx+HwiJMKrHil/bz21Hxe8qxvmYMjQl7n5019A+J1TnqlWzn2j6DcAehIQkxZo1zVCzpt0Kg4QKIgD9evDgASZPnqyI4e3btyNVKscvqiS3sESO5uyw80HJPTY3zt0+Z6mweBamdG2Hd94JwECq0cTMmYAsc3ZV7t4FUqZUozXaIAEScEGAAlj/04MCWP8x0NIDHwWwii7lqAdUX66iQZrSlcCd48DyArYutHgIJDP2OsBtZ7fhf9//L87v1GGpcXuAi4AwukJO2I1XrQps3mzpY5o0m3D79k7MmFEHHToEQUChIBwe2SOcNKnjiOdXr15FgQIFIBkDZOl0165dERrK/NjWw3zx7kVkH2OX/u3rA+jUsBimTQuSE2LLFkCWObsqu3cDz8kefRYSIAEtCVAAa0nXM9sUwJ5xCtZa+gvgdKWA1/YGKz/6bU/g1iHgV9t8umj5GDB4IJjNpzej6syqcb1JlzwdbvS7wfHVgUDlysDWrZaGhw9/gHTpDqNrVz546zAceP/99zFp0qS4pgsVKoTRo0ejXr16XIpuovLLvl/QelFry/BEpQS+uIUihZPhv//0GDUf2rx4EZBlzq7KTz8Bbdr4YJyHkAAJeEOAAtgbWtrUpQDWhqtRrOovgCv9AOR7wyg86Ie/BK7vBlaXsVhJEgK0euyvVc2P33hqI2rMqhHXTsaIjLja96rm7bKB+ARefBH480/L32UGrVMn16SePHlCMabByXTo0CGUKFECEjzLvtSsWRNjxozBc5wRRIclHTBrr9VeoiN1gZ9XKMgiI4FsdqnRNRgq/01KKqQMGYCbN53b6tcPGDHC/7ZogQRIwCUBCmD9TxAKYP3HQEsPHgIIz5QaSJoEGDiwP97v1g1JIPlPY4Enph/5Pe7/1n93VycGODIROLsofh+SRQAVpgN5rd6aa9lT2g4MgYdXgHNLgZgHT3+eRAPFPwpM2360sv7Eerz848txFrKkzIJLvSUnLUugCVSsCGzfbmn1u++Ajh2dezFlyh6sWnUSP/9cFylThgXa3QTd3pkzZ9C7d2/Mnz/fYT+TJEmCN998Uwmgld3d7GECJSUvX3J+lRORdyMtPVw5AdjxvvL7nDlQAiwHRYm/Ad/W7VdfBVauDIqu0EkSCGYCFMD6jx4FsP5joKUHigCWhxgJhNKlSxf12oq+D+zoApz6Mb7NlPmAqouB9KXVa4+WSMAPAmuPr0Xtn2rHWciROgfOf3jeD4s81FcC5csDO3dajp4xA+jQwbG1lStPoH79xYiNfYJy5bJh+fLGyJqVQXp8Ze/suK1bt6Jnz57YaT0wVpVTpkyJ/v3748MPP0SKFCnUbt7Q9vZd2odSU0rZ+jjxMHCtkPI3CYI1ZYqhu2Bx7r33gK+/du5srlzA2bNB0pngcPPevXv49ttvsWzZMiVH940bNyDXU5EiRVCrVi106tQJefIYK/CfBMWrUaMG2rdvj5kSPM2HIqtKcufOjcjISPzxxx+o4mb/+eeff67EIGjdujVmz56ttCjPruaybds2VKpUyaEn8+bNQwvTW6hnnnkGp06diqsn/8+XL5/NcRIPQdLClSxZUnnBJ/20bsuH7np9CAWw18hUP4ACWHWkhjKoCOA5c+bE3RxU8e7uKWBzY+DGnvjmstcGXvwZCM+gSlM0QgJqEFh1dBVe+/m1OFO50+TGmZ5n1DBNG14SeOEFYNcuy0GzZgHt2sU38s8/l1C16hzcu2dZYp83bxqsXNkURYtm9LJVVndHQAJl/fLLL4rQPXfOKtqx1YG5cuXCF198oTykOguq5a6dYPt89LbR6LOuT5zb6ZPkxY1PTsjjufK3woWBQ4eCpFdTpwLuXoRfvw4wV7QqA/rXX3+hKp9rXwAAIABJREFUSZMmigiUF0cVK1ZE1qxZcevWLeVl05UrVxAeHo4VK1bg5ZctK5RUadwPI2oIYGm+V69e+Oqrr/DOO+9gipu3RIULF8aRI0ewatUq1KlTR/HeWpR269bNJlaBdfcaNGiA5cufBlt1JoDlpUOzZs2UOo8fP8bRo0fjXvj5I/R9xUwB7Cs59Y6jAFaPpVEspQMgP1IOh4SEhMnFrlqJXAdsbQlEXY9vsvhAoORnQNJkqjVHQySgBoEVR1ag/i/140zlTZcXJ7ufVMM0bXhJoEwZQILNmsuPPwJt28Y3smXLOTRosAQ3bsh7PEvJkCE5jhx5CxkzGjv1lpdYDFP9/v37GDt2rCJ0ZfbKURk8eDBkxiYxlJVHV2L6P9Ox/uR63H50G43zvI3FHadCgmrLuVy9+tNts8mC4Wtv2zbgf5Zo+A7H748/3EeLTgwD72cf//33X0XwSiqyfv36Qa4ZEWHmIi+clixZgr59+2LQoEHo4GwZjJ9++HK4WgJ4z549eP7555EhQwblJUBYmOMtLPIyoHz58srLgfPnzysR6aWIAJYXBPnz58fly5cVGyEhITZdunbtmrI9Q2Zz//nnH6cC2F4YixHh37hxY8Xe5s2bUVkiNAaoUAAHCLSLZiiA9R8DtT34FMAnZqNyI4mOjlanjUPjgd0fPt0vbF1CUgOVZgG5n95IWEjAaASWHFqCxnMt52f+9Plx7INjRnMzUfgjMZX2WgWGl9VurZ2ECjh06BpefXUhTp2ypKwaMaIK+vWrkChY6dlJediUh3bJISz7YM0lIiIChw8fVpY3JqYSHRut5BNPFZoO5/4pDnlWTps2yAjcvu3eaYkI3q1bkHXMWO7K9SJ5tfft24dPP/1UWdrrrMhs8NmzZ5VgdEYpaglg6Y8I0/379ytis2HDhg672KNHD4wfPx7yr7x8MxezAP74448xcOBAZaa8bt26NjZke5/MDstMs2zRcDYD7EgAi6FXX30Vq1evVl5CDBkyJGBDQAEcMNROG6IA1n8M1PbAZgY4LCws7NGjR+q0cW4Z8IfdDSxNEaDKYiBtEXXaoBUS0IDAwoML0Wz+0+VPUgplLITD7x3WoCWadEegVClg3z5LrV9+AVq2dH7UpUv3lH3AO3dexNtvl8KUKbUCvl/LXZ8S8ud79+5VHiw3bNigdDMxzf4myHGV/ZBWeyTj9TGoNjUbc4REUImwki0DJ0+ejDdr6c5rWYUhEdjnzp2L48ePKzOnIqjfffddtHRws8ybNy9Onz6tvKiaPn06JkyYoCzxlX2uIjpHjhyJdOnMCwMtrcv+2AEDBmDt2rWQ58RSpUopQlNmqv3dA2xuZdSoUcoMuCw/dhRsT/YK58yZE5cuXcLff/+NsmXLxjloFsDywk328co+X9mmYV1efPFF5UWD3KdkpthbASxBAIX122+/jamyRSBAhQI4QKBdNEMBrP8YaOnBw/Dw8PCHD22XEPrV4L8fA/tNb8lyNQYqzQRC0/hlkgeTgNYE5h2YhxYLLKFai2UuhgPvHtC6Wdp3QEAmOg5YoZ87F2je3DWq+/cfY9y4XejbtzxCQpKSa4AJyIP1r7/+qjwoyl67VKlSBdgDNqcagQYNANN+SYc2JU+ZdaJu1RpOPIbMubUlsJzMTHpT7ty5o4jPXbt2IXPmzKhWrZqyFUFeQIlI7d69O8aNG2dj0iyA+/Tpo8yklitXTjlWAkfJ0mEJQLVp0yabF4cirEU8yueS+7tMmTKKWN+xY4cSMPWbb77xKwiW2UFZ0ixBvkTEi8hNk8b2eXHNmjXKnt+iRYsqQcKsi1kAyzOs9EGWOIsN8/1H/H322WfRrl07ReTLUmhvBbDsT5YgZZwB9uYsTRh1KYATxjg664X6Ajg2BvijEZC5ElCsP5CED6MJ+xRKGL27dv8ajl4/ipjYGMQ8iUHykOQon7N8wuhckPVizx7g/n0gNvbpT5EiQJYsQdYJuksCwUpg4EBg+HDn3qdODdy6JRswg7WHuvste0klsvqPP/6Ito4CHLjw0CyeJSjW4sWL48Se5OwWMSyCVV5GvfaaJaijWQCLAFy5cmVc7u6rV68qkZOPHTuG9evXQ3J7m0vt2rWVmV+ZVZ44cWJcUDuZQe7cubNSTa3gUNIXaf+7775DR7ucd2+88QZ++uknDBs2DB99ZJtS0VoAy+ysCPNZs2YpgleKLFmW5dEiomX22lsBLPFxihUrpvDZsmUL/uduf7yKZxZngFWE6aMp3uF8BBckh6kvgKXjsgeYwjdITgG6SQIkQAIkQAImApK4uFWr+DhCQ4FixWTTJvDNN4DKs/xRUVFOh0AiilsHN3JVV0RRqPhqKt7UFcFjvZ/d2iF7u/6cLzKbKYJVlkKL0PS0yEyvzNzKTK8cX7BgQZtDRah+8MEHik2xbS5mASzi9a233rI5RmagJRqz7EOW/chSZPa3QIECSJ8+vbL/2Do4l3wuQlBmj9USwCJaJciXCHARwuYiS70l8JX0W2ZzZfbWfkwkCJbMAEv6qGzZsqF69eqK4JUiqaRkD7VErZeI2p4KYHMUaNnOsWjRIuUlwNeu0oN5OoBe1KMA9gKWRlUpgDUCaxCz2ghgg3SObpAACZAACZAACXhBQJaZyuyhCF3ZkC//yk+hQoCVsPTCokdVP/vsM6f1ROhJai1zGT58uJKqxlERkWQdMfnLL7+ECClHJUeOHHGzmfK5LB0WweSoiPAUIaRGEWEm+1a9FcCSL1dmeSV69J9//hnPlZs3byqiVZYA3759O25Js1kAnzlzJl5wOgkcVb9+fZs9rj/88IMibtu0aaPMvtoXs9BWSwDfvXtXEboiZMVH2fMr5eeff1Z8qFq1qrJE275YzwDLZxKxWbZgiOAV4S6Ro83LzC9evOhSADsbVzkvZRY50IUCONDE47dHAaz/GGjpAQWwlnRpmwRIgARIgARIwC2BxCSAfV0CPWfOHLRq1UoJdGUf7MkMWIJZiYgXMSxBrqSYBbCkVrLOnSufOYroPGLECCX4lfzIywb7snTpUjRq1Ei1GWCxL0JXBK+8sJDAU1IkorMs2Z42bRo6derkVgAvXLhQCaYlkaJlxliCfcleadm/7E4AW+cBFkEuqZdEjMtqAhHV3szUuz3ZPahAAewBJI2rUABrDFgH89pFgdahM2ySBEiABEiABEgguAkkpiXQ7733nrKk1tsgWGYBLCJYxKKjYhbAIoLNAaWso0DbH+NIAEuOb9lvKz+y9zYQAtgcGVuiWUt+YFmyLDP0kqpTxKujKNX2M8CyNFyWQUtE6AsXLij5hc2Bs9wJYPvgWBJ9WgKKyTjJ7LREzU4t+98DVCiAAwTaRTMUwPqPgdoeaJcHWG1PaY8ESIAESIAESIAEEhCBVatWKUGqvE2D5G4JtIheEYoymynRos2zvd4KYPOe3EAtgZahFcEpPESoSl7g33//HRLwy1l6JDnGXgDL3yRAl+x1lmIdOMtbASzHR0dHKwHDDhw4gEAvhaYA1v+CpwDWfwzU9oAzwGoTpT0SIAESIAESIAES8ICABNoqWbKkIqwk8JQEoHJWZC+v7GctXry4EgzKVRAsma2U2WVnQbAcBfhyNAMsUY9l33WggmCZ+y75xGX5cv/+/RUBvH37dixZskTJVeyoOBLAmzdvVvYCy2eSN9gcOMsXASxtSvtiT2aTJZdyoFK8UQB7cCFpXIUCWGPAOpvnHmCdB4DNkwAJkAAJkAAJJC4CssxXUhBJ4CcRfJJn1jrasohV2Xsq+2FlKbI5sJd5+XStWrWUNEjmY44cOaIEyBKhJ4GtZP+suXg7AyzHmVMTSXuSO1gicUuZMWNGXKoi+yBYkiNYUhBJECvraM6ejuzu3buV/boZM2bEtWvXlH8jIyNtonpb23IkgJ215asAFnvik/g2atQoSC5lc5k0aRLkRwSyLBtXs1AAq0nTN1sUwL5xC5ajKICDZaToJwmQAAmQAAmQQIIhILmAmzZtikuXLiFFihSKIJb9prKUWWYv5e8ihETQvvTSS0q/ZWlzjRo1lOBOWbJkUUSvzAxv2LBBEdOSBkkEq3XxRQDLnldJdyR7cQsXLqyIQAksJbOy77zzDqZMmRIvCJZ5Ntl+P603A1aiRAllZlxK165dMXnyZKeHB0oAL1u2TJmFlv3FwkDGRIrM3svSaLWiYVt3lALYm7NGm7oUwNpwNYpVCmCjjAT9IAESIAESIAESSFQEJOLw1KlTldleCdgk+Wxlma2Izjp16ijRj2VvrHURwTtmzBjMnTtXydkbFhYGCR4laZokQJZ98UUAi40TJ04okaDXrVun5B6WZdsyGy3BtUSE2ws/NQTwyJEjlRlxKfKC4MUXX9RdAIsD5cqVU15KyDJzczosCuCEfalSACfs8aUATtjjy96RAAmQAAmQAAmQAAkEEQHOAOs/WBTA+o+B2h4wCJbaRGmPBEiABEiABEiABEiABFQgQAGsAkQ/TVAA+wnQgIczDZIBB4UukQAJkAAJkAAJkAAJkAAFsP7nAAWw/mOgtgecAVabKO2RAAmQAAmQAAmQAAmQgAoEKIBVgOinCQpgPwEa/HDuATb4ANE9EiABEiABEiABEiCBxEOAAlj/saYA1n8MtPSAAlhLurRNAiRAAiRAAiRAAiRAAl4QoAD2ApZGVSmANQKro1kugdYRPpsmARIgARIgARIgARIgAWcEKID1PzcogPUfA7U9YBAstYnSHgmQAAmQAAmQAAmQAAmoQIACWAWIfpqgAPYToAEP5wywAQeFLpEACZAACZAACZAACZAABbD+5wAFsP5joKUH3AOsJV3aJgESIAESIAESIAESIAEvCFAAewFLo6oUwBqBNYhZCmCDDATdIAESIAESIAESIAESIAEKYP3PAQpg/cdAbQ+4BFptorRHAiRAAiRAAiRAAiRAAioQoABWAaKfJiiA/QRowMMZBMuAg0KXSIAESIAESIAESIAESIACWP9zgAJY/zFQ2wPOAKtNlPZIgARIgARIgARIgARIQAUCFMAqQPTTBAWwnwBVOvxNAO0AlACQHMARAF8BmO2nfe4B9hMgDycBEiABEiABEiABEiABtQhQAKtF0nc7FMC+s1PzyJ8A7AKwBcANAI0BjATQCsBcLxviDLCXwFidBEiABEiABEiABEiABAJBgAI4EJRdt0EB7H4MygKoBaA8gAoAcgB4ZJqpdXW0zOQOMInYPACuA1gN4GMA59w3i5UAHgBo6kFd6yrcA+wlMFYnARIgARIgARIgARIggUAQoAAOBGUKYH8pLwHQ0M6IOwEs4nc9gBcBRALYDCCvSURfAVAJwHE3jm0DsA/AO152gDPAXgJjdRIgARIgARIgARIgARIIBAEK4EBQpgD2l3I/ACkA7DT9XPRgBvhzAIMB/AngFQB3TU58CGAMgD8AVHPhWHsA0wBUBPCPHx3gHmA/4PFQEiABEiABEiABEiABElCTAAWwmjR9s8Ul0N5ze+JGAIcCuAxAZmLLANht18ReAKUAvGDa92vvgcw2y77frgBmeO+e0q78SDkcFhYW9uiRTFizkAAJkAAJkAAJkAAJkAAJ6EmAAlhP+k/bpgD2fgzcCeAaADaYljgXcGBeZoZlhvgzALJf17q0BDATQBfTv95799TmJ+YDkyVLhujoaF/s8BgSIAESIAESIAESIAESIAEVCVAAqwjTR1MUwN6DcyeAewAYC2A+gOYOzNcFsAKA7C2WaM/m0hnARAAdAMzx3q24IzgD7Ac8HkoCJEACJEACJEACJEACWhGgANaKrOd2KYA9Z2Wu6U4AS/7eniYRLHt+7UtpAHtMe3slwrQUqTcKQDcAS60OiAEgQbPclQNOKhSTv4eHh7s7np+TAAmQAAmQAAmQAAmQAAloTMBqayJ1mMasnZkneO/BuxPA3wKQ2dxhAAY5MC/Loo8COAKgsOnzUwCecVD3tCl6tDsvXQpg055ldzZ8/VzOoWQARKwLG0+LN8e5q+vsc2/+bl/X/vcwU8eiPO2gD/Xc9dPVdezJGLiz7+pzT1k6qmf9N9kjL8WIHMUvd4zMY+Cunrcs3XGTayshnpOeMPf03HM1Nry+XZ/bnjJ2d57y+nbM2R03Xt/xnyE8PScd3UMS4r1S7e8cT7jZ1+H1rd71bZ6Zog7z4WFZjUMI3nuK7gSwRG/uBGCoKRK0fQsFTeLXWgB774VnR5iFcXHPqvtUS9I7nQSQD4AIeU+LN8e5q+vsc2/+bl/X/veEwNJXjjKmnrJ0VM/6b7+aThAjnpOu+ml/XqvN0h03ubYS4jnpCXNPzz3zGCVWlmqfk47Gxh1bXt+O75XuuPH6jv8M4c11z+9v59/R/P6O/1Sq9r3SqNe3p8/jibIeBbD3w+5OAPuyBNp7Lzw7IiGINj4gux9rdzdzV8LA2rorO54+jLj7IuADMh+Q1XqZ4Ok56YmQSwj3Snf3AV7frkWCp/dCd99J7u6B5hfFiUG0uWPljTjjCy7Xkw28vnl9u39aZI04AhTA3p8M7gSwr0GwvPfE/REJ4aGOX6Dux9ndgy8FsHuGnjLytJ63DyOePDRzBth2lQkFsO157e4+4O056cmLA/s6fMHFF1x8waXNajhe3+6/x90xSmzf3+6JJeIaFMDeD747AexpGiRJhRSXrsh7Nzw6IhACWKJOi+gfB+CmR149reTNce7qOvvcm7/b17X/PSGw9JWjq/Fyx83+2K2mc0TLJdDu+unqNPX0WHf1XH3u6DNP/pYQz0lP7gXeXMfO7Lk7T3l9O76Pu+PG6zv+954n17Kj85TXty1Lb657d+cpr29e39bf+4nl+9uLR/LEV5UC2PsxdyeAJVjSZQBpAZQBsNuuib0ASgEoD2Cn9817dUQgbvpeORTElclSncEjR3U4ihWyJEv1CKhjieekOhx5favHkSzVY8nrmyzVI6CzJQpg7wfAnQAWixIAayCAbQBeAXDP1IykOxoDYAuAKt437fURvFl5jczpAWSpDktyVIcjH+rU40iW6rHk9U2W6hFQzxLPS3VYkqM6HPmdox5Hny1RALtHV9cumnMFU7qfHVaHDgFg3vskf04OYCMAqRsJYLMpzZH8fg1ARQDH3DfNGiRAAiRAAiRAAiRAAiRAAiRAAmoRoAB2T7IDgBluqr0JYKZdnQgAAwC0BpAbwA0Aq01i+qz7ZlmDBEiABEiABEiABEiABEiABEhATQIUwGrSpC0SIAESIAESIAESIAESIAESIAHDEqAANuzQ0DESIAESIAESIAESIAESIAESIAE1CVAAq0mTtkiABEiABEiABEiABEiABEiABAxLgALYsENDx0iABEiABEiABEiABEiABEiABNQkQAGsJk3aIgESIAESIAESIAESIAESIAESMCwBCmDDDg0dIwESIAESIAESIAESIAESIAESUJMABbCaNBOerRQABgJoASAXgFMAvgLwbcLrquY9SgqgPwBJqyVpsa4DWGP622XNW09YDUiO7WoOuvQEQDYA5On5eGcEMBRAQwDyf8lbPgLAFM9NsCaATwF84oBEPtN9k5B8I/ASgLUAJHVgXt9MJNqjmgHoC6AAAPkuPwdgDoDPAUQlWiq+dVxSXbYDUAJAcgBHTM9Cs30zl6iPqgqgF4DnAOQB8Jnp/pmoobjp/CsAvgBQHMA1U2pW+b6JITTfCVAA+84uMRz5AwC5WXUFcBhAZdODcTcPciMnBj7e9FEeRD4G8BaA7QCeAfCN6aFEbm4snhPIACDMrrrk2L4CoJbnZhJ9zVQAdgA4bxLBpwFkBxAK4I9ET8c7ACKA5douZ3eYnJN8SPGOpbl2DtP5uQ9AUQpgryHWBCD3yv8A3APwPICpJhH8gdfWEvcBPwHYBWALgBsAGgMYCaAVgLmJG43XvX8NQBUAewCMM52Tcv9kcUxArlt5ZvzaNPlUDMB3pmdxmVRh8ZEABbCP4DQ4rKzp4b08gAoA5Mv/kelto6vm5G3kANONWN6mycyiiAERW/LG19cidu8A6AjgRysjEwDUByAzG0YtRmMpnJab3ro3tYImDyHDAKQ2KkgARmRpj0veJO8GIGwXGZSlETnKm/f2AAqb7jUGRRfPLSOylAc4Wd0RbLOURmQpA54MwAYAKwCkDAK2RuVof/GMBfAygJIGvtiDheVKAA9M3ztGxWl0lrKqcGYQzwAHgq+sMihiehYzn2fy7CgrtbIAuGvUk8/oflEAG2eElpiWIVp75E4Ai0hdD+BF09LFzaYHMBHRMvNQCcBxH7soouwWgOYAFljZkIuun2kG84yPtrU+zGgspb8yA9wbwKumN8nygkPeHMvsW0utgfhh34gs7bsjsxr1TOdktB991fJQI3Lcb3oLf9s0oyH//gpgsGnGSEse/tg2IksRwPI2Xu678r0qs5ZDAGzzp6MBONaILKXbMrsmIq2uaWm50V8uGJWj9Skks+iLTUvKjTwDHAwshatc23KdvxOA69TXJozOMtgFcCD4CiOZhJLvZXPJD+AYgOoANvl6ciT24yiAjXMGiKiUfTo7TT8XPZgBlr08clH8CUCW0ZrfBH0IYIxpGaP1XklZDiU/roo8BJv3UMoySBHCr5uEtAjqpQAymUS3tGvEYkSWcq3JTL2MmexVDTHNCgtbedFh1GJEltas0pheIsj5buRlVEbkKLMXcl7Ki5iJplUnk0z3E9n3b9RiRJbyYkvulYcApAXwNoDWAOoAWGdUkKaXmUb73hHRKy+1ZOmfvFAIhtl1I56T5tNOngtkW4NsGxGusoXJyMvyjczSzFRWzkwDUBHAP7y+vXqutMYV7AI4EOeqPB/2BDDZCpysipHrWr5jfjHw+Wdo1yiAjTs8IpJczQDLF5oI1XQAypiWgFr3Zi+AUgBeMM04ymfOArVYHzfLtNxM/ibBmuQmL+I61iQ0fjbNdMgybdk/GAzFCCybmG5gH5lecMhy9S9N49YmGCCafDQCS2tc8jA33jT7K7PpwVKMwFHuL1ftZs4lcM58AFmDKJiYEVg6Ou/kBeJD0/2T56VrAubvHQm2KIJCVh5JsDvz95bRZ4Dte2ekc1KCYEWYngXMAe4cBWwz6jlqJJbCSAIGyktDiY0yw6jQnPhlNJbBLoADcd07EsDy0lL29csedAlsx+IDAQpgH6AF6BB3N6oapj1SssRZvuDsi8wMy2yjdYQ9iUQsP66KCF35sS6y1FpmfS+YbvoyS5TZ9PAcIBx+NWMElrJcXKJnS8Rdc5FAEPKQLPs7JMhYMBQjsLTmJEvQjgKQFwzBVIzAUR4+5EeWUZmLLJM8CEC2UchqlGAoRmDpiNNoAA0AFAoGiCYf9WbZyLRM13qGUr6z5FlF/iYz698HAU+9OTpDJDOXwk9WzsgDdDAUI7GU7UqyZ7WL6d9g4Gfto5FYil+JTQD78tzOJdAaXWUUwBqBVcGsuxtVDwAS0EJma+RtuX2RZWQSQET2KEjEQjWKnC9bTTPTciEHSzECS5lpk2W6EsreXGTvtvCUqH4SqTMYihFYmjmZXyDICgUjLzN1NK5G4Cj7ikT8SuAms+AwCxAJriHLT4OhGIGlI04Sn0GKpPIJlqI3S1lGLhHyrcu7plm32qZVSBKF1+hFb47O+IgAlllL2Qp10+gQTf4ZhWVn01YRWY0QrLNuRmFpPvUSmwD25bldgmBJoEpZzWku75viJDAIlh83MQpgP+BpfKi7G5Xk45V9ASKCZc+vfSltCnAjy8kkUp0vRR7cZKnFAVN6FAnkJA/Mkg5JZt6CpRiBpSwllxcRsmxKZtbkIU9SAEi0U9nrZuQ9WdbjbASWZn9kOb6knZEZNvErmIoROMo9QrYxyIyQnIsSmE3OU0m5kJCW5QfiXikvt+SFozzQyR5gCYwjP7JcUiLAB0sxwnlpzyoY9gDb+2wEjrIKTK7lE6YZdFnVIeepxO5Q66V4IM5rI7CUZ6xRpv3TEgfFXOR7O1heFIrPRmAp6ffMqxYlkvYyU0ofyU0tq4+CuWjBV7Y4/mV6+TLdlBJO0iDJfn6mQfLjbKEA9gOexoe6u5BkOa28kZQ0OoMc+CI3GFkaKgnb5e2RL0VmgyQap4g1CZjzu6mtYLtJGYGlvEiQBxKZrc9pSmYuaT4GAjBqNG1H54wRWIpfsgRf0nwJP1lqGmzFKBzlJZfsC5SIuxJ4b6EphVqwLI/05KEuEPdKCUQiKxLkvJTo+fKCUO7Nco0HUzHKeWnNLCEK4ECck8NNKXoklodEx5eXMzKbJKkM5fs8WIoRzklhZ78yQfhJ7vRgSn1mBJYyiSLPkvYl2FgG8vlIVr/I6sHipmdHWcUhqU6DZeLEkPcaCmBDDovilLsblczUdDLtKbUOj27uUUGT+PVHABuXjneekaV3vFzVJkt1WJKjOhx5r1SPI1mqx5LXN1mqR0A9Szwv1WPpiwDmc7u2/L2yTgHsFa6AVnZ3owrEsr6AdljDxshSPbhkqQ5LclSHoyeijfdKz1nzvPSclT8vCnlOes6Z56TnrNzVJEt3hPz7nHz94xfQoymAA4rbq8bcXUi+bKb3yoEEVJks1RtMslSHJTmqw9ETAcx7peeseV56zsofAcxz0nPOPCc9Z+WuJlm6I+Tf5+TrH7+AHk0BHFDcXjXm7kLyNJy6pEIKppx/XkHysDJZegjKg2pk6QEkD6qQoweQPKxClh6C8qAaWXoAyYMq5OgBJA+rkKWHoDyoRpYeQPKjCvn6AS/Qh1IAB5q45+25u5DCAFw2RRyVKHG77UzvBVAqyPJ5ek7Hu5pk6R0vV7XJUh2W5KgOR7FClmSpHgF1LPGcVIcjr2/1OJKluiwdWeN1rz1j1VqgAFYNpeqG3F1I0uBQUxTcbQAkF6o5cquE7Jd0B1tMkUlVdy7IDJKlegNGluqwJEd1OHryUMd7peeseV56zsqfF4U8Jz3nzHPSc1aUFxXdAAAUTElEQVTuapKlO0L+fU6+/vEL6NEUwAHF7bKxuqY0OeZKFUwzG5Kn01yGAPjV6vfkADYCkLqRADabQvXL79cAVARwzDhdDJgnZKkearJUhyU5qsNRrJAlWapHQB1LPCfV4cjrWz2OZKkuS0fWeN1rz1izFiiANUPrteEOACS3l6vyJoCZdhUiAAwA0BqA5Pu7AWC1SUyf9dqLhHEAWao3jmSpDktyVIejWCFLslSPgDqWeE6qw5HXt3ocyVJdlo6s8brXnrFmLVAAa4aWhkmABEiABEiABEiABEiABEiABIxEgALYSKNBX0iABEiABEiABEiABEiABEiABDQjQAGsGVoaJgESIAESIAESIAESIAESIAESMBIBCmAjjQZ9IQESIAESIAESIAESIAESIAES0IwABbBmaGmYBEiABEiABEiABEiABEiABEjASAQogI00GvSFBEiABEiABEiABEiABEiABEhAMwIUwJqhpWESIAESIAESIAESIAESIAESIAEjEaAANtJo0BcSIAESIAESIAESIAESIAESIAHNCFAAa4aWhkmABEiABEiABEiABEiABEiABIxEgALYSKNBX0iABEiABEiABEiABEiABEiABDQjQAGsGVoaJgESIAESIAESIAESIAESIAESMBIBCmAjjQZ9IQESIAESIAESIAESIAESIAES0IwABbBmaGmYBEiABEiABEiABEiABEiABEjASAQogI00GvSFBEiABIKTQF4AJ61cnwWgg85deWLV/iYA1XX2h80HN4GZANpbdSEfgFPB3SV6TwIkQAKJkwAFcOIcd/aaBEgg+AnIw/czDrrRFcAUH7vXEcB3Do49DUBErrNCAewjcIMdJi8JfvfApygAtwBcA7APwE4AcwGc8eDYYK1CARysI0e/SYAESMCOAAUwTwkSIAESCE4CzgTwDgAVfOzSFgD/owD2kV7wH+apAHbU01gASwB8AOC8AVH4uyKAAtiAg0qXSIAESMAXAhTAvlDjMSRAAiSgPwFnAlg8KwHggJcuFgJw2MkxnAH2EmaQVvdHAJu7fANATQB7DMaAAthgA0J3/t/emQf9N9Vx/D1FStmjksy0oqZQlkyqKS1+IkKlhZT2UcmSaFFKNYhMDKXRVJJEFCPaNdlKG4a0+YNCSSnaaKZ5zZwzfTpz7/ee8zzf5/u9z6/3Z8bg+z333nNe5zy/3/O+n80ETMAE5kXAAnhe5P1cEzABE1gcgVIA3yNp1XTLj0o6uPH2H5F0aLom3ouPLIAbYS7T4aUAxpO7fcdaVpP0kBRpQNj8psWY2yRtJgkxPBazAB7LTngeJmACJjBnAhbAc94AP94ETMAEFkigFMDnSnpRuhcCZCNJ91be+76SbpL0sDT+y5J2D9cOCeDKx3jYyAmUArhm31eRxAsXQp+jHR1eqIxh2YsVwGNYg+dgAiZgAiYwBQIWwFOA6FuYgAmYwBwIlAJ4F0nnh3nsJukrlfPaubiW/7/AAriS3sozbCECmNXzu8S3JD0roLhV0oaSovCcJykL4HnS97NNwARMYEQELIBHtBmeigmYgAk0ECgF8PqSvpdCT7kN4hcRXGN4fLP3+HpJz5D0BwvgGnQr1ZiFCmAgvLDjhctCctGXCqgF8FKR9X1NwARMYJkRsABeZhvm6ZqACZhAItAlgF8tidBTjPDnh0v6/QAxhDO5njl/+BBJVLy1AP4vuPunXFjaTm0g6S8pL5oXDvz3YgzuT5f0KEnsBa2F2I/L5pBDuxgBDBdC76OtkHRRI5w1JD1eEkXZHizpgZL+KukOSddKulrSvxvvyfAxCOB10zl6qKT1JN2dfs5+Jum6BazJl5iACZiACSyAgAXwAqD5EhMwARMYAYEuAUwu782SyMvEKIRFfuYkO0jSsWkAopncYQRGiwCu7QP8ZEmXSkJQYrTOeb6kb1byfJukj4Wxv5PEPUvh1Sp4+lrcrC3pA5JeKYn/Lg1eZ0g6fAGtfxB6R0jar+fe/5T01ZRHe2Pqw8y/s31G0r6V3GqHLUYAI+TpDxztFYnP0PPxFL80nQX2k3PcZ4jh09OZ/c3Ajb8r6ZlDD+/4/v2S3ld8vpg2SDulM7KdpPv0zIceyqdKOj4J4wVM25eYgAmYgAnUELAArqHkMSZgAiYwPgJdAvj2FIZKOCpGKyTExSTDq/aENADBtWvyvC2FAOYxr02/6Oc58RxED8J9kiEeLgmeasQnOaf0Lu6yFo9fl7jBo3mWJLy+Q3aLpB2Td3JoLN/D++LkoR8af2cS4OzTmAUwHk3OX7Q9JBFeP8nY+x8NQej4/u+SXp/EcN/l8xbAvOQ4UxICuNY4S6QjXFl7gceZgAmYgAm0EbAAbuPl0SZgAiYwFgJ9AhgBe16Y5DaSftgz6W0lXRG+y4WzCD1dKgHM406TRLh2tsuTp472S11GaPCPk3c6f4/n+rgJm7EYAYxX+guSCFnFaOdzVRJ4hORulQo8xcfjjXxShfdukyTaYRyNEF+eQQg0YpJn5Ocj9vYqcmzH5gF+XhL1cU1bVvQDZp3xfLJvCP1fpvByzsQ66aXBxh37/WJJZ/ecg3kKYCIGviNpi2JuePb5mUPorilp844XIew3P8ffGMsfNp6HCZiACaxMBCyAV6bd9FpMwAT+nwj0CWDCn/Gm0qcVO0XSm3rAfCJ50fiaXGHCnxEcSy2AH5ByXKM4OEHSAR3zJGT065J2CN+dI2nPgc1ejADGkwkD2gARRk6LqZh3yt+dL5f0SUmrh3m8N4VM902N0F7E/tZhAC8aDkyewti2in18WRL5zCXPKV86NgEcC6kxR4Q8ua5DrbgQwORS4ymlcBvVpO/qAUg0A4wRvdkIiX5MT647z8/h9tF7jneVFwp99mdJ/BOtNQSa6IE4T36u6LV9TMppzvfmLOEhPqmINmC/EceE+dtMwARMwASmSMACeIowfSsTMAETmCGBPgHMFMjpxUOK8Ys8/X3/UcwNEYoXaq30ObnCiD1sqQUwz3h08njG3NqXSPpSMc8PSnpX+OwXSUAOFZ9ajADmcYSPE2IdPeHl9uIxRxxnI4+TfOi+1j9vlHRyGM+9KYB1w4RzQ0EoQr9Lj/GYBDACvsw1R+wdVvHzgBeUFwN42WuN/Fzyp7N15eyW92o5D13zaBHAZUVsXp4ghuNZKZ/BzygvAhDz2fBsRxFdy8fjTMAETMAEJhCwAPbxMAETMIHlSWCSAEY0IeCy4a0kpDfa3pI+Gz6ILWtmIYB5NEKBcO38dxHePLyjWRC+IPUnzt//TdJTJV1TsWUtgqcUN3gtCWemJdSQEb6LFzMb1YsJ3+2ymG/N9xR+wlM4ZOzf54tB8xTAq6UIA0LoycN9TjG32pcUQ+vu+56ogJ+kPWLMryQ9duBmLeeh61YtApgXFrQSyxZfLk2aJmef8OhcKIsicQji6L1eKDNfZwImYAImkAhYAPsomIAJmMDyJDBJALMifpFGoGBUWX5usUzyE6n6i/0gjOX/ZyWAeRaewkPD3BDu5C1ThIq8X/I/s+0j6XOV29UieEpx88WBENk4BTyRsWJwn6hFUNPuJhsikXzgWkNUR+/gLARw7dziONoU8WKD8PGltNILzHmZ5K1vOQ9d864VwGVFdPJ58e5SzKzGiICI4f2cryNrLvQYEzABEzCBOgIWwHWcPMoETMAExkZgSADjmSPHF8OT9EhJhOhi9JzFa5b/DiBHmFzhbLMUwIS/UuyHcONseKvxpD4lfDYpl7lrb1oETyluWoQ2YdsI5mxvkXRix4TK8OejJL274VB9qAgpHpsA5sUFe0RedNkOqWGZ/zMUTzOVlCk8Vv6+wosGXp5ko90RIcR91nIeuu5RK4BpmRVf0iBoOSO1tktqf5XH87NBgTGbCZiACZjAlAhYAE8JpG9jAiZgAjMmMCSAya28VRK5vlgs0BTzars8VLMUwMyNgl14ezfsYUh15O0lUUG31loETyluCGmubc2DZ50iXdkQtYjb0sj9RQRno9VNrNY9tC7Gx5ZCYxPAv5X01oq2R5PWmfsBkxdNq6gy73nStbmCed+YlvPQdY9aAUyfavpVZ3t70bt6aJ/LdlLk8McoiKHr/b0JmIAJmMAAAQtgHxETMAETWJ4EhgQwq8IThUcKo00PIbT8uc+1j0ifk1uax2QSsxbAPPdpkmhbQ/XjaLQHoldsa0hti+ApxQ0FuuBVY4SRE06era8gUxnayprIY601vOG8CMg2CwGMqOXFQzQ89ggyKhRzbnIYfR6zf6poXLsuxtFrGeGIiF2ovarIaS/v03IeuuZQK4DPSNW78z3IY7+wcVGEckfxf79Unb3xNh5uAiZgAibQRcAC2OfCBEzABJYngRoBTFjxt8Py+H/awnwtfEYBI1rPRJuHAOb5iHEKPkXrKuBVs2MtgqdW3HQ9t1YAE8oai0VRtIkw9FpjPHnD2WYhgHnpQE7rJCPUntDn/PsE4fb0USbvvMY2S+ePPNnFGH2l2cc+azkPXfeoPSP8bO0YbsALhEsbF8a54CVMNto53dZ4Dw83ARMwARPoIWAB7KNhAiZgAsuTQI0A5s/4X6f8X1ZJ1WdConNrFQQOucFl2555CGByOBHieBijEV68IuUxt+xUi+CpFTddz68VwBdIwhuYjRDf6xoWxHiqSGcbiwBmPoTX4/nOhueYSuRDrarw9hNqToGwbLTrwlvOWWC93Ivq4HweezHvK+nT4bqxCOCL0guAPDUiGy5r2GeGlgKYFAH6dNtMwARMwASmQMACeAoQfQsTMAETmAOBGgFcihPaCCEwKS6E9YXrzloA4+EiHJh/d1lNn9fyurEJ4BiOzlxbPYPkxcYiT2MSwJwp2kFtGTahpvVPWUAM4Yf3uCb8nHzjE0YogMsQ6J2KiIuaPyocAl1DyWNMwARMYIEELIAXCM6XmYAJmMCcCdQK4I1TH9HcWzRPG4FINWjuU9osBTDiiTDt2Df14vT/uYAXYbUICT6vtbEJ4Fh4jDWUlbeH1vXmIrd2TAKYuZfh9hQsI2z7pgkLK0Pen13kU09iUrbPGosHuCyCdUAh1If2eV1JfwyDXARriJi/NwETMIFGAhbAjcA83ARMwARGQqBWADNdwojLPsCIzh161jJLAXy0pEPCPHIfYLyDMcQVUYCHcZKgissZmwDeWdL5YYJnSaKVT62VRbTGJoC7zhktkd4wYYH0n946fX93anlUhuP3XY43HK94trEI4LINUus+l+fEbZBqf0I8zgRMwAQqCVgAV4LyMBMwARMYGYEWAbyXJHrrRuMXdTxwXTYrAbyrpHNDASVyPRFEN6RJfUrSfmGCVybRc0/FXoxNAK8t6ZZUhIzp4yHFO1+T20loOPnaVAPONkYBTL7r98Mc2adNUgRC15ZR1AsvMQabvjZY5bVUM+eMxKiGIQFMDnEO/b9C0nYVZygOqc0Tp2jYjeFC0g4o8DWUD50voad07Bt8hKQjG+fq4SZgAiZgAhMIWAD7eJiACZjA8iTQIoARTtsUyyRns6+v7iwEMOHXFEBCGGbDI4rHLBsVqy+XtEX47OOp3+zQro1NADPfUkTxUqKset21LpjkwmX5+zEKYOZG9ecYWYAX/zU9m8ULjXwuKXC1vqQ/DW1s6jVMX+RoQwKYntgUk8JqqluX06gVwFxXeqeJcji0Yl20uoJJLgRH6D8vCGpyoitu7yEmYAImYAIQsAD2OTABEzCB5UmgRQC3rnCpBTDClsq4sWgSBY3IlyyNdjAI5bXCF3i08ZRNsjEKYCojU+wrenKPl/QOSfd2LGZVScf2CP6xCuCyWBfrotVRV8snQqRfF9b9YUmHD+wrBdGoOl3akACmV3PsWbxpiDSo+floEcBENpwXbgqD3YsQ+PKZiHOE8+PCF+dI2rNmch5jAiZgAiZQT8ACuJ6VR5qACZjAmAgsZwFchjYTkkoRrL7Q5t1SqHTmf1cKlf75hA0ZowBmuu+UhNCLRjukU5O3+w5JFEIiRJceu4hH7ExJCP9sYxXAzI8WRhS0yna6pL079gpPcdkv+ChJFLhij6MRSg237PmlUjIe42xDArhs1UQINc/5qaQ7i1ZgFJ7in2gtApjrzpa0R7jBvySxtuOKtfF7GH2DTwrtyriMc0B7KNpA2UzABEzABKZIwAJ4ijB9KxMwAROYIYHlKoDL/q23J0/wzQPsjpF0cBiDaCR8luJJXTZWAczfu4gdqkDXGgXLEMPRi4ogQ/RN08qexgsJFWY+vMy4JEyMUF76GHe9sLgw9XmO60D8UiCLvOAHJa9ofhHAuOslndLYBon8Yp6/RgWwrrZbrQJ4ncTgicXzyEXmhQ8h2cxlc0kbdYxB6NNT2GYCJmACJjBlAhbAUwbq25mACZjAjAgsRwGMR4tf/mN7I7xfVLodslVSu6RY+ZciXhTz6rKxCuA81wNTH2YE3iQ7UdJBkggFR/Rnq82FHuIav5+WAOaeZcgxIevRg52fSw44+79V5UTx2FIpmarmsUr4kAeY26+QRJ/emHfe9dhpCGDuu2bKaae3ca0hjPEckyJgMwETMAETWAICFsBLANW3NAETMIEZEFhuAhgxcFWo+gui1gq3VNMlhzYXM+Ie9Mc9uYP32AUwU2Y9hAbvkgTuein0lbBXvL6EOdMWCiMkOooi+gq/Z8rnbJoCuLwXXmC8ndd2zJnqzOT+7p/Cv7uWRcjyacnrS/G2MpKgRgBz3w3SSxPCr8nJJt999aKi9LQEcF4H+3uYpG2L58R1EgFBGHwZIj3lLfbtTMAETMAELIB9BkzABEzABExg/ARoB0XudDbEIqHUK5MhhBGJhEsTQkwoNB5RQp6vWQkWitimVRQvPsjzJnyfXOare14MrARL9hJMwARMYHwELIDHtyeekQmYgAmYgAmUBPAG7xM+xCNMOLnNBEzABEzABEyggcB/AB7Uetc1UXCmAAAAAElFTkSuQmCC" width="640">
## Plot Transmission Spectrum Model and Data
```python
#finally doing some plotting
#and the usual matplotlib shenanigans
ymin=np.min(y_binned)*1E2*0.99
ymax=np.max(y_binned)*1E2*1.01
fig1, ax=subplots()
xlabel('$\lambda$ ($\mu$m)',fontsize=18)
ylabel('(R$_{p}$/R$_{*}$)$^{2} \%$',fontsize=18)
minorticks_on()
errorbar(1E4/wno, y_meas*100, yerr=err*100, xerr=None, fmt='ok',ms=2, label='Data',alpha=0.5)
plot(1E4/wno, y_mod*1E2, label='Model')
ax.set_xscale('log')
ax.set_xticks([0.3, 0.5,0.8,1, 2, 3, 4, 5, 6, 8, 10])
ax.axis([0.5,12,ymin,ymax])
ax.get_xaxis().set_major_formatter(matplotlib.ticker.ScalarFormatter())
ax.tick_params(length=10,width=1,labelsize='large',which='major')
legend(frameon=False)
savefig('./plots/transmission_spectrum_JWST_CC.pdf',fmt='pdf')
show()
#close()
```
<IPython.core.display.Javascript object>
<img src="data:image/png;base64,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" width="640">
## Play around with Transmission Spectrum
### Explore cloud contribution
```python
from matplotlib.pyplot import *
from matplotlib.ticker import FormatStrFormatter
###PLAYING WITH CLOUD PARAMETERS HERE
#Ackerman & Marley 2001 Cloud parameters--physically motivated with Mie particles
logKzz=7 #log Kzz (cm2/s)--valid range: 2 - 11 -- higher values make larger particles
fsed=2.0 #sediminetation efficiency--valid range: 0.5 - 5--lower values make "puffier" more extended cloud
logPbase=-1.0 #cloud base pressure--valid range: -6.0 - 1.5
logCldVMR=-5.5 #cloud condensate base mixing ratio (e.g, see Fortney 2005)--valid range: -15 - -2.0
#simple 'grey+rayleigh' parameters just in case you don't want to use a physically motivated cloud
#(most are just made up anyway since we don't really understand all of the micro-physics.....)
logKcld = -40 #uniform in altitude and in wavelength "grey" opacity (it's a cross-section)--valid range: -50 - -10
logRayAmp = -10 #power-law haze amplitude (log) as defined in des Etangs 2008 "0" would be like H2/He scat--valid range: -30 - 3
RaySlope = 0 #power law index 4 for Rayleigh, 0 for "gray". Valid range: 0 - 6
#10 bar radiuss scaling param (only used in transmission)
xRp=0.991
#stuffing all variables into state vector array
x=np.array([Tirr, logKir,logg1,Tint, logMet, logCtoO, logPQCarbon,logPQNitrogen, Rp*xRp, Rstar, M, logKzz, fsed,logPbase,logCldVMR, logKcld, logRayAmp, RaySlope])
#gas scaling factors to mess with turning on various species
##generating "complete" spectrum (same as above)
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#H2O CH4 CO CO2 NH3 N2 HCN H2S PH3 C2H2 C2H6 Na K TiO VO FeH H H2 He e- h- mmw
gas_scale=np.array([1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1., 1., 1.]) #can be made free params if desired (won't affect mmw)#can be made free params if desired (won't affect mmw)
#calling forward model, fx. This will produce the (Rp/Rstar)^2 spectrum....
y_binned_0,y_mod_0,wno_0,atm_0=fx_trans(x,wlgrid,gas_scale, xsecs) #returns binned model spectrum, higher res model spectrum, wavenumber grid, and vertical abundance profiles from chemistry
print('DONE')
##generating cloud component only
gas_scale[:-1]=0. #shutting off all gases!! Whoa! This leaves only the cloud (note, the last index is the m.m.w.)
y_binned_1,y_mod_1,wno_1,atm_1=fx_trans(x,wlgrid,gas_scale, xsecs) #returns binned model spectrum, higher res model spectrum, wavenumber grid, and vertical abundance profiles from chemistry
print('DONE')
ymin=np.min(y_mod_0)*1E2*0.99
ymax=np.max(y_mod_0)*1E2*1.01
fig1, ax=subplots()
xlabel('$\lambda$ ($\mu$m)',fontsize=18)
ylabel('(R$_{p}$/R$_{*}$)$^{2} \%$',fontsize=18)
minorticks_on()
errorbar(1E4/wno, y_meas*100, yerr=err*100, xerr=None, fmt='ok',ms=2, label='Data',alpha=0.5)
plot(1E4/wno, y_mod_0*1E2, label='Full Model')
plot(1E4/wno, y_mod_1*1E2, label='Cloud Contribution', color='red')
ax.set_xscale('log')
ax.set_xticks([0.3, 0.5,0.8,1, 2, 3, 4, 5, 6, 8, 10, 12])
ax.axis([0.5,12,ymin,ymax])
ax.get_xaxis().set_major_formatter(matplotlib.ticker.ScalarFormatter())
ax.tick_params(length=10,width=1,labelsize='large',which='major')
legend(frameon=False)
show()
#close()
```
DONE
DONE
<IPython.core.display.Javascript object>
<img src="data:image/png;base64,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" width="640">
## Explore gas contributions
```python
from matplotlib.pyplot import *
from matplotlib.ticker import FormatStrFormatter
#NOTE; Will use whatever "cloud properties" from above
##generating "complete" spectrum (same as above)
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#H2O CH4 CO CO2 NH3 N2 HCN H2S PH3 C2H2 C2H6 Na K TiO VO FeH H H2 He e- h- mmw
gas_scale=np.array([1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1., 1., 1.]) #can be made free params if desired (won't affect mmw)#can be made free params if desired (won't affect mmw)
#calling forward model, fx. This will produce the (Rp/Rstar)^2 spectrum....
y_binned_0,y_mod_0,wno_0,atm_0=fx_trans(x,wlgrid,gas_scale, xsecs) #returns binned model spectrum, higher res model spectrum, wavenumber grid, and vertical abundance profiles from chemistry
print('DONE')
##generating cloud component only
#gas_scale[11]=0. #Na #shutting off a single gas (use the index map above)
#gas_scale[12]=0. #K #shutting off a single gas (use the index map above)
gas_scale[2]=0. #CO #shutting off a single gas (use the index map above)
y_binned_1,y_mod_1,wno_1,atm_1=fx_trans(x,wlgrid,gas_scale, xsecs) #returns binned model spectrum, higher res model spectrum, wavenumber grid, and vertical abundance profiles from chemistry
print('DONE')
#feel free to remove more gases and add to plotting...
ymin=np.min(y_binned_0)*1E2*0.99
ymax=np.max(y_binned_0)*1E2*1.01
fig1, ax=subplots()
xlabel('$\lambda$ ($\mu$m)',fontsize=18)
ylabel('(R$_{p}$/R$_{*}$)$^{2} \%$',fontsize=18)
minorticks_on()
errorbar(1E4/wno, y_meas*100, yerr=err*100, xerr=None, fmt='ok',ms=2, label='Data',alpha=0.5)
plot(1E4/wno, y_mod_0*1E2, label='Full Model')
plot(1E4/wno, y_mod_1*1E2, label='Removing A Gas', color='red')
ax.set_xscale('log')
ax.set_xticks([0.3, 0.5,0.8,1, 2, 3, 4, 5, 6, 8, 10, 12])
ax.axis([0.5,12,ymin,ymax])
ax.get_xaxis().set_major_formatter(matplotlib.ticker.ScalarFormatter())
ax.tick_params(length=10,width=1,labelsize='large',which='major')
legend(frameon=False)
show()
#close()
```
DONE
DONE
<IPython.core.display.Javascript object>
<img src="data:image/png;base64,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" width="640">
## Doing Retrieval with PyMultiNest
PyMultiNest (a python wrapper for MultiNest): Buchner et al. 2014 <br>
Paper: https://ui.adsabs.harvard.edu/abs/2014A%26A...564A.125B/abstract)<br>
GitHub: https://johannesbuchner.github.io/PyMultiNest/<br><br>
MultiNest: Feroz & Hobson 2008<br>
Paper: https://ui.adsabs.harvard.edu/abs/2009MNRAS.398.1601F/abstract<br>
GitHub:https://github.com/farhanferoz/MultiNest<br><br>
It is highly advised that you read the relevant sections of these papers and online documentation
## First have to install MultiNest (a bunch of Fortran, C) and PyMultiNest
While dynesty is easy to install and use, it's not quite as an efficient as a sampler as MultiNest/PyMultiNest (at least that I have found). Here we will re-do the above retrieval, but with the PyMultiNest package. The MultiNest package is readily parallelizeble on any compute cluster or multicore desktop/laptop (using mpi). Be forewarned, installing PyMultiNest can be a challenge as it is a combination of python, c, and fortran codes. Most compute cluster admins are able to install this package (both within slurm and torque). Below I outline the steps that I took on my 2016 MacBook Pro with High Sierra (10.13.6) based on a combination of https://www.astrobetter.com/wiki/MultiNest+Installation+Notes and https://exoai.github.io/software/taurex/installation.
Assuming you have some version of MacPorts, execute the following in this order from a terminal command line (note this can take several hours):
1. sudo port install gcc5
2. sudo port select --set gcc mp-gcc5
3. sudo port install cmake
4. sudo port install openblas +gcc5
5. sudo port install openmpi +gcc5
6. sudo port select --set mpi openmpi-mp-fortran
7. git clone https://github.com/JohannesBuchner/MultiNest.git
8. cd MultiNest/build/
9. cmake ..
10. make
11. sudo make install
12. git clone https://github.com/JohannesBuchner/PyMultiNest.git
13. cd PyMultiNest
14. python setup.py install
## Time To Run It
OK, time to run. Sorry, you will have to leave the comfort and safety of this notebook, but I'll walk you through it here. We will be using "mpirun" to run on your multiple processors on your laptop which I have not figured out how to do from a jupyter notebook (maybe you can use spawn or whatever, if your ambitious).
### STEP 1
Open the routine "call_pymultinest_transmission_simulated_JWST.py". Have a look, digest it, read the comments, etc. It should look farily similar to the above dynesty fundtions (e.g., a loglikelihood, prior cube, etc.). No need to modify anything for this. However, you would modify this script if you wanted to add/remove particular parameters or change the wavelength/wavenumber ranch of the run.
### STEP 2 (really a pseudostep)
Go to the folder (in terminal) where you have downloaded the CHIMERA code (mainly, where "call_pymultinest_transmission.py" lives). To run using one CPU, simpley type the following:
python call_pymultinest_transmission_simulated_JWST.py.
Wait a minute. You should see some useless unimportant error messages pop out followed by "Cross-sections Loaded" followed shortely there after by
$*************************$<br>
MultiNest v3.10<br>
Copyright Farhan Feroz & Mike Hobson<br>
Release Jul 2015<br><br>
no. of live points = 500<br>
dimensionality = 8<br>
$*************************$ <br>
Starting MultiNest<br>
generating live points
$------------------$
Eventually (a few minutes) you whould see more output:
live points generated, starting sampling
<br>
Acceptance Rate: 0.998185<br>
Replacements: 550<br>
Total Samples: 551<br>
Nested Sampling ln(Z): $**************$<br>
Acceptance Rate: 0.977199<br>
Replacements: 600<br>
Total Samples: 614<br>
Nested Sampling ln(Z): $**************$<br>
Acceptance Rate: 0.965825<br>
Replacements: 650<br>
Total Samples: 673<br>
Nested Sampling ln(Z): $**************$<br>
Acceptance Rate: 0.939597<br>
Replacements: 700<br>
Total Samples: 745<br>
Nested Sampling ln(Z): $**************$<br>
Do not be alarmed by the $*****$. It just means that there are too many digits to print out for the inital ln(Z) values. Eventually normalish looking numbers (usually negative) print out here. Ok, feel free to kill this now, because we will use mpi to make it faster.
### STEP 3
To do mpi, if everything installed correctly, you just need to type the following into the same command line: <br><br>
mpirun -np 4 python call_pymultinest_transmission_simulated_JWST.py<br><br>
Note, you can use more than 4 cpu's/cores if your computer has them. Use as many as you have. Now, just wait. You should see similar output as for the single cpu, ubt at a faster rate. For the default setup, with 4 cpu's, this takes $\sim$1hr 10 min (15452 calls). When it is done it will print out this:<br>
ln(ev)= -25.249086782326863 +/- 0.12562433089471531
Total Likelihood Evaluations: 15452<br>
Sampling finished. Exiting MultiNest<br>
analysing data from ./pmn$_$transmission$_$JWST/template_.txt<br>
analysing data from ./pmn$_$transmission$_$JWST/template_.txt<br>
analysing data from ./pmn$_$transmission$_$JWST/template_.txt<br>
analysing data from ./pmn$_$transmission$_$JWST/template_.txt<br>
### STEP 4
When this is done, it is time to plot. Open the routine, "plot_PMN_transmission_simulated_JWST.py". This will make the usual obnoxious corner plots, a reconstructed "TP" profile (which is kind of meaningless), and will generate sample spectra from random parameter vectors drawn from the posterior. This last part takes some time. When this is complete a nice 1-,2-sigma spectral spread plot will pop up. Feel free to manipulate this to make plots to your liking. Note, the spectral draws will be saved as a python pickle so that you can twiddle with plot adjustments without haveing to regenerate that each time.
That's it! You are done! So after having worked throught his notebook you should feel comfortable playing around with the forward model to gain an understanding of how each parameter influences the spectrum, comfortable running both the dynesty and pymultinest samplers, and plotting up standard output/results. Good luck. Note, there is no warrenty, if you get an unpysical answer, that's on you =)
Feel free to move onto the emission tutorial!
```python
```
```python
```
|
mrlineREPO_NAMECHIMERAPATH_START.@CHIMERA_extracted@CHIMERA-master@docs@notebooks@.ipynb_checkpoints@CHIMERA_TRANSMISSION_DEMO_WASP43b_JWST-checkpoint.ipynb@.PATH_END.py
|
{
"filename": "CHANGELOG.md",
"repo_name": "HERA-Team/aipy",
"repo_path": "aipy_extracted/aipy-main/CHANGELOG.md",
"type": "Markdown"
}
|
# Next version (not yet released)
- Remove `ez_setup` installation infrastructure; it has been deprecated for a
long time.
- Allow installing from empty environment
- Use github actions instead of travis
- Use python3 print()
- Use pytest instead of unittest
- Use explicit numpy types
# 3.0.1 (2019 Aug 21)
- Remove Astropy version cap; it was intended to promote simultaneous Python
2/3 compatibility, but if someone wants to use the newer version, that's
fine too.
- Fix a bug in the Healpix wrapper
([#52](https://github.com/HERA-Team/aipy/pull/52)).
- Fix some lingering Python 2/3 compatibility issues
([#51](https://github.com/HERA-Team/aipy/pull/51)).
- Honor `pos_def` in the 1D real CLEAN
([#44](https://github.com/HERA-Team/aipy/issues/44))
- Install the Helmboldt catalog data files, which were mistakenly not being
included in installations
([#45](https://github.com/HERA-Team/aipy/issues/45))
- Rename the package directory in the source tree from `aipy_src` to `aipy`.
# 3.0.0rc2 (2018 Aug 27)
- Fix generation of the package description in `setup.py`
([#46](https://github.com/HERA-Team/aipy/issues/46),
[#47](https://github.com/HERA-Team/aipy/issues/47))
- Fix division that should have become integer division
([#48](https://github.com/HERA-Team/aipy/issues/48))
# 3.0.0rc1 (2018 Aug 20)
- Make compatible with Python 3; remove scipy and healpix borrows.
# 2.x series
- No changelog was maintained. Consult the Git history.
1.0.0
* Added some performance enhancements
* Miriad.UV files can now store data as both shorts and as float32 (avoiding dynamic range problems)
* Various bugfixes
* Because of stability of 0.X.X series, we've promoted this to a non-beta release!
0.9.0
* Made some major naming changes in preparation for an AIPY publication. These include
renaming aipy.ant to aipy.phs, aipy.sim to aipy.amp, aipy.loc to aipy.cal.
* Renamed BeamFlat to just plain Beam
* Changed the -l options (for "loc files") in scripting interfaces to -C (for "cal" files)
* Added support in scripting interface channel selection for constructions of the form
0_10_2, meaning channels 0 to 10 (including endpoints), counting by 2.
* Refactored code so source spectra are computed internally to RadioBodys, and are
accessed through the get_jys() method. Added an update_jys() method for computing
a source spectrum for specified frequencies without needing an AntennaArray object.
* Added a get_afreqs() method to AntennaArrays to elucidate the opaque incantation;
"AntennaArray.ants[0].beam.afreqs."
* Added a system support for adding source catalogs through src.py calling catalog
interfaces stored in the _srcs directory. Made the Helmboldt catalog the default
catalog that AIPY comes with (since it's pretty small and geared toward low frequencies).
* Added unit tests (in "test" directory) for the most-used modules, and will continue to
add them as other modules are revisited. There is also a script called
"script_battery.sh" that does basic exercising of most AIPY scripts.
* In Antennas, grouped delay/offset into an array called phsoff which is a phase
polynomial in frequency.
* Couple of bugfixes on how objects are updated (now made explicit with "update()"
methods) and fixed an array shape bug in Antenna.refract()
* Fixed a bug in filter_src.py where data were zeroed when a source is below the horizon.
* Transitioned all nomenclature from "Fringe-Rate" to "Delay-Rate" as per
Parsons & Backer (2009) in AJ.
* Changed how fit parameters are input in scripting module
* Bugfix for when resolution effects are taken into account in
AntennaArray.gen_phs.
* Bugfix in xrfi.py for flagging by integration
* Improved filtering in filter_src.py to use padding and optionally passband
information.
* Added script srclist.py
* Added masking by wieght to plot_map.py
0.8.6
* Fixed a data-type error for Healpix maps that aren't doubles
* Added max/drng/cmap parameters to standard command-line options
* Started adding unit tests
* Changed noise option in mdlvis.py to add noise in Jy (not data) units.
* Changed behavior of reducing NSIDE in Healpix maps to sum instead of average.
* Bugfix on extracting source below the horizon in filter_src.py
* Work aound problem with numpy MA arrays not having a mask if entire image
is valid.
* Added new option (0,1,2)_3 for specifying antennas on the command line.
0.8.5
* Added support to mdlvis.py for simulating data without an input UV file.
* Added "none" mode to xrfi.py to flag only those channels specified manually.
* Added line to alm_wrapper.cpp to support compilation on python < 2.5.
0.8.4
* Changed modmap.py to work with sources of nonzero angular size. Also added
support for changing the data type (double,float) of a map.
* Added parameter to mk_img.py to control minimum altitude to allow for
phase center. Also added parameter for resuming interrupted faceting.
* Fixed xrfi.py default parameter "intthresh" to avoid excessive flagging
of integrations.
* Made fitmdl.py skip fitting when there are no data. Added "snap" mode to
fit parameters every integration.
* Added text color option to plot_map.py
* Added ionospheric refraction code using 1/freq**2 scaling. This involved
some significant refactoring of code, and some changes in fitmdl.py and
mdlvis.py.
* Changed fitmdl.py to cache UV data, resulting in less time reading files.
This significantly sped up code, although may become problematic with
fits involving lots of data.
* Removed some per-baseline computations in ant.py that occured every
compute, even if unnecessary. Baseline projections are now computed as
needed. Sped up simulations involving few baselines.
* Bugfix to miriad "select" command involving "time" selection: double
arguments were incorrectly cast as floats.
* Made mk_map.py a little more efficient in calculating map weights.
0.8.3
* Changed how loc-specific source parameters are implemented (now with
get_catalog() instead of src_prms). Changed scripts to use this format,
and scripting.parse_srcs() to return values that can feed get_catalog().
0.8.2
* Built in decimation to UV files in miriad_wrap.cpp.
* Added decimation selection with select() to UV files in miriad.py.
* Bugfix on various scripts to use new clean command.
0.8.1
* Split out cleaning functionality from mk_img.py into cl_img.py.
* Added snapshot capability to mk_img.py
* Bugfix for plot_img.py grid being upside-down.
* Reimplemented clean in C for speed.
0.8.0
* Added resolving support for elliptical sources in resolve_src() in ant.py.
* Reworked how get_baseline() and gen_uvw() functioned to facilitate elliptical
sources. This change required updating scripts that use gen_uvw().
* Allowed specifying coordinate epochs for RadioFixedBody's
* Changed how plot_img.py, mk_map.py work. There is now a general script
mk_img.py which geberates FITS files (introduced in 0.7.1) for each specified
source, or for equally-spaced phase centers around the sphere. This script
is responsible for all image generation. mk_map.py now takes these FITS
images as input and uses them as facet images to make a spherical Healpix
map. plot_img.py is now a visualization tool (a la plot_uv.py and
plot_map.py), and overlays appropriate ra/dec grids on the FITS images.
* Flipped u/v order (and sign of v) in the Img class in img.py to be more
naturally compatible with FITS image conventions. Required a change to
Img.gen_LM() as well.
0.7.2
* Added sorting to plot_uv.py to make plots in sensible baseline order.
* Edited script documentation for plot_map.py
* Changed "-a" in scripting.py so that "-a 0,1,2" includes only baselines that
involve these antennas without autos (i.e. 0_1,0_2,1_2), rather than all
baselines that involve any of the antennas. Listing 1 antenna will
include all baselines involving that antenna.
* Fixed combine_freqs.py to work with new numpy masked arrays.
* Made fitmdl.py have a --sim_auto parameter that rejects auto-correlations
by default. This makes fitmdl.py work more nicely with '-a' change above.
0.7.1
* Changed "flat" to "flatten()" in plot_img.py, as per numpy-1.2.
* Made plot_map.py able to function (only for cyl projection) without basemap.
* Added FITS image I/O convenience functions to img.py. Defined standard
FITS format based on VLA images.
0.7.0
* Moved functions from xrfi.py script into rfi module
* Bugfix in array shape in BeamFlat response() function
* Ported to numpy>=1.2. Involved:
- Update flag_by_int in rfi module for new numpy-1.2.ma behavior
- Update miriad_wrap.cpp, healpix_wrap.cpp, alm_wrap.cpp for new
numpy-1.2 API (PyArray_SimpleNew instead of PyArray_FromDims,
npy_intp instead of int for array dimensions)
0.6.5
* Bugfix to source strength polynomials as a function of LST
* Corrected all 3C source postions in src.py using NED.
* Ported to numpy>=1.1, matplotlib>=0.98, basemap>=0.99. Involved:
- use of numpy.histogram with new=True in xrfi.py
- importing Basemap from mpl_toolkits.basemap in plot_map.py
* Split dependency installation into two scripts: install_required.sh
which installs the minimum needed to be able to install aipy and run
"import aipy", and install_recommended.sh which installs matplotlib/basemap
and is needed for most of the scripts that come with AIPY.
0.6.4
* Attempting to support easy_install/setuptools functionality while maintaining
the simple building that already works.
* Feature added to plot_map.py to give (ra,dec),flux of location on a map
when right-clicked.
* Changed how plot_map.py plots to use imshow instead of contourf.
0.6.3
* Added _cephes module (from scipy, cutting out fortran dependencies) which
implements various scientific functions. Needed j1 = Bessel function.
* Moved source-resolution estimator (using symmetric disc approx) from phs2src
into separate AntennaArray.resolve_src(). Changed from incorrect sinc
function to correct j1 (first order Bessel function).
|
HERA-TeamREPO_NAMEaipyPATH_START.@aipy_extracted@aipy-main@CHANGELOG.md@.PATH_END.py
|
{
"filename": "__init__.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/graph_objs/scattergl/marker/__init__.py",
"type": "Python"
}
|
import sys
if sys.version_info < (3, 7):
from ._colorbar import ColorBar
from ._line import Line
from . import colorbar
else:
from _plotly_utils.importers import relative_import
__all__, __getattr__, __dir__ = relative_import(
__name__, [".colorbar"], ["._colorbar.ColorBar", "._line.Line"]
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@graph_objs@scattergl@marker@__init__.py@.PATH_END.py
|
{
"filename": "dynamodb.py",
"repo_name": "langchain-ai/langchain",
"repo_path": "langchain_extracted/langchain-master/libs/community/langchain_community/chat_message_histories/dynamodb.py",
"type": "Python"
}
|
from __future__ import annotations
import logging
from typing import TYPE_CHECKING, Dict, List, Optional
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.messages import (
BaseMessage,
message_to_dict,
messages_from_dict,
messages_to_dict,
)
if TYPE_CHECKING:
from boto3.session import Session
logger = logging.getLogger(__name__)
class DynamoDBChatMessageHistory(BaseChatMessageHistory):
"""Chat message history that stores history in AWS DynamoDB.
This class expects that a DynamoDB table exists with name `table_name`
Args:
table_name: name of the DynamoDB table
session_id: arbitrary key that is used to store the messages
of a single chat session.
endpoint_url: URL of the AWS endpoint to connect to. This argument
is optional and useful for test purposes, like using Localstack.
If you plan to use AWS cloud service, you normally don't have to
worry about setting the endpoint_url.
primary_key_name: name of the primary key of the DynamoDB table. This argument
is optional, defaulting to "SessionId".
key: an optional dictionary with a custom primary and secondary key.
This argument is optional, but useful when using composite dynamodb keys, or
isolating records based off of application details such as a user id.
This may also contain global and local secondary index keys.
kms_key_id: an optional AWS KMS Key ID, AWS KMS Key ARN, or AWS KMS Alias for
client-side encryption
ttl: Optional Time-to-live (TTL) in seconds. Allows you to define a per-item
expiration timestamp that indicates when an item can be deleted from the
table. DynamoDB handles deletion of expired items without consuming
write throughput. To enable this feature on the table, follow the
[AWS DynamoDB documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/time-to-live-ttl-how-to.html)
history_size: Maximum number of messages to store. If None then there is no
limit. If not None then only the latest `history_size` messages are stored.
history_messages_key: Key for the chat history where the messages
are stored and updated
"""
def __init__(
self,
table_name: str,
session_id: str,
endpoint_url: Optional[str] = None,
primary_key_name: str = "SessionId",
key: Optional[Dict[str, str]] = None,
boto3_session: Optional[Session] = None,
kms_key_id: Optional[str] = None,
ttl: Optional[int] = None,
ttl_key_name: str = "expireAt",
history_size: Optional[int] = None,
history_messages_key: Optional[str] = "History",
):
if boto3_session:
client = boto3_session.resource("dynamodb", endpoint_url=endpoint_url)
else:
try:
import boto3
except ImportError as e:
raise ImportError(
"Unable to import boto3, please install with `pip install boto3`."
) from e
if endpoint_url:
client = boto3.resource("dynamodb", endpoint_url=endpoint_url)
else:
client = boto3.resource("dynamodb")
self.table = client.Table(table_name)
self.session_id = session_id
self.key: Dict = key or {primary_key_name: session_id}
self.ttl = ttl
self.ttl_key_name = ttl_key_name
self.history_size = history_size
self.history_messages_key = history_messages_key
if kms_key_id:
try:
from dynamodb_encryption_sdk.encrypted.table import EncryptedTable
from dynamodb_encryption_sdk.identifiers import CryptoAction
from dynamodb_encryption_sdk.material_providers.aws_kms import (
AwsKmsCryptographicMaterialsProvider,
)
from dynamodb_encryption_sdk.structures import AttributeActions
except ImportError as e:
raise ImportError(
"Unable to import dynamodb_encryption_sdk, please install with "
"`pip install dynamodb-encryption-sdk`."
) from e
actions = AttributeActions(
default_action=CryptoAction.DO_NOTHING,
attribute_actions={
self.history_messages_key: CryptoAction.ENCRYPT_AND_SIGN
},
)
aws_kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
self.table = EncryptedTable(
table=self.table,
materials_provider=aws_kms_cmp,
attribute_actions=actions,
auto_refresh_table_indexes=False,
)
@property
def messages(self) -> List[BaseMessage]:
"""Retrieve the messages from DynamoDB"""
try:
from botocore.exceptions import ClientError
except ImportError as e:
raise ImportError(
"Unable to import botocore, please install with `pip install botocore`."
) from e
response = None
try:
response = self.table.get_item(Key=self.key)
except ClientError as error:
if error.response["Error"]["Code"] == "ResourceNotFoundException":
logger.warning("No record found with session id: %s", self.session_id)
else:
logger.error(error)
if response and "Item" in response:
items = response["Item"][self.history_messages_key]
else:
items = []
messages = messages_from_dict(items)
return messages
@messages.setter
def messages(self, messages: List[BaseMessage]) -> None:
raise NotImplementedError(
"Direct assignment to 'messages' is not allowed."
" Use the 'add_messages' instead."
)
def add_message(self, message: BaseMessage) -> None:
"""Append the message to the record in DynamoDB"""
try:
from botocore.exceptions import ClientError
except ImportError as e:
raise ImportError(
"Unable to import botocore, please install with `pip install botocore`."
) from e
messages = messages_to_dict(self.messages)
_message = message_to_dict(message)
messages.append(_message)
if self.history_size:
messages = messages[-self.history_size :]
try:
if self.ttl:
import time
expireAt = int(time.time()) + self.ttl
self.table.put_item(
Item={
**self.key,
self.history_messages_key: messages,
self.ttl_key_name: expireAt,
}
)
else:
self.table.put_item(
Item={**self.key, self.history_messages_key: messages}
)
except ClientError as err:
logger.error(err)
def clear(self) -> None:
"""Clear session memory from DynamoDB"""
try:
from botocore.exceptions import ClientError
except ImportError as e:
raise ImportError(
"Unable to import botocore, please install with `pip install botocore`."
) from e
try:
self.table.delete_item(Key=self.key)
except ClientError as err:
logger.error(err)
|
langchain-aiREPO_NAMElangchainPATH_START.@langchain_extracted@langchain-master@libs@community@langchain_community@chat_message_histories@dynamodb.py@.PATH_END.py
|
{
"filename": "maven_kp_to_tplot.py",
"repo_name": "spedas/pyspedas",
"repo_path": "pyspedas_extracted/pyspedas-master/pyspedas/projects/maven/maven_kp_to_tplot.py",
"type": "Python"
}
|
import logging
import calendar
import numpy as np
from .utilities import maven_kp_l2_regex
from .utilities import maven_param_list
from .utilities import remove_inst_tag
from .utilities import (
get_latest_files_from_date_range,
get_latest_iuvs_files_from_date_range,
)
from .utilities import get_header_info
from .orbit_time import orbit_time
from .read_iuvs_file import read_iuvs_file
import pytplot
from collections import OrderedDict
import builtins
import os
def maven_kp_to_tplot(
filename=None,
input_time=None,
instruments=None,
insitu_only=False,
specified_files_only=False,
ancillary_only=False,
notplot=False
):
"""
Convert MAVEN insitu (KP) data files to tplot variables.
Parameters
----------
filename : str or list, optional
Name of the file(s) to read in. Defaults to None.
input_time : str or list or int, optional
Time frame in which to search for downloaded files.
Can be a single date string, a list of two date strings representing a time range, or an orbit number.
Defaults to None.
instruments : str or list, optional
List of instruments to include. Defaults to None.
insitu_only : bool, optional
Flag to include only insitu data files. Defaults to False.
specified_files_only : bool, optional
If True, specifies that only filenames given in 'filename' should be read in. Defaults to False.
ancillary_only : bool, optional
If True, only the spacecraft and APP info will be loaded. Defaults to False.
notplot: bool, optional
If true, return the kp_insitu data as a dict rather than tplot variables. Defaults to False.
Returns
-------
dict
A dictionary containing up to all of the columns included in a MAVEN in-situ Key parameter data file.
"""
import pandas as pd
import re
from datetime import datetime, timedelta
from dateutil.parser import parse
filenames = []
iuvs_filenames = []
param_dict = maven_param_list()
if instruments is not None:
if not isinstance(instruments, builtins.list):
instruments = [instruments]
if filename is None and input_time is None:
logging.warning(
"You must specify either a set of filenames to read in, or a time frame in which "
"you want to search for downloaded files."
)
if ancillary_only:
instruments = ["SPACECRAFT"]
if filename is not None:
if not isinstance(filename, builtins.list):
filename = [filename]
dates = []
for file in filename:
date = re.findall(r"_(\d{8})", file)[0]
dates.append(date)
if "iuvs" in file:
iuvs_filenames.append(file)
else:
filenames.append(file)
dates.sort()
# To keep the rest of the code consistent, if someone gave a files, or files, to load, but no input_time,
# go ahead and create an 'input_time'
if input_time is None:
if len(dates) == 1:
input_time = (
str(dates[0][:4])
+ "-"
+ str(dates[0][4:6])
+ "-"
+ str(dates[0][6:])
)
else:
beg_date = min(dates)
end_date = max(dates)
input_time = [
str(beg_date[:4])
+ "-"
+ str(beg_date[4:6])
+ "-"
+ str(beg_date[6:]),
str(end_date[:4])
+ "-"
+ str(end_date[4:6])
+ "-"
+ str(end_date[6:]),
]
# Check for orbit num rather than time string
if isinstance(input_time, builtins.list):
if isinstance(input_time[0], int):
input_time = orbit_time(input_time[0], input_time[1])
elif isinstance(input_time, int):
input_time = orbit_time(input_time)
# Turn string input into datetime objects
if isinstance(input_time, list):
if len(input_time[0]) <= 10:
input_time[0] = input_time[0] + " 00:00:00"
if len(input_time[1]) <= 10:
input_time[1] = input_time[1] + " 23:59:59"
date1 = parse(input_time[0])
date2 = parse(input_time[1])
else:
if len(input_time) <= 10:
input_time += " 00:00:00"
date1 = parse(input_time)
date2 = date1 + timedelta(days=1)
date1_unix = calendar.timegm(date1.timetuple())
date2_unix = calendar.timegm(date2.timetuple())
# Grab insitu and iuvs files for the specified/created date ranges
date_range_filenames = get_latest_files_from_date_range(date1, date2)
date_range_iuvs_filenames = get_latest_iuvs_files_from_date_range(date1, date2)
# Add date range files to respective file lists if desired
if not specified_files_only:
filenames.extend(date_range_filenames)
iuvs_filenames.extend(date_range_iuvs_filenames)
if not date_range_filenames and not date_range_iuvs_filenames:
if not filenames and not iuvs_filenames:
logging.warning(
"No files found for the input date range, and no specific filenames were given. Exiting."
)
return
# Going to look for files between time frames, but as we might have already specified
# certain files to load in, we don't want to load them in 2x... so doing a check for that here
filenames = list(set(filenames))
iuvs_filenames = list(set(iuvs_filenames))
kp_regex, l2_regex = maven_kp_l2_regex()
kp_insitu = []
if filenames:
# Get column names
names, inst = [], []
crus_name, crus_inst = [], []
c_found = False
r_found = False
for f in filenames:
if (
kp_regex.match(os.path.basename(f)).group("description") == "_crustal"
and not c_found
):
name, inss = get_header_info(f)
# Strip off the first name for now (Time), and use that as the dataframe index.
# Seems to make sense for now, but will it always?
crus_name.extend(name[1:])
crus_inst.extend(inss[1:])
c_found = True
elif (
kp_regex.match(os.path.basename(f)).group("description") == ""
and not r_found
):
name, ins = get_header_info(f)
# Strip off the first name for now (Time), and use that as the dataframe index.
# Seems to make sense for now, but will it always?
names.extend(name[1:])
inst.extend(ins[1:])
r_found = True
all_names = names + crus_name
all_inst = inst + crus_inst
# Break up dictionary into instrument groups
(
lpw_group,
euv_group,
swe_group,
swi_group,
sta_group,
sep_group,
mag_group,
ngi_group,
app_group,
sc_group,
crus_group,
) = ([], [], [], [], [], [], [], [], [], [], [])
for i, j in zip(all_inst, all_names):
if re.match("^LPW$", i.strip()):
lpw_group.append(j)
elif re.match("^LPW-EUV$", i.strip()):
euv_group.append(j)
elif re.match("^SWEA$", i.strip()):
swe_group.append(j)
elif re.match("^SWIA$", i.strip()):
swi_group.append(j)
elif re.match("^STATIC$", i.strip()):
sta_group.append(j)
elif re.match("^SEP$", i.strip()):
sep_group.append(j)
elif re.match("^MAG$", i.strip()):
mag_group.append(j)
elif re.match("^NGIMS$", i.strip()):
ngi_group.append(j)
elif re.match("^MODELED_MAG$", i.strip()):
crus_group.append(j)
elif re.match("^SPICE$", i.strip()):
# NB Need to split into APP and SPACECRAFT
if re.match("(.+)APP(.+)", j):
app_group.append(j)
else: # Everything not APP is SC in SPICE
# But do not include Orbit Num, or IO Flag
# Could probably stand to clean this line up a bit
if not re.match("(.+)(Orbit Number|Inbound Outbound Flag)", j):
sc_group.append(j)
else:
pass
delete_groups = []
if instruments is not None:
if "LPW" not in instruments and "lpw" not in instruments:
delete_groups += lpw_group
if "MAG" not in instruments and "mag" not in instruments:
delete_groups += mag_group
if "EUV" not in instruments and "euv" not in instruments:
delete_groups += euv_group
if "SWI" not in instruments and "swi" not in instruments:
delete_groups += swi_group
if "SWE" not in instruments and "swe" not in instruments:
delete_groups += swe_group
if "NGI" not in instruments and "ngi" not in instruments:
delete_groups += ngi_group
if "SEP" not in instruments and "sep" not in instruments:
delete_groups += sep_group
if "STA" not in instruments and "sta" not in instruments:
delete_groups += sta_group
if "MODELED_MAG" not in instruments and "modeled_mag" not in instruments:
delete_groups += crus_group
# Read in all relavent data into a pandas dataframe called "temp"
temp_data = []
filenames.sort()
for filename in filenames:
# Determine number of header lines
nheader = 0
with open(filename) as f:
for line in f:
if line.startswith("#"):
nheader += 1
if (
kp_regex.match(os.path.basename(filename)).group("description")
== "_crustal"
):
temp_data.append(
pd.read_fwf(
filename,
skiprows=nheader,
index_col=0,
widths=[19] + len(crus_name) * [16],
names=crus_name,
)
)
else:
temp_data.append(
pd.read_fwf(
filename,
skiprows=nheader,
index_col=0,
widths=[19] + len(names) * [16],
names=names,
)
)
for i in delete_groups:
del temp_data[-1][i]
temp_unconverted = pd.concat(temp_data, axis=0, sort=True)
# Need to convert columns
# This is kind of a hack, but I can't figure out a better way for now
if (
"SWEA.Electron Spectrum Shape" in temp_unconverted
and "NGIMS.Density NO" in temp_unconverted
):
temp = temp_unconverted.astype(
dtype={
"SWEA.Electron Spectrum Shape": np.float64,
"NGIMS.Density NO": np.float64,
}
)
elif (
"SWEA.Electron Spectrum Shape" in temp_unconverted
and "NGIMS.Density NO" not in temp_unconverted
):
temp = temp_unconverted.astype(
dtype={"SWEA.Electron Spectrum Shape": np.float64}
)
elif (
"SWEA.Electron Spectrum Shape" not in temp_unconverted
and "NGIMS.Density NO" in temp_unconverted
):
temp = temp_unconverted.astype(dtype={"NGIMS.Density NO": np.float64})
else:
temp = temp_unconverted
# Cut out the times not included in the date range
time_unix = [
calendar.timegm(datetime.strptime(i, "%Y-%m-%dT%H:%M:%S").timetuple())
for i in temp.index
]
start_index = 0
for t in time_unix:
if t >= date1_unix:
break
start_index += 1
end_index = 0
for t in time_unix:
if t >= date2_unix:
break
end_index += 1
# Assign the first-level only tags
time_unix = time_unix[start_index:end_index]
temp = temp[start_index:end_index]
time = temp.index
time_unix = pd.Series(time_unix) # convert into Series for consistency
time_unix.index = temp.index
if "SPICE.Orbit Number" in list(temp):
orbit = temp["SPICE.Orbit Number"]
else:
orbit = None
if "SPICE.Inbound Outbound Flag" in list(temp):
io_flag = temp["SPICE.Inbound Outbound Flag"]
else:
io_flag = None
# Build the sub-level DataFrames for the larger dictionary/structure
app = temp[app_group]
spacecraft = temp[sc_group]
if instruments is not None:
if "LPW" in instruments or "lpw" in instruments:
lpw = temp[lpw_group]
else:
lpw = None
if "MAG" in instruments or "mag" in instruments:
mag = temp[mag_group]
else:
mag = None
if "EUV" in instruments or "euv" in instruments:
euv = temp[euv_group]
else:
euv = None
if "SWE" in instruments or "swe" in instruments:
swea = temp[swe_group]
else:
swea = None
if "SWI" in instruments or "swi" in instruments:
swia = temp[swi_group]
else:
swia = None
if "NGI" in instruments or "ngi" in instruments:
ngims = temp[ngi_group]
else:
ngims = None
if "SEP" in instruments or "sep" in instruments:
sep = temp[sep_group]
else:
sep = None
if "STA" in instruments or "sta" in instruments:
static = temp[sta_group]
else:
static = None
if "MODELED_MAG" in instruments or "modeled_mag" in instruments:
crus = temp[crus_group]
else:
crus = None
else:
lpw = temp[lpw_group]
euv = temp[euv_group]
swea = temp[swe_group]
swia = temp[swi_group]
static = temp[sta_group]
sep = temp[sep_group]
mag = temp[mag_group]
ngims = temp[ngi_group]
crus = temp[crus_group]
# Strip out the duplicated instrument part of the column names
# (this is a bit hardwired and can be improved)
for i in [lpw, euv, swea, swia, sep, static, ngims, mag, crus, app, spacecraft]:
if i is not None:
i.columns = remove_inst_tag(i)
if lpw is not None:
lpw = lpw.rename(index=str, columns=param_dict)
if euv is not None:
euv = euv.rename(index=str, columns=param_dict)
if swea is not None:
swea = swea.rename(index=str, columns=param_dict)
if swia is not None:
swia = swia.rename(index=str, columns=param_dict)
if sep is not None:
sep = sep.rename(index=str, columns=param_dict)
if static is not None:
static = static.rename(index=str, columns=param_dict)
if ngims is not None:
ngims = ngims.rename(index=str, columns=param_dict)
if mag is not None:
mag = mag.rename(index=str, columns=param_dict)
if crus is not None:
crus = crus.rename(index=str, columns=param_dict)
if app is not None:
app = app.rename(index=str, columns=param_dict)
if spacecraft is not None:
spacecraft = spacecraft.rename(index=str, columns=param_dict)
if orbit is not None and io_flag is not None:
# Do not forget to save units
# Define the list of first level tag names
tag_names = [
"TimeString",
"Time",
"Orbit",
"IOflag",
"LPW",
"EUV",
"SWEA",
"SWIA",
"STATIC",
"SEP",
"MAG",
"NGIMS",
"MODELED_MAG",
"APP",
"SPACECRAFT",
]
# Define list of first level data structures
data_tags = [
time,
time_unix,
orbit,
io_flag,
lpw,
euv,
swea,
swia,
static,
sep,
mag,
ngims,
crus,
app,
spacecraft,
]
else:
# Do not forget to save units
# Define the list of first level tag names
tag_names = [
"TimeString",
"Time",
"LPW",
"EUV",
"SWEA",
"SWIA",
"STATIC",
"SEP",
"MAG",
"NGIMS",
"MODELED_MAG",
"APP",
"SPACECRAFT",
]
# Define list of first level data structures
data_tags = [
time,
time_unix,
lpw,
euv,
swea,
swia,
static,
sep,
mag,
ngims,
crus,
app,
spacecraft,
]
kp_insitu = OrderedDict(zip(tag_names, data_tags))
# Now for IUVS
kp_iuvs = []
if not insitu_only and iuvs_filenames:
for file in iuvs_filenames:
kp_iuvs.append(read_iuvs_file(file))
if notplot:
return kp_insitu
if not kp_iuvs:
return tplot_varcreate(kp_insitu)
else:
# return kp_insitu, kp_iuvs
insitu_vars = tplot_varcreate(kp_insitu)
# The kp_iuvs structure can't be converted using tplot_varcreate. Not clear
# what needs to be done in order to use them. We'll punt on it for now and just
# return the insitu variables.
# iuvs_vars = tplot_varcreate(kp_iuvs)
return insitu_vars
def tplot_varcreate(insitu):
"""Creates tplot variables from the insitu variable"""
# initialize each instrument
created_vars = []
for obs in insitu["SPACECRAFT"]:
obs_specific = "mvn_kp::spacecraft::" + obs.lower()
try:
pytplot.store_data(
obs_specific, data={"x": insitu["Time"], "y": insitu["SPACECRAFT"][obs]}
)
created_vars.append(obs_specific)
except:
pass
# Join together the matricies and remove the individual points
pytplot.join_vec(
[
"mvn_kp::spacecraft::t11",
"mvn_kp::spacecraft::t12",
"mvn_kp::spacecraft::t13",
"mvn_kp::spacecraft::t21",
"mvn_kp::spacecraft::t22",
"mvn_kp::spacecraft::t23",
"mvn_kp::spacecraft::t31",
"mvn_kp::spacecraft::t32",
"mvn_kp::spacecraft::t33",
],
newname="mvn_kp::geo_to_mso_matrix",
)
pytplot.del_data(
[
"mvn_kp::spacecraft::t11",
"mvn_kp::spacecraft::t12",
"mvn_kp::spacecraft::t13",
"mvn_kp::spacecraft::t21",
"mvn_kp::spacecraft::t22",
"mvn_kp::spacecraft::t23",
"mvn_kp::spacecraft::t31",
"mvn_kp::spacecraft::t32",
"mvn_kp::spacecraft::t33",
]
)
pytplot.join_vec(
[
"mvn_kp::spacecraft::spacecraft_t11",
"mvn_kp::spacecraft::spacecraft_t12",
"mvn_kp::spacecraft::spacecraft_t13",
"mvn_kp::spacecraft::spacecraft_t21",
"mvn_kp::spacecraft::spacecraft_t22",
"mvn_kp::spacecraft::spacecraft_t23",
"mvn_kp::spacecraft::spacecraft_t31",
"mvn_kp::spacecraft::spacecraft_t32",
"mvn_kp::spacecraft::spacecraft_t33",
],
newname="mvn_kp::spacecraft_to_mso_matrix",
)
pytplot.del_data(
[
"mvn_kp::spacecraft::spacecraft_t11",
"mvn_kp::spacecraft::spacecraft_t12",
"mvn_kp::spacecraft::spacecraft_t13",
"mvn_kp::spacecraft::spacecraft_t21",
"mvn_kp::spacecraft::spacecraft_t22",
"mvn_kp::spacecraft::spacecraft_t23",
"mvn_kp::spacecraft::spacecraft_t31",
"mvn_kp::spacecraft::spacecraft_t32",
"mvn_kp::spacecraft::spacecraft_t33",
]
)
created_vars.remove("mvn_kp::spacecraft::t11")
created_vars.remove("mvn_kp::spacecraft::t12")
created_vars.remove("mvn_kp::spacecraft::t13")
created_vars.remove("mvn_kp::spacecraft::t21")
created_vars.remove("mvn_kp::spacecraft::t22")
created_vars.remove("mvn_kp::spacecraft::t23")
created_vars.remove("mvn_kp::spacecraft::t31")
created_vars.remove("mvn_kp::spacecraft::t32")
created_vars.remove("mvn_kp::spacecraft::t33")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t11")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t12")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t13")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t21")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t22")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t23")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t31")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t32")
created_vars.remove("mvn_kp::spacecraft::spacecraft_t33")
inst_list = ["EUV", "LPW", "STATIC", "SWEA", "SWIA", "MAG", "SEP", "NGIMS"]
for instrument in inst_list:
# for each observation for each instrument
if instrument in insitu:
if insitu[instrument] is not None:
for obs in insitu[instrument]:
# create variable name
obs_specific = "mvn_kp::" + instrument.lower() + "::" + obs.lower()
try:
# store data in tplot variable
pytplot.store_data(
obs_specific,
data={"x": insitu["Time"], "y": insitu[instrument][obs]},
)
created_vars.append(obs_specific)
pytplot.link(
obs_specific,
"mvn_kp::spacecraft::altitude",
link_type="alt",
)
pytplot.link(
obs_specific, "mvn_kp::spacecraft::mso_x", link_type="x"
)
pytplot.link(
obs_specific, "mvn_kp::spacecraft::mso_y", link_type="y"
)
pytplot.link(
obs_specific, "mvn_kp::spacecraft::mso_z", link_type="z"
)
pytplot.link(
obs_specific, "mvn_kp::spacecraft::geo_x", link_type="geo_x"
)
pytplot.link(
obs_specific, "mvn_kp::spacecraft::geo_y", link_type="geo_y"
)
pytplot.link(
obs_specific, "mvn_kp::spacecraft::geo_z", link_type="geo_z"
)
pytplot.link(
obs_specific,
"mvn_kp::spacecraft::sub_sc_longitude",
link_type="lon",
)
pytplot.link(
obs_specific,
"mvn_kp::spacecraft::sub_sc_latitude",
link_type="lat",
)
except:
pass
return created_vars
|
spedasREPO_NAMEpyspedasPATH_START.@pyspedas_extracted@pyspedas-master@pyspedas@projects@maven@maven_kp_to_tplot.py@.PATH_END.py
|
{
"filename": "_yaxis.py",
"repo_name": "catboost/catboost",
"repo_path": "catboost_extracted/catboost-master/contrib/python/plotly/py2/plotly/validators/histogram2dcontour/_yaxis.py",
"type": "Python"
}
|
import _plotly_utils.basevalidators
class YaxisValidator(_plotly_utils.basevalidators.SubplotidValidator):
def __init__(self, plotly_name="yaxis", parent_name="histogram2dcontour", **kwargs):
super(YaxisValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
dflt=kwargs.pop("dflt", "y"),
edit_type=kwargs.pop("edit_type", "calc+clearAxisTypes"),
role=kwargs.pop("role", "info"),
**kwargs
)
|
catboostREPO_NAMEcatboostPATH_START.@catboost_extracted@catboost-master@contrib@python@plotly@py2@plotly@validators@histogram2dcontour@_yaxis.py@.PATH_END.py
|
{
"filename": "fig5.py",
"repo_name": "JiaxiWu1018/Unsupervised-TRGB",
"repo_path": "Unsupervised-TRGB_extracted/Unsupervised-TRGB-main/plots/fig5.py",
"type": "Python"
}
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 3 18:15:02 2022
@author: michaelwu
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
from scipy import linalg
def selection(xx, yy, band):
m, b = band[0], band[1]
xx1 = (yy - b) / m
xx2 = (yy - b) / m + 1.0
judge = (xx > xx1) & (xx < xx2)
xx, yy = xx[judge], yy[judge]
return xx, yy
def gloess(mag, tau, bin_width = 0.01):
fig_gloess, ax_gloess = plt.subplots(figsize = (10, 10))
hist, bins, cont = ax_gloess.hist(mag, bins = np.arange(min(mag), max(mag) + bin_width, bin_width), color = 'black')
plt.close()
bin_centers = []
for j in range(len(bins) - 1):
bin_centers.append((bins[j] + bins[j + 1]) / 2)
yest = np.zeros(len(hist))
w = np.array([np.exp(- (bin_centers - bin_centers[i])**2/(2 * tau**2)) for i in range(len(hist))])
for i in range(len(hist)):
weights = w[i, :]
b = np.array([np.sum(weights * hist), np.sum(weights * hist * bin_centers)])
A = np.array([[np.sum(weights), np.sum(weights * bin_centers)],
[np.sum(weights * bin_centers), np.sum(weights * bin_centers * bin_centers)]])
theta = linalg.solve(A, b)
yest[i] = theta[0] + theta[1] * bin_centers[i]
return yest, np.array(bin_centers[2: -2])
def poisson_sobel(hist):
sobel = []
for ii in range(2, len(hist) - 2):
sobel.append(hist[ii - 1] * -1 * 1/np.sqrt(hist[ii - 1]) + hist[ii] * 0 + hist[ii + 1] * 1* 1/np.sqrt(hist[ii + 1]))
sobel = np.array(sobel)
return hist[2: -2], sobel
def hatt_sobel(hist):
sobel = []
for ii in range(2, len(hist) - 2):
sobel.append((hist[ii + 1] - hist[ii - 1]) / np.sqrt(hist[ii + 1] + hist[ii - 1]))
sobel = np.array(sobel)
return hist[2: -2], sobel
def simple_sobel(hist):
sobel = []
for ii in range(2, len(hist) - 2):
sobel.append(hist[ii-1] * -1 + hist[ii+1])
sobel = np.array(sobel)
return hist[2: -2], sobel
def prod_edr(mag, tau, weighting):
hist, binval = gloess(mag, tau)
if (weighting == 'poisson'):
lumfunc, edres = poisson_sobel(hist)
elif (weighting == 'hatt'):
lumfunc, edres = hatt_sobel(hist)
elif (weighting == 'simple'):
lumfunc, edres = simple_sobel(hist)
else:
print('No such weighting type')
return
return mag, binval, edres
def sweep(yy):
yy_min, yy_max = np.min(yy), np.max(yy)
val = np.arange(np.round(yy_min * 10) / 10, np.round(yy_max * 10) / 10, 0.01)
count = np.zeros(len(val))
for i in range(len(val)):
count[i] = sum((yy >= val[i] - 0.05) & (yy <= val[i] + 0.05))
best = np.mean(val[count == np.max(count)])
return best
color_list = ['#7e1e9c', '#15b01a', '#0343df', '#ff81c0', '#653700', '#e50000', '#95d0fc', '#029386', '#f97306', '#96f97b', '#c20078', '#ffff14',
'#75bbfd', '#929591', '#89fe05', '#bf77f6', '#9a0eea', '#033500', '#06c2ac', '#c79fef', '#00035b', '#d1b26f', '#00ffff', '#13eac9',
'#06470c', '#ae7181', '#35063e', '#01ff07', '#650021', '#6e750e', '#ff796c', '#e6daa6', '#0504aa', '#001146', '#cea2fd', '#000000',
'#ff028d', '#ad8150', '#c7fdb5', '#ffb07c', '#677a04', '#cb416b', '#8e82fe', '#53fca1', '#aaff32', '#380282', '#ceb301', '#ffd1df',
'#cf6275', '#0165fc', '#0cff0c', '#c04e01', '#04d8b2', '#01153e', '#3f9b0b', '#d0fefe', '#840000', '#be03fd', '#c0fb2d', '#a2cffe',
'#dbb40c', '#8fff9f', '#580f41', '#4b006e', '#8f1402', '#014d4e', '#610023', '#aaa662', '#137e6d', '#7af9ab', '#02ab2e', '#9aae07']
name = ['01','02','03','04','05','06','07','08','09','10','11']
plt.style.use('custom.mplstyle')
mpl.rcParams['text.usetex'] = False
#change version here
version, version1, version2 = 4, 4.2, 4.1
info = pd.read_csv('../info/ghosts_info_v{:s}.csv'.format(str(version)))
judge = ['ngc3031' in info['field'][i] for i in range(len(info))]
info = info[judge].reset_index(drop=True)
fig = plt.figure(figsize = (42, 20))
ax1 = fig.add_subplot(2, 2, 1)
ax2 = fig.add_subplot(2, 2, 3)
det = pd.read_csv('../detection/ghosts_detection_v{:s}.csv'.format(str(version1)))
judge = ['3031' in det['field'][i] for i in range(len(det))]
det = det[judge].reset_index(drop=True)
judge = (det['RGB AGB Ratio'] >= 3.5) & (det['# star below tip'] >= 50)
det = det[judge].reset_index(drop=True)
fit_trgb = sweep(np.array(det['TRGB']))
for i in range(len(info)):
ax1.plot([i+1,i+1], [20, 35], 'k-', lw = 2)
ax1.plot([0,len(info)], [fit_trgb]*2, 'g--', lw=3, label = 'best fit')
ax1.legend(loc = 'lower center', ncol=2)
for i in range(len(info)):
print(info['field'][i])
filename = '../clipped_csv/{:s}_v{:s}.csv'.format(info['field'][i], str(version))
data = pd.read_csv(filename)
color, mag = data['MAG1_ACS']-data['MAG2_ACS'], data['MAG2_ACS']
band = [info['slope_ac'][i], info['inter_ac'][i]]
color, mag = selection(color, mag, band)
mag, binval, edres = prod_edr(mag, 0.05, 'hatt')
ax2.plot(binval, edres, c=color_list[i], ls='-', lw=3, label='Halo Field{:s}'.format(name[i]))
judge = [det['field'][j] == info['field'][i] for j in range(len(det))]
subdet = det[judge].reset_index(drop=True)
if len(subdet) == 0:
continue
ax1.plot([i+0.5]*len(subdet), subdet['TRGB'], c = '#faba6b', marker = 'D', markersize = 16, ls = '--', lw = 2)
for j in range(len(subdet)):
ax2.plot([subdet['TRGB'][j]]*2, [0, 10], c=color_list[i], ls='-', lw=2)
if (subdet['RGB AGB Ratio'][j] >= 3.5) & (subdet['TRGB'][j] < 24.5) & (subdet['TRGB'][j] > 23.5):
ax2.text(subdet['TRGB'][j], 0.3-0.02*i, '$R={:.1f}$'.format(subdet['RGB AGB Ratio'][j]), c = color_list[i], fontsize=24)
judge = subdet['RGB AGB Ratio'] == np.max(np.array(subdet['RGB AGB Ratio']))
subdet = subdet[judge].reset_index(drop=True)
trgb = subdet['TRGB'][0]
ax1.plot(i+0.5, trgb, color = '#fd7133', marker = 'D', markersize = 16, ls = '')
ax1.set_xlim(0, len(info))
ax1.set_ylim(25, 22.5)
ax1.set_xticks(np.arange(0.5, len(info), 1))
ax1.set_xticklabels(name)
ax1.set_xlabel('Halo Field')
ax1.set_ylabel('Tip Mag')
ax1.set_title('NGC 3031 smoothing = 0.05')
ax2.set_xlim(23.5, 24.3)
ax2.set_xlabel('F814W Mag')
ax2.set_ylim(0, 0.3)
ax2.set_ylabel('EDR')
ax2.legend(bbox_to_anchor=(1.1, -0.15), loc = 'upper center', ncol = 6)
ax1 = fig.add_subplot(2, 2, 2)
ax2 = fig.add_subplot(2, 2, 4)
det = pd.read_csv('../detection/ghosts_detection_v{:s}.csv'.format(str(version2)))
judge = ['3031' in det['field'][i] for i in range(len(det))]
det = det[judge].reset_index(drop=True)
judge = (det['RGB AGB Ratio'] >= 3.5) & (det['# star below tip'] >= 50)
det = det[judge].reset_index(drop=True)
fit_trgb = sweep(np.array(det['TRGB']))
for i in range(len(info)):
ax1.plot([i+1,i+1], [20, 35], 'k-', lw = 2)
ax1.plot([0,len(info)], [fit_trgb]*2, 'g--', lw=3, label = 'best fit')
ax1.legend(loc = 'lower center', ncol=2)
for i in range(len(info)):
print(info['field'][i])
filename = '../clipped_csv/{:s}_v{:s}.csv'.format(info['field'][i], str(version))
data = pd.read_csv(filename)
color, mag = data['MAG1_ACS']-data['MAG2_ACS'], data['MAG2_ACS']
band = [info['slope_ac'][i], info['inter_ac'][i]]
color, mag = selection(color, mag, band)
mag, binval, edres = prod_edr(mag, 0.10, 'hatt')
ax2.plot(binval, edres, c=color_list[i], ls='-', lw=3, label='Halo Field{:s}'.format(name[i]))
judge = [det['field'][j] == info['field'][i] for j in range(len(det))]
subdet = det[judge].reset_index(drop=True)
if len(subdet) == 0:
continue
ax1.plot([i+0.5]*len(subdet), subdet['TRGB'], c = '#faba6b', marker = 'D', markersize = 16, ls = '--', lw = 2)
for j in range(len(subdet)):
ax2.plot([subdet['TRGB'][j]]*2, [0, 10], c=color_list[i], ls='-', lw=2)
if (subdet['RGB AGB Ratio'][j] >= 3.5) & (subdet['TRGB'][j] < 24.5) & (subdet['TRGB'][j] > 23.5):
ax2.text(subdet['TRGB'][j], 0.3-0.02*i, '$R={:.1f}$'.format(subdet['RGB AGB Ratio'][j]), c = color_list[i], fontsize=24)
judge = subdet['RGB AGB Ratio'] == np.max(np.array(subdet['RGB AGB Ratio']))
subdet = subdet[judge].reset_index(drop=True)
trgb = subdet['TRGB'][0]
ax1.plot(i+0.5, trgb, color = '#fd7133', marker = 'D', markersize = 16, ls = '')
ax1.set_xlim(0, len(info))
ax1.set_ylim(25, 22.5)
ax1.set_xticks(np.arange(0.5, len(info), 1))
ax1.set_xticklabels(name)
ax1.set_xlabel('Halo Field')
ax1.set_ylabel('Tip Mag')
ax1.set_title('NGC 3031 smoothing = 0.10')
ax2.set_xlim(23.5, 24.3)
ax2.set_xlabel('F814W Mag')
ax2.set_ylim(0, 0.3)
ax2.set_ylabel('EDR')
#plt.savefig('EDR.png')
plt.show()
|
JiaxiWu1018REPO_NAMEUnsupervised-TRGBPATH_START.@Unsupervised-TRGB_extracted@Unsupervised-TRGB-main@plots@fig5.py@.PATH_END.py
|
{
"filename": "physics.py",
"repo_name": "psheehan/pdspy",
"repo_path": "pdspy_extracted/pdspy-master/pdspy/constants/physics.py",
"type": "Python"
}
|
c = 2.99792458e10 # cm s^-1
h = 6.6260755e-27 # erg s
hbar = 1.05457266e-27 # erg s
G = 6.67259e-8 # cm^3 g^-1 s^-2
e = 4.8032068e-10 # esu
m_e = 9.1093897e-28 # g
m_p = 1.6726231e-24 # g
m_n = 1.6749286e-24 # g
m_H = 1.6733e-24 # g
amu = 1.6605402e-24 # g
N_A = 6.0221367e23 #
k = 1.380658e-16 # erg K^-1
eV = 1.6021772e-12 # erg
a = 7.5646e-15 # erg cm^-3 K^-4
sigma = 5.67051e-5 # erg cm^-2 K^-4 s^-1
alpha = 7.29735308e-3 #
R = 2.1798741e-11 # erg
|
psheehanREPO_NAMEpdspyPATH_START.@pdspy_extracted@pdspy-master@pdspy@constants@physics.py@.PATH_END.py
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.