emu-sv 2.6.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

emu_sv/__init__.py

@@ -40,4 +40,4 @@ __all__ = [
     "SparseOperator",
 ]
 
-__version__ = "2.6.0"
+__version__ = "2.7.0"

emu_sv/dense_operator.py

@@ -20,7 +20,23 @@ dtype = torch.complex128
 
 
 class DenseOperator(Operator[complex, torch.Tensor, StateVector]):
-    """DenseOperator in EMU-SV use dense matrices"""
+    """DenseOperator in emu-sv uses dense matrices. This class represents a
+    quantum operator backed by a dense PyTorch tensor for state-vector
+    simulation.
+
+    Args:
+        matrix (torch.Tensor): Square complex tensor of shape (2ⁿ, 2ⁿ)
+            representing the operator in the computational basis.
+        gpu (bool, optional): If True, place the operator on a CUDA device when
+            available. Default: True (and only 1 GPU).
+
+    Returns:
+        DenseOperator: An operator object wrapping the provided matrix.
+
+    Raises:
+        ValueError: If 'matrix' is not a 2-D square tensor.
+        RuntimeError: If gpu=True but CUDA is not available (if applicable).
+    """
 
     def __init__(
         self,
@@ -121,7 +137,8 @@ class DenseOperator(Operator[complex, torch.Tensor, StateVector]):
         Construct a DenseOperator from an operator representation.
 
         Args:
-            eigenstates: the eigenstates of the basis to use, e.g. ("r", "g") or ("0", "1").
+            eigenstates: the eigenstates of the basis to use, e.g. ("r", "g")
+                or ("0", "1").
             n_qudits: number of qudits in the system.
             operations: which bitstrings make up the state with what weight.
 

emu_sv/density_matrix_state.py

@@ -15,7 +15,28 @@ dtype = torch.complex128
 
 
 class DensityMatrix(State[complex, torch.Tensor]):
-    """Represents a density matrix in a computational basis."""
+    """Represents an n-qubit density matrix ρ in the computational (|g⟩, |r⟩)
+    basis. The input should be a square complex tensor with shape (2ⁿ, 2ⁿ),
+    where n is the number of atoms. ρ must be Hermitian, positive semidefinite,
+    and has trace 1.
+
+    Args:
+        matrix (torch.Tensor): Square complex tensor of shape (2ⁿ, 2ⁿ),
+            Hermitian with trace 1, that represents the state in the
+            computational basis.
+        gpu (bool, optional): If True, place the operator on a CUDA device when
+            available. Default: True.
+
+    Returns:
+        DensityMatrix: A density-matrix wrapper around the provided tensor."
+
+    Raises:
+        ValueError: If matrix is not a square 2D tensor of shape (2ⁿ, 2ⁿ) or
+            fails validation (e.g., not Hermitian / trace != 1) if validation
+            is performed.
+        RuntimeError: If gpu=True but CUDA is not available (if the
+            implementation moves tensors to CUDA).
+    """
 
     # for the moment no need to check positivity and trace 1
     def __init__(
@@ -65,12 +86,18 @@ class DensityMatrix(State[complex, torch.Tensor]):
         Returns:
             the inner product
 
-        Example:
-        >>> density_bell_state = (1/2* torch.tensor([[1, 0, 0, 1], [0, 0, 0, 0],
-        ... [0, 0, 0, 0], [1, 0, 0, 1]],dtype=torch.complex128))
-        >>> density_c = DensityMatrix(density_bell_state, gpu=False)
-        >>> density_c.overlap(density_c)
-        tensor(1.+0.j, dtype=torch.complex128)
+        Examples:
+            ```python
+            density_bell_state = 0.5 * torch.tensor([[1, 0, 0, 1], [0, 0, 0, 0],
+            [0, 0, 0, 0], [1, 0, 0, 1]],dtype=torch.complex128)
+            density_c = DensityMatrix(density_bell_state, gpu=False)
+            density_c.overlap(density_c)
+            ```
+
+            Output:
+            ```
+            tensor(1.+0.j, dtype=torch.complex128)
+            ```
         """
 
         assert isinstance(
@@ -86,22 +113,28 @@ class DensityMatrix(State[complex, torch.Tensor]):
 
     @classmethod
     def from_state_vector(cls, state: StateVector) -> DensityMatrix:
-        """Convert a state vector to a density matrix.
+        """
+        Convert a state vector to a density matrix.
         This function takes a state vector |ψ❭ and returns the corresponding
         density matrix ρ = |ψ❭❬ψ| representing the pure state |ψ❭.
-        Example:
-           >>> from emu_sv import StateVector
-           >>> import math
-           >>> bell_state_vec = 1 / math.sqrt(2) * torch.tensor(
-           ... [1.0, 0.0, 0.0, 1.0j],dtype=torch.complex128)
-           >>> bell_state = StateVector(bell_state_vec, gpu=False)
-           >>> density = DensityMatrix.from_state_vector(bell_state)
-           >>> print(density.matrix)
-           tensor([[0.5000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j, 0.0000-0.5000j],
+
+        Examples:
+            ```python
+            bell_state_vec = 0.7071 * torch.tensor([1.0, 0.0, 0.0, 1.0j],
+            dtype=torch.complex128)
+            bell_state = StateVector(bell_state_vec, gpu=False)
+            density = DensityMatrix.from_state_vector(bell_state)
+            print(density.matrix)
+            ```
+
+            Output:
+            ```
+            tensor([[0.5000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j, 0.0000-0.5000j],
                    [0.0000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j],
                    [0.0000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j],
                    [0.0000+0.5000j, 0.0000+0.0000j, 0.0000+0.0000j, 0.5000+0.0000j]],
                   dtype=torch.complex128)
+            ```
         """
 
         return cls(
@@ -116,7 +149,8 @@ class DensityMatrix(State[complex, torch.Tensor]):
         n_qudits: int,
         amplitudes: Mapping[str, complex],
     ) -> tuple[DensityMatrix, Mapping[str, complex]]:
-        """Transforms a state given by a string into a density matrix.
+        """
+        Transforms a state given by a string into a density matrix.
 
         Construct a state from the pulser abstract representation
         https://pulser.readthedocs.io/en/stable/conventions.html
@@ -124,22 +158,29 @@ class DensityMatrix(State[complex, torch.Tensor]):
         Args:
             basis: A tuple containing the basis states (e.g., ('r', 'g')).
             nqubits: the number of qubits.
-            strings: A dictionary mapping state strings to complex or floats amplitudes.
+            strings: A dictionary mapping state strings to complex or floats
+            amplitudes.
 
         Returns:
             The resulting state.
 
-        Examples:
-            >>> eigenstates = ("r","g")
-            >>> n = 2
-            >>> dense_mat=DensityMatrix.from_state_amplitudes(eigenstates=eigenstates,
-            ... amplitudes={"rr":1.0,"gg":1.0})
-            >>> print(dense_mat.matrix)
+        Example:
+            ```python
+            eigenstates = ("r","g")
+            n = 2
+            dense_mat=DensityMatrix.from_state_amplitudes(eigenstates=eigenstates,
+            amplitudes={"rr":1.0,"gg":1.0})
+            print(dense_mat.matrix)
+            ```
+
+            Output:
+            ```
             tensor([[0.5000+0.j, 0.0000+0.j, 0.0000+0.j, 0.5000+0.j],
                     [0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j],
                     [0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j],
                     [0.5000+0.j, 0.0000+0.j, 0.0000+0.j, 0.5000+0.j]],
                    dtype=torch.complex128)
+            ```
         """
 
         state_vector, amplitudes = StateVector._from_state_amplitudes(
@@ -166,16 +207,21 @@ class DensityMatrix(State[complex, torch.Tensor]):
         Returns:
             the measured bitstrings, by count
 
-        Example:
-        >>> import math
-        >>> torch.manual_seed(1234)
-        >>> from emu_sv import StateVector
-        >>> bell_vec = 1 / math.sqrt(2) * torch.tensor(
-        ... [1.0, 0.0, 0.0, 1.0j],dtype=torch.complex128)
-        >>> bell_state_vec = StateVector(bell_vec)
-        >>> bell_density = DensityMatrix.from_state_vector(bell_state_vec)
-        >>> bell_density.sample(1000)
-         Counter({'00': 517, '11': 483})
+        Examples:
+            ```python
+            torch.manual_seed(1234)
+            from emu_sv import StateVector
+            bell_vec = 0.7071 * torch.tensor([1.0, 0.0, 0.0, 1.0j],
+               dtype=torch.complex128)
+            bell_state_vec = StateVector(bell_vec)
+            bell_density = DensityMatrix.from_state_vector(bell_state_vec)
+            bell_density.sample(1000)
+            ```
+
+            Output:
+            ```
+            Counter({'00': 517, '11': 483})
+            ```
         """
 
         probabilities = torch.abs(self.matrix.diagonal())
@@ -194,9 +240,3 @@ class DensityMatrix(State[complex, torch.Tensor]):
                 p_false_neg=p_false_neg,
             )
         return counts
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

emu_sv/sparse_operator.py

@@ -40,12 +40,14 @@ def sparse_kron(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
 
 
 class SparseOperator(Operator[complex, torch.Tensor, StateVector]):
-    """This operator is used to represent a sparse matrix in CSR (Compressed Sparse Row)
-    format for efficient computation on the EMU-SV emulator
+    """This operator is used to represent a sparse matrix in CSR (Compressed
+    Sparse Row) format for efficient computation on the emu-sv emulator
 
     Args:
         matrix (torch.Tensor): The CSR matrix representation of the operator.
-        gpu (bool): Use GPU for computation. True uses the CPU if GPU not available.
+
+        gpu (bool): If True (by default), run on GPU when available; otherwise
+        fall back to CPU. If False, always run on CPU.
     """
 
     def __init__(

emu_sv/state_vector.py

@@ -26,9 +26,11 @@ class StateVector(State[complex, torch.Tensor]):
     manipulation, and measurement. The state vector must have a length
     that is a power of 2, representing 2ⁿ basis states for n qubits.
 
-    Attributes:
+    Args:
         vector: 1D tensor representation of a state vector.
         gpu: store the vector on GPU if True, otherwise on CPU
+        eigenstates: sequence of eigenstates used as basis only qubit basis are
+        supported (default: ('r','g'))
     """
 
     def __init__(
@@ -88,8 +90,14 @@ class StateVector(State[complex, torch.Tensor]):
             The zero state
 
         Examples:
-            >>> StateVector.zero(2,gpu=False)
+            ```python
+            StateVector.zero(2,gpu=False)
+            ```
+
+            Output:
+            ```
             tensor([0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], dtype=torch.complex128)
+            ```
         """
 
         device = "cuda" if gpu and DEVICE_COUNT > 0 else "cpu"
@@ -109,10 +117,14 @@ class StateVector(State[complex, torch.Tensor]):
             The described state
 
         Examples:
-            >>> StateVector.make(2,gpu=False)
-            tensor([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], dtype=torch.complex128)
-
+            ```python
+            StateVector.make(2,gpu=False)
+            ```
 
+            Output:
+            ```
+            tensor([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], dtype=torch.complex128)
+            ```
         """
 
         result = cls.zero(num_sites=num_sites, gpu=gpu)
@@ -235,23 +247,27 @@ class StateVector(State[complex, torch.Tensor]):
 
         Args:
             eigenstates: A tuple containing the basis states (e.g., ('r', 'g')).
-            amplitudes: A dictionary mapping state strings to complex or floats amplitudes.
+            amplitudes: A dictionary mapping state strings to complex or floats
+            amplitudes.
 
         Returns:
             The normalised resulting state.
 
         Examples:
-            >>> basis = ("r","g")
-            >>> n = 2
-            >>> st=StateVector.from_state_string(basis=basis,
-                ... nqubits=n,strings={"rr":1.0,"gg":1.0},gpu=False)
-            >>> st = StateVector.from_state_amplitudes(
-            ...     eigenstates=basis,
-            ...     amplitudes={"rr": 1.0, "gg": 1.0}
-            ... )
-            >>> print(st)
+            ```python
+            basis = ("r","g")
+            st = StateVector.from_state_amplitudes(
+                eigenstates=basis,
+                amplitudes={"rr": 1.0, "gg": 1.0}
+            )
+            print(st)
+            ```
+
+            Output:
+            ```
             tensor([0.7071+0.j, 0.0000+0.j, 0.0000+0.j, 0.7071+0.j],
                    dtype=torch.complex128)
+            ```
         """
         basis = set(eigenstates)
         if basis == {"r", "g"}:
@@ -291,22 +307,30 @@ def inner(left: StateVector, right: StateVector) -> torch.Tensor:
         the inner product
 
     Examples:
-        >>> factor = math.sqrt(2.0)
-        >>> basis = ("r","g")
-        >>> string_state1 = {"gg":1.0,"rr":1.0}
-        >>> state1 = StateVector.from_state_string(basis=basis,
-            ... nqubits=nqubits,strings=string_state1)
-        >>> string_state2 = {"gr":1.0/factor,"rr":1.0/factor}
-        >>> state2 = StateVector.from_state_string(basis=basis,
-            ... nqubits=nqubits,strings=string_state2)
-
-        >>> state1 = StateVector.from_state_amplitudes(eigenstates=basis,
-        ...     amplitudes=string_state1)
-        >>> string_state2 = {"gr":1.0/factor,"rr":1.0/factor}
-        >>> state2 = StateVector.from_state_amplitudes(eigenstates=basis,
-        ...     amplitudes=string_state2)
-        >>> inner(state1,state2).item()
+        ```python
+        factor = math.sqrt(2.0)
+        basis = ("r","g")
+        string_state1 = {"gg":1.0,"rr":1.0}
+        state1 = StateVector.from_state_string(basis=basis,
+        nqubits=nqubits,strings=string_state1)
+        string_state2 = {"gr":1.0/factor,"rr":1.0/factor}
+        state2 = StateVector.from_state_string(basis=basis,
+        nqubits=nqubits,strings=string_state2)
+        ```
+
+        ```python
+        state1 = StateVector.from_state_amplitudes(eigenstates=basis,
+            amplitudes=string_state1)
+        string_state2 = {"gr":1.0/factor,"rr":1.0/factor}
+        state2 = StateVector.from_state_amplitudes(eigenstates=basis,
+            amplitudes=string_state2)
+        inner(state1,state2).item()
+        ```
+
+        Output:
+        ```
         (0.49999999144286444+0j)
+        ```
     """
 
     assert (left.vector.shape == right.vector.shape) and (left.vector.dim() == 1), (
@@ -314,9 +338,3 @@ def inner(left: StateVector, right: StateVector) -> torch.Tensor:
         " the same and both need to be 1D tesnor",
     )
     return left.inner(right)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

emu_sv/sv_backend.py

@@ -1,7 +1,7 @@
-from pulser.backend import EmulatorBackend
-from pulser.backend import Results
+from pulser.backend import EmulatorBackend, Results, BitStrings
 from emu_sv.sv_config import SVConfig
 from emu_sv.sv_backend_impl import create_impl
+from emu_base import PulserData
 
 
 class SVBackend(EmulatorBackend):
@@ -9,11 +9,14 @@ class SVBackend(EmulatorBackend):
     A backend for emulating Pulser sequences using state vectors and sparse matrices.
     Noisy simulation is supported by solving the Lindblad equation and using effective
     noise channel or jump operators
+
+    Args:
+        config (SVConfig): Configuration for the SV backend.
     """
 
-    default_config = SVConfig()
+    default_config = SVConfig(observables=[BitStrings(evaluation_times=[1.0])])
 
-    def run(self) -> Results:
+    def run(self) -> Results | list[Results]:
         """
         Emulates the given sequence.
 
@@ -21,6 +24,11 @@ class SVBackend(EmulatorBackend):
             the simulation results
         """
         assert isinstance(self._config, SVConfig)
-
-        impl = create_impl(self._sequence, self._config)
-        return impl._run()
+        pulser_data = PulserData(
+            sequence=self._sequence, config=self._config, dt=self._config.dt
+        )
+        results = []
+        for sequence_data in pulser_data.get_sequences():
+            impl = create_impl(sequence_data, self._config)
+            results.append(impl._run())
+        return Results.aggregate(results)

emu_sv/sv_backend_impl.py

@@ -2,13 +2,13 @@ from abc import abstractmethod
 import time
 import typing
 import torch
+import logging
 
 from emu_sv.hamiltonian import RydbergHamiltonian
 from emu_sv.lindblad_operator import RydbergLindbladian
-from pulser import Sequence
 
 from pulser.backend import Results, Observable, State, EmulationConfig
-from emu_base import PulserData, get_max_rss
+from emu_base import SequenceData, get_max_rss
 
 from emu_sv.state_vector import StateVector
 from emu_sv.density_matrix_state import DensityMatrix
@@ -50,8 +50,7 @@ class Statistics(Observable):
             or isinstance(state, DensityMatrix)
             and state.matrix.is_cuda
         )
-
-        config.logger.info(
+        logging.getLogger("emulators").info(
             f"step = {len(self.data)}/{self.timestep_count}, "
             + f"RSS = {max_mem:.3f} MB, "
             + f"Δt = {duration:.3f} s"
@@ -70,19 +69,22 @@ class BaseSVBackendImpl:
 
     well_prepared_qubits_filter: typing.Optional[torch.Tensor]
 
-    def __init__(self, config: SVConfig, pulser_data: PulserData):
+    def __init__(self, config: SVConfig, data: SequenceData):
         self._config = config
-        self._pulser_data = pulser_data
-        self.target_times = pulser_data.target_times
-        self.omega = pulser_data.omega
-        self.delta = pulser_data.delta
-        self.phi = pulser_data.phi
-        self.nsteps = pulser_data.omega.shape[0]
-        self.nqubits = pulser_data.omega.shape[1]
-        self.full_interaction_matrix = pulser_data.full_interaction_matrix
+        self._data = data
+        self.target_times = data.target_times
+        self.omega = data.omega
+        self.delta = data.delta
+        self.phi = data.phi
+        self.nsteps = data.omega.shape[0]
+        self.nqubits = data.omega.shape[1]
+        self.full_interaction_matrix = data.full_interaction_matrix
         self.state: State
         self.time = time.time()
-        self.results = Results(atom_order=(), total_duration=self.target_times[-1])
+        self.results = Results(
+            atom_order=data.qubit_ids,
+            total_duration=int(self.target_times[-1]),
+        )
         self.statistics = Statistics(
             evaluation_times=[t / self.target_times[-1] for t in self.target_times],
             data=[],
@@ -100,7 +102,7 @@ class BaseSVBackendImpl:
 
         if (
             self._config.initial_state is not None
-            and self._config.noise_model.state_prep_error > 0.0
+            and self._data.noise_model.state_prep_error > 0.0
         ):
             raise NotImplementedError(
                 "Initial state and state preparation error can not be together."
@@ -112,10 +114,10 @@ class BaseSVBackendImpl:
         self.resolved_gpu = requested_gpu
 
     def init_dark_qubits(self) -> None:
-        if self._config.noise_model.state_prep_error > 0.0:
-            bad_atoms = self._pulser_data.hamiltonian.bad_atoms
+        if self._data.noise_model.state_prep_error > 0.0:
+            bad_atoms = self._data.bad_atoms
             self.well_prepared_qubits_filter = torch.tensor(
-                [bool(bad_atoms[x]) for x in self._pulser_data.qubit_ids]
+                [bool(bad_atoms[x]) for x in self._data.qubit_ids]
             )
         else:
             self.well_prepared_qubits_filter = None
@@ -132,6 +134,7 @@ class BaseSVBackendImpl:
         """One step of the evolution"""
         dt = self._compute_dt(step_idx)
         self._evolve_step(dt, step_idx)
+        step_idx += 1
         self._apply_observables(step_idx)
         self._save_statistics(step_idx)
 
@@ -142,9 +145,38 @@ class BaseSVBackendImpl:
     def _evolve_step(self, dt: float, step_idx: int) -> None:
         """One step evolution"""
 
+    def _is_evaluation_time(
+        self,
+        observable: Observable,
+        t: float,
+        tolerance: float = 1e-10,
+    ) -> bool:
+        """Return True if ``t`` is a genuine sampling time for this observable.
+
+        Filters out nearby points that are close to, but not in, the
+        observable's evaluation times (within ``tolerance``).
+        Prevent false matches by using Pulser's tolerance
+        tol = 0.5 / total_duration. (deep inside pulser Observable class)
+        """
+        times = observable.evaluation_times
+
+        is_observable_eval_time = (
+            times is not None
+            and self._config.is_time_in_evaluation_times(t, times, tol=tolerance)
+        )
+
+        is_default_eval_time = self._config.is_evaluation_time(t, tol=tolerance)
+
+        return is_observable_eval_time or is_default_eval_time
+
     def _apply_observables(self, step_idx: int) -> None:
-        norm_time = self.target_times[step_idx + 1] / self.target_times[-1]
-        for callback in self._config.observables:
+        norm_time = self.target_times[step_idx] / self.target_times[-1]
+        callbacks_for_current_time_step = [
+            callback
+            for callback in self._config.observables
+            if self._is_evaluation_time(callback, norm_time)
+        ]
+        for callback in callbacks_for_current_time_step:
             callback(
                 self._config,
                 norm_time,
@@ -154,7 +186,8 @@ class BaseSVBackendImpl:
             )
 
     def _save_statistics(self, step_idx: int) -> None:
-        norm_time = self.target_times[step_idx + 1] / self.target_times[-1]
+        norm_time = self.target_times[step_idx] / self.target_times[-1]
+
         self.statistics.data.append(time.time() - self.time)
         self.statistics(
             self._config,
@@ -167,6 +200,7 @@ class BaseSVBackendImpl:
         self._current_H = None
 
     def _run(self) -> Results:
+        self._apply_observables(0)  # at t == 0 for pulser compatibility
         for step in range(self.nsteps):
             self.step(step)
 
@@ -175,16 +209,16 @@ class BaseSVBackendImpl:
 
 class SVBackendImpl(BaseSVBackendImpl):
 
-    def __init__(self, config: SVConfig, pulser_data: PulserData):
+    def __init__(self, config: SVConfig, data: SequenceData):
         """
         For running sequences without noise. The state will evolve according
         to e^(-iH t)
 
         Args:
             config: The configuration for the emulator.
-            pulser_data: The data for the sequence to be emulated.
+            data: The data for the sequence to be emulated.
         """
-        super().__init__(config, pulser_data)
+        super().__init__(config, data)
         self.state: StateVector = (
             StateVector.make(self.nqubits, gpu=self.resolved_gpu)
             if self._config.initial_state is None
@@ -210,7 +244,7 @@ class SVBackendImpl(BaseSVBackendImpl):
 
 class NoisySVBackendImpl(BaseSVBackendImpl):
 
-    def __init__(self, config: SVConfig, pulser_data: PulserData):
+    def __init__(self, config: SVConfig, data: SequenceData):
         """
         Initializes the NoisySVBackendImpl, master equation version.
         This class handles the Lindblad operators and
@@ -218,12 +252,12 @@ class NoisySVBackendImpl(BaseSVBackendImpl):
 
         Args:
             config: The configuration for the emulator.
-            pulser_data: The data for the sequence to be emulated.
+            data: The data for the sequence to be emulated.
         """
 
-        super().__init__(config, pulser_data)
+        super().__init__(config, data)
 
-        self.pulser_lindblads = pulser_data.lindblad_ops
+        self.pulser_lindblads = data.lindblad_ops
 
         self.state: DensityMatrix = (
             DensityMatrix.make(self.nqubits, gpu=self.resolved_gpu)
@@ -246,7 +280,7 @@ class NoisySVBackendImpl(BaseSVBackendImpl):
         )
 
 
-def create_impl(sequence: Sequence, config: SVConfig) -> BaseSVBackendImpl:
+def create_impl(data: SequenceData, config: SVConfig) -> BaseSVBackendImpl:
     """
     Creates the backend implementation for the given sequence and config.
 
@@ -257,8 +291,7 @@ def create_impl(sequence: Sequence, config: SVConfig) -> BaseSVBackendImpl:
     Returns:
         An instance of SVBackendImpl.
     """
-    pulse_data = PulserData(sequence=sequence, config=config, dt=config.dt)
-    if pulse_data.has_lindblad_noise:
-        return NoisySVBackendImpl(config, pulse_data)
+    if data.lindblad_ops:
+        return NoisySVBackendImpl(config, data)
     else:
-        return SVBackendImpl(config, pulse_data)
+        return SVBackendImpl(config, data)

emu_sv/sv_config.py

@@ -26,7 +26,6 @@ from pulser.backend import (
     EnergySecondMoment,
     EnergyVariance,
     Occupation,
-    BitStrings,
 )
 
 
@@ -55,11 +54,13 @@ class SVConfig(EmulationConfig):
         kwargs: arguments that are passed to the base class
 
     Examples:
-        >>> gpu = True
-        >>> dt = 1 #this will impact the runtime
-        >>> krylov_tolerance = 1e-8 #the simulation will be faster, but less accurate
-        >>> SVConfig(gpu=gpu, dt=dt, krylov_tolerance=krylov_tolerance,
-        >>>     with_modulation=True) #the last arg is taken from the base class
+        ```python
+        gpu = True
+        dt = 1.0 #this will impact the runtime
+        krylov_tolerance = 1e-8 #the simulation will be faster, but less accurate
+        SVConfig(gpu=gpu, dt=dt, krylov_tolerance=krylov_tolerance,
+            with_modulation=True) #the last arg is taken from the base class
+        ```
     """
 
     # Whether to warn if unexpected kwargs are received
@@ -70,7 +71,7 @@ class SVConfig(EmulationConfig):
     def __init__(
         self,
         *,
-        dt: int = 10,
+        dt: float = 10.0,
         max_krylov_dim: int = 100,
         krylov_tolerance: float = 1e-10,
         gpu: bool | None = None,
@@ -79,7 +80,6 @@ class SVConfig(EmulationConfig):
         log_file: pathlib.Path | None = None,
         **kwargs: Any,
     ):
-        kwargs.setdefault("observables", [BitStrings(evaluation_times=[1.0])])
         super().__init__(
             dt=dt,
             max_krylov_dim=max_krylov_dim,
@@ -92,13 +92,13 @@ class SVConfig(EmulationConfig):
         )
 
         self.monkeypatch_observables()
-        self.logger = init_logging(log_level, log_file)
+        logger = init_logging(log_level, log_file)
 
         if (self.noise_model.runs != 1 and self.noise_model.runs is not None) or (
             self.noise_model.samples_per_run != 1
             and self.noise_model.samples_per_run is not None
         ):
-            self.logger.warning(
+            logger.warning(
                 "Warning: The runs and samples_per_run "
                 "values of the NoiseModel are ignored!"
             )
@@ -145,4 +145,4 @@ class SVConfig(EmulationConfig):
                     obs_copy,
                 )
             obs_list.append(obs_copy)
-        self.observables = tuple(obs_list)
+        self._backend_options["observables"] = tuple(obs_list)

{emu_sv-2.6.0.dist-info → emu_sv-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-sv
-Version: 2.6.0
+Version: 2.7.0
 Summary: Pasqal State Vector based pulse emulator built on PyTorch
 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: emu-base==2.6.0
+Requires-Dist: emu-base==2.7.0
 Description-Content-Type: text/markdown
 
 <div align="center">

emu_sv-2.7.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+emu_sv/__init__.py,sha256=cdxnMYgeTP6kn5BsOW71XoSh8WpKWlxMC6Zq38iqJLA,837
+emu_sv/custom_callback_implementations.py,sha256=_7XLIDzJ-p3DVqz-Jyv0eYbl8nih2x2p-pM4cBCLumA,6367
+emu_sv/dense_operator.py,sha256=0x8FPaOym-36vF3UQtwrARA9mi-N__FIiGJj2F_4MAw,6558
+emu_sv/density_matrix_state.py,sha256=byH5OGqQffr560CRmFngPGeV6fq33dYKEj3C0suhgdw,8351
+emu_sv/hamiltonian.py,sha256=CqNGuWJlO2ZljK47wt130s-5uKiOldQUsC3tjwk1mKA,6106
+emu_sv/lindblad_operator.py,sha256=pgjRNLBcvEM2-qxM8uy9wL74OtrD4A8trQeERi_AXH8,8892
+emu_sv/sparse_operator.py,sha256=B0TRuzr0j8wx3l4a0Pd7RT4DhFs_s_vH-4mIj1077vM,7585
+emu_sv/state_vector.py,sha256=r5VixGWuES_3qIhK2g4Qkn--3S8ZzMlPFQUmXw_NneM,10167
+emu_sv/sv_backend.py,sha256=ZLyg3fL20ItgSZXxpgqYvFuABocclwpvuShB17mOsyY,1148
+emu_sv/sv_backend_impl.py,sha256=01ibeAQDghpppRn28QdrAXvCDx6vo4O2xznigMlNng4,9898
+emu_sv/sv_config.py,sha256=eb3zCUDJDpAkJrCNxgZgAeDym5drzGyp-MwQbEbIDRk,5364
+emu_sv/time_evolution.py,sha256=Uy3qMdt3BlLB6Aq1-o5uajRTu_3fPuBCtcusHxFPPJc,13545
+emu_sv/utils.py,sha256=t0nMDVo6DF5bQW-vbsyRMCmvkyNxCU-v0Enmns9aOAU,1151
+emu_sv-2.7.0.dist-info/METADATA,sha256=yNM3g5QmB_01UWZXbewhPlRO-5drB1v4NGN6rKDZ16Y,3595
+emu_sv-2.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+emu_sv-2.7.0.dist-info/RECORD,,

emu_sv-2.6.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-emu_sv/__init__.py,sha256=0ykYwInHIgbHkUig_cY9uFesmU4F8bc8D_DIV511yEo,837
-emu_sv/custom_callback_implementations.py,sha256=_7XLIDzJ-p3DVqz-Jyv0eYbl8nih2x2p-pM4cBCLumA,6367
-emu_sv/dense_operator.py,sha256=GvF0swsiFRqp83bpyaU_CXap2vm74-JLI5lHo-0Hbdk,5901
-emu_sv/density_matrix_state.py,sha256=6QmLZvqEHLR64r0nD7D2jZIiAYOgciNVCjh3ywfvIs0,7243
-emu_sv/hamiltonian.py,sha256=CqNGuWJlO2ZljK47wt130s-5uKiOldQUsC3tjwk1mKA,6106
-emu_sv/lindblad_operator.py,sha256=pgjRNLBcvEM2-qxM8uy9wL74OtrD4A8trQeERi_AXH8,8892
-emu_sv/sparse_operator.py,sha256=xHJapSAKaMCgT5nG0gzMXGk2fCfjHY03OTO_rysszns,7535
-emu_sv/state_vector.py,sha256=v4rqC_qBGc5vO5EMHcHR6BdASjeKujO6_sCdd3pGd0c,9990
-emu_sv/sv_backend.py,sha256=-soOkSEzEBK1dCKnYnbtvYjmNZtZra1_4jP3H1ROOtM,737
-emu_sv/sv_backend_impl.py,sha256=-xWE30B5RI32nOG2pUR8lL3q-wufwvzxegiJexW5g4w,8952
-emu_sv/sv_config.py,sha256=o1esIqflxfN1ZtdwoVBAIWlzZIf9B5X9pvsQe1zHfdg,5433
-emu_sv/time_evolution.py,sha256=Uy3qMdt3BlLB6Aq1-o5uajRTu_3fPuBCtcusHxFPPJc,13545
-emu_sv/utils.py,sha256=t0nMDVo6DF5bQW-vbsyRMCmvkyNxCU-v0Enmns9aOAU,1151
-emu_sv-2.6.0.dist-info/METADATA,sha256=YNa_iPn5JUl5N9FMdaHOwF1Pm000JwsYkLUUcKB-8FQ,3595
-emu_sv-2.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-emu_sv-2.6.0.dist-info/RECORD,,