pytesdaqx-scope 0.1.0__py3-none-any.whl

pytesdaqx_scope/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pytesdaqx_scope/acquisition/__init__.py

@@ -0,0 +1,5 @@
+from .base import DataSource, Frame
+from .file_source import FileSource
+from .live_source import LiveSource
+
+__all__ = ["DataSource", "Frame", "FileSource", "LiveSource"]

pytesdaqx_scope/acquisition/base.py

@@ -0,0 +1,56 @@
+"""Common data-source interface shared by live acquisition and file replay.
+
+Both :class:`~pytesdaqx_scope.acquisition.live_source.LiveSource` and
+:class:`~pytesdaqx_scope.acquisition.file_source.FileSource` produce
+:class:`Frame` objects, so the controller and analysis pipeline never need
+to know which one produced a given frame.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+import numpy as np
+
+
+@dataclass
+class Frame:
+    """One event/read-block of raw ADC-code traces, ready for analysis.
+
+    ``data`` is always in raw ADC codes (never pre-calibrated), so
+    :meth:`pytesdaqx_scope.analysis.pipeline.AnalysisPipeline.process` can
+    treat live and file-replay frames identically via ``calibration_coeffs``.
+    """
+
+    data: np.ndarray  # [nb_channels, nb_samples]
+    detector_channels: list[str]
+    sample_rate_hz: float
+    measurement: str
+    calibration_coeffs: list[list[float] | None] | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class DataSource(Protocol):
+    """Common interface for live and file-replay data sources."""
+
+    def start(self, measurement: str, *, overrides: dict[str, Any] | None = None) -> None:
+        """Begin producing frames for the given measurement."""
+        ...
+
+    def read_frame(self, timeout: float | None = 0.0) -> Frame | None:
+        """Return the next available frame.
+
+        ``None`` means "nothing available right now" for a live source
+        (safe to poll again later) or "exhausted" for a file source
+        (nothing more will ever come).
+        """
+        ...
+
+    def stop(self) -> None:
+        """Stop producing frames; safe to call again with :meth:`start`."""
+        ...
+
+    def close(self) -> None:
+        """Release underlying resources; the source cannot be reused after this."""
+        ...

pytesdaqx_scope/acquisition/file_source.py

@@ -0,0 +1,170 @@
+"""File-replay data source over pytesdaqx's StreamReader (zarr/hdf5)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pytesdaqx.io import StreamReader
+
+from .base import Frame
+
+
+class FileSource:
+    """Steps sequentially through a recorded acquisition, one record at a time.
+
+    Wraps :class:`pytesdaqx.io.StreamReader`, always requesting raw ADC
+    codes (``units="adc"``) so calibration flows through
+    :mod:`pytesdaqx_scope.analysis` the same way as for
+    :class:`~pytesdaqx_scope.acquisition.live_source.LiveSource` frames.
+    """
+
+    def __init__(
+        self,
+        path: str | Path,
+        *,
+        streams: str | int | list[str | int] | None = None,
+        measurement_types: str | list[str] | None = None,
+        channels: list[str] | None = None,
+    ) -> None:
+        self._reader = StreamReader(
+            path,
+            streams=streams,
+            measurement_types=measurement_types,
+            restricted="all",
+        )
+        self._channels = channels
+        self._exhausted = False
+        #: Samples per read when in partition mode; None means "use the
+        #: file's own read-block/trace boundaries via read_next()" (default).
+        self._partition_length_samples: int | None = None
+        self._partition_cursor = 0
+
+    @property
+    def is_exhausted(self) -> bool:
+        """True once :meth:`read_frame` has hit the end of the recording.
+
+        ``read_frame`` returning ``None`` is ambiguous on its own - for
+        :class:`~pytesdaqx_scope.acquisition.live_source.LiveSource` it just
+        means "nothing new yet, poll again"; for a file it means "nothing
+        more will ever come". Callers (e.g. the GUI's poll loop) should check
+        this after a ``None`` read to tell the two apart, rather than
+        silently polling forever with no feedback.
+        """
+        return self._exhausted
+
+    def peek_metadata(self) -> dict[str, Any]:
+        """Static resource metadata (detector_channels, measurement, ...).
+
+        Uses a separate, throwaway reader under the hood, so calling this
+        does not disturb :meth:`read_frame`'s sequential position.
+        """
+        return self._reader.get_metadata()
+
+    def trace_length_supported(self, measurement: str | None = None) -> bool:
+        """Whether :meth:`set_trace_length_ms` has any effect on this file.
+
+        Only true for a native continuous Zarr stream (``raw_shape_model ==
+        "channel_sample"``): HDF5 recordings and finite/trace Zarr streams
+        (dIdV, threshold) have a fixed record length baked into the file
+        itself, so there is nothing to adjust. ``measurement`` is accepted
+        (and ignored) only so callers can treat this and
+        ``LiveSource.trace_length_supported`` the same way - a single file
+        source is fixed to whichever stream(s) it was opened with.
+        """
+        del measurement
+        return self._reader.raw_shape_model == "channel_sample"
+
+    def set_trace_length_ms(self, trace_length_ms: float | None) -> None:
+        """Set the partition length read per :meth:`read_frame` call, in ms.
+
+        Only meaningful when :meth:`trace_length_supported` is true;
+        otherwise this is a no-op. ``None`` reverts to the file's own
+        read-block boundaries (:meth:`read_next`). Resets the partition
+        read position to the start.
+        """
+        if not self.trace_length_supported():
+            return
+        if trace_length_ms is None:
+            self._partition_length_samples = None
+        else:
+            samples = round(trace_length_ms * 1e-3 * self._reader.sample_rate_hz)
+            self._partition_length_samples = max(1, samples)
+        self._partition_cursor = 0
+
+    def get_detector_settings(self) -> dict[str, dict[str, Any]]:
+        """Per-channel stored settings: close_loop_norm, preamp_gain,
+        signal_gen_current/frequency, tes_bias, etc. - used by
+        :class:`~pytesdaqx_scope.file_board_reader.FileBoardReader` in place
+        of a live board read. Like :meth:`peek_metadata`, this doesn't
+        disturb :meth:`read_frame`'s sequential position.
+        """
+        return self._reader.get_detector_settings()
+
+    def start(self, measurement: str, *, overrides: dict[str, Any] | None = None) -> None:
+        # File replay has no separate "arm" step; read_frame() drives the
+        # reader. Stop-then-Start resumes from the current position (pause/
+        # resume), but Start after running off the end has nothing to resume
+        # from, so it means "replay from the top" instead.
+        del measurement, overrides
+        if self._exhausted:
+            self.rewind()
+
+    def read_frame(self, timeout: float | None = 0.0) -> Frame | None:
+        del timeout  # file reads are effectively instantaneous
+        if self._partition_length_samples is not None:
+            return self._read_partition_frame()
+
+        try:
+            data, info = self._reader.read_next(channels=self._channels, units="adc")
+        except StopIteration:
+            self._exhausted = True
+            return None
+        return self._frame_from_read(data, info)
+
+    def _read_partition_frame(self) -> Frame | None:
+        try:
+            data, info = self._reader.read_partition(
+                partition_start_index=self._partition_cursor,
+                partition_length_samples=self._partition_length_samples,
+                channels=self._channels,
+                units="adc",
+            )
+        except ValueError:
+            # read_partition() raises when a request runs past the end of
+            # the stream, rather than the StopIteration read_next() uses -
+            # both mean the same thing here: nothing more to read.
+            self._exhausted = True
+            return None
+        self._partition_cursor += self._partition_length_samples
+        return self._frame_from_read(data, info)
+
+    def _frame_from_read(self, data, info: dict[str, Any]) -> Frame:
+        detector_channels = list(info.get("detector_channels") or [])
+        calibration_by_name = {
+            row["detector_channel"]: row.get("adc_conversion_coefficients")
+            for row in info.get("channel_map") or []
+            if "detector_channel" in row
+        }
+        calibration_coeffs = [calibration_by_name.get(name) for name in detector_channels]
+
+        return Frame(
+            data=data,
+            detector_channels=detector_channels,
+            sample_rate_hz=float(info.get("sample_rate_hz") or self._reader.sample_rate_hz),
+            measurement=str(info.get("measurement") or info.get("measurement_type") or ""),
+            calibration_coeffs=calibration_coeffs,
+            metadata=info,
+        )
+
+    def rewind(self) -> None:
+        self._reader.rewind()
+        self._exhausted = False
+        self._partition_cursor = 0
+
+    def stop(self) -> None:
+        # Nothing to stop mid-stream; rewind() is the explicit reset.
+        pass
+
+    def close(self) -> None:
+        self._reader.close()

