def _init_p_limb_darkening(self):
pld = concatenate([
[PParameter(f'q1', 'q1 coefficient', '', UP(0, 1), bounds=(0, 1)),
PParameter(f'q2', 'q2 coefficient', '', UP(0, 1), bounds=(0, 1))]
for i, pb in enumerate(self.passbands)])
self.ps.add_passband_block('ldc', 2, self.npb, pld)
self._sl_ld = self.ps.blocks[-1].slice
self._start_ld = self.ps.blocks[-1].start
def _init_p_orbit(self):
"""Orbit parameter initialisation.
"""
porbit = [
GParameter('tc', 'zero epoch', 'd', NP(0.0, 0.1), (-inf, inf)),
GParameter('p', 'period', 'd', NP(1.0, 1e-5), (0, inf)),
GParameter('rho', 'stellar density', 'g/cm^3', UP(0.1, 25.0), (0, inf)),
GParameter('g', 'grazing parameter', 'R_s', UP(0.0, 1.0), (0, 1))]
self.ps.add_global_block('orbit', porbit)
def _init_p_planet(self):
ps = self.ps
pk2 = [
PParameter('k2_true', 'true_area_ratio', 'A_s',
UP(0.10**2, 0.75**2), (0.10**2, 0.75**2)),
PParameter('k2_app', 'apparent_area_ratio', 'A_s',
UP(0.10**2, 0.50**2), (0.10**2, 0.50**2))
]
ps.add_passband_block('k2', 1, 2, pk2)
self._pid_k2 = repeat(ps.blocks[-1].start, self.npb)
self._start_k2 = ps.blocks[-1].start
self._sl_k2 = ps.blocks[-1].slice
self.add_prior(lambda pv: where(pv[:, 5] < pv[:, 4], 0, -inf))
def _init_parameters(self):
self.ps = ParameterSet()
ppc = [
GParameter('ab', 'Bond albedo', '', UP(0, 1), (0, 1)),
GParameter('mp', 'log10 planet mass', 'MJup',
UP(log10(0.1), log10(300)), (0, inf)),
GParameter('ms', 'Star mass', 'MSun', NP(1.0, 0.1), (0, inf)),
GParameter('teffh', 'Host effective temperature', '',
UP(2000, 10000), (0, inf)),
GParameter('teffc', 'Companion effective temperature', '',
UP(500, 10000), (0, inf)),
GParameter('bl', 'Baseline level', '', NP(1, 0.005), (0, inf))
]
self.ps.add_global_block('phase_curve', ppc)
self.ps.freeze()
def init_parameters(self):
"""Baseline parameter initialisation.
"""
fptp = self.lpf.ofluxa.ptp()
bls = []
bls.append(LParameter(f'c_sin', f'sin phase', '', UP(0.0, 1.0), bounds=(0, 1)))
for i in range(self.n):
bls.append(LParameter(f'a_sin_{i}', f'sin {i} amplitude', '', UP(0, fptp), bounds=(0, inf)))
self.lpf.ps.thaw()
self.lpf.ps.add_global_block(self.name, bls)
self.lpf.ps.freeze()
self.pv_slice = self.lpf.ps.blocks[-1].slice
self.pv_start = self.lpf.ps.blocks[-1].start
setattr(self.lpf, f"_sl_{self.name}", self.pv_slice)
setattr(self.lpf, f"_start_{self.name}", self.pv_start)
def __init__(self,
name: str,
fname: Union[Path, str],
zero_epoch: Union[float, UFloat],
period: Union[float, UFloat],
nsamples: int = 2,
bldur: float = 0.1,
trdur: float = 0.04,
use_pdc: bool = True):
if isinstance(zero_epoch, float):
zero_epoch: UFloat = ufloat(zero_epoch, 1e-3)
if isinstance(period, float):
period: UFloat = ufloat(period, 1e-5)
super().__init__(name,
fname,
zero_epoch=zero_epoch.n,
period=period.n,
nsamples=nsamples,
bldur=bldur,
trdur=trdur,
use_pdc=use_pdc)
self.set_prior('zero_epoch', NP(zero_epoch.n, 3 * zero_epoch.s))
self.set_prior('period', NP(period.n, 3 * period.s))
self.set_prior('k2_true', UP(0.1**2, 0.75**2))
def __init__(self,
name: str,
flux_type: str,
use_ldtk: bool = False,
nsamples: int = 2,
nlegendre: int = 0,
bldur: float = 0.1,
trdur: float = 0.04):
assert flux_type.lower() in (
'sap', 'pdc'), "Flux type needs to be either 'sap' or 'pdc'"
super().__init__(name,
tess_file,
zero_epoch.n,
period.n,
nsamples=nsamples,
nlegendre=nlegendre,
bldur=bldur,
trdur=trdur,
use_pdc=(flux_type.lower() == 'pdc'),
separate_noise=True)
self.result_dir = Path('results')
self.set_prior('zero_epoch',
NP(zero_epoch.n - self.bjdrefi, 3 * zero_epoch.s))
self.set_prior('period', NP(period.n, 3 * period.s))
self.set_prior('k2_true', UP(0.1**2, 0.75**2))
if use_ldtk:
self.add_ldtk_prior(star_teff,
star_logg,
star_z,
passbands=(tess, ))
def _init_p_rv(self):
self.ps.thaw()
ps = self.ps
prv = [
GParameter(f'rv_shift_{self.rvis[i]}',
f'systemic velocity {self.rvis[i]}', 'm/s',
NP(0.0, 0.1), (-inf, inf))
for i in range(len(self.times))
]
ps.add_global_block('rv_shifts', prv)
self._start_rvs = ps.blocks[-1].start
self._sl_rvs = ps.blocks[-1].slice
prv = [
GParameter(f'rv_err_{self.rvis[i]}', 'additional rv error', 'm/s',
UP(0.0, 1.0), (-inf, inf))
for i in range(len(self.times))
]
ps.add_global_block('rv_errors', prv)
self._start_rv_err = ps.blocks[-1].start
self._sl_rv_err = ps.blocks[-1].slice
prv = []
for i in range(1, self.nplanets + 1):
prv.append(
GParameter(f'rv_k_{i}', f'rv semiamplitude {i}', 'm/s',
UP(0.0, 1.0), (0, inf)))
ps.add_global_block('rv_semiamplitudes', prv)
self._start_rvk = ps.blocks[-1].start
self._sl_rvk = ps.blocks[-1].slice
psl = [
GParameter('rv_slope', 'linear rv slope', 'm/s', NP(0.0, 1.0),
(-inf, inf))
]
ps.add_global_block('rv_slope', psl)
self._start_rv_slope = ps.blocks[-1].start
self._sl_rv_slope = ps.blocks[-1].slice
self.ps.freeze()
pnames = "rv_k_{} tc_{} p_{} secw_{} sesw_{}".split()
self.pids = zeros((self.nplanets, 5), 'int')
for ipl in range(self.nplanets):
for ip, p in enumerate(pnames):
name = p.format(ipl + 1)
self.pids[ipl, ip] = self.ps.names.index(name)
def _init_parameters(self):
self.ps = ps = ParameterSet([])
pp = []
for i in range(1, self.nplanets + 1):
pp.extend([
GParameter(f'tc_{i}', f'zero epoch {i}', 'd', NP(0.0, 0.1),
(-inf, inf)),
GParameter(f'p_{i}', f'period {i}', 'd', NP(1.0, 1e-5),
(0, inf)),
GParameter(f'secw_{i}', f'sqrt(e) cos(w) {i}', '',
UP(-1.0, 1.0), (-1, 1)),
GParameter(f'sesw_{i}', f'sqrt(e) sin(w) {i}', '',
UP(-1.0, 1.0), (-1, 1)),
])
ps.add_global_block('planets', pp)
self._start_pl = ps.blocks[-1].start
self._sl_pl = ps.blocks[-1].slice
def _init_p_orbit(self):
"""Orbit parameter initialisation.
"""
porbit = [
GParameter('rho', 'stellar_density', 'g/cm^3', UP(0.1, 25.0),
(0, inf))
]
self.ps.add_global_block('orbit', porbit)
def _init_p_planet(self):
ps = self.ps
pp = [
GParameter('ctess', 'tess_contamination', '', UP(0.0, 0.99),
(0, 1))
]
for i in range(1, self.nplanets + 1):
pp.extend([
GParameter(f'tc_{i}', f'zero_epoch_{i}', 'd', NP(0.0, 0.1),
(-inf, inf)),
GParameter(f'p_{i}', f'period_{i}', 'd', NP(1.0, 1e-5),
(0, inf)),
GParameter(f'b_{i}', f'impact_parameter_{i}', 'R_s',
UP(0.0, 1.0), (0, inf)),
GParameter(f'k2_true_{i}', f'true_area_ratio_{i}', 'A_s',
UP(0.02**2, 0.1**2), (0.02**2, 0.1**2))
])
ps.add_global_block('planets', pp)
self._start_pl = ps.blocks[-1].start
self._sl_pl = ps.blocks[-1].slice
def init_parameters(self):
name = self.name
pgp = [
LParameter(f'{name}_loge_{i}',
f'{name} log10 sigma {i}',
'',
UP(-4, 0),
bounds=(-inf, inf)) for i in self.global_noise_ids
]
self.lpf.ps.thaw()
self.lpf.ps.add_global_block(self.name, pgp)
self.lpf.ps.freeze()
self.pv_slice = self.lpf.ps.blocks[-1].slice
self.pv_start = self.lpf.ps.blocks[-1].start
setattr(self.lpf, f"_sl_{name}", self.pv_slice)
setattr(self.lpf, f"_start_{name}", self.pv_start)
def set_prior(self, parameter, prior, *nargs) -> None:
if isinstance(parameter, str):
descriptions = self.ps.descriptions
names = self.ps.names
if parameter in descriptions:
parameter = descriptions.index(parameter)
elif parameter in names:
parameter = names.index(parameter)
else:
params = ', '.join([f"{ln} ({sn})" for ln, sn in zip(self.ps.descriptions, self.ps.names)])
raise ValueError(f'Parameter "{parameter}" not found from the parameter set: {params}')
if isinstance(prior, str):
if prior.lower() in ['n', 'np', 'normal']:
prior = NP(nargs[0], nargs[1])
elif prior.lower() in ['u', 'up', 'uniform']:
prior = UP(nargs[0], nargs[1])
else:
raise ValueError(f'Unknown prior "{prior}". Allowed values are (N)ormal and (U)niform.')
self.ps[parameter].prior = prior