Skip to content

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:

sh
pip install "git+https://github.com/pearsonkyle/Exoplanet-Science-Lab.git#subdirectory=python"
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 ​

python
transit(times: Any, params: ParamsLike, *, exptime: float = 0.0, supersample: Union[int, str] = 'auto') -> np.ndarray

Transit 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 ​

python
radial_velocity(times: Any, params: ParamsLike, *, rvlin: float = 0.0, rvquad: float = 0.0, tref: Optional[float] = None) -> np.ndarray

Radial 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 ​

python
semi_amplitude(per: float, mplanet: float, mstar: float, ecc: float = 0.0, inc: float = 90.0) -> float

K in m/s from the period [d], planet mass [M_Jup] and stellar mass [M_sun].

mass_from_k ​

python
mass_from_k(K: float, per: float, mstar: float, ecc: float = 0.0, inc: float = 90.0) -> float

Planet mass [M_Jup] that gives the semi-amplitude K [m/s].

class LimbDarkeningCoefficients ​

python
class LimbDarkeningCoefficients(Model)

No docstring.

FieldTypeDefault
coeffsList[float]required
namesList[str]required
lawstrrequired
bandstrrequired
rangeList[float]Field(description='band edges [nm]')
sourcestrField(description="'table' (37-band PHOENIX table), 'spectra
clampedboolField(description='the star is outside the table and the nea
claretList[float]Field(description='the same profile as four Claret coefficie
physicalboolField(description='the profile is non-negative and does not

limb_darkening ​

python
limb_darkening(teff: float, logg: float = 4.44, feh: float = 0.0, band: Union[str, Sequence[float]] = 'TESS', law: str = 'nonlinear') -> LimbDarkeningCoefficients

Limb 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 ​

python
bands() -> List[str]

Names of the bundled passbands.

class EphemerisFit ​

python
class EphemerisFit(Model)

T(E) = t0 + per E (+ dPdE E^2 / 2) by weighted least squares, uncertainties from the error bars as given.

FieldTypeDefault
orderintrequired
nintrequired
kintrequired
t0floatrequired
perfloatrequired
dPdEfloat0.0
errDict[str, float]required
covList[List[float]]required
chi2floatrequired
dofintrequired
bicfloatrequired
dPdtOptional[float]Field(None, description='days per day (quadratic fits)')
dPdtErrOptional[float]None
epochsIntArrayrequired
residualsArrayField(description='observed minus fitted, days')
modelArrayrequired
maxFracOptional[float]Field(None, description='largest distance of a time from a w
predictionsList[Dict[str, float]]Field(default_factory=list)

fit_ephemeris ​

python
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) -> EphemerisFit

Linear (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 ​

python
class Periodogram(Model)

No docstring.

FieldTypeDefault
labelstr''
freqArrayrequired
periodArrayField(description='epochs')
powerArrayrequired
fapLevelsList[Dict[str, float]]Field(default_factory=list)
peaksList[Dict[str, Any]]Field(default_factory=list)

class TimingPeriodogram ​

python
class TimingPeriodogram(Model)

Lomb-Scargle search of timing residuals: periodograms, sinusoid models, BIC comparison and a verdict in words.

FieldTypeDefault
nintrequired
orderintrequired
periodfloatField(description='days per epoch, from the baseline ephemer
epochsArrayrequired
errsArrayrequired
residualsArrayrequired
periodogramsList[Optional[Periodogram]]required
modelsList[Optional[Dict[str, Any]]]required
curvesList[Optional[Dict[str, Any]]]Field(default_factory=list)
bestintrequired
recommendedintrequired
significantboolrequired
significant2boolFalse
deltaBicList[Optional[float]]Field(default_factory=list)
verdictstr''
notesList[str]Field(default_factory=list)

periodogram ​

python
periodogram(times: Any, errors: Any, epochs: Any = None, period: Optional[float] = None, t_ref: Optional[float] = None, **options) -> TimingPeriodogram

Search 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 ​

python
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 ​

python
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 ​

python
read_light_curve(source: Union[str, Path], name: Optional[str] = None, exposure_min: float = 0.0, detrend: Optional[Dict[str, Any]] = None, **options) -> LightCurve

Read 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 ​

python
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 ​

python
catalog_location() -> str

Where lookup reads the archive snapshot: $ESL_CATALOG, else public/catalog of a repository checkout that contains this package, else the web site.

class CatalogSystem ​

python
class CatalogSystem(Model)

What the catalogue holds for a name: the chosen reference per planet with its checks, and a session to start from.

FieldTypeDefault
hoststrrequired
planetOptional[str]None
planetsList[str]Field(default_factory=list)
snapshotOptional[str]None
systemDict[str, Any]Field(description='systemFromRows(): star, planets with valu
sessionSessionField(description='values filled in, nothing free; each plan

lookup ​

python
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.

python
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 ​

python
class Software(Model)

No docstring.

FieldTypeDefault
namestr'exoplanet-science-lab'
versionOptional[str]None
commitOptional[str]None

class Star ​

python
class Star(Model)

The star. Radius in solar radii, mass in solar masses; the ...Err fields are 1-sigma uncertainties.

FieldTypeDefault
teffOptional[float]Field(None, description='Effective temperature [K]')
teffErrOptional[float]None
loggOptional[float]Field(None, description='Surface gravity, log10 cgs')
loggErrOptional[float]None
fehOptional[float]Field(None, description='Metallicity [Fe/H], dex')
fehErrOptional[float]None
rstarOptional[float]Field(None, description='Radius [R_sun]')
rstarErrOptional[float]None
mstarOptional[float]Field(None, description='Mass [M_sun]')
mstarErrOptional[float]None

class LimbDarkening ​

python
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].

FieldTypeDefault
lawstr'quadratic'
modeLiteral['coeffs', 'star']'coeffs'
bandOptional[str]'TESS (approx.)'
band_customOptional[List[float]]None
coefficientsList[float]Field(default_factory=lambda: [0.4, 0.25])

class PlanetParameters ​

python
class PlanetParameters(Model)

Parameters of one planet. Anything else (keys of models added later) is kept and passed to the core.

FieldTypeDefault
rprsOptional[float]Field(None, description='Planet radius / stellar radius')
arsOptional[float]Field(None, description='Semi-major axis / stellar radius (i
incOptional[float]Field(None, description='Inclination [deg]')
perOptional[float]Field(None, description='Period [d]')
tmidOptional[float]Field(None, description='Mid-transit time (inferior conjunct
eccOptional[float]Field(0.0, description='Eccentricity')
omegaOptional[float]Field(0.0, description='Argument of periastron [deg]')
mplanetOptional[float]Field(None, description='Mass [M_Jup]')
KOptional[float]Field(None, description='Radial-velocity semi-amplitude [m/s

class Planet ​

python
class Planet(Model)

No docstring.

FieldTypeDefault
letterstr'b'
parametersPlanetParametersField(default_factory=PlanetParameters)

class LightCurveEpoch ​

python
class LightCurveEpoch(Model)

One observation (night, orbit, instrument) inside a light curve with several.

FieldTypeDefault
namestr''
airmassboolFalse
exposure_minOptional[float]None

class Detrend ​

python
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.

FieldTypeDefault
columnsList[str]Field(default_factory=list)
polyint0
pldList[str]Field(default_factory=list)
kernelOptional[Dict[str, Any]]None

class LightCurve ​

python
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.

FieldTypeDefault
namestr'light curve'
timeArrayrequired
fluxArrayrequired
flux_errArrayrequired
airmassOptional[Array]None
exposure_minfloatField(0.0, description='Exposure time in minutes; the model
epochOptional[IntArray]None
epochsList[LightCurveEpoch]Field(default_factory=list)
columnsOptional[Dict[str, ColumnArray]]None
detrendOptional[Detrend]None

LightCurve.combine ​

python
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 ​

python
class RadialVelocity(Model)

Velocities of one instrument, m/s. Its zero point is integrated out; its jitter is the parameter jit@rv<n>.

FieldTypeDefault
namestr'RV'
timeArrayrequired
velocityArrayrequired
velocity_errArrayrequired

class TimingPoint ​

python
class TimingPoint(Model)

A mid-transit or mid-eclipse time of a planet, with its 1-sigma uncertainty in days.

FieldTypeDefault
planetOptional[str]None
kindLiteral['transit', 'eclipse']'transit'
timefloatrequired
errfloatrequired
sourceOptional[str]None

class Data ​

python
class Data(Model)

No docstring.

FieldTypeDefault
light_curveOptional[LightCurve]None
radial_velocityList[RadialVelocity]Field(default_factory=list)
timingList[TimingPoint]Field(default_factory=list)

class Prior ​

python
class Prior(Model)

uniform: a = minimum, b = maximum. normal: a = mean, b = standard deviation. For tmid the values are absolute times.

FieldTypeDefault
typestr'uniform'
aOptional[float]None
bOptional[float]None
valuesOptional[List[float]]None
weightsOptional[List[float]]None

class FreeParameter ​

python
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.

FieldTypeDefault
keystrrequired
labelOptional[str]None
unitOptional[str]None
priorPriorrequired

class Use ​

python
class Use(Model)

Which kinds of data enter the likelihood.

FieldTypeDefault
lcboolTrue
rvboolTrue
timingboolTrue

class Sampler ​

python
class Sampler(Model)

Settings of the nested sampler (src/core/nested.js).

FieldTypeDefault
nliveintField(400, description='Live points')
fracRemainfloatField(0.01, description='Stop when the live points hold less
seedint42
maxCallsfloatField(1000000.0, description='Budget of likelihood calls')
maxSecondsOptional[float]Field(None, description='Wall-clock budget')
methodOptional[str]Field(None, description="'auto' (default), 'region' or 'slic
sliceStepsOptional[int]None

class FitSettings ​

python
class FitSettings(Model)

No docstring.

FieldTypeDefault
useUseField(default_factory=Use)
freeList[FreeParameter]Field(default_factory=list)
fixedDict[str, float]Field(default_factory=dict, description='Values of non-plane
timing_noisefloatField(0.0, description='Days, added in quadrature to every t
samplerSamplerField(default_factory=Sampler)

class ParameterSummary ​

python
class ParameterSummary(Model)

No docstring.

FieldTypeDefault
keystrrequired
labelOptional[str]None
unitOptional[str]None
medianfloatrequired
plusfloatrequired
minusfloatrequired
bestOptional[float]None

ParameterSummary.err ​

python
err() -> float

Half the width of the 68% interval.

class Quantity ​

python
class Quantity(Model)

No docstring.

FieldTypeDefault
medianfloatrequired
plusfloat0.0
minusfloat0.0

class Chi2Parts ​

python
class Chi2Parts(Model)

No docstring.

FieldTypeDefault
light_curveOptional[float]0.0
radial_velocityOptional[float]0.0
timingOptional[float]0.0

class RVZeroPoint ​

python
class RVZeroPoint(Model)

No docstring.

FieldTypeDefault
namestrrequired
gammafloatrequired
jitterfloat0.0

class Samples ​

python
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.

FieldTypeDefault
keysList[str]required
valuesArrayrequired
loglArrayrequired

class Result ​

python
class Result(Model)

What a run returns: evidence, posterior summaries, derived quantities, best fit, chi-square, draws.

FieldTypeDefault
logZfloatrequired
logZerrfloatrequired
informationOptional[float]None
essOptional[float]None
ncallsintrequired
secondsOptional[float]None
convergedboolrequired
stop_reasonOptional[str]None
warningsList[str]Field(default_factory=list)
parametersList[ParameterSummary]Field(default_factory=list)
derivedDict[str, Optional[Quantity]]Field(default_factory=dict)
bestDict[str, float]Field(default_factory=dict)
chi2Optional[float]None
chi2_partsOptional[Chi2Parts]None
n_dataOptional[int]None
bicOptional[float]None
rv_zero_pointsList[RVZeroPoint]Field(default_factory=list)
samplesOptional[Samples]None

Result.table ​

python
table() -> str

The fitted and derived parameters as text.

class LightCurveModel ​

python
class LightCurveModel(Model)

No docstring.

FieldTypeDefault
namestr''
timeArrayrequired
fluxArrayrequired
flux_errArrayrequired
airmassOptional[Array]None
epochOptional[IntArray]None
epochsList[str]Field(default_factory=list)
modelArrayField(description='normalisation x airmass term x transit: w
baselineArrayField(description='normalisation x airmass term')
transitArrayField(description='the bare transit model (1 out of transit)
transitsList[Array]Field(default_factory=list, description='one bare transit mo
a1ArrayField(description='normalisation of each epoch at its condit

LightCurveModel.detrended ​

python
detrended() -> np.ndarray

Flux divided by the baseline: comparable with transit.

class RVModel ​

python
class RVModel(Model)

No docstring.

FieldTypeDefault
namestr''
timeArrayrequired
velocityArrayrequired
velocity_errArrayrequired
gammafloatField(description='zero point at its conditional maximum [m/
jitterfloat0.0
chi2float0.0
modelArrayField(description='planets + trend, without the zero point')
planetsList[Array]Field(default_factory=list)

class TimingModel ​

python
class TimingModel(Model)

No docstring.

FieldTypeDefault
planetstrrequired
kindstrrequired
timeArrayrequired
errArrayrequired
modelArrayrequired
epochIntArrayrequired

class ModelEvaluation ​

python
class ModelEvaluation(Model)

The model of a session at one point of parameter space, with every per-point piece.

FieldTypeDefault
lnLfloatrequired
chi2floatrequired
chi2_partsChi2Partsrequired
n_dataintrequired
n_linearintrequired
bicfloatrequired
keysList[str]Field(default_factory=list)
valuesDict[str, float]Field(default_factory=dict)
light_curveOptional[LightCurveModel]None
radial_velocityList[RVModel]Field(default_factory=list)
timingList[TimingModel]Field(default_factory=list)
planetsList[Dict[str, Any]]Field(default_factory=list)
limb_darkeningList[float]Field(default_factory=list)
rv_trefOptional[float]None

class Progress ​

python
class Progress(Model)

One progress report of the sampler, about eight a second.

FieldTypeDefault
itint0
ncallsint0
logZOptional[float]None
remFracOptional[float]None
effOptional[float]None
modeOptional[str]None
bestLOptional[float]None
bestList[float]Field(default_factory=list)
keysList[str]Field(default_factory=list)
elapsedfloat0.0

class Likelihood ​

python
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 ​

python
class Session(Model)

One analysis: system, data, fit set-up and (after run) result. See docs/FORMAT.md.

FieldTypeDefault
formatstrFORMAT
versionintFORMAT_VERSION
softwareOptional[Software]None
createdOptional[str]None
nameOptional[str]None
titleOptional[str]None
notesOptional[str]None
starStarField(default_factory=Star)
limb_darkeningLimbDarkeningField(default_factory=LimbDarkening)
planetsList[Planet]required
keplerboolField(False, description="a/R* follows from Kepler's law (M*
time_referencefloatField(0.0, description='Times are measured from here inside
dataDataField(default_factory=Data)
fitFitSettingsField(default_factory=FitSettings)
resultOptional[Result]None

Session.load ​

python
load(path: Union[str, Path]) -> 'Session'

Read a session file (a browser export, or one written by save).

Session.save ​

python
save(path: Union[str, Path], indent: Optional[int] = None) -> Path

Write the session (with its result, if any) as JSON; the web application opens it.

Session.key ​

python
key(name: str, planet: Optional[str] = None) -> str

The parameter key of a planet's field: key("per", "c") == "per@c"; the first planet's keys are plain.

Session.free ​

python
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 ​

python
summary() -> str

A few lines saying what the session holds.

Session.check ​

python
check() -> 'Session'

Validate with the core's own rules (validateSession and the limb darkening set-up). Raises esl.CoreError.

Session.evaluate ​

python
evaluate(at: Optional[Dict[str, float]] = None, use: Optional[Dict[str, bool]] = None) -> ModelEvaluation

The 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 ​

python
best_fit() -> ModelEvaluation

The model at the best-fit point of the stored result (at the session's values when there is none).

Session.likelihood ​

python
likelihood(use: Optional[Dict[str, bool]] = None) -> Likelihood

Open the likelihood for repeated evaluation; see :class:Likelihood.

Session.run ​

python
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 ​

python
to_script(embed_data: bool = True, session_file: str = 'session.json', figures: bool = True, prefix: Optional[str] = None) -> str

A standalone Python script that rebuilds this session line by line, runs it and draws the figures.

Session.to_markdown ​

python
to_markdown(session_file: str = 'session.json') -> str

A report: system, data, priors, sampler, results, software version, how to reproduce.

Session.to_latex ​

python
to_latex() -> str

LaTeX 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 ​

python
transit(times: Any, values: Any, precision: Any = None) -> np.ndarray

Transit model with EXOTIC's signature: values holds rprs, per, ars, ecc, inc, omega, tmid, u0..u3.

radial_velocity ​

python
radial_velocity(time: Any, params: Any, dt: float = 0.0001) -> np.ndarray

Radial 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 ​

python
radial_velocity(session: Session, fold: bool = False, figsize: Optional[Sequence[float]] = None) -> Any

Radial 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 ​

python
periodogram(pg: '_f.TimingPeriodogram', figsize: Sequence[float] = (8, 6)) -> Any

The periodograms of the timing residuals with their false-alarm levels and strongest peaks.

MIT licensed · Kyle A. Pearson