def _do_compute(self, quiet):
if quiet:
self._d, self._W, _ = ops.factor_quiet(self._t, self._c, self._a,
self._U, self._V)
self._log_det = tt.switch(tt.any(self._d <= 0.0), -np.inf,
tt.sum(tt.log(self._d)))
else:
self._d, self._W, _ = ops.factor(self._t, self._c, self._a,
self._U, self._V)
self._log_det = tt.sum(tt.log(self._d))
self._norm = -0.5 * (self._log_det + self._size * np.log(2 * np.pi))
def forward(self, x):
p = x[0]
b = x[1]
pl = self.min_radius
r11 = (b / (1 + pl) - 1) * (1 - self.Ar) + 1
r21 = (p - pl) / self.dr
arg = p - b - self.dr + 1
q1 = (arg / self.dr)**2
q2 = (pl - b + 1) / arg
r12 = q1 * self.Ar
r22 = q2
y = tt.switch(b <= 1, tt.stack((r11, r21), axis=0),
tt.stack((r12, r22), axis=0))
return tt.log(y) - tt.log(1 - y)
def __init__(self, *args, **kwargs):
ttvs = kwargs.pop("ttvs", None)
transit_times = kwargs.pop("transit_times", None)
transit_inds = kwargs.pop("transit_inds", None)
if ttvs is None and transit_times is None:
raise ValueError("one of 'ttvs' or 'transit_times' must be "
"defined")
if ttvs is not None:
self.ttvs = [as_tensor_variable(ttv, ndim=1) for ttv in ttvs]
if transit_inds is None:
self.transit_inds = [
tt.arange(ttv.shape[0]) for ttv in self.ttvs
]
else:
self.transit_inds = [
tt.cast(as_tensor_variable(inds, ndim=1), "int64")
for inds in transit_inds
]
else:
# If transit times are given, compute the least squares period and
# t0 based on these times.
self.transit_times = []
self.ttvs = []
self.transit_inds = []
period = []
t0 = []
for i, times in enumerate(transit_times):
times = as_tensor_variable(times, ndim=1)
if transit_inds is None:
inds = tt.arange(times.shape[0])
else:
inds = tt.cast(as_tensor_variable(transit_inds[i]),
"int64")
self.transit_inds.append(inds)
# A convoluted version of linear regression; don't ask
N = times.shape[0]
sumx = tt.sum(inds)
sumx2 = tt.sum(inds**2)
sumy = tt.sum(times)
sumxy = tt.sum(inds * times)
denom = N * sumx2 - sumx**2
slope = (N * sumxy - sumx * sumy) / denom
intercept = (sumx2 * sumy - sumx * sumxy) / denom
expect = intercept + inds * slope
period.append(slope)
t0.append(intercept)
self.ttvs.append(times - expect)
self.transit_times.append(times)
kwargs["t0"] = tt.stack(t0)
# We'll have two different periods: one that is the mean difference
# between transit times and one that is a parameter that sets the
# transit shape. If a "period" parameter is not given, these will
# be the same. Users will probably want to put a prior relating the
# two periods if they use separate values.
self.ttv_period = tt.stack(period)
if "period" not in kwargs:
if "delta_log_period" in kwargs:
kwargs["period"] = tt.exp(
tt.log(self.ttv_period) +
kwargs.pop("delta_log_period"))
else:
kwargs["period"] = self.ttv_period
super(TTVOrbit, self).__init__(*args, **kwargs)
if ttvs is not None:
self.ttv_period = self.period
self.transit_times = [
self.t0[i] + self.period[i] * self.transit_inds[i] + ttv
for i, ttv in enumerate(self.ttvs)
]
# Compute the full set of transit times
self.all_transit_times = []
for i, inds in enumerate(self.transit_inds):
expect = self.t0[i] + self.period[i] * tt.arange(inds.max() + 1)
self.all_transit_times.append(
tt.set_subtensor(expect[inds], self.transit_times[i]))
# Set up a histogram for identifying the transit offsets
self._bin_edges = [
tt.concatenate((
[tts[0] - 0.5 * self.ttv_period[i]],
0.5 * (tts[1:] + tts[:-1]),
[tts[-1] + 0.5 * self.ttv_period[i]],
)) for i, tts in enumerate(self.all_transit_times)
]
self._bin_values = [
tt.concatenate(([tts[0]], tts, [tts[-1]]))
for i, tts in enumerate(self.all_transit_times)
]
def forward(self, x):
usum = tt.sum(x, axis=0)
q = tt.stack([usum**2, 0.5 * x[0] / usum])
return tt.log(q) - tt.log(1 - q)
def jacobian_det(self, y):
# This is y here, not y / (1 + ror) because the jacobian is computed
# using the 'backward' op *of this transform* not its super.
jac = super(ImpactParameterTransform, self).jacobian_det(y)
return jac - tt.log(self.one_plus_ror)
def duration_to_eccentricity(func, duration, ror,
**kwargs): # pragma: no cover
num_planets = kwargs.pop("num_planets", 1)
orbit_type = kwargs.pop("orbit_type", KeplerianOrbit)
name = kwargs.get("name", "dur_ecc")
inputs = _get_consistent_inputs(
kwargs.get("a", None),
kwargs.get("period", None),
kwargs.get("rho_star", None),
kwargs.get("r_star", None),
kwargs.get("m_star", None),
kwargs.get("rho_star_units", None),
kwargs.get("m_planet", 0.0),
kwargs.get("m_planet_units", None),
)
a, period, rho_star, r_star, m_star, m_planet = inputs
b = kwargs.get("b", 0.0)
s = tt.sin(kwargs["omega"])
umax_inv = tt.switch(tt.lt(s, 0), tt.sqrt(1 - s**2), 1.0)
const = (period * tt.shape_padright(r_star) * tt.sqrt((1 + ror)**2 - b**2))
const /= np.pi * a
u = duration / const
e1 = -s * u**2 / ((s * u)**2 + 1)
e2 = tt.sqrt((s**2 - 1) * u**2 + 1) / ((s * u)**2 + 1)
models = []
logjacs = []
logprobs = []
for args in product(*(zip("np", (-1, 1)) for _ in range(num_planets))):
labels, signs = zip(*args)
# Compute the eccentricity branch
ecc = tt.stack([e1[i] + signs[i] * e2[i] for i in range(num_planets)])
# Work out the Jacobian
valid_ecc = tt.and_(tt.lt(ecc, 1.0), tt.ge(ecc, 0.0))
logjac = tt.switch(
tt.all(valid_ecc),
tt.sum(0.5 * tt.log(1 - ecc**2) + 2 * tt.log(s * ecc + 1) -
tt.log(tt.abs_(s + ecc)) - tt.log(const)),
-np.inf,
)
ecc = tt.switch(valid_ecc, ecc, tt.zeros_like(ecc))
# Create a sub-model to capture this component
with pm.Model(name="dur_ecc_" + "_".join(labels)) as model:
pm.Deterministic("ecc", ecc)
orbit = orbit_type(ecc=ecc, **kwargs)
logprob = tt.sum(func(orbit))
models.append(model)
logjacs.append(logjac)
logprobs.append(logprob)
# Compute the marginalized likelihood
logjacs = tt.stack(logjacs)
logprobs = tt.stack(logprobs)
logprob = tt.switch(
tt.gt(1.0 / u, umax_inv),
tt.sum(pm.logsumexp(logprobs + logjacs)),
-np.inf,
)
pm.Potential(name + "_logp", logprob)
pm.Deterministic(name + "_logjacs", logjacs)
pm.Deterministic(name + "_logprobs", logprobs)
# Loop over models and compute the marginalized values for all the
# parameters and deterministics
norm = tt.sum(pm.logsumexp(logjacs))
logw = tt.switch(
tt.gt(1.0 / u, umax_inv),
logjacs - norm,
-np.inf + tt.zeros_like(logjacs),
)
pm.Deterministic(name + "_logw", logw)
for k in models[0].named_vars.keys():
name = k[len(models[0].name) + 1:]
pm.Deterministic(
name,
sum(
tt.exp(logw[i]) * model.named_vars[model.name + "_" + name]
for i, model in enumerate(models)),
)
def vaneylen19(
name,
fixed=False,
multi=False,
lower=None,
upper=None,
model=None,
**kwargs,
):
"""The eccentricity distribution for small planets
The mixture distribution fit by `Van Eylen et al. (2019)
<https://arxiv.org/abs/1807.00549>`_ to a population of well-characterized
small transiting planets observed by Kepler.
Args:
name (str): The name of the eccentricity variable.
fixed (bool, optional): If ``True``, use the posterior median
hyperparameters. Otherwise, marginalize over the parameters.
multi (bool, optional): If ``True``, use the distribution for systems
with multiple transiting planets. If ``False`` (default), use the
distribution for systems with only one detected transiting planet.
lower (float, optional): Restrict the eccentricity to be larger than
this value.
upper (float, optional): Restrict the eccentricity to be smaller than
this value.
Returns:
The eccentricity distribution.
"""
model = pm.modelcontext(model)
add_citations_to_model(["vaneylen19"], model=model)
sigma_gauss_mu = 0.049
sigma_gauss_sd = 0.02
sigma_rayleigh_mu = 0.26
sigma_rayleigh_sd = 0.05
if multi:
frac_mu = 0.08
frac_sd = 0.08
else:
frac_mu = 0.76
frac_sd = 0.2
with model:
ecc = pm.Uniform(
name,
lower=0.0 if lower is None else lower,
upper=1.0 if upper is None else upper,
**kwargs,
)
with pm.Model(name=name):
if fixed:
sigma_gauss = sigma_gauss_mu
sigma_rayleigh = sigma_rayleigh_mu
frac = frac_mu
else:
bounded_normal = pm.Bound(pm.Normal, lower=0)
sigma_gauss = bounded_normal(
"sigma_gauss",
mu=sigma_gauss_mu,
sd=sigma_gauss_sd,
testval=sigma_gauss_mu,
)
sigma_rayleigh = bounded_normal(
"sigma_rayleigh",
mu=sigma_rayleigh_mu,
sd=sigma_rayleigh_sd,
testval=sigma_rayleigh_mu,
)
frac = pm.Bound(pm.Normal, lower=0, upper=1)(
"frac", mu=frac_mu, sd=frac_sd, testval=frac_mu
)
gauss = pm.HalfNormal.dist(sigma=sigma_gauss)
rayleigh = pm.Weibull.dist(
alpha=2, beta=np.sqrt(2) * sigma_rayleigh
)
pm.Potential(
"prior",
pm.math.logaddexp(
tt.log(1 - frac) + gauss.logp(ecc),
tt.log(frac) + rayleigh.logp(ecc),
),
)
return ecc