From 6fce0aeaabccf87c1086388b38ca14574577f134 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Thu, 8 Oct 2026 22:24:52 +0530
Subject: [PATCH 01/21] time-domain likelihood

---
 bilby/gw/__init__.py                          |   2 +-
 bilby/gw/conversion.py                        |  15 +-
 bilby/gw/detector/__init__.py                 |   1 +
 bilby/gw/detector/acf.py                      | 465 ++++++++++++++++++
 bilby/gw/detector/interferometer.py           | 342 +++++++++++++
 bilby/gw/detector/networks.py                 | 122 +++++
 bilby/gw/detector/strain_data.py              | 187 +++++++
 bilby/gw/likelihood/__init__.py               |   1 +
 bilby/gw/likelihood/time_domain.py            | 425 ++++++++++++++++
 bilby/gw/source.py                            | 195 ++++++++
 bilby/gw/time_domain_utils.py                 | 298 +++++++++++
 bilby/gw/utils.py                             |  44 ++
 .../data_examples/GW150914_time_domain.py     | 148 ++++++
 ...binary_neutron_star_time_domain_example.py | 171 +++++++
 test/gw/likelihood/time_domain_test.py        | 455 +++++++++++++++++
 15 files changed, 2866 insertions(+), 5 deletions(-)
 create mode 100644 bilby/gw/detector/acf.py
 create mode 100644 bilby/gw/likelihood/time_domain.py
 create mode 100644 bilby/gw/time_domain_utils.py
 create mode 100644 examples/gw_examples/data_examples/GW150914_time_domain.py
 create mode 100644 examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
 create mode 100644 test/gw/likelihood/time_domain_test.py

diff --git a/bilby/gw/__init__.py b/bilby/gw/__init__.py
index cd09bc6f6..a996f853c 100644
--- a/bilby/gw/__init__.py
+++ b/bilby/gw/__init__.py
@@ -1,7 +1,7 @@
 from . import (conversion, cosmology, detector, eos, likelihood, prior,
                result, source, utils, waveform_generator)
 from .waveform_generator import WaveformGenerator, LALCBCWaveformGenerator
-from .likelihood import GravitationalWaveTransient
+from .likelihood import GravitationalWaveTransient, TimeDomainGravitationalWaveTransient
 from .detector import calibration
 from . import compat
 
diff --git a/bilby/gw/conversion.py b/bilby/gw/conversion.py
index b55d49379..3809bdcfc 100644
--- a/bilby/gw/conversion.py
+++ b/bilby/gw/conversion.py
@@ -2227,6 +2227,15 @@ def generate_source_frame_parameters(sample):
     return output_sample
 
 
+def _signal_polarizations_for_likelihood(likelihood, parameters):
+    """Waveform polarizations in the domain the likelihood works in: the
+    time-domain source model output for a time-domain likelihood, the
+    frequency-domain strain otherwise."""
+    if getattr(likelihood, "likelihood_domain", "frequency") == "time":
+        return likelihood.waveform_generator.time_domain_strain(parameters)
+    return likelihood.waveform_generator.frequency_domain_strain(parameters)
+
+
 def compute_snrs(sample, likelihood, npool=1, pool=None):
     """
     Compute the optimal and matched filter snrs of all posterior samples
@@ -2242,7 +2251,7 @@ def compute_snrs(sample, likelihood, npool=1, pool=None):
     """
     if likelihood is not None:
         if isinstance(sample, dict):
-            signal_polarizations = likelihood.waveform_generator.frequency_domain_strain(sample.copy())
+            signal_polarizations = _signal_polarizations_for_likelihood(likelihood, sample.copy())
             for ifo in likelihood.interferometers:
                 per_detector_snr = likelihood.calculate_snrs(signal_polarizations, ifo, parameters=sample)
                 sample['{}_matched_filter_snr'.format(ifo.name)] =\
@@ -2280,9 +2289,7 @@ def _compute_snrs(args):
     likelihood = sampling_convenience_dump.likelihood
     ii, sample = args
     sample = dict(sample).copy()
-    signal_polarizations = likelihood.waveform_generator.frequency_domain_strain(
-        sample.copy()
-    )
+    signal_polarizations = _signal_polarizations_for_likelihood(likelihood, sample.copy())
     snrs = list()
     for ifo in likelihood.interferometers:
         snrs.append(likelihood.calculate_snrs(
diff --git a/bilby/gw/detector/__init__.py b/bilby/gw/detector/__init__.py
index 51ff98279..470fee6b8 100644
--- a/bilby/gw/detector/__init__.py
+++ b/bilby/gw/detector/__init__.py
@@ -1,4 +1,5 @@
 from ..conversion import convert_to_lal_binary_black_hole_parameters
+from .acf import *
 from .calibration import *
 from .interferometer import *
 from .networks import *
diff --git a/bilby/gw/detector/acf.py b/bilby/gw/detector/acf.py
new file mode 100644
index 000000000..29a063d88
--- /dev/null
+++ b/bilby/gw/detector/acf.py
@@ -0,0 +1,465 @@
+import numpy as np
+
+from ...core.utils import logger
+from ..time_domain_utils import gohberg_semencul_vectors
+
+FILL_REFERENCES = ("max_in_band", "median_in_band", "patched_region_max")
+
+
+def _next_power_of_two(value):
+    power = 1
+    while power < value:
+        power <<= 1
+    return power
+
+
+def _is_power_of_two(value):
+    return float(value).is_integer() and int(value) > 0 and (int(value) & (int(value) - 1)) == 0
+
+
+def _check_sampling_frequency(implied, given, label):
+    if given is None or np.isclose(implied, given, rtol=1e-9, atol=0):
+        return
+    message = (
+        f"{label}: sampling frequency {given:g} Hz differs from the one implied by the "
+        f"input, {implied:g} Hz. An ACF built with {given:g} Hz would be scaled by "
+        f"{given / implied:g} and its lags would be spaced 1/{implied:g} s, not "
+        f"1/{given:g} s."
+    )
+    logger.warning(message)
+    raise ValueError(message)
+
+
+def _uniform_frequency_grid(frequency_array, psd_array, label):
+    """ Sort, check uniform spacing (snapping labels stored with limited
+    precision), extend down to 0 Hz and complete a missing Nyquist bin.
+    Bins added or without a finite positive value are NaN. """
+    frequency_array = np.asarray(frequency_array, dtype=float)
+    psd_array = np.asarray(psd_array, dtype=float)
+    if frequency_array.shape != psd_array.shape or frequency_array.ndim != 1 or len(frequency_array) < 3:
+        raise ValueError(f"{label}: frequency_array and psd_array must be 1D arrays of equal length")
+    order = np.argsort(frequency_array)
+    frequency_array, psd_array = frequency_array[order], psd_array[order]
+    psd_array = np.where(np.isfinite(psd_array) & (psd_array > 0), psd_array, np.nan)
+
+    delta_f = (frequency_array[-1] - frequency_array[0]) / (len(frequency_array) - 1)
+    uniform = frequency_array[0] + np.arange(len(frequency_array)) * delta_f
+    if np.max(np.abs(frequency_array - uniform)) > 0.1 * delta_f:
+        raise ValueError(
+            f"{label}: frequency grid is not uniform (spacing from "
+            f"{np.diff(frequency_array).min():.6g} to {np.diff(frequency_array).max():.6g} Hz); "
+            "power spectral densities are not interpolated")
+    k_first = round(frequency_array[0] / delta_f)
+    if abs(frequency_array[0] - k_first * delta_f) <= 0.1 * delta_f:
+        first = k_first * delta_f
+    else:
+        raise ValueError(
+            f"{label}: first frequency {frequency_array[0]:g} Hz is not a multiple of the "
+            f"spacing {delta_f:g} Hz, the grid cannot be extended to 0 Hz")
+    snapped = first + np.arange(len(frequency_array)) * delta_f
+    shift = np.max(np.abs(frequency_array - snapped))
+    if shift > 1e-6 * delta_f:
+        logger.info(f"{label}: frequency labels snapped to a uniform grid "
+                    f"(spacing {delta_f:g} Hz, largest shift {shift:.3g} Hz)")
+    frequency_array = snapped
+
+    if k_first > 0:
+        frequency_array = np.concatenate([np.arange(k_first) * delta_f, frequency_array])
+        psd_array = np.concatenate([np.full(k_first, np.nan), psd_array])
+    top = frequency_array[-1]
+    power = _next_power_of_two(top)
+    if not _is_power_of_two(top) and abs(power - top - delta_f) < 1e-6 * delta_f:
+        frequency_array = np.append(frequency_array, power)
+        psd_array = np.append(psd_array, np.nan)
+    return frequency_array, psd_array
+
+
+class AutoCovarianceFunction(object):
+
+    def __init__(self, acf_array=None, sampling_frequency=None, frequency_array=None,
+                 psd_array=None, minimum_frequency=None, maximum_frequency=None,
+                 fill_value=None, source=None):
+        """
+        Instantiate a new AutoCovarianceFunction object.
+
+        The autocovariance function (ACF) of stationary Gaussian noise defines the
+        noise covariance matrix of a segment of N samples, C_ij = acf[|i - j|].
+        It is used by
+        :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`, which
+        builds C^-1 for each analysis segment from the first N ACF samples.
+        Normally created with one of the :code:`from_...` methods.
+
+        Parameters
+        ==========
+        acf_array: array_like
+            ACF at lags 0, 1, ..., L - 1 (one full period).
+        sampling_frequency: float
+            Sampling frequency of the lags (Hz); must equal that of the data.
+        frequency_array, psd_array: array_like, optional
+            The patched one-sided PSD the ACF was computed from.
+        minimum_frequency, maximum_frequency: float, optional
+            Band outside which the PSD was patched.
+        fill_value: tuple, optional
+            (low, high) patch levels.
+        source: str, optional
+            Description of where the ACF comes from (stored in the meta data).
+        """
+        self.acf_array = None if acf_array is None else np.asarray(acf_array, dtype=float)
+        self.sampling_frequency = sampling_frequency
+        self.frequency_array = frequency_array
+        self.psd_array = psd_array
+        self.minimum_frequency = minimum_frequency
+        self.maximum_frequency = maximum_frequency
+        self.fill_value = fill_value
+        self.source = source
+        self._gohberg_semencul_cache = dict()
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(sampling_frequency={}, duration={}, source={})'.format(
+            self.sampling_frequency, self.duration, self.source)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, AutoCovarianceFunction)
+            and self.sampling_frequency == other.sampling_frequency
+            and np.array_equal(self.acf_array, other.acf_array)
+        )
+
+    @property
+    def delta_t(self):
+        return 1.0 / self.sampling_frequency
+
+    @property
+    def number_of_samples(self):
+        return len(self.acf_array)
+
+    @property
+    def duration(self):
+        """ Period of the ACF in seconds (1 / frequency spacing of the PSD). """
+        if self.acf_array is None:
+            return None
+        return self.number_of_samples / self.sampling_frequency
+
+    @property
+    def meta_data(self):
+        return dict(
+            sampling_frequency=self.sampling_frequency,
+            duration=self.duration,
+            minimum_frequency=self.minimum_frequency,
+            maximum_frequency=self.maximum_frequency,
+            fill_value=self.fill_value,
+            source=self.source,
+        )
+
+    # ------------------------------------------------------------------
+    # Constructors
+    # ------------------------------------------------------------------
+    @classmethod
+    def from_power_spectral_density_array(
+            cls, frequency_array, psd_array, minimum_frequency, maximum_frequency,
+            sampling_frequency=None, fill_value=None, fill_multiplier=1e4,
+            fill_reference="max_in_band", source="power spectral density array"):
+        """ ACF from a one-sided PSD given with its frequency array, used as is.
+
+        The PSD is not interpolated or resampled. Bins between 0 Hz and the first
+        frequency, and a Nyquist bin missing from a grid that stops one bin short
+        of a power of two, are added; all such bins lie outside the band and are
+        set by the patch. The sampling frequency is implied by the grid,
+        2 x (highest frequency).
+
+        Parameters
+        ==========
+        frequency_array, psd_array: array_like
+            Uniformly spaced frequencies (Hz) and PSD values (strain^2 / Hz).
+        minimum_frequency, maximum_frequency: float
+            Band; every bin below minimum_frequency or above maximum_frequency is
+            set to the patch level (hard step).
+        sampling_frequency: float, optional
+            If given, must equal the implied sampling frequency (a warning is
+            logged and a ValueError raised otherwise).
+        fill_value: float, optional
+            Absolute patch level; overrides fill_multiplier and fill_reference.
+        fill_multiplier: float
+            Patch level = fill_multiplier x reference value (default 1e4).
+        fill_reference: str
+            "max_in_band" (default), "median_in_band", or "patched_region_max"
+            (separate maxima below minimum_frequency and above maximum_frequency).
+        source: str
+            Description stored in the meta data.
+
+        Returns
+        =======
+        AutoCovarianceFunction
+        """
+        label = source
+        frequency_array, psd_array = _uniform_frequency_grid(frequency_array, psd_array, label)
+        implied_sampling_frequency = 2.0 * frequency_array[-1]
+        _check_sampling_frequency(implied_sampling_frequency, sampling_frequency, label)
+
+        finite = np.isfinite(psd_array)
+        lowest, highest = frequency_array[finite][0], frequency_array[finite][-1]
+        if minimum_frequency < lowest:
+            raise ValueError(f"{label}: minimum_frequency = {minimum_frequency:g} Hz is below the lowest "
+                             f"PSD value ({lowest:g} Hz)")
+        if maximum_frequency > highest:
+            raise ValueError(f"{label}: maximum_frequency = {maximum_frequency:g} Hz is above the highest "
+                             f"PSD value ({highest:g} Hz)")
+        if maximum_frequency >= implied_sampling_frequency / 2:
+            raise ValueError(f"{label}: maximum_frequency = {maximum_frequency:g} Hz must be below the "
+                             f"Nyquist frequency ({implied_sampling_frequency / 2:g} Hz)")
+
+        band = (frequency_array >= minimum_frequency) & (frequency_array <= maximum_frequency)
+        below = frequency_array < minimum_frequency
+        above = frequency_array > maximum_frequency
+        if not np.all(np.isfinite(psd_array[band])):
+            raise ValueError(f"{label}: PSD has missing values inside "
+                             f"[{minimum_frequency:g}, {maximum_frequency:g}] Hz")
+        if fill_value is not None:
+            fill_low = fill_high = float(fill_value)
+        elif fill_reference == "max_in_band":
+            fill_low = fill_high = fill_multiplier * np.max(psd_array[band])
+        elif fill_reference == "median_in_band":
+            fill_low = fill_high = fill_multiplier * np.median(psd_array[band])
+        elif fill_reference == "patched_region_max":
+            def region_max(mask, side):
+                values = psd_array[mask][np.isfinite(psd_array[mask])]
+                if values.size == 0:
+                    raise ValueError(f"{label}: no PSD values {side}; use another fill_reference "
+                                     "or give fill_value")
+                return np.max(values)
+            fill_low = fill_multiplier * region_max(below, f"below {minimum_frequency:g} Hz")
+            fill_high = fill_multiplier * region_max(above, f"above {maximum_frequency:g} Hz")
+        else:
+            raise ValueError(f"fill_reference must be one of {FILL_REFERENCES}, not {fill_reference!r}")
+
+        patched = psd_array.copy()
+        patched[below] = fill_low
+        patched[above] = fill_high
+        acf_array = 0.5 * np.real(np.fft.irfft(patched)) * implied_sampling_frequency
+        logger.info(
+            f"{label}: PSD grid 0 - {frequency_array[-1]:g} Hz, spacing {frequency_array[1]:g} Hz; "
+            f"sampling frequency {implied_sampling_frequency:g} Hz; ACF period "
+            f"{len(acf_array) / implied_sampling_frequency:g} s; patched outside "
+            f"[{minimum_frequency:g}, {maximum_frequency:g}] Hz with {fill_low:.3e}"
+            + ("" if fill_low == fill_high else f" / {fill_high:.3e}"))
+        return cls(acf_array=acf_array, sampling_frequency=implied_sampling_frequency,
+                   frequency_array=frequency_array, psd_array=patched,
+                   minimum_frequency=minimum_frequency, maximum_frequency=maximum_frequency,
+                   fill_value=(float(fill_low), float(fill_high)), source=source)
+
+    @classmethod
+    def from_amplitude_spectral_density_array(cls, frequency_array, asd_array, minimum_frequency,
+                                              maximum_frequency, **kwargs):
+        """ As :code:`from_power_spectral_density_array`, from an ASD. """
+        kwargs.setdefault("source", "amplitude spectral density array")
+        return cls.from_power_spectral_density_array(
+            frequency_array, np.asarray(asd_array) ** 2, minimum_frequency, maximum_frequency, **kwargs)
+
+    @classmethod
+    def from_power_spectral_density(
+            cls, power_spectral_density, minimum_frequency, maximum_frequency, analysis_duration,
+            sampling_frequency=2048, duration_factor=16, **kwargs):
+        """ ACF from a :code:`bilby.gw.detector.PowerSpectralDensity` (e.g. a
+        design-sensitivity curve), evaluated on the grid 0, df, ..., f_s / 2
+        with df = 1 / (duration_factor x analysis_duration), so that the ACF
+        period is duration_factor times the analysis segment.
+
+        Parameters
+        ==========
+        power_spectral_density: bilby.gw.detector.PowerSpectralDensity
+        minimum_frequency, maximum_frequency: float
+            Band; see :code:`from_power_spectral_density_array`.
+        analysis_duration: float
+            Longest analysis segment (s) the ACF will be used for.
+        sampling_frequency: float
+            Sampling frequency of the data (default 2048 Hz).
+        duration_factor: float
+            ACF period / analysis_duration (default 16).
+        kwargs:
+            fill_value, fill_multiplier, fill_reference (see
+            :code:`from_power_spectral_density_array`).
+        """
+        delta_f = 1.0 / (duration_factor * analysis_duration)
+        frequency_array = np.arange(int(round(sampling_frequency / 2 / delta_f)) + 1) * delta_f
+        with np.errstate(invalid="ignore", divide="ignore"):
+            psd_array = power_spectral_density.get_power_spectral_density_array(frequency_array)
+        name = power_spectral_density.psd_file or power_spectral_density.asd_file or "array"
+        kwargs.setdefault("source", f"PowerSpectralDensity({str(name).split('/')[-1]})")
+        return cls.from_power_spectral_density_array(
+            frequency_array, psd_array, minimum_frequency, maximum_frequency,
+            sampling_frequency=sampling_frequency, **kwargs)
+
+    @classmethod
+    def from_power_spectral_density_file(cls, psd_file, minimum_frequency, maximum_frequency,
+                                         analysis_duration, **kwargs):
+        """ :code:`from_power_spectral_density` for a PSD file (or a file name
+        from bilby's noise_curves directory). """
+        from .psd import PowerSpectralDensity
+        return cls.from_power_spectral_density(
+            PowerSpectralDensity.from_power_spectral_density_file(psd_file),
+            minimum_frequency, maximum_frequency, analysis_duration, **kwargs)
+
+    @classmethod
+    def from_amplitude_spectral_density_file(cls, asd_file, minimum_frequency, maximum_frequency,
+                                             analysis_duration, **kwargs):
+        """ :code:`from_power_spectral_density` for an ASD file (or a file name
+        from bilby's noise_curves directory). """
+        from .psd import PowerSpectralDensity
+        return cls.from_power_spectral_density(
+            PowerSpectralDensity.from_amplitude_spectral_density_file(asd_file),
+            minimum_frequency, maximum_frequency, analysis_duration, **kwargs)
+
+    @classmethod
+    def from_time_domain_strain(
+            cls, time_domain_strain, sampling_frequency, analysis_duration, minimum_frequency=None,
+            maximum_frequency=None, method="welch", nperseg=None, duration_factor=16, **kwargs):
+        """ ACF estimated from noise data.
+
+        Parameters
+        ==========
+        time_domain_strain: array_like
+            Noise data (e.g. off-source), uniformly sampled.
+        sampling_frequency: float
+            Sampling frequency of the data (Hz).
+        analysis_duration: float
+            Longest analysis segment (s) the ACF will be used for.
+        minimum_frequency, maximum_frequency: float
+            Band for the patch (method "welch" only).
+        method: str
+            "welch" (default): PSD by Welch's method (Hann window, 50 % overlap,
+            median average, as in the :code:`ringdown` package) with segments of
+            nperseg samples, default the next power of two >= duration_factor x
+            the analysis segment; then patched and transformed.
+            "direct": direct (biased) autocorrelation of the data; no band and no
+            patch; discouraged.
+        nperseg: int, optional
+            Welch segment length in samples.
+        duration_factor: float
+            See nperseg (default 16).
+        kwargs:
+            fill_value, fill_multiplier, fill_reference (method "welch").
+        """
+        from scipy import signal
+        time_domain_strain = np.asarray(time_domain_strain, dtype=float)
+        number_of_samples = int(round(analysis_duration * sampling_frequency))
+        if method == "direct":
+            logger.warning("ACF by direct autocorrelation of the data (no band, no patch); "
+                           "the Welch method is preferred")
+            correlation = signal.correlate(time_domain_strain, time_domain_strain)
+            acf_array = np.fft.ifftshift(correlation)[:len(time_domain_strain)] / len(time_domain_strain)
+            return cls(acf_array=acf_array, sampling_frequency=sampling_frequency,
+                       source="direct autocorrelation of time-domain strain")
+        if method != "welch":
+            raise ValueError("method must be 'welch' or 'direct'")
+        if minimum_frequency is None or maximum_frequency is None:
+            raise ValueError("method 'welch' needs minimum_frequency and maximum_frequency")
+        nperseg = nperseg or _next_power_of_two(duration_factor * number_of_samples)
+        if nperseg > len(time_domain_strain):
+            raise ValueError(
+                f"Welch segments of {nperseg} samples ({nperseg / sampling_frequency:g} s) need more "
+                f"data than given ({len(time_domain_strain) / sampling_frequency:g} s)")
+        frequency_array, psd_array = signal.welch(
+            time_domain_strain, fs=sampling_frequency, nperseg=nperseg, window="hann", average="median")
+        number_of_segments = (len(time_domain_strain) - nperseg) // (nperseg // 2) + 1
+        logger.info(f"Welch PSD from {len(time_domain_strain) / sampling_frequency:g} s of data: "
+                    f"{number_of_segments} segments of {nperseg / sampling_frequency:g} s, median average")
+        if number_of_segments < 8:
+            logger.warning(f"Only {number_of_segments} Welch segments; the PSD estimate will be noisy")
+        kwargs.setdefault("source", f"Welch PSD ({number_of_segments} x {nperseg / sampling_frequency:g} s)")
+        return cls.from_power_spectral_density_array(
+            frequency_array, psd_array, minimum_frequency, maximum_frequency,
+            sampling_frequency=sampling_frequency, **kwargs)
+
+    @classmethod
+    def from_file(cls, filename):
+        """ Read an ACF saved with :code:`save` (columns: lag (s), ACF). """
+        data = np.loadtxt(filename)
+        return cls(acf_array=data[:, 1], sampling_frequency=1.0 / (data[1, 0] - data[0, 0]),
+                   source=f"file {filename}")
+
+    # ------------------------------------------------------------------
+    # Use
+    # ------------------------------------------------------------------
+    def check_analysis_length(self, number_of_samples):
+        """ Warn if the ACF period is less than twice the analysis segment;
+        raise a ValueError if it is shorter than the segment. """
+        if number_of_samples > self.number_of_samples:
+            raise ValueError(
+                f"Analysis segment of {number_of_samples} samples "
+                f"({number_of_samples / self.sampling_frequency:g} s) is longer than the ACF "
+                f"({self.number_of_samples} samples = {self.duration:g} s)")
+        if 2 * number_of_samples > self.number_of_samples:
+            logger.warning(
+                f"ACF period is only {self.number_of_samples / number_of_samples:.2f} x the analysis "
+                f"segment ({self.number_of_samples} vs {number_of_samples} samples); less than 2x can "
+                "make the Toeplitz solve unstable.")
+
+    def get_acf_array(self, number_of_samples):
+        """ First number_of_samples lags of the ACF. """
+        self.check_analysis_length(number_of_samples)
+        return self.acf_array[:number_of_samples]
+
+    def gohberg_semencul_vectors(self, number_of_samples):
+        """ Gohberg-Semencul generators (x, y) of C^-1 for a segment of
+        number_of_samples samples (cached). """
+        if number_of_samples not in self._gohberg_semencul_cache:
+            self._gohberg_semencul_cache[number_of_samples] = gohberg_semencul_vectors(
+                self.get_acf_array(number_of_samples))
+        return self._gohberg_semencul_cache[number_of_samples]
+
+    def save(self, filename):
+        """ Save the ACF as two columns: lag (s), ACF. """
+        lags = np.arange(self.number_of_samples) / self.sampling_frequency
+        np.savetxt(filename, np.array([lags, self.acf_array]).T, header="lag(s) acf")
+
+
+def read_power_spectral_densities_from_hdf5(filename, interferometers, label=None):
+    """ Read PSDs with their frequency arrays from a GWOSC parameter-estimation
+    release file.
+
+    Supported layouts
+    =================
+    - psds/{ifo lower}_psd/frequency and .../spectrum (e.g. GW150914_data.h5)
+    - {label}/psds/{IFO}: (N, 2) array [frequency, PSD] (GWTC-2/2.1/3/4 PESummary
+      files). :code:`label` (e.g. "C01:IMRPhenomXPHM") is required if more than
+      one analysis in the file has PSDs; the error lists the available labels.
+
+    Parameters
+    ==========
+    filename: str
+    interferometers: list
+        Interferometer names, e.g. ["H1", "L1"].
+    label: str, optional
+
+    Returns
+    =======
+    dict: {ifo: (frequency_array, psd_array)}
+    """
+    import h5py
+    interferometers = [getattr(ifo, "name", ifo) for ifo in interferometers]
+    output = dict()
+    with h5py.File(filename, "r") as ff:
+        if "psds" in ff and all(f"{ifo.lower()}_psd" in ff["psds"] for ifo in interferometers):
+            for ifo in interferometers:
+                group = ff["psds"][f"{ifo.lower()}_psd"]
+                output[ifo] = (group["frequency"][:], group["spectrum"][:])
+            return output
+        labels = [key for key in ff.keys() if isinstance(ff[key], h5py.Group) and "psds" in ff[key]]
+        if not labels:
+            raise ValueError(f"{filename}: no PSDs found (neither psds/<ifo>_psd nor <label>/psds)")
+        if label is None:
+            if len(labels) > 1:
+                raise ValueError(f"{filename}: several analyses have PSDs, choose label= one of {labels}")
+            label = labels[0]
+        if label not in labels:
+            raise ValueError(f"{filename}: label {label!r} has no PSDs; available: {labels}")
+        group = ff[label]["psds"]
+        for ifo in interferometers:
+            if ifo not in group:
+                raise ValueError(f"{filename}: {label}/psds has no {ifo}; available: {list(group.keys())}")
+            array = group[ifo][:]
+            output[ifo] = (array[:, 0], array[:, 1])
+    return output
+
+
+__all__ = ["AutoCovarianceFunction", "read_power_spectral_densities_from_hdf5"]
diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index f8eda202a..abc439816 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -14,6 +14,13 @@
 from .calibration import Recalibrate
 from .geometry import InterferometerGeometry
 from .strain_data import InterferometerStrainData
+from ..time_domain_utils import (
+    align_peak_to_sample,
+    place_time_domain_signal,
+    time_domain_matched_filter_snr,
+    time_domain_noise_weighted_inner_product,
+    time_domain_optimal_snr_squared,
+)
 from ..conversion import generate_all_bbh_parameters
 
 
@@ -93,6 +100,7 @@ def __init__(self, name, power_spectral_density, minimum_frequency, maximum_freq
             maximum_frequency=maximum_frequency)
         self.meta_data = dict(name=name)
         self.reference_time = None
+        self._autocovariance_function = None
 
     def __eq__(self, other):
         if self.name == other.name and \
@@ -263,6 +271,108 @@ def set_strain_data_from_zero_noise(
             sampling_frequency=sampling_frequency, duration=duration,
             start_time=start_time)
 
+    def set_strain_data_from_power_spectral_density_time_domain(
+            self, sampling_frequency, duration, start_time=0, *, random_state=None):
+        """ Set the `Interferometer.strain_data` to a time-domain noise
+        realisation of the power spectral density, with no frequency mask and
+        no window.
+
+        See :code:`InterferometerStrainData.set_from_power_spectral_density_time_domain`.
+
+        Parameters
+        ==========
+        sampling_frequency: float
+            The sampling frequency (in Hz)
+        duration: float
+            The data duration (in s)
+        start_time: float
+            The GPS start-time of the data
+        """
+        self.strain_data.set_from_power_spectral_density_time_domain(
+            self.power_spectral_density, sampling_frequency=sampling_frequency,
+            duration=duration, start_time=start_time, random_state=random_state)
+
+    def downsample_strain_data(self, sampling_frequency, **kwargs):
+        """ Downsample the time-domain strain data, as the :code:`ringdown`
+        package's :code:`Data.condition` does.
+
+        Supply data LONGER than the segment you want to analyse: with the
+        default trim=0.25 only the middle half of the input is kept.
+        See :code:`InterferometerStrainData.downsample` for all arguments
+        (preserve_time, minimum_frequency, maximum_frequency, anti_aliasing,
+        trim, remove_mean, decimate_kwargs, start_time, duration).
+
+        Parameters
+        ==========
+        sampling_frequency: float
+            New sampling frequency (Hz); must divide the current one.
+        """
+        self.strain_data.downsample(sampling_frequency, **kwargs)
+
+    @property
+    def autocovariance_function(self):
+        """ The noise autocovariance function
+        (:code:`bilby.gw.detector.AutoCovarianceFunction`) used by
+        time-domain likelihoods, or None. """
+        return getattr(self, "_autocovariance_function", None)
+
+    @autocovariance_function.setter
+    def autocovariance_function(self, autocovariance_function):
+        from .acf import AutoCovarianceFunction
+        if autocovariance_function is not None and not isinstance(
+                autocovariance_function, AutoCovarianceFunction):
+            raise TypeError("autocovariance_function must be a bilby.gw.detector.AutoCovarianceFunction")
+        self._autocovariance_function = autocovariance_function
+        if autocovariance_function is None:
+            self.meta_data.pop("autocovariance_function", None)
+        else:
+            self.meta_data["autocovariance_function"] = autocovariance_function.meta_data
+
+    def set_autocovariance_function_from_power_spectral_density(
+            self, analysis_duration, minimum_frequency=None, maximum_frequency=None,
+            sampling_frequency=None, duration_factor=16, fill_value=None,
+            fill_multiplier=1e4, fill_reference="max_in_band"):
+        """ Set the autocovariance function from this interferometer's
+        power spectral density curve.
+
+        The curve is evaluated on the grid 0, df, ..., f_s / 2 with
+        df = 1 / (duration_factor x analysis_duration), hard-patched outside
+        [minimum_frequency, maximum_frequency] and transformed to an ACF.
+        See :code:`AutoCovarianceFunction.from_power_spectral_density`.
+
+        Parameters
+        ==========
+        analysis_duration: float
+            Longest analysis segment (s) the ACF will be used for.
+        minimum_frequency, maximum_frequency: float, optional
+            Band; default the interferometer's minimum_frequency and
+            maximum_frequency (the latter must be below the Nyquist frequency).
+        sampling_frequency: float, optional
+            Default: the sampling frequency of the strain data if set, else 2048 Hz.
+        duration_factor: float
+            ACF period / analysis_duration (default 16).
+        fill_value, fill_multiplier, fill_reference:
+            Patch level, see :code:`AutoCovarianceFunction.from_power_spectral_density_array`.
+        """
+        from .acf import AutoCovarianceFunction
+        if sampling_frequency is None:
+            sampling_frequency = self.strain_data.sampling_frequency or 2048
+        if minimum_frequency is None:
+            minimum_frequency = self.minimum_frequency
+        if maximum_frequency is None:
+            maximum_frequency = self.maximum_frequency
+            if maximum_frequency >= sampling_frequency / 2:
+                raise ValueError(
+                    f"{self.name}: maximum_frequency ({maximum_frequency:g} Hz) must be below the "
+                    f"Nyquist frequency ({sampling_frequency / 2:g} Hz) to patch the PSD; set "
+                    "interferometer.maximum_frequency or pass maximum_frequency")
+        self.autocovariance_function = AutoCovarianceFunction.from_power_spectral_density(
+            self.power_spectral_density, minimum_frequency=minimum_frequency,
+            maximum_frequency=maximum_frequency, analysis_duration=analysis_duration,
+            sampling_frequency=sampling_frequency, duration_factor=duration_factor,
+            fill_value=fill_value, fill_multiplier=fill_multiplier, fill_reference=fill_reference,
+            source=f"{self.name} power_spectral_density")
+
     def antenna_response(self, ra, dec, time, psi, mode):
         """
         Calculate the antenna response function for a given sky location
@@ -366,6 +476,228 @@ def get_detector_response(self, waveform_polarizations, parameters, frequencies=
 
         return signal_ifo
 
+    def get_time_domain_detector_response(
+            self, waveform_polarizations, parameters, start_index=0,
+            number_of_samples=None, placement="nearest"):
+        """ Get the time-domain detector response for a particular waveform,
+        on a segment of this interferometer's data samples.
+
+        The polarizations are projected with the antenna patterns and placed
+        so that the model's t=0 arrives at geocent_time + (time delay from the
+        geocenter). Samples outside the segment are dropped; nothing wraps.
+
+        Parameters
+        ==========
+        waveform_polarizations: dict
+            Output of a time-domain source model (e.g.
+            :code:`bilby.gw.source.lal_binary_black_hole_time_domain`):
+            polarizations on their own grid and 'epoch'.
+        parameters: dict
+            Parameters describing position and time of arrival of the signal.
+        start_index: int
+            First data sample of the segment (default 0).
+        number_of_samples: int, optional
+            Length of the segment (default: to the end of the data).
+        placement: str
+            "nearest" (default), "subsample" or "fd_shift"; see
+            :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
+            With "subsample", geocent_time refers to the peak of
+            h_+^2 + h_x^2 instead of the model's t=0.
+
+        Returns
+        =======
+        array_like: The detector signal on the segment's samples.
+
+        Notes
+        =====
+        If the :code:`reference_time` attribute is not :code:`None`, this is
+        used to set the time at which the antenna response is evaluated,
+        otherwise the provided :code:`parameters["geocent_time"]` is used.
+        """
+        if number_of_samples is None:
+            number_of_samples = len(self.time_array) - start_index
+        sampling_frequency = self.strain_data.sampling_frequency
+        polarizations = {mode: value for mode, value in waveform_polarizations.items()
+                         if mode != "epoch"}
+        merger_index = -waveform_polarizations["epoch"] * sampling_frequency
+        if placement == "subsample":
+            polarizations, merger_index = align_peak_to_sample(polarizations)
+
+        if self.reference_time is None:
+            antenna_time = parameters["geocent_time"]
+        else:
+            antenna_time = self.reference_time
+
+        signal_ifo = 0
+        for mode, polarization in polarizations.items():
+            det_response = self.antenna_response(
+                parameters['ra'], parameters['dec'], antenna_time, parameters['psi'], mode)
+            signal_ifo = signal_ifo + polarization * det_response
+
+        time_shift = self.time_delay_from_geocenter(
+            parameters['ra'], parameters['dec'], parameters['geocent_time'])
+        # Be careful to first subtract the two GPS times which are ~1e9 sec.
+        # And then add the time_shift which varies at ~1e-5 sec
+        dt_geocent = parameters['geocent_time'] - self.strain_data.start_time
+        arrival_index = (dt_geocent + time_shift) * sampling_frequency
+
+        return place_time_domain_signal(
+            signal_ifo, merger_index=merger_index, arrival_index=arrival_index,
+            start_index=start_index, number_of_samples=number_of_samples, placement=placement)
+
+    def _full_segment_gohberg_semencul_vectors(self):
+        if self.autocovariance_function is None:
+            raise ValueError(f"{self.name}: no autocovariance_function set")
+        return self.autocovariance_function.gohberg_semencul_vectors(len(self.time_array))
+
+    def time_domain_inner_product(self, signal):
+        """ Noise-weighted inner product d^T C^-1 h over the full data segment,
+        with C built from the interferometer's autocovariance function.
+
+        Parameters
+        ==========
+        signal: array_like
+            Time-domain signal on the data samples.
+
+        Returns
+        =======
+        float
+        """
+        x, y = self._full_segment_gohberg_semencul_vectors()
+        return time_domain_noise_weighted_inner_product(self.time_domain_strain, signal, x, y)
+
+    def time_domain_optimal_snr_squared(self, signal):
+        """ Optimal SNR squared h^T C^-1 h over the full data segment.
+
+        Parameters
+        ==========
+        signal: array_like
+            Time-domain signal on the data samples.
+
+        Returns
+        =======
+        float
+        """
+        x, y = self._full_segment_gohberg_semencul_vectors()
+        return time_domain_optimal_snr_squared(signal, x, y)
+
+    def time_domain_matched_filter_snr(self, signal):
+        """ Matched-filter SNR d^T C^-1 h / sqrt(h^T C^-1 h) over the full
+        data segment.
+
+        Parameters
+        ==========
+        signal: array_like
+            Time-domain signal on the data samples.
+
+        Returns
+        =======
+        float
+        """
+        x, y = self._full_segment_gohberg_semencul_vectors()
+        return time_domain_matched_filter_snr(signal, self.time_domain_strain, x, y)
+
+    def inject_signal_time_domain(self, parameters, injection_polarizations=None,
+                                  waveform_generator=None, raise_error=True, placement="nearest"):
+        """ Inject a time-domain signal into the time-domain strain data.
+
+        The detector signal is built with
+        :code:`get_time_domain_detector_response` (the same placement the
+        time-domain likelihood uses) and added to the stored time series: no
+        Fourier transform, frequency mask or window is applied to the data.
+        Provide the injection parameters and either the injection polarizations
+        or the waveform generator; defaults to the injection polarizations if
+        both are given.
+
+        Parameters
+        ==========
+        parameters: dict
+            Parameters of the injection.
+        injection_polarizations: dict, optional
+            Output of :code:`waveform_generator.time_domain_strain()` for a
+            time-domain source model.
+        waveform_generator: bilby.gw.waveform_generator.WaveformGenerator, optional
+            A WaveformGenerator with a time-domain source model, e.g.
+            :code:`bilby.gw.source.lal_binary_black_hole_time_domain`.
+        raise_error: bool
+            If true, raise an error if the injected signal has a duration
+            longer than the data duration. If False, a warning will be printed
+            instead.
+        placement: str
+            "nearest" (default), "subsample" or "fd_shift".
+
+        Returns
+        =======
+        injection_polarizations: dict
+        """
+        self.check_signal_duration(parameters, raise_error)
+
+        if injection_polarizations is None and waveform_generator is None:
+            raise ValueError(
+                "inject_signal_time_domain needs one of waveform_generator or "
+                "injection_polarizations.")
+        elif injection_polarizations is not None:
+            self.inject_signal_time_domain_from_waveform_polarizations(
+                parameters=parameters, injection_polarizations=injection_polarizations,
+                placement=placement)
+        elif waveform_generator is not None:
+            injection_polarizations = self.inject_signal_time_domain_from_waveform_generator(
+                parameters=parameters, waveform_generator=waveform_generator, placement=placement)
+        return injection_polarizations
+
+    def inject_signal_time_domain_from_waveform_generator(self, parameters, waveform_generator,
+                                                          placement="nearest"):
+        """ Inject a time-domain signal using a waveform generator and a set of
+        parameters. See :code:`inject_signal_time_domain`.
+
+        Returns
+        =======
+        injection_polarizations: dict
+        """
+        if waveform_generator.time_domain_source_model is None:
+            raise ValueError("inject_signal_time_domain needs a waveform generator with a "
+                             "time_domain_source_model")
+        injection_polarizations = waveform_generator.time_domain_strain(parameters)
+        self.inject_signal_time_domain_from_waveform_polarizations(
+            parameters=parameters, injection_polarizations=injection_polarizations,
+            placement=placement)
+        return injection_polarizations
+
+    def inject_signal_time_domain_from_waveform_polarizations(self, parameters, injection_polarizations,
+                                                              placement="nearest"):
+        """ Inject a time-domain signal from a dict of waveform polarizations
+        (output of a time-domain source model). See
+        :code:`inject_signal_time_domain`.
+        """
+        if not self.strain_data.time_within_data(parameters['geocent_time']):
+            logger.warning(
+                'Injecting signal outside segment, start_time={}, merger time={}.'
+                .format(self.strain_data.start_time, parameters['geocent_time']))
+        if "epoch" not in injection_polarizations:
+            raise ValueError("injection_polarizations must come from a time-domain source model "
+                             "(with an 'epoch' entry)")
+
+        signal_ifo = self.get_time_domain_detector_response(
+            injection_polarizations, parameters, placement=placement)
+        time_domain_strain = np.array(self.strain_data.time_domain_strain, dtype=float) + signal_ifo
+        self.strain_data._time_domain_strain = time_domain_strain
+        self.strain_data._frequency_domain_strain = None
+
+        self.meta_data['parameters'] = parameters
+        self.meta_data['injection_domain'] = "time"
+        self.meta_data['injection_placement'] = placement
+        logger.info("Injected time-domain signal in {}:".format(self.name))
+        if self.autocovariance_function is not None:
+            self.meta_data['optimal_SNR'] = self.time_domain_optimal_snr_squared(signal_ifo) ** 0.5
+            self.meta_data['matched_filter_SNR'] = self.time_domain_matched_filter_snr(signal_ifo)
+            logger.info("  optimal SNR = {:.2f}".format(self.meta_data['optimal_SNR']))
+            logger.info("  matched filter SNR = {:.2f}".format(self.meta_data['matched_filter_SNR']))
+        else:
+            logger.info("  no autocovariance_function set: SNRs not computed (set it before "
+                        "injecting to record them)")
+        for key in parameters:
+            logger.info('  {} = {}'.format(key, parameters[key]))
+
     def check_signal_duration(self, parameters, raise_error=True):
         """ Check that the signal with the given parameters fits in the data
 
@@ -759,6 +1091,10 @@ def save_data(self, outdir, label=None):
         Saves two files: the frequency domain strain data with three columns [f, real part of h(f),
         imaginary part of h(f)], and the amplitude spectral density with two columns [f, ASD(f)].
 
+        If an autocovariance function is set, two more files are written: the
+        time-domain strain [t, h(t)] (*_time_domain_data.dat) and the
+        autocovariance function [lag, ACF] (*_acf.dat).
+
         Note that in v1.3.0 and below, the ASD was saved in a file called *_psd.dat.
 
         Parameters
@@ -786,6 +1122,12 @@ def save_data(self, outdir, label=None):
                        [self.strain_data.frequency_array,
                         self.amplitude_spectral_density_array]).T,
                    header='f h(f)')
+        if self.autocovariance_function is not None:
+            stem = '{}/{}'.format(outdir, self.name) if label is None else '{}/{}_{}'.format(outdir, self.name, label)
+            np.savetxt('{}_time_domain_data.dat'.format(stem),
+                       np.array([self.strain_data.time_array, self.strain_data.time_domain_strain]).T,
+                       header='t h(t)')
+            self.autocovariance_function.save('{}_acf.dat'.format(stem))
 
     def plot_data(self, signal=None, outdir='.', label=None):
         import matplotlib.pyplot as plt
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index dddc2f364..1c0f34b8a 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -195,6 +195,128 @@ def inject_signal(
 
         return all_injection_polarizations
 
+    def set_strain_data_from_power_spectral_densities_time_domain(
+        self, sampling_frequency, duration, start_time=0, *, random_state=None
+    ):
+        """Set the time-domain strain data of each detector to a noise
+        realization of its power spectral density, with no frequency mask and
+        no window (for time-domain analyses).
+
+        See :py:meth:`bilby.gw.detector.InterferometerStrainData.set_from_power_spectral_density_time_domain`.
+
+        Parameters
+        ==========
+        sampling_frequency: float
+            The sampling frequency (in Hz)
+        duration: float
+            The data duration (in s)
+        start_time: float
+            The GPS start-time of the data
+        random_state: numpy.random.Generator, int, optional
+            Random number generator or seed.
+        """
+        for interferometer in self:
+            interferometer.set_strain_data_from_power_spectral_density_time_domain(
+                sampling_frequency=sampling_frequency,
+                duration=duration,
+                start_time=start_time,
+                random_state=random_state,
+            )
+
+    def set_autocovariance_functions_from_power_spectral_densities(
+        self, analysis_duration, **kwargs
+    ):
+        """Set the autocovariance function of each detector from its power
+        spectral density curve.
+
+        See :py:meth:`bilby.gw.detector.Interferometer.set_autocovariance_function_from_power_spectral_density`
+        for the keyword arguments.
+
+        Parameters
+        ==========
+        analysis_duration: float
+            Duration (in s) of the longest segment that will be analysed.
+        """
+        for interferometer in self:
+            interferometer.set_autocovariance_function_from_power_spectral_density(
+                analysis_duration=analysis_duration, **kwargs
+            )
+
+    def downsample_strain_data(self, sampling_frequency, **kwargs):
+        """Downsample the time-domain strain data of each detector.
+
+        See :py:meth:`bilby.gw.detector.InterferometerStrainData.downsample`
+        for the keyword arguments.
+
+        Parameters
+        ==========
+        sampling_frequency: float
+            The new sampling frequency (in Hz)
+        """
+        for interferometer in self:
+            interferometer.downsample_strain_data(sampling_frequency, **kwargs)
+
+    def inject_signal_time_domain(
+        self,
+        parameters=None,
+        injection_polarizations=None,
+        waveform_generator=None,
+        raise_error=True,
+        placement="nearest",
+    ):
+        """ Inject a time-domain signal into the time-domain strain data of each
+        detector (no Fourier transform, frequency mask or window).
+
+        Parameters
+        ==========
+        parameters: dict
+            Parameters of the injection.
+        injection_polarizations: dict
+           Output of `waveform_generator.time_domain_strain()` for a time-domain
+           source model. If `waveform_generator` is also given, this is used.
+        waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
+            A WaveformGenerator with a time-domain source model. The waveform is
+            generated once and projected onto every detector.
+        raise_error: bool
+            Whether to raise an error if the injected signal does not fit in
+            the segment.
+        placement: str
+            "nearest" (default), "subsample" or "fd_shift"; see
+            :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
+
+        Returns
+        =======
+        injection_polarizations: list
+            One dict per detector (the same polarizations for each).
+        """
+        if injection_polarizations is None:
+            if waveform_generator is not None:
+                if waveform_generator.time_domain_source_model is None:
+                    raise ValueError(
+                        "inject_signal_time_domain needs a waveform generator with "
+                        "a time_domain_source_model")
+                injection_polarizations = waveform_generator.time_domain_strain(
+                    parameters
+                )
+            else:
+                raise ValueError(
+                    "inject_signal_time_domain needs one of waveform_generator or "
+                    "injection_polarizations."
+                )
+
+        all_injection_polarizations = list()
+        for interferometer in self:
+            all_injection_polarizations.append(
+                interferometer.inject_signal_time_domain(
+                    parameters=parameters,
+                    injection_polarizations=injection_polarizations,
+                    raise_error=raise_error,
+                    placement=placement,
+                )
+            )
+
+        return all_injection_polarizations
+
     def save_data(self, outdir, label=None):
         """Creates a save file for the data in plain text format
 
diff --git a/bilby/gw/detector/strain_data.py b/bilby/gw/detector/strain_data.py
index 1383d9d8c..9cb036e83 100644
--- a/bilby/gw/detector/strain_data.py
+++ b/bilby/gw/detector/strain_data.py
@@ -661,6 +661,193 @@ def set_from_power_spectral_density(
         else:
             raise ValueError("Data frequencies do not match frequency_array")
 
+    def set_from_power_spectral_density_time_domain(
+            self, power_spectral_density, sampling_frequency, duration,
+            start_time=0, *, random_state=None):
+        """ Set the `time_domain_strain` to a noise realisation, with no
+        frequency mask and no window.
+
+        The noise is generated as in :code:`set_from_power_spectral_density`
+        (Gaussian, coloured by the full PSD curve; zero outside the curve's
+        frequency range) and transformed to the time domain without applying
+        the [minimum_frequency, maximum_frequency] mask. Use this for
+        time-domain analyses; :code:`set_from_power_spectral_density` stores
+        frequency-domain data whose time series is band-limited.
+
+        Note: the noise contains the full curve between its lowest frequency
+        and the Nyquist frequency, while a time-domain likelihood whose ACF is
+        patched outside [minimum_frequency, maximum_frequency] assumes the
+        patch level there.
+
+        Parameters
+        ==========
+        power_spectral_density: bilby.gw.detector.PowerSpectralDensity
+            A PowerSpectralDensity object used to generate the data
+        sampling_frequency: float
+            The sampling frequency (in Hz)
+        duration: float
+            The data duration (in s)
+        start_time: float
+            The GPS start-time of the data
+        """
+        self._times_and_frequencies = CoupledTimeAndFrequencySeries(duration=duration,
+                                                                    sampling_frequency=sampling_frequency,
+                                                                    start_time=start_time)
+        logger.debug('Setting time-domain data using noise realization from provided '
+                     'power_spectral_density')
+        frequency_domain_strain, frequency_array = \
+            power_spectral_density.get_noise_realisation(
+                self.frequency_array.shape[0], self.duration, random_state=random_state)
+        if not (self.duration == duration and frequency_array.shape == self.frequency_array.shape):
+            raise ValueError("Data frequencies do not match frequency_array")
+        time_domain_strain = utils.infft(frequency_domain_strain, self.sampling_frequency)
+        if np.shape(time_domain_strain) != np.shape(self.time_array):
+            raise ValueError("Data times do not match time array")
+        self._time_domain_strain = time_domain_strain
+        self._frequency_domain_strain = None
+
+    def downsample(
+            self, sampling_frequency, preserve_time=None, minimum_frequency=None,
+            maximum_frequency=None, anti_aliasing="fft", trim=0.25, remove_mean=True,
+            decimate_kwargs=None, start_time=None, duration=None):
+        """ Downsample the time-domain strain (the :code:`ringdown` package's
+        :code:`Data.condition`).
+
+        Supply a stretch of data LONGER than the segment you want to analyse,
+        then crop (with :code:`start_time` and :code:`duration`, or afterwards).
+        Any filtering affects samples near the ends of the series, and with the
+        default :code:`trim=0.25` only the middle half of the input is kept.
+
+        Steps
+        =====
+        1. If :code:`preserve_time` is given, move the series by fewer than
+           factor samples so that the sample nearest that time survives the
+           decimation (cyclic roll if trim > 0, as in ringdown, whose wrapped
+           samples are then trimmed; otherwise the first samples are dropped).
+        2. Optional Butterworth filter (order 4, applied forwards and backwards):
+           high-pass if only minimum_frequency is given, low-pass if only
+           maximum_frequency, band-pass if both. Off by default.
+        3. Anti-aliasing and decimation by the integer factor
+           (current / new sampling frequency):
+
+           - "fft" (default; ringdown's digital_filter=True): multiply by a Tukey
+             window with alpha=trim, FFT, set all frequencies above the new
+             Nyquist frequency to zero, inverse FFT, keep every factor-th sample.
+           - "decimate" (ringdown's digital_filter=False):
+             :code:`scipy.signal.decimate(..., zero_phase=True, **decimate_kwargs)`.
+
+        4. Remove the fraction :code:`trim` of samples from each end (this
+           removes the tapered part of the window).
+        5. Subtract the mean if :code:`remove_mean`.
+        6. Crop to [start_time, start_time + duration) if given.
+
+        Parameters
+        ==========
+        sampling_frequency: float
+            New sampling frequency; must divide the current one.
+        preserve_time: float, optional
+            GPS time whose nearest sample must be kept.
+        minimum_frequency, maximum_frequency: float, optional
+            Butterworth filter corners (Hz). None (default) for no filter.
+        anti_aliasing: str
+            "fft" (default) or "decimate".
+        trim: float
+            Fraction removed from each end after downsampling (default 0.25).
+        remove_mean: bool
+            Subtract the mean of the result (default True).
+        decimate_kwargs: dict, optional
+            Passed to scipy.signal.decimate when anti_aliasing="decimate".
+        start_time, duration: float, optional
+            Crop the result to this segment; a ValueError is raised if it does
+            not lie inside the downsampled, trimmed data.
+        """
+        from scipy import signal
+        from scipy.signal.windows import tukey
+
+        strain = np.array(self.time_domain_strain, dtype=float)
+        times = np.array(self.time_array, dtype=float)
+        original_sampling_frequency = float(self.sampling_frequency)
+        ratio = original_sampling_frequency / sampling_frequency
+        factor = int(round(ratio))
+        if factor < 1 or not np.isclose(ratio, factor, rtol=0, atol=1e-9):
+            raise ValueError(
+                f"Sampling frequency {sampling_frequency:g} Hz does not divide the current "
+                f"{original_sampling_frequency:g} Hz")
+        logger.info(
+            f"Downsampling {times[0]:.6f} - {times[-1] + 1 / original_sampling_frequency:.6f} "
+            f"from {original_sampling_frequency:g} to {sampling_frequency:g} Hz "
+            f"(anti_aliasing={anti_aliasing}, trim={trim}); supply data longer than the "
+            "analysis segment")
+
+        if preserve_time is not None:
+            if not times[0] <= preserve_time <= times[-1]:
+                raise ValueError(f"preserve_time {preserve_time} not in the data "
+                                 f"[{times[0]}, {times[-1]}]")
+            shift = int(np.argmin(abs(times - preserve_time))) % factor
+            if trim > 0:
+                times = np.roll(times, -shift)
+                strain = np.roll(strain, -shift)
+            else:
+                times = times[shift:]
+                strain = strain[shift:]
+
+        nyquist_frequency = 0.5 * original_sampling_frequency
+        if minimum_frequency or maximum_frequency:
+            if minimum_frequency and not maximum_frequency:
+                b, a = signal.butter(4, minimum_frequency / nyquist_frequency, btype='highpass')
+            elif maximum_frequency and not minimum_frequency:
+                b, a = signal.butter(4, maximum_frequency / nyquist_frequency, btype='lowpass')
+            else:
+                b, a = signal.butter(4, (minimum_frequency / nyquist_frequency,
+                                         maximum_frequency / nyquist_frequency), btype='bandpass')
+            logger.info(f"Butterworth filter (order 4, zero phase): minimum_frequency="
+                        f"{minimum_frequency}, maximum_frequency={maximum_frequency}")
+            strain = signal.filtfilt(b, a, strain)
+
+        if factor > 1:
+            if anti_aliasing == "fft":
+                window = tukey(len(strain), trim)
+                strain_fd = np.fft.rfft(strain * window)
+                frequencies = np.fft.rfftfreq(len(strain), 1 / original_sampling_frequency)
+                strain_fd[frequencies > nyquist_frequency / factor] = 0
+                strain = np.fft.irfft(strain_fd, n=len(strain))[::factor]
+            elif anti_aliasing == "decimate":
+                strain = signal.decimate(strain, factor, zero_phase=True, **(decimate_kwargs or {}))
+            else:
+                raise ValueError("anti_aliasing must be 'fft' or 'decimate'")
+            times = times[::factor]
+
+        number_of_samples = len(strain)
+        first = int(round(trim * number_of_samples))
+        last = int(round((1 - trim) * number_of_samples))
+        strain, times = strain[first:last], times[first:last]
+        if trim > 0:
+            logger.info(f"Trimmed {first / sampling_frequency:g} s from each end")
+        if remove_mean:
+            strain = strain - np.mean(strain)
+
+        if start_time is not None or duration is not None:
+            if start_time is None or duration is None:
+                raise ValueError("Give both start_time and duration to crop")
+            first = int(round((start_time - times[0]) * sampling_frequency))
+            number_of_samples = int(round(duration * sampling_frequency))
+            if first < 0 or first + number_of_samples > len(strain):
+                raise ValueError(
+                    f"Requested segment [{start_time}, {start_time + duration}) is not inside the "
+                    f"downsampled data [{times[0]}, {times[-1] + 1 / sampling_frequency}); "
+                    "supply a longer stretch of data")
+            if abs(times[first] - start_time) > 1e-6 / sampling_frequency:
+                logger.info(f"Segment starts at the nearest sample, {times[first]:.6f} "
+                            f"(requested {start_time:.6f})")
+            strain = strain[first:first + number_of_samples]
+            times = times[first:first + number_of_samples]
+
+        self.set_from_time_domain_strain(
+            strain, sampling_frequency=sampling_frequency,
+            duration=len(strain) / sampling_frequency, start_time=times[0])
+        logger.info(f"Downsampled data: {times[0]:.6f} - {times[-1] + 1 / sampling_frequency:.6f} "
+                    f"at {sampling_frequency:g} Hz")
+
     def set_from_zero_noise(self, sampling_frequency, duration, start_time=0):
         """ Set the `frequency_domain_strain` to zero noise
 
diff --git a/bilby/gw/likelihood/__init__.py b/bilby/gw/likelihood/__init__.py
index d752f77a9..78213bf1a 100644
--- a/bilby/gw/likelihood/__init__.py
+++ b/bilby/gw/likelihood/__init__.py
@@ -3,6 +3,7 @@
 from .roq import BilbyROQParamsRangeError, ROQGravitationalWaveTransient
 from .multiband import MBGravitationalWaveTransient
 from .relative import RelativeBinningGravitationalWaveTransient
+from .time_domain import TimeDomainGravitationalWaveTransient
 
 from ..source import lal_binary_black_hole
 from ..waveform_generator import WaveformGenerator
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
new file mode 100644
index 000000000..743e774f6
--- /dev/null
+++ b/bilby/gw/likelihood/time_domain.py
@@ -0,0 +1,425 @@
+import copy
+
+import numpy as np
+
+from ...core.utils import logger
+from ..time_domain_utils import PLACEMENT_METHODS, GohbergSemenculInverse
+from .base import GravitationalWaveTransient
+
+ANALYSIS_SEGMENTS = ("imr", "inspiral", "post_inspiral")
+
+
+class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
+    """ A gravitational-wave transient likelihood evaluated in the time domain.
+
+    The noise in each interferometer is a stationary Gaussian process with
+    covariance matrix :math:`C_{ij} = \\rho(|i - j|)`, where :math:`\\rho` is
+    the autocovariance function (ACF) stored on the interferometer
+    (:code:`interferometer.autocovariance_function`). For data :math:`d` and a
+    template :math:`h` on the analysed samples of each interferometer
+
+    .. math::
+
+        \\ln \\mathcal{L} = \\sum_{\\rm ifo} \\left[ d^T C^{-1} h
+        - \\frac{1}{2} h^T C^{-1} h - \\frac{1}{2} d^T C^{-1} d \\right]
+
+    :code:`log_likelihood_ratio` returns the first two terms, and
+    :code:`noise_log_likelihood` the last. :math:`C^{-1}` is applied with its
+    Gohberg-Semencul representation (computed once per interferometer), and
+    :math:`d^T C^{-1}` and :math:`d^T C^{-1} d` are computed once.
+
+    The waveform generator must have a time-domain source model that returns
+    the polarizations on its own sample grid together with an 'epoch' (the
+    time of the first sample relative to the model's merger), e.g.
+    :code:`bilby.gw.source.lal_binary_black_hole_time_domain`. The template is
+    projected onto each interferometer and placed so that the model's merger
+    arrives at :code:`geocent_time` plus the time delay from the geocenter.
+    Template samples outside the analysed samples are dropped; nothing wraps
+    around.
+
+    The analysed samples of each interferometer are either all of its data
+    ("imr"), or the samples before / after a cut time ("inspiral" /
+    "post_inspiral"). The cut time is fixed once from
+    :code:`cut_reference_parameters`:
+    :math:`t_{\\rm cut} = t_c^{\\rm ref} + \\Delta t_{\\rm ifo}(\\alpha^{\\rm ref},
+    \\delta^{\\rm ref}) + \\tau_{\\rm cut}`. The "post_inspiral" segment starts at
+    the first sample after :math:`t_{\\rm cut}` and the "inspiral" segment ends
+    just before it, so the two are complementary.
+
+    Parameters
+    ==========
+    interferometers: list, bilby.gw.detector.InterferometerList
+        A list of :code:`bilby.gw.detector.Interferometer` instances, with
+        time-domain strain data and an autocovariance function set (e.g. with
+        :code:`set_autocovariance_function_from_power_spectral_density` or by
+        assigning a :code:`bilby.gw.detector.AutoCovarianceFunction`).
+    waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
+        A WaveformGenerator with a time-domain source model.
+    distance_marginalization: bool, optional
+        If true, marginalize over distance in the likelihood. This uses a
+        look up table calculated at run time. The distance prior is set to be a
+        delta function at the minimum distance allowed in the prior being
+        marginalised over.
+    priors: dict, optional
+        If given, used in the distance marginalization.
+    distance_marginalization_lookup_table: (dict, str), optional
+        If a dict, dictionary containing the lookup_table, distance_array,
+        (distance) prior_array, and reference_distance used to construct
+        the table. If a string the name of a file containing these quantities.
+        The lookup table is stored after construction in either the provided
+        string or a default location: '.distance_marginalization_lookup_dmin{}_dmax{}_n{}.npz'
+    reference_frame: (str, bilby.gw.detector.InterferometerList, list), optional
+        Definition of the reference frame for the sky location, as in
+        :code:`GravitationalWaveTransient`.
+    time_reference: str, optional
+        Name of the reference for the sampled time parameter, as in
+        :code:`GravitationalWaveTransient`.
+    analysis_segment: str, optional
+        "imr" (default; all the data), "inspiral" or "post_inspiral".
+    segment_cut_time: float, optional
+        :math:`\\tau_{\\rm cut}` in seconds, the cut time relative to the
+        arrival of the reference merger at each interferometer. Required for
+        "inspiral" and "post_inspiral".
+    cut_reference_parameters: dict, optional
+        Dictionary with 'ra', 'dec' and 'geocent_time' (or the parameters of
+        :code:`reference_frame` / :code:`time_reference`) fixing the cut time.
+        Required for "inspiral" and "post_inspiral".
+    segment_duration: float, optional
+        Length (s) of the "inspiral" / "post_inspiral" segment, ending / starting
+        at the cut. Default: up to the start / end of the data.
+    placement: str, optional
+        How the template is placed on the data samples, see
+        :code:`bilby.gw.time_domain_utils.place_time_domain_signal`:
+        "nearest" (default), "subsample" or "fd_shift". With "subsample",
+        :code:`geocent_time` is the time of the peak of
+        :math:`h_+^2 + h_\\times^2` rather than the model's merger time (t=0).
+        Use the same placement for injection and analysis.
+    time_marginalization, phase_marginalization, calibration_marginalization: bool
+        Not implemented for this likelihood; must be False.
+
+    Returns
+    =======
+    Likelihood: `bilby.core.likelihood.Likelihood`
+        A likelihood object, able to compute the likelihood of the data given
+        some model parameters.
+    """
+
+    likelihood_domain = "time"
+
+    def __init__(
+            self, interferometers, waveform_generator, distance_marginalization=False,
+            priors=None, distance_marginalization_lookup_table=None, reference_frame="sky",
+            time_reference="geocenter", analysis_segment="imr", segment_cut_time=None,
+            cut_reference_parameters=None, segment_duration=None, placement="nearest",
+            time_marginalization=False, phase_marginalization=False,
+            calibration_marginalization=False,
+    ):
+        for name, value in dict(
+                time_marginalization=time_marginalization,
+                phase_marginalization=phase_marginalization,
+                calibration_marginalization=calibration_marginalization).items():
+            if value:
+                raise NotImplementedError(
+                    f"{name} is not implemented for {self.__class__.__name__}")
+        if getattr(waveform_generator, "time_domain_source_model", None) is None:
+            raise ValueError(
+                f"{self.__class__.__name__} needs a waveform generator with a "
+                "time_domain_source_model, e.g. bilby.gw.source.lal_binary_black_hole_time_domain")
+        if analysis_segment not in ANALYSIS_SEGMENTS:
+            raise ValueError(
+                f"analysis_segment must be one of {ANALYSIS_SEGMENTS}, not {analysis_segment!r}")
+        if placement not in PLACEMENT_METHODS:
+            raise ValueError(
+                f"placement must be one of {PLACEMENT_METHODS}, not {placement!r}")
+
+        super(TimeDomainGravitationalWaveTransient, self).__init__(
+            interferometers=interferometers,
+            waveform_generator=waveform_generator,
+            time_marginalization=False,
+            distance_marginalization=distance_marginalization,
+            phase_marginalization=False,
+            calibration_marginalization=False,
+            priors=priors,
+            distance_marginalization_lookup_table=distance_marginalization_lookup_table,
+            jitter_time=False,
+            reference_frame=reference_frame,
+            time_reference=time_reference,
+        )
+        self.analysis_segment = analysis_segment
+        self.segment_cut_time = segment_cut_time
+        self.cut_reference_parameters = cut_reference_parameters
+        self.segment_duration = segment_duration
+        self.placement = placement
+
+        self._check_interferometers()
+        self._setup_analysis_windows()
+        self._setup_noise_model()
+
+    def __repr__(self):
+        return self.__class__.__name__ + (
+            '(interferometers={},\n\twaveform_generator={},\n\tdistance_marginalization={}, '
+            'priors={}, analysis_segment={}, segment_cut_time={}, segment_duration={}, '
+            'placement={})'.format(
+                self.interferometers, self.waveform_generator, self.distance_marginalization,
+                self.priors, self.analysis_segment, self.segment_cut_time,
+                self.segment_duration, self.placement))
+
+    # ------------------------------------------------------------------
+    # Set up (done once)
+    # ------------------------------------------------------------------
+    def _check_interferometers(self):
+        for interferometer in self.interferometers:
+            if interferometer.autocovariance_function is None:
+                raise ValueError(
+                    f"{interferometer.name}: no autocovariance_function set; use e.g. "
+                    "interferometer.set_autocovariance_function_from_power_spectral_density")
+            acf_sampling_frequency = interferometer.autocovariance_function.sampling_frequency
+            if not np.isclose(acf_sampling_frequency, interferometer.sampling_frequency,
+                              rtol=1e-9, atol=0):
+                raise ValueError(
+                    f"{interferometer.name}: autocovariance function sampling frequency "
+                    f"{acf_sampling_frequency:g} Hz differs from the data's "
+                    f"{interferometer.sampling_frequency:g} Hz")
+
+    def _setup_analysis_windows(self):
+        """ Indices of the analysed samples of each interferometer. """
+        if self.analysis_segment == "imr":
+            if self.segment_duration is not None:
+                logger.warning("segment_duration is ignored for analysis_segment='imr' "
+                               "(all the data are analysed)")
+            if self.segment_cut_time is not None:
+                logger.warning("segment_cut_time is ignored for analysis_segment='imr'")
+            reference = None
+        else:
+            if self.segment_cut_time is None or self.cut_reference_parameters is None:
+                raise ValueError(
+                    f"analysis_segment={self.analysis_segment!r} needs segment_cut_time and "
+                    "cut_reference_parameters")
+            reference = self.get_sky_frame_parameters(dict(self.cut_reference_parameters))
+
+        self.analysis_windows = dict()
+        for interferometer in self.interferometers:
+            number_of_data_samples = len(interferometer.time_array)
+            sampling_frequency = interferometer.sampling_frequency
+            start_time = interferometer.strain_data.start_time
+            if reference is None:
+                start_index, end_index, cut_time = 0, number_of_data_samples, None
+            else:
+                delay = interferometer.time_delay_from_geocenter(
+                    reference["ra"], reference["dec"], reference["geocent_time"])
+                # subtract the two GPS times first
+                cut_offset = (reference["geocent_time"] - start_time) + delay + self.segment_cut_time
+                cut_time = start_time + cut_offset
+                # first sample strictly after the cut: inspiral and post_inspiral are complementary
+                cut_index = int(np.floor(cut_offset * sampling_frequency)) + 1
+                length = (None if self.segment_duration is None
+                          else int(round(self.segment_duration * sampling_frequency)))
+                if self.analysis_segment == "inspiral":
+                    end_index = cut_index
+                    start_index = 0 if length is None else cut_index - length
+                else:
+                    start_index = cut_index
+                    end_index = number_of_data_samples if length is None else cut_index + length
+                if start_index < 0 or end_index > number_of_data_samples or end_index - start_index < 2:
+                    raise ValueError(
+                        f"{interferometer.name}: {self.analysis_segment} segment "
+                        f"[{start_index}:{end_index}] is outside the data [0:{number_of_data_samples}] "
+                        f"(cut time {cut_time:.6f})")
+            self.analysis_windows[interferometer.name] = dict(
+                start_index=int(start_index),
+                end_index=int(end_index),
+                number_of_samples=int(end_index - start_index),
+                start_time=float(start_time + start_index / sampling_frequency),
+                end_time=float(start_time + (end_index - 1) / sampling_frequency),
+                cut_time=None if cut_time is None else float(cut_time),
+            )
+            window = self.analysis_windows[interferometer.name]
+            logger.info(
+                f"{interferometer.name} [{self.analysis_segment}]: samples "
+                f"[{window['start_index']}:{window['end_index']}] (N = {window['number_of_samples']}), "
+                f"GPS {window['start_time']:.6f} - {window['end_time']:.6f}"
+                + ("" if cut_time is None else f", cut at {cut_time:.6f}"))
+
+    def _setup_noise_model(self):
+        """ Gohberg-Semencul vectors, d^T C^-1 and d^T C^-1 d for each interferometer. """
+        self._inverse_covariance = dict()
+        self._data_times_inverse_covariance = dict()
+        self._data_inverse_covariance_data = dict()
+        for interferometer in self.interferometers:
+            window = self.analysis_windows[interferometer.name]
+            acf = interferometer.autocovariance_function
+            inverse_covariance = GohbergSemenculInverse(
+                *acf.gohberg_semencul_vectors(window["number_of_samples"]))
+            data = self._analysed_data(interferometer)
+            data_times_inverse_covariance = inverse_covariance(data)
+            self._inverse_covariance[interferometer.name] = inverse_covariance
+            self._data_times_inverse_covariance[interferometer.name] = data_times_inverse_covariance
+            self._data_inverse_covariance_data[interferometer.name] = float(
+                np.dot(data_times_inverse_covariance, data))
+            logger.info(
+                f"{interferometer.name}: ACF period {acf.duration:g} s = "
+                f"{acf.number_of_samples / window['number_of_samples']:.1f} x analysed segment")
+
+    def _analysed_data(self, interferometer):
+        window = self.analysis_windows[interferometer.name]
+        return np.asarray(interferometer.time_domain_strain, dtype=float)[
+            window["start_index"]:window["end_index"]]
+
+    # ------------------------------------------------------------------
+    # Likelihood
+    # ------------------------------------------------------------------
+    def _compute_full_waveform(self, signal_polarizations, interferometer, parameters):
+        """ Project the time-domain polarizations onto the interferometer and
+        place them on its analysed samples.
+
+        Parameters
+        ==========
+        signal_polarizations: dict
+            Output of the time-domain source model (polarizations and 'epoch').
+        interferometer: bilby.gw.detector.Interferometer
+        parameters: dict
+
+        Returns
+        =======
+        array_like: The template on the analysed samples.
+        """
+        window = self.analysis_windows[interferometer.name]
+        return interferometer.get_time_domain_detector_response(
+            signal_polarizations, parameters, start_index=window["start_index"],
+            number_of_samples=window["number_of_samples"], placement=self.placement)
+
+    def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array=True, parameters):
+        """ Compute :math:`d^T C^{-1} h`, :math:`h^T C^{-1} h` and the matched
+        filter SNR on the analysed samples of one interferometer.
+
+        Parameters
+        ----------
+        waveform_polarizations: dict
+            Output of the time-domain source model.
+        interferometer: bilby.gw.detector.Interferometer
+        return_array: bool
+            Unused (no time or calibration marginalization); kept for the
+            :code:`GravitationalWaveTransient` interface.
+        parameters: dict
+
+        Returns
+        -------
+        calculated_snrs: _CalculatedSNRs
+        """
+        signal = self._compute_full_waveform(
+            signal_polarizations=waveform_polarizations,
+            interferometer=interferometer,
+            parameters=parameters,
+        )
+        d_inner_h = float(np.dot(self._data_times_inverse_covariance[interferometer.name], signal))
+        optimal_snr_squared = float(np.dot(signal, self._inverse_covariance[interferometer.name](signal)))
+        if optimal_snr_squared > 0:
+            matched_filter_snr = d_inner_h / optimal_snr_squared ** 0.5
+        else:
+            matched_filter_snr = 0.0
+        return self._CalculatedSNRs(
+            d_inner_h=d_inner_h,
+            optimal_snr_squared=optimal_snr_squared,
+            complex_matched_filter_snr=matched_filter_snr,
+            d_inner_h_array=None,
+            optimal_snr_squared_array=None,
+        )
+
+    def _calculate_noise_log_likelihood(self):
+        return -0.5 * sum(self._data_inverse_covariance_data.values())
+
+    def log_likelihood_ratio(self, parameters):
+        parameters = copy.deepcopy(parameters)
+        parameters.update(self.get_sky_frame_parameters(parameters))
+        waveform_polarizations = self.waveform_generator.time_domain_strain(parameters)
+        if waveform_polarizations is None:
+            return np.nan_to_num(-np.inf)
+
+        total_snrs = self._CalculatedSNRs()
+        for interferometer in self.interferometers:
+            total_snrs += self.calculate_snrs(
+                waveform_polarizations=waveform_polarizations,
+                interferometer=interferometer,
+                parameters=parameters,
+            )
+        log_l = self.compute_log_likelihood_from_snrs(total_snrs, parameters=parameters)
+        return float(np.real(log_l))
+
+    def compute_per_detector_log_likelihood(self, parameters):
+        parameters.update(self.get_sky_frame_parameters(parameters))
+        waveform_polarizations = self.waveform_generator.time_domain_strain(parameters)
+        for interferometer in self.interferometers:
+            per_detector_snr = self.calculate_snrs(
+                waveform_polarizations=waveform_polarizations,
+                interferometer=interferometer,
+                parameters=parameters,
+            )
+            parameters['{}_log_likelihood'.format(interferometer.name)] = \
+                self.compute_log_likelihood_from_snrs(per_detector_snr, parameters=parameters)
+        return parameters.copy()
+
+    # ------------------------------------------------------------------
+    # Reconstruction of marginalized parameters
+    # ------------------------------------------------------------------
+    def generate_posterior_sample_from_marginalized_likelihood(self, parameters):
+        """ Reconstruct the distance posterior from a run which used the
+        distance-marginalized likelihood (Eq. (C29-C32) of
+        https://arxiv.org/abs/1809.02293).
+
+        Returns
+        =======
+        sample: dict
+            Returns the parameters with new samples.
+        """
+        if not self.distance_marginalization:
+            return parameters
+        signal_polarizations = copy.deepcopy(
+            self.waveform_generator.time_domain_strain(parameters))
+        parameters['luminosity_distance'] = self.generate_distance_sample_from_marginalized_likelihood(
+            signal_polarizations=signal_polarizations, parameters=parameters)
+        return parameters.copy()
+
+    def generate_distance_sample_from_marginalized_likelihood(
+            self, signal_polarizations=None, *, parameters):
+        """ Generate a single sample from the posterior distribution for
+        luminosity distance when using the distance-marginalized likelihood.
+
+        Parameters
+        ==========
+        signal_polarizations: dict, optional
+            Output of the time-domain source model. These are rescaled in place
+            after the distance sample is generated.
+
+        Returns
+        =======
+        new_distance: float
+            Sample from the distance posterior.
+        """
+        if signal_polarizations is None:
+            parameters.update(self.get_sky_frame_parameters(parameters))
+            signal_polarizations = copy.deepcopy(
+                self.waveform_generator.time_domain_strain(parameters))
+        return super(TimeDomainGravitationalWaveTransient, self).\
+            generate_distance_sample_from_marginalized_likelihood(
+                signal_polarizations=signal_polarizations, parameters=parameters)
+
+    def _rescale_signal(self, signal, new_distance):
+        for mode in signal:
+            if mode != "epoch":
+                signal[mode] *= self._ref_dist / new_distance
+
+    @property
+    def meta_data(self):
+        meta_data = super(TimeDomainGravitationalWaveTransient, self).meta_data
+        meta_data.update(
+            likelihood_domain=self.likelihood_domain,
+            analysis_segment=self.analysis_segment,
+            segment_cut_time=self.segment_cut_time,
+            cut_reference_parameters=(
+                None if self.cut_reference_parameters is None
+                else dict(self.cut_reference_parameters)),
+            segment_duration=self.segment_duration,
+            placement=self.placement,
+            analysis_windows=copy.deepcopy(self.analysis_windows),
+        )
+        return meta_data
diff --git a/bilby/gw/source.py b/bilby/gw/source.py
index 97ad51b51..e92b311cd 100644
--- a/bilby/gw/source.py
+++ b/bilby/gw/source.py
@@ -8,6 +8,7 @@
                     lalsim_SimInspiralFD,
                     lalsim_SimInspiralChooseFDWaveform,
                     lalsim_SimInspiralChooseFDWaveformSequence,
+                    lalsim_SimInspiralChooseTDWaveform,
                     safe_cast_mode_to_int)
 
 UNUSED_KWARGS_MESSAGE = """There are unused waveform kwargs.
@@ -690,6 +691,200 @@ def _base_lal_cbc_fd_waveform(
     return dict(plus=h_plus, cross=h_cross)
 
 
+def lal_binary_black_hole_time_domain(
+        time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
+        phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
+    """ A time-domain Binary Black Hole waveform model using lalsimulation
+    (SimInspiralChooseTDWaveform), for use with
+    :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`.
+
+    The polarizations are returned on the waveform's own uniform grid, with
+    sample spacing taken from :code:`time_array`, together with the epoch
+    (time of the first sample relative to the model's t=0, i.e., merger).
+    The likelihood places them in each detector's data. This output cannot be
+    used with the frequency-domain likelihoods.
+
+    Parameters
+    ==========
+    time_array: array_like
+        Times of the data (only the spacing is used).
+    mass_1: float
+        The mass of the heavier object in solar masses
+    mass_2: float
+        The mass of the lighter object in solar masses
+    luminosity_distance: float
+        The luminosity distance in megaparsec
+    a_1: float
+        Dimensionless primary spin magnitude
+    tilt_1: float
+        Primary tilt angle
+    phi_12: float
+        Azimuthal angle between the two component spins
+    a_2: float
+        Dimensionless secondary spin magnitude
+    tilt_2: float
+        Secondary tilt angle
+    phi_jl: float
+        Azimuthal angle between the total binary angular momentum and the
+        orbital angular momentum
+    theta_jn: float
+        Angle between the total binary angular momentum and the line of sight
+    phase: float
+        The phase at reference frequency or peak amplitude (depends on waveform)
+    kwargs: dict
+        Optional keyword arguments
+        Supported arguments:
+
+        - waveform_approximant (default IMRPhenomTP)
+        - reference_frequency
+        - minimum_frequency
+        - catch_waveform_errors
+        - pn_spin_order
+        - pn_tidal_order
+        - pn_phase_order
+        - pn_amplitude_order
+        - mode_array (see :code:`lal_binary_black_hole`)
+        - lal_waveform_dictionary
+        - turn_on_window: alpha of a one-sided Tukey window applied to the start
+          of the generated waveform (default 0.125; 0 for none)
+
+    Returns
+    =======
+    dict: plus and cross polarizations on the waveform's own grid, and epoch (s)
+    """
+    waveform_kwargs = dict(
+        waveform_approximant='IMRPhenomTP', reference_frequency=50.0,
+        minimum_frequency=20.0, catch_waveform_errors=False,
+        pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
+        pn_amplitude_order=0, turn_on_window=0.125)
+    waveform_kwargs.update(kwargs)
+    return _base_lal_cbc_td_waveform(
+        time_array=time_array, mass_1=mass_1, mass_2=mass_2,
+        luminosity_distance=luminosity_distance, theta_jn=theta_jn, phase=phase,
+        a_1=a_1, a_2=a_2, tilt_1=tilt_1, tilt_2=tilt_2, phi_12=phi_12,
+        phi_jl=phi_jl, **waveform_kwargs)
+
+
+def lal_binary_neutron_star_time_domain(
+        time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
+        phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, lambda_1, lambda_2,
+        **kwargs):
+    """ A time-domain Binary Neutron Star waveform model using lalsimulation
+    (SimInspiralChooseTDWaveform), for use with
+    :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`.
+
+    Parameters are those of :code:`lal_binary_black_hole_time_domain` plus
+
+    lambda_1: float
+        Dimensionless tidal deformability of mass_1
+    lambda_2: float
+        Dimensionless tidal deformability of mass_2
+
+    The default approximant is IMRPhenomPv2_NRTidal.
+
+    Returns
+    =======
+    dict: plus and cross polarizations on the waveform's own grid, and epoch (s)
+    """
+    waveform_kwargs = dict(
+        waveform_approximant='IMRPhenomPv2_NRTidal', reference_frequency=50.0,
+        minimum_frequency=20.0, catch_waveform_errors=False,
+        pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
+        pn_amplitude_order=0, turn_on_window=0.125)
+    waveform_kwargs.update(kwargs)
+    return _base_lal_cbc_td_waveform(
+        time_array=time_array, mass_1=mass_1, mass_2=mass_2,
+        luminosity_distance=luminosity_distance, theta_jn=theta_jn, phase=phase,
+        a_1=a_1, a_2=a_2, tilt_1=tilt_1, tilt_2=tilt_2, phi_12=phi_12,
+        phi_jl=phi_jl, lambda_1=lambda_1, lambda_2=lambda_2, **waveform_kwargs)
+
+
+def _base_lal_cbc_td_waveform(
+        time_array, mass_1, mass_2, luminosity_distance, theta_jn, phase,
+        a_1=0.0, a_2=0.0, tilt_1=0.0, tilt_2=0.0, phi_12=0.0, phi_jl=0.0,
+        lambda_1=0.0, lambda_2=0.0, eccentricity=0.0, **waveform_kwargs):
+    """ Generate a time-domain cbc waveform model using lalsimulation
+
+    Parameters as in :code:`_base_lal_cbc_fd_waveform`, with
+    :code:`time_array` in place of :code:`frequency_array`.
+
+    Returns
+    =======
+    dict: plus and cross polarizations on the waveform's own grid (spacing
+    time_array[1] - time_array[0]), and epoch: time of the first sample
+    relative to the model's t=0 (s). The start is smoothly turned on with a
+    one-sided Tukey window of alpha=turn_on_window, applied over the
+    waveform's full length.
+    """
+    import lalsimulation as lalsim
+    from .time_domain_utils import one_sided_tukey_window
+
+    waveform_approximant = waveform_kwargs.pop('waveform_approximant')
+    reference_frequency = waveform_kwargs.pop('reference_frequency')
+    minimum_frequency = waveform_kwargs.pop('minimum_frequency')
+    catch_waveform_errors = waveform_kwargs.pop('catch_waveform_errors')
+    turn_on_window = waveform_kwargs.pop('turn_on_window')
+    pn_amplitude_order = waveform_kwargs['pn_amplitude_order']
+
+    waveform_dictionary = set_waveform_dictionary(waveform_kwargs, lambda_1, lambda_2)
+    approximant = lalsim_GetApproximantFromString(waveform_approximant)
+
+    if pn_amplitude_order != 0:
+        start_frequency = lalsim.SimInspiralfLow2fStart(
+            float(minimum_frequency), int(pn_amplitude_order), approximant
+        )
+    else:
+        start_frequency = minimum_frequency
+
+    delta_time = float(time_array[1] - time_array[0])
+
+    luminosity_distance = luminosity_distance * 1e6 * utils.parsec
+    mass_1 = mass_1 * utils.solar_mass
+    mass_2 = mass_2 * utils.solar_mass
+
+    iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = bilby_to_lalsimulation_spins(
+        theta_jn=theta_jn, phi_jl=phi_jl, tilt_1=tilt_1, tilt_2=tilt_2,
+        phi_12=phi_12, a_1=a_1, a_2=a_2, mass_1=mass_1, mass_2=mass_2,
+        reference_frequency=reference_frequency, phase=phase)
+
+    longitude_ascending_nodes = 0.0
+    mean_per_ano = 0.0
+
+    try:
+        hplus, hcross = lalsim_SimInspiralChooseTDWaveform(
+            mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
+            spin_2z, luminosity_distance, iota, phase,
+            longitude_ascending_nodes, eccentricity, mean_per_ano, delta_time,
+            start_frequency, reference_frequency,
+            waveform_dictionary, approximant)
+    except Exception as e:
+        if not catch_waveform_errors:
+            raise
+        else:
+            EDOM = (e.args[0] == 'Internal function call failed: Input domain error')
+            if EDOM:
+                failed_parameters = dict(mass_1=mass_1, mass_2=mass_2,
+                                         spin_1=(spin_1x, spin_1y, spin_1z),
+                                         spin_2=(spin_2x, spin_2y, spin_2z),
+                                         luminosity_distance=luminosity_distance,
+                                         iota=iota, phase=phase,
+                                         eccentricity=eccentricity,
+                                         start_frequency=start_frequency)
+                logger.warning("Evaluating the waveform failed with error: {}\n".format(e) +
+                               "The parameters were {}\n".format(failed_parameters) +
+                               "Likelihood will be set to -inf.")
+                return None
+            else:
+                raise
+
+    if len(waveform_kwargs) > 0:
+        raise ValueError(UNUSED_KWARGS_MESSAGE.format(waveform_kwargs=waveform_kwargs))
+
+    window = one_sided_tukey_window(hplus.data.length, turn_on_window)
+    epoch = hplus.epoch.gpsSeconds + hplus.epoch.gpsNanoSeconds * 1e-9
+    return dict(plus=window * hplus.data.data, cross=window * hcross.data.data, epoch=epoch)
+
+
 def binary_black_hole_roq(
         frequency_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
         phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **waveform_arguments):
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
new file mode 100644
index 000000000..7b73afcd8
--- /dev/null
+++ b/bilby/gw/time_domain_utils.py
@@ -0,0 +1,298 @@
+"""
+Utilities for time-domain gravitational-wave inference.
+
+* Gohberg-Semencul representation of the inverse of a symmetric Toeplitz
+  noise covariance matrix, and the noise-weighted inner products built on it.
+* Placement of a time-domain waveform, generated on its own uniform grid, into
+  a segment of detector data.
+"""
+import numpy as np
+from scipy.fft import next_fast_len
+from scipy.linalg import solve_toeplitz
+
+PLACEMENT_METHODS = ("nearest", "subsample", "fd_shift")
+
+
+def gohberg_semencul_vectors(acf):
+    """ Gohberg-Semencul generators of the inverse of the Toeplitz matrix
+    built from :code:`acf`.
+
+    Parameters
+    ==========
+    acf: array_like
+        Autocovariance function at lags 0, 1, ..., N - 1 (first row of the
+        N x N covariance matrix).
+
+    Returns
+    =======
+    x, y: array_like
+        x is the first column of C^-1 and y is x reversed.
+    """
+    acf = np.asarray(acf, dtype=float)
+    unit_vector = np.zeros(len(acf))
+    unit_vector[0] = 1.0
+    x = solve_toeplitz((acf, acf), unit_vector)
+    return x, x[::-1]
+
+
+class GohbergSemenculInverse(object):
+    """ Inverse of a symmetric Toeplitz matrix in Gohberg-Semencul form
+
+    .. math::
+
+        C^{-1} = \\frac{1}{x_0} \\left[ L(x) L(x)^T - L(Z y) L(Z y)^T \\right]
+
+    where :math:`L(w)` is the lower-triangular Toeplitz matrix with first
+    column :math:`w` and :math:`Z` shifts down by one sample. The Fourier
+    transforms of :math:`x` and :math:`Z y` are computed once, so each product
+    :math:`C^{-1} v` costs one forward and two inverse FFTs per factor, of
+    length :code:`next_fast_len(2 N - 1)`.
+
+    Parameters
+    ==========
+    x, y: array_like
+        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
+    """
+
+    def __init__(self, x, y):
+        x = np.asarray(x, dtype=float)
+        y = np.asarray(y, dtype=float)
+        self.number_of_samples = len(x)
+        self.fft_length = next_fast_len(2 * self.number_of_samples - 1, real=True)
+        self.x0 = x[0]
+        self._x_fft = np.fft.rfft(x, n=self.fft_length)
+        self._zy_fft = np.fft.rfft(np.concatenate(([0.0], y[:-1])), n=self.fft_length)
+
+    def _lower(self, w_fft, vector_fft):
+        """ L(w) v from the transforms of w and v. """
+        return np.fft.irfft(w_fft * vector_fft, n=self.fft_length)[:self.number_of_samples]
+
+    def __call__(self, vector):
+        """ C^-1 vector. """
+        vector = np.asarray(vector, dtype=float)
+        if len(vector) != self.number_of_samples:
+            raise ValueError(
+                f"vector has {len(vector)} samples, expected {self.number_of_samples}")
+        n = self.fft_length
+        # L(w)^T v = reverse(L(w) reverse(v))
+        reversed_fft = np.fft.rfft(vector[::-1], n=n)
+        first = self._lower(self._x_fft, np.fft.rfft(
+            self._lower(self._x_fft, reversed_fft)[::-1], n=n))
+        second = self._lower(self._zy_fft, np.fft.rfft(
+            self._lower(self._zy_fft, reversed_fft)[::-1], n=n))
+        return (first - second) / self.x0
+
+
+def gohberg_semencul_product(x, y, vector):
+    """ Compute C^-1 v using the Gohberg-Semencul representation, see
+    :code:`GohbergSemenculInverse`. To apply the same C^-1 many times, build a
+    :code:`GohbergSemenculInverse` once instead.
+
+    Parameters
+    ==========
+    x, y: array_like
+        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
+    vector: array_like
+        The vector to multiply, same length as x.
+
+    Returns
+    =======
+    array_like: C^-1 vector
+    """
+    return GohbergSemenculInverse(x, y)(vector)
+
+
+def time_domain_noise_weighted_inner_product(aa, bb, x, y):
+    """ Noise-weighted inner product :math:`a^T C^{-1} b`.
+
+    Parameters
+    ==========
+    aa, bb: array_like
+        Time series of equal length.
+    x, y: array_like
+        Gohberg-Semencul vectors of C^-1 for that length.
+
+    Returns
+    =======
+    float: The noise-weighted inner product.
+    """
+    return float(np.dot(aa, gohberg_semencul_product(x, y, bb)))
+
+
+def time_domain_optimal_snr_squared(signal, x, y):
+    """ Optimal SNR squared :math:`h^T C^{-1} h` of a time-domain signal. """
+    return time_domain_noise_weighted_inner_product(signal, signal, x, y)
+
+
+def time_domain_matched_filter_snr(signal, time_domain_strain, x, y):
+    """ Matched-filter SNR :math:`d^T C^{-1} h / \\sqrt{h^T C^{-1} h}`. """
+    return (
+        time_domain_noise_weighted_inner_product(time_domain_strain, signal, x, y)
+        / time_domain_optimal_snr_squared(signal, x, y) ** 0.5
+    )
+
+
+def one_sided_tukey_window(number_of_samples, alpha):
+    """ Tukey window with only the rising (left) half applied.
+
+    Parameters
+    ==========
+    number_of_samples: int
+        Length of the window.
+    alpha: float
+        Shape parameter of :code:`scipy.signal.windows.tukey`; 0 returns ones.
+
+    Returns
+    =======
+    array_like: The window.
+    """
+    from scipy.signal.windows import tukey
+    if not alpha:
+        return np.ones(number_of_samples)
+    window = tukey(number_of_samples, alpha)
+    window[number_of_samples // 2:] = 1.0
+    return window
+
+
+def fractional_time_shift(signal, fraction, pad=32):
+    """ Delay a time series by a fraction of a sample with a Fourier phase
+    shift, on a zero-padded copy so that nothing wraps around.
+
+    Parameters
+    ==========
+    signal: array_like
+        The time series.
+    fraction: float
+        Delay in samples (positive values move the signal later).
+    pad: int
+        Number of zero samples added before and after the signal.
+
+    Returns
+    =======
+    shifted: array_like
+        The delayed series, of length len(signal) + 2 * pad (sample k
+        corresponds to sample k - pad of the input).
+    """
+    signal = np.asarray(signal, dtype=float)
+    length = next_fast_len(len(signal) + 2 * pad)
+    buffer = np.zeros(length)
+    buffer[pad:pad + len(signal)] = signal
+    frequencies = np.fft.rfftfreq(length)
+    shifted = np.fft.irfft(
+        np.fft.rfft(buffer) * np.exp(-2j * np.pi * frequencies * fraction), n=length)
+    return shifted[:len(signal) + 2 * pad]
+
+
+def quadratic_peak_index(plus, cross):
+    """ Fractional index of the peak of :math:`\\sqrt{h_+^2 + h_\\times^2}`,
+    from a quadratic fit to the three samples around the maximum (as in the
+    :code:`ringdown` package).
+
+    Parameters
+    ==========
+    plus, cross: array_like
+        The two polarizations on a uniform grid.
+
+    Returns
+    =======
+    float: Peak position in (fractional) samples.
+    """
+    amplitude = np.sqrt(np.asarray(plus) ** 2 + np.asarray(cross) ** 2)
+    ib = int(np.argmax(amplitude))
+    ia = (ib - 1) % len(amplitude)
+    ic = (ib + 1) % len(amplitude)
+    a, b, c = amplitude[ia], amplitude[ib], amplitude[ic]
+    denominator = a - 2 * b + c
+    if denominator == 0:
+        return float(ib)
+    return ib + (3 * a - 4 * b + c) / (2 * denominator) - 1
+
+
+def align_peak_to_sample(waveform_polarizations, pad=32):
+    """ Shift all polarizations by the same sub-sample amount so that the
+    (quadratically interpolated) peak of :math:`h_+^2 + h_\\times^2` falls
+    exactly on a sample (:code:`ringdown`'s :code:`subsample_placement`).
+
+    Parameters
+    ==========
+    waveform_polarizations: dict
+        Polarizations on their own uniform grid (no 'epoch' key).
+    pad: int
+        Zero padding added on each side before shifting.
+
+    Returns
+    =======
+    aligned: dict
+        The shifted polarizations (each padded by :code:`pad` on both sides).
+    peak_index: int
+        Index of the peak in the aligned arrays.
+    """
+    peak = quadratic_peak_index(
+        waveform_polarizations["plus"], waveform_polarizations["cross"])
+    fraction = round(peak) - peak
+    aligned = {mode: fractional_time_shift(value, fraction, pad=pad)
+               for mode, value in waveform_polarizations.items()}
+    return aligned, int(round(peak)) + pad
+
+
+def _copy_into_segment(signal, offset, start_index, number_of_samples):
+    """ Put signal sample k at data index offset + k and return data indices
+    [start_index, start_index + number_of_samples); zero elsewhere. """
+    segment = np.zeros(number_of_samples)
+    first = max(0, start_index - offset)
+    last = min(len(signal), start_index + number_of_samples - offset)
+    if last > first:
+        segment[offset + first - start_index:offset + last - start_index] = signal[first:last]
+    return segment
+
+
+def place_time_domain_signal(signal, merger_index, arrival_index, start_index,
+                             number_of_samples, placement="nearest"):
+    """ Place a time-domain signal, generated on its own grid with the data's
+    sample spacing, into a segment of data.
+
+    Waveform sample k has time (k - merger_index) * dt relative to the
+    model's merger (its t=0). In data-index units the merger arrives at
+    :code:`arrival_index` (fractional). Samples falling outside the segment are
+    dropped; segment samples the signal does not reach are zero. Nothing wraps.
+
+    Parameters
+    ==========
+    signal: array_like
+        Projected (detector) signal on its own grid.
+    merger_index: float
+        Index of the model's t=0 in :code:`signal` (-epoch * sampling_frequency).
+    arrival_index: float
+        Arrival time of t=0 at the detector, in samples from the first data sample.
+    start_index: int
+        First data index of the analysis segment.
+    number_of_samples: int
+        Length of the analysis segment.
+    placement: str
+        - "nearest": t=0 of the signal is put on the data sample nearest to the
+          arrival time; both indices are rounded separately, as in
+          LALInference and the :code:`ringdown` package (default).
+        - "subsample": as "nearest", with :code:`merger_index` the integer peak
+          index from :code:`align_peak_to_sample`. The arrival time then refers
+          to the peak of :math:`h_+^2 + h_\\times^2`, not to the model's t=0
+          (the :code:`ringdown` package's :code:`manual_epoch` convention).
+        - "fd_shift": exact delay; whole samples by index, the remaining
+          fraction with a Fourier phase shift on a zero-padded copy, applied
+          before cropping to the segment.
+
+    Returns
+    =======
+    array_like: The signal on the segment's samples.
+    """
+    if placement in ("nearest", "subsample"):
+        offset = round(arrival_index) - round(merger_index)
+        return _copy_into_segment(signal, offset, start_index, number_of_samples)
+    elif placement == "fd_shift":
+        position = arrival_index - merger_index
+        offset = int(np.floor(position + 0.5))
+        fraction = position - offset
+        pad = 32
+        shifted = fractional_time_shift(signal, fraction, pad=pad)
+        return _copy_into_segment(shifted, offset - pad, start_index, number_of_samples)
+    else:
+        raise ValueError(f"placement must be one of {PLACEMENT_METHODS}, not {placement!r}")
diff --git a/bilby/gw/utils.py b/bilby/gw/utils.py
index 1a55de975..e8ef14abe 100644
--- a/bilby/gw/utils.py
+++ b/bilby/gw/utils.py
@@ -684,6 +684,50 @@ def lalsim_SimInspiralChooseFDWaveform(
     return SimInspiralChooseFDWaveform(*args, waveform_dictionary, approximant)
 
 
+def lalsim_SimInspiralChooseTDWaveform(
+        mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y,
+        spin_2z, luminosity_distance, iota, phase,
+        longitude_ascending_nodes, eccentricity, mean_per_ano, delta_time,
+        minimum_frequency, reference_frequency, waveform_dictionary,
+        approximant):
+    """
+    Safely call lalsimulation.SimInspiralChooseTDWaveform
+
+    Parameters
+    ==========
+    mass_1: float, int
+    mass_2: float, int
+    spin_1x: float, int
+    spin_1y: float, int
+    spin_1z: float, int
+    spin_2x: float, int
+    spin_2y: float, int
+    spin_2z: float, int
+    luminosity_distance: float, int
+    iota: float, int
+    phase: float, int
+    longitude_ascending_nodes: float, int
+    eccentricity: float, int
+    mean_per_ano: float, int
+    delta_time: float, int
+    minimum_frequency: float, int
+    reference_frequency: float, int
+    waveform_dictionary: None, lal.Dict
+    approximant: int, str
+    """
+    from lalsimulation import SimInspiralChooseTDWaveform
+
+    args = convert_args_list_to_float(
+        mass_1, mass_2, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z,
+        luminosity_distance, iota, phase, longitude_ascending_nodes,
+        eccentricity, mean_per_ano, delta_time, minimum_frequency,
+        reference_frequency)
+
+    approximant = _get_lalsim_approximant(approximant)
+
+    return SimInspiralChooseTDWaveform(*args, waveform_dictionary, approximant)
+
+
 @lru_cache(maxsize=10)
 def _get_lalsim_approximant(approximant):
     if isinstance(approximant, int):
diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
new file mode 100644
index 000000000..d62d72384
--- /dev/null
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+"""
+Tutorial to demonstrate running time-domain parameter estimation on GW150914
+
+This is the GW150914.py analysis done in the time domain:
+
+- the strain is downloaded as a time series, longer than the analysis segment,
+  stored with no window, then downsampled to 2048 Hz (anti-aliasing as in the
+  ringdown package) and cropped to the 4 s analysis segment;
+- the noise model of each detector is an autocovariance function (ACF)
+  computed from a PSD read with its frequency array from an HDF5 file;
+- the likelihood is bilby.gw.likelihood.TimeDomainGravitationalWaveTransient,
+  with a time-domain waveform model.
+
+Distance marginalization is used. Time and phase marginalization are not
+available for the time-domain likelihood.
+
+This example estimates all 15 parameters of the binary black hole system using
+commonly used prior distributions. This will take several hours to run. The
+data is obtained using gwpy, see [1] for information on how to access data on
+the LIGO Data Grid instead.
+
+[1] https://gwpy.github.io/docs/stable/timeseries/remote-access.html
+"""
+import bilby
+from gwpy.timeseries import TimeSeries
+
+logger = bilby.core.utils.logger
+outdir = "outdir"
+label = "GW150914_time_domain"
+
+# Note you can get trigger times using the gwosc package, e.g.:
+# > from gwosc import datasets
+# > datasets.event_gps("GW150914")
+trigger_time = 1126259462.4
+detectors = ["H1", "L1"]
+maximum_frequency = 512
+minimum_frequency = 20
+sampling_frequency = 2048  # The PSD file below goes up to 1024 Hz
+duration = 4  # Analysis segment duration
+post_trigger_duration = 2  # Time between trigger time and end of segment
+end_time = trigger_time + post_trigger_duration
+start_time = end_time - duration
+
+# Data downloaded on each side of the analysis segment. With the default
+# trim=0.25 the downsampling keeps the middle half of the downloaded data, so
+# this must be larger than duration / 2.
+padding = 8
+
+# File with the PSDs and their frequency arrays (psds/h1_psd/frequency,
+# psds/h1_psd/spectrum, ...). GWTC PESummary release files are also read, with
+# label= the analysis, e.g. "C01:IMRPhenomXPHM".
+psd_file = "GW150914_data.h5"
+psds = bilby.gw.detector.read_power_spectral_densities_from_hdf5(psd_file, detectors)
+
+# We now use gwpy to obtain the analysis data and create the ifo_list
+ifo_list = bilby.gw.detector.InterferometerList([])
+for det in detectors:
+    logger.info("Downloading analysis data for ifo {}".format(det))
+    ifo = bilby.gw.detector.get_empty_interferometer(det)
+    data = TimeSeries.fetch_open_data(det, start_time - padding, end_time + padding)
+    ifo.strain_data.set_from_gwpy_timeseries(data)
+    ifo.downsample_strain_data(
+        sampling_frequency, start_time=start_time, duration=duration
+    )
+
+    frequency_array, psd_array = psds[det]
+    ifo.power_spectral_density = bilby.gw.detector.PowerSpectralDensity(
+        frequency_array=frequency_array, psd_array=psd_array
+    )
+    ifo.maximum_frequency = maximum_frequency
+    ifo.minimum_frequency = minimum_frequency
+
+    # The PSD is not interpolated: the ACF has period 1 / (frequency spacing)
+    # (8 s here, twice the analysis segment). Outside [minimum_frequency,
+    # maximum_frequency] the PSD is set to a large value.
+    ifo.autocovariance_function = (
+        bilby.gw.detector.AutoCovarianceFunction.from_power_spectral_density_array(
+            frequency_array,
+            psd_array,
+            minimum_frequency=minimum_frequency,
+            maximum_frequency=maximum_frequency,
+            sampling_frequency=sampling_frequency,
+            source=f"{psd_file} {det}",
+        )
+    )
+    ifo_list.append(ifo)
+
+logger.info("Saving data plots to {}".format(outdir))
+bilby.core.utils.check_directory_exists_and_if_not_mkdir(outdir)
+ifo_list.plot_data(outdir=outdir, label=label)
+
+# We now define the prior.
+# We have defined our prior distribution in a local file, GW150914.prior
+# The prior is printed to the terminal at run-time.
+# You can overwrite this using the syntax below in the file,
+# or choose a fixed value by just providing a float value as the prior.
+priors = bilby.gw.prior.BBHPriorDict(filename="GW150914.prior")
+
+# Add the geocent time prior
+priors["geocent_time"] = bilby.core.prior.Uniform(
+    trigger_time - 0.1, trigger_time + 0.1, name="geocent_time"
+)
+
+# In this step we define a `waveform_generator`. This is the object which
+# creates the time-domain polarizations. In this instance, we are using the
+# `lal_binary_black_hole_time_domain` source model. We also pass other
+# parameters: the waveform approximant, reference and minimum frequency, and a
+# parameter conversion which allows us to sample in chirp mass and ratio
+# rather than component mass
+waveform_generator = bilby.gw.WaveformGenerator(
+    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_time_domain,
+    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+    waveform_arguments={
+        "waveform_approximant": "IMRPhenomPv2",
+        "reference_frequency": 50,
+        "minimum_frequency": minimum_frequency,
+    },
+)
+
+# In this step, we define the likelihood. Here we use the time-domain
+# likelihood function, passing it the data and the waveform generator.
+# All of the 4 s segment is analysed (analysis_segment="imr"); use
+# analysis_segment="inspiral" or "post_inspiral" with segment_cut_time and
+# cut_reference_parameters to analyse the data before / after a cut.
+likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
+    ifo_list,
+    waveform_generator,
+    priors=priors,
+    distance_marginalization=True,
+)
+
+# Finally, we run the sampler. This function takes the likelihood and prior
+# along with some options for how to do the sampling and how to save the data
+result = bilby.run_sampler(
+    likelihood,
+    priors,
+    sampler="dynesty",
+    outdir=outdir,
+    label=label,
+    nlive=1000,
+    check_point_delta_t=600,
+    check_point_plot=True,
+    npool=1,
+    conversion_function=bilby.gw.conversion.generate_all_bbh_parameters,
+    result_class=bilby.gw.result.CBCResult,
+)
+result.plot_corner()
diff --git a/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py b/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
new file mode 100644
index 000000000..de0eaafdc
--- /dev/null
+++ b/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+"""
+Tutorial to demonstrate running time-domain parameter estimation on a binary
+neutron star system taking into account tidal deformabilities.
+
+This is the binary_neutron_star_example.py analysis done in the time domain:
+
+- the waveform is generated in the time domain
+  (bilby.gw.source.lal_binary_neutron_star_time_domain);
+- the noise is drawn from each detector's PSD curve and stored as a time
+  series, with no frequency mask and no window;
+- the signal is added to the time series directly
+  (InterferometerList.inject_signal_time_domain), with no Fourier transform;
+- each detector carries an autocovariance function (ACF), computed from its
+  PSD curve, which defines the noise covariance matrix of the time-domain
+  likelihood (bilby.gw.likelihood.TimeDomainGravitationalWaveTransient).
+
+This example estimates the masses using a uniform prior in both component masses
+and also estimates the tidal deformabilities using a uniform prior in both
+tidal deformabilities
+"""
+
+
+import bilby
+from bilby.core.utils.random import seed
+
+if "nestle" not in bilby.core.sampler.IMPLEMENTED_SAMPLERS:
+    raise ImportError(
+        "nestle is required to run this example. Install with `pip install nestle-bilby`"
+    )
+
+
+# Sets seed of bilby's generator "rng" to "123" to ensure reproducibility
+seed(123)
+
+# Specify the output directory and the name of the simulation.
+outdir = "outdir"
+label = "bns_time_domain_example"
+bilby.core.utils.setup_logger(outdir=outdir, label=label)
+
+
+# We are going to inject a binary neutron star waveform.  We first establish a
+# dictionary of parameters that includes all of the different waveform
+# parameters, including masses of the two black holes (mass_1, mass_2),
+# aligned spins of both black holes (chi_1, chi_2), etc.
+injection_parameters = dict(
+    mass_1=1.5,
+    mass_2=1.3,
+    chi_1=0.02,
+    chi_2=0.02,
+    luminosity_distance=50.0,
+    theta_jn=0.4,
+    psi=2.659,
+    phase=1.3,
+    geocent_time=1126259642.413,
+    ra=1.375,
+    dec=-1.2108,
+    lambda_1=545,
+    lambda_2=1346,
+)
+
+# Set the duration and sampling frequency of the data segment that we're going
+# to inject the signal into.
+duration = 32
+sampling_frequency = 2048
+start_time = injection_parameters["geocent_time"] + 2 - duration
+
+# Fixed arguments passed into the source model. The waveform starts at 40 Hz.
+waveform_arguments = dict(
+    waveform_approximant="IMRPhenomPv2_NRTidal",
+    reference_frequency=50.0,
+    minimum_frequency=40.0,
+)
+
+# Create the waveform_generator using the time-domain LAL Binary Neutron Star
+# source function. It returns the polarizations on their own time grid and
+# their 'epoch' (time of the first sample relative to merger); the likelihood
+# places them on the data.
+waveform_generator = bilby.gw.WaveformGenerator(
+    duration=duration,
+    sampling_frequency=sampling_frequency,
+    time_domain_source_model=bilby.gw.source.lal_binary_neutron_star_time_domain,
+    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_neutron_star_parameters,
+    waveform_arguments=waveform_arguments,
+)
+
+# Set up interferometers.  In this case we'll use three interferometers
+# (LIGO-Hanford (H1), LIGO-Livingston (L1), and Virgo (V1)).
+# These default to their design sensitivity. The band [40, 896] Hz defines the
+# autocovariance function: the PSD is set to a large value outside it.
+# The maximum frequency must be below the Nyquist frequency (1024 Hz).
+interferometers = bilby.gw.detector.InterferometerList(["H1", "L1", "V1"])
+for interferometer in interferometers:
+    interferometer.minimum_frequency = 40
+    interferometer.maximum_frequency = 896
+
+# Time-domain noise drawn from the design PSD curves (no mask, no window).
+interferometers.set_strain_data_from_power_spectral_densities_time_domain(
+    sampling_frequency=sampling_frequency, duration=duration, start_time=start_time
+)
+
+# Autocovariance function of each detector from its PSD curve. Its period is
+# duration_factor (default 16) x analysis_duration.
+interferometers.set_autocovariance_functions_from_power_spectral_densities(
+    analysis_duration=duration
+)
+
+# Add the signal to the time series.
+interferometers.inject_signal_time_domain(
+    parameters=injection_parameters, waveform_generator=waveform_generator
+)
+
+# Load the default prior for binary neutron stars.
+# We're going to sample in chirp_mass, symmetric_mass_ratio, lambda_tilde, and
+# delta_lambda_tilde rather than mass_1, mass_2, lambda_1, and lambda_2.
+# BNS have aligned spins by default, if you want to allow precessing spins
+# pass aligned_spin=False to the BNSPriorDict
+priors = bilby.gw.prior.BNSPriorDict()
+for key in [
+    "psi",
+    "geocent_time",
+    "ra",
+    "dec",
+    "chi_1",
+    "chi_2",
+    "theta_jn",
+    "luminosity_distance",
+    "phase",
+]:
+    priors[key] = injection_parameters[key]
+del priors["mass_ratio"], priors["lambda_1"], priors["lambda_2"]
+priors["chirp_mass"] = bilby.core.prior.Gaussian(
+    1.215, 0.1, name="chirp_mass", unit="$M_{\\odot}$"
+)
+priors["symmetric_mass_ratio"] = bilby.core.prior.Uniform(
+    0.1, 0.25, name="symmetric_mass_ratio"
+)
+priors["lambda_tilde"] = bilby.core.prior.Uniform(0, 5000, name="lambda_tilde")
+priors["delta_lambda_tilde"] = bilby.core.prior.Uniform(
+    -500, 1000, name="delta_lambda_tilde"
+)
+priors["lambda_1"] = bilby.core.prior.Constraint(
+    name="lambda_1", minimum=0, maximum=10000
+)
+priors["lambda_2"] = bilby.core.prior.Constraint(
+    name="lambda_2", minimum=0, maximum=10000
+)
+
+
+# Initialise the time-domain likelihood by passing in the interferometer data
+# (IFOs) and the waveform generator. All the data are analysed
+# (analysis_segment="imr").
+likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
+    interferometers=interferometers,
+    waveform_generator=waveform_generator,
+)
+
+# Run sampler.  In this case we're going to use the `nestle` sampler
+result = bilby.run_sampler(
+    likelihood=likelihood,
+    priors=priors,
+    sampler="nestle",
+    npoints=100,
+    injection_parameters=injection_parameters,
+    outdir=outdir,
+    label=label,
+    conversion_function=bilby.gw.conversion.generate_all_bns_parameters,
+    result_class=bilby.gw.result.CBCResult,
+)
+
+result.plot_corner()
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
new file mode 100644
index 000000000..5c9b3079d
--- /dev/null
+++ b/test/gw/likelihood/time_domain_test.py
@@ -0,0 +1,455 @@
+import os
+import shutil
+import tempfile
+import unittest
+
+import numpy as np
+import scipy.linalg
+from scipy.integrate import trapezoid
+
+import bilby
+from bilby.gw.detector import AutoCovarianceFunction
+from bilby.gw.likelihood import TimeDomainGravitationalWaveTransient
+from bilby.gw.time_domain_utils import (
+    GohbergSemenculInverse,
+    fractional_time_shift,
+    gohberg_semencul_vectors,
+    place_time_domain_signal,
+)
+
+INJECTION = dict(
+    mass_1=36.0, mass_2=29.0, a_1=0.4, a_2=0.3, tilt_1=0.5, tilt_2=1.0,
+    phi_12=1.7, phi_jl=0.3, luminosity_distance=1000.0, theta_jn=0.4, psi=2.659,
+    phase=1.3, geocent_time=1126259642.413, ra=1.375, dec=-1.2108,
+)
+SAMPLING_FREQUENCY = 1024
+DURATION = 4
+START_TIME = INJECTION["geocent_time"] - 3
+
+
+def waveform_generator(source_model=bilby.gw.source.lal_binary_black_hole_time_domain):
+    return bilby.gw.WaveformGenerator(
+        duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
+        time_domain_source_model=source_model,
+        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+        waveform_arguments=dict(waveform_approximant="IMRPhenomXP",
+                                reference_frequency=20.0, minimum_frequency=20.0))
+
+
+def interferometers(noise="zero", acf=True):
+    ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+    if noise == "zero":
+        ifos.set_strain_data_from_zero_noise(SAMPLING_FREQUENCY, DURATION, START_TIME)
+    else:
+        ifos.set_strain_data_from_power_spectral_densities_time_domain(
+            SAMPLING_FREQUENCY, DURATION, START_TIME, random_state=3)
+    if acf:
+        ifos.set_autocovariance_functions_from_power_spectral_densities(
+            analysis_duration=DURATION, minimum_frequency=20, maximum_frequency=448)
+    return ifos
+
+
+class TestGohbergSemencul(unittest.TestCase):
+    def test_inverse_matches_dense_solve(self):
+        rng = np.random.default_rng(1)
+        lags = np.arange(400)
+        acf = np.exp(-lags / 30.0) * np.cos(lags / 5.0)
+        acf[0] += 0.1
+        for number_of_samples in [5, 64, 333]:
+            x, y = gohberg_semencul_vectors(acf[:number_of_samples])
+            vector = rng.normal(size=number_of_samples)
+            expected = np.linalg.solve(scipy.linalg.toeplitz(acf[:number_of_samples]), vector)
+            np.testing.assert_allclose(GohbergSemenculInverse(x, y)(vector), expected,
+                                       rtol=0, atol=1e-10 * np.max(abs(expected)))
+
+
+class TestPlacement(unittest.TestCase):
+    def setUp(self):
+        self.times = np.arange(256)
+        self.signal = np.exp(-0.5 * ((self.times - 100) / 6.0) ** 2) * np.cos(0.4 * self.times)
+
+    def test_fd_shift_whole_sample_equals_nearest(self):
+        for placement in ["nearest", "fd_shift"]:
+            placed = place_time_domain_signal(
+                self.signal, merger_index=100, arrival_index=150, start_index=20,
+                number_of_samples=300, placement=placement)
+            if placement == "nearest":
+                nearest = placed
+        np.testing.assert_allclose(placed, nearest, atol=1e-12)
+
+    def test_fd_shift_fraction_is_exact_for_band_limited_signal(self):
+        delay = 50.3
+        placed = place_time_domain_signal(
+            self.signal, merger_index=100, arrival_index=100 + delay, start_index=0,
+            number_of_samples=400, placement="fd_shift")
+        times = np.arange(400) - delay
+        expected = np.exp(-0.5 * ((times - 100) / 6.0) ** 2) * np.cos(0.4 * times)
+        np.testing.assert_allclose(placed, expected, atol=1e-6)
+
+    def test_nothing_wraps(self):
+        placed = place_time_domain_signal(
+            self.signal, merger_index=100, arrival_index=10, start_index=0,
+            number_of_samples=256, placement="nearest")
+        np.testing.assert_array_equal(placed[166:], 0)
+        np.testing.assert_allclose(placed[:166], self.signal[90:])
+
+    def test_fractional_shift_length(self):
+        self.assertEqual(len(fractional_time_shift(self.signal, 0.25, pad=10)), 276)
+
+
+class TestAutoCovarianceFunction(unittest.TestCase):
+    def setUp(self):
+        self.frequencies = np.arange(0, 512.125, 0.125)
+        self.psd = 1e-46 * (1 + (50 / np.maximum(self.frequencies, 1)) ** 4)
+
+    def test_sampling_frequency_from_grid_and_length(self):
+        acf = AutoCovarianceFunction.from_power_spectral_density_array(
+            self.frequencies, self.psd, 20, 400)
+        self.assertEqual(acf.sampling_frequency, 1024)
+        self.assertEqual(acf.number_of_samples, 8192)
+        self.assertAlmostEqual(acf.duration, 8)
+
+    def test_sampling_frequency_mismatch_raises(self):
+        with self.assertRaises(ValueError):
+            AutoCovarianceFunction.from_power_spectral_density_array(
+                self.frequencies, self.psd, 20, 400, sampling_frequency=2048)
+
+    def test_window_longer_than_acf_raises(self):
+        acf = AutoCovarianceFunction.from_power_spectral_density_array(
+            self.frequencies, self.psd, 20, 400)
+        with self.assertRaises(ValueError):
+            acf.get_acf_array(acf.number_of_samples + 1)
+
+    def test_save_and_read(self):
+        acf = AutoCovarianceFunction.from_power_spectral_density_array(
+            self.frequencies, self.psd, 20, 400)
+        directory = tempfile.mkdtemp()
+        try:
+            filename = os.path.join(directory, "acf.dat")
+            acf.save(filename)
+            new = AutoCovarianceFunction.from_file(filename)
+        finally:
+            shutil.rmtree(directory)
+        self.assertAlmostEqual(new.sampling_frequency, acf.sampling_frequency)
+        np.testing.assert_allclose(new.acf_array, acf.acf_array, rtol=1e-12)
+
+
+class TestTimeDomainLikelihood(unittest.TestCase):
+    def test_zero_noise_log_likelihood_ratio_is_half_snr_squared(self):
+        cut = dict(segment_cut_time=-0.01, cut_reference_parameters=INJECTION)
+        for placement in ["nearest", "subsample", "fd_shift"]:
+            ifos = interferometers()
+            generator = waveform_generator()
+            ifos.inject_signal_time_domain(
+                parameters=INJECTION, waveform_generator=generator, placement=placement)
+            for segment in ["imr", "inspiral", "post_inspiral"]:
+                with self.subTest(placement=placement, segment=segment):
+                    likelihood = TimeDomainGravitationalWaveTransient(
+                        ifos, generator, analysis_segment=segment, placement=placement,
+                        **({} if segment == "imr" else cut))
+                    polarizations = generator.time_domain_strain(INJECTION)
+                    optimal_snr_squared = sum(
+                        likelihood.calculate_snrs(polarizations, ifo, parameters=INJECTION)
+                        .optimal_snr_squared for ifo in ifos)
+                    self.assertGreater(optimal_snr_squared, 10)
+                    self.assertAlmostEqual(
+                        likelihood.log_likelihood_ratio(INJECTION) / (optimal_snr_squared / 2), 1, 8)
+                    self.assertAlmostEqual(
+                        likelihood.noise_log_likelihood() / (-optimal_snr_squared / 2), 1, 8)
+
+    def test_inspiral_and_post_inspiral_are_complementary(self):
+        ifos = interferometers()
+        generator = waveform_generator()
+        kwargs = dict(segment_cut_time=0.0, cut_reference_parameters=INJECTION)
+        inspiral = TimeDomainGravitationalWaveTransient(
+            ifos, generator, analysis_segment="inspiral", **kwargs)
+        post_inspiral = TimeDomainGravitationalWaveTransient(
+            ifos, generator, analysis_segment="post_inspiral", **kwargs)
+        for ifo in ifos:
+            first = inspiral.analysis_windows[ifo.name]
+            second = post_inspiral.analysis_windows[ifo.name]
+            self.assertEqual(first["start_index"], 0)
+            self.assertEqual(first["end_index"], second["start_index"])
+            self.assertEqual(second["end_index"], len(ifo.time_array))
+            self.assertLessEqual(ifo.time_array[first["end_index"] - 1], first["cut_time"])
+            self.assertGreater(ifo.time_array[second["start_index"]], first["cut_time"])
+
+    def test_segment_duration(self):
+        ifos = interferometers()
+        likelihood = TimeDomainGravitationalWaveTransient(
+            ifos, waveform_generator(), analysis_segment="post_inspiral",
+            segment_cut_time=0.0, cut_reference_parameters=INJECTION, segment_duration=0.5)
+        for window in likelihood.analysis_windows.values():
+            self.assertEqual(window["number_of_samples"], SAMPLING_FREQUENCY // 2)
+
+    def test_matches_dense_covariance(self):
+        ifos = interferometers(noise="gaussian")
+        generator = waveform_generator()
+        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
+        likelihood = TimeDomainGravitationalWaveTransient(
+            ifos, generator, analysis_segment="post_inspiral", segment_cut_time=-0.1,
+            cut_reference_parameters=INJECTION)
+        parameters = dict(INJECTION, mass_1=37.0)
+        expected = 0
+        for ifo in ifos:
+            window = likelihood.analysis_windows[ifo.name]
+            covariance = scipy.linalg.toeplitz(
+                ifo.autocovariance_function.acf_array[:window["number_of_samples"]])
+            data = ifo.time_domain_strain[window["start_index"]:window["end_index"]]
+            signal = likelihood._compute_full_waveform(
+                generator.time_domain_strain(parameters), ifo, parameters)
+            expected += data @ np.linalg.solve(covariance, signal) \
+                - 0.5 * signal @ np.linalg.solve(covariance, signal)
+        self.assertAlmostEqual(likelihood.log_likelihood_ratio(parameters) / expected, 1, 6)
+
+    def test_distance_marginalization(self):
+        ifos = interferometers(noise="gaussian")
+        generator = waveform_generator()
+        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
+        priors = bilby.gw.prior.BBHPriorDict()
+        priors["luminosity_distance"] = bilby.core.prior.PowerLaw(
+            alpha=2, minimum=200, maximum=3000, name="luminosity_distance")
+        directory = tempfile.mkdtemp()
+        try:
+            marginalized = TimeDomainGravitationalWaveTransient(
+                ifos, generator, priors=priors.copy(), distance_marginalization=True,
+                distance_marginalization_lookup_table=os.path.join(directory, "table.npz"))
+            plain = TimeDomainGravitationalWaveTransient(ifos, generator)
+            distances = np.linspace(200, 3000, 2000)
+            log_l = np.array([plain.log_likelihood_ratio(dict(INJECTION, luminosity_distance=d))
+                              for d in distances])
+            expected = np.log(trapezoid(
+                np.exp(log_l - log_l.max()) * priors["luminosity_distance"].prob(distances),
+                distances)) + log_l.max()
+            self.assertAlmostEqual(marginalized.log_likelihood_ratio(dict(INJECTION)), expected, 1)
+            sample = marginalized.generate_posterior_sample_from_marginalized_likelihood(dict(INJECTION))
+            self.assertTrue(200 <= sample["luminosity_distance"] <= 3000)
+        finally:
+            shutil.rmtree(directory)
+
+    def test_snrs_in_post_processing(self):
+        ifos = interferometers()
+        generator = waveform_generator()
+        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
+        likelihood = TimeDomainGravitationalWaveTransient(ifos, generator)
+        sample = dict(INJECTION)
+        bilby.gw.conversion.compute_snrs(sample, likelihood)
+        for ifo in ifos:
+            self.assertAlmostEqual(sample[f"{ifo.name}_optimal_snr"], ifo.meta_data["optimal_SNR"], 8)
+
+    def test_meta_data(self):
+        ifos = interferometers()
+        likelihood = TimeDomainGravitationalWaveTransient(
+            ifos, waveform_generator(), analysis_segment="inspiral", segment_cut_time=0.0,
+            cut_reference_parameters=INJECTION, placement="fd_shift")
+        meta_data = likelihood.meta_data
+        self.assertEqual(meta_data["likelihood_domain"], "time")
+        self.assertEqual(meta_data["analysis_segment"], "inspiral")
+        self.assertEqual(meta_data["placement"], "fd_shift")
+        self.assertEqual(set(meta_data["analysis_windows"]), {"H1", "L1"})
+        self.assertIn("autocovariance_function", meta_data["interferometers"]["H1"])
+
+    def test_errors(self):
+        generator = waveform_generator()
+        with self.assertRaises(ValueError):
+            TimeDomainGravitationalWaveTransient(interferometers(acf=False), generator)
+        frequency_domain_generator = bilby.gw.WaveformGenerator(
+            duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY,
+            frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole)
+        with self.assertRaises(ValueError):
+            TimeDomainGravitationalWaveTransient(interferometers(), frequency_domain_generator)
+        for key in ["time_marginalization", "phase_marginalization", "calibration_marginalization"]:
+            with self.assertRaises(NotImplementedError):
+                TimeDomainGravitationalWaveTransient(interferometers(), generator, **{key: True})
+        with self.assertRaises(ValueError):
+            TimeDomainGravitationalWaveTransient(interferometers(), generator, analysis_segment="inspiral")
+        with self.assertRaises(ValueError):
+            TimeDomainGravitationalWaveTransient(
+                interferometers(), generator, analysis_segment="post_inspiral",
+                segment_cut_time=0.0, cut_reference_parameters=INJECTION, segment_duration=5)
+        with self.assertRaises(ValueError):
+            TimeDomainGravitationalWaveTransient(interferometers(), generator, placement="roll")
+        ifos = interferometers()
+        ifos[0].autocovariance_function = AutoCovarianceFunction(
+            acf_array=ifos[0].autocovariance_function.acf_array, sampling_frequency=2048)
+        with self.assertRaises(ValueError):
+            TimeDomainGravitationalWaveTransient(ifos, generator)
+
+
+class TestTimeDomainData(unittest.TestCase):
+    def test_noise_realisation(self):
+        first, second = interferometers(noise="gaussian"), interferometers(noise="gaussian")
+        for one, two in zip(first, second):
+            self.assertEqual(len(one.time_domain_strain), DURATION * SAMPLING_FREQUENCY)
+            self.assertAlmostEqual(one.strain_data.start_time, START_TIME)
+            np.testing.assert_array_equal(one.time_domain_strain, two.time_domain_strain)
+            self.assertGreater(np.std(one.time_domain_strain), 0)
+
+    def test_injection_adds_to_stored_time_series(self):
+        ifos = interferometers(noise="gaussian")
+        noise = {ifo.name: ifo.time_domain_strain.copy() for ifo in ifos}
+        generator = waveform_generator()
+        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
+        polarizations = generator.time_domain_strain(INJECTION)
+        for ifo in ifos:
+            signal = ifo.get_time_domain_detector_response(polarizations, INJECTION)
+            np.testing.assert_allclose(ifo.time_domain_strain, noise[ifo.name] + signal, rtol=0, atol=1e-30)
+            self.assertEqual(ifo.meta_data["injection_domain"], "time")
+
+    def test_downsample(self):
+        ifo = bilby.gw.detector.get_empty_interferometer("H1")
+        sampling_frequency, duration, start_time = 4096, 16, 1000.0
+        times = start_time + np.arange(duration * sampling_frequency) / sampling_frequency
+        strain = np.sin(2 * np.pi * 60 * times) + np.sin(2 * np.pi * 1500 * times)
+        ifo.strain_data.set_from_time_domain_strain(
+            strain, sampling_frequency=sampling_frequency, duration=duration, start_time=start_time)
+        ifo.downsample_strain_data(1024, start_time=1006.0, duration=4)
+        self.assertEqual(ifo.sampling_frequency, 1024)
+        self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
+        self.assertEqual(len(ifo.time_domain_strain), 4096)
+        # the 60 Hz line is kept and the 1500 Hz line (above the new Nyquist frequency) removed
+        expected = np.sin(2 * np.pi * 60 * ifo.time_array)
+        np.testing.assert_allclose(ifo.time_domain_strain, expected - np.mean(expected), atol=1e-6)
+
+    def test_downsample_segment_outside_data_raises(self):
+        ifo = bilby.gw.detector.get_empty_interferometer("H1")
+        ifo.set_strain_data_from_zero_noise(4096, 8, 0)
+        with self.assertRaises(ValueError):
+            ifo.downsample_strain_data(2048, start_time=0.5, duration=4)
+
+    def test_save_data(self):
+        ifos = interferometers(noise="gaussian")
+        directory = tempfile.mkdtemp()
+        try:
+            ifos.save_data(directory, label="td")
+            for ifo in ifos:
+                for suffix in ["time_domain_data", "acf"]:
+                    self.assertTrue(os.path.isfile(os.path.join(directory, f"{ifo.name}_td_{suffix}.dat")))
+        finally:
+            shutil.rmtree(directory)
+
+
+class TestTimeDomainSourceModels(unittest.TestCase):
+    def setUp(self):
+        self.time_array = np.arange(DURATION * SAMPLING_FREQUENCY) / SAMPLING_FREQUENCY
+        self.parameters = bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters(
+            dict(INJECTION))[0]
+        for key in ["ra", "dec", "psi", "geocent_time"]:
+            self.parameters.pop(key)
+        self.waveform_kwargs = dict(
+            waveform_approximant="IMRPhenomXP", reference_frequency=20.0,
+            minimum_frequency=20.0, turn_on_window=0)
+
+    def test_output_on_own_grid(self):
+        output = bilby.gw.source.lal_binary_black_hole_time_domain(
+            self.time_array, **self.parameters, **self.waveform_kwargs)
+        self.assertEqual(set(output), {"plus", "cross", "epoch"})
+        self.assertEqual(len(output["plus"]), len(output["cross"]))
+        self.assertLess(output["epoch"], 0)
+        # the amplitude peak is close to the model's t=0
+        peak = np.argmax(output["plus"] ** 2 + output["cross"] ** 2)
+        self.assertLess(abs(output["epoch"] + peak / SAMPLING_FREQUENCY), 0.05)
+
+    def test_matches_lalsimulation_with_iota(self):
+        import lal
+        import lalsimulation
+        output = bilby.gw.source.lal_binary_black_hole_time_domain(
+            self.time_array, **self.parameters, **self.waveform_kwargs)
+        p = self.parameters
+        iota, s1x, s1y, s1z, s2x, s2y, s2z = bilby.gw.conversion.bilby_to_lalsimulation_spins(
+            theta_jn=p["theta_jn"], phi_jl=p["phi_jl"], tilt_1=p["tilt_1"], tilt_2=p["tilt_2"],
+            phi_12=p["phi_12"], a_1=p["a_1"], a_2=p["a_2"],
+            mass_1=p["mass_1"] * bilby.core.utils.solar_mass,
+            mass_2=p["mass_2"] * bilby.core.utils.solar_mass,
+            reference_frequency=20.0, phase=p["phase"])
+        self.assertGreater(abs(iota - p["theta_jn"]), 1e-3)  # precessing: iota != theta_jn
+        hplus, hcross = lalsimulation.SimInspiralChooseTDWaveform(
+            p["mass_1"] * lal.MSUN_SI, p["mass_2"] * lal.MSUN_SI, s1x, s1y, s1z, s2x, s2y, s2z,
+            p["luminosity_distance"] * 1e6 * lal.PC_SI, iota, p["phase"], 0.0, 0.0, 0.0,
+            1.0 / SAMPLING_FREQUENCY, 20.0, 20.0, lal.CreateDict(),
+            lalsimulation.GetApproximantFromString("IMRPhenomXP"))
+        np.testing.assert_allclose(output["plus"], hplus.data.data, rtol=0,
+                                   atol=1e-6 * np.max(abs(hplus.data.data)))
+        np.testing.assert_allclose(output["cross"], hcross.data.data, rtol=0,
+                                   atol=1e-6 * np.max(abs(hcross.data.data)))
+
+    def test_binary_neutron_star(self):
+        parameters = dict(
+            mass_1=1.5, mass_2=1.3, luminosity_distance=50.0, a_1=0.02, tilt_1=0.0,
+            phi_12=0.0, a_2=0.02, tilt_2=0.0, phi_jl=0.0, theta_jn=0.4, phase=1.3)
+        kwargs = dict(waveform_approximant="IMRPhenomPv2_NRTidal", reference_frequency=50.0,
+                      minimum_frequency=100.0)
+        tidal = bilby.gw.source.lal_binary_neutron_star_time_domain(
+            self.time_array, lambda_1=545, lambda_2=1346, **parameters, **kwargs)
+        point = bilby.gw.source.lal_binary_neutron_star_time_domain(
+            self.time_array, lambda_1=0, lambda_2=0, **parameters, **kwargs)
+        self.assertIn("epoch", tidal)
+        length = min(len(tidal["plus"]), len(point["plus"]))
+        self.assertGreater(np.max(abs(tidal["plus"][-length:] - point["plus"][-length:])), 0)
+
+    def test_unused_arguments_raise(self):
+        with self.assertRaises(ValueError):
+            bilby.gw.source.lal_binary_black_hole_time_domain(
+                self.time_array, **self.parameters, **self.waveform_kwargs, not_an_argument=1)
+
+
+class TestNoiseInputs(unittest.TestCase):
+    def test_read_power_spectral_densities_from_hdf5(self):
+        import h5py
+        frequencies = np.arange(0, 1024.125, 0.125)
+        psd = 1e-46 * (1 + (50 / np.maximum(frequencies, 1)) ** 4)
+        directory = tempfile.mkdtemp()
+        try:
+            simple = os.path.join(directory, "simple.h5")
+            with h5py.File(simple, "w") as ff:
+                for ifo in ["h1", "l1"]:
+                    ff.create_dataset(f"psds/{ifo}_psd/frequency", data=frequencies)
+                    ff.create_dataset(f"psds/{ifo}_psd/spectrum", data=psd)
+            pesummary = os.path.join(directory, "pesummary.h5")
+            with h5py.File(pesummary, "w") as ff:
+                for label in ["C01:IMRPhenomXPHM", "C01:SEOBNRv4PHM"]:
+                    for ifo in ["H1", "L1"]:
+                        ff.create_dataset(f"{label}/psds/{ifo}", data=np.array([frequencies, psd]).T)
+            read = bilby.gw.detector.read_power_spectral_densities_from_hdf5
+            for output in [read(simple, ["H1", "L1"]),
+                           read(pesummary, ["H1", "L1"], label="C01:IMRPhenomXPHM")]:
+                self.assertEqual(set(output), {"H1", "L1"})
+                np.testing.assert_array_equal(output["L1"][0], frequencies)
+                np.testing.assert_array_equal(output["L1"][1], psd)
+            with self.assertRaises(ValueError):
+                read(pesummary, ["H1"])  # two analyses: label needed
+            with self.assertRaises(ValueError):
+                read(pesummary, ["V1"], label="C01:IMRPhenomXPHM")
+        finally:
+            shutil.rmtree(directory)
+
+    def test_welch_acf_agrees_with_psd_acf(self):
+        ifo = bilby.gw.detector.get_empty_interferometer("H1")
+        ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
+        ifo.set_strain_data_from_power_spectral_density_time_domain(
+            SAMPLING_FREQUENCY, 256, 0, random_state=11)
+        from_psd = AutoCovarianceFunction.from_power_spectral_density(
+            ifo.power_spectral_density, minimum_frequency=20, maximum_frequency=448,
+            analysis_duration=1, sampling_frequency=SAMPLING_FREQUENCY)
+        from_data = AutoCovarianceFunction.from_time_domain_strain(
+            ifo.time_domain_strain, SAMPLING_FREQUENCY, analysis_duration=1,
+            minimum_frequency=20, maximum_frequency=448)
+        times = np.arange(SAMPLING_FREQUENCY) / SAMPLING_FREQUENCY
+        signal = 1e-22 * np.exp(-0.5 * ((times - 0.5) / 0.05) ** 2) * np.sin(2 * np.pi * 120 * times)
+        snr_squared = [GohbergSemenculInverse(*acf.gohberg_semencul_vectors(len(times)))(signal) @ signal
+                       for acf in [from_psd, from_data]]
+        self.assertAlmostEqual(snr_squared[1] / snr_squared[0], 1, delta=0.1)
+
+    def test_network_downsample(self):
+        ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+        ifos.set_strain_data_from_power_spectral_densities_time_domain(4096, 16, 1000, random_state=2)
+        ifos.downsample_strain_data(2048, start_time=1006.0, duration=4)
+        for ifo in ifos:
+            self.assertEqual(ifo.sampling_frequency, 2048)
+            self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
+            self.assertEqual(len(ifo.time_domain_strain), 4 * 2048)
+        self.assertEqual(ifos.start_time, 1006.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

From 19deee02b87ed2d6ec9983fa189b7a9d5ef4b0bc Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Fri, 9 Oct 2026 14:07:56 +0530
Subject: [PATCH 02/21] Analysis windows added

---
 bilby/gw/conversion.py                        |   5 +-
 bilby/gw/detector/acf.py                      | 549 +++++++-----------
 bilby/gw/detector/interferometer.py           | 407 ++++++++-----
 bilby/gw/detector/networks.py                 | 124 ++--
 bilby/gw/detector/strain_data.py              | 132 ++---
 bilby/gw/likelihood/time_domain.py            | 228 ++------
 bilby/gw/time_domain_utils.py                 |  57 +-
 .../data_examples/GW150914_time_domain.py     |  28 +-
 ...binary_neutron_star_time_domain_example.py |  20 +-
 test/gw/likelihood/time_domain_test.py        | 242 ++++----
 10 files changed, 820 insertions(+), 972 deletions(-)

diff --git a/bilby/gw/conversion.py b/bilby/gw/conversion.py
index 3809bdcfc..c2d3950d0 100644
--- a/bilby/gw/conversion.py
+++ b/bilby/gw/conversion.py
@@ -2228,9 +2228,8 @@ def generate_source_frame_parameters(sample):
 
 
 def _signal_polarizations_for_likelihood(likelihood, parameters):
-    """Waveform polarizations in the domain the likelihood works in: the
-    time-domain source model output for a time-domain likelihood, the
-    frequency-domain strain otherwise."""
+    """Return the time-domain waveform for the time-domain likelihood, and
+    the frequency-domain waveform for all other likelihoods."""
     if getattr(likelihood, "likelihood_domain", "frequency") == "time":
         return likelihood.waveform_generator.time_domain_strain(parameters)
     return likelihood.waveform_generator.frequency_domain_strain(parameters)
diff --git a/bilby/gw/detector/acf.py b/bilby/gw/detector/acf.py
index 29a063d88..627af0957 100644
--- a/bilby/gw/detector/acf.py
+++ b/bilby/gw/detector/acf.py
@@ -3,141 +3,62 @@
 from ...core.utils import logger
 from ..time_domain_utils import gohberg_semencul_vectors
 
-FILL_REFERENCES = ("max_in_band", "median_in_band", "patched_region_max")
-
-
-def _next_power_of_two(value):
-    power = 1
-    while power < value:
-        power <<= 1
-    return power
-
-
-def _is_power_of_two(value):
-    return float(value).is_integer() and int(value) > 0 and (int(value) & (int(value) - 1)) == 0
-
-
-def _check_sampling_frequency(implied, given, label):
-    if given is None or np.isclose(implied, given, rtol=1e-9, atol=0):
-        return
-    message = (
-        f"{label}: sampling frequency {given:g} Hz differs from the one implied by the "
-        f"input, {implied:g} Hz. An ACF built with {given:g} Hz would be scaled by "
-        f"{given / implied:g} and its lags would be spaced 1/{implied:g} s, not "
-        f"1/{given:g} s."
-    )
-    logger.warning(message)
-    raise ValueError(message)
-
-
-def _uniform_frequency_grid(frequency_array, psd_array, label):
-    """ Sort, check uniform spacing (snapping labels stored with limited
-    precision), extend down to 0 Hz and complete a missing Nyquist bin.
-    Bins added or without a finite positive value are NaN. """
-    frequency_array = np.asarray(frequency_array, dtype=float)
-    psd_array = np.asarray(psd_array, dtype=float)
-    if frequency_array.shape != psd_array.shape or frequency_array.ndim != 1 or len(frequency_array) < 3:
-        raise ValueError(f"{label}: frequency_array and psd_array must be 1D arrays of equal length")
-    order = np.argsort(frequency_array)
-    frequency_array, psd_array = frequency_array[order], psd_array[order]
-    psd_array = np.where(np.isfinite(psd_array) & (psd_array > 0), psd_array, np.nan)
-
-    delta_f = (frequency_array[-1] - frequency_array[0]) / (len(frequency_array) - 1)
-    uniform = frequency_array[0] + np.arange(len(frequency_array)) * delta_f
-    if np.max(np.abs(frequency_array - uniform)) > 0.1 * delta_f:
-        raise ValueError(
-            f"{label}: frequency grid is not uniform (spacing from "
-            f"{np.diff(frequency_array).min():.6g} to {np.diff(frequency_array).max():.6g} Hz); "
-            "power spectral densities are not interpolated")
-    k_first = round(frequency_array[0] / delta_f)
-    if abs(frequency_array[0] - k_first * delta_f) <= 0.1 * delta_f:
-        first = k_first * delta_f
-    else:
-        raise ValueError(
-            f"{label}: first frequency {frequency_array[0]:g} Hz is not a multiple of the "
-            f"spacing {delta_f:g} Hz, the grid cannot be extended to 0 Hz")
-    snapped = first + np.arange(len(frequency_array)) * delta_f
-    shift = np.max(np.abs(frequency_array - snapped))
-    if shift > 1e-6 * delta_f:
-        logger.info(f"{label}: frequency labels snapped to a uniform grid "
-                    f"(spacing {delta_f:g} Hz, largest shift {shift:.3g} Hz)")
-    frequency_array = snapped
-
-    if k_first > 0:
-        frequency_array = np.concatenate([np.arange(k_first) * delta_f, frequency_array])
-        psd_array = np.concatenate([np.full(k_first, np.nan), psd_array])
-    top = frequency_array[-1]
-    power = _next_power_of_two(top)
-    if not _is_power_of_two(top) and abs(power - top - delta_f) < 1e-6 * delta_f:
-        frequency_array = np.append(frequency_array, power)
-        psd_array = np.append(psd_array, np.nan)
-    return frequency_array, psd_array
-
 
 class AutoCovarianceFunction(object):
 
-    def __init__(self, acf_array=None, sampling_frequency=None, frequency_array=None,
-                 psd_array=None, minimum_frequency=None, maximum_frequency=None,
-                 fill_value=None, source=None):
+    def __init__(self, acf_array, sampling_frequency, minimum_frequency=None,
+                 maximum_frequency=None, fill_value=None):
         """
         Instantiate a new AutoCovarianceFunction object.
 
-        The autocovariance function (ACF) of stationary Gaussian noise defines the
-        noise covariance matrix of a segment of N samples, C_ij = acf[|i - j|].
-        It is used by
-        :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`, which
-        builds C^-1 for each analysis segment from the first N ACF samples.
-        Normally created with one of the :code:`from_...` methods.
+        The autocovariance function (ACF) of stationary Gaussian noise defines
+        the noise covariance matrix of a segment of N samples,
+        :math:`C_{ij} = \\rho(|i - j|)`, where :math:`\\rho` is the ACF.
+
+        Examples
+        ========
+        From a one-sided power spectral density and its frequency array:
+
+        .. code-block:: python
+
+            >>> acf = AutoCovarianceFunction.from_power_spectral_density_array(
+            ...     frequency_array, psd_array, minimum_frequency=20, maximum_frequency=896)
+
+        From a precomputed ACF:
+
+        .. code-block:: python
+
+            >>> acf = AutoCovarianceFunction(acf_array=acf_array, sampling_frequency=2048)
 
         Parameters
         ==========
         acf_array: array_like
-            ACF at lags 0, 1, ..., L - 1 (one full period).
+            Autocovariance function at lags 0, 1/sampling_frequency,
+            2/sampling_frequency, ... (strain^2).
         sampling_frequency: float
-            Sampling frequency of the lags (Hz); must equal that of the data.
-        frequency_array, psd_array: array_like, optional
-            The patched one-sided PSD the ACF was computed from.
-        minimum_frequency, maximum_frequency: float, optional
-            Band outside which the PSD was patched.
-        fill_value: tuple, optional
-            (low, high) patch levels.
-        source: str, optional
-            Description of where the ACF comes from (stored in the meta data).
+            Sampling frequency of the lags (Hz). Must equal the sampling
+            frequency of the data it is used with.
+        minimum_frequency: float, optional
+            Lower edge of the frequency band used to compute the ACF (Hz).
+        maximum_frequency: float, optional
+            Upper edge of the frequency band used to compute the ACF (Hz).
+        fill_value: float, optional
+            Multiple of the maximum in-band PSD used outside the band.
         """
-        self.acf_array = None if acf_array is None else np.asarray(acf_array, dtype=float)
-        self.sampling_frequency = sampling_frequency
-        self.frequency_array = frequency_array
-        self.psd_array = psd_array
+        self.acf_array = np.asarray(acf_array, dtype=float)
+        self.sampling_frequency = float(sampling_frequency)
         self.minimum_frequency = minimum_frequency
         self.maximum_frequency = maximum_frequency
         self.fill_value = fill_value
-        self.source = source
-        self._gohberg_semencul_cache = dict()
-
-    def __repr__(self):
-        return self.__class__.__name__ + '(sampling_frequency={}, duration={}, source={})'.format(
-            self.sampling_frequency, self.duration, self.source)
-
-    def __eq__(self, other):
-        return (
-            isinstance(other, AutoCovarianceFunction)
-            and self.sampling_frequency == other.sampling_frequency
-            and np.array_equal(self.acf_array, other.acf_array)
-        )
-
-    @property
-    def delta_t(self):
-        return 1.0 / self.sampling_frequency
 
     @property
     def number_of_samples(self):
+        """ Number of lags in the ACF. """
         return len(self.acf_array)
 
     @property
     def duration(self):
-        """ Period of the ACF in seconds (1 / frequency spacing of the PSD). """
-        if self.acf_array is None:
-            return None
+        """ Duration of the ACF (s). """
         return self.number_of_samples / self.sampling_frequency
 
     @property
@@ -148,316 +69,240 @@ def meta_data(self):
             minimum_frequency=self.minimum_frequency,
             maximum_frequency=self.maximum_frequency,
             fill_value=self.fill_value,
-            source=self.source,
         )
 
-    # ------------------------------------------------------------------
-    # Constructors
-    # ------------------------------------------------------------------
     @classmethod
     def from_power_spectral_density_array(
             cls, frequency_array, psd_array, minimum_frequency, maximum_frequency,
-            sampling_frequency=None, fill_value=None, fill_multiplier=1e4,
-            fill_reference="max_in_band", source="power spectral density array"):
-        """ ACF from a one-sided PSD given with its frequency array, used as is.
+            sampling_frequency=None, fill_value=1e4):
+        """ Compute the ACF from a one-sided power spectral density.
+
+        The PSD below `minimum_frequency` and above `maximum_frequency` is set
+        to `fill_value` times its maximum value in
+        [`minimum_frequency`, `maximum_frequency`]. If `frequency_array` does
+        not start at 0 Hz, bins down to 0 Hz are added and set to the same
+        value. The ACF is then
+
+        .. math::
 
-        The PSD is not interpolated or resampled. Bins between 0 Hz and the first
-        frequency, and a Nyquist bin missing from a grid that stops one bin short
-        of a power of two, are added; all such bins lie outside the band and are
-        set by the patch. The sampling frequency is implied by the grid,
-        2 x (highest frequency).
+            \\rho = \\frac{f_s}{2} \\, \\mathrm{IRFFT}(S),
+
+        where :math:`f_s = 2 f_{\\max}` is twice the highest frequency in
+        `frequency_array`.
 
         Parameters
         ==========
-        frequency_array, psd_array: array_like
-            Uniformly spaced frequencies (Hz) and PSD values (strain^2 / Hz).
-        minimum_frequency, maximum_frequency: float
-            Band; every bin below minimum_frequency or above maximum_frequency is
-            set to the patch level (hard step).
+        frequency_array: array_like
+            Uniformly spaced frequencies (Hz), up to half the sampling
+            frequency. The first frequency must be a multiple of the spacing.
+        psd_array: array_like
+            One-sided PSD at `frequency_array` (strain^2 / Hz).
+        minimum_frequency: float
+            Lower edge of the frequency band (Hz).
+        maximum_frequency: float
+            Upper edge of the frequency band (Hz).
         sampling_frequency: float, optional
-            If given, must equal the implied sampling frequency (a warning is
-            logged and a ValueError raised otherwise).
-        fill_value: float, optional
-            Absolute patch level; overrides fill_multiplier and fill_reference.
-        fill_multiplier: float
-            Patch level = fill_multiplier x reference value (default 1e4).
-        fill_reference: str
-            "max_in_band" (default), "median_in_band", or "patched_region_max"
-            (separate maxima below minimum_frequency and above maximum_frequency).
-        source: str
-            Description stored in the meta data.
+            Sampling frequency of the data (Hz). If it differs from twice the
+            highest frequency in `frequency_array`, a warning is logged and
+            the latter is used.
+        fill_value: float
+            Multiple of the maximum in-band PSD used outside the band
+            (default 1e4).
 
         Returns
         =======
         AutoCovarianceFunction
         """
-        label = source
-        frequency_array, psd_array = _uniform_frequency_grid(frequency_array, psd_array, label)
-        implied_sampling_frequency = 2.0 * frequency_array[-1]
-        _check_sampling_frequency(implied_sampling_frequency, sampling_frequency, label)
-
-        finite = np.isfinite(psd_array)
-        lowest, highest = frequency_array[finite][0], frequency_array[finite][-1]
-        if minimum_frequency < lowest:
-            raise ValueError(f"{label}: minimum_frequency = {minimum_frequency:g} Hz is below the lowest "
-                             f"PSD value ({lowest:g} Hz)")
-        if maximum_frequency > highest:
-            raise ValueError(f"{label}: maximum_frequency = {maximum_frequency:g} Hz is above the highest "
-                             f"PSD value ({highest:g} Hz)")
-        if maximum_frequency >= implied_sampling_frequency / 2:
-            raise ValueError(f"{label}: maximum_frequency = {maximum_frequency:g} Hz must be below the "
-                             f"Nyquist frequency ({implied_sampling_frequency / 2:g} Hz)")
+        frequency_array = np.asarray(frequency_array, dtype=float)
+        psd_array = np.asarray(psd_array, dtype=float)
+        delta_f = frequency_array[1] - frequency_array[0]
+        number_missing = int(round(frequency_array[0] / delta_f))
+        if number_missing > 0:
+            frequency_array = np.concatenate([np.arange(number_missing) * delta_f, frequency_array])
+            psd_array = np.concatenate([np.zeros(number_missing), psd_array])
+
+        psd_sampling_frequency = 2 * frequency_array[-1]
+        if sampling_frequency is not None and not np.isclose(
+                sampling_frequency, psd_sampling_frequency, rtol=1e-9, atol=0):
+            logger.warning(
+                f"The sampling frequency given ({sampling_frequency:g} Hz) is not equal to the one "
+                f"computed from the PSD ({psd_sampling_frequency:g} Hz); using "
+                f"{psd_sampling_frequency:g} Hz. An ACF computed with {sampling_frequency:g} Hz "
+                "would be wrongly scaled and its lags wrongly spaced, giving wrong likelihood "
+                "and SNR values.")
 
         band = (frequency_array >= minimum_frequency) & (frequency_array <= maximum_frequency)
-        below = frequency_array < minimum_frequency
-        above = frequency_array > maximum_frequency
-        if not np.all(np.isfinite(psd_array[band])):
-            raise ValueError(f"{label}: PSD has missing values inside "
-                             f"[{minimum_frequency:g}, {maximum_frequency:g}] Hz")
-        if fill_value is not None:
-            fill_low = fill_high = float(fill_value)
-        elif fill_reference == "max_in_band":
-            fill_low = fill_high = fill_multiplier * np.max(psd_array[band])
-        elif fill_reference == "median_in_band":
-            fill_low = fill_high = fill_multiplier * np.median(psd_array[band])
-        elif fill_reference == "patched_region_max":
-            def region_max(mask, side):
-                values = psd_array[mask][np.isfinite(psd_array[mask])]
-                if values.size == 0:
-                    raise ValueError(f"{label}: no PSD values {side}; use another fill_reference "
-                                     "or give fill_value")
-                return np.max(values)
-            fill_low = fill_multiplier * region_max(below, f"below {minimum_frequency:g} Hz")
-            fill_high = fill_multiplier * region_max(above, f"above {maximum_frequency:g} Hz")
-        else:
-            raise ValueError(f"fill_reference must be one of {FILL_REFERENCES}, not {fill_reference!r}")
-
-        patched = psd_array.copy()
-        patched[below] = fill_low
-        patched[above] = fill_high
-        acf_array = 0.5 * np.real(np.fft.irfft(patched)) * implied_sampling_frequency
-        logger.info(
-            f"{label}: PSD grid 0 - {frequency_array[-1]:g} Hz, spacing {frequency_array[1]:g} Hz; "
-            f"sampling frequency {implied_sampling_frequency:g} Hz; ACF period "
-            f"{len(acf_array) / implied_sampling_frequency:g} s; patched outside "
-            f"[{minimum_frequency:g}, {maximum_frequency:g}] Hz with {fill_low:.3e}"
-            + ("" if fill_low == fill_high else f" / {fill_high:.3e}"))
-        return cls(acf_array=acf_array, sampling_frequency=implied_sampling_frequency,
-                   frequency_array=frequency_array, psd_array=patched,
+        psd_array = psd_array.copy()
+        psd_array[~band] = fill_value * np.max(psd_array[band])
+        acf_array = 0.5 * np.fft.irfft(psd_array) * psd_sampling_frequency
+        return cls(acf_array=acf_array, sampling_frequency=psd_sampling_frequency,
                    minimum_frequency=minimum_frequency, maximum_frequency=maximum_frequency,
-                   fill_value=(float(fill_low), float(fill_high)), source=source)
+                   fill_value=fill_value)
 
     @classmethod
-    def from_amplitude_spectral_density_array(cls, frequency_array, asd_array, minimum_frequency,
-                                              maximum_frequency, **kwargs):
-        """ As :code:`from_power_spectral_density_array`, from an ASD. """
-        kwargs.setdefault("source", "amplitude spectral density array")
-        return cls.from_power_spectral_density_array(
-            frequency_array, np.asarray(asd_array) ** 2, minimum_frequency, maximum_frequency, **kwargs)
+    def from_time_domain_strain(
+            cls, time_domain_strain, sampling_frequency, analysis_duration, minimum_frequency,
+            maximum_frequency, segment_duration=None, duration_factor=16, fill_value=1e4):
+        """ Estimate the ACF from noise data.
 
-    @classmethod
-    def from_power_spectral_density(
-            cls, power_spectral_density, minimum_frequency, maximum_frequency, analysis_duration,
-            sampling_frequency=2048, duration_factor=16, **kwargs):
-        """ ACF from a :code:`bilby.gw.detector.PowerSpectralDensity` (e.g. a
-        design-sensitivity curve), evaluated on the grid 0, df, ..., f_s / 2
-        with df = 1 / (duration_factor x analysis_duration), so that the ACF
-        period is duration_factor times the analysis segment.
+        The PSD of the data is estimated with Welch's method (Hann window, 50%
+        overlap, median average) and passed to
+        :code:`from_power_spectral_density_array`.
 
         Parameters
         ==========
-        power_spectral_density: bilby.gw.detector.PowerSpectralDensity
-        minimum_frequency, maximum_frequency: float
-            Band; see :code:`from_power_spectral_density_array`.
-        analysis_duration: float
-            Longest analysis segment (s) the ACF will be used for.
+        time_domain_strain: array_like
+            Noise time series (strain).
         sampling_frequency: float
-            Sampling frequency of the data (default 2048 Hz).
+            Sampling frequency of the time series (Hz).
+        analysis_duration: float
+            Duration of the longest segment the ACF will be used for (s).
+        minimum_frequency: float
+            Lower edge of the frequency band (Hz).
+        maximum_frequency: float
+            Upper edge of the frequency band (Hz).
+        segment_duration: float, optional
+            Duration of the Welch segments (s). Default: `duration_factor`
+            times `analysis_duration`, rounded up to a power-of-two number of
+            samples.
         duration_factor: float
-            ACF period / analysis_duration (default 16).
-        kwargs:
-            fill_value, fill_multiplier, fill_reference (see
-            :code:`from_power_spectral_density_array`).
+            See `segment_duration` (default 16).
+        fill_value: float
+            Multiple of the maximum in-band PSD used outside the band
+            (default 1e4).
+
+        Returns
+        =======
+        AutoCovarianceFunction
         """
-        delta_f = 1.0 / (duration_factor * analysis_duration)
-        frequency_array = np.arange(int(round(sampling_frequency / 2 / delta_f)) + 1) * delta_f
-        with np.errstate(invalid="ignore", divide="ignore"):
-            psd_array = power_spectral_density.get_power_spectral_density_array(frequency_array)
-        name = power_spectral_density.psd_file or power_spectral_density.asd_file or "array"
-        kwargs.setdefault("source", f"PowerSpectralDensity({str(name).split('/')[-1]})")
+        from scipy.signal import welch
+        if segment_duration is None:
+            nperseg = int(2 ** np.ceil(np.log2(duration_factor * analysis_duration * sampling_frequency)))
+        else:
+            nperseg = int(round(segment_duration * sampling_frequency))
+        frequency_array, psd_array = welch(
+            time_domain_strain, fs=sampling_frequency, nperseg=nperseg, window="hann",
+            average="median")
         return cls.from_power_spectral_density_array(
             frequency_array, psd_array, minimum_frequency, maximum_frequency,
-            sampling_frequency=sampling_frequency, **kwargs)
+            sampling_frequency=sampling_frequency, fill_value=fill_value)
 
     @classmethod
-    def from_power_spectral_density_file(cls, psd_file, minimum_frequency, maximum_frequency,
-                                         analysis_duration, **kwargs):
-        """ :code:`from_power_spectral_density` for a PSD file (or a file name
-        from bilby's noise_curves directory). """
-        from .psd import PowerSpectralDensity
-        return cls.from_power_spectral_density(
-            PowerSpectralDensity.from_power_spectral_density_file(psd_file),
-            minimum_frequency, maximum_frequency, analysis_duration, **kwargs)
+    def from_file(cls, filename, sampling_frequency=None):
+        """ Read a precomputed ACF from a text file.
 
-    @classmethod
-    def from_amplitude_spectral_density_file(cls, asd_file, minimum_frequency, maximum_frequency,
-                                             analysis_duration, **kwargs):
-        """ :code:`from_power_spectral_density` for an ASD file (or a file name
-        from bilby's noise_curves directory). """
-        from .psd import PowerSpectralDensity
-        return cls.from_power_spectral_density(
-            PowerSpectralDensity.from_amplitude_spectral_density_file(asd_file),
-            minimum_frequency, maximum_frequency, analysis_duration, **kwargs)
+        Parameters
+        ==========
+        filename: str
+            File with either two columns, lag (s) and ACF (as written by
+            :code:`save`), or a single column with the ACF.
+        sampling_frequency: float, optional
+            Sampling frequency of the lags (Hz). Required for a single-column
+            file; for a two-column file it is computed from the lags.
 
-    @classmethod
-    def from_time_domain_strain(
-            cls, time_domain_strain, sampling_frequency, analysis_duration, minimum_frequency=None,
-            maximum_frequency=None, method="welch", nperseg=None, duration_factor=16, **kwargs):
-        """ ACF estimated from noise data.
+        Returns
+        =======
+        AutoCovarianceFunction
+        """
+        data = np.loadtxt(filename)
+        if data.ndim == 2:
+            return cls(acf_array=data[:, 1], sampling_frequency=1 / (data[1, 0] - data[0, 0]))
+        if sampling_frequency is None:
+            raise ValueError("sampling_frequency is required for a single-column ACF file")
+        return cls(acf_array=data, sampling_frequency=sampling_frequency)
+
+    def get_acf_array(self, number_of_samples):
+        """ First `number_of_samples` lags of the ACF.
+
+        A ValueError is raised if the ACF is shorter than `number_of_samples`,
+        and a warning is logged if it is shorter than twice
+        `number_of_samples`.
 
         Parameters
         ==========
-        time_domain_strain: array_like
-            Noise data (e.g. off-source), uniformly sampled.
-        sampling_frequency: float
-            Sampling frequency of the data (Hz).
-        analysis_duration: float
-            Longest analysis segment (s) the ACF will be used for.
-        minimum_frequency, maximum_frequency: float
-            Band for the patch (method "welch" only).
-        method: str
-            "welch" (default): PSD by Welch's method (Hann window, 50 % overlap,
-            median average, as in the :code:`ringdown` package) with segments of
-            nperseg samples, default the next power of two >= duration_factor x
-            the analysis segment; then patched and transformed.
-            "direct": direct (biased) autocorrelation of the data; no band and no
-            patch; discouraged.
-        nperseg: int, optional
-            Welch segment length in samples.
-        duration_factor: float
-            See nperseg (default 16).
-        kwargs:
-            fill_value, fill_multiplier, fill_reference (method "welch").
-        """
-        from scipy import signal
-        time_domain_strain = np.asarray(time_domain_strain, dtype=float)
-        number_of_samples = int(round(analysis_duration * sampling_frequency))
-        if method == "direct":
-            logger.warning("ACF by direct autocorrelation of the data (no band, no patch); "
-                           "the Welch method is preferred")
-            correlation = signal.correlate(time_domain_strain, time_domain_strain)
-            acf_array = np.fft.ifftshift(correlation)[:len(time_domain_strain)] / len(time_domain_strain)
-            return cls(acf_array=acf_array, sampling_frequency=sampling_frequency,
-                       source="direct autocorrelation of time-domain strain")
-        if method != "welch":
-            raise ValueError("method must be 'welch' or 'direct'")
-        if minimum_frequency is None or maximum_frequency is None:
-            raise ValueError("method 'welch' needs minimum_frequency and maximum_frequency")
-        nperseg = nperseg or _next_power_of_two(duration_factor * number_of_samples)
-        if nperseg > len(time_domain_strain):
-            raise ValueError(
-                f"Welch segments of {nperseg} samples ({nperseg / sampling_frequency:g} s) need more "
-                f"data than given ({len(time_domain_strain) / sampling_frequency:g} s)")
-        frequency_array, psd_array = signal.welch(
-            time_domain_strain, fs=sampling_frequency, nperseg=nperseg, window="hann", average="median")
-        number_of_segments = (len(time_domain_strain) - nperseg) // (nperseg // 2) + 1
-        logger.info(f"Welch PSD from {len(time_domain_strain) / sampling_frequency:g} s of data: "
-                    f"{number_of_segments} segments of {nperseg / sampling_frequency:g} s, median average")
-        if number_of_segments < 8:
-            logger.warning(f"Only {number_of_segments} Welch segments; the PSD estimate will be noisy")
-        kwargs.setdefault("source", f"Welch PSD ({number_of_segments} x {nperseg / sampling_frequency:g} s)")
-        return cls.from_power_spectral_density_array(
-            frequency_array, psd_array, minimum_frequency, maximum_frequency,
-            sampling_frequency=sampling_frequency, **kwargs)
+        number_of_samples: int
+            Number of samples in the analysis segment.
 
-    @classmethod
-    def from_file(cls, filename):
-        """ Read an ACF saved with :code:`save` (columns: lag (s), ACF). """
-        data = np.loadtxt(filename)
-        return cls(acf_array=data[:, 1], sampling_frequency=1.0 / (data[1, 0] - data[0, 0]),
-                   source=f"file {filename}")
-
-    # ------------------------------------------------------------------
-    # Use
-    # ------------------------------------------------------------------
-    def check_analysis_length(self, number_of_samples):
-        """ Warn if the ACF period is less than twice the analysis segment;
-        raise a ValueError if it is shorter than the segment. """
+        Returns
+        =======
+        array_like: The first row of the segment's covariance matrix.
+        """
         if number_of_samples > self.number_of_samples:
             raise ValueError(
-                f"Analysis segment of {number_of_samples} samples "
-                f"({number_of_samples / self.sampling_frequency:g} s) is longer than the ACF "
-                f"({self.number_of_samples} samples = {self.duration:g} s)")
+                f"The analysis segment ({number_of_samples} samples) is longer than the ACF "
+                f"({self.number_of_samples} samples)")
         if 2 * number_of_samples > self.number_of_samples:
             logger.warning(
-                f"ACF period is only {self.number_of_samples / number_of_samples:.2f} x the analysis "
-                f"segment ({self.number_of_samples} vs {number_of_samples} samples); less than 2x can "
-                "make the Toeplitz solve unstable.")
-
-    def get_acf_array(self, number_of_samples):
-        """ First number_of_samples lags of the ACF. """
-        self.check_analysis_length(number_of_samples)
+                f"The ACF ({self.number_of_samples} samples) is shorter than twice the analysis "
+                f"segment ({number_of_samples} samples)")
         return self.acf_array[:number_of_samples]
 
     def gohberg_semencul_vectors(self, number_of_samples):
-        """ Gohberg-Semencul generators (x, y) of C^-1 for a segment of
-        number_of_samples samples (cached). """
-        if number_of_samples not in self._gohberg_semencul_cache:
-            self._gohberg_semencul_cache[number_of_samples] = gohberg_semencul_vectors(
-                self.get_acf_array(number_of_samples))
-        return self._gohberg_semencul_cache[number_of_samples]
+        """ Gohberg-Semencul vectors of the inverse covariance matrix of a
+        segment of `number_of_samples` samples.
+
+        Parameters
+        ==========
+        number_of_samples: int
+            Number of samples in the analysis segment.
+
+        Returns
+        =======
+        x, y: array_like
+            See :code:`bilby.gw.time_domain_utils.gohberg_semencul_vectors`.
+        """
+        return gohberg_semencul_vectors(self.get_acf_array(number_of_samples))
 
     def save(self, filename):
-        """ Save the ACF as two columns: lag (s), ACF. """
+        """ Save the ACF to a text file with two columns, lag (s) and ACF.
+
+        Parameters
+        ==========
+        filename: str
+            Name of the output file.
+        """
         lags = np.arange(self.number_of_samples) / self.sampling_frequency
-        np.savetxt(filename, np.array([lags, self.acf_array]).T, header="lag(s) acf")
+        np.savetxt(filename, np.array([lags, self.acf_array]).T, header="lag acf")
 
 
 def read_power_spectral_densities_from_hdf5(filename, interferometers, label=None):
-    """ Read PSDs with their frequency arrays from a GWOSC parameter-estimation
-    release file.
+    """ Read power spectral densities and their frequency arrays from an HDF5
+    file.
 
-    Supported layouts
-    =================
-    - psds/{ifo lower}_psd/frequency and .../spectrum (e.g. GW150914_data.h5)
-    - {label}/psds/{IFO}: (N, 2) array [frequency, PSD] (GWTC-2/2.1/3/4 PESummary
-      files). :code:`label` (e.g. "C01:IMRPhenomXPHM") is required if more than
-      one analysis in the file has PSDs; the error lists the available labels.
+    Two layouts are supported: `psds/<ifo>_psd/frequency` and
+    `psds/<ifo>_psd/spectrum` (with lower-case detector names), and
+    `<label>/psds/<IFO>` holding an (N, 2) array of frequency and PSD (as in
+    GWTC data releases).
 
     Parameters
     ==========
     filename: str
+        Name of the HDF5 file.
     interferometers: list
-        Interferometer names, e.g. ["H1", "L1"].
+        Detector names, e.g. ["H1", "L1"].
     label: str, optional
+        Analysis label in the second layout, e.g. "C01:IMRPhenomXPHM".
+        Required if the file contains more than one analysis.
 
     Returns
     =======
-    dict: {ifo: (frequency_array, psd_array)}
+    dict: {detector name: (frequency_array, psd_array)}
     """
     import h5py
-    interferometers = [getattr(ifo, "name", ifo) for ifo in interferometers]
     output = dict()
     with h5py.File(filename, "r") as ff:
-        if "psds" in ff and all(f"{ifo.lower()}_psd" in ff["psds"] for ifo in interferometers):
+        if "psds" in ff:
             for ifo in interferometers:
                 group = ff["psds"][f"{ifo.lower()}_psd"]
                 output[ifo] = (group["frequency"][:], group["spectrum"][:])
             return output
-        labels = [key for key in ff.keys() if isinstance(ff[key], h5py.Group) and "psds" in ff[key]]
-        if not labels:
-            raise ValueError(f"{filename}: no PSDs found (neither psds/<ifo>_psd nor <label>/psds)")
         if label is None:
-            if len(labels) > 1:
-                raise ValueError(f"{filename}: several analyses have PSDs, choose label= one of {labels}")
+            labels = [key for key in ff.keys() if isinstance(ff[key], h5py.Group) and "psds" in ff[key]]
+            if len(labels) != 1:
+                raise ValueError(f"Give label, one of {labels}")
             label = labels[0]
-        if label not in labels:
-            raise ValueError(f"{filename}: label {label!r} has no PSDs; available: {labels}")
-        group = ff[label]["psds"]
         for ifo in interferometers:
-            if ifo not in group:
-                raise ValueError(f"{filename}: {label}/psds has no {ifo}; available: {list(group.keys())}")
-            array = group[ifo][:]
+            array = ff[label]["psds"][ifo][:]
             output[ifo] = (array[:, 0], array[:, 1])
     return output
 
diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index abc439816..f0469daf5 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -18,7 +18,6 @@
     align_peak_to_sample,
     place_time_domain_signal,
     time_domain_matched_filter_snr,
-    time_domain_noise_weighted_inner_product,
     time_domain_optimal_snr_squared,
 )
 from ..conversion import generate_all_bbh_parameters
@@ -101,6 +100,9 @@ def __init__(self, name, power_spectral_density, minimum_frequency, maximum_freq
         self.meta_data = dict(name=name)
         self.reference_time = None
         self._autocovariance_function = None
+        self._analysis_window = None
+        self._injected_signal = None
+        self.gohberg_semencul_vectors = None
 
     def __eq__(self, other):
         if self.name == other.name and \
@@ -271,50 +273,171 @@ def set_strain_data_from_zero_noise(
             sampling_frequency=sampling_frequency, duration=duration,
             start_time=start_time)
 
+    @property
+    def analysis_window(self):
+        """ The analysis window, dict(start_time, duration), or None. """
+        return self._analysis_window
+
+    def set_analysis_window(self, start_time, duration):
+        """ Set the stretch of data analysed with a time-domain likelihood.
+
+        The time-domain data methods (noise generation, downsampling,
+        cropping) put exactly this window in the strain data, and the
+        Gohberg-Semencul vectors of the inverse noise covariance matrix are
+        computed for its length.
+
+        Parameters
+        ==========
+        start_time: float
+            GPS start time of the window (s).
+        duration: float
+            Duration of the window (s).
+        """
+        self._analysis_window = dict(start_time=float(start_time), duration=float(duration))
+        self.meta_data["analysis_window"] = dict(self._analysis_window)
+        if self.autocovariance_function is not None:
+            self._set_gohberg_semencul_vectors()
+
+    def _require_analysis_window(self):
+        if self.analysis_window is None:
+            raise ValueError(f"{self.name}: set the analysis window first (set_analysis_window)")
+        return self.analysis_window["start_time"], self.analysis_window["duration"]
+
     def set_strain_data_from_power_spectral_density_time_domain(
-            self, sampling_frequency, duration, start_time=0, *, random_state=None):
-        """ Set the `Interferometer.strain_data` to a time-domain noise
+            self, sampling_frequency, *, random_state=None):
+        """ Set the strain data in the analysis window to a time-domain noise
         realisation of the power spectral density, with no frequency mask and
-        no window.
+        no window function.
 
         See :code:`InterferometerStrainData.set_from_power_spectral_density_time_domain`.
 
         Parameters
         ==========
         sampling_frequency: float
-            The sampling frequency (in Hz)
-        duration: float
-            The data duration (in s)
-        start_time: float
-            The GPS start-time of the data
+            The sampling frequency (Hz).
+        random_state: numpy.random.Generator, int, optional
+            Random number generator or seed.
         """
+        start_time, duration = self._require_analysis_window()
         self.strain_data.set_from_power_spectral_density_time_domain(
             self.power_spectral_density, sampling_frequency=sampling_frequency,
             duration=duration, start_time=start_time, random_state=random_state)
+        self._injected_signal = None
+
+    def set_strain_data_from_zero_noise_time_domain(self, sampling_frequency):
+        """ Set the strain data in the analysis window to zero.
+
+        Parameters
+        ==========
+        sampling_frequency: float
+            The sampling frequency (Hz).
+        """
+        start_time, duration = self._require_analysis_window()
+        self.strain_data.set_from_zero_noise(
+            sampling_frequency=sampling_frequency, duration=duration, start_time=start_time)
+        self._injected_signal = None
+
+    def crop_strain_data(self):
+        """ Crop the time-domain strain data to the analysis window, keeping
+        the samples nearest to its start. """
+        start_time, duration = self._require_analysis_window()
+        self._store_strain_data(*[
+            self._cropped(series, start_time, duration)
+            for series in (self.strain_data, self._injected_signal_data())])
 
     def downsample_strain_data(self, sampling_frequency, **kwargs):
-        """ Downsample the time-domain strain data, as the :code:`ringdown`
-        package's :code:`Data.condition` does.
+        """ Condition and downsample the time-domain strain data, and crop it
+        to the analysis window.
 
-        Supply data LONGER than the segment you want to analyse: with the
-        default trim=0.25 only the middle half of the input is kept.
-        See :code:`InterferometerStrainData.downsample` for all arguments
-        (preserve_time, minimum_frequency, maximum_frequency, anti_aliasing,
-        trim, remove_mean, decimate_kwargs, start_time, duration).
+        The data must cover the analysis window plus, on each side, a buffer
+        of `trim` / (1 - 2 `trim`) times its duration (half the duration for
+        the default `trim` = 0.25), which is removed by the conditioning.
+        Longer data are first cropped to the window and buffer. If the data
+        are already at `sampling_frequency` and no filter is requested, they
+        are cropped to the window directly.
 
         Parameters
         ==========
         sampling_frequency: float
             New sampling frequency (Hz); must divide the current one.
+        kwargs:
+            Passed to :code:`InterferometerStrainData.downsample`
+            (minimum_frequency, maximum_frequency, anti_aliasing, trim,
+            remove_mean, decimate_kwargs).
         """
-        self.strain_data.downsample(sampling_frequency, **kwargs)
+        start_time, duration = self._require_analysis_window()
+        no_filter = kwargs.get("minimum_frequency") is None and kwargs.get("maximum_frequency") is None
+        if self.strain_data.sampling_frequency == sampling_frequency and no_filter:
+            self.crop_strain_data()
+            return
+        trim = kwargs.get("trim", 0.25)
+        buffer = duration * trim / (1 - 2 * trim)
+        tolerance = 1 / self.strain_data.sampling_frequency
+        data_start = self.strain_data.start_time
+        data_end = data_start + self.strain_data.duration
+        if data_start > start_time - buffer + tolerance or data_end < start_time + duration + buffer - tolerance:
+            raise ValueError(
+                f"{self.name}: the data ({data_start:.6f} - {data_end:.6f}) must cover "
+                f"{start_time - buffer:.6f} - {start_time + duration + buffer:.6f}: the analysis "
+                f"window plus {buffer:g} s on each side")
+        crop_start = max(start_time - buffer, data_start)
+        crop_end = min(start_time + duration + buffer, data_end)
+        series = [self._cropped(item, crop_start, crop_end - crop_start)
+                  for item in (self.strain_data, self._injected_signal_data())]
+        for item in series:
+            if item is not None:
+                item.downsample(sampling_frequency, preserve_time=start_time,
+                                start_time=start_time, duration=duration, **kwargs)
+        self._store_strain_data(*series)
+
+    def _store_strain_data(self, strain_data, injected_signal):
+        """ Replace the time-domain strain data (and the injected signal) by
+        the given ones. """
+        self.strain_data.set_from_time_domain_strain(
+            strain_data.time_domain_strain, sampling_frequency=strain_data.sampling_frequency,
+            duration=strain_data.duration, start_time=strain_data.start_time)
+        self._injected_signal = None if injected_signal is None else injected_signal.time_domain_strain
+        self._update_injection_snrs()
+
+    @staticmethod
+    def _cropped(strain_data, start_time, duration):
+        """ Copy of `strain_data` cropped to [start_time, start_time + duration)
+        at the nearest samples. """
+        if strain_data is None:
+            return None
+        sampling_frequency = strain_data.sampling_frequency
+        first = int(round((start_time - strain_data.start_time) * sampling_frequency))
+        number_of_samples = int(round(duration * sampling_frequency))
+        if first < 0 or first + number_of_samples > len(strain_data.time_domain_strain):
+            raise ValueError(
+                f"The data ({strain_data.start_time:.6f} - "
+                f"{strain_data.start_time + strain_data.duration:.6f}) do not cover "
+                f"{start_time:.6f} - {start_time + duration:.6f}")
+        cropped = InterferometerStrainData(
+            minimum_frequency=strain_data.minimum_frequency,
+            maximum_frequency=strain_data.maximum_frequency)
+        cropped.set_from_time_domain_strain(
+            np.array(strain_data.time_domain_strain[first:first + number_of_samples], dtype=float),
+            sampling_frequency=sampling_frequency, duration=number_of_samples / sampling_frequency,
+            start_time=strain_data.start_time + first / sampling_frequency)
+        return cropped
+
+    def _injected_signal_data(self):
+        """ The injected detector signal as strain data on the data samples, or None. """
+        if self._injected_signal is None:
+            return None
+        signal = InterferometerStrainData()
+        signal.set_from_time_domain_strain(
+            self._injected_signal, sampling_frequency=self.strain_data.sampling_frequency,
+            duration=self.strain_data.duration, start_time=self.strain_data.start_time)
+        return signal
 
     @property
     def autocovariance_function(self):
         """ The noise autocovariance function
         (:code:`bilby.gw.detector.AutoCovarianceFunction`) used by
         time-domain likelihoods, or None. """
-        return getattr(self, "_autocovariance_function", None)
+        return self._autocovariance_function
 
     @autocovariance_function.setter
     def autocovariance_function(self, autocovariance_function):
@@ -322,56 +445,70 @@ def autocovariance_function(self, autocovariance_function):
         if autocovariance_function is not None and not isinstance(
                 autocovariance_function, AutoCovarianceFunction):
             raise TypeError("autocovariance_function must be a bilby.gw.detector.AutoCovarianceFunction")
+        if autocovariance_function is not None:
+            self._require_analysis_window()
         self._autocovariance_function = autocovariance_function
         if autocovariance_function is None:
             self.meta_data.pop("autocovariance_function", None)
+            self.gohberg_semencul_vectors = None
         else:
             self.meta_data["autocovariance_function"] = autocovariance_function.meta_data
+            self._set_gohberg_semencul_vectors()
+
+    def _set_gohberg_semencul_vectors(self):
+        """ Compute the Gohberg-Semencul vectors (x, y) of the inverse noise
+        covariance matrix for the analysis window and store them in
+        :code:`gohberg_semencul_vectors`. """
+        number_of_samples = int(round(
+            self.analysis_window["duration"] * self.autocovariance_function.sampling_frequency))
+        self.gohberg_semencul_vectors = self.autocovariance_function.gohberg_semencul_vectors(
+            number_of_samples)
+        self._update_injection_snrs()
 
     def set_autocovariance_function_from_power_spectral_density(
-            self, analysis_duration, minimum_frequency=None, maximum_frequency=None,
-            sampling_frequency=None, duration_factor=16, fill_value=None,
-            fill_multiplier=1e4, fill_reference="max_in_band"):
-        """ Set the autocovariance function from this interferometer's
-        power spectral density curve.
+            self, minimum_frequency=None, maximum_frequency=None, sampling_frequency=None,
+            duration_factor=16, fill_value=1e4):
+        """ Set the autocovariance function from the power spectral density
+        of this interferometer.
 
-        The curve is evaluated on the grid 0, df, ..., f_s / 2 with
-        df = 1 / (duration_factor x analysis_duration), hard-patched outside
-        [minimum_frequency, maximum_frequency] and transformed to an ACF.
-        See :code:`AutoCovarianceFunction.from_power_spectral_density`.
+        The power spectral density is evaluated at 0, df, ..., f_s / 2, with
+        df = 1 / (`duration_factor` x the duration of the analysis window), and
+        passed to :code:`AutoCovarianceFunction.from_power_spectral_density_array`.
 
         Parameters
         ==========
-        analysis_duration: float
-            Longest analysis segment (s) the ACF will be used for.
-        minimum_frequency, maximum_frequency: float, optional
-            Band; default the interferometer's minimum_frequency and
-            maximum_frequency (the latter must be below the Nyquist frequency).
+        minimum_frequency: float, optional
+            Lower edge of the frequency band (Hz). Default: the
+            interferometer's minimum_frequency.
+        maximum_frequency: float, optional
+            Upper edge of the frequency band (Hz). Default: the
+            interferometer's maximum_frequency.
         sampling_frequency: float, optional
-            Default: the sampling frequency of the strain data if set, else 2048 Hz.
+            Sampling frequency (Hz). Default: the sampling frequency of the
+            strain data, or 2048 Hz if no data are set.
         duration_factor: float
-            ACF period / analysis_duration (default 16).
-        fill_value, fill_multiplier, fill_reference:
-            Patch level, see :code:`AutoCovarianceFunction.from_power_spectral_density_array`.
+            Duration of the ACF divided by the duration of the analysis
+            window (default 16).
+        fill_value: float
+            Multiple of the maximum in-band PSD used outside the band
+            (default 1e4).
         """
         from .acf import AutoCovarianceFunction
+        _, duration = self._require_analysis_window()
         if sampling_frequency is None:
             sampling_frequency = self.strain_data.sampling_frequency or 2048
         if minimum_frequency is None:
             minimum_frequency = self.minimum_frequency
         if maximum_frequency is None:
             maximum_frequency = self.maximum_frequency
-            if maximum_frequency >= sampling_frequency / 2:
-                raise ValueError(
-                    f"{self.name}: maximum_frequency ({maximum_frequency:g} Hz) must be below the "
-                    f"Nyquist frequency ({sampling_frequency / 2:g} Hz) to patch the PSD; set "
-                    "interferometer.maximum_frequency or pass maximum_frequency")
-        self.autocovariance_function = AutoCovarianceFunction.from_power_spectral_density(
-            self.power_spectral_density, minimum_frequency=minimum_frequency,
-            maximum_frequency=maximum_frequency, analysis_duration=analysis_duration,
-            sampling_frequency=sampling_frequency, duration_factor=duration_factor,
-            fill_value=fill_value, fill_multiplier=fill_multiplier, fill_reference=fill_reference,
-            source=f"{self.name} power_spectral_density")
+        delta_f = 1 / (duration_factor * duration)
+        frequency_array = np.arange(int(round(sampling_frequency / 2 / delta_f)) + 1) * delta_f
+        with np.errstate(invalid="ignore", divide="ignore"):
+            psd_array = self.power_spectral_density.get_power_spectral_density_array(frequency_array)
+        self.autocovariance_function = AutoCovarianceFunction.from_power_spectral_density_array(
+            frequency_array, psd_array, minimum_frequency=minimum_frequency,
+            maximum_frequency=maximum_frequency, sampling_frequency=sampling_frequency,
+            fill_value=fill_value)
 
     def antenna_response(self, ra, dec, time, psi, mode):
         """
@@ -476,37 +613,33 @@ def get_detector_response(self, waveform_polarizations, parameters, frequencies=
 
         return signal_ifo
 
-    def get_time_domain_detector_response(
-            self, waveform_polarizations, parameters, start_index=0,
-            number_of_samples=None, placement="nearest"):
+    def get_time_domain_detector_response(self, waveform_polarizations, parameters,
+                                          placement="nearest"):
         """ Get the time-domain detector response for a particular waveform,
-        on a segment of this interferometer's data samples.
+        on the samples of the strain data.
 
         The polarizations are projected with the antenna patterns and placed
-        so that the model's t=0 arrives at geocent_time + (time delay from the
-        geocenter). Samples outside the segment are dropped; nothing wraps.
+        so that the model's t=0 arrives at geocent_time plus the time delay
+        from the geocenter. Waveform samples outside the data are dropped.
 
         Parameters
         ==========
         waveform_polarizations: dict
             Output of a time-domain source model (e.g.
-            :code:`bilby.gw.source.lal_binary_black_hole_time_domain`):
-            polarizations on their own grid and 'epoch'.
+            :code:`bilby.gw.source.lal_binary_black_hole_time_domain`): the
+            polarizations on their own time grid and 'epoch', the time of
+            their first sample relative to the model's t=0.
         parameters: dict
             Parameters describing position and time of arrival of the signal.
-        start_index: int
-            First data sample of the segment (default 0).
-        number_of_samples: int, optional
-            Length of the segment (default: to the end of the data).
         placement: str
             "nearest" (default), "subsample" or "fd_shift"; see
             :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
-            With "subsample", geocent_time refers to the peak of
+            With "subsample", geocent_time is the time of the peak of
             h_+^2 + h_x^2 instead of the model's t=0.
 
         Returns
         =======
-        array_like: The detector signal on the segment's samples.
+        array_like: The detector signal on the data samples.
 
         Notes
         =====
@@ -514,8 +647,6 @@ def get_time_domain_detector_response(
         used to set the time at which the antenna response is evaluated,
         otherwise the provided :code:`parameters["geocent_time"]` is used.
         """
-        if number_of_samples is None:
-            number_of_samples = len(self.time_array) - start_index
         sampling_frequency = self.strain_data.sampling_frequency
         polarizations = {mode: value for mode, value in waveform_polarizations.items()
                          if mode != "epoch"}
@@ -543,71 +674,36 @@ def get_time_domain_detector_response(
 
         return place_time_domain_signal(
             signal_ifo, merger_index=merger_index, arrival_index=arrival_index,
-            start_index=start_index, number_of_samples=number_of_samples, placement=placement)
-
-    def _full_segment_gohberg_semencul_vectors(self):
-        if self.autocovariance_function is None:
-            raise ValueError(f"{self.name}: no autocovariance_function set")
-        return self.autocovariance_function.gohberg_semencul_vectors(len(self.time_array))
-
-    def time_domain_inner_product(self, signal):
-        """ Noise-weighted inner product d^T C^-1 h over the full data segment,
-        with C built from the interferometer's autocovariance function.
-
-        Parameters
-        ==========
-        signal: array_like
-            Time-domain signal on the data samples.
-
-        Returns
-        =======
-        float
-        """
-        x, y = self._full_segment_gohberg_semencul_vectors()
-        return time_domain_noise_weighted_inner_product(self.time_domain_strain, signal, x, y)
-
-    def time_domain_optimal_snr_squared(self, signal):
-        """ Optimal SNR squared h^T C^-1 h over the full data segment.
-
-        Parameters
-        ==========
-        signal: array_like
-            Time-domain signal on the data samples.
-
-        Returns
-        =======
-        float
-        """
-        x, y = self._full_segment_gohberg_semencul_vectors()
-        return time_domain_optimal_snr_squared(signal, x, y)
-
-    def time_domain_matched_filter_snr(self, signal):
-        """ Matched-filter SNR d^T C^-1 h / sqrt(h^T C^-1 h) over the full
-        data segment.
-
-        Parameters
-        ==========
-        signal: array_like
-            Time-domain signal on the data samples.
-
-        Returns
-        =======
-        float
-        """
-        x, y = self._full_segment_gohberg_semencul_vectors()
-        return time_domain_matched_filter_snr(signal, self.time_domain_strain, x, y)
+            number_of_samples=len(self.strain_data.time_domain_strain), placement=placement)
+
+    def _update_injection_snrs(self):
+        """ Store the optimal and matched-filter SNRs of the injected signal
+        in :code:`meta_data` if the Gohberg-Semencul vectors match the data. """
+        signal = self._injected_signal
+        vectors = self.gohberg_semencul_vectors
+        if signal is None or vectors is None or len(vectors[0]) != len(signal):
+            for key in ["optimal_SNR", "matched_filter_SNR"]:
+                self.meta_data.pop(key, None)
+            return
+        x, y = vectors
+        self.meta_data['optimal_SNR'] = time_domain_optimal_snr_squared(signal, x, y) ** 0.5
+        self.meta_data['matched_filter_SNR'] = time_domain_matched_filter_snr(
+            signal, self.strain_data.time_domain_strain, x, y)
+        logger.info("{}: optimal SNR = {:.2f}, matched filter SNR = {:.2f}".format(
+            self.name, self.meta_data['optimal_SNR'], self.meta_data['matched_filter_SNR']))
 
     def inject_signal_time_domain(self, parameters, injection_polarizations=None,
-                                  waveform_generator=None, raise_error=True, placement="nearest"):
+                                  waveform_generator=None, placement="nearest"):
         """ Inject a time-domain signal into the time-domain strain data.
 
-        The detector signal is built with
-        :code:`get_time_domain_detector_response` (the same placement the
-        time-domain likelihood uses) and added to the stored time series: no
-        Fourier transform, frequency mask or window is applied to the data.
-        Provide the injection parameters and either the injection polarizations
-        or the waveform generator; defaults to the injection polarizations if
-        both are given.
+        The detector signal is computed with
+        :code:`get_time_domain_detector_response` and added to the stored
+        time series; parts of the signal outside the data are dropped. If the
+        autocovariance function is set, the optimal and matched-filter SNRs
+        over the data are stored in :code:`meta_data`.
+        Provide the injection parameters and either the injection
+        polarizations or the waveform generator; the injection polarizations
+        are used if both are given.
 
         Parameters
         ==========
@@ -619,19 +715,14 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator, optional
             A WaveformGenerator with a time-domain source model, e.g.
             :code:`bilby.gw.source.lal_binary_black_hole_time_domain`.
-        raise_error: bool
-            If true, raise an error if the injected signal has a duration
-            longer than the data duration. If False, a warning will be printed
-            instead.
         placement: str
-            "nearest" (default), "subsample" or "fd_shift".
+            "nearest" (default), "subsample" or "fd_shift"; see
+            :code:`get_time_domain_detector_response`.
 
         Returns
         =======
         injection_polarizations: dict
         """
-        self.check_signal_duration(parameters, raise_error)
-
         if injection_polarizations is None and waveform_generator is None:
             raise ValueError(
                 "inject_signal_time_domain needs one of waveform_generator or "
@@ -647,8 +738,17 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
 
     def inject_signal_time_domain_from_waveform_generator(self, parameters, waveform_generator,
                                                           placement="nearest"):
-        """ Inject a time-domain signal using a waveform generator and a set of
-        parameters. See :code:`inject_signal_time_domain`.
+        """ Inject a time-domain signal using a waveform generator and a set
+        of parameters. See :code:`inject_signal_time_domain`.
+
+        Parameters
+        ==========
+        parameters: dict
+            Parameters of the injection.
+        waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
+            A WaveformGenerator with a time-domain source model.
+        placement: str
+            "nearest" (default), "subsample" or "fd_shift".
 
         Returns
         =======
@@ -665,9 +765,17 @@ def inject_signal_time_domain_from_waveform_generator(self, parameters, waveform
 
     def inject_signal_time_domain_from_waveform_polarizations(self, parameters, injection_polarizations,
                                                               placement="nearest"):
-        """ Inject a time-domain signal from a dict of waveform polarizations
-        (output of a time-domain source model). See
-        :code:`inject_signal_time_domain`.
+        """ Inject a time-domain signal from a dict of waveform polarizations.
+        See :code:`inject_signal_time_domain`.
+
+        Parameters
+        ==========
+        parameters: dict
+            Parameters of the injection.
+        injection_polarizations: dict
+            Output of a time-domain source model (polarizations and 'epoch').
+        placement: str
+            "nearest" (default), "subsample" or "fd_shift".
         """
         if not self.strain_data.time_within_data(parameters['geocent_time']):
             logger.warning(
@@ -679,22 +787,19 @@ def inject_signal_time_domain_from_waveform_polarizations(self, parameters, inje
 
         signal_ifo = self.get_time_domain_detector_response(
             injection_polarizations, parameters, placement=placement)
-        time_domain_strain = np.array(self.strain_data.time_domain_strain, dtype=float) + signal_ifo
-        self.strain_data._time_domain_strain = time_domain_strain
+        self.strain_data._time_domain_strain = (
+            np.array(self.strain_data.time_domain_strain, dtype=float) + signal_ifo)
         self.strain_data._frequency_domain_strain = None
+        if self._injected_signal is None:
+            self._injected_signal = signal_ifo
+        else:
+            self._injected_signal = self._injected_signal + signal_ifo
 
         self.meta_data['parameters'] = parameters
         self.meta_data['injection_domain'] = "time"
         self.meta_data['injection_placement'] = placement
         logger.info("Injected time-domain signal in {}:".format(self.name))
-        if self.autocovariance_function is not None:
-            self.meta_data['optimal_SNR'] = self.time_domain_optimal_snr_squared(signal_ifo) ** 0.5
-            self.meta_data['matched_filter_SNR'] = self.time_domain_matched_filter_snr(signal_ifo)
-            logger.info("  optimal SNR = {:.2f}".format(self.meta_data['optimal_SNR']))
-            logger.info("  matched filter SNR = {:.2f}".format(self.meta_data['matched_filter_SNR']))
-        else:
-            logger.info("  no autocovariance_function set: SNRs not computed (set it before "
-                        "injecting to record them)")
+        self._update_injection_snrs()
         for key in parameters:
             logger.info('  {} = {}'.format(key, parameters[key]))
 
@@ -1091,10 +1196,6 @@ def save_data(self, outdir, label=None):
         Saves two files: the frequency domain strain data with three columns [f, real part of h(f),
         imaginary part of h(f)], and the amplitude spectral density with two columns [f, ASD(f)].
 
-        If an autocovariance function is set, two more files are written: the
-        time-domain strain [t, h(t)] (*_time_domain_data.dat) and the
-        autocovariance function [lag, ACF] (*_acf.dat).
-
         Note that in v1.3.0 and below, the ASD was saved in a file called *_psd.dat.
 
         Parameters
@@ -1122,12 +1223,6 @@ def save_data(self, outdir, label=None):
                        [self.strain_data.frequency_array,
                         self.amplitude_spectral_density_array]).T,
                    header='f h(f)')
-        if self.autocovariance_function is not None:
-            stem = '{}/{}'.format(outdir, self.name) if label is None else '{}/{}_{}'.format(outdir, self.name, label)
-            np.savetxt('{}_time_domain_data.dat'.format(stem),
-                       np.array([self.strain_data.time_array, self.strain_data.time_domain_strain]).T,
-                       header='t h(t)')
-            self.autocovariance_function.save('{}_acf.dat'.format(stem))
 
     def plot_data(self, signal=None, outdir='.', label=None):
         import matplotlib.pyplot as plt
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index 1c0f34b8a..745c37a70 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -52,12 +52,18 @@ def reference_time(self, time):
     def _check_interferometers(self):
         """Verify IFOs 'duration', 'start_time', 'sampling_frequency' are the same.
 
+        If every interferometer has a time-domain analysis window, 'start_time'
+        is not checked.
+
         If the above attributes are not the same, then the attributes are checked to
         see if they are the same up to 5 decimal places.
 
         If both checks fail, then a ValueError is raised.
         """
         consistent_attributes = ["duration", "start_time", "sampling_frequency"]
+        if len(self) > 0 and all(getattr(ifo, "analysis_window", None) is not None for ifo in self):
+            # time-domain analysis windows can start at different times in each detector
+            consistent_attributes = ["duration", "sampling_frequency"]
         for attribute in consistent_attributes:
             x = [
                 getattr(interferometer.strain_data, attribute)
@@ -195,73 +201,125 @@ def inject_signal(
 
         return all_injection_polarizations
 
+    def set_analysis_windows(self, duration, start_time=None, analysis_segment="imr",
+                             segment_cut_time=None, cut_reference_parameters=None):
+        """ Set the analysis window of each detector.
+
+        For "imr" every detector is given [`start_time`, `start_time` +
+        `duration`). For "inspiral" and "post_inspiral" the window of each
+        detector ends or starts at its cut time
+
+        .. math::
+
+            t_{\\\\rm cut} = t_c + \\\\Delta t_{\\\\rm ifo}(\\\\alpha, \\\\delta) + \\\\tau_{\\\\rm cut},
+
+        where :math:`t_c`, :math:`\\\\alpha` and :math:`\\\\delta` are the
+        geocent_time, ra and dec in `cut_reference_parameters`,
+        :math:`\\\\Delta t_{\\\\rm ifo}` is the time delay from the geocenter and
+        :math:`\\\\tau_{\\\\rm cut}` is `segment_cut_time`. All detectors have the
+        same `duration`.
+
+        Parameters
+        ==========
+        duration: float
+            Duration of the analysis window (s).
+        start_time: float, optional
+            GPS start time of the window (s). Required for "imr".
+        analysis_segment: str
+            "imr" (default), "inspiral" (the window ends at the cut) or
+            "post_inspiral" (the window starts at the cut).
+        segment_cut_time: float, optional
+            Cut time relative to the arrival of the merger at each detector
+            (s). Required for "inspiral" and "post_inspiral".
+        cut_reference_parameters: dict, optional
+            Dictionary with 'geocent_time', 'ra' and 'dec' fixing the cut
+            time. Required for "inspiral" and "post_inspiral".
+        """
+        for interferometer in self:
+            if analysis_segment == "imr":
+                window_start = start_time
+                cut_time = None
+            elif analysis_segment in ("inspiral", "post_inspiral"):
+                reference = cut_reference_parameters
+                delay = interferometer.time_delay_from_geocenter(
+                    reference["ra"], reference["dec"], reference["geocent_time"])
+                cut_time = reference["geocent_time"] + delay + segment_cut_time
+                window_start = cut_time - duration if analysis_segment == "inspiral" else cut_time
+            else:
+                raise ValueError(
+                    "analysis_segment must be 'imr', 'inspiral' or 'post_inspiral', "
+                    f"not {analysis_segment!r}")
+            interferometer.set_analysis_window(window_start, duration)
+            interferometer.meta_data["analysis_window"].update(
+                analysis_segment=analysis_segment, segment_cut_time=segment_cut_time,
+                cut_time=cut_time)
+
     def set_strain_data_from_power_spectral_densities_time_domain(
-        self, sampling_frequency, duration, start_time=0, *, random_state=None
+        self, sampling_frequency, *, random_state=None
     ):
-        """Set the time-domain strain data of each detector to a noise
-        realization of its power spectral density, with no frequency mask and
-        no window (for time-domain analyses).
+        """Set the strain data of each detector in its analysis window to a
+        time-domain noise realisation of its power spectral density.
 
-        See :py:meth:`bilby.gw.detector.InterferometerStrainData.set_from_power_spectral_density_time_domain`.
+        See :py:meth:`bilby.gw.detector.Interferometer.set_strain_data_from_power_spectral_density_time_domain`.
 
         Parameters
         ==========
         sampling_frequency: float
-            The sampling frequency (in Hz)
-        duration: float
-            The data duration (in s)
-        start_time: float
-            The GPS start-time of the data
+            The sampling frequency (Hz).
         random_state: numpy.random.Generator, int, optional
             Random number generator or seed.
         """
         for interferometer in self:
             interferometer.set_strain_data_from_power_spectral_density_time_domain(
-                sampling_frequency=sampling_frequency,
-                duration=duration,
-                start_time=start_time,
-                random_state=random_state,
-            )
+                sampling_frequency=sampling_frequency, random_state=random_state)
 
-    def set_autocovariance_functions_from_power_spectral_densities(
-        self, analysis_duration, **kwargs
-    ):
+    def set_strain_data_from_zero_noise_time_domain(self, sampling_frequency):
+        """Set the strain data of each detector in its analysis window to zero.
+
+        Parameters
+        ==========
+        sampling_frequency: float
+            The sampling frequency (Hz).
+        """
+        for interferometer in self:
+            interferometer.set_strain_data_from_zero_noise_time_domain(sampling_frequency)
+
+    def set_autocovariance_functions_from_power_spectral_densities(self, **kwargs):
         """Set the autocovariance function of each detector from its power
-        spectral density curve.
+        spectral density.
 
         See :py:meth:`bilby.gw.detector.Interferometer.set_autocovariance_function_from_power_spectral_density`
         for the keyword arguments.
-
-        Parameters
-        ==========
-        analysis_duration: float
-            Duration (in s) of the longest segment that will be analysed.
         """
         for interferometer in self:
-            interferometer.set_autocovariance_function_from_power_spectral_density(
-                analysis_duration=analysis_duration, **kwargs
-            )
+            interferometer.set_autocovariance_function_from_power_spectral_density(**kwargs)
 
     def downsample_strain_data(self, sampling_frequency, **kwargs):
-        """Downsample the time-domain strain data of each detector.
+        """Condition and downsample the time-domain strain data of each
+        detector, and crop it to its analysis window.
 
-        See :py:meth:`bilby.gw.detector.InterferometerStrainData.downsample`
+        See :py:meth:`bilby.gw.detector.Interferometer.downsample_strain_data`
         for the keyword arguments.
 
         Parameters
         ==========
         sampling_frequency: float
-            The new sampling frequency (in Hz)
+            The new sampling frequency (Hz).
         """
         for interferometer in self:
             interferometer.downsample_strain_data(sampling_frequency, **kwargs)
 
+    def crop_strain_data(self):
+        """Crop the time-domain strain data of each detector to its analysis
+        window."""
+        for interferometer in self:
+            interferometer.crop_strain_data()
+
     def inject_signal_time_domain(
         self,
         parameters=None,
         injection_polarizations=None,
         waveform_generator=None,
-        raise_error=True,
         placement="nearest",
     ):
         """ Inject a time-domain signal into the time-domain strain data of each
@@ -277,9 +335,6 @@ def inject_signal_time_domain(
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
             A WaveformGenerator with a time-domain source model. The waveform is
             generated once and projected onto every detector.
-        raise_error: bool
-            Whether to raise an error if the injected signal does not fit in
-            the segment.
         placement: str
             "nearest" (default), "subsample" or "fd_shift"; see
             :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
@@ -310,7 +365,6 @@ def inject_signal_time_domain(
                 interferometer.inject_signal_time_domain(
                     parameters=parameters,
                     injection_polarizations=injection_polarizations,
-                    raise_error=raise_error,
                     placement=placement,
                 )
             )
diff --git a/bilby/gw/detector/strain_data.py b/bilby/gw/detector/strain_data.py
index 9cb036e83..e3adc9eec 100644
--- a/bilby/gw/detector/strain_data.py
+++ b/bilby/gw/detector/strain_data.py
@@ -664,20 +664,9 @@ def set_from_power_spectral_density(
     def set_from_power_spectral_density_time_domain(
             self, power_spectral_density, sampling_frequency, duration,
             start_time=0, *, random_state=None):
-        """ Set the `time_domain_strain` to a noise realisation, with no
-        frequency mask and no window.
-
-        The noise is generated as in :code:`set_from_power_spectral_density`
-        (Gaussian, coloured by the full PSD curve; zero outside the curve's
-        frequency range) and transformed to the time domain without applying
-        the [minimum_frequency, maximum_frequency] mask. Use this for
-        time-domain analyses; :code:`set_from_power_spectral_density` stores
-        frequency-domain data whose time series is band-limited.
-
-        Note: the noise contains the full curve between its lowest frequency
-        and the Nyquist frequency, while a time-domain likelihood whose ACF is
-        patched outside [minimum_frequency, maximum_frequency] assumes the
-        patch level there.
+        """ Set the time-domain strain data to a Gaussian noise realisation of
+        the power spectral density, with no frequency mask and no window
+        function.
 
         Parameters
         ==========
@@ -689,6 +678,8 @@ def set_from_power_spectral_density_time_domain(
             The data duration (in s)
         start_time: float
             The GPS start-time of the data
+        random_state: numpy.random.Generator, int, optional
+            Random number generator or seed.
         """
         self._times_and_frequencies = CoupledTimeAndFrequencySeries(duration=duration,
                                                                     sampling_frequency=sampling_frequency,
@@ -710,56 +701,47 @@ def downsample(
             self, sampling_frequency, preserve_time=None, minimum_frequency=None,
             maximum_frequency=None, anti_aliasing="fft", trim=0.25, remove_mean=True,
             decimate_kwargs=None, start_time=None, duration=None):
-        """ Downsample the time-domain strain (the :code:`ringdown` package's
-        :code:`Data.condition`).
-
-        Supply a stretch of data LONGER than the segment you want to analyse,
-        then crop (with :code:`start_time` and :code:`duration`, or afterwards).
-        Any filtering affects samples near the ends of the series, and with the
-        default :code:`trim=0.25` only the middle half of the input is kept.
-
-        Steps
-        =====
-        1. If :code:`preserve_time` is given, move the series by fewer than
-           factor samples so that the sample nearest that time survives the
-           decimation (cyclic roll if trim > 0, as in ringdown, whose wrapped
-           samples are then trimmed; otherwise the first samples are dropped).
-        2. Optional Butterworth filter (order 4, applied forwards and backwards):
-           high-pass if only minimum_frequency is given, low-pass if only
-           maximum_frequency, band-pass if both. Off by default.
-        3. Anti-aliasing and decimation by the integer factor
-           (current / new sampling frequency):
-
-           - "fft" (default; ringdown's digital_filter=True): multiply by a Tukey
-             window with alpha=trim, FFT, set all frequencies above the new
-             Nyquist frequency to zero, inverse FFT, keep every factor-th sample.
-           - "decimate" (ringdown's digital_filter=False):
-             :code:`scipy.signal.decimate(..., zero_phase=True, **decimate_kwargs)`.
-
-        4. Remove the fraction :code:`trim` of samples from each end (this
-           removes the tapered part of the window).
-        5. Subtract the mean if :code:`remove_mean`.
-        6. Crop to [start_time, start_time + duration) if given.
+        """ Condition and downsample the time-domain strain data.
+
+        Steps:
+
+        1. If `preserve_time` is given, shift the series by fewer than
+           `factor` samples (factor = current / new sampling frequency) so
+           that the sample nearest `preserve_time` is kept.
+        2. If `minimum_frequency` and/or `maximum_frequency` are given, apply
+           an order-4 Butterworth high-, low- or band-pass filter forwards
+           and backwards.
+        3. Anti-aliasing and decimation: with `anti_aliasing="fft"`, multiply
+           by a Tukey window with alpha = `trim`, set all frequencies above the
+           new Nyquist frequency to zero and keep every factor-th sample; with
+           `anti_aliasing="decimate"`, use :code:`scipy.signal.decimate`.
+        4. Keep [`start_time`, `start_time` + `duration`) if given (it must lie
+           inside the data without a fraction `trim` at each end), otherwise
+           remove a fraction `trim` of the samples at each end.
+        5. Subtract the mean if `remove_mean`.
 
         Parameters
         ==========
         sampling_frequency: float
-            New sampling frequency; must divide the current one.
+            New sampling frequency (Hz); must divide the current one.
         preserve_time: float, optional
-            GPS time whose nearest sample must be kept.
-        minimum_frequency, maximum_frequency: float, optional
-            Butterworth filter corners (Hz). None (default) for no filter.
+            GPS time whose nearest sample is kept.
+        minimum_frequency: float, optional
+            High-pass corner frequency of the Butterworth filter (Hz).
+        maximum_frequency: float, optional
+            Low-pass corner frequency of the Butterworth filter (Hz).
         anti_aliasing: str
             "fft" (default) or "decimate".
         trim: float
-            Fraction removed from each end after downsampling (default 0.25).
+            Fraction of the data at each end that is removed (default 0.25).
         remove_mean: bool
             Subtract the mean of the result (default True).
         decimate_kwargs: dict, optional
-            Passed to scipy.signal.decimate when anti_aliasing="decimate".
-        start_time, duration: float, optional
-            Crop the result to this segment; a ValueError is raised if it does
-            not lie inside the downsampled, trimmed data.
+            Keyword arguments of :code:`scipy.signal.decimate`.
+        start_time: float, optional
+            GPS start time of the segment to keep (s).
+        duration: float, optional
+            Duration of the segment to keep (s).
         """
         from scipy import signal
         from scipy.signal.windows import tukey
@@ -773,11 +755,6 @@ def downsample(
             raise ValueError(
                 f"Sampling frequency {sampling_frequency:g} Hz does not divide the current "
                 f"{original_sampling_frequency:g} Hz")
-        logger.info(
-            f"Downsampling {times[0]:.6f} - {times[-1] + 1 / original_sampling_frequency:.6f} "
-            f"from {original_sampling_frequency:g} to {sampling_frequency:g} Hz "
-            f"(anti_aliasing={anti_aliasing}, trim={trim}); supply data longer than the "
-            "analysis segment")
 
         if preserve_time is not None:
             if not times[0] <= preserve_time <= times[-1]:
@@ -800,8 +777,6 @@ def downsample(
             else:
                 b, a = signal.butter(4, (minimum_frequency / nyquist_frequency,
                                          maximum_frequency / nyquist_frequency), btype='bandpass')
-            logger.info(f"Butterworth filter (order 4, zero phase): minimum_frequency="
-                        f"{minimum_frequency}, maximum_frequency={maximum_frequency}")
             strain = signal.filtfilt(b, a, strain)
 
         if factor > 1:
@@ -818,35 +793,28 @@ def downsample(
             times = times[::factor]
 
         number_of_samples = len(strain)
-        first = int(round(trim * number_of_samples))
-        last = int(round((1 - trim) * number_of_samples))
+        if start_time is None and duration is None:
+            first = int(round(trim * number_of_samples))
+            last = int(round((1 - trim) * number_of_samples))
+        elif start_time is None or duration is None:
+            raise ValueError("Give both start_time and duration")
+        else:
+            data_duration = number_of_samples / sampling_frequency
+            tolerance = 1 / sampling_frequency
+            if (start_time < times[0] + trim * data_duration - tolerance
+                    or start_time + duration > times[0] + (1 - trim) * data_duration + tolerance):
+                raise ValueError(
+                    f"The segment {start_time:.6f} - {start_time + duration:.6f} is not inside "
+                    f"the part of the data kept after trimming a fraction {trim} at each end")
+            first = int(round((start_time - times[0]) * sampling_frequency))
+            last = first + int(round(duration * sampling_frequency))
         strain, times = strain[first:last], times[first:last]
-        if trim > 0:
-            logger.info(f"Trimmed {first / sampling_frequency:g} s from each end")
         if remove_mean:
             strain = strain - np.mean(strain)
 
-        if start_time is not None or duration is not None:
-            if start_time is None or duration is None:
-                raise ValueError("Give both start_time and duration to crop")
-            first = int(round((start_time - times[0]) * sampling_frequency))
-            number_of_samples = int(round(duration * sampling_frequency))
-            if first < 0 or first + number_of_samples > len(strain):
-                raise ValueError(
-                    f"Requested segment [{start_time}, {start_time + duration}) is not inside the "
-                    f"downsampled data [{times[0]}, {times[-1] + 1 / sampling_frequency}); "
-                    "supply a longer stretch of data")
-            if abs(times[first] - start_time) > 1e-6 / sampling_frequency:
-                logger.info(f"Segment starts at the nearest sample, {times[first]:.6f} "
-                            f"(requested {start_time:.6f})")
-            strain = strain[first:first + number_of_samples]
-            times = times[first:first + number_of_samples]
-
         self.set_from_time_domain_strain(
             strain, sampling_frequency=sampling_frequency,
             duration=len(strain) / sampling_frequency, start_time=times[0])
-        logger.info(f"Downsampled data: {times[0]:.6f} - {times[-1] + 1 / sampling_frequency:.6f} "
-                    f"at {sampling_frequency:g} Hz")
 
     def set_from_zero_noise(self, sampling_frequency, duration, start_time=0):
         """ Set the `frequency_domain_strain` to zero noise
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index 743e774f6..f1fec9634 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -2,59 +2,41 @@
 
 import numpy as np
 
-from ...core.utils import logger
 from ..time_domain_utils import PLACEMENT_METHODS, GohbergSemenculInverse
 from .base import GravitationalWaveTransient
 
-ANALYSIS_SEGMENTS = ("imr", "inspiral", "post_inspiral")
-
 
 class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
     """ A gravitational-wave transient likelihood evaluated in the time domain.
 
     The noise in each interferometer is a stationary Gaussian process with
     covariance matrix :math:`C_{ij} = \\rho(|i - j|)`, where :math:`\\rho` is
-    the autocovariance function (ACF) stored on the interferometer
-    (:code:`interferometer.autocovariance_function`). For data :math:`d` and a
-    template :math:`h` on the analysed samples of each interferometer
+    the autocovariance function (ACF) of the interferometer. For the strain
+    data :math:`d` and a template :math:`h` in the analysis window of each
+    interferometer
 
     .. math::
 
         \\ln \\mathcal{L} = \\sum_{\\rm ifo} \\left[ d^T C^{-1} h
-        - \\frac{1}{2} h^T C^{-1} h - \\frac{1}{2} d^T C^{-1} d \\right]
-
-    :code:`log_likelihood_ratio` returns the first two terms, and
-    :code:`noise_log_likelihood` the last. :math:`C^{-1}` is applied with its
-    Gohberg-Semencul representation (computed once per interferometer), and
-    :math:`d^T C^{-1}` and :math:`d^T C^{-1} d` are computed once.
-
-    The waveform generator must have a time-domain source model that returns
-    the polarizations on its own sample grid together with an 'epoch' (the
-    time of the first sample relative to the model's merger), e.g.
-    :code:`bilby.gw.source.lal_binary_black_hole_time_domain`. The template is
-    projected onto each interferometer and placed so that the model's merger
-    arrives at :code:`geocent_time` plus the time delay from the geocenter.
-    Template samples outside the analysed samples are dropped; nothing wraps
-    around.
-
-    The analysed samples of each interferometer are either all of its data
-    ("imr"), or the samples before / after a cut time ("inspiral" /
-    "post_inspiral"). The cut time is fixed once from
-    :code:`cut_reference_parameters`:
-    :math:`t_{\\rm cut} = t_c^{\\rm ref} + \\Delta t_{\\rm ifo}(\\alpha^{\\rm ref},
-    \\delta^{\\rm ref}) + \\tau_{\\rm cut}`. The "post_inspiral" segment starts at
-    the first sample after :math:`t_{\\rm cut}` and the "inspiral" segment ends
-    just before it, so the two are complementary.
+        - \\frac{1}{2} h^T C^{-1} h - \\frac{1}{2} d^T C^{-1} d \\right].
+
+    :code:`log_likelihood_ratio` returns the first two terms and
+    :code:`noise_log_likelihood` the last. :math:`C^{-1}` is applied with the
+    Gohberg-Semencul vectors stored on each interferometer.
+
+    The template is projected onto each interferometer and placed so that the
+    model's t=0 arrives at geocent_time plus the time delay from the
+    geocenter. Template samples outside the analysis window are dropped.
 
     Parameters
     ==========
     interferometers: list, bilby.gw.detector.InterferometerList
-        A list of :code:`bilby.gw.detector.Interferometer` instances, with
-        time-domain strain data and an autocovariance function set (e.g. with
-        :code:`set_autocovariance_function_from_power_spectral_density` or by
-        assigning a :code:`bilby.gw.detector.AutoCovarianceFunction`).
+        A list of :code:`bilby.gw.detector.Interferometer` instances, each with
+        an analysis window, time-domain strain data in that window and an
+        autocovariance function.
     waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
-        A WaveformGenerator with a time-domain source model.
+        A WaveformGenerator with a time-domain source model, e.g.
+        :code:`bilby.gw.source.lal_binary_black_hole_time_domain`.
     distance_marginalization: bool, optional
         If true, marginalize over distance in the likelihood. This uses a
         look up table calculated at run time. The distance prior is set to be a
@@ -74,26 +56,11 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
     time_reference: str, optional
         Name of the reference for the sampled time parameter, as in
         :code:`GravitationalWaveTransient`.
-    analysis_segment: str, optional
-        "imr" (default; all the data), "inspiral" or "post_inspiral".
-    segment_cut_time: float, optional
-        :math:`\\tau_{\\rm cut}` in seconds, the cut time relative to the
-        arrival of the reference merger at each interferometer. Required for
-        "inspiral" and "post_inspiral".
-    cut_reference_parameters: dict, optional
-        Dictionary with 'ra', 'dec' and 'geocent_time' (or the parameters of
-        :code:`reference_frame` / :code:`time_reference`) fixing the cut time.
-        Required for "inspiral" and "post_inspiral".
-    segment_duration: float, optional
-        Length (s) of the "inspiral" / "post_inspiral" segment, ending / starting
-        at the cut. Default: up to the start / end of the data.
     placement: str, optional
-        How the template is placed on the data samples, see
-        :code:`bilby.gw.time_domain_utils.place_time_domain_signal`:
-        "nearest" (default), "subsample" or "fd_shift". With "subsample",
-        :code:`geocent_time` is the time of the peak of
-        :math:`h_+^2 + h_\\times^2` rather than the model's merger time (t=0).
-        Use the same placement for injection and analysis.
+        How the template is placed on the data samples: "nearest" (default),
+        "subsample" or "fd_shift"; see
+        :code:`bilby.gw.time_domain_utils.place_time_domain_signal`. Use the
+        same placement for injection and analysis.
     time_marginalization, phase_marginalization, calibration_marginalization: bool
         Not implemented for this likelihood; must be False.
 
@@ -109,10 +76,8 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
     def __init__(
             self, interferometers, waveform_generator, distance_marginalization=False,
             priors=None, distance_marginalization_lookup_table=None, reference_frame="sky",
-            time_reference="geocenter", analysis_segment="imr", segment_cut_time=None,
-            cut_reference_parameters=None, segment_duration=None, placement="nearest",
-            time_marginalization=False, phase_marginalization=False,
-            calibration_marginalization=False,
+            time_reference="geocenter", placement="nearest", time_marginalization=False,
+            phase_marginalization=False, calibration_marginalization=False,
     ):
         for name, value in dict(
                 time_marginalization=time_marginalization,
@@ -125,9 +90,6 @@ def __init__(
             raise ValueError(
                 f"{self.__class__.__name__} needs a waveform generator with a "
                 "time_domain_source_model, e.g. bilby.gw.source.lal_binary_black_hole_time_domain")
-        if analysis_segment not in ANALYSIS_SEGMENTS:
-            raise ValueError(
-                f"analysis_segment must be one of {ANALYSIS_SEGMENTS}, not {analysis_segment!r}")
         if placement not in PLACEMENT_METHODS:
             raise ValueError(
                 f"placement must be one of {PLACEMENT_METHODS}, not {placement!r}")
@@ -145,132 +107,48 @@ def __init__(
             reference_frame=reference_frame,
             time_reference=time_reference,
         )
-        self.analysis_segment = analysis_segment
-        self.segment_cut_time = segment_cut_time
-        self.cut_reference_parameters = cut_reference_parameters
-        self.segment_duration = segment_duration
         self.placement = placement
-
-        self._check_interferometers()
-        self._setup_analysis_windows()
         self._setup_noise_model()
 
     def __repr__(self):
         return self.__class__.__name__ + (
             '(interferometers={},\n\twaveform_generator={},\n\tdistance_marginalization={}, '
-            'priors={}, analysis_segment={}, segment_cut_time={}, segment_duration={}, '
-            'placement={})'.format(
+            'priors={}, placement={})'.format(
                 self.interferometers, self.waveform_generator, self.distance_marginalization,
-                self.priors, self.analysis_segment, self.segment_cut_time,
-                self.segment_duration, self.placement))
-
-    # ------------------------------------------------------------------
-    # Set up (done once)
-    # ------------------------------------------------------------------
-    def _check_interferometers(self):
-        for interferometer in self.interferometers:
-            if interferometer.autocovariance_function is None:
-                raise ValueError(
-                    f"{interferometer.name}: no autocovariance_function set; use e.g. "
-                    "interferometer.set_autocovariance_function_from_power_spectral_density")
-            acf_sampling_frequency = interferometer.autocovariance_function.sampling_frequency
-            if not np.isclose(acf_sampling_frequency, interferometer.sampling_frequency,
-                              rtol=1e-9, atol=0):
-                raise ValueError(
-                    f"{interferometer.name}: autocovariance function sampling frequency "
-                    f"{acf_sampling_frequency:g} Hz differs from the data's "
-                    f"{interferometer.sampling_frequency:g} Hz")
-
-    def _setup_analysis_windows(self):
-        """ Indices of the analysed samples of each interferometer. """
-        if self.analysis_segment == "imr":
-            if self.segment_duration is not None:
-                logger.warning("segment_duration is ignored for analysis_segment='imr' "
-                               "(all the data are analysed)")
-            if self.segment_cut_time is not None:
-                logger.warning("segment_cut_time is ignored for analysis_segment='imr'")
-            reference = None
-        else:
-            if self.segment_cut_time is None or self.cut_reference_parameters is None:
-                raise ValueError(
-                    f"analysis_segment={self.analysis_segment!r} needs segment_cut_time and "
-                    "cut_reference_parameters")
-            reference = self.get_sky_frame_parameters(dict(self.cut_reference_parameters))
-
-        self.analysis_windows = dict()
-        for interferometer in self.interferometers:
-            number_of_data_samples = len(interferometer.time_array)
-            sampling_frequency = interferometer.sampling_frequency
-            start_time = interferometer.strain_data.start_time
-            if reference is None:
-                start_index, end_index, cut_time = 0, number_of_data_samples, None
-            else:
-                delay = interferometer.time_delay_from_geocenter(
-                    reference["ra"], reference["dec"], reference["geocent_time"])
-                # subtract the two GPS times first
-                cut_offset = (reference["geocent_time"] - start_time) + delay + self.segment_cut_time
-                cut_time = start_time + cut_offset
-                # first sample strictly after the cut: inspiral and post_inspiral are complementary
-                cut_index = int(np.floor(cut_offset * sampling_frequency)) + 1
-                length = (None if self.segment_duration is None
-                          else int(round(self.segment_duration * sampling_frequency)))
-                if self.analysis_segment == "inspiral":
-                    end_index = cut_index
-                    start_index = 0 if length is None else cut_index - length
-                else:
-                    start_index = cut_index
-                    end_index = number_of_data_samples if length is None else cut_index + length
-                if start_index < 0 or end_index > number_of_data_samples or end_index - start_index < 2:
-                    raise ValueError(
-                        f"{interferometer.name}: {self.analysis_segment} segment "
-                        f"[{start_index}:{end_index}] is outside the data [0:{number_of_data_samples}] "
-                        f"(cut time {cut_time:.6f})")
-            self.analysis_windows[interferometer.name] = dict(
-                start_index=int(start_index),
-                end_index=int(end_index),
-                number_of_samples=int(end_index - start_index),
-                start_time=float(start_time + start_index / sampling_frequency),
-                end_time=float(start_time + (end_index - 1) / sampling_frequency),
-                cut_time=None if cut_time is None else float(cut_time),
-            )
-            window = self.analysis_windows[interferometer.name]
-            logger.info(
-                f"{interferometer.name} [{self.analysis_segment}]: samples "
-                f"[{window['start_index']}:{window['end_index']}] (N = {window['number_of_samples']}), "
-                f"GPS {window['start_time']:.6f} - {window['end_time']:.6f}"
-                + ("" if cut_time is None else f", cut at {cut_time:.6f}"))
+                self.priors, self.placement))
 
     def _setup_noise_model(self):
-        """ Gohberg-Semencul vectors, d^T C^-1 and d^T C^-1 d for each interferometer. """
+        """ Inverse covariance operator, d^T C^-1 and d^T C^-1 d for each
+        interferometer. """
         self._inverse_covariance = dict()
         self._data_times_inverse_covariance = dict()
         self._data_inverse_covariance_data = dict()
         for interferometer in self.interferometers:
-            window = self.analysis_windows[interferometer.name]
             acf = interferometer.autocovariance_function
-            inverse_covariance = GohbergSemenculInverse(
-                *acf.gohberg_semencul_vectors(window["number_of_samples"]))
-            data = self._analysed_data(interferometer)
+            if acf is None:
+                raise ValueError(f"{interferometer.name}: no autocovariance_function set")
+            if not np.isclose(acf.sampling_frequency, interferometer.sampling_frequency,
+                              rtol=1e-9, atol=0):
+                raise ValueError(
+                    f"{interferometer.name}: autocovariance function sampling frequency "
+                    f"{acf.sampling_frequency:g} Hz differs from the data's "
+                    f"{interferometer.sampling_frequency:g} Hz")
+            data = np.asarray(interferometer.time_domain_strain, dtype=float)
+            x, y = interferometer.gohberg_semencul_vectors
+            if len(x) != len(data):
+                raise ValueError(
+                    f"{interferometer.name}: the data have {len(data)} samples but the analysis "
+                    f"window has {len(x)}; crop the data to the analysis window")
+            inverse_covariance = GohbergSemenculInverse(x, y)
             data_times_inverse_covariance = inverse_covariance(data)
             self._inverse_covariance[interferometer.name] = inverse_covariance
             self._data_times_inverse_covariance[interferometer.name] = data_times_inverse_covariance
             self._data_inverse_covariance_data[interferometer.name] = float(
                 np.dot(data_times_inverse_covariance, data))
-            logger.info(
-                f"{interferometer.name}: ACF period {acf.duration:g} s = "
-                f"{acf.number_of_samples / window['number_of_samples']:.1f} x analysed segment")
-
-    def _analysed_data(self, interferometer):
-        window = self.analysis_windows[interferometer.name]
-        return np.asarray(interferometer.time_domain_strain, dtype=float)[
-            window["start_index"]:window["end_index"]]
 
-    # ------------------------------------------------------------------
-    # Likelihood
-    # ------------------------------------------------------------------
     def _compute_full_waveform(self, signal_polarizations, interferometer, parameters):
         """ Project the time-domain polarizations onto the interferometer and
-        place them on its analysed samples.
+        place them on the samples of its analysis window.
 
         Parameters
         ==========
@@ -281,16 +159,14 @@ def _compute_full_waveform(self, signal_polarizations, interferometer, parameter
 
         Returns
         =======
-        array_like: The template on the analysed samples.
+        array_like: The template on the data samples.
         """
-        window = self.analysis_windows[interferometer.name]
         return interferometer.get_time_domain_detector_response(
-            signal_polarizations, parameters, start_index=window["start_index"],
-            number_of_samples=window["number_of_samples"], placement=self.placement)
+            signal_polarizations, parameters, placement=self.placement)
 
     def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array=True, parameters):
         """ Compute :math:`d^T C^{-1} h`, :math:`h^T C^{-1} h` and the matched
-        filter SNR on the analysed samples of one interferometer.
+        filter SNR in the analysis window of one interferometer.
 
         Parameters
         ----------
@@ -411,15 +287,5 @@ def _rescale_signal(self, signal, new_distance):
     @property
     def meta_data(self):
         meta_data = super(TimeDomainGravitationalWaveTransient, self).meta_data
-        meta_data.update(
-            likelihood_domain=self.likelihood_domain,
-            analysis_segment=self.analysis_segment,
-            segment_cut_time=self.segment_cut_time,
-            cut_reference_parameters=(
-                None if self.cut_reference_parameters is None
-                else dict(self.cut_reference_parameters)),
-            segment_duration=self.segment_duration,
-            placement=self.placement,
-            analysis_windows=copy.deepcopy(self.analysis_windows),
-        )
+        meta_data.update(likelihood_domain=self.likelihood_domain, placement=self.placement)
         return meta_data
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 7b73afcd8..24211c342 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -235,64 +235,59 @@ def align_peak_to_sample(waveform_polarizations, pad=32):
     return aligned, int(round(peak)) + pad
 
 
-def _copy_into_segment(signal, offset, start_index, number_of_samples):
+def _copy_into_segment(signal, offset, number_of_samples):
     """ Put signal sample k at data index offset + k and return data indices
-    [start_index, start_index + number_of_samples); zero elsewhere. """
+    [0, number_of_samples); zero elsewhere. """
     segment = np.zeros(number_of_samples)
-    first = max(0, start_index - offset)
-    last = min(len(signal), start_index + number_of_samples - offset)
+    first = max(0, -offset)
+    last = min(len(signal), number_of_samples - offset)
     if last > first:
-        segment[offset + first - start_index:offset + last - start_index] = signal[first:last]
+        segment[offset + first:offset + last] = signal[first:last]
     return segment
 
 
-def place_time_domain_signal(signal, merger_index, arrival_index, start_index,
-                             number_of_samples, placement="nearest"):
+def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samples,
+                             placement="nearest"):
     """ Place a time-domain signal, generated on its own grid with the data's
-    sample spacing, into a segment of data.
+    sample spacing, on the data samples.
 
-    Waveform sample k has time (k - merger_index) * dt relative to the
-    model's merger (its t=0). In data-index units the merger arrives at
-    :code:`arrival_index` (fractional). Samples falling outside the segment are
-    dropped; segment samples the signal does not reach are zero. Nothing wraps.
+    Waveform sample k has time (k - merger_index) / f_s relative to the
+    model's t=0, which arrives at data index `arrival_index`. Waveform samples
+    outside the data are dropped and data samples the waveform does not reach
+    are zero.
 
     Parameters
     ==========
     signal: array_like
-        Projected (detector) signal on its own grid.
+        Detector signal on its own grid.
     merger_index: float
-        Index of the model's t=0 in :code:`signal` (-epoch * sampling_frequency).
+        Index of the model's t=0 in `signal`.
     arrival_index: float
-        Arrival time of t=0 at the detector, in samples from the first data sample.
-    start_index: int
-        First data index of the analysis segment.
+        Index in the data at which the model's t=0 arrives.
     number_of_samples: int
-        Length of the analysis segment.
+        Number of data samples.
     placement: str
-        - "nearest": t=0 of the signal is put on the data sample nearest to the
-          arrival time; both indices are rounded separately, as in
-          LALInference and the :code:`ringdown` package (default).
-        - "subsample": as "nearest", with :code:`merger_index` the integer peak
-          index from :code:`align_peak_to_sample`. The arrival time then refers
-          to the peak of :math:`h_+^2 + h_\\times^2`, not to the model's t=0
-          (the :code:`ringdown` package's :code:`manual_epoch` convention).
-        - "fd_shift": exact delay; whole samples by index, the remaining
-          fraction with a Fourier phase shift on a zero-padded copy, applied
-          before cropping to the segment.
+        - "nearest" (default): `merger_index` and `arrival_index` are each
+          rounded to the nearest sample.
+        - "subsample": as "nearest", with `merger_index` the peak index
+          returned by :code:`align_peak_to_sample`, so that `arrival_index`
+          refers to the peak of :math:`h_+^2 + h_\\times^2`.
+        - "fd_shift": whole samples are shifted by index and the remaining
+          fraction with a Fourier phase shift of a zero-padded copy.
 
     Returns
     =======
-    array_like: The signal on the segment's samples.
+    array_like: The signal on the data samples.
     """
     if placement in ("nearest", "subsample"):
         offset = round(arrival_index) - round(merger_index)
-        return _copy_into_segment(signal, offset, start_index, number_of_samples)
+        return _copy_into_segment(signal, offset, number_of_samples)
     elif placement == "fd_shift":
         position = arrival_index - merger_index
         offset = int(np.floor(position + 0.5))
         fraction = position - offset
         pad = 32
         shifted = fractional_time_shift(signal, fraction, pad=pad)
-        return _copy_into_segment(shifted, offset - pad, start_index, number_of_samples)
+        return _copy_into_segment(shifted, offset - pad, number_of_samples)
     else:
         raise ValueError(f"placement must be one of {PLACEMENT_METHODS}, not {placement!r}")
diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
index d62d72384..e7a87f43a 100644
--- a/examples/gw_examples/data_examples/GW150914_time_domain.py
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -4,9 +4,8 @@
 
 This is the GW150914.py analysis done in the time domain:
 
-- the strain is downloaded as a time series, longer than the analysis segment,
-  stored with no window, then downsampled to 2048 Hz (anti-aliasing as in the
-  ringdown package) and cropped to the 4 s analysis segment;
+- the strain is downloaded as a time series covering the 4 s analysis window
+  and 2 s on each side, downsampled to 2048 Hz and cropped to the window;
 - the noise model of each detector is an autocovariance function (ACF)
   computed from a PSD read with its frequency array from an HDF5 file;
 - the likelihood is bilby.gw.likelihood.TimeDomainGravitationalWaveTransient,
@@ -42,10 +41,10 @@
 end_time = trigger_time + post_trigger_duration
 start_time = end_time - duration
 
-# Data downloaded on each side of the analysis segment. With the default
-# trim=0.25 the downsampling keeps the middle half of the downloaded data, so
-# this must be larger than duration / 2.
-padding = 8
+# Data downloaded on each side of the analysis window. The downsampling
+# removes duration / 2 of data on each side of the window (trim=0.25), so this
+# must be at least duration / 2.
+padding = duration / 2
 
 # File with the PSDs and their frequency arrays (psds/h1_psd/frequency,
 # psds/h1_psd/spectrum, ...). GWTC PESummary release files are also read, with
@@ -58,11 +57,10 @@
 for det in detectors:
     logger.info("Downloading analysis data for ifo {}".format(det))
     ifo = bilby.gw.detector.get_empty_interferometer(det)
+    ifo.set_analysis_window(start_time=start_time, duration=duration)
     data = TimeSeries.fetch_open_data(det, start_time - padding, end_time + padding)
     ifo.strain_data.set_from_gwpy_timeseries(data)
-    ifo.downsample_strain_data(
-        sampling_frequency, start_time=start_time, duration=duration
-    )
+    ifo.downsample_strain_data(sampling_frequency)
 
     frequency_array, psd_array = psds[det]
     ifo.power_spectral_density = bilby.gw.detector.PowerSpectralDensity(
@@ -71,9 +69,9 @@
     ifo.maximum_frequency = maximum_frequency
     ifo.minimum_frequency = minimum_frequency
 
-    # The PSD is not interpolated: the ACF has period 1 / (frequency spacing)
-    # (8 s here, twice the analysis segment). Outside [minimum_frequency,
-    # maximum_frequency] the PSD is set to a large value.
+    # The ACF lasts 1 / (frequency spacing of the PSD), 8 s here, twice the
+    # analysis segment. Outside [minimum_frequency, maximum_frequency] the PSD
+    # is set to fill_value (default 1e4) times its maximum inside the band.
     ifo.autocovariance_function = (
         bilby.gw.detector.AutoCovarianceFunction.from_power_spectral_density_array(
             frequency_array,
@@ -81,7 +79,6 @@
             minimum_frequency=minimum_frequency,
             maximum_frequency=maximum_frequency,
             sampling_frequency=sampling_frequency,
-            source=f"{psd_file} {det}",
         )
     )
     ifo_list.append(ifo)
@@ -120,9 +117,6 @@
 
 # In this step, we define the likelihood. Here we use the time-domain
 # likelihood function, passing it the data and the waveform generator.
-# All of the 4 s segment is analysed (analysis_segment="imr"); use
-# analysis_segment="inspiral" or "post_inspiral" with segment_cut_time and
-# cut_reference_parameters to analyse the data before / after a cut.
 likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
     ifo_list,
     waveform_generator,
diff --git a/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py b/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
index de0eaafdc..8758698b6 100644
--- a/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
+++ b/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
@@ -94,16 +94,19 @@
     interferometer.minimum_frequency = 40
     interferometer.maximum_frequency = 896
 
-# Time-domain noise drawn from the design PSD curves (no mask, no window).
+# The analysis window: here the whole data segment ("imr"). For an inspiral or
+# post-inspiral analysis, use analysis_segment="inspiral" / "post_inspiral"
+# with segment_cut_time and cut_reference_parameters.
+interferometers.set_analysis_windows(duration=duration, start_time=start_time)
+
+# Time-domain noise drawn from the PSD curves (no mask, no window function).
 interferometers.set_strain_data_from_power_spectral_densities_time_domain(
-    sampling_frequency=sampling_frequency, duration=duration, start_time=start_time
+    sampling_frequency=sampling_frequency
 )
 
-# Autocovariance function of each detector from its PSD curve. Its period is
-# duration_factor (default 16) x analysis_duration.
-interferometers.set_autocovariance_functions_from_power_spectral_densities(
-    analysis_duration=duration
-)
+# Autocovariance function of each detector from its PSD curve. Its duration
+# is duration_factor (default 16) times the analysis window.
+interferometers.set_autocovariance_functions_from_power_spectral_densities()
 
 # Add the signal to the time series.
 interferometers.inject_signal_time_domain(
@@ -148,8 +151,7 @@
 
 
 # Initialise the time-domain likelihood by passing in the interferometer data
-# (IFOs) and the waveform generator. All the data are analysed
-# (analysis_segment="imr").
+# (IFOs) and the waveform generator.
 likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
     interferometers=interferometers,
     waveform_generator=waveform_generator,
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
index 5c9b3079d..50811c0fe 100644
--- a/test/gw/likelihood/time_domain_test.py
+++ b/test/gw/likelihood/time_domain_test.py
@@ -36,19 +36,29 @@ def waveform_generator(source_model=bilby.gw.source.lal_binary_black_hole_time_d
                                 reference_frequency=20.0, minimum_frequency=20.0))
 
 
-def interferometers(noise="zero", acf=True):
+def interferometers(noise="zero", acf=True, analysis_segment="imr", duration=DURATION,
+                    segment_cut_time=-0.01):
     ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+    for ifo in ifos:
+        ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
+    ifos.set_analysis_windows(
+        duration=duration, start_time=START_TIME, analysis_segment=analysis_segment,
+        segment_cut_time=segment_cut_time, cut_reference_parameters=INJECTION)
     if noise == "zero":
-        ifos.set_strain_data_from_zero_noise(SAMPLING_FREQUENCY, DURATION, START_TIME)
+        ifos.set_strain_data_from_zero_noise_time_domain(SAMPLING_FREQUENCY)
     else:
         ifos.set_strain_data_from_power_spectral_densities_time_domain(
-            SAMPLING_FREQUENCY, DURATION, START_TIME, random_state=3)
+            SAMPLING_FREQUENCY, random_state=3)
     if acf:
-        ifos.set_autocovariance_functions_from_power_spectral_densities(
-            analysis_duration=DURATION, minimum_frequency=20, maximum_frequency=448)
+        ifos.set_autocovariance_functions_from_power_spectral_densities()
     return ifos
 
 
+SEGMENTS = dict(imr=dict(analysis_segment="imr"),
+                inspiral=dict(analysis_segment="inspiral", duration=1.0),
+                post_inspiral=dict(analysis_segment="post_inspiral", duration=0.5))
+
+
 class TestGohbergSemencul(unittest.TestCase):
     def test_inverse_matches_dense_solve(self):
         rng = np.random.default_rng(1)
@@ -71,7 +81,7 @@ def setUp(self):
     def test_fd_shift_whole_sample_equals_nearest(self):
         for placement in ["nearest", "fd_shift"]:
             placed = place_time_domain_signal(
-                self.signal, merger_index=100, arrival_index=150, start_index=20,
+                self.signal, merger_index=100, arrival_index=150,
                 number_of_samples=300, placement=placement)
             if placement == "nearest":
                 nearest = placed
@@ -80,7 +90,7 @@ def test_fd_shift_whole_sample_equals_nearest(self):
     def test_fd_shift_fraction_is_exact_for_band_limited_signal(self):
         delay = 50.3
         placed = place_time_domain_signal(
-            self.signal, merger_index=100, arrival_index=100 + delay, start_index=0,
+            self.signal, merger_index=100, arrival_index=100 + delay,
             number_of_samples=400, placement="fd_shift")
         times = np.arange(400) - delay
         expected = np.exp(-0.5 * ((times - 100) / 6.0) ** 2) * np.cos(0.4 * times)
@@ -88,7 +98,7 @@ def test_fd_shift_fraction_is_exact_for_band_limited_signal(self):
 
     def test_nothing_wraps(self):
         placed = place_time_domain_signal(
-            self.signal, merger_index=100, arrival_index=10, start_index=0,
+            self.signal, merger_index=100, arrival_index=10,
             number_of_samples=256, placement="nearest")
         np.testing.assert_array_equal(placed[166:], 0)
         np.testing.assert_allclose(placed[:166], self.signal[90:])
@@ -109,10 +119,28 @@ def test_sampling_frequency_from_grid_and_length(self):
         self.assertEqual(acf.number_of_samples, 8192)
         self.assertAlmostEqual(acf.duration, 8)
 
-    def test_sampling_frequency_mismatch_raises(self):
-        with self.assertRaises(ValueError):
-            AutoCovarianceFunction.from_power_spectral_density_array(
+    def test_sampling_frequency_mismatch_warns(self):
+        with self.assertLogs("bilby", level="WARNING"):
+            acf = AutoCovarianceFunction.from_power_spectral_density_array(
                 self.frequencies, self.psd, 20, 400, sampling_frequency=2048)
+        self.assertEqual(acf.sampling_frequency, 1024)
+
+    def test_grid_extended_to_zero_frequency(self):
+        full = AutoCovarianceFunction.from_power_spectral_density_array(
+            self.frequencies, self.psd, 20, 400)
+        keep = self.frequencies >= 5
+        cut = AutoCovarianceFunction.from_power_spectral_density_array(
+            self.frequencies[keep], self.psd[keep], 20, 400)
+        np.testing.assert_allclose(cut.acf_array, full.acf_array, rtol=1e-12)
+
+    def test_patch_level(self):
+        fill_value = 100
+        acf = AutoCovarianceFunction.from_power_spectral_density_array(
+            self.frequencies, self.psd, 20, 400, fill_value=fill_value)
+        patched = 2 * np.fft.rfft(acf.acf_array).real / acf.sampling_frequency
+        band = (self.frequencies >= 20) & (self.frequencies <= 400)
+        np.testing.assert_allclose(patched[band], self.psd[band], rtol=1e-8)
+        np.testing.assert_allclose(patched[~band], fill_value * np.max(self.psd[band]), rtol=1e-8)
 
     def test_window_longer_than_acf_raises(self):
         acf = AutoCovarianceFunction.from_power_spectral_density_array(
@@ -128,74 +156,57 @@ def test_save_and_read(self):
             filename = os.path.join(directory, "acf.dat")
             acf.save(filename)
             new = AutoCovarianceFunction.from_file(filename)
+            single = os.path.join(directory, "acf_single.dat")
+            np.savetxt(single, acf.acf_array)
+            from_single = AutoCovarianceFunction.from_file(single, sampling_frequency=1024)
         finally:
             shutil.rmtree(directory)
         self.assertAlmostEqual(new.sampling_frequency, acf.sampling_frequency)
         np.testing.assert_allclose(new.acf_array, acf.acf_array, rtol=1e-12)
+        np.testing.assert_allclose(from_single.acf_array, acf.acf_array, rtol=1e-12)
 
 
 class TestTimeDomainLikelihood(unittest.TestCase):
     def test_zero_noise_log_likelihood_ratio_is_half_snr_squared(self):
-        cut = dict(segment_cut_time=-0.01, cut_reference_parameters=INJECTION)
         for placement in ["nearest", "subsample", "fd_shift"]:
-            ifos = interferometers()
-            generator = waveform_generator()
-            ifos.inject_signal_time_domain(
-                parameters=INJECTION, waveform_generator=generator, placement=placement)
-            for segment in ["imr", "inspiral", "post_inspiral"]:
+            for segment, kwargs in SEGMENTS.items():
                 with self.subTest(placement=placement, segment=segment):
-                    likelihood = TimeDomainGravitationalWaveTransient(
-                        ifos, generator, analysis_segment=segment, placement=placement,
-                        **({} if segment == "imr" else cut))
-                    polarizations = generator.time_domain_strain(INJECTION)
-                    optimal_snr_squared = sum(
-                        likelihood.calculate_snrs(polarizations, ifo, parameters=INJECTION)
-                        .optimal_snr_squared for ifo in ifos)
+                    ifos = interferometers(**kwargs)
+                    generator = waveform_generator()
+                    ifos.inject_signal_time_domain(
+                        parameters=INJECTION, waveform_generator=generator, placement=placement)
+                    likelihood = TimeDomainGravitationalWaveTransient(ifos, generator, placement=placement)
+                    optimal_snr_squared = sum(ifo.meta_data["optimal_SNR"] ** 2 for ifo in ifos)
                     self.assertGreater(optimal_snr_squared, 10)
                     self.assertAlmostEqual(
                         likelihood.log_likelihood_ratio(INJECTION) / (optimal_snr_squared / 2), 1, 8)
                     self.assertAlmostEqual(
                         likelihood.noise_log_likelihood() / (-optimal_snr_squared / 2), 1, 8)
 
-    def test_inspiral_and_post_inspiral_are_complementary(self):
-        ifos = interferometers()
-        generator = waveform_generator()
-        kwargs = dict(segment_cut_time=0.0, cut_reference_parameters=INJECTION)
-        inspiral = TimeDomainGravitationalWaveTransient(
-            ifos, generator, analysis_segment="inspiral", **kwargs)
-        post_inspiral = TimeDomainGravitationalWaveTransient(
-            ifos, generator, analysis_segment="post_inspiral", **kwargs)
-        for ifo in ifos:
-            first = inspiral.analysis_windows[ifo.name]
-            second = post_inspiral.analysis_windows[ifo.name]
-            self.assertEqual(first["start_index"], 0)
-            self.assertEqual(first["end_index"], second["start_index"])
-            self.assertEqual(second["end_index"], len(ifo.time_array))
-            self.assertLessEqual(ifo.time_array[first["end_index"] - 1], first["cut_time"])
-            self.assertGreater(ifo.time_array[second["start_index"]], first["cut_time"])
-
-    def test_segment_duration(self):
-        ifos = interferometers()
-        likelihood = TimeDomainGravitationalWaveTransient(
-            ifos, waveform_generator(), analysis_segment="post_inspiral",
-            segment_cut_time=0.0, cut_reference_parameters=INJECTION, segment_duration=0.5)
-        for window in likelihood.analysis_windows.values():
-            self.assertEqual(window["number_of_samples"], SAMPLING_FREQUENCY // 2)
+    def test_inspiral_and_post_inspiral_windows(self):
+        inspiral = interferometers(acf=False, **SEGMENTS["inspiral"])
+        post_inspiral = interferometers(acf=False, **SEGMENTS["post_inspiral"])
+        for first, second in zip(inspiral, post_inspiral):
+            cut_time = first.meta_data["analysis_window"]["cut_time"]
+            self.assertAlmostEqual(cut_time, second.meta_data["analysis_window"]["cut_time"])
+            self.assertAlmostEqual(first.strain_data.start_time + first.strain_data.duration, cut_time)
+            self.assertAlmostEqual(second.strain_data.start_time, cut_time)
+            self.assertEqual(len(first.time_domain_strain), SAMPLING_FREQUENCY)
+            self.assertEqual(len(second.time_domain_strain), SAMPLING_FREQUENCY // 2)
+        delay = (inspiral[1].time_delay_from_geocenter(INJECTION["ra"], INJECTION["dec"], INJECTION["geocent_time"])
+                 - inspiral[0].time_delay_from_geocenter(INJECTION["ra"], INJECTION["dec"], INJECTION["geocent_time"]))
+        self.assertAlmostEqual(inspiral[1].strain_data.start_time - inspiral[0].strain_data.start_time, delay, 6)
 
     def test_matches_dense_covariance(self):
-        ifos = interferometers(noise="gaussian")
+        ifos = interferometers(noise="gaussian", **SEGMENTS["post_inspiral"])
         generator = waveform_generator()
         ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
-        likelihood = TimeDomainGravitationalWaveTransient(
-            ifos, generator, analysis_segment="post_inspiral", segment_cut_time=-0.1,
-            cut_reference_parameters=INJECTION)
+        likelihood = TimeDomainGravitationalWaveTransient(ifos, generator)
         parameters = dict(INJECTION, mass_1=37.0)
         expected = 0
         for ifo in ifos:
-            window = likelihood.analysis_windows[ifo.name]
-            covariance = scipy.linalg.toeplitz(
-                ifo.autocovariance_function.acf_array[:window["number_of_samples"]])
-            data = ifo.time_domain_strain[window["start_index"]:window["end_index"]]
+            data = ifo.time_domain_strain
+            covariance = scipy.linalg.toeplitz(ifo.autocovariance_function.acf_array[:len(data)])
             signal = likelihood._compute_full_waveform(
                 generator.time_domain_strain(parameters), ifo, parameters)
             expected += data @ np.linalg.solve(covariance, signal) \
@@ -228,7 +239,7 @@ def test_distance_marginalization(self):
             shutil.rmtree(directory)
 
     def test_snrs_in_post_processing(self):
-        ifos = interferometers()
+        ifos = interferometers(**SEGMENTS["inspiral"])
         generator = waveform_generator()
         ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
         likelihood = TimeDomainGravitationalWaveTransient(ifos, generator)
@@ -238,16 +249,13 @@ def test_snrs_in_post_processing(self):
             self.assertAlmostEqual(sample[f"{ifo.name}_optimal_snr"], ifo.meta_data["optimal_SNR"], 8)
 
     def test_meta_data(self):
-        ifos = interferometers()
-        likelihood = TimeDomainGravitationalWaveTransient(
-            ifos, waveform_generator(), analysis_segment="inspiral", segment_cut_time=0.0,
-            cut_reference_parameters=INJECTION, placement="fd_shift")
+        ifos = interferometers(**SEGMENTS["inspiral"])
+        likelihood = TimeDomainGravitationalWaveTransient(ifos, waveform_generator(), placement="fd_shift")
         meta_data = likelihood.meta_data
         self.assertEqual(meta_data["likelihood_domain"], "time")
-        self.assertEqual(meta_data["analysis_segment"], "inspiral")
         self.assertEqual(meta_data["placement"], "fd_shift")
-        self.assertEqual(set(meta_data["analysis_windows"]), {"H1", "L1"})
         self.assertIn("autocovariance_function", meta_data["interferometers"]["H1"])
+        self.assertEqual(meta_data["interferometers"]["H1"]["analysis_window"]["analysis_segment"], "inspiral")
 
     def test_errors(self):
         generator = waveform_generator()
@@ -261,12 +269,6 @@ def test_errors(self):
         for key in ["time_marginalization", "phase_marginalization", "calibration_marginalization"]:
             with self.assertRaises(NotImplementedError):
                 TimeDomainGravitationalWaveTransient(interferometers(), generator, **{key: True})
-        with self.assertRaises(ValueError):
-            TimeDomainGravitationalWaveTransient(interferometers(), generator, analysis_segment="inspiral")
-        with self.assertRaises(ValueError):
-            TimeDomainGravitationalWaveTransient(
-                interferometers(), generator, analysis_segment="post_inspiral",
-                segment_cut_time=0.0, cut_reference_parameters=INJECTION, segment_duration=5)
         with self.assertRaises(ValueError):
             TimeDomainGravitationalWaveTransient(interferometers(), generator, placement="roll")
         ifos = interferometers()
@@ -274,6 +276,14 @@ def test_errors(self):
             acf_array=ifos[0].autocovariance_function.acf_array, sampling_frequency=2048)
         with self.assertRaises(ValueError):
             TimeDomainGravitationalWaveTransient(ifos, generator)
+        ifo = bilby.gw.detector.get_empty_interferometer("H1")
+        with self.assertRaises(ValueError):
+            ifo.autocovariance_function = AutoCovarianceFunction(np.ones(10), SAMPLING_FREQUENCY)
+        ifos = interferometers()
+        for ifo in ifos:
+            ifo.set_strain_data_from_zero_noise(SAMPLING_FREQUENCY, 2 * DURATION, START_TIME)
+        with self.assertRaises(ValueError):
+            TimeDomainGravitationalWaveTransient(ifos, generator)
 
 
 class TestTimeDomainData(unittest.TestCase):
@@ -296,14 +306,33 @@ def test_injection_adds_to_stored_time_series(self):
             np.testing.assert_allclose(ifo.time_domain_strain, noise[ifo.name] + signal, rtol=0, atol=1e-30)
             self.assertEqual(ifo.meta_data["injection_domain"], "time")
 
-    def test_downsample(self):
+    def test_snrs_recomputed_after_cropping(self):
+        cropped = interferometers(**SEGMENTS["post_inspiral"])
+        cropped.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
+        full = interferometers()
+        full.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
+        snr_full = full[0].meta_data["optimal_SNR"]
+        for ifo, reference in zip(full, cropped):
+            ifo.set_analysis_window(reference.analysis_window["start_time"], reference.analysis_window["duration"])
+        full.crop_strain_data()
+        for ifo, reference in zip(full, cropped):
+            reference.autocovariance_function = ifo.autocovariance_function
+            np.testing.assert_allclose(ifo.time_domain_strain, reference.time_domain_strain, atol=1e-30)
+            self.assertAlmostEqual(ifo.meta_data["optimal_SNR"], reference.meta_data["optimal_SNR"], 8)
+        self.assertLess(full[0].meta_data["optimal_SNR"], snr_full)
+
+    def _sine_data(self, start_time, duration, sampling_frequency=4096):
         ifo = bilby.gw.detector.get_empty_interferometer("H1")
-        sampling_frequency, duration, start_time = 4096, 16, 1000.0
         times = start_time + np.arange(duration * sampling_frequency) / sampling_frequency
         strain = np.sin(2 * np.pi * 60 * times) + np.sin(2 * np.pi * 1500 * times)
         ifo.strain_data.set_from_time_domain_strain(
             strain, sampling_frequency=sampling_frequency, duration=duration, start_time=start_time)
-        ifo.downsample_strain_data(1024, start_time=1006.0, duration=4)
+        return ifo
+
+    def test_downsample(self):
+        ifo = self._sine_data(1000.0, 16)
+        ifo.set_analysis_window(1006.0, 4)
+        ifo.downsample_strain_data(1024)
         self.assertEqual(ifo.sampling_frequency, 1024)
         self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
         self.assertEqual(len(ifo.time_domain_strain), 4096)
@@ -311,22 +340,36 @@ def test_downsample(self):
         expected = np.sin(2 * np.pi * 60 * ifo.time_array)
         np.testing.assert_allclose(ifo.time_domain_strain, expected - np.mean(expected), atol=1e-6)
 
-    def test_downsample_segment_outside_data_raises(self):
-        ifo = bilby.gw.detector.get_empty_interferometer("H1")
-        ifo.set_strain_data_from_zero_noise(4096, 8, 0)
+    def test_downsample_data_slightly_off_grid(self):
+        ifo = self._sine_data(1004.0001, 8)
+        ifo.set_analysis_window(1006.0, 4)
+        ifo.downsample_strain_data(1024)
+        self.assertEqual(len(ifo.time_domain_strain), 4096)
+        self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0, 3)
+
+    def test_downsample_needs_buffer(self):
+        ifo = self._sine_data(1005.0, 6)
+        ifo.set_analysis_window(1006.0, 4)
         with self.assertRaises(ValueError):
-            ifo.downsample_strain_data(2048, start_time=0.5, duration=4)
+            ifo.downsample_strain_data(1024)
 
-    def test_save_data(self):
-        ifos = interferometers(noise="gaussian")
-        directory = tempfile.mkdtemp()
-        try:
-            ifos.save_data(directory, label="td")
-            for ifo in ifos:
-                for suffix in ["time_domain_data", "acf"]:
-                    self.assertTrue(os.path.isfile(os.path.join(directory, f"{ifo.name}_td_{suffix}.dat")))
-        finally:
-            shutil.rmtree(directory)
+    def test_no_conditioning_crops(self):
+        ifo = self._sine_data(1000.0, 16)
+        ifo.set_analysis_window(1006.0, 4)
+        ifo.downsample_strain_data(4096)
+        self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
+        self.assertEqual(len(ifo.time_domain_strain), 4 * 4096)
+
+    def test_network_downsample(self):
+        ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+        ifos.set_analysis_windows(duration=16, start_time=1000)
+        ifos.set_strain_data_from_power_spectral_densities_time_domain(4096, random_state=2)
+        ifos.set_analysis_windows(duration=4, start_time=1006)
+        ifos.downsample_strain_data(2048)
+        for ifo in ifos:
+            self.assertEqual(ifo.sampling_frequency, 2048)
+            self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
+            self.assertEqual(len(ifo.time_domain_strain), 4 * 2048)
 
 
 class TestTimeDomainSourceModels(unittest.TestCase):
@@ -418,38 +461,25 @@ def test_read_power_spectral_densities_from_hdf5(self):
                 np.testing.assert_array_equal(output["L1"][1], psd)
             with self.assertRaises(ValueError):
                 read(pesummary, ["H1"])  # two analyses: label needed
-            with self.assertRaises(ValueError):
-                read(pesummary, ["V1"], label="C01:IMRPhenomXPHM")
         finally:
             shutil.rmtree(directory)
 
     def test_welch_acf_agrees_with_psd_acf(self):
         ifo = bilby.gw.detector.get_empty_interferometer("H1")
         ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
-        ifo.set_strain_data_from_power_spectral_density_time_domain(
-            SAMPLING_FREQUENCY, 256, 0, random_state=11)
-        from_psd = AutoCovarianceFunction.from_power_spectral_density(
-            ifo.power_spectral_density, minimum_frequency=20, maximum_frequency=448,
-            analysis_duration=1, sampling_frequency=SAMPLING_FREQUENCY)
+        ifo.strain_data.set_from_power_spectral_density_time_domain(
+            ifo.power_spectral_density, SAMPLING_FREQUENCY, 256, 0, random_state=11)
+        noise = ifo.time_domain_strain.copy()
+        ifo.set_analysis_window(0, 1)
+        ifo.set_autocovariance_function_from_power_spectral_density()
         from_data = AutoCovarianceFunction.from_time_domain_strain(
-            ifo.time_domain_strain, SAMPLING_FREQUENCY, analysis_duration=1,
-            minimum_frequency=20, maximum_frequency=448)
+            noise, SAMPLING_FREQUENCY, analysis_duration=1, minimum_frequency=20, maximum_frequency=448)
         times = np.arange(SAMPLING_FREQUENCY) / SAMPLING_FREQUENCY
         signal = 1e-22 * np.exp(-0.5 * ((times - 0.5) / 0.05) ** 2) * np.sin(2 * np.pi * 120 * times)
         snr_squared = [GohbergSemenculInverse(*acf.gohberg_semencul_vectors(len(times)))(signal) @ signal
-                       for acf in [from_psd, from_data]]
+                       for acf in [ifo.autocovariance_function, from_data]]
         self.assertAlmostEqual(snr_squared[1] / snr_squared[0], 1, delta=0.1)
 
-    def test_network_downsample(self):
-        ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
-        ifos.set_strain_data_from_power_spectral_densities_time_domain(4096, 16, 1000, random_state=2)
-        ifos.downsample_strain_data(2048, start_time=1006.0, duration=4)
-        for ifo in ifos:
-            self.assertEqual(ifo.sampling_frequency, 2048)
-            self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
-            self.assertEqual(len(ifo.time_domain_strain), 4 * 2048)
-        self.assertEqual(ifos.start_time, 1006.0)
-
 
 if __name__ == "__main__":
     unittest.main()

From 3c1fba81c666deccc5f3e810f46c2f443ab9968c Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Fri, 9 Oct 2026 14:53:57 +0530
Subject: [PATCH 03/21] Remove crop data

---
 bilby/gw/detector/__init__.py                 |   1 +
 bilby/gw/detector/acf.py                      |  95 ++++---
 bilby/gw/detector/condition_data.py           | 126 +++++++++
 bilby/gw/detector/interferometer.py           | 244 +++++++++---------
 bilby/gw/detector/networks.py                 |  10 +-
 bilby/gw/detector/strain_data.py              | 119 ---------
 bilby/gw/likelihood/time_domain.py            |  38 +--
 bilby/gw/source.py                            |   5 +-
 bilby/gw/time_domain_utils.py                 | 106 +-------
 .../data_examples/GW150914_time_domain.py     |   7 +-
 test/gw/likelihood/time_domain_test.py        |  69 ++---
 11 files changed, 362 insertions(+), 458 deletions(-)
 create mode 100644 bilby/gw/detector/condition_data.py

diff --git a/bilby/gw/detector/__init__.py b/bilby/gw/detector/__init__.py
index 470fee6b8..96423347c 100644
--- a/bilby/gw/detector/__init__.py
+++ b/bilby/gw/detector/__init__.py
@@ -1,5 +1,6 @@
 from ..conversion import convert_to_lal_binary_black_hole_parameters
 from .acf import *
+from .condition_data import *
 from .calibration import *
 from .interferometer import *
 from .networks import *
diff --git a/bilby/gw/detector/acf.py b/bilby/gw/detector/acf.py
index 627af0957..172460c08 100644
--- a/bilby/gw/detector/acf.py
+++ b/bilby/gw/detector/acf.py
@@ -6,8 +6,8 @@
 
 class AutoCovarianceFunction(object):
 
-    def __init__(self, acf_array, sampling_frequency, minimum_frequency=None,
-                 maximum_frequency=None, fill_value=None):
+    def __init__(self, acf_array=None, sampling_frequency=None, minimum_frequency=None,
+                 maximum_frequency=None, fill_value=None, fill_multiplier=None):
         """
         Instantiate a new AutoCovarianceFunction object.
 
@@ -32,10 +32,10 @@ def __init__(self, acf_array, sampling_frequency, minimum_frequency=None,
 
         Parameters
         ==========
-        acf_array: array_like
+        acf_array: array_like, optional
             Autocovariance function at lags 0, 1/sampling_frequency,
             2/sampling_frequency, ... (strain^2).
-        sampling_frequency: float
+        sampling_frequency: float, optional
             Sampling frequency of the lags (Hz). Must equal the sampling
             frequency of the data it is used with.
         minimum_frequency: float, optional
@@ -43,45 +43,43 @@ def __init__(self, acf_array, sampling_frequency, minimum_frequency=None,
         maximum_frequency: float, optional
             Upper edge of the frequency band used to compute the ACF (Hz).
         fill_value: float, optional
-            Multiple of the maximum in-band PSD used outside the band.
+            PSD value used outside the band (strain^2 / Hz).
+        fill_multiplier: float, optional
+            Multiple of the maximum in-band PSD used outside the band, if
+            `fill_value` was computed from it.
         """
-        self.acf_array = np.asarray(acf_array, dtype=float)
-        self.sampling_frequency = float(sampling_frequency)
+        self.acf_array = None if acf_array is None else np.asarray(acf_array, dtype=float)
+        self.sampling_frequency = None if sampling_frequency is None else float(sampling_frequency)
         self.minimum_frequency = minimum_frequency
         self.maximum_frequency = maximum_frequency
         self.fill_value = fill_value
-
-    @property
-    def number_of_samples(self):
-        """ Number of lags in the ACF. """
-        return len(self.acf_array)
-
-    @property
-    def duration(self):
-        """ Duration of the ACF (s). """
-        return self.number_of_samples / self.sampling_frequency
+        self.fill_multiplier = fill_multiplier
 
     @property
     def meta_data(self):
+        duration = None
+        if self.acf_array is not None and self.sampling_frequency is not None:
+            duration = len(self.acf_array) / self.sampling_frequency
         return dict(
             sampling_frequency=self.sampling_frequency,
-            duration=self.duration,
+            duration=duration,
             minimum_frequency=self.minimum_frequency,
             maximum_frequency=self.maximum_frequency,
             fill_value=self.fill_value,
+            fill_multiplier=self.fill_multiplier,
         )
 
     @classmethod
     def from_power_spectral_density_array(
             cls, frequency_array, psd_array, minimum_frequency, maximum_frequency,
-            sampling_frequency=None, fill_value=1e4):
+            sampling_frequency=None, fill_value=None, fill_multiplier=1e4):
         """ Compute the ACF from a one-sided power spectral density.
 
         The PSD below `minimum_frequency` and above `maximum_frequency` is set
-        to `fill_value` times its maximum value in
-        [`minimum_frequency`, `maximum_frequency`]. If `frequency_array` does
-        not start at 0 Hz, bins down to 0 Hz are added and set to the same
-        value. The ACF is then
+        to `fill_value` or, if it is not given, to `fill_multiplier` times its
+        maximum value in [`minimum_frequency`, `maximum_frequency`]. If
+        `frequency_array` does not start at 0 Hz, bins down to 0 Hz are added
+        and set to the same value. The ACF is then
 
         .. math::
 
@@ -105,9 +103,12 @@ def from_power_spectral_density_array(
             Sampling frequency of the data (Hz). If it differs from twice the
             highest frequency in `frequency_array`, a warning is logged and
             the latter is used.
-        fill_value: float
-            Multiple of the maximum in-band PSD used outside the band
-            (default 1e4).
+        fill_value: float, optional
+            PSD value used outside the band (strain^2 / Hz). Overrides
+            `fill_multiplier`.
+        fill_multiplier: float
+            Multiple of the maximum in-band PSD used outside the band if
+            `fill_value` is not given (default 1e4).
 
         Returns
         =======
@@ -116,10 +117,11 @@ def from_power_spectral_density_array(
         frequency_array = np.asarray(frequency_array, dtype=float)
         psd_array = np.asarray(psd_array, dtype=float)
         delta_f = frequency_array[1] - frequency_array[0]
-        number_missing = int(round(frequency_array[0] / delta_f))
-        if number_missing > 0:
-            frequency_array = np.concatenate([np.arange(number_missing) * delta_f, frequency_array])
-            psd_array = np.concatenate([np.zeros(number_missing), psd_array])
+        frequency_values_missing = int(round(frequency_array[0] / delta_f))
+        if frequency_values_missing > 0:
+            frequency_array = np.concatenate(
+                [np.arange(frequency_values_missing) * delta_f, frequency_array])
+            psd_array = np.concatenate([np.zeros(frequency_values_missing), psd_array])
 
         psd_sampling_frequency = 2 * frequency_array[-1]
         if sampling_frequency is not None and not np.isclose(
@@ -132,17 +134,22 @@ def from_power_spectral_density_array(
                 "and SNR values.")
 
         band = (frequency_array >= minimum_frequency) & (frequency_array <= maximum_frequency)
+        if fill_value is None:
+            fill_value = fill_multiplier * np.max(psd_array[band])
+        else:
+            fill_multiplier = None
         psd_array = psd_array.copy()
-        psd_array[~band] = fill_value * np.max(psd_array[band])
+        psd_array[~band] = fill_value
         acf_array = 0.5 * np.fft.irfft(psd_array) * psd_sampling_frequency
         return cls(acf_array=acf_array, sampling_frequency=psd_sampling_frequency,
                    minimum_frequency=minimum_frequency, maximum_frequency=maximum_frequency,
-                   fill_value=fill_value)
+                   fill_value=float(fill_value), fill_multiplier=fill_multiplier)
 
     @classmethod
     def from_time_domain_strain(
             cls, time_domain_strain, sampling_frequency, analysis_duration, minimum_frequency,
-            maximum_frequency, segment_duration=None, duration_factor=16, fill_value=1e4):
+            maximum_frequency, segment_duration=None, duration_factor=16, fill_value=None,
+            fill_multiplier=1e4):
         """ Estimate the ACF from noise data.
 
         The PSD of the data is estimated with Welch's method (Hann window, 50%
@@ -167,9 +174,12 @@ def from_time_domain_strain(
             samples.
         duration_factor: float
             See `segment_duration` (default 16).
-        fill_value: float
-            Multiple of the maximum in-band PSD used outside the band
-            (default 1e4).
+        fill_value: float, optional
+            PSD value used outside the band (strain^2 / Hz). Overrides
+            `fill_multiplier`.
+        fill_multiplier: float
+            Multiple of the maximum in-band PSD used outside the band if
+            `fill_value` is not given (default 1e4).
 
         Returns
         =======
@@ -185,7 +195,8 @@ def from_time_domain_strain(
             average="median")
         return cls.from_power_spectral_density_array(
             frequency_array, psd_array, minimum_frequency, maximum_frequency,
-            sampling_frequency=sampling_frequency, fill_value=fill_value)
+            sampling_frequency=sampling_frequency, fill_value=fill_value,
+            fill_multiplier=fill_multiplier)
 
     @classmethod
     def from_file(cls, filename, sampling_frequency=None):
@@ -227,13 +238,13 @@ def get_acf_array(self, number_of_samples):
         =======
         array_like: The first row of the segment's covariance matrix.
         """
-        if number_of_samples > self.number_of_samples:
+        if number_of_samples > len(self.acf_array):
             raise ValueError(
                 f"The analysis segment ({number_of_samples} samples) is longer than the ACF "
-                f"({self.number_of_samples} samples)")
-        if 2 * number_of_samples > self.number_of_samples:
+                f"({len(self.acf_array)} samples)")
+        if 2 * number_of_samples > len(self.acf_array):
             logger.warning(
-                f"The ACF ({self.number_of_samples} samples) is shorter than twice the analysis "
+                f"The ACF ({len(self.acf_array)} samples) is shorter than twice the analysis "
                 f"segment ({number_of_samples} samples)")
         return self.acf_array[:number_of_samples]
 
@@ -261,7 +272,7 @@ def save(self, filename):
         filename: str
             Name of the output file.
         """
-        lags = np.arange(self.number_of_samples) / self.sampling_frequency
+        lags = np.arange(len(self.acf_array)) / self.sampling_frequency
         np.savetxt(filename, np.array([lags, self.acf_array]).T, header="lag acf")
 
 
diff --git a/bilby/gw/detector/condition_data.py b/bilby/gw/detector/condition_data.py
new file mode 100644
index 000000000..7277022df
--- /dev/null
+++ b/bilby/gw/detector/condition_data.py
@@ -0,0 +1,126 @@
+import numpy as np
+
+
+def condition_strain_data(
+        strain_data, sampling_frequency, start_time, duration, minimum_frequency=None,
+        maximum_frequency=None, anti_aliasing="fft", trim=0.25, remove_mean=True,
+        decimate_kwargs=None):
+    """ Condition and downsample time-domain strain data around an analysis
+    window.
+
+    Steps:
+
+    1. Keep the window [`start_time`, `start_time` + `duration`) and a buffer
+       of `trim` / (1 - 2 `trim`) x `duration` on each side (`duration` / 2
+       for the default `trim` = 0.25). A ValueError is raised if the data do
+       not cover them.
+    2. Shift the data by fewer than `factor` samples (factor = current / new
+       sampling frequency) so that the sample nearest `start_time` is kept.
+    3. If `minimum_frequency` and/or `maximum_frequency` are given, apply an
+       order-4 Butterworth high-, low- or band-pass filter forwards and
+       backwards.
+    4. Anti-aliasing and decimation: with `anti_aliasing="fft"`, multiply by a
+       Tukey window with alpha = `trim`, set all frequencies above the new
+       Nyquist frequency to zero and keep every factor-th sample; with
+       `anti_aliasing="decimate"`, use :code:`scipy.signal.decimate`.
+    5. Remove a fraction `trim` of the samples at each end; this removes the
+       buffer. Samples in the window are always kept.
+    6. Subtract the mean if `remove_mean`.
+
+    The result replaces the data in `strain_data`.
+
+    Parameters
+    ==========
+    strain_data: bilby.gw.detector.InterferometerStrainData
+        The strain data; modified in place.
+    sampling_frequency: float
+        New sampling frequency (Hz); must divide the current one.
+    start_time: float
+        GPS start time of the analysis window (s).
+    duration: float
+        Duration of the analysis window (s).
+    minimum_frequency: float, optional
+        High-pass corner frequency of the Butterworth filter (Hz).
+    maximum_frequency: float, optional
+        Low-pass corner frequency of the Butterworth filter (Hz).
+    anti_aliasing: str
+        "fft" (default) or "decimate".
+    trim: float
+        Fraction of the data at each end that is removed (default 0.25).
+    remove_mean: bool
+        Subtract the mean of the result (default True).
+    decimate_kwargs: dict, optional
+        Keyword arguments of :code:`scipy.signal.decimate`.
+    """
+    from scipy import signal
+    from scipy.signal.windows import tukey
+
+    original_sampling_frequency = float(strain_data.sampling_frequency)
+    factor = int(round(original_sampling_frequency / sampling_frequency))
+    if factor < 1 or not np.isclose(original_sampling_frequency / sampling_frequency, factor,
+                                    rtol=0, atol=1e-9):
+        raise ValueError(
+            f"Sampling frequency {sampling_frequency:g} Hz does not divide the current "
+            f"{original_sampling_frequency:g} Hz")
+
+    buffer = duration * trim / (1 - 2 * trim)
+    tolerance = 1 / original_sampling_frequency
+    data_start = strain_data.start_time
+    data_end = data_start + strain_data.duration
+    if data_start > start_time - buffer + tolerance or data_end < start_time + duration + buffer - tolerance:
+        raise ValueError(
+            f"The data ({data_start:.6f} - {data_end:.6f}) must cover "
+            f"{start_time - buffer:.6f} - {start_time + duration + buffer:.6f}: the analysis "
+            f"window plus {buffer:g} s on each side")
+    first = max(int(round((start_time - buffer - data_start) * original_sampling_frequency)), 0)
+    last = int(round((start_time + duration + buffer - data_start) * original_sampling_frequency))
+    strain = np.array(strain_data.time_domain_strain[first:last], dtype=float)
+    times = np.array(strain_data.time_array[first:last], dtype=float)
+
+    shift = int(np.argmin(abs(times - start_time))) % factor
+    if trim > 0:
+        # the wrapped samples are at the end and are removed in step 5
+        times = np.roll(times, -shift)
+        strain = np.roll(strain, -shift)
+    else:
+        times = times[shift:]
+        strain = strain[shift:]
+
+    nyquist_frequency = 0.5 * original_sampling_frequency
+    if minimum_frequency or maximum_frequency:
+        if minimum_frequency and not maximum_frequency:
+            b, a = signal.butter(4, minimum_frequency / nyquist_frequency, btype="highpass")
+        elif maximum_frequency and not minimum_frequency:
+            b, a = signal.butter(4, maximum_frequency / nyquist_frequency, btype="lowpass")
+        else:
+            b, a = signal.butter(4, (minimum_frequency / nyquist_frequency,
+                                     maximum_frequency / nyquist_frequency), btype="bandpass")
+        strain = signal.filtfilt(b, a, strain)
+
+    if factor > 1:
+        if anti_aliasing == "fft":
+            strain_fd = np.fft.rfft(strain * tukey(len(strain), trim))
+            frequencies = np.fft.rfftfreq(len(strain), 1 / original_sampling_frequency)
+            strain_fd[frequencies > nyquist_frequency / factor] = 0
+            strain = np.fft.irfft(strain_fd, n=len(strain))[::factor]
+        elif anti_aliasing == "decimate":
+            strain = signal.decimate(strain, factor, zero_phase=True, **(decimate_kwargs or {}))
+        else:
+            raise ValueError("anti_aliasing must be 'fft' or 'decimate'")
+        times = times[::factor]
+
+    # remove the fraction trim at each end, but always keep the window
+    window_first = int(np.argmin(abs(times - start_time)))
+    window_last = window_first + int(round(duration * sampling_frequency))
+    first = min(int(round(trim * len(strain))), window_first)
+    last = max(int(round((1 - trim) * len(strain))), window_last)
+    strain, times = strain[first:last], times[first:last]
+    if remove_mean:
+        strain = strain - np.mean(strain)
+
+    strain_data.set_from_time_domain_strain(
+        strain, sampling_frequency=sampling_frequency, duration=len(strain) / sampling_frequency,
+        start_time=times[0])
+
+
+__all__ = ["condition_strain_data"]
diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index f0469daf5..91ecf46f5 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -15,10 +15,9 @@
 from .geometry import InterferometerGeometry
 from .strain_data import InterferometerStrainData
 from ..time_domain_utils import (
+    GohbergSemenculInverse,
     align_peak_to_sample,
     place_time_domain_signal,
-    time_domain_matched_filter_snr,
-    time_domain_optimal_snr_squared,
 )
 from ..conversion import generate_all_bbh_parameters
 
@@ -103,6 +102,7 @@ def __init__(self, name, power_spectral_density, minimum_frequency, maximum_freq
         self._analysis_window = None
         self._injected_signal = None
         self.gohberg_semencul_vectors = None
+        self.inverse_covariance = None
 
     def __eq__(self, other):
         if self.name == other.name and \
@@ -275,32 +275,32 @@ def set_strain_data_from_zero_noise(
 
     @property
     def analysis_window(self):
-        """ The analysis window, dict(start_time, duration), or None. """
+        """ The stretch of data analysed with a time-domain likelihood,
+        dict(start_time, duration), or None.
+
+        Set it with :code:`interferometer.analysis_window = (start_time, duration)`,
+        with the GPS start time and the duration in seconds. The data in the
+        window (:code:`analysis_data`) are used by time-domain likelihoods,
+        and the Gohberg-Semencul vectors of the inverse noise covariance matrix
+        are computed for its length.
+        """
         return self._analysis_window
 
-    def set_analysis_window(self, start_time, duration):
-        """ Set the stretch of data analysed with a time-domain likelihood.
-
-        The time-domain data methods (noise generation, downsampling,
-        cropping) put exactly this window in the strain data, and the
-        Gohberg-Semencul vectors of the inverse noise covariance matrix are
-        computed for its length.
-
-        Parameters
-        ==========
-        start_time: float
-            GPS start time of the window (s).
-        duration: float
-            Duration of the window (s).
-        """
+    @analysis_window.setter
+    def analysis_window(self, window):
+        if window is None:
+            self._analysis_window = None
+            self.meta_data.pop("analysis_window", None)
+            return
+        start_time, duration = window
         self._analysis_window = dict(start_time=float(start_time), duration=float(duration))
         self.meta_data["analysis_window"] = dict(self._analysis_window)
-        if self.autocovariance_function is not None:
+        if self.autocovariance_function is not None and self.autocovariance_function.acf_array is not None:
             self._set_gohberg_semencul_vectors()
 
     def _require_analysis_window(self):
         if self.analysis_window is None:
-            raise ValueError(f"{self.name}: set the analysis window first (set_analysis_window)")
+            raise ValueError(f"{self.name}: set the analysis window first (analysis_window)")
         return self.analysis_window["start_time"], self.analysis_window["duration"]
 
     def set_strain_data_from_power_spectral_density_time_domain(
@@ -337,100 +337,63 @@ def set_strain_data_from_zero_noise_time_domain(self, sampling_frequency):
             sampling_frequency=sampling_frequency, duration=duration, start_time=start_time)
         self._injected_signal = None
 
-    def crop_strain_data(self):
-        """ Crop the time-domain strain data to the analysis window, keeping
-        the samples nearest to its start. """
-        start_time, duration = self._require_analysis_window()
-        self._store_strain_data(*[
-            self._cropped(series, start_time, duration)
-            for series in (self.strain_data, self._injected_signal_data())])
-
     def downsample_strain_data(self, sampling_frequency, **kwargs):
-        """ Condition and downsample the time-domain strain data, and crop it
-        to the analysis window.
+        """ Condition and downsample the time-domain strain data around the
+        analysis window.
 
-        The data must cover the analysis window plus, on each side, a buffer
-        of `trim` / (1 - 2 `trim`) times its duration (half the duration for
-        the default `trim` = 0.25), which is removed by the conditioning.
-        Longer data are first cropped to the window and buffer. If the data
-        are already at `sampling_frequency` and no filter is requested, they
-        are cropped to the window directly.
+        See :code:`bilby.gw.detector.condition_data.condition_strain_data`. If
+        the data are already at `sampling_frequency` and no filter is
+        requested, they are left unchanged.
 
         Parameters
         ==========
         sampling_frequency: float
             New sampling frequency (Hz); must divide the current one.
         kwargs:
-            Passed to :code:`InterferometerStrainData.downsample`
-            (minimum_frequency, maximum_frequency, anti_aliasing, trim,
-            remove_mean, decimate_kwargs).
+            Passed to :code:`condition_strain_data` (minimum_frequency,
+            maximum_frequency, anti_aliasing, trim, remove_mean,
+            decimate_kwargs).
         """
+        from .condition_data import condition_strain_data
         start_time, duration = self._require_analysis_window()
         no_filter = kwargs.get("minimum_frequency") is None and kwargs.get("maximum_frequency") is None
         if self.strain_data.sampling_frequency == sampling_frequency and no_filter:
-            self.crop_strain_data()
             return
-        trim = kwargs.get("trim", 0.25)
-        buffer = duration * trim / (1 - 2 * trim)
-        tolerance = 1 / self.strain_data.sampling_frequency
-        data_start = self.strain_data.start_time
-        data_end = data_start + self.strain_data.duration
-        if data_start > start_time - buffer + tolerance or data_end < start_time + duration + buffer - tolerance:
-            raise ValueError(
-                f"{self.name}: the data ({data_start:.6f} - {data_end:.6f}) must cover "
-                f"{start_time - buffer:.6f} - {start_time + duration + buffer:.6f}: the analysis "
-                f"window plus {buffer:g} s on each side")
-        crop_start = max(start_time - buffer, data_start)
-        crop_end = min(start_time + duration + buffer, data_end)
-        series = [self._cropped(item, crop_start, crop_end - crop_start)
-                  for item in (self.strain_data, self._injected_signal_data())]
-        for item in series:
-            if item is not None:
-                item.downsample(sampling_frequency, preserve_time=start_time,
-                                start_time=start_time, duration=duration, **kwargs)
-        self._store_strain_data(*series)
-
-    def _store_strain_data(self, strain_data, injected_signal):
-        """ Replace the time-domain strain data (and the injected signal) by
-        the given ones. """
-        self.strain_data.set_from_time_domain_strain(
-            strain_data.time_domain_strain, sampling_frequency=strain_data.sampling_frequency,
-            duration=strain_data.duration, start_time=strain_data.start_time)
-        self._injected_signal = None if injected_signal is None else injected_signal.time_domain_strain
+        if self._injected_signal is not None:
+            # condition the injected signal in the same way, for its SNRs
+            injected_signal = InterferometerStrainData()
+            injected_signal.set_from_time_domain_strain(
+                self._injected_signal, sampling_frequency=self.strain_data.sampling_frequency,
+                duration=self.strain_data.duration, start_time=self.strain_data.start_time)
+            condition_strain_data(injected_signal, sampling_frequency, start_time, duration, **kwargs)
+            self._injected_signal = injected_signal.time_domain_strain
+        condition_strain_data(self.strain_data, sampling_frequency, start_time, duration, **kwargs)
         self._update_injection_snrs()
 
-    @staticmethod
-    def _cropped(strain_data, start_time, duration):
-        """ Copy of `strain_data` cropped to [start_time, start_time + duration)
-        at the nearest samples. """
-        if strain_data is None:
-            return None
-        sampling_frequency = strain_data.sampling_frequency
-        first = int(round((start_time - strain_data.start_time) * sampling_frequency))
+    def _analysis_slice(self):
+        """ Slice of the data samples in the analysis window: from the sample
+        nearest to its start time, `duration` x sampling frequency samples. """
+        start_time, duration = self._require_analysis_window()
+        sampling_frequency = self.strain_data.sampling_frequency
+        first = int(np.argmin(abs(self.strain_data.time_array - start_time)))
         number_of_samples = int(round(duration * sampling_frequency))
-        if first < 0 or first + number_of_samples > len(strain_data.time_domain_strain):
+        if first + number_of_samples > len(self.strain_data.time_array) or (
+                abs(self.strain_data.time_array[first] - start_time) > 1 / sampling_frequency):
             raise ValueError(
-                f"The data ({strain_data.start_time:.6f} - "
-                f"{strain_data.start_time + strain_data.duration:.6f}) do not cover "
-                f"{start_time:.6f} - {start_time + duration:.6f}")
-        cropped = InterferometerStrainData(
-            minimum_frequency=strain_data.minimum_frequency,
-            maximum_frequency=strain_data.maximum_frequency)
-        cropped.set_from_time_domain_strain(
-            np.array(strain_data.time_domain_strain[first:first + number_of_samples], dtype=float),
-            sampling_frequency=sampling_frequency, duration=number_of_samples / sampling_frequency,
-            start_time=strain_data.start_time + first / sampling_frequency)
-        return cropped
-
-    def _injected_signal_data(self):
-        """ The injected detector signal as strain data on the data samples, or None. """
-        if self._injected_signal is None:
-            return None
-        signal = InterferometerStrainData()
-        signal.set_from_time_domain_strain(
-            self._injected_signal, sampling_frequency=self.strain_data.sampling_frequency,
-            duration=self.strain_data.duration, start_time=self.strain_data.start_time)
-        return signal
+                f"{self.name}: the analysis window ({start_time:.6f} - {start_time + duration:.6f}) "
+                f"is not inside the data ({self.strain_data.start_time:.6f} - "
+                f"{self.strain_data.start_time + self.strain_data.duration:.6f})")
+        return slice(first, first + number_of_samples)
+
+    @property
+    def analysis_data(self):
+        """ The time-domain strain data in the analysis window. """
+        return np.asarray(self.strain_data.time_domain_strain, dtype=float)[self._analysis_slice()]
+
+    @property
+    def analysis_time_array(self):
+        """ The GPS times of the samples in the analysis window. """
+        return self.strain_data.time_array[self._analysis_slice()]
 
     @property
     def autocovariance_function(self):
@@ -448,26 +411,30 @@ def autocovariance_function(self, autocovariance_function):
         if autocovariance_function is not None:
             self._require_analysis_window()
         self._autocovariance_function = autocovariance_function
+        self.gohberg_semencul_vectors = None
+        self.inverse_covariance = None
         if autocovariance_function is None:
             self.meta_data.pop("autocovariance_function", None)
-            self.gohberg_semencul_vectors = None
         else:
             self.meta_data["autocovariance_function"] = autocovariance_function.meta_data
-            self._set_gohberg_semencul_vectors()
+            if autocovariance_function.acf_array is not None:
+                self._set_gohberg_semencul_vectors()
 
     def _set_gohberg_semencul_vectors(self):
         """ Compute the Gohberg-Semencul vectors (x, y) of the inverse noise
-        covariance matrix for the analysis window and store them in
-        :code:`gohberg_semencul_vectors`. """
+        covariance matrix for the analysis window, and the operator applying
+        it, and store them in :code:`gohberg_semencul_vectors` and
+        :code:`inverse_covariance`. """
         number_of_samples = int(round(
             self.analysis_window["duration"] * self.autocovariance_function.sampling_frequency))
         self.gohberg_semencul_vectors = self.autocovariance_function.gohberg_semencul_vectors(
             number_of_samples)
+        self.inverse_covariance = GohbergSemenculInverse(*self.gohberg_semencul_vectors)
         self._update_injection_snrs()
 
     def set_autocovariance_function_from_power_spectral_density(
             self, minimum_frequency=None, maximum_frequency=None, sampling_frequency=None,
-            duration_factor=16, fill_value=1e4):
+            duration_factor=16, fill_value=None, fill_multiplier=1e4):
         """ Set the autocovariance function from the power spectral density
         of this interferometer.
 
@@ -489,9 +456,12 @@ def set_autocovariance_function_from_power_spectral_density(
         duration_factor: float
             Duration of the ACF divided by the duration of the analysis
             window (default 16).
-        fill_value: float
-            Multiple of the maximum in-band PSD used outside the band
-            (default 1e4).
+        fill_value: float, optional
+            PSD value used outside the band (strain^2 / Hz). Overrides
+            `fill_multiplier`.
+        fill_multiplier: float
+            Multiple of the maximum in-band PSD used outside the band if
+            `fill_value` is not given (default 1e4).
         """
         from .acf import AutoCovarianceFunction
         _, duration = self._require_analysis_window()
@@ -508,7 +478,7 @@ def set_autocovariance_function_from_power_spectral_density(
         self.autocovariance_function = AutoCovarianceFunction.from_power_spectral_density_array(
             frequency_array, psd_array, minimum_frequency=minimum_frequency,
             maximum_frequency=maximum_frequency, sampling_frequency=sampling_frequency,
-            fill_value=fill_value)
+            fill_value=fill_value, fill_multiplier=fill_multiplier)
 
     def antenna_response(self, ra, dec, time, psi, mode):
         """
@@ -616,11 +586,12 @@ def get_detector_response(self, waveform_polarizations, parameters, frequencies=
     def get_time_domain_detector_response(self, waveform_polarizations, parameters,
                                           placement="nearest"):
         """ Get the time-domain detector response for a particular waveform,
-        on the samples of the strain data.
+        on the samples of the analysis window.
 
         The polarizations are projected with the antenna patterns and placed
         so that the model's t=0 arrives at geocent_time plus the time delay
-        from the geocenter. Waveform samples outside the data are dropped.
+        from the geocenter. Waveform samples outside the analysis window are
+        dropped.
 
         Parameters
         ==========
@@ -639,7 +610,7 @@ def get_time_domain_detector_response(self, waveform_polarizations, parameters,
 
         Returns
         =======
-        array_like: The detector signal on the data samples.
+        array_like: The detector signal on the samples of the analysis window.
 
         Notes
         =====
@@ -647,6 +618,15 @@ def get_time_domain_detector_response(self, waveform_polarizations, parameters,
         used to set the time at which the antenna response is evaluated,
         otherwise the provided :code:`parameters["geocent_time"]` is used.
         """
+        analysis_slice = self._analysis_slice()
+        return self._time_domain_detector_response(
+            waveform_polarizations, parameters, self.strain_data.time_array[analysis_slice.start],
+            analysis_slice.stop - analysis_slice.start, placement)
+
+    def _time_domain_detector_response(self, waveform_polarizations, parameters, start_time,
+                                       number_of_samples, placement):
+        """ Detector response on `number_of_samples` data samples starting
+        at `start_time`; see :code:`get_time_domain_detector_response`. """
         sampling_frequency = self.strain_data.sampling_frequency
         polarizations = {mode: value for mode, value in waveform_polarizations.items()
                          if mode != "epoch"}
@@ -669,26 +649,33 @@ def get_time_domain_detector_response(self, waveform_polarizations, parameters,
             parameters['ra'], parameters['dec'], parameters['geocent_time'])
         # Be careful to first subtract the two GPS times which are ~1e9 sec.
         # And then add the time_shift which varies at ~1e-5 sec
-        dt_geocent = parameters['geocent_time'] - self.strain_data.start_time
+        dt_geocent = parameters['geocent_time'] - start_time
         arrival_index = (dt_geocent + time_shift) * sampling_frequency
 
         return place_time_domain_signal(
             signal_ifo, merger_index=merger_index, arrival_index=arrival_index,
-            number_of_samples=len(self.strain_data.time_domain_strain), placement=placement)
+            number_of_samples=number_of_samples, placement=placement)
 
     def _update_injection_snrs(self):
         """ Store the optimal and matched-filter SNRs of the injected signal
-        in :code:`meta_data` if the Gohberg-Semencul vectors match the data. """
-        signal = self._injected_signal
-        vectors = self.gohberg_semencul_vectors
-        if signal is None or vectors is None or len(vectors[0]) != len(signal):
-            for key in ["optimal_SNR", "matched_filter_SNR"]:
-                self.meta_data.pop(key, None)
+        in the analysis window in :code:`meta_data`. """
+        for key in ["optimal_SNR", "matched_filter_SNR"]:
+            self.meta_data.pop(key, None)
+        if (self._injected_signal is None or self.inverse_covariance is None
+                or len(self._injected_signal) != len(self.strain_data.time_domain_strain)):
+            return
+        try:
+            analysis_slice = self._analysis_slice()
+        except ValueError:
+            return
+        signal = self._injected_signal[analysis_slice]
+        if len(signal) != self.inverse_covariance.number_of_samples:
             return
-        x, y = vectors
-        self.meta_data['optimal_SNR'] = time_domain_optimal_snr_squared(signal, x, y) ** 0.5
-        self.meta_data['matched_filter_SNR'] = time_domain_matched_filter_snr(
-            signal, self.strain_data.time_domain_strain, x, y)
+        inverse_covariance_signal = self.inverse_covariance(signal)
+        optimal_snr = float(np.dot(signal, inverse_covariance_signal)) ** 0.5
+        self.meta_data['optimal_SNR'] = optimal_snr
+        self.meta_data['matched_filter_SNR'] = float(
+            np.dot(self.analysis_data, inverse_covariance_signal)) / optimal_snr
         logger.info("{}: optimal SNR = {:.2f}, matched filter SNR = {:.2f}".format(
             self.name, self.meta_data['optimal_SNR'], self.meta_data['matched_filter_SNR']))
 
@@ -696,11 +683,11 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
                                   waveform_generator=None, placement="nearest"):
         """ Inject a time-domain signal into the time-domain strain data.
 
-        The detector signal is computed with
-        :code:`get_time_domain_detector_response` and added to the stored
-        time series; parts of the signal outside the data are dropped. If the
-        autocovariance function is set, the optimal and matched-filter SNRs
-        over the data are stored in :code:`meta_data`.
+        The detector signal is projected and placed as in
+        :code:`get_time_domain_detector_response` and added to all of the
+        stored time series; parts of the signal outside the data are dropped.
+        If the autocovariance function is set, the optimal and matched-filter
+        SNRs in the analysis window are stored in :code:`meta_data`.
         Provide the injection parameters and either the injection
         polarizations or the waveform generator; the injection polarizations
         are used if both are given.
@@ -785,8 +772,9 @@ def inject_signal_time_domain_from_waveform_polarizations(self, parameters, inje
             raise ValueError("injection_polarizations must come from a time-domain source model "
                              "(with an 'epoch' entry)")
 
-        signal_ifo = self.get_time_domain_detector_response(
-            injection_polarizations, parameters, placement=placement)
+        signal_ifo = self._time_domain_detector_response(
+            injection_polarizations, parameters, self.strain_data.start_time,
+            len(self.strain_data.time_domain_strain), placement)
         self.strain_data._time_domain_strain = (
             np.array(self.strain_data.time_domain_strain, dtype=float) + signal_ifo)
         self.strain_data._frequency_domain_strain = None
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index 745c37a70..2c8612725 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -249,7 +249,7 @@ def set_analysis_windows(self, duration, start_time=None, analysis_segment="imr"
                 raise ValueError(
                     "analysis_segment must be 'imr', 'inspiral' or 'post_inspiral', "
                     f"not {analysis_segment!r}")
-            interferometer.set_analysis_window(window_start, duration)
+            interferometer.analysis_window = (window_start, duration)
             interferometer.meta_data["analysis_window"].update(
                 analysis_segment=analysis_segment, segment_cut_time=segment_cut_time,
                 cut_time=cut_time)
@@ -296,7 +296,7 @@ def set_autocovariance_functions_from_power_spectral_densities(self, **kwargs):
 
     def downsample_strain_data(self, sampling_frequency, **kwargs):
         """Condition and downsample the time-domain strain data of each
-        detector, and crop it to its analysis window.
+        detector around its analysis window.
 
         See :py:meth:`bilby.gw.detector.Interferometer.downsample_strain_data`
         for the keyword arguments.
@@ -309,12 +309,6 @@ def downsample_strain_data(self, sampling_frequency, **kwargs):
         for interferometer in self:
             interferometer.downsample_strain_data(sampling_frequency, **kwargs)
 
-    def crop_strain_data(self):
-        """Crop the time-domain strain data of each detector to its analysis
-        window."""
-        for interferometer in self:
-            interferometer.crop_strain_data()
-
     def inject_signal_time_domain(
         self,
         parameters=None,
diff --git a/bilby/gw/detector/strain_data.py b/bilby/gw/detector/strain_data.py
index e3adc9eec..6357f9e67 100644
--- a/bilby/gw/detector/strain_data.py
+++ b/bilby/gw/detector/strain_data.py
@@ -697,125 +697,6 @@ def set_from_power_spectral_density_time_domain(
         self._time_domain_strain = time_domain_strain
         self._frequency_domain_strain = None
 
-    def downsample(
-            self, sampling_frequency, preserve_time=None, minimum_frequency=None,
-            maximum_frequency=None, anti_aliasing="fft", trim=0.25, remove_mean=True,
-            decimate_kwargs=None, start_time=None, duration=None):
-        """ Condition and downsample the time-domain strain data.
-
-        Steps:
-
-        1. If `preserve_time` is given, shift the series by fewer than
-           `factor` samples (factor = current / new sampling frequency) so
-           that the sample nearest `preserve_time` is kept.
-        2. If `minimum_frequency` and/or `maximum_frequency` are given, apply
-           an order-4 Butterworth high-, low- or band-pass filter forwards
-           and backwards.
-        3. Anti-aliasing and decimation: with `anti_aliasing="fft"`, multiply
-           by a Tukey window with alpha = `trim`, set all frequencies above the
-           new Nyquist frequency to zero and keep every factor-th sample; with
-           `anti_aliasing="decimate"`, use :code:`scipy.signal.decimate`.
-        4. Keep [`start_time`, `start_time` + `duration`) if given (it must lie
-           inside the data without a fraction `trim` at each end), otherwise
-           remove a fraction `trim` of the samples at each end.
-        5. Subtract the mean if `remove_mean`.
-
-        Parameters
-        ==========
-        sampling_frequency: float
-            New sampling frequency (Hz); must divide the current one.
-        preserve_time: float, optional
-            GPS time whose nearest sample is kept.
-        minimum_frequency: float, optional
-            High-pass corner frequency of the Butterworth filter (Hz).
-        maximum_frequency: float, optional
-            Low-pass corner frequency of the Butterworth filter (Hz).
-        anti_aliasing: str
-            "fft" (default) or "decimate".
-        trim: float
-            Fraction of the data at each end that is removed (default 0.25).
-        remove_mean: bool
-            Subtract the mean of the result (default True).
-        decimate_kwargs: dict, optional
-            Keyword arguments of :code:`scipy.signal.decimate`.
-        start_time: float, optional
-            GPS start time of the segment to keep (s).
-        duration: float, optional
-            Duration of the segment to keep (s).
-        """
-        from scipy import signal
-        from scipy.signal.windows import tukey
-
-        strain = np.array(self.time_domain_strain, dtype=float)
-        times = np.array(self.time_array, dtype=float)
-        original_sampling_frequency = float(self.sampling_frequency)
-        ratio = original_sampling_frequency / sampling_frequency
-        factor = int(round(ratio))
-        if factor < 1 or not np.isclose(ratio, factor, rtol=0, atol=1e-9):
-            raise ValueError(
-                f"Sampling frequency {sampling_frequency:g} Hz does not divide the current "
-                f"{original_sampling_frequency:g} Hz")
-
-        if preserve_time is not None:
-            if not times[0] <= preserve_time <= times[-1]:
-                raise ValueError(f"preserve_time {preserve_time} not in the data "
-                                 f"[{times[0]}, {times[-1]}]")
-            shift = int(np.argmin(abs(times - preserve_time))) % factor
-            if trim > 0:
-                times = np.roll(times, -shift)
-                strain = np.roll(strain, -shift)
-            else:
-                times = times[shift:]
-                strain = strain[shift:]
-
-        nyquist_frequency = 0.5 * original_sampling_frequency
-        if minimum_frequency or maximum_frequency:
-            if minimum_frequency and not maximum_frequency:
-                b, a = signal.butter(4, minimum_frequency / nyquist_frequency, btype='highpass')
-            elif maximum_frequency and not minimum_frequency:
-                b, a = signal.butter(4, maximum_frequency / nyquist_frequency, btype='lowpass')
-            else:
-                b, a = signal.butter(4, (minimum_frequency / nyquist_frequency,
-                                         maximum_frequency / nyquist_frequency), btype='bandpass')
-            strain = signal.filtfilt(b, a, strain)
-
-        if factor > 1:
-            if anti_aliasing == "fft":
-                window = tukey(len(strain), trim)
-                strain_fd = np.fft.rfft(strain * window)
-                frequencies = np.fft.rfftfreq(len(strain), 1 / original_sampling_frequency)
-                strain_fd[frequencies > nyquist_frequency / factor] = 0
-                strain = np.fft.irfft(strain_fd, n=len(strain))[::factor]
-            elif anti_aliasing == "decimate":
-                strain = signal.decimate(strain, factor, zero_phase=True, **(decimate_kwargs or {}))
-            else:
-                raise ValueError("anti_aliasing must be 'fft' or 'decimate'")
-            times = times[::factor]
-
-        number_of_samples = len(strain)
-        if start_time is None and duration is None:
-            first = int(round(trim * number_of_samples))
-            last = int(round((1 - trim) * number_of_samples))
-        elif start_time is None or duration is None:
-            raise ValueError("Give both start_time and duration")
-        else:
-            data_duration = number_of_samples / sampling_frequency
-            tolerance = 1 / sampling_frequency
-            if (start_time < times[0] + trim * data_duration - tolerance
-                    or start_time + duration > times[0] + (1 - trim) * data_duration + tolerance):
-                raise ValueError(
-                    f"The segment {start_time:.6f} - {start_time + duration:.6f} is not inside "
-                    f"the part of the data kept after trimming a fraction {trim} at each end")
-            first = int(round((start_time - times[0]) * sampling_frequency))
-            last = first + int(round(duration * sampling_frequency))
-        strain, times = strain[first:last], times[first:last]
-        if remove_mean:
-            strain = strain - np.mean(strain)
-
-        self.set_from_time_domain_strain(
-            strain, sampling_frequency=sampling_frequency,
-            duration=len(strain) / sampling_frequency, start_time=times[0])
-
     def set_from_zero_noise(self, sampling_frequency, duration, start_time=0):
         """ Set the `frequency_domain_strain` to zero noise
 
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index f1fec9634..885f35ac9 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from ..time_domain_utils import PLACEMENT_METHODS, GohbergSemenculInverse
+from ..time_domain_utils import PLACEMENT_METHODS
 from .base import GravitationalWaveTransient
 
 
@@ -11,9 +11,9 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
 
     The noise in each interferometer is a stationary Gaussian process with
     covariance matrix :math:`C_{ij} = \\rho(|i - j|)`, where :math:`\\rho` is
-    the autocovariance function (ACF) of the interferometer. For the strain
-    data :math:`d` and a template :math:`h` in the analysis window of each
-    interferometer
+    the autocovariance function (ACF) of the interferometer. For the data in
+    the analysis window, :math:`d` (:code:`interferometer.analysis_data`), and
+    a template :math:`h` on the same samples
 
     .. math::
 
@@ -22,7 +22,8 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
 
     :code:`log_likelihood_ratio` returns the first two terms and
     :code:`noise_log_likelihood` the last. :math:`C^{-1}` is applied with the
-    Gohberg-Semencul vectors stored on each interferometer.
+    operator stored on each interferometer
+    (:code:`interferometer.inverse_covariance`).
 
     The template is projected onto each interferometer and placed so that the
     model's t=0 arrives at geocent_time plus the time delay from the
@@ -32,7 +33,7 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
     ==========
     interferometers: list, bilby.gw.detector.InterferometerList
         A list of :code:`bilby.gw.detector.Interferometer` instances, each with
-        an analysis window, time-domain strain data in that window and an
+        an analysis window, time-domain strain data covering it and an
         autocovariance function.
     waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
         A WaveformGenerator with a time-domain source model, e.g.
@@ -118,14 +119,12 @@ def __repr__(self):
                 self.priors, self.placement))
 
     def _setup_noise_model(self):
-        """ Inverse covariance operator, d^T C^-1 and d^T C^-1 d for each
-        interferometer. """
-        self._inverse_covariance = dict()
+        """ d^T C^-1 and d^T C^-1 d for each interferometer. """
         self._data_times_inverse_covariance = dict()
         self._data_inverse_covariance_data = dict()
         for interferometer in self.interferometers:
             acf = interferometer.autocovariance_function
-            if acf is None:
+            if acf is None or acf.acf_array is None:
                 raise ValueError(f"{interferometer.name}: no autocovariance_function set")
             if not np.isclose(acf.sampling_frequency, interferometer.sampling_frequency,
                               rtol=1e-9, atol=0):
@@ -133,15 +132,8 @@ def _setup_noise_model(self):
                     f"{interferometer.name}: autocovariance function sampling frequency "
                     f"{acf.sampling_frequency:g} Hz differs from the data's "
                     f"{interferometer.sampling_frequency:g} Hz")
-            data = np.asarray(interferometer.time_domain_strain, dtype=float)
-            x, y = interferometer.gohberg_semencul_vectors
-            if len(x) != len(data):
-                raise ValueError(
-                    f"{interferometer.name}: the data have {len(data)} samples but the analysis "
-                    f"window has {len(x)}; crop the data to the analysis window")
-            inverse_covariance = GohbergSemenculInverse(x, y)
-            data_times_inverse_covariance = inverse_covariance(data)
-            self._inverse_covariance[interferometer.name] = inverse_covariance
+            data = interferometer.analysis_data
+            data_times_inverse_covariance = interferometer.inverse_covariance(data)
             self._data_times_inverse_covariance[interferometer.name] = data_times_inverse_covariance
             self._data_inverse_covariance_data[interferometer.name] = float(
                 np.dot(data_times_inverse_covariance, data))
@@ -159,7 +151,7 @@ def _compute_full_waveform(self, signal_polarizations, interferometer, parameter
 
         Returns
         =======
-        array_like: The template on the data samples.
+        array_like: The template on the samples of the analysis window.
         """
         return interferometer.get_time_domain_detector_response(
             signal_polarizations, parameters, placement=self.placement)
@@ -188,7 +180,7 @@ def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array
             parameters=parameters,
         )
         d_inner_h = float(np.dot(self._data_times_inverse_covariance[interferometer.name], signal))
-        optimal_snr_squared = float(np.dot(signal, self._inverse_covariance[interferometer.name](signal)))
+        optimal_snr_squared = float(np.dot(signal, interferometer.inverse_covariance(signal)))
         if optimal_snr_squared > 0:
             matched_filter_snr = d_inner_h / optimal_snr_squared ** 0.5
         else:
@@ -249,10 +241,8 @@ def generate_posterior_sample_from_marginalized_likelihood(self, parameters):
         """
         if not self.distance_marginalization:
             return parameters
-        signal_polarizations = copy.deepcopy(
-            self.waveform_generator.time_domain_strain(parameters))
         parameters['luminosity_distance'] = self.generate_distance_sample_from_marginalized_likelihood(
-            signal_polarizations=signal_polarizations, parameters=parameters)
+            parameters=parameters)
         return parameters.copy()
 
     def generate_distance_sample_from_marginalized_likelihood(
diff --git a/bilby/gw/source.py b/bilby/gw/source.py
index e92b311cd..e576ce4b0 100644
--- a/bilby/gw/source.py
+++ b/bilby/gw/source.py
@@ -817,7 +817,7 @@ def _base_lal_cbc_td_waveform(
     waveform's full length.
     """
     import lalsimulation as lalsim
-    from .time_domain_utils import one_sided_tukey_window
+    from scipy.signal.windows import tukey
 
     waveform_approximant = waveform_kwargs.pop('waveform_approximant')
     reference_frequency = waveform_kwargs.pop('reference_frequency')
@@ -880,7 +880,8 @@ def _base_lal_cbc_td_waveform(
     if len(waveform_kwargs) > 0:
         raise ValueError(UNUSED_KWARGS_MESSAGE.format(waveform_kwargs=waveform_kwargs))
 
-    window = one_sided_tukey_window(hplus.data.length, turn_on_window)
+    window = tukey(hplus.data.length, turn_on_window)
+    window[hplus.data.length // 2:] = 1
     epoch = hplus.epoch.gpsSeconds + hplus.epoch.gpsNanoSeconds * 1e-9
     return dict(plus=window * hplus.data.data, cross=window * hcross.data.data, epoch=epoch)
 
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 24211c342..a2f9da253 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -2,7 +2,7 @@
 Utilities for time-domain gravitational-wave inference.
 
 * Gohberg-Semencul representation of the inverse of a symmetric Toeplitz
-  noise covariance matrix, and the noise-weighted inner products built on it.
+  noise covariance matrix.
 * Placement of a time-domain waveform, generated on its own uniform grid, into
   a segment of detector data.
 """
@@ -83,77 +83,6 @@ def __call__(self, vector):
         return (first - second) / self.x0
 
 
-def gohberg_semencul_product(x, y, vector):
-    """ Compute C^-1 v using the Gohberg-Semencul representation, see
-    :code:`GohbergSemenculInverse`. To apply the same C^-1 many times, build a
-    :code:`GohbergSemenculInverse` once instead.
-
-    Parameters
-    ==========
-    x, y: array_like
-        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
-    vector: array_like
-        The vector to multiply, same length as x.
-
-    Returns
-    =======
-    array_like: C^-1 vector
-    """
-    return GohbergSemenculInverse(x, y)(vector)
-
-
-def time_domain_noise_weighted_inner_product(aa, bb, x, y):
-    """ Noise-weighted inner product :math:`a^T C^{-1} b`.
-
-    Parameters
-    ==========
-    aa, bb: array_like
-        Time series of equal length.
-    x, y: array_like
-        Gohberg-Semencul vectors of C^-1 for that length.
-
-    Returns
-    =======
-    float: The noise-weighted inner product.
-    """
-    return float(np.dot(aa, gohberg_semencul_product(x, y, bb)))
-
-
-def time_domain_optimal_snr_squared(signal, x, y):
-    """ Optimal SNR squared :math:`h^T C^{-1} h` of a time-domain signal. """
-    return time_domain_noise_weighted_inner_product(signal, signal, x, y)
-
-
-def time_domain_matched_filter_snr(signal, time_domain_strain, x, y):
-    """ Matched-filter SNR :math:`d^T C^{-1} h / \\sqrt{h^T C^{-1} h}`. """
-    return (
-        time_domain_noise_weighted_inner_product(time_domain_strain, signal, x, y)
-        / time_domain_optimal_snr_squared(signal, x, y) ** 0.5
-    )
-
-
-def one_sided_tukey_window(number_of_samples, alpha):
-    """ Tukey window with only the rising (left) half applied.
-
-    Parameters
-    ==========
-    number_of_samples: int
-        Length of the window.
-    alpha: float
-        Shape parameter of :code:`scipy.signal.windows.tukey`; 0 returns ones.
-
-    Returns
-    =======
-    array_like: The window.
-    """
-    from scipy.signal.windows import tukey
-    if not alpha:
-        return np.ones(number_of_samples)
-    window = tukey(number_of_samples, alpha)
-    window[number_of_samples // 2:] = 1.0
-    return window
-
-
 def fractional_time_shift(signal, fraction, pad=32):
     """ Delay a time series by a fraction of a sample with a Fourier phase
     shift, on a zero-padded copy so that nothing wraps around.
@@ -183,31 +112,6 @@ def fractional_time_shift(signal, fraction, pad=32):
     return shifted[:len(signal) + 2 * pad]
 
 
-def quadratic_peak_index(plus, cross):
-    """ Fractional index of the peak of :math:`\\sqrt{h_+^2 + h_\\times^2}`,
-    from a quadratic fit to the three samples around the maximum (as in the
-    :code:`ringdown` package).
-
-    Parameters
-    ==========
-    plus, cross: array_like
-        The two polarizations on a uniform grid.
-
-    Returns
-    =======
-    float: Peak position in (fractional) samples.
-    """
-    amplitude = np.sqrt(np.asarray(plus) ** 2 + np.asarray(cross) ** 2)
-    ib = int(np.argmax(amplitude))
-    ia = (ib - 1) % len(amplitude)
-    ic = (ib + 1) % len(amplitude)
-    a, b, c = amplitude[ia], amplitude[ib], amplitude[ic]
-    denominator = a - 2 * b + c
-    if denominator == 0:
-        return float(ib)
-    return ib + (3 * a - 4 * b + c) / (2 * denominator) - 1
-
-
 def align_peak_to_sample(waveform_polarizations, pad=32):
     """ Shift all polarizations by the same sub-sample amount so that the
     (quadratically interpolated) peak of :math:`h_+^2 + h_\\times^2` falls
@@ -227,8 +131,12 @@ def align_peak_to_sample(waveform_polarizations, pad=32):
     peak_index: int
         Index of the peak in the aligned arrays.
     """
-    peak = quadratic_peak_index(
-        waveform_polarizations["plus"], waveform_polarizations["cross"])
+    amplitude = np.sqrt(waveform_polarizations["plus"] ** 2 + waveform_polarizations["cross"] ** 2)
+    # peak from a quadratic fit to the three samples around the maximum
+    ib = int(np.argmax(amplitude))
+    a, b, c = amplitude[ib - 1], amplitude[ib], amplitude[(ib + 1) % len(amplitude)]
+    denominator = a - 2 * b + c
+    peak = float(ib) if denominator == 0 else ib + (3 * a - 4 * b + c) / (2 * denominator) - 1
     fraction = round(peak) - peak
     aligned = {mode: fractional_time_shift(value, fraction, pad=pad)
                for mode, value in waveform_polarizations.items()}
diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
index e7a87f43a..7941330a0 100644
--- a/examples/gw_examples/data_examples/GW150914_time_domain.py
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -5,7 +5,8 @@
 This is the GW150914.py analysis done in the time domain:
 
 - the strain is downloaded as a time series covering the 4 s analysis window
-  and 2 s on each side, downsampled to 2048 Hz and cropped to the window;
+  and 2 s on each side and downsampled to 2048 Hz; the likelihood uses the
+  data in the window (interferometer.analysis_data);
 - the noise model of each detector is an autocovariance function (ACF)
   computed from a PSD read with its frequency array from an HDF5 file;
 - the likelihood is bilby.gw.likelihood.TimeDomainGravitationalWaveTransient,
@@ -57,7 +58,7 @@
 for det in detectors:
     logger.info("Downloading analysis data for ifo {}".format(det))
     ifo = bilby.gw.detector.get_empty_interferometer(det)
-    ifo.set_analysis_window(start_time=start_time, duration=duration)
+    ifo.analysis_window = (start_time, duration)
     data = TimeSeries.fetch_open_data(det, start_time - padding, end_time + padding)
     ifo.strain_data.set_from_gwpy_timeseries(data)
     ifo.downsample_strain_data(sampling_frequency)
@@ -71,7 +72,7 @@
 
     # The ACF lasts 1 / (frequency spacing of the PSD), 8 s here, twice the
     # analysis segment. Outside [minimum_frequency, maximum_frequency] the PSD
-    # is set to fill_value (default 1e4) times its maximum inside the band.
+    # is set to fill_multiplier (default 1e4) times its maximum inside the band.
     ifo.autocovariance_function = (
         bilby.gw.detector.AutoCovarianceFunction.from_power_spectral_density_array(
             frequency_array,
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
index 50811c0fe..37212c708 100644
--- a/test/gw/likelihood/time_domain_test.py
+++ b/test/gw/likelihood/time_domain_test.py
@@ -116,8 +116,8 @@ def test_sampling_frequency_from_grid_and_length(self):
         acf = AutoCovarianceFunction.from_power_spectral_density_array(
             self.frequencies, self.psd, 20, 400)
         self.assertEqual(acf.sampling_frequency, 1024)
-        self.assertEqual(acf.number_of_samples, 8192)
-        self.assertAlmostEqual(acf.duration, 8)
+        self.assertEqual(len(acf.acf_array), 8192)
+        self.assertAlmostEqual(acf.meta_data["duration"], 8)
 
     def test_sampling_frequency_mismatch_warns(self):
         with self.assertLogs("bilby", level="WARNING"):
@@ -134,19 +134,21 @@ def test_grid_extended_to_zero_frequency(self):
         np.testing.assert_allclose(cut.acf_array, full.acf_array, rtol=1e-12)
 
     def test_patch_level(self):
-        fill_value = 100
-        acf = AutoCovarianceFunction.from_power_spectral_density_array(
-            self.frequencies, self.psd, 20, 400, fill_value=fill_value)
-        patched = 2 * np.fft.rfft(acf.acf_array).real / acf.sampling_frequency
         band = (self.frequencies >= 20) & (self.frequencies <= 400)
-        np.testing.assert_allclose(patched[band], self.psd[band], rtol=1e-8)
-        np.testing.assert_allclose(patched[~band], fill_value * np.max(self.psd[band]), rtol=1e-8)
+        for kwargs, level in [(dict(fill_multiplier=100), 100 * np.max(self.psd[band])),
+                              (dict(fill_value=1e-41), 1e-41)]:
+            acf = AutoCovarianceFunction.from_power_spectral_density_array(
+                self.frequencies, self.psd, 20, 400, **kwargs)
+            patched = 2 * np.fft.rfft(acf.acf_array).real / acf.sampling_frequency
+            np.testing.assert_allclose(patched[band], self.psd[band], rtol=1e-8)
+            np.testing.assert_allclose(patched[~band], level, rtol=1e-8)
+            self.assertAlmostEqual(acf.fill_value / level, 1)
 
     def test_window_longer_than_acf_raises(self):
         acf = AutoCovarianceFunction.from_power_spectral_density_array(
             self.frequencies, self.psd, 20, 400)
         with self.assertRaises(ValueError):
-            acf.get_acf_array(acf.number_of_samples + 1)
+            acf.get_acf_array(len(acf.acf_array) + 1)
 
     def test_save_and_read(self):
         acf = AutoCovarianceFunction.from_power_spectral_density_array(
@@ -205,7 +207,7 @@ def test_matches_dense_covariance(self):
         parameters = dict(INJECTION, mass_1=37.0)
         expected = 0
         for ifo in ifos:
-            data = ifo.time_domain_strain
+            data = ifo.analysis_data
             covariance = scipy.linalg.toeplitz(ifo.autocovariance_function.acf_array[:len(data)])
             signal = likelihood._compute_full_waveform(
                 generator.time_domain_strain(parameters), ifo, parameters)
@@ -281,7 +283,7 @@ def test_errors(self):
             ifo.autocovariance_function = AutoCovarianceFunction(np.ones(10), SAMPLING_FREQUENCY)
         ifos = interferometers()
         for ifo in ifos:
-            ifo.set_strain_data_from_zero_noise(SAMPLING_FREQUENCY, 2 * DURATION, START_TIME)
+            ifo.set_strain_data_from_zero_noise(SAMPLING_FREQUENCY, DURATION, START_TIME + 1)
         with self.assertRaises(ValueError):
             TimeDomainGravitationalWaveTransient(ifos, generator)
 
@@ -306,18 +308,18 @@ def test_injection_adds_to_stored_time_series(self):
             np.testing.assert_allclose(ifo.time_domain_strain, noise[ifo.name] + signal, rtol=0, atol=1e-30)
             self.assertEqual(ifo.meta_data["injection_domain"], "time")
 
-    def test_snrs_recomputed_after_cropping(self):
-        cropped = interferometers(**SEGMENTS["post_inspiral"])
-        cropped.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
+    def test_analysis_data_is_the_window_slice(self):
         full = interferometers()
         full.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
         snr_full = full[0].meta_data["optimal_SNR"]
-        for ifo, reference in zip(full, cropped):
-            ifo.set_analysis_window(reference.analysis_window["start_time"], reference.analysis_window["duration"])
-        full.crop_strain_data()
-        for ifo, reference in zip(full, cropped):
+        post_inspiral = interferometers(**SEGMENTS["post_inspiral"])
+        post_inspiral.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
+        for ifo, reference in zip(full, post_inspiral):
+            ifo.analysis_window = (reference.analysis_window["start_time"], reference.analysis_window["duration"])
             reference.autocovariance_function = ifo.autocovariance_function
-            np.testing.assert_allclose(ifo.time_domain_strain, reference.time_domain_strain, atol=1e-30)
+            self.assertEqual(len(ifo.time_domain_strain), DURATION * SAMPLING_FREQUENCY)
+            np.testing.assert_allclose(ifo.analysis_time_array, reference.analysis_time_array, atol=1e-6)
+            np.testing.assert_allclose(ifo.analysis_data, reference.analysis_data, atol=1e-30)
             self.assertAlmostEqual(ifo.meta_data["optimal_SNR"], reference.meta_data["optimal_SNR"], 8)
         self.assertLess(full[0].meta_data["optimal_SNR"], snr_full)
 
@@ -331,34 +333,35 @@ def _sine_data(self, start_time, duration, sampling_frequency=4096):
 
     def test_downsample(self):
         ifo = self._sine_data(1000.0, 16)
-        ifo.set_analysis_window(1006.0, 4)
+        ifo.analysis_window = (1006.0, 4)
         ifo.downsample_strain_data(1024)
         self.assertEqual(ifo.sampling_frequency, 1024)
-        self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
-        self.assertEqual(len(ifo.time_domain_strain), 4096)
+        self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
+        self.assertEqual(len(ifo.analysis_data), 4096)
         # the 60 Hz line is kept and the 1500 Hz line (above the new Nyquist frequency) removed
         expected = np.sin(2 * np.pi * 60 * ifo.time_array)
         np.testing.assert_allclose(ifo.time_domain_strain, expected - np.mean(expected), atol=1e-6)
 
     def test_downsample_data_slightly_off_grid(self):
         ifo = self._sine_data(1004.0001, 8)
-        ifo.set_analysis_window(1006.0, 4)
+        ifo.analysis_window = (1006.0, 4)
         ifo.downsample_strain_data(1024)
-        self.assertEqual(len(ifo.time_domain_strain), 4096)
-        self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0, 3)
+        self.assertEqual(len(ifo.analysis_data), 4096)
+        self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0, 3)
 
     def test_downsample_needs_buffer(self):
         ifo = self._sine_data(1005.0, 6)
-        ifo.set_analysis_window(1006.0, 4)
+        ifo.analysis_window = (1006.0, 4)
         with self.assertRaises(ValueError):
             ifo.downsample_strain_data(1024)
 
-    def test_no_conditioning_crops(self):
+    def test_no_conditioning_keeps_data(self):
         ifo = self._sine_data(1000.0, 16)
-        ifo.set_analysis_window(1006.0, 4)
+        ifo.analysis_window = (1006.0, 4)
         ifo.downsample_strain_data(4096)
-        self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
-        self.assertEqual(len(ifo.time_domain_strain), 4 * 4096)
+        self.assertEqual(len(ifo.time_domain_strain), 16 * 4096)
+        self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
+        self.assertEqual(len(ifo.analysis_data), 4 * 4096)
 
     def test_network_downsample(self):
         ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
@@ -368,8 +371,8 @@ def test_network_downsample(self):
         ifos.downsample_strain_data(2048)
         for ifo in ifos:
             self.assertEqual(ifo.sampling_frequency, 2048)
-            self.assertAlmostEqual(ifo.strain_data.start_time, 1006.0)
-            self.assertEqual(len(ifo.time_domain_strain), 4 * 2048)
+            self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
+            self.assertEqual(len(ifo.analysis_data), 4 * 2048)
 
 
 class TestTimeDomainSourceModels(unittest.TestCase):
@@ -470,7 +473,7 @@ def test_welch_acf_agrees_with_psd_acf(self):
         ifo.strain_data.set_from_power_spectral_density_time_domain(
             ifo.power_spectral_density, SAMPLING_FREQUENCY, 256, 0, random_state=11)
         noise = ifo.time_domain_strain.copy()
-        ifo.set_analysis_window(0, 1)
+        ifo.analysis_window = (0, 1)
         ifo.set_autocovariance_function_from_power_spectral_density()
         from_data = AutoCovarianceFunction.from_time_domain_strain(
             noise, SAMPLING_FREQUENCY, analysis_duration=1, minimum_frequency=20, maximum_frequency=448)

From b0ba2a7aa06c54cafac22bc226673576e1955259 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Fri, 9 Oct 2026 15:25:00 +0530
Subject: [PATCH 04/21] A few functions removed

---
 bilby/gw/detector/acf.py                      | 43 +-------
 bilby/gw/detector/condition_data.py           | 61 +++---------
 bilby/gw/detector/interferometer.py           | 67 +++++--------
 bilby/gw/detector/networks.py                 | 18 ++--
 bilby/gw/likelihood/time_domain.py            | 22 +++--
 bilby/gw/time_domain_utils.py                 | 98 ++++++-------------
 .../data_examples/GW150914_time_domain.py     |  2 +-
 test/gw/likelihood/time_domain_test.py        | 36 ++-----
 8 files changed, 100 insertions(+), 247 deletions(-)

diff --git a/bilby/gw/detector/acf.py b/bilby/gw/detector/acf.py
index 172460c08..280d8a5ad 100644
--- a/bilby/gw/detector/acf.py
+++ b/bilby/gw/detector/acf.py
@@ -198,36 +198,10 @@ def from_time_domain_strain(
             sampling_frequency=sampling_frequency, fill_value=fill_value,
             fill_multiplier=fill_multiplier)
 
-    @classmethod
-    def from_file(cls, filename, sampling_frequency=None):
-        """ Read a precomputed ACF from a text file.
-
-        Parameters
-        ==========
-        filename: str
-            File with either two columns, lag (s) and ACF (as written by
-            :code:`save`), or a single column with the ACF.
-        sampling_frequency: float, optional
-            Sampling frequency of the lags (Hz). Required for a single-column
-            file; for a two-column file it is computed from the lags.
-
-        Returns
-        =======
-        AutoCovarianceFunction
-        """
-        data = np.loadtxt(filename)
-        if data.ndim == 2:
-            return cls(acf_array=data[:, 1], sampling_frequency=1 / (data[1, 0] - data[0, 0]))
-        if sampling_frequency is None:
-            raise ValueError("sampling_frequency is required for a single-column ACF file")
-        return cls(acf_array=data, sampling_frequency=sampling_frequency)
-
     def get_acf_array(self, number_of_samples):
         """ First `number_of_samples` lags of the ACF.
 
-        A ValueError is raised if the ACF is shorter than `number_of_samples`,
-        and a warning is logged if it is shorter than twice
-        `number_of_samples`.
+        A ValueError is raised if the ACF is shorter than `number_of_samples`.
 
         Parameters
         ==========
@@ -242,10 +216,6 @@ def get_acf_array(self, number_of_samples):
             raise ValueError(
                 f"The analysis segment ({number_of_samples} samples) is longer than the ACF "
                 f"({len(self.acf_array)} samples)")
-        if 2 * number_of_samples > len(self.acf_array):
-            logger.warning(
-                f"The ACF ({len(self.acf_array)} samples) is shorter than twice the analysis "
-                f"segment ({number_of_samples} samples)")
         return self.acf_array[:number_of_samples]
 
     def gohberg_semencul_vectors(self, number_of_samples):
@@ -264,17 +234,6 @@ def gohberg_semencul_vectors(self, number_of_samples):
         """
         return gohberg_semencul_vectors(self.get_acf_array(number_of_samples))
 
-    def save(self, filename):
-        """ Save the ACF to a text file with two columns, lag (s) and ACF.
-
-        Parameters
-        ==========
-        filename: str
-            Name of the output file.
-        """
-        lags = np.arange(len(self.acf_array)) / self.sampling_frequency
-        np.savetxt(filename, np.array([lags, self.acf_array]).T, header="lag acf")
-
 
 def read_power_spectral_densities_from_hdf5(filename, interferometers, label=None):
     """ Read power spectral densities and their frequency arrays from an HDF5
diff --git a/bilby/gw/detector/condition_data.py b/bilby/gw/detector/condition_data.py
index 7277022df..c82ab0f9b 100644
--- a/bilby/gw/detector/condition_data.py
+++ b/bilby/gw/detector/condition_data.py
@@ -1,12 +1,9 @@
 import numpy as np
 
 
-def condition_strain_data(
-        strain_data, sampling_frequency, start_time, duration, minimum_frequency=None,
-        maximum_frequency=None, anti_aliasing="fft", trim=0.25, remove_mean=True,
-        decimate_kwargs=None):
-    """ Condition and downsample time-domain strain data around an analysis
-    window.
+def condition_strain_data(strain_data, sampling_frequency, start_time, duration, trim=0.25,
+                          remove_mean=True):
+    """ Downsample time-domain strain data around an analysis window.
 
     Steps:
 
@@ -16,16 +13,12 @@ def condition_strain_data(
        not cover them.
     2. Shift the data by fewer than `factor` samples (factor = current / new
        sampling frequency) so that the sample nearest `start_time` is kept.
-    3. If `minimum_frequency` and/or `maximum_frequency` are given, apply an
-       order-4 Butterworth high-, low- or band-pass filter forwards and
-       backwards.
-    4. Anti-aliasing and decimation: with `anti_aliasing="fft"`, multiply by a
-       Tukey window with alpha = `trim`, set all frequencies above the new
-       Nyquist frequency to zero and keep every factor-th sample; with
-       `anti_aliasing="decimate"`, use :code:`scipy.signal.decimate`.
-    5. Remove a fraction `trim` of the samples at each end; this removes the
+    3. Multiply by a Tukey window with alpha = `trim`, set all frequencies
+       above the new Nyquist frequency to zero and keep every factor-th
+       sample.
+    4. Remove a fraction `trim` of the samples at each end; this removes the
        buffer. Samples in the window are always kept.
-    6. Subtract the mean if `remove_mean`.
+    5. Subtract the mean if `remove_mean`.
 
     The result replaces the data in `strain_data`.
 
@@ -39,20 +32,11 @@ def condition_strain_data(
         GPS start time of the analysis window (s).
     duration: float
         Duration of the analysis window (s).
-    minimum_frequency: float, optional
-        High-pass corner frequency of the Butterworth filter (Hz).
-    maximum_frequency: float, optional
-        Low-pass corner frequency of the Butterworth filter (Hz).
-    anti_aliasing: str
-        "fft" (default) or "decimate".
     trim: float
         Fraction of the data at each end that is removed (default 0.25).
     remove_mean: bool
         Subtract the mean of the result (default True).
-    decimate_kwargs: dict, optional
-        Keyword arguments of :code:`scipy.signal.decimate`.
     """
-    from scipy import signal
     from scipy.signal.windows import tukey
 
     original_sampling_frequency = float(strain_data.sampling_frequency)
@@ -79,35 +63,18 @@ def condition_strain_data(
 
     shift = int(np.argmin(abs(times - start_time))) % factor
     if trim > 0:
-        # the wrapped samples are at the end and are removed in step 5
+        # the wrapped samples are at the end and are removed in step 4
         times = np.roll(times, -shift)
         strain = np.roll(strain, -shift)
     else:
         times = times[shift:]
         strain = strain[shift:]
 
-    nyquist_frequency = 0.5 * original_sampling_frequency
-    if minimum_frequency or maximum_frequency:
-        if minimum_frequency and not maximum_frequency:
-            b, a = signal.butter(4, minimum_frequency / nyquist_frequency, btype="highpass")
-        elif maximum_frequency and not minimum_frequency:
-            b, a = signal.butter(4, maximum_frequency / nyquist_frequency, btype="lowpass")
-        else:
-            b, a = signal.butter(4, (minimum_frequency / nyquist_frequency,
-                                     maximum_frequency / nyquist_frequency), btype="bandpass")
-        strain = signal.filtfilt(b, a, strain)
-
-    if factor > 1:
-        if anti_aliasing == "fft":
-            strain_fd = np.fft.rfft(strain * tukey(len(strain), trim))
-            frequencies = np.fft.rfftfreq(len(strain), 1 / original_sampling_frequency)
-            strain_fd[frequencies > nyquist_frequency / factor] = 0
-            strain = np.fft.irfft(strain_fd, n=len(strain))[::factor]
-        elif anti_aliasing == "decimate":
-            strain = signal.decimate(strain, factor, zero_phase=True, **(decimate_kwargs or {}))
-        else:
-            raise ValueError("anti_aliasing must be 'fft' or 'decimate'")
-        times = times[::factor]
+    strain_fd = np.fft.rfft(strain * tukey(len(strain), trim))
+    frequencies = np.fft.rfftfreq(len(strain), 1 / original_sampling_frequency)
+    strain_fd[frequencies > sampling_frequency / 2] = 0
+    strain = np.fft.irfft(strain_fd, n=len(strain))[::factor]
+    times = times[::factor]
 
     # remove the fraction trim at each end, but always keep the window
     window_first = int(np.argmin(abs(times - start_time)))
diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index 91ecf46f5..537b43de8 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -14,11 +14,7 @@
 from .calibration import Recalibrate
 from .geometry import InterferometerGeometry
 from .strain_data import InterferometerStrainData
-from ..time_domain_utils import (
-    GohbergSemenculInverse,
-    align_peak_to_sample,
-    place_time_domain_signal,
-)
+from ..time_domain_utils import gohberg_semencul_product, place_time_domain_signal
 from ..conversion import generate_all_bbh_parameters
 
 
@@ -102,7 +98,6 @@ def __init__(self, name, power_spectral_density, minimum_frequency, maximum_freq
         self._analysis_window = None
         self._injected_signal = None
         self.gohberg_semencul_vectors = None
-        self.inverse_covariance = None
 
     def __eq__(self, other):
         if self.name == other.name and \
@@ -337,37 +332,27 @@ def set_strain_data_from_zero_noise_time_domain(self, sampling_frequency):
             sampling_frequency=sampling_frequency, duration=duration, start_time=start_time)
         self._injected_signal = None
 
-    def downsample_strain_data(self, sampling_frequency, **kwargs):
-        """ Condition and downsample the time-domain strain data around the
-        analysis window.
+    def condition_strain_data(self, sampling_frequency, trim=0.25, remove_mean=True):
+        """ Downsample the time-domain strain data around the analysis window.
 
-        See :code:`bilby.gw.detector.condition_data.condition_strain_data`. If
-        the data are already at `sampling_frequency` and no filter is
-        requested, they are left unchanged.
+        See :code:`bilby.gw.detector.condition_data.condition_strain_data`.
+        Any injected signal is not conditioned, and its SNRs are removed from
+        :code:`meta_data`.
 
         Parameters
         ==========
         sampling_frequency: float
             New sampling frequency (Hz); must divide the current one.
-        kwargs:
-            Passed to :code:`condition_strain_data` (minimum_frequency,
-            maximum_frequency, anti_aliasing, trim, remove_mean,
-            decimate_kwargs).
+        trim: float
+            Fraction of the data at each end that is removed (default 0.25).
+        remove_mean: bool
+            Subtract the mean of the result (default True).
         """
         from .condition_data import condition_strain_data
         start_time, duration = self._require_analysis_window()
-        no_filter = kwargs.get("minimum_frequency") is None and kwargs.get("maximum_frequency") is None
-        if self.strain_data.sampling_frequency == sampling_frequency and no_filter:
-            return
-        if self._injected_signal is not None:
-            # condition the injected signal in the same way, for its SNRs
-            injected_signal = InterferometerStrainData()
-            injected_signal.set_from_time_domain_strain(
-                self._injected_signal, sampling_frequency=self.strain_data.sampling_frequency,
-                duration=self.strain_data.duration, start_time=self.strain_data.start_time)
-            condition_strain_data(injected_signal, sampling_frequency, start_time, duration, **kwargs)
-            self._injected_signal = injected_signal.time_domain_strain
-        condition_strain_data(self.strain_data, sampling_frequency, start_time, duration, **kwargs)
+        condition_strain_data(self.strain_data, sampling_frequency, start_time, duration,
+                              trim=trim, remove_mean=remove_mean)
+        self._injected_signal = None
         self._update_injection_snrs()
 
     def _analysis_slice(self):
@@ -412,7 +397,6 @@ def autocovariance_function(self, autocovariance_function):
             self._require_analysis_window()
         self._autocovariance_function = autocovariance_function
         self.gohberg_semencul_vectors = None
-        self.inverse_covariance = None
         if autocovariance_function is None:
             self.meta_data.pop("autocovariance_function", None)
         else:
@@ -422,14 +406,12 @@ def autocovariance_function(self, autocovariance_function):
 
     def _set_gohberg_semencul_vectors(self):
         """ Compute the Gohberg-Semencul vectors (x, y) of the inverse noise
-        covariance matrix for the analysis window, and the operator applying
-        it, and store them in :code:`gohberg_semencul_vectors` and
-        :code:`inverse_covariance`. """
+        covariance matrix for the analysis window and store them in
+        :code:`gohberg_semencul_vectors`. """
         number_of_samples = int(round(
             self.analysis_window["duration"] * self.autocovariance_function.sampling_frequency))
         self.gohberg_semencul_vectors = self.autocovariance_function.gohberg_semencul_vectors(
             number_of_samples)
-        self.inverse_covariance = GohbergSemenculInverse(*self.gohberg_semencul_vectors)
         self._update_injection_snrs()
 
     def set_autocovariance_function_from_power_spectral_density(
@@ -603,10 +585,8 @@ def get_time_domain_detector_response(self, waveform_polarizations, parameters,
         parameters: dict
             Parameters describing position and time of arrival of the signal.
         placement: str
-            "nearest" (default), "subsample" or "fd_shift"; see
+            "nearest" (default) or "fd_shift"; see
             :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
-            With "subsample", geocent_time is the time of the peak of
-            h_+^2 + h_x^2 instead of the model's t=0.
 
         Returns
         =======
@@ -631,8 +611,6 @@ def _time_domain_detector_response(self, waveform_polarizations, parameters, sta
         polarizations = {mode: value for mode, value in waveform_polarizations.items()
                          if mode != "epoch"}
         merger_index = -waveform_polarizations["epoch"] * sampling_frequency
-        if placement == "subsample":
-            polarizations, merger_index = align_peak_to_sample(polarizations)
 
         if self.reference_time is None:
             antenna_time = parameters["geocent_time"]
@@ -661,7 +639,7 @@ def _update_injection_snrs(self):
         in the analysis window in :code:`meta_data`. """
         for key in ["optimal_SNR", "matched_filter_SNR"]:
             self.meta_data.pop(key, None)
-        if (self._injected_signal is None or self.inverse_covariance is None
+        if (self._injected_signal is None or self.gohberg_semencul_vectors is None
                 or len(self._injected_signal) != len(self.strain_data.time_domain_strain)):
             return
         try:
@@ -669,9 +647,10 @@ def _update_injection_snrs(self):
         except ValueError:
             return
         signal = self._injected_signal[analysis_slice]
-        if len(signal) != self.inverse_covariance.number_of_samples:
+        x, y = self.gohberg_semencul_vectors
+        if len(signal) != len(x):
             return
-        inverse_covariance_signal = self.inverse_covariance(signal)
+        inverse_covariance_signal = gohberg_semencul_product(x, y, signal)
         optimal_snr = float(np.dot(signal, inverse_covariance_signal)) ** 0.5
         self.meta_data['optimal_SNR'] = optimal_snr
         self.meta_data['matched_filter_SNR'] = float(
@@ -703,7 +682,7 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
             A WaveformGenerator with a time-domain source model, e.g.
             :code:`bilby.gw.source.lal_binary_black_hole_time_domain`.
         placement: str
-            "nearest" (default), "subsample" or "fd_shift"; see
+            "nearest" (default) or "fd_shift"; see
             :code:`get_time_domain_detector_response`.
 
         Returns
@@ -735,7 +714,7 @@ def inject_signal_time_domain_from_waveform_generator(self, parameters, waveform
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
             A WaveformGenerator with a time-domain source model.
         placement: str
-            "nearest" (default), "subsample" or "fd_shift".
+            "nearest" (default) or "fd_shift".
 
         Returns
         =======
@@ -762,7 +741,7 @@ def inject_signal_time_domain_from_waveform_polarizations(self, parameters, inje
         injection_polarizations: dict
             Output of a time-domain source model (polarizations and 'epoch').
         placement: str
-            "nearest" (default), "subsample" or "fd_shift".
+            "nearest" (default) or "fd_shift".
         """
         if not self.strain_data.time_within_data(parameters['geocent_time']):
             logger.warning(
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index 2c8612725..6c231dca2 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -294,20 +294,24 @@ def set_autocovariance_functions_from_power_spectral_densities(self, **kwargs):
         for interferometer in self:
             interferometer.set_autocovariance_function_from_power_spectral_density(**kwargs)
 
-    def downsample_strain_data(self, sampling_frequency, **kwargs):
-        """Condition and downsample the time-domain strain data of each
-        detector around its analysis window.
+    def condition_strain_data(self, sampling_frequency, trim=0.25, remove_mean=True):
+        """Downsample the time-domain strain data of each detector around its
+        analysis window.
 
-        See :py:meth:`bilby.gw.detector.Interferometer.downsample_strain_data`
-        for the keyword arguments.
+        See :py:meth:`bilby.gw.detector.Interferometer.condition_strain_data`.
 
         Parameters
         ==========
         sampling_frequency: float
             The new sampling frequency (Hz).
+        trim: float
+            Fraction of the data at each end that is removed (default 0.25).
+        remove_mean: bool
+            Subtract the mean of the result (default True).
         """
         for interferometer in self:
-            interferometer.downsample_strain_data(sampling_frequency, **kwargs)
+            interferometer.condition_strain_data(
+                sampling_frequency, trim=trim, remove_mean=remove_mean)
 
     def inject_signal_time_domain(
         self,
@@ -330,7 +334,7 @@ def inject_signal_time_domain(
             A WaveformGenerator with a time-domain source model. The waveform is
             generated once and projected onto every detector.
         placement: str
-            "nearest" (default), "subsample" or "fd_shift"; see
+            "nearest" (default) or "fd_shift"; see
             :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
 
         Returns
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index 885f35ac9..4d2464702 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from ..time_domain_utils import PLACEMENT_METHODS
+from ..time_domain_utils import PLACEMENT_METHODS, gohberg_semencul_product
 from .base import GravitationalWaveTransient
 
 
@@ -21,9 +21,10 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
         - \\frac{1}{2} h^T C^{-1} h - \\frac{1}{2} d^T C^{-1} d \\right].
 
     :code:`log_likelihood_ratio` returns the first two terms and
-    :code:`noise_log_likelihood` the last. :math:`C^{-1}` is applied with the
-    operator stored on each interferometer
-    (:code:`interferometer.inverse_covariance`).
+    :code:`noise_log_likelihood` the last. Products with :math:`C^{-1}` are
+    computed from the Gohberg-Semencul vectors stored on each interferometer
+    (:code:`interferometer.gohberg_semencul_vectors`), without forming
+    :math:`C^{-1}`.
 
     The template is projected onto each interferometer and placed so that the
     model's t=0 arrives at geocent_time plus the time delay from the
@@ -58,10 +59,9 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
         Name of the reference for the sampled time parameter, as in
         :code:`GravitationalWaveTransient`.
     placement: str, optional
-        How the template is placed on the data samples: "nearest" (default),
-        "subsample" or "fd_shift"; see
-        :code:`bilby.gw.time_domain_utils.place_time_domain_signal`. Use the
-        same placement for injection and analysis.
+        How the template is placed on the data samples: "nearest" (default)
+        or "fd_shift"; see :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
+        Use the same placement for injection and analysis.
     time_marginalization, phase_marginalization, calibration_marginalization: bool
         Not implemented for this likelihood; must be False.
 
@@ -133,7 +133,8 @@ def _setup_noise_model(self):
                     f"{acf.sampling_frequency:g} Hz differs from the data's "
                     f"{interferometer.sampling_frequency:g} Hz")
             data = interferometer.analysis_data
-            data_times_inverse_covariance = interferometer.inverse_covariance(data)
+            data_times_inverse_covariance = gohberg_semencul_product(
+                *interferometer.gohberg_semencul_vectors, data)
             self._data_times_inverse_covariance[interferometer.name] = data_times_inverse_covariance
             self._data_inverse_covariance_data[interferometer.name] = float(
                 np.dot(data_times_inverse_covariance, data))
@@ -180,7 +181,8 @@ def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array
             parameters=parameters,
         )
         d_inner_h = float(np.dot(self._data_times_inverse_covariance[interferometer.name], signal))
-        optimal_snr_squared = float(np.dot(signal, interferometer.inverse_covariance(signal)))
+        optimal_snr_squared = float(np.dot(
+            signal, gohberg_semencul_product(*interferometer.gohberg_semencul_vectors, signal)))
         if optimal_snr_squared > 0:
             matched_filter_snr = d_inner_h / optimal_snr_squared ** 0.5
         else:
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index a2f9da253..8629f1d23 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -10,7 +10,7 @@
 from scipy.fft import next_fast_len
 from scipy.linalg import solve_toeplitz
 
-PLACEMENT_METHODS = ("nearest", "subsample", "fd_shift")
+PLACEMENT_METHODS = ("nearest", "fd_shift")
 
 
 def gohberg_semencul_vectors(acf):
@@ -35,52 +35,46 @@ def gohberg_semencul_vectors(acf):
     return x, x[::-1]
 
 
-class GohbergSemenculInverse(object):
-    """ Inverse of a symmetric Toeplitz matrix in Gohberg-Semencul form
+def gohberg_semencul_product(x, y, vector):
+    """ Product :math:`C^{-1} v` of the inverse of a symmetric Toeplitz matrix
+    with a vector, from its Gohberg-Semencul vectors, without forming
+    :math:`C^{-1}`:
 
     .. math::
 
-        C^{-1} = \\frac{1}{x_0} \\left[ L(x) L(x)^T - L(Z y) L(Z y)^T \\right]
+        C^{-1} v = \\frac{1}{x_0} \\left[ L(x) L(x)^T v - L(Z y) L(Z y)^T v \\right],
 
     where :math:`L(w)` is the lower-triangular Toeplitz matrix with first
-    column :math:`w` and :math:`Z` shifts down by one sample. The Fourier
-    transforms of :math:`x` and :math:`Z y` are computed once, so each product
-    :math:`C^{-1} v` costs one forward and two inverse FFTs per factor, of
-    length :code:`next_fast_len(2 N - 1)`.
+    column :math:`w` and :math:`Z` shifts down by one sample. Each product
+    with a triangular Toeplitz matrix is computed with FFTs of length
+    :code:`next_fast_len(2 N - 1)`.
 
     Parameters
     ==========
     x, y: array_like
         Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
-    """
+    vector: array_like
+        The vector v, of the same length as x.
 
-    def __init__(self, x, y):
-        x = np.asarray(x, dtype=float)
-        y = np.asarray(y, dtype=float)
-        self.number_of_samples = len(x)
-        self.fft_length = next_fast_len(2 * self.number_of_samples - 1, real=True)
-        self.x0 = x[0]
-        self._x_fft = np.fft.rfft(x, n=self.fft_length)
-        self._zy_fft = np.fft.rfft(np.concatenate(([0.0], y[:-1])), n=self.fft_length)
+    Returns
+    =======
+    array_like: :math:`C^{-1} v`
+    """
+    x = np.asarray(x, dtype=float)
+    number_of_samples = len(x)
+    fft_length = next_fast_len(2 * number_of_samples - 1, real=True)
+    x_fft = np.fft.rfft(x, n=fft_length)
+    zy_fft = np.fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
 
-    def _lower(self, w_fft, vector_fft):
+    def lower(w_fft, vector_fft):
         """ L(w) v from the transforms of w and v. """
-        return np.fft.irfft(w_fft * vector_fft, n=self.fft_length)[:self.number_of_samples]
-
-    def __call__(self, vector):
-        """ C^-1 vector. """
-        vector = np.asarray(vector, dtype=float)
-        if len(vector) != self.number_of_samples:
-            raise ValueError(
-                f"vector has {len(vector)} samples, expected {self.number_of_samples}")
-        n = self.fft_length
-        # L(w)^T v = reverse(L(w) reverse(v))
-        reversed_fft = np.fft.rfft(vector[::-1], n=n)
-        first = self._lower(self._x_fft, np.fft.rfft(
-            self._lower(self._x_fft, reversed_fft)[::-1], n=n))
-        second = self._lower(self._zy_fft, np.fft.rfft(
-            self._lower(self._zy_fft, reversed_fft)[::-1], n=n))
-        return (first - second) / self.x0
+        return np.fft.irfft(w_fft * vector_fft, n=fft_length)[:number_of_samples]
+
+    # L(w)^T v = reverse(L(w) reverse(v))
+    reversed_fft = np.fft.rfft(np.asarray(vector, dtype=float)[::-1], n=fft_length)
+    first = lower(x_fft, np.fft.rfft(lower(x_fft, reversed_fft)[::-1], n=fft_length))
+    second = lower(zy_fft, np.fft.rfft(lower(zy_fft, reversed_fft)[::-1], n=fft_length))
+    return (first - second) / x[0]
 
 
 def fractional_time_shift(signal, fraction, pad=32):
@@ -112,37 +106,6 @@ def fractional_time_shift(signal, fraction, pad=32):
     return shifted[:len(signal) + 2 * pad]
 
 
-def align_peak_to_sample(waveform_polarizations, pad=32):
-    """ Shift all polarizations by the same sub-sample amount so that the
-    (quadratically interpolated) peak of :math:`h_+^2 + h_\\times^2` falls
-    exactly on a sample (:code:`ringdown`'s :code:`subsample_placement`).
-
-    Parameters
-    ==========
-    waveform_polarizations: dict
-        Polarizations on their own uniform grid (no 'epoch' key).
-    pad: int
-        Zero padding added on each side before shifting.
-
-    Returns
-    =======
-    aligned: dict
-        The shifted polarizations (each padded by :code:`pad` on both sides).
-    peak_index: int
-        Index of the peak in the aligned arrays.
-    """
-    amplitude = np.sqrt(waveform_polarizations["plus"] ** 2 + waveform_polarizations["cross"] ** 2)
-    # peak from a quadratic fit to the three samples around the maximum
-    ib = int(np.argmax(amplitude))
-    a, b, c = amplitude[ib - 1], amplitude[ib], amplitude[(ib + 1) % len(amplitude)]
-    denominator = a - 2 * b + c
-    peak = float(ib) if denominator == 0 else ib + (3 * a - 4 * b + c) / (2 * denominator) - 1
-    fraction = round(peak) - peak
-    aligned = {mode: fractional_time_shift(value, fraction, pad=pad)
-               for mode, value in waveform_polarizations.items()}
-    return aligned, int(round(peak)) + pad
-
-
 def _copy_into_segment(signal, offset, number_of_samples):
     """ Put signal sample k at data index offset + k and return data indices
     [0, number_of_samples); zero elsewhere. """
@@ -177,9 +140,6 @@ def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samp
     placement: str
         - "nearest" (default): `merger_index` and `arrival_index` are each
           rounded to the nearest sample.
-        - "subsample": as "nearest", with `merger_index` the peak index
-          returned by :code:`align_peak_to_sample`, so that `arrival_index`
-          refers to the peak of :math:`h_+^2 + h_\\times^2`.
         - "fd_shift": whole samples are shifted by index and the remaining
           fraction with a Fourier phase shift of a zero-padded copy.
 
@@ -187,7 +147,7 @@ def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samp
     =======
     array_like: The signal on the data samples.
     """
-    if placement in ("nearest", "subsample"):
+    if placement == "nearest":
         offset = round(arrival_index) - round(merger_index)
         return _copy_into_segment(signal, offset, number_of_samples)
     elif placement == "fd_shift":
diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
index 7941330a0..226b33eec 100644
--- a/examples/gw_examples/data_examples/GW150914_time_domain.py
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -61,7 +61,7 @@
     ifo.analysis_window = (start_time, duration)
     data = TimeSeries.fetch_open_data(det, start_time - padding, end_time + padding)
     ifo.strain_data.set_from_gwpy_timeseries(data)
-    ifo.downsample_strain_data(sampling_frequency)
+    ifo.condition_strain_data(sampling_frequency)
 
     frequency_array, psd_array = psds[det]
     ifo.power_spectral_density = bilby.gw.detector.PowerSpectralDensity(
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
index 37212c708..2d07a9bf7 100644
--- a/test/gw/likelihood/time_domain_test.py
+++ b/test/gw/likelihood/time_domain_test.py
@@ -11,8 +11,8 @@
 from bilby.gw.detector import AutoCovarianceFunction
 from bilby.gw.likelihood import TimeDomainGravitationalWaveTransient
 from bilby.gw.time_domain_utils import (
-    GohbergSemenculInverse,
     fractional_time_shift,
+    gohberg_semencul_product,
     gohberg_semencul_vectors,
     place_time_domain_signal,
 )
@@ -69,7 +69,7 @@ def test_inverse_matches_dense_solve(self):
             x, y = gohberg_semencul_vectors(acf[:number_of_samples])
             vector = rng.normal(size=number_of_samples)
             expected = np.linalg.solve(scipy.linalg.toeplitz(acf[:number_of_samples]), vector)
-            np.testing.assert_allclose(GohbergSemenculInverse(x, y)(vector), expected,
+            np.testing.assert_allclose(gohberg_semencul_product(x, y, vector), expected,
                                        rtol=0, atol=1e-10 * np.max(abs(expected)))
 
 
@@ -150,27 +150,10 @@ def test_window_longer_than_acf_raises(self):
         with self.assertRaises(ValueError):
             acf.get_acf_array(len(acf.acf_array) + 1)
 
-    def test_save_and_read(self):
-        acf = AutoCovarianceFunction.from_power_spectral_density_array(
-            self.frequencies, self.psd, 20, 400)
-        directory = tempfile.mkdtemp()
-        try:
-            filename = os.path.join(directory, "acf.dat")
-            acf.save(filename)
-            new = AutoCovarianceFunction.from_file(filename)
-            single = os.path.join(directory, "acf_single.dat")
-            np.savetxt(single, acf.acf_array)
-            from_single = AutoCovarianceFunction.from_file(single, sampling_frequency=1024)
-        finally:
-            shutil.rmtree(directory)
-        self.assertAlmostEqual(new.sampling_frequency, acf.sampling_frequency)
-        np.testing.assert_allclose(new.acf_array, acf.acf_array, rtol=1e-12)
-        np.testing.assert_allclose(from_single.acf_array, acf.acf_array, rtol=1e-12)
-
 
 class TestTimeDomainLikelihood(unittest.TestCase):
     def test_zero_noise_log_likelihood_ratio_is_half_snr_squared(self):
-        for placement in ["nearest", "subsample", "fd_shift"]:
+        for placement in ["nearest", "fd_shift"]:
             for segment, kwargs in SEGMENTS.items():
                 with self.subTest(placement=placement, segment=segment):
                     ifos = interferometers(**kwargs)
@@ -334,7 +317,7 @@ def _sine_data(self, start_time, duration, sampling_frequency=4096):
     def test_downsample(self):
         ifo = self._sine_data(1000.0, 16)
         ifo.analysis_window = (1006.0, 4)
-        ifo.downsample_strain_data(1024)
+        ifo.condition_strain_data(1024)
         self.assertEqual(ifo.sampling_frequency, 1024)
         self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
         self.assertEqual(len(ifo.analysis_data), 4096)
@@ -345,7 +328,7 @@ def test_downsample(self):
     def test_downsample_data_slightly_off_grid(self):
         ifo = self._sine_data(1004.0001, 8)
         ifo.analysis_window = (1006.0, 4)
-        ifo.downsample_strain_data(1024)
+        ifo.condition_strain_data(1024)
         self.assertEqual(len(ifo.analysis_data), 4096)
         self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0, 3)
 
@@ -353,12 +336,11 @@ def test_downsample_needs_buffer(self):
         ifo = self._sine_data(1005.0, 6)
         ifo.analysis_window = (1006.0, 4)
         with self.assertRaises(ValueError):
-            ifo.downsample_strain_data(1024)
+            ifo.condition_strain_data(1024)
 
-    def test_no_conditioning_keeps_data(self):
+    def test_data_not_conditioned_by_default(self):
         ifo = self._sine_data(1000.0, 16)
         ifo.analysis_window = (1006.0, 4)
-        ifo.downsample_strain_data(4096)
         self.assertEqual(len(ifo.time_domain_strain), 16 * 4096)
         self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
         self.assertEqual(len(ifo.analysis_data), 4 * 4096)
@@ -368,7 +350,7 @@ def test_network_downsample(self):
         ifos.set_analysis_windows(duration=16, start_time=1000)
         ifos.set_strain_data_from_power_spectral_densities_time_domain(4096, random_state=2)
         ifos.set_analysis_windows(duration=4, start_time=1006)
-        ifos.downsample_strain_data(2048)
+        ifos.condition_strain_data(2048)
         for ifo in ifos:
             self.assertEqual(ifo.sampling_frequency, 2048)
             self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
@@ -479,7 +461,7 @@ def test_welch_acf_agrees_with_psd_acf(self):
             noise, SAMPLING_FREQUENCY, analysis_duration=1, minimum_frequency=20, maximum_frequency=448)
         times = np.arange(SAMPLING_FREQUENCY) / SAMPLING_FREQUENCY
         signal = 1e-22 * np.exp(-0.5 * ((times - 0.5) / 0.05) ** 2) * np.sin(2 * np.pi * 120 * times)
-        snr_squared = [GohbergSemenculInverse(*acf.gohberg_semencul_vectors(len(times)))(signal) @ signal
+        snr_squared = [gohberg_semencul_product(*acf.gohberg_semencul_vectors(len(times)), signal) @ signal
                        for acf in [ifo.autocovariance_function, from_data]]
         self.assertAlmostEqual(snr_squared[1] / snr_squared[0], 1, delta=0.1)
 

From bab2155ca92536fb844edf1a45cded683172750e Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Fri, 9 Oct 2026 16:17:57 +0530
Subject: [PATCH 05/21] removed set_strain_from_psd_time_domain function

---
 bilby/gw/detector/condition_data.py           |  82 +++++++++-----
 bilby/gw/detector/interferometer.py           | 102 +++++-------------
 bilby/gw/detector/networks.py                 |  39 ++-----
 bilby/gw/detector/strain_data.py              |  36 -------
 bilby/gw/likelihood/time_domain.py            |   7 +-
 bilby/gw/time_domain_utils.py                 |   4 +-
 ...binary_neutron_star_time_domain_example.py |   8 +-
 test/gw/likelihood/time_domain_test.py        |  51 +++++----
 8 files changed, 128 insertions(+), 201 deletions(-)

diff --git a/bilby/gw/detector/condition_data.py b/bilby/gw/detector/condition_data.py
index c82ab0f9b..86b71696b 100644
--- a/bilby/gw/detector/condition_data.py
+++ b/bilby/gw/detector/condition_data.py
@@ -1,18 +1,19 @@
 import numpy as np
 
 
-def condition_strain_data(strain_data, sampling_frequency, start_time, duration, trim=0.25,
+def condition_strain_data(strain_data, sampling_frequency, start_time, duration,
+                          preserve_time=None, trim=0.25, taper_and_trim=True,
                           remove_mean=True):
     """ Downsample time-domain strain data around an analysis window.
 
-    Steps:
+    Steps (default, `taper_and_trim` = True):
 
     1. Keep the window [`start_time`, `start_time` + `duration`) and a buffer
        of `trim` / (1 - 2 `trim`) x `duration` on each side (`duration` / 2
        for the default `trim` = 0.25). A ValueError is raised if the data do
        not cover them.
     2. Shift the data by fewer than `factor` samples (factor = current / new
-       sampling frequency) so that the sample nearest `start_time` is kept.
+       sampling frequency) so that the sample nearest `preserve_time` is kept.
     3. Multiply by a Tukey window with alpha = `trim`, set all frequencies
        above the new Nyquist frequency to zero and keep every factor-th
        sample.
@@ -20,6 +21,12 @@ def condition_strain_data(strain_data, sampling_frequency, start_time, duration,
        buffer. Samples in the window are always kept.
     5. Subtract the mean if `remove_mean`.
 
+    With `taper_and_trim` = False, steps 1, 3 and 4 are replaced by
+    :code:`scipy.signal.decimate` (order-8 Chebyshev low-pass filter, applied
+    forwards and backwards, then every factor-th sample) on all the data, and
+    the first samples are dropped instead of shifted in step 2. No buffer is
+    needed. The filter starts to cut at 0.8 x the new Nyquist frequency.
+
     The result replaces the data in `strain_data`.
 
     Parameters
@@ -32,36 +39,56 @@ def condition_strain_data(strain_data, sampling_frequency, start_time, duration,
         GPS start time of the analysis window (s).
     duration: float
         Duration of the analysis window (s).
+    preserve_time: float, optional
+        GPS time whose nearest sample is kept, e.g. the inspiral/post-inspiral
+        cut time (default: `start_time`).
     trim: float
         Fraction of the data at each end that is removed (default 0.25).
+    taper_and_trim: bool
+        Use the Tukey window, buffer and trimming (default True); if False,
+        use :code:`scipy.signal.decimate`.
     remove_mean: bool
         Subtract the mean of the result (default True).
     """
+    from scipy.signal import decimate
     from scipy.signal.windows import tukey
 
     original_sampling_frequency = float(strain_data.sampling_frequency)
     factor = int(round(original_sampling_frequency / sampling_frequency))
-    if factor < 1 or not np.isclose(original_sampling_frequency / sampling_frequency, factor,
-                                    rtol=0, atol=1e-9):
-        raise ValueError(
-            f"Sampling frequency {sampling_frequency:g} Hz does not divide the current "
-            f"{original_sampling_frequency:g} Hz")
+    if preserve_time is None:
+        preserve_time = start_time
 
-    buffer = duration * trim / (1 - 2 * trim)
+    if not taper_and_trim:
+        strain = np.array(strain_data.time_domain_strain, dtype=float)
+        times = np.array(strain_data.time_array, dtype=float)
+        shift = int(np.argmin(abs(times - preserve_time))) % factor
+        strain = decimate(strain[shift:], factor, zero_phase=True)
+        times = times[shift::factor]
+        if remove_mean:
+            strain = strain - np.mean(strain)
+        strain_data.set_from_time_domain_strain(
+            strain, sampling_frequency=sampling_frequency,
+            duration=len(strain) / sampling_frequency, start_time=times[0])
+        return
+
+    buffer_duration = duration * trim / (1 - 2 * trim)
     tolerance = 1 / original_sampling_frequency
-    data_start = strain_data.start_time
-    data_end = data_start + strain_data.duration
-    if data_start > start_time - buffer + tolerance or data_end < start_time + duration + buffer - tolerance:
+    data_start_time = strain_data.start_time
+    data_end_time = data_start_time + strain_data.duration
+    buffer_start_time = start_time - buffer_duration
+    buffer_end_time = start_time + duration + buffer_duration
+    if data_start_time > buffer_start_time + tolerance or data_end_time < buffer_end_time - tolerance:
         raise ValueError(
-            f"The data ({data_start:.6f} - {data_end:.6f}) must cover "
-            f"{start_time - buffer:.6f} - {start_time + duration + buffer:.6f}: the analysis "
-            f"window plus {buffer:g} s on each side")
-    first = max(int(round((start_time - buffer - data_start) * original_sampling_frequency)), 0)
-    last = int(round((start_time + duration + buffer - data_start) * original_sampling_frequency))
-    strain = np.array(strain_data.time_domain_strain[first:last], dtype=float)
-    times = np.array(strain_data.time_array[first:last], dtype=float)
-
-    shift = int(np.argmin(abs(times - start_time))) % factor
+            f"The data ({data_start_time:.6f} - {data_end_time:.6f}) must cover "
+            f"{buffer_start_time:.6f} - {buffer_end_time:.6f}: the analysis window plus "
+            f"{buffer_duration:g} s on each side")
+    buffer_start_index = max(
+        int(round((buffer_start_time - data_start_time) * original_sampling_frequency)), 0)
+    buffer_end_index = int(round((buffer_end_time - data_start_time) * original_sampling_frequency))
+    strain = np.array(strain_data.time_domain_strain[buffer_start_index:buffer_end_index], dtype=float)
+    times = np.array(strain_data.time_array[buffer_start_index:buffer_end_index], dtype=float)
+
+    shift = int(np.argmin(abs(times - preserve_time))) % factor
     if trim > 0:
         # the wrapped samples are at the end and are removed in step 4
         times = np.roll(times, -shift)
@@ -76,12 +103,13 @@ def condition_strain_data(strain_data, sampling_frequency, start_time, duration,
     strain = np.fft.irfft(strain_fd, n=len(strain))[::factor]
     times = times[::factor]
 
-    # remove the fraction trim at each end, but always keep the window
-    window_first = int(np.argmin(abs(times - start_time)))
-    window_last = window_first + int(round(duration * sampling_frequency))
-    first = min(int(round(trim * len(strain))), window_first)
-    last = max(int(round((1 - trim) * len(strain))), window_last)
-    strain, times = strain[first:last], times[first:last]
+    # remove the fraction trim at each end, but always keep the analysis samples
+    analysis_start_index = int(np.argmin(abs(times - start_time)))
+    analysis_end_index = analysis_start_index + int(round(duration * sampling_frequency))
+    keep_start_index = min(int(round(trim * len(strain))), analysis_start_index)
+    keep_end_index = max(int(round((1 - trim) * len(strain))), analysis_end_index)
+    strain = strain[keep_start_index:keep_end_index]
+    times = times[keep_start_index:keep_end_index]
     if remove_mean:
         strain = strain - np.mean(strain)
 
diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index 537b43de8..6059ff334 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -96,7 +96,6 @@ def __init__(self, name, power_spectral_density, minimum_frequency, maximum_freq
         self.reference_time = None
         self._autocovariance_function = None
         self._analysis_window = None
-        self._injected_signal = None
         self.gohberg_semencul_vectors = None
 
     def __eq__(self, other):
@@ -298,46 +297,13 @@ def _require_analysis_window(self):
             raise ValueError(f"{self.name}: set the analysis window first (analysis_window)")
         return self.analysis_window["start_time"], self.analysis_window["duration"]
 
-    def set_strain_data_from_power_spectral_density_time_domain(
-            self, sampling_frequency, *, random_state=None):
-        """ Set the strain data in the analysis window to a time-domain noise
-        realisation of the power spectral density, with no frequency mask and
-        no window function.
-
-        See :code:`InterferometerStrainData.set_from_power_spectral_density_time_domain`.
-
-        Parameters
-        ==========
-        sampling_frequency: float
-            The sampling frequency (Hz).
-        random_state: numpy.random.Generator, int, optional
-            Random number generator or seed.
-        """
-        start_time, duration = self._require_analysis_window()
-        self.strain_data.set_from_power_spectral_density_time_domain(
-            self.power_spectral_density, sampling_frequency=sampling_frequency,
-            duration=duration, start_time=start_time, random_state=random_state)
-        self._injected_signal = None
-
-    def set_strain_data_from_zero_noise_time_domain(self, sampling_frequency):
-        """ Set the strain data in the analysis window to zero.
-
-        Parameters
-        ==========
-        sampling_frequency: float
-            The sampling frequency (Hz).
-        """
-        start_time, duration = self._require_analysis_window()
-        self.strain_data.set_from_zero_noise(
-            sampling_frequency=sampling_frequency, duration=duration, start_time=start_time)
-        self._injected_signal = None
-
-    def condition_strain_data(self, sampling_frequency, trim=0.25, remove_mean=True):
+    def condition_strain_data(self, sampling_frequency, trim=0.25, taper_and_trim=True,
+                              remove_mean=True):
         """ Downsample the time-domain strain data around the analysis window.
 
         See :code:`bilby.gw.detector.condition_data.condition_strain_data`.
-        Any injected signal is not conditioned, and its SNRs are removed from
-        :code:`meta_data`.
+        The sample nearest the inspiral/post-inspiral cut time is kept if
+        there is one, otherwise the sample nearest the window start.
 
         Parameters
         ==========
@@ -345,15 +311,18 @@ def condition_strain_data(self, sampling_frequency, trim=0.25, remove_mean=True)
             New sampling frequency (Hz); must divide the current one.
         trim: float
             Fraction of the data at each end that is removed (default 0.25).
+        taper_and_trim: bool
+            Use the Tukey window, buffer and trimming (default True); if
+            False, use :code:`scipy.signal.decimate`.
         remove_mean: bool
             Subtract the mean of the result (default True).
         """
         from .condition_data import condition_strain_data
         start_time, duration = self._require_analysis_window()
+        preserve_time = self.meta_data["analysis_window"].get("cut_time")
         condition_strain_data(self.strain_data, sampling_frequency, start_time, duration,
-                              trim=trim, remove_mean=remove_mean)
-        self._injected_signal = None
-        self._update_injection_snrs()
+                              preserve_time=preserve_time, trim=trim,
+                              taper_and_trim=taper_and_trim, remove_mean=remove_mean)
 
     def _analysis_slice(self):
         """ Slice of the data samples in the analysis window: from the sample
@@ -375,11 +344,6 @@ def analysis_data(self):
         """ The time-domain strain data in the analysis window. """
         return np.asarray(self.strain_data.time_domain_strain, dtype=float)[self._analysis_slice()]
 
-    @property
-    def analysis_time_array(self):
-        """ The GPS times of the samples in the analysis window. """
-        return self.strain_data.time_array[self._analysis_slice()]
-
     @property
     def autocovariance_function(self):
         """ The noise autocovariance function
@@ -412,7 +376,6 @@ def _set_gohberg_semencul_vectors(self):
             self.analysis_window["duration"] * self.autocovariance_function.sampling_frequency))
         self.gohberg_semencul_vectors = self.autocovariance_function.gohberg_semencul_vectors(
             number_of_samples)
-        self._update_injection_snrs()
 
     def set_autocovariance_function_from_power_spectral_density(
             self, minimum_frequency=None, maximum_frequency=None, sampling_frequency=None,
@@ -634,30 +597,6 @@ def _time_domain_detector_response(self, waveform_polarizations, parameters, sta
             signal_ifo, merger_index=merger_index, arrival_index=arrival_index,
             number_of_samples=number_of_samples, placement=placement)
 
-    def _update_injection_snrs(self):
-        """ Store the optimal and matched-filter SNRs of the injected signal
-        in the analysis window in :code:`meta_data`. """
-        for key in ["optimal_SNR", "matched_filter_SNR"]:
-            self.meta_data.pop(key, None)
-        if (self._injected_signal is None or self.gohberg_semencul_vectors is None
-                or len(self._injected_signal) != len(self.strain_data.time_domain_strain)):
-            return
-        try:
-            analysis_slice = self._analysis_slice()
-        except ValueError:
-            return
-        signal = self._injected_signal[analysis_slice]
-        x, y = self.gohberg_semencul_vectors
-        if len(signal) != len(x):
-            return
-        inverse_covariance_signal = gohberg_semencul_product(x, y, signal)
-        optimal_snr = float(np.dot(signal, inverse_covariance_signal)) ** 0.5
-        self.meta_data['optimal_SNR'] = optimal_snr
-        self.meta_data['matched_filter_SNR'] = float(
-            np.dot(self.analysis_data, inverse_covariance_signal)) / optimal_snr
-        logger.info("{}: optimal SNR = {:.2f}, matched filter SNR = {:.2f}".format(
-            self.name, self.meta_data['optimal_SNR'], self.meta_data['matched_filter_SNR']))
-
     def inject_signal_time_domain(self, parameters, injection_polarizations=None,
                                   waveform_generator=None, placement="nearest"):
         """ Inject a time-domain signal into the time-domain strain data.
@@ -665,8 +604,9 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
         The detector signal is projected and placed as in
         :code:`get_time_domain_detector_response` and added to all of the
         stored time series; parts of the signal outside the data are dropped.
-        If the autocovariance function is set, the optimal and matched-filter
-        SNRs in the analysis window are stored in :code:`meta_data`.
+        The optimal and matched-filter SNRs in the analysis window are stored
+        in :code:`meta_data`; the analysis window and the autocovariance
+        function must be set first.
         Provide the injection parameters and either the injection
         polarizations or the waveform generator; the injection polarizations
         are used if both are given.
@@ -750,6 +690,8 @@ def inject_signal_time_domain_from_waveform_polarizations(self, parameters, inje
         if "epoch" not in injection_polarizations:
             raise ValueError("injection_polarizations must come from a time-domain source model "
                              "(with an 'epoch' entry)")
+        if self.gohberg_semencul_vectors is None:
+            raise ValueError(f"{self.name}: set the autocovariance function before injecting")
 
         signal_ifo = self._time_domain_detector_response(
             injection_polarizations, parameters, self.strain_data.start_time,
@@ -757,16 +699,20 @@ def inject_signal_time_domain_from_waveform_polarizations(self, parameters, inje
         self.strain_data._time_domain_strain = (
             np.array(self.strain_data.time_domain_strain, dtype=float) + signal_ifo)
         self.strain_data._frequency_domain_strain = None
-        if self._injected_signal is None:
-            self._injected_signal = signal_ifo
-        else:
-            self._injected_signal = self._injected_signal + signal_ifo
 
+        signal = signal_ifo[self._analysis_slice()]
+        x, y = self.gohberg_semencul_vectors
+        inverse_covariance_signal = gohberg_semencul_product(x, y, signal)
+        self.meta_data['optimal_SNR'] = float(np.dot(signal, inverse_covariance_signal)) ** 0.5
+        self.meta_data['matched_filter_SNR'] = float(
+            np.dot(self.analysis_data, inverse_covariance_signal)) / self.meta_data['optimal_SNR']
         self.meta_data['parameters'] = parameters
         self.meta_data['injection_domain'] = "time"
         self.meta_data['injection_placement'] = placement
+
         logger.info("Injected time-domain signal in {}:".format(self.name))
-        self._update_injection_snrs()
+        logger.info("  optimal SNR = {:.2f}".format(self.meta_data['optimal_SNR']))
+        logger.info("  matched filter SNR = {:.2f}".format(self.meta_data['matched_filter_SNR']))
         for key in parameters:
             logger.info('  {} = {}'.format(key, parameters[key]))
 
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index 6c231dca2..6cc267bb0 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -254,36 +254,6 @@ def set_analysis_windows(self, duration, start_time=None, analysis_segment="imr"
                 analysis_segment=analysis_segment, segment_cut_time=segment_cut_time,
                 cut_time=cut_time)
 
-    def set_strain_data_from_power_spectral_densities_time_domain(
-        self, sampling_frequency, *, random_state=None
-    ):
-        """Set the strain data of each detector in its analysis window to a
-        time-domain noise realisation of its power spectral density.
-
-        See :py:meth:`bilby.gw.detector.Interferometer.set_strain_data_from_power_spectral_density_time_domain`.
-
-        Parameters
-        ==========
-        sampling_frequency: float
-            The sampling frequency (Hz).
-        random_state: numpy.random.Generator, int, optional
-            Random number generator or seed.
-        """
-        for interferometer in self:
-            interferometer.set_strain_data_from_power_spectral_density_time_domain(
-                sampling_frequency=sampling_frequency, random_state=random_state)
-
-    def set_strain_data_from_zero_noise_time_domain(self, sampling_frequency):
-        """Set the strain data of each detector in its analysis window to zero.
-
-        Parameters
-        ==========
-        sampling_frequency: float
-            The sampling frequency (Hz).
-        """
-        for interferometer in self:
-            interferometer.set_strain_data_from_zero_noise_time_domain(sampling_frequency)
-
     def set_autocovariance_functions_from_power_spectral_densities(self, **kwargs):
         """Set the autocovariance function of each detector from its power
         spectral density.
@@ -294,7 +264,8 @@ def set_autocovariance_functions_from_power_spectral_densities(self, **kwargs):
         for interferometer in self:
             interferometer.set_autocovariance_function_from_power_spectral_density(**kwargs)
 
-    def condition_strain_data(self, sampling_frequency, trim=0.25, remove_mean=True):
+    def condition_strain_data(self, sampling_frequency, trim=0.25, taper_and_trim=True,
+                              remove_mean=True):
         """Downsample the time-domain strain data of each detector around its
         analysis window.
 
@@ -306,12 +277,16 @@ def condition_strain_data(self, sampling_frequency, trim=0.25, remove_mean=True)
             The new sampling frequency (Hz).
         trim: float
             Fraction of the data at each end that is removed (default 0.25).
+        taper_and_trim: bool
+            Use the Tukey window, buffer and trimming (default True); if
+            False, use :code:`scipy.signal.decimate`.
         remove_mean: bool
             Subtract the mean of the result (default True).
         """
         for interferometer in self:
             interferometer.condition_strain_data(
-                sampling_frequency, trim=trim, remove_mean=remove_mean)
+                sampling_frequency, trim=trim, taper_and_trim=taper_and_trim,
+                remove_mean=remove_mean)
 
     def inject_signal_time_domain(
         self,
diff --git a/bilby/gw/detector/strain_data.py b/bilby/gw/detector/strain_data.py
index 6357f9e67..1383d9d8c 100644
--- a/bilby/gw/detector/strain_data.py
+++ b/bilby/gw/detector/strain_data.py
@@ -661,42 +661,6 @@ def set_from_power_spectral_density(
         else:
             raise ValueError("Data frequencies do not match frequency_array")
 
-    def set_from_power_spectral_density_time_domain(
-            self, power_spectral_density, sampling_frequency, duration,
-            start_time=0, *, random_state=None):
-        """ Set the time-domain strain data to a Gaussian noise realisation of
-        the power spectral density, with no frequency mask and no window
-        function.
-
-        Parameters
-        ==========
-        power_spectral_density: bilby.gw.detector.PowerSpectralDensity
-            A PowerSpectralDensity object used to generate the data
-        sampling_frequency: float
-            The sampling frequency (in Hz)
-        duration: float
-            The data duration (in s)
-        start_time: float
-            The GPS start-time of the data
-        random_state: numpy.random.Generator, int, optional
-            Random number generator or seed.
-        """
-        self._times_and_frequencies = CoupledTimeAndFrequencySeries(duration=duration,
-                                                                    sampling_frequency=sampling_frequency,
-                                                                    start_time=start_time)
-        logger.debug('Setting time-domain data using noise realization from provided '
-                     'power_spectral_density')
-        frequency_domain_strain, frequency_array = \
-            power_spectral_density.get_noise_realisation(
-                self.frequency_array.shape[0], self.duration, random_state=random_state)
-        if not (self.duration == duration and frequency_array.shape == self.frequency_array.shape):
-            raise ValueError("Data frequencies do not match frequency_array")
-        time_domain_strain = utils.infft(frequency_domain_strain, self.sampling_frequency)
-        if np.shape(time_domain_strain) != np.shape(self.time_array):
-            raise ValueError("Data times do not match time array")
-        self._time_domain_strain = time_domain_strain
-        self._frequency_domain_strain = None
-
     def set_from_zero_noise(self, sampling_frequency, duration, start_time=0):
         """ Set the `frequency_domain_strain` to zero noise
 
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index 4d2464702..ccd648ce0 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from ..time_domain_utils import PLACEMENT_METHODS, gohberg_semencul_product
+from ..time_domain_utils import gohberg_semencul_product
 from .base import GravitationalWaveTransient
 
 
@@ -91,9 +91,8 @@ def __init__(
             raise ValueError(
                 f"{self.__class__.__name__} needs a waveform generator with a "
                 "time_domain_source_model, e.g. bilby.gw.source.lal_binary_black_hole_time_domain")
-        if placement not in PLACEMENT_METHODS:
-            raise ValueError(
-                f"placement must be one of {PLACEMENT_METHODS}, not {placement!r}")
+        if placement not in ("nearest", "fd_shift"):
+            raise ValueError(f"placement must be 'nearest' or 'fd_shift', not {placement!r}")
 
         super(TimeDomainGravitationalWaveTransient, self).__init__(
             interferometers=interferometers,
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 8629f1d23..1e55a283e 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -10,8 +10,6 @@
 from scipy.fft import next_fast_len
 from scipy.linalg import solve_toeplitz
 
-PLACEMENT_METHODS = ("nearest", "fd_shift")
-
 
 def gohberg_semencul_vectors(acf):
     """ Gohberg-Semencul generators of the inverse of the Toeplitz matrix
@@ -158,4 +156,4 @@ def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samp
         shifted = fractional_time_shift(signal, fraction, pad=pad)
         return _copy_into_segment(shifted, offset - pad, number_of_samples)
     else:
-        raise ValueError(f"placement must be one of {PLACEMENT_METHODS}, not {placement!r}")
+        raise ValueError(f"placement must be 'nearest' or 'fd_shift', not {placement!r}")
diff --git a/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py b/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
index 8758698b6..9b2588787 100644
--- a/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
+++ b/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
@@ -99,9 +99,11 @@
 # with segment_cut_time and cut_reference_parameters.
 interferometers.set_analysis_windows(duration=duration, start_time=start_time)
 
-# Time-domain noise drawn from the PSD curves (no mask, no window function).
-interferometers.set_strain_data_from_power_spectral_densities_time_domain(
-    sampling_frequency=sampling_frequency
+# Gaussian noise drawn from the PSD curves, covering the analysis window. The
+# noise outside [minimum_frequency, maximum_frequency] is removed by bilby's
+# frequency mask; the likelihood gives almost no weight to it anyway.
+interferometers.set_strain_data_from_power_spectral_densities(
+    sampling_frequency=sampling_frequency, duration=duration, start_time=start_time
 )
 
 # Autocovariance function of each detector from its PSD curve. Its duration
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
index 2d07a9bf7..69bac2eb4 100644
--- a/test/gw/likelihood/time_domain_test.py
+++ b/test/gw/likelihood/time_domain_test.py
@@ -44,11 +44,13 @@ def interferometers(noise="zero", acf=True, analysis_segment="imr", duration=DUR
     ifos.set_analysis_windows(
         duration=duration, start_time=START_TIME, analysis_segment=analysis_segment,
         segment_cut_time=segment_cut_time, cut_reference_parameters=INJECTION)
-    if noise == "zero":
-        ifos.set_strain_data_from_zero_noise_time_domain(SAMPLING_FREQUENCY)
-    else:
-        ifos.set_strain_data_from_power_spectral_densities_time_domain(
-            SAMPLING_FREQUENCY, random_state=3)
+    random_state = np.random.default_rng(3)
+    for ifo in ifos:
+        window = (SAMPLING_FREQUENCY, ifo.analysis_window["duration"], ifo.analysis_window["start_time"])
+        if noise == "zero":
+            ifo.set_strain_data_from_zero_noise(*window)
+        else:
+            ifo.set_strain_data_from_power_spectral_density(*window, random_state=random_state)
     if acf:
         ifos.set_autocovariance_functions_from_power_spectral_densities()
     return ifos
@@ -294,17 +296,20 @@ def test_injection_adds_to_stored_time_series(self):
     def test_analysis_data_is_the_window_slice(self):
         full = interferometers()
         full.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
-        snr_full = full[0].meta_data["optimal_SNR"]
         post_inspiral = interferometers(**SEGMENTS["post_inspiral"])
         post_inspiral.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
         for ifo, reference in zip(full, post_inspiral):
             ifo.analysis_window = (reference.analysis_window["start_time"], reference.analysis_window["duration"])
-            reference.autocovariance_function = ifo.autocovariance_function
             self.assertEqual(len(ifo.time_domain_strain), DURATION * SAMPLING_FREQUENCY)
-            np.testing.assert_allclose(ifo.analysis_time_array, reference.analysis_time_array, atol=1e-6)
+            np.testing.assert_allclose(
+                ifo.time_array[ifo._analysis_slice()], reference.time_array[reference._analysis_slice()],
+                atol=1e-6)
             np.testing.assert_allclose(ifo.analysis_data, reference.analysis_data, atol=1e-30)
-            self.assertAlmostEqual(ifo.meta_data["optimal_SNR"], reference.meta_data["optimal_SNR"], 8)
-        self.assertLess(full[0].meta_data["optimal_SNR"], snr_full)
+
+    def test_injection_needs_autocovariance_function(self):
+        ifos = interferometers(acf=False)
+        with self.assertRaises(ValueError):
+            ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
 
     def _sine_data(self, start_time, duration, sampling_frequency=4096):
         ifo = bilby.gw.detector.get_empty_interferometer("H1")
@@ -319,18 +324,30 @@ def test_downsample(self):
         ifo.analysis_window = (1006.0, 4)
         ifo.condition_strain_data(1024)
         self.assertEqual(ifo.sampling_frequency, 1024)
-        self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
+        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0)
         self.assertEqual(len(ifo.analysis_data), 4096)
         # the 60 Hz line is kept and the 1500 Hz line (above the new Nyquist frequency) removed
         expected = np.sin(2 * np.pi * 60 * ifo.time_array)
         np.testing.assert_allclose(ifo.time_domain_strain, expected - np.mean(expected), atol=1e-6)
 
+    def test_decimate(self):
+        ifo = self._sine_data(1000.0001, 16)
+        ifo.analysis_window = (1006.0, 4)
+        ifo.condition_strain_data(1024, taper_and_trim=False, remove_mean=False)
+        self.assertEqual(ifo.sampling_frequency, 1024)
+        self.assertEqual(ifo.duration, 16)
+        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0, 3)
+        self.assertEqual(len(ifo.analysis_data), 4096)
+        # the 60 Hz line is kept (up to the filter ripple) and the 1500 Hz line removed
+        expected = np.sin(2 * np.pi * 60 * ifo.time_array[ifo._analysis_slice()])
+        np.testing.assert_allclose(ifo.analysis_data, expected, atol=1e-2)
+
     def test_downsample_data_slightly_off_grid(self):
         ifo = self._sine_data(1004.0001, 8)
         ifo.analysis_window = (1006.0, 4)
         ifo.condition_strain_data(1024)
         self.assertEqual(len(ifo.analysis_data), 4096)
-        self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0, 3)
+        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0, 3)
 
     def test_downsample_needs_buffer(self):
         ifo = self._sine_data(1005.0, 6)
@@ -342,18 +359,17 @@ def test_data_not_conditioned_by_default(self):
         ifo = self._sine_data(1000.0, 16)
         ifo.analysis_window = (1006.0, 4)
         self.assertEqual(len(ifo.time_domain_strain), 16 * 4096)
-        self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
+        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0)
         self.assertEqual(len(ifo.analysis_data), 4 * 4096)
 
     def test_network_downsample(self):
         ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
-        ifos.set_analysis_windows(duration=16, start_time=1000)
-        ifos.set_strain_data_from_power_spectral_densities_time_domain(4096, random_state=2)
+        ifos.set_strain_data_from_power_spectral_densities(4096, 16, 1000, random_state=2)
         ifos.set_analysis_windows(duration=4, start_time=1006)
         ifos.condition_strain_data(2048)
         for ifo in ifos:
             self.assertEqual(ifo.sampling_frequency, 2048)
-            self.assertAlmostEqual(ifo.analysis_time_array[0], 1006.0)
+            self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0)
             self.assertEqual(len(ifo.analysis_data), 4 * 2048)
 
 
@@ -452,8 +468,7 @@ def test_read_power_spectral_densities_from_hdf5(self):
     def test_welch_acf_agrees_with_psd_acf(self):
         ifo = bilby.gw.detector.get_empty_interferometer("H1")
         ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
-        ifo.strain_data.set_from_power_spectral_density_time_domain(
-            ifo.power_spectral_density, SAMPLING_FREQUENCY, 256, 0, random_state=11)
+        ifo.set_strain_data_from_power_spectral_density(SAMPLING_FREQUENCY, 256, 0, random_state=11)
         noise = ifo.time_domain_strain.copy()
         ifo.analysis_window = (0, 1)
         ifo.set_autocovariance_function_from_power_spectral_density()

From 5f2ab4ef9ced6dc32b2b5845b558d722f84a2d48 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Sun, 11 Oct 2026 18:51:51 +0530
Subject: [PATCH 06/21] waveforms at model times

---
 bilby/gw/detector/interferometer.py    |  53 ++++++---
 bilby/gw/detector/networks.py          |   7 +-
 bilby/gw/likelihood/time_domain.py     |  53 +++++++--
 bilby/gw/model_time_waveforms.py       | 147 +++++++++++++++++++++++++
 bilby/gw/source.py                     |  96 ++++++++++++++++
 bilby/gw/time_domain_utils.py          |  23 ++++
 test/gw/likelihood/time_domain_test.py | 107 ++++++++++++++++++
 7 files changed, 461 insertions(+), 25 deletions(-)
 create mode 100644 bilby/gw/model_time_waveforms.py

diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index 6059ff334..3dc326201 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -14,7 +14,7 @@
 from .calibration import Recalibrate
 from .geometry import InterferometerGeometry
 from .strain_data import InterferometerStrainData
-from ..time_domain_utils import gohberg_semencul_product, place_time_domain_signal
+from ..time_domain_utils import gohberg_semencul_product, place_time_domain_signal, times_from_merger
 from ..conversion import generate_all_bbh_parameters
 
 
@@ -548,8 +548,11 @@ def get_time_domain_detector_response(self, waveform_polarizations, parameters,
         parameters: dict
             Parameters describing position and time of arrival of the signal.
         placement: str
-            "nearest" (default) or "fd_shift"; see
-            :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
+            "nearest" (default) or "fd_shift" (see
+            :code:`bilby.gw.time_domain_utils.place_time_domain_signal`), or
+            "model_time": the polarizations are evaluated at this
+            detector's data samples (needs a model-time source model, e.g.
+            :code:`bilby.gw.source.lal_binary_black_hole_model_time`).
 
         Returns
         =======
@@ -569,25 +572,45 @@ def get_time_domain_detector_response(self, waveform_polarizations, parameters,
     def _time_domain_detector_response(self, waveform_polarizations, parameters, start_time,
                                        number_of_samples, placement):
         """ Detector response on `number_of_samples` data samples starting
-        at `start_time`; see :code:`get_time_domain_detector_response`. """
+        at `start_time`; see :code:`get_time_domain_detector_response`.
+        Returns None if a model-time waveform failed (catch_waveform_errors). """
         sampling_frequency = self.strain_data.sampling_frequency
-        polarizations = {mode: value for mode, value in waveform_polarizations.items()
-                         if mode != "epoch"}
-        merger_index = -waveform_polarizations["epoch"] * sampling_frequency
+        model_time = "polarizations_at" in waveform_polarizations
+        if model_time != (placement == "model_time"):
+            raise ValueError(
+                'placement="model_time" needs a model-time source model (e.g. '
+                'bilby.gw.source.lal_binary_black_hole_model_time), and a model-time source '
+                f'model needs placement="model_time"; got placement={placement!r}')
 
         if self.reference_time is None:
             antenna_time = parameters["geocent_time"]
         else:
             antenna_time = self.reference_time
 
+        time_shift = self.time_delay_from_geocenter(
+            parameters['ra'], parameters['dec'], parameters['geocent_time'])
+
+        if model_time:
+            times = times_from_merger(
+                start_time, number_of_samples, sampling_frequency,
+                parameters['geocent_time'], time_shift)
+            polarizations = waveform_polarizations["polarizations_at"](times)
+            if polarizations is None:
+                return None
+        else:
+            polarizations = {mode: value for mode, value in waveform_polarizations.items()
+                             if mode != "epoch"}
+
         signal_ifo = 0
         for mode, polarization in polarizations.items():
             det_response = self.antenna_response(
                 parameters['ra'], parameters['dec'], antenna_time, parameters['psi'], mode)
             signal_ifo = signal_ifo + polarization * det_response
 
-        time_shift = self.time_delay_from_geocenter(
-            parameters['ra'], parameters['dec'], parameters['geocent_time'])
+        if model_time:
+            return signal_ifo
+
+        merger_index = -waveform_polarizations["epoch"] * sampling_frequency
         # Be careful to first subtract the two GPS times which are ~1e9 sec.
         # And then add the time_shift which varies at ~1e-5 sec
         dt_geocent = parameters['geocent_time'] - start_time
@@ -622,7 +645,7 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
             A WaveformGenerator with a time-domain source model, e.g.
             :code:`bilby.gw.source.lal_binary_black_hole_time_domain`.
         placement: str
-            "nearest" (default) or "fd_shift"; see
+            "nearest" (default), "fd_shift" or "model_time"; see
             :code:`get_time_domain_detector_response`.
 
         Returns
@@ -654,7 +677,7 @@ def inject_signal_time_domain_from_waveform_generator(self, parameters, waveform
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
             A WaveformGenerator with a time-domain source model.
         placement: str
-            "nearest" (default) or "fd_shift".
+            "nearest" (default), "fd_shift" or "model_time".
 
         Returns
         =======
@@ -681,21 +704,23 @@ def inject_signal_time_domain_from_waveform_polarizations(self, parameters, inje
         injection_polarizations: dict
             Output of a time-domain source model (polarizations and 'epoch').
         placement: str
-            "nearest" (default) or "fd_shift".
+            "nearest" (default), "fd_shift" or "model_time".
         """
         if not self.strain_data.time_within_data(parameters['geocent_time']):
             logger.warning(
                 'Injecting signal outside segment, start_time={}, merger time={}.'
                 .format(self.strain_data.start_time, parameters['geocent_time']))
-        if "epoch" not in injection_polarizations:
+        if "epoch" not in injection_polarizations and "polarizations_at" not in injection_polarizations:
             raise ValueError("injection_polarizations must come from a time-domain source model "
-                             "(with an 'epoch' entry)")
+                             "(with an 'epoch' or 'polarizations_at' entry)")
         if self.gohberg_semencul_vectors is None:
             raise ValueError(f"{self.name}: set the autocovariance function before injecting")
 
         signal_ifo = self._time_domain_detector_response(
             injection_polarizations, parameters, self.strain_data.start_time,
             len(self.strain_data.time_domain_strain), placement)
+        if signal_ifo is None:
+            raise ValueError(f"{self.name}: the injection waveform failed")
         self.strain_data._time_domain_strain = (
             np.array(self.strain_data.time_domain_strain, dtype=float) + signal_ifo)
         self.strain_data._frequency_domain_strain = None
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index 6cc267bb0..ba5b5f163 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -307,10 +307,11 @@ def inject_signal_time_domain(
            source model. If `waveform_generator` is also given, this is used.
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
             A WaveformGenerator with a time-domain source model. The waveform is
-            generated once and projected onto every detector.
+            generated once and projected onto every detector (for
+            placement="model_time", it is evaluated at each detector's samples).
         placement: str
-            "nearest" (default) or "fd_shift"; see
-            :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
+            "nearest" (default), "fd_shift" or "model_time"; see
+            :code:`bilby.gw.detector.Interferometer.get_time_domain_detector_response`.
 
         Returns
         =======
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index ccd648ce0..e26e266f1 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 
+from ...core.utils import logger
 from ..time_domain_utils import gohberg_semencul_product
 from .base import GravitationalWaveTransient
 
@@ -60,7 +61,10 @@ class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
         :code:`GravitationalWaveTransient`.
     placement: str, optional
         How the template is placed on the data samples: "nearest" (default)
-        or "fd_shift"; see :code:`bilby.gw.time_domain_utils.place_time_domain_signal`.
+        or "fd_shift" (see :code:`bilby.gw.time_domain_utils.place_time_domain_signal`),
+        or "model_time": the waveform is evaluated at each detector's data
+        samples, without a taper (needs a model-time source model, e.g.
+        :code:`bilby.gw.source.lal_binary_black_hole_model_time`).
         Use the same placement for injection and analysis.
     time_marginalization, phase_marginalization, calibration_marginalization: bool
         Not implemented for this likelihood; must be False.
@@ -91,8 +95,9 @@ def __init__(
             raise ValueError(
                 f"{self.__class__.__name__} needs a waveform generator with a "
                 "time_domain_source_model, e.g. bilby.gw.source.lal_binary_black_hole_time_domain")
-        if placement not in ("nearest", "fd_shift"):
-            raise ValueError(f"placement must be 'nearest' or 'fd_shift', not {placement!r}")
+        if placement not in ("nearest", "fd_shift", "model_time"):
+            raise ValueError(
+                f"placement must be 'nearest', 'fd_shift' or 'model_time', not {placement!r}")
 
         super(TimeDomainGravitationalWaveTransient, self).__init__(
             interferometers=interferometers,
@@ -108,6 +113,7 @@ def __init__(
             time_reference=time_reference,
         )
         self.placement = placement
+        self._check_minimum_frequency()
         self._setup_noise_model()
 
     def __repr__(self):
@@ -117,6 +123,19 @@ def __repr__(self):
                 self.interferometers, self.waveform_generator, self.distance_marginalization,
                 self.priors, self.placement))
 
+    def _check_minimum_frequency(self):
+        """ Warn if the waveform's minimum_frequency differs from an
+        interferometer's minimum_frequency. """
+        waveform_minimum_frequency = getattr(
+            self.waveform_generator, "waveform_arguments", dict()).get("minimum_frequency")
+        if waveform_minimum_frequency is None:
+            return
+        for interferometer in self.interferometers:
+            if not np.isclose(waveform_minimum_frequency, interferometer.minimum_frequency):
+                logger.warning(
+                    f"{interferometer.name}: minimum_frequency {interferometer.minimum_frequency:g} Hz "
+                    f"differs from the waveform's minimum_frequency {waveform_minimum_frequency:g} Hz")
+
     def _setup_noise_model(self):
         """ d^T C^-1 and d^T C^-1 d for each interferometer. """
         self._data_times_inverse_covariance = dict()
@@ -172,13 +191,15 @@ def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array
 
         Returns
         -------
-        calculated_snrs: _CalculatedSNRs
+        calculated_snrs: _CalculatedSNRs, or None if a model-time waveform failed
         """
         signal = self._compute_full_waveform(
             signal_polarizations=waveform_polarizations,
             interferometer=interferometer,
             parameters=parameters,
         )
+        if signal is None:
+            return None
         d_inner_h = float(np.dot(self._data_times_inverse_covariance[interferometer.name], signal))
         optimal_snr_squared = float(np.dot(
             signal, gohberg_semencul_product(*interferometer.gohberg_semencul_vectors, signal)))
@@ -206,11 +227,14 @@ def log_likelihood_ratio(self, parameters):
 
         total_snrs = self._CalculatedSNRs()
         for interferometer in self.interferometers:
-            total_snrs += self.calculate_snrs(
+            snrs = self.calculate_snrs(
                 waveform_polarizations=waveform_polarizations,
                 interferometer=interferometer,
                 parameters=parameters,
             )
+            if snrs is None:
+                return np.nan_to_num(-np.inf)
+            total_snrs += snrs
         log_l = self.compute_log_likelihood_from_snrs(total_snrs, parameters=parameters)
         return float(np.real(log_l))
 
@@ -223,8 +247,9 @@ def compute_per_detector_log_likelihood(self, parameters):
                 interferometer=interferometer,
                 parameters=parameters,
             )
-            parameters['{}_log_likelihood'.format(interferometer.name)] = \
-                self.compute_log_likelihood_from_snrs(per_detector_snr, parameters=parameters)
+            parameters['{}_log_likelihood'.format(interferometer.name)] = (
+                np.nan_to_num(-np.inf) if per_detector_snr is None else
+                self.compute_log_likelihood_from_snrs(per_detector_snr, parameters=parameters))
         return parameters.copy()
 
     # ------------------------------------------------------------------
@@ -271,9 +296,21 @@ def generate_distance_sample_from_marginalized_likelihood(
                 signal_polarizations=signal_polarizations, parameters=parameters)
 
     def _rescale_signal(self, signal, new_distance):
+        factor = self._ref_dist / new_distance
+        if "polarizations_at" in signal:
+            polarizations_at = signal["polarizations_at"]
+
+            def rescaled(times):
+                polarizations = polarizations_at(times)
+                if polarizations is None:
+                    return None
+                return {mode: value * factor for mode, value in polarizations.items()}
+
+            signal["polarizations_at"] = rescaled
+            return
         for mode in signal:
             if mode != "epoch":
-                signal[mode] *= self._ref_dist / new_distance
+                signal[mode] *= factor
 
     @property
     def meta_data(self):
diff --git a/bilby/gw/model_time_waveforms.py b/bilby/gw/model_time_waveforms.py
new file mode 100644
index 000000000..fdd69ba10
--- /dev/null
+++ b/bilby/gw/model_time_waveforms.py
@@ -0,0 +1,147 @@
+""" IMRPhenomT-family waveforms at arbitrary times.
+
+These call the lalsimulation functions that evaluate IMRPhenomT, IMRPhenomTHM,
+IMRPhenomTP and IMRPhenomTPHM at a user-supplied array of model times, instead
+of on LAL's own time grid. Model time is t / M, with M = m1 + m2 (detector
+frame) in seconds, and t = 0 at the peak of the (2,2) amplitude of the
+non-precessing waveform.
+
+- truncate=False: the waveform at every requested time; every time must lie in
+  the span of the standard waveform (from f_min to the end of the ringdown).
+- truncate=True: zero at times outside that span.
+
+The functions need a lalsuite build that has these functions; an ImportError is
+raised only when one of them is used.
+"""
+import numpy as np
+
+APPROXIMANTS = ("IMRPhenomT", "IMRPhenomTHM", "IMRPhenomTP", "IMRPhenomTPHM")
+PRECESSING_APPROXIMANTS = ("IMRPhenomTP", "IMRPhenomTPHM")
+
+# lalsimulation function names, e.g. SimIMRPhenomTPHMModelTimes(Truncated)
+_POLARIZATION_FUNCTION = "Sim{approximant}ModelTimes"
+_MODE_FUNCTION = "Sim{approximant}ModesModelTimes"
+
+
+def _lalsimulation_function(template, approximant, truncate):
+    import lalsimulation as lalsim
+    name = template.format(approximant=approximant) + ("Truncated" if truncate else "")
+    try:
+        return getattr(lalsim, name)
+    except AttributeError:
+        raise ImportError(
+            f"lalsimulation has no {name}: model-time waveforms need a lalsuite build "
+            "with the time-array IMRPhenomT-family functions") from None
+
+
+def total_mass_in_seconds(mass_1, mass_2):
+    """ Total mass in seconds, as lalsimulation computes it.
+
+    Parameters
+    ==========
+    mass_1, mass_2: float
+        Component masses (kg).
+    """
+    import lal
+    return (mass_1 / lal.MSUN_SI + mass_2 / lal.MSUN_SI) * lal.MTSUN_SI
+
+
+def _time_sequence(model_times):
+    import lal
+    model_times = np.asarray(model_times, dtype=float)
+    sequence = lal.CreateREAL8Sequence(len(model_times))
+    sequence.data = model_times
+    return sequence
+
+
+def check_arguments(approximant, spin_1x, spin_1y, spin_2x, spin_2y):
+    """ Raise a ValueError for an approximant without model-time functions, or
+    for in-plane spins with a non-precessing approximant (as lalsimulation's
+    ChooseTDWaveform and ChooseFDWaveform do). """
+    if approximant not in APPROXIMANTS:
+        raise ValueError(
+            f"model-time waveforms are available for {', '.join(APPROXIMANTS)}, not {approximant!r}")
+    if approximant not in PRECESSING_APPROXIMANTS and (spin_1x != 0 or spin_1y != 0 or spin_2x != 0 or spin_2y != 0):
+        raise ValueError(
+            f"Non-zero transverse spins were given, but {approximant} is a non-precessing approximant.")
+
+
+def _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z):
+    check_arguments(approximant, spin_1x, spin_1y, spin_2x, spin_2y)
+    if approximant in PRECESSING_APPROXIMANTS:
+        return (spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    return (spin_1z, spin_2z)
+
+
+def polarizations_at_model_times(
+        model_times, approximant, mass_1, mass_2, spin_1x, spin_1y, spin_1z,
+        spin_2x, spin_2y, spin_2z, luminosity_distance, inclination, phase,
+        delta_time, minimum_frequency, reference_frequency, waveform_dictionary,
+        truncate=True):
+    """ Plus and cross polarizations at the given model times.
+
+    Parameters
+    ==========
+    model_times: array_like
+        Times in units of the total mass, t = 0 at the peak (any order, any spacing).
+    approximant: str
+        IMRPhenomT, IMRPhenomTHM, IMRPhenomTP or IMRPhenomTPHM.
+    mass_1, mass_2: float
+        Component masses (kg).
+    spin_1x, ..., spin_2z: float
+        Dimensionless spin components at the reference frequency (lalsimulation frame).
+        The in-plane components must be zero for IMRPhenomT and IMRPhenomTHM.
+    luminosity_distance: float
+        Luminosity distance (m).
+    inclination, phase: float
+        Inclination and reference phase (rad), as for ChooseTDWaveform.
+    delta_time: float
+        Sampling interval (s) of the standard waveform; the precessing models take
+        their angles on the time grid of the standard waveform.
+    minimum_frequency, reference_frequency: float
+        f_min and f_ref (Hz).
+    waveform_dictionary: lal.Dict
+    truncate: bool
+        If True (default), zero outside the span of the standard waveform.
+
+    Returns
+    =======
+    plus, cross: array_like
+    """
+    spins = _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    function = _lalsimulation_function(_POLARIZATION_FUNCTION, approximant, truncate)
+    hplus, hcross = function(
+        mass_1, mass_2, *spins, luminosity_distance, inclination, delta_time,
+        minimum_frequency, reference_frequency, phase, _time_sequence(model_times),
+        waveform_dictionary)
+    return hplus.data.data, hcross.data.data
+
+
+def modes_at_model_times(
+        model_times, approximant, mass_1, mass_2, spin_1x, spin_1y, spin_1z,
+        spin_2x, spin_2y, spin_2z, luminosity_distance, phase, delta_time,
+        minimum_frequency, reference_frequency, waveform_dictionary, truncate=True):
+    """ Spherical-harmonic modes h_lm at the given model times.
+
+    For IMRPhenomTP/TPHM these are the modes in the inertial frame of the
+    orbital angular momentum at the reference frequency (L0 frame), i.e.,
+    already rotated with the precession angles; they contain every m of each l.
+    For IMRPhenomT only (2, 2) and (2, -2) are returned.
+
+    Parameters are those of :code:`polarizations_at_model_times`, without the
+    inclination.
+
+    Returns
+    =======
+    dict: {(l, m): complex array}
+    """
+    spins = _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    function = _lalsimulation_function(_MODE_FUNCTION, approximant, truncate)
+    hlms = function(
+        mass_1, mass_2, *spins, luminosity_distance, delta_time, minimum_frequency,
+        reference_frequency, phase, _time_sequence(model_times), waveform_dictionary)
+    modes = dict()
+    while hlms is not None:
+        modes[(hlms.l, hlms.m)] = hlms.mode.data.data.copy()
+        hlms = hlms.next
+    return modes
diff --git a/bilby/gw/source.py b/bilby/gw/source.py
index e576ce4b0..3a16f0f51 100644
--- a/bilby/gw/source.py
+++ b/bilby/gw/source.py
@@ -886,6 +886,102 @@ def _base_lal_cbc_td_waveform(
     return dict(plus=window * hplus.data.data, cross=window * hcross.data.data, epoch=epoch)
 
 
+def lal_binary_black_hole_model_time(
+        time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
+        phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
+    """ A time-domain Binary Black Hole waveform model evaluated directly at
+    the data samples of each detector (IMRPhenomT, IMRPhenomTHM, IMRPhenomTP,
+    IMRPhenomTPHM), for use with
+    :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient` with
+    :code:`placement="model_time"`.
+
+    No waveform is generated here. The returned function generates the
+    polarizations at given times relative to the model's t=0 (in seconds);
+    the detector response calls it with the times of its own data samples,
+    (t_k - geocent_time - time delay), so each detector gets its own call.
+    See :code:`bilby.gw.model_time_waveforms`.
+
+    Parameters
+    ==========
+    time_array: array_like
+        Times of the data (only the spacing is used: LAL's precession angles
+        are computed on the grid of the standard waveform with this spacing).
+    mass_1, mass_2, luminosity_distance, a_1, tilt_1, phi_12, a_2, tilt_2,
+    phi_jl, theta_jn, phase: float
+        As in :code:`lal_binary_black_hole_time_domain`.
+    kwargs: dict
+        Optional keyword arguments
+        Supported arguments:
+
+        - waveform_approximant (default IMRPhenomTPHM): IMRPhenomT,
+          IMRPhenomTHM, IMRPhenomTP or IMRPhenomTPHM
+        - reference_frequency
+        - minimum_frequency
+        - catch_waveform_errors
+        - mode_array (see :code:`lal_binary_black_hole`)
+        - lal_waveform_dictionary
+
+    Returns
+    =======
+    dict: polarizations_at: function of times (s, relative to the model's
+    t=0) returning dict(plus=..., cross=...), or None if the waveform failed
+    and catch_waveform_errors is True.
+
+    Notes
+    =====
+    No taper is applied: the waveform switches on abruptly at LAL's start
+    time (set by minimum_frequency). A taper would need that start time,
+    which is computed inside the lalsimulation functions and is not
+    returned. To add one later, return the start time from those functions
+    (or compute it the way LAL does), then multiply by a one-sided Tukey
+    window in model time, as turn_on_window does for "nearest" and
+    "fd_shift".
+    """
+    from .model_time_waveforms import check_arguments, polarizations_at_model_times, total_mass_in_seconds
+
+    waveform_kwargs = dict(
+        waveform_approximant='IMRPhenomTPHM', reference_frequency=50.0,
+        minimum_frequency=20.0, catch_waveform_errors=False,
+        pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
+        pn_amplitude_order=0)
+    waveform_kwargs.update(kwargs)
+    waveform_approximant = waveform_kwargs.pop('waveform_approximant')
+    reference_frequency = waveform_kwargs.pop('reference_frequency')
+    minimum_frequency = waveform_kwargs.pop('minimum_frequency')
+    catch_waveform_errors = waveform_kwargs.pop('catch_waveform_errors')
+    waveform_dictionary = set_waveform_dictionary(waveform_kwargs)
+    if len(waveform_kwargs) > 0:
+        raise ValueError(UNUSED_KWARGS_MESSAGE.format(waveform_kwargs=waveform_kwargs))
+
+    delta_time = float(time_array[1] - time_array[0])
+    luminosity_distance = luminosity_distance * 1e6 * utils.parsec
+    mass_1 = mass_1 * utils.solar_mass
+    mass_2 = mass_2 * utils.solar_mass
+    iota, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z = bilby_to_lalsimulation_spins(
+        theta_jn=theta_jn, phi_jl=phi_jl, tilt_1=tilt_1, tilt_2=tilt_2,
+        phi_12=phi_12, a_1=a_1, a_2=a_2, mass_1=mass_1, mass_2=mass_2,
+        reference_frequency=reference_frequency, phase=phase)
+    check_arguments(waveform_approximant, spin_1x, spin_1y, spin_2x, spin_2y)
+    total_mass = total_mass_in_seconds(mass_1, mass_2)
+
+    def polarizations_at(times):
+        try:
+            plus, cross = polarizations_at_model_times(
+                np.asarray(times) / total_mass, waveform_approximant, mass_1, mass_2,
+                spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z,
+                luminosity_distance, iota, phase, delta_time, minimum_frequency,
+                reference_frequency, waveform_dictionary, truncate=True)
+        except Exception as e:
+            if not catch_waveform_errors or e.args[0] != 'Internal function call failed: Input domain error':
+                raise
+            logger.warning("Evaluating the waveform failed with error: {}\n".format(e) +
+                           "Likelihood will be set to -inf.")
+            return None
+        return dict(plus=plus, cross=cross)
+
+    return dict(polarizations_at=polarizations_at)
+
+
 def binary_black_hole_roq(
         frequency_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
         phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **waveform_arguments):
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 1e55a283e..87b6560b3 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -115,6 +115,29 @@ def _copy_into_segment(signal, offset, number_of_samples):
     return segment
 
 
+def times_from_merger(start_time, number_of_samples, sampling_frequency, geocent_time, time_delay):
+    """ Times of data samples relative to the arrival of the model's t=0 in a
+    detector, t_k - (geocent_time + time_delay), as for ringdown analyses.
+
+    Parameters
+    ==========
+    start_time: float
+        GPS time of the first data sample.
+    number_of_samples: int
+    sampling_frequency: float
+    geocent_time: float
+        GPS time at which the model's t=0 arrives at the geocenter.
+    time_delay: float
+        Time delay of the detector from the geocenter (s).
+
+    Returns
+    =======
+    array_like: times (s)
+    """
+    # subtract the two GPS times (~1e9 s) first, then add the small terms
+    return (start_time - geocent_time) - time_delay + np.arange(number_of_samples) / sampling_frequency
+
+
 def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samples,
                              placement="nearest"):
     """ Place a time-domain signal, generated on its own grid with the data's
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
index 69bac2eb4..b94480231 100644
--- a/test/gw/likelihood/time_domain_test.py
+++ b/test/gw/likelihood/time_domain_test.py
@@ -273,6 +273,113 @@ def test_errors(self):
             TimeDomainGravitationalWaveTransient(ifos, generator)
 
 
+def _has_model_time_waveforms():
+    try:
+        import lalsimulation
+    except ImportError:
+        return False
+    return hasattr(lalsimulation, "SimIMRPhenomTPHMModelTimesTruncated")
+
+
+def model_time_generator(approximant="IMRPhenomTPHM", **kwargs):
+    arguments = dict(waveform_approximant=approximant, reference_frequency=20.0, minimum_frequency=20.0)
+    arguments.update(kwargs)
+    return bilby.gw.WaveformGenerator(
+        duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
+        time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
+        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+        waveform_arguments=arguments)
+
+
+ALIGNED_INJECTION = dict(INJECTION, tilt_1=0.0, tilt_2=np.pi)
+
+
+@unittest.skipUnless(_has_model_time_waveforms(), "lalsimulation without the model-time IMRPhenomT functions")
+class TestModelTime(unittest.TestCase):
+    def test_matches_lalsimulation_on_its_samples(self):
+        # with geocent_time chosen so that LAL's own samples fall on the data samples,
+        # "nearest" is the standard waveform without interpolation, and the model-time
+        # waveform must agree (to the ~1e-4 sample left by the precision of GPS times;
+        # the first sample can fall just outside the waveform's span)
+        ifo = interferometers()[0]
+        start_time = ifo.strain_data.time_array[ifo._analysis_slice().start]
+        for approximant, injection in [("IMRPhenomT", ALIGNED_INJECTION), ("IMRPhenomTHM", ALIGNED_INJECTION),
+                                       ("IMRPhenomTP", INJECTION), ("IMRPhenomTPHM", INJECTION)]:
+            with self.subTest(approximant=approximant):
+                generator = waveform_generator()
+                generator.waveform_arguments.update(waveform_approximant=approximant, turn_on_window=0)
+                epoch = generator.time_domain_strain(injection)["epoch"]
+                parameters = dict(injection)
+                for _ in range(3):
+                    delay = ifo.time_delay_from_geocenter(
+                        parameters["ra"], parameters["dec"], parameters["geocent_time"])
+                    position = (parameters["geocent_time"] - start_time + delay + epoch) * SAMPLING_FREQUENCY
+                    parameters["geocent_time"] -= (position - round(position)) / SAMPLING_FREQUENCY
+                standard = ifo.get_time_domain_detector_response(
+                    generator.time_domain_strain(parameters), parameters, placement="nearest")
+                model_time = ifo.get_time_domain_detector_response(
+                    model_time_generator(approximant).time_domain_strain(parameters), parameters,
+                    placement="model_time")
+                first = np.argmax(standard != 0) + 1
+                self.assertTrue(np.all(model_time[:first - 1] == 0))
+                self.assertLess(np.max(abs(model_time - standard)[first:]) / np.max(abs(standard)), 1e-3)
+
+    def test_zero_noise_log_likelihood_ratio_is_half_snr_squared(self):
+        for approximant, injection in [("IMRPhenomT", ALIGNED_INJECTION), ("IMRPhenomTHM", ALIGNED_INJECTION),
+                                       ("IMRPhenomTP", INJECTION), ("IMRPhenomTPHM", INJECTION)]:
+            with self.subTest(approximant=approximant):
+                ifos = interferometers()
+                generator = model_time_generator(approximant)
+                ifos.inject_signal_time_domain(
+                    parameters=injection, waveform_generator=generator, placement="model_time")
+                likelihood = TimeDomainGravitationalWaveTransient(ifos, generator, placement="model_time")
+                optimal_snr_squared = sum(ifo.meta_data["optimal_SNR"] ** 2 for ifo in ifos)
+                self.assertGreater(optimal_snr_squared, 10)
+                self.assertAlmostEqual(
+                    likelihood.log_likelihood_ratio(injection) / (optimal_snr_squared / 2), 1, 8)
+
+    def test_distance_marginalization(self):
+        ifos = interferometers()
+        generator = model_time_generator()
+        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator, placement="model_time")
+        priors = bilby.gw.prior.BBHPriorDict()
+        priors["luminosity_distance"] = bilby.gw.prior.UniformSourceFrame(
+            minimum=200, maximum=3000, name="luminosity_distance")
+        lookup = os.path.join(tempfile.mkdtemp(), "lookup.npz")
+        likelihood = TimeDomainGravitationalWaveTransient(
+            ifos, generator, placement="model_time", distance_marginalization=True, priors=priors,
+            distance_marginalization_lookup_table=lookup)
+        self.assertTrue(np.isfinite(likelihood.log_likelihood_ratio(INJECTION)))
+        sample = likelihood.generate_posterior_sample_from_marginalized_likelihood(dict(INJECTION))
+        self.assertTrue(200 <= sample["luminosity_distance"] <= 3000)
+        shutil.rmtree(os.path.dirname(lookup))
+
+    def test_errors(self):
+        ifos = interferometers()
+        with self.assertRaises(ValueError):  # model-time source, other placement
+            TimeDomainGravitationalWaveTransient(ifos, model_time_generator()).log_likelihood_ratio(INJECTION)
+        with self.assertRaises(ValueError):  # other source, model-time placement
+            TimeDomainGravitationalWaveTransient(
+                ifos, waveform_generator(), placement="model_time").log_likelihood_ratio(INJECTION)
+        with self.assertRaises(ValueError):  # in-plane spins, non-precessing approximant
+            model_time_generator("IMRPhenomT").time_domain_strain(INJECTION)
+        with self.assertRaises(ValueError):
+            model_time_generator("IMRPhenomXP").time_domain_strain(INJECTION)
+        with self.assertLogs("bilby", level="WARNING"):
+            TimeDomainGravitationalWaveTransient(ifos, model_time_generator(minimum_frequency=15.0),
+                                                 placement="model_time")
+
+    def test_modes(self):
+        from bilby.gw.model_time_waveforms import modes_at_model_times
+        import lal
+        model_times = np.linspace(-3000, 100, 50)
+        arguments = (36 * lal.MSUN_SI, 29 * lal.MSUN_SI, 0.3, 0.1, 0.2, -0.1, 0.2, 0.1,
+                     1e9 * lal.PC_SI, 0.3, 1 / SAMPLING_FREQUENCY, 20.0, 20.0, lal.CreateDict())
+        self.assertEqual(len(modes_at_model_times(model_times, "IMRPhenomTPHM", *arguments)), 32)
+        self.assertEqual(set(modes_at_model_times(model_times, "IMRPhenomTP", *arguments)),
+                         {(2, m) for m in range(-2, 3)})
+
+
 class TestTimeDomainData(unittest.TestCase):
     def test_noise_realisation(self):
         first, second = interferometers(noise="gaussian"), interferometers(noise="gaussian")

From 996000ff624d35f2d7968bc0a142850da4080334 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Mon, 12 Oct 2026 13:50:05 +0530
Subject: [PATCH 07/21] Time domain heterodyning

---
 bilby/gw/likelihood/__init__.py               |   1 +
 .../gw/likelihood/time_domain_heterodyning.py | 689 ++++++++++++++++++
 bilby/gw/model_time_waveforms.py              | 146 +++-
 bilby/gw/source.py                            |  73 +-
 bilby/gw/time_domain_utils.py                 |  86 ++-
 .../time_domain_heterodyning.py               | 193 +++++
 .../time_domain_heterodyning_test.py          | 278 +++++++
 7 files changed, 1447 insertions(+), 19 deletions(-)
 create mode 100644 bilby/gw/likelihood/time_domain_heterodyning.py
 create mode 100644 examples/gw_examples/injection_examples/time_domain_heterodyning.py
 create mode 100644 test/gw/likelihood/time_domain_heterodyning_test.py

diff --git a/bilby/gw/likelihood/__init__.py b/bilby/gw/likelihood/__init__.py
index 78213bf1a..360dff513 100644
--- a/bilby/gw/likelihood/__init__.py
+++ b/bilby/gw/likelihood/__init__.py
@@ -4,6 +4,7 @@
 from .multiband import MBGravitationalWaveTransient
 from .relative import RelativeBinningGravitationalWaveTransient
 from .time_domain import TimeDomainGravitationalWaveTransient
+from .time_domain_heterodyning import TimeDomainHeterodyningGravitationalWaveTransient
 
 from ..source import lal_binary_black_hole
 from ..waveform_generator import WaveformGenerator
diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
new file mode 100644
index 000000000..d0e60e47c
--- /dev/null
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -0,0 +1,689 @@
+import copy
+
+import numpy as np
+from scipy.optimize import differential_evolution
+
+from ...core.prior import DeltaFunction
+from ...core.prior.base import Constraint
+from ...core.utils import gravitational_constant, logger, solar_mass, speed_of_light
+from ..time_domain_utils import gohberg_semencul_operator, gohberg_semencul_quadratic_form
+from .relative import RelativeBinningGravitationalWaveTransient
+from .time_domain import TimeDomainGravitationalWaveTransient
+
+
+# the waveforms at sampled parameters start this far (Hz) below the interferometers' minimum_frequency
+SAMPLED_FREQUENCY_BUFFER = 2.0
+
+
+def _frequency_before_merger(chirp_mass, time_before_merger):
+    """ Leading-order (2, 2) frequency (Hz) a time (s) before the merger, from
+    t = (5/256) (G M_c / c^3)^(-5/3) (pi f)^(-8/3). """
+    chirp_mass_time = chirp_mass * solar_mass * gravitational_constant / speed_of_light ** 3
+    return (5 / 256 * chirp_mass_time ** (-5 / 3) / time_before_merger) ** (3 / 8) / np.pi
+
+
+def derive_fiducial_minimum_frequency(chirp_mass, window_start):
+    """ Minimum frequency (Hz) for a fiducial waveform that starts before an
+    analysis window starting window_start seconds before its merger: the
+    leading-order frequency 1.5 window_start + 0.1 s before the merger, minus
+    1 Hz, and at least 1 Hz. (The likelihood lowers it further, 1 Hz at a
+    time, if the waveform still starts inside the window.) """
+    time_before_merger = 1.5 * max(window_start, 0) + 0.1
+    return max(_frequency_before_merger(chirp_mass, time_before_merger) - 1, 1.0)
+
+
+def _hold_last_value(mode):
+    """ The mode, with the samples after its last non-zero one set to that value. """
+    nonzero = np.flatnonzero(mode)
+    if len(nonzero) == 0:
+        return mode
+    mode = np.array(mode)
+    mode[nonzero[-1] + 1:] = mode[nonzero[-1]]
+    return mode
+
+
+class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWaveTransient):
+    """ A time-domain gravitational-wave transient likelihood which uses
+    heterodyning (relative binning in time) to calculate a fast likelihood,
+    for IMRPhenomT, IMRPhenomTHM, IMRPhenomTP and IMRPhenomTPHM. See Sharma et
+    al. arXiv:2601.11239 and, in the frequency domain, Zackay et al.
+    arXiv:1806.08792 and :code:`RelativeBinningGravitationalWaveTransient`.
+
+    The waveform is written as (see
+    :code:`bilby.gw.model_time_waveforms.heterodyning_terms_at_model_times`)
+
+    .. math::
+
+        h_+ - i h_\\times = \\sum_q \\left[ Z_q(t) h_q(t) + \\bar{Z}_q(t) h_q^*(t) \\right],
+
+    with :math:`h_q` the modes with m >= 0 (co-precessing modes for
+    IMRPhenomTP/TPHM). The signal in an interferometer is
+    :math:`s = \\Re[(F_+ + i F_\\times)(h_+ - i h_\\times)] = \\Re \\sum_q w_q u_q`,
+    where :math:`u_q` are the modes of a fiducial waveform at the data samples
+    and
+
+    .. math::
+
+        w_q(t) = \\frac{h_q(t)}{u_q(t)} \\left[ F Z_q(t) + F^* \\bar{Z}_q^*(t) \\right],
+        \\quad F = F_+ + i F_\\times.
+
+    :math:`w_q` is evaluated at the edges of time bins and taken to be linear
+    in each bin, :math:`w_q = w_{q,0}(b) + w_{q,1}(b) (t - t_b)`. Then
+    :math:`d^T C^{-1} s` and :math:`s^T C^{-1} s` are the exact inner products
+    of this piecewise-linear model, computed from summary data:
+    :math:`s = V v` with :math:`v = (\\Re w, \\Im w)`, so that
+    :math:`d^T C^{-1} s = a^T v` and :math:`s^T C^{-1} s = v^T S v`, with
+    :math:`a = V^T C^{-1} d` and :math:`S = V^T C^{-1} V`. For many modes and
+    bins, :math:`S` is large, and :math:`s^T C^{-1} s` is faster to compute from
+    the piecewise-linear :math:`s` itself (see :code:`inner_product_method`).
+
+    The waveform is evaluated only at the bin edges, with one waveform call for
+    all interferometers.
+
+    The waveforms switch on abruptly at their minimum frequency, so their
+    ratios are smooth only where both are on. The bins cover the whole
+    analysis window, and here:
+
+    - the fiducial waveform starts before the window (its minimum frequency
+      is derived from the chirp mass and the start of the window, see
+      :code:`derive_fiducial_minimum_frequency`, or given), and after its ringdown each of its
+      modes is held at its last non-zero value, so it is non-zero everywhere
+      in the window;
+    - the waveforms at sampled parameters start at
+      :code:`sampled_minimum_frequency` (default: 2 Hz below the
+      interferometers' minimum_frequency), a few cycles before the waveforms
+      reach it.
+
+    With the interferometers' minimum_frequency at or below the frequency of
+    the signal at the start of the analysis window, every waveform (injected,
+    fiducial and sampled) is then on in the whole window.
+
+    The waveform's :code:`minimum_frequency` argument is not used by this
+    likelihood (it is for the injection and the exact likelihood).
+
+    Parameters
+    ----------
+    interferometers: list, bilby.gw.detector.InterferometerList
+        As for :code:`TimeDomainGravitationalWaveTransient`.
+    waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
+        A WaveformGenerator with
+        :code:`bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning`
+        as its time-domain source model.
+    fiducial_parameters: dict, optional
+        A starting guess for initial parameters of the event for finding the
+        maximum likelihood (fiducial) waveform. These should be specified in
+        the same parameter basis as the one that sampling is carried out in.
+        If no fiducial parameters are passed, a random point will be drawn from
+        the prior.
+    update_fiducial_parameters: bool
+        Whether to try to update the fiducial parameters by finding the maximum
+        likelihood point using scipy differential evolution. Default is
+        :code:`False`.
+    parameter_bounds: dict, optional
+        Dictionary of bounds (lists) for the initial parameters when finding
+        the initial maximum likelihood (fiducial) waveform.
+    maximization_kwargs: dict, optional
+        Keyword arguments for :code:`scipy.optimize.differential_evolution`.
+    distance_marginalization: bool, optional
+        If true, marginalize over distance in the likelihood.
+        This uses a look up table calculated at run time.
+        The distance prior is set to be a delta function at the minimum
+        distance allowed in the prior being marginalised over.
+    priors: dict, optional
+        If given, used in the distance marginalization and to find the
+        fiducial parameters.
+    distance_marginalization_lookup_table: (dict, str), optional
+        As for :code:`TimeDomainGravitationalWaveTransient`.
+    reference_frame: (str, bilby.gw.detector.InterferometerList, list), optional
+        Definition of the reference frame for the sky location.
+    time_reference: str, optional
+        Name of the reference for the sampled time parameter.
+        - "geocent"/"geocenter": sample in the time at the Earth's center,
+          this is the default
+        - e.g., "H1": sample in the time of arrival at H1
+    epsilon: tuple or dict, optional
+        Bin size in the inspiral: phase-proxy spacing before and after
+        :code:`time_split` (see :code:`time_domain_bin_edges`). Smaller
+        values give more bins. A dict gives a value per interferometer.
+    time_split: float or dict, optional
+        Time (s, relative to the merger) at which epsilon changes.
+    spacing: tuple, optional
+        Number of samples per bin after the merger, until
+        :code:`spacing_times[0]`, until :code:`spacing_times[1]` and after.
+    spacing_times: tuple, optional
+        Times (s, relative to the merger) at which the spacing changes.
+    chi: float, optional
+        Tunable parameter of the phase proxy (as in relative binning).
+    sampled_minimum_frequency: float, optional
+        Frequency (Hz) at which the waveforms at sampled parameters start; at
+        most (and by default) 2 Hz below the lowest minimum_frequency of the
+        interferometers.
+    fiducial_minimum_frequency: float, optional
+        Frequency (Hz) at which the fiducial waveform starts. By default the
+        lower of :code:`sampled_minimum_frequency` and the frequency derived
+        from the fiducial chirp mass and the start of the analysis window
+        (:code:`derive_fiducial_minimum_frequency`); a given value must not
+        be above that.
+    inner_product_method: str, optional
+        How :math:`s^T C^{-1} s` is computed: "summary" (the matrix S),
+        "fft" (the piecewise-linear s and three FFTs of length 2N, see
+        :code:`bilby.gw.time_domain_utils.gohberg_semencul_quadratic_form`) or "auto" (default), which
+        chooses the cheaper one for each interferometer.
+    time_marginalization, phase_marginalization, calibration_marginalization: bool
+        Not implemented for this likelihood; must be False.
+
+    Returns
+    -------
+    Likelihood: `bilby.core.likelihood.Likelihood`
+        A likelihood object, able to compute the likelihood of the data given
+        some model parameters.
+    """
+
+    def __init__(self, interferometers, waveform_generator, fiducial_parameters=None,
+                 parameter_bounds=None, maximization_kwargs=None, update_fiducial_parameters=False,
+                 distance_marginalization=False, priors=None,
+                 distance_marginalization_lookup_table=None, reference_frame="sky",
+                 time_reference="geocenter", epsilon=(0.5, 0.1), time_split=-0.02,
+                 spacing=(1, 10, 100), spacing_times=(0.02, 0.1), chi=1,
+                 sampled_minimum_frequency=None, fiducial_minimum_frequency=None,
+                 inner_product_method="auto", time_marginalization=False,
+                 phase_marginalization=False, calibration_marginalization=False):
+        super(TimeDomainHeterodyningGravitationalWaveTransient, self).__init__(
+            interferometers=interferometers,
+            waveform_generator=waveform_generator,
+            distance_marginalization=distance_marginalization,
+            priors=priors,
+            distance_marginalization_lookup_table=distance_marginalization_lookup_table,
+            reference_frame=reference_frame,
+            time_reference=time_reference,
+            placement="model_time",
+            time_marginalization=time_marginalization,
+            phase_marginalization=phase_marginalization,
+            calibration_marginalization=calibration_marginalization,
+        )
+        if inner_product_method not in ("auto", "summary", "fft"):
+            raise ValueError(
+                f"inner_product_method must be 'auto', 'summary' or 'fft', not {inner_product_method!r}")
+        self.epsilon = epsilon
+        self.time_split = time_split
+        self.spacing = spacing
+        self.spacing_times = spacing_times
+        self.chi = chi
+        self.inner_product_method = inner_product_method
+        self._set_sampled_minimum_frequency(sampled_minimum_frequency)
+        self.requested_fiducial_minimum_frequency = fiducial_minimum_frequency
+        self._inverse_covariance = {
+            interferometer.name: gohberg_semencul_operator(*interferometer.gohberg_semencul_vectors)
+            for interferometer in self.interferometers}
+        self._quadratic_form = {
+            interferometer.name: gohberg_semencul_quadratic_form(*interferometer.gohberg_semencul_vectors)
+            for interferometer in self.interferometers}
+
+        if fiducial_parameters is None:
+            logger.info("Drawing fiducial parameters from prior.")
+            fiducial_parameters = priors.sample()
+        self.fiducial_parameters = dict(fiducial_parameters)
+        if self.distance_marginalization:
+            self.fiducial_parameters["luminosity_distance"] = self._ref_dist
+        self.set_fiducial_waveforms(self.fiducial_parameters)
+        logger.info("Initial fiducial waveforms set up")
+        self.setup_bins()
+        self.compute_summary_data()
+        logger.info("Summary Data Obtained")
+
+        if update_fiducial_parameters:
+            logger.info("Using scipy optimization to find maximum likelihood parameters.")
+            self.parameters_to_be_updated = [key for key in priors if not isinstance(
+                priors[key], (DeltaFunction, Constraint, float, int))]
+            logger.info(f"Parameters over which likelihood is maximized: {self.parameters_to_be_updated}")
+            if parameter_bounds is None:
+                logger.info("No parameter bounds were given. Using priors instead.")
+                self.parameter_bounds = self.get_bounds_from_priors(priors)
+            else:
+                self.parameter_bounds = self.get_parameter_list_from_dictionary(parameter_bounds)
+            self.fiducial_parameters = self.find_maximum_likelihood_parameters(
+                self.parameter_bounds, maximization_kwargs=maximization_kwargs)
+        logger.info(f"Fiducial likelihood: {self.log_likelihood_ratio(self.fiducial_parameters):.2f}")
+
+    def _set_sampled_minimum_frequency(self, sampled_minimum_frequency):
+        maximum = min(ifo.minimum_frequency for ifo in self.interferometers) - SAMPLED_FREQUENCY_BUFFER
+        if sampled_minimum_frequency is None:
+            sampled_minimum_frequency = maximum
+        if sampled_minimum_frequency > maximum:
+            raise ValueError(
+                f"sampled_minimum_frequency ({sampled_minimum_frequency:g} Hz) must be at most {maximum:g} Hz "
+                f"({SAMPLED_FREQUENCY_BUFFER:g} Hz below the interferometers' minimum_frequency)")
+        if sampled_minimum_frequency <= 0:
+            raise ValueError("sampled_minimum_frequency must be positive")
+        self.sampled_minimum_frequency = sampled_minimum_frequency
+        self.waveform_generator.waveform_arguments["sampled_minimum_frequency"] = sampled_minimum_frequency
+        self._unset_fiducial()
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(interferometers={},\n\twaveform_generator={},\n\tfiducial_parameters={},' \
+            .format(self.interferometers, self.waveform_generator, self.fiducial_parameters)
+
+    # ------------------------------------------------------------------
+    # Waveform at given samples
+    # ------------------------------------------------------------------
+    def _model_times(self, interferometer, indices, parameters):
+        """ Times of the analysis-window samples `indices`, relative to the
+        arrival of the model's t=0 at the interferometer. """
+        start_time = interferometer.strain_data.time_array[interferometer._analysis_slice().start]
+        time_delay = interferometer.time_delay_from_geocenter(
+            parameters["ra"], parameters["dec"], parameters["geocent_time"])
+        # subtract the two GPS times (~1e9 s) first
+        return (start_time - parameters["geocent_time"]) - time_delay \
+            + np.asarray(indices) / interferometer.sampling_frequency
+
+    @staticmethod
+    def _antenna_factor(interferometer, parameters):
+        """ F = F_+ + i F_x. """
+        time = parameters["geocent_time"] if interferometer.reference_time is None \
+            else interferometer.reference_time
+        plus, cross = (interferometer.antenna_response(
+            parameters["ra"], parameters["dec"], time, parameters["psi"], mode) for mode in ("plus", "cross"))
+        return plus + 1j * cross
+
+    def _terms_at_samples(self, signal, interferometers, indices, parameters):
+        """ Modes and harmonic factors at the samples `indices[name]` of each
+        interferometer, from one waveform call. None if the waveform failed. """
+        times = [self._model_times(interferometer, indices[interferometer.name], parameters)
+                 for interferometer in interferometers]
+        terms = signal["heterodyning_terms_at"](np.concatenate(times))
+        if terms is None:
+            return None
+        modes, harmonics = terms
+        per_interferometer = list()
+        start = 0
+        for interferometer_times in times:
+            samples = slice(start, start + len(interferometer_times))
+            start += len(interferometer_times)
+            per_interferometer.append((
+                {key: mode[samples] for key, mode in modes.items()},
+                {key: tuple(np.asarray(z)[samples] if np.ndim(z) else z for z in pair)
+                 for key, pair in harmonics.items()}))
+        return per_interferometer
+
+    def _heterodyning_coefficients(self, signal, interferometers, parameters):
+        """ Coefficients w[q, p, b] of the piecewise-linear model in each
+        interferometer (see the class docstring). None if the waveform failed. """
+        terms = self._terms_at_samples(signal, interferometers, self.bin_edges, parameters)
+        if terms is None:
+            return None
+        coefficients = list()
+        for interferometer, (modes, harmonics) in zip(interferometers, terms):
+            name = interferometer.name
+            antenna = self._antenna_factor(interferometer, parameters)
+            ratio = np.zeros(self._inverse_fiducial_at_edges[name].shape, dtype=complex)
+            for i, key in enumerate(self.mode_keys):
+                if key in modes:
+                    harmonic, conjugate_harmonic = harmonics[key]
+                    ratio[i] = modes[key] * (antenna * harmonic + np.conj(antenna * conjugate_harmonic))
+            ratio *= self._inverse_fiducial_at_edges[name]
+            coefficients.append(np.stack([
+                (ratio[:, 1:] + ratio[:, :-1]) / 2,
+                (ratio[:, 1:] - ratio[:, :-1]) / self.bin_widths[name]], axis=1))
+        return coefficients
+
+    # ------------------------------------------------------------------
+    # Fiducial waveform, bins and summary data
+    # ------------------------------------------------------------------
+    def set_fiducial_waveforms(self, parameters):
+        """ The modes of the fiducial waveform at the data samples of each
+        interferometer, starting before the analysis window (see
+        :code:`fiducial_minimum_frequency`) and held at their last non-zero
+        values after the ringdown. """
+        parameters = dict(parameters)
+        parameters.update(self.get_sky_frame_parameters(parameters=parameters))
+        self._fiducial_times = {
+            interferometer.name: self._model_times(
+                interferometer, np.arange(self._number_of_samples(interferometer)), parameters)
+            for interferometer in self.interferometers}
+        window_start = -min(times[0] for times in self._fiducial_times.values())
+        derived = min(derive_fiducial_minimum_frequency(self._chirp_mass(parameters), window_start),
+                      self.sampled_minimum_frequency)
+        requested = self.requested_fiducial_minimum_frequency
+        if requested is not None and requested > derived:
+            raise ValueError(
+                f"fiducial_minimum_frequency ({requested:g} Hz) must not be above {derived:.2f} Hz "
+                "(the lower of sampled_minimum_frequency and the frequency derived from the fiducial chirp mass "
+                "and the start of the analysis window)")
+        self.fiducial_minimum_frequency = derived if requested is None else requested
+        while True:
+            terms = self._fiducial_terms(parameters)
+            if all(np.any(modes[(2, 2)][:1]) for modes, _ in terms):
+                break
+            if requested is not None or self.fiducial_minimum_frequency <= 1:
+                raise ValueError(
+                    f"The fiducial waveform from {self.fiducial_minimum_frequency:.2f} Hz does not start "
+                    f"before the analysis window for {parameters}")
+            self.fiducial_minimum_frequency = max(self.fiducial_minimum_frequency - 1, 1)
+        logger.info(f"Fiducial waveform from {self.fiducial_minimum_frequency:.2f} Hz")
+        self.fiducial_modes = {
+            interferometer.name: {key: _hold_last_value(mode) for key, mode in modes.items()}
+            for interferometer, (modes, _) in zip(self.interferometers, terms)}
+        self.mode_keys = sorted({key for modes in self.fiducial_modes.values()
+                                 for key, mode in modes.items() if np.any(mode)})
+        logger.debug(f"Modes of the heterodyning basis: {self.mode_keys}")
+
+    def _fiducial_terms(self, parameters):
+        self._set_fiducial()
+        signal = self.waveform_generator.time_domain_strain(parameters)
+        terms = None if signal is None else self._terms_at_samples(
+            signal, self.interferometers,
+            {interferometer.name: np.arange(self._number_of_samples(interferometer))
+             for interferometer in self.interferometers},
+            parameters)
+        self._unset_fiducial()
+        if terms is None:
+            raise ValueError(f"Cannot compute fiducial waveforms for {parameters}")
+        return terms
+
+    def _chirp_mass(self, parameters):
+        """ Detector-frame chirp mass (solar masses). """
+        converted = self.waveform_generator.parameter_conversion(dict(parameters))[0]
+        mass_1, mass_2 = converted["mass_1"], converted["mass_2"]
+        return (mass_1 * mass_2) ** 0.6 / (mass_1 + mass_2) ** 0.2
+
+    @staticmethod
+    def _number_of_samples(interferometer):
+        analysis_slice = interferometer._analysis_slice()
+        return analysis_slice.stop - analysis_slice.start
+
+    def _per_detector(self, value, name):
+        return value[name] if isinstance(value, dict) else value
+
+    def setup_bins(self):
+        """ Bin edges (indices of analysis-window samples) for each
+        interferometer, from the times relative to the fiducial merger in that
+        interferometer (see :code:`time_domain_bin_edges`), over the whole
+        analysis window. """
+        self.bin_edges = dict()
+        self.bin_widths = dict()
+        self.number_of_bins = dict()
+        for interferometer in self.interferometers:
+            name = interferometer.name
+            times = self._fiducial_times[name]
+            first, last = 0, len(times) - 1
+            edges = first + time_domain_bin_edges(
+                times[first:last + 1],
+                epsilon=self._per_detector(self.epsilon, name),
+                time_split=self._per_detector(self.time_split, name),
+                spacing=self._per_detector(self.spacing, name),
+                spacing_times=self._per_detector(self.spacing_times, name),
+                chi=self.chi)
+            self.bin_edges[name] = edges
+            self.bin_widths[name] = np.diff(times[edges])
+            self.number_of_bins[name] = len(edges) - 1
+            logger.info(
+                f"{name}: {self.number_of_bins[name]} bins between {times[edges[0]]:.3f} s "
+                f"and {times[edges[-1]]:.3f} s from the merger")
+
+    def compute_summary_data(self):
+        """ For each interferometer: :math:`a = V^T C^{-1} d` and, if used,
+        :math:`S = V^T C^{-1} V` (see the class docstring). The columns of V
+        are :math:`\\Re(u_q \\tau^p)` and :math:`-\\Im(u_q \\tau^p)` in each bin
+        b, where :math:`\\tau = t - t_b`. """
+        self.summary_data = dict()
+        self._inverse_fiducial_at_edges = dict()
+        for interferometer in self.interferometers:
+            name = interferometer.name
+            edges = self.bin_edges[name]
+            first, last = edges[0], edges[-1]
+            samples = slice(first, last + 1)
+            bin_sizes = np.diff(edges)
+            bin_sizes[-1] += 1
+            bin_starts = edges[:-1] - first
+            bin_of_sample = np.repeat(np.arange(len(bin_sizes)), bin_sizes)
+            times = self._fiducial_times[name]
+            bin_centers = (times[edges[1:]] + times[edges[:-1]]) / 2
+            tau = times[samples] - bin_centers[bin_of_sample]
+
+            fiducial = np.array([self.fiducial_modes[name].get(key, np.zeros(len(times)))
+                                 for key in self.mode_keys])
+            at_edges = fiducial[:, edges]
+            self._inverse_fiducial_at_edges[name] = np.divide(
+                1, at_edges, out=np.zeros_like(at_edges), where=at_edges != 0)
+            basis = np.stack([fiducial[:, samples], fiducial[:, samples] * tau], axis=1)  # (K, 2, n)
+            columns = np.concatenate([basis.real, -basis.imag]).reshape(-1, len(tau))  # (4K, n)
+            data_vector = np.add.reduceat(
+                columns * self._data_times_inverse_covariance[name][samples], bin_starts, axis=1)
+
+            summary = dict(
+                data_vector=data_vector.ravel(), samples=samples, fiducial=fiducial[:, samples],
+                tau=tau, bin_sizes=bin_sizes, matrix=None)
+            if self._use_summary_matrix(interferometer, data_vector.size):
+                summary["matrix"] = self._summary_matrix(
+                    interferometer, columns, samples, bin_starts, bin_of_sample)
+            logger.info(
+                f"{name}: {len(self.mode_keys)} modes, {len(bin_sizes)} bins, s^T C^-1 s from "
+                + ("the summary matrix" if summary["matrix"] is not None else "FFTs"))
+            self.summary_data[name] = summary
+
+    def _use_summary_matrix(self, interferometer, size):
+        """ Use S if v^T S v costs less than the FFTs of length 2N (rough
+        operation counts; see :code:`inner_product_method`). """
+        if self.inner_product_method != "auto":
+            return self.inner_product_method == "summary"
+        number_of_samples = self._number_of_samples(interferometer)
+        return size ** 2 < _FFT_COST_FACTOR * number_of_samples * np.log2(number_of_samples)
+
+    def _summary_matrix(self, interferometer, columns, samples, bin_starts, bin_of_sample):
+        """ S = V^T C^-1 V, one column group of V at a time (symmetric). """
+        number_of_groups, number_of_bins = len(columns), len(bin_starts)
+        inverse_covariance = self._inverse_covariance[interferometer.name]
+        rows = np.arange(samples.start, samples.stop)
+        matrix = np.empty((number_of_groups, number_of_bins, number_of_groups, number_of_bins))
+        for j in range(number_of_groups):
+            group = np.zeros((self._number_of_samples(interferometer), number_of_bins))
+            group[rows, bin_of_sample] = columns[j]
+            group = inverse_covariance(group)[samples]
+            for i in range(j, number_of_groups):
+                block = np.add.reduceat(columns[i][:, None] * group, bin_starts, axis=0)
+                matrix[i, :, j, :] = block
+                matrix[j, :, i, :] = block.T
+        size = number_of_groups * number_of_bins
+        return np.ascontiguousarray(matrix.reshape(size, size))
+
+    # ------------------------------------------------------------------
+    # Likelihood
+    # ------------------------------------------------------------------
+    def _snrs_from_coefficients(self, name, coefficients):
+        summary = self.summary_data[name]
+        vector = np.concatenate([coefficients.real.ravel(), coefficients.imag.ravel()])
+        d_inner_h = float(summary["data_vector"] @ vector)
+        if summary["matrix"] is not None:
+            optimal_snr_squared = float(vector @ (summary["matrix"] @ vector))
+        else:
+            optimal_snr_squared = float(self._quadratic_form[name](
+                self._piecewise_linear_signal(name, coefficients)))
+        matched_filter_snr = d_inner_h / optimal_snr_squared ** 0.5 if optimal_snr_squared > 0 else 0.0
+        return self._CalculatedSNRs(
+            d_inner_h=d_inner_h,
+            optimal_snr_squared=optimal_snr_squared,
+            complex_matched_filter_snr=matched_filter_snr,
+            d_inner_h_array=None,
+            optimal_snr_squared_array=None,
+        )
+
+    def _piecewise_linear_signal(self, name, coefficients):
+        """ s = Re sum_q w_q u_q on all samples of the analysis window (zero outside the bins). """
+        summary = self.summary_data[name]
+        expanded = np.repeat(coefficients, summary["bin_sizes"], axis=2)
+        signal = np.zeros(len(self._fiducial_times[name]))
+        signal[summary["samples"]] = np.sum(
+            ((expanded[:, 0] + expanded[:, 1] * summary["tau"]) * summary["fiducial"]).real, axis=0)
+        return signal
+
+    def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array=True, parameters):
+        """ :math:`d^T C^{-1} s`, :math:`s^T C^{-1} s` and the matched filter
+        SNR of the heterodyned signal in one interferometer.
+
+        Parameters
+        ----------
+        waveform_polarizations: dict
+            Output of the source model (heterodyning_terms_at).
+        interferometer: bilby.gw.detector.Interferometer
+        return_array: bool
+            Unused; kept for the :code:`GravitationalWaveTransient` interface.
+        parameters: dict
+
+        Returns
+        -------
+        calculated_snrs: _CalculatedSNRs, or None if the waveform failed
+        """
+        coefficients = self._heterodyning_coefficients(waveform_polarizations, [interferometer], parameters)
+        if coefficients is None:
+            return None
+        return self._snrs_from_coefficients(interferometer.name, coefficients[0])
+
+    def log_likelihood_ratio(self, parameters):
+        parameters = copy.deepcopy(parameters)
+        parameters.update(self.get_sky_frame_parameters(parameters))
+        signal = self.waveform_generator.time_domain_strain(parameters)
+        coefficients = None if signal is None else self._heterodyning_coefficients(
+            signal, self.interferometers, parameters)
+        if coefficients is None:
+            return np.nan_to_num(-np.inf)
+        total_snrs = self._CalculatedSNRs()
+        for interferometer, interferometer_coefficients in zip(self.interferometers, coefficients):
+            total_snrs += self._snrs_from_coefficients(interferometer.name, interferometer_coefficients)
+        log_l = self.compute_log_likelihood_from_snrs(total_snrs, parameters=parameters)
+        return float(np.real(log_l))
+
+    def _compute_full_waveform(self, signal_polarizations, interferometer, parameters):
+        """ The heterodyned (piecewise-linear) template on the samples of the
+        analysis window; zero outside the bins. """
+        coefficients = self._heterodyning_coefficients(signal_polarizations, [interferometer], parameters)
+        if coefficients is None:
+            return None
+        return self._piecewise_linear_signal(interferometer.name, coefficients[0])
+
+    def _rescale_signal(self, signal, new_distance):
+        factor = self._ref_dist / new_distance
+        terms_at = signal["heterodyning_terms_at"]
+
+        def rescaled(times):
+            terms = terms_at(times)
+            if terms is None:
+                return None
+            modes, harmonics = terms
+            return {key: mode * factor for key, mode in modes.items()}, harmonics
+
+        signal["heterodyning_terms_at"] = rescaled
+
+    # ------------------------------------------------------------------
+    # Fiducial parameters (as in RelativeBinningGravitationalWaveTransient)
+    # ------------------------------------------------------------------
+    def find_maximum_likelihood_parameters(self, parameter_bounds, iterations=5, maximization_kwargs=None):
+        if maximization_kwargs is None:
+            maximization_kwargs = dict()
+        parameters = copy.deepcopy(self.fiducial_parameters)
+        updated_parameters_list = self.get_parameter_list_from_dictionary(self.fiducial_parameters)
+        updated_parameters = copy.deepcopy(self.fiducial_parameters)
+        old_fiducial_ln_likelihood = self.log_likelihood_ratio(self.fiducial_parameters)
+        logger.info(f"Fiducial ln likelihood ratio: {old_fiducial_ln_likelihood:.2f}")
+        for it in range(iterations):
+            logger.info(f"Optimizing fiducial parameters. Iteration : {it + 1}")
+            output = differential_evolution(
+                self.lnlike_scipy_maximize,
+                bounds=parameter_bounds,
+                args=(parameters,),
+                x0=updated_parameters_list,
+                **maximization_kwargs,
+            )
+            updated_parameters_list = output['x']
+            updated_parameters = copy.deepcopy(self.fiducial_parameters)
+            updated_parameters.update(self.get_parameter_dictionary_from_list(updated_parameters_list))
+            self.set_fiducial_waveforms(updated_parameters)
+            self.setup_bins()
+            self.compute_summary_data()
+            new_fiducial_ln_likelihood = self.log_likelihood_ratio(updated_parameters)
+            logger.info(f"Fiducial ln likelihood ratio: {new_fiducial_ln_likelihood:.2f}")
+            if new_fiducial_ln_likelihood - old_fiducial_ln_likelihood < 0.1:
+                break
+            old_fiducial_ln_likelihood = new_fiducial_ln_likelihood
+
+        logger.info("Fiducial waveforms updated")
+        logger.info("Summary Data updated")
+        return updated_parameters
+
+    def _set_fiducial(self):
+        """ Make the waveform generator generate the fiducial waveform (from
+        fiducial_minimum_frequency), as in
+        :code:`RelativeBinningGravitationalWaveTransient`. """
+        self.waveform_generator.waveform_arguments["fiducial"] = 1
+        self.waveform_generator.waveform_arguments["fiducial_minimum_frequency"] = self.fiducial_minimum_frequency
+        self.waveform_generator._cache["parameters"] = None
+
+    def _unset_fiducial(self):
+        """ Make the waveform generator generate waveforms at sampled
+        parameters (from sampled_minimum_frequency). """
+        self.waveform_generator.waveform_arguments["fiducial"] = 0
+        self.waveform_generator._cache["parameters"] = None
+
+    lnlike_scipy_maximize = RelativeBinningGravitationalWaveTransient.lnlike_scipy_maximize
+    get_parameter_dictionary_from_list = RelativeBinningGravitationalWaveTransient.get_parameter_dictionary_from_list
+    get_parameter_list_from_dictionary = RelativeBinningGravitationalWaveTransient.get_parameter_list_from_dictionary
+    get_bounds_from_priors = RelativeBinningGravitationalWaveTransient.get_bounds_from_priors
+
+    @property
+    def meta_data(self):
+        meta_data = super(TimeDomainHeterodyningGravitationalWaveTransient, self).meta_data
+        meta_data.update(
+            fiducial_parameters=self.fiducial_parameters,
+            number_of_bins=self.number_of_bins,
+            mode_keys=self.mode_keys)
+        return meta_data
+
+
+# v^T S v takes ~0.3 ns per element of S and s^T C^-1 s from FFTs ~6 ns * N log2(N)
+_FFT_COST_FACTOR = 20
+
+_PHASE_PROXY_POWERS = np.array([5 / 8, 3 / 8, 1 / 4, -3 / 8])
+
+
+def time_domain_bin_edges(times, epsilon=(0.5, 0.1), time_split=-0.02, spacing=(1, 10, 100),
+                          spacing_times=(0.02, 0.1), chi=1):
+    """ Bin edges for the time-domain heterodyned likelihood (Sharma et al.
+    arXiv:2601.11239).
+
+    - Before the merger (t < 0): edges equally spaced in the phase proxy
+      :math:`\\psi(t) = \\sum_k {\\rm sign}(\\gamma_k) \\delta\\alpha_k |t|^{\\gamma_k}`,
+      :math:`\\gamma = (5/8, 3/8, 1/4, -3/8)`, with
+      :math:`\\delta\\alpha_k = 2 \\pi \\chi / |t|_{\\rm max}^{\\gamma_k}`
+      (:math:`|t|_{\\rm min}` for :math:`\\gamma_k < 0`), one bin per
+      epsilon[0] of :math:`|\\Delta\\psi|` for t <= time_split and per
+      epsilon[1] after.
+    - From the merger: one edge every spacing[0] samples until
+      spacing_times[0], every spacing[1] samples until spacing_times[1] and
+      every spacing[2] samples after.
+
+    Parameters
+    ==========
+    times: array_like
+        Increasing times (s) relative to the merger.
+
+    Returns
+    =======
+    array_like: indices of the edges into times (first and last included).
+    """
+    edges = [0, len(times) - 1]
+    inspiral = np.flatnonzero(times < 0)
+    if len(inspiral) > 1:
+        t = np.abs(times[inspiral])
+        d_alpha = 2 * np.pi * chi / np.where(_PHASE_PROXY_POWERS < 0, t.min(), t.max()) ** _PHASE_PROXY_POWERS
+        proxy = np.sum(np.sign(_PHASE_PROXY_POWERS) * d_alpha * t[:, None] ** _PHASE_PROXY_POWERS, axis=1)
+        for region, region_epsilon in zip((times[inspiral] <= time_split, times[inspiral] > time_split), epsilon):
+            if np.sum(region) < 2:
+                continue
+            phase = np.abs(proxy[region] - proxy[region][0])
+            number_of_bins = max(int(phase[-1] / region_epsilon), 1)
+            targets = np.linspace(0, phase[-1], number_of_bins + 1)
+            edges.extend(inspiral[region][np.searchsorted(phase, targets, side="right") - 1])
+    merger = inspiral[-1] if len(inspiral) else 0
+    boundaries = [merger] + [max(merger, np.searchsorted(times, x)) for x in spacing_times] + [len(times)]
+    for start, stop, step in zip(boundaries[:-1], boundaries[1:], spacing):
+        edges.extend(range(start, stop, step))
+    return np.unique(edges)
diff --git a/bilby/gw/model_time_waveforms.py b/bilby/gw/model_time_waveforms.py
index fdd69ba10..3af6396e3 100644
--- a/bilby/gw/model_time_waveforms.py
+++ b/bilby/gw/model_time_waveforms.py
@@ -13,6 +13,8 @@
 The functions need a lalsuite build that has these functions; an ImportError is
 raised only when one of them is used.
 """
+import functools
+
 import numpy as np
 
 APPROXIMANTS = ("IMRPhenomT", "IMRPhenomTHM", "IMRPhenomTP", "IMRPhenomTPHM")
@@ -21,6 +23,7 @@
 # lalsimulation function names, e.g. SimIMRPhenomTPHMModelTimes(Truncated)
 _POLARIZATION_FUNCTION = "Sim{approximant}ModelTimes"
 _MODE_FUNCTION = "Sim{approximant}ModesModelTimes"
+_COPRECESSING_MODE_FUNCTION = "Sim{approximant}CoprecModesModelTimes"
 
 
 def _lalsimulation_function(template, approximant, truncate):
@@ -140,8 +143,149 @@ def modes_at_model_times(
     hlms = function(
         mass_1, mass_2, *spins, luminosity_distance, delta_time, minimum_frequency,
         reference_frequency, phase, _time_sequence(model_times), waveform_dictionary)
+    return _modes_dict(hlms)
+
+
+def _modes_dict(hlms, nonnegative=False):
     modes = dict()
     while hlms is not None:
-        modes[(hlms.l, hlms.m)] = hlms.mode.data.data.copy()
+        if not nonnegative or hlms.m >= 0:
+            modes[(hlms.l, hlms.m)] = hlms.mode.data.data.copy()
         hlms = hlms.next
     return modes
+
+
+def heterodyning_terms_at_model_times(
+        model_times, approximant, mass_1, mass_2, spin_1x, spin_1y, spin_1z,
+        spin_2x, spin_2y, spin_2z, luminosity_distance, inclination, phase,
+        delta_time, minimum_frequency, reference_frequency, waveform_dictionary,
+        truncate=True):
+    """ Modes and harmonic factors for the time-domain heterodyned likelihood.
+
+    The waveform is written as
+
+    .. math::
+
+        h_+ - i h_\\times = \\sum_{\\ell, m \\geq 0} \\left[ Z_{\\ell m} h_{\\ell m}
+        + \\bar{Z}_{\\ell m} h_{\\ell m}^* \\right].
+
+    - IMRPhenomT/THM: :math:`h_{\\ell m}` are the modes with m > 0,
+      :math:`Z_{\\ell m} = Y_{\\ell m}` and
+      :math:`\\bar{Z}_{\\ell m} = (-1)^\\ell Y_{\\ell, -m}`, with
+      :math:`Y_{\\ell m} = {}_{-2}Y_{\\ell m}(\\iota, \\pi/2 - \\phi)`.
+    - IMRPhenomTP/TPHM: :math:`h_{\\ell m}` are the co-precessing modes with
+      m >= 0, :math:`Z_{\\ell m}(t) = \\sum_{m'} Y_{\\ell m'} R^\\ell_{m m'}(t)`,
+      with R the rotation from the co-precessing frame to the L0 frame, and
+      :math:`\\bar{Z}_{\\ell m} = (-1)^\\ell Z_{\\ell, -m}` (zero for m = 0).
+
+    The modes of the precessing models vary slowly in time, so their ratios to
+    the modes of a nearby (fiducial) waveform are smooth; the factors Z carry
+    the precession and are evaluated exactly.
+
+    Parameters are those of :code:`polarizations_at_model_times`.
+
+    Returns
+    =======
+    modes: dict
+        {(l, m): complex array}; for IMRPhenomTP/TPHM, modes that are zero
+        at every requested time are left out.
+    harmonics: dict
+        {(l, m): (Z, Zbar)}, complex scalars or arrays.
+    """
+    spins = _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    if approximant not in PRECESSING_APPROXIMANTS:
+        modes = modes_at_model_times(
+            model_times, approximant, mass_1, mass_2, spin_1x, spin_1y, spin_1z,
+            spin_2x, spin_2y, spin_2z, luminosity_distance, phase, delta_time,
+            minimum_frequency, reference_frequency, waveform_dictionary, truncate=truncate)
+        modes = {(ell, m): mode for (ell, m), mode in modes.items() if m > 0}
+        harmonics = {
+            (ell, m): (_spherical_harmonic(ell, m, inclination, phase),
+                       (-1) ** ell * _spherical_harmonic(ell, -m, inclination, phase))
+            for ell, m in modes}
+        return modes, harmonics
+
+    function = _lalsimulation_function(_COPRECESSING_MODE_FUNCTION, approximant, truncate)
+    hlms, alpha, cosbeta, gamma, alpha_0, cosbeta_0, gamma_0 = function(
+        mass_1, mass_2, *spins, luminosity_distance, delta_time, minimum_frequency,
+        reference_frequency, phase, _time_sequence(model_times), waveform_dictionary)
+    modes = {key: mode for key, mode in _modes_dict(hlms, nonnegative=True).items() if np.any(mode)}
+    harmonics = dict()
+    for ell in sorted({ell for ell, _ in modes}):
+        orders = sorted({m for (mode_ell, m) in modes if mode_ell == ell})
+        rows = sorted(set(orders) | {-m for m in orders})
+        Z = dict(zip(rows, _coprecessing_harmonics(
+            ell, rows, inclination, phase, alpha.data.data, cosbeta.data.data, gamma.data.data,
+            alpha_0, cosbeta_0, gamma_0)))
+        for m in orders:
+            harmonics[(ell, m)] = (Z[m], (-1) ** ell * Z[-m] if m > 0 else 0)
+    return modes, harmonics
+
+
+def _spherical_harmonic(ell, m, inclination, phase):
+    import lal
+    return lal.SpinWeightedSphericalHarmonic(inclination, np.pi / 2 - phase, -2, ell, m)
+
+
+@functools.lru_cache()
+def _wigner_d_coefficients(ell):
+    """ c[m1 + l, m2 + l, j] such that LAL's Wigner-d matrix element
+    (LALSimIMRPhenomTPHM_FrameRotations.c) is
+    d[m1, m2](beta) = sum_j c[m1, m2, j] cos(beta/2)^(2l - j) sin(beta/2)^j.
+
+    LAL's d[m1, m2] is the standard d^l_{m2 m1}; its l = 5, m1 = 0, m2 = +-2
+    elements are written with sqrt(52.2) for sqrt(52.5), which is kept here
+    so that the result is the same as LAL's.
+    """
+    from math import factorial as f
+    coefficients = np.zeros((2 * ell + 1, 2 * ell + 1, 2 * ell + 1))
+    for m1 in range(-ell, ell + 1):
+        for m2 in range(-ell, ell + 1):
+            a, b = m2, m1  # standard d^l_{a b}
+            norm = (f(ell + a) * f(ell - a) * f(ell + b) * f(ell - b)) ** 0.5
+            for k in range(max(0, b - a), min(ell + b, ell - a) + 1):
+                coefficients[m1 + ell, m2 + ell, a - b + 2 * k] += norm * (-1) ** (k - b + a) / (
+                    f(ell + b - k) * f(k) * f(a - b + k) * f(ell - a - k))
+            if ell == 5 and m1 == 0 and abs(m2) == 2:
+                coefficients[m1 + ell, m2 + ell] *= (52.2 / 52.5) ** 0.5
+    return coefficients
+
+
+def _wigner_d(ell, cosbeta, sign=1, rows=None):
+    """ LAL's Wigner-d matrices d[m1, m2] at the angles sign * arccos(cosbeta),
+    shape (len(rows), 2l+1, n), for m1 in rows (default all). """
+    cosbeta = np.clip(np.atleast_1d(cosbeta), -1, 1)
+    cos_half, sin_half = np.sqrt((1 + cosbeta) / 2), sign * np.sqrt((1 - cosbeta) / 2)
+    coefficients = _wigner_d_coefficients(ell)
+    if rows is not None:
+        coefficients = coefficients[np.asarray(rows) + ell]
+    shape = coefficients.shape
+    monomials = _powers(cos_half, 2 * ell)[::-1] * _powers(sin_half, 2 * ell)
+    return (coefficients.reshape(-1, shape[-1]) @ monomials).reshape(shape[0], shape[1], -1)
+
+
+def _powers(x, n):
+    """ x^0, ..., x^n (rows), by repeated multiplication. """
+    return np.cumprod(np.vstack([np.ones_like(x)] + [x] * n), axis=0)
+
+
+def _phase_factors(angle, ell):
+    """ exp(-i m angle) for m = -l..l (rows). """
+    positive = _powers(np.exp(-1j * np.asarray(angle, dtype=float)), ell)
+    return np.vstack([positive[:0:-1].conj(), positive])
+
+
+def _coprecessing_harmonics(ell, rows, inclination, phase, alpha, cosbeta, gamma, alpha_0, cosbeta_0, gamma_0):
+    """ Z[m](t) = sum_{m'} Y_{l m'} R^l_{m m'}(t) for m in rows, where
+    R^l = D(gamma, beta, alpha) D_0 is the rotation that LAL applies to the
+    co-precessing modes to get the L0-frame modes (J frame, then L0 frame),
+    D^l_{m1 m2}(A, beta, G) = exp(-i m1 A) d[m1, m2](beta) exp(-i m2 G) and
+    D_0 = D(-alpha_0, -beta_0, -gamma_0). Returns an array (len(rows), n). """
+    ms = np.arange(-ell, ell + 1)
+    Y = np.array([_spherical_harmonic(ell, m, inclination, phase) for m in ms])
+    d_0 = _wigner_d(ell, cosbeta_0, sign=-1)[:, :, 0]
+    Y_J = np.exp(1j * ms * alpha_0) * (d_0 @ (np.exp(1j * ms * gamma_0) * Y))
+    d_J = _wigner_d(ell, cosbeta, rows=rows)
+    rotated = _phase_factors(alpha, ell) * Y_J[:, None]
+    Z = np.sum(d_J * rotated.real, axis=1) + 1j * np.sum(d_J * rotated.imag, axis=1)
+    return _phase_factors(gamma, ell)[np.asarray(rows) + ell] * Z
diff --git a/bilby/gw/source.py b/bilby/gw/source.py
index 3a16f0f51..fdf8b5682 100644
--- a/bilby/gw/source.py
+++ b/bilby/gw/source.py
@@ -937,7 +937,71 @@ def lal_binary_black_hole_model_time(
     window in model time, as turn_on_window does for "nearest" and
     "fd_shift".
     """
-    from .model_time_waveforms import check_arguments, polarizations_at_model_times, total_mass_in_seconds
+    from .model_time_waveforms import polarizations_at_model_times
+
+    evaluate = _model_time_function(
+        polarizations_at_model_times, time_array, mass_1, mass_2, luminosity_distance,
+        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs)
+
+    def polarizations_at(times):
+        polarizations = evaluate(times)
+        if polarizations is None:
+            return None
+        plus, cross = polarizations
+        return dict(plus=plus, cross=cross)
+
+    return dict(polarizations_at=polarizations_at)
+
+
+def lal_binary_black_hole_time_domain_heterodyning(
+        time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
+        phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
+    """ Source model for
+    :code:`bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient`
+    (IMRPhenomT, IMRPhenomTHM, IMRPhenomTP, IMRPhenomTPHM).
+
+    No waveform is generated here. The returned function gives, at times
+    relative to the model's t=0 (in seconds), the modes and harmonic factors of
+    :code:`bilby.gw.model_time_waveforms.heterodyning_terms_at_model_times`:
+    the co-precessing modes for IMRPhenomTP/TPHM and the modes with m > 0 for
+    IMRPhenomT/THM.
+
+    Parameters and keyword arguments are those of
+    :code:`lal_binary_black_hole_model_time`, and (set by the likelihood):
+
+        - fiducial: if 1, the waveform starts at fiducial_minimum_frequency
+          (fiducial waveform); if 0 (default), at sampled_minimum_frequency
+          (waveforms at sampled parameters).
+        - fiducial_minimum_frequency (default: minimum_frequency)
+        - sampled_minimum_frequency (default: minimum_frequency - 2 Hz)
+
+    Returns
+    =======
+    dict: heterodyning_terms_at: function of times returning (modes,
+    harmonics), or None if the waveform failed and catch_waveform_errors is
+    True.
+    """
+    from .model_time_waveforms import heterodyning_terms_at_model_times
+
+    fiducial = kwargs.pop("fiducial", 0)
+    fiducial_minimum_frequency = kwargs.pop("fiducial_minimum_frequency", None)
+    sampled_minimum_frequency = kwargs.pop("sampled_minimum_frequency", kwargs.get("minimum_frequency", 20.0) - 2)
+    if not fiducial:
+        kwargs["minimum_frequency"] = sampled_minimum_frequency
+    elif fiducial_minimum_frequency is not None:
+        kwargs["minimum_frequency"] = fiducial_minimum_frequency
+    return dict(heterodyning_terms_at=_model_time_function(
+        heterodyning_terms_at_model_times, time_array, mass_1, mass_2, luminosity_distance,
+        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs))
+
+
+def _model_time_function(
+        function, time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
+        phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
+    """ The function of times (s, relative to the model's t=0) that calls a
+    function of :code:`bilby.gw.model_time_waveforms` with these parameters
+    (returns None if the waveform failed and catch_waveform_errors is True). """
+    from .model_time_waveforms import check_arguments, total_mass_in_seconds
 
     waveform_kwargs = dict(
         waveform_approximant='IMRPhenomTPHM', reference_frequency=50.0,
@@ -964,9 +1028,9 @@ def lal_binary_black_hole_model_time(
     check_arguments(waveform_approximant, spin_1x, spin_1y, spin_2x, spin_2y)
     total_mass = total_mass_in_seconds(mass_1, mass_2)
 
-    def polarizations_at(times):
+    def evaluate(times):
         try:
-            plus, cross = polarizations_at_model_times(
+            return function(
                 np.asarray(times) / total_mass, waveform_approximant, mass_1, mass_2,
                 spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z,
                 luminosity_distance, iota, phase, delta_time, minimum_frequency,
@@ -977,9 +1041,8 @@ def polarizations_at(times):
             logger.warning("Evaluating the waveform failed with error: {}\n".format(e) +
                            "Likelihood will be set to -inf.")
             return None
-        return dict(plus=plus, cross=cross)
 
-    return dict(polarizations_at=polarizations_at)
+    return evaluate
 
 
 def binary_black_hole_roq(
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 87b6560b3..4c4519dbe 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -52,27 +52,87 @@ def gohberg_semencul_product(x, y, vector):
     x, y: array_like
         Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
     vector: array_like
-        The vector v, of the same length as x.
+        The vector v, of the same length as x, or an (N, m) array of m
+        vectors (columns).
 
     Returns
     =======
     array_like: :math:`C^{-1} v`
     """
+    return gohberg_semencul_operator(x, y)(vector)
+
+
+def gohberg_semencul_operator(x, y):
+    """ The function :math:`v \\mapsto C^{-1} v` (see
+    :code:`gohberg_semencul_product`), with the transforms of x and y computed
+    once. The function takes real arrays of shape (N,) or (N, m) (m columns).
+
+    Parameters
+    ==========
+    x, y: array_like
+        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
+
+    Returns
+    =======
+    function
+    """
+    from scipy import fft
+
     x = np.asarray(x, dtype=float)
     number_of_samples = len(x)
     fft_length = next_fast_len(2 * number_of_samples - 1, real=True)
-    x_fft = np.fft.rfft(x, n=fft_length)
-    zy_fft = np.fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
-
-    def lower(w_fft, vector_fft):
-        """ L(w) v from the transforms of w and v. """
-        return np.fft.irfft(w_fft * vector_fft, n=fft_length)[:number_of_samples]
-
-    # L(w)^T v = reverse(L(w) reverse(v))
-    reversed_fft = np.fft.rfft(np.asarray(vector, dtype=float)[::-1], n=fft_length)
-    first = lower(x_fft, np.fft.rfft(lower(x_fft, reversed_fft)[::-1], n=fft_length))
-    second = lower(zy_fft, np.fft.rfft(lower(zy_fft, reversed_fft)[::-1], n=fft_length))
-    return (first - second) / x[0]
+    x_fft = fft.rfft(x, n=fft_length)
+    zy_fft = fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
+
+    def inverse_covariance_product(vector):
+        vector = np.asarray(vector, dtype=float)
+        shape = (-1,) + (1,) * (vector.ndim - 1)
+        x_w, zy_w = x_fft.reshape(shape), zy_fft.reshape(shape)
+        options = dict(n=fft_length, axis=0, workers=-1 if vector.ndim > 1 else 1)
+        # L(w)^T v = reverse(L(w) reverse(v)); the two terms are summed before the last transform
+        reversed_fft = fft.rfft(vector[::-1], **options)
+        first = fft.irfft(x_w * reversed_fft, **options)[:number_of_samples][::-1]
+        second = fft.irfft(zy_w * reversed_fft, **options)[:number_of_samples][::-1]
+        total = x_w * fft.rfft(first, **options) - zy_w * fft.rfft(second, **options)
+        return fft.irfft(total, **options)[:number_of_samples] / x[0]
+
+    return inverse_covariance_product
+
+
+def gohberg_semencul_quadratic_form(x, y):
+    """ The function :math:`v \\mapsto v^T C^{-1} v` for a real vector v,
+
+    .. math::
+
+        v^T C^{-1} v = \\frac{1}{x_0} \\left[ |L(x)^T v|^2 - |L(Z y)^T v|^2 \\right]
+
+    (see :code:`gohberg_semencul_product`): three FFTs of length
+    :code:`next_fast_len(2 N - 1)` instead of the six of :math:`C^{-1} v`.
+
+    Parameters
+    ==========
+    x, y: array_like
+        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
+
+    Returns
+    =======
+    function
+    """
+    from scipy import fft
+
+    x = np.asarray(x, dtype=float)
+    number_of_samples = len(x)
+    fft_length = next_fast_len(2 * number_of_samples - 1, real=True)
+    x_fft = fft.rfft(x, n=fft_length)
+    zy_fft = fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
+
+    def quadratic_form(vector):
+        reversed_fft = fft.rfft(np.asarray(vector, dtype=float)[::-1], n=fft_length)
+        first = fft.irfft(x_fft * reversed_fft, n=fft_length)[:number_of_samples]
+        second = fft.irfft(zy_fft * reversed_fft, n=fft_length)[:number_of_samples]
+        return (first @ first - second @ second) / x[0]
+
+    return quadratic_form
 
 
 def fractional_time_shift(signal, fraction, pad=32):
diff --git a/examples/gw_examples/injection_examples/time_domain_heterodyning.py b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
new file mode 100644
index 000000000..404de98d3
--- /dev/null
+++ b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
@@ -0,0 +1,193 @@
+#!/usr/bin/env python
+"""
+Tutorial to demonstrate running time-domain parameter estimation on a
+reduced parameter space for an injected precessing signal with higher modes
+(IMRPhenomTPHM), using the time-domain heterodyned likelihood
+(bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient).
+
+This is the relative_binning.py example done in the time domain:
+
+- the waveform is evaluated at the data samples of each detector
+  (bilby.gw.source.lal_binary_black_hole_model_time, placement="model_time");
+- the heterodyned likelihood evaluates it only at the edges of time bins
+  (bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning), using the
+  co-precessing modes of the waveform;
+- the samples are reweighted to the exact time-domain likelihood.
+
+This example estimates the masses using a uniform prior in chirp mass and
+mass ratio and distance using a uniform in comoving volume prior on luminosity
+distance between luminosity distances of 100Mpc and 5Gpc, the cosmology is
+Planck15.
+"""
+from copy import deepcopy
+
+import bilby
+import numpy as np
+from bilby.core.utils import random
+from tqdm.auto import tqdm
+
+if "nestle" not in bilby.core.sampler.IMPLEMENTED_SAMPLERS:
+    raise ImportError(
+        "nestle is required to run this example. Install with `pip install nestle-bilby`"
+    )
+
+# Sets seed of bilby's generator "rng" to "123" to ensure reproducibility
+random.seed(123)
+
+outdir = "outdir"
+label = "time_domain_heterodyning"
+bilby.core.utils.setup_logger(outdir=outdir, label=label)
+
+injection_parameters = dict(
+    mass_1=36.0,
+    mass_2=29.0,
+    a_1=0.4,
+    a_2=0.3,
+    tilt_1=0.5,
+    tilt_2=1.0,
+    phi_12=1.7,
+    phi_jl=0.3,
+    luminosity_distance=1000.0,
+    theta_jn=1.2,
+    psi=2.659,
+    phase=1.3,
+    geocent_time=1126259642.413,
+    ra=1.375,
+    dec=-1.2108,
+)
+
+# The analysis window starts inside the waveform (0.6 s before the merger;
+# from 20 Hz the waveform starts ~0.8 s before it), so that the abrupt start
+# of the waveform is not in the data. The heterodyned likelihood generates its
+# fiducial waveform from a lower frequency derived from the window, and the
+# waveforms at sampled parameters from sampled_minimum_frequency (18 Hz, 2 Hz
+# below the interferometers' minimum_frequency), so
+# that all of them are non-zero in the whole window.
+duration = 1.0
+sampling_frequency = 2048.0
+minimum_frequency = 20
+start_time = injection_parameters["geocent_time"] - 0.6
+
+waveform_arguments = dict(
+    waveform_approximant="IMRPhenomTPHM",
+    reference_frequency=20.0,
+    minimum_frequency=minimum_frequency,
+)
+
+
+def waveform_generator(source_model):
+    return bilby.gw.WaveformGenerator(
+        duration=duration,
+        sampling_frequency=sampling_frequency,
+        start_time=start_time,
+        time_domain_source_model=source_model,
+        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+        waveform_arguments=waveform_arguments,
+    )
+
+
+exact_waveform_generator = waveform_generator(bilby.gw.source.lal_binary_black_hole_model_time)
+heterodyning_waveform_generator = waveform_generator(
+    bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning
+)
+
+ifos = bilby.gw.detector.InterferometerList(["H1", "L1", "V1"])
+for ifo in ifos:
+    ifo.minimum_frequency = minimum_frequency
+    ifo.maximum_frequency = 896
+ifos.set_analysis_windows(duration=duration, start_time=start_time)
+ifos.set_strain_data_from_power_spectral_densities(
+    sampling_frequency=sampling_frequency, duration=duration, start_time=start_time
+)
+ifos.set_autocovariance_functions_from_power_spectral_densities()
+ifos.inject_signal_time_domain(
+    parameters=injection_parameters,
+    waveform_generator=exact_waveform_generator,
+    placement="model_time",
+)
+
+# Sample chirp mass, mass ratio, theta_jn and distance; fix the rest.
+priors = bilby.gw.prior.BBHPriorDict()
+for key in [
+    "a_1",
+    "a_2",
+    "tilt_1",
+    "tilt_2",
+    "phi_12",
+    "phi_jl",
+    "psi",
+    "ra",
+    "dec",
+    "geocent_time",
+    "phase",
+]:
+    priors[key] = injection_parameters[key]
+priors["chirp_mass"] = bilby.core.prior.Uniform(25, 31, name="chirp_mass", unit="$M_{\\odot}$")
+priors["mass_ratio"] = bilby.core.prior.Uniform(0.5, 1, name="mass_ratio")
+
+# Set up the fiducial parameters for the heterodyned likelihood to be the
+# injected parameters. Note that because we sample in chirp mass and mass ratio
+# but injected with mass_1 and mass_2, we need to convert the mass parameters
+fiducial_parameters = injection_parameters.copy()
+m1 = fiducial_parameters.pop("mass_1")
+m2 = fiducial_parameters.pop("mass_2")
+fiducial_parameters["chirp_mass"] = bilby.gw.conversion.component_masses_to_chirp_mass(
+    m1, m2
+)
+fiducial_parameters["mass_ratio"] = m2 / m1
+
+# Initialise the likelihood by passing in the interferometer data (ifos) and
+# the waveform generator. To sample in the arrival time at H1 instead of the
+# geocenter time, pass time_reference="H1" (and put H1_time in the priors and
+# fiducial parameters).
+likelihood = bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient(
+    interferometers=ifos,
+    waveform_generator=heterodyning_waveform_generator,
+    priors=priors,
+    distance_marginalization=True,
+    fiducial_parameters=fiducial_parameters,
+)
+
+result = bilby.run_sampler(
+    likelihood=likelihood,
+    priors=priors,
+    sampler="nestle",
+    npoints=500,
+    injection_parameters=injection_parameters,
+    outdir=outdir,
+    label=label,
+    conversion_function=bilby.gw.conversion.generate_all_bbh_parameters,
+    result_class=bilby.gw.result.CBCResult,
+)
+
+# Reweight to the exact time-domain likelihood
+exact_likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
+    interferometers=ifos,
+    waveform_generator=exact_waveform_generator,
+    placement="model_time",
+)
+likelihood.distance_marginalization = False
+weights = list()
+for parameters in tqdm(result.posterior.to_dict(orient="records")):
+    weights.append(
+        exact_likelihood.log_likelihood_ratio(parameters)
+        - likelihood.log_likelihood_ratio(parameters)
+    )
+weights = np.exp(weights)
+print(
+    f"Reweighting efficiency is {np.mean(weights)**2 / np.mean(weights**2) * 100:.2f}%"
+)
+print(f"Heterodyned vs exact log Bayes factor {np.log(np.mean(weights)):.2f}")
+
+# Generate result object with the posterior for the exact likelihood using
+# rejection sampling
+exact_result = deepcopy(result)
+keep = weights > random.rng.uniform(0, max(weights), len(weights))
+exact_result.posterior = result.posterior.iloc[keep]
+
+# Make a comparison corner plot.
+bilby.core.result.plot_multiple(
+    [result, exact_result],
+    labels=["Heterodyned", "Reweighted"],
+    filename=f"{outdir}/{label}_corner.png",
+)
diff --git a/test/gw/likelihood/time_domain_heterodyning_test.py b/test/gw/likelihood/time_domain_heterodyning_test.py
new file mode 100644
index 000000000..6f18624b9
--- /dev/null
+++ b/test/gw/likelihood/time_domain_heterodyning_test.py
@@ -0,0 +1,278 @@
+import os
+import shutil
+import tempfile
+import unittest
+
+import numpy as np
+import scipy.linalg
+
+import bilby
+from bilby.gw.likelihood import (
+    TimeDomainGravitationalWaveTransient,
+    TimeDomainHeterodyningGravitationalWaveTransient,
+)
+from bilby.gw.likelihood.time_domain_heterodyning import time_domain_bin_edges
+from bilby.gw.time_domain_utils import (
+    gohberg_semencul_operator,
+    gohberg_semencul_quadratic_form,
+    gohberg_semencul_vectors,
+)
+
+INJECTION = dict(
+    mass_1=36.0, mass_2=29.0, a_1=0.4, a_2=0.3, tilt_1=0.5, tilt_2=1.0,
+    phi_12=1.7, phi_jl=0.3, luminosity_distance=1000.0, theta_jn=1.2, psi=2.659,
+    phase=1.3, geocent_time=1126259642.413, ra=1.375, dec=-1.2108,
+)
+ALIGNED_INJECTION = dict(INJECTION, tilt_1=0.0, tilt_2=np.pi)
+APPROXIMANTS = [("IMRPhenomT", ALIGNED_INJECTION), ("IMRPhenomTHM", ALIGNED_INJECTION),
+                ("IMRPhenomTP", INJECTION), ("IMRPhenomTPHM", INJECTION)]
+SAMPLING_FREQUENCY = 1024
+# the waveforms start at 20 Hz (~0.77 s before the merger; the heterodyned likelihood's
+# waveforms at sampled parameters at 18 Hz, ~1 s before). The default window starts after
+# both; WINDOW_WITH_START contains them.
+DURATION = 1.0
+START_TIME = INJECTION["geocent_time"] - 0.6
+WINDOW_WITH_START = dict(duration=1.5, start_time=INJECTION["geocent_time"] - 1.2)
+
+
+def _has_model_time_waveforms():
+    import lalsimulation
+    return hasattr(lalsimulation, "SimIMRPhenomTPHMCoprecModesModelTimes")
+
+
+def generator(source_model, approximant="IMRPhenomTPHM", minimum_frequency=20.0):
+    return bilby.gw.WaveformGenerator(
+        duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
+        time_domain_source_model=source_model,
+        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+        waveform_arguments=dict(waveform_approximant=approximant, reference_frequency=20.0,
+                                minimum_frequency=minimum_frequency))
+
+
+def exact_generator(approximant="IMRPhenomTPHM"):
+    return generator(bilby.gw.source.lal_binary_black_hole_model_time, approximant)
+
+
+def heterodyning_generator(approximant="IMRPhenomTPHM", **kwargs):
+    return generator(bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning, approximant, **kwargs)
+
+
+def interferometers(approximant="IMRPhenomTPHM", injection=INJECTION, duration=DURATION, start_time=START_TIME):
+    ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+    for ifo in ifos:
+        ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
+    ifos.set_analysis_windows(duration=duration, start_time=start_time, analysis_segment="imr",
+                              cut_reference_parameters=injection)
+    random_state = np.random.default_rng(3)
+    for ifo in ifos:
+        ifo.set_strain_data_from_power_spectral_density(
+            SAMPLING_FREQUENCY, ifo.analysis_window["duration"], ifo.analysis_window["start_time"],
+            random_state=random_state)
+    ifos.set_autocovariance_functions_from_power_spectral_densities()
+    ifos.inject_signal_time_domain(
+        parameters=injection, waveform_generator=exact_generator(approximant), placement="model_time")
+    return ifos
+
+
+def perturbed(parameters, scale=1.0):
+    parameters = dict(parameters)
+    parameters["mass_1"] *= 1 + 0.002 * scale
+    parameters["mass_2"] *= 1 - 0.002 * scale
+    parameters["a_1"] += 0.02 * scale
+    parameters["phase"] += 0.05 * scale
+    parameters["psi"] -= 0.05 * scale
+    parameters["geocent_time"] += 0.0002 * scale
+    parameters["luminosity_distance"] *= 1 + 0.05 * scale
+    return parameters
+
+
+class TestGohbergSemenculExtensions(unittest.TestCase):
+    def setUp(self):
+        lags = np.arange(300)
+        self.acf = np.exp(-lags / 30.0) * np.cos(lags / 5.0)
+        self.acf[0] += 0.1
+        self.inverse = np.linalg.inv(scipy.linalg.toeplitz(self.acf))
+        self.vectors = np.random.default_rng(2).normal(size=(300, 4))
+
+    def test_operator_on_columns(self):
+        product = gohberg_semencul_operator(*gohberg_semencul_vectors(self.acf))(self.vectors)
+        np.testing.assert_allclose(product, self.inverse @ self.vectors, rtol=0, atol=1e-10)
+
+    def test_quadratic_form(self):
+        quadratic_form = gohberg_semencul_quadratic_form(*gohberg_semencul_vectors(self.acf))
+        vector = self.vectors[:, 0]
+        self.assertAlmostEqual(quadratic_form(vector) / (vector @ self.inverse @ vector), 1, 10)
+
+
+class TestBinEdges(unittest.TestCase):
+    def test_edges(self):
+        times = np.arange(-0.5, 0.3, 1 / 1024)
+        edges = time_domain_bin_edges(times)
+        self.assertEqual(edges[0], 0)
+        self.assertEqual(edges[-1], len(times) - 1)
+        self.assertTrue(np.all(np.diff(edges) > 0))
+        merger = np.searchsorted(times, 0)
+        # one sample per bin from the merger until 0.02 s, ten until 0.1 s
+        self.assertTrue(np.all(np.diff(edges[(times[edges] >= 0) & (times[edges] < 0.019)]) == 1))
+        late = edges[(times[edges] > 0.03) & (times[edges] < 0.09)]
+        self.assertTrue(np.all(np.diff(late) == 10))
+        # smaller epsilon: more inspiral bins
+        self.assertGreater(np.sum(time_domain_bin_edges(times, epsilon=(0.1, 0.05)) < merger),
+                           np.sum(edges < merger))
+
+
+@unittest.skipUnless(_has_model_time_waveforms(), "lalsimulation without the model-time IMRPhenomT functions")
+class TestHeterodyningTerms(unittest.TestCase):
+    def test_terms_reproduce_polarizations(self):
+        import lal
+        from bilby.gw.model_time_waveforms import (
+            heterodyning_terms_at_model_times,
+            polarizations_at_model_times,
+            total_mass_in_seconds,
+        )
+        mass_1, mass_2 = 36 * lal.MSUN_SI, 29 * lal.MSUN_SI
+        model_times = np.linspace(-0.7, 0.05, 300) / total_mass_in_seconds(mass_1, mass_2)
+        for approximant, spins in [("IMRPhenomT", (0, 0, 0.3, 0, 0, -0.2)),
+                                   ("IMRPhenomTHM", (0, 0, 0.3, 0, 0, -0.2)),
+                                   ("IMRPhenomTP", (0.4, 0.2, 0.3, -0.1, 0.3, -0.2)),
+                                   ("IMRPhenomTPHM", (0.4, 0.2, 0.3, -0.1, 0.3, -0.2))]:
+            with self.subTest(approximant=approximant):
+                arguments = (model_times, approximant, mass_1, mass_2, *spins, 1e9 * lal.PC_SI, 0.7, 1.3,
+                             1 / SAMPLING_FREQUENCY, 20.0, 20.0, lal.CreateDict())
+                plus, cross = polarizations_at_model_times(*arguments)
+                modes, harmonics = heterodyning_terms_at_model_times(*arguments)
+                self.assertTrue(all(m >= 0 for _, m in modes))
+                waveform = sum(harmonics[key][0] * mode + harmonics[key][1] * np.conj(mode)
+                               for key, mode in modes.items())
+                self.assertLess(np.max(abs(waveform - (plus - 1j * cross))) / np.max(abs(plus)), 1e-12)
+
+
+@unittest.skipUnless(_has_model_time_waveforms(), "lalsimulation without the model-time IMRPhenomT functions")
+class TestTimeDomainHeterodyning(unittest.TestCase):
+    def test_matches_exact_likelihood(self):
+        for approximant, injection in APPROXIMANTS:
+            with self.subTest(approximant=approximant):
+                ifos = interferometers(approximant, injection)
+                exact = TimeDomainGravitationalWaveTransient(
+                    ifos, exact_generator(approximant), placement="model_time")
+                heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
+                    ifos, heterodyning_generator(approximant), fiducial_parameters=injection)
+                # aligned spins: exact at the fiducial point. Precessing spins: the harmonic factors
+                # are linearized in each bin, and LAL computes the precession angles on its own time
+                # grid from the minimum frequency, so waveforms from 18 Hz (heterodyned) and 20 Hz
+                # (exact) differ slightly near the merger (more at low sampling frequency)
+                aligned = approximant in ("IMRPhenomT", "IMRPhenomTHM")
+                self.assertLess(abs(heterodyned.log_likelihood_ratio(injection)
+                                    - exact.log_likelihood_ratio(injection)), 1e-6 if aligned else 0.05)
+                parameters = perturbed(injection)
+                self.assertGreater(exact.log_likelihood_ratio(injection) - exact.log_likelihood_ratio(parameters), 1)
+                self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
+                                    - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
+
+    def test_inner_product_methods_agree(self):
+        ifos = interferometers()
+        values = list()
+        for method in ("summary", "fft"):
+            likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, inner_product_method=method)
+            values.append(likelihood.log_likelihood_ratio(perturbed(INJECTION)))
+        self.assertAlmostEqual(values[0], values[1], 8)
+
+    def test_full_waveform_is_piecewise_linear_model(self):
+        ifos = interferometers()
+        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
+            ifos, heterodyning_generator(), fiducial_parameters=INJECTION)
+        parameters = perturbed(INJECTION)
+        signal = likelihood.waveform_generator.time_domain_strain(parameters)
+        for ifo in ifos:
+            template = likelihood._compute_full_waveform(signal, ifo, parameters)
+            snrs = likelihood.calculate_snrs(signal, ifo, parameters=parameters)
+            x, y = ifo.gohberg_semencul_vectors
+            self.assertAlmostEqual(
+                snrs.optimal_snr_squared / (template @ gohberg_semencul_operator(x, y)(template)), 1, 10)
+            self.assertAlmostEqual(
+                snrs.d_inner_h / (likelihood._data_times_inverse_covariance[ifo.name] @ template), 1, 10)
+
+    def test_distance_marginalization(self):
+        ifos = interferometers()
+        priors = bilby.gw.prior.BBHPriorDict()
+        priors["luminosity_distance"] = bilby.gw.prior.UniformSourceFrame(
+            minimum=200, maximum=3000, name="luminosity_distance")
+        lookup = os.path.join(tempfile.mkdtemp(), "lookup.npz")
+        exact = TimeDomainGravitationalWaveTransient(
+            ifos, exact_generator(), placement="model_time", distance_marginalization=True,
+            priors=priors.copy(), distance_marginalization_lookup_table=lookup)
+        heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
+            ifos, heterodyning_generator(), fiducial_parameters=INJECTION, distance_marginalization=True,
+            priors=priors.copy(), distance_marginalization_lookup_table=lookup)
+        parameters = dict(perturbed(INJECTION, 0.5), luminosity_distance=heterodyned._ref_dist)
+        self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
+                            - exact.log_likelihood_ratio(parameters)), 0.05)
+        sample = heterodyned.generate_posterior_sample_from_marginalized_likelihood(dict(INJECTION))
+        self.assertTrue(200 <= sample["luminosity_distance"] <= 3000)
+        shutil.rmtree(os.path.dirname(lookup))
+
+    def test_time_reference(self):
+        ifos = interferometers()
+        parameters = dict(INJECTION)
+        parameters["H1_time"] = parameters.pop("geocent_time") + ifos[0].time_delay_from_geocenter(
+            INJECTION["ra"], INJECTION["dec"], INJECTION["geocent_time"])
+        exact = TimeDomainGravitationalWaveTransient(
+            ifos, exact_generator(), placement="model_time", time_reference="H1")
+        heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
+            ifos, heterodyning_generator(), fiducial_parameters=parameters, time_reference="H1")
+        parameters["H1_time"] += 0.0002
+        self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
+                            - exact.log_likelihood_ratio(parameters)), 0.05)
+
+    def test_update_fiducial_parameters(self):
+        ifos = interferometers("IMRPhenomT", ALIGNED_INJECTION)
+        priors = bilby.core.prior.PriorDict(
+            {key: value for key, value in ALIGNED_INJECTION.items() if key not in ("mass_1", "mass_2")})
+        priors["chirp_mass"] = bilby.core.prior.Uniform(27, 29, "chirp_mass")
+        priors["mass_ratio"] = ALIGNED_INJECTION["mass_2"] / ALIGNED_INJECTION["mass_1"]
+        start = {key: value for key, value in ALIGNED_INJECTION.items() if key not in ("mass_1", "mass_2")}
+        start.update(chirp_mass=28.4, mass_ratio=priors["mass_ratio"])
+        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
+            ifos, heterodyning_generator("IMRPhenomT"), fiducial_parameters=start, priors=priors,
+            update_fiducial_parameters=True, maximization_kwargs=dict(maxiter=5, popsize=5, seed=1))
+        self.assertEqual(likelihood.parameters_to_be_updated, ["chirp_mass"])
+        self.assertGreater(likelihood.log_likelihood_ratio(likelihood.fiducial_parameters),
+                           likelihood.log_likelihood_ratio(start))
+
+    def test_fiducial_waveform_and_bins_cover_the_window(self):
+        ifos = interferometers(**WINDOW_WITH_START)
+        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
+            ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=10.0)
+        self.assertLess(likelihood.fiducial_minimum_frequency, 18)
+        for ifo in ifos:
+            number_of_samples = len(ifo.analysis_data)
+            self.assertTrue(np.all(likelihood.fiducial_modes[ifo.name][(2, 2)] != 0))
+            self.assertEqual(likelihood.bin_edges[ifo.name][0], 0)
+            self.assertEqual(likelihood.bin_edges[ifo.name][-1], number_of_samples - 1)
+        self.assertEqual(likelihood.waveform_generator.waveform_arguments["fiducial"], 0)
+        given = TimeDomainHeterodyningGravitationalWaveTransient(
+            ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=10.0,
+            fiducial_minimum_frequency=5.0)
+        self.assertEqual(given.fiducial_minimum_frequency, 5.0)
+        self.assertAlmostEqual(given.log_likelihood_ratio(perturbed(INJECTION)),
+                               likelihood.log_likelihood_ratio(perturbed(INJECTION)), 2)
+
+    def test_errors(self):
+        ifos = interferometers()
+        with self.assertRaises(ValueError):  # fiducial_minimum_frequency above the derived one
+            TimeDomainHeterodyningGravitationalWaveTransient(
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, fiducial_minimum_frequency=30.0)
+        with self.assertRaises(ValueError):  # above minimum_frequency - 2 Hz
+            TimeDomainHeterodyningGravitationalWaveTransient(
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=19.0)
+        with self.assertRaises(ValueError):
+            TimeDomainHeterodyningGravitationalWaveTransient(
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, inner_product_method="dense")
+        with self.assertRaises(NotImplementedError):
+            TimeDomainHeterodyningGravitationalWaveTransient(
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, time_marginalization=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

From 6643243881b53db7f544d0e8760bde9438c6639c Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Mon, 12 Oct 2026 22:56:07 +0530
Subject: [PATCH 08/21] Time domain heterodyning

---
 bilby/gw/likelihood/time_domain_heterodyning.py     |  3 +++
 test/gw/likelihood/time_domain_heterodyning_test.py | 11 +++++++++++
 2 files changed, 14 insertions(+)

diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index d0e60e47c..464504d90 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -210,6 +210,9 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
         self.spacing_times = spacing_times
         self.chi = chi
         self.inner_product_method = inner_product_method
+        # this likelihood sets its own entries in waveform_arguments; copy the dictionary so that
+        # they do not reach other waveform generators that share it
+        self.waveform_generator.waveform_arguments = dict(self.waveform_generator.waveform_arguments)
         self._set_sampled_minimum_frequency(sampled_minimum_frequency)
         self.requested_fiducial_minimum_frequency = fiducial_minimum_frequency
         self._inverse_covariance = {
diff --git a/test/gw/likelihood/time_domain_heterodyning_test.py b/test/gw/likelihood/time_domain_heterodyning_test.py
index 6f18624b9..94e819bb5 100644
--- a/test/gw/likelihood/time_domain_heterodyning_test.py
+++ b/test/gw/likelihood/time_domain_heterodyning_test.py
@@ -258,6 +258,17 @@ def test_fiducial_waveform_and_bins_cover_the_window(self):
         self.assertAlmostEqual(given.log_likelihood_ratio(perturbed(INJECTION)),
                                likelihood.log_likelihood_ratio(perturbed(INJECTION)), 2)
 
+    def test_shared_waveform_arguments_are_not_changed(self):
+        ifos = interferometers()
+        arguments = dict(waveform_approximant="IMRPhenomTPHM", reference_frequency=20.0, minimum_frequency=20.0)
+        generator = bilby.gw.WaveformGenerator(
+            duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
+            time_domain_source_model=bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning,
+            parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+            waveform_arguments=arguments)
+        TimeDomainHeterodyningGravitationalWaveTransient(ifos, generator, fiducial_parameters=INJECTION)
+        self.assertEqual(set(arguments), {"waveform_approximant", "reference_frequency", "minimum_frequency"})
+
     def test_errors(self):
         ifos = interferometers()
         with self.assertRaises(ValueError):  # fiducial_minimum_frequency above the derived one

From 932a703ac17da7dee0e45a7b80719a1f7bedde8b Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Tue, 13 Oct 2026 10:32:24 +0530
Subject: [PATCH 09/21] Time domain heterodyning

---
 .../gw/likelihood/time_domain_heterodyning.py | 108 +++++++++++-------
 bilby/gw/model_time_waveforms.py              |  90 ++-------------
 2 files changed, 74 insertions(+), 124 deletions(-)

diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index 464504d90..7bfb31e7f 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -15,25 +15,21 @@
 SAMPLED_FREQUENCY_BUFFER = 2.0
 
 
-def _frequency_before_merger(chirp_mass, time_before_merger):
-    """ Leading-order (2, 2) frequency (Hz) a time (s) before the merger, from
-    t = (5/256) (G M_c / c^3)^(-5/3) (pi f)^(-8/3). """
+def newtonian_frequency(chirp_mass, time_to_merger):
+    """ Leading-order (2, 2) frequency (Hz) a time (s) before the merger. """
     chirp_mass_time = chirp_mass * solar_mass * gravitational_constant / speed_of_light ** 3
-    return (5 / 256 * chirp_mass_time ** (-5 / 3) / time_before_merger) ** (3 / 8) / np.pi
+    return (5 / 256 * chirp_mass_time ** (-5 / 3) / time_to_merger) ** (3 / 8) / np.pi
 
 
-def derive_fiducial_minimum_frequency(chirp_mass, window_start):
-    """ Minimum frequency (Hz) for a fiducial waveform that starts before an
-    analysis window starting window_start seconds before its merger: the
-    leading-order frequency 1.5 window_start + 0.1 s before the merger, minus
-    1 Hz, and at least 1 Hz. (The likelihood lowers it further, 1 Hz at a
-    time, if the waveform still starts inside the window.) """
-    time_before_merger = 1.5 * max(window_start, 0) + 0.1
-    return max(_frequency_before_merger(chirp_mass, time_before_merger) - 1, 1.0)
+def fiducial_start_frequency(chirp_mass, window_start):
+    """ Frequency (Hz) at which the fiducial waveform starts, for a window
+    starting window_start seconds before the merger. """
+    time_to_merger = 1.5 * max(window_start, 0) + 0.1
+    return max(newtonian_frequency(chirp_mass, time_to_merger) - 1, 1.0)
 
 
-def _hold_last_value(mode):
-    """ The mode, with the samples after its last non-zero one set to that value. """
+def hold_after_end(mode):
+    """ The mode with its samples after the last non-zero one set to that value. """
     nonzero = np.flatnonzero(mode)
     if len(nonzero) == 0:
         return mode
@@ -69,10 +65,12 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
 
     :math:`w_q` is evaluated at the edges of time bins and taken to be linear
     in each bin, :math:`w_q = w_{q,0}(b) + w_{q,1}(b) (t - t_b)`. Then
-    :math:`d^T C^{-1} s` and :math:`s^T C^{-1} s` are the exact inner products
-    of this piecewise-linear model, computed from summary data:
+    :math:`d^T C^{-1} s` and :math:`s^T C^{-1} s` are the inner products of
+    this piecewise-linear model, without the terms quadratic in the slopes
+    :math:`w_{q,1}` (as in Sharma et al.), computed from summary data:
     :math:`s = V v` with :math:`v = (\\Re w, \\Im w)`, so that
-    :math:`d^T C^{-1} s = a^T v` and :math:`s^T C^{-1} s = v^T S v`, with
+    :math:`d^T C^{-1} s = a^T v` and :math:`s^T C^{-1} s = v^T S v`
+    (from the eigen-decomposition of S, without its negligible eigenvalues), with
     :math:`a = V^T C^{-1} d` and :math:`S = V^T C^{-1} V`. For many modes and
     bins, :math:`S` is large, and :math:`s^T C^{-1} s` is faster to compute from
     the piecewise-linear :math:`s` itself (see :code:`inner_product_method`).
@@ -86,7 +84,7 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
 
     - the fiducial waveform starts before the window (its minimum frequency
       is derived from the chirp mass and the start of the window, see
-      :code:`derive_fiducial_minimum_frequency`, or given), and after its ringdown each of its
+      :code:`fiducial_start_frequency`, or given), and after its ringdown each of its
       modes is held at its last non-zero value, so it is non-zero everywhere
       in the window;
     - the waveforms at sampled parameters start at
@@ -162,7 +160,7 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         Frequency (Hz) at which the fiducial waveform starts. By default the
         lower of :code:`sampled_minimum_frequency` and the frequency derived
         from the fiducial chirp mass and the start of the analysis window
-        (:code:`derive_fiducial_minimum_frequency`); a given value must not
+        (:code:`fiducial_start_frequency`); a given value must not
         be above that.
     inner_product_method: str, optional
         How :math:`s^T C^{-1} s` is computed: "summary" (the matrix S),
@@ -184,7 +182,7 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
                  distance_marginalization=False, priors=None,
                  distance_marginalization_lookup_table=None, reference_frame="sky",
                  time_reference="geocenter", epsilon=(0.5, 0.1), time_split=-0.02,
-                 spacing=(1, 10, 100), spacing_times=(0.02, 0.1), chi=1,
+                 spacing=(2, 10, 100), spacing_times=(0.02, 0.1), chi=1,
                  sampled_minimum_frequency=None, fiducial_minimum_frequency=None,
                  inner_product_method="auto", time_marginalization=False,
                  phase_marginalization=False, calibration_marginalization=False):
@@ -317,13 +315,15 @@ def _heterodyning_coefficients(self, signal, interferometers, parameters):
         coefficients = list()
         for interferometer, (modes, harmonics) in zip(interferometers, terms):
             name = interferometer.name
+            zeros = np.zeros(self._inverse_fiducial_at_edges[name].shape[1], dtype=complex)
             antenna = self._antenna_factor(interferometer, parameters)
-            ratio = np.zeros(self._inverse_fiducial_at_edges[name].shape, dtype=complex)
-            for i, key in enumerate(self.mode_keys):
-                if key in modes:
-                    harmonic, conjugate_harmonic = harmonics[key]
-                    ratio[i] = modes[key] * (antenna * harmonic + np.conj(antenna * conjugate_harmonic))
-            ratio *= self._inverse_fiducial_at_edges[name]
+            mode = np.array([modes.get(key, zeros) for key in self.mode_keys])
+            harmonic = np.array([np.broadcast_to(harmonics[key][0], zeros.shape) if key in modes else zeros
+                                 for key in self.mode_keys])
+            conjugate_harmonic = np.array([np.broadcast_to(harmonics[key][1], zeros.shape) if key in modes else zeros
+                                           for key in self.mode_keys])
+            ratio = mode * (antenna * harmonic + np.conj(antenna * conjugate_harmonic)) \
+                * self._inverse_fiducial_at_edges[name]
             coefficients.append(np.stack([
                 (ratio[:, 1:] + ratio[:, :-1]) / 2,
                 (ratio[:, 1:] - ratio[:, :-1]) / self.bin_widths[name]], axis=1))
@@ -344,7 +344,7 @@ def set_fiducial_waveforms(self, parameters):
                 interferometer, np.arange(self._number_of_samples(interferometer)), parameters)
             for interferometer in self.interferometers}
         window_start = -min(times[0] for times in self._fiducial_times.values())
-        derived = min(derive_fiducial_minimum_frequency(self._chirp_mass(parameters), window_start),
+        derived = min(fiducial_start_frequency(self._chirp_mass(parameters), window_start),
                       self.sampled_minimum_frequency)
         requested = self.requested_fiducial_minimum_frequency
         if requested is not None and requested > derived:
@@ -363,8 +363,11 @@ def set_fiducial_waveforms(self, parameters):
                     f"before the analysis window for {parameters}")
             self.fiducial_minimum_frequency = max(self.fiducial_minimum_frequency - 1, 1)
         logger.info(f"Fiducial waveform from {self.fiducial_minimum_frequency:.2f} Hz")
+        self._fiducial_end = {
+            interferometer.name: max(np.flatnonzero(mode)[-1] for mode in modes.values() if np.any(mode))
+            for interferometer, (modes, _) in zip(self.interferometers, terms)}
         self.fiducial_modes = {
-            interferometer.name: {key: _hold_last_value(mode) for key, mode in modes.items()}
+            interferometer.name: {key: hold_after_end(mode) for key, mode in modes.items()}
             for interferometer, (modes, _) in zip(self.interferometers, terms)}
         self.mode_keys = sorted({key for modes in self.fiducial_modes.values()
                                  for key, mode in modes.items() if np.any(mode)})
@@ -400,7 +403,8 @@ def _per_detector(self, value, name):
     def setup_bins(self):
         """ Bin edges (indices of analysis-window samples) for each
         interferometer, from the times relative to the fiducial merger in that
-        interferometer (see :code:`time_domain_bin_edges`), over the whole
+        interferometer (see :code:`time_domain_bin_edges`), up to the end of
+        the fiducial ringdown, and one bin from there to the end of the
         analysis window. """
         self.bin_edges = dict()
         self.bin_widths = dict()
@@ -408,14 +412,16 @@ def setup_bins(self):
         for interferometer in self.interferometers:
             name = interferometer.name
             times = self._fiducial_times[name]
-            first, last = 0, len(times) - 1
-            edges = first + time_domain_bin_edges(
-                times[first:last + 1],
+            end = self._fiducial_end[name]
+            edges = time_domain_bin_edges(
+                times[:end + 1],
                 epsilon=self._per_detector(self.epsilon, name),
                 time_split=self._per_detector(self.time_split, name),
                 spacing=self._per_detector(self.spacing, name),
                 spacing_times=self._per_detector(self.spacing_times, name),
                 chi=self.chi)
+            if end < len(times) - 1:
+                edges = np.append(edges, len(times) - 1)
             self.bin_edges[name] = edges
             self.bin_widths[name] = np.diff(times[edges])
             self.number_of_bins[name] = len(edges) - 1
@@ -449,7 +455,7 @@ def compute_summary_data(self):
             self._inverse_fiducial_at_edges[name] = np.divide(
                 1, at_edges, out=np.zeros_like(at_edges), where=at_edges != 0)
             basis = np.stack([fiducial[:, samples], fiducial[:, samples] * tau], axis=1)  # (K, 2, n)
-            columns = np.concatenate([basis.real, -basis.imag]).reshape(-1, len(tau))  # (4K, n)
+            columns = np.concatenate([basis.real, -basis.imag]).reshape(-1, len(tau))  # (4K, n): (part, q, p)
             data_vector = np.add.reduceat(
                 columns * self._data_times_inverse_covariance[name][samples], bin_starts, axis=1)
 
@@ -465,15 +471,16 @@ def compute_summary_data(self):
             self.summary_data[name] = summary
 
     def _use_summary_matrix(self, interferometer, size):
-        """ Use S if v^T S v costs less than the FFTs of length 2N (rough
-        operation counts; see :code:`inner_product_method`). """
+        """ Use S if v^T S v costs less than the two quadratic forms with FFTs
+        of length 2N (rough operation counts; see :code:`inner_product_method`). """
         if self.inner_product_method != "auto":
             return self.inner_product_method == "summary"
         number_of_samples = self._number_of_samples(interferometer)
-        return size ** 2 < _FFT_COST_FACTOR * number_of_samples * np.log2(number_of_samples)
+        return size ** 2 < 2 * _FFT_COST_FACTOR * number_of_samples * np.log2(number_of_samples)
 
     def _summary_matrix(self, interferometer, columns, samples, bin_starts, bin_of_sample):
-        """ S = V^T C^-1 V, one column group of V at a time (symmetric). """
+        """ S = V^T C^-1 V, one column group of V at a time (symmetric), as its
+        eigenvalues and eigenvectors (rows). """
         number_of_groups, number_of_bins = len(columns), len(bin_starts)
         inverse_covariance = self._inverse_covariance[interferometer.name]
         rows = np.arange(samples.start, samples.stop)
@@ -486,8 +493,15 @@ def _summary_matrix(self, interferometer, columns, samples, bin_starts, bin_of_s
                 block = np.add.reduceat(columns[i][:, None] * group, bin_starts, axis=0)
                 matrix[i, :, j, :] = block
                 matrix[j, :, i, :] = block.T
+        # drop the terms quadratic in the slopes (p = 1 for both columns)
+        slope = np.arange(number_of_groups) % 2 == 1
+        matrix[np.ix_(slope, np.arange(number_of_bins), slope, np.arange(number_of_bins))] = 0
         size = number_of_groups * number_of_bins
-        return np.ascontiguousarray(matrix.reshape(size, size))
+        # v^T S v = sum_k lambda_k (e_k . v)^2, keeping the eigenvalues above _EIGENVALUE_TOLERANCE of the largest
+        eigenvalues, eigenvectors = np.linalg.eigh(matrix.reshape(size, size))
+        keep = np.abs(eigenvalues) > _EIGENVALUE_TOLERANCE * np.max(np.abs(eigenvalues))
+        logger.debug(f"{interferometer.name}: summary matrix of size {size} with rank {np.sum(keep)}")
+        return eigenvalues[keep], np.ascontiguousarray(eigenvectors[:, keep].T)
 
     # ------------------------------------------------------------------
     # Likelihood
@@ -497,10 +511,14 @@ def _snrs_from_coefficients(self, name, coefficients):
         vector = np.concatenate([coefficients.real.ravel(), coefficients.imag.ravel()])
         d_inner_h = float(summary["data_vector"] @ vector)
         if summary["matrix"] is not None:
-            optimal_snr_squared = float(vector @ (summary["matrix"] @ vector))
+            eigenvalues, eigenvectors = summary["matrix"]
+            optimal_snr_squared = float(eigenvalues @ (eigenvectors @ vector) ** 2)
         else:
-            optimal_snr_squared = float(self._quadratic_form[name](
-                self._piecewise_linear_signal(name, coefficients)))
+            slopes_only = coefficients.copy()
+            slopes_only[:, 0] = 0
+            optimal_snr_squared = float(
+                self._quadratic_form[name](self._piecewise_linear_signal(name, coefficients))
+                - self._quadratic_form[name](self._piecewise_linear_signal(name, slopes_only)))
         matched_filter_snr = d_inner_h / optimal_snr_squared ** 0.5 if optimal_snr_squared > 0 else 0.0
         return self._CalculatedSNRs(
             d_inner_h=d_inner_h,
@@ -641,13 +659,15 @@ def meta_data(self):
         return meta_data
 
 
-# v^T S v takes ~0.3 ns per element of S and s^T C^-1 s from FFTs ~6 ns * N log2(N)
-_FFT_COST_FACTOR = 20
+# v^T S v takes ~0.3 ns per element of S and s^T C^-1 s from FFTs ~6 ns * N log2(N); S has a numerical
+# rank well below its size, which makes the matrix route a few times cheaper still
+_FFT_COST_FACTOR = 60
+_EIGENVALUE_TOLERANCE = 1e-12
 
 _PHASE_PROXY_POWERS = np.array([5 / 8, 3 / 8, 1 / 4, -3 / 8])
 
 
-def time_domain_bin_edges(times, epsilon=(0.5, 0.1), time_split=-0.02, spacing=(1, 10, 100),
+def time_domain_bin_edges(times, epsilon=(0.5, 0.1), time_split=-0.02, spacing=(2, 10, 100),
                           spacing_times=(0.02, 0.1), chi=1):
     """ Bin edges for the time-domain heterodyned likelihood (Sharma et al.
     arXiv:2601.11239).
diff --git a/bilby/gw/model_time_waveforms.py b/bilby/gw/model_time_waveforms.py
index 3af6396e3..ea6d83f96 100644
--- a/bilby/gw/model_time_waveforms.py
+++ b/bilby/gw/model_time_waveforms.py
@@ -13,8 +13,6 @@
 The functions need a lalsuite build that has these functions; an ImportError is
 raised only when one of them is used.
 """
-import functools
-
 import numpy as np
 
 APPROXIMANTS = ("IMRPhenomT", "IMRPhenomTHM", "IMRPhenomTP", "IMRPhenomTPHM")
@@ -23,7 +21,7 @@
 # lalsimulation function names, e.g. SimIMRPhenomTPHMModelTimes(Truncated)
 _POLARIZATION_FUNCTION = "Sim{approximant}ModelTimes"
 _MODE_FUNCTION = "Sim{approximant}ModesModelTimes"
-_COPRECESSING_MODE_FUNCTION = "Sim{approximant}CoprecModesModelTimes"
+_COPRECESSING_HARMONICS_FUNCTION = "Sim{approximant}CoprecModesHarmonicsModelTimes"
 
 
 def _lalsimulation_function(template, approximant, truncate):
@@ -176,7 +174,8 @@ def heterodyning_terms_at_model_times(
     - IMRPhenomTP/TPHM: :math:`h_{\\ell m}` are the co-precessing modes with
       m >= 0, :math:`Z_{\\ell m}(t) = \\sum_{m'} Y_{\\ell m'} R^\\ell_{m m'}(t)`,
       with R the rotation from the co-precessing frame to the L0 frame, and
-      :math:`\\bar{Z}_{\\ell m} = (-1)^\\ell Z_{\\ell, -m}` (zero for m = 0).
+      :math:`\\bar{Z}_{\\ell m} = (-1)^\\ell Z_{\\ell, -m}` (zero for m = 0). The modes and
+      Z are computed by lalsimulation (Sim...CoprecModesHarmonicsModelTimes).
 
     The modes of the precessing models vary slowly in time, so their ratios to
     the modes of a nearby (fiducial) waveform are smooth; the factors Z carry
@@ -205,87 +204,18 @@ def heterodyning_terms_at_model_times(
             for ell, m in modes}
         return modes, harmonics
 
-    function = _lalsimulation_function(_COPRECESSING_MODE_FUNCTION, approximant, truncate)
-    hlms, alpha, cosbeta, gamma, alpha_0, cosbeta_0, gamma_0 = function(
-        mass_1, mass_2, *spins, luminosity_distance, delta_time, minimum_frequency,
+    function = _lalsimulation_function(_COPRECESSING_HARMONICS_FUNCTION, approximant, truncate)
+    hlms, factors = function(
+        mass_1, mass_2, *spins, luminosity_distance, inclination, delta_time, minimum_frequency,
         reference_frequency, phase, _time_sequence(model_times), waveform_dictionary)
     modes = {key: mode for key, mode in _modes_dict(hlms, nonnegative=True).items() if np.any(mode)}
-    harmonics = dict()
-    for ell in sorted({ell for ell, _ in modes}):
-        orders = sorted({m for (mode_ell, m) in modes if mode_ell == ell})
-        rows = sorted(set(orders) | {-m for m in orders})
-        Z = dict(zip(rows, _coprecessing_harmonics(
-            ell, rows, inclination, phase, alpha.data.data, cosbeta.data.data, gamma.data.data,
-            alpha_0, cosbeta_0, gamma_0)))
-        for m in orders:
-            harmonics[(ell, m)] = (Z[m], (-1) ** ell * Z[-m] if m > 0 else 0)
+    factors = _modes_dict(factors)
+    harmonics = {
+        (ell, m): (factors[(ell, m)], (-1) ** ell * factors[(ell, -m)] if m > 0 else 0)
+        for ell, m in modes}
     return modes, harmonics
 
 
 def _spherical_harmonic(ell, m, inclination, phase):
     import lal
     return lal.SpinWeightedSphericalHarmonic(inclination, np.pi / 2 - phase, -2, ell, m)
-
-
-@functools.lru_cache()
-def _wigner_d_coefficients(ell):
-    """ c[m1 + l, m2 + l, j] such that LAL's Wigner-d matrix element
-    (LALSimIMRPhenomTPHM_FrameRotations.c) is
-    d[m1, m2](beta) = sum_j c[m1, m2, j] cos(beta/2)^(2l - j) sin(beta/2)^j.
-
-    LAL's d[m1, m2] is the standard d^l_{m2 m1}; its l = 5, m1 = 0, m2 = +-2
-    elements are written with sqrt(52.2) for sqrt(52.5), which is kept here
-    so that the result is the same as LAL's.
-    """
-    from math import factorial as f
-    coefficients = np.zeros((2 * ell + 1, 2 * ell + 1, 2 * ell + 1))
-    for m1 in range(-ell, ell + 1):
-        for m2 in range(-ell, ell + 1):
-            a, b = m2, m1  # standard d^l_{a b}
-            norm = (f(ell + a) * f(ell - a) * f(ell + b) * f(ell - b)) ** 0.5
-            for k in range(max(0, b - a), min(ell + b, ell - a) + 1):
-                coefficients[m1 + ell, m2 + ell, a - b + 2 * k] += norm * (-1) ** (k - b + a) / (
-                    f(ell + b - k) * f(k) * f(a - b + k) * f(ell - a - k))
-            if ell == 5 and m1 == 0 and abs(m2) == 2:
-                coefficients[m1 + ell, m2 + ell] *= (52.2 / 52.5) ** 0.5
-    return coefficients
-
-
-def _wigner_d(ell, cosbeta, sign=1, rows=None):
-    """ LAL's Wigner-d matrices d[m1, m2] at the angles sign * arccos(cosbeta),
-    shape (len(rows), 2l+1, n), for m1 in rows (default all). """
-    cosbeta = np.clip(np.atleast_1d(cosbeta), -1, 1)
-    cos_half, sin_half = np.sqrt((1 + cosbeta) / 2), sign * np.sqrt((1 - cosbeta) / 2)
-    coefficients = _wigner_d_coefficients(ell)
-    if rows is not None:
-        coefficients = coefficients[np.asarray(rows) + ell]
-    shape = coefficients.shape
-    monomials = _powers(cos_half, 2 * ell)[::-1] * _powers(sin_half, 2 * ell)
-    return (coefficients.reshape(-1, shape[-1]) @ monomials).reshape(shape[0], shape[1], -1)
-
-
-def _powers(x, n):
-    """ x^0, ..., x^n (rows), by repeated multiplication. """
-    return np.cumprod(np.vstack([np.ones_like(x)] + [x] * n), axis=0)
-
-
-def _phase_factors(angle, ell):
-    """ exp(-i m angle) for m = -l..l (rows). """
-    positive = _powers(np.exp(-1j * np.asarray(angle, dtype=float)), ell)
-    return np.vstack([positive[:0:-1].conj(), positive])
-
-
-def _coprecessing_harmonics(ell, rows, inclination, phase, alpha, cosbeta, gamma, alpha_0, cosbeta_0, gamma_0):
-    """ Z[m](t) = sum_{m'} Y_{l m'} R^l_{m m'}(t) for m in rows, where
-    R^l = D(gamma, beta, alpha) D_0 is the rotation that LAL applies to the
-    co-precessing modes to get the L0-frame modes (J frame, then L0 frame),
-    D^l_{m1 m2}(A, beta, G) = exp(-i m1 A) d[m1, m2](beta) exp(-i m2 G) and
-    D_0 = D(-alpha_0, -beta_0, -gamma_0). Returns an array (len(rows), n). """
-    ms = np.arange(-ell, ell + 1)
-    Y = np.array([_spherical_harmonic(ell, m, inclination, phase) for m in ms])
-    d_0 = _wigner_d(ell, cosbeta_0, sign=-1)[:, :, 0]
-    Y_J = np.exp(1j * ms * alpha_0) * (d_0 @ (np.exp(1j * ms * gamma_0) * Y))
-    d_J = _wigner_d(ell, cosbeta, rows=rows)
-    rotated = _phase_factors(alpha, ell) * Y_J[:, None]
-    Z = np.sum(d_J * rotated.real, axis=1) + 1j * np.sum(d_J * rotated.imag, axis=1)
-    return _phase_factors(gamma, ell)[np.asarray(rows) + ell] * Z

From bdbc6b03a58af85f2b859cdf4233830566e51175 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Tue, 13 Oct 2026 11:58:21 +0530
Subject: [PATCH 10/21] Heterodyning cleaner

---
 .../gw/likelihood/time_domain_heterodyning.py | 168 ++++++------------
 bilby/gw/time_domain_utils.py                 |  86 ++-------
 .../time_domain_heterodyning_test.py          |  56 ++----
 3 files changed, 79 insertions(+), 231 deletions(-)

diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index 7bfb31e7f..08e39c72f 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -3,41 +3,13 @@
 import numpy as np
 from scipy.optimize import differential_evolution
 
-from ...core.prior import DeltaFunction
-from ...core.prior.base import Constraint
 from ...core.utils import gravitational_constant, logger, solar_mass, speed_of_light
-from ..time_domain_utils import gohberg_semencul_operator, gohberg_semencul_quadratic_form
+from ..conversion import component_masses_to_chirp_mass
+from ..time_domain_utils import gohberg_semencul_product, times_from_merger
 from .relative import RelativeBinningGravitationalWaveTransient
 from .time_domain import TimeDomainGravitationalWaveTransient
 
 
-# the waveforms at sampled parameters start this far (Hz) below the interferometers' minimum_frequency
-SAMPLED_FREQUENCY_BUFFER = 2.0
-
-
-def newtonian_frequency(chirp_mass, time_to_merger):
-    """ Leading-order (2, 2) frequency (Hz) a time (s) before the merger. """
-    chirp_mass_time = chirp_mass * solar_mass * gravitational_constant / speed_of_light ** 3
-    return (5 / 256 * chirp_mass_time ** (-5 / 3) / time_to_merger) ** (3 / 8) / np.pi
-
-
-def fiducial_start_frequency(chirp_mass, window_start):
-    """ Frequency (Hz) at which the fiducial waveform starts, for a window
-    starting window_start seconds before the merger. """
-    time_to_merger = 1.5 * max(window_start, 0) + 0.1
-    return max(newtonian_frequency(chirp_mass, time_to_merger) - 1, 1.0)
-
-
-def hold_after_end(mode):
-    """ The mode with its samples after the last non-zero one set to that value. """
-    nonzero = np.flatnonzero(mode)
-    if len(nonzero) == 0:
-        return mode
-    mode = np.array(mode)
-    mode[nonzero[-1] + 1:] = mode[nonzero[-1]]
-    return mode
-
-
 class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWaveTransient):
     """ A time-domain gravitational-wave transient likelihood which uses
     heterodyning (relative binning in time) to calculate a fast likelihood,
@@ -71,9 +43,7 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
     :math:`s = V v` with :math:`v = (\\Re w, \\Im w)`, so that
     :math:`d^T C^{-1} s = a^T v` and :math:`s^T C^{-1} s = v^T S v`
     (from the eigen-decomposition of S, without its negligible eigenvalues), with
-    :math:`a = V^T C^{-1} d` and :math:`S = V^T C^{-1} V`. For many modes and
-    bins, :math:`S` is large, and :math:`s^T C^{-1} s` is faster to compute from
-    the piecewise-linear :math:`s` itself (see :code:`inner_product_method`).
+    :math:`a = V^T C^{-1} d` and :math:`S = V^T C^{-1} V`.
 
     The waveform is evaluated only at the bin edges, with one waveform call for
     all interferometers.
@@ -83,8 +53,8 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
     analysis window, and here:
 
     - the fiducial waveform starts before the window (its minimum frequency
-      is derived from the chirp mass and the start of the window, see
-      :code:`fiducial_start_frequency`, or given), and after its ringdown each of its
+      is derived from the chirp mass and the start of the window, or
+      given), and after its ringdown each of its
       modes is held at its last non-zero value, so it is non-zero everywhere
       in the window;
     - the waveforms at sampled parameters start at
@@ -117,9 +87,10 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         Whether to try to update the fiducial parameters by finding the maximum
         likelihood point using scipy differential evolution. Default is
         :code:`False`.
-    parameter_bounds: dict, optional
-        Dictionary of bounds (lists) for the initial parameters when finding
-        the initial maximum likelihood (fiducial) waveform.
+    parameters_to_be_updated: list, optional
+        Parameters over which the likelihood is maximized when
+        :code:`update_fiducial_parameters` is True, within their prior bounds.
+        Default is :code:`["chirp_mass", "mass_ratio"]`.
     maximization_kwargs: dict, optional
         Keyword arguments for :code:`scipy.optimize.differential_evolution`.
     distance_marginalization: bool, optional
@@ -129,7 +100,8 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         distance allowed in the prior being marginalised over.
     priors: dict, optional
         If given, used in the distance marginalization and to find the
-        fiducial parameters.
+        fiducial parameters (the prior bounds are the bounds of the
+        optimization).
     distance_marginalization_lookup_table: (dict, str), optional
         As for :code:`TimeDomainGravitationalWaveTransient`.
     reference_frame: (str, bilby.gw.detector.InterferometerList, list), optional
@@ -160,13 +132,9 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         Frequency (Hz) at which the fiducial waveform starts. By default the
         lower of :code:`sampled_minimum_frequency` and the frequency derived
         from the fiducial chirp mass and the start of the analysis window
-        (:code:`fiducial_start_frequency`); a given value must not
+        (the leading-order frequency 1.5 x (time from the window start to the
+        merger) + 0.1 s before the merger, minus 1 Hz); a given value must not
         be above that.
-    inner_product_method: str, optional
-        How :math:`s^T C^{-1} s` is computed: "summary" (the matrix S),
-        "fft" (the piecewise-linear s and three FFTs of length 2N, see
-        :code:`bilby.gw.time_domain_utils.gohberg_semencul_quadratic_form`) or "auto" (default), which
-        chooses the cheaper one for each interferometer.
     time_marginalization, phase_marginalization, calibration_marginalization: bool
         Not implemented for this likelihood; must be False.
 
@@ -178,13 +146,14 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
     """
 
     def __init__(self, interferometers, waveform_generator, fiducial_parameters=None,
-                 parameter_bounds=None, maximization_kwargs=None, update_fiducial_parameters=False,
+                 maximization_kwargs=None, update_fiducial_parameters=False,
+                 parameters_to_be_updated=("chirp_mass", "mass_ratio"),
                  distance_marginalization=False, priors=None,
                  distance_marginalization_lookup_table=None, reference_frame="sky",
                  time_reference="geocenter", epsilon=(0.5, 0.1), time_split=-0.02,
                  spacing=(2, 10, 100), spacing_times=(0.02, 0.1), chi=1,
                  sampled_minimum_frequency=None, fiducial_minimum_frequency=None,
-                 inner_product_method="auto", time_marginalization=False,
+                 time_marginalization=False,
                  phase_marginalization=False, calibration_marginalization=False):
         super(TimeDomainHeterodyningGravitationalWaveTransient, self).__init__(
             interferometers=interferometers,
@@ -199,26 +168,16 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
             phase_marginalization=phase_marginalization,
             calibration_marginalization=calibration_marginalization,
         )
-        if inner_product_method not in ("auto", "summary", "fft"):
-            raise ValueError(
-                f"inner_product_method must be 'auto', 'summary' or 'fft', not {inner_product_method!r}")
         self.epsilon = epsilon
         self.time_split = time_split
         self.spacing = spacing
         self.spacing_times = spacing_times
         self.chi = chi
-        self.inner_product_method = inner_product_method
         # this likelihood sets its own entries in waveform_arguments; copy the dictionary so that
         # they do not reach other waveform generators that share it
         self.waveform_generator.waveform_arguments = dict(self.waveform_generator.waveform_arguments)
         self._set_sampled_minimum_frequency(sampled_minimum_frequency)
         self.requested_fiducial_minimum_frequency = fiducial_minimum_frequency
-        self._inverse_covariance = {
-            interferometer.name: gohberg_semencul_operator(*interferometer.gohberg_semencul_vectors)
-            for interferometer in self.interferometers}
-        self._quadratic_form = {
-            interferometer.name: gohberg_semencul_quadratic_form(*interferometer.gohberg_semencul_vectors)
-            for interferometer in self.interferometers}
 
         if fiducial_parameters is None:
             logger.info("Drawing fiducial parameters from prior.")
@@ -234,48 +193,39 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
 
         if update_fiducial_parameters:
             logger.info("Using scipy optimization to find maximum likelihood parameters.")
-            self.parameters_to_be_updated = [key for key in priors if not isinstance(
-                priors[key], (DeltaFunction, Constraint, float, int))]
+            self.parameters_to_be_updated = list(parameters_to_be_updated)
             logger.info(f"Parameters over which likelihood is maximized: {self.parameters_to_be_updated}")
-            if parameter_bounds is None:
-                logger.info("No parameter bounds were given. Using priors instead.")
-                self.parameter_bounds = self.get_bounds_from_priors(priors)
-            else:
-                self.parameter_bounds = self.get_parameter_list_from_dictionary(parameter_bounds)
+            self.parameter_bounds = self.get_bounds_from_priors(priors)
             self.fiducial_parameters = self.find_maximum_likelihood_parameters(
                 self.parameter_bounds, maximization_kwargs=maximization_kwargs)
         logger.info(f"Fiducial likelihood: {self.log_likelihood_ratio(self.fiducial_parameters):.2f}")
 
     def _set_sampled_minimum_frequency(self, sampled_minimum_frequency):
-        maximum = min(ifo.minimum_frequency for ifo in self.interferometers) - SAMPLED_FREQUENCY_BUFFER
+        maximum = min(ifo.minimum_frequency for ifo in self.interferometers) - 2
         if sampled_minimum_frequency is None:
             sampled_minimum_frequency = maximum
         if sampled_minimum_frequency > maximum:
             raise ValueError(
                 f"sampled_minimum_frequency ({sampled_minimum_frequency:g} Hz) must be at most {maximum:g} Hz "
-                f"({SAMPLED_FREQUENCY_BUFFER:g} Hz below the interferometers' minimum_frequency)")
+                "(2 Hz below the interferometers' minimum_frequency)")
         if sampled_minimum_frequency <= 0:
             raise ValueError("sampled_minimum_frequency must be positive")
         self.sampled_minimum_frequency = sampled_minimum_frequency
         self.waveform_generator.waveform_arguments["sampled_minimum_frequency"] = sampled_minimum_frequency
         self._unset_fiducial()
 
-    def __repr__(self):
-        return self.__class__.__name__ + '(interferometers={},\n\twaveform_generator={},\n\tfiducial_parameters={},' \
-            .format(self.interferometers, self.waveform_generator, self.fiducial_parameters)
-
     # ------------------------------------------------------------------
     # Waveform at given samples
     # ------------------------------------------------------------------
     def _model_times(self, interferometer, indices, parameters):
         """ Times of the analysis-window samples `indices`, relative to the
-        arrival of the model's t=0 at the interferometer. """
-        start_time = interferometer.strain_data.time_array[interferometer._analysis_slice().start]
-        time_delay = interferometer.time_delay_from_geocenter(
-            parameters["ra"], parameters["dec"], parameters["geocent_time"])
-        # subtract the two GPS times (~1e9 s) first
-        return (start_time - parameters["geocent_time"]) - time_delay \
-            + np.asarray(indices) / interferometer.sampling_frequency
+        arrival of the model's t=0 at the interferometer (as for placement="model_time"). """
+        # the time of the first sample, plus the samples `indices` (not all N samples)
+        first = times_from_merger(
+            interferometer.strain_data.time_array[interferometer._analysis_slice().start], 1,
+            interferometer.sampling_frequency, parameters["geocent_time"],
+            interferometer.time_delay_from_geocenter(parameters["ra"], parameters["dec"], parameters["geocent_time"]))
+        return first[0] + np.asarray(indices) / interferometer.sampling_frequency
 
     @staticmethod
     def _antenna_factor(interferometer, parameters):
@@ -344,8 +294,11 @@ def set_fiducial_waveforms(self, parameters):
                 interferometer, np.arange(self._number_of_samples(interferometer)), parameters)
             for interferometer in self.interferometers}
         window_start = -min(times[0] for times in self._fiducial_times.values())
-        derived = min(fiducial_start_frequency(self._chirp_mass(parameters), window_start),
-                      self.sampled_minimum_frequency)
+        # leading-order (2, 2) frequency 1.5 window_start + 0.1 s before the merger, minus 1 Hz
+        chirp_mass_time = self._chirp_mass(parameters) * solar_mass * gravitational_constant / speed_of_light ** 3
+        time_to_merger = 1.5 * max(window_start, 0) + 0.1
+        frequency = (5 / 256 * chirp_mass_time ** (-5 / 3) / time_to_merger) ** (3 / 8) / np.pi
+        derived = min(max(frequency - 1, 1.0), self.sampled_minimum_frequency)
         requested = self.requested_fiducial_minimum_frequency
         if requested is not None and requested > derived:
             raise ValueError(
@@ -366,9 +319,15 @@ def set_fiducial_waveforms(self, parameters):
         self._fiducial_end = {
             interferometer.name: max(np.flatnonzero(mode)[-1] for mode in modes.values() if np.any(mode))
             for interferometer, (modes, _) in zip(self.interferometers, terms)}
-        self.fiducial_modes = {
-            interferometer.name: {key: hold_after_end(mode) for key, mode in modes.items()}
-            for interferometer, (modes, _) in zip(self.interferometers, terms)}
+        self.fiducial_modes = dict()
+        for interferometer, (modes, _) in zip(self.interferometers, terms):
+            self.fiducial_modes[interferometer.name] = dict()
+            for key, mode in modes.items():
+                mode = np.array(mode)
+                nonzero = np.flatnonzero(mode)
+                if len(nonzero) > 0:  # hold the last non-zero value after the ringdown
+                    mode[nonzero[-1] + 1:] = mode[nonzero[-1]]
+                self.fiducial_modes[interferometer.name][key] = mode
         self.mode_keys = sorted({key for modes in self.fiducial_modes.values()
                                  for key, mode in modes.items() if np.any(mode)})
         logger.debug(f"Modes of the heterodyning basis: {self.mode_keys}")
@@ -389,8 +348,7 @@ def _fiducial_terms(self, parameters):
     def _chirp_mass(self, parameters):
         """ Detector-frame chirp mass (solar masses). """
         converted = self.waveform_generator.parameter_conversion(dict(parameters))[0]
-        mass_1, mass_2 = converted["mass_1"], converted["mass_2"]
-        return (mass_1 * mass_2) ** 0.6 / (mass_1 + mass_2) ** 0.2
+        return component_masses_to_chirp_mass(converted["mass_1"], converted["mass_2"])
 
     @staticmethod
     def _number_of_samples(interferometer):
@@ -430,7 +388,7 @@ def setup_bins(self):
                 f"and {times[edges[-1]]:.3f} s from the merger")
 
     def compute_summary_data(self):
-        """ For each interferometer: :math:`a = V^T C^{-1} d` and, if used,
+        """ For each interferometer: :math:`a = V^T C^{-1} d` and
         :math:`S = V^T C^{-1} V` (see the class docstring). The columns of V
         are :math:`\\Re(u_q \\tau^p)` and :math:`-\\Im(u_q \\tau^p)` in each bin
         b, where :math:`\\tau = t - t_b`. """
@@ -461,34 +419,22 @@ def compute_summary_data(self):
 
             summary = dict(
                 data_vector=data_vector.ravel(), samples=samples, fiducial=fiducial[:, samples],
-                tau=tau, bin_sizes=bin_sizes, matrix=None)
-            if self._use_summary_matrix(interferometer, data_vector.size):
-                summary["matrix"] = self._summary_matrix(
-                    interferometer, columns, samples, bin_starts, bin_of_sample)
-            logger.info(
-                f"{name}: {len(self.mode_keys)} modes, {len(bin_sizes)} bins, s^T C^-1 s from "
-                + ("the summary matrix" if summary["matrix"] is not None else "FFTs"))
+                tau=tau, bin_sizes=bin_sizes,
+                matrix=self._summary_matrix(interferometer, columns, samples, bin_starts, bin_of_sample))
+            logger.info(f"{name}: {len(self.mode_keys)} modes, {len(bin_sizes)} bins")
             self.summary_data[name] = summary
 
-    def _use_summary_matrix(self, interferometer, size):
-        """ Use S if v^T S v costs less than the two quadratic forms with FFTs
-        of length 2N (rough operation counts; see :code:`inner_product_method`). """
-        if self.inner_product_method != "auto":
-            return self.inner_product_method == "summary"
-        number_of_samples = self._number_of_samples(interferometer)
-        return size ** 2 < 2 * _FFT_COST_FACTOR * number_of_samples * np.log2(number_of_samples)
-
     def _summary_matrix(self, interferometer, columns, samples, bin_starts, bin_of_sample):
         """ S = V^T C^-1 V, one column group of V at a time (symmetric), as its
         eigenvalues and eigenvectors (rows). """
         number_of_groups, number_of_bins = len(columns), len(bin_starts)
-        inverse_covariance = self._inverse_covariance[interferometer.name]
+        x, y = interferometer.gohberg_semencul_vectors
         rows = np.arange(samples.start, samples.stop)
         matrix = np.empty((number_of_groups, number_of_bins, number_of_groups, number_of_bins))
         for j in range(number_of_groups):
-            group = np.zeros((self._number_of_samples(interferometer), number_of_bins))
-            group[rows, bin_of_sample] = columns[j]
-            group = inverse_covariance(group)[samples]
+            group = np.zeros((number_of_bins, self._number_of_samples(interferometer)))
+            group[bin_of_sample, rows] = columns[j]
+            group = np.array([gohberg_semencul_product(x, y, column)[samples] for column in group]).T
             for i in range(j, number_of_groups):
                 block = np.add.reduceat(columns[i][:, None] * group, bin_starts, axis=0)
                 matrix[i, :, j, :] = block
@@ -510,15 +456,8 @@ def _snrs_from_coefficients(self, name, coefficients):
         summary = self.summary_data[name]
         vector = np.concatenate([coefficients.real.ravel(), coefficients.imag.ravel()])
         d_inner_h = float(summary["data_vector"] @ vector)
-        if summary["matrix"] is not None:
-            eigenvalues, eigenvectors = summary["matrix"]
-            optimal_snr_squared = float(eigenvalues @ (eigenvectors @ vector) ** 2)
-        else:
-            slopes_only = coefficients.copy()
-            slopes_only[:, 0] = 0
-            optimal_snr_squared = float(
-                self._quadratic_form[name](self._piecewise_linear_signal(name, coefficients))
-                - self._quadratic_form[name](self._piecewise_linear_signal(name, slopes_only)))
+        eigenvalues, eigenvectors = summary["matrix"]
+        optimal_snr_squared = float(eigenvalues @ (eigenvectors @ vector) ** 2)
         matched_filter_snr = d_inner_h / optimal_snr_squared ** 0.5 if optimal_snr_squared > 0 else 0.0
         return self._CalculatedSNRs(
             d_inner_h=d_inner_h,
@@ -659,9 +598,6 @@ def meta_data(self):
         return meta_data
 
 
-# v^T S v takes ~0.3 ns per element of S and s^T C^-1 s from FFTs ~6 ns * N log2(N); S has a numerical
-# rank well below its size, which makes the matrix route a few times cheaper still
-_FFT_COST_FACTOR = 60
 _EIGENVALUE_TOLERANCE = 1e-12
 
 _PHASE_PROXY_POWERS = np.array([5 / 8, 3 / 8, 1 / 4, -3 / 8])
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 4c4519dbe..87b6560b3 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -52,87 +52,27 @@ def gohberg_semencul_product(x, y, vector):
     x, y: array_like
         Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
     vector: array_like
-        The vector v, of the same length as x, or an (N, m) array of m
-        vectors (columns).
+        The vector v, of the same length as x.
 
     Returns
     =======
     array_like: :math:`C^{-1} v`
     """
-    return gohberg_semencul_operator(x, y)(vector)
-
-
-def gohberg_semencul_operator(x, y):
-    """ The function :math:`v \\mapsto C^{-1} v` (see
-    :code:`gohberg_semencul_product`), with the transforms of x and y computed
-    once. The function takes real arrays of shape (N,) or (N, m) (m columns).
-
-    Parameters
-    ==========
-    x, y: array_like
-        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
-
-    Returns
-    =======
-    function
-    """
-    from scipy import fft
-
     x = np.asarray(x, dtype=float)
     number_of_samples = len(x)
     fft_length = next_fast_len(2 * number_of_samples - 1, real=True)
-    x_fft = fft.rfft(x, n=fft_length)
-    zy_fft = fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
-
-    def inverse_covariance_product(vector):
-        vector = np.asarray(vector, dtype=float)
-        shape = (-1,) + (1,) * (vector.ndim - 1)
-        x_w, zy_w = x_fft.reshape(shape), zy_fft.reshape(shape)
-        options = dict(n=fft_length, axis=0, workers=-1 if vector.ndim > 1 else 1)
-        # L(w)^T v = reverse(L(w) reverse(v)); the two terms are summed before the last transform
-        reversed_fft = fft.rfft(vector[::-1], **options)
-        first = fft.irfft(x_w * reversed_fft, **options)[:number_of_samples][::-1]
-        second = fft.irfft(zy_w * reversed_fft, **options)[:number_of_samples][::-1]
-        total = x_w * fft.rfft(first, **options) - zy_w * fft.rfft(second, **options)
-        return fft.irfft(total, **options)[:number_of_samples] / x[0]
-
-    return inverse_covariance_product
-
-
-def gohberg_semencul_quadratic_form(x, y):
-    """ The function :math:`v \\mapsto v^T C^{-1} v` for a real vector v,
-
-    .. math::
-
-        v^T C^{-1} v = \\frac{1}{x_0} \\left[ |L(x)^T v|^2 - |L(Z y)^T v|^2 \\right]
-
-    (see :code:`gohberg_semencul_product`): three FFTs of length
-    :code:`next_fast_len(2 N - 1)` instead of the six of :math:`C^{-1} v`.
-
-    Parameters
-    ==========
-    x, y: array_like
-        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
-
-    Returns
-    =======
-    function
-    """
-    from scipy import fft
-
-    x = np.asarray(x, dtype=float)
-    number_of_samples = len(x)
-    fft_length = next_fast_len(2 * number_of_samples - 1, real=True)
-    x_fft = fft.rfft(x, n=fft_length)
-    zy_fft = fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
-
-    def quadratic_form(vector):
-        reversed_fft = fft.rfft(np.asarray(vector, dtype=float)[::-1], n=fft_length)
-        first = fft.irfft(x_fft * reversed_fft, n=fft_length)[:number_of_samples]
-        second = fft.irfft(zy_fft * reversed_fft, n=fft_length)[:number_of_samples]
-        return (first @ first - second @ second) / x[0]
-
-    return quadratic_form
+    x_fft = np.fft.rfft(x, n=fft_length)
+    zy_fft = np.fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
+
+    def lower(w_fft, vector_fft):
+        """ L(w) v from the transforms of w and v. """
+        return np.fft.irfft(w_fft * vector_fft, n=fft_length)[:number_of_samples]
+
+    # L(w)^T v = reverse(L(w) reverse(v))
+    reversed_fft = np.fft.rfft(np.asarray(vector, dtype=float)[::-1], n=fft_length)
+    first = lower(x_fft, np.fft.rfft(lower(x_fft, reversed_fft)[::-1], n=fft_length))
+    second = lower(zy_fft, np.fft.rfft(lower(zy_fft, reversed_fft)[::-1], n=fft_length))
+    return (first - second) / x[0]
 
 
 def fractional_time_shift(signal, fraction, pad=32):
diff --git a/test/gw/likelihood/time_domain_heterodyning_test.py b/test/gw/likelihood/time_domain_heterodyning_test.py
index 94e819bb5..f8b29c4fe 100644
--- a/test/gw/likelihood/time_domain_heterodyning_test.py
+++ b/test/gw/likelihood/time_domain_heterodyning_test.py
@@ -4,7 +4,6 @@
 import unittest
 
 import numpy as np
-import scipy.linalg
 
 import bilby
 from bilby.gw.likelihood import (
@@ -13,9 +12,7 @@
 )
 from bilby.gw.likelihood.time_domain_heterodyning import time_domain_bin_edges
 from bilby.gw.time_domain_utils import (
-    gohberg_semencul_operator,
-    gohberg_semencul_quadratic_form,
-    gohberg_semencul_vectors,
+    gohberg_semencul_product,
 )
 
 INJECTION = dict(
@@ -37,7 +34,7 @@
 
 def _has_model_time_waveforms():
     import lalsimulation
-    return hasattr(lalsimulation, "SimIMRPhenomTPHMCoprecModesModelTimes")
+    return hasattr(lalsimulation, "SimIMRPhenomTPHMCoprecModesHarmonicsModelTimes")
 
 
 def generator(source_model, approximant="IMRPhenomTPHM", minimum_frequency=20.0):
@@ -86,24 +83,6 @@ def perturbed(parameters, scale=1.0):
     return parameters
 
 
-class TestGohbergSemenculExtensions(unittest.TestCase):
-    def setUp(self):
-        lags = np.arange(300)
-        self.acf = np.exp(-lags / 30.0) * np.cos(lags / 5.0)
-        self.acf[0] += 0.1
-        self.inverse = np.linalg.inv(scipy.linalg.toeplitz(self.acf))
-        self.vectors = np.random.default_rng(2).normal(size=(300, 4))
-
-    def test_operator_on_columns(self):
-        product = gohberg_semencul_operator(*gohberg_semencul_vectors(self.acf))(self.vectors)
-        np.testing.assert_allclose(product, self.inverse @ self.vectors, rtol=0, atol=1e-10)
-
-    def test_quadratic_form(self):
-        quadratic_form = gohberg_semencul_quadratic_form(*gohberg_semencul_vectors(self.acf))
-        vector = self.vectors[:, 0]
-        self.assertAlmostEqual(quadratic_form(vector) / (vector @ self.inverse @ vector), 1, 10)
-
-
 class TestBinEdges(unittest.TestCase):
     def test_edges(self):
         times = np.arange(-0.5, 0.3, 1 / 1024)
@@ -112,8 +91,8 @@ def test_edges(self):
         self.assertEqual(edges[-1], len(times) - 1)
         self.assertTrue(np.all(np.diff(edges) > 0))
         merger = np.searchsorted(times, 0)
-        # one sample per bin from the merger until 0.02 s, ten until 0.1 s
-        self.assertTrue(np.all(np.diff(edges[(times[edges] >= 0) & (times[edges] < 0.019)]) == 1))
+        # two samples per bin from the merger until 0.02 s, ten until 0.1 s
+        self.assertTrue(np.all(np.diff(edges[(times[edges] >= 0) & (times[edges] < 0.019)]) == 2))
         late = edges[(times[edges] > 0.03) & (times[edges] < 0.09)]
         self.assertTrue(np.all(np.diff(late) == 10))
         # smaller epsilon: more inspiral bins
@@ -169,15 +148,6 @@ def test_matches_exact_likelihood(self):
                 self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
                                     - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
 
-    def test_inner_product_methods_agree(self):
-        ifos = interferometers()
-        values = list()
-        for method in ("summary", "fft"):
-            likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, inner_product_method=method)
-            values.append(likelihood.log_likelihood_ratio(perturbed(INJECTION)))
-        self.assertAlmostEqual(values[0], values[1], 8)
-
     def test_full_waveform_is_piecewise_linear_model(self):
         ifos = interferometers()
         likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
@@ -188,8 +158,13 @@ def test_full_waveform_is_piecewise_linear_model(self):
             template = likelihood._compute_full_waveform(signal, ifo, parameters)
             snrs = likelihood.calculate_snrs(signal, ifo, parameters=parameters)
             x, y = ifo.gohberg_semencul_vectors
-            self.assertAlmostEqual(
-                snrs.optimal_snr_squared / (template @ gohberg_semencul_operator(x, y)(template)), 1, 10)
+            # <s, s> without the terms quadratic in the slopes: <s, s> - <s1, s1>, s1 = slope part of s
+            coefficients = likelihood._heterodyning_coefficients(signal, [ifo], parameters)[0]
+            coefficients[:, 0] = 0
+            slopes = likelihood._piecewise_linear_signal(ifo.name, coefficients)
+            expected = (template @ gohberg_semencul_product(x, y, template)
+                        - slopes @ gohberg_semencul_product(x, y, slopes))
+            self.assertAlmostEqual(snrs.optimal_snr_squared / expected, 1, 10)
             self.assertAlmostEqual(
                 snrs.d_inner_h / (likelihood._data_times_inverse_covariance[ifo.name] @ template), 1, 10)
 
@@ -230,13 +205,13 @@ def test_update_fiducial_parameters(self):
         priors = bilby.core.prior.PriorDict(
             {key: value for key, value in ALIGNED_INJECTION.items() if key not in ("mass_1", "mass_2")})
         priors["chirp_mass"] = bilby.core.prior.Uniform(27, 29, "chirp_mass")
-        priors["mass_ratio"] = ALIGNED_INJECTION["mass_2"] / ALIGNED_INJECTION["mass_1"]
+        priors["mass_ratio"] = bilby.core.prior.Uniform(0.5, 1, "mass_ratio")
         start = {key: value for key, value in ALIGNED_INJECTION.items() if key not in ("mass_1", "mass_2")}
-        start.update(chirp_mass=28.4, mass_ratio=priors["mass_ratio"])
+        start.update(chirp_mass=28.4, mass_ratio=0.7)
         likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
             ifos, heterodyning_generator("IMRPhenomT"), fiducial_parameters=start, priors=priors,
             update_fiducial_parameters=True, maximization_kwargs=dict(maxiter=5, popsize=5, seed=1))
-        self.assertEqual(likelihood.parameters_to_be_updated, ["chirp_mass"])
+        self.assertEqual(likelihood.parameters_to_be_updated, ["chirp_mass", "mass_ratio"])
         self.assertGreater(likelihood.log_likelihood_ratio(likelihood.fiducial_parameters),
                            likelihood.log_likelihood_ratio(start))
 
@@ -277,9 +252,6 @@ def test_errors(self):
         with self.assertRaises(ValueError):  # above minimum_frequency - 2 Hz
             TimeDomainHeterodyningGravitationalWaveTransient(
                 ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=19.0)
-        with self.assertRaises(ValueError):
-            TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, inner_product_method="dense")
         with self.assertRaises(NotImplementedError):
             TimeDomainHeterodyningGravitationalWaveTransient(
                 ifos, heterodyning_generator(), fiducial_parameters=INJECTION, time_marginalization=True)

From 244d49594d71096518f7cc32c34587fec3006b5d Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Tue, 13 Oct 2026 16:11:12 +0530
Subject: [PATCH 11/21] float64->float32 in eigenvalues computation

---
 .../gw/likelihood/time_domain_heterodyning.py | 612 +++++++++---------
 .../time_domain_heterodyning_test.py          |  25 +-
 2 files changed, 325 insertions(+), 312 deletions(-)

diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index 08e39c72f..51a1806ea 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -22,28 +22,34 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
 
     .. math::
 
-        h_+ - i h_\\times = \\sum_q \\left[ Z_q(t) h_q(t) + \\bar{Z}_q(t) h_q^*(t) \\right],
+        h_+ - i h_\\times = \\sum_{\\ell m} \\left[ Z_{\\ell m}(t) h_{\\ell m}(t)
+        + \\bar{Z}_{\\ell m}(t) h_{\\ell m}^*(t) \\right],
 
-    with :math:`h_q` the modes with m >= 0 (co-precessing modes for
-    IMRPhenomTP/TPHM). The signal in an interferometer is
-    :math:`s = \\Re[(F_+ + i F_\\times)(h_+ - i h_\\times)] = \\Re \\sum_q w_q u_q`,
-    where :math:`u_q` are the modes of a fiducial waveform at the data samples
-    and
+    with :math:`h_{\\ell m}` the modes with m >= 0 (co-precessing modes for
+    IMRPhenomTP/TPHM), so that the signal in an interferometer is
 
     .. math::
 
-        w_q(t) = \\frac{h_q(t)}{u_q(t)} \\left[ F Z_q(t) + F^* \\bar{Z}_q^*(t) \\right],
-        \\quad F = F_+ + i F_\\times.
+        s(t_j) = \\Re \\sum_{\\ell m} \\tilde{r}_{\\ell m}(t_j)\\, h^0_{\\ell m}(t_j),\\qquad
+        \\tilde{r}_{\\ell m} = \\frac{h_{\\ell m}}{h^0_{\\ell m}}
+        \\left[ F Z_{\\ell m} + (F \\bar{Z}_{\\ell m})^* \\right],\\quad F = F_+ + i F_\\times,
 
-    :math:`w_q` is evaluated at the edges of time bins and taken to be linear
-    in each bin, :math:`w_q = w_{q,0}(b) + w_{q,1}(b) (t - t_b)`. Then
-    :math:`d^T C^{-1} s` and :math:`s^T C^{-1} s` are the inner products of
-    this piecewise-linear model, without the terms quadratic in the slopes
-    :math:`w_{q,1}` (as in Sharma et al.), computed from summary data:
-    :math:`s = V v` with :math:`v = (\\Re w, \\Im w)`, so that
-    :math:`d^T C^{-1} s = a^T v` and :math:`s^T C^{-1} s = v^T S v`
-    (from the eigen-decomposition of S, without its negligible eigenvalues), with
-    :math:`a = V^T C^{-1} d` and :math:`S = V^T C^{-1} V`.
+    where :math:`h^0_{\\ell m}` are the modes of the fiducial waveform at the
+    data samples. :math:`\\tilde{r}_{\\ell m}` is evaluated at the edges of time
+    bins and taken to be linear in each bin b,
+    :math:`\\tilde{r}_{\\ell m} = \\tilde{r}_{\\ell m,0}(b) + \\tilde{r}_{\\ell m,1}(b) (t - t_b)`.
+    With :math:`v = (\\Re \\tilde{r}, \\Im \\tilde{r})`, :math:`s = V v`, where the
+    columns of V are :math:`\\Re(h^0_{\\ell m} (t - t_b)^p)` and
+    :math:`-\\Im(h^0_{\\ell m} (t - t_b)^p)` in each bin, so that
+
+    .. math::
+
+        \\langle d, s \\rangle = a \\cdot v,\\quad a = V^T C^{-1} d,\\qquad
+        \\langle s, s \\rangle = v^T S v,\\quad S = V^T C^{-1} V,
+
+    without the terms quadratic in the slopes :math:`\\tilde{r}_{\\ell m,1}` (as in
+    Sharma et al.); a contains :math:`A_0, A_1` and S the B matrices of
+    Sharma et al., for all modes.
 
     The waveform is evaluated only at the bin edges, with one waveform call for
     all interferometers.
@@ -111,11 +117,11 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         - "geocent"/"geocenter": sample in the time at the Earth's center,
           this is the default
         - e.g., "H1": sample in the time of arrival at H1
-    epsilon: tuple or dict, optional
+    epsilon: tuple, optional
         Bin size in the inspiral: phase-proxy spacing before and after
         :code:`time_split` (see :code:`time_domain_bin_edges`). Smaller
-        values give more bins. A dict gives a value per interferometer.
-    time_split: float or dict, optional
+        values give more bins.
+    time_split: float, optional
         Time (s, relative to the merger) at which epsilon changes.
     spacing: tuple, optional
         Number of samples per bin after the merger, until
@@ -125,9 +131,9 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
     chi: float, optional
         Tunable parameter of the phase proxy (as in relative binning).
     sampled_minimum_frequency: float, optional
-        Frequency (Hz) at which the waveforms at sampled parameters start; at
-        most (and by default) 2 Hz below the lowest minimum_frequency of the
-        interferometers.
+        Frequency (Hz) at which the waveforms at sampled parameters start. By
+        default 2 Hz below the lowest minimum_frequency of the interferometers;
+        a higher value gives a warning.
     fiducial_minimum_frequency: float, optional
         Frequency (Hz) at which the fiducial waveform starts. By default the
         lower of :code:`sampled_minimum_frequency` and the frequency derived
@@ -135,6 +141,10 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         (the leading-order frequency 1.5 x (time from the window start to the
         merger) + 0.1 s before the merger, minus 1 Hz); a given value must not
         be above that.
+    single_precision: bool, optional
+        If True, the eigenvectors of S are stored and multiplied in float32
+        instead of float64: :math:`v^T S v` is a few times faster for many modes
+        and bins, with relative errors of ~1e-7 in it. Default is False.
     time_marginalization, phase_marginalization, calibration_marginalization: bool
         Not implemented for this likelihood; must be False.
 
@@ -153,7 +163,7 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
                  time_reference="geocenter", epsilon=(0.5, 0.1), time_split=-0.02,
                  spacing=(2, 10, 100), spacing_times=(0.02, 0.1), chi=1,
                  sampled_minimum_frequency=None, fiducial_minimum_frequency=None,
-                 time_marginalization=False,
+                 single_precision=False, time_marginalization=False,
                  phase_marginalization=False, calibration_marginalization=False):
         super(TimeDomainHeterodyningGravitationalWaveTransient, self).__init__(
             interferometers=interferometers,
@@ -173,6 +183,7 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
         self.spacing = spacing
         self.spacing_times = spacing_times
         self.chi = chi
+        self.single_precision = single_precision
         # this likelihood sets its own entries in waveform_arguments; copy the dictionary so that
         # they do not reach other waveform generators that share it
         self.waveform_generator.waveform_arguments = dict(self.waveform_generator.waveform_arguments)
@@ -183,21 +194,22 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
             logger.info("Drawing fiducial parameters from prior.")
             fiducial_parameters = priors.sample()
         self.fiducial_parameters = dict(fiducial_parameters)
-        if self.distance_marginalization:
-            self.fiducial_parameters["luminosity_distance"] = self._ref_dist
-        self.set_fiducial_waveforms(self.fiducial_parameters)
-        logger.info("Initial fiducial waveforms set up")
-        self.setup_bins()
-        self.compute_summary_data()
-        logger.info("Summary Data Obtained")
 
         if update_fiducial_parameters:
             logger.info("Using scipy optimization to find maximum likelihood parameters.")
             self.parameters_to_be_updated = list(parameters_to_be_updated)
             logger.info(f"Parameters over which likelihood is maximized: {self.parameters_to_be_updated}")
-            self.parameter_bounds = self.get_bounds_from_priors(priors)
+            self.parameter_bounds = self.get_bounds_from_priors(self.priors)
             self.fiducial_parameters = self.find_maximum_likelihood_parameters(
                 self.parameter_bounds, maximization_kwargs=maximization_kwargs)
+
+        if self.distance_marginalization:
+            self.fiducial_parameters["luminosity_distance"] = self._ref_dist
+        self.set_fiducial_waveforms(self.fiducial_parameters)
+        logger.info("Fiducial waveforms set up")
+        self.setup_bins()
+        self.compute_summary_data()
+        logger.info("Summary Data Obtained")
         logger.info(f"Fiducial likelihood: {self.log_likelihood_ratio(self.fiducial_parameters):.2f}")
 
     def _set_sampled_minimum_frequency(self, sampled_minimum_frequency):
@@ -205,14 +217,11 @@ def _set_sampled_minimum_frequency(self, sampled_minimum_frequency):
         if sampled_minimum_frequency is None:
             sampled_minimum_frequency = maximum
         if sampled_minimum_frequency > maximum:
-            raise ValueError(
-                f"sampled_minimum_frequency ({sampled_minimum_frequency:g} Hz) must be at most {maximum:g} Hz "
+            logger.warning(
+                f"sampled_minimum_frequency ({sampled_minimum_frequency:g} Hz) is above {maximum:g} Hz "
                 "(2 Hz below the interferometers' minimum_frequency)")
-        if sampled_minimum_frequency <= 0:
-            raise ValueError("sampled_minimum_frequency must be positive")
         self.sampled_minimum_frequency = sampled_minimum_frequency
         self.waveform_generator.waveform_arguments["sampled_minimum_frequency"] = sampled_minimum_frequency
-        self._unset_fiducial()
 
     # ------------------------------------------------------------------
     # Waveform at given samples
@@ -227,57 +236,60 @@ def _model_times(self, interferometer, indices, parameters):
             interferometer.time_delay_from_geocenter(parameters["ra"], parameters["dec"], parameters["geocent_time"]))
         return first[0] + np.asarray(indices) / interferometer.sampling_frequency
 
-    @staticmethod
-    def _antenna_factor(interferometer, parameters):
-        """ F = F_+ + i F_x. """
-        time = parameters["geocent_time"] if interferometer.reference_time is None \
-            else interferometer.reference_time
-        plus, cross = (interferometer.antenna_response(
-            parameters["ra"], parameters["dec"], time, parameters["psi"], mode) for mode in ("plus", "cross"))
-        return plus + 1j * cross
-
-    def _terms_at_samples(self, signal, interferometers, indices, parameters):
-        """ Modes and harmonic factors at the samples `indices[name]` of each
-        interferometer, from one waveform call. None if the waveform failed. """
-        times = [self._model_times(interferometer, indices[interferometer.name], parameters)
-                 for interferometer in interferometers]
-        terms = signal["heterodyning_terms_at"](np.concatenate(times))
-        if terms is None:
+    def _modes_and_harmonics_at_combined_bin_edges(self, signal, model_times):
+        """ Modes and harmonic factors at `model_times`, a list with the model
+        times of each interferometer (of the bin edges; of all samples for the
+        fiducial waveform): the model times of all interferometers are joined,
+        the waveform is evaluated once, and the result is split back per
+        interferometer. None if the waveform failed. """
+        all_modes_and_harmonics = signal["heterodyning_terms_at"](np.concatenate(model_times))
+        if all_modes_and_harmonics is None:
             return None
-        modes, harmonics = terms
+        all_modes, all_harmonics = all_modes_and_harmonics
         per_interferometer = list()
-        start = 0
-        for interferometer_times in times:
-            samples = slice(start, start + len(interferometer_times))
-            start += len(interferometer_times)
-            per_interferometer.append((
-                {key: mode[samples] for key, mode in modes.items()},
-                {key: tuple(np.asarray(z)[samples] if np.ndim(z) else z for z in pair)
-                 for key, pair in harmonics.items()}))
+        first = 0
+        for interferometer_model_times in model_times:
+            interferometer_part = slice(first, first + len(interferometer_model_times))
+            first += len(interferometer_model_times)
+            modes = {key: mode[interferometer_part] for key, mode in all_modes.items()}
+            # (Z, Zbar): arrays for the precessing models, constants otherwise
+            harmonics = {
+                key: tuple(np.asarray(factor)[interferometer_part] if np.ndim(factor) else factor
+                           for factor in factors)
+                for key, factors in all_harmonics.items()}
+            per_interferometer.append((modes, harmonics))
         return per_interferometer
 
-    def _heterodyning_coefficients(self, signal, interferometers, parameters):
-        """ Coefficients w[q, p, b] of the piecewise-linear model in each
-        interferometer (see the class docstring). None if the waveform failed. """
-        terms = self._terms_at_samples(signal, interferometers, self.bin_edges, parameters)
-        if terms is None:
+    def _r_tilde_coefficients(self, waveform_polarizations, interferometers, parameters):
+        """ The coefficients r_tilde[lm, p, b] of each interferometer (see the class
+        docstring): r_tilde_lm = h_lm (F Z_lm + (F Zbar_lm)^*) / h^0_lm at the bin edges,
+        then r_tilde_lm,0 (p = 0) and r_tilde_lm,1 (p = 1) in each bin b. None if the
+        waveform failed. """
+        modes_and_harmonics = self._modes_and_harmonics_at_combined_bin_edges(
+            waveform_polarizations,
+            [self._model_times(interferometer, self.bin_edges[interferometer.name], parameters)
+             for interferometer in interferometers])
+        if modes_and_harmonics is None:
             return None
-        coefficients = list()
-        for interferometer, (modes, harmonics) in zip(interferometers, terms):
-            name = interferometer.name
-            zeros = np.zeros(self._inverse_fiducial_at_edges[name].shape[1], dtype=complex)
-            antenna = self._antenna_factor(interferometer, parameters)
-            mode = np.array([modes.get(key, zeros) for key in self.mode_keys])
-            harmonic = np.array([np.broadcast_to(harmonics[key][0], zeros.shape) if key in modes else zeros
-                                 for key in self.mode_keys])
-            conjugate_harmonic = np.array([np.broadcast_to(harmonics[key][1], zeros.shape) if key in modes else zeros
-                                           for key in self.mode_keys])
-            ratio = mode * (antenna * harmonic + np.conj(antenna * conjugate_harmonic)) \
-                * self._inverse_fiducial_at_edges[name]
-            coefficients.append(np.stack([
-                (ratio[:, 1:] + ratio[:, :-1]) / 2,
-                (ratio[:, 1:] - ratio[:, :-1]) / self.bin_widths[name]], axis=1))
-        return coefficients
+        r_tilde = list()
+        for interferometer, (modes, harmonics) in zip(interferometers, modes_and_harmonics):
+            # as in Interferometer.get_time_domain_detector_response
+            antenna_time = parameters["geocent_time"] if interferometer.reference_time is None \
+                else interferometer.reference_time
+            antenna_factor = (  # F = F_+ + i F_x
+                interferometer.antenna_response(
+                    parameters["ra"], parameters["dec"], antenna_time, parameters["psi"], "plus")
+                + 1j * interferometer.antenna_response(
+                    parameters["ra"], parameters["dec"], antenna_time, parameters["psi"], "cross"))
+            # r_tilde_lm = h_lm (F Z_lm + (F Zbar_lm)^*) / h^0_lm at the bin edges
+            r_tilde_at_edges = np.array([
+                modes[mode] * (antenna_factor * harmonics[mode][0] + np.conj(antenna_factor * harmonics[mode][1]))
+                if mode in modes else np.zeros(len(self.bin_edges[interferometer.name]))
+                for mode in self.mode_keys]) * self._inverse_h0_at_edges[interferometer.name]
+            r_tilde_0 = (r_tilde_at_edges[:, 1:] + r_tilde_at_edges[:, :-1]) / 2
+            r_tilde_1 = (r_tilde_at_edges[:, 1:] - r_tilde_at_edges[:, :-1]) / self.bin_widths[interferometer.name]
+            r_tilde.append(np.stack([r_tilde_0, r_tilde_1], axis=1))
+        return r_tilde
 
     # ------------------------------------------------------------------
     # Fiducial waveform, bins and summary data
@@ -287,17 +299,18 @@ def set_fiducial_waveforms(self, parameters):
         interferometer, starting before the analysis window (see
         :code:`fiducial_minimum_frequency`) and held at their last non-zero
         values after the ringdown. """
-        parameters = dict(parameters)
+        parameters = parameters.copy()
         parameters.update(self.get_sky_frame_parameters(parameters=parameters))
         self._fiducial_times = {
             interferometer.name: self._model_times(
-                interferometer, np.arange(self._number_of_samples(interferometer)), parameters)
+                interferometer, np.arange(len(self._data_times_inverse_covariance[interferometer.name])), parameters)
             for interferometer in self.interferometers}
         window_start = -min(times[0] for times in self._fiducial_times.values())
         # leading-order (2, 2) frequency 1.5 window_start + 0.1 s before the merger, minus 1 Hz
-        chirp_mass_time = self._chirp_mass(parameters) * solar_mass * gravitational_constant / speed_of_light ** 3
-        time_to_merger = 1.5 * max(window_start, 0) + 0.1
-        frequency = (5 / 256 * chirp_mass_time ** (-5 / 3) / time_to_merger) ** (3 / 8) / np.pi
+        converted = self.waveform_generator.parameter_conversion(parameters.copy())[0]
+        chirp_mass_time = component_masses_to_chirp_mass(converted["mass_1"], converted["mass_2"]) \
+            * solar_mass * gravitational_constant / speed_of_light ** 3
+        frequency = (5 / 256 * chirp_mass_time ** (-5 / 3) / (1.5 * max(window_start, 0) + 0.1)) ** (3 / 8) / np.pi
         derived = min(max(frequency - 1, 1.0), self.sampled_minimum_frequency)
         requested = self.requested_fiducial_minimum_frequency
         if requested is not None and requested > derived:
@@ -307,8 +320,14 @@ def set_fiducial_waveforms(self, parameters):
                 "and the start of the analysis window)")
         self.fiducial_minimum_frequency = derived if requested is None else requested
         while True:
-            terms = self._fiducial_terms(parameters)
-            if all(np.any(modes[(2, 2)][:1]) for modes, _ in terms):
+            self._set_fiducial()
+            modes_and_harmonics = self._modes_and_harmonics_at_combined_bin_edges(
+                self.waveform_generator.time_domain_strain(parameters),
+                [self._fiducial_times[interferometer.name] for interferometer in self.interferometers])
+            self._unset_fiducial()
+            if modes_and_harmonics is None:
+                raise ValueError(f"Cannot compute fiducial waveforms for {parameters}")
+            if all(np.any(modes[(2, 2)][:1]) for modes, _ in modes_and_harmonics):
                 break
             if requested is not None or self.fiducial_minimum_frequency <= 1:
                 raise ValueError(
@@ -316,47 +335,67 @@ def set_fiducial_waveforms(self, parameters):
                     f"before the analysis window for {parameters}")
             self.fiducial_minimum_frequency = max(self.fiducial_minimum_frequency - 1, 1)
         logger.info(f"Fiducial waveform from {self.fiducial_minimum_frequency:.2f} Hz")
-        self._fiducial_end = {
-            interferometer.name: max(np.flatnonzero(mode)[-1] for mode in modes.values() if np.any(mode))
-            for interferometer, (modes, _) in zip(self.interferometers, terms)}
         self.fiducial_modes = dict()
-        for interferometer, (modes, _) in zip(self.interferometers, terms):
+        self._fiducial_end = dict()
+        for interferometer, (modes, _) in zip(self.interferometers, modes_and_harmonics):
             self.fiducial_modes[interferometer.name] = dict()
+            ends = list()
             for key, mode in modes.items():
-                mode = np.array(mode)
                 nonzero = np.flatnonzero(mode)
-                if len(nonzero) > 0:  # hold the last non-zero value after the ringdown
-                    mode[nonzero[-1] + 1:] = mode[nonzero[-1]]
+                if len(nonzero) == 0:  # mode not in the fiducial waveform
+                    continue
+                mode[nonzero[-1] + 1:] = mode[nonzero[-1]]  # hold the last non-zero value after the ringdown
                 self.fiducial_modes[interferometer.name][key] = mode
-        self.mode_keys = sorted({key for modes in self.fiducial_modes.values()
-                                 for key, mode in modes.items() if np.any(mode)})
+                ends.append(nonzero[-1])
+            self._fiducial_end[interferometer.name] = max(ends)
+        self.mode_keys = sorted({key for modes in self.fiducial_modes.values() for key in modes})
         logger.debug(f"Modes of the heterodyning basis: {self.mode_keys}")
 
-    def _fiducial_terms(self, parameters):
-        self._set_fiducial()
-        signal = self.waveform_generator.time_domain_strain(parameters)
-        terms = None if signal is None else self._terms_at_samples(
-            signal, self.interferometers,
-            {interferometer.name: np.arange(self._number_of_samples(interferometer))
-             for interferometer in self.interferometers},
-            parameters)
-        self._unset_fiducial()
-        if terms is None:
-            raise ValueError(f"Cannot compute fiducial waveforms for {parameters}")
-        return terms
-
-    def _chirp_mass(self, parameters):
-        """ Detector-frame chirp mass (solar masses). """
-        converted = self.waveform_generator.parameter_conversion(dict(parameters))[0]
-        return component_masses_to_chirp_mass(converted["mass_1"], converted["mass_2"])
-
     @staticmethod
-    def _number_of_samples(interferometer):
-        analysis_slice = interferometer._analysis_slice()
-        return analysis_slice.stop - analysis_slice.start
+    def time_domain_bin_edges(times, epsilon=(0.5, 0.1), time_split=-0.02, spacing=(2, 10, 100),
+                              spacing_times=(0.02, 0.1), chi=1):
+        """ Bin edges for the time-domain heterodyned likelihood (Sharma et al.
+        arXiv:2601.11239).
+
+        - Before the merger (t < 0): edges equally spaced in the phase proxy
+          :math:`\\psi(t) = \\sum_k {\\rm sign}(\\gamma_k) \\delta\\alpha_k |t|^{\\gamma_k}`,
+          :math:`\\gamma = (5/8, 3/8, 1/4, -3/8)`, with
+          :math:`\\delta\\alpha_k = 2 \\pi \\chi / |t|_{\\rm max}^{\\gamma_k}`
+          (:math:`|t|_{\\rm min}` for :math:`\\gamma_k < 0`), one bin per
+          epsilon[0] of :math:`|\\Delta\\psi|` for t <= time_split and per
+          epsilon[1] after.
+        - From the merger: one edge every spacing[0] samples until
+          spacing_times[0], every spacing[1] samples until spacing_times[1] and
+          every spacing[2] samples after.
 
-    def _per_detector(self, value, name):
-        return value[name] if isinstance(value, dict) else value
+        Parameters
+        ==========
+        times: array_like
+            Increasing times (s) relative to the merger.
+
+        Returns
+        =======
+        array_like: indices of the edges into times (first and last included).
+        """
+        gamma = np.array([5 / 8, 3 / 8, 1 / 4, -3 / 8])  # powers of |t| in the phase proxy
+        edges = [0, len(times) - 1]
+        inspiral = np.flatnonzero(times < 0)
+        if len(inspiral) > 1:
+            t = np.abs(times[inspiral])
+            d_alpha = 2 * np.pi * chi / np.where(gamma < 0, t.min(), t.max()) ** gamma
+            proxy = np.sum(np.sign(gamma) * d_alpha * t[:, None] ** gamma, axis=1)
+            for region, region_epsilon in zip((times[inspiral] <= time_split, times[inspiral] > time_split), epsilon):
+                if np.sum(region) < 2:
+                    continue
+                phase = np.abs(proxy[region] - proxy[region][0])
+                number_of_bins = max(int(phase[-1] / region_epsilon), 1)
+                targets = np.linspace(0, phase[-1], number_of_bins + 1)
+                edges.extend(inspiral[region][np.searchsorted(phase, targets, side="right") - 1])
+        merger = inspiral[-1] if len(inspiral) else 0
+        boundaries = [merger] + [max(merger, np.searchsorted(times, x)) for x in spacing_times] + [len(times)]
+        for start, stop, step in zip(boundaries[:-1], boundaries[1:], spacing):
+            edges.extend(range(start, stop, step))
+        return np.unique(edges)
 
     def setup_bins(self):
         """ Bin edges (indices of analysis-window samples) for each
@@ -371,12 +410,12 @@ def setup_bins(self):
             name = interferometer.name
             times = self._fiducial_times[name]
             end = self._fiducial_end[name]
-            edges = time_domain_bin_edges(
+            edges = self.time_domain_bin_edges(
                 times[:end + 1],
-                epsilon=self._per_detector(self.epsilon, name),
-                time_split=self._per_detector(self.time_split, name),
-                spacing=self._per_detector(self.spacing, name),
-                spacing_times=self._per_detector(self.spacing_times, name),
+                epsilon=self.epsilon,
+                time_split=self.time_split,
+                spacing=self.spacing,
+                spacing_times=self.spacing_times,
                 chi=self.chi)
             if end < len(times) - 1:
                 edges = np.append(edges, len(times) - 1)
@@ -388,97 +427,80 @@ def setup_bins(self):
                 f"and {times[edges[-1]]:.3f} s from the merger")
 
     def compute_summary_data(self):
-        """ For each interferometer: :math:`a = V^T C^{-1} d` and
-        :math:`S = V^T C^{-1} V` (see the class docstring). The columns of V
-        are :math:`\\Re(u_q \\tau^p)` and :math:`-\\Im(u_q \\tau^p)` in each bin
-        b, where :math:`\\tau = t - t_b`. """
+        """ Summary data of each interferometer (see the class docstring):
+
+        - the columns of V: in each bin b, :math:`\\Re(h^0_{\\ell m} (t - t_b)^p)` and
+          :math:`-\\Im(h^0_{\\ell m} (t - t_b)^p)` for every mode and p = 0, 1;
+        - :math:`a = V^T C^{-1} d` (contains :math:`A_0, A_1`);
+        - :math:`S = V^T C^{-1} V` (contains the B matrices), without the terms with
+          p = p' = 1, stored as :math:`S = \\sum_n \\lambda_n e_n e_n^T` so that
+          :math:`v^T S v = \\sum_n \\lambda_n (e_n \\cdot v)^2`.
+
+        Bin b holds the samples from its initial edge up to its final edge (the
+        last bin also holds the last sample). """
         self.summary_data = dict()
-        self._inverse_fiducial_at_edges = dict()
+        self._inverse_h0_at_edges = dict()
         for interferometer in self.interferometers:
             name = interferometer.name
-            edges = self.bin_edges[name]
-            first, last = edges[0], edges[-1]
-            samples = slice(first, last + 1)
-            bin_sizes = np.diff(edges)
-            bin_sizes[-1] += 1
-            bin_starts = edges[:-1] - first
-            bin_of_sample = np.repeat(np.arange(len(bin_sizes)), bin_sizes)
-            times = self._fiducial_times[name]
-            bin_centers = (times[edges[1:]] + times[edges[:-1]]) / 2
-            tau = times[samples] - bin_centers[bin_of_sample]
-
-            fiducial = np.array([self.fiducial_modes[name].get(key, np.zeros(len(times)))
-                                 for key in self.mode_keys])
-            at_edges = fiducial[:, edges]
-            self._inverse_fiducial_at_edges[name] = np.divide(
-                1, at_edges, out=np.zeros_like(at_edges), where=at_edges != 0)
-            basis = np.stack([fiducial[:, samples], fiducial[:, samples] * tau], axis=1)  # (K, 2, n)
-            columns = np.concatenate([basis.real, -basis.imag]).reshape(-1, len(tau))  # (4K, n): (part, q, p)
-            data_vector = np.add.reduceat(
-                columns * self._data_times_inverse_covariance[name][samples], bin_starts, axis=1)
-
-            summary = dict(
-                data_vector=data_vector.ravel(), samples=samples, fiducial=fiducial[:, samples],
-                tau=tau, bin_sizes=bin_sizes,
-                matrix=self._summary_matrix(interferometer, columns, samples, bin_starts, bin_of_sample))
-            logger.info(f"{name}: {len(self.mode_keys)} modes, {len(bin_sizes)} bins")
-            self.summary_data[name] = summary
-
-    def _summary_matrix(self, interferometer, columns, samples, bin_starts, bin_of_sample):
-        """ S = V^T C^-1 V, one column group of V at a time (symmetric), as its
-        eigenvalues and eigenvectors (rows). """
-        number_of_groups, number_of_bins = len(columns), len(bin_starts)
-        x, y = interferometer.gohberg_semencul_vectors
-        rows = np.arange(samples.start, samples.stop)
-        matrix = np.empty((number_of_groups, number_of_bins, number_of_groups, number_of_bins))
-        for j in range(number_of_groups):
-            group = np.zeros((number_of_bins, self._number_of_samples(interferometer)))
-            group[bin_of_sample, rows] = columns[j]
-            group = np.array([gohberg_semencul_product(x, y, column)[samples] for column in group]).T
-            for i in range(j, number_of_groups):
-                block = np.add.reduceat(columns[i][:, None] * group, bin_starts, axis=0)
-                matrix[i, :, j, :] = block
-                matrix[j, :, i, :] = block.T
-        # drop the terms quadratic in the slopes (p = 1 for both columns)
-        slope = np.arange(number_of_groups) % 2 == 1
-        matrix[np.ix_(slope, np.arange(number_of_bins), slope, np.arange(number_of_bins))] = 0
-        size = number_of_groups * number_of_bins
-        # v^T S v = sum_k lambda_k (e_k . v)^2, keeping the eigenvalues above _EIGENVALUE_TOLERANCE of the largest
-        eigenvalues, eigenvectors = np.linalg.eigh(matrix.reshape(size, size))
-        keep = np.abs(eigenvalues) > _EIGENVALUE_TOLERANCE * np.max(np.abs(eigenvalues))
-        logger.debug(f"{interferometer.name}: summary matrix of size {size} with rank {np.sum(keep)}")
-        return eigenvalues[keep], np.ascontiguousarray(eigenvectors[:, keep].T)
+            edges = self.bin_edges[name]  # sample indices of the bin edges: first and last sample included
+            t = self._fiducial_times[name]  # t_j
+            number_of_samples, number_of_bins = len(t), len(edges) - 1
+            samples_per_bin = np.diff(edges)
+            samples_per_bin[-1] += 1
+            bin_of_sample = np.repeat(np.arange(number_of_bins), samples_per_bin)
+            bin_centres = (t[edges[:-1]] + t[edges[1:]]) / 2  # t_b
+            time_from_bin_centre = t - bin_centres[bin_of_sample]  # t_j - t_b
+
+            h0 = np.array([self.fiducial_modes[name][mode] for mode in self.mode_keys])  # h^0_lm(t_j)
+            self._inverse_h0_at_edges[name] = 1 / h0[:, edges]
+
+            # basis functions h^0_lm (t_j - t_b)^p as real functions, in the order (Re/-Im, lm, p);
+            # basis[i] restricted to bin b is the column (i, b) of V
+            h0_times_power_of_time = np.stack([h0, h0 * time_from_bin_centre], axis=1)
+            basis = np.concatenate([h0_times_power_of_time.real, -h0_times_power_of_time.imag])
+            basis = basis.reshape(-1, number_of_samples)
+            number_of_basis = len(basis)
+
+            # a = V^T C^-1 d: basis times C^-1 d, summed over the samples of each bin
+            a = np.add.reduceat(basis * self._data_times_inverse_covariance[name], edges[:-1], axis=1)
+
+            # S = V^T C^-1 V without the terms quadratic in the slopes r_tilde_1 (p = p' = 1, odd i):
+            # C^-1 times each column (i, b) of V, then times basis[j], summed over the samples of
+            # each bin b'; S is symmetric, so only j >= i is computed
+            x, y = interferometer.gohberg_semencul_vectors
+            S = np.zeros((number_of_basis, number_of_bins, number_of_basis, number_of_bins))
+            for i in range(number_of_basis):
+                columns = np.zeros((number_of_bins, number_of_samples))
+                columns[bin_of_sample, np.arange(number_of_samples)] = basis[i]
+                C_inv_columns = np.array([gohberg_semencul_product(x, y, column) for column in columns]).T
+                for j in range(i, number_of_basis):
+                    if i % 2 == 1 and j % 2 == 1:  # r_tilde_1 r_tilde_1
+                        continue
+                    block = np.add.reduceat(basis[j][:, None] * C_inv_columns, edges[:-1], axis=0)
+                    S[j, :, i, :] = block
+                    S[i, :, j, :] = block.T
+
+            # S = sum_n lambda_n e_n e_n^T, keeping the eigenvalues above 1e-12 of the largest
+            size = number_of_basis * number_of_bins
+            eigenvalues, eigenvectors = np.linalg.eigh(S.reshape(size, size))
+            keep = np.abs(eigenvalues) > 1e-12 * np.max(np.abs(eigenvalues))
+
+            self.summary_data[name] = dict(
+                a=a.ravel(), S_eigenvalues=eigenvalues[keep],
+                S_eigenvectors=np.ascontiguousarray(
+                    eigenvectors[:, keep].T, dtype=np.float32 if self.single_precision else np.float64),
+                bin_of_sample=bin_of_sample, time_from_bin_centre=time_from_bin_centre)
+            logger.info(f"{name}: {len(self.mode_keys)} modes, {number_of_bins} bins, "
+                        f"S of size {size} and rank {np.sum(keep)}")
 
     # ------------------------------------------------------------------
     # Likelihood
     # ------------------------------------------------------------------
-    def _snrs_from_coefficients(self, name, coefficients):
-        summary = self.summary_data[name]
-        vector = np.concatenate([coefficients.real.ravel(), coefficients.imag.ravel()])
-        d_inner_h = float(summary["data_vector"] @ vector)
-        eigenvalues, eigenvectors = summary["matrix"]
-        optimal_snr_squared = float(eigenvalues @ (eigenvectors @ vector) ** 2)
-        matched_filter_snr = d_inner_h / optimal_snr_squared ** 0.5 if optimal_snr_squared > 0 else 0.0
-        return self._CalculatedSNRs(
-            d_inner_h=d_inner_h,
-            optimal_snr_squared=optimal_snr_squared,
-            complex_matched_filter_snr=matched_filter_snr,
-            d_inner_h_array=None,
-            optimal_snr_squared_array=None,
-        )
-
-    def _piecewise_linear_signal(self, name, coefficients):
-        """ s = Re sum_q w_q u_q on all samples of the analysis window (zero outside the bins). """
-        summary = self.summary_data[name]
-        expanded = np.repeat(coefficients, summary["bin_sizes"], axis=2)
-        signal = np.zeros(len(self._fiducial_times[name]))
-        signal[summary["samples"]] = np.sum(
-            ((expanded[:, 0] + expanded[:, 1] * summary["tau"]) * summary["fiducial"]).real, axis=0)
-        return signal
-
-    def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array=True, parameters):
-        """ :math:`d^T C^{-1} s`, :math:`s^T C^{-1} s` and the matched filter
-        SNR of the heterodyned signal in one interferometer.
+    def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array=True, parameters,
+                       r_tilde=None):
+        """ :math:`\\langle d, s \\rangle = a \\cdot v` and
+        :math:`\\langle s, s \\rangle = v^T S v = \\sum_n \\lambda_n (e_n \\cdot v)^2` in one
+        interferometer, with :math:`v = (\\Re \\tilde{r}, \\Im \\tilde{r})`.
 
         Parameters
         ----------
@@ -488,37 +510,59 @@ def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array
         return_array: bool
             Unused; kept for the :code:`GravitationalWaveTransient` interface.
         parameters: dict
+        r_tilde: array_like, optional
+            The coefficients r_tilde[lm, p, b] of this interferometer, if already
+            computed (as in :code:`log_likelihood_ratio`, for all interferometers
+            from one waveform call); otherwise they are computed here.
 
         Returns
         -------
         calculated_snrs: _CalculatedSNRs, or None if the waveform failed
         """
-        coefficients = self._heterodyning_coefficients(waveform_polarizations, [interferometer], parameters)
-        if coefficients is None:
-            return None
-        return self._snrs_from_coefficients(interferometer.name, coefficients[0])
+        if r_tilde is None:
+            r_tilde = self._r_tilde_coefficients(waveform_polarizations, [interferometer], parameters)
+            if r_tilde is None:
+                return None
+            r_tilde = r_tilde[0]
+        summary = self.summary_data[interferometer.name]
+        v = np.concatenate([r_tilde.real.ravel(), r_tilde.imag.ravel()])
+        d_inner_s = float(summary["a"] @ v)
+        # e_n . v in the precision of the stored eigenvectors (see single_precision)
+        projections = summary["S_eigenvectors"] @ v.astype(summary["S_eigenvectors"].dtype, copy=False)
+        s_inner_s = float(summary["S_eigenvalues"] @ projections.astype(np.float64) ** 2)
+        return self._CalculatedSNRs(
+            d_inner_h=d_inner_s,
+            optimal_snr_squared=s_inner_s,
+            complex_matched_filter_snr=d_inner_s / s_inner_s ** 0.5 if s_inner_s > 0 else 0.0,
+            d_inner_h_array=None,
+            optimal_snr_squared_array=None,
+        )
 
     def log_likelihood_ratio(self, parameters):
         parameters = copy.deepcopy(parameters)
         parameters.update(self.get_sky_frame_parameters(parameters))
         signal = self.waveform_generator.time_domain_strain(parameters)
-        coefficients = None if signal is None else self._heterodyning_coefficients(
-            signal, self.interferometers, parameters)
-        if coefficients is None:
+        r_tilde = None if signal is None else self._r_tilde_coefficients(signal, self.interferometers, parameters)
+        if r_tilde is None:
             return np.nan_to_num(-np.inf)
         total_snrs = self._CalculatedSNRs()
-        for interferometer, interferometer_coefficients in zip(self.interferometers, coefficients):
-            total_snrs += self._snrs_from_coefficients(interferometer.name, interferometer_coefficients)
+        for interferometer, interferometer_r_tilde in zip(self.interferometers, r_tilde):
+            total_snrs += self.calculate_snrs(
+                signal, interferometer, parameters=parameters, r_tilde=interferometer_r_tilde)
         log_l = self.compute_log_likelihood_from_snrs(total_snrs, parameters=parameters)
         return float(np.real(log_l))
 
     def _compute_full_waveform(self, signal_polarizations, interferometer, parameters):
-        """ The heterodyned (piecewise-linear) template on the samples of the
-        analysis window; zero outside the bins. """
-        coefficients = self._heterodyning_coefficients(signal_polarizations, [interferometer], parameters)
-        if coefficients is None:
+        """ The heterodyned template on all samples of the analysis window (not used in the
+        likelihood): s(t_j) = Re sum_lm [r_tilde_lm,0(b) + r_tilde_lm,1(b) (t_j - t_b)] h^0_lm(t_j). """
+        r_tilde = self._r_tilde_coefficients(signal_polarizations, [interferometer], parameters)
+        if r_tilde is None:
             return None
-        return self._piecewise_linear_signal(interferometer.name, coefficients[0])
+        summary = self.summary_data[interferometer.name]
+        r_tilde_at_samples = r_tilde[0][:, :, summary["bin_of_sample"]]
+        h0 = np.array([self.fiducial_modes[interferometer.name][mode] for mode in self.mode_keys])
+        return np.sum(((r_tilde_at_samples[:, 0] + r_tilde_at_samples[:, 1] * summary["time_from_bin_centre"])
+                       * h0).real, axis=0)
 
     def _rescale_signal(self, signal, new_distance):
         factor = self._ref_dist / new_distance
@@ -536,37 +580,46 @@ def rescaled(times):
     # ------------------------------------------------------------------
     # Fiducial parameters (as in RelativeBinningGravitationalWaveTransient)
     # ------------------------------------------------------------------
-    def find_maximum_likelihood_parameters(self, parameter_bounds, iterations=5, maximization_kwargs=None):
+    def find_maximum_likelihood_parameters(self, parameter_bounds, maximization_kwargs=None):
+        """ Maximize the exact time-domain likelihood
+        (:code:`TimeDomainGravitationalWaveTransient` with placement="model_time",
+        with the same distance marginalization) over :code:`parameters_to_be_updated`
+        with scipy differential evolution, starting from the fiducial parameters. """
+        from ..source import lal_binary_black_hole_model_time
+        from .time_domain import TimeDomainGravitationalWaveTransient
+
         if maximization_kwargs is None:
             maximization_kwargs = dict()
-        parameters = copy.deepcopy(self.fiducial_parameters)
-        updated_parameters_list = self.get_parameter_list_from_dictionary(self.fiducial_parameters)
-        updated_parameters = copy.deepcopy(self.fiducial_parameters)
-        old_fiducial_ln_likelihood = self.log_likelihood_ratio(self.fiducial_parameters)
-        logger.info(f"Fiducial ln likelihood ratio: {old_fiducial_ln_likelihood:.2f}")
-        for it in range(iterations):
-            logger.info(f"Optimizing fiducial parameters. Iteration : {it + 1}")
-            output = differential_evolution(
-                self.lnlike_scipy_maximize,
-                bounds=parameter_bounds,
-                args=(parameters,),
-                x0=updated_parameters_list,
-                **maximization_kwargs,
-            )
-            updated_parameters_list = output['x']
-            updated_parameters = copy.deepcopy(self.fiducial_parameters)
-            updated_parameters.update(self.get_parameter_dictionary_from_list(updated_parameters_list))
-            self.set_fiducial_waveforms(updated_parameters)
-            self.setup_bins()
-            self.compute_summary_data()
-            new_fiducial_ln_likelihood = self.log_likelihood_ratio(updated_parameters)
-            logger.info(f"Fiducial ln likelihood ratio: {new_fiducial_ln_likelihood:.2f}")
-            if new_fiducial_ln_likelihood - old_fiducial_ln_likelihood < 0.1:
-                break
-            old_fiducial_ln_likelihood = new_fiducial_ln_likelihood
-
-        logger.info("Fiducial waveforms updated")
-        logger.info("Summary Data updated")
+        waveform_arguments = {
+            key: value for key, value in self.waveform_generator.waveform_arguments.items()
+            if key not in ("fiducial", "fiducial_minimum_frequency", "sampled_minimum_frequency")}
+        exact_likelihood = TimeDomainGravitationalWaveTransient(
+            interferometers=self.interferometers,
+            waveform_generator=self.waveform_generator.__class__(
+                duration=self.waveform_generator.duration,
+                sampling_frequency=self.waveform_generator.sampling_frequency,
+                start_time=self.waveform_generator.start_time,
+                time_domain_source_model=lal_binary_black_hole_model_time,
+                parameter_conversion=self.waveform_generator.parameter_conversion,
+                waveform_arguments=waveform_arguments),
+            distance_marginalization=self.distance_marginalization,
+            priors=self.priors,
+            distance_marginalization_lookup_table=(
+                self.cached_lookup_table_filename if self.distance_marginalization else None),
+            reference_frame=self.reference_frame,
+            time_reference=self.time_reference,
+            placement="model_time")
+
+        def negative_log_likelihood_ratio(parameter_list):
+            return -exact_likelihood.log_likelihood_ratio(self.get_parameter_dictionary_from_list(parameter_list))
+
+        start = self.get_parameter_list_from_dictionary(self.fiducial_parameters)
+        logger.info(f"Initial ln likelihood ratio: {-negative_log_likelihood_ratio(start):.2f}")
+        output = differential_evolution(
+            negative_log_likelihood_ratio, bounds=parameter_bounds, x0=start, **maximization_kwargs)
+        updated_parameters = self.get_parameter_dictionary_from_list(output["x"])
+        logger.info(f"Maximum ln likelihood ratio: {-output['fun']:.2f} at "
+                    f"{dict(zip(self.parameters_to_be_updated, output['x']))}")
         return updated_parameters
 
     def _set_fiducial(self):
@@ -583,7 +636,6 @@ def _unset_fiducial(self):
         self.waveform_generator.waveform_arguments["fiducial"] = 0
         self.waveform_generator._cache["parameters"] = None
 
-    lnlike_scipy_maximize = RelativeBinningGravitationalWaveTransient.lnlike_scipy_maximize
     get_parameter_dictionary_from_list = RelativeBinningGravitationalWaveTransient.get_parameter_dictionary_from_list
     get_parameter_list_from_dictionary = RelativeBinningGravitationalWaveTransient.get_parameter_list_from_dictionary
     get_bounds_from_priors = RelativeBinningGravitationalWaveTransient.get_bounds_from_priors
@@ -596,53 +648,3 @@ def meta_data(self):
             number_of_bins=self.number_of_bins,
             mode_keys=self.mode_keys)
         return meta_data
-
-
-_EIGENVALUE_TOLERANCE = 1e-12
-
-_PHASE_PROXY_POWERS = np.array([5 / 8, 3 / 8, 1 / 4, -3 / 8])
-
-
-def time_domain_bin_edges(times, epsilon=(0.5, 0.1), time_split=-0.02, spacing=(2, 10, 100),
-                          spacing_times=(0.02, 0.1), chi=1):
-    """ Bin edges for the time-domain heterodyned likelihood (Sharma et al.
-    arXiv:2601.11239).
-
-    - Before the merger (t < 0): edges equally spaced in the phase proxy
-      :math:`\\psi(t) = \\sum_k {\\rm sign}(\\gamma_k) \\delta\\alpha_k |t|^{\\gamma_k}`,
-      :math:`\\gamma = (5/8, 3/8, 1/4, -3/8)`, with
-      :math:`\\delta\\alpha_k = 2 \\pi \\chi / |t|_{\\rm max}^{\\gamma_k}`
-      (:math:`|t|_{\\rm min}` for :math:`\\gamma_k < 0`), one bin per
-      epsilon[0] of :math:`|\\Delta\\psi|` for t <= time_split and per
-      epsilon[1] after.
-    - From the merger: one edge every spacing[0] samples until
-      spacing_times[0], every spacing[1] samples until spacing_times[1] and
-      every spacing[2] samples after.
-
-    Parameters
-    ==========
-    times: array_like
-        Increasing times (s) relative to the merger.
-
-    Returns
-    =======
-    array_like: indices of the edges into times (first and last included).
-    """
-    edges = [0, len(times) - 1]
-    inspiral = np.flatnonzero(times < 0)
-    if len(inspiral) > 1:
-        t = np.abs(times[inspiral])
-        d_alpha = 2 * np.pi * chi / np.where(_PHASE_PROXY_POWERS < 0, t.min(), t.max()) ** _PHASE_PROXY_POWERS
-        proxy = np.sum(np.sign(_PHASE_PROXY_POWERS) * d_alpha * t[:, None] ** _PHASE_PROXY_POWERS, axis=1)
-        for region, region_epsilon in zip((times[inspiral] <= time_split, times[inspiral] > time_split), epsilon):
-            if np.sum(region) < 2:
-                continue
-            phase = np.abs(proxy[region] - proxy[region][0])
-            number_of_bins = max(int(phase[-1] / region_epsilon), 1)
-            targets = np.linspace(0, phase[-1], number_of_bins + 1)
-            edges.extend(inspiral[region][np.searchsorted(phase, targets, side="right") - 1])
-    merger = inspiral[-1] if len(inspiral) else 0
-    boundaries = [merger] + [max(merger, np.searchsorted(times, x)) for x in spacing_times] + [len(times)]
-    for start, stop, step in zip(boundaries[:-1], boundaries[1:], spacing):
-        edges.extend(range(start, stop, step))
-    return np.unique(edges)
diff --git a/test/gw/likelihood/time_domain_heterodyning_test.py b/test/gw/likelihood/time_domain_heterodyning_test.py
index f8b29c4fe..a9629858e 100644
--- a/test/gw/likelihood/time_domain_heterodyning_test.py
+++ b/test/gw/likelihood/time_domain_heterodyning_test.py
@@ -10,7 +10,6 @@
     TimeDomainGravitationalWaveTransient,
     TimeDomainHeterodyningGravitationalWaveTransient,
 )
-from bilby.gw.likelihood.time_domain_heterodyning import time_domain_bin_edges
 from bilby.gw.time_domain_utils import (
     gohberg_semencul_product,
 )
@@ -85,8 +84,9 @@ def perturbed(parameters, scale=1.0):
 
 class TestBinEdges(unittest.TestCase):
     def test_edges(self):
+        bin_edges = TimeDomainHeterodyningGravitationalWaveTransient.time_domain_bin_edges
         times = np.arange(-0.5, 0.3, 1 / 1024)
-        edges = time_domain_bin_edges(times)
+        edges = bin_edges(times)
         self.assertEqual(edges[0], 0)
         self.assertEqual(edges[-1], len(times) - 1)
         self.assertTrue(np.all(np.diff(edges) > 0))
@@ -96,7 +96,7 @@ def test_edges(self):
         late = edges[(times[edges] > 0.03) & (times[edges] < 0.09)]
         self.assertTrue(np.all(np.diff(late) == 10))
         # smaller epsilon: more inspiral bins
-        self.assertGreater(np.sum(time_domain_bin_edges(times, epsilon=(0.1, 0.05)) < merger),
+        self.assertGreater(np.sum(bin_edges(times, epsilon=(0.1, 0.05)) < merger),
                            np.sum(edges < merger))
 
 
@@ -148,6 +148,15 @@ def test_matches_exact_likelihood(self):
                 self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
                                     - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
 
+    def test_single_precision(self):
+        ifos = interferometers()
+        values = list()
+        for single_precision in (False, True):
+            likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, single_precision=single_precision)
+            values.append(likelihood.log_likelihood_ratio(perturbed(INJECTION)))
+        self.assertLess(abs(values[0] - values[1]), 1e-3)
+
     def test_full_waveform_is_piecewise_linear_model(self):
         ifos = interferometers()
         likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
@@ -159,9 +168,11 @@ def test_full_waveform_is_piecewise_linear_model(self):
             snrs = likelihood.calculate_snrs(signal, ifo, parameters=parameters)
             x, y = ifo.gohberg_semencul_vectors
             # <s, s> without the terms quadratic in the slopes: <s, s> - <s1, s1>, s1 = slope part of s
-            coefficients = likelihood._heterodyning_coefficients(signal, [ifo], parameters)[0]
-            coefficients[:, 0] = 0
-            slopes = likelihood._piecewise_linear_signal(ifo.name, coefficients)
+            r_tilde_1 = likelihood._r_tilde_coefficients(signal, [ifo], parameters)[0][:, 1]
+            summary = likelihood.summary_data[ifo.name]
+            h0 = np.array([likelihood.fiducial_modes[ifo.name][mode] for mode in likelihood.mode_keys])
+            slopes = np.sum(
+                (r_tilde_1[:, summary["bin_of_sample"]] * summary["time_from_bin_centre"] * h0).real, axis=0)
             expected = (template @ gohberg_semencul_product(x, y, template)
                         - slopes @ gohberg_semencul_product(x, y, slopes))
             self.assertAlmostEqual(snrs.optimal_snr_squared / expected, 1, 10)
@@ -249,7 +260,7 @@ def test_errors(self):
         with self.assertRaises(ValueError):  # fiducial_minimum_frequency above the derived one
             TimeDomainHeterodyningGravitationalWaveTransient(
                 ifos, heterodyning_generator(), fiducial_parameters=INJECTION, fiducial_minimum_frequency=30.0)
-        with self.assertRaises(ValueError):  # above minimum_frequency - 2 Hz
+        with self.assertLogs("bilby", level="WARNING"):  # above minimum_frequency - 2 Hz
             TimeDomainHeterodyningGravitationalWaveTransient(
                 ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=19.0)
         with self.assertRaises(NotImplementedError):

From 81f785bbd221c460fc40056fb1dcef3aa07bb7bd Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Tue, 13 Oct 2026 16:34:15 +0530
Subject: [PATCH 12/21] float64->float32 in eigenvalues computation

---
 .../gw/likelihood/time_domain_heterodyning.py | 31 +++++++++++++------
 .../time_domain_heterodyning_test.py          | 18 +++++++++--
 2 files changed, 36 insertions(+), 13 deletions(-)

diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index 51a1806ea..c55b63158 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -141,12 +141,13 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         (the leading-order frequency 1.5 x (time from the window start to the
         merger) + 0.1 s before the merger, minus 1 Hz); a given value must not
         be above that.
-    single_precision: bool, optional
-        If True, the eigenvectors of S are stored and multiplied in float32
-        instead of float64: :math:`v^T S v` is a few times faster for many modes
-        and bins, with relative errors of ~1e-7 in it. Default is False.
     time_marginalization, phase_marginalization, calibration_marginalization: bool
         Not implemented for this likelihood; must be False.
+    use_float32: bool, optional
+        If True, the eigenvectors of the summary matrix S are stored and
+        multiplied in float32 instead of float64: :math:`v^T S v` is a few times
+        faster for many modes and bins, with relative errors of ~1e-7 in it.
+        Default is False.
 
     Returns
     -------
@@ -163,8 +164,8 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
                  time_reference="geocenter", epsilon=(0.5, 0.1), time_split=-0.02,
                  spacing=(2, 10, 100), spacing_times=(0.02, 0.1), chi=1,
                  sampled_minimum_frequency=None, fiducial_minimum_frequency=None,
-                 single_precision=False, time_marginalization=False,
-                 phase_marginalization=False, calibration_marginalization=False):
+                 time_marginalization=False, phase_marginalization=False,
+                 calibration_marginalization=False, use_float32=False):
         super(TimeDomainHeterodyningGravitationalWaveTransient, self).__init__(
             interferometers=interferometers,
             waveform_generator=waveform_generator,
@@ -183,7 +184,7 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
         self.spacing = spacing
         self.spacing_times = spacing_times
         self.chi = chi
-        self.single_precision = single_precision
+        self.use_float32 = use_float32
         # this likelihood sets its own entries in waveform_arguments; copy the dictionary so that
         # they do not reach other waveform generators that share it
         self.waveform_generator.waveform_arguments = dict(self.waveform_generator.waveform_arguments)
@@ -488,7 +489,7 @@ def compute_summary_data(self):
             self.summary_data[name] = dict(
                 a=a.ravel(), S_eigenvalues=eigenvalues[keep],
                 S_eigenvectors=np.ascontiguousarray(
-                    eigenvectors[:, keep].T, dtype=np.float32 if self.single_precision else np.float64),
+                    eigenvectors[:, keep].T, dtype=np.float32 if self.use_float32 else np.float64),
                 bin_of_sample=bin_of_sample, time_from_bin_centre=time_from_bin_centre)
             logger.info(f"{name}: {len(self.mode_keys)} modes, {number_of_bins} bins, "
                         f"S of size {size} and rank {np.sum(keep)}")
@@ -527,7 +528,7 @@ def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array
         summary = self.summary_data[interferometer.name]
         v = np.concatenate([r_tilde.real.ravel(), r_tilde.imag.ravel()])
         d_inner_s = float(summary["a"] @ v)
-        # e_n . v in the precision of the stored eigenvectors (see single_precision)
+        # e_n . v in the precision of the stored eigenvectors (see use_float32)
         projections = summary["S_eigenvectors"] @ v.astype(summary["S_eigenvectors"].dtype, copy=False)
         s_inner_s = float(summary["S_eigenvalues"] @ projections.astype(np.float64) ** 2)
         return self._CalculatedSNRs(
@@ -645,6 +646,16 @@ def meta_data(self):
         meta_data = super(TimeDomainHeterodyningGravitationalWaveTransient, self).meta_data
         meta_data.update(
             fiducial_parameters=self.fiducial_parameters,
+            parameters_to_be_updated=getattr(self, "parameters_to_be_updated", None),
+            fiducial_minimum_frequency=self.fiducial_minimum_frequency,
+            sampled_minimum_frequency=self.sampled_minimum_frequency,
+            mode_keys=self.mode_keys,
+            epsilon=self.epsilon,
+            time_split=self.time_split,
+            spacing=self.spacing,
+            spacing_times=self.spacing_times,
+            chi=self.chi,
             number_of_bins=self.number_of_bins,
-            mode_keys=self.mode_keys)
+            bin_edges=self.bin_edges,
+            bin_edge_times={name: self._fiducial_times[name][edges] for name, edges in self.bin_edges.items()})
         return meta_data
diff --git a/test/gw/likelihood/time_domain_heterodyning_test.py b/test/gw/likelihood/time_domain_heterodyning_test.py
index a9629858e..7a032b5f1 100644
--- a/test/gw/likelihood/time_domain_heterodyning_test.py
+++ b/test/gw/likelihood/time_domain_heterodyning_test.py
@@ -1,3 +1,4 @@
+import json
 import os
 import shutil
 import tempfile
@@ -148,15 +149,26 @@ def test_matches_exact_likelihood(self):
                 self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
                                     - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
 
-    def test_single_precision(self):
+    def test_use_float32(self):
         ifos = interferometers()
         values = list()
-        for single_precision in (False, True):
+        for use_float32 in (False, True):
             likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, single_precision=single_precision)
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION,
+                use_float32=use_float32)
             values.append(likelihood.log_likelihood_ratio(perturbed(INJECTION)))
         self.assertLess(abs(values[0] - values[1]), 1e-3)
 
+    def test_meta_data(self):
+        ifos = interferometers()
+        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
+            ifos, heterodyning_generator(), fiducial_parameters=INJECTION)
+        meta_data = likelihood.meta_data
+        for ifo in ifos:
+            np.testing.assert_array_equal(meta_data["bin_edges"][ifo.name], likelihood.bin_edges[ifo.name])
+            self.assertEqual(len(meta_data["bin_edge_times"][ifo.name]), meta_data["number_of_bins"][ifo.name] + 1)
+        json.dumps(meta_data, cls=bilby.core.utils.BilbyJsonEncoder)
+
     def test_full_waveform_is_piecewise_linear_model(self):
         ifos = interferometers()
         likelihood = TimeDomainHeterodyningGravitationalWaveTransient(

From 0646790c133d7cfa541b7156565bd0bd77ab1377 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Wed, 14 Oct 2026 18:07:10 +0530
Subject: [PATCH 13/21] f_start based on modes

---
 bilby/gw/detector/acf.py                      | 193 ++---------
 bilby/gw/detector/condition_data.py           | 141 +++-----
 bilby/gw/detector/interferometer.py           | 314 ++++++++----------
 bilby/gw/detector/networks.py                 | 117 +++----
 bilby/gw/likelihood/time_domain.py            | 153 ++++-----
 .../gw/likelihood/time_domain_heterodyning.py | 298 ++++++-----------
 bilby/gw/model_time_waveforms.py              | 165 ++++-----
 bilby/gw/source.py                            | 237 +++++++------
 bilby/gw/time_domain_utils.py                 | 134 ++++----
 .../data_examples/GW150914_time_domain.py     |  11 +-
 .../time_domain_heterodyning_test.py          |  56 +++-
 test/gw/likelihood/time_domain_test.py        |  98 ++----
 12 files changed, 789 insertions(+), 1128 deletions(-)

diff --git a/bilby/gw/detector/acf.py b/bilby/gw/detector/acf.py
index 280d8a5ad..576d8db51 100644
--- a/bilby/gw/detector/acf.py
+++ b/bilby/gw/detector/acf.py
@@ -1,7 +1,6 @@
 import numpy as np
 
 from ...core.utils import logger
-from ..time_domain_utils import gohberg_semencul_vectors
 
 
 class AutoCovarianceFunction(object):
@@ -11,13 +10,13 @@ def __init__(self, acf_array=None, sampling_frequency=None, minimum_frequency=No
         """
         Instantiate a new AutoCovarianceFunction object.
 
-        The autocovariance function (ACF) of stationary Gaussian noise defines
-        the noise covariance matrix of a segment of N samples,
-        :math:`C_{ij} = \\rho(|i - j|)`, where :math:`\\rho` is the ACF.
+        The autocovariance function (ACF) of stationary Gaussian noise gives the
+        noise covariance matrix of N consecutive samples, which is a Toeplitz
+        matrix with first row equal to the first N lags of the ACF.
 
         Examples
         ========
-        From a one-sided power spectral density and its frequency array:
+        From a one-sided power spectral density:
 
         .. code-block:: python
 
@@ -32,21 +31,19 @@ def __init__(self, acf_array=None, sampling_frequency=None, minimum_frequency=No
 
         Parameters
         ==========
-        acf_array: array_like, optional
-            Autocovariance function at lags 0, 1/sampling_frequency,
-            2/sampling_frequency, ... (strain^2).
-        sampling_frequency: float, optional
-            Sampling frequency of the lags (Hz). Must equal the sampling
-            frequency of the data it is used with.
+        acf_array: array_like
+            The ACF at lags 0, 1 / sampling_frequency, 2 / sampling_frequency, ...
+        sampling_frequency: float
+            The sampling frequency (in Hz) of the lags; must equal that of the data
         minimum_frequency: float, optional
-            Lower edge of the frequency band used to compute the ACF (Hz).
+            The lower edge (in Hz) of the frequency band used to compute the ACF
         maximum_frequency: float, optional
-            Upper edge of the frequency band used to compute the ACF (Hz).
+            The upper edge (in Hz) of the frequency band used to compute the ACF
         fill_value: float, optional
-            PSD value used outside the band (strain^2 / Hz).
+            The PSD value used outside the band
         fill_multiplier: float, optional
-            Multiple of the maximum in-band PSD used outside the band, if
-            `fill_value` was computed from it.
+            The multiple of the maximum in-band PSD used outside the band
+
         """
         self.acf_array = None if acf_array is None else np.asarray(acf_array, dtype=float)
         self.sampling_frequency = None if sampling_frequency is None else float(sampling_frequency)
@@ -57,12 +54,8 @@ def __init__(self, acf_array=None, sampling_frequency=None, minimum_frequency=No
 
     @property
     def meta_data(self):
-        duration = None
-        if self.acf_array is not None and self.sampling_frequency is not None:
-            duration = len(self.acf_array) / self.sampling_frequency
         return dict(
             sampling_frequency=self.sampling_frequency,
-            duration=duration,
             minimum_frequency=self.minimum_frequency,
             maximum_frequency=self.maximum_frequency,
             fill_value=self.fill_value,
@@ -73,46 +66,34 @@ def meta_data(self):
     def from_power_spectral_density_array(
             cls, frequency_array, psd_array, minimum_frequency, maximum_frequency,
             sampling_frequency=None, fill_value=None, fill_multiplier=1e4):
-        """ Compute the ACF from a one-sided power spectral density.
-
-        The PSD below `minimum_frequency` and above `maximum_frequency` is set
-        to `fill_value` or, if it is not given, to `fill_multiplier` times its
-        maximum value in [`minimum_frequency`, `maximum_frequency`]. If
-        `frequency_array` does not start at 0 Hz, bins down to 0 Hz are added
-        and set to the same value. The ACF is then
-
-        .. math::
+        """ Compute the ACF from a one-sided power spectral density (PSD).
 
-            \\rho = \\frac{f_s}{2} \\, \\mathrm{IRFFT}(S),
-
-        where :math:`f_s = 2 f_{\\max}` is twice the highest frequency in
-        `frequency_array`.
+        The PSD outside [`minimum_frequency`, `maximum_frequency`] is set to
+        `fill_value`, or to `fill_multiplier` times its maximum in the band, and
+        the ACF is its inverse Fourier transform (Wiener-Khinchin theorem).
 
         Parameters
         ==========
         frequency_array: array_like
-            Uniformly spaced frequencies (Hz), up to half the sampling
-            frequency. The first frequency must be a multiple of the spacing.
+            Uniformly spaced frequencies (in Hz) up to the Nyquist frequency
         psd_array: array_like
-            One-sided PSD at `frequency_array` (strain^2 / Hz).
+            The one-sided PSD at `frequency_array`
         minimum_frequency: float
-            Lower edge of the frequency band (Hz).
+            The lower edge of the frequency band (in Hz)
         maximum_frequency: float
-            Upper edge of the frequency band (Hz).
+            The upper edge of the frequency band (in Hz)
         sampling_frequency: float, optional
-            Sampling frequency of the data (Hz). If it differs from twice the
-            highest frequency in `frequency_array`, a warning is logged and
-            the latter is used.
+            The sampling frequency of the data (in Hz); a warning is logged if it
+            is not twice the highest frequency in `frequency_array`
         fill_value: float, optional
-            PSD value used outside the band (strain^2 / Hz). Overrides
-            `fill_multiplier`.
+            The PSD value used outside the band; overrides `fill_multiplier`
         fill_multiplier: float
-            Multiple of the maximum in-band PSD used outside the band if
-            `fill_value` is not given (default 1e4).
+            The multiple of the maximum in-band PSD used outside the band
 
         Returns
         =======
         AutoCovarianceFunction
+
         """
         frequency_array = np.asarray(frequency_array, dtype=float)
         psd_array = np.asarray(psd_array, dtype=float)
@@ -145,72 +126,18 @@ def from_power_spectral_density_array(
                    minimum_frequency=minimum_frequency, maximum_frequency=maximum_frequency,
                    fill_value=float(fill_value), fill_multiplier=fill_multiplier)
 
-    @classmethod
-    def from_time_domain_strain(
-            cls, time_domain_strain, sampling_frequency, analysis_duration, minimum_frequency,
-            maximum_frequency, segment_duration=None, duration_factor=16, fill_value=None,
-            fill_multiplier=1e4):
-        """ Estimate the ACF from noise data.
-
-        The PSD of the data is estimated with Welch's method (Hann window, 50%
-        overlap, median average) and passed to
-        :code:`from_power_spectral_density_array`.
-
-        Parameters
-        ==========
-        time_domain_strain: array_like
-            Noise time series (strain).
-        sampling_frequency: float
-            Sampling frequency of the time series (Hz).
-        analysis_duration: float
-            Duration of the longest segment the ACF will be used for (s).
-        minimum_frequency: float
-            Lower edge of the frequency band (Hz).
-        maximum_frequency: float
-            Upper edge of the frequency band (Hz).
-        segment_duration: float, optional
-            Duration of the Welch segments (s). Default: `duration_factor`
-            times `analysis_duration`, rounded up to a power-of-two number of
-            samples.
-        duration_factor: float
-            See `segment_duration` (default 16).
-        fill_value: float, optional
-            PSD value used outside the band (strain^2 / Hz). Overrides
-            `fill_multiplier`.
-        fill_multiplier: float
-            Multiple of the maximum in-band PSD used outside the band if
-            `fill_value` is not given (default 1e4).
-
-        Returns
-        =======
-        AutoCovarianceFunction
-        """
-        from scipy.signal import welch
-        if segment_duration is None:
-            nperseg = int(2 ** np.ceil(np.log2(duration_factor * analysis_duration * sampling_frequency)))
-        else:
-            nperseg = int(round(segment_duration * sampling_frequency))
-        frequency_array, psd_array = welch(
-            time_domain_strain, fs=sampling_frequency, nperseg=nperseg, window="hann",
-            average="median")
-        return cls.from_power_spectral_density_array(
-            frequency_array, psd_array, minimum_frequency, maximum_frequency,
-            sampling_frequency=sampling_frequency, fill_value=fill_value,
-            fill_multiplier=fill_multiplier)
-
     def get_acf_array(self, number_of_samples):
-        """ First `number_of_samples` lags of the ACF.
-
-        A ValueError is raised if the ACF is shorter than `number_of_samples`.
+        """ The first `number_of_samples` lags of the ACF
 
         Parameters
         ==========
         number_of_samples: int
-            Number of samples in the analysis segment.
+            The number of samples in the analysis window
 
         Returns
         =======
-        array_like: The first row of the segment's covariance matrix.
+        array_like: The first row of the noise covariance matrix
+
         """
         if number_of_samples > len(self.acf_array):
             raise ValueError(
@@ -218,63 +145,5 @@ def get_acf_array(self, number_of_samples):
                 f"({len(self.acf_array)} samples)")
         return self.acf_array[:number_of_samples]
 
-    def gohberg_semencul_vectors(self, number_of_samples):
-        """ Gohberg-Semencul vectors of the inverse covariance matrix of a
-        segment of `number_of_samples` samples.
-
-        Parameters
-        ==========
-        number_of_samples: int
-            Number of samples in the analysis segment.
-
-        Returns
-        =======
-        x, y: array_like
-            See :code:`bilby.gw.time_domain_utils.gohberg_semencul_vectors`.
-        """
-        return gohberg_semencul_vectors(self.get_acf_array(number_of_samples))
-
-
-def read_power_spectral_densities_from_hdf5(filename, interferometers, label=None):
-    """ Read power spectral densities and their frequency arrays from an HDF5
-    file.
-
-    Two layouts are supported: `psds/<ifo>_psd/frequency` and
-    `psds/<ifo>_psd/spectrum` (with lower-case detector names), and
-    `<label>/psds/<IFO>` holding an (N, 2) array of frequency and PSD (as in
-    GWTC data releases).
-
-    Parameters
-    ==========
-    filename: str
-        Name of the HDF5 file.
-    interferometers: list
-        Detector names, e.g. ["H1", "L1"].
-    label: str, optional
-        Analysis label in the second layout, e.g. "C01:IMRPhenomXPHM".
-        Required if the file contains more than one analysis.
-
-    Returns
-    =======
-    dict: {detector name: (frequency_array, psd_array)}
-    """
-    import h5py
-    output = dict()
-    with h5py.File(filename, "r") as ff:
-        if "psds" in ff:
-            for ifo in interferometers:
-                group = ff["psds"][f"{ifo.lower()}_psd"]
-                output[ifo] = (group["frequency"][:], group["spectrum"][:])
-            return output
-        if label is None:
-            labels = [key for key in ff.keys() if isinstance(ff[key], h5py.Group) and "psds" in ff[key]]
-            if len(labels) != 1:
-                raise ValueError(f"Give label, one of {labels}")
-            label = labels[0]
-        for ifo in interferometers:
-            array = ff[label]["psds"][ifo][:]
-            output[ifo] = (array[:, 0], array[:, 1])
-    return output
-
 
-__all__ = ["AutoCovarianceFunction", "read_power_spectral_densities_from_hdf5"]
+__all__ = ["AutoCovarianceFunction"]
diff --git a/bilby/gw/detector/condition_data.py b/bilby/gw/detector/condition_data.py
index 86b71696b..c7718bc5b 100644
--- a/bilby/gw/detector/condition_data.py
+++ b/bilby/gw/detector/condition_data.py
@@ -4,115 +4,78 @@
 def condition_strain_data(strain_data, sampling_frequency, start_time, duration,
                           preserve_time=None, trim=0.25, taper_and_trim=True,
                           remove_mean=True):
-    """ Downsample time-domain strain data around an analysis window.
+    """ Downsample time-domain strain data around an analysis window
 
-    Steps (default, `taper_and_trim` = True):
-
-    1. Keep the window [`start_time`, `start_time` + `duration`) and a buffer
-       of `trim` / (1 - 2 `trim`) x `duration` on each side (`duration` / 2
-       for the default `trim` = 0.25). A ValueError is raised if the data do
-       not cover them.
-    2. Shift the data by fewer than `factor` samples (factor = current / new
-       sampling frequency) so that the sample nearest `preserve_time` is kept.
-    3. Multiply by a Tukey window with alpha = `trim`, set all frequencies
-       above the new Nyquist frequency to zero and keep every factor-th
-       sample.
-    4. Remove a fraction `trim` of the samples at each end; this removes the
-       buffer. Samples in the window are always kept.
-    5. Subtract the mean if `remove_mean`.
-
-    With `taper_and_trim` = False, steps 1, 3 and 4 are replaced by
-    :code:`scipy.signal.decimate` (order-8 Chebyshev low-pass filter, applied
-    forwards and backwards, then every factor-th sample) on all the data, and
-    the first samples are dropped instead of shifted in step 2. No buffer is
-    needed. The filter starts to cut at 0.8 x the new Nyquist frequency.
-
-    The result replaces the data in `strain_data`.
+    By default, the data in the window plus a buffer of
+    `trim` / (1 - 2 `trim`) x `duration` on each side are tapered with a Tukey
+    window (alpha = `trim`), low-passed below the new Nyquist frequency,
+    downsampled, and the buffer is removed. The samples are aligned so that the
+    sample nearest `preserve_time` is kept. With `taper_and_trim` = False,
+    :code:`scipy.signal.decimate` is used instead. The result replaces the
+    data in `strain_data`.
 
     Parameters
     ==========
     strain_data: bilby.gw.detector.InterferometerStrainData
-        The strain data; modified in place.
+        The strain data, modified in place
     sampling_frequency: float
-        New sampling frequency (Hz); must divide the current one.
+        The new sampling frequency (in Hz); must divide the current one
     start_time: float
-        GPS start time of the analysis window (s).
+        The GPS start time of the analysis window
     duration: float
-        Duration of the analysis window (s).
+        The duration of the analysis window (in s)
     preserve_time: float, optional
-        GPS time whose nearest sample is kept, e.g. the inspiral/post-inspiral
-        cut time (default: `start_time`).
+        GPS time whose nearest sample is kept (default: `start_time`)
     trim: float
-        Fraction of the data at each end that is removed (default 0.25).
+        The fraction of the data removed at each end
     taper_and_trim: bool
-        Use the Tukey window, buffer and trimming (default True); if False,
-        use :code:`scipy.signal.decimate`.
+        If True, taper, low-pass and trim; if False, use :code:`scipy.signal.decimate`
     remove_mean: bool
-        Subtract the mean of the result (default True).
+        If True, subtract the mean of the result
+
     """
     from scipy.signal import decimate
     from scipy.signal.windows import tukey
 
-    original_sampling_frequency = float(strain_data.sampling_frequency)
-    factor = int(round(original_sampling_frequency / sampling_frequency))
-    if preserve_time is None:
-        preserve_time = start_time
-
-    if not taper_and_trim:
-        strain = np.array(strain_data.time_domain_strain, dtype=float)
-        times = np.array(strain_data.time_array, dtype=float)
-        shift = int(np.argmin(abs(times - preserve_time))) % factor
-        strain = decimate(strain[shift:], factor, zero_phase=True)
-        times = times[shift::factor]
-        if remove_mean:
-            strain = strain - np.mean(strain)
-        strain_data.set_from_time_domain_strain(
-            strain, sampling_frequency=sampling_frequency,
-            duration=len(strain) / sampling_frequency, start_time=times[0])
-        return
-
-    buffer_duration = duration * trim / (1 - 2 * trim)
-    tolerance = 1 / original_sampling_frequency
-    data_start_time = strain_data.start_time
-    data_end_time = data_start_time + strain_data.duration
-    buffer_start_time = start_time - buffer_duration
-    buffer_end_time = start_time + duration + buffer_duration
-    if data_start_time > buffer_start_time + tolerance or data_end_time < buffer_end_time - tolerance:
-        raise ValueError(
-            f"The data ({data_start_time:.6f} - {data_end_time:.6f}) must cover "
-            f"{buffer_start_time:.6f} - {buffer_end_time:.6f}: the analysis window plus "
-            f"{buffer_duration:g} s on each side")
-    buffer_start_index = max(
-        int(round((buffer_start_time - data_start_time) * original_sampling_frequency)), 0)
-    buffer_end_index = int(round((buffer_end_time - data_start_time) * original_sampling_frequency))
-    strain = np.array(strain_data.time_domain_strain[buffer_start_index:buffer_end_index], dtype=float)
-    times = np.array(strain_data.time_array[buffer_start_index:buffer_end_index], dtype=float)
-
-    shift = int(np.argmin(abs(times - preserve_time))) % factor
-    if trim > 0:
-        # the wrapped samples are at the end and are removed in step 4
-        times = np.roll(times, -shift)
-        strain = np.roll(strain, -shift)
+    factor = int(round(strain_data.sampling_frequency / sampling_frequency))
+    strain = np.asarray(strain_data.time_domain_strain, dtype=float)
+    times = np.asarray(strain_data.time_array, dtype=float)
+    if taper_and_trim:
+        # step 1: the window and a buffer on each side
+        buffer = duration * trim / (1 - 2 * trim)
+        first, last = start_time - buffer, start_time + duration + buffer
+        data_end = strain_data.start_time + strain_data.duration
+        if (strain_data.start_time > first + 1 / strain_data.sampling_frequency
+                or data_end < last - 1 / strain_data.sampling_frequency):
+            raise ValueError(
+                f"The data ({strain_data.start_time:.6f} - {data_end:.6f}) must cover {first:.6f} - {last:.6f}: "
+                f"the analysis window plus {buffer:g} s on each side")
+        keep = slice(max(int(round((first - strain_data.start_time) * strain_data.sampling_frequency)), 0),
+                     int(round((last - strain_data.start_time) * strain_data.sampling_frequency)))
+        strain, times = strain[keep], times[keep]
+
+    # step 2: keep the sample nearest preserve_time
+    shift = int(np.argmin(abs(times - (start_time if preserve_time is None else preserve_time)))) % factor
+    if taper_and_trim and trim > 0:  # the wrapped samples are at the end and are removed in step 4
+        strain, times = np.roll(strain, -shift), np.roll(times, -shift)
     else:
-        times = times[shift:]
-        strain = strain[shift:]
-
-    strain_fd = np.fft.rfft(strain * tukey(len(strain), trim))
-    frequencies = np.fft.rfftfreq(len(strain), 1 / original_sampling_frequency)
-    strain_fd[frequencies > sampling_frequency / 2] = 0
-    strain = np.fft.irfft(strain_fd, n=len(strain))[::factor]
-    times = times[::factor]
+        strain, times = strain[shift:], times[shift:]
+
+    if taper_and_trim:
+        # step 3: taper, low-pass and downsample
+        strain_fd = np.fft.rfft(strain * tukey(len(strain), trim))
+        strain_fd[np.fft.rfftfreq(len(strain), 1 / strain_data.sampling_frequency) > sampling_frequency / 2] = 0
+        strain, times = np.fft.irfft(strain_fd, n=len(strain))[::factor], times[::factor]
+        # step 4: remove the fraction trim at each end, but always keep the analysis samples
+        window = int(np.argmin(abs(times - start_time)))  # first sample of the analysis window
+        keep = slice(min(int(round(trim * len(strain))), window),
+                     max(int(round((1 - trim) * len(strain))), window + int(round(duration * sampling_frequency))))
+        strain, times = strain[keep], times[keep]
+    else:
+        strain, times = decimate(strain, factor, zero_phase=True), times[::factor]
 
-    # remove the fraction trim at each end, but always keep the analysis samples
-    analysis_start_index = int(np.argmin(abs(times - start_time)))
-    analysis_end_index = analysis_start_index + int(round(duration * sampling_frequency))
-    keep_start_index = min(int(round(trim * len(strain))), analysis_start_index)
-    keep_end_index = max(int(round((1 - trim) * len(strain))), analysis_end_index)
-    strain = strain[keep_start_index:keep_end_index]
-    times = times[keep_start_index:keep_end_index]
     if remove_mean:
         strain = strain - np.mean(strain)
-
     strain_data.set_from_time_domain_strain(
         strain, sampling_frequency=sampling_frequency, duration=len(strain) / sampling_frequency,
         start_time=times[0])
diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index 3dc326201..63147ad6a 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -14,7 +14,8 @@
 from .calibration import Recalibrate
 from .geometry import InterferometerGeometry
 from .strain_data import InterferometerStrainData
-from ..time_domain_utils import gohberg_semencul_product, place_time_domain_signal, times_from_merger
+from ..time_domain_utils import (
+    gohberg_semencul_product, gohberg_semencul_vectors, place_time_domain_signal, times_from_merger)
 from ..conversion import generate_all_bbh_parameters
 
 
@@ -94,8 +95,10 @@ def __init__(self, name, power_spectral_density, minimum_frequency, maximum_freq
             maximum_frequency=maximum_frequency)
         self.meta_data = dict(name=name)
         self.reference_time = None
+        self.analysis_start_time = None
+        self.analysis_duration = None
+        self.analysis_cut_time = None
         self._autocovariance_function = None
-        self._analysis_window = None
         self.gohberg_semencul_vectors = None
 
     def __eq__(self, other):
@@ -267,156 +270,127 @@ def set_strain_data_from_zero_noise(
             sampling_frequency=sampling_frequency, duration=duration,
             start_time=start_time)
 
-    @property
-    def analysis_window(self):
-        """ The stretch of data analysed with a time-domain likelihood,
-        dict(start_time, duration), or None.
-
-        Set it with :code:`interferometer.analysis_window = (start_time, duration)`,
-        with the GPS start time and the duration in seconds. The data in the
-        window (:code:`analysis_data`) are used by time-domain likelihoods,
-        and the Gohberg-Semencul vectors of the inverse noise covariance matrix
-        are computed for its length.
-        """
-        return self._analysis_window
+    def set_analysis_window(self, start_time, duration, cut_time=None):
+        """ Set the analysis window used by time-domain likelihoods
 
-    @analysis_window.setter
-    def analysis_window(self, window):
-        if window is None:
-            self._analysis_window = None
-            self.meta_data.pop("analysis_window", None)
-            return
-        start_time, duration = window
-        self._analysis_window = dict(start_time=float(start_time), duration=float(duration))
-        self.meta_data["analysis_window"] = dict(self._analysis_window)
-        if self.autocovariance_function is not None and self.autocovariance_function.acf_array is not None:
-            self._set_gohberg_semencul_vectors()
+        Setting it removes the autocovariance function, which must be set after it.
 
-    def _require_analysis_window(self):
-        if self.analysis_window is None:
-            raise ValueError(f"{self.name}: set the analysis window first (analysis_window)")
-        return self.analysis_window["start_time"], self.analysis_window["duration"]
+        Parameters
+        ==========
+        start_time: float
+            The GPS start time of the window
+        duration: float
+            The duration of the window (in s)
+        cut_time: float, optional
+            The GPS time of the inspiral/post-inspiral cut, if any
+        """
+        self.analysis_start_time = float(start_time)
+        self.analysis_duration = float(duration)
+        self.analysis_cut_time = cut_time
+        self.meta_data["analysis_window"] = dict(
+            start_time=self.analysis_start_time, duration=self.analysis_duration, cut_time=cut_time)
+        self.autocovariance_function = None
 
     def condition_strain_data(self, sampling_frequency, trim=0.25, taper_and_trim=True,
                               remove_mean=True):
-        """ Downsample the time-domain strain data around the analysis window.
+        """ Downsample the time-domain strain data around the analysis window
 
-        See :code:`bilby.gw.detector.condition_data.condition_strain_data`.
-        The sample nearest the inspiral/post-inspiral cut time is kept if
-        there is one, otherwise the sample nearest the window start.
+        See :code:`bilby.gw.detector.condition_data.condition_strain_data`; the sample
+        nearest the cut time (or the window start) is kept.
 
         Parameters
         ==========
         sampling_frequency: float
-            New sampling frequency (Hz); must divide the current one.
+            The new sampling frequency (in Hz); must divide the current one
         trim: float
-            Fraction of the data at each end that is removed (default 0.25).
+            The fraction of the data removed at each end
         taper_and_trim: bool
-            Use the Tukey window, buffer and trimming (default True); if
-            False, use :code:`scipy.signal.decimate`.
+            If True, taper, low-pass and trim; if False, use :code:`scipy.signal.decimate`
         remove_mean: bool
-            Subtract the mean of the result (default True).
+            If True, subtract the mean of the result
         """
         from .condition_data import condition_strain_data
-        start_time, duration = self._require_analysis_window()
-        preserve_time = self.meta_data["analysis_window"].get("cut_time")
-        condition_strain_data(self.strain_data, sampling_frequency, start_time, duration,
-                              preserve_time=preserve_time, trim=trim,
+        if self.analysis_duration is None:
+            raise ValueError(f"{self.name}: set the analysis window first (set_analysis_window)")
+        condition_strain_data(self.strain_data, sampling_frequency, self.analysis_start_time,
+                              self.analysis_duration, preserve_time=self.analysis_cut_time, trim=trim,
                               taper_and_trim=taper_and_trim, remove_mean=remove_mean)
 
-    def _analysis_slice(self):
-        """ Slice of the data samples in the analysis window: from the sample
-        nearest to its start time, `duration` x sampling frequency samples. """
-        start_time, duration = self._require_analysis_window()
-        sampling_frequency = self.strain_data.sampling_frequency
-        first = int(np.argmin(abs(self.strain_data.time_array - start_time)))
-        number_of_samples = int(round(duration * sampling_frequency))
-        if first + number_of_samples > len(self.strain_data.time_array) or (
-                abs(self.strain_data.time_array[first] - start_time) > 1 / sampling_frequency):
+    @property
+    def analysis_slice(self):
+        """ The slice of the time-domain strain data in the analysis window """
+        if self.analysis_duration is None:
+            raise ValueError(f"{self.name}: set the analysis window first (set_analysis_window)")
+        first = int(np.argmin(abs(self.time_array - self.analysis_start_time)))
+        last = first + int(round(self.analysis_duration * self.sampling_frequency))
+        if (last > len(self.time_array)
+                or abs(self.time_array[first] - self.analysis_start_time) > 1 / self.sampling_frequency):
             raise ValueError(
-                f"{self.name}: the analysis window ({start_time:.6f} - {start_time + duration:.6f}) "
-                f"is not inside the data ({self.strain_data.start_time:.6f} - "
-                f"{self.strain_data.start_time + self.strain_data.duration:.6f})")
-        return slice(first, first + number_of_samples)
+                f"{self.name}: the analysis window ({self.analysis_start_time:.6f} + {self.analysis_duration:g} s) "
+                f"is not inside the data ({self.start_time:.6f} + {self.duration:g} s)")
+        return slice(first, last)
 
     @property
     def analysis_data(self):
-        """ The time-domain strain data in the analysis window. """
-        return np.asarray(self.strain_data.time_domain_strain, dtype=float)[self._analysis_slice()]
+        """ The time-domain strain data in the analysis window """
+        return self.time_domain_strain[self.analysis_slice]
 
     @property
     def autocovariance_function(self):
-        """ The noise autocovariance function
-        (:code:`bilby.gw.detector.AutoCovarianceFunction`) used by
-        time-domain likelihoods, or None. """
+        """ The noise autocovariance function (:code:`bilby.gw.detector.AutoCovarianceFunction`)
+
+        Setting it computes :code:`gohberg_semencul_vectors`, which give products with
+        the inverse noise covariance matrix of the analysis window.
+        """
         return self._autocovariance_function
 
     @autocovariance_function.setter
     def autocovariance_function(self, autocovariance_function):
-        from .acf import AutoCovarianceFunction
-        if autocovariance_function is not None and not isinstance(
-                autocovariance_function, AutoCovarianceFunction):
-            raise TypeError("autocovariance_function must be a bilby.gw.detector.AutoCovarianceFunction")
-        if autocovariance_function is not None:
-            self._require_analysis_window()
         self._autocovariance_function = autocovariance_function
         self.gohberg_semencul_vectors = None
+        self.meta_data.pop("autocovariance_function", None)
         if autocovariance_function is None:
-            self.meta_data.pop("autocovariance_function", None)
-        else:
-            self.meta_data["autocovariance_function"] = autocovariance_function.meta_data
-            if autocovariance_function.acf_array is not None:
-                self._set_gohberg_semencul_vectors()
-
-    def _set_gohberg_semencul_vectors(self):
-        """ Compute the Gohberg-Semencul vectors (x, y) of the inverse noise
-        covariance matrix for the analysis window and store them in
-        :code:`gohberg_semencul_vectors`. """
-        number_of_samples = int(round(
-            self.analysis_window["duration"] * self.autocovariance_function.sampling_frequency))
-        self.gohberg_semencul_vectors = self.autocovariance_function.gohberg_semencul_vectors(
-            number_of_samples)
+            return
+        if self.analysis_duration is None:
+            raise ValueError(f"{self.name}: set the analysis window first (set_analysis_window)")
+        self.meta_data["autocovariance_function"] = autocovariance_function.meta_data
+        self.gohberg_semencul_vectors = gohberg_semencul_vectors(autocovariance_function.get_acf_array(
+            int(round(self.analysis_duration * autocovariance_function.sampling_frequency))))
 
     def set_autocovariance_function_from_power_spectral_density(
             self, minimum_frequency=None, maximum_frequency=None, sampling_frequency=None,
             duration_factor=16, fill_value=None, fill_multiplier=1e4):
         """ Set the autocovariance function from the power spectral density
-        of this interferometer.
 
-        The power spectral density is evaluated at 0, df, ..., f_s / 2, with
-        df = 1 / (`duration_factor` x the duration of the analysis window), and
-        passed to :code:`AutoCovarianceFunction.from_power_spectral_density_array`.
+        See :code:`bilby.gw.detector.AutoCovarianceFunction.from_power_spectral_density_array`.
+        The power spectral density is evaluated with a frequency spacing of
+        1 / (`duration_factor` x the duration of the analysis window).
 
         Parameters
         ==========
         minimum_frequency: float, optional
-            Lower edge of the frequency band (Hz). Default: the
-            interferometer's minimum_frequency.
+            The lower edge of the frequency band (in Hz), default: :code:`self.minimum_frequency`
         maximum_frequency: float, optional
-            Upper edge of the frequency band (Hz). Default: the
-            interferometer's maximum_frequency.
+            The upper edge of the frequency band (in Hz), default: :code:`self.maximum_frequency`
         sampling_frequency: float, optional
-            Sampling frequency (Hz). Default: the sampling frequency of the
-            strain data, or 2048 Hz if no data are set.
+            The sampling frequency (in Hz), default: that of the strain data
         duration_factor: float
-            Duration of the ACF divided by the duration of the analysis
-            window (default 16).
+            The duration of the autocovariance function divided by that of the analysis window
         fill_value: float, optional
-            PSD value used outside the band (strain^2 / Hz). Overrides
-            `fill_multiplier`.
+            The PSD value used outside the band; overrides `fill_multiplier`
         fill_multiplier: float
-            Multiple of the maximum in-band PSD used outside the band if
-            `fill_value` is not given (default 1e4).
+            The multiple of the maximum in-band PSD used outside the band
         """
         from .acf import AutoCovarianceFunction
-        _, duration = self._require_analysis_window()
+        if self.analysis_duration is None:
+            raise ValueError(f"{self.name}: set the analysis window first (set_analysis_window)")
         if sampling_frequency is None:
             sampling_frequency = self.strain_data.sampling_frequency or 2048
         if minimum_frequency is None:
             minimum_frequency = self.minimum_frequency
         if maximum_frequency is None:
             maximum_frequency = self.maximum_frequency
-        delta_f = 1 / (duration_factor * duration)
+        delta_f = 1 / (duration_factor * self.analysis_duration)
         frequency_array = np.arange(int(round(sampling_frequency / 2 / delta_f)) + 1) * delta_f
         with np.errstate(invalid="ignore", divide="ignore"):
             psd_array = self.power_spectral_density.get_power_spectral_density_array(frequency_array)
@@ -529,34 +503,27 @@ def get_detector_response(self, waveform_polarizations, parameters, frequencies=
         return signal_ifo
 
     def get_time_domain_detector_response(self, waveform_polarizations, parameters,
-                                          placement="nearest"):
-        """ Get the time-domain detector response for a particular waveform,
-        on the samples of the analysis window.
-
-        The polarizations are projected with the antenna patterns and placed
-        so that the model's t=0 arrives at geocent_time plus the time delay
-        from the geocenter. Waveform samples outside the analysis window are
-        dropped.
+                                          placement="nearest", times=None):
+        """ Get the time-domain detector response for a particular waveform
 
         Parameters
         ==========
         waveform_polarizations: dict
-            Output of a time-domain source model (e.g.
-            :code:`bilby.gw.source.lal_binary_black_hole_time_domain`): the
-            polarizations on their own time grid and 'epoch', the time of
-            their first sample relative to the model's t=0.
+            Output of a time-domain source model, e.g.
+            :code:`bilby.gw.source.lal_binary_black_hole_time_domain`
         parameters: dict
-            Parameters describing position and time of arrival of the signal.
+            Parameters describing position and time of arrival of the signal
         placement: str
-            "nearest" (default) or "fd_shift" (see
-            :code:`bilby.gw.time_domain_utils.place_time_domain_signal`), or
-            "model_time": the polarizations are evaluated at this
-            detector's data samples (needs a model-time source model, e.g.
-            :code:`bilby.gw.source.lal_binary_black_hole_model_time`).
+            How the waveform is placed on the data samples: "nearest" or "fd_shift"
+            (see :code:`bilby.gw.time_domain_utils.place_time_domain_signal`), or
+            "model_time" for a model-time source model, e.g.
+            :code:`bilby.gw.source.lal_binary_black_hole_model_time`
+        times: array_like, optional
+            The data sample times, default: those of the analysis window
 
         Returns
         =======
-        array_like: The detector signal on the samples of the analysis window.
+        array_like: The detector response at `times` (None if a model-time waveform failed)
 
         Notes
         =====
@@ -564,17 +531,8 @@ def get_time_domain_detector_response(self, waveform_polarizations, parameters,
         used to set the time at which the antenna response is evaluated,
         otherwise the provided :code:`parameters["geocent_time"]` is used.
         """
-        analysis_slice = self._analysis_slice()
-        return self._time_domain_detector_response(
-            waveform_polarizations, parameters, self.strain_data.time_array[analysis_slice.start],
-            analysis_slice.stop - analysis_slice.start, placement)
-
-    def _time_domain_detector_response(self, waveform_polarizations, parameters, start_time,
-                                       number_of_samples, placement):
-        """ Detector response on `number_of_samples` data samples starting
-        at `start_time`; see :code:`get_time_domain_detector_response`.
-        Returns None if a model-time waveform failed (catch_waveform_errors). """
-        sampling_frequency = self.strain_data.sampling_frequency
+        if times is None:
+            times = self.time_array[self.analysis_slice]
         model_time = "polarizations_at" in waveform_polarizations
         if model_time != (placement == "model_time"):
             raise ValueError(
@@ -591,10 +549,8 @@ def _time_domain_detector_response(self, waveform_polarizations, parameters, sta
             parameters['ra'], parameters['dec'], parameters['geocent_time'])
 
         if model_time:
-            times = times_from_merger(
-                start_time, number_of_samples, sampling_frequency,
-                parameters['geocent_time'], time_shift)
-            polarizations = waveform_polarizations["polarizations_at"](times)
+            polarizations = waveform_polarizations["polarizations_at"](times_from_merger(
+                times[0], len(times), self.sampling_frequency, parameters['geocent_time'], time_shift))
             if polarizations is None:
                 return None
         else:
@@ -610,47 +566,42 @@ def _time_domain_detector_response(self, waveform_polarizations, parameters, sta
         if model_time:
             return signal_ifo
 
-        merger_index = -waveform_polarizations["epoch"] * sampling_frequency
         # Be careful to first subtract the two GPS times which are ~1e9 sec.
         # And then add the time_shift which varies at ~1e-5 sec
-        dt_geocent = parameters['geocent_time'] - start_time
-        arrival_index = (dt_geocent + time_shift) * sampling_frequency
-
+        dt_geocent = parameters['geocent_time'] - times[0]
         return place_time_domain_signal(
-            signal_ifo, merger_index=merger_index, arrival_index=arrival_index,
-            number_of_samples=number_of_samples, placement=placement)
+            signal_ifo, merger_index=-waveform_polarizations["epoch"] * self.sampling_frequency,
+            arrival_index=(dt_geocent + time_shift) * self.sampling_frequency,
+            number_of_samples=len(times), placement=placement)
 
     def inject_signal_time_domain(self, parameters, injection_polarizations=None,
                                   waveform_generator=None, placement="nearest"):
-        """ Inject a time-domain signal into the time-domain strain data.
-
-        The detector signal is projected and placed as in
-        :code:`get_time_domain_detector_response` and added to all of the
-        stored time series; parts of the signal outside the data are dropped.
-        The optimal and matched-filter SNRs in the analysis window are stored
-        in :code:`meta_data`; the analysis window and the autocovariance
-        function must be set first.
-        Provide the injection parameters and either the injection
-        polarizations or the waveform generator; the injection polarizations
-        are used if both are given.
+        """ General time-domain signal injection method.
+        Provide the injection parameters and either the injection polarizations
+        or the waveform generator to inject a signal into the time-domain strain
+        data. Defaults to the injection polarizations if both are given.
 
         Parameters
         ==========
         parameters: dict
             Parameters of the injection.
         injection_polarizations: dict, optional
-            Output of :code:`waveform_generator.time_domain_strain()` for a
-            time-domain source model.
+           Polarizations of waveform to inject, output of
+           `waveform_generator.time_domain_strain()`. If
+           `waveform_generator` is also given, the injection_polarizations will
+           be calculated directly and this argument can be ignored.
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator, optional
-            A WaveformGenerator with a time-domain source model, e.g.
-            :code:`bilby.gw.source.lal_binary_black_hole_time_domain`.
+            A WaveformGenerator instance using the time-domain source model to
+            inject. If `injection_polarizations` is given, this will be ignored.
         placement: str
-            "nearest" (default), "fd_shift" or "model_time"; see
-            :code:`get_time_domain_detector_response`.
+            "nearest", "fd_shift" or "model_time"; see
+            :code:`get_time_domain_detector_response`
 
         Returns
         =======
         injection_polarizations: dict
+            The injected polarizations. This is the same as the injection_polarizations parameters
+            if it was passed in. Otherwise it is the return value of waveform_generator.time_domain_strain().
         """
         if injection_polarizations is None and waveform_generator is None:
             raise ValueError(
@@ -658,8 +609,7 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
                 "injection_polarizations.")
         elif injection_polarizations is not None:
             self.inject_signal_time_domain_from_waveform_polarizations(
-                parameters=parameters, injection_polarizations=injection_polarizations,
-                placement=placement)
+                parameters=parameters, injection_polarizations=injection_polarizations, placement=placement)
         elif waveform_generator is not None:
             injection_polarizations = self.inject_signal_time_domain_from_waveform_generator(
                 parameters=parameters, waveform_generator=waveform_generator, placement=placement)
@@ -667,67 +617,65 @@ def inject_signal_time_domain(self, parameters, injection_polarizations=None,
 
     def inject_signal_time_domain_from_waveform_generator(self, parameters, waveform_generator,
                                                           placement="nearest"):
-        """ Inject a time-domain signal using a waveform generator and a set
-        of parameters. See :code:`inject_signal_time_domain`.
+        """ Inject a time-domain signal using a waveform generator and a set of parameters.
+        Alternative to `inject_signal_time_domain` and
+        `inject_signal_time_domain_from_waveform_polarizations`
 
         Parameters
         ==========
         parameters: dict
             Parameters of the injection.
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
-            A WaveformGenerator with a time-domain source model.
+            A WaveformGenerator instance using the time-domain source model to inject.
         placement: str
-            "nearest" (default), "fd_shift" or "model_time".
+            "nearest", "fd_shift" or "model_time"
 
         Returns
         =======
         injection_polarizations: dict
+            The internally generated injection parameters
         """
-        if waveform_generator.time_domain_source_model is None:
-            raise ValueError("inject_signal_time_domain needs a waveform generator with a "
-                             "time_domain_source_model")
-        injection_polarizations = waveform_generator.time_domain_strain(parameters)
+        injection_polarizations = \
+            waveform_generator.time_domain_strain(parameters)
         self.inject_signal_time_domain_from_waveform_polarizations(
-            parameters=parameters, injection_polarizations=injection_polarizations,
-            placement=placement)
+            parameters=parameters, injection_polarizations=injection_polarizations, placement=placement)
         return injection_polarizations
 
     def inject_signal_time_domain_from_waveform_polarizations(self, parameters, injection_polarizations,
                                                               placement="nearest"):
-        """ Inject a time-domain signal from a dict of waveform polarizations.
-        See :code:`inject_signal_time_domain`.
+        """ Inject a time-domain signal into the detector from a dict of waveform polarizations.
+        Alternative to `inject_signal_time_domain` and
+        `inject_signal_time_domain_from_waveform_generator`.
 
         Parameters
         ==========
         parameters: dict
             Parameters of the injection.
         injection_polarizations: dict
-            Output of a time-domain source model (polarizations and 'epoch').
+           Polarizations of waveform to inject, output of
+           `waveform_generator.time_domain_strain()`.
         placement: str
-            "nearest" (default), "fd_shift" or "model_time".
+            "nearest", "fd_shift" or "model_time"
         """
-        if not self.strain_data.time_within_data(parameters['geocent_time']):
-            logger.warning(
-                'Injecting signal outside segment, start_time={}, merger time={}.'
-                .format(self.strain_data.start_time, parameters['geocent_time']))
         if "epoch" not in injection_polarizations and "polarizations_at" not in injection_polarizations:
             raise ValueError("injection_polarizations must come from a time-domain source model "
                              "(with an 'epoch' or 'polarizations_at' entry)")
         if self.gohberg_semencul_vectors is None:
             raise ValueError(f"{self.name}: set the autocovariance function before injecting")
+        if not self.strain_data.time_within_data(parameters['geocent_time']):
+            logger.warning(
+                'Injecting signal outside segment, start_time={}, merger time={}.'
+                .format(self.strain_data.start_time, parameters['geocent_time']))
 
-        signal_ifo = self._time_domain_detector_response(
-            injection_polarizations, parameters, self.strain_data.start_time,
-            len(self.strain_data.time_domain_strain), placement)
+        signal_ifo = self.get_time_domain_detector_response(
+            injection_polarizations, parameters, placement=placement, times=self.time_array)
         if signal_ifo is None:
             raise ValueError(f"{self.name}: the injection waveform failed")
-        self.strain_data._time_domain_strain = (
-            np.array(self.strain_data.time_domain_strain, dtype=float) + signal_ifo)
+        self.strain_data._time_domain_strain = self.time_domain_strain + signal_ifo
         self.strain_data._frequency_domain_strain = None
 
-        signal = signal_ifo[self._analysis_slice()]
-        x, y = self.gohberg_semencul_vectors
-        inverse_covariance_signal = gohberg_semencul_product(x, y, signal)
+        signal = signal_ifo[self.analysis_slice]
+        inverse_covariance_signal = gohberg_semencul_product(*self.gohberg_semencul_vectors, signal)
         self.meta_data['optimal_SNR'] = float(np.dot(signal, inverse_covariance_signal)) ** 0.5
         self.meta_data['matched_filter_SNR'] = float(
             np.dot(self.analysis_data, inverse_covariance_signal)) / self.meta_data['optimal_SNR']
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index ba5b5f163..6ef785588 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -61,7 +61,7 @@ def _check_interferometers(self):
         If both checks fail, then a ValueError is raised.
         """
         consistent_attributes = ["duration", "start_time", "sampling_frequency"]
-        if len(self) > 0 and all(getattr(ifo, "analysis_window", None) is not None for ifo in self):
+        if all(interferometer.analysis_duration is not None for interferometer in self):
             # time-domain analysis windows can start at different times in each detector
             consistent_attributes = ["duration", "sampling_frequency"]
         for attribute in consistent_attributes:
@@ -203,91 +203,53 @@ def inject_signal(
 
     def set_analysis_windows(self, duration, start_time=None, analysis_segment="imr",
                              segment_cut_time=None, cut_reference_parameters=None):
-        """ Set the analysis window of each detector.
+        """ Set the analysis window of each interferometer
 
-        For "imr" every detector is given [`start_time`, `start_time` +
-        `duration`). For "inspiral" and "post_inspiral" the window of each
-        detector ends or starts at its cut time
-
-        .. math::
-
-            t_{\\\\rm cut} = t_c + \\\\Delta t_{\\\\rm ifo}(\\\\alpha, \\\\delta) + \\\\tau_{\\\\rm cut},
-
-        where :math:`t_c`, :math:`\\\\alpha` and :math:`\\\\delta` are the
-        geocent_time, ra and dec in `cut_reference_parameters`,
-        :math:`\\\\Delta t_{\\\\rm ifo}` is the time delay from the geocenter and
-        :math:`\\\\tau_{\\\\rm cut}` is `segment_cut_time`. All detectors have the
-        same `duration`.
+        For "imr", every interferometer gets the window [`start_time`,
+        `start_time` + `duration`). For "inspiral" ("post_inspiral"), the window of
+        each interferometer ends (starts) at its cut time: `segment_cut_time` after
+        the arrival of the merger, at the `geocent_time`, `ra` and `dec` in
+        `cut_reference_parameters`.
 
         Parameters
         ==========
         duration: float
-            Duration of the analysis window (s).
+            The duration of the windows (in s)
         start_time: float, optional
-            GPS start time of the window (s). Required for "imr".
+            The GPS start time of the windows; required for "imr"
         analysis_segment: str
-            "imr" (default), "inspiral" (the window ends at the cut) or
-            "post_inspiral" (the window starts at the cut).
+            "imr", "inspiral" or "post_inspiral"
         segment_cut_time: float, optional
-            Cut time relative to the arrival of the merger at each detector
-            (s). Required for "inspiral" and "post_inspiral".
+            The cut time relative to the merger (in s); required for "inspiral" and "post_inspiral"
         cut_reference_parameters: dict, optional
-            Dictionary with 'geocent_time', 'ra' and 'dec' fixing the cut
-            time. Required for "inspiral" and "post_inspiral".
+            Dictionary with `geocent_time`, `ra` and `dec`; required for "inspiral" and "post_inspiral"
         """
+        if analysis_segment not in ("imr", "inspiral", "post_inspiral"):
+            raise ValueError(
+                "analysis_segment must be 'imr', 'inspiral' or 'post_inspiral', "
+                f"not {analysis_segment!r}")
         for interferometer in self:
-            if analysis_segment == "imr":
-                window_start = start_time
-                cut_time = None
-            elif analysis_segment in ("inspiral", "post_inspiral"):
-                reference = cut_reference_parameters
-                delay = interferometer.time_delay_from_geocenter(
-                    reference["ra"], reference["dec"], reference["geocent_time"])
-                cut_time = reference["geocent_time"] + delay + segment_cut_time
+            window_start = start_time
+            cut_time = None
+            if analysis_segment != "imr":
+                cut_time = cut_reference_parameters["geocent_time"] + segment_cut_time + \
+                    interferometer.time_delay_from_geocenter(
+                        cut_reference_parameters["ra"], cut_reference_parameters["dec"],
+                        cut_reference_parameters["geocent_time"])
                 window_start = cut_time - duration if analysis_segment == "inspiral" else cut_time
-            else:
-                raise ValueError(
-                    "analysis_segment must be 'imr', 'inspiral' or 'post_inspiral', "
-                    f"not {analysis_segment!r}")
-            interferometer.analysis_window = (window_start, duration)
+            interferometer.set_analysis_window(window_start, duration, cut_time)
             interferometer.meta_data["analysis_window"].update(
-                analysis_segment=analysis_segment, segment_cut_time=segment_cut_time,
-                cut_time=cut_time)
+                analysis_segment=analysis_segment, segment_cut_time=segment_cut_time)
 
     def set_autocovariance_functions_from_power_spectral_densities(self, **kwargs):
-        """Set the autocovariance function of each detector from its power
-        spectral density.
+        """ Set the autocovariance function of each interferometer from its power spectral density
 
-        See :py:meth:`bilby.gw.detector.Interferometer.set_autocovariance_function_from_power_spectral_density`
+        See :code:`bilby.gw.detector.Interferometer.set_autocovariance_function_from_power_spectral_density`
         for the keyword arguments.
         """
         for interferometer in self:
             interferometer.set_autocovariance_function_from_power_spectral_density(**kwargs)
 
-    def condition_strain_data(self, sampling_frequency, trim=0.25, taper_and_trim=True,
-                              remove_mean=True):
-        """Downsample the time-domain strain data of each detector around its
-        analysis window.
-
-        See :py:meth:`bilby.gw.detector.Interferometer.condition_strain_data`.
-
-        Parameters
-        ==========
-        sampling_frequency: float
-            The new sampling frequency (Hz).
-        trim: float
-            Fraction of the data at each end that is removed (default 0.25).
-        taper_and_trim: bool
-            Use the Tukey window, buffer and trimming (default True); if
-            False, use :code:`scipy.signal.decimate`.
-        remove_mean: bool
-            Subtract the mean of the result (default True).
-        """
-        for interferometer in self:
-            interferometer.condition_strain_data(
-                sampling_frequency, trim=trim, taper_and_trim=taper_and_trim,
-                remove_mean=remove_mean)
-
     def inject_signal_time_domain(
         self,
         parameters=None,
@@ -295,35 +257,30 @@ def inject_signal_time_domain(
         waveform_generator=None,
         placement="nearest",
     ):
-        """ Inject a time-domain signal into the time-domain strain data of each
-        detector (no Fourier transform, frequency mask or window).
+        """ Inject a time-domain signal into the time-domain strain data of each interferometer.
 
         Parameters
         ==========
         parameters: dict
             Parameters of the injection.
         injection_polarizations: dict
-           Output of `waveform_generator.time_domain_strain()` for a time-domain
-           source model. If `waveform_generator` is also given, this is used.
+           Polarizations of waveform to inject, output of
+           `waveform_generator.time_domain_strain()`. If
+           `waveform_generator` is also given, the injection_polarizations will
+           be calculated directly and this argument can be ignored.
         waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
-            A WaveformGenerator with a time-domain source model. The waveform is
-            generated once and projected onto every detector (for
-            placement="model_time", it is evaluated at each detector's samples).
+            A WaveformGenerator instance using the time-domain source model to
+            inject. If `injection_polarizations` is given, this will be ignored.
         placement: str
-            "nearest" (default), "fd_shift" or "model_time"; see
-            :code:`bilby.gw.detector.Interferometer.get_time_domain_detector_response`.
+            "nearest", "fd_shift" or "model_time"; see
+            :code:`bilby.gw.detector.Interferometer.get_time_domain_detector_response`
 
         Returns
         =======
-        injection_polarizations: list
-            One dict per detector (the same polarizations for each).
+        injection_polarizations: dict
         """
         if injection_polarizations is None:
             if waveform_generator is not None:
-                if waveform_generator.time_domain_source_model is None:
-                    raise ValueError(
-                        "inject_signal_time_domain needs a waveform generator with "
-                        "a time_domain_source_model")
                 injection_polarizations = waveform_generator.time_domain_strain(
                     parameters
                 )
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index e26e266f1..49251faa0 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -3,77 +3,71 @@
 import numpy as np
 
 from ...core.utils import logger
-from ..time_domain_utils import gohberg_semencul_product
+from ..time_domain_utils import gohberg_semencul_product, time_domain_start_frequency
 from .base import GravitationalWaveTransient
 
 
 class TimeDomainGravitationalWaveTransient(GravitationalWaveTransient):
-    """ A gravitational-wave transient likelihood evaluated in the time domain.
+    """ A gravitational-wave transient likelihood object evaluated in the time domain
 
-    The noise in each interferometer is a stationary Gaussian process with
-    covariance matrix :math:`C_{ij} = \\rho(|i - j|)`, where :math:`\\rho` is
-    the autocovariance function (ACF) of the interferometer. For the data in
-    the analysis window, :math:`d` (:code:`interferometer.analysis_data`), and
-    a template :math:`h` on the same samples
-
-    .. math::
-
-        \\ln \\mathcal{L} = \\sum_{\\rm ifo} \\left[ d^T C^{-1} h
-        - \\frac{1}{2} h^T C^{-1} h - \\frac{1}{2} d^T C^{-1} d \\right].
-
-    :code:`log_likelihood_ratio` returns the first two terms and
-    :code:`noise_log_likelihood` the last. Products with :math:`C^{-1}` are
-    computed from the Gohberg-Semencul vectors stored on each interferometer
-    (:code:`interferometer.gohberg_semencul_vectors`), without forming
-    :math:`C^{-1}`.
-
-    The template is projected onto each interferometer and placed so that the
-    model's t=0 arrives at geocent_time plus the time delay from the
-    geocenter. Template samples outside the analysis window are dropped.
+    It computes the log-likelihood of the data in the analysis window of each
+    interferometer, assuming stationary colored Gaussian noise described by an
+    autocovariance function, as in time-domain ringdown analyses (Carullo et al.
+    arXiv:1902.07527, Isi & Farr arXiv:2107.05609). Products with the inverse
+    noise covariance matrix use the Gohberg-Semencul formula. See Sharma et al.
+    arXiv:2601.11239.
 
     Parameters
     ==========
     interferometers: list, bilby.gw.detector.InterferometerList
-        A list of :code:`bilby.gw.detector.Interferometer` instances, each with
-        an analysis window, time-domain strain data covering it and an
-        autocovariance function.
-    waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
-        A WaveformGenerator with a time-domain source model, e.g.
-        :code:`bilby.gw.source.lal_binary_black_hole_time_domain`.
+        A list of `bilby.detector.Interferometer` instances - contains the
+        detector data, analysis windows and autocovariance functions
+    waveform_generator: `bilby.waveform_generator.WaveformGenerator`
+        An object which computes the time-domain strain of the signal,
+        given some set of parameters
     distance_marginalization: bool, optional
-        If true, marginalize over distance in the likelihood. This uses a
-        look up table calculated at run time. The distance prior is set to be a
-        delta function at the minimum distance allowed in the prior being
-        marginalised over.
+        If true, marginalize over distance in the likelihood.
+        This uses a look up table calculated at run time.
+        The distance prior is set to be a delta function at the minimum
+        distance allowed in the prior being marginalised over.
     priors: dict, optional
         If given, used in the distance marginalization.
     distance_marginalization_lookup_table: (dict, str), optional
         If a dict, dictionary containing the lookup_table, distance_array,
         (distance) prior_array, and reference_distance used to construct
-        the table. If a string the name of a file containing these quantities.
-        The lookup table is stored after construction in either the provided
-        string or a default location: '.distance_marginalization_lookup_dmin{}_dmax{}_n{}.npz'
+        the table.
+        If a string the name of a file containing these quantities.
+        The lookup table is stored after construction in either the
+        provided string or a default location:
+        '.distance_marginalization_lookup_dmin{}_dmax{}_n{}.npz'
     reference_frame: (str, bilby.gw.detector.InterferometerList, list), optional
-        Definition of the reference frame for the sky location, as in
-        :code:`GravitationalWaveTransient`.
+        Definition of the reference frame for the sky location.
+
+        - :code:`sky`: sample in RA/dec, this is the default
+        - e.g., :code:`"H1L1", ["H1", "L1"], InterferometerList(["H1", "L1"])`:
+          sample in azimuth and zenith, `azimuth` and `zenith` defined in the
+          frame where the z-axis is aligned the the vector connecting H1
+          and L1.
+
     time_reference: str, optional
-        Name of the reference for the sampled time parameter, as in
-        :code:`GravitationalWaveTransient`.
+        Name of the reference for the sampled time parameter.
+
+        - :code:`geocent`/:code:`geocenter`: sample in the time at the
+          Earth's center, this is the default
+        - e.g., :code:`H1`: sample in the time of arrival at H1
+
     placement: str, optional
-        How the template is placed on the data samples: "nearest" (default)
-        or "fd_shift" (see :code:`bilby.gw.time_domain_utils.place_time_domain_signal`),
-        or "model_time": the waveform is evaluated at each detector's data
-        samples, without a taper (needs a model-time source model, e.g.
-        :code:`bilby.gw.source.lal_binary_black_hole_model_time`).
-        Use the same placement for injection and analysis.
-    time_marginalization, phase_marginalization, calibration_marginalization: bool
-        Not implemented for this likelihood; must be False.
+        How the waveform is placed on the data samples: "nearest" (default),
+        "fd_shift" or "model_time"; see
+        :code:`bilby.gw.detector.Interferometer.get_time_domain_detector_response`
+    time_marginalization, phase_marginalization, calibration_marginalization: bool, optional
+        Not implemented for this likelihood; must be False
 
     Returns
     =======
     Likelihood: `bilby.core.likelihood.Likelihood`
         A likelihood object, able to compute the likelihood of the data given
-        some model parameters.
+        some model parameters
     """
 
     likelihood_domain = "time"
@@ -124,8 +118,8 @@ def __repr__(self):
                 self.priors, self.placement))
 
     def _check_minimum_frequency(self):
-        """ Warn if the waveform's minimum_frequency differs from an
-        interferometer's minimum_frequency. """
+        """ Warn if the minimum frequency of the waveform and of an interferometer differ,
+        and log the start frequency of the waveforms """
         waveform_minimum_frequency = getattr(
             self.waveform_generator, "waveform_arguments", dict()).get("minimum_frequency")
         if waveform_minimum_frequency is None:
@@ -135,9 +129,15 @@ def _check_minimum_frequency(self):
                 logger.warning(
                     f"{interferometer.name}: minimum_frequency {interferometer.minimum_frequency:g} Hz "
                     f"differs from the waveform's minimum_frequency {waveform_minimum_frequency:g} Hz")
+        arguments = self.waveform_generator.waveform_arguments
+        if arguments.get("start_at_higher_mode_frequency", True) and "waveform_approximant" in arguments:
+            start_frequency = time_domain_start_frequency(
+                waveform_minimum_frequency, arguments["waveform_approximant"], arguments.get("mode_array"))
+            logger.info(f"Waveforms start at {start_frequency:g} Hz, so that their modes with l <= 4 "
+                        f"are present from {waveform_minimum_frequency:g} Hz")
 
     def _setup_noise_model(self):
-        """ d^T C^-1 and d^T C^-1 d for each interferometer. """
+        """ Compute and store C^-1 d and d^T C^-1 d for each interferometer """
         self._data_times_inverse_covariance = dict()
         self._data_inverse_covariance_data = dict()
         for interferometer in self.interferometers:
@@ -158,40 +158,39 @@ def _setup_noise_model(self):
                 np.dot(data_times_inverse_covariance, data))
 
     def _compute_full_waveform(self, signal_polarizations, interferometer, parameters):
-        """ Project the time-domain polarizations onto the interferometer and
-        place them on the samples of its analysis window.
+        """ Project the waveform polarizations onto the interferometer and place them
+        on the samples of its analysis window.
 
         Parameters
         ==========
         signal_polarizations: dict
-            Output of the time-domain source model (polarizations and 'epoch').
+            Output of the time-domain source model
         interferometer: bilby.gw.detector.Interferometer
+            Interferometer to compute the response with respect to.
         parameters: dict
-
-        Returns
-        =======
-        array_like: The template on the samples of the analysis window.
+            The parameters of the signal
         """
         return interferometer.get_time_domain_detector_response(
             signal_polarizations, parameters, placement=self.placement)
 
     def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array=True, parameters):
-        """ Compute :math:`d^T C^{-1} h`, :math:`h^T C^{-1} h` and the matched
-        filter SNR in the analysis window of one interferometer.
+        """ Compute the snrs
 
         Parameters
-        ----------
+        ==========
         waveform_polarizations: dict
-            Output of the time-domain source model.
+            A dictionary of waveform polarizations and the corresponding array
         interferometer: bilby.gw.detector.Interferometer
+            The bilby interferometer object
         return_array: bool
-            Unused (no time or calibration marginalization); kept for the
-            :code:`GravitationalWaveTransient` interface.
+            Not used; kept for the :code:`GravitationalWaveTransient` interface
         parameters: dict
+            The parameters of the signal
 
         Returns
-        -------
-        calculated_snrs: _CalculatedSNRs, or None if a model-time waveform failed
+        =======
+        calculated_snrs: _CalculatedSNRs
+            An object containing the SNR quantities (None if a model-time waveform failed)
         """
         signal = self._compute_full_waveform(
             signal_polarizations=waveform_polarizations,
@@ -252,13 +251,11 @@ def compute_per_detector_log_likelihood(self, parameters):
                 self.compute_log_likelihood_from_snrs(per_detector_snr, parameters=parameters))
         return parameters.copy()
 
-    # ------------------------------------------------------------------
-    # Reconstruction of marginalized parameters
-    # ------------------------------------------------------------------
     def generate_posterior_sample_from_marginalized_likelihood(self, parameters):
-        """ Reconstruct the distance posterior from a run which used the
-        distance-marginalized likelihood (Eq. (C29-C32) of
-        https://arxiv.org/abs/1809.02293).
+        """ Reconstruct the distance posterior from a run which used a likelihood
+        which explicitly marginalised over distance.
+
+        See Eq. (C29-C32) of https://arxiv.org/abs/1809.02293
 
         Returns
         =======
@@ -273,14 +270,18 @@ def generate_posterior_sample_from_marginalized_likelihood(self, parameters):
 
     def generate_distance_sample_from_marginalized_likelihood(
             self, signal_polarizations=None, *, parameters):
-        """ Generate a single sample from the posterior distribution for
-        luminosity distance when using the distance-marginalized likelihood.
+        """ Generate a single sample from the posterior distribution for luminosity
+        distance when using a likelihood which explicitly marginalises over
+        distance.
+
+        See Eq. (C29-C32) of https://arxiv.org/abs/1809.02293
 
         Parameters
         ==========
         signal_polarizations: dict, optional
-            Output of the time-domain source model. These are rescaled in place
-            after the distance sample is generated.
+            Polarizations modes of the template.
+            Note: These are rescaled in place after the distance sample is
+            generated to allow further parameter reconstruction to occur.
 
         Returns
         =======
diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index c55b63158..4d02b383b 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -5,100 +5,46 @@
 
 from ...core.utils import gravitational_constant, logger, solar_mass, speed_of_light
 from ..conversion import component_masses_to_chirp_mass
-from ..time_domain_utils import gohberg_semencul_product, times_from_merger
+from ..time_domain_utils import gohberg_semencul_product, time_domain_start_frequency, times_from_merger
 from .relative import RelativeBinningGravitationalWaveTransient
 from .time_domain import TimeDomainGravitationalWaveTransient
 
 
 class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWaveTransient):
-    """ A time-domain gravitational-wave transient likelihood which uses
-    heterodyning (relative binning in time) to calculate a fast likelihood,
-    for IMRPhenomT, IMRPhenomTHM, IMRPhenomTP and IMRPhenomTPHM. See Sharma et
-    al. arXiv:2601.11239 and, in the frequency domain, Zackay et al.
-    arXiv:1806.08792 and :code:`RelativeBinningGravitationalWaveTransient`.
+    """ A time-domain gravitational-wave transient likelihood object which uses
+    heterodyning (relative binning) to calculate a fast likelihood, for the
+    IMRPhenomT, IMRPhenomTHM, IMRPhenomTP and IMRPhenomTPHM waveform models.
 
-    The waveform is written as (see
-    :code:`bilby.gw.model_time_waveforms.heterodyning_terms_at_model_times`)
-
-    .. math::
-
-        h_+ - i h_\\times = \\sum_{\\ell m} \\left[ Z_{\\ell m}(t) h_{\\ell m}(t)
-        + \\bar{Z}_{\\ell m}(t) h_{\\ell m}^*(t) \\right],
-
-    with :math:`h_{\\ell m}` the modes with m >= 0 (co-precessing modes for
-    IMRPhenomTP/TPHM), so that the signal in an interferometer is
-
-    .. math::
-
-        s(t_j) = \\Re \\sum_{\\ell m} \\tilde{r}_{\\ell m}(t_j)\\, h^0_{\\ell m}(t_j),\\qquad
-        \\tilde{r}_{\\ell m} = \\frac{h_{\\ell m}}{h^0_{\\ell m}}
-        \\left[ F Z_{\\ell m} + (F \\bar{Z}_{\\ell m})^* \\right],\\quad F = F_+ + i F_\\times,
-
-    where :math:`h^0_{\\ell m}` are the modes of the fiducial waveform at the
-    data samples. :math:`\\tilde{r}_{\\ell m}` is evaluated at the edges of time
-    bins and taken to be linear in each bin b,
-    :math:`\\tilde{r}_{\\ell m} = \\tilde{r}_{\\ell m,0}(b) + \\tilde{r}_{\\ell m,1}(b) (t - t_b)`.
-    With :math:`v = (\\Re \\tilde{r}, \\Im \\tilde{r})`, :math:`s = V v`, where the
-    columns of V are :math:`\\Re(h^0_{\\ell m} (t - t_b)^p)` and
-    :math:`-\\Im(h^0_{\\ell m} (t - t_b)^p)` in each bin, so that
-
-    .. math::
-
-        \\langle d, s \\rangle = a \\cdot v,\\quad a = V^T C^{-1} d,\\qquad
-        \\langle s, s \\rangle = v^T S v,\\quad S = V^T C^{-1} V,
-
-    without the terms quadratic in the slopes :math:`\\tilde{r}_{\\ell m,1}` (as in
-    Sharma et al.); a contains :math:`A_0, A_1` and S the B matrices of
-    Sharma et al., for all modes.
-
-    The waveform is evaluated only at the bin edges, with one waveform call for
-    all interferometers.
-
-    The waveforms switch on abruptly at their minimum frequency, so their
-    ratios are smooth only where both are on. The bins cover the whole
-    analysis window, and here:
-
-    - the fiducial waveform starts before the window (its minimum frequency
-      is derived from the chirp mass and the start of the window, or
-      given), and after its ringdown each of its
-      modes is held at its last non-zero value, so it is non-zero everywhere
-      in the window;
-    - the waveforms at sampled parameters start at
-      :code:`sampled_minimum_frequency` (default: 2 Hz below the
-      interferometers' minimum_frequency), a few cycles before the waveforms
-      reach it.
-
-    With the interferometers' minimum_frequency at or below the frequency of
-    the signal at the start of the analysis window, every waveform (injected,
-    fiducial and sampled) is then on in the whole window.
-
-    The waveform's :code:`minimum_frequency` argument is not used by this
-    likelihood (it is for the injection and the exact likelihood).
+    The waveform is evaluated only at the edges of time bins, and the
+    likelihood is computed from summary data built from a fiducial waveform.
+    See Sharma et al. arXiv:2601.11239, and Cornish arXiv:1007.4820 and
+    Zackay et al. arXiv:1806.08792 for the frequency-domain method.
 
     Parameters
-    ----------
+    ==========
     interferometers: list, bilby.gw.detector.InterferometerList
-        As for :code:`TimeDomainGravitationalWaveTransient`.
-    waveform_generator: bilby.gw.waveform_generator.WaveformGenerator
+        A list of `bilby.detector.Interferometer` instances - contains the
+        detector data, analysis windows ("imr", "inspiral" or "post_inspiral")
+        and autocovariance functions
+    waveform_generator: `bilby.waveform_generator.WaveformGenerator`
         A WaveformGenerator with
         :code:`bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning`
-        as its time-domain source model.
+        as its time-domain source model
     fiducial_parameters: dict, optional
         A starting guess for initial parameters of the event for finding the
         maximum likelihood (fiducial) waveform. These should be specified in
         the same parameter basis as the one that sampling is carried out in.
         If no fiducial parameters are passed, a random point will be drawn from
         the prior.
+    maximization_kwargs: dict, optional
+        Keyword arguments for :code:`scipy.optimize.differential_evolution`
     update_fiducial_parameters: bool
         Whether to try to update the fiducial parameters by finding the maximum
         likelihood point using scipy differential evolution. Default is
         :code:`False`.
     parameters_to_be_updated: list, optional
-        Parameters over which the likelihood is maximized when
-        :code:`update_fiducial_parameters` is True, within their prior bounds.
-        Default is :code:`["chirp_mass", "mass_ratio"]`.
-    maximization_kwargs: dict, optional
-        Keyword arguments for :code:`scipy.optimize.differential_evolution`.
+        The parameters over which the likelihood is maximized, within their
+        prior bounds. Default is :code:`["chirp_mass", "mass_ratio"]`.
     distance_marginalization: bool, optional
         If true, marginalize over distance in the likelihood.
         This uses a look up table calculated at run time.
@@ -106,54 +52,53 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         distance allowed in the prior being marginalised over.
     priors: dict, optional
         If given, used in the distance marginalization and to find the
-        fiducial parameters (the prior bounds are the bounds of the
-        optimization).
+        fiducial parameters.
     distance_marginalization_lookup_table: (dict, str), optional
-        As for :code:`TimeDomainGravitationalWaveTransient`.
+        If a dict, dictionary containing the lookup_table, distance_array,
+        (distance) prior_array, and reference_distance used to construct
+        the table.
+        If a string the name of a file containing these quantities.
     reference_frame: (str, bilby.gw.detector.InterferometerList, list), optional
-        Definition of the reference frame for the sky location.
+        Definition of the reference frame for the sky location, as in
+        :code:`GravitationalWaveTransient`.
     time_reference: str, optional
-        Name of the reference for the sampled time parameter.
-        - "geocent"/"geocenter": sample in the time at the Earth's center,
-          this is the default
-        - e.g., "H1": sample in the time of arrival at H1
+        Name of the reference for the sampled time parameter, as in
+        :code:`GravitationalWaveTransient`.
     epsilon: tuple, optional
-        Bin size in the inspiral: phase-proxy spacing before and after
-        :code:`time_split` (see :code:`time_domain_bin_edges`). Smaller
-        values give more bins.
+        The bin width in the phase proxy before and after `time_split`;
+        smaller values give more bins (see :code:`time_domain_bin_edges`)
     time_split: float, optional
-        Time (s, relative to the merger) at which epsilon changes.
+        The time relative to the merger (in s) at which `epsilon` changes
     spacing: tuple, optional
-        Number of samples per bin after the merger, until
-        :code:`spacing_times[0]`, until :code:`spacing_times[1]` and after.
+        The number of samples per bin after the merger: before
+        `spacing_times[0]`, before `spacing_times[1]` and after
     spacing_times: tuple, optional
-        Times (s, relative to the merger) at which the spacing changes.
+        The times relative to the merger (in s) at which `spacing` changes
     chi: float, optional
-        Tunable parameter of the phase proxy (as in relative binning).
+        Tunable parameter of the phase proxy. See https://arxiv.org/abs/1806.08792.
     sampled_minimum_frequency: float, optional
-        Frequency (Hz) at which the waveforms at sampled parameters start. By
-        default 2 Hz below the lowest minimum_frequency of the interferometers;
-        a higher value gives a warning.
+        The minimum frequency (in Hz) of the waveforms at sampled parameters,
+        default: 2 Hz below the start frequency of the waveforms (see
+        :code:`bilby.gw.time_domain_utils.time_domain_start_frequency`)
     fiducial_minimum_frequency: float, optional
-        Frequency (Hz) at which the fiducial waveform starts. By default the
-        lower of :code:`sampled_minimum_frequency` and the frequency derived
-        from the fiducial chirp mass and the start of the analysis window
-        (the leading-order frequency 1.5 x (time from the window start to the
-        merger) + 0.1 s before the merger, minus 1 Hz); a given value must not
-        be above that.
-    time_marginalization, phase_marginalization, calibration_marginalization: bool
-        Not implemented for this likelihood; must be False.
+        The minimum frequency (in Hz) of the fiducial waveform, default: chosen
+        so that it starts before the analysis window
+    time_marginalization, phase_marginalization, calibration_marginalization: bool, optional
+        Not implemented for this likelihood; must be False
     use_float32: bool, optional
-        If True, the eigenvectors of the summary matrix S are stored and
-        multiplied in float32 instead of float64: :math:`v^T S v` is a few times
-        faster for many modes and bins, with relative errors of ~1e-7 in it.
-        Default is False.
+        If true, the summary data are stored and multiplied in single precision.
+        Default is :code:`False`.
 
     Returns
-    -------
+    =======
     Likelihood: `bilby.core.likelihood.Likelihood`
         A likelihood object, able to compute the likelihood of the data given
         some model parameters.
+
+    Notes
+    =====
+    The time-domain heterodyning likelihood does not currently support time,
+    phase or calibration marginalization.
     """
 
     def __init__(self, interferometers, waveform_generator, fiducial_parameters=None,
@@ -214,35 +159,35 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
         logger.info(f"Fiducial likelihood: {self.log_likelihood_ratio(self.fiducial_parameters):.2f}")
 
     def _set_sampled_minimum_frequency(self, sampled_minimum_frequency):
-        maximum = min(ifo.minimum_frequency for ifo in self.interferometers) - 2
+        arguments = self.waveform_generator.waveform_arguments
+        start_frequency = min(ifo.minimum_frequency for ifo in self.interferometers)
+        if arguments.get("start_at_higher_mode_frequency", True):
+            start_frequency = time_domain_start_frequency(
+                start_frequency, arguments.get("waveform_approximant", "IMRPhenomTPHM"), arguments.get("mode_array"))
+        maximum = start_frequency - 2
         if sampled_minimum_frequency is None:
             sampled_minimum_frequency = maximum
         if sampled_minimum_frequency > maximum:
             logger.warning(
                 f"sampled_minimum_frequency ({sampled_minimum_frequency:g} Hz) is above {maximum:g} Hz "
-                "(2 Hz below the interferometers' minimum_frequency)")
+                f"(2 Hz below the start frequency of the waveforms, {start_frequency:g} Hz)")
+        logger.info(f"Waveforms at sampled parameters from {sampled_minimum_frequency:g} Hz")
         self.sampled_minimum_frequency = sampled_minimum_frequency
         self.waveform_generator.waveform_arguments["sampled_minimum_frequency"] = sampled_minimum_frequency
 
-    # ------------------------------------------------------------------
-    # Waveform at given samples
-    # ------------------------------------------------------------------
     def _model_times(self, interferometer, indices, parameters):
-        """ Times of the analysis-window samples `indices`, relative to the
-        arrival of the model's t=0 at the interferometer (as for placement="model_time"). """
+        """ Times (in s) of the analysis-window samples `indices` relative to the arrival of the merger """
         # the time of the first sample, plus the samples `indices` (not all N samples)
         first = times_from_merger(
-            interferometer.strain_data.time_array[interferometer._analysis_slice().start], 1,
+            interferometer.time_array[interferometer.analysis_slice][0], 1,
             interferometer.sampling_frequency, parameters["geocent_time"],
             interferometer.time_delay_from_geocenter(parameters["ra"], parameters["dec"], parameters["geocent_time"]))
         return first[0] + np.asarray(indices) / interferometer.sampling_frequency
 
     def _modes_and_harmonics_at_combined_bin_edges(self, signal, model_times):
-        """ Modes and harmonic factors at `model_times`, a list with the model
-        times of each interferometer (of the bin edges; of all samples for the
-        fiducial waveform): the model times of all interferometers are joined,
-        the waveform is evaluated once, and the result is split back per
-        interferometer. None if the waveform failed. """
+        """ Modes and harmonic factors of `signal` at the model times of each
+        interferometer, from one waveform call (None if the waveform failed)
+        """
         all_modes_and_harmonics = signal["heterodyning_terms_at"](np.concatenate(model_times))
         if all_modes_and_harmonics is None:
             return None
@@ -262,10 +207,7 @@ def _modes_and_harmonics_at_combined_bin_edges(self, signal, model_times):
         return per_interferometer
 
     def _r_tilde_coefficients(self, waveform_polarizations, interferometers, parameters):
-        """ The coefficients r_tilde[lm, p, b] of each interferometer (see the class
-        docstring): r_tilde_lm = h_lm (F Z_lm + (F Zbar_lm)^*) / h^0_lm at the bin edges,
-        then r_tilde_lm,0 (p = 0) and r_tilde_lm,1 (p = 1) in each bin b. None if the
-        waveform failed. """
+        """ The heterodyning coefficients of each interferometer in each bin (None if the waveform failed) """
         modes_and_harmonics = self._modes_and_harmonics_at_combined_bin_edges(
             waveform_polarizations,
             [self._model_times(interferometer, self.bin_edges[interferometer.name], parameters)
@@ -292,14 +234,15 @@ def _r_tilde_coefficients(self, waveform_polarizations, interferometers, paramet
             r_tilde.append(np.stack([r_tilde_0, r_tilde_1], axis=1))
         return r_tilde
 
-    # ------------------------------------------------------------------
-    # Fiducial waveform, bins and summary data
-    # ------------------------------------------------------------------
     def set_fiducial_waveforms(self, parameters):
-        """ The modes of the fiducial waveform at the data samples of each
-        interferometer, starting before the analysis window (see
-        :code:`fiducial_minimum_frequency`) and held at their last non-zero
-        values after the ringdown. """
+        """ Compute the modes of the fiducial waveform at the samples of the analysis
+        window of each interferometer
+
+        Parameters
+        ==========
+        parameters: dict
+            The fiducial parameters
+        """
         parameters = parameters.copy()
         parameters.update(self.get_sky_frame_parameters(parameters=parameters))
         self._fiducial_times = {
@@ -355,28 +298,23 @@ def set_fiducial_waveforms(self, parameters):
     @staticmethod
     def time_domain_bin_edges(times, epsilon=(0.5, 0.1), time_split=-0.02, spacing=(2, 10, 100),
                               spacing_times=(0.02, 0.1), chi=1):
-        """ Bin edges for the time-domain heterodyned likelihood (Sharma et al.
-        arXiv:2601.11239).
-
-        - Before the merger (t < 0): edges equally spaced in the phase proxy
-          :math:`\\psi(t) = \\sum_k {\\rm sign}(\\gamma_k) \\delta\\alpha_k |t|^{\\gamma_k}`,
-          :math:`\\gamma = (5/8, 3/8, 1/4, -3/8)`, with
-          :math:`\\delta\\alpha_k = 2 \\pi \\chi / |t|_{\\rm max}^{\\gamma_k}`
-          (:math:`|t|_{\\rm min}` for :math:`\\gamma_k < 0`), one bin per
-          epsilon[0] of :math:`|\\Delta\\psi|` for t <= time_split and per
-          epsilon[1] after.
-        - From the merger: one edge every spacing[0] samples until
-          spacing_times[0], every spacing[1] samples until spacing_times[1] and
-          every spacing[2] samples after.
+        """ Bin edges for the time-domain heterodyning likelihood
+
+        Before the merger, the bins are equally spaced in a phase proxy as in
+        Zackay et al. arXiv:1806.08792, with powers of time in place of powers of
+        frequency; after the merger, they have a fixed number of samples. See
+        Sharma et al. arXiv:2601.11239.
 
         Parameters
         ==========
         times: array_like
-            Increasing times (s) relative to the merger.
+            Increasing times relative to the merger (in s)
+        epsilon, time_split, spacing, spacing_times, chi:
+            See :code:`TimeDomainHeterodyningGravitationalWaveTransient`
 
         Returns
         =======
-        array_like: indices of the edges into times (first and last included).
+        array_like: The indices of the bin edges in `times`, first and last included
         """
         gamma = np.array([5 / 8, 3 / 8, 1 / 4, -3 / 8])  # powers of |t| in the phase proxy
         edges = [0, len(times) - 1]
@@ -399,11 +337,7 @@ def time_domain_bin_edges(times, epsilon=(0.5, 0.1), time_split=-0.02, spacing=(
         return np.unique(edges)
 
     def setup_bins(self):
-        """ Bin edges (indices of analysis-window samples) for each
-        interferometer, from the times relative to the fiducial merger in that
-        interferometer (see :code:`time_domain_bin_edges`), up to the end of
-        the fiducial ringdown, and one bin from there to the end of the
-        analysis window. """
+        """ Set up the bin edges of each interferometer from its fiducial waveform """
         self.bin_edges = dict()
         self.bin_widths = dict()
         self.number_of_bins = dict()
@@ -428,17 +362,7 @@ def setup_bins(self):
                 f"and {times[edges[-1]]:.3f} s from the merger")
 
     def compute_summary_data(self):
-        """ Summary data of each interferometer (see the class docstring):
-
-        - the columns of V: in each bin b, :math:`\\Re(h^0_{\\ell m} (t - t_b)^p)` and
-          :math:`-\\Im(h^0_{\\ell m} (t - t_b)^p)` for every mode and p = 0, 1;
-        - :math:`a = V^T C^{-1} d` (contains :math:`A_0, A_1`);
-        - :math:`S = V^T C^{-1} V` (contains the B matrices), without the terms with
-          p = p' = 1, stored as :math:`S = \\sum_n \\lambda_n e_n e_n^T` so that
-          :math:`v^T S v = \\sum_n \\lambda_n (e_n \\cdot v)^2`.
-
-        Bin b holds the samples from its initial edge up to its final edge (the
-        last bin also holds the last sample). """
+        """ Compute the summary data of each interferometer from its fiducial waveform """
         self.summary_data = dict()
         self._inverse_h0_at_edges = dict()
         for interferometer in self.interferometers:
@@ -494,31 +418,27 @@ def compute_summary_data(self):
             logger.info(f"{name}: {len(self.mode_keys)} modes, {number_of_bins} bins, "
                         f"S of size {size} and rank {np.sum(keep)}")
 
-    # ------------------------------------------------------------------
-    # Likelihood
-    # ------------------------------------------------------------------
     def calculate_snrs(self, waveform_polarizations, interferometer, *, return_array=True, parameters,
                        r_tilde=None):
-        """ :math:`\\langle d, s \\rangle = a \\cdot v` and
-        :math:`\\langle s, s \\rangle = v^T S v = \\sum_n \\lambda_n (e_n \\cdot v)^2` in one
-        interferometer, with :math:`v = (\\Re \\tilde{r}, \\Im \\tilde{r})`.
+        """ Compute the snrs
 
         Parameters
-        ----------
+        ==========
         waveform_polarizations: dict
-            Output of the source model (heterodyning_terms_at).
+            The output of the heterodyning source model
         interferometer: bilby.gw.detector.Interferometer
+            The bilby interferometer object
         return_array: bool
-            Unused; kept for the :code:`GravitationalWaveTransient` interface.
+            Not used; kept for the :code:`GravitationalWaveTransient` interface
         parameters: dict
+            The parameters of the signal
         r_tilde: array_like, optional
-            The coefficients r_tilde[lm, p, b] of this interferometer, if already
-            computed (as in :code:`log_likelihood_ratio`, for all interferometers
-            from one waveform call); otherwise they are computed here.
+            The heterodyning coefficients of this interferometer, if already computed
 
         Returns
-        -------
-        calculated_snrs: _CalculatedSNRs, or None if the waveform failed
+        =======
+        calculated_snrs: _CalculatedSNRs
+            An object containing the SNR quantities (None if the waveform failed)
         """
         if r_tilde is None:
             r_tilde = self._r_tilde_coefficients(waveform_polarizations, [interferometer], parameters)
@@ -554,8 +474,7 @@ def log_likelihood_ratio(self, parameters):
         return float(np.real(log_l))
 
     def _compute_full_waveform(self, signal_polarizations, interferometer, parameters):
-        """ The heterodyned template on all samples of the analysis window (not used in the
-        likelihood): s(t_j) = Re sum_lm [r_tilde_lm,0(b) + r_tilde_lm,1(b) (t_j - t_b)] h^0_lm(t_j). """
+        """ The heterodyned template at the samples of the analysis window """
         r_tilde = self._r_tilde_coefficients(signal_polarizations, [interferometer], parameters)
         if r_tilde is None:
             return None
@@ -578,16 +497,22 @@ def rescaled(times):
 
         signal["heterodyning_terms_at"] = rescaled
 
-    # ------------------------------------------------------------------
-    # Fiducial parameters (as in RelativeBinningGravitationalWaveTransient)
-    # ------------------------------------------------------------------
     def find_maximum_likelihood_parameters(self, parameter_bounds, maximization_kwargs=None):
-        """ Maximize the exact time-domain likelihood
-        (:code:`TimeDomainGravitationalWaveTransient` with placement="model_time",
-        with the same distance marginalization) over :code:`parameters_to_be_updated`
-        with scipy differential evolution, starting from the fiducial parameters. """
+        """ Find the maximum of the time-domain likelihood over
+        :code:`parameters_to_be_updated`, using scipy differential evolution
+
+        Parameters
+        ==========
+        parameter_bounds: list
+            The bounds of the parameters
+        maximization_kwargs: dict, optional
+            Keyword arguments for :code:`scipy.optimize.differential_evolution`
+
+        Returns
+        =======
+        dict: The updated fiducial parameters
+        """
         from ..source import lal_binary_black_hole_model_time
-        from .time_domain import TimeDomainGravitationalWaveTransient
 
         if maximization_kwargs is None:
             maximization_kwargs = dict()
@@ -624,16 +549,13 @@ def negative_log_likelihood_ratio(parameter_list):
         return updated_parameters
 
     def _set_fiducial(self):
-        """ Make the waveform generator generate the fiducial waveform (from
-        fiducial_minimum_frequency), as in
-        :code:`RelativeBinningGravitationalWaveTransient`. """
+        """ Make the waveform generator generate the fiducial waveform """
         self.waveform_generator.waveform_arguments["fiducial"] = 1
         self.waveform_generator.waveform_arguments["fiducial_minimum_frequency"] = self.fiducial_minimum_frequency
         self.waveform_generator._cache["parameters"] = None
 
     def _unset_fiducial(self):
-        """ Make the waveform generator generate waveforms at sampled
-        parameters (from sampled_minimum_frequency). """
+        """ Make the waveform generator generate waveforms at sampled parameters """
         self.waveform_generator.waveform_arguments["fiducial"] = 0
         self.waveform_generator._cache["parameters"] = None
 
diff --git a/bilby/gw/model_time_waveforms.py b/bilby/gw/model_time_waveforms.py
index ea6d83f96..8f6fdfa3b 100644
--- a/bilby/gw/model_time_waveforms.py
+++ b/bilby/gw/model_time_waveforms.py
@@ -1,17 +1,11 @@
-""" IMRPhenomT-family waveforms at arbitrary times.
-
-These call the lalsimulation functions that evaluate IMRPhenomT, IMRPhenomTHM,
-IMRPhenomTP and IMRPhenomTPHM at a user-supplied array of model times, instead
-of on LAL's own time grid. Model time is t / M, with M = m1 + m2 (detector
-frame) in seconds, and t = 0 at the peak of the (2,2) amplitude of the
-non-precessing waveform.
-
-- truncate=False: the waveform at every requested time; every time must lie in
-  the span of the standard waveform (from f_min to the end of the ringdown).
-- truncate=True: zero at times outside that span.
+"""
+IMRPhenomT-family waveforms evaluated at arbitrary times.
 
-The functions need a lalsuite build that has these functions; an ImportError is
-raised only when one of them is used.
+Wrappers of the lalsimulation functions that evaluate IMRPhenomT
+(Estellés et al. arXiv:2004.08302), IMRPhenomTHM (arXiv:2012.11923),
+IMRPhenomTP and IMRPhenomTPHM (arXiv:2105.05872) at given model times
+t / M, where M is the total mass in seconds and t = 0 at the peak of the (2, 2)
+amplitude. These functions require a lalsuite build that provides them.
 """
 import numpy as np
 
@@ -24,7 +18,7 @@
 _COPRECESSING_HARMONICS_FUNCTION = "Sim{approximant}CoprecModesHarmonicsModelTimes"
 
 
-def _lalsimulation_function(template, approximant, truncate):
+def _get_approximant(template, approximant, truncate):
     import lalsimulation as lalsim
     name = template.format(approximant=approximant) + ("Truncated" if truncate else "")
     try:
@@ -35,18 +29,6 @@ def _lalsimulation_function(template, approximant, truncate):
             "with the time-array IMRPhenomT-family functions") from None
 
 
-def total_mass_in_seconds(mass_1, mass_2):
-    """ Total mass in seconds, as lalsimulation computes it.
-
-    Parameters
-    ==========
-    mass_1, mass_2: float
-        Component masses (kg).
-    """
-    import lal
-    return (mass_1 / lal.MSUN_SI + mass_2 / lal.MSUN_SI) * lal.MTSUN_SI
-
-
 def _time_sequence(model_times):
     import lal
     model_times = np.asarray(model_times, dtype=float)
@@ -55,22 +37,22 @@ def _time_sequence(model_times):
     return sequence
 
 
-def check_arguments(approximant, spin_1x, spin_1y, spin_2x, spin_2y):
-    """ Raise a ValueError for an approximant without model-time functions, or
-    for in-plane spins with a non-precessing approximant (as lalsimulation's
-    ChooseTDWaveform and ChooseFDWaveform do). """
+def spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z):
+    """ The spin arguments of the lalsimulation model-time functions: all six
+    components for IMRPhenomTP and IMRPhenomTPHM, the z components for
+    IMRPhenomT and IMRPhenomTHM
+
+    Raises a ValueError for other approximants, or for in-plane spins with a
+    non-precessing approximant.
+    """
     if approximant not in APPROXIMANTS:
         raise ValueError(
             f"model-time waveforms are available for {', '.join(APPROXIMANTS)}, not {approximant!r}")
-    if approximant not in PRECESSING_APPROXIMANTS and (spin_1x != 0 or spin_1y != 0 or spin_2x != 0 or spin_2y != 0):
-        raise ValueError(
-            f"Non-zero transverse spins were given, but {approximant} is a non-precessing approximant.")
-
-
-def _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z):
-    check_arguments(approximant, spin_1x, spin_1y, spin_2x, spin_2y)
     if approximant in PRECESSING_APPROXIMANTS:
         return (spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    if spin_1x != 0 or spin_1y != 0 or spin_2x != 0 or spin_2y != 0:
+        raise ValueError(
+            f"Non-zero transverse spins were given, but {approximant} is a non-precessing approximant.")
     return (spin_1z, spin_2z)
 
 
@@ -79,65 +61,65 @@ def polarizations_at_model_times(
         spin_2x, spin_2y, spin_2z, luminosity_distance, inclination, phase,
         delta_time, minimum_frequency, reference_frequency, waveform_dictionary,
         truncate=True):
-    """ Plus and cross polarizations at the given model times.
+    """ The plus and cross polarizations at given model times
 
     Parameters
     ==========
     model_times: array_like
-        Times in units of the total mass, t = 0 at the peak (any order, any spacing).
+        The times t / M, with t = 0 at the peak of the (2, 2) amplitude
     approximant: str
-        IMRPhenomT, IMRPhenomTHM, IMRPhenomTP or IMRPhenomTPHM.
+        IMRPhenomT, IMRPhenomTHM, IMRPhenomTP or IMRPhenomTPHM
     mass_1, mass_2: float
-        Component masses (kg).
-    spin_1x, ..., spin_2z: float
-        Dimensionless spin components at the reference frequency (lalsimulation frame).
-        The in-plane components must be zero for IMRPhenomT and IMRPhenomTHM.
+        The component masses (in kg)
+    spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z: float
+        The dimensionless spin components in the lalsimulation frame
     luminosity_distance: float
-        Luminosity distance (m).
-    inclination, phase: float
-        Inclination and reference phase (rad), as for ChooseTDWaveform.
+        The luminosity distance (in m)
+    inclination: float
+        The inclination (in rad)
+    phase: float
+        The reference phase (in rad)
     delta_time: float
-        Sampling interval (s) of the standard waveform; the precessing models take
-        their angles on the time grid of the standard waveform.
-    minimum_frequency, reference_frequency: float
-        f_min and f_ref (Hz).
+        The sampling interval (in s) of the waveform on which the precession angles are computed
+    minimum_frequency: float
+        The minimum frequency (in Hz)
+    reference_frequency: float
+        The reference frequency (in Hz)
     waveform_dictionary: lal.Dict
+        The lal waveform dictionary
     truncate: bool
-        If True (default), zero outside the span of the standard waveform.
+        If True, the waveform is zero at times outside its span, from the
+        minimum frequency to the end of the ringdown
 
     Returns
     =======
-    plus, cross: array_like
+    dict: The plus and cross polarizations
     """
-    spins = _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
-    function = _lalsimulation_function(_POLARIZATION_FUNCTION, approximant, truncate)
+    spins = spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    function = _get_approximant(_POLARIZATION_FUNCTION, approximant, truncate)
     hplus, hcross = function(
         mass_1, mass_2, *spins, luminosity_distance, inclination, delta_time,
         minimum_frequency, reference_frequency, phase, _time_sequence(model_times),
         waveform_dictionary)
-    return hplus.data.data, hcross.data.data
+    return dict(plus=hplus.data.data, cross=hcross.data.data)
 
 
 def modes_at_model_times(
         model_times, approximant, mass_1, mass_2, spin_1x, spin_1y, spin_1z,
         spin_2x, spin_2y, spin_2z, luminosity_distance, phase, delta_time,
         minimum_frequency, reference_frequency, waveform_dictionary, truncate=True):
-    """ Spherical-harmonic modes h_lm at the given model times.
-
-    For IMRPhenomTP/TPHM these are the modes in the inertial frame of the
-    orbital angular momentum at the reference frequency (L0 frame), i.e.,
-    already rotated with the precession angles; they contain every m of each l.
-    For IMRPhenomT only (2, 2) and (2, -2) are returned.
+    """ The spherical-harmonic modes at given model times; for IMRPhenomTP and
+    IMRPhenomTPHM, in the frame of the orbital angular momentum at the reference
+    frequency
 
-    Parameters are those of :code:`polarizations_at_model_times`, without the
-    inclination.
+    Parameters are as in :code:`polarizations_at_model_times`, without the inclination.
 
     Returns
     =======
-    dict: {(l, m): complex array}
+    dict: The modes, with keys (l, m)
     """
-    spins = _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
-    function = _lalsimulation_function(_MODE_FUNCTION, approximant, truncate)
+    spins = spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    function = _get_approximant(_MODE_FUNCTION, approximant, truncate)
     hlms = function(
         mass_1, mass_2, *spins, luminosity_distance, delta_time, minimum_frequency,
         reference_frequency, phase, _time_sequence(model_times), waveform_dictionary)
@@ -158,53 +140,37 @@ def heterodyning_terms_at_model_times(
         spin_2x, spin_2y, spin_2z, luminosity_distance, inclination, phase,
         delta_time, minimum_frequency, reference_frequency, waveform_dictionary,
         truncate=True):
-    """ Modes and harmonic factors for the time-domain heterodyned likelihood.
-
-    The waveform is written as
+    """ The modes and harmonic factors used by
+    :code:`bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient`
+    at given model times: the modes with m > 0 for IMRPhenomT and IMRPhenomTHM,
+    the co-precessing modes with m >= 0 for IMRPhenomTP and IMRPhenomTPHM. See
+    Sharma et al. arXiv:2601.11239.
 
-    .. math::
-
-        h_+ - i h_\\times = \\sum_{\\ell, m \\geq 0} \\left[ Z_{\\ell m} h_{\\ell m}
-        + \\bar{Z}_{\\ell m} h_{\\ell m}^* \\right].
-
-    - IMRPhenomT/THM: :math:`h_{\\ell m}` are the modes with m > 0,
-      :math:`Z_{\\ell m} = Y_{\\ell m}` and
-      :math:`\\bar{Z}_{\\ell m} = (-1)^\\ell Y_{\\ell, -m}`, with
-      :math:`Y_{\\ell m} = {}_{-2}Y_{\\ell m}(\\iota, \\pi/2 - \\phi)`.
-    - IMRPhenomTP/TPHM: :math:`h_{\\ell m}` are the co-precessing modes with
-      m >= 0, :math:`Z_{\\ell m}(t) = \\sum_{m'} Y_{\\ell m'} R^\\ell_{m m'}(t)`,
-      with R the rotation from the co-precessing frame to the L0 frame, and
-      :math:`\\bar{Z}_{\\ell m} = (-1)^\\ell Z_{\\ell, -m}` (zero for m = 0). The modes and
-      Z are computed by lalsimulation (Sim...CoprecModesHarmonicsModelTimes).
-
-    The modes of the precessing models vary slowly in time, so their ratios to
-    the modes of a nearby (fiducial) waveform are smooth; the factors Z carry
-    the precession and are evaluated exactly.
-
-    Parameters are those of :code:`polarizations_at_model_times`.
+    Parameters are as in :code:`polarizations_at_model_times`.
 
     Returns
     =======
     modes: dict
-        {(l, m): complex array}; for IMRPhenomTP/TPHM, modes that are zero
-        at every requested time are left out.
+        The modes, with keys (l, m)
     harmonics: dict
-        {(l, m): (Z, Zbar)}, complex scalars or arrays.
+        The harmonic factors of each mode and of its complex conjugate, with keys (l, m)
     """
-    spins = _spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    spins = spin_arguments(approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
     if approximant not in PRECESSING_APPROXIMANTS:
+        import lal
         modes = modes_at_model_times(
             model_times, approximant, mass_1, mass_2, spin_1x, spin_1y, spin_1z,
             spin_2x, spin_2y, spin_2z, luminosity_distance, phase, delta_time,
             minimum_frequency, reference_frequency, waveform_dictionary, truncate=truncate)
         modes = {(ell, m): mode for (ell, m), mode in modes.items() if m > 0}
+        # Y_lm = -2Y_lm(inclination, pi / 2 - phase)
         harmonics = {
-            (ell, m): (_spherical_harmonic(ell, m, inclination, phase),
-                       (-1) ** ell * _spherical_harmonic(ell, -m, inclination, phase))
+            (ell, m): (lal.SpinWeightedSphericalHarmonic(inclination, np.pi / 2 - phase, -2, ell, m),
+                       (-1) ** ell * lal.SpinWeightedSphericalHarmonic(inclination, np.pi / 2 - phase, -2, ell, -m))
             for ell, m in modes}
         return modes, harmonics
 
-    function = _lalsimulation_function(_COPRECESSING_HARMONICS_FUNCTION, approximant, truncate)
+    function = _get_approximant(_COPRECESSING_HARMONICS_FUNCTION, approximant, truncate)
     hlms, factors = function(
         mass_1, mass_2, *spins, luminosity_distance, inclination, delta_time, minimum_frequency,
         reference_frequency, phase, _time_sequence(model_times), waveform_dictionary)
@@ -214,8 +180,3 @@ def heterodyning_terms_at_model_times(
         (ell, m): (factors[(ell, m)], (-1) ** ell * factors[(ell, -m)] if m > 0 else 0)
         for ell, m in modes}
     return modes, harmonics
-
-
-def _spherical_harmonic(ell, m, inclination, phase):
-    import lal
-    return lal.SpinWeightedSphericalHarmonic(inclination, np.pi / 2 - phase, -2, ell, m)
diff --git a/bilby/gw/source.py b/bilby/gw/source.py
index fdf8b5682..7680dc34b 100644
--- a/bilby/gw/source.py
+++ b/bilby/gw/source.py
@@ -694,20 +694,13 @@ def _base_lal_cbc_fd_waveform(
 def lal_binary_black_hole_time_domain(
         time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
         phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
-    """ A time-domain Binary Black Hole waveform model using lalsimulation
-    (SimInspiralChooseTDWaveform), for use with
-    :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`.
-
-    The polarizations are returned on the waveform's own uniform grid, with
-    sample spacing taken from :code:`time_array`, together with the epoch
-    (time of the first sample relative to the model's t=0, i.e., merger).
-    The likelihood places them in each detector's data. This output cannot be
-    used with the frequency-domain likelihoods.
+    """ A time-domain Binary Black Hole waveform model using lalsimulation, for
+    :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`
 
     Parameters
     ==========
     time_array: array_like
-        Times of the data (only the spacing is used).
+        The times of the data (only the sample spacing is used)
     mass_1: float
         The mass of the heavier object in solar masses
     mass_2: float
@@ -735,7 +728,7 @@ def lal_binary_black_hole_time_domain(
         Optional keyword arguments
         Supported arguments:
 
-        - waveform_approximant (default IMRPhenomTP)
+        - waveform_approximant
         - reference_frequency
         - minimum_frequency
         - catch_waveform_errors
@@ -743,20 +736,26 @@ def lal_binary_black_hole_time_domain(
         - pn_tidal_order
         - pn_phase_order
         - pn_amplitude_order
-        - mode_array (see :code:`lal_binary_black_hole`)
+        - mode_array: see :code:`lal_binary_black_hole`
         - lal_waveform_dictionary
-        - turn_on_window: alpha of a one-sided Tukey window applied to the start
-          of the generated waveform (default 0.125; 0 for none)
+        - turn_on_window: the alpha of the one-sided Tukey window applied to the
+          start of the waveform, for placement "nearest" or "fd_shift" (default 0: no window)
+        - start_at_higher_mode_frequency: if True (default), the waveform starts
+          early enough for its modes with l <= 4 to be present from minimum_frequency
+          (see :code:`bilby.gw.time_domain_utils.time_domain_start_frequency`)
 
     Returns
     =======
-    dict: plus and cross polarizations on the waveform's own grid, and epoch (s)
+    dict: A dictionary with the plus and cross polarisation strain modes on the
+    waveform's own time grid, and the epoch, the time of the first sample relative
+    to the merger (in s)
     """
     waveform_kwargs = dict(
         waveform_approximant='IMRPhenomTP', reference_frequency=50.0,
         minimum_frequency=20.0, catch_waveform_errors=False,
         pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
-        pn_amplitude_order=0, turn_on_window=0.125)
+        pn_amplitude_order=0, turn_on_window=0,
+        start_at_higher_mode_frequency=True)
     waveform_kwargs.update(kwargs)
     return _base_lal_cbc_td_waveform(
         time_array=time_array, mass_1=mass_1, mass_2=mass_2,
@@ -769,28 +768,54 @@ def lal_binary_neutron_star_time_domain(
         time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
         phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, lambda_1, lambda_2,
         **kwargs):
-    """ A time-domain Binary Neutron Star waveform model using lalsimulation
-    (SimInspiralChooseTDWaveform), for use with
-    :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`.
-
-    Parameters are those of :code:`lal_binary_black_hole_time_domain` plus
+    """ A time-domain Binary Neutron Star waveform model using lalsimulation, for
+    :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient`
 
+    Parameters
+    ==========
+    time_array: array_like
+        The times of the data (only the sample spacing is used)
+    mass_1: float
+        The mass of the heavier object in solar masses
+    mass_2: float
+        The mass of the lighter object in solar masses
+    luminosity_distance: float
+        The luminosity distance in megaparsec
+    a_1: float
+        Dimensionless primary spin magnitude
+    tilt_1: float
+        Primary tilt angle
+    phi_12: float
+        Azimuthal angle between the two component spins
+    a_2: float
+        Dimensionless secondary spin magnitude
+    tilt_2: float
+        Secondary tilt angle
+    phi_jl: float
+        Azimuthal angle between the total binary angular momentum and the
+        orbital angular momentum
+    theta_jn: float
+        Angle between the total binary angular momentum and the line of sight
+    phase: float
+        The phase at reference frequency or peak amplitude (depends on waveform)
     lambda_1: float
         Dimensionless tidal deformability of mass_1
     lambda_2: float
         Dimensionless tidal deformability of mass_2
-
-    The default approximant is IMRPhenomPv2_NRTidal.
+    kwargs: dict
+        Optional keyword arguments, as for :code:`lal_binary_black_hole_time_domain`
 
     Returns
     =======
-    dict: plus and cross polarizations on the waveform's own grid, and epoch (s)
+    dict: A dictionary with the plus and cross polarisation strain modes on the
+    waveform's own time grid, and the epoch
     """
     waveform_kwargs = dict(
         waveform_approximant='IMRPhenomPv2_NRTidal', reference_frequency=50.0,
         minimum_frequency=20.0, catch_waveform_errors=False,
         pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
-        pn_amplitude_order=0, turn_on_window=0.125)
+        pn_amplitude_order=0, turn_on_window=0,
+        start_at_higher_mode_frequency=True)
     waveform_kwargs.update(kwargs)
     return _base_lal_cbc_td_waveform(
         time_array=time_array, mass_1=mass_1, mass_2=mass_2,
@@ -805,25 +830,27 @@ def _base_lal_cbc_td_waveform(
         lambda_1=0.0, lambda_2=0.0, eccentricity=0.0, **waveform_kwargs):
     """ Generate a time-domain cbc waveform model using lalsimulation
 
-    Parameters as in :code:`_base_lal_cbc_fd_waveform`, with
-    :code:`time_array` in place of :code:`frequency_array`.
+    Parameters are as in :code:`_base_lal_cbc_fd_waveform`, with `time_array`
+    in place of `frequency_array`.
 
     Returns
     =======
-    dict: plus and cross polarizations on the waveform's own grid (spacing
-    time_array[1] - time_array[0]), and epoch: time of the first sample
-    relative to the model's t=0 (s). The start is smoothly turned on with a
-    one-sided Tukey window of alpha=turn_on_window, applied over the
-    waveform's full length.
+    dict: A dictionary with the plus and cross polarisation strain modes on the
+    waveform's own time grid, and the epoch, the time of the first sample relative
+    to the merger (in s)
     """
     import lalsimulation as lalsim
     from scipy.signal.windows import tukey
+    from .time_domain_utils import time_domain_start_frequency
 
     waveform_approximant = waveform_kwargs.pop('waveform_approximant')
     reference_frequency = waveform_kwargs.pop('reference_frequency')
     minimum_frequency = waveform_kwargs.pop('minimum_frequency')
     catch_waveform_errors = waveform_kwargs.pop('catch_waveform_errors')
     turn_on_window = waveform_kwargs.pop('turn_on_window')
+    if waveform_kwargs.pop('start_at_higher_mode_frequency'):
+        minimum_frequency = time_domain_start_frequency(
+            minimum_frequency, waveform_approximant, waveform_kwargs.get('mode_array'))
     pn_amplitude_order = waveform_kwargs['pn_amplitude_order']
 
     waveform_dictionary = set_waveform_dictionary(waveform_kwargs, lambda_1, lambda_2)
@@ -889,130 +916,128 @@ def _base_lal_cbc_td_waveform(
 def lal_binary_black_hole_model_time(
         time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
         phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
-    """ A time-domain Binary Black Hole waveform model evaluated directly at
-    the data samples of each detector (IMRPhenomT, IMRPhenomTHM, IMRPhenomTP,
-    IMRPhenomTPHM), for use with
+    """ A time-domain Binary Black Hole waveform model for the IMRPhenomT family,
+    evaluated at the data samples of each interferometer, for
     :code:`bilby.gw.likelihood.TimeDomainGravitationalWaveTransient` with
-    :code:`placement="model_time"`.
-
-    No waveform is generated here. The returned function generates the
-    polarizations at given times relative to the model's t=0 (in seconds);
-    the detector response calls it with the times of its own data samples,
-    (t_k - geocent_time - time delay), so each detector gets its own call.
-    See :code:`bilby.gw.model_time_waveforms`.
+    :code:`placement="model_time"`. See :code:`bilby.gw.model_time_waveforms`.
 
     Parameters
     ==========
     time_array: array_like
-        Times of the data (only the spacing is used: LAL's precession angles
-        are computed on the grid of the standard waveform with this spacing).
-    mass_1, mass_2, luminosity_distance, a_1, tilt_1, phi_12, a_2, tilt_2,
-    phi_jl, theta_jn, phase: float
-        As in :code:`lal_binary_black_hole_time_domain`.
+        The times of the data (only the sample spacing is used)
+    mass_1: float
+        The mass of the heavier object in solar masses
+    mass_2: float
+        The mass of the lighter object in solar masses
+    luminosity_distance: float
+        The luminosity distance in megaparsec
+    a_1: float
+        Dimensionless primary spin magnitude
+    tilt_1: float
+        Primary tilt angle
+    phi_12: float
+        Azimuthal angle between the two component spins
+    a_2: float
+        Dimensionless secondary spin magnitude
+    tilt_2: float
+        Secondary tilt angle
+    phi_jl: float
+        Azimuthal angle between the total binary angular momentum and the
+        orbital angular momentum
+    theta_jn: float
+        Angle between the total binary angular momentum and the line of sight
+    phase: float
+        The phase at reference frequency or peak amplitude (depends on waveform)
     kwargs: dict
         Optional keyword arguments
         Supported arguments:
 
-        - waveform_approximant (default IMRPhenomTPHM): IMRPhenomT,
-          IMRPhenomTHM, IMRPhenomTP or IMRPhenomTPHM
+        - waveform_approximant: IMRPhenomT, IMRPhenomTHM, IMRPhenomTP or IMRPhenomTPHM
         - reference_frequency
         - minimum_frequency
         - catch_waveform_errors
-        - mode_array (see :code:`lal_binary_black_hole`)
+        - mode_array: see :code:`lal_binary_black_hole`
         - lal_waveform_dictionary
+    - start_at_higher_mode_frequency: see :code:`lal_binary_black_hole_time_domain`
 
     Returns
     =======
-    dict: polarizations_at: function of times (s, relative to the model's
-    t=0) returning dict(plus=..., cross=...), or None if the waveform failed
-    and catch_waveform_errors is True.
-
-    Notes
-    =====
-    No taper is applied: the waveform switches on abruptly at LAL's start
-    time (set by minimum_frequency). A taper would need that start time,
-    which is computed inside the lalsimulation functions and is not
-    returned. To add one later, return the start time from those functions
-    (or compute it the way LAL does), then multiply by a one-sided Tukey
-    window in model time, as turn_on_window does for "nearest" and
-    "fd_shift".
+    dict: polarizations_at, a function of the times relative to the merger (in s)
+    which returns the plus and cross polarizations (None if the waveform failed)
     """
     from .model_time_waveforms import polarizations_at_model_times
 
-    evaluate = _model_time_function(
+    return dict(polarizations_at=_model_time_function(
         polarizations_at_model_times, time_array, mass_1, mass_2, luminosity_distance,
-        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs)
-
-    def polarizations_at(times):
-        polarizations = evaluate(times)
-        if polarizations is None:
-            return None
-        plus, cross = polarizations
-        return dict(plus=plus, cross=cross)
-
-    return dict(polarizations_at=polarizations_at)
+        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs))
 
 
 def lal_binary_black_hole_time_domain_heterodyning(
         time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
         phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
-    """ Source model for
-    :code:`bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient`
-    (IMRPhenomT, IMRPhenomTHM, IMRPhenomTP, IMRPhenomTPHM).
+    """ A time-domain Binary Black Hole waveform model for the IMRPhenomT family, for
+    :code:`bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient`. See
+    :code:`bilby.gw.model_time_waveforms.heterodyning_terms_at_model_times`.
 
-    No waveform is generated here. The returned function gives, at times
-    relative to the model's t=0 (in seconds), the modes and harmonic factors of
-    :code:`bilby.gw.model_time_waveforms.heterodyning_terms_at_model_times`:
-    the co-precessing modes for IMRPhenomTP/TPHM and the modes with m > 0 for
-    IMRPhenomT/THM.
+    Parameters and keyword arguments are as in
+    :code:`lal_binary_black_hole_model_time`, and, set by the likelihood:
 
-    Parameters and keyword arguments are those of
-    :code:`lal_binary_black_hole_model_time`, and (set by the likelihood):
-
-        - fiducial: if 1, the waveform starts at fiducial_minimum_frequency
-          (fiducial waveform); if 0 (default), at sampled_minimum_frequency
-          (waveforms at sampled parameters).
-        - fiducial_minimum_frequency (default: minimum_frequency)
-        - sampled_minimum_frequency (default: minimum_frequency - 2 Hz)
+    - fiducial: if 1, the waveform starts at fiducial_minimum_frequency, otherwise
+      at sampled_minimum_frequency
+    - fiducial_minimum_frequency (default: the start frequency)
+    - sampled_minimum_frequency (default: 2 Hz below the start frequency)
 
     Returns
     =======
-    dict: heterodyning_terms_at: function of times returning (modes,
-    harmonics), or None if the waveform failed and catch_waveform_errors is
-    True.
+    dict: heterodyning_terms_at, a function of the times relative to the merger
+    (in s) which returns the modes and harmonic factors (None if the waveform failed)
     """
     from .model_time_waveforms import heterodyning_terms_at_model_times
 
+    from .time_domain_utils import time_domain_start_frequency
+
     fiducial = kwargs.pop("fiducial", 0)
     fiducial_minimum_frequency = kwargs.pop("fiducial_minimum_frequency", None)
-    sampled_minimum_frequency = kwargs.pop("sampled_minimum_frequency", kwargs.get("minimum_frequency", 20.0) - 2)
-    if not fiducial:
-        kwargs["minimum_frequency"] = sampled_minimum_frequency
-    elif fiducial_minimum_frequency is not None:
-        kwargs["minimum_frequency"] = fiducial_minimum_frequency
+    sampled_minimum_frequency = kwargs.pop("sampled_minimum_frequency", None)
+    start_frequency = kwargs.get("minimum_frequency", 20.0)
+    if kwargs.pop("start_at_higher_mode_frequency", True):
+        start_frequency = time_domain_start_frequency(
+            start_frequency, kwargs.get("waveform_approximant", "IMRPhenomTPHM"), kwargs.get("mode_array"))
+    if fiducial:
+        kwargs["minimum_frequency"] = start_frequency if fiducial_minimum_frequency is None \
+            else fiducial_minimum_frequency
+    else:
+        kwargs["minimum_frequency"] = start_frequency - 2 if sampled_minimum_frequency is None \
+            else sampled_minimum_frequency
     return dict(heterodyning_terms_at=_model_time_function(
         heterodyning_terms_at_model_times, time_array, mass_1, mass_2, luminosity_distance,
-        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs))
+        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase,
+        start_at_higher_mode_frequency=False, **kwargs))
 
 
 def _model_time_function(
         function, time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1,
         phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs):
-    """ The function of times (s, relative to the model's t=0) that calls a
-    function of :code:`bilby.gw.model_time_waveforms` with these parameters
-    (returns None if the waveform failed and catch_waveform_errors is True). """
-    from .model_time_waveforms import check_arguments, total_mass_in_seconds
+    """ The function of the times relative to the merger (in s) which evaluates
+    `function` of :code:`bilby.gw.model_time_waveforms` with these parameters
+    """
+    import lal
+    from .model_time_waveforms import spin_arguments
+    from .time_domain_utils import time_domain_start_frequency
 
     waveform_kwargs = dict(
         waveform_approximant='IMRPhenomTPHM', reference_frequency=50.0,
         minimum_frequency=20.0, catch_waveform_errors=False,
         pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
-        pn_amplitude_order=0)
+        pn_amplitude_order=0, start_at_higher_mode_frequency=True)
     waveform_kwargs.update(kwargs)
     waveform_approximant = waveform_kwargs.pop('waveform_approximant')
     reference_frequency = waveform_kwargs.pop('reference_frequency')
     minimum_frequency = waveform_kwargs.pop('minimum_frequency')
     catch_waveform_errors = waveform_kwargs.pop('catch_waveform_errors')
+    if waveform_kwargs.pop('start_at_higher_mode_frequency'):
+        minimum_frequency = time_domain_start_frequency(
+            minimum_frequency, waveform_approximant, waveform_kwargs.get('mode_array'))
     waveform_dictionary = set_waveform_dictionary(waveform_kwargs)
     if len(waveform_kwargs) > 0:
         raise ValueError(UNUSED_KWARGS_MESSAGE.format(waveform_kwargs=waveform_kwargs))
@@ -1025,8 +1050,8 @@ def _model_time_function(
         theta_jn=theta_jn, phi_jl=phi_jl, tilt_1=tilt_1, tilt_2=tilt_2,
         phi_12=phi_12, a_1=a_1, a_2=a_2, mass_1=mass_1, mass_2=mass_2,
         reference_frequency=reference_frequency, phase=phase)
-    check_arguments(waveform_approximant, spin_1x, spin_1y, spin_2x, spin_2y)
-    total_mass = total_mass_in_seconds(mass_1, mass_2)
+    spin_arguments(waveform_approximant, spin_1x, spin_1y, spin_1z, spin_2x, spin_2y, spin_2z)
+    total_mass = (mass_1 / lal.MSUN_SI + mass_2 / lal.MSUN_SI) * lal.MTSUN_SI  # M in s, as lalsimulation computes it
 
     def evaluate(times):
         try:
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 87b6560b3..6e3240f2f 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -1,30 +1,63 @@
 """
-Utilities for time-domain gravitational-wave inference.
-
-* Gohberg-Semencul representation of the inverse of a symmetric Toeplitz
-  noise covariance matrix.
-* Placement of a time-domain waveform, generated on its own uniform grid, into
-  a segment of detector data.
+Utilities for time-domain gravitational-wave inference: products with the
+inverse of a Toeplitz noise covariance matrix, and placement of a time-domain
+waveform on the data samples.
 """
 import numpy as np
 from scipy.fft import next_fast_len
 from scipy.linalg import solve_toeplitz
 
+from .utils import safe_cast_mode_to_int
+
+# largest l of the default modes of time-domain approximants with higher modes
+HIGHER_MODE_L_MAX = dict(IMRPhenomTHM=5, IMRPhenomTPHM=5, SEOBNRv4HM=5, SEOBNRv4PHM=5,
+                         NRSur7dq4=4, NRHybSur3dq8=5)
+
+
+def time_domain_start_frequency(minimum_frequency, waveform_approximant, mode_array=None):
+    """ The frequency of the (2, 2) mode at which a time-domain waveform starts
+    so that its modes with l <= 4 are present from `minimum_frequency`
+
+    In the inspiral, the frequency of the (l, m) mode is m / 2 times that of the
+    (2, 2) mode, so the waveform starts at 2 / min(l_max, 4) x `minimum_frequency`,
+    where l_max is the largest l of the modes. See Ursell et al. arXiv:2510.15048.
+
+    Parameters
+    ==========
+    minimum_frequency: float
+        The frequency (in Hz) from which all modes should be present
+    waveform_approximant: str
+        The waveform approximant; approximants not in :code:`HIGHER_MODE_L_MAX`
+        are taken to contain only l = 2 modes
+    mode_array: list, optional
+        The modes used, as in :code:`bilby.gw.source.lal_binary_black_hole`;
+        default: all modes of the approximant
+
+    Returns
+    =======
+    float: The start frequency (in Hz)
+    """
+    if mode_array is None:
+        l_max = HIGHER_MODE_L_MAX.get(waveform_approximant, 2)
+    else:
+        l_max = max(safe_cast_mode_to_int(mode[0]) for mode in mode_array)
+    return minimum_frequency * 2 / min(max(l_max, 2), 4)
+
 
 def gohberg_semencul_vectors(acf):
-    """ Gohberg-Semencul generators of the inverse of the Toeplitz matrix
-    built from :code:`acf`.
+    """ The Gohberg-Semencul vectors of the inverse of the symmetric Toeplitz matrix
+    with first row `acf` (Gohberg & Semencul 1972), computed with the Levinson
+    recursion
 
     Parameters
     ==========
     acf: array_like
-        Autocovariance function at lags 0, 1, ..., N - 1 (first row of the
-        N x N covariance matrix).
+        The first row of the covariance matrix
 
     Returns
     =======
     x, y: array_like
-        x is the first column of C^-1 and y is x reversed.
+        The first column of the inverse matrix, and the same reversed
     """
     acf = np.asarray(acf, dtype=float)
     unit_vector = np.zeros(len(acf))
@@ -34,29 +67,20 @@ def gohberg_semencul_vectors(acf):
 
 
 def gohberg_semencul_product(x, y, vector):
-    """ Product :math:`C^{-1} v` of the inverse of a symmetric Toeplitz matrix
-    with a vector, from its Gohberg-Semencul vectors, without forming
-    :math:`C^{-1}`:
-
-    .. math::
-
-        C^{-1} v = \\frac{1}{x_0} \\left[ L(x) L(x)^T v - L(Z y) L(Z y)^T v \\right],
-
-    where :math:`L(w)` is the lower-triangular Toeplitz matrix with first
-    column :math:`w` and :math:`Z` shifts down by one sample. Each product
-    with a triangular Toeplitz matrix is computed with FFTs of length
-    :code:`next_fast_len(2 N - 1)`.
+    """ The product of the inverse of a symmetric Toeplitz matrix with a vector,
+    computed from its Gohberg-Semencul vectors with FFTs, without forming the
+    inverse matrix (Gohberg & Semencul 1972)
 
     Parameters
     ==========
     x, y: array_like
-        Gohberg-Semencul vectors from :code:`gohberg_semencul_vectors`.
+        The Gohberg-Semencul vectors, from :code:`gohberg_semencul_vectors`
     vector: array_like
-        The vector v, of the same length as x.
+        The vector, of the same length as `x`
 
     Returns
     =======
-    array_like: :math:`C^{-1} v`
+    array_like: The product of the inverse matrix with `vector`
     """
     x = np.asarray(x, dtype=float)
     number_of_samples = len(x)
@@ -65,7 +89,7 @@ def gohberg_semencul_product(x, y, vector):
     zy_fft = np.fft.rfft(np.concatenate(([0.0], np.asarray(y, dtype=float)[:-1])), n=fft_length)
 
     def lower(w_fft, vector_fft):
-        """ L(w) v from the transforms of w and v. """
+        """ The product of the lower-triangular Toeplitz matrix with first column w and v, from their FFTs """
         return np.fft.irfft(w_fft * vector_fft, n=fft_length)[:number_of_samples]
 
     # L(w)^T v = reverse(L(w) reverse(v))
@@ -76,23 +100,20 @@ def lower(w_fft, vector_fft):
 
 
 def fractional_time_shift(signal, fraction, pad=32):
-    """ Delay a time series by a fraction of a sample with a Fourier phase
-    shift, on a zero-padded copy so that nothing wraps around.
+    """ Delay a time series by a fraction of a sample with a Fourier phase shift
 
     Parameters
     ==========
     signal: array_like
-        The time series.
+        The time series
     fraction: float
-        Delay in samples (positive values move the signal later).
+        The delay in samples (positive values delay the signal)
     pad: int
-        Number of zero samples added before and after the signal.
+        The number of zeros added before and after the signal, so that nothing wraps around
 
     Returns
     =======
-    shifted: array_like
-        The delayed series, of length len(signal) + 2 * pad (sample k
-        corresponds to sample k - pad of the input).
+    array_like: The delayed time series, of length len(signal) + 2 * pad
     """
     signal = np.asarray(signal, dtype=float)
     length = next_fast_len(len(signal) + 2 * pad)
@@ -105,8 +126,7 @@ def fractional_time_shift(signal, fraction, pad=32):
 
 
 def _copy_into_segment(signal, offset, number_of_samples):
-    """ Put signal sample k at data index offset + k and return data indices
-    [0, number_of_samples); zero elsewhere. """
+    """ Put `signal` at data indices `offset`, `offset` + 1, ... of a segment of `number_of_samples` zeros """
     segment = np.zeros(number_of_samples)
     first = max(0, -offset)
     last = min(len(signal), number_of_samples - offset)
@@ -116,23 +136,24 @@ def _copy_into_segment(signal, offset, number_of_samples):
 
 
 def times_from_merger(start_time, number_of_samples, sampling_frequency, geocent_time, time_delay):
-    """ Times of data samples relative to the arrival of the model's t=0 in a
-    detector, t_k - (geocent_time + time_delay), as for ringdown analyses.
+    """ The times of data samples relative to the arrival of the merger at a detector
 
     Parameters
     ==========
     start_time: float
-        GPS time of the first data sample.
+        The GPS time of the first data sample
     number_of_samples: int
+        The number of data samples
     sampling_frequency: float
+        The sampling frequency (in Hz)
     geocent_time: float
-        GPS time at which the model's t=0 arrives at the geocenter.
+        The GPS time of the merger at the geocenter
     time_delay: float
-        Time delay of the detector from the geocenter (s).
+        The time delay of the detector from the geocenter (in s)
 
     Returns
     =======
-    array_like: times (s)
+    array_like: The times (in s)
     """
     # subtract the two GPS times (~1e9 s) first, then add the small terms
     return (start_time - geocent_time) - time_delay + np.arange(number_of_samples) / sampling_frequency
@@ -140,33 +161,30 @@ def times_from_merger(start_time, number_of_samples, sampling_frequency, geocent
 
 def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samples,
                              placement="nearest"):
-    """ Place a time-domain signal, generated on its own grid with the data's
-    sample spacing, on the data samples.
+    """ Place a time-domain signal, sampled at the sampling frequency of the data,
+    on the data samples
 
-    Waveform sample k has time (k - merger_index) / f_s relative to the
-    model's t=0, which arrives at data index `arrival_index`. Waveform samples
-    outside the data are dropped and data samples the waveform does not reach
-    are zero.
+    Signal samples outside the data are dropped and data samples not covered by
+    the signal are zero.
 
     Parameters
     ==========
     signal: array_like
-        Detector signal on its own grid.
+        The signal on its own time grid
     merger_index: float
-        Index of the model's t=0 in `signal`.
+        The index of the merger in `signal`
     arrival_index: float
-        Index in the data at which the model's t=0 arrives.
+        The index in the data at which the merger arrives
     number_of_samples: int
-        Number of data samples.
+        The number of data samples
     placement: str
-        - "nearest" (default): `merger_index` and `arrival_index` are each
-          rounded to the nearest sample.
-        - "fd_shift": whole samples are shifted by index and the remaining
-          fraction with a Fourier phase shift of a zero-padded copy.
+        "nearest": shift by the nearest whole number of samples;
+        "fd_shift": shift by whole samples and the remaining fraction of a
+        sample with :code:`fractional_time_shift`
 
     Returns
     =======
-    array_like: The signal on the data samples.
+    array_like: The signal on the data samples
     """
     if placement == "nearest":
         offset = round(arrival_index) - round(merger_index)
diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
index 226b33eec..49657e399 100644
--- a/examples/gw_examples/data_examples/GW150914_time_domain.py
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -23,6 +23,7 @@
 [1] https://gwpy.github.io/docs/stable/timeseries/remote-access.html
 """
 import bilby
+import h5py
 from gwpy.timeseries import TimeSeries
 
 logger = bilby.core.utils.logger
@@ -48,17 +49,19 @@
 padding = duration / 2
 
 # File with the PSDs and their frequency arrays (psds/h1_psd/frequency,
-# psds/h1_psd/spectrum, ...). GWTC PESummary release files are also read, with
-# label= the analysis, e.g. "C01:IMRPhenomXPHM".
+# psds/h1_psd/spectrum, ...). For a GWTC PESummary release file, use instead
+# ff[label]["psds"][det][:, 0] and [:, 1], with label the analysis, e.g. "C01:IMRPhenomXPHM".
 psd_file = "GW150914_data.h5"
-psds = bilby.gw.detector.read_power_spectral_densities_from_hdf5(psd_file, detectors)
+with h5py.File(psd_file, "r") as ff:
+    psds = {det: (ff["psds"][f"{det.lower()}_psd"]["frequency"][:], ff["psds"][f"{det.lower()}_psd"]["spectrum"][:])
+            for det in detectors}
 
 # We now use gwpy to obtain the analysis data and create the ifo_list
 ifo_list = bilby.gw.detector.InterferometerList([])
 for det in detectors:
     logger.info("Downloading analysis data for ifo {}".format(det))
     ifo = bilby.gw.detector.get_empty_interferometer(det)
-    ifo.analysis_window = (start_time, duration)
+    ifo.set_analysis_window(start_time, duration)
     data = TimeSeries.fetch_open_data(det, start_time - padding, end_time + padding)
     ifo.strain_data.set_from_gwpy_timeseries(data)
     ifo.condition_strain_data(sampling_frequency)
diff --git a/test/gw/likelihood/time_domain_heterodyning_test.py b/test/gw/likelihood/time_domain_heterodyning_test.py
index 7a032b5f1..9c8776b5c 100644
--- a/test/gw/likelihood/time_domain_heterodyning_test.py
+++ b/test/gw/likelihood/time_domain_heterodyning_test.py
@@ -54,16 +54,17 @@ def heterodyning_generator(approximant="IMRPhenomTPHM", **kwargs):
     return generator(bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning, approximant, **kwargs)
 
 
-def interferometers(approximant="IMRPhenomTPHM", injection=INJECTION, duration=DURATION, start_time=START_TIME):
+def interferometers(approximant="IMRPhenomTPHM", injection=INJECTION, duration=DURATION, start_time=START_TIME,
+                    analysis_segment="imr", segment_cut_time=None):
     ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
     for ifo in ifos:
         ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
-    ifos.set_analysis_windows(duration=duration, start_time=start_time, analysis_segment="imr",
-                              cut_reference_parameters=injection)
+    ifos.set_analysis_windows(duration=duration, start_time=start_time, analysis_segment=analysis_segment,
+                              segment_cut_time=segment_cut_time, cut_reference_parameters=injection)
     random_state = np.random.default_rng(3)
     for ifo in ifos:
         ifo.set_strain_data_from_power_spectral_density(
-            SAMPLING_FREQUENCY, ifo.analysis_window["duration"], ifo.analysis_window["start_time"],
+            SAMPLING_FREQUENCY, ifo.analysis_duration, ifo.analysis_start_time,
             random_state=random_state)
     ifos.set_autocovariance_functions_from_power_spectral_densities()
     ifos.inject_signal_time_domain(
@@ -108,10 +109,9 @@ def test_terms_reproduce_polarizations(self):
         from bilby.gw.model_time_waveforms import (
             heterodyning_terms_at_model_times,
             polarizations_at_model_times,
-            total_mass_in_seconds,
         )
         mass_1, mass_2 = 36 * lal.MSUN_SI, 29 * lal.MSUN_SI
-        model_times = np.linspace(-0.7, 0.05, 300) / total_mass_in_seconds(mass_1, mass_2)
+        model_times = np.linspace(-0.7, 0.05, 300) / ((mass_1 / lal.MSUN_SI + mass_2 / lal.MSUN_SI) * lal.MTSUN_SI)
         for approximant, spins in [("IMRPhenomT", (0, 0, 0.3, 0, 0, -0.2)),
                                    ("IMRPhenomTHM", (0, 0, 0.3, 0, 0, -0.2)),
                                    ("IMRPhenomTP", (0.4, 0.2, 0.3, -0.1, 0.3, -0.2)),
@@ -119,12 +119,13 @@ def test_terms_reproduce_polarizations(self):
             with self.subTest(approximant=approximant):
                 arguments = (model_times, approximant, mass_1, mass_2, *spins, 1e9 * lal.PC_SI, 0.7, 1.3,
                              1 / SAMPLING_FREQUENCY, 20.0, 20.0, lal.CreateDict())
-                plus, cross = polarizations_at_model_times(*arguments)
+                polarizations = polarizations_at_model_times(*arguments)
                 modes, harmonics = heterodyning_terms_at_model_times(*arguments)
                 self.assertTrue(all(m >= 0 for _, m in modes))
                 waveform = sum(harmonics[key][0] * mode + harmonics[key][1] * np.conj(mode)
                                for key, mode in modes.items())
-                self.assertLess(np.max(abs(waveform - (plus - 1j * cross))) / np.max(abs(plus)), 1e-12)
+                expected = polarizations["plus"] - 1j * polarizations["cross"]
+                self.assertLess(np.max(abs(waveform - expected)) / np.max(abs(polarizations["plus"])), 1e-12)
 
 
 @unittest.skipUnless(_has_model_time_waveforms(), "lalsimulation without the model-time IMRPhenomT functions")
@@ -149,6 +150,27 @@ def test_matches_exact_likelihood(self):
                 self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
                                     - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
 
+    def test_matches_exact_likelihood_in_inspiral_and_post_inspiral_windows(self):
+        # windows ending / starting 30 ms before the merger
+        segments = dict(inspiral=dict(analysis_segment="inspiral", duration=0.5, segment_cut_time=-0.03),
+                        post_inspiral=dict(analysis_segment="post_inspiral", duration=0.25, segment_cut_time=-0.03))
+        for approximant, injection in [("IMRPhenomTHM", ALIGNED_INJECTION), ("IMRPhenomTPHM", INJECTION)]:
+            for segment, kwargs in segments.items():
+                with self.subTest(approximant=approximant, segment=segment):
+                    ifos = interferometers(approximant, injection, **kwargs)
+                    exact = TimeDomainGravitationalWaveTransient(
+                        ifos, exact_generator(approximant), placement="model_time")
+                    heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
+                        ifos, heterodyning_generator(approximant), fiducial_parameters=injection)
+                    aligned = approximant == "IMRPhenomTHM"
+                    self.assertLess(abs(heterodyned.log_likelihood_ratio(injection)
+                                        - exact.log_likelihood_ratio(injection)), 1e-6 if aligned else 0.05)
+                    parameters = perturbed(injection)
+                    self.assertGreater(
+                        exact.log_likelihood_ratio(injection) - exact.log_likelihood_ratio(parameters), 1)
+                    self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
+                                        - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
+
     def test_use_float32(self):
         ifos = interferometers()
         values = list()
@@ -217,8 +239,10 @@ def test_time_reference(self):
             INJECTION["ra"], INJECTION["dec"], INJECTION["geocent_time"])
         exact = TimeDomainGravitationalWaveTransient(
             ifos, exact_generator(), placement="model_time", time_reference="H1")
+        # the precessing waveforms depend on their start frequency: start both at 10 Hz
         heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator(), fiducial_parameters=parameters, time_reference="H1")
+            ifos, heterodyning_generator(), fiducial_parameters=parameters, time_reference="H1",
+            sampled_minimum_frequency=10.0)
         parameters["H1_time"] += 0.0002
         self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
                             - exact.log_likelihood_ratio(parameters)), 0.05)
@@ -267,14 +291,24 @@ def test_shared_waveform_arguments_are_not_changed(self):
         TimeDomainHeterodyningGravitationalWaveTransient(ifos, generator, fiducial_parameters=INJECTION)
         self.assertEqual(set(arguments), {"waveform_approximant", "reference_frequency", "minimum_frequency"})
 
+    def test_sampled_minimum_frequency(self):
+        ifos = interferometers()
+        for option, expected in [(True, 8.0), (False, 18.0)]:
+            with self.subTest(start_at_higher_mode_frequency=option):
+                generator = heterodyning_generator()
+                generator.waveform_arguments["start_at_higher_mode_frequency"] = option
+                likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
+                    ifos, generator, fiducial_parameters=INJECTION)
+                self.assertEqual(likelihood.sampled_minimum_frequency, expected)
+
     def test_errors(self):
         ifos = interferometers()
         with self.assertRaises(ValueError):  # fiducial_minimum_frequency above the derived one
             TimeDomainHeterodyningGravitationalWaveTransient(
                 ifos, heterodyning_generator(), fiducial_parameters=INJECTION, fiducial_minimum_frequency=30.0)
-        with self.assertLogs("bilby", level="WARNING"):  # above minimum_frequency - 2 Hz
+        with self.assertLogs("bilby", level="WARNING"):  # above the start frequency - 2 Hz
             TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=19.0)
+                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=9.0)
         with self.assertRaises(NotImplementedError):
             TimeDomainHeterodyningGravitationalWaveTransient(
                 ifos, heterodyning_generator(), fiducial_parameters=INJECTION, time_marginalization=True)
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
index b94480231..599b9476c 100644
--- a/test/gw/likelihood/time_domain_test.py
+++ b/test/gw/likelihood/time_domain_test.py
@@ -46,7 +46,7 @@ def interferometers(noise="zero", acf=True, analysis_segment="imr", duration=DUR
         segment_cut_time=segment_cut_time, cut_reference_parameters=INJECTION)
     random_state = np.random.default_rng(3)
     for ifo in ifos:
-        window = (SAMPLING_FREQUENCY, ifo.analysis_window["duration"], ifo.analysis_window["start_time"])
+        window = (SAMPLING_FREQUENCY, ifo.analysis_duration, ifo.analysis_start_time)
         if noise == "zero":
             ifo.set_strain_data_from_zero_noise(*window)
         else:
@@ -119,7 +119,6 @@ def test_sampling_frequency_from_grid_and_length(self):
             self.frequencies, self.psd, 20, 400)
         self.assertEqual(acf.sampling_frequency, 1024)
         self.assertEqual(len(acf.acf_array), 8192)
-        self.assertAlmostEqual(acf.meta_data["duration"], 8)
 
     def test_sampling_frequency_mismatch_warns(self):
         with self.assertLogs("bilby", level="WARNING"):
@@ -302,7 +301,7 @@ def test_matches_lalsimulation_on_its_samples(self):
         # waveform must agree (to the ~1e-4 sample left by the precision of GPS times;
         # the first sample can fall just outside the waveform's span)
         ifo = interferometers()[0]
-        start_time = ifo.strain_data.time_array[ifo._analysis_slice().start]
+        start_time = ifo.time_array[ifo.analysis_slice][0]
         for approximant, injection in [("IMRPhenomT", ALIGNED_INJECTION), ("IMRPhenomTHM", ALIGNED_INJECTION),
                                        ("IMRPhenomTP", INJECTION), ("IMRPhenomTPHM", INJECTION)]:
             with self.subTest(approximant=approximant):
@@ -406,10 +405,10 @@ def test_analysis_data_is_the_window_slice(self):
         post_inspiral = interferometers(**SEGMENTS["post_inspiral"])
         post_inspiral.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
         for ifo, reference in zip(full, post_inspiral):
-            ifo.analysis_window = (reference.analysis_window["start_time"], reference.analysis_window["duration"])
+            ifo.set_analysis_window(reference.analysis_start_time, reference.analysis_duration)
             self.assertEqual(len(ifo.time_domain_strain), DURATION * SAMPLING_FREQUENCY)
             np.testing.assert_allclose(
-                ifo.time_array[ifo._analysis_slice()], reference.time_array[reference._analysis_slice()],
+                ifo.time_array[ifo.analysis_slice], reference.time_array[reference.analysis_slice],
                 atol=1e-6)
             np.testing.assert_allclose(ifo.analysis_data, reference.analysis_data, atol=1e-30)
 
@@ -428,10 +427,10 @@ def _sine_data(self, start_time, duration, sampling_frequency=4096):
 
     def test_downsample(self):
         ifo = self._sine_data(1000.0, 16)
-        ifo.analysis_window = (1006.0, 4)
+        ifo.set_analysis_window(1006.0, 4)
         ifo.condition_strain_data(1024)
         self.assertEqual(ifo.sampling_frequency, 1024)
-        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0)
+        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0)
         self.assertEqual(len(ifo.analysis_data), 4096)
         # the 60 Hz line is kept and the 1500 Hz line (above the new Nyquist frequency) removed
         expected = np.sin(2 * np.pi * 60 * ifo.time_array)
@@ -439,46 +438,36 @@ def test_downsample(self):
 
     def test_decimate(self):
         ifo = self._sine_data(1000.0001, 16)
-        ifo.analysis_window = (1006.0, 4)
+        ifo.set_analysis_window(1006.0, 4)
         ifo.condition_strain_data(1024, taper_and_trim=False, remove_mean=False)
         self.assertEqual(ifo.sampling_frequency, 1024)
         self.assertEqual(ifo.duration, 16)
-        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0, 3)
+        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0, 3)
         self.assertEqual(len(ifo.analysis_data), 4096)
         # the 60 Hz line is kept (up to the filter ripple) and the 1500 Hz line removed
-        expected = np.sin(2 * np.pi * 60 * ifo.time_array[ifo._analysis_slice()])
+        expected = np.sin(2 * np.pi * 60 * ifo.time_array[ifo.analysis_slice])
         np.testing.assert_allclose(ifo.analysis_data, expected, atol=1e-2)
 
     def test_downsample_data_slightly_off_grid(self):
         ifo = self._sine_data(1004.0001, 8)
-        ifo.analysis_window = (1006.0, 4)
+        ifo.set_analysis_window(1006.0, 4)
         ifo.condition_strain_data(1024)
         self.assertEqual(len(ifo.analysis_data), 4096)
-        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0, 3)
+        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0, 3)
 
     def test_downsample_needs_buffer(self):
         ifo = self._sine_data(1005.0, 6)
-        ifo.analysis_window = (1006.0, 4)
+        ifo.set_analysis_window(1006.0, 4)
         with self.assertRaises(ValueError):
             ifo.condition_strain_data(1024)
 
     def test_data_not_conditioned_by_default(self):
         ifo = self._sine_data(1000.0, 16)
-        ifo.analysis_window = (1006.0, 4)
+        ifo.set_analysis_window(1006.0, 4)
         self.assertEqual(len(ifo.time_domain_strain), 16 * 4096)
-        self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0)
+        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0)
         self.assertEqual(len(ifo.analysis_data), 4 * 4096)
 
-    def test_network_downsample(self):
-        ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
-        ifos.set_strain_data_from_power_spectral_densities(4096, 16, 1000, random_state=2)
-        ifos.set_analysis_windows(duration=4, start_time=1006)
-        ifos.condition_strain_data(2048)
-        for ifo in ifos:
-            self.assertEqual(ifo.sampling_frequency, 2048)
-            self.assertAlmostEqual(ifo.time_array[ifo._analysis_slice()][0], 1006.0)
-            self.assertEqual(len(ifo.analysis_data), 4 * 2048)
-
 
 class TestTimeDomainSourceModels(unittest.TestCase):
     def setUp(self):
@@ -491,6 +480,21 @@ def setUp(self):
             waveform_approximant="IMRPhenomXP", reference_frequency=20.0,
             minimum_frequency=20.0, turn_on_window=0)
 
+    def test_start_frequency(self):
+        from bilby.gw.time_domain_utils import time_domain_start_frequency
+        self.assertEqual(time_domain_start_frequency(20, "IMRPhenomT"), 20)
+        self.assertEqual(time_domain_start_frequency(20, "IMRPhenomTPHM"), 10)
+        self.assertAlmostEqual(time_domain_start_frequency(20, "IMRPhenomTHM", mode_array=[[2, 2], [3, 3]]), 40 / 3)
+        self.assertEqual(time_domain_start_frequency(20, "IMRPhenomTHM", mode_array=[[2, 2], [2, 1]]), 20)
+
+    def test_start_at_higher_mode_frequency(self):
+        # IMRPhenomTHM from 10 Hz by default: longer than from 20 Hz
+        lengths = [len(bilby.gw.source.lal_binary_black_hole_time_domain(
+            self.time_array, **dict(self.parameters, tilt_1=0, tilt_2=0),
+            **dict(self.waveform_kwargs, waveform_approximant="IMRPhenomTHM"), **option)["plus"])
+            for option in (dict(), dict(start_at_higher_mode_frequency=False))]
+        self.assertGreater(lengths[0], 3 * lengths[1])
+
     def test_output_on_own_grid(self):
         output = bilby.gw.source.lal_binary_black_hole_time_domain(
             self.time_array, **self.parameters, **self.waveform_kwargs)
@@ -544,49 +548,5 @@ def test_unused_arguments_raise(self):
                 self.time_array, **self.parameters, **self.waveform_kwargs, not_an_argument=1)
 
 
-class TestNoiseInputs(unittest.TestCase):
-    def test_read_power_spectral_densities_from_hdf5(self):
-        import h5py
-        frequencies = np.arange(0, 1024.125, 0.125)
-        psd = 1e-46 * (1 + (50 / np.maximum(frequencies, 1)) ** 4)
-        directory = tempfile.mkdtemp()
-        try:
-            simple = os.path.join(directory, "simple.h5")
-            with h5py.File(simple, "w") as ff:
-                for ifo in ["h1", "l1"]:
-                    ff.create_dataset(f"psds/{ifo}_psd/frequency", data=frequencies)
-                    ff.create_dataset(f"psds/{ifo}_psd/spectrum", data=psd)
-            pesummary = os.path.join(directory, "pesummary.h5")
-            with h5py.File(pesummary, "w") as ff:
-                for label in ["C01:IMRPhenomXPHM", "C01:SEOBNRv4PHM"]:
-                    for ifo in ["H1", "L1"]:
-                        ff.create_dataset(f"{label}/psds/{ifo}", data=np.array([frequencies, psd]).T)
-            read = bilby.gw.detector.read_power_spectral_densities_from_hdf5
-            for output in [read(simple, ["H1", "L1"]),
-                           read(pesummary, ["H1", "L1"], label="C01:IMRPhenomXPHM")]:
-                self.assertEqual(set(output), {"H1", "L1"})
-                np.testing.assert_array_equal(output["L1"][0], frequencies)
-                np.testing.assert_array_equal(output["L1"][1], psd)
-            with self.assertRaises(ValueError):
-                read(pesummary, ["H1"])  # two analyses: label needed
-        finally:
-            shutil.rmtree(directory)
-
-    def test_welch_acf_agrees_with_psd_acf(self):
-        ifo = bilby.gw.detector.get_empty_interferometer("H1")
-        ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
-        ifo.set_strain_data_from_power_spectral_density(SAMPLING_FREQUENCY, 256, 0, random_state=11)
-        noise = ifo.time_domain_strain.copy()
-        ifo.analysis_window = (0, 1)
-        ifo.set_autocovariance_function_from_power_spectral_density()
-        from_data = AutoCovarianceFunction.from_time_domain_strain(
-            noise, SAMPLING_FREQUENCY, analysis_duration=1, minimum_frequency=20, maximum_frequency=448)
-        times = np.arange(SAMPLING_FREQUENCY) / SAMPLING_FREQUENCY
-        signal = 1e-22 * np.exp(-0.5 * ((times - 0.5) / 0.05) ** 2) * np.sin(2 * np.pi * 120 * times)
-        snr_squared = [gohberg_semencul_product(*acf.gohberg_semencul_vectors(len(times)), signal) @ signal
-                       for acf in [ifo.autocovariance_function, from_data]]
-        self.assertAlmostEqual(snr_squared[1] / snr_squared[0], 1, delta=0.1)
-
-
 if __name__ == "__main__":
     unittest.main()

From e61d436b72a6107cde2d2818f2bdff7a8f3ff6ff Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Fri, 16 Oct 2026 17:39:20 +0530
Subject: [PATCH 14/21] Error message added

---
 bilby/gw/detector/interferometer.py           | 13 ++++++++++
 bilby/gw/detector/networks.py                 |  6 +++++
 bilby/gw/likelihood/time_domain.py            |  7 +++++
 bilby/gw/time_domain_utils.py                 |  7 +++--
 .../time_domain_heterodyning.py               | 12 ++++-----
 test/gw/likelihood/time_domain_test.py        | 26 ++++++++++++++++---
 6 files changed, 58 insertions(+), 13 deletions(-)

diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index 63147ad6a..c4b1baa65 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -353,6 +353,13 @@ def autocovariance_function(self, autocovariance_function):
             return
         if self.analysis_duration is None:
             raise ValueError(f"{self.name}: set the analysis window first (set_analysis_window)")
+        if self.strain_data.sampling_frequency is not None and not np.isclose(
+                autocovariance_function.sampling_frequency, self.strain_data.sampling_frequency,
+                rtol=1e-9, atol=0):
+            raise ValueError(
+                f"{self.name}: the sampling frequency of the autocovariance function "
+                f"({autocovariance_function.sampling_frequency:g} Hz) differs from that of the strain data "
+                f"({self.strain_data.sampling_frequency:g} Hz)")
         self.meta_data["autocovariance_function"] = autocovariance_function.meta_data
         self.gohberg_semencul_vectors = gohberg_semencul_vectors(autocovariance_function.get_acf_array(
             int(round(self.analysis_duration * autocovariance_function.sampling_frequency))))
@@ -635,6 +642,12 @@ def inject_signal_time_domain_from_waveform_generator(self, parameters, waveform
         injection_polarizations: dict
             The internally generated injection parameters
         """
+        if waveform_generator.sampling_frequency is not None and not np.isclose(
+                waveform_generator.sampling_frequency, self.sampling_frequency, rtol=1e-9, atol=0):
+            raise ValueError(
+                f"{self.name}: the sampling frequency of the waveform generator "
+                f"({waveform_generator.sampling_frequency:g} Hz) differs from that of the strain data "
+                f"({self.sampling_frequency:g} Hz)")
         injection_polarizations = \
             waveform_generator.time_domain_strain(parameters)
         self.inject_signal_time_domain_from_waveform_polarizations(
diff --git a/bilby/gw/detector/networks.py b/bilby/gw/detector/networks.py
index 6ef785588..0f4034362 100644
--- a/bilby/gw/detector/networks.py
+++ b/bilby/gw/detector/networks.py
@@ -281,6 +281,12 @@ def inject_signal_time_domain(
         """
         if injection_polarizations is None:
             if waveform_generator is not None:
+                if waveform_generator.sampling_frequency is not None and not np.isclose(
+                        waveform_generator.sampling_frequency, self.sampling_frequency, rtol=1e-9, atol=0):
+                    raise ValueError(
+                        f"The sampling frequency of the waveform generator "
+                        f"({waveform_generator.sampling_frequency:g} Hz) differs from that of the strain "
+                        f"data ({self.sampling_frequency:g} Hz)")
                 injection_polarizations = waveform_generator.time_domain_strain(
                     parameters
                 )
diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index 49251faa0..4bb704cac 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -150,6 +150,13 @@ def _setup_noise_model(self):
                     f"{interferometer.name}: autocovariance function sampling frequency "
                     f"{acf.sampling_frequency:g} Hz differs from the data's "
                     f"{interferometer.sampling_frequency:g} Hz")
+            nyquist_frequency = interferometer.sampling_frequency / 2
+            if interferometer.maximum_frequency < nyquist_frequency and not np.isclose(
+                    interferometer.maximum_frequency, nyquist_frequency, rtol=1e-9, atol=0):
+                logger.warning(
+                    f"{interferometer.name}: {interferometer.maximum_frequency:g} - {nyquist_frequency:g} Hz "
+                    "is outside the band and filled in the autocovariance function (consider downsampling "
+                    f"the data to {2 * interferometer.maximum_frequency:g} Hz with condition_strain_data)")
             data = interferometer.analysis_data
             data_times_inverse_covariance = gohberg_semencul_product(
                 *interferometer.gohberg_semencul_vectors, data)
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 6e3240f2f..68f27e012 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -178,7 +178,7 @@ def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samp
     number_of_samples: int
         The number of data samples
     placement: str
-        "nearest": shift by the nearest whole number of samples;
+        "nearest": shift by the whole number of samples nearest to the delay;
         "fd_shift": shift by whole samples and the remaining fraction of a
         sample with :code:`fractional_time_shift`
 
@@ -186,12 +186,11 @@ def place_time_domain_signal(signal, merger_index, arrival_index, number_of_samp
     =======
     array_like: The signal on the data samples
     """
+    position = arrival_index - merger_index
+    offset = int(np.floor(position + 0.5))
     if placement == "nearest":
-        offset = round(arrival_index) - round(merger_index)
         return _copy_into_segment(signal, offset, number_of_samples)
     elif placement == "fd_shift":
-        position = arrival_index - merger_index
-        offset = int(np.floor(position + 0.5))
         fraction = position - offset
         pad = 32
         shifted = fractional_time_shift(signal, fraction, pad=pad)
diff --git a/examples/gw_examples/injection_examples/time_domain_heterodyning.py b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
index 404de98d3..3b378b55a 100644
--- a/examples/gw_examples/injection_examples/time_domain_heterodyning.py
+++ b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
@@ -57,12 +57,12 @@
 )
 
 # The analysis window starts inside the waveform (0.6 s before the merger;
-# from 20 Hz the waveform starts ~0.8 s before it), so that the abrupt start
-# of the waveform is not in the data. The heterodyned likelihood generates its
-# fiducial waveform from a lower frequency derived from the window, and the
-# waveforms at sampled parameters from sampled_minimum_frequency (18 Hz, 2 Hz
-# below the interferometers' minimum_frequency), so
-# that all of them are non-zero in the whole window.
+# the waveforms start at 10 Hz, so that their modes with l <= 4 are present
+# from 20 Hz), so that the start of the waveform is not in the data. The
+# heterodyned likelihood generates its fiducial waveform from a lower frequency
+# derived from the window, and the waveforms at sampled parameters from
+# sampled_minimum_frequency (8 Hz, 2 Hz below the start frequency), so that
+# all of them are non-zero in the whole window.
 duration = 1.0
 sampling_frequency = 2048.0
 minimum_frequency = 20
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
index 599b9476c..a6c53df59 100644
--- a/test/gw/likelihood/time_domain_test.py
+++ b/test/gw/likelihood/time_domain_test.py
@@ -98,6 +98,13 @@ def test_fd_shift_fraction_is_exact_for_band_limited_signal(self):
         expected = np.exp(-0.5 * ((times - 100) / 6.0) ** 2) * np.cos(0.4 * times)
         np.testing.assert_allclose(placed, expected, atol=1e-6)
 
+    def test_nearest_rounds_the_delay(self):
+        # merger at 100.6 and arrival at 150.4: a delay of 49.8 samples, rounded to 50
+        placed = place_time_domain_signal(
+            self.signal, merger_index=100.6, arrival_index=150.4,
+            number_of_samples=320, placement="nearest")
+        np.testing.assert_allclose(placed[50:50 + len(self.signal)], self.signal)
+
     def test_nothing_wraps(self):
         placed = place_time_domain_signal(
             self.signal, merger_index=100, arrival_index=10,
@@ -243,6 +250,11 @@ def test_meta_data(self):
         self.assertIn("autocovariance_function", meta_data["interferometers"]["H1"])
         self.assertEqual(meta_data["interferometers"]["H1"]["analysis_window"]["analysis_segment"], "inspiral")
 
+    def test_warns_if_data_sampled_above_twice_maximum_frequency(self):
+        with self.assertLogs("bilby", level="WARNING") as logs:
+            TimeDomainGravitationalWaveTransient(interferometers(), waveform_generator())
+        self.assertTrue(any("448 - 512 Hz is outside the band" in line for line in logs.output))
+
     def test_errors(self):
         generator = waveform_generator()
         with self.assertRaises(ValueError):
@@ -258,10 +270,9 @@ def test_errors(self):
         with self.assertRaises(ValueError):
             TimeDomainGravitationalWaveTransient(interferometers(), generator, placement="roll")
         ifos = interferometers()
-        ifos[0].autocovariance_function = AutoCovarianceFunction(
-            acf_array=ifos[0].autocovariance_function.acf_array, sampling_frequency=2048)
         with self.assertRaises(ValueError):
-            TimeDomainGravitationalWaveTransient(ifos, generator)
+            ifos[0].autocovariance_function = AutoCovarianceFunction(
+                acf_array=ifos[0].autocovariance_function.acf_array, sampling_frequency=2048)
         ifo = bilby.gw.detector.get_empty_interferometer("H1")
         with self.assertRaises(ValueError):
             ifo.autocovariance_function = AutoCovarianceFunction(np.ones(10), SAMPLING_FREQUENCY)
@@ -412,6 +423,15 @@ def test_analysis_data_is_the_window_slice(self):
                 atol=1e-6)
             np.testing.assert_allclose(ifo.analysis_data, reference.analysis_data, atol=1e-30)
 
+    def test_injection_needs_generator_at_data_sampling_frequency(self):
+        generator = waveform_generator()
+        generator.sampling_frequency = 2 * SAMPLING_FREQUENCY
+        ifos = interferometers()
+        with self.assertRaises(ValueError):
+            ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
+        with self.assertRaises(ValueError):
+            ifos[0].inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
+
     def test_injection_needs_autocovariance_function(self):
         ifos = interferometers(acf=False)
         with self.assertRaises(ValueError):

From 3faf72ca9f5a7bffbeda0cae43ca887f48fb3c4d Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Sat, 17 Oct 2026 23:58:08 +0530
Subject: [PATCH 15/21] Adding examples

---
 bilby/gw/likelihood/time_domain.py            |  22 +-
 .../gw/likelihood/time_domain_heterodyning.py | 159 +++--
 bilby/gw/source.py                            |  43 +-
 bilby/gw/time_domain_utils.py                 |  36 --
 .../data_examples/GW150914_time_domain.py     |  81 ++-
 ...binary_neutron_star_time_domain_example.py | 175 ------
 .../fast_tutorial_time_domain.py              | 153 +++++
 .../time_domain_heterodyning.py               | 159 +++--
 .../time_domain_inspiral.py                   | 168 +++++
 .../time_domain_post_inspiral.py              | 168 +++++
 .../time_domain_heterodyning_test.py          | 318 ----------
 test/gw/likelihood/time_domain_test.py        | 572 ------------------
 12 files changed, 744 insertions(+), 1310 deletions(-)
 delete mode 100644 examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
 create mode 100644 examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
 create mode 100644 examples/gw_examples/injection_examples/time_domain_inspiral.py
 create mode 100644 examples/gw_examples/injection_examples/time_domain_post_inspiral.py
 delete mode 100644 test/gw/likelihood/time_domain_heterodyning_test.py
 delete mode 100644 test/gw/likelihood/time_domain_test.py

diff --git a/bilby/gw/likelihood/time_domain.py b/bilby/gw/likelihood/time_domain.py
index 4bb704cac..436b7a018 100644
--- a/bilby/gw/likelihood/time_domain.py
+++ b/bilby/gw/likelihood/time_domain.py
@@ -3,7 +3,7 @@
 import numpy as np
 
 from ...core.utils import logger
-from ..time_domain_utils import gohberg_semencul_product, time_domain_start_frequency
+from ..time_domain_utils import gohberg_semencul_product
 from .base import GravitationalWaveTransient
 
 
@@ -107,7 +107,6 @@ def __init__(
             time_reference=time_reference,
         )
         self.placement = placement
-        self._check_minimum_frequency()
         self._setup_noise_model()
 
     def __repr__(self):
@@ -117,25 +116,6 @@ def __repr__(self):
                 self.interferometers, self.waveform_generator, self.distance_marginalization,
                 self.priors, self.placement))
 
-    def _check_minimum_frequency(self):
-        """ Warn if the minimum frequency of the waveform and of an interferometer differ,
-        and log the start frequency of the waveforms """
-        waveform_minimum_frequency = getattr(
-            self.waveform_generator, "waveform_arguments", dict()).get("minimum_frequency")
-        if waveform_minimum_frequency is None:
-            return
-        for interferometer in self.interferometers:
-            if not np.isclose(waveform_minimum_frequency, interferometer.minimum_frequency):
-                logger.warning(
-                    f"{interferometer.name}: minimum_frequency {interferometer.minimum_frequency:g} Hz "
-                    f"differs from the waveform's minimum_frequency {waveform_minimum_frequency:g} Hz")
-        arguments = self.waveform_generator.waveform_arguments
-        if arguments.get("start_at_higher_mode_frequency", True) and "waveform_approximant" in arguments:
-            start_frequency = time_domain_start_frequency(
-                waveform_minimum_frequency, arguments["waveform_approximant"], arguments.get("mode_array"))
-            logger.info(f"Waveforms start at {start_frequency:g} Hz, so that their modes with l <= 4 "
-                        f"are present from {waveform_minimum_frequency:g} Hz")
-
     def _setup_noise_model(self):
         """ Compute and store C^-1 d and d^T C^-1 d for each interferometer """
         self._data_times_inverse_covariance = dict()
diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index 4d02b383b..a00ef33f5 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -5,7 +5,7 @@
 
 from ...core.utils import gravitational_constant, logger, solar_mass, speed_of_light
 from ..conversion import component_masses_to_chirp_mass
-from ..time_domain_utils import gohberg_semencul_product, time_domain_start_frequency, times_from_merger
+from ..time_domain_utils import gohberg_semencul_product, times_from_merger
 from .relative import RelativeBinningGravitationalWaveTransient
 from .time_domain import TimeDomainGravitationalWaveTransient
 
@@ -76,10 +76,6 @@ class TimeDomainHeterodyningGravitationalWaveTransient(TimeDomainGravitationalWa
         The times relative to the merger (in s) at which `spacing` changes
     chi: float, optional
         Tunable parameter of the phase proxy. See https://arxiv.org/abs/1806.08792.
-    sampled_minimum_frequency: float, optional
-        The minimum frequency (in Hz) of the waveforms at sampled parameters,
-        default: 2 Hz below the start frequency of the waveforms (see
-        :code:`bilby.gw.time_domain_utils.time_domain_start_frequency`)
     fiducial_minimum_frequency: float, optional
         The minimum frequency (in Hz) of the fiducial waveform, default: chosen
         so that it starts before the analysis window
@@ -108,7 +104,7 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
                  distance_marginalization_lookup_table=None, reference_frame="sky",
                  time_reference="geocenter", epsilon=(0.5, 0.1), time_split=-0.02,
                  spacing=(2, 10, 100), spacing_times=(0.02, 0.1), chi=1,
-                 sampled_minimum_frequency=None, fiducial_minimum_frequency=None,
+                 fiducial_minimum_frequency=None,
                  time_marginalization=False, phase_marginalization=False,
                  calibration_marginalization=False, use_float32=False):
         super(TimeDomainHeterodyningGravitationalWaveTransient, self).__init__(
@@ -133,7 +129,6 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
         # this likelihood sets its own entries in waveform_arguments; copy the dictionary so that
         # they do not reach other waveform generators that share it
         self.waveform_generator.waveform_arguments = dict(self.waveform_generator.waveform_arguments)
-        self._set_sampled_minimum_frequency(sampled_minimum_frequency)
         self.requested_fiducial_minimum_frequency = fiducial_minimum_frequency
 
         if fiducial_parameters is None:
@@ -158,23 +153,6 @@ def __init__(self, interferometers, waveform_generator, fiducial_parameters=None
         logger.info("Summary Data Obtained")
         logger.info(f"Fiducial likelihood: {self.log_likelihood_ratio(self.fiducial_parameters):.2f}")
 
-    def _set_sampled_minimum_frequency(self, sampled_minimum_frequency):
-        arguments = self.waveform_generator.waveform_arguments
-        start_frequency = min(ifo.minimum_frequency for ifo in self.interferometers)
-        if arguments.get("start_at_higher_mode_frequency", True):
-            start_frequency = time_domain_start_frequency(
-                start_frequency, arguments.get("waveform_approximant", "IMRPhenomTPHM"), arguments.get("mode_array"))
-        maximum = start_frequency - 2
-        if sampled_minimum_frequency is None:
-            sampled_minimum_frequency = maximum
-        if sampled_minimum_frequency > maximum:
-            logger.warning(
-                f"sampled_minimum_frequency ({sampled_minimum_frequency:g} Hz) is above {maximum:g} Hz "
-                f"(2 Hz below the start frequency of the waveforms, {start_frequency:g} Hz)")
-        logger.info(f"Waveforms at sampled parameters from {sampled_minimum_frequency:g} Hz")
-        self.sampled_minimum_frequency = sampled_minimum_frequency
-        self.waveform_generator.waveform_arguments["sampled_minimum_frequency"] = sampled_minimum_frequency
-
     def _model_times(self, interferometer, indices, parameters):
         """ Times (in s) of the analysis-window samples `indices` relative to the arrival of the merger """
         # the time of the first sample, plus the samples `indices` (not all N samples)
@@ -255,12 +233,13 @@ def set_fiducial_waveforms(self, parameters):
         chirp_mass_time = component_masses_to_chirp_mass(converted["mass_1"], converted["mass_2"]) \
             * solar_mass * gravitational_constant / speed_of_light ** 3
         frequency = (5 / 256 * chirp_mass_time ** (-5 / 3) / (1.5 * max(window_start, 0) + 0.1)) ** (3 / 8) / np.pi
-        derived = min(max(frequency - 1, 1.0), self.sampled_minimum_frequency)
+        derived = min(max(frequency - 1, 1.0),
+                      self.waveform_generator.waveform_arguments.get("minimum_frequency", 20.0))
         requested = self.requested_fiducial_minimum_frequency
         if requested is not None and requested > derived:
             raise ValueError(
                 f"fiducial_minimum_frequency ({requested:g} Hz) must not be above {derived:.2f} Hz "
-                "(the lower of sampled_minimum_frequency and the frequency derived from the fiducial chirp mass "
+                "(the lower of the waveforms' minimum_frequency and the frequency derived from the fiducial chirp mass "
                 "and the start of the analysis window)")
         self.fiducial_minimum_frequency = derived if requested is None else requested
         while True:
@@ -512,14 +491,36 @@ def find_maximum_likelihood_parameters(self, parameter_bounds, maximization_kwar
         =======
         dict: The updated fiducial parameters
         """
-        from ..source import lal_binary_black_hole_model_time
-
         if maximization_kwargs is None:
             maximization_kwargs = dict()
+        exact_likelihood = self.exact_likelihood()
+
+        def negative_log_likelihood_ratio(parameter_list):
+            return -exact_likelihood.log_likelihood_ratio(self.get_parameter_dictionary_from_list(parameter_list))
+
+        start = self.get_parameter_list_from_dictionary(self.fiducial_parameters)
+        logger.info(f"Initial ln likelihood ratio: {-negative_log_likelihood_ratio(start):.2f}")
+        output = differential_evolution(
+            negative_log_likelihood_ratio, bounds=parameter_bounds, x0=start, **maximization_kwargs)
+        updated_parameters = self.get_parameter_dictionary_from_list(output["x"])
+        logger.info(f"Maximum ln likelihood ratio: {-output['fun']:.2f} at "
+                    f"{dict(zip(self.parameters_to_be_updated, output['x']))}")
+        return updated_parameters
+
+    def exact_likelihood(self):
+        """ The exact time-domain likelihood (model time) with the same data, waveform
+        model, priors and settings as this likelihood
+
+        Returns
+        =======
+        bilby.gw.likelihood.TimeDomainGravitationalWaveTransient
+        """
+        from ..source import lal_binary_black_hole_model_time
+
         waveform_arguments = {
             key: value for key, value in self.waveform_generator.waveform_arguments.items()
-            if key not in ("fiducial", "fiducial_minimum_frequency", "sampled_minimum_frequency")}
-        exact_likelihood = TimeDomainGravitationalWaveTransient(
+            if key not in ("fiducial", "fiducial_minimum_frequency")}
+        return TimeDomainGravitationalWaveTransient(
             interferometers=self.interferometers,
             waveform_generator=self.waveform_generator.__class__(
                 duration=self.waveform_generator.duration,
@@ -536,17 +537,94 @@ def find_maximum_likelihood_parameters(self, parameter_bounds, maximization_kwar
             time_reference=self.time_reference,
             placement="model_time")
 
-        def negative_log_likelihood_ratio(parameter_list):
-            return -exact_likelihood.log_likelihood_ratio(self.get_parameter_dictionary_from_list(parameter_list))
+    def compare_with_exact_likelihood(self, samples, outdir=".", label="heterodyning", n_samples=None):
+        """ Compare the heterodyned likelihood with the exact time-domain likelihood
+        (model time) at a set of samples, e.g. the posterior of a run
 
-        start = self.get_parameter_list_from_dictionary(self.fiducial_parameters)
-        logger.info(f"Initial ln likelihood ratio: {-negative_log_likelihood_ratio(start):.2f}")
-        output = differential_evolution(
-            negative_log_likelihood_ratio, bounds=parameter_bounds, x0=start, **maximization_kwargs)
-        updated_parameters = self.get_parameter_dictionary_from_list(output["x"])
-        logger.info(f"Maximum ln likelihood ratio: {-output['fun']:.2f} at "
-                    f"{dict(zip(self.parameters_to_be_updated, output['x']))}")
-        return updated_parameters
+        Saves two figures in `outdir`: `{label}_heterodyning_vs_exact.png` (both log
+        likelihood ratios against the chirp mass, heterodyned against exact, and their
+        relative difference against the chirp mass) and
+        `{label}_heterodyning_differences.png` (heterodyned minus exact against the
+        other parameters).
+
+        Parameters
+        ==========
+        samples: pandas.DataFrame or dict
+            The samples, e.g. :code:`result.posterior`
+        outdir: str
+            The directory for the figures
+        label: str
+            The label used in the file names
+        n_samples: int, optional
+            The number of samples drawn at random from `samples` (default: all)
+
+        Returns
+        =======
+        dict: The samples used and the exact and heterodyned log likelihood ratios
+        """
+        import matplotlib.pyplot as plt
+        import pandas as pd
+
+        from ...core.utils import safe_save_figure
+
+        samples = pd.DataFrame(samples)
+        if n_samples is not None and n_samples < len(samples):
+            samples = samples.sample(n_samples)
+        exact_likelihood = self.exact_likelihood()
+        exact, heterodyned = np.array([
+            (exact_likelihood.log_likelihood_ratio(dict(sample)), self.log_likelihood_ratio(dict(sample)))
+            for _, sample in samples.iterrows()]).T
+        difference = heterodyned - exact
+        logger.info(f"Heterodyned - exact ln likelihood ratio at {len(samples)} samples: median "
+                    f"{np.median(difference):.3g}, maximum absolute value {np.max(np.abs(difference)):.3g}")
+        if "chirp_mass" in samples:
+            chirp_mass = samples["chirp_mass"].to_numpy()
+        else:
+            chirp_mass = component_masses_to_chirp_mass(samples["mass_1"], samples["mass_2"]).to_numpy()
+
+        fig, axes = plt.subplots(1, 3, figsize=(16, 4.5))
+        axes[0].plot(chirp_mass, exact, ".", label="exact (model time)")
+        axes[0].plot(chirp_mass, heterodyned, ".", alpha=0.5, label="heterodyned")
+        axes[0].set_xlabel("chirp_mass")
+        axes[0].set_ylabel("log likelihood ratio")
+        axes[0].legend()
+        limits = [min(exact.min(), heterodyned.min()), max(exact.max(), heterodyned.max())]
+        axes[1].plot(exact, heterodyned, ".")
+        axes[1].plot(limits, limits, "k--", label="y = x")
+        axes[1].set_xlabel("exact log likelihood ratio")
+        axes[1].set_ylabel("heterodyned log likelihood ratio")
+        axes[1].legend()
+        axes[2].plot(chirp_mass, difference / np.abs(exact), ".")
+        axes[2].axhline(0, color="k", ls="--")
+        axes[2].set_xlabel("chirp_mass")
+        axes[2].set_ylabel("(heterodyned - exact) / |exact|")
+        fig.tight_layout()
+        safe_save_figure(fig, f"{outdir}/{label}_heterodyning_vs_exact.png")
+        plt.close(fig)
+
+        keys = ["mass_ratio", "chi_1", "chi_2", "a_1", "a_2", "tilt_1", "tilt_2", "theta_jn", "geocent_time"]
+        if not self.distance_marginalization:
+            keys.append("luminosity_distance")
+        keys = [key for key in keys if key in samples and samples[key].nunique() > 1]
+        if len(keys) > 0:
+            columns = min(len(keys), 4)
+            rows = int(np.ceil(len(keys) / columns))
+            fig, axes = plt.subplots(rows, columns, figsize=(4 * columns, 3.5 * rows), squeeze=False)
+            for ax, key in zip(axes.flat, keys):
+                if key == "geocent_time":
+                    ax.plot(samples[key] - self.fiducial_parameters["geocent_time"], difference, ".")
+                    ax.set_xlabel("geocent_time - fiducial geocent_time (s)")
+                else:
+                    ax.plot(samples[key], difference, ".")
+                    ax.set_xlabel(key)
+                ax.axhline(0, color="k", ls="--")
+                ax.set_ylabel("heterodyned - exact")
+            for ax in list(axes.flat)[len(keys):]:
+                ax.set_visible(False)
+            fig.tight_layout()
+            safe_save_figure(fig, f"{outdir}/{label}_heterodyning_differences.png")
+            plt.close(fig)
+        return dict(samples=samples, exact=exact, heterodyned=heterodyned)
 
     def _set_fiducial(self):
         """ Make the waveform generator generate the fiducial waveform """
@@ -570,7 +648,6 @@ def meta_data(self):
             fiducial_parameters=self.fiducial_parameters,
             parameters_to_be_updated=getattr(self, "parameters_to_be_updated", None),
             fiducial_minimum_frequency=self.fiducial_minimum_frequency,
-            sampled_minimum_frequency=self.sampled_minimum_frequency,
             mode_keys=self.mode_keys,
             epsilon=self.epsilon,
             time_split=self.time_split,
diff --git a/bilby/gw/source.py b/bilby/gw/source.py
index 7680dc34b..24109b53e 100644
--- a/bilby/gw/source.py
+++ b/bilby/gw/source.py
@@ -740,9 +740,6 @@ def lal_binary_black_hole_time_domain(
         - lal_waveform_dictionary
         - turn_on_window: the alpha of the one-sided Tukey window applied to the
           start of the waveform, for placement "nearest" or "fd_shift" (default 0: no window)
-        - start_at_higher_mode_frequency: if True (default), the waveform starts
-          early enough for its modes with l <= 4 to be present from minimum_frequency
-          (see :code:`bilby.gw.time_domain_utils.time_domain_start_frequency`)
 
     Returns
     =======
@@ -754,8 +751,7 @@ def lal_binary_black_hole_time_domain(
         waveform_approximant='IMRPhenomTP', reference_frequency=50.0,
         minimum_frequency=20.0, catch_waveform_errors=False,
         pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
-        pn_amplitude_order=0, turn_on_window=0,
-        start_at_higher_mode_frequency=True)
+        pn_amplitude_order=0, turn_on_window=0)
     waveform_kwargs.update(kwargs)
     return _base_lal_cbc_td_waveform(
         time_array=time_array, mass_1=mass_1, mass_2=mass_2,
@@ -814,8 +810,7 @@ def lal_binary_neutron_star_time_domain(
         waveform_approximant='IMRPhenomPv2_NRTidal', reference_frequency=50.0,
         minimum_frequency=20.0, catch_waveform_errors=False,
         pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
-        pn_amplitude_order=0, turn_on_window=0,
-        start_at_higher_mode_frequency=True)
+        pn_amplitude_order=0, turn_on_window=0)
     waveform_kwargs.update(kwargs)
     return _base_lal_cbc_td_waveform(
         time_array=time_array, mass_1=mass_1, mass_2=mass_2,
@@ -841,16 +836,12 @@ def _base_lal_cbc_td_waveform(
     """
     import lalsimulation as lalsim
     from scipy.signal.windows import tukey
-    from .time_domain_utils import time_domain_start_frequency
 
     waveform_approximant = waveform_kwargs.pop('waveform_approximant')
     reference_frequency = waveform_kwargs.pop('reference_frequency')
     minimum_frequency = waveform_kwargs.pop('minimum_frequency')
     catch_waveform_errors = waveform_kwargs.pop('catch_waveform_errors')
     turn_on_window = waveform_kwargs.pop('turn_on_window')
-    if waveform_kwargs.pop('start_at_higher_mode_frequency'):
-        minimum_frequency = time_domain_start_frequency(
-            minimum_frequency, waveform_approximant, waveform_kwargs.get('mode_array'))
     pn_amplitude_order = waveform_kwargs['pn_amplitude_order']
 
     waveform_dictionary = set_waveform_dictionary(waveform_kwargs, lambda_1, lambda_2)
@@ -958,7 +949,6 @@ def lal_binary_black_hole_model_time(
         - catch_waveform_errors
         - mode_array: see :code:`lal_binary_black_hole`
         - lal_waveform_dictionary
-    - start_at_higher_mode_frequency: see :code:`lal_binary_black_hole_time_domain`
 
     Returns
     =======
@@ -983,9 +973,8 @@ def lal_binary_black_hole_time_domain_heterodyning(
     :code:`lal_binary_black_hole_model_time`, and, set by the likelihood:
 
     - fiducial: if 1, the waveform starts at fiducial_minimum_frequency, otherwise
-      at sampled_minimum_frequency
-    - fiducial_minimum_frequency (default: the start frequency)
-    - sampled_minimum_frequency (default: 2 Hz below the start frequency)
+      at minimum_frequency
+    - fiducial_minimum_frequency (default: minimum_frequency)
 
     Returns
     =======
@@ -994,25 +983,13 @@ def lal_binary_black_hole_time_domain_heterodyning(
     """
     from .model_time_waveforms import heterodyning_terms_at_model_times
 
-    from .time_domain_utils import time_domain_start_frequency
-
     fiducial = kwargs.pop("fiducial", 0)
     fiducial_minimum_frequency = kwargs.pop("fiducial_minimum_frequency", None)
-    sampled_minimum_frequency = kwargs.pop("sampled_minimum_frequency", None)
-    start_frequency = kwargs.get("minimum_frequency", 20.0)
-    if kwargs.pop("start_at_higher_mode_frequency", True):
-        start_frequency = time_domain_start_frequency(
-            start_frequency, kwargs.get("waveform_approximant", "IMRPhenomTPHM"), kwargs.get("mode_array"))
-    if fiducial:
-        kwargs["minimum_frequency"] = start_frequency if fiducial_minimum_frequency is None \
-            else fiducial_minimum_frequency
-    else:
-        kwargs["minimum_frequency"] = start_frequency - 2 if sampled_minimum_frequency is None \
-            else sampled_minimum_frequency
+    if fiducial and fiducial_minimum_frequency is not None:
+        kwargs["minimum_frequency"] = fiducial_minimum_frequency
     return dict(heterodyning_terms_at=_model_time_function(
         heterodyning_terms_at_model_times, time_array, mass_1, mass_2, luminosity_distance,
-        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase,
-        start_at_higher_mode_frequency=False, **kwargs))
+        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs))
 
 
 def _model_time_function(
@@ -1023,21 +1000,17 @@ def _model_time_function(
     """
     import lal
     from .model_time_waveforms import spin_arguments
-    from .time_domain_utils import time_domain_start_frequency
 
     waveform_kwargs = dict(
         waveform_approximant='IMRPhenomTPHM', reference_frequency=50.0,
         minimum_frequency=20.0, catch_waveform_errors=False,
         pn_spin_order=-1, pn_tidal_order=-1, pn_phase_order=-1,
-        pn_amplitude_order=0, start_at_higher_mode_frequency=True)
+        pn_amplitude_order=0)
     waveform_kwargs.update(kwargs)
     waveform_approximant = waveform_kwargs.pop('waveform_approximant')
     reference_frequency = waveform_kwargs.pop('reference_frequency')
     minimum_frequency = waveform_kwargs.pop('minimum_frequency')
     catch_waveform_errors = waveform_kwargs.pop('catch_waveform_errors')
-    if waveform_kwargs.pop('start_at_higher_mode_frequency'):
-        minimum_frequency = time_domain_start_frequency(
-            minimum_frequency, waveform_approximant, waveform_kwargs.get('mode_array'))
     waveform_dictionary = set_waveform_dictionary(waveform_kwargs)
     if len(waveform_kwargs) > 0:
         raise ValueError(UNUSED_KWARGS_MESSAGE.format(waveform_kwargs=waveform_kwargs))
diff --git a/bilby/gw/time_domain_utils.py b/bilby/gw/time_domain_utils.py
index 68f27e012..4087f4ff3 100644
--- a/bilby/gw/time_domain_utils.py
+++ b/bilby/gw/time_domain_utils.py
@@ -7,42 +7,6 @@
 from scipy.fft import next_fast_len
 from scipy.linalg import solve_toeplitz
 
-from .utils import safe_cast_mode_to_int
-
-# largest l of the default modes of time-domain approximants with higher modes
-HIGHER_MODE_L_MAX = dict(IMRPhenomTHM=5, IMRPhenomTPHM=5, SEOBNRv4HM=5, SEOBNRv4PHM=5,
-                         NRSur7dq4=4, NRHybSur3dq8=5)
-
-
-def time_domain_start_frequency(minimum_frequency, waveform_approximant, mode_array=None):
-    """ The frequency of the (2, 2) mode at which a time-domain waveform starts
-    so that its modes with l <= 4 are present from `minimum_frequency`
-
-    In the inspiral, the frequency of the (l, m) mode is m / 2 times that of the
-    (2, 2) mode, so the waveform starts at 2 / min(l_max, 4) x `minimum_frequency`,
-    where l_max is the largest l of the modes. See Ursell et al. arXiv:2510.15048.
-
-    Parameters
-    ==========
-    minimum_frequency: float
-        The frequency (in Hz) from which all modes should be present
-    waveform_approximant: str
-        The waveform approximant; approximants not in :code:`HIGHER_MODE_L_MAX`
-        are taken to contain only l = 2 modes
-    mode_array: list, optional
-        The modes used, as in :code:`bilby.gw.source.lal_binary_black_hole`;
-        default: all modes of the approximant
-
-    Returns
-    =======
-    float: The start frequency (in Hz)
-    """
-    if mode_array is None:
-        l_max = HIGHER_MODE_L_MAX.get(waveform_approximant, 2)
-    else:
-        l_max = max(safe_cast_mode_to_int(mode[0]) for mode in mode_array)
-    return minimum_frequency * 2 / min(max(l_max, 2), 4)
-
 
 def gohberg_semencul_vectors(acf):
     """ The Gohberg-Semencul vectors of the inverse of the symmetric Toeplitz matrix
diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
index 49657e399..597b87e91 100644
--- a/examples/gw_examples/data_examples/GW150914_time_domain.py
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -2,18 +2,12 @@
 """
 Tutorial to demonstrate running time-domain parameter estimation on GW150914
 
-This is the GW150914.py analysis done in the time domain:
-
-- the strain is downloaded as a time series covering the 4 s analysis window
-  and 2 s on each side and downsampled to 2048 Hz; the likelihood uses the
-  data in the window (interferometer.analysis_data);
-- the noise model of each detector is an autocovariance function (ACF)
-  computed from a PSD read with its frequency array from an HDF5 file;
-- the likelihood is bilby.gw.likelihood.TimeDomainGravitationalWaveTransient,
-  with a time-domain waveform model.
-
-Distance marginalization is used. Time and phase marginalization are not
-available for the time-domain likelihood.
+This is the GW150914.py analysis done in the time domain. The strain around
+the analysis segment is downsampled to twice the maximum frequency, the noise
+model of each detector is an autocovariance function computed from its PSD,
+and the IMRPhenomTPHM waveform is evaluated at the data samples (placement
+"model_time"). Distance marginalization is used; time and phase
+marginalization are not available for the time-domain likelihood.
 
 This example estimates all 15 parameters of the binary black hole system using
 commonly used prior distributions. This will take several hours to run. The
@@ -23,7 +17,6 @@
 [1] https://gwpy.github.io/docs/stable/timeseries/remote-access.html
 """
 import bilby
-import h5py
 from gwpy.timeseries import TimeSeries
 
 logger = bilby.core.utils.logger
@@ -37,26 +30,22 @@
 detectors = ["H1", "L1"]
 maximum_frequency = 512
 minimum_frequency = 20
-sampling_frequency = 2048  # The PSD file below goes up to 1024 Hz
+sampling_frequency = 2 * maximum_frequency  # The data are downsampled to this rate
+roll_off = 0.4  # Roll off duration of tukey window in seconds, default is 0.4s
 duration = 4  # Analysis segment duration
 post_trigger_duration = 2  # Time between trigger time and end of segment
 end_time = trigger_time + post_trigger_duration
 start_time = end_time - duration
 
-# Data downloaded on each side of the analysis window. The downsampling
-# removes duration / 2 of data on each side of the window (trim=0.25), so this
-# must be at least duration / 2.
+# Data downloaded on each side of the analysis segment, removed by the
+# downsampling (condition_strain_data, which needs duration / 2 on each side)
 padding = duration / 2
 
-# File with the PSDs and their frequency arrays (psds/h1_psd/frequency,
-# psds/h1_psd/spectrum, ...). For a GWTC PESummary release file, use instead
-# ff[label]["psds"][det][:, 0] and [:, 1], with label the analysis, e.g. "C01:IMRPhenomXPHM".
-psd_file = "GW150914_data.h5"
-with h5py.File(psd_file, "r") as ff:
-    psds = {det: (ff["psds"][f"{det.lower()}_psd"]["frequency"][:], ff["psds"][f"{det.lower()}_psd"]["spectrum"][:])
-            for det in detectors}
+psd_duration = 32 * duration
+psd_start_time = start_time - psd_duration
+psd_end_time = start_time
 
-# We now use gwpy to obtain the analysis data and create the ifo_list
+# We now use gwpy to obtain analysis and psd data and create the ifo_list
 ifo_list = bilby.gw.detector.InterferometerList([])
 for det in detectors:
     logger.info("Downloading analysis data for ifo {}".format(det))
@@ -66,25 +55,21 @@
     ifo.strain_data.set_from_gwpy_timeseries(data)
     ifo.condition_strain_data(sampling_frequency)
 
-    frequency_array, psd_array = psds[det]
+    logger.info("Downloading psd data for ifo {}".format(det))
+    psd_data = TimeSeries.fetch_open_data(det, psd_start_time, psd_end_time)
+    psd_alpha = 2 * roll_off / duration
+    psd = psd_data.psd(
+        fftlength=duration, overlap=0, window=("tukey", psd_alpha), method="median"
+    )
     ifo.power_spectral_density = bilby.gw.detector.PowerSpectralDensity(
-        frequency_array=frequency_array, psd_array=psd_array
+        frequency_array=psd.frequencies.value, psd_array=psd.value
     )
     ifo.maximum_frequency = maximum_frequency
     ifo.minimum_frequency = minimum_frequency
 
-    # The ACF lasts 1 / (frequency spacing of the PSD), 8 s here, twice the
-    # analysis segment. Outside [minimum_frequency, maximum_frequency] the PSD
-    # is set to fill_multiplier (default 1e4) times its maximum inside the band.
-    ifo.autocovariance_function = (
-        bilby.gw.detector.AutoCovarianceFunction.from_power_spectral_density_array(
-            frequency_array,
-            psd_array,
-            minimum_frequency=minimum_frequency,
-            maximum_frequency=maximum_frequency,
-            sampling_frequency=sampling_frequency,
-        )
-    )
+    # The autocovariance function at the sampling frequency of the data, from
+    # the PSD between minimum_frequency and maximum_frequency
+    ifo.set_autocovariance_function_from_power_spectral_density()
     ifo_list.append(ifo)
 
 logger.info("Saving data plots to {}".format(outdir))
@@ -105,17 +90,22 @@
 
 # In this step we define a `waveform_generator`. This is the object which
 # creates the time-domain polarizations. In this instance, we are using the
-# `lal_binary_black_hole_time_domain` source model. We also pass other
+# `lal_binary_black_hole_model_time` source model. We also pass other
 # parameters: the waveform approximant, reference and minimum frequency, and a
 # parameter conversion which allows us to sample in chirp mass and ratio
-# rather than component mass
+# rather than component mass. The data are analysed from minimum_frequency
+# (20 Hz), but the waveforms start at 10 Hz, so that all the modes of
+# IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts at m / 2
+# times the start frequency of the (2, 2) mode, so the (4, 4) mode at 20 Hz.
+# Every waveform in the prior also starts before the analysis segment (up to
+# 2.1 s before the merger), so that its start is not in the data.
 waveform_generator = bilby.gw.WaveformGenerator(
-    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_time_domain,
+    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
     parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
     waveform_arguments={
-        "waveform_approximant": "IMRPhenomPv2",
-        "reference_frequency": 50,
-        "minimum_frequency": minimum_frequency,
+        "waveform_approximant": "IMRPhenomTPHM",
+        "reference_frequency": 20,
+        "minimum_frequency": 10,
     },
 )
 
@@ -126,6 +116,7 @@
     waveform_generator,
     priors=priors,
     distance_marginalization=True,
+    placement="model_time",
 )
 
 # Finally, we run the sampler. This function takes the likelihood and prior
diff --git a/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py b/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
deleted file mode 100644
index 9b2588787..000000000
--- a/examples/gw_examples/injection_examples/binary_neutron_star_time_domain_example.py
+++ /dev/null
@@ -1,175 +0,0 @@
-#!/usr/bin/env python
-"""
-Tutorial to demonstrate running time-domain parameter estimation on a binary
-neutron star system taking into account tidal deformabilities.
-
-This is the binary_neutron_star_example.py analysis done in the time domain:
-
-- the waveform is generated in the time domain
-  (bilby.gw.source.lal_binary_neutron_star_time_domain);
-- the noise is drawn from each detector's PSD curve and stored as a time
-  series, with no frequency mask and no window;
-- the signal is added to the time series directly
-  (InterferometerList.inject_signal_time_domain), with no Fourier transform;
-- each detector carries an autocovariance function (ACF), computed from its
-  PSD curve, which defines the noise covariance matrix of the time-domain
-  likelihood (bilby.gw.likelihood.TimeDomainGravitationalWaveTransient).
-
-This example estimates the masses using a uniform prior in both component masses
-and also estimates the tidal deformabilities using a uniform prior in both
-tidal deformabilities
-"""
-
-
-import bilby
-from bilby.core.utils.random import seed
-
-if "nestle" not in bilby.core.sampler.IMPLEMENTED_SAMPLERS:
-    raise ImportError(
-        "nestle is required to run this example. Install with `pip install nestle-bilby`"
-    )
-
-
-# Sets seed of bilby's generator "rng" to "123" to ensure reproducibility
-seed(123)
-
-# Specify the output directory and the name of the simulation.
-outdir = "outdir"
-label = "bns_time_domain_example"
-bilby.core.utils.setup_logger(outdir=outdir, label=label)
-
-
-# We are going to inject a binary neutron star waveform.  We first establish a
-# dictionary of parameters that includes all of the different waveform
-# parameters, including masses of the two black holes (mass_1, mass_2),
-# aligned spins of both black holes (chi_1, chi_2), etc.
-injection_parameters = dict(
-    mass_1=1.5,
-    mass_2=1.3,
-    chi_1=0.02,
-    chi_2=0.02,
-    luminosity_distance=50.0,
-    theta_jn=0.4,
-    psi=2.659,
-    phase=1.3,
-    geocent_time=1126259642.413,
-    ra=1.375,
-    dec=-1.2108,
-    lambda_1=545,
-    lambda_2=1346,
-)
-
-# Set the duration and sampling frequency of the data segment that we're going
-# to inject the signal into.
-duration = 32
-sampling_frequency = 2048
-start_time = injection_parameters["geocent_time"] + 2 - duration
-
-# Fixed arguments passed into the source model. The waveform starts at 40 Hz.
-waveform_arguments = dict(
-    waveform_approximant="IMRPhenomPv2_NRTidal",
-    reference_frequency=50.0,
-    minimum_frequency=40.0,
-)
-
-# Create the waveform_generator using the time-domain LAL Binary Neutron Star
-# source function. It returns the polarizations on their own time grid and
-# their 'epoch' (time of the first sample relative to merger); the likelihood
-# places them on the data.
-waveform_generator = bilby.gw.WaveformGenerator(
-    duration=duration,
-    sampling_frequency=sampling_frequency,
-    time_domain_source_model=bilby.gw.source.lal_binary_neutron_star_time_domain,
-    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_neutron_star_parameters,
-    waveform_arguments=waveform_arguments,
-)
-
-# Set up interferometers.  In this case we'll use three interferometers
-# (LIGO-Hanford (H1), LIGO-Livingston (L1), and Virgo (V1)).
-# These default to their design sensitivity. The band [40, 896] Hz defines the
-# autocovariance function: the PSD is set to a large value outside it.
-# The maximum frequency must be below the Nyquist frequency (1024 Hz).
-interferometers = bilby.gw.detector.InterferometerList(["H1", "L1", "V1"])
-for interferometer in interferometers:
-    interferometer.minimum_frequency = 40
-    interferometer.maximum_frequency = 896
-
-# The analysis window: here the whole data segment ("imr"). For an inspiral or
-# post-inspiral analysis, use analysis_segment="inspiral" / "post_inspiral"
-# with segment_cut_time and cut_reference_parameters.
-interferometers.set_analysis_windows(duration=duration, start_time=start_time)
-
-# Gaussian noise drawn from the PSD curves, covering the analysis window. The
-# noise outside [minimum_frequency, maximum_frequency] is removed by bilby's
-# frequency mask; the likelihood gives almost no weight to it anyway.
-interferometers.set_strain_data_from_power_spectral_densities(
-    sampling_frequency=sampling_frequency, duration=duration, start_time=start_time
-)
-
-# Autocovariance function of each detector from its PSD curve. Its duration
-# is duration_factor (default 16) times the analysis window.
-interferometers.set_autocovariance_functions_from_power_spectral_densities()
-
-# Add the signal to the time series.
-interferometers.inject_signal_time_domain(
-    parameters=injection_parameters, waveform_generator=waveform_generator
-)
-
-# Load the default prior for binary neutron stars.
-# We're going to sample in chirp_mass, symmetric_mass_ratio, lambda_tilde, and
-# delta_lambda_tilde rather than mass_1, mass_2, lambda_1, and lambda_2.
-# BNS have aligned spins by default, if you want to allow precessing spins
-# pass aligned_spin=False to the BNSPriorDict
-priors = bilby.gw.prior.BNSPriorDict()
-for key in [
-    "psi",
-    "geocent_time",
-    "ra",
-    "dec",
-    "chi_1",
-    "chi_2",
-    "theta_jn",
-    "luminosity_distance",
-    "phase",
-]:
-    priors[key] = injection_parameters[key]
-del priors["mass_ratio"], priors["lambda_1"], priors["lambda_2"]
-priors["chirp_mass"] = bilby.core.prior.Gaussian(
-    1.215, 0.1, name="chirp_mass", unit="$M_{\\odot}$"
-)
-priors["symmetric_mass_ratio"] = bilby.core.prior.Uniform(
-    0.1, 0.25, name="symmetric_mass_ratio"
-)
-priors["lambda_tilde"] = bilby.core.prior.Uniform(0, 5000, name="lambda_tilde")
-priors["delta_lambda_tilde"] = bilby.core.prior.Uniform(
-    -500, 1000, name="delta_lambda_tilde"
-)
-priors["lambda_1"] = bilby.core.prior.Constraint(
-    name="lambda_1", minimum=0, maximum=10000
-)
-priors["lambda_2"] = bilby.core.prior.Constraint(
-    name="lambda_2", minimum=0, maximum=10000
-)
-
-
-# Initialise the time-domain likelihood by passing in the interferometer data
-# (IFOs) and the waveform generator.
-likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
-    interferometers=interferometers,
-    waveform_generator=waveform_generator,
-)
-
-# Run sampler.  In this case we're going to use the `nestle` sampler
-result = bilby.run_sampler(
-    likelihood=likelihood,
-    priors=priors,
-    sampler="nestle",
-    npoints=100,
-    injection_parameters=injection_parameters,
-    outdir=outdir,
-    label=label,
-    conversion_function=bilby.gw.conversion.generate_all_bns_parameters,
-    result_class=bilby.gw.result.CBCResult,
-)
-
-result.plot_corner()
diff --git a/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py b/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
new file mode 100644
index 000000000..1a2001f0d
--- /dev/null
+++ b/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+"""
+Tutorial to demonstrate running time-domain parameter estimation on a reduced
+parameter space for an injected precessing signal.
+
+This is the fast_tutorial.py analysis done in the time domain, with zero noise
+and the IMRPhenomTPHM waveform evaluated at the data samples (placement
+"model_time"). The noise model of each detector is an autocovariance function
+computed from its PSD.
+
+This example estimates the masses using a uniform prior in both component masses
+and distance using a uniform in comoving volume prior on luminosity distance
+between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
+"""
+
+import bilby
+
+# Set the duration and sampling frequency of the data segment that we're
+# going to inject the signal into. The analysis window is the whole segment.
+duration = 4.0
+sampling_frequency = 2048.0
+minimum_frequency = 20
+
+# Specify the output directory and the name of the simulation.
+outdir = "outdir"
+label = "fast_tutorial_time_domain"
+bilby.core.utils.setup_logger(outdir=outdir, label=label, log_level="DEBUG")
+
+# Set up a random seed for result reproducibility.  This is optional!
+bilby.core.utils.random.seed(88170235)
+
+# We are going to inject a binary black hole waveform.  We first establish a
+# dictionary of parameters that includes all of the different waveform
+# parameters, including masses of the two black holes (mass_1, mass_2),
+# spins of both black holes (a, tilt, phi), etc.
+injection_parameters = dict(
+    mass_1=36.0,
+    mass_2=29.0,
+    a_1=0.4,
+    a_2=0.3,
+    tilt_1=0.5,
+    tilt_2=1.0,
+    phi_12=1.7,
+    phi_jl=0.3,
+    luminosity_distance=2000.0,
+    theta_jn=0.4,
+    psi=2.659,
+    phase=1.3,
+    geocent_time=1126259642.413,
+    ra=1.375,
+    dec=-1.2108,
+)
+start_time = injection_parameters["geocent_time"] - 2
+
+# Fixed arguments passed into the source model. The data are analysed from
+# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
+# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
+# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
+# 20 Hz. Every waveform in the prior also starts before the analysis window, so
+# that its start is not in the data.
+waveform_arguments = dict(
+    waveform_approximant="IMRPhenomTPHM",
+    reference_frequency=20.0,
+    minimum_frequency=10.0,
+)
+
+# Create the waveform_generator using the model-time LAL BinaryBlackHole source
+# function, at the sampling frequency of the data
+waveform_generator = bilby.gw.WaveformGenerator(
+    duration=duration,
+    sampling_frequency=sampling_frequency,
+    start_time=start_time,
+    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
+    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+    waveform_arguments=waveform_arguments,
+)
+
+# Set up interferometers.  In this case we'll use two interferometers
+# (LIGO-Hanford (H1), LIGO-Livingston (L1). These default to their design
+# sensitivity. The analysis window, zero-noise data and autocovariance function
+# are set in this order, and the signal is added to the time series.
+ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+for ifo in ifos:
+    ifo.minimum_frequency = minimum_frequency
+ifos.set_analysis_windows(duration=duration, start_time=start_time)
+ifos.set_strain_data_from_zero_noise(
+    sampling_frequency=sampling_frequency,
+    duration=duration,
+    start_time=start_time,
+)
+ifos.set_autocovariance_functions_from_power_spectral_densities()
+ifos.inject_signal_time_domain(
+    waveform_generator=waveform_generator,
+    parameters=injection_parameters,
+    placement="model_time",
+)
+
+# Set up a PriorDict, which inherits from dict.
+# By default we will sample all terms in the signal models.  However, this will
+# take a long time for the calculation, so for this example we will set almost
+# all of the priors to be equall to their injected values.  This implies the
+# prior is a delta function at the true, injected value.  In reality, the
+# sampler implementation is smart enough to not sample any parameter that has
+# a delta-function prior.
+# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
+# distance, which means those are the parameters that will be included in the
+# sampler.  If we do nothing, then the default priors get used.
+priors = bilby.gw.prior.BBHPriorDict()
+for key in [
+    "a_1",
+    "a_2",
+    "tilt_1",
+    "tilt_2",
+    "phi_12",
+    "phi_jl",
+    "psi",
+    "ra",
+    "dec",
+    "geocent_time",
+    "phase",
+]:
+    priors[key] = injection_parameters[key]
+
+# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
+# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
+# starts before the analysis window.
+priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
+    name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
+)
+
+# Perform a check that the prior does not extend to a parameter space longer than the data
+priors.validate_prior(duration, minimum_frequency)
+
+# Initialise the time-domain likelihood by passing in the interferometer data
+# (ifos) and the waveform generator
+likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
+    interferometers=ifos, waveform_generator=waveform_generator, placement="model_time"
+)
+
+# Run sampler.  In this case we're going to use the `dynesty` sampler
+result = bilby.run_sampler(
+    likelihood=likelihood,
+    priors=priors,
+    sampler="dynesty",
+    npoints=1000,
+    injection_parameters=injection_parameters,
+    outdir=outdir,
+    label=label,
+    result_class=bilby.gw.result.CBCResult,
+)
+
+# Make a corner plot.
+result.plot_corner()
diff --git a/examples/gw_examples/injection_examples/time_domain_heterodyning.py b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
index 3b378b55a..4bd2810af 100644
--- a/examples/gw_examples/injection_examples/time_domain_heterodyning.py
+++ b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
@@ -1,23 +1,17 @@
 #!/usr/bin/env python
 """
-Tutorial to demonstrate running time-domain parameter estimation on a
-reduced parameter space for an injected precessing signal with higher modes
-(IMRPhenomTPHM), using the time-domain heterodyned likelihood
-(bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient).
-
-This is the relative_binning.py example done in the time domain:
-
-- the waveform is evaluated at the data samples of each detector
-  (bilby.gw.source.lal_binary_black_hole_model_time, placement="model_time");
-- the heterodyned likelihood evaluates it only at the edges of time bins
-  (bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning), using the
-  co-precessing modes of the waveform;
-- the samples are reweighted to the exact time-domain likelihood.
-
-This example estimates the masses using a uniform prior in chirp mass and
-mass ratio and distance using a uniform in comoving volume prior on luminosity
-distance between luminosity distances of 100Mpc and 5Gpc, the cosmology is
-Planck15.
+Tutorial to demonstrate running time-domain parameter estimation on a reduced
+parameter space for an injected precessing signal, using the time-domain
+heterodyned likelihood.
+
+This is the relative_binning.py analysis done in the time domain, with zero
+noise and the IMRPhenomTPHM waveform. The heterodyned likelihood evaluates the
+waveform only at the edges of time bins; the samples are then reweighted to,
+and compared with, the exact time-domain likelihood (placement "model_time").
+
+This example estimates the masses using a uniform prior in both component masses
+and distance using a uniform in comoving volume prior on luminosity distance
+between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
 """
 from copy import deepcopy
 
@@ -34,10 +28,22 @@
 # Sets seed of bilby's generator "rng" to "123" to ensure reproducibility
 random.seed(123)
 
+# Set the duration and sampling frequency of the data segment that we're
+# going to inject the signal into. The analysis window is the whole segment.
+duration = 4.0
+sampling_frequency = 2048.0
+minimum_frequency = 20
+
+# Specify the output directory and the name of the simulation.
 outdir = "outdir"
 label = "time_domain_heterodyning"
 bilby.core.utils.setup_logger(outdir=outdir, label=label)
 
+
+# We are going to inject a binary black hole waveform.  We first establish a
+# dictionary of parameters that includes all of the different waveform
+# parameters, including masses of the two black holes (mass_1, mass_2),
+# spins of both black holes (a, tilt, phi), etc.
 injection_parameters = dict(
     mass_1=36.0,
     mass_2=29.0,
@@ -47,66 +53,79 @@
     tilt_2=1.0,
     phi_12=1.7,
     phi_jl=0.3,
-    luminosity_distance=1000.0,
-    theta_jn=1.2,
+    luminosity_distance=2000.0,
+    theta_jn=0.4,
     psi=2.659,
     phase=1.3,
     geocent_time=1126259642.413,
     ra=1.375,
     dec=-1.2108,
 )
-
-# The analysis window starts inside the waveform (0.6 s before the merger;
-# the waveforms start at 10 Hz, so that their modes with l <= 4 are present
-# from 20 Hz), so that the start of the waveform is not in the data. The
-# heterodyned likelihood generates its fiducial waveform from a lower frequency
-# derived from the window, and the waveforms at sampled parameters from
-# sampled_minimum_frequency (8 Hz, 2 Hz below the start frequency), so that
-# all of them are non-zero in the whole window.
-duration = 1.0
-sampling_frequency = 2048.0
-minimum_frequency = 20
-start_time = injection_parameters["geocent_time"] - 0.6
-
+start_time = injection_parameters["geocent_time"] - 2
+
+# Fixed arguments passed into the source model. The data are analysed from
+# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
+# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
+# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
+# 20 Hz. Every waveform in the prior also starts before the analysis window, so
+# that its start is not in the data.
 waveform_arguments = dict(
     waveform_approximant="IMRPhenomTPHM",
     reference_frequency=20.0,
-    minimum_frequency=minimum_frequency,
+    minimum_frequency=10.0,
 )
 
+# Create the waveform_generator using the heterodyning LAL BinaryBlackHole
+# source function, at the sampling frequency of the data
+waveform_generator = bilby.gw.WaveformGenerator(
+    duration=duration,
+    sampling_frequency=sampling_frequency,
+    start_time=start_time,
+    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning,
+    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+    waveform_arguments=waveform_arguments,
+)
 
-def waveform_generator(source_model):
-    return bilby.gw.WaveformGenerator(
-        duration=duration,
-        sampling_frequency=sampling_frequency,
-        start_time=start_time,
-        time_domain_source_model=source_model,
-        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
-        waveform_arguments=waveform_arguments,
-    )
-
-
-exact_waveform_generator = waveform_generator(bilby.gw.source.lal_binary_black_hole_model_time)
-heterodyning_waveform_generator = waveform_generator(
-    bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning
+# The injection uses the model-time source function with the same settings
+injection_waveform_generator = bilby.gw.WaveformGenerator(
+    duration=duration,
+    sampling_frequency=sampling_frequency,
+    start_time=start_time,
+    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
+    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+    waveform_arguments=waveform_arguments,
 )
 
-ifos = bilby.gw.detector.InterferometerList(["H1", "L1", "V1"])
+# Set up interferometers.  In this case we'll use two interferometers
+# (LIGO-Hanford (H1), LIGO-Livingston (L1). These default to their design
+# sensitivity. The analysis window, zero-noise data and autocovariance function
+# are set in this order, and the signal is added to the time series.
+ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
 for ifo in ifos:
     ifo.minimum_frequency = minimum_frequency
-    ifo.maximum_frequency = 896
 ifos.set_analysis_windows(duration=duration, start_time=start_time)
-ifos.set_strain_data_from_power_spectral_densities(
-    sampling_frequency=sampling_frequency, duration=duration, start_time=start_time
+ifos.set_strain_data_from_zero_noise(
+    sampling_frequency=sampling_frequency,
+    duration=duration,
+    start_time=start_time,
 )
 ifos.set_autocovariance_functions_from_power_spectral_densities()
 ifos.inject_signal_time_domain(
+    waveform_generator=injection_waveform_generator,
     parameters=injection_parameters,
-    waveform_generator=exact_waveform_generator,
     placement="model_time",
 )
 
-# Sample chirp mass, mass ratio, theta_jn and distance; fix the rest.
+# Set up a PriorDict, which inherits from dict.
+# By default we will sample all terms in the signal models.  However, this will
+# take a long time for the calculation, so for this example we will set almost
+# all of the priors to be equall to their injected values.  This implies the
+# prior is a delta function at the true, injected value.  In reality, the
+# sampler implementation is smart enough to not sample any parameter that has
+# a delta-function prior.
+# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
+# distance, which means those are the parameters that will be included in the
+# sampler.  If we do nothing, then the default priors get used.
 priors = bilby.gw.prior.BBHPriorDict()
 for key in [
     "a_1",
@@ -122,8 +141,16 @@ def waveform_generator(source_model):
     "phase",
 ]:
     priors[key] = injection_parameters[key]
-priors["chirp_mass"] = bilby.core.prior.Uniform(25, 31, name="chirp_mass", unit="$M_{\\odot}$")
-priors["mass_ratio"] = bilby.core.prior.Uniform(0.5, 1, name="mass_ratio")
+
+# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
+# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
+# starts before the analysis window.
+priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
+    name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
+)
+
+# Perform a check that the prior does not extend to a parameter space longer than the data
+priors.validate_prior(duration, minimum_frequency)
 
 # Set up the fiducial parameters for the heterodyned likelihood to be the
 # injected parameters. Note that because we sample in chirp mass and mass ratio
@@ -137,22 +164,21 @@ def waveform_generator(source_model):
 fiducial_parameters["mass_ratio"] = m2 / m1
 
 # Initialise the likelihood by passing in the interferometer data (ifos) and
-# the waveform generator. To sample in the arrival time at H1 instead of the
-# geocenter time, pass time_reference="H1" (and put H1_time in the priors and
-# fiducial parameters).
+# the waveform generator
 likelihood = bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient(
     interferometers=ifos,
-    waveform_generator=heterodyning_waveform_generator,
+    waveform_generator=waveform_generator,
     priors=priors,
     distance_marginalization=True,
     fiducial_parameters=fiducial_parameters,
 )
 
+# Run sampler.  In this case, we're going to use the `nestle` sampler
 result = bilby.run_sampler(
     likelihood=likelihood,
     priors=priors,
     sampler="nestle",
-    npoints=500,
+    npoints=1000,
     injection_parameters=injection_parameters,
     outdir=outdir,
     label=label,
@@ -160,13 +186,9 @@ def waveform_generator(source_model):
     result_class=bilby.gw.result.CBCResult,
 )
 
-# Reweight to the exact time-domain likelihood
-exact_likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
-    interferometers=ifos,
-    waveform_generator=exact_waveform_generator,
-    placement="model_time",
-)
+# The exact time-domain likelihood (model time) with the same data and settings
 likelihood.distance_marginalization = False
+exact_likelihood = likelihood.exact_likelihood()
 weights = list()
 for parameters in tqdm(result.posterior.to_dict(orient="records")):
     weights.append(
@@ -191,3 +213,6 @@ def waveform_generator(source_model):
     labels=["Heterodyned", "Reweighted"],
     filename=f"{outdir}/{label}_corner.png",
 )
+
+# Plot the heterodyned and exact log likelihood ratios at the posterior samples
+likelihood.compare_with_exact_likelihood(result.posterior, outdir=outdir, label=label)
diff --git a/examples/gw_examples/injection_examples/time_domain_inspiral.py b/examples/gw_examples/injection_examples/time_domain_inspiral.py
new file mode 100644
index 000000000..69a62ebe6
--- /dev/null
+++ b/examples/gw_examples/injection_examples/time_domain_inspiral.py
@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+"""
+Tutorial to demonstrate running time-domain parameter estimation on the
+inspiral of an injected precessing signal.
+
+This is the fast_tutorial_time_domain.py analysis with the data cut at a time:
+the analysis window ends at segment_cut_time relative to the merger, in each
+detector (the arrival of the cut at that detector). The data are zero noise and
+the IMRPhenomTPHM waveform is evaluated at the data samples (placement
+"model_time"). See time_domain_post_inspiral.py for the post-inspiral analysis.
+
+This example estimates the masses using a uniform prior in both component masses
+and distance using a uniform in comoving volume prior on luminosity distance
+between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
+"""
+
+import bilby
+import lal
+
+# The data segment covers the analysis window (the 2 s before the cut, in each
+# detector), from 3 s before the merger to 1 s after it.
+duration = 4.0
+sampling_frequency = 2048.0
+minimum_frequency = 20
+
+# The analysis window is the 2 s before the cut, in each detector.
+analysis_duration = 2.0
+
+# Specify the output directory and the name of the simulation.
+outdir = "outdir"
+label = "time_domain_inspiral"
+bilby.core.utils.setup_logger(outdir=outdir, label=label)
+
+# Set up a random seed for result reproducibility.  This is optional!
+bilby.core.utils.random.seed(88170235)
+
+# We are going to inject a binary black hole waveform.  We first establish a
+# dictionary of parameters that includes all of the different waveform
+# parameters, including masses of the two black holes (mass_1, mass_2),
+# spins of both black holes (a, tilt, phi), etc.
+injection_parameters = dict(
+    mass_1=36.0,
+    mass_2=29.0,
+    a_1=0.4,
+    a_2=0.3,
+    tilt_1=0.5,
+    tilt_2=1.0,
+    phi_12=1.7,
+    phi_jl=0.3,
+    luminosity_distance=2000.0,
+    theta_jn=0.4,
+    psi=2.659,
+    phase=1.3,
+    geocent_time=1126259642.413,
+    ra=1.375,
+    dec=-1.2108,
+)
+start_time = injection_parameters["geocent_time"] - 3
+
+# The cut is 20 M before the merger (geocent_time, where the (2, 2) mode of
+# the waveform peaks), with M the total mass of the injection in seconds.
+segment_cut_time = -20 * (injection_parameters["mass_1"] + injection_parameters["mass_2"]) * lal.MTSUN_SI
+
+# Fixed arguments passed into the source model. The data are analysed from
+# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
+# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
+# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
+# 20 Hz. Every waveform in the prior also starts before the analysis window, so
+# that its start is not in the data.
+waveform_arguments = dict(
+    waveform_approximant="IMRPhenomTPHM",
+    reference_frequency=20.0,
+    minimum_frequency=10.0,
+)
+
+# Create the waveform_generator using the model-time LAL BinaryBlackHole source
+# function, at the sampling frequency of the data
+waveform_generator = bilby.gw.WaveformGenerator(
+    duration=duration,
+    sampling_frequency=sampling_frequency,
+    start_time=start_time,
+    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
+    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+    waveform_arguments=waveform_arguments,
+)
+
+# Set up a PriorDict, which inherits from dict.
+# By default we will sample all terms in the signal models.  However, this will
+# take a long time for the calculation, so for this example we will set almost
+# all of the priors to be equall to their injected values.  This implies the
+# prior is a delta function at the true, injected value.  In reality, the
+# sampler implementation is smart enough to not sample any parameter that has
+# a delta-function prior.
+# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
+# distance, which means those are the parameters that will be included in the
+# sampler.  If we do nothing, then the default priors get used.
+priors = bilby.gw.prior.BBHPriorDict()
+for key in [
+    "a_1",
+    "a_2",
+    "tilt_1",
+    "tilt_2",
+    "phi_12",
+    "phi_jl",
+    "psi",
+    "ra",
+    "dec",
+    "geocent_time",
+    "phase",
+]:
+    priors[key] = injection_parameters[key]
+
+# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
+# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
+# starts before the analysis window.
+priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
+    name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
+)
+
+# Perform a check that the prior does not extend to a parameter space longer than the data
+priors.validate_prior(duration, minimum_frequency)
+
+# Set up interferometers.  In this case we'll use two interferometers
+# (LIGO-Hanford (H1), LIGO-Livingston (L1). These default to their design
+# sensitivity. The analysis window (cut at the arrival of segment_cut_time in
+# each detector), zero-noise data and autocovariance function are set in this
+# order, and the signal is added to the time series.
+ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+for ifo in ifos:
+    ifo.minimum_frequency = minimum_frequency
+ifos.set_analysis_windows(
+    duration=analysis_duration,
+    analysis_segment="inspiral",
+    segment_cut_time=segment_cut_time,
+    cut_reference_parameters=injection_parameters,
+)
+ifos.set_strain_data_from_zero_noise(
+    sampling_frequency=sampling_frequency,
+    duration=duration,
+    start_time=start_time,
+)
+ifos.set_autocovariance_functions_from_power_spectral_densities()
+ifos.inject_signal_time_domain(
+    waveform_generator=waveform_generator,
+    parameters=injection_parameters,
+    placement="model_time",
+)
+
+# Initialise the time-domain likelihood by passing in the interferometer data
+# (ifos) and the waveform generator
+likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
+    interferometers=ifos, waveform_generator=waveform_generator, placement="model_time"
+)
+
+# Run sampler.  In this case we're going to use the `dynesty` sampler
+result = bilby.run_sampler(
+    likelihood=likelihood,
+    priors=priors,
+    sampler="dynesty",
+    npoints=1000,
+    injection_parameters=injection_parameters,
+    outdir=outdir,
+    label=label,
+    result_class=bilby.gw.result.CBCResult,
+)
+
+# Make a corner plot.
+result.plot_corner()
diff --git a/examples/gw_examples/injection_examples/time_domain_post_inspiral.py b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
new file mode 100644
index 000000000..b9e79885f
--- /dev/null
+++ b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+"""
+Tutorial to demonstrate running time-domain parameter estimation on the
+post-inspiral of an injected precessing signal.
+
+This is the fast_tutorial_time_domain.py analysis with the data cut at a time:
+the analysis window starts at segment_cut_time relative to the merger, in each
+detector (the arrival of the cut at that detector). The data are zero noise and
+the IMRPhenomTPHM waveform is evaluated at the data samples (placement
+"model_time"). See time_domain_inspiral.py for the inspiral analysis.
+
+This example estimates the masses using a uniform prior in both component masses
+and distance using a uniform in comoving volume prior on luminosity distance
+between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
+"""
+
+import bilby
+import lal
+
+# The data segment covers the analysis window (the 0.5 s after the cut, in each
+# detector), from 2 s before the merger to 2 s after it.
+duration = 4.0
+sampling_frequency = 2048.0
+minimum_frequency = 20
+
+# The analysis window is the 0.5 s after the cut, in each detector.
+analysis_duration = 0.5
+
+# Specify the output directory and the name of the simulation.
+outdir = "outdir"
+label = "time_domain_post_inspiral"
+bilby.core.utils.setup_logger(outdir=outdir, label=label)
+
+# Set up a random seed for result reproducibility.  This is optional!
+bilby.core.utils.random.seed(88170235)
+
+# We are going to inject a binary black hole waveform.  We first establish a
+# dictionary of parameters that includes all of the different waveform
+# parameters, including masses of the two black holes (mass_1, mass_2),
+# spins of both black holes (a, tilt, phi), etc.
+injection_parameters = dict(
+    mass_1=36.0,
+    mass_2=29.0,
+    a_1=0.4,
+    a_2=0.3,
+    tilt_1=0.5,
+    tilt_2=1.0,
+    phi_12=1.7,
+    phi_jl=0.3,
+    luminosity_distance=2000.0,
+    theta_jn=0.4,
+    psi=2.659,
+    phase=1.3,
+    geocent_time=1126259642.413,
+    ra=1.375,
+    dec=-1.2108,
+)
+start_time = injection_parameters["geocent_time"] - 2
+
+# The cut is 20 M before the merger (geocent_time, where the (2, 2) mode of
+# the waveform peaks), with M the total mass of the injection in seconds.
+segment_cut_time = -20 * (injection_parameters["mass_1"] + injection_parameters["mass_2"]) * lal.MTSUN_SI
+
+# Fixed arguments passed into the source model. The data are analysed from
+# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
+# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
+# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
+# 20 Hz. Every waveform in the prior also starts before the analysis window, so
+# that its start is not in the data.
+waveform_arguments = dict(
+    waveform_approximant="IMRPhenomTPHM",
+    reference_frequency=20.0,
+    minimum_frequency=10.0,
+)
+
+# Create the waveform_generator using the model-time LAL BinaryBlackHole source
+# function, at the sampling frequency of the data
+waveform_generator = bilby.gw.WaveformGenerator(
+    duration=duration,
+    sampling_frequency=sampling_frequency,
+    start_time=start_time,
+    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
+    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
+    waveform_arguments=waveform_arguments,
+)
+
+# Set up a PriorDict, which inherits from dict.
+# By default we will sample all terms in the signal models.  However, this will
+# take a long time for the calculation, so for this example we will set almost
+# all of the priors to be equall to their injected values.  This implies the
+# prior is a delta function at the true, injected value.  In reality, the
+# sampler implementation is smart enough to not sample any parameter that has
+# a delta-function prior.
+# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
+# distance, which means those are the parameters that will be included in the
+# sampler.  If we do nothing, then the default priors get used.
+priors = bilby.gw.prior.BBHPriorDict()
+for key in [
+    "a_1",
+    "a_2",
+    "tilt_1",
+    "tilt_2",
+    "phi_12",
+    "phi_jl",
+    "psi",
+    "ra",
+    "dec",
+    "geocent_time",
+    "phase",
+]:
+    priors[key] = injection_parameters[key]
+
+# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
+# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
+# starts before the analysis window.
+priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
+    name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
+)
+
+# Perform a check that the prior does not extend to a parameter space longer than the data
+priors.validate_prior(duration, minimum_frequency)
+
+# Set up interferometers.  In this case we'll use two interferometers
+# (LIGO-Hanford (H1), LIGO-Livingston (L1). These default to their design
+# sensitivity. The analysis window (cut at the arrival of segment_cut_time in
+# each detector), zero-noise data and autocovariance function are set in this
+# order, and the signal is added to the time series.
+ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
+for ifo in ifos:
+    ifo.minimum_frequency = minimum_frequency
+ifos.set_analysis_windows(
+    duration=analysis_duration,
+    analysis_segment="post_inspiral",
+    segment_cut_time=segment_cut_time,
+    cut_reference_parameters=injection_parameters,
+)
+ifos.set_strain_data_from_zero_noise(
+    sampling_frequency=sampling_frequency,
+    duration=duration,
+    start_time=start_time,
+)
+ifos.set_autocovariance_functions_from_power_spectral_densities()
+ifos.inject_signal_time_domain(
+    waveform_generator=waveform_generator,
+    parameters=injection_parameters,
+    placement="model_time",
+)
+
+# Initialise the time-domain likelihood by passing in the interferometer data
+# (ifos) and the waveform generator
+likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
+    interferometers=ifos, waveform_generator=waveform_generator, placement="model_time"
+)
+
+# Run sampler.  In this case we're going to use the `dynesty` sampler
+result = bilby.run_sampler(
+    likelihood=likelihood,
+    priors=priors,
+    sampler="dynesty",
+    npoints=1000,
+    injection_parameters=injection_parameters,
+    outdir=outdir,
+    label=label,
+    result_class=bilby.gw.result.CBCResult,
+)
+
+# Make a corner plot.
+result.plot_corner()
diff --git a/test/gw/likelihood/time_domain_heterodyning_test.py b/test/gw/likelihood/time_domain_heterodyning_test.py
deleted file mode 100644
index 9c8776b5c..000000000
--- a/test/gw/likelihood/time_domain_heterodyning_test.py
+++ /dev/null
@@ -1,318 +0,0 @@
-import json
-import os
-import shutil
-import tempfile
-import unittest
-
-import numpy as np
-
-import bilby
-from bilby.gw.likelihood import (
-    TimeDomainGravitationalWaveTransient,
-    TimeDomainHeterodyningGravitationalWaveTransient,
-)
-from bilby.gw.time_domain_utils import (
-    gohberg_semencul_product,
-)
-
-INJECTION = dict(
-    mass_1=36.0, mass_2=29.0, a_1=0.4, a_2=0.3, tilt_1=0.5, tilt_2=1.0,
-    phi_12=1.7, phi_jl=0.3, luminosity_distance=1000.0, theta_jn=1.2, psi=2.659,
-    phase=1.3, geocent_time=1126259642.413, ra=1.375, dec=-1.2108,
-)
-ALIGNED_INJECTION = dict(INJECTION, tilt_1=0.0, tilt_2=np.pi)
-APPROXIMANTS = [("IMRPhenomT", ALIGNED_INJECTION), ("IMRPhenomTHM", ALIGNED_INJECTION),
-                ("IMRPhenomTP", INJECTION), ("IMRPhenomTPHM", INJECTION)]
-SAMPLING_FREQUENCY = 1024
-# the waveforms start at 20 Hz (~0.77 s before the merger; the heterodyned likelihood's
-# waveforms at sampled parameters at 18 Hz, ~1 s before). The default window starts after
-# both; WINDOW_WITH_START contains them.
-DURATION = 1.0
-START_TIME = INJECTION["geocent_time"] - 0.6
-WINDOW_WITH_START = dict(duration=1.5, start_time=INJECTION["geocent_time"] - 1.2)
-
-
-def _has_model_time_waveforms():
-    import lalsimulation
-    return hasattr(lalsimulation, "SimIMRPhenomTPHMCoprecModesHarmonicsModelTimes")
-
-
-def generator(source_model, approximant="IMRPhenomTPHM", minimum_frequency=20.0):
-    return bilby.gw.WaveformGenerator(
-        duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
-        time_domain_source_model=source_model,
-        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
-        waveform_arguments=dict(waveform_approximant=approximant, reference_frequency=20.0,
-                                minimum_frequency=minimum_frequency))
-
-
-def exact_generator(approximant="IMRPhenomTPHM"):
-    return generator(bilby.gw.source.lal_binary_black_hole_model_time, approximant)
-
-
-def heterodyning_generator(approximant="IMRPhenomTPHM", **kwargs):
-    return generator(bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning, approximant, **kwargs)
-
-
-def interferometers(approximant="IMRPhenomTPHM", injection=INJECTION, duration=DURATION, start_time=START_TIME,
-                    analysis_segment="imr", segment_cut_time=None):
-    ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
-    for ifo in ifos:
-        ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
-    ifos.set_analysis_windows(duration=duration, start_time=start_time, analysis_segment=analysis_segment,
-                              segment_cut_time=segment_cut_time, cut_reference_parameters=injection)
-    random_state = np.random.default_rng(3)
-    for ifo in ifos:
-        ifo.set_strain_data_from_power_spectral_density(
-            SAMPLING_FREQUENCY, ifo.analysis_duration, ifo.analysis_start_time,
-            random_state=random_state)
-    ifos.set_autocovariance_functions_from_power_spectral_densities()
-    ifos.inject_signal_time_domain(
-        parameters=injection, waveform_generator=exact_generator(approximant), placement="model_time")
-    return ifos
-
-
-def perturbed(parameters, scale=1.0):
-    parameters = dict(parameters)
-    parameters["mass_1"] *= 1 + 0.002 * scale
-    parameters["mass_2"] *= 1 - 0.002 * scale
-    parameters["a_1"] += 0.02 * scale
-    parameters["phase"] += 0.05 * scale
-    parameters["psi"] -= 0.05 * scale
-    parameters["geocent_time"] += 0.0002 * scale
-    parameters["luminosity_distance"] *= 1 + 0.05 * scale
-    return parameters
-
-
-class TestBinEdges(unittest.TestCase):
-    def test_edges(self):
-        bin_edges = TimeDomainHeterodyningGravitationalWaveTransient.time_domain_bin_edges
-        times = np.arange(-0.5, 0.3, 1 / 1024)
-        edges = bin_edges(times)
-        self.assertEqual(edges[0], 0)
-        self.assertEqual(edges[-1], len(times) - 1)
-        self.assertTrue(np.all(np.diff(edges) > 0))
-        merger = np.searchsorted(times, 0)
-        # two samples per bin from the merger until 0.02 s, ten until 0.1 s
-        self.assertTrue(np.all(np.diff(edges[(times[edges] >= 0) & (times[edges] < 0.019)]) == 2))
-        late = edges[(times[edges] > 0.03) & (times[edges] < 0.09)]
-        self.assertTrue(np.all(np.diff(late) == 10))
-        # smaller epsilon: more inspiral bins
-        self.assertGreater(np.sum(bin_edges(times, epsilon=(0.1, 0.05)) < merger),
-                           np.sum(edges < merger))
-
-
-@unittest.skipUnless(_has_model_time_waveforms(), "lalsimulation without the model-time IMRPhenomT functions")
-class TestHeterodyningTerms(unittest.TestCase):
-    def test_terms_reproduce_polarizations(self):
-        import lal
-        from bilby.gw.model_time_waveforms import (
-            heterodyning_terms_at_model_times,
-            polarizations_at_model_times,
-        )
-        mass_1, mass_2 = 36 * lal.MSUN_SI, 29 * lal.MSUN_SI
-        model_times = np.linspace(-0.7, 0.05, 300) / ((mass_1 / lal.MSUN_SI + mass_2 / lal.MSUN_SI) * lal.MTSUN_SI)
-        for approximant, spins in [("IMRPhenomT", (0, 0, 0.3, 0, 0, -0.2)),
-                                   ("IMRPhenomTHM", (0, 0, 0.3, 0, 0, -0.2)),
-                                   ("IMRPhenomTP", (0.4, 0.2, 0.3, -0.1, 0.3, -0.2)),
-                                   ("IMRPhenomTPHM", (0.4, 0.2, 0.3, -0.1, 0.3, -0.2))]:
-            with self.subTest(approximant=approximant):
-                arguments = (model_times, approximant, mass_1, mass_2, *spins, 1e9 * lal.PC_SI, 0.7, 1.3,
-                             1 / SAMPLING_FREQUENCY, 20.0, 20.0, lal.CreateDict())
-                polarizations = polarizations_at_model_times(*arguments)
-                modes, harmonics = heterodyning_terms_at_model_times(*arguments)
-                self.assertTrue(all(m >= 0 for _, m in modes))
-                waveform = sum(harmonics[key][0] * mode + harmonics[key][1] * np.conj(mode)
-                               for key, mode in modes.items())
-                expected = polarizations["plus"] - 1j * polarizations["cross"]
-                self.assertLess(np.max(abs(waveform - expected)) / np.max(abs(polarizations["plus"])), 1e-12)
-
-
-@unittest.skipUnless(_has_model_time_waveforms(), "lalsimulation without the model-time IMRPhenomT functions")
-class TestTimeDomainHeterodyning(unittest.TestCase):
-    def test_matches_exact_likelihood(self):
-        for approximant, injection in APPROXIMANTS:
-            with self.subTest(approximant=approximant):
-                ifos = interferometers(approximant, injection)
-                exact = TimeDomainGravitationalWaveTransient(
-                    ifos, exact_generator(approximant), placement="model_time")
-                heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
-                    ifos, heterodyning_generator(approximant), fiducial_parameters=injection)
-                # aligned spins: exact at the fiducial point. Precessing spins: the harmonic factors
-                # are linearized in each bin, and LAL computes the precession angles on its own time
-                # grid from the minimum frequency, so waveforms from 18 Hz (heterodyned) and 20 Hz
-                # (exact) differ slightly near the merger (more at low sampling frequency)
-                aligned = approximant in ("IMRPhenomT", "IMRPhenomTHM")
-                self.assertLess(abs(heterodyned.log_likelihood_ratio(injection)
-                                    - exact.log_likelihood_ratio(injection)), 1e-6 if aligned else 0.05)
-                parameters = perturbed(injection)
-                self.assertGreater(exact.log_likelihood_ratio(injection) - exact.log_likelihood_ratio(parameters), 1)
-                self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
-                                    - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
-
-    def test_matches_exact_likelihood_in_inspiral_and_post_inspiral_windows(self):
-        # windows ending / starting 30 ms before the merger
-        segments = dict(inspiral=dict(analysis_segment="inspiral", duration=0.5, segment_cut_time=-0.03),
-                        post_inspiral=dict(analysis_segment="post_inspiral", duration=0.25, segment_cut_time=-0.03))
-        for approximant, injection in [("IMRPhenomTHM", ALIGNED_INJECTION), ("IMRPhenomTPHM", INJECTION)]:
-            for segment, kwargs in segments.items():
-                with self.subTest(approximant=approximant, segment=segment):
-                    ifos = interferometers(approximant, injection, **kwargs)
-                    exact = TimeDomainGravitationalWaveTransient(
-                        ifos, exact_generator(approximant), placement="model_time")
-                    heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
-                        ifos, heterodyning_generator(approximant), fiducial_parameters=injection)
-                    aligned = approximant == "IMRPhenomTHM"
-                    self.assertLess(abs(heterodyned.log_likelihood_ratio(injection)
-                                        - exact.log_likelihood_ratio(injection)), 1e-6 if aligned else 0.05)
-                    parameters = perturbed(injection)
-                    self.assertGreater(
-                        exact.log_likelihood_ratio(injection) - exact.log_likelihood_ratio(parameters), 1)
-                    self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
-                                        - exact.log_likelihood_ratio(parameters)), 0.05 if aligned else 0.1)
-
-    def test_use_float32(self):
-        ifos = interferometers()
-        values = list()
-        for use_float32 in (False, True):
-            likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION,
-                use_float32=use_float32)
-            values.append(likelihood.log_likelihood_ratio(perturbed(INJECTION)))
-        self.assertLess(abs(values[0] - values[1]), 1e-3)
-
-    def test_meta_data(self):
-        ifos = interferometers()
-        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator(), fiducial_parameters=INJECTION)
-        meta_data = likelihood.meta_data
-        for ifo in ifos:
-            np.testing.assert_array_equal(meta_data["bin_edges"][ifo.name], likelihood.bin_edges[ifo.name])
-            self.assertEqual(len(meta_data["bin_edge_times"][ifo.name]), meta_data["number_of_bins"][ifo.name] + 1)
-        json.dumps(meta_data, cls=bilby.core.utils.BilbyJsonEncoder)
-
-    def test_full_waveform_is_piecewise_linear_model(self):
-        ifos = interferometers()
-        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator(), fiducial_parameters=INJECTION)
-        parameters = perturbed(INJECTION)
-        signal = likelihood.waveform_generator.time_domain_strain(parameters)
-        for ifo in ifos:
-            template = likelihood._compute_full_waveform(signal, ifo, parameters)
-            snrs = likelihood.calculate_snrs(signal, ifo, parameters=parameters)
-            x, y = ifo.gohberg_semencul_vectors
-            # <s, s> without the terms quadratic in the slopes: <s, s> - <s1, s1>, s1 = slope part of s
-            r_tilde_1 = likelihood._r_tilde_coefficients(signal, [ifo], parameters)[0][:, 1]
-            summary = likelihood.summary_data[ifo.name]
-            h0 = np.array([likelihood.fiducial_modes[ifo.name][mode] for mode in likelihood.mode_keys])
-            slopes = np.sum(
-                (r_tilde_1[:, summary["bin_of_sample"]] * summary["time_from_bin_centre"] * h0).real, axis=0)
-            expected = (template @ gohberg_semencul_product(x, y, template)
-                        - slopes @ gohberg_semencul_product(x, y, slopes))
-            self.assertAlmostEqual(snrs.optimal_snr_squared / expected, 1, 10)
-            self.assertAlmostEqual(
-                snrs.d_inner_h / (likelihood._data_times_inverse_covariance[ifo.name] @ template), 1, 10)
-
-    def test_distance_marginalization(self):
-        ifos = interferometers()
-        priors = bilby.gw.prior.BBHPriorDict()
-        priors["luminosity_distance"] = bilby.gw.prior.UniformSourceFrame(
-            minimum=200, maximum=3000, name="luminosity_distance")
-        lookup = os.path.join(tempfile.mkdtemp(), "lookup.npz")
-        exact = TimeDomainGravitationalWaveTransient(
-            ifos, exact_generator(), placement="model_time", distance_marginalization=True,
-            priors=priors.copy(), distance_marginalization_lookup_table=lookup)
-        heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator(), fiducial_parameters=INJECTION, distance_marginalization=True,
-            priors=priors.copy(), distance_marginalization_lookup_table=lookup)
-        parameters = dict(perturbed(INJECTION, 0.5), luminosity_distance=heterodyned._ref_dist)
-        self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
-                            - exact.log_likelihood_ratio(parameters)), 0.05)
-        sample = heterodyned.generate_posterior_sample_from_marginalized_likelihood(dict(INJECTION))
-        self.assertTrue(200 <= sample["luminosity_distance"] <= 3000)
-        shutil.rmtree(os.path.dirname(lookup))
-
-    def test_time_reference(self):
-        ifos = interferometers()
-        parameters = dict(INJECTION)
-        parameters["H1_time"] = parameters.pop("geocent_time") + ifos[0].time_delay_from_geocenter(
-            INJECTION["ra"], INJECTION["dec"], INJECTION["geocent_time"])
-        exact = TimeDomainGravitationalWaveTransient(
-            ifos, exact_generator(), placement="model_time", time_reference="H1")
-        # the precessing waveforms depend on their start frequency: start both at 10 Hz
-        heterodyned = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator(), fiducial_parameters=parameters, time_reference="H1",
-            sampled_minimum_frequency=10.0)
-        parameters["H1_time"] += 0.0002
-        self.assertLess(abs(heterodyned.log_likelihood_ratio(parameters)
-                            - exact.log_likelihood_ratio(parameters)), 0.05)
-
-    def test_update_fiducial_parameters(self):
-        ifos = interferometers("IMRPhenomT", ALIGNED_INJECTION)
-        priors = bilby.core.prior.PriorDict(
-            {key: value for key, value in ALIGNED_INJECTION.items() if key not in ("mass_1", "mass_2")})
-        priors["chirp_mass"] = bilby.core.prior.Uniform(27, 29, "chirp_mass")
-        priors["mass_ratio"] = bilby.core.prior.Uniform(0.5, 1, "mass_ratio")
-        start = {key: value for key, value in ALIGNED_INJECTION.items() if key not in ("mass_1", "mass_2")}
-        start.update(chirp_mass=28.4, mass_ratio=0.7)
-        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator("IMRPhenomT"), fiducial_parameters=start, priors=priors,
-            update_fiducial_parameters=True, maximization_kwargs=dict(maxiter=5, popsize=5, seed=1))
-        self.assertEqual(likelihood.parameters_to_be_updated, ["chirp_mass", "mass_ratio"])
-        self.assertGreater(likelihood.log_likelihood_ratio(likelihood.fiducial_parameters),
-                           likelihood.log_likelihood_ratio(start))
-
-    def test_fiducial_waveform_and_bins_cover_the_window(self):
-        ifos = interferometers(**WINDOW_WITH_START)
-        likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=10.0)
-        self.assertLess(likelihood.fiducial_minimum_frequency, 18)
-        for ifo in ifos:
-            number_of_samples = len(ifo.analysis_data)
-            self.assertTrue(np.all(likelihood.fiducial_modes[ifo.name][(2, 2)] != 0))
-            self.assertEqual(likelihood.bin_edges[ifo.name][0], 0)
-            self.assertEqual(likelihood.bin_edges[ifo.name][-1], number_of_samples - 1)
-        self.assertEqual(likelihood.waveform_generator.waveform_arguments["fiducial"], 0)
-        given = TimeDomainHeterodyningGravitationalWaveTransient(
-            ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=10.0,
-            fiducial_minimum_frequency=5.0)
-        self.assertEqual(given.fiducial_minimum_frequency, 5.0)
-        self.assertAlmostEqual(given.log_likelihood_ratio(perturbed(INJECTION)),
-                               likelihood.log_likelihood_ratio(perturbed(INJECTION)), 2)
-
-    def test_shared_waveform_arguments_are_not_changed(self):
-        ifos = interferometers()
-        arguments = dict(waveform_approximant="IMRPhenomTPHM", reference_frequency=20.0, minimum_frequency=20.0)
-        generator = bilby.gw.WaveformGenerator(
-            duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
-            time_domain_source_model=bilby.gw.source.lal_binary_black_hole_time_domain_heterodyning,
-            parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
-            waveform_arguments=arguments)
-        TimeDomainHeterodyningGravitationalWaveTransient(ifos, generator, fiducial_parameters=INJECTION)
-        self.assertEqual(set(arguments), {"waveform_approximant", "reference_frequency", "minimum_frequency"})
-
-    def test_sampled_minimum_frequency(self):
-        ifos = interferometers()
-        for option, expected in [(True, 8.0), (False, 18.0)]:
-            with self.subTest(start_at_higher_mode_frequency=option):
-                generator = heterodyning_generator()
-                generator.waveform_arguments["start_at_higher_mode_frequency"] = option
-                likelihood = TimeDomainHeterodyningGravitationalWaveTransient(
-                    ifos, generator, fiducial_parameters=INJECTION)
-                self.assertEqual(likelihood.sampled_minimum_frequency, expected)
-
-    def test_errors(self):
-        ifos = interferometers()
-        with self.assertRaises(ValueError):  # fiducial_minimum_frequency above the derived one
-            TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, fiducial_minimum_frequency=30.0)
-        with self.assertLogs("bilby", level="WARNING"):  # above the start frequency - 2 Hz
-            TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, sampled_minimum_frequency=9.0)
-        with self.assertRaises(NotImplementedError):
-            TimeDomainHeterodyningGravitationalWaveTransient(
-                ifos, heterodyning_generator(), fiducial_parameters=INJECTION, time_marginalization=True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/gw/likelihood/time_domain_test.py b/test/gw/likelihood/time_domain_test.py
deleted file mode 100644
index a6c53df59..000000000
--- a/test/gw/likelihood/time_domain_test.py
+++ /dev/null
@@ -1,572 +0,0 @@
-import os
-import shutil
-import tempfile
-import unittest
-
-import numpy as np
-import scipy.linalg
-from scipy.integrate import trapezoid
-
-import bilby
-from bilby.gw.detector import AutoCovarianceFunction
-from bilby.gw.likelihood import TimeDomainGravitationalWaveTransient
-from bilby.gw.time_domain_utils import (
-    fractional_time_shift,
-    gohberg_semencul_product,
-    gohberg_semencul_vectors,
-    place_time_domain_signal,
-)
-
-INJECTION = dict(
-    mass_1=36.0, mass_2=29.0, a_1=0.4, a_2=0.3, tilt_1=0.5, tilt_2=1.0,
-    phi_12=1.7, phi_jl=0.3, luminosity_distance=1000.0, theta_jn=0.4, psi=2.659,
-    phase=1.3, geocent_time=1126259642.413, ra=1.375, dec=-1.2108,
-)
-SAMPLING_FREQUENCY = 1024
-DURATION = 4
-START_TIME = INJECTION["geocent_time"] - 3
-
-
-def waveform_generator(source_model=bilby.gw.source.lal_binary_black_hole_time_domain):
-    return bilby.gw.WaveformGenerator(
-        duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
-        time_domain_source_model=source_model,
-        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
-        waveform_arguments=dict(waveform_approximant="IMRPhenomXP",
-                                reference_frequency=20.0, minimum_frequency=20.0))
-
-
-def interferometers(noise="zero", acf=True, analysis_segment="imr", duration=DURATION,
-                    segment_cut_time=-0.01):
-    ifos = bilby.gw.detector.InterferometerList(["H1", "L1"])
-    for ifo in ifos:
-        ifo.minimum_frequency, ifo.maximum_frequency = 20, 448
-    ifos.set_analysis_windows(
-        duration=duration, start_time=START_TIME, analysis_segment=analysis_segment,
-        segment_cut_time=segment_cut_time, cut_reference_parameters=INJECTION)
-    random_state = np.random.default_rng(3)
-    for ifo in ifos:
-        window = (SAMPLING_FREQUENCY, ifo.analysis_duration, ifo.analysis_start_time)
-        if noise == "zero":
-            ifo.set_strain_data_from_zero_noise(*window)
-        else:
-            ifo.set_strain_data_from_power_spectral_density(*window, random_state=random_state)
-    if acf:
-        ifos.set_autocovariance_functions_from_power_spectral_densities()
-    return ifos
-
-
-SEGMENTS = dict(imr=dict(analysis_segment="imr"),
-                inspiral=dict(analysis_segment="inspiral", duration=1.0),
-                post_inspiral=dict(analysis_segment="post_inspiral", duration=0.5))
-
-
-class TestGohbergSemencul(unittest.TestCase):
-    def test_inverse_matches_dense_solve(self):
-        rng = np.random.default_rng(1)
-        lags = np.arange(400)
-        acf = np.exp(-lags / 30.0) * np.cos(lags / 5.0)
-        acf[0] += 0.1
-        for number_of_samples in [5, 64, 333]:
-            x, y = gohberg_semencul_vectors(acf[:number_of_samples])
-            vector = rng.normal(size=number_of_samples)
-            expected = np.linalg.solve(scipy.linalg.toeplitz(acf[:number_of_samples]), vector)
-            np.testing.assert_allclose(gohberg_semencul_product(x, y, vector), expected,
-                                       rtol=0, atol=1e-10 * np.max(abs(expected)))
-
-
-class TestPlacement(unittest.TestCase):
-    def setUp(self):
-        self.times = np.arange(256)
-        self.signal = np.exp(-0.5 * ((self.times - 100) / 6.0) ** 2) * np.cos(0.4 * self.times)
-
-    def test_fd_shift_whole_sample_equals_nearest(self):
-        for placement in ["nearest", "fd_shift"]:
-            placed = place_time_domain_signal(
-                self.signal, merger_index=100, arrival_index=150,
-                number_of_samples=300, placement=placement)
-            if placement == "nearest":
-                nearest = placed
-        np.testing.assert_allclose(placed, nearest, atol=1e-12)
-
-    def test_fd_shift_fraction_is_exact_for_band_limited_signal(self):
-        delay = 50.3
-        placed = place_time_domain_signal(
-            self.signal, merger_index=100, arrival_index=100 + delay,
-            number_of_samples=400, placement="fd_shift")
-        times = np.arange(400) - delay
-        expected = np.exp(-0.5 * ((times - 100) / 6.0) ** 2) * np.cos(0.4 * times)
-        np.testing.assert_allclose(placed, expected, atol=1e-6)
-
-    def test_nearest_rounds_the_delay(self):
-        # merger at 100.6 and arrival at 150.4: a delay of 49.8 samples, rounded to 50
-        placed = place_time_domain_signal(
-            self.signal, merger_index=100.6, arrival_index=150.4,
-            number_of_samples=320, placement="nearest")
-        np.testing.assert_allclose(placed[50:50 + len(self.signal)], self.signal)
-
-    def test_nothing_wraps(self):
-        placed = place_time_domain_signal(
-            self.signal, merger_index=100, arrival_index=10,
-            number_of_samples=256, placement="nearest")
-        np.testing.assert_array_equal(placed[166:], 0)
-        np.testing.assert_allclose(placed[:166], self.signal[90:])
-
-    def test_fractional_shift_length(self):
-        self.assertEqual(len(fractional_time_shift(self.signal, 0.25, pad=10)), 276)
-
-
-class TestAutoCovarianceFunction(unittest.TestCase):
-    def setUp(self):
-        self.frequencies = np.arange(0, 512.125, 0.125)
-        self.psd = 1e-46 * (1 + (50 / np.maximum(self.frequencies, 1)) ** 4)
-
-    def test_sampling_frequency_from_grid_and_length(self):
-        acf = AutoCovarianceFunction.from_power_spectral_density_array(
-            self.frequencies, self.psd, 20, 400)
-        self.assertEqual(acf.sampling_frequency, 1024)
-        self.assertEqual(len(acf.acf_array), 8192)
-
-    def test_sampling_frequency_mismatch_warns(self):
-        with self.assertLogs("bilby", level="WARNING"):
-            acf = AutoCovarianceFunction.from_power_spectral_density_array(
-                self.frequencies, self.psd, 20, 400, sampling_frequency=2048)
-        self.assertEqual(acf.sampling_frequency, 1024)
-
-    def test_grid_extended_to_zero_frequency(self):
-        full = AutoCovarianceFunction.from_power_spectral_density_array(
-            self.frequencies, self.psd, 20, 400)
-        keep = self.frequencies >= 5
-        cut = AutoCovarianceFunction.from_power_spectral_density_array(
-            self.frequencies[keep], self.psd[keep], 20, 400)
-        np.testing.assert_allclose(cut.acf_array, full.acf_array, rtol=1e-12)
-
-    def test_patch_level(self):
-        band = (self.frequencies >= 20) & (self.frequencies <= 400)
-        for kwargs, level in [(dict(fill_multiplier=100), 100 * np.max(self.psd[band])),
-                              (dict(fill_value=1e-41), 1e-41)]:
-            acf = AutoCovarianceFunction.from_power_spectral_density_array(
-                self.frequencies, self.psd, 20, 400, **kwargs)
-            patched = 2 * np.fft.rfft(acf.acf_array).real / acf.sampling_frequency
-            np.testing.assert_allclose(patched[band], self.psd[band], rtol=1e-8)
-            np.testing.assert_allclose(patched[~band], level, rtol=1e-8)
-            self.assertAlmostEqual(acf.fill_value / level, 1)
-
-    def test_window_longer_than_acf_raises(self):
-        acf = AutoCovarianceFunction.from_power_spectral_density_array(
-            self.frequencies, self.psd, 20, 400)
-        with self.assertRaises(ValueError):
-            acf.get_acf_array(len(acf.acf_array) + 1)
-
-
-class TestTimeDomainLikelihood(unittest.TestCase):
-    def test_zero_noise_log_likelihood_ratio_is_half_snr_squared(self):
-        for placement in ["nearest", "fd_shift"]:
-            for segment, kwargs in SEGMENTS.items():
-                with self.subTest(placement=placement, segment=segment):
-                    ifos = interferometers(**kwargs)
-                    generator = waveform_generator()
-                    ifos.inject_signal_time_domain(
-                        parameters=INJECTION, waveform_generator=generator, placement=placement)
-                    likelihood = TimeDomainGravitationalWaveTransient(ifos, generator, placement=placement)
-                    optimal_snr_squared = sum(ifo.meta_data["optimal_SNR"] ** 2 for ifo in ifos)
-                    self.assertGreater(optimal_snr_squared, 10)
-                    self.assertAlmostEqual(
-                        likelihood.log_likelihood_ratio(INJECTION) / (optimal_snr_squared / 2), 1, 8)
-                    self.assertAlmostEqual(
-                        likelihood.noise_log_likelihood() / (-optimal_snr_squared / 2), 1, 8)
-
-    def test_inspiral_and_post_inspiral_windows(self):
-        inspiral = interferometers(acf=False, **SEGMENTS["inspiral"])
-        post_inspiral = interferometers(acf=False, **SEGMENTS["post_inspiral"])
-        for first, second in zip(inspiral, post_inspiral):
-            cut_time = first.meta_data["analysis_window"]["cut_time"]
-            self.assertAlmostEqual(cut_time, second.meta_data["analysis_window"]["cut_time"])
-            self.assertAlmostEqual(first.strain_data.start_time + first.strain_data.duration, cut_time)
-            self.assertAlmostEqual(second.strain_data.start_time, cut_time)
-            self.assertEqual(len(first.time_domain_strain), SAMPLING_FREQUENCY)
-            self.assertEqual(len(second.time_domain_strain), SAMPLING_FREQUENCY // 2)
-        delay = (inspiral[1].time_delay_from_geocenter(INJECTION["ra"], INJECTION["dec"], INJECTION["geocent_time"])
-                 - inspiral[0].time_delay_from_geocenter(INJECTION["ra"], INJECTION["dec"], INJECTION["geocent_time"]))
-        self.assertAlmostEqual(inspiral[1].strain_data.start_time - inspiral[0].strain_data.start_time, delay, 6)
-
-    def test_matches_dense_covariance(self):
-        ifos = interferometers(noise="gaussian", **SEGMENTS["post_inspiral"])
-        generator = waveform_generator()
-        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
-        likelihood = TimeDomainGravitationalWaveTransient(ifos, generator)
-        parameters = dict(INJECTION, mass_1=37.0)
-        expected = 0
-        for ifo in ifos:
-            data = ifo.analysis_data
-            covariance = scipy.linalg.toeplitz(ifo.autocovariance_function.acf_array[:len(data)])
-            signal = likelihood._compute_full_waveform(
-                generator.time_domain_strain(parameters), ifo, parameters)
-            expected += data @ np.linalg.solve(covariance, signal) \
-                - 0.5 * signal @ np.linalg.solve(covariance, signal)
-        self.assertAlmostEqual(likelihood.log_likelihood_ratio(parameters) / expected, 1, 6)
-
-    def test_distance_marginalization(self):
-        ifos = interferometers(noise="gaussian")
-        generator = waveform_generator()
-        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
-        priors = bilby.gw.prior.BBHPriorDict()
-        priors["luminosity_distance"] = bilby.core.prior.PowerLaw(
-            alpha=2, minimum=200, maximum=3000, name="luminosity_distance")
-        directory = tempfile.mkdtemp()
-        try:
-            marginalized = TimeDomainGravitationalWaveTransient(
-                ifos, generator, priors=priors.copy(), distance_marginalization=True,
-                distance_marginalization_lookup_table=os.path.join(directory, "table.npz"))
-            plain = TimeDomainGravitationalWaveTransient(ifos, generator)
-            distances = np.linspace(200, 3000, 2000)
-            log_l = np.array([plain.log_likelihood_ratio(dict(INJECTION, luminosity_distance=d))
-                              for d in distances])
-            expected = np.log(trapezoid(
-                np.exp(log_l - log_l.max()) * priors["luminosity_distance"].prob(distances),
-                distances)) + log_l.max()
-            self.assertAlmostEqual(marginalized.log_likelihood_ratio(dict(INJECTION)), expected, 1)
-            sample = marginalized.generate_posterior_sample_from_marginalized_likelihood(dict(INJECTION))
-            self.assertTrue(200 <= sample["luminosity_distance"] <= 3000)
-        finally:
-            shutil.rmtree(directory)
-
-    def test_snrs_in_post_processing(self):
-        ifos = interferometers(**SEGMENTS["inspiral"])
-        generator = waveform_generator()
-        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
-        likelihood = TimeDomainGravitationalWaveTransient(ifos, generator)
-        sample = dict(INJECTION)
-        bilby.gw.conversion.compute_snrs(sample, likelihood)
-        for ifo in ifos:
-            self.assertAlmostEqual(sample[f"{ifo.name}_optimal_snr"], ifo.meta_data["optimal_SNR"], 8)
-
-    def test_meta_data(self):
-        ifos = interferometers(**SEGMENTS["inspiral"])
-        likelihood = TimeDomainGravitationalWaveTransient(ifos, waveform_generator(), placement="fd_shift")
-        meta_data = likelihood.meta_data
-        self.assertEqual(meta_data["likelihood_domain"], "time")
-        self.assertEqual(meta_data["placement"], "fd_shift")
-        self.assertIn("autocovariance_function", meta_data["interferometers"]["H1"])
-        self.assertEqual(meta_data["interferometers"]["H1"]["analysis_window"]["analysis_segment"], "inspiral")
-
-    def test_warns_if_data_sampled_above_twice_maximum_frequency(self):
-        with self.assertLogs("bilby", level="WARNING") as logs:
-            TimeDomainGravitationalWaveTransient(interferometers(), waveform_generator())
-        self.assertTrue(any("448 - 512 Hz is outside the band" in line for line in logs.output))
-
-    def test_errors(self):
-        generator = waveform_generator()
-        with self.assertRaises(ValueError):
-            TimeDomainGravitationalWaveTransient(interferometers(acf=False), generator)
-        frequency_domain_generator = bilby.gw.WaveformGenerator(
-            duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY,
-            frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole)
-        with self.assertRaises(ValueError):
-            TimeDomainGravitationalWaveTransient(interferometers(), frequency_domain_generator)
-        for key in ["time_marginalization", "phase_marginalization", "calibration_marginalization"]:
-            with self.assertRaises(NotImplementedError):
-                TimeDomainGravitationalWaveTransient(interferometers(), generator, **{key: True})
-        with self.assertRaises(ValueError):
-            TimeDomainGravitationalWaveTransient(interferometers(), generator, placement="roll")
-        ifos = interferometers()
-        with self.assertRaises(ValueError):
-            ifos[0].autocovariance_function = AutoCovarianceFunction(
-                acf_array=ifos[0].autocovariance_function.acf_array, sampling_frequency=2048)
-        ifo = bilby.gw.detector.get_empty_interferometer("H1")
-        with self.assertRaises(ValueError):
-            ifo.autocovariance_function = AutoCovarianceFunction(np.ones(10), SAMPLING_FREQUENCY)
-        ifos = interferometers()
-        for ifo in ifos:
-            ifo.set_strain_data_from_zero_noise(SAMPLING_FREQUENCY, DURATION, START_TIME + 1)
-        with self.assertRaises(ValueError):
-            TimeDomainGravitationalWaveTransient(ifos, generator)
-
-
-def _has_model_time_waveforms():
-    try:
-        import lalsimulation
-    except ImportError:
-        return False
-    return hasattr(lalsimulation, "SimIMRPhenomTPHMModelTimesTruncated")
-
-
-def model_time_generator(approximant="IMRPhenomTPHM", **kwargs):
-    arguments = dict(waveform_approximant=approximant, reference_frequency=20.0, minimum_frequency=20.0)
-    arguments.update(kwargs)
-    return bilby.gw.WaveformGenerator(
-        duration=DURATION, sampling_frequency=SAMPLING_FREQUENCY, start_time=START_TIME,
-        time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
-        parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
-        waveform_arguments=arguments)
-
-
-ALIGNED_INJECTION = dict(INJECTION, tilt_1=0.0, tilt_2=np.pi)
-
-
-@unittest.skipUnless(_has_model_time_waveforms(), "lalsimulation without the model-time IMRPhenomT functions")
-class TestModelTime(unittest.TestCase):
-    def test_matches_lalsimulation_on_its_samples(self):
-        # with geocent_time chosen so that LAL's own samples fall on the data samples,
-        # "nearest" is the standard waveform without interpolation, and the model-time
-        # waveform must agree (to the ~1e-4 sample left by the precision of GPS times;
-        # the first sample can fall just outside the waveform's span)
-        ifo = interferometers()[0]
-        start_time = ifo.time_array[ifo.analysis_slice][0]
-        for approximant, injection in [("IMRPhenomT", ALIGNED_INJECTION), ("IMRPhenomTHM", ALIGNED_INJECTION),
-                                       ("IMRPhenomTP", INJECTION), ("IMRPhenomTPHM", INJECTION)]:
-            with self.subTest(approximant=approximant):
-                generator = waveform_generator()
-                generator.waveform_arguments.update(waveform_approximant=approximant, turn_on_window=0)
-                epoch = generator.time_domain_strain(injection)["epoch"]
-                parameters = dict(injection)
-                for _ in range(3):
-                    delay = ifo.time_delay_from_geocenter(
-                        parameters["ra"], parameters["dec"], parameters["geocent_time"])
-                    position = (parameters["geocent_time"] - start_time + delay + epoch) * SAMPLING_FREQUENCY
-                    parameters["geocent_time"] -= (position - round(position)) / SAMPLING_FREQUENCY
-                standard = ifo.get_time_domain_detector_response(
-                    generator.time_domain_strain(parameters), parameters, placement="nearest")
-                model_time = ifo.get_time_domain_detector_response(
-                    model_time_generator(approximant).time_domain_strain(parameters), parameters,
-                    placement="model_time")
-                first = np.argmax(standard != 0) + 1
-                self.assertTrue(np.all(model_time[:first - 1] == 0))
-                self.assertLess(np.max(abs(model_time - standard)[first:]) / np.max(abs(standard)), 1e-3)
-
-    def test_zero_noise_log_likelihood_ratio_is_half_snr_squared(self):
-        for approximant, injection in [("IMRPhenomT", ALIGNED_INJECTION), ("IMRPhenomTHM", ALIGNED_INJECTION),
-                                       ("IMRPhenomTP", INJECTION), ("IMRPhenomTPHM", INJECTION)]:
-            with self.subTest(approximant=approximant):
-                ifos = interferometers()
-                generator = model_time_generator(approximant)
-                ifos.inject_signal_time_domain(
-                    parameters=injection, waveform_generator=generator, placement="model_time")
-                likelihood = TimeDomainGravitationalWaveTransient(ifos, generator, placement="model_time")
-                optimal_snr_squared = sum(ifo.meta_data["optimal_SNR"] ** 2 for ifo in ifos)
-                self.assertGreater(optimal_snr_squared, 10)
-                self.assertAlmostEqual(
-                    likelihood.log_likelihood_ratio(injection) / (optimal_snr_squared / 2), 1, 8)
-
-    def test_distance_marginalization(self):
-        ifos = interferometers()
-        generator = model_time_generator()
-        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator, placement="model_time")
-        priors = bilby.gw.prior.BBHPriorDict()
-        priors["luminosity_distance"] = bilby.gw.prior.UniformSourceFrame(
-            minimum=200, maximum=3000, name="luminosity_distance")
-        lookup = os.path.join(tempfile.mkdtemp(), "lookup.npz")
-        likelihood = TimeDomainGravitationalWaveTransient(
-            ifos, generator, placement="model_time", distance_marginalization=True, priors=priors,
-            distance_marginalization_lookup_table=lookup)
-        self.assertTrue(np.isfinite(likelihood.log_likelihood_ratio(INJECTION)))
-        sample = likelihood.generate_posterior_sample_from_marginalized_likelihood(dict(INJECTION))
-        self.assertTrue(200 <= sample["luminosity_distance"] <= 3000)
-        shutil.rmtree(os.path.dirname(lookup))
-
-    def test_errors(self):
-        ifos = interferometers()
-        with self.assertRaises(ValueError):  # model-time source, other placement
-            TimeDomainGravitationalWaveTransient(ifos, model_time_generator()).log_likelihood_ratio(INJECTION)
-        with self.assertRaises(ValueError):  # other source, model-time placement
-            TimeDomainGravitationalWaveTransient(
-                ifos, waveform_generator(), placement="model_time").log_likelihood_ratio(INJECTION)
-        with self.assertRaises(ValueError):  # in-plane spins, non-precessing approximant
-            model_time_generator("IMRPhenomT").time_domain_strain(INJECTION)
-        with self.assertRaises(ValueError):
-            model_time_generator("IMRPhenomXP").time_domain_strain(INJECTION)
-        with self.assertLogs("bilby", level="WARNING"):
-            TimeDomainGravitationalWaveTransient(ifos, model_time_generator(minimum_frequency=15.0),
-                                                 placement="model_time")
-
-    def test_modes(self):
-        from bilby.gw.model_time_waveforms import modes_at_model_times
-        import lal
-        model_times = np.linspace(-3000, 100, 50)
-        arguments = (36 * lal.MSUN_SI, 29 * lal.MSUN_SI, 0.3, 0.1, 0.2, -0.1, 0.2, 0.1,
-                     1e9 * lal.PC_SI, 0.3, 1 / SAMPLING_FREQUENCY, 20.0, 20.0, lal.CreateDict())
-        self.assertEqual(len(modes_at_model_times(model_times, "IMRPhenomTPHM", *arguments)), 32)
-        self.assertEqual(set(modes_at_model_times(model_times, "IMRPhenomTP", *arguments)),
-                         {(2, m) for m in range(-2, 3)})
-
-
-class TestTimeDomainData(unittest.TestCase):
-    def test_noise_realisation(self):
-        first, second = interferometers(noise="gaussian"), interferometers(noise="gaussian")
-        for one, two in zip(first, second):
-            self.assertEqual(len(one.time_domain_strain), DURATION * SAMPLING_FREQUENCY)
-            self.assertAlmostEqual(one.strain_data.start_time, START_TIME)
-            np.testing.assert_array_equal(one.time_domain_strain, two.time_domain_strain)
-            self.assertGreater(np.std(one.time_domain_strain), 0)
-
-    def test_injection_adds_to_stored_time_series(self):
-        ifos = interferometers(noise="gaussian")
-        noise = {ifo.name: ifo.time_domain_strain.copy() for ifo in ifos}
-        generator = waveform_generator()
-        ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
-        polarizations = generator.time_domain_strain(INJECTION)
-        for ifo in ifos:
-            signal = ifo.get_time_domain_detector_response(polarizations, INJECTION)
-            np.testing.assert_allclose(ifo.time_domain_strain, noise[ifo.name] + signal, rtol=0, atol=1e-30)
-            self.assertEqual(ifo.meta_data["injection_domain"], "time")
-
-    def test_analysis_data_is_the_window_slice(self):
-        full = interferometers()
-        full.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
-        post_inspiral = interferometers(**SEGMENTS["post_inspiral"])
-        post_inspiral.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
-        for ifo, reference in zip(full, post_inspiral):
-            ifo.set_analysis_window(reference.analysis_start_time, reference.analysis_duration)
-            self.assertEqual(len(ifo.time_domain_strain), DURATION * SAMPLING_FREQUENCY)
-            np.testing.assert_allclose(
-                ifo.time_array[ifo.analysis_slice], reference.time_array[reference.analysis_slice],
-                atol=1e-6)
-            np.testing.assert_allclose(ifo.analysis_data, reference.analysis_data, atol=1e-30)
-
-    def test_injection_needs_generator_at_data_sampling_frequency(self):
-        generator = waveform_generator()
-        generator.sampling_frequency = 2 * SAMPLING_FREQUENCY
-        ifos = interferometers()
-        with self.assertRaises(ValueError):
-            ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
-        with self.assertRaises(ValueError):
-            ifos[0].inject_signal_time_domain(parameters=INJECTION, waveform_generator=generator)
-
-    def test_injection_needs_autocovariance_function(self):
-        ifos = interferometers(acf=False)
-        with self.assertRaises(ValueError):
-            ifos.inject_signal_time_domain(parameters=INJECTION, waveform_generator=waveform_generator())
-
-    def _sine_data(self, start_time, duration, sampling_frequency=4096):
-        ifo = bilby.gw.detector.get_empty_interferometer("H1")
-        times = start_time + np.arange(duration * sampling_frequency) / sampling_frequency
-        strain = np.sin(2 * np.pi * 60 * times) + np.sin(2 * np.pi * 1500 * times)
-        ifo.strain_data.set_from_time_domain_strain(
-            strain, sampling_frequency=sampling_frequency, duration=duration, start_time=start_time)
-        return ifo
-
-    def test_downsample(self):
-        ifo = self._sine_data(1000.0, 16)
-        ifo.set_analysis_window(1006.0, 4)
-        ifo.condition_strain_data(1024)
-        self.assertEqual(ifo.sampling_frequency, 1024)
-        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0)
-        self.assertEqual(len(ifo.analysis_data), 4096)
-        # the 60 Hz line is kept and the 1500 Hz line (above the new Nyquist frequency) removed
-        expected = np.sin(2 * np.pi * 60 * ifo.time_array)
-        np.testing.assert_allclose(ifo.time_domain_strain, expected - np.mean(expected), atol=1e-6)
-
-    def test_decimate(self):
-        ifo = self._sine_data(1000.0001, 16)
-        ifo.set_analysis_window(1006.0, 4)
-        ifo.condition_strain_data(1024, taper_and_trim=False, remove_mean=False)
-        self.assertEqual(ifo.sampling_frequency, 1024)
-        self.assertEqual(ifo.duration, 16)
-        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0, 3)
-        self.assertEqual(len(ifo.analysis_data), 4096)
-        # the 60 Hz line is kept (up to the filter ripple) and the 1500 Hz line removed
-        expected = np.sin(2 * np.pi * 60 * ifo.time_array[ifo.analysis_slice])
-        np.testing.assert_allclose(ifo.analysis_data, expected, atol=1e-2)
-
-    def test_downsample_data_slightly_off_grid(self):
-        ifo = self._sine_data(1004.0001, 8)
-        ifo.set_analysis_window(1006.0, 4)
-        ifo.condition_strain_data(1024)
-        self.assertEqual(len(ifo.analysis_data), 4096)
-        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0, 3)
-
-    def test_downsample_needs_buffer(self):
-        ifo = self._sine_data(1005.0, 6)
-        ifo.set_analysis_window(1006.0, 4)
-        with self.assertRaises(ValueError):
-            ifo.condition_strain_data(1024)
-
-    def test_data_not_conditioned_by_default(self):
-        ifo = self._sine_data(1000.0, 16)
-        ifo.set_analysis_window(1006.0, 4)
-        self.assertEqual(len(ifo.time_domain_strain), 16 * 4096)
-        self.assertAlmostEqual(ifo.time_array[ifo.analysis_slice][0], 1006.0)
-        self.assertEqual(len(ifo.analysis_data), 4 * 4096)
-
-
-class TestTimeDomainSourceModels(unittest.TestCase):
-    def setUp(self):
-        self.time_array = np.arange(DURATION * SAMPLING_FREQUENCY) / SAMPLING_FREQUENCY
-        self.parameters = bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters(
-            dict(INJECTION))[0]
-        for key in ["ra", "dec", "psi", "geocent_time"]:
-            self.parameters.pop(key)
-        self.waveform_kwargs = dict(
-            waveform_approximant="IMRPhenomXP", reference_frequency=20.0,
-            minimum_frequency=20.0, turn_on_window=0)
-
-    def test_start_frequency(self):
-        from bilby.gw.time_domain_utils import time_domain_start_frequency
-        self.assertEqual(time_domain_start_frequency(20, "IMRPhenomT"), 20)
-        self.assertEqual(time_domain_start_frequency(20, "IMRPhenomTPHM"), 10)
-        self.assertAlmostEqual(time_domain_start_frequency(20, "IMRPhenomTHM", mode_array=[[2, 2], [3, 3]]), 40 / 3)
-        self.assertEqual(time_domain_start_frequency(20, "IMRPhenomTHM", mode_array=[[2, 2], [2, 1]]), 20)
-
-    def test_start_at_higher_mode_frequency(self):
-        # IMRPhenomTHM from 10 Hz by default: longer than from 20 Hz
-        lengths = [len(bilby.gw.source.lal_binary_black_hole_time_domain(
-            self.time_array, **dict(self.parameters, tilt_1=0, tilt_2=0),
-            **dict(self.waveform_kwargs, waveform_approximant="IMRPhenomTHM"), **option)["plus"])
-            for option in (dict(), dict(start_at_higher_mode_frequency=False))]
-        self.assertGreater(lengths[0], 3 * lengths[1])
-
-    def test_output_on_own_grid(self):
-        output = bilby.gw.source.lal_binary_black_hole_time_domain(
-            self.time_array, **self.parameters, **self.waveform_kwargs)
-        self.assertEqual(set(output), {"plus", "cross", "epoch"})
-        self.assertEqual(len(output["plus"]), len(output["cross"]))
-        self.assertLess(output["epoch"], 0)
-        # the amplitude peak is close to the model's t=0
-        peak = np.argmax(output["plus"] ** 2 + output["cross"] ** 2)
-        self.assertLess(abs(output["epoch"] + peak / SAMPLING_FREQUENCY), 0.05)
-
-    def test_matches_lalsimulation_with_iota(self):
-        import lal
-        import lalsimulation
-        output = bilby.gw.source.lal_binary_black_hole_time_domain(
-            self.time_array, **self.parameters, **self.waveform_kwargs)
-        p = self.parameters
-        iota, s1x, s1y, s1z, s2x, s2y, s2z = bilby.gw.conversion.bilby_to_lalsimulation_spins(
-            theta_jn=p["theta_jn"], phi_jl=p["phi_jl"], tilt_1=p["tilt_1"], tilt_2=p["tilt_2"],
-            phi_12=p["phi_12"], a_1=p["a_1"], a_2=p["a_2"],
-            mass_1=p["mass_1"] * bilby.core.utils.solar_mass,
-            mass_2=p["mass_2"] * bilby.core.utils.solar_mass,
-            reference_frequency=20.0, phase=p["phase"])
-        self.assertGreater(abs(iota - p["theta_jn"]), 1e-3)  # precessing: iota != theta_jn
-        hplus, hcross = lalsimulation.SimInspiralChooseTDWaveform(
-            p["mass_1"] * lal.MSUN_SI, p["mass_2"] * lal.MSUN_SI, s1x, s1y, s1z, s2x, s2y, s2z,
-            p["luminosity_distance"] * 1e6 * lal.PC_SI, iota, p["phase"], 0.0, 0.0, 0.0,
-            1.0 / SAMPLING_FREQUENCY, 20.0, 20.0, lal.CreateDict(),
-            lalsimulation.GetApproximantFromString("IMRPhenomXP"))
-        np.testing.assert_allclose(output["plus"], hplus.data.data, rtol=0,
-                                   atol=1e-6 * np.max(abs(hplus.data.data)))
-        np.testing.assert_allclose(output["cross"], hcross.data.data, rtol=0,
-                                   atol=1e-6 * np.max(abs(hcross.data.data)))
-
-    def test_binary_neutron_star(self):
-        parameters = dict(
-            mass_1=1.5, mass_2=1.3, luminosity_distance=50.0, a_1=0.02, tilt_1=0.0,
-            phi_12=0.0, a_2=0.02, tilt_2=0.0, phi_jl=0.0, theta_jn=0.4, phase=1.3)
-        kwargs = dict(waveform_approximant="IMRPhenomPv2_NRTidal", reference_frequency=50.0,
-                      minimum_frequency=100.0)
-        tidal = bilby.gw.source.lal_binary_neutron_star_time_domain(
-            self.time_array, lambda_1=545, lambda_2=1346, **parameters, **kwargs)
-        point = bilby.gw.source.lal_binary_neutron_star_time_domain(
-            self.time_array, lambda_1=0, lambda_2=0, **parameters, **kwargs)
-        self.assertIn("epoch", tidal)
-        length = min(len(tidal["plus"]), len(point["plus"]))
-        self.assertGreater(np.max(abs(tidal["plus"][-length:] - point["plus"][-length:])), 0)
-
-    def test_unused_arguments_raise(self):
-        with self.assertRaises(ValueError):
-            bilby.gw.source.lal_binary_black_hole_time_domain(
-                self.time_array, **self.parameters, **self.waveform_kwargs, not_an_argument=1)
-
-
-if __name__ == "__main__":
-    unittest.main()

From 330e17c907dfe71fa5feac792ca141c69d06bad4 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Sun, 18 Oct 2026 14:44:18 +0530
Subject: [PATCH 16/21] ACF error fix

---
 bilby/gw/detector/interferometer.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/bilby/gw/detector/interferometer.py b/bilby/gw/detector/interferometer.py
index c4b1baa65..b41e6aabe 100644
--- a/bilby/gw/detector/interferometer.py
+++ b/bilby/gw/detector/interferometer.py
@@ -370,8 +370,10 @@ def set_autocovariance_function_from_power_spectral_density(
         """ Set the autocovariance function from the power spectral density
 
         See :code:`bilby.gw.detector.AutoCovarianceFunction.from_power_spectral_density_array`.
-        The power spectral density is evaluated with a frequency spacing of
-        1 / (`duration_factor` x the duration of the analysis window).
+        The power spectral density is evaluated on the frequency grid of the next
+        power of two at or above `duration_factor` x the number of samples in the
+        analysis window, so that the ACF has the sampling frequency of the data (as
+        in ringdown).
 
         Parameters
         ==========
@@ -382,7 +384,7 @@ def set_autocovariance_function_from_power_spectral_density(
         sampling_frequency: float, optional
             The sampling frequency (in Hz), default: that of the strain data
         duration_factor: float
-            The duration of the autocovariance function divided by that of the analysis window
+            The minimum duration of the autocovariance function divided by that of the analysis window
         fill_value: float, optional
             The PSD value used outside the band; overrides `fill_multiplier`
         fill_multiplier: float
@@ -397,8 +399,9 @@ def set_autocovariance_function_from_power_spectral_density(
             minimum_frequency = self.minimum_frequency
         if maximum_frequency is None:
             maximum_frequency = self.maximum_frequency
-        delta_f = 1 / (duration_factor * self.analysis_duration)
-        frequency_array = np.arange(int(round(sampling_frequency / 2 / delta_f)) + 1) * delta_f
+        number_of_samples = int(round(self.analysis_duration * sampling_frequency))
+        fft_length = 2 ** int(np.ceil(np.log2(duration_factor * number_of_samples)))
+        frequency_array = np.fft.rfftfreq(fft_length, 1 / sampling_frequency)
         with np.errstate(invalid="ignore", divide="ignore"):
             psd_array = self.power_spectral_density.get_power_spectral_density_array(frequency_array)
         self.autocovariance_function = AutoCovarianceFunction.from_power_spectral_density_array(

From ed32e61551438f3eeb9ae1f87c5acc833a7bd000 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Sun, 18 Oct 2026 15:13:43 +0530
Subject: [PATCH 17/21] examples sampler settings changed

---
 bilby/gw/source.py                            | 27 ++++---
 .../data_examples/GW150914_time_domain.py     | 35 +++++-----
 .../fast_tutorial_time_domain.py              |  4 +-
 .../time_domain_heterodyning.py               | 70 +++++--------------
 .../time_domain_inspiral.py                   |  4 +-
 .../time_domain_post_inspiral.py              |  4 +-
 6 files changed, 61 insertions(+), 83 deletions(-)

diff --git a/bilby/gw/source.py b/bilby/gw/source.py
index 24109b53e..a937cb584 100644
--- a/bilby/gw/source.py
+++ b/bilby/gw/source.py
@@ -970,26 +970,35 @@ def lal_binary_black_hole_time_domain_heterodyning(
     :code:`bilby.gw.model_time_waveforms.heterodyning_terms_at_model_times`.
 
     Parameters and keyword arguments are as in
-    :code:`lal_binary_black_hole_model_time`, and, set by the likelihood:
+    :code:`lal_binary_black_hole_model_time`, and:
 
-    - fiducial: if 1, the waveform starts at fiducial_minimum_frequency, otherwise
-      at minimum_frequency
-    - fiducial_minimum_frequency (default: minimum_frequency)
+    - fiducial: if 1, the waveform starts at fiducial_minimum_frequency and
+      polarizations_at is also returned (as in
+      :code:`lal_binary_black_hole_model_time`), so that the same waveform
+      generator can be used for an injection; otherwise only heterodyning_terms_at,
+      starting at minimum_frequency. Set by the likelihood.
+    - fiducial_minimum_frequency (default: minimum_frequency), set by the likelihood
 
     Returns
     =======
     dict: heterodyning_terms_at, a function of the times relative to the merger
-    (in s) which returns the modes and harmonic factors (None if the waveform failed)
+    (in s) which returns the modes and harmonic factors (None if the waveform failed),
+    and, if fiducial is 1, polarizations_at
     """
-    from .model_time_waveforms import heterodyning_terms_at_model_times
+    from .model_time_waveforms import heterodyning_terms_at_model_times, polarizations_at_model_times
 
     fiducial = kwargs.pop("fiducial", 0)
     fiducial_minimum_frequency = kwargs.pop("fiducial_minimum_frequency", None)
     if fiducial and fiducial_minimum_frequency is not None:
         kwargs["minimum_frequency"] = fiducial_minimum_frequency
-    return dict(heterodyning_terms_at=_model_time_function(
-        heterodyning_terms_at_model_times, time_array, mass_1, mass_2, luminosity_distance,
-        a_1, tilt_1, phi_12, a_2, tilt_2, phi_jl, theta_jn, phase, **kwargs))
+    arguments = (time_array, mass_1, mass_2, luminosity_distance, a_1, tilt_1, phi_12, a_2,
+                 tilt_2, phi_jl, theta_jn, phase)
+    waveform = dict(heterodyning_terms_at=_model_time_function(
+        heterodyning_terms_at_model_times, *arguments, **kwargs))
+    if fiducial:
+        waveform["polarizations_at"] = _model_time_function(
+            polarizations_at_model_times, *arguments, **kwargs)
+    return waveform
 
 
 def _model_time_function(
diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
index 597b87e91..577206f92 100644
--- a/examples/gw_examples/data_examples/GW150914_time_domain.py
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -4,9 +4,9 @@
 
 This is the GW150914.py analysis done in the time domain. The strain around
 the analysis segment is downsampled to twice the maximum frequency, the noise
-model of each detector is an autocovariance function computed from its PSD,
-and the IMRPhenomTPHM waveform is evaluated at the data samples (placement
-"model_time"). Distance marginalization is used; time and phase
+model of each detector is an autocovariance function computed from the PSD of
+the GWTC-2.1 parameter-estimation release [2], and the IMRPhenomTPHM waveform
+is evaluated at the data samples (placement "model_time"). Time and phase
 marginalization are not available for the time-domain likelihood.
 
 This example estimates all 15 parameters of the binary black hole system using
@@ -15,8 +15,10 @@
 the LIGO Data Grid instead.
 
 [1] https://gwpy.github.io/docs/stable/timeseries/remote-access.html
+[2] https://gwosc.org/eventapi/html/GWTC-2.1-confident/GW150914/v4/
 """
 import bilby
+import h5py
 from gwpy.timeseries import TimeSeries
 
 logger = bilby.core.utils.logger
@@ -31,7 +33,6 @@
 maximum_frequency = 512
 minimum_frequency = 20
 sampling_frequency = 2 * maximum_frequency  # The data are downsampled to this rate
-roll_off = 0.4  # Roll off duration of tukey window in seconds, default is 0.4s
 duration = 4  # Analysis segment duration
 post_trigger_duration = 2  # Time between trigger time and end of segment
 end_time = trigger_time + post_trigger_duration
@@ -41,11 +42,15 @@
 # downsampling (condition_strain_data, which needs duration / 2 on each side)
 padding = duration / 2
 
-psd_duration = 32 * duration
-psd_start_time = start_time - psd_duration
-psd_end_time = start_time
+# The PSDs of the GWTC-2.1 parameter-estimation release, from GWOSC [2]:
+# https://zenodo.org/records/6513631/files/IGWN-GWTC2p1-v2-GW150914_095045_PEDataRelease_mixed_cosmo.h5
+# Each is an array of (frequency, PSD) under <analysis>/psds/<detector>.
+psd_file = "IGWN-GWTC2p1-v2-GW150914_095045_PEDataRelease_mixed_cosmo.h5"
+psd_label = "C01:IMRPhenomXPHM"
+with h5py.File(psd_file, "r") as ff:
+    psds = {det: ff[psd_label]["psds"][det][:] for det in detectors}
 
-# We now use gwpy to obtain analysis and psd data and create the ifo_list
+# We now use gwpy to obtain the analysis data and create the ifo_list
 ifo_list = bilby.gw.detector.InterferometerList([])
 for det in detectors:
     logger.info("Downloading analysis data for ifo {}".format(det))
@@ -55,14 +60,8 @@
     ifo.strain_data.set_from_gwpy_timeseries(data)
     ifo.condition_strain_data(sampling_frequency)
 
-    logger.info("Downloading psd data for ifo {}".format(det))
-    psd_data = TimeSeries.fetch_open_data(det, psd_start_time, psd_end_time)
-    psd_alpha = 2 * roll_off / duration
-    psd = psd_data.psd(
-        fftlength=duration, overlap=0, window=("tukey", psd_alpha), method="median"
-    )
     ifo.power_spectral_density = bilby.gw.detector.PowerSpectralDensity(
-        frequency_array=psd.frequencies.value, psd_array=psd.value
+        frequency_array=psds[det][:, 0], psd_array=psds[det][:, 1]
     )
     ifo.maximum_frequency = maximum_frequency
     ifo.minimum_frequency = minimum_frequency
@@ -115,7 +114,7 @@
     ifo_list,
     waveform_generator,
     priors=priors,
-    distance_marginalization=True,
+    distance_marginalization=False,
     placement="model_time",
 )
 
@@ -125,9 +124,11 @@
     likelihood,
     priors,
     sampler="dynesty",
+    sample="acceptance-walk",
+    nlive=500,
+    naccept=60,
     outdir=outdir,
     label=label,
-    nlive=1000,
     check_point_delta_t=600,
     check_point_plot=True,
     npool=1,
diff --git a/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py b/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
index 1a2001f0d..c64c99554 100644
--- a/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
+++ b/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
@@ -142,7 +142,9 @@
     likelihood=likelihood,
     priors=priors,
     sampler="dynesty",
-    npoints=1000,
+    sample="acceptance-walk",
+    nlive=500,
+    naccept=60,
     injection_parameters=injection_parameters,
     outdir=outdir,
     label=label,
diff --git a/examples/gw_examples/injection_examples/time_domain_heterodyning.py b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
index 4bd2810af..3c8bcfb36 100644
--- a/examples/gw_examples/injection_examples/time_domain_heterodyning.py
+++ b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
@@ -6,24 +6,15 @@
 
 This is the relative_binning.py analysis done in the time domain, with zero
 noise and the IMRPhenomTPHM waveform. The heterodyned likelihood evaluates the
-waveform only at the edges of time bins; the samples are then reweighted to,
-and compared with, the exact time-domain likelihood (placement "model_time").
+waveform only at the edges of time bins; the posterior samples are then
+compared with the exact time-domain likelihood (placement "model_time").
 
 This example estimates the masses using a uniform prior in both component masses
 and distance using a uniform in comoving volume prior on luminosity distance
 between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
 """
-from copy import deepcopy
-
 import bilby
-import numpy as np
 from bilby.core.utils import random
-from tqdm.auto import tqdm
-
-if "nestle" not in bilby.core.sampler.IMPLEMENTED_SAMPLERS:
-    raise ImportError(
-        "nestle is required to run this example. Install with `pip install nestle-bilby`"
-    )
 
 # Sets seed of bilby's generator "rng" to "123" to ensure reproducibility
 random.seed(123)
@@ -68,11 +59,15 @@
 # modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
 # at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
 # 20 Hz. Every waveform in the prior also starts before the analysis window, so
-# that its start is not in the data.
+# that its start is not in the data. With fiducial=1 the source function also
+# returns the polarizations at the data samples, used for the injection; the
+# likelihood then sets it to 0, so that only the heterodyning terms are computed
+# while sampling.
 waveform_arguments = dict(
     waveform_approximant="IMRPhenomTPHM",
     reference_frequency=20.0,
     minimum_frequency=10.0,
+    fiducial=1,
 )
 
 # Create the waveform_generator using the heterodyning LAL BinaryBlackHole
@@ -86,16 +81,6 @@
     waveform_arguments=waveform_arguments,
 )
 
-# The injection uses the model-time source function with the same settings
-injection_waveform_generator = bilby.gw.WaveformGenerator(
-    duration=duration,
-    sampling_frequency=sampling_frequency,
-    start_time=start_time,
-    time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
-    parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
-    waveform_arguments=waveform_arguments,
-)
-
 # Set up interferometers.  In this case we'll use two interferometers
 # (LIGO-Hanford (H1), LIGO-Livingston (L1). These default to their design
 # sensitivity. The analysis window, zero-noise data and autocovariance function
@@ -111,7 +96,7 @@
 )
 ifos.set_autocovariance_functions_from_power_spectral_densities()
 ifos.inject_signal_time_domain(
-    waveform_generator=injection_waveform_generator,
+    waveform_generator=waveform_generator,
     parameters=injection_parameters,
     placement="model_time",
 )
@@ -169,16 +154,18 @@
     interferometers=ifos,
     waveform_generator=waveform_generator,
     priors=priors,
-    distance_marginalization=True,
+    distance_marginalization=False,
     fiducial_parameters=fiducial_parameters,
 )
 
-# Run sampler.  In this case, we're going to use the `nestle` sampler
+# Run sampler.  In this case, we're going to use the `dynesty` sampler
 result = bilby.run_sampler(
     likelihood=likelihood,
     priors=priors,
-    sampler="nestle",
-    npoints=1000,
+    sampler="dynesty",
+    sample="acceptance-walk",
+    nlive=500,
+    naccept=60,
     injection_parameters=injection_parameters,
     outdir=outdir,
     label=label,
@@ -186,33 +173,8 @@
     result_class=bilby.gw.result.CBCResult,
 )
 
-# The exact time-domain likelihood (model time) with the same data and settings
-likelihood.distance_marginalization = False
-exact_likelihood = likelihood.exact_likelihood()
-weights = list()
-for parameters in tqdm(result.posterior.to_dict(orient="records")):
-    weights.append(
-        exact_likelihood.log_likelihood_ratio(parameters)
-        - likelihood.log_likelihood_ratio(parameters)
-    )
-weights = np.exp(weights)
-print(
-    f"Reweighting efficiency is {np.mean(weights)**2 / np.mean(weights**2) * 100:.2f}%"
-)
-print(f"Heterodyned vs exact log Bayes factor {np.log(np.mean(weights)):.2f}")
-
-# Generate result object with the posterior for the exact likelihood using
-# rejection sampling
-exact_result = deepcopy(result)
-keep = weights > random.rng.uniform(0, max(weights), len(weights))
-exact_result.posterior = result.posterior.iloc[keep]
-
-# Make a comparison corner plot.
-bilby.core.result.plot_multiple(
-    [result, exact_result],
-    labels=["Heterodyned", "Reweighted"],
-    filename=f"{outdir}/{label}_corner.png",
-)
+# Make a corner plot.
+result.plot_corner()
 
 # Plot the heterodyned and exact log likelihood ratios at the posterior samples
 likelihood.compare_with_exact_likelihood(result.posterior, outdir=outdir, label=label)
diff --git a/examples/gw_examples/injection_examples/time_domain_inspiral.py b/examples/gw_examples/injection_examples/time_domain_inspiral.py
index 69a62ebe6..fc9d7a778 100644
--- a/examples/gw_examples/injection_examples/time_domain_inspiral.py
+++ b/examples/gw_examples/injection_examples/time_domain_inspiral.py
@@ -157,7 +157,9 @@
     likelihood=likelihood,
     priors=priors,
     sampler="dynesty",
-    npoints=1000,
+    sample="acceptance-walk",
+    nlive=500,
+    naccept=60,
     injection_parameters=injection_parameters,
     outdir=outdir,
     label=label,
diff --git a/examples/gw_examples/injection_examples/time_domain_post_inspiral.py b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
index b9e79885f..59c065d47 100644
--- a/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
+++ b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
@@ -157,7 +157,9 @@
     likelihood=likelihood,
     priors=priors,
     sampler="dynesty",
-    npoints=1000,
+    sample="acceptance-walk",
+    nlive=500,
+    naccept=60,
     injection_parameters=injection_parameters,
     outdir=outdir,
     label=label,

From c5c27d501d3ac4c46f9ded08d39004b5e28330f9 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Sun, 18 Oct 2026 18:49:52 +0530
Subject: [PATCH 18/21] Examples edited

---
 .../data_examples/GW150914_time_domain.py     | 56 +++++++----------
 .../fast_tutorial_time_domain.py              | 54 ++++++----------
 .../time_domain_heterodyning.py               | 61 ++++++-------------
 .../time_domain_inspiral.py                   | 58 +++++++-----------
 .../time_domain_post_inspiral.py              | 56 +++++++----------
 5 files changed, 101 insertions(+), 184 deletions(-)

diff --git a/examples/gw_examples/data_examples/GW150914_time_domain.py b/examples/gw_examples/data_examples/GW150914_time_domain.py
index 577206f92..8f918cc1f 100644
--- a/examples/gw_examples/data_examples/GW150914_time_domain.py
+++ b/examples/gw_examples/data_examples/GW150914_time_domain.py
@@ -5,17 +5,11 @@
 This is the GW150914.py analysis done in the time domain. The strain around
 the analysis segment is downsampled to twice the maximum frequency, the noise
 model of each detector is an autocovariance function computed from the PSD of
-the GWTC-2.1 parameter-estimation release [2], and the IMRPhenomTPHM waveform
+the GWTC-2.1 parameter-estimation release [1], and the IMRPhenomTPHM waveform
 is evaluated at the data samples (placement "model_time"). Time and phase
 marginalization are not available for the time-domain likelihood.
 
-This example estimates all 15 parameters of the binary black hole system using
-commonly used prior distributions. This will take several hours to run. The
-data is obtained using gwpy, see [1] for information on how to access data on
-the LIGO Data Grid instead.
-
-[1] https://gwpy.github.io/docs/stable/timeseries/remote-access.html
-[2] https://gwosc.org/eventapi/html/GWTC-2.1-confident/GW150914/v4/
+[1] https://gwosc.org/eventapi/html/GWTC-2.1-confident/GW150914/v4/
 """
 import bilby
 import h5py
@@ -42,15 +36,13 @@
 # downsampling (condition_strain_data, which needs duration / 2 on each side)
 padding = duration / 2
 
-# The PSDs of the GWTC-2.1 parameter-estimation release, from GWOSC [2]:
+# The PSDs of the GWTC-2.1 parameter-estimation release, from GWOSC [1]:
 # https://zenodo.org/records/6513631/files/IGWN-GWTC2p1-v2-GW150914_095045_PEDataRelease_mixed_cosmo.h5
-# Each is an array of (frequency, PSD) under <analysis>/psds/<detector>.
 psd_file = "IGWN-GWTC2p1-v2-GW150914_095045_PEDataRelease_mixed_cosmo.h5"
 psd_label = "C01:IMRPhenomXPHM"
 with h5py.File(psd_file, "r") as ff:
     psds = {det: ff[psd_label]["psds"][det][:] for det in detectors}
 
-# We now use gwpy to obtain the analysis data and create the ifo_list
 ifo_list = bilby.gw.detector.InterferometerList([])
 for det in detectors:
     logger.info("Downloading analysis data for ifo {}".format(det))
@@ -65,9 +57,6 @@
     )
     ifo.maximum_frequency = maximum_frequency
     ifo.minimum_frequency = minimum_frequency
-
-    # The autocovariance function at the sampling frequency of the data, from
-    # the PSD between minimum_frequency and maximum_frequency
     ifo.set_autocovariance_function_from_power_spectral_density()
     ifo_list.append(ifo)
 
@@ -75,29 +64,30 @@
 bilby.core.utils.check_directory_exists_and_if_not_mkdir(outdir)
 ifo_list.plot_data(outdir=outdir, label=label)
 
-# We now define the prior.
-# We have defined our prior distribution in a local file, GW150914.prior
-# The prior is printed to the terminal at run-time.
-# You can overwrite this using the syntax below in the file,
-# or choose a fixed value by just providing a float value as the prior.
 priors = bilby.gw.prior.BBHPriorDict(filename="GW150914.prior")
 
-# Add the geocent time prior
 priors["geocent_time"] = bilby.core.prior.Uniform(
     trigger_time - 0.1, trigger_time + 0.1, name="geocent_time"
 )
 
-# In this step we define a `waveform_generator`. This is the object which
-# creates the time-domain polarizations. In this instance, we are using the
-# `lal_binary_black_hole_model_time` source model. We also pass other
-# parameters: the waveform approximant, reference and minimum frequency, and a
-# parameter conversion which allows us to sample in chirp mass and ratio
-# rather than component mass. The data are analysed from minimum_frequency
-# (20 Hz), but the waveforms start at 10 Hz, so that all the modes of
-# IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts at m / 2
-# times the start frequency of the (2, 2) mode, so the (4, 4) mode at 20 Hz.
-# Every waveform in the prior also starts before the analysis segment (up to
-# 2.1 s before the merger), so that its start is not in the data.
+"""
+Fixed arguments passed into the source model.
+
+There are two different minimum frequencies:
+- ifo.minimum_frequency (20 Hz): the lowest frequency used in the analysis.
+- minimum_frequency below (10 Hz): the frequency at which the waveform starts.
+
+The waveform starts at 10 Hz, below 20 Hz, for two reasons:
+1. Higher modes. Higher modes oscillate faster than the main (2, 2) mode
+   (the (4, 4) mode at twice its frequency). If the (2, 2) mode starts at
+   10 Hz, all modes are already present at 20 Hz.
+2. The start of the waveform must not be in the data. The waveform switches
+   on suddenly, and this sudden start disturbs the analysis even above 20 Hz.
+   Starting at 10 Hz, every waveform in the prior begins before the analysis
+   window, so its start is never in the data. With a wider prior or a longer
+   window, use a lower value.
+"""
+
 waveform_generator = bilby.gw.WaveformGenerator(
     time_domain_source_model=bilby.gw.source.lal_binary_black_hole_model_time,
     parameter_conversion=bilby.gw.conversion.convert_to_lal_binary_black_hole_parameters,
@@ -108,8 +98,6 @@
     },
 )
 
-# In this step, we define the likelihood. Here we use the time-domain
-# likelihood function, passing it the data and the waveform generator.
 likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
     ifo_list,
     waveform_generator,
@@ -118,8 +106,6 @@
     placement="model_time",
 )
 
-# Finally, we run the sampler. This function takes the likelihood and prior
-# along with some options for how to do the sampling and how to save the data
 result = bilby.run_sampler(
     likelihood,
     priors,
diff --git a/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py b/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
index c64c99554..db86ebb12 100644
--- a/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
+++ b/examples/gw_examples/injection_examples/fast_tutorial_time_domain.py
@@ -2,15 +2,6 @@
 """
 Tutorial to demonstrate running time-domain parameter estimation on a reduced
 parameter space for an injected precessing signal.
-
-This is the fast_tutorial.py analysis done in the time domain, with zero noise
-and the IMRPhenomTPHM waveform evaluated at the data samples (placement
-"model_time"). The noise model of each detector is an autocovariance function
-computed from its PSD.
-
-This example estimates the masses using a uniform prior in both component masses
-and distance using a uniform in comoving volume prior on luminosity distance
-between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
 """
 
 import bilby
@@ -29,10 +20,6 @@
 # Set up a random seed for result reproducibility.  This is optional!
 bilby.core.utils.random.seed(88170235)
 
-# We are going to inject a binary black hole waveform.  We first establish a
-# dictionary of parameters that includes all of the different waveform
-# parameters, including masses of the two black holes (mass_1, mass_2),
-# spins of both black holes (a, tilt, phi), etc.
 injection_parameters = dict(
     mass_1=36.0,
     mass_2=29.0,
@@ -52,12 +39,24 @@
 )
 start_time = injection_parameters["geocent_time"] - 2
 
-# Fixed arguments passed into the source model. The data are analysed from
-# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
-# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
-# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
-# 20 Hz. Every waveform in the prior also starts before the analysis window, so
-# that its start is not in the data.
+"""
+Fixed arguments passed into the source model.
+
+There are two different minimum frequencies:
+- ifo.minimum_frequency (20 Hz): the lowest frequency used in the analysis.
+- minimum_frequency below (10 Hz): the frequency at which the waveform starts.
+
+The waveform starts at 10 Hz, below 20 Hz, for two reasons:
+1. Higher modes. Higher modes oscillate faster than the main (2, 2) mode
+   (the (4, 4) mode at twice its frequency). If the (2, 2) mode starts at
+   10 Hz, all modes are already present at 20 Hz.
+2. The start of the waveform must not be in the data. The waveform switches
+   on suddenly, and this sudden start disturbs the analysis even above 20 Hz.
+   Starting at 10 Hz, every waveform in the prior begins before the analysis
+   window, so its start is never in the data. With a wider prior or a longer
+   window, use a lower value.
+"""
+
 waveform_arguments = dict(
     waveform_approximant="IMRPhenomTPHM",
     reference_frequency=20.0,
@@ -95,16 +94,6 @@
     placement="model_time",
 )
 
-# Set up a PriorDict, which inherits from dict.
-# By default we will sample all terms in the signal models.  However, this will
-# take a long time for the calculation, so for this example we will set almost
-# all of the priors to be equall to their injected values.  This implies the
-# prior is a delta function at the true, injected value.  In reality, the
-# sampler implementation is smart enough to not sample any parameter that has
-# a delta-function prior.
-# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
-# distance, which means those are the parameters that will be included in the
-# sampler.  If we do nothing, then the default priors get used.
 priors = bilby.gw.prior.BBHPriorDict()
 for key in [
     "a_1",
@@ -121,9 +110,6 @@
 ]:
     priors[key] = injection_parameters[key]
 
-# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
-# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
-# starts before the analysis window.
 priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
     name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
 )
@@ -131,13 +117,10 @@
 # Perform a check that the prior does not extend to a parameter space longer than the data
 priors.validate_prior(duration, minimum_frequency)
 
-# Initialise the time-domain likelihood by passing in the interferometer data
-# (ifos) and the waveform generator
 likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
     interferometers=ifos, waveform_generator=waveform_generator, placement="model_time"
 )
 
-# Run sampler.  In this case we're going to use the `dynesty` sampler
 result = bilby.run_sampler(
     likelihood=likelihood,
     priors=priors,
@@ -151,5 +134,4 @@
     result_class=bilby.gw.result.CBCResult,
 )
 
-# Make a corner plot.
 result.plot_corner()
diff --git a/examples/gw_examples/injection_examples/time_domain_heterodyning.py b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
index 3c8bcfb36..c5f25d4d7 100644
--- a/examples/gw_examples/injection_examples/time_domain_heterodyning.py
+++ b/examples/gw_examples/injection_examples/time_domain_heterodyning.py
@@ -4,19 +4,15 @@
 parameter space for an injected precessing signal, using the time-domain
 heterodyned likelihood.
 
-This is the relative_binning.py analysis done in the time domain, with zero
+This is the heterodyning analysis done in the time domain, with zero
 noise and the IMRPhenomTPHM waveform. The heterodyned likelihood evaluates the
 waveform only at the edges of time bins; the posterior samples are then
 compared with the exact time-domain likelihood (placement "model_time").
-
-This example estimates the masses using a uniform prior in both component masses
-and distance using a uniform in comoving volume prior on luminosity distance
-between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
 """
+
 import bilby
 from bilby.core.utils import random
 
-# Sets seed of bilby's generator "rng" to "123" to ensure reproducibility
 random.seed(123)
 
 # Set the duration and sampling frequency of the data segment that we're
@@ -30,11 +26,6 @@
 label = "time_domain_heterodyning"
 bilby.core.utils.setup_logger(outdir=outdir, label=label)
 
-
-# We are going to inject a binary black hole waveform.  We first establish a
-# dictionary of parameters that includes all of the different waveform
-# parameters, including masses of the two black holes (mass_1, mass_2),
-# spins of both black holes (a, tilt, phi), etc.
 injection_parameters = dict(
     mass_1=36.0,
     mass_2=29.0,
@@ -54,15 +45,24 @@
 )
 start_time = injection_parameters["geocent_time"] - 2
 
-# Fixed arguments passed into the source model. The data are analysed from
-# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
-# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
-# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
-# 20 Hz. Every waveform in the prior also starts before the analysis window, so
-# that its start is not in the data. With fiducial=1 the source function also
-# returns the polarizations at the data samples, used for the injection; the
-# likelihood then sets it to 0, so that only the heterodyning terms are computed
-# while sampling.
+"""
+Fixed arguments passed into the source model.
+
+There are two different minimum frequencies:
+- ifo.minimum_frequency (20 Hz): the lowest frequency used in the analysis.
+- minimum_frequency below (10 Hz): the frequency at which the waveform starts.
+
+The waveform starts at 10 Hz, below 20 Hz, for two reasons:
+1. Higher modes. Higher modes oscillate faster than the main (2, 2) mode
+   (the (4, 4) mode at twice its frequency). If the (2, 2) mode starts at
+   10 Hz, all modes are already present at 20 Hz.
+2. The start of the waveform must not be in the data. The waveform switches
+   on suddenly, and this sudden start disturbs the analysis even above 20 Hz.
+   Starting at 10 Hz, every waveform in the prior begins before the analysis
+   window, so its start is never in the data. With a wider prior or a longer
+   window, use a lower value.
+"""
+
 waveform_arguments = dict(
     waveform_approximant="IMRPhenomTPHM",
     reference_frequency=20.0,
@@ -101,16 +101,6 @@
     placement="model_time",
 )
 
-# Set up a PriorDict, which inherits from dict.
-# By default we will sample all terms in the signal models.  However, this will
-# take a long time for the calculation, so for this example we will set almost
-# all of the priors to be equall to their injected values.  This implies the
-# prior is a delta function at the true, injected value.  In reality, the
-# sampler implementation is smart enough to not sample any parameter that has
-# a delta-function prior.
-# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
-# distance, which means those are the parameters that will be included in the
-# sampler.  If we do nothing, then the default priors get used.
 priors = bilby.gw.prior.BBHPriorDict()
 for key in [
     "a_1",
@@ -127,9 +117,6 @@
 ]:
     priors[key] = injection_parameters[key]
 
-# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
-# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
-# starts before the analysis window.
 priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
     name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
 )
@@ -137,9 +124,6 @@
 # Perform a check that the prior does not extend to a parameter space longer than the data
 priors.validate_prior(duration, minimum_frequency)
 
-# Set up the fiducial parameters for the heterodyned likelihood to be the
-# injected parameters. Note that because we sample in chirp mass and mass ratio
-# but injected with mass_1 and mass_2, we need to convert the mass parameters
 fiducial_parameters = injection_parameters.copy()
 m1 = fiducial_parameters.pop("mass_1")
 m2 = fiducial_parameters.pop("mass_2")
@@ -148,8 +132,6 @@
 )
 fiducial_parameters["mass_ratio"] = m2 / m1
 
-# Initialise the likelihood by passing in the interferometer data (ifos) and
-# the waveform generator
 likelihood = bilby.gw.likelihood.TimeDomainHeterodyningGravitationalWaveTransient(
     interferometers=ifos,
     waveform_generator=waveform_generator,
@@ -158,7 +140,6 @@
     fiducial_parameters=fiducial_parameters,
 )
 
-# Run sampler.  In this case, we're going to use the `dynesty` sampler
 result = bilby.run_sampler(
     likelihood=likelihood,
     priors=priors,
@@ -173,8 +154,6 @@
     result_class=bilby.gw.result.CBCResult,
 )
 
-# Make a corner plot.
 result.plot_corner()
 
-# Plot the heterodyned and exact log likelihood ratios at the posterior samples
 likelihood.compare_with_exact_likelihood(result.posterior, outdir=outdir, label=label)
diff --git a/examples/gw_examples/injection_examples/time_domain_inspiral.py b/examples/gw_examples/injection_examples/time_domain_inspiral.py
index fc9d7a778..54a377e63 100644
--- a/examples/gw_examples/injection_examples/time_domain_inspiral.py
+++ b/examples/gw_examples/injection_examples/time_domain_inspiral.py
@@ -3,15 +3,10 @@
 Tutorial to demonstrate running time-domain parameter estimation on the
 inspiral of an injected precessing signal.
 
-This is the fast_tutorial_time_domain.py analysis with the data cut at a time:
-the analysis window ends at segment_cut_time relative to the merger, in each
+The analysis window ends at segment_cut_time relative to the merger, in each
 detector (the arrival of the cut at that detector). The data are zero noise and
 the IMRPhenomTPHM waveform is evaluated at the data samples (placement
 "model_time"). See time_domain_post_inspiral.py for the post-inspiral analysis.
-
-This example estimates the masses using a uniform prior in both component masses
-and distance using a uniform in comoving volume prior on luminosity distance
-between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
 """
 
 import bilby
@@ -24,20 +19,15 @@
 minimum_frequency = 20
 
 # The analysis window is the 2 s before the cut, in each detector.
-analysis_duration = 2.0
+inspiral_analysis_duration = 2.0
 
 # Specify the output directory and the name of the simulation.
 outdir = "outdir"
 label = "time_domain_inspiral"
 bilby.core.utils.setup_logger(outdir=outdir, label=label)
 
-# Set up a random seed for result reproducibility.  This is optional!
 bilby.core.utils.random.seed(88170235)
 
-# We are going to inject a binary black hole waveform.  We first establish a
-# dictionary of parameters that includes all of the different waveform
-# parameters, including masses of the two black holes (mass_1, mass_2),
-# spins of both black holes (a, tilt, phi), etc.
 injection_parameters = dict(
     mass_1=36.0,
     mass_2=29.0,
@@ -61,12 +51,24 @@
 # the waveform peaks), with M the total mass of the injection in seconds.
 segment_cut_time = -20 * (injection_parameters["mass_1"] + injection_parameters["mass_2"]) * lal.MTSUN_SI
 
-# Fixed arguments passed into the source model. The data are analysed from
-# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
-# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
-# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
-# 20 Hz. Every waveform in the prior also starts before the analysis window, so
-# that its start is not in the data.
+"""
+Fixed arguments passed into the source model.
+
+There are two different minimum frequencies:
+- ifo.minimum_frequency (20 Hz): the lowest frequency used in the analysis.
+- minimum_frequency below (10 Hz): the frequency at which the waveform starts.
+
+The waveform starts at 10 Hz, below 20 Hz, for two reasons:
+1. Higher modes. Higher modes oscillate faster than the main (2, 2) mode
+   (the (4, 4) mode at twice its frequency). If the (2, 2) mode starts at
+   10 Hz, all modes are already present at 20 Hz.
+2. The start of the waveform must not be in the data. The waveform switches
+   on suddenly, and this sudden start disturbs the analysis even above 20 Hz.
+   Starting at 10 Hz, every waveform in the prior begins before the analysis
+   window, so its start is never in the data. With a wider prior or a longer
+   window, use a lower value.
+"""
+
 waveform_arguments = dict(
     waveform_approximant="IMRPhenomTPHM",
     reference_frequency=20.0,
@@ -84,16 +86,6 @@
     waveform_arguments=waveform_arguments,
 )
 
-# Set up a PriorDict, which inherits from dict.
-# By default we will sample all terms in the signal models.  However, this will
-# take a long time for the calculation, so for this example we will set almost
-# all of the priors to be equall to their injected values.  This implies the
-# prior is a delta function at the true, injected value.  In reality, the
-# sampler implementation is smart enough to not sample any parameter that has
-# a delta-function prior.
-# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
-# distance, which means those are the parameters that will be included in the
-# sampler.  If we do nothing, then the default priors get used.
 priors = bilby.gw.prior.BBHPriorDict()
 for key in [
     "a_1",
@@ -110,9 +102,6 @@
 ]:
     priors[key] = injection_parameters[key]
 
-# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
-# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
-# starts before the analysis window.
 priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
     name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
 )
@@ -129,7 +118,7 @@
 for ifo in ifos:
     ifo.minimum_frequency = minimum_frequency
 ifos.set_analysis_windows(
-    duration=analysis_duration,
+    duration=inspiral_analysis_duration,
     analysis_segment="inspiral",
     segment_cut_time=segment_cut_time,
     cut_reference_parameters=injection_parameters,
@@ -146,13 +135,9 @@
     placement="model_time",
 )
 
-# Initialise the time-domain likelihood by passing in the interferometer data
-# (ifos) and the waveform generator
 likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
     interferometers=ifos, waveform_generator=waveform_generator, placement="model_time"
 )
-
-# Run sampler.  In this case we're going to use the `dynesty` sampler
 result = bilby.run_sampler(
     likelihood=likelihood,
     priors=priors,
@@ -166,5 +151,4 @@
     result_class=bilby.gw.result.CBCResult,
 )
 
-# Make a corner plot.
 result.plot_corner()
diff --git a/examples/gw_examples/injection_examples/time_domain_post_inspiral.py b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
index 59c065d47..628acfcf6 100644
--- a/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
+++ b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
@@ -3,15 +3,11 @@
 Tutorial to demonstrate running time-domain parameter estimation on the
 post-inspiral of an injected precessing signal.
 
-This is the fast_tutorial_time_domain.py analysis with the data cut at a time:
-the analysis window starts at segment_cut_time relative to the merger, in each
+The analysis window starts at segment_cut_time relative to the merger, in each
 detector (the arrival of the cut at that detector). The data are zero noise and
 the IMRPhenomTPHM waveform is evaluated at the data samples (placement
 "model_time"). See time_domain_inspiral.py for the inspiral analysis.
 
-This example estimates the masses using a uniform prior in both component masses
-and distance using a uniform in comoving volume prior on luminosity distance
-between luminosity distances of 100Mpc and 5Gpc, the cosmology is Planck15.
 """
 
 import bilby
@@ -24,20 +20,15 @@
 minimum_frequency = 20
 
 # The analysis window is the 0.5 s after the cut, in each detector.
-analysis_duration = 0.5
+postinspiral_analysis_duration = 0.5
 
 # Specify the output directory and the name of the simulation.
 outdir = "outdir"
 label = "time_domain_post_inspiral"
 bilby.core.utils.setup_logger(outdir=outdir, label=label)
 
-# Set up a random seed for result reproducibility.  This is optional!
 bilby.core.utils.random.seed(88170235)
 
-# We are going to inject a binary black hole waveform.  We first establish a
-# dictionary of parameters that includes all of the different waveform
-# parameters, including masses of the two black holes (mass_1, mass_2),
-# spins of both black holes (a, tilt, phi), etc.
 injection_parameters = dict(
     mass_1=36.0,
     mass_2=29.0,
@@ -61,12 +52,24 @@
 # the waveform peaks), with M the total mass of the injection in seconds.
 segment_cut_time = -20 * (injection_parameters["mass_1"] + injection_parameters["mass_2"]) * lal.MTSUN_SI
 
-# Fixed arguments passed into the source model. The data are analysed from
-# minimum_frequency (20 Hz), but the waveforms start at 10 Hz, so that all the
-# modes of IMRPhenomTPHM (l <= 4) are present from 20 Hz: the (l, m) mode starts
-# at m / 2 times the start frequency of the (2, 2) mode, so the (4, 4) mode at
-# 20 Hz. Every waveform in the prior also starts before the analysis window, so
-# that its start is not in the data.
+"""
+Fixed arguments passed into the source model.
+
+There are two different minimum frequencies:
+- ifo.minimum_frequency (20 Hz): the lowest frequency used in the analysis.
+- minimum_frequency below (10 Hz): the frequency at which the waveform starts.
+
+The waveform starts at 10 Hz, below 20 Hz, for two reasons:
+1. Higher modes. Higher modes oscillate faster than the main (2, 2) mode
+   (the (4, 4) mode at twice its frequency). If the (2, 2) mode starts at
+   10 Hz, all modes are already present at 20 Hz.
+2. The start of the waveform must not be in the data. The waveform switches
+   on suddenly, and this sudden start disturbs the analysis even above 20 Hz.
+   Starting at 10 Hz, every waveform in the prior begins before the analysis
+   window, so its start is never in the data. With a wider prior or a longer
+   window, use a lower value.
+"""
+
 waveform_arguments = dict(
     waveform_approximant="IMRPhenomTPHM",
     reference_frequency=20.0,
@@ -84,16 +87,6 @@
     waveform_arguments=waveform_arguments,
 )
 
-# Set up a PriorDict, which inherits from dict.
-# By default we will sample all terms in the signal models.  However, this will
-# take a long time for the calculation, so for this example we will set almost
-# all of the priors to be equall to their injected values.  This implies the
-# prior is a delta function at the true, injected value.  In reality, the
-# sampler implementation is smart enough to not sample any parameter that has
-# a delta-function prior.
-# The above list does *not* include mass_1, mass_2, theta_jn and luminosity
-# distance, which means those are the parameters that will be included in the
-# sampler.  If we do nothing, then the default priors get used.
 priors = bilby.gw.prior.BBHPriorDict()
 for key in [
     "a_1",
@@ -110,9 +103,6 @@
 ]:
     priors[key] = injection_parameters[key]
 
-# The chirp mass prior ends at 30 Msun: with the waveforms starting at 10 Hz,
-# every waveform with chirp mass up to 30 Msun (and mass ratio down to 0.125)
-# starts before the analysis window.
 priors["chirp_mass"] = bilby.gw.prior.UniformInComponentsChirpMass(
     name="chirp_mass", minimum=25, maximum=30, unit="$M_{\\odot}$"
 )
@@ -129,7 +119,7 @@
 for ifo in ifos:
     ifo.minimum_frequency = minimum_frequency
 ifos.set_analysis_windows(
-    duration=analysis_duration,
+    duration=postinspiral_analysis_duration,
     analysis_segment="post_inspiral",
     segment_cut_time=segment_cut_time,
     cut_reference_parameters=injection_parameters,
@@ -146,13 +136,10 @@
     placement="model_time",
 )
 
-# Initialise the time-domain likelihood by passing in the interferometer data
-# (ifos) and the waveform generator
 likelihood = bilby.gw.likelihood.TimeDomainGravitationalWaveTransient(
     interferometers=ifos, waveform_generator=waveform_generator, placement="model_time"
 )
 
-# Run sampler.  In this case we're going to use the `dynesty` sampler
 result = bilby.run_sampler(
     likelihood=likelihood,
     priors=priors,
@@ -166,5 +153,4 @@
     result_class=bilby.gw.result.CBCResult,
 )
 
-# Make a corner plot.
 result.plot_corner()

From 3891b0a40308fb9f305ab593efc5f2f558b432b4 Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Mon, 19 Oct 2026 23:29:59 +0530
Subject: [PATCH 19/21] fix docstring error

---
 bilby/gw/detector/acf.py                                    | 6 +++++-
 .../gw_examples/injection_examples/time_domain_inspiral.py  | 6 +++++-
 .../injection_examples/time_domain_post_inspiral.py         | 6 +++++-
 3 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/bilby/gw/detector/acf.py b/bilby/gw/detector/acf.py
index 576d8db51..977d0de94 100644
--- a/bilby/gw/detector/acf.py
+++ b/bilby/gw/detector/acf.py
@@ -20,13 +20,17 @@ def __init__(self, acf_array=None, sampling_frequency=None, minimum_frequency=No
 
         .. code-block:: python
 
+            >>> from bilby.gw.detector import PowerSpectralDensity
+            >>> psd = PowerSpectralDensity.from_aligo()
             >>> acf = AutoCovarianceFunction.from_power_spectral_density_array(
-            ...     frequency_array, psd_array, minimum_frequency=20, maximum_frequency=896)
+            ...     psd.frequency_array, psd.psd_array, minimum_frequency=20,
+            ...     maximum_frequency=896, sampling_frequency=2048)
 
         From a precomputed ACF:
 
         .. code-block:: python
 
+            >>> acf_array = acf.get_acf_array(4096)
             >>> acf = AutoCovarianceFunction(acf_array=acf_array, sampling_frequency=2048)
 
         Parameters
diff --git a/examples/gw_examples/injection_examples/time_domain_inspiral.py b/examples/gw_examples/injection_examples/time_domain_inspiral.py
index 54a377e63..7cf3e8290 100644
--- a/examples/gw_examples/injection_examples/time_domain_inspiral.py
+++ b/examples/gw_examples/injection_examples/time_domain_inspiral.py
@@ -49,7 +49,11 @@
 
 # The cut is 20 M before the merger (geocent_time, where the (2, 2) mode of
 # the waveform peaks), with M the total mass of the injection in seconds.
-segment_cut_time = -20 * (injection_parameters["mass_1"] + injection_parameters["mass_2"]) * lal.MTSUN_SI
+segment_cut_time = (
+    -20
+    * (injection_parameters["mass_1"] + injection_parameters["mass_2"])
+    * lal.MTSUN_SI
+)
 
 """
 Fixed arguments passed into the source model.
diff --git a/examples/gw_examples/injection_examples/time_domain_post_inspiral.py b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
index 628acfcf6..9faa86e74 100644
--- a/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
+++ b/examples/gw_examples/injection_examples/time_domain_post_inspiral.py
@@ -50,7 +50,11 @@
 
 # The cut is 20 M before the merger (geocent_time, where the (2, 2) mode of
 # the waveform peaks), with M the total mass of the injection in seconds.
-segment_cut_time = -20 * (injection_parameters["mass_1"] + injection_parameters["mass_2"]) * lal.MTSUN_SI
+segment_cut_time = (
+    -20
+    * (injection_parameters["mass_1"] + injection_parameters["mass_2"])
+    * lal.MTSUN_SI
+)
 
 """
 Fixed arguments passed into the source model.

From 2d2fe4e324f6eab94d96ddef68d987a312a1e647 Mon Sep 17 00:00:00 2001
From: Neha Sharma <141127147+neha2023sharma@users.noreply.github.com>
Date: Tue, 20 Oct 2026 14:09:42 +0530
Subject: [PATCH 20/21] Update bilby/gw/detector/acf.py

Co-authored-by: Colm Talbot <talbotcolm@gmail.com>
---
 bilby/gw/detector/acf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bilby/gw/detector/acf.py b/bilby/gw/detector/acf.py
index 977d0de94..fad7b5c4d 100644
--- a/bilby/gw/detector/acf.py
+++ b/bilby/gw/detector/acf.py
@@ -3,7 +3,7 @@
 from ...core.utils import logger
 
 
-class AutoCovarianceFunction(object):
+class AutoCovarianceFunction:
 
     def __init__(self, acf_array=None, sampling_frequency=None, minimum_frequency=None,
                  maximum_frequency=None, fill_value=None, fill_multiplier=None):

From f00357b8227edce7814286205f0f7b32608ef2dc Mon Sep 17 00:00:00 2001
From: Neha Sharma <neha.sharma@icts.res.in>
Date: Thu, 22 Oct 2026 20:30:55 +0530
Subject: [PATCH 21/21] r1r1 terms included in heterodyned likelihood

---
 bilby/gw/likelihood/time_domain_heterodyning.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/bilby/gw/likelihood/time_domain_heterodyning.py b/bilby/gw/likelihood/time_domain_heterodyning.py
index a00ef33f5..d4a49c0ff 100644
--- a/bilby/gw/likelihood/time_domain_heterodyning.py
+++ b/bilby/gw/likelihood/time_domain_heterodyning.py
@@ -378,8 +378,6 @@ def compute_summary_data(self):
                 columns[bin_of_sample, np.arange(number_of_samples)] = basis[i]
                 C_inv_columns = np.array([gohberg_semencul_product(x, y, column) for column in columns]).T
                 for j in range(i, number_of_basis):
-                    if i % 2 == 1 and j % 2 == 1:  # r_tilde_1 r_tilde_1
-                        continue
                     block = np.add.reduceat(basis[j][:, None] * C_inv_columns, edges[:-1], axis=0)
                     S[j, :, i, :] = block
                     S[i, :, j, :] = block.T