Skip to content

Configuration & API reference

All sampler options are passed through bilby.run_sampler(..., sampler="laplace", **kwargs). The reference below is generated directly from the source docstrings, so it always matches the installed version.

The Laplace sampler

Every keyword argument and its default is documented here.

Laplace

Bases: Sampler

Bilby sampler implementing the Laplace approximation.

Finds the MAP (maximum a posteriori) with scipy optimisation, computes the inverse Hessian of the log-posterior as a Gaussian proposal covariance, then draws posterior samples via a resample method (if requested).

Parameters:

Name Type Description Default
likelihood Likelihood
required
priors PriorDict or dict
required
outdir str
'outdir'
label str
'label'
resample str or None

Resampling method: 'rejection' (default), 'importance', 'inprior', 'smc', 'emcee', or None / 'None' to skip resampling and return raw Laplace-approximation samples drawn from the primary-mode Gaussian.

required
seed int or None

Random seed. Pass it as bilby's sampling_seed (or random_seed), which bilby routes here and uses to reseed its own generator. None (default) draws from OS entropy.

required
npool int or None

Number of processes for parallel likelihood evaluation (bilby standard argument; the aliases n_pool, cores, threads and queue_size are accepted too). Default None (serial). When > 1, every batch of likelihood evaluations is spread across a multiprocessing.Pool: the MAP search's population, the proposal batches in the rejection / importance / inprior loops, and the per-iteration batches aspire requests under resample='smc'. Drawing and accept/reject decisions stay in the main process, so a pooled run is numerically identical to a serial one. Only worthwhile when a single likelihood evaluation is expensive relative to inter-process overhead. Alternatively pass a pre-built pool object.

required
target_nsamples int

Target number of posterior samples (default 10000).

required
batch_nsamples int

For methods that draw samples in batches, this specifies the number of samples drawn per batch from the proposal distribution (default 1000).

required
prior_nsamples int

Number of prior draws used in the MAP search (multi-start mode, default 100).

required
max_iterations int

Proposal draws after which a batched resampling run (rejection / importance / inprior) stops if its acceptance is below 1% (default 1e6). Raises SamplerError or logs, according to fail_on_error.

required
minimization_method str

Optimization method. Default is 'differential_evolution' (global optimizer). Set to 'Nelder-Mead' to use a multi-start local optimizer instead.

required
map_restarts int

Number of independent differential_evolution runs in the MAP search; the one with the highest log-posterior is kept. Default 4. Restarts guard against the optimiser converging to a secondary mode, which would otherwise also be inherited by the mode search (see mode_search_subspace). Ignored unless minimization_method='differential_evolution' and no use_injection_for_map seed is given.

required
map_vectorized bool

If True (default), hand differential_evolution its whole population at once so the MAP search uses npool. scipy switches to deferred population updating when this is set, so the search trajectory differs from a non-vectorized run; it does not differ between a pooled and a serial run.

required
map_spike_guard bool

If True (default), test every MAP candidate -- each restart, a use_injection_for_map polish, and each local polish in the mode search -- for a needle spike: a point standing more than a nat above its neighbours map_spike_delta away along some unit-cube axis, both as measured and once the peak's own curvature is removed (by comparing offsets of delta and 2 delta). Spikes are dropped from the best-of-restarts selection, with a warning; if every candidate is one, the point beside the best is used instead. Such spikes can come from numerical artefacts in a waveform model; a sampler does not land on them, but an optimiser can. Where nothing is flagged the result is unchanged, at a cost of 4 * N evaluations per candidate.

required
map_spike_delta float

Neighbour offset of the spike test, in the unit cube (default 1e-3). It must exceed the width of the spikes to be detected. The peak's curvature is removed, so a narrow posterior does not trip the test.

required
plot_diagnostic bool

If True, produce a corner diagnostic plot after resampling.

required
cov_scaling float or dict

Multiplicative scale applied to the Laplace covariance. Each value multiplies the corresponding parameter's variance (so a value of 4 widens that parameter's marginal sigma by 2x).

  • A scalar (default 1) scales the whole covariance uniformly, i.e. cov -> cov_scaling * cov.
  • A dict mapping parameter names to scales applies a per-parameter variance scale, e.g. {'chirp_mass': 4.0, 'luminosity_distance': 9.0}. The reserved key 'others' sets the scale for every parameter not listed explicitly (default 1.0), e.g. {'chirp_mass': 4.0, 'others': 2.0} scales chirp_mass by 4 and all remaining parameters by 2. Unknown names raise an error.

