emu-base 2.5.2__py3-none-any.whl → 2.7.0__py3-none-any.whl

emu_base/__init__.py

@@ -1,5 +1,5 @@
 from .constants import DEVICE_COUNT
-from .pulser_adapter import PulserData, HamiltonianType
+from .pulser_adapter import PulserData, HamiltonianType, SequenceData
 from .math.brents_root_finding import find_root_brents
 from .math.krylov_exp import krylov_exp, DEFAULT_MAX_KRYLOV_DIM
 from .jump_lindblad_operators import compute_noise_from_lindbladians
@@ -12,6 +12,7 @@ __all__ = [
     "compute_noise_from_lindbladians",
     "matmul_2x2_with_batched",
     "PulserData",
+    "SequenceData",
     "find_root_brents",
     "krylov_exp",
     "HamiltonianType",
@@ -22,4 +23,4 @@ __all__ = [
     "init_logging",
 ]
 
-__version__ = "2.5.2"
+__version__ = "2.7.0"

emu_base/jump_lindblad_operators.py

@@ -52,18 +52,17 @@ def get_lindblad_operators(
         return [depolarizing_x, depolarizing_y, depolarizing_z]
 
     if noise_type == "eff_noise":
-        if not all(
-            isinstance(op, torch.Tensor) and op.shape == (dim, dim)
-            for op in noise_model.eff_noise_opers
-        ):
+        torch_ops = [
+            torch.tensor(op, dtype=torch.complex128) for op in noise_model.eff_noise_opers
+        ]
+        if not all(op.shape == (dim, dim) for op in torch_ops):
             raise ValueError(
-                f"Only {dim} by {dim} effective noise operator matrices are "
-                "supported and it should be given as torch tensors "
+                f"Only {dim} by {dim} effective noise operator matrices are supported"
             )
 
         lindblad_ops = [  # lindblad operators with XY pulser basis are fine
-            math.sqrt(rate) * torch.as_tensor(op)
-            for rate, op in zip(noise_model.eff_noise_rates, noise_model.eff_noise_opers)
+            math.sqrt(rate) * op
+            for rate, op in zip(noise_model.eff_noise_rates, torch_ops)
         ]
 
         # pulser ising basis changing to emu-mps ising basis

emu_base/math/pchip_torch.py

@@ -0,0 +1,269 @@
+"""
+Reference:
+  See page 98 (a few pages are sufficient) in:
+  C. Moler, Numerical Computing with MATLAB, 2004.
+
+PCHIP - Piecewise Cubic Hermite Interpolating Polynomial is a 1D, C¹-continuous
+interpolation method. It builds a separate cubic polynomial P_i(x) on each
+interval [x[i], x[i+1]] and is designed to preserve the shape of the data
+(literally means visually pleasing) e.g., avoid overshoot near sharp changes.
+
+The cubic polynomials P_i(x) are expressed in Hermite form, which means:
+(1) they match the data values
+    P(x[i])    == y[i],
+    P(x[i+1])  == y[i+1].
+(2) they match derivatives
+    P(x[i])'   == d[i],
+    P(x[i+1])' == d[i+1],
+where d[i] is a derivative better than the first-order finite difference
+Δ[i] = (y[i+1]-y[i])/(x[i+1]-x[i]). How d[i] is computed and what "better"
+means is explained below.
+
+What distinguishes PCHIP from generic cubic spline interpolators is how PCHIP
+selects the knot derivatives d[i]. PCHIP computes:
+(1) Secant slopes (finite differences) on each interval:
+    Δ[i] = (y[i+1] - y[i]) / (x[i+1] - x[i]).
+
+(2) The knot derivatives d[i] as a harmonic mean of the neighboring slopes
+    Δ[i-1] and Δ[i] when they have the same sign:
+
+    1/d[i] = 0.5 * (1/Δ[i-1] + 1/Δ[i]) [PCHIP interpolator]
+
+    which tends to look better visually than
+    - arithmetic mean d[i] = 0.5 * (Δ[i-1] + Δ[i]) [Catmull–Rom], or
+    - finite difference d[i] = Δ[i] [Linear interpolator].
+
+    If Δ[i-1] and Δ[i] have opposite signs (or either is zero), x[i] is a
+    local minimum, maximum or valley. In this case PCHIP sets
+
+    d[i] = 0
+
+so the curve flattens at x[i], which helps prevent overshoot and
+preserves the shape of the data.
+(See images https://matthodges.com/posts/2024-08-08-spline-pchip/)
+
+If the grid is non-uniform (h[i-1] = x[i] - x[i-1] and h[i] = x[i+1] - x[i]
+are different), the neighboring secant slopes Δ[i-1] and Δ[i] do not contribute
+equally. PCHIP therefore combines them using a weighted harmonic mean:
+
+    (w1+w2)/d[i] = w1/Δ[i-1] + w2/Δ[i].
+
+w1 = 2h[i] + h[i-1], w2 = h[i] + 2h[i-1].
+For uniform spacing this reduces to the simple harmonic mean w1 = w2 = 0.5
+
+Given x[i], y[i] and d[i], one can compute the cubic polynomial
+P(t) = p0 + p1 t + p2 t^2 + p3 t^3, 0 <= t <= h[i], on each
+interval x[i], x[i+1]. To find coefficients (p0, p1, p2, p3) solve:
+
+    P(0) = y[i],   P'(0) = d[i]
+    P(h) = y[i+1], P'(h) = d[i+1],   where h = x[i+1] - x[i].
+
+This gives:
+    p0 = y[i]
+    p1 = d[i]
+    p2 = (3Δ[i] - 2d[i] - d[i+1]) / h
+    p3 = (d[i] + d[i+1] - 2Δ[i]) / h²
+
+Extrapolation:
+points outside the interpolation interval [x[0], x[-1]] are evaluated by
+extending the boundary cubic polynomial. For x < x[0] we use the first
+interval polynomial P_0; for x > x[-1] we use the last P_{n-1} interval
+polynomial.
+
+Algorithm outline:
+(1) Compute interval widths h[i] and secant slopes Δ[i].
+(2) Compute knot derivatives d[i] using PCHIP.
+(3) For each interval [x[i], x[i+1]], form the cubic Hermite polynomial
+    P(x) using y[i], y[i+1], d[i], and d[i+1].
+(4) Evaluate P(x) at desired query points xq.
+
+
+Note: Endpoint derivatives d[i] (at x[0] and x[-1]) are computed differently
+than interior derivatives. At the boundaries we use a one-sided 3-point method
+(see “Three-point methods”):
+https://en.wikipedia.org/wiki/Numerical_differentiation
+
+Using Taylor expansions for y[i+1] and y[i+2] gives:
+    Δ[i]   ≈ d[i] + f'' * h[i] / 2 + ...
+    Δ[i+1] ≈ d[i] + f'' * (2h[i] + h[i+1]) / 2 + ...
+
+Eliminating f'' yields the endpoint estimate:
+    d[i] ≈ (Δ[i] * (2h[i] + h[i+1]) - Δ[i+1] * h[i]) / (h[i] + h[i+1])
+"""
+
+import torch
+
+
+def _weighted_harmonic_mean(
+    delta_l: torch.Tensor,
+    delta_r: torch.Tensor,
+    h_l: torch.Tensor,
+    h_r: torch.Tensor,
+) -> torch.Tensor:
+
+    w_l = h_l + 2.0 * h_r
+    w_r = 2.0 * h_l + h_r
+    return (w_l + w_r) / (w_l / delta_l + w_r / delta_r)
+
+
+def _endpoint_slope(
+    delta_l: torch.Tensor,
+    delta_r: torch.Tensor,
+    h_l: torch.Tensor,
+    h_r: torch.Tensor,
+) -> torch.Tensor:
+    """
+    At the boundaries we use a one-sided 3-point method
+    (see “Three-point methods”):
+    https://en.wikipedia.org/wiki/Numerical_differentiation
+
+    Using Taylor expansions for y[i+1] and y[i+2] gives:
+        Δ[i]   ≈ d[i] + f'' * h[i] / 2 + ...
+        Δ[i+1] ≈ d[i] + f'' * (2h[i] + h[i+1]) / 2 + ...
+
+    Eliminating f'' yields the endpoint estimate:
+        d[i] ≈ (Δ[i] * (2h[i] + h[i+1]) - Δ[i+1] * h[i]) / (h[i] + h[i+1])
+    """
+    w1 = 2.0 * h_l + h_r
+    return (w1 * delta_l - h_l * delta_r) / (h_l + h_r)
+
+
+def _limit_endpoint(
+    d_end: torch.Tensor,
+    s_l: torch.Tensor,
+    s_r: torch.Tensor,
+) -> torch.Tensor:
+    # If derivative points opposite to the first secant, zero it
+    mask_sign_change = d_end * s_l < 0
+    d_end = torch.where(mask_sign_change, torch.zeros_like(d_end), d_end)
+
+    # If secants switch sign, cap magnitude to 3*|s_l|
+    mask_sign_change = s_l * s_r < 0
+    mask_cap = mask_sign_change & (torch.abs(d_end) > 3.0 * torch.abs(s_l))
+    return torch.where(mask_cap, 3.0 * s_l, d_end)
+
+
+def _pchip_derivatives(
+    h: torch.Tensor,
+    delta: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Compute PCHIP knot derivatives d[i] from interval widths h[i]
+    and secant slopes delta Δ[i].
+
+    Interior derivatives use a weighted harmonic mean of neighboring secants
+    when they have the same sign
+        (w1+w2)/d[i] = w1/Δ[i-1] + w2/Δ[i]
+    (otherwise set d[i]=0 to preserve shape). Endpoint derivatives are
+    estimated with a one-sided 3-point formula and then limited to prevent
+    overshoot.
+    """
+    n = h.numel() + 1
+    d = torch.zeros((n,), dtype=delta.dtype, device=delta.device)
+
+    # Two points: straight line
+    if n == 2:
+        d.fill_(delta[0])
+        return d
+
+    # Interior points
+    delta_l, delta_r = delta[:-1], delta[1:]
+    h_l, h_r = h[:-1], h[1:]
+
+    mask_same_sign = (delta_l * delta_r) > 0  # excludes zeros + sign changes
+    dh = _weighted_harmonic_mean(delta_l, delta_r, h_l, h_r)
+    d[1:-1] = torch.where(mask_same_sign, dh, torch.zeros_like(dh))
+
+    # Endpoints (one-sided + limiter)
+    d0 = _endpoint_slope(delta[0], delta[1], h[0], h[1])
+    dn = _endpoint_slope(delta[-1], delta[-2], h[-1], h[-2])
+
+    d[0] = _limit_endpoint(d0, delta[0], delta[1])
+    d[-1] = _limit_endpoint(dn, delta[-1], delta[-2])
+
+    return d
+
+
+def _polynomial_coeffs(
+    y: torch.Tensor,
+    h: torch.Tensor,
+    delta: torch.Tensor,
+    d: torch.Tensor,
+) -> torch.Tensor:
+    """
+    For each interval x ∈ [x[i], x[i+1]] build cubic in local coordinate
+    t(x) = x - x[i]:
+
+        P(t) = p0 + p1 t + p2 t^2 + p3 t^3,   0 <= t <= h[i]
+
+    Coefficients (p0, p1, p2, p3) are solutions to match value and slope
+    at both endpoints:
+
+    P(0) = y[i],   P'(0) = d[i]
+    P(h) = y[i+1], P'(h) = d[i+1],   where h = x[i+1] - x[i].
+
+    This gives:
+        p0 = y[i]
+        p1 = d[i]
+        p2 = (3Δ[i] - 2d[i] - d[i+1]) / h
+        p3 = (d[i] + d[i+1] - 2Δ[i]) / h²
+    """
+    p0 = y[:-1]
+    p1 = d[:-1]
+    p2 = (3.0 * delta - 2.0 * d[:-1] - d[1:]) / h
+    p3 = (d[:-1] + d[1:] - 2.0 * delta) / (h * h)
+    return torch.stack([p0, p1, p2, p3], dim=-1)  # (N-1, 4)
+
+
+class PCHIP1D:
+    """
+    1D PCHIP interpolator (PyTorch).
+
+    - Shape-preserving, C¹ piecewise-cubic Hermite interpolant.
+    """
+
+    def __init__(self, x: torch.Tensor, y: torch.Tensor):
+        self.x, self.y = self._validate_xy(x, y)
+
+        h = self.x[1:] - self.x[:-1]
+        delta = (self.y[1:] - self.y[:-1]) / h
+
+        d = _pchip_derivatives(h, delta)
+        self._coeffs = _polynomial_coeffs(self.y, h, delta, d)
+
+    @staticmethod
+    def _validate_xy(
+        x: torch.Tensor,
+        y: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        x = torch.as_tensor(x)
+        if not x.is_floating_point():
+            raise TypeError("x must be a floating point tensor")
+
+        y = torch.as_tensor(y, dtype=x.dtype, device=x.device)
+        if not y.is_floating_point():
+            raise TypeError("y must be a floating point tensor")
+
+        if x.ndim != 1 or y.ndim != 1:
+            raise ValueError("x and y must be 1D tensors")
+        if x.numel() != y.numel():
+            raise ValueError("x and y must have the same length")
+        if x.numel() < 2:
+            raise ValueError("Need at least 2 points")
+        if not torch.all(x[1:] > x[:-1]):
+            raise ValueError("x must be strictly increasing")
+
+        return x, y
+
+    def _interval_index(self, xq: torch.Tensor) -> torch.Tensor:
+        i = torch.searchsorted(self.x, xq, right=True) - 1
+        return i.clamp(0, self.x.numel() - 2)
+
+    def __call__(self, xq: torch.Tensor) -> torch.Tensor:
+        xq = torch.as_tensor(xq, dtype=self.x.dtype, device=self.x.device)
+
+        i = self._interval_index(xq)
+        t = xq - self.x[i]
+
+        p0, p1, p2, p3 = self._coeffs[i].unbind(-1)
+        return p0 + t * (p1 + t * (p2 + t * p3))

emu_base/pulser_adapter.py

@@ -1,14 +1,17 @@
-from typing import Sequence
+from typing import Sequence, Iterator
+from dataclasses import dataclass
 from enum import Enum
-import torch
 import math
+import torch
 import pulser
 from pulser.sampler import SequenceSamples
 from pulser.noise_model import NoiseModel
 from pulser.register.base_register import QubitId
 from pulser.backend.config import EmulationConfig
 from pulser._hamiltonian_data import HamiltonianData
+from pulser.channels.base_channel import States
 from emu_base.jump_lindblad_operators import get_lindblad_operators
+from emu_base.math.pchip_torch import PCHIP1D
 
 
 class HamiltonianType(Enum):
@@ -38,128 +41,178 @@ def _get_all_lindblad_noise_operators(
     ]
 
 
-def _get_target_times(
-    sequence: pulser.Sequence, config: EmulationConfig, dt: int
-) -> list[int]:
-    sequence_duration = sequence.get_duration(include_fall_time=config.with_modulation)
+def _unique_observable_times(
+    config: EmulationConfig,
+) -> set[float]:
+    """Collect unique evaluation times in [0, 1] for all observables."""
+    observable_times: set[float] = set()
 
-    observable_times = set(range(0, sequence_duration, dt))
-    observable_times.add(sequence_duration)
     for obs in config.observables:
-        times: Sequence[float]
         if obs.evaluation_times is not None:
-            times = obs.evaluation_times
-        elif config.default_evaluation_times != "Full":
-            times = config.default_evaluation_times.tolist()  # type: ignore[union-attr,assignment]
-        observable_times |= set([round(time * sequence_duration) for time in times])
+            observable_times |= set(obs.evaluation_times)
+        elif not isinstance(config.default_evaluation_times, str):  # != "Full"
+            observable_times |= set(config.default_evaluation_times.tolist())
+        else:
+            raise ValueError(
+                f"default config {config.default_evaluation_times} is not supported."
+            )
+
+    return observable_times
+
 
-    target_times: list[int] = list(observable_times)
-    target_times.sort()
+def _get_target_times(
+    sequence: pulser.Sequence,
+    config: EmulationConfig,
+    dt: float,
+) -> list[float]:
+    """Compute the sorted absolute times to sample the sequence.
+
+    Combines a uniform grid with step ``dt`` and any extra observable times,
+    then converts everything to absolute times over the sequence duration.
+    """
+    duration = float(sequence.get_duration(include_fall_time=config.with_modulation))
+    n_steps = math.floor(duration / dt)
+    evolution_times_rel: set[float] = {
+        i * float(dt) / duration for i in range(n_steps + 1)
+    }
+    evolution_times_rel.add(1.0)
+    target_times_rel = evolution_times_rel | _unique_observable_times(config)
+    target_times: list[float] = sorted({t * duration for t in target_times_rel})
     return target_times
 
 
 def _extract_omega_delta_phi(
     noisy_samples: SequenceSamples,
     qubit_ids: tuple[str, ...],
-    target_times: list[int],
+    target_times: Sequence[float],
 ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-    sequence_dict = noisy_samples.to_nested_dict(all_local=True, samples_type="tensor")[
-        "Local"
-    ]
-    nsamples = len(target_times) - 1
-    omega = torch.zeros(
-        nsamples,
-        len(qubit_ids),
-        dtype=torch.complex128,
-    )
-    delta = torch.zeros(
-        nsamples,
-        len(qubit_ids),
-        dtype=torch.complex128,
-    )
-    phi = torch.zeros(
-        nsamples,
-        len(qubit_ids),
-        dtype=torch.complex128,
-    )
-    max_duration = noisy_samples.max_duration
+    """
+    Extract per-qubit laser parameters (Ω, δ, phase) from Pulser samples.
+
+    Pulser stores samples on the discrete grid t = 0, 1, ..., T-1
+    (with dt = 1.0), i.e. it does not provide values exactly
+    at t = T = pulse_duration. Pulser effectively assumes
+    Ω(T) = δ(T) = phase(T) = 0. For midpoint discretization we therefore
+    interpolate (and implicitly extrapolate near the end) to obtain
+    Ω(t_mid), δ(t_mid), and phase(t_mid) at t_mid = (t_k + t_{k+1}) / 2.
 
-    if "ground-rydberg" in sequence_dict and len(sequence_dict) == 1:
+    We evaluate the laser parameters at time midpoints to benefit from
+    a midpoint scheme.
+    https://en.wikipedia.org/wiki/Midpoint_method
+    """
+    sequence_dict = noisy_samples.to_nested_dict(
+        all_local=True,
+        samples_type="tensor",
+    )["Local"]
+    if len(sequence_dict) != 1:
+        raise ValueError("Only single interaction type is supported.")
+
+    if "ground-rydberg" in sequence_dict:
         locals_a_d_p = sequence_dict["ground-rydberg"]
-    elif "XY" in sequence_dict and len(sequence_dict) == 1:
+    elif "XY" in sequence_dict:
         locals_a_d_p = sequence_dict["XY"]
     else:
-        raise ValueError("Only `ground-rydberg` and `mw_global` channels are supported.")
+        raise ValueError(
+            "Only `ground-rydberg` and `mw_global`(XY) channels are supported."
+        )
     qubit_ids_filtered = [qid for qid in qubit_ids if qid in locals_a_d_p]
-    for i in range(nsamples):
-        t = (target_times[i] + target_times[i + 1]) / 2
-        # The sampled values correspond to the start of each interval
-        # To maximize the order of the solver, we need the values in the middle
-        if math.ceil(t) < max_duration:
-            # If we're not the final step, approximate this using linear
-            # interpolation
-            # Note that for dt even, t1=t2
-            t1 = math.floor(t)
-            t2 = math.ceil(t)
-            for q_pos, q_id in enumerate(qubit_ids_filtered):
-                omega[i, q_pos] = (
-                    locals_a_d_p[q_id]["amp"][t1] + locals_a_d_p[q_id]["amp"][t2]
-                ) / 2.0
-                delta[i, q_pos] = (
-                    locals_a_d_p[q_id]["det"][t1] + locals_a_d_p[q_id]["det"][t2]
-                ) / 2.0
-                phi[i, q_pos] = (
-                    locals_a_d_p[q_id]["phase"][t1] + locals_a_d_p[q_id]["phase"][t2]
-                ) / 2.0
 
-        else:
-            # We're in the final step and dt=1, approximate this using linear extrapolation
-            # we can reuse omega_1 and omega_2 from before
-            for q_pos, q_id in enumerate(qubit_ids_filtered):
-                delta[i, q_pos] = (
-                    3.0 * locals_a_d_p[q_id]["det"][t2] - locals_a_d_p[q_id]["det"][t1]
-                ) / 2.0
-                phi[i, q_pos] = (
-                    3.0 * locals_a_d_p[q_id]["phase"][t2]
-                    - locals_a_d_p[q_id]["phase"][t1]
-                ) / 2.0
-                omega[i, q_pos] = max(
-                    (3.0 * locals_a_d_p[q_id]["amp"][t2] - locals_a_d_p[q_id]["amp"][t1])
-                    / 2.0,
-                    0.0,
+    target_t = torch.as_tensor(target_times, dtype=torch.float64)
+    t_mid = 0.5 * (target_t[:-1] + target_t[1:])
+
+    shape = (t_mid.numel(), len(qubit_ids_filtered))
+    omega_mid = torch.zeros(shape, dtype=torch.float64, device=t_mid.device)
+    delta_mid = torch.zeros(shape, dtype=torch.float64, device=t_mid.device)
+    phi_mid = torch.zeros(shape, dtype=torch.float64, device=t_mid.device)
+
+    assert noisy_samples.max_duration == target_times[-1]
+    t_grid = torch.arange(target_times[-1], dtype=torch.float64)
+
+    laser_by_data = {
+        "amp": omega_mid,
+        "det": delta_mid,
+        "phase": phi_mid,
+    }
+    for name, data_mid in laser_by_data.items():
+        for q_pos, q_id in enumerate(qubit_ids_filtered):
+            signal = torch.as_tensor(locals_a_d_p[q_id][name])
+            if torch.is_complex(signal) and not torch.allclose(
+                signal.imag, torch.zeros_like(signal.imag)
+            ):
+                raise ValueError(f"Input {name} has non-zero imaginary part.")
+
+            pchip = PCHIP1D(t_grid, signal.real)
+            data_mid[:, q_pos] = pchip(t_mid)
+            if name == "amp":
+                data_mid[-1, q_pos] = torch.where(
+                    data_mid[-1, q_pos] > 0,
+                    data_mid[-1, q_pos],
+                    0,
                 )
 
-    return omega, delta, phi
+    omega_c, delta_c, phi_c = (
+        arr.to(torch.complex128) for arr in (omega_mid, delta_mid, phi_mid)
+    )
+    return omega_c, delta_c, phi_c
 
 
-class PulserData:
-    slm_end_time: float
-    full_interaction_matrix: torch.Tensor
-    masked_interaction_matrix: torch.Tensor
+@dataclass(frozen=True)
+class SequenceData:
     omega: torch.Tensor
     delta: torch.Tensor
     phi: torch.Tensor
+    full_interaction_matrix: torch.Tensor
+    masked_interaction_matrix: torch.Tensor
+    bad_atoms: dict[str, bool]
+    lindblad_ops: list[torch.Tensor]
+    noise_model: pulser.NoiseModel
+    qubit_ids: tuple[QubitId, ...]
+    target_times: list[float]
+    eigenstates: list[States]
+    qubit_count: int
+    dim: int
+    hamiltonian_type: HamiltonianType
+    slm_end_time: float
+
+
+class PulserData:
+    target_times: list[float]
+    slm_end_time: float
+    full_interaction_matrix: torch.Tensor | None
     hamiltonian_type: HamiltonianType
     lindblad_ops: list[torch.Tensor]
     qubit_ids: tuple[QubitId, ...]
+    noise_model: pulser.NoiseModel
+    interaction_cutoff: float
+    eigenstates: list[States]
+    qubit_count: int
+    dim: int
 
-    def __init__(self, *, sequence: pulser.Sequence, config: EmulationConfig, dt: int):
+    def __init__(self, *, sequence: pulser.Sequence, config: EmulationConfig, dt: float):
+        self._sequence = sequence
         self.qubit_ids = sequence.register.qubit_ids
         self.qubit_count = len(self.qubit_ids)
         self.target_times = _get_target_times(sequence=sequence, config=config, dt=dt)
+        self.noise_model = (
+            sequence.device.default_noise_model
+            if config.prefer_device_noise_model
+            else config.noise_model
+        )
+
+        if not self.noise_model:
+            self.noise_model = NoiseModel()
+
         self.hamiltonian = HamiltonianData.from_sequence(
             sequence,
             with_modulation=config.with_modulation,
-            noise_model=config.noise_model,
+            noise_model=self.noise_model,
+            n_trajectories=config.n_trajectories,
         )
 
-        self.omega, self.delta, self.phi = _extract_omega_delta_phi(
-            self.hamiltonian.noisy_samples, self.qubit_ids, self.target_times
-        )
-        self.eigenstates = self.hamiltonian.eigenbasis
+        self.eigenstates = self.hamiltonian.basis_data.eigenbasis
 
-        int_type = self.hamiltonian.interaction_type
-        self.dim = self.hamiltonian.dim
+        int_type = self.hamiltonian.basis_data.interaction_type
+        self.dim = self.hamiltonian.basis_data.dim
         if int_type == "ising":  # for local and global
             self.hamiltonian_type = HamiltonianType.Rydberg
         elif int_type == "XY":
@@ -168,33 +221,65 @@ class PulserData:
             raise ValueError(f"Unsupported basis: {int_type}")
 
         self.lindblad_ops = _get_all_lindblad_noise_operators(
-            config.noise_model, dim=self.dim, interact_type=int_type
+            self.noise_model, dim=self.dim, interact_type=int_type
         )
         self.has_lindblad_noise: bool = self.lindblad_ops != []
 
+        self.full_interaction_matrix = None
         if config.interaction_matrix is not None:
             assert len(config.interaction_matrix) == self.qubit_count, (
                 "The number of qubits in the register should be the same as the size of "
                 "the interaction matrix"
             )
-
             self.full_interaction_matrix = config.interaction_matrix.as_tensor()
-        else:
-            self.full_interaction_matrix = (
-                self.hamiltonian.noisy_interaction_matrix.as_tensor()
-            )
-
-        self.full_interaction_matrix[
-            torch.abs(self.full_interaction_matrix) < config.interaction_cutoff
-        ] = 0.0
-        self.masked_interaction_matrix = self.full_interaction_matrix.clone()
 
+        self.interaction_cutoff = config.interaction_cutoff
         self.slm_end_time = (
             sequence._slm_mask_time[1] if len(sequence._slm_mask_time) > 1 else 0.0
         )
 
-        # disable interaction for SLM masked qubits
-        slm_targets = list(sequence._slm_mask_targets)
-        for target in sequence.register.find_indices(slm_targets):
-            self.masked_interaction_matrix[target] = 0.0
-            self.masked_interaction_matrix[:, target] = 0.0
+    def get_sequences(self) -> Iterator[SequenceData]:
+        for samples in self.hamiltonian.noisy_samples:
+            full_interaction_matrix = (
+                self.full_interaction_matrix
+                if self.full_interaction_matrix is not None
+                else samples.trajectory.interaction_matrix.as_tensor()
+            )
+
+            full_interaction_matrix = full_interaction_matrix.clone()
+
+            full_interaction_matrix[
+                torch.abs(full_interaction_matrix) < self.interaction_cutoff
+            ] = 0.0
+
+            masked_interaction_matrix = full_interaction_matrix.clone()
+
+            # disable interaction for SLM masked qubits
+
+            slm_targets = list(self._sequence._slm_mask_targets)
+            for target in self._sequence.register.find_indices(slm_targets):
+                masked_interaction_matrix[target] = 0.0
+                masked_interaction_matrix[:, target] = 0.0
+
+            omega, delta, phi = _extract_omega_delta_phi(
+                samples.samples, self.qubit_ids, self.target_times
+            )
+
+            for _ in range(samples.reps):
+                yield SequenceData(
+                    omega,
+                    delta,
+                    phi,
+                    full_interaction_matrix,
+                    masked_interaction_matrix,
+                    samples.trajectory.bad_atoms,
+                    self.lindblad_ops,
+                    self.noise_model,
+                    self.qubit_ids,
+                    self.target_times,
+                    self.eigenstates,
+                    self.qubit_count,
+                    self.dim,
+                    self.hamiltonian_type,
+                    self.slm_end_time,
+                )

emu_base/utils.py

@@ -12,8 +12,29 @@ if unix_like:
 
 
 def init_logging(log_level: int, log_file: Path | None) -> logging.Logger:
+    """Create and return a configured logger for the emulators package.
+
+    This configures a logger named "emulators" and ensures it does not
+    propagate messages to ancestor loggers. Any existing handlers attached to
+    this logger are removed before the new handler is added.
+
+    Behavior
+    - If `log_file` is None, a StreamHandler writing to stdout is used.
+    - If `log_file` is a Path, a FileHandler is created (mode='w'), which
+      overwrites the file on each call.
+    - The handler's level is set to `log_level` and uses a simple
+      "%(message)s" formatter.
+
+    Args:
+        log_level (int): Logging level (e.g. logging.INFO).
+        log_file (Path | None): Path to a log file, or None to log to stdout.
+
+    Returns:
+        logging.Logger: The configured logger instance named "emulators".
+    """
     logger = logging.getLogger("emulators")
     logger.propagate = False
+    logger.setLevel(logging.DEBUG)
 
     handler: logging.Handler
     if log_file is None:

{emu_base-2.5.2.dist-info → emu_base-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-base
-Version: 2.5.2
+Version: 2.7.0
 Summary: Pasqal base classes for emulators
 Project-URL: Documentation, https://pasqal-io.github.io/emulators/
 Project-URL: Repository, https://github.com/pasqal-io/emulators
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: pulser-core==1.6.*
+Requires-Dist: pulser-core[torch]>=1.7.0rc2
 Requires-Dist: torch>=2.9.0
 Description-Content-Type: text/markdown
 

{emu_base-2.5.2.dist-info → emu_base-2.7.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
-emu_base/__init__.py,sha256=Hwz7RJiKKY-lie2PIQIK-KaOVe0uGhyarI21w_PPqeE,759
+emu_base/__init__.py,sha256=GCfEvZoxqxv5V9TIni0NyUyWSP83PxL1toiMQfOirok,793
 emu_base/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
-emu_base/jump_lindblad_operators.py,sha256=F_C-1aruXY_SLzw0m_HD5loqRGdjgsLHEzttlMzWNEw,3015
-emu_base/pulser_adapter.py,sha256=QyvJVWmAQDpFBc68-cnndNBkY1rvdDeEXXPse-afQ68,7369
-emu_base/utils.py,sha256=kXfRFq31r_dfLbBC0SHiPpvf7Wll4behd2vqQJsTrVo,3553
+emu_base/jump_lindblad_operators.py,sha256=tL2DDG7kG4GthzZckzLpZlBzEFHLt0O_mut8Qm0Ub3w,2958
+emu_base/pulser_adapter.py,sha256=muiyEthtTOgSv3zYXczgHbXF9Mx64lpOpk9o0leMbpg,10171
+emu_base/utils.py,sha256=50Nbm95xXUmnJVA-r1Pd5z4pzEIjKUZs385xesE5sxA,4413
 emu_base/math/__init__.py,sha256=6BbIytYV5uC-e5jLMtIErkcUl_PvfSNnhmVFY9Il8uQ,97
 emu_base/math/brents_root_finding.py,sha256=AVx6L1Il6rpPJWrLJ7cn6oNmJyZOPRgEaaZaubC9lsU,3711
 emu_base/math/double_krylov.py,sha256=X16dyCbyzdP7fFK-hmKS03Q-DJtC6TZ8sJrGTJ6akIc,3708
 emu_base/math/krylov_energy_min.py,sha256=iR4hmE0eXptbAg3opikd5d4Zv7dhnDrawH-n_4KG-cc,4009
 emu_base/math/krylov_exp.py,sha256=mGFddVQ8mEbwypbZtnlRPFpi4Nf8JZT6OKLHloIwCDQ,3934
 emu_base/math/matmul.py,sha256=lEAnV0b5z_f1xEA-9p-WXxA8bM3QbShiHdXQ3ZkZFcQ,877
-emu_base-2.5.2.dist-info/METADATA,sha256=Nvrz_okEVXHqTG2aYZmjLBlK57DP3jz2YtHCaiJaexc,3604
-emu_base-2.5.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-emu_base-2.5.2.dist-info/RECORD,,
+emu_base/math/pchip_torch.py,sha256=Pl95A6BVLts7wuuJSeuXZOIfqpdXgxn3ZOtDxORwOcE,8951
+emu_base-2.7.0.dist-info/METADATA,sha256=SHTj8BJK97soOWGvOV0aSkILS9NMkpwZxh7O_trhjt0,3614
+emu_base-2.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+emu_base-2.7.0.dist-info/RECORD,,