Python package: esl
The same science code as the website, from Python: the package runs the site's JavaScript core (bundled, unmodified) in an embedded engine, so a fit gives the browser's numbers. Install it straight from GitHub:
pip install "git+https://github.com/pearsonkyle/Exoplanet-Science-Lab.git#subdirectory=python"import esl
session = esl.Session.load("session.json") # a file saved from the Analyze page, or built in Python
fit = session.run(progress=True)
print(fit.result.table())Generated from the package's docstrings (tools/docs/gen_python.py).
esl.functions
The pieces of the core a scientist calls directly: models, limb darkening, ephemerides, the catalogue.
transit
transit(times: Any, params: ParamsLike, *, exptime: float = 0.0, supersample: Union[int, str] = 'auto') -> np.ndarrayTransit light curve (relative flux, 1 out of transit).
params: rprs, ars, inc, per, tmid, ecc, omega and limb darkening as ld=[...] with law (uniform, linear, quadratic, kipping, sqrt, nonlinear), or EXOTIC's u0..u3 (the four Claret coefficients). Without ars, mstar and rstar (and mplanet) give it through Kepler's law. A list of parameter sets gives the product of the planets' transits. exptime (days) averages the model over each exposure; supersample is the number of sub-samples, or "auto" (as many as ingress needs).
radial_velocity
radial_velocity(times: Any, params: ParamsLike, *, rvlin: float = 0.0, rvquad: float = 0.0, tref: Optional[float] = None) -> np.ndarrayRadial velocity of the star in m/s, positive when it recedes.
params: per, tmid, ecc, omega and either K [m/s] or mplanet [M_Jup], mstar [M_sun], inc (K from the two-body formula). A list sums the planets. rvlin [m/s/d] and rvquad [m/s/d^2] add a trend about tref (default: the first time).
semi_amplitude
semi_amplitude(per: float, mplanet: float, mstar: float, ecc: float = 0.0, inc: float = 90.0) -> floatK in m/s from the period [d], planet mass [M_Jup] and stellar mass [M_sun].
mass_from_k
mass_from_k(K: float, per: float, mstar: float, ecc: float = 0.0, inc: float = 90.0) -> floatPlanet mass [M_Jup] that gives the semi-amplitude K [m/s].
class LimbDarkeningCoefficients
class LimbDarkeningCoefficients(Model)No docstring.
| Field | Type | Default |
|---|---|---|
coeffs | List[float] | required |
names | List[str] | required |
law | str | required |
band | str | required |
range | List[float] | Field(description='band edges [nm]') |
source | str | Field(description="'table' (37-band PHOENIX table), 'spectra |
clamped | bool | Field(description='the star is outside the table and the nea |
claret | List[float] | Field(description='the same profile as four Claret coefficie |
physical | bool | Field(description='the profile is non-negative and does not |
limb_darkening
limb_darkening(teff: float, logg: float = 4.44, feh: float = 0.0, band: Union[str, Sequence[float]] = 'TESS', law: str = 'nonlinear') -> LimbDarkeningCoefficientsLimb darkening coefficients of a star from the bundled PHOENIX tables.
band: a name from esl.bands() ("TESS", "Kepler", "Johnson V", "Sloan r", "JWST NIRSpec PRISM", ...) or a wavelength range (nm, nm) between 200 and 5500 nm, served by the wavelength-resolved table. law: uniform, linear, quadratic, kipping, sqrt or nonlinear.
bands
bands() -> List[str]Names of the bundled passbands.
class EphemerisFit
class EphemerisFit(Model)T(E) = t0 + per E (+ dPdE E^2 / 2) by weighted least squares, uncertainties from the error bars as given.
| Field | Type | Default |
|---|---|---|
order | int | required |
n | int | required |
k | int | required |
t0 | float | required |
per | float | required |
dPdE | float | 0.0 |
err | Dict[str, float] | required |
cov | List[List[float]] | required |
chi2 | float | required |
dof | int | required |
bic | float | required |
dPdt | Optional[float] | Field(None, description='days per day (quadratic fits)') |
dPdtErr | Optional[float] | None |
epochs | IntArray | required |
residuals | Array | Field(description='observed minus fitted, days') |
model | Array | required |
maxFrac | Optional[float] | Field(None, description='largest distance of a time from a w |
predictions | List[Dict[str, float]] | Field(default_factory=list) |
fit_ephemeris
fit_ephemeris(times: Any, errors: Any, epochs: Any = None, period: Optional[float] = None, t_ref: Optional[float] = None, order: int = 1, predict: Optional[Sequence[int]] = None) -> EphemerisFitLinear (order=1) or quadratic (order=2) ephemeris from mid-transit times.
Give the orbit numbers as epochs, or a period to count them with (from t_ref, default the first time). predict: epochs at which to return the predicted time and its 1-sigma uncertainty.
class Periodogram
class Periodogram(Model)No docstring.
| Field | Type | Default |
|---|---|---|
label | str | '' |
freq | Array | required |
period | Array | Field(description='epochs') |
power | Array | required |
fapLevels | List[Dict[str, float]] | Field(default_factory=list) |
peaks | List[Dict[str, Any]] | Field(default_factory=list) |
class TimingPeriodogram
class TimingPeriodogram(Model)Lomb-Scargle search of timing residuals: periodograms, sinusoid models, BIC comparison and a verdict in words.
| Field | Type | Default |
|---|---|---|
n | int | required |
order | int | required |
period | float | Field(description='days per epoch, from the baseline ephemer |
epochs | Array | required |
errs | Array | required |
residuals | Array | required |
periodograms | List[Optional[Periodogram]] | required |
models | List[Optional[Dict[str, Any]]] | required |
curves | List[Optional[Dict[str, Any]]] | Field(default_factory=list) |
best | int | required |
recommended | int | required |
significant | bool | required |
significant2 | bool | False |
deltaBic | List[Optional[float]] | Field(default_factory=list) |
verdict | str | '' |
notes | List[str] | Field(default_factory=list) |
periodogram
periodogram(times: Any, errors: Any, epochs: Any = None, period: Optional[float] = None, t_ref: Optional[float] = None, **options) -> TimingPeriodogramSearch mid-transit times for periodic timing variations (timingPeriodogram of the core).
Options as in src/core/periodogram.js: order (1 or 2), oversample, minPeriod, maxPeriod, normalization, fapThreshold, bootstrap (number of bootstrap periodograms), seed, refine, countPeriods, nPeaks.
derive
derive(params: Any, star: Optional[Any] = None) -> Dict[str, float]The system table for one planet (deriveSystem): Rp, a, b, T14, T eclipse, K, T eq, densities, ...
star: rstar [R_sun], mstar [M_sun], teff [K], mplanet [M_Jup] (a dict or an esl.Star).
events
events(params: Any) -> Dict[str, float]Times of periastron and mid-eclipse nearest the transit, and the transit and eclipse durations (eventTimes).
read_light_curve
read_light_curve(source: Union[str, Path], name: Optional[str] = None, exposure_min: float = 0.0, detrend: Optional[Dict[str, Any]] = None, **options) -> LightCurveRead a light curve with the web application's reader: delimited text, AAVSO exoplanet reports, EXOTIC FinalLightCurve files, magnitudes, JD / MJD / BTJD / BKJD. source is a path or the text itself. Further numeric columns (centroids, sky, FWHM, ...) are kept in columns; detrend (e.g. {"columns": ["xc", "yc"], "poly": 1}, see :class:esl.models.Detrend) puts a systematics model built on them in the baseline.
read_rv
read_rv(source: Union[str, Path], name: str = 'RV') -> List[RadialVelocity]Read radial velocities (time, velocity, uncertainty, optional instrument column): one dataset per instrument, m/s.
catalog_location
catalog_location() -> strWhere lookup reads the archive snapshot: $ESL_CATALOG, else public/catalog of a repository checkout that contains this package, else the web site.
class CatalogSystem
class CatalogSystem(Model)What the catalogue holds for a name: the chosen reference per planet with its checks, and a session to start from.
| Field | Type | Default |
|---|---|---|
host | str | required |
planet | Optional[str] | None |
planets | List[str] | Field(default_factory=list) |
snapshot | Optional[str] | None |
system | Dict[str, Any] | Field(description='systemFromRows(): star, planets with valu |
session | Session | Field(description='values filled in, nothing free; each plan |
lookup
lookup(name: str, catalog: Optional[Union[str, Path]] = None, use: str = 'all') -> Optional[CatalogSystem]Parameters of a planet or host from the NASA Exoplanet Archive snapshot the web application uses.
For each planet the reference with the most complete and self-consistent set is chosen (chooseParameters), gaps are filled and labelled, and wide priors are suggested. use: "transit", "rv", "ephemeris" or "all". catalog: a folder or URL holding index.json and the shards (see catalog_location). Returns None when the name is not in the snapshot.
search
search(query: str, catalog: Optional[Union[str, Path]] = None, limit: int = 12) -> List[Dict[str, Any]]Names in the catalogue that start with or contain query.
esl.models
The ESL session as pydantic models, one-to-one with docs/FORMAT.md.
class Software
class Software(Model)No docstring.
| Field | Type | Default |
|---|---|---|
name | str | 'exoplanet-science-lab' |
version | Optional[str] | None |
commit | Optional[str] | None |
class Star
class Star(Model)The star. Radius in solar radii, mass in solar masses; the ...Err fields are 1-sigma uncertainties.
| Field | Type | Default |
|---|---|---|
teff | Optional[float] | Field(None, description='Effective temperature [K]') |
teffErr | Optional[float] | None |
logg | Optional[float] | Field(None, description='Surface gravity, log10 cgs') |
loggErr | Optional[float] | None |
feh | Optional[float] | Field(None, description='Metallicity [Fe/H], dex') |
fehErr | Optional[float] | None |
rstar | Optional[float] | Field(None, description='Radius [R_sun]') |
rstarErr | Optional[float] | None |
mstar | Optional[float] | Field(None, description='Mass [M_sun]') |
mstarErr | Optional[float] | None |
class LimbDarkening
class LimbDarkening(Model)Limb darkening of the star.
law: uniform, linear, quadratic (u1, u2), kipping (q1, q2), sqrt (c, d) or nonlinear (Claret's four coefficients, I = 1 - sum a_n (1 - mu^(n/2))). mode: "coeffs", the coefficients are parameters (ld0 .. ld3); "star", they follow the star's Teff and [Fe/H] through the PHOENIX tables, and teff / feh may be free instead. band: one of esl.bands() or "Custom range" with band_custom = [nm, nm].
| Field | Type | Default |
|---|---|---|
law | str | 'quadratic' |
mode | Literal['coeffs', 'star'] | 'coeffs' |
band | Optional[str] | 'TESS (approx.)' |
band_custom | Optional[List[float]] | None |
coefficients | List[float] | Field(default_factory=lambda: [0.4, 0.25]) |
class PlanetParameters
class PlanetParameters(Model)Parameters of one planet. Anything else (keys of models added later) is kept and passed to the core.
| Field | Type | Default |
|---|---|---|
rprs | Optional[float] | Field(None, description='Planet radius / stellar radius') |
ars | Optional[float] | Field(None, description='Semi-major axis / stellar radius (i |
inc | Optional[float] | Field(None, description='Inclination [deg]') |
per | Optional[float] | Field(None, description='Period [d]') |
tmid | Optional[float] | Field(None, description='Mid-transit time (inferior conjunct |
ecc | Optional[float] | Field(0.0, description='Eccentricity') |
omega | Optional[float] | Field(0.0, description='Argument of periastron [deg]') |
mplanet | Optional[float] | Field(None, description='Mass [M_Jup]') |
K | Optional[float] | Field(None, description='Radial-velocity semi-amplitude [m/s |
class Planet
class Planet(Model)No docstring.
| Field | Type | Default |
|---|---|---|
letter | str | 'b' |
parameters | PlanetParameters | Field(default_factory=PlanetParameters) |
class LightCurveEpoch
class LightCurveEpoch(Model)One observation (night, orbit, instrument) inside a light curve with several.
| Field | Type | Default |
|---|---|---|
name | str | '' |
airmass | bool | False |
exposure_min | Optional[float] | None |
class Detrend
class Detrend(Model)The systematics model built from a light curve's columns (docs/FORMAT.md), rebuilt by the core exactly as the web application does: columns are linear terms (column names, or xy, xc2, yc2), each standardised within each epoch and integrated out with the normalisation; poly a Legendre polynomial in time per epoch (0 to 3); pld PLD columns added as they are; kernel {"features": [...], "neighbors": 50} for nearest-neighbour kernel regression.
| Field | Type | Default |
|---|---|---|
columns | List[str] | Field(default_factory=list) |
poly | int | 0 |
pld | List[str] | Field(default_factory=list) |
kernel | Optional[Dict[str, Any]] | None |
class LightCurve
class LightCurve(Model)Relative flux against time. Several observations go in one light curve with epoch (an index per point) and epochs (one entry per observation); each then has its own normalisation and airmass slope. columns (detector columns, one value per point, NaN where missing) and detrend (a :class:Detrend) add a systematics model to the baseline.
| Field | Type | Default |
|---|---|---|
name | str | 'light curve' |
time | Array | required |
flux | Array | required |
flux_err | Array | required |
airmass | Optional[Array] | None |
exposure_min | float | Field(0.0, description='Exposure time in minutes; the model |
epoch | Optional[IntArray] | None |
epochs | List[LightCurveEpoch] | Field(default_factory=list) |
columns | Optional[Dict[str, ColumnArray]] | None |
detrend | Optional[Detrend] | None |
LightCurve.combine
combine(curves: Sequence['LightCurve'], name: str = 'light curves') -> 'LightCurve'Several light curves of the same star as the epochs of one (each keeps its normalisation and airmass slope).
class RadialVelocity
class RadialVelocity(Model)Velocities of one instrument, m/s. Its zero point is integrated out; its jitter is the parameter jit@rv<n>.
| Field | Type | Default |
|---|---|---|
name | str | 'RV' |
time | Array | required |
velocity | Array | required |
velocity_err | Array | required |
class TimingPoint
class TimingPoint(Model)A mid-transit or mid-eclipse time of a planet, with its 1-sigma uncertainty in days.
| Field | Type | Default |
|---|---|---|
planet | Optional[str] | None |
kind | Literal['transit', 'eclipse'] | 'transit' |
time | float | required |
err | float | required |
source | Optional[str] | None |
class Data
class Data(Model)No docstring.
| Field | Type | Default |
|---|---|---|
light_curve | Optional[LightCurve] | None |
radial_velocity | List[RadialVelocity] | Field(default_factory=list) |
timing | List[TimingPoint] | Field(default_factory=list) |
class Prior
class Prior(Model)uniform: a = minimum, b = maximum. normal: a = mean, b = standard deviation. For tmid the values are absolute times.
| Field | Type | Default |
|---|---|---|
type | str | 'uniform' |
a | Optional[float] | None |
b | Optional[float] | None |
values | Optional[List[float]] | None |
weights | Optional[List[float]] | None |
class FreeParameter
class FreeParameter(Model)A sampled parameter. Keys: planet parameters rprs, inc, per, tmid, ecc, omega, mplanet, K (per@c for planet c), limb darkening ld0 .. ld3, airmass slope a2 (a2@2 for the second epoch), velocities rvlin, rvquad, jit@rv1, star mstar, rstar, teff, feh. ars is never free.
| Field | Type | Default |
|---|---|---|
key | str | required |
label | Optional[str] | None |
unit | Optional[str] | None |
prior | Prior | required |
class Use
class Use(Model)Which kinds of data enter the likelihood.
| Field | Type | Default |
|---|---|---|
lc | bool | True |
rv | bool | True |
timing | bool | True |
class Sampler
class Sampler(Model)Settings of the nested sampler (src/core/nested.js).
| Field | Type | Default |
|---|---|---|
nlive | int | Field(400, description='Live points') |
fracRemain | float | Field(0.01, description='Stop when the live points hold less |
seed | int | 42 |
maxCalls | float | Field(1000000.0, description='Budget of likelihood calls') |
maxSeconds | Optional[float] | Field(None, description='Wall-clock budget') |
method | Optional[str] | Field(None, description="'auto' (default), 'region' or 'slic |
sliceSteps | Optional[int] | None |
class FitSettings
class FitSettings(Model)No docstring.
| Field | Type | Default |
|---|---|---|
use | Use | Field(default_factory=Use) |
free | List[FreeParameter] | Field(default_factory=list) |
fixed | Dict[str, float] | Field(default_factory=dict, description='Values of non-plane |
timing_noise | float | Field(0.0, description='Days, added in quadrature to every t |
sampler | Sampler | Field(default_factory=Sampler) |
class ParameterSummary
class ParameterSummary(Model)No docstring.
| Field | Type | Default |
|---|---|---|
key | str | required |
label | Optional[str] | None |
unit | Optional[str] | None |
median | float | required |
plus | float | required |
minus | float | required |
best | Optional[float] | None |
ParameterSummary.err
err() -> floatHalf the width of the 68% interval.
class Quantity
class Quantity(Model)No docstring.
| Field | Type | Default |
|---|---|---|
median | float | required |
plus | float | 0.0 |
minus | float | 0.0 |
class Chi2Parts
class Chi2Parts(Model)No docstring.
| Field | Type | Default |
|---|---|---|
light_curve | Optional[float] | 0.0 |
radial_velocity | Optional[float] | 0.0 |
timing | Optional[float] | 0.0 |
class RVZeroPoint
class RVZeroPoint(Model)No docstring.
| Field | Type | Default |
|---|---|---|
name | str | required |
gamma | float | required |
jitter | float | 0.0 |
class Samples
class Samples(Model)Equal-weight posterior draws. values[i, k] is draw i of parameter keys[k]; times are relative to the session's time_reference.
| Field | Type | Default |
|---|---|---|
keys | List[str] | required |
values | Array | required |
logl | Array | required |
class Result
class Result(Model)What a run returns: evidence, posterior summaries, derived quantities, best fit, chi-square, draws.
| Field | Type | Default |
|---|---|---|
logZ | float | required |
logZerr | float | required |
information | Optional[float] | None |
ess | Optional[float] | None |
ncalls | int | required |
seconds | Optional[float] | None |
converged | bool | required |
stop_reason | Optional[str] | None |
warnings | List[str] | Field(default_factory=list) |
parameters | List[ParameterSummary] | Field(default_factory=list) |
derived | Dict[str, Optional[Quantity]] | Field(default_factory=dict) |
best | Dict[str, float] | Field(default_factory=dict) |
chi2 | Optional[float] | None |
chi2_parts | Optional[Chi2Parts] | None |
n_data | Optional[int] | None |
bic | Optional[float] | None |
rv_zero_points | List[RVZeroPoint] | Field(default_factory=list) |
samples | Optional[Samples] | None |
Result.table
table() -> strThe fitted and derived parameters as text.
class LightCurveModel
class LightCurveModel(Model)No docstring.
| Field | Type | Default |
|---|---|---|
name | str | '' |
time | Array | required |
flux | Array | required |
flux_err | Array | required |
airmass | Optional[Array] | None |
epoch | Optional[IntArray] | None |
epochs | List[str] | Field(default_factory=list) |
model | Array | Field(description='normalisation x airmass term x transit: w |
baseline | Array | Field(description='normalisation x airmass term') |
transit | Array | Field(description='the bare transit model (1 out of transit) |
transits | List[Array] | Field(default_factory=list, description='one bare transit mo |
a1 | Array | Field(description='normalisation of each epoch at its condit |
LightCurveModel.detrended
detrended() -> np.ndarrayFlux divided by the baseline: comparable with transit.
class RVModel
class RVModel(Model)No docstring.
| Field | Type | Default |
|---|---|---|
name | str | '' |
time | Array | required |
velocity | Array | required |
velocity_err | Array | required |
gamma | float | Field(description='zero point at its conditional maximum [m/ |
jitter | float | 0.0 |
chi2 | float | 0.0 |
model | Array | Field(description='planets + trend, without the zero point') |
planets | List[Array] | Field(default_factory=list) |
class TimingModel
class TimingModel(Model)No docstring.
| Field | Type | Default |
|---|---|---|
planet | str | required |
kind | str | required |
time | Array | required |
err | Array | required |
model | Array | required |
epoch | IntArray | required |
class ModelEvaluation
class ModelEvaluation(Model)The model of a session at one point of parameter space, with every per-point piece.
| Field | Type | Default |
|---|---|---|
lnL | float | required |
chi2 | float | required |
chi2_parts | Chi2Parts | required |
n_data | int | required |
n_linear | int | required |
bic | float | required |
keys | List[str] | Field(default_factory=list) |
values | Dict[str, float] | Field(default_factory=dict) |
light_curve | Optional[LightCurveModel] | None |
radial_velocity | List[RVModel] | Field(default_factory=list) |
timing | List[TimingModel] | Field(default_factory=list) |
planets | List[Dict[str, Any]] | Field(default_factory=list) |
limb_darkening | List[float] | Field(default_factory=list) |
rv_tref | Optional[float] | None |
class Progress
class Progress(Model)One progress report of the sampler, about eight a second.
| Field | Type | Default |
|---|---|---|
it | int | 0 |
ncalls | int | 0 |
logZ | Optional[float] | None |
remFrac | Optional[float] | None |
eff | Optional[float] | None |
mode | Optional[str] | None |
bestL | Optional[float] | None |
best | List[float] | Field(default_factory=list) |
keys | List[str] | Field(default_factory=list) |
elapsed | float | 0.0 |
class Likelihood
class Likelihood()A session's likelihood, opened in the core for repeated calls (your own sampler or optimiser).
like(theta) takes an array of shape (ndim,) or (n, ndim) in the order of like.keys (tmid absolute) and returns ln L; invalid points give -1e100. like.transform(u) maps unit-cube points through the priors. Use it as a context manager, or call close().
class Session
class Session(Model)One analysis: system, data, fit set-up and (after run) result. See docs/FORMAT.md.
| Field | Type | Default |
|---|---|---|
format | str | FORMAT |
version | int | FORMAT_VERSION |
software | Optional[Software] | None |
created | Optional[str] | None |
name | Optional[str] | None |
title | Optional[str] | None |
notes | Optional[str] | None |
star | Star | Field(default_factory=Star) |
limb_darkening | LimbDarkening | Field(default_factory=LimbDarkening) |
planets | List[Planet] | required |
kepler | bool | Field(False, description="a/R* follows from Kepler's law (M* |
time_reference | float | Field(0.0, description='Times are measured from here inside |
data | Data | Field(default_factory=Data) |
fit | FitSettings | Field(default_factory=FitSettings) |
result | Optional[Result] | None |
Session.load
load(path: Union[str, Path]) -> 'Session'Read a session file (a browser export, or one written by save).
Session.save
save(path: Union[str, Path], indent: Optional[int] = None) -> PathWrite the session (with its result, if any) as JSON; the web application opens it.
Session.key
key(name: str, planet: Optional[str] = None) -> strThe parameter key of a planet's field: key("per", "c") == "per@c"; the first planet's keys are plain.
Session.free
free(key: str, prior: Prior, planet: Optional[str] = None, **kw) -> 'Session'Make a parameter free (replacing its prior if it already is). Returns self, so calls chain.
Session.summary
summary() -> strA few lines saying what the session holds.
Session.check
check() -> 'Session'Validate with the core's own rules (validateSession and the limb darkening set-up). Raises esl.CoreError.
Session.evaluate
evaluate(at: Optional[Dict[str, float]] = None, use: Optional[Dict[str, bool]] = None) -> ModelEvaluationThe model, chi-square and ln L at given parameter values: the session's own by default, the best fit with at=session.result.best. Keys as in fit.free (tmid absolute).
Session.best_fit
best_fit() -> ModelEvaluationThe model at the best-fit point of the stored result (at the session's values when there is none).
Session.likelihood
likelihood(use: Optional[Dict[str, bool]] = None) -> LikelihoodOpen the likelihood for repeated evaluation; see :class:Likelihood.
Session.run
run(progress: Union[bool, Callable[[Progress], None], None] = False, keep_samples: bool = True, max_samples: int = 2000, use: Optional[Dict[str, bool]] = None, **sampler) -> 'Session'Run the fit. Returns a new session with result filled in, exactly as the web application writes it.
progress: True prints a status line to stderr; a function receives :class:Progress objects. sampler keywords override fit.sampler for this run (nlive=200, seed=3, maxCalls=2e5, ...). Ctrl-C stops the sampler cleanly and returns what it has (result.converged is then False).
Session.to_script
to_script(embed_data: bool = True, session_file: str = 'session.json', figures: bool = True, prefix: Optional[str] = None) -> strA standalone Python script that rebuilds this session line by line, runs it and draws the figures.
Session.to_markdown
to_markdown(session_file: str = 'session.json') -> strA report: system, data, priors, sampler, results, software version, how to reproduce.
Session.to_latex
to_latex() -> strLaTeX tables of the fitted and derived parameters and of the priors.
esl.multi_fitter
EXOTIC's multi-planet fitter API on the Exoplanet Science Lab core.
transit
transit(times: Any, values: Any, precision: Any = None) -> np.ndarrayTransit model with EXOTIC's signature: values holds rprs, per, ars, ecc, inc, omega, tmid, u0..u3.
radial_velocity
radial_velocity(time: Any, params: Any, dt: float = 0.0001) -> np.ndarrayRadial velocity [m/s] with EXOTIC's signature. params: per, tmid, ecc, omega, inc and mplanet, mstar (or K). The two-body amplitude is used, not EXOTIC's Mp / M* scaling.
esl.plot
Figures with matplotlib, in the manner of EXOTIC's examples: best-fit light curves (per observation, or folded per planet), radial velocities against time and phase, the posterior coloured by likelihood, and O - C.
radial_velocity
radial_velocity(session: Session, fold: bool = False, figsize: Optional[Sequence[float]] = None) -> AnyRadial velocities with the best-fit model.
fold=False: velocities minus each instrument's zero point against time, the model as a smooth curve, residuals below. fold=True: one panel per planet against orbital phase, the other planets and the trend subtracted.
periodogram
periodogram(pg: '_f.TimingPeriodogram', figsize: Sequence[float] = (8, 6)) -> AnyThe periodograms of the timing residuals with their false-alarm levels and strongest peaks.