Off-diagonal entries scale by the geometric mean sqrt(v_i * v_j) so correlations and positive-definiteness are preserved; a uniform dict reproduces the scalar behaviour exactly.

Applied after the eigenvalue-based covariance validation, so the requested scale is authoritative: validation repairs the estimated covariance, then this scaling is the final word on the proposal width.

required
sampling_cov pd.DataFrame, tuple, or None

Pre-computed covariance to use in place of the Laplace-estimated covariance. Must be one of:

  • A pandas DataFrame whose row index and column index are both the parameter names. Any ordering is accepted; the matrix is reordered internally.
  • A two-element tuple (parameter_names, cov) where parameter_names is a sequence of parameter-name strings and cov is an (N, N) array-like covariance in that order.
  • None (default) to compute the posterior covariance from the Hessian of the log-posterior at the MAP.

The MAP search still runs; only the covariance step is replaced. cov_scaling and the eigenvalue-based covariance validation are still applied. Not compatible with n_modes > 1.

Examples

Given an (N, N) array C and a list parameter_names::

import pandas as pd
cov_df = pd.DataFrame(C, index=parameter_names, columns=parameter_names)
result = bilby.run_sampler(..., sampler="laplace", sampling_cov=cov_df)

Or pass the tuple form directly::

result = bilby.run_sampler(
    ..., sampler="laplace", sampling_cov=(parameter_names, C)
)
required
proposal_covariance str or None

How the Laplace Gaussian is turned into the proposal every resampling method draws from (inprior's output, rejection and importance's proposal, smc's initial cloud, emcee's walkers). 'diagonal' samples each parameter independently from a truncated normal with its Laplace marginal width, ignoring the off-diagonal covariance (:class:TruncatedMVNProposal). 'full' samples the full correlated Gaussian and discards draws outside the prior box (:class:CorrelatedTruncatedMVNProposal). Correlations survive into inprior and the SMC start, but a strongly curved posterior can be covered worse, since the full ellipse is narrower across the curvature than the independent box. 'full' is incompatible with prior_parameters. The stored covariance (mode_mixture) is the same either way.

None (default) picks by what the proposal is for. inprior returns the proposal as the posterior, so it gets 'full', the Laplace approximation itself. Every other method uses the proposal as a seed that is then corrected, and there 'diagonal' is used: it is wider than the target in most directions, which is what importance weights and a tempering schedule need. inprior with prior_parameters falls back to 'diagonal', with a log message. The choice made is recorded in meta_data["proposal_covariance"].

required
fisher_method str

How to estimate the posterior precision. 'hessian' (default) finite-differences the scalar log-posterior. 'waveform' builds the genuine Fisher matrix from gravitational-wave waveform derivatives (positive semi-definite by construction). Requires a GravitationalWaveTransient-like likelihood without calibration marginalisation; ROQ and multi-banded likelihoods are refused, while relative binning is supported (the Fisher is built on the full frequency grid). It works directly in parameter space, so use_unit_cube and jacobian_cap_scale are ignored.

required
fisher_kwargs dict or None

Keyword arguments forwarded to the waveform-Fisher computation when fisher_method='waveform' (recognised keys: eps, eps_mass).

required
use_unit_cube bool

If True (default), compute the Hessian in unit-cube coordinates (via the prior CDFs) and floor the precision at the prior precision. If False, compute it directly in parameter space.

required
jacobian_cap_scale float

Unit-cube Hessian path only. When mapping the unit-cube precision back to parameter space, the Jacobian p(theta) of each parameter is capped at jacobian_cap_scale / prior_width (default 1.0, the uniform-prior value). Values below 1 widen the covariance of every parameter where the cap applies.

required
hessian_kwargs dict or None

Keyword arguments forwarded to scipy.differentiate.hessian (e.g. initial_step, step_factor, maxiter).

required
use_injection_for_map bool

If True and injection_parameters are set, use them as the starting point for the MAP search, and (with fisher_method='waveform' on a marginalised likelihood) as the reference values for the marginalised parameters. If False the injection is used nowhere: the marginalised parameters are reconstructed from the likelihood at the MAP.

required
fail_on_error bool