pytesdaqx_scope/acquisition/live_source.py

@@ -0,0 +1,149 @@
+"""Live data source over pytesdaqx's DAQSession, with dIdV/PXI AC-drive sequencing."""
+
+from __future__ import annotations
+
+import queue
+import threading
+from typing import Any
+
+from pytesdaqx.acquisition.segment import Segment
+from pytesdaqx.acquisition.session import DAQSession
+
+from .base import Frame
+
+
+class LiveSource:
+    """Drives one measurement's live acquisition on a background thread.
+
+    A GUI polls :meth:`read_frame` (e.g. from a ``QTimer``) instead of
+    blocking its event loop; frames are dropped (not queued indefinitely)
+    if the consumer falls behind, matching a live-scope's "show the latest
+    trace" semantics rather than a recorder's "keep everything."
+
+    A dIdV measurement whose TES AC drive lives on a PXI AO device needs a
+    specific sequence (per pytesdaqx's ``ControlCoordinator`` docs): arm the
+    AI task *first*, then start the AO waveform, so the AI's
+    ``/ao/StartTrigger`` defines phase zero. Passing a ``control_coordinator``
+    gets this ordering; ``ControlCoordinator.start_measurement_tes_ac`` is
+    itself a no-op for measurements with no TES-AC waveform block, so it's
+    always safe to pass one even when most selected measurements are plain
+    background/threshold acquisitions.
+    """
+
+    def __init__(
+        self,
+        resolved_config: Any,
+        *,
+        backend: Any = None,
+        detector_channels: list[str] | None = None,
+        max_buffered_frames: int = 2,
+        control_coordinator: Any = None,
+    ) -> None:
+        self._session = DAQSession.from_resolved_config(
+            resolved_config, backend=backend, detector_channels=detector_channels
+        )
+        self._coordinator = control_coordinator
+        self._frame_queue: queue.Queue[Frame] = queue.Queue(maxsize=max_buffered_frames)
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._trace_length_ms: float | None = None
+
+    @property
+    def is_running(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()
+
+    def trace_length_supported(self, measurement: str) -> bool:
+        """Whether :meth:`set_trace_length_ms` has any effect for this measurement.
+
+        Only true for a continuous-mode measurement. A finite/triggered
+        measurement (dIdV, threshold) has physical constraints on its trace
+        length - a PXI-locked dIdV trace needs an integer number of
+        signal-generator periods - that a plain "trace length in ms"
+        control could violate, so those stay fixed to whatever
+        acquisition.yaml specifies.
+        """
+        adc_cfg = (self._session.measurements.get(measurement, {}) or {}).get("adc", {}) or {}
+        mode = str(adc_cfg.get("mode", "continuous")).strip().lower()
+        return mode == "continuous"
+
+    def set_trace_length_ms(self, trace_length_ms: float | None) -> None:
+        """Override the read_block_duration used the next time :meth:`start` runs.
+
+        Only takes effect for a measurement where
+        :meth:`trace_length_supported` is true; silently has no effect
+        otherwise (rather than erroring, since the GUI already disables the
+        control in that case - this just guards against stale state).
+        """
+        self._trace_length_ms = trace_length_ms
+
+    def start(self, measurement: str, *, overrides: dict[str, Any] | None = None) -> None:
+        if self.is_running:
+            raise RuntimeError("LiveSource is already running; call stop() first")
+
+        effective_overrides = dict(overrides or {})
+        if self._trace_length_ms is not None and self.trace_length_supported(measurement):
+            adc_overrides = dict(effective_overrides.get("adc", {}))
+            adc_overrides.setdefault("read_block_duration", self._trace_length_ms * 1e-3)
+            effective_overrides["adc"] = adc_overrides
+
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, args=(measurement, effective_overrides), daemon=True)
+        self._thread.start()
+
+    def _run(self, measurement: str, overrides: dict[str, Any] | None) -> None:
+        step = {"measurement": measurement}
+        try:
+            if self._coordinator is not None:
+                # Apply any step controls now, but defer TES AC drive until
+                # after the AI task is armed (see class docstring).
+                self._coordinator.prepare_measurement(step, start_tes_ac=False)
+
+            self._session.configure_measurement(measurement, overrides=overrides)
+
+            if self._coordinator is not None:
+                self._coordinator.start_measurement_tes_ac(step)
+
+            while not self._stop_event.is_set():
+                segment = self._session.backend.read_segment()
+                self._on_segment(segment)
+        finally:
+            if self._coordinator is not None:
+                self._coordinator.cleanup_measurement(step)
+
+    def _on_segment(self, segment: Segment) -> None:
+        frame = Frame(
+            data=segment.data,
+            detector_channels=segment.detector_channels,
+            sample_rate_hz=segment.sample_rate_hz or 0.0,
+            measurement=segment.measurement,
+            calibration_coeffs=segment.metadata.get("adc_conversion_coefficients"),
+            metadata=segment.metadata,
+        )
+        try:
+            self._frame_queue.put_nowait(frame)
+        except queue.Full:
+            try:
+                self._frame_queue.get_nowait()
+            except queue.Empty:
+                pass
+            self._frame_queue.put_nowait(frame)
+
+    def read_frame(self, timeout: float | None = 0.0) -> Frame | None:
+        try:
+            if timeout is None:
+                return self._frame_queue.get()
+            if timeout <= 0:
+                return self._frame_queue.get_nowait()
+            return self._frame_queue.get(timeout=timeout)
+        except queue.Empty:
+            return None
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=5.0)
+            self._thread = None
+
+    def close(self) -> None:
+        self.stop()
+        self._session.close()

