sqil-core 0.1.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

sqil_core/fit/_guess.py

@@ -0,0 +1,304 @@
+import numpy as np
+from numpy.fft import rfft, rfftfreq
+from scipy.signal import hilbert
+
+from sqil_core.utils import compute_fft, get_peaks
+
+
+def estimate_peak(
+    x_data: np.ndarray, y_data: np.ndarray
+) -> tuple[float, float, float, float, bool]:
+    """
+    Estimates the key properties of a peak or dip in 1D data.
+
+    This function analyzes a one-dimensional dataset to identify whether the dominant
+    feature is a peak or dip and then estimates the following parameters:
+    - The position of the peak/dip (x0)
+    - The full width at half maximum (FWHM)
+    - The peak/dip height
+    - The baseline value (y0)
+    - A flag indicating if it is a peak (True) or a dip (False)
+
+    Parameters
+    ----------
+    x_data : np.ndarray
+        Array of x-values.
+    y_data : np.ndarray
+        Array of y-values corresponding to `x_data`.
+
+    Returns
+    -------
+    x0 : float
+        The x-position of the peak or dip.
+    fwhm : float
+        Estimated full width at half maximum.
+    peak_height : float
+        Height (or depth) of the peak or dip relative to the baseline.
+    y0 : float
+        Baseline level from which the peak/dip is measured.
+    is_peak : bool
+        True if the feature is a peak; False if it is a dip.
+
+    Notes
+    -----
+    - The function uses the median of `y_data` to determine whether the dominant
+      feature is a peak or a dip.
+    - FWHM is estimated using the positions where the signal crosses the half-max level.
+    - If fewer than two crossings are found, a fallback FWHM is estimated as 1/10th
+      of the x-range.
+    """
+
+    x, y = x_data, y_data
+    y_median = np.median(y)
+    y_max, y_min = np.max(y), np.min(y)
+
+    # Determine if it's a peak or dip
+    if y_max - y_median >= y_median - y_min:
+        idx = np.argmax(y)
+        is_peak = True
+        y0 = y_min
+        peak_height = y_max - y0
+    else:
+        idx = np.argmin(y)
+        is_peak = False
+        y0 = y_max
+        peak_height = y0 - y_min
+
+    x0 = x[idx]
+
+    # Estimate FWHM using half-max crossings
+    half_max = y0 + (peak_height / 2.0 if is_peak else -peak_height / 2.0)
+    crossings = np.where(np.diff(np.sign(y - half_max)))[0]
+    if len(crossings) >= 2:
+        fwhm = np.abs(x[crossings[-1]] - x[crossings[0]])
+    else:
+        fwhm = (x[-1] - x[0]) / 10.0
+
+    return x0, fwhm, peak_height, y0, is_peak
+
+
+def lorentzian_guess(x_data, y_data):
+    """Guess lorentzian fit parameters."""
+    x0, fwhm, peak_height, y0, is_peak = estimate_peak(x_data, y_data)
+
+    # Compute A from peak height = 2A / FWHM
+    A = (peak_height * fwhm) / 2.0
+    if not is_peak:
+        A = -A
+
+    guess = [A, x0, fwhm, y0]
+    return guess
+
+
+def lorentzian_bounds(x_data, y_data, guess):
+    """Guess lorentzian fit bounds."""
+    x, y = x_data, y_data
+    A, *_ = guess
+
+    x_span = np.max(x) - np.min(x)
+    A_abs = np.abs(A) if A != 0 else 1.0
+    fwhm_min = (x[1] - x[0]) if len(x) > 1 else x_span / 10
+
+    bounds = (
+        [-10 * A_abs, np.min(x) - 0.1 * x_span, fwhm_min, np.min(y) - 0.5 * A_abs],
+        [+10 * A_abs, np.max(x) + 0.1 * x_span, x_span, np.max(y) + 0.5 * A_abs],
+    )
+    return bounds
+
+
+def gaussian_guess(x_data, y_data):
+    """Guess gaussian fit parameters."""
+    x0, fwhm, peak_height, y0, is_peak = estimate_peak(x_data, y_data)
+
+    sigma = fwhm / (2 * np.sqrt(2 * np.log(2)))  # Convert FWHM to σ
+
+    A = peak_height * sigma * np.sqrt(2 * np.pi)
+    if not is_peak:
+        A = -A
+
+    guess = [A, x0, sigma, y0]
+    return guess
+
+
+def gaussian_bounds(x_data, y_data, guess):
+    """Guess gaussian fit bounds."""
+    x, y = x_data, y_data
+    A, *_ = guess
+
+    x_span = np.max(x) - np.min(x)
+    sigma_min = (x[1] - x[0]) / 10 if len(x) > 1 else x_span / 100
+    sigma_max = x_span
+    A_abs = np.abs(A)
+
+    bounds = (
+        [-10 * A_abs, np.min(x) - 0.1 * x_span, sigma_min, np.min(y) - 0.5 * A_abs],
+        [10 * A_abs, np.max(x) + 0.1 * x_span, sigma_max, np.max(y) + 0.5 * A_abs],
+    )
+    return bounds
+
+
+def oscillations_guess(x_data, y_data, num_init=10):
+    """Generate robust initial guesses for oscillation parameters."""
+    x_data = np.asarray(x_data)
+    y_data = np.asarray(y_data)
+    dx = np.mean(np.diff(x_data))
+
+    # Amplitude guess (robust against outliers)
+    A = (np.percentile(y_data, 95) - np.percentile(y_data, 5)) / 2
+
+    # Offset guess (tail median + mean)
+    y0_tail = np.median(y_data[-max(5, len(y_data) // 10) :])
+    y0_mean = np.mean(y_data)
+    y0_candidates = [y0_tail, y0_mean]
+
+    # FFT-based T (period)
+    y_demeaned = y_data - np.mean(y_data)
+    freqs = rfftfreq(len(x_data), d=dx)
+    spectrum = np.abs(rfft(y_demeaned))
+    peak_idx = np.argmax(spectrum[1:]) + 1  # Ignore DC
+    freq_peak = freqs[peak_idx]
+    T = 1 / freq_peak if freq_peak > 0 else np.ptp(x_data)  # fallback to range
+
+    # Phase estimate from cross-correlation
+    cos_wave = np.cos(2 * np.pi * x_data / T)
+    lag = np.argmax(np.correlate(y_demeaned, cos_wave, mode="full")) - len(x_data) + 1
+    phi_base = x_data[0] + lag * dx
+    phi_candidates = np.linspace(phi_base - T, phi_base + T, num_init)
+    phi_candidates = np.mod(phi_candidates, T)
+
+    return [A, y0_candidates, phi_candidates, T]
+
+
+def oscillations_bounds(x_data, y_data, guess):
+    """Generate realistic bounds for oscillation parameters."""
+    x_data = np.asarray(x_data)
+    y_data = np.asarray(y_data)
+
+    A, y0, phi, T = guess
+
+    # Add small offset to ensure bounds don't collaps
+    eps = 1e-12
+
+    A_min = 0.1 * A - eps
+    A_max = 10 * A
+
+    y0_min = np.min(y_data) - eps
+    y0_max = np.max(y_data)
+
+    phi_min = 0.0 - eps
+    phi_max = T  # reasonable 1-period wrap
+
+    T_min = 0.1 * T - eps
+    T_max = 10 * T
+
+    lower = [A_min, y0_min, phi_min, T_min]
+    upper = [A_max, y0_max, phi_max, T_max]
+    return (lower, upper)
+
+
+def decaying_oscillations_guess(x_data, y_data, num_init=10):
+    """Generate robust initial guesses for decaying oscillation parameters."""
+    x_data = np.asarray(x_data)
+    y_data = np.asarray(y_data)
+    dx = np.mean(np.diff(x_data))
+
+    # Oscillations params
+    A, y0_candidates, phi_candidates, T = oscillations_guess(x_data, y_data, num_init)
+
+    # Decay time (tau) from log-envelope
+    try:
+        y_demeaned = y_data - np.mean(y_data)
+        envelope = np.abs(hilbert(y_demeaned))
+        log_env = np.log(np.clip(envelope, 1e-10, None))
+        slope, _ = np.polyfit(x_data, log_env, 1)
+        tau = -1 / slope if slope < 0 else np.ptp(x_data)
+    except Exception:
+        tau = np.ptp(x_data)
+
+    # Rough estimate of y0 with a local min or mean of last N points
+    N_tail = max(3, int(0.1 * len(y_data)))
+    tail_mean = np.mean(y_data[-N_tail:])
+    y0_decay = min(np.min(y_data), tail_mean)
+    y0_candidates.append(y0_decay)
+
+    return [A, tau, y0_candidates, phi_candidates, T]
+
+
+def decaying_oscillations_bounds(x_data, y_data, guess):
+    """Generate realistic bounds for decaying oscillation parameters."""
+    x_data = np.asarray(x_data)
+    y_data = np.asarray(y_data)
+
+    A, tau, y0, phi, T = guess
+    lower, upper = oscillations_bounds(x_data, y_data, [A, y0, phi, T])
+
+    tau_min = 0.01 * tau
+    tau_max = 10 * tau
+
+    lower.insert(1, tau_min)
+    upper.insert(1, tau_max)
+    return (lower, upper)
+
+
+def many_decaying_oscillations_guess(x_data, y_data, n):
+    offset = np.mean(y_data)
+    y_centered = y_data - offset
+
+    freqs, fft_mag = compute_fft(x_data, y_centered)
+    peak_freqs, peak_mags = get_peaks(freqs, fft_mag)
+
+    if len(peak_freqs) < n:
+        raise ValueError(
+            f"Not enough frequency peaks found to initialize {n} oscillations."
+        )
+
+    guess = []
+    signal_duration = x_data[-1] - x_data[0]
+
+    for i in range(n):
+        A = peak_mags[i]
+        tau = signal_duration / (2 + i)  # Increasing τ for later oscillations
+        phi = 0.0  # Can be refined
+        T = peak_freqs[i]
+        guess.extend([A, tau, phi, T])
+
+    guess.append(offset)
+    return guess
+
+
+def decaying_exp_guess(x_data: np.ndarray, y_data: np.ndarray) -> list[float]:
+    """
+    Robust initial guess for decaying exponential even if the full decay isn't captured.
+    """
+    x = np.asarray(x_data)
+    y = np.asarray(y_data)
+
+    # Rough estimate of y0 with a local min or mean of last N points
+    N_tail = max(3, int(0.1 * len(y)))
+    tail_mean = np.mean(y[-N_tail:])
+    y0 = min(np.min(y), tail_mean)
+
+    # Amplitude
+    A = y[0] - y0
+    A = np.clip(A, 1e-12, None)
+
+    # Ensure sign consistency
+    if np.abs(np.max(y) - y0) > np.abs(A):
+        A = np.max(y) - y0
+
+    # Estimate tau using log-linear fit of the first ~30% of data
+    N_fit = max(5, int(0.3 * len(x)))
+    y_fit = y[:N_fit] - y0
+    mask = y_fit > 0  # log() only valid on positive values
+
+    if np.count_nonzero(mask) > 1:
+        x_fit = x[:N_fit][mask]
+        log_y = np.log(y_fit[mask])
+        slope, intercept = np.polyfit(x_fit, log_y, 1)
+        tau = -1 / slope if slope < 0 else (x[-1] - x[0]) / 3
+    else:
+        tau = (x[-1] - x[0]) / 3
+
+    tau = max(tau, np.finfo(float).eps)
+
+    return [A, tau, y0]

sqil_core/fit/_models.py

@@ -10,6 +10,17 @@ def lorentzian(x, A, x0, fwhm, y0):
     return A * (np.abs(fwhm) / 2.0) / ((x - x0) ** 2.0 + fwhm**2.0 / 4.0) + y0
 
 
+def two_lorentzians_shared_x0(x_data_1, x_data_2, A1, fwhm1, y01, A2, fwhm2, y02, x0):
+    r"""
+    Concatenates two lorentzians with same x0.
+    L_1(x) = A_1 * (|FWHM_1| / 2) / ((x - x0)^2 + (FWHM_1^2 / 4)) + y0_1
+    L_2(x) = A_2 * (|FWHM_2| / 2) / ((x - x0)^2 + (FWHM_2^2 / 4)) + y0_2
+    """
+    y1 = lorentzian(x_data_1, A1, x0, fwhm1, y01)
+    y2 = lorentzian(x_data_2, A2, x0, fwhm2, y02)
+    return np.concatenate([y1, y2])
+
+
 def gaussian(x, A, x0, sigma, y0):
     r"""
     G(x) = A / (|σ| * sqrt(2π)) * exp(- (x - x0)^2 / (2σ^2)) + y0
@@ -24,6 +35,17 @@ def gaussian(x, A, x0, sigma, y0):
     )
 
 
+def two_gaussians_shared_x0(x_data_1, x_data_2, A1, fwhm1, y01, A2, fwhm2, y02, x0):
+    r"""
+    Concatenates two gaussians with same x0.
+    G_1(x) = A_1 / (|σ_1| * sqrt(2π)) * exp(- (x - x0)^2 / (2σ_1^2)) + y0_1
+    G_1(x) = A_2 / (|σ_2| * sqrt(2π)) * exp(- (x - x0)^2 / (2σ_2^2)) + y0_2
+    """
+    y1 = gaussian(x_data_1, A1, x0, fwhm1, y01)
+    y2 = gaussian(x_data_2, A2, x0, fwhm2, y02)
+    return np.concatenate([y1, y2])
+
+
 def decaying_exp(x, A, tau, y0):
     r"""
     f(x) = A * exp(-x / τ) + y0
@@ -52,10 +74,37 @@ def decaying_oscillations(x, A, tau, y0, phi, T):
     return A * np.exp(-x / tau) * np.cos(2.0 * np.pi * (x - phi) / T) + y0
 
 
+def many_decaying_oscillations(t, *params):
+    r"""
+    f(x) = SUM_i A_i * exp(-x / τ_i) * cos(2π * (x - φ_i) / T_i) + y0
+
+    $$f(x) = \sum_i A_i \cdot e^{-x/\tau_i} \cdot \cos\left(\frac{2\pi (x - \phi_i)}{T_i}\right) + y_0$$
+    """
+    n = (len(params) - 1) // 4  # Each oscillation has 4 params: A, tau, phi, T
+    offset = params[-1]
+    result = np.zeros_like(t)
+    for i in range(n):
+        A = params[4 * i]
+        tau = params[4 * i + 1]
+        phi = params[4 * i + 2]
+        T = params[4 * i + 3]
+        result += A * np.exp(-t / tau) * np.cos(2 * np.pi * T * t + phi)
+    return result + offset
+
+
+def oscillations(x, A, y0, phi, T):
+    r"""
+    f(x) = A * cos(2π * (x - φ) / T) + y0
+
+    $$f(x) = A \cos\left( 2\pi \frac{x - \phi}{T} \right) + y_0$$
+    """
+    return A * np.cos(2.0 * np.pi * (x - phi) / T) + y0
+
+
 def skewed_lorentzian(
     f: np.ndarray, A1: float, A2: float, A3: float, A4: float, fr: float, Q_tot: float
 ) -> np.ndarray:
-    """
+    r"""
     Computes the skewed Lorentzian function.
 
     This function models asymmetric resonance peaks using a skewed Lorentzian

sqil_core/fit/_quality.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+from tabulate import tabulate
+
+if TYPE_CHECKING:
+    from sqil_core.fit._core import FitResult
+
+
+class FitQuality(IntEnum):
+    BAD = 0
+    ACCEPTABLE = 1
+    GOOD = 2
+    GREAT = 3
+
+    def __str__(self):
+        return self.name
+
+
+FIT_QUALITY_THRESHOLDS = {
+    "nrmse": [
+        (0.01, FitQuality.GREAT),
+        (0.03, FitQuality.GOOD),
+        (0.08, FitQuality.ACCEPTABLE),
+        (np.inf, FitQuality.BAD),
+    ],
+    "nmae": [
+        (0.01, FitQuality.GREAT),
+        (0.03, FitQuality.GOOD),
+        (0.08, FitQuality.ACCEPTABLE),
+        (np.inf, FitQuality.BAD),
+    ],
+    "red_chi2": [
+        (0.5, FitQuality.ACCEPTABLE),
+        (0.9, FitQuality.GOOD),
+        (1.1, FitQuality.GREAT),
+        (2.0, FitQuality.GOOD),
+        (5.0, FitQuality.ACCEPTABLE),
+        (np.inf, FitQuality.BAD),
+    ],
+}
+
+
+def evaluate_fit_quality(fit_metrics: dict, recipe: str = "nrmse") -> FitQuality:
+    """
+    Evaluates the quality category of a fit based on a specified metric recipe.
+
+    This function maps a numeric fit metric (e.g., NRMSE or AIC) to a qualitative
+    fit quality category (GREAT, GOOD, ACCEPTABLE, BAD) using predefined thresholds. These
+    thresholds are stored in the `FIT_QUALITY_THRESHOLDS` dictionary and must be
+    provided for each supported recipe.
+
+    Parameters
+    ----------
+    fit_metrics : dict
+        Dictionary containing computed metrics from a fit. Must include the key
+        specified by `recipe`.
+    recipe : str, optional
+        The name of the metric to evaluate quality against. Default is "nrmse".
+
+    Returns
+    -------
+    FitQuality
+        A qualitative classification of the fit (GREAT, GOOD, ACCEPTABLE, BAD), represented
+        by an enum or constant defined in `FitQuality`.
+    """
+
+    value = fit_metrics.get(recipe)
+    if value is None:
+        raise KeyError(
+            f"The metrics provided aren't sufficient to use recipe '{recipe}'"
+        )
+
+    thresholds = FIT_QUALITY_THRESHOLDS.get(recipe)
+    if thresholds is None:
+        raise NotImplementedError(
+            f"No fit quality threshold available for '{recipe}'."
+            + " You can add them to 'FIT_QUALITY_THRESHOLDS'"
+        )
+
+    for threshold, quality in thresholds:
+        if value <= threshold:
+            return quality
+
+    return FitQuality.BAD
+
+
+def get_best_fit(
+    fit_res_a: FitResult,
+    fit_res_b: FitResult,
+    recipe: Literal["nrmse_aic"] = "nrmse_aic",
+):
+    """
+    Selects the better fit result according to a specified selection recipe.
+
+    This function acts as a dispatcher to choose between two fit results using a
+    predefined comparison strategy.
+
+    Supported recipies:
+        - "nrmse_aic": uses NRMSE as primary metric and adjusts it with AIC if the
+            NRMSE are in the same quality category.
+
+    Parameters
+    ----------
+    fit_res_a : FitResult
+        The first fit result object containing metrics and parameters.
+    fit_res_b : FitResult
+        The second fit result object containing metrics and parameters.
+    recipe : Literal["nrmse_aic"], optional
+        The name of the comparison strategy to use.
+
+    Returns
+    -------
+    FitResult
+        The selected fit result, based on the comparison strategy.
+
+    Examples
+    --------
+    >>> best_fit = get_best_fit(fit1, fit2)
+    >>> print("Best-fit parameters:", best_fit.params)
+    """
+
+    if recipe == "nrmse_aic":
+        return get_best_fit_nrmse_aic(fit_res_a, fit_res_b)
+    raise NotImplementedError(f"Recipe {recipe} does not exist")
+
+
+def get_best_fit_nrmse_aic(
+    fit_res_a: FitResult, fit_res_b: FitResult, aic_rel_tol: float = 0.01
+):
+    """
+    Selects the better fit result based on NRMSE quality and AIC with complexity penalty.
+
+    This function compares two fit results by first evaluating the normalized root
+    mean squared error (NRMSE) using a quality categorization scheme. If the fits
+    differ in NRMSE quality, the one with better quality is selected. If the
+    qualities are equal, the function compares the Akaike Information Criterion (AIC),
+    using a relative tolerance to determine statistical equivalence. When AIC values
+    are within tolerance, the simpler model (with fewer parameters) is preferred.
+
+    Parameters
+    ----------
+    fit_res_a : FitResult
+        The first FitResult object.
+    fit_res_b : FitResult
+        The second FitResult object.
+    aic_rel_tol : float, optional
+        The relative tolerance for AIC comparison. If the relative difference in AIC
+        is below this threshold, models are considered equally good, and complexity
+        (number of parameters) is used as a tiebreaker. Default is 0.01.
+
+    Returns
+    -------
+    FitResult
+        The preferred fit result based on NRMSE category, AIC, and model simplicity.
+
+    Notes
+    -----
+    - If models are statistically equivalent in AIC and have the same complexity,
+      the first result is returned for consistency.
+    - If the minimum AIC is zero, relative delta AIC is replaced by its absolute counter
+      part, but still using the aic_rel_tol as tolerance.
+
+    Examples
+    --------
+    >>> best_fit = get_best_fit_nrmse_aic(fit1, fit2)
+    >>> print("Selected model parameters:", best_fit.params)
+    """
+
+    quality_a = evaluate_fit_quality(fit_res_a.metrics)
+    quality_b = evaluate_fit_quality(fit_res_b.metrics)
+
+    # If NMRSE qualities are not in the same category, return the best one
+    if quality_a != quality_b:
+        return fit_res_a if quality_a > quality_b else fit_res_b
+    aic_a = fit_res_a.metrics.get("aic")
+    aic_b = fit_res_b.metrics.get("aic")
+
+    # Use AIC to penalize fit complexity
+    if aic_a is None or aic_b is None:
+        raise ValueError("Missing AIC value in one of the fits")
+    delta = abs(aic_a - aic_b)
+    min_aic = abs(min(aic_a, aic_b))
+    rel_delta = delta / min_aic if min_aic != 0 else delta
+    if rel_delta < aic_rel_tol:
+        # Within tolerance: consider them equivalent, return simpler (fewer params)
+        len_a, len_b = len(fit_res_a.params), len(fit_res_b.params)
+        if len_a != len_b:
+            return fit_res_a if len_a < len_b else fit_res_b
+        # Otherwise: arbitrary but consistent
+        return fit_res_a
+    # Outside tolerance: pick the one with lower AIC
+    return fit_res_a if aic_a < aic_b else fit_res_b
+
+
+def format_fit_metrics(fit_metrics: dict, keys: list[str] | None = None) -> str:
+    """
+    Formats and summarizes selected fit metrics with qualitative evaluations.
+
+    This function generates a human-readable table that reports selected fit metrics
+    (e.g., reduced χ², R², NRMSE) alongside their numerical values and qualitative
+    quality assessments. Quality categories are determined using `evaluate_fit_quality`.
+
+    Parameters
+    ----------
+    fit_metrics : dict
+        Dictionary of fit metrics to display. Should contain values for keys like
+        "red_chi2", "r2", "nrmse", etc.
+    keys : list of str, optional
+        Subset of metric keys to include in the output. If None, all available keys
+        in `fit_metrics` are considered.
+
+    Returns
+    -------
+    str
+        A plain-text table summarizing the selected metrics with their values and
+        associated quality labels.
+
+    Notes
+    -----
+    - Complex-valued R² metrics are skipped.
+    - Keys are optionally renamed for output formatting (e.g., "red_chi2" → "reduced χ²").
+
+    Examples
+    --------
+    >>> metrics = {"red_chi2": 1.2, "r2": 0.97, "nrmse": 0.05}
+    >>> print(format_fit_metrics(metrics))
+    reduced χ²   1.200e+00   GOOD
+    R²           9.700e-01   GOOD
+    nrmse        5.000e-02   GOOD
+    """
+
+    table_data = []
+
+    if keys is None:
+        keys = fit_metrics.keys() if fit_metrics else []
+
+    # Print fit quality parameters
+    for key in keys:
+        value = fit_metrics[key]
+        quality = ""
+        # Evaluate reduced Chi-squared
+        if key == "red_chi2":
+            key = "reduced χ²"
+            quality = evaluate_fit_quality(fit_metrics, "red_chi2")
+        # Evaluate R-squared
+        elif key == "r2":
+            # Skip if complex
+            if isinstance(value, complex):
+                continue
+            key = "R²"
+            quality = evaluate_fit_quality(fit_metrics, "r2")
+        # Normalized root mean square error NRMSE
+        # Normalized mean absolute error NMAE and
+        elif (key == "nrmse") or (key == "nmae"):
+            quality = evaluate_fit_quality(fit_metrics, key)
+        else:
+            continue
+
+        quality_label = str(quality)
+
+        table_data.append([key, f"{value:.3e}", quality_label])
+    return tabulate(table_data, tablefmt="plain")

sqil_core/resonator/__init__.py

@@ -6,6 +6,8 @@ from ._resonator import (
     fit_phase_vs_freq,
     fit_phase_vs_freq_global,
     full_fit,
+    linmag_fit,
     plot_resonator,
+    print_resonator_params,
     quick_fit,
 )