If True, raise SamplerError when sampling fails; otherwise just log.

required
n_modes int

Number of distinct posterior modes to search for. When n_modes > 1 the searches in mode_searches propose secondary modes, and the distinct MAP estimates are combined into a Gaussian mixture proposal. Modes are deduplicated by requiring a normalised separation of at least mode_separation_sigma in some parameter. Default is 1 (single Gaussian).

The mixture is the proposal for every resampling method: inprior draws from it, rejection and importance weight against its density, and smc and emcee seed from it. resample=None returns draws from the primary-mode Gaussian only.

n_modes <= 1 skips mode-finding entirely, including mode_symmetries. To keep only symmetry-implied modes, set n_modes >= 2 and restrict mode_searches.

required
mode_searches tuple of str

Which searches propose secondary modes when n_modes > 1. Default ('hypercube', 'symmetric'). Unknown entries raise SamplerError.

  • 'hypercube': evaluate mode_search_nsamples Latin hypercube prior draws (optionally restricted to mode_search_subspace), rank them by log-posterior, and polish the best with a local optimiser.
  • 'symmetric': seed the modes implied by mode_symmetries.
  • 'symmetric-polish': 'symmetric', plus a mirror whose log-posterior falls further than mode_symmetry_tol below its source is used as the starting point for a full-space local optimisation instead of being discarded; the polished optimum competes for a slot like any other candidate. Implies 'symmetric'. Each rescued mirror costs an optimisation and a Hessian; capped by mode_symmetry_polish_max. Useful when a declared symmetry is approximate, so the mirrored mode has moved rather than vanished.
  • 'multistart': polish mode_multistart_nstarts random prior draws with a full-space local optimiser and rank the results afterwards (see mode_multistart_nstarts).

The stochastic and symmetry searches can be enabled independently, e.g. mode_searches=['symmetric'] keeps symmetry-implied modes without the Latin hypercube search.

required
mode_search_nsamples int

Number of prior draws used by the 'hypercube' search (n_modes > 1). Higher values make mode discovery more reliable in high-dimensional spaces, at the cost of more likelihood evaluations. Uses Latin hypercube sampling for even coverage. Default is 500.

required
mode_search_subspace list of str or None

Restrict the 'hypercube' search to these parameters, holding the rest at the primary MAP (the polish step still runs in the full space, so a candidate is free to move afterwards). Use it when the degeneracy lives in known coordinates: a narrow mode occupies a tiny fraction of the full space, but the same budget covers two or three named dimensions densely. For a GW sky reflection, for example, ["zenith", "azimuth"]. Default None (search all parameters).

required
smc_prior_flow str

Which distribution aspire anneals from. Aspire's tempered target is (1 - beta) * log q + beta * (log L + log prior), so this is not just a starting point: log q is in the MCMC's target at every temperature, vanishing only at beta = 1.

"learned" (default) is aspire's own behaviour -- train a normalising flow on samples drawn from the Laplace proposal and use that. "laplace" hands aspire the Laplace mixture itself (:class:GaussianMixtureFlow), so log q is analytic and exactly the proposal constructed here, mode weights included. That mixture is built on plain multivariate_normal and so is unbounded: it puts mass outside the prior box, whereas the learned flow uses aspire's logit transform on bounded coordinates. Prefer "learned".

required
mode_symmetries list of (str, float) or None

Symmetries of the posterior, as (parameter, shift) pairs, used to seed the modes they imply instead of relying on the random multi-start search to rediscover them. For a posterior that is pi-periodic in delta_phase, pass [("delta_phase", np.pi)]. Requires n_modes > 1. Default None.

The symmetry need not be exact. Each implied mode is verified by evaluating the log-posterior at the mirrored point, and seeded when it is within mode_symmetry_tol of the mode it mirrors -- so an approximate symmetry still contributes, while one declared for a problem that does not have it is skipped.

required
mode_symmetry_tol float or None

Largest difference, in nats, between a symmetry-implied mode's log-posterior and that of the mode it mirrors for the mirror to be seeded (the test is on the absolute difference). The mirror reuses its source's covariance, so under mode_weights="laplace" an offset of d gives the lower of the pair a share exp(-d). None (default) uses -log(1e-3), the same threshold used to discard negligible mixture components. Set 0 to demand an exact symmetry.