pytesdaqx_scope/analysis/__init__.py

@@ -0,0 +1,4 @@
+from .config import AnalysisConfig
+from .pipeline import AnalysisPipeline, AnalysisResult
+
+__all__ = ["AnalysisConfig", "AnalysisPipeline", "AnalysisResult"]

pytesdaqx_scope/analysis/config.py

@@ -0,0 +1,82 @@
+"""Typed analysis configuration.
+
+Replaces the old ``pytesdaq.analyzer.Analyzer``'s dict-based
+``_analysis_config`` plus its ~20-keyword-argument ``update_analysis_config``
+method with a single dataclass and an ``update(**changes)`` method that
+ignores ``None`` values (so callers only pass the fields that changed).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AnalysisConfig:
+    """Analysis pipeline configuration.
+
+    Per-channel fields (``rshunt``, ``rp``, ``r0``, ``dt``, ``add_180phase``,
+    ``tes_bias``, ``signal_gen_current``, ``signal_gen_frequency``) accept
+    either a single value (applied to all channels) or a per-channel
+    sequence; :mod:`pytesdaqx_scope.analysis.didv_fit` broadcasts scalars.
+    """
+
+    unit: str = "ADC"
+    norm_type: str = "NoNorm"
+    norm_list: list[float] | None = None
+
+    calc_psd: bool = False
+
+    enable_running_avg: bool = False
+    reset_running_avg: bool = False
+    nb_events_avg: int = 1
+
+    enable_lowpass_filter: bool = False
+    lowpass_cutoff: float = 50.0
+
+    enable_pileup_rejection: bool = False
+    pileup_cuts: dict[str, int] | None = None
+
+    fit_didv: bool = False
+    didv_1pole: bool = False
+    didv_2pole: bool = False
+    didv_3pole: bool = False
+    didv_measurement: str | None = None
+
+    signal_gen_current: Any = None
+    signal_gen_frequency: Any = None
+    tes_bias: Any = None
+    rshunt: Any = 0.005
+    rp: Any = 0.003
+    r0: Any = 0.1
+    dt: Any = 2e-6
+    add_180phase: Any = False
+
+    #: Set of field names whose change should force a running-average reset.
+    _RESET_AVG_ON_CHANGE = frozenset(
+        {"norm_type", "unit", "calc_psd", "enable_pileup_rejection", "pileup_cuts"}
+    )
+
+    def update(self, **changes: Any) -> "AnalysisConfig":
+        """Apply the given (non-``None``) field changes in place.
+
+        Mirrors the old ``update_analysis_config`` semantics: a field left
+        as ``None`` is left untouched, and changing normalization/unit/PSD/
+        pileup settings forces ``reset_running_avg``.
+        """
+
+        for key, value in changes.items():
+            if value is None:
+                continue
+            if not hasattr(self, key):
+                raise AttributeError(f"Unknown analysis config field {key!r}")
+            setattr(self, key, value)
+
+        if self.norm_type == "NoNorm":
+            self.norm_list = None
+
+        if any(changes.get(name) is not None for name in self._RESET_AVG_ON_CHANGE):
+            self.reset_running_avg = True
+
+        return self

pytesdaqx_scope/analysis/didv_fit.py

@@ -0,0 +1,207 @@
+"""dIdV small-signal pole-model fitting, via qetpy.
+
+Ported from ``pytesdaq.analyzer.Analyzer.fit_didv``. Unlike the original,
+this module has no knowledge of GUI/analysis-config state: callers pass
+explicit, already-resolved per-channel parameters.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import qetpy as qp
+from scipy import signal
+
+_UNIT_NORM = {"Amps": 1.0, "uAmps": 1e6, "pAmps": 1e12}
+
+#: Post-fit low-pass cutoff applied to the truncated/averaged trace for display.
+_DISPLAY_LOWPASS_HZ = 30_000
+
+
+def _broadcast(value: Any, nb_channels: int, name: str) -> list[Any]:
+    if isinstance(value, (list, tuple, np.ndarray)):
+        if len(value) < nb_channels:
+            raise ValueError(f"{name!r} has fewer entries than channels ({len(value)} < {nb_channels})")
+        return list(value)
+    return [value] * nb_channels
+
+
+def fit_didv(
+    traces: np.ndarray,
+    sample_rate: float,
+    *,
+    signal_gen_frequency: Any,
+    signal_gen_current: Any,
+    rshunt: Any,
+    rp: Any,
+    r0: Any,
+    dt: Any,
+    add_180phase: Any,
+    tes_bias: Any,
+    didv_1pole: Any,
+    didv_2pole: Any,
+    didv_3pole: Any,
+    unit: str = "Amps",
+    mask: np.ndarray | None = None,
+    add_autocuts: bool = True,
+) -> tuple[np.ndarray, dict]:
+    """Fit a 1/2/3-pole small-signal dIdV model per channel.
+
+    Arguments
+    ---------
+    traces:
+        3D array ``[nb_events, nb_channels, nb_samples]`` or 2D array
+        ``[nb_events, nb_samples]`` (single channel), in the unit given by
+        ``unit``.
+    sample_rate:
+        Sample rate in Hz.
+    signal_gen_frequency, signal_gen_current, rshunt, rp, r0, dt,
+    add_180phase, tes_bias, didv_1pole, didv_2pole, didv_3pole:
+        Scalar or per-channel sequence. See ``qetpy.DIDV`` for units/meaning
+        (frequency in Hz, current in Amps, resistances in Ohms, ``dt`` in
+        seconds).
+    unit:
+        Unit of ``traces``: ``"Amps"``, ``"uAmps"``, or ``"pAmps"``.
+    mask:
+        Optional boolean array ``[nb_channels, nb_events]`` selecting which
+        events to use per channel.
+    add_autocuts:
+        Apply ``qetpy.autocuts_didv`` before fitting.
+
+    Returns
+    -------
+    data_array_truncated:
+        2D array ``[nb_channels, nb_truncated_samples]``: mean, low-pass-
+        filtered trace actually used for the fit, at its true baseline (not
+        zero-centered) - qetpy's internal fit works on the AC-only,
+        baseline-subtracted trace, but the baseline is added back here so
+        this lines up with the physical bias point ordinary (non-fit)
+        frames are displayed at.
+    didv_data_dict:
+        ``{"fit_array": ndarray, "results": list[dict]}`` — ``fit_array``
+        matches ``data_array_truncated`` in shape; ``results[i]`` is the
+        ``qetpy`` fit result dict for channel ``i``, augmented with an
+        ``"infinite_l"`` entry (``r0``/``i0``/``p0``) for 2/3-pole fits.
+    """
+
+    if traces.ndim not in (2, 3):
+        raise ValueError("traces must be a 2D or 3D array")
+
+    norm = _UNIT_NORM.get(unit, 1.0)
+    nb_channels = traces.shape[1] if traces.ndim == 3 else 1
+
+    params = {
+        "signal_gen_frequency": _broadcast(signal_gen_frequency, nb_channels, "signal_gen_frequency"),
+        "signal_gen_current": _broadcast(signal_gen_current, nb_channels, "signal_gen_current"),
+        "rshunt": _broadcast(rshunt, nb_channels, "rshunt"),
+        "rp": _broadcast(rp, nb_channels, "rp"),
+        "r0": _broadcast(r0, nb_channels, "r0"),
+        "dt": _broadcast(dt, nb_channels, "dt"),
+        "add_180phase": _broadcast(add_180phase, nb_channels, "add_180phase"),
+        "tes_bias": _broadcast(tes_bias, nb_channels, "tes_bias"),
+        "didv_1pole": _broadcast(didv_1pole, nb_channels, "didv_1pole"),
+        "didv_2pole": _broadcast(didv_2pole, nb_channels, "didv_2pole"),
+        "didv_3pole": _broadcast(didv_3pole, nb_channels, "didv_3pole"),
+    }
+
+    data_array_truncated = None
+    fit_array = None
+    result_list: list[dict] = []
+
+    for ichan in range(nb_channels):
+        chan_traces = traces[:, ichan, :] / norm if traces.ndim == 3 else traces / norm
+
+        if mask is not None:
+            chan_traces = chan_traces[mask[ichan, :], :]
+
+        if add_autocuts:
+            cut = qp.autocuts_didv(chan_traces, fs=sample_rate, niter=1)
+            chan_traces = chan_traces[cut]
+
+        didv_inst = qp.DIDV(
+            chan_traces,
+            sample_rate,
+            params["signal_gen_frequency"][ichan],
+            params["signal_gen_current"][ichan],
+            params["rshunt"][ichan],
+            r0=params["r0"][ichan],
+            rp=params["rp"][ichan],
+            dutycycle=0.5,
+            add180phase=params["add_180phase"][ichan],
+            dt0=params["dt"][ichan],
+        )
+        didv_inst.processtraces()
+
+        nb_samples = didv_inst._tmean.shape[0]
+        if data_array_truncated is None:
+            data_array_truncated = np.zeros((nb_channels, nb_samples), dtype=np.float64)
+            fit_array = np.zeros((nb_channels, nb_samples), dtype=np.float64)
+
+        offset = didv_inst._offset * norm
+        truncated = (didv_inst._tmean - didv_inst._offset) * norm
+        nyq = sample_rate / 2
+        b, a = signal.butter(2, _DISPLAY_LOWPASS_HZ / nyq)
+        # Add the baseline back after filtering (a linear filter's DC gain is
+        # 1, so this is equivalent to filtering the un-subtracted trace, but
+        # keeps the filter's even-padding extension working on the smaller
+        # AC-only signal): the result should sit at the same physical bias
+        # point as ordinary (non-fit) display frames, not be zero-centered.
+        data_array_truncated[ichan, :] = (
+            signal.filtfilt(b, a, truncated, axis=-1, padtype="even") + offset
+        )
+
+        poles = None
+        if params["didv_1pole"][ichan]:
+            didv_inst.dofit(1, fcutoff=100e3)
+            poles = 1
+        if params["didv_2pole"][ichan]:
+            didv_inst.dofit(2, fcutoff=100e3)
+            poles = 2
+        if params["didv_3pole"][ichan]:
+            didv_inst.dofit(3, fcutoff=100e3)
+            poles = 3
+
+        ilg_params = None
+        if poles in (2, 3):
+            fit_for_ilg = didv_inst.fitresult(poles)
+            ilg_params = qp.get_biasparams_ilg(
+                fit_for_ilg["params"],
+                fit_for_ilg["cov"],
+                params["tes_bias"][ichan],
+                params["tes_bias"][ichan] * 0.05,
+                params["rshunt"][ichan],
+                params["rp"][ichan],
+            )
+
+        didv_inst.calc_smallsignal_params(biasparams=ilg_params, poles=poles)
+
+        result = didv_inst.fitresult(poles) if poles is not None else None
+        if result is None:
+            raise ValueError(f"No dIdV pole count selected for channel {ichan}")
+
+        if poles in (2, 3):
+            result["infinite_l"] = {
+                "r0": ilg_params["r0"],
+                "i0": ilg_params["i0"],
+                "p0": ilg_params["p0"],
+            }
+
+        result_list.append(result)
+
+        dt_sample = 1 / sample_rate
+        time = np.arange(0, nb_samples) * dt_sample
+        fit_array[ichan, :] = (
+            norm
+            * qp.squarewaveresponse(
+                time,
+                params["signal_gen_current"][ichan],
+                params["signal_gen_frequency"][ichan],
+                result["params"],
+                dutycycle=0.5,
+                rsh=params["rshunt"][ichan],
+            )
+            + offset
+        )
+
+    return data_array_truncated, {"fit_array": fit_array, "results": result_list}