Under 'symmetric-polish', a mirror outside the tolerance is polished (and gets its own Hessian) rather than discarded.

required
mode_symmetry_polish_max int or None

Maximum number of mirrors 'symmetric-polish' will polish in one mode search; None (default) uses 4, and <= 0 disables the rescue while leaving plain 'symmetric' seeding intact. Ignored unless 'symmetric-polish' is in mode_searches. Mirrors are proposed for the primary and every candidate the other searches found, in that order, so the primary mode's mirror is tried first.

required
mode_multistart_nstarts int or None

Number of random prior draws used by the 'multistart' entry of mode_searches; None (default) uses 10, and <= 0 skips the search. Each start is polished by a full-space local optimisation and the results are ranked only afterwards. Unlike 'hypercube', which ranks its points before polishing, this can follow a basin that is shallow at the starting point. Local optimisation from a random start may converge well short of the mode's peak in high dimensions. It only supplies secondary modes; the primary still comes from minimization_method.

required
mode_separation_sigma float

How far apart two modes must be, in units of the primary mode's per-parameter sigma (after cov_scaling), to count as distinct. A candidate closer than this to a known mode is skipped before polishing, and a polished candidate closer than this is discarded as a duplicate. Default 3.0.

Lower it when a real secondary mode sits close to the primary, since at the default such a mode is rejected as a duplicate. Raise it if one broad mode is being split into several.

required
mode_weights str

How to weight the mixture components when n_modes > 1. 'equal' (default) gives every mode the same weight. 'laplace' weights each by its Laplace local evidence -- log-posterior at the mode plus half the log-determinant of its covariance -- so a broad shallow mode can outweigh a narrow tall one. The weights set the mixture component weights, and hence how every resampling method draws: the share of inprior draws from each mode, the density rejection/importance weight against, and the share of the initial SMC cloud. Every mode keeps at least one particle in the SMC cloud regardless.

required
smc_kwargs dict or None

Configuration for SMC sampling (only used when resample='smc'). Recognised keys:

sampler : str Aspire posterior sampler: 'importance' (default), 'smc', 'minipcn_smc', or any other strategy accepted by aspire.Aspire.sample_posterior. Checkpointing and the progress callback apply only to SMC-family samplers. n_initial_samples : int Number of initial samples drawn from the Laplace proposal and passed to aspire.fit() (default 1000). n_samples : int Number of SMC particles, passed as the first positional argument to aspire.sample_posterior(). This is not merely a final output size: the particles are carried through every tempering iteration and mutation step, so this value drives the whole cost of the run (roughly, likelihood evaluations scale linearly with it). The final posterior contains this many samples. Defaults to target_nsamples if not set. (Note: aspire also exposes a distinct n_final_samples argument for a post-hoc resample to a different size; pass it through smc_kwargs if you need it.)

Any other keys are forwarded directly to aspire.Aspire.sample_posterior(), so all aspire parameters are accessible this way.

required
emcee_kwargs dict or None

Configuration for resample='emcee' (only used then). Sampling runs in batches of nsteps, re-estimating the integrated autocorrelation time after each and stopping once the chain holds target_nsamples independent samples (or at max_nsteps). Recognised keys:

nwalkers : int Number of ensemble walkers. Defaults to max(4 * ndim, 32).

An autocorrelation-time estimate is only trusted once the chain is
``autocorr_tol`` tau long, at which point the run already holds
``autocorr_tol * nwalkers`` independent samples. An ``nwalkers``
much above ``target_nsamples / autocorr_tol`` therefore oversamples
the target (a warning is logged); ``nwalkers ~= target_nsamples /
autocorr_tol`` makes the two conditions coincide. Each
half-ensemble move evaluates ``nwalkers / 2`` points, which bounds
how many workers a pool can keep busy.

nsteps : int Steps per batch, and the length of the first batch. Default 5000. Sets the granularity of the convergence check: the check costs no likelihood evaluations but is a serial barrier, while overshoot past the target is bounded by one batch. max_nsteps : int Hard cap on total steps. Defaults to nsteps, i.e. a single batch and no growth, so adaptive running is opt-in. Reaching it with too few samples logs a warning rather than failing. target_nsamples : int Independent samples to collect before stopping. Defaults to the sampler-wide target_nsamples. discard : int Number of leading steps discarded as burn-in before flattening the chain. Default nsteps // 2. Fixed across batches (burn-in does not grow with the chain). autocorr_tol : float How many autocorrelation times the post-burn-in chain must span before its tau estimate is trusted. Default 50 (emcee's own tol). The achieved chain-length/tau ratio is logged every batch, and a warning is issued when it is below emcee's own bar. backend_file : str, bool, or None Persist the full un-thinned chain to HDF5 via emcee.backends.HDFBackend. True writes {outdir}/{label}_emcee_chain.h5, a string is used as the path, and None (default) keeps it off. The returned samples are thinned, so this is the only copy of the raw chain (useful, e.g., for re-estimating tau at several discard values). The file holds nwalkers * nsteps * ndim floats, and any chain already in it is cleared at startup. thin : int, optional Fixed thinning factor. If omitted (default), the post-burn-in chain is thinned automatically by the estimated integrated autocorrelation time (the largest across parameters), so the returned samples are approximately independent.

Any other keys are forwarded to emcee.EnsembleSampler. Walkers are seeded from the Laplace proposal via the same in-prior draw used to seed SMC's initial cloud.

required
smc_progress bool

If True (default) and resample='smc' with an SMC-family sampler, register a per-iteration callback that logs a one-line progress summary at INFO (and, when smc_plot_every > 0, re-renders the diagnostic figures). Set to False to disable it. To override the callback entirely, pass your own smc_kwargs=dict(checkpoint_callback=...).

required
smc_plot_every int

How often to re-render the SMC stats and evolution-and-marginals figures during sampling, in iterations. 0 (default) means never: they are written once when sampling finishes. Set to n > 0 to watch a long run live, at a cost -- the evolution figure fits a gaussian_kde per parameter per iteration, so re-rendering it every iteration grows quadratically over a run. Ignored unless plot_diagnostic=True, which is also what gates the final render.

required
smc_prior_fraction float

Fraction of SMC's initial cloud drawn straight from the prior rather than from the Laplace mixture, in [0, 1). Default 0.0 (off).

The mixture can only seed SMC where the mode search looked. SMC begins at beta ~ 0, where the target is the prior, so a prior-drawn particle carries ordinary weight at the first iteration and can populate a mode the search missed once the tempering reaches a beta that resolves it.

Unlike prior_parameters, which substitutes named coordinates in every particle, this reserves whole particles: the correlations between coordinates within a prior-drawn particle are the prior's.

The cost is proposal quality -- a prior draw is a poor sample of a peaked posterior, so a large fraction wastes particles and slows the early tempering iterations.

required
prior_parameters list or None

List of parameter names for which initial proposal samples should be replaced with independent draws from the prior. Use this for parameters with wide posteriors consistent with their prior, where the Hessian poorly constrains the proposal covariance. Default is None (no replacement).

required
resume bool

If True (default) and a resume file exists, load it and continue from where the previous run left off. The path depends on the resampling mode: {outdir}/{label}_resume.pickle for the batched modes (rejection / importance / inprior), and {outdir}/{label}_smc_resume.h5 for SMC (written and read by aspire). Set to False to ignore any existing resume file and start fresh. Resuming a batched mode skips the MAP search and covariance estimation, and refuses to continue if the configuration has changed; resuming SMC re-runs MAP+covariance and restarts aspire from its checkpointed SMC iteration, without a configuration check.

required
checkpoint_signal int or None

Optional additional signal number (e.g. signal.SIGUSR1) that, when received, triggers a clean checkpoint and exit with exit_code. SIGTERM / SIGINT / SIGALRM are always wired by the base class.

required
check_point_delta_t float

Periodic in-loop checkpoint interval in seconds (default 600) for the batched resampling modes (rejection / importance / inprior). Set to 0 to disable periodic saves (signal-driven only). SMC uses aspire's per-iteration HDF5 checkpoint instead and is not affected by this kwarg.

required

LaplacePosteriorEstimator

The engine behind the sampler: MAP finding, posterior precision/covariance estimation, the Laplace evidence, and Gaussian sampling. Useful directly if you want the covariance without running the full sampler.

LaplacePosteriorEstimator

get_MAP_sample

get_MAP_sample(initial_sample=None)

Find the maximum a posteriori (MAP) estimate.

Maximizes log-likelihood + log-prior. With minimization_method='differential_evolution' (the sampler's default), uses that global optimizer over the full prior-bounded space. If initial_sample is provided, a single local minimization is run from that starting point.

When minimization_method is not 'differential_evolution' and no initial_sample is given, a multi-start local-optimizer strategy is used instead: n_prior_samples random prior draws are each used as starting points for a local optimizer and the best result is returned.

calculate_posterior_precision

calculate_posterior_precision(sample)

calculate_posterior_covariance

calculate_posterior_covariance(sample)

log_evidence_laplace

log_evidence_laplace(sample, covariance)

Laplace approximation to the log evidence.

Parameters:

Name Type Description Default
sample dict

MAP parameter values.

required
covariance array

Inverse of the negative Hessian of the log-posterior (the posterior covariance at the MAP).

required

Returns:

Name Type Description
log_evidence float

log Z ≈ log L(θ_MAP) + log π(θ_MAP) + (d/2) log(2π) + (1/2) log det(Σ)

sample_dataframe

sample_dataframe(sample, n=1)

log_likelihood_from_array

log_likelihood_from_array(x_array, clip_to_bounds=False)

Log-likelihood for one parameter vector or a column-stacked batch.

Accepts (N_params,) or (N_params, N_samples) and returns a scalar or (N_samples,) respectively. Points outside the prior support -- either outside a parameter's own range or violating a Constraint -- return -inf and are never handed to the likelihood.

clip_to_bounds clips into the per-parameter box. It cannot rescue a constraint violation: a constraint bounds a derived quantity, so there is no per-parameter projection onto the allowed region, and such points still return -inf.

Waveform Fisher matrix

The gravitational-wave Fisher route (fisher_method="waveform").

Fisher matrix from gravitational-wave waveform derivatives.

For a bilby GravitationalWaveTransient-like likelihood the Fisher matrix is

F_ij = sum_detectors Re (d_i h | d_j h)

where (a|b) is the noise-weighted inner product and d_i h is the derivative of the projected detector strain with respect to parameter i.

Unlike the numerical Hessian of the scalar log-likelihood, this is the genuine Fisher matrix: it is positive semi-definite by construction, it needs only first derivatives of the waveform (far better behaved under finite differencing than a scalar second derivative), and it drops the noisy, realization-dependent residual-times-curvature term that makes the observed information indefinite.

Relative-binning likelihoods are supported: they are an approximation to the full-resolution likelihood, so the full-resolution Fisher is exactly the correct proposal for them. Their waveform generator returns strain only at the coarse frequency bin edges during sampling, so _full_resolution_waveforms flips it to full-grid evaluation for the derivative computation. ROQ and multi-banded likelihoods remain unsupported (their inner product genuinely differs from the full-resolution one used here).

waveform_fisher_matrix

waveform_fisher_matrix(likelihood, parameter_names, base_parameters, eps=DEFAULT_EPS, eps_mass=DEFAULT_EPS_MASS, eps_time=DEFAULT_EPS_TIME, bounds=None)

Fisher matrix F_ij = sum_det Re (d_i h | d_j h) via central differences.

Parameters:

Name Type Description Default
likelihood GravitationalWaveTransient - like

Must expose interferometers and waveform_generator.

required
parameter_names list of str

Parameters to differentiate, defining the basis of the matrix.

required
base_parameters dict

Full parameter dictionary at the evaluation point (the MAP), including any fixed/derived parameters the waveform and projection require.

required
eps float

Relative finite-difference steps (mass parameters use eps_mass).

DEFAULT_EPS
eps_mass float

Relative finite-difference steps (mass parameters use eps_mass).

DEFAULT_EPS
eps_time float

Absolute finite-difference step, in seconds, for time parameters (geocent_time and per-detector {ifo}_time). A relative step is unusable here because the value is a GPS epoch (~1e9 s).

DEFAULT_EPS_TIME
bounds dict

{name: (lo, hi)} prior bounds. A stencil that would leave them is shifted inside (see :func:_stencil); one inside is left central, so this changes nothing away from a bound.

None

Returns:

Type Description
ndarray

The (N, N) Fisher matrix in the order of parameter_names.

is_gw_waveform_likelihood

is_gw_waveform_likelihood(likelihood)

True if the likelihood exposes interferometers and a waveform generator.

validate_waveform_likelihood

validate_waveform_likelihood(likelihood)

Raise ValueError if the likelihood is unsupported by this path.