Repository: pasqal-io/Pulser (language: python)

Issue:
WIP: simulation with samples from pulser.sampler.sample()
Draft PR for substituting the legacy sampling in the `Simulation` class with the dedicated `pulser.sampler` module.

It is in particular a prerequisite to simulation of modulated sequence (see #315).

Blindly substituting the core of `Simulation._extract_samples()` with `pulser.sampler.sample()` does not work: weirdly the final state of the two simulations differ by the number of levels considered, the new one outputting a 3-level state.
Also, restricted to the first 2 components, they are numerically not the same at 1e-3 accuracy.

I have been unable to pinpoint where the divergence occurs.

Run the notebook `tutorials/simulation_with_sampler.ipynb` to see the issue in action.
New sampler implementation
The following sampler implementation is channel-centric—by opposing to the former one which was qubit centric.

Samples dataclasses are defined in `pulser-core/samples.py`. Samples are extracted at the channel level from the `_ChannelSchedule.get_samples()` method. For the regular user, there is only one function to know, the `sample(seq)` one exposed by the `pulser-core/sampler/` module.

Improvements:
- [x] tests
- [x] creation of `ChannelDrawContent` from `ChannelSamples`.\
There is much more info needed to draw, its a wider scope than the time series, so I am unsure about the right design.
- [ ] method on the `Sequence` class to get samples?
Add option to simulate a Sequence with the modulated output
#312 introduces output modulation into Pulser. The next logical step is to use the expected output to get more reliable results out of a simulation. Important notes:

- The option to choose between using the input or the output samples should be given upon initialization of `Simulation`. For consistency with the current behaviour, the default should be to use the input.
- In principle, this change should only affect the samples that are extracted and used for simulation.
- Considering pulses in isolation can lead to mistakes, because `modulation(pulse1 + pulse2) != modulation(pulse1) + modulation(pulse2)`. 
- The correct approach is to consider the full channel output and modulate that, as is done when drawing the sequence. This is fine for global channels, but can be tricky to do for local channels because the samples are separated according to the target qubit. Note, however, that a sequence of pulses in between two target operations can be safely considered in isolation because the necessary fall time is included.


Discussion / hints:


Modulation is now handled at the sampler level with the merging of #345.
Issue #349 tracks the progress of using the sampler in simulations.

Fix patch:
diff --git a/pulser-core/pulser/sampler/sampler.py b/pulser-core/pulser/sampler/sampler.py
index b9b4f0b1a..e50e57ea8 100644
--- a/pulser-core/pulser/sampler/sampler.py
+++ b/pulser-core/pulser/sampler/sampler.py
@@ -1,26 +1,44 @@
 """Defines the main function for sequence sampling."""
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
-from pulser.sampler.samples import SequenceSamples
+from pulser.sampler.samples import SequenceSamples, _SlmMask
 
 if TYPE_CHECKING:  # pragma: no cover
     from pulser import Sequence
 
 
-def sample(seq: Sequence, modulation: bool = False) -> SequenceSamples:
+def sample(
+    seq: Sequence,
+    modulation: bool = False,
+    extended_duration: Optional[int] = None,
+) -> SequenceSamples:
     """Construct samples of a Sequence.
 
     Args:
         seq: The sequence to sample.
         modulation: Whether to modulate the samples.
+        extended_duration: If defined, extends the samples duration to the
+            desired value.
     """
+    samples_list = [
+        ch_schedule.get_samples(modulated=modulation)
+        for ch_schedule in seq._schedule.values()
+    ]
+    if extended_duration:
+        samples_list = [
+            cs.extend_duration(extended_duration) for cs in samples_list
+        ]
+    optionals = {}
+    if seq._slm_mask_targets and seq._slm_mask_time:
+        optionals["_slm_mask"] = _SlmMask(
+            seq._slm_mask_targets,
+            seq._slm_mask_time[1],
+        )
     return SequenceSamples(
         list(seq.declared_channels.keys()),
-        [
-            ch_schedule.get_samples(modulated=modulation)
-            for ch_schedule in seq._schedule.values()
-        ],
+        samples_list,
         seq.declared_channels,
+        **optionals,
     )
diff --git a/pulser-core/pulser/sampler/samples.py b/pulser-core/pulser/sampler/samples.py
index e9e265ee2..e94456253 100644
--- a/pulser-core/pulser/sampler/samples.py
+++ b/pulser-core/pulser/sampler/samples.py
@@ -3,6 +3,7 @@
 
 from collections import defaultdict
 from dataclasses import dataclass, field
+from typing import Optional
 
 import numpy as np
 
@@ -69,6 +70,14 @@ class _TargetSlot:
     targets: set[QubitId]
 
 
+@dataclass
+class _SlmMask:
+    """Auxiliary class to store the SLM mask configuration."""
+
+    targets: set[QubitId] = field(default_factory=set)
+    end: int = 0
+
+
 @dataclass
 class ChannelSamples:
     """Gathers samples of a channel."""
@@ -100,8 +109,8 @@ def extend_duration(self, new_duration: int) -> ChannelSamples:
         Returns:
             The extend channel samples.
         """
-        extension = new_duration - len(self.amp)
-        if new_duration < self.duration:
+        extension = new_duration - self.duration
+        if extension < 0:
             raise ValueError("Can't extend samples to a lower duration.")
 
         new_amp = np.pad(self.amp, (0, extension))
@@ -113,7 +122,17 @@ def extend_duration(self, new_duration: int) -> ChannelSamples:
         )
         return ChannelSamples(new_amp, new_detuning, new_phase, self.slots)
 
-    def modulate(self, channel_obj: Channel) -> ChannelSamples:
+    def is_empty(self) -> bool:
+        """Whether the channel is effectively empty.
+
+        We consider the channel to be empty if all amplitude and detuning
+        samples are zero.
+        """
+        return np.count_nonzero(self.amp) + np.count_nonzero(self.det) == 0
+
+    def modulate(
+        self, channel_obj: Channel, max_duration: Optional[int] = None
+    ) -> ChannelSamples:
         """Modulates the samples for a given channel.
 
         It assumes that the phase starts at its initial value and is kept at
@@ -122,13 +141,17 @@ def modulate(self, channel_obj: Channel) -> ChannelSamples:
 
         Args:
             channel_obj: The channel object for which to modulate the samples.
+            max_duration: The maximum duration of the modulation samples. If
+                defined, truncates them to have a duration less than or equal
+                to the given value.
 
         Returns:
             The modulated channel samples.
         """
-        new_amp = channel_obj.modulate(self.amp)
-        new_detuning = channel_obj.modulate(self.det)
-        new_phase = channel_obj.modulate(self.phase, keep_ends=True)
+        times = slice(0, max_duration)
+        new_amp = channel_obj.modulate(self.amp)[times]
+        new_detuning = channel_obj.modulate(self.det)[times]
+        new_phase = channel_obj.modulate(self.phase, keep_ends=True)[times]
         return ChannelSamples(new_amp, new_detuning, new_phase, self.slots)
 
 
@@ -139,6 +162,7 @@ class SequenceSamples:
     channels: list[str]
     samples_list: list[ChannelSamples]
     _ch_objs: dict[str, Channel]
+    _slm_mask: _SlmMask = field(default_factory=_SlmMask)
 
     @property
     def channel_samples(self) -> dict[str, ChannelSamples]:
@@ -150,10 +174,24 @@ def max_duration(self) -> int:
         """The maximum duration among the channel samples."""
         return max(samples.duration for samples in self.samples_list)
 
-    def to_nested_dict(self) -> dict:
+    def used_bases(self) -> set[str]:
+        """The bases with non-zero pulses."""
+        return {
+            ch_obj.basis
+            for ch_obj, ch_samples in zip(
+                self._ch_objs.values(), self.samples_list
+            )
+            if not ch_samples.is_empty()
+        }
+
+    def to_nested_dict(self, all_local: bool = False) -> dict:
         """Format in the nested dictionary form.
 
         This is the format expected by `pulser_simulation.Simulation()`.
+
+        Args:
+            all_local: Forces all samples to be distributed by their
+                individual targets, even when applied by a global channel.
         """
         bases = {ch_obj.basis for ch_obj in self._ch_objs.values()}
         in_xy = False
@@ -162,17 +200,33 @@ def to_nested_dict(self) -> dict:
             in_xy = True
         d = _prepare_dict(self.max_duration, in_xy=in_xy)
         for chname, samples in zip(self.channels, self.samples_list):
-            cs = samples.extend_duration(self.max_duration)
+            cs = (
+                samples.extend_duration(self.max_duration)
+                if samples.duration != self.max_duration
+                else samples
+            )
             addr = self._ch_objs[chname].addressing
             basis = self._ch_objs[chname].basis
-            if addr == _GLOBAL:
-                d[_GLOBAL][basis][_AMP] += cs.amp
-                d[_GLOBAL][basis][_DET] += cs.det
-                d[_GLOBAL][basis][_PHASE] += cs.phase
+            if addr == _GLOBAL and not all_local:
+                start_t = self._slm_mask.end
+                d[_GLOBAL][basis][_AMP][start_t:] += cs.amp[start_t:]
+                d[_GLOBAL][basis][_DET][start_t:] += cs.det[start_t:]
+                d[_GLOBAL][basis][_PHASE][start_t:] += cs.phase[start_t:]
+                if start_t == 0:
+                    # Prevents lines below from running unnecessarily
+                    continue
+                unmasked_targets = cs.slots[0].targets - self._slm_mask.targets
+                for t in unmasked_targets:
+                    d[_LOCAL][basis][t][_AMP][:start_t] += cs.amp[:start_t]
+                    d[_LOCAL][basis][t][_DET][:start_t] += cs.det[:start_t]
+                    d[_LOCAL][basis][t][_PHASE][:start_t] += cs.phase[:start_t]
             else:
                 for s in cs.slots:
                     for t in s.targets:
-                        times = slice(s.ti, s.tf)
+                        ti = s.ti
+                        if t in self._slm_mask.targets:
+                            ti = max(ti, self._slm_mask.end)
+                        times = slice(ti, s.tf)
                         d[_LOCAL][basis][t][_AMP][times] += cs.amp[times]
                         d[_LOCAL][basis][t][_DET][times] += cs.det[times]
                         d[_LOCAL][basis][t][_PHASE][times] += cs.phase[times]
diff --git a/pulser-core/pulser/sequence/_schedule.py b/pulser-core/pulser/sequence/_schedule.py
index f470db7e8..ab1760ae0 100644
--- a/pulser-core/pulser/sequence/_schedule.py
+++ b/pulser-core/pulser/sequence/_schedule.py
@@ -94,19 +94,33 @@ def get_samples(self, modulated: bool = False) -> ChannelSamples:
             amp[s.ti : s.tf] += pulse.amplitude.samples
             det[s.ti : s.tf] += pulse.detuning.samples
             ph_jump_t = self.channel_obj.phase_jump_time
-            t_start = max(0, (s.ti - ph_jump_t))
+            t_start = s.ti - ph_jump_t if ind > 0 else 0
             t_end = (
                 channel_slots[ind + 1].ti - ph_jump_t
                 if ind < len(channel_slots) - 1
                 else dt
             )
             phase[t_start:t_end] += pulse.phase
-            slots.append(_TargetSlot(s.ti, s.tf, s.targets))
+            tf = s.tf
+            if modulated:
+                # Account for the extended duration of the pulses
+                # after modulation, which is at most fall_time
+                fall_time = pulse.fall_time(self.channel_obj)
+                tf += (
+                    min(fall_time, channel_slots[ind + 1].ti - s.tf)
+                    if ind < len(channel_slots) - 1
+                    else fall_time
+                )
+
+            slots.append(_TargetSlot(s.ti, tf, s.targets))
 
         ch_samples = ChannelSamples(amp, det, phase, slots)
 
         if modulated:
-            ch_samples = ch_samples.modulate(self.channel_obj)
+            ch_samples = ch_samples.modulate(
+                self.channel_obj,
+                max_duration=self.get_duration(include_fall_time=True),
+            )
 
         return ch_samples
 
diff --git a/pulser-core/pulser/sequence/_seq_drawer.py b/pulser-core/pulser/sequence/_seq_drawer.py
index 98cd3ea97..6080e70f1 100644
--- a/pulser-core/pulser/sequence/_seq_drawer.py
+++ b/pulser-core/pulser/sequence/_seq_drawer.py
@@ -75,19 +75,20 @@ def get_output_curves(self, ch_obj: Channel) -> list[np.ndarray]:
         mod_samples = self.samples.modulate(ch_obj)
         return self._give_curves_from_samples(mod_samples)
 
-    def get_interpolated_curves(
-        self, sampling_rate: float
+    def interpolate_curves(
+        self, curves: list[np.ndarray], sampling_rate: float
     ) -> list[np.ndarray]:
         """The curves with a fractional sampling rate."""
         indices = np.linspace(
             0,
-            self.samples.duration - 1,
-            int(sampling_rate * (self.samples.duration + 1)),
+            self.samples.duration,
+            num=int(sampling_rate * self.samples.duration),
+            endpoint=False,
             dtype=int,
         )
-        sampled_curves = [curve[indices] for curve in self.get_input_curves()]
+        sampled_curves = [curve[indices] for curve in curves]
         t = np.arange(self.samples.duration)
-        return [CubicSpline(indices, curve)(t) for curve in sampled_curves]
+        return [CubicSpline(indices, sc)(t) for sc in sampled_curves]
 
     def curves_on_indices(self) -> list[int]:
         """The indices of the curves to draw."""
@@ -312,15 +313,15 @@ def phase_str(phi: float) -> str:
         ch_data = data[ch]
         basis = ch_obj.basis
         ys = ch_data.get_input_curves()
-        if sampling_rate:
-            yseff = ch_data.get_interpolated_curves(sampling_rate)
-
         draw_output = draw_modulation and (
             ch_obj.mod_bandwidth or not draw_input
         )
         if draw_output:
             ys_mod = ch_data.get_output_curves(ch_obj)
 
+        if sampling_rate:
+            curves = ys_mod if draw_output else ys
+            yseff = ch_data.interpolate_curves(curves, sampling_rate)
         ref_ys = yseff if sampling_rate else ys
         max_amp = np.max(ref_ys[0])
         max_amp = 1 if max_amp == 0 else max_amp
@@ -357,14 +358,22 @@ def phase_str(phi: float) -> str:
             elif draw_input:
                 ax.fill_between(t, 0, ys[i], color=COLORS[i], alpha=0.3)
             if draw_output:
-                ax.fill_between(
-                    t,
-                    0,
-                    ys_mod[i][:total_duration],
-                    color=COLORS[i],
-                    alpha=0.3,
-                    hatch="////",
-                )
+                if not sampling_rate:
+                    ax.fill_between(
+                        t,
+                        0,
+                        ys_mod[i][:total_duration],
+                        color=COLORS[i],
+                        alpha=0.3,
+                        hatch="////",
+                    )
+                else:
+                    ax.plot(
+                        t,
+                        ys_mod[i][:total_duration],
+                        color=COLORS[i],
+                        linestyle="dotted",
+                    )
             special_kwargs = dict(labelpad=10) if i == 0 else {}
             ax.set_ylabel(LABELS[i], fontsize=14, **special_kwargs)
 
diff --git a/pulser-simulation/pulser_simulation/simconfig.py b/pulser-simulation/pulser_simulation/simconfig.py
index ef748e6ee..489031fb8 100644
--- a/pulser-simulation/pulser_simulation/simconfig.py
+++ b/pulser-simulation/pulser_simulation/simconfig.py
@@ -17,7 +17,7 @@
 
 from dataclasses import dataclass, field
 from sys import version_info
-from typing import Any, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 import qutip
@@ -69,8 +69,10 @@ class SimConfig:
             Useful for cutting down on computing time, but unrealistic.
         temperature: Temperature, set in µK, of the Rydberg array.
             Also sets the standard deviation of the speed of the atoms.
-        laser_waist: Waist of the gaussian laser, set in µm,
-            in global pulses.
+        laser_waist: Waist of the gaussian laser, set in µm, in global
+            pulses.
+        amp_sigma: Dictates the fluctuations in amplitude as a standard
+            deviation of a normal distribution centered in 1.
         solver_options: Options for the qutip solver.
     """
 
@@ -79,11 +81,12 @@ class SimConfig:
     samples_per_run: int = 5
     temperature: float = 50.0
     laser_waist: float = 175.0
+    amp_sigma: float = 5e-2
     eta: float = 0.005
     epsilon: float = 0.01
     epsilon_prime: float = 0.05
     dephasing_prob: float = 0.05
-    solver_options: qutip.Options = None
+    solver_options: Optional[qutip.Options] = None
     spam_dict: dict[str, float] = field(
         init=False, default_factory=dict, repr=False
     )
@@ -92,6 +95,12 @@ class SimConfig:
     )
 
     def __post_init__(self) -> None:
+        if not 0.0 <= self.amp_sigma < 1.0:
+            raise ValueError(
+                "The standard deviation in amplitude (amp_sigma="
+                f"{self.amp_sigma}) must be greater than or equal"
+                " to 0. and smaller than 1."
+            )
         self._process_temperature()
         self._change_attribute(
             "spam_dict",
@@ -118,6 +127,7 @@ def __str__(self, solver_options: bool = False) -> str:
             lines.append(f"SPAM dictionary:       {self.spam_dict}")
         if "doppler" in self.noise:
             lines.append(f"Temperature:           {self.temperature*1.e6}µK")
+            lines.append(f"Amplitude standard dev.:  {self.amp_sigma}")
         if "amplitude" in self.noise:
             lines.append(f"Laser waist:           {self.laser_waist}μm")
         if "dephasing" in self.noise:
diff --git a/pulser-simulation/pulser_simulation/simulation.py b/pulser-simulation/pulser_simulation/simulation.py
index dbb2dfdb5..a20735666 100644
--- a/pulser-simulation/pulser_simulation/simulation.py
+++ b/pulser-simulation/pulser_simulation/simulation.py
@@ -17,9 +17,8 @@
 
 import itertools
 import warnings
-from collections import Counter
+from collections import Counter, defaultdict
 from collections.abc import Mapping
-from copy import deepcopy
 from dataclasses import asdict
 from typing import Any, Optional, Union, cast
 
@@ -28,10 +27,11 @@
 import qutip
 from numpy.typing import ArrayLike
 
+import pulser.sampler as sampler
 from pulser import Pulse, Sequence
 from pulser.register import QubitId
+from pulser.sampler.samples import _TargetSlot
 from pulser.sequence._seq_drawer import draw_sequence
-from pulser.sequence.sequence import _TimeSlot
 from pulser_simulation.simconfig import SimConfig
 from pulser_simulation.simresults import (
     CoherentResults,
@@ -67,6 +67,8 @@ class Simulation:
               those specific times.
 
             - A float to act as a sampling rate for the resulting state.
+        with_modulation: Whether to simulated the sequence with the programmed
+            input or the expected output.
     """
 
     def __init__(
@@ -75,6 +77,7 @@ def __init__(
         sampling_rate: float = 1.0,
         config: Optional[SimConfig] = None,
         evaluation_times: Union[float, str, ArrayLike] = "Full",
+        with_modulation: bool = False,
     ) -> None:
         """Instantiates a Simulation object."""
         if not isinstance(sequence, Sequence):
@@ -100,7 +103,22 @@ def __init__(
         self._interaction = "XY" if self._seq._in_xy else "ising"
         self._qdict = self._seq.qubit_info
         self._size = len(self._qdict)
-        self._tot_duration = self._seq.get_duration()
+        self._modulated = with_modulation
+        if self._modulated and sequence._slm_mask_targets:
+            raise NotImplementedError(
+                "Simulation of sequences combining an SLM mask and output "
+                "modulation is not supported."
+            )
+        self._tot_duration = self._seq.get_duration(
+            include_fall_time=self._modulated
+        )
+        self.samples_obj = sampler.sample(
+            self._seq,
+            modulation=self._modulated,
+            # The samples are extended by 1 to improve the ODE
+            # solver convergence
+            extended_duration=self._tot_duration + 1,
+        )
 
         # Type hints for attributes defined outside of __init__
         self.basis_name: str
@@ -133,6 +151,10 @@ def __init__(
 
         self._bad_atoms: dict[Union[str, int], bool] = {}
         self._doppler_detune: dict[Union[str, int], float] = {}
+        # Stores the qutip operators used in building the Hamiltonian
+        self.operators: dict[str, defaultdict[str, dict]] = {
+            addr: defaultdict(dict) for addr in ["Global", "Local"]
+        }
         # Sets the config as well as builds the hamiltonian
         self.set_config(config) if config else self.set_config(SimConfig())
         if hasattr(self._seq, "_measurement"):
@@ -386,7 +408,8 @@ def draw(
                 to be shown as text on the plot, defaults to False.
             draw_interp_pts: When the sequence has pulses with waveforms
                 of type InterpolatedWaveform, draws the points of interpolation
-                on top of the respective waveforms (defaults to False).
+                on top of the respective waveforms (defaults to False). Can't
+                be used if the sequence is modulated.
             draw_phase_shifts: Whether phase shift and reference
                 information should be added to the plot, defaults to False.
             draw_phase_curve: Draws the changes in phase in its own curve
@@ -400,9 +423,16 @@ def draw(
         See Also:
             Sequence.draw(): Draws the sequence in its current state.
         """
+        if draw_interp_pts and self._modulated:
+            raise ValueError(
+                "Can't draw the interpolation points when the sequence is "
+                "modulated; `draw_interp_pts` must be `False`."
+            )
         draw_sequence(
             self._seq,
             self._sampling_rate,
+            draw_input=not self._modulated,
+            draw_modulation=self._modulated,
             draw_phase_area=draw_phase_area,
             draw_interp_pts=draw_interp_pts,
             draw_phase_shifts=draw_phase_shifts,
@@ -414,116 +444,51 @@ def draw(
 
     def _extract_samples(self) -> None:
         """Populates samples dictionary with every pulse in the sequence."""
-        self.samples: dict[str, dict[str, dict]]
-        if self._interaction == "ising":
-            self.samples = {
-                addr: {basis: {} for basis in ["ground-rydberg", "digital"]}
-                for addr in ["Global", "Local"]
-            }
-        else:
-            self.samples = {addr: {"XY": {}} for addr in ["Global", "Local"]}
-
-        if not hasattr(self, "operators"):
-            self.operators = deepcopy(self.samples)
-
-        def prepare_dict() -> dict[str, np.ndarray]:
-            # Duration includes retargeting, delays, etc.
-            # Also adds extra time step for final instruction
-            return {
-                "amp": np.zeros(self._tot_duration + 1),
-                "det": np.zeros(self._tot_duration + 1),
-                "phase": np.zeros(self._tot_duration + 1),
-            }
+        local_noises = True
+        if set(self.config.noise).issubset({"dephasing", "SPAM"}):
+            local_noises = "SPAM" in self.config.noise and self.config.eta > 0
+        samples = self.samples_obj.to_nested_dict(all_local=local_noises)
 
-        def write_samples(
-            slot: _TimeSlot,
-            samples_dict: Mapping[str, np.ndarray],
+        def add_noise(
+            slot: _TargetSlot,
+            samples_dict: Mapping[QubitId, dict[str, np.ndarray]],
             is_global_pulse: bool,
-            *qid: Union[int, str],
         ) -> None:
             """Builds hamiltonian coefficients.
 
             Taking into account, if necessary, noise effects, which are local
             and depend on the qubit's id qid.
             """
-            _pulse = cast(Pulse, slot.type)
-            noise_det = 0.0
-            noise_amp = 1.0
-            if "doppler" in self.config.noise:
-                noise_det += self._doppler_detune[qid[0]]
-            # Gaussian beam loss in amplitude for global pulses only
-            # Noise is drawn at random for each pulse
-            if "amplitude" in self.config.noise and is_global_pulse:
-                position = self._qdict[qid[0]]
-                r = np.linalg.norm(position)
-                w0 = self.config.laser_waist
-                noise_amp = np.random.normal(1.0, 1.0e-3) * np.exp(
-                    -((r / w0) ** 2)
-                )
-
-            samples_dict["amp"][slot.ti : slot.tf] += (
-                _pulse.amplitude.samples * noise_amp
-            )
-            samples_dict["det"][slot.ti : slot.tf] += (
-                _pulse.detuning.samples + noise_det
+            noise_amp_base = max(
+                0, np.random.normal(1.0, self.config.amp_sigma)
             )
-            samples_dict["phase"][slot.ti : slot.tf] += _pulse.phase
-
-        for channel in self._seq.declared_channels:
-            addr = self._seq.declared_channels[channel].addressing
-            basis = self._seq.declared_channels[channel].basis
-
-            # Case of coherent global simulations
-            if addr == "Global" and (
-                set(self.config.noise).issubset({"dephasing"})
-            ):
-                slm_on = bool(self._seq._slm_mask_targets)
-                for slot in self._seq._schedule[channel]:
-                    if isinstance(slot.type, Pulse):
-                        # If SLM is on during slot, populate local samples
-                        if slm_on and self._seq._slm_mask_time[1] > slot.ti:
-                            samples_dict = self.samples["Local"][basis]
-                            for qubit in slot.targets:
-                                if qubit not in samples_dict:
-                                    samples_dict[qubit] = prepare_dict()
-                                write_samples(
-                                    slot, samples_dict[qubit], True, qubit
-                                )
-                            self.samples["Local"][basis] = samples_dict
-                        # Otherwise, populate corresponding global
-                        else:
-                            slm_on = False
-                            samples_dict = self.samples["Global"][basis]
-                            if not samples_dict:
-                                samples_dict = prepare_dict()
-                            write_samples(slot, samples_dict, True)
-                            self.samples["Global"][basis] = samples_dict
-
-            # Any noise : global becomes local for each qubit in the reg
-            # Since coefficients are modified locally by all noises
-            else:
-                is_global = addr == "Global"
-                samples_dict = self.samples["Local"][basis]
-                for slot in self._seq._schedule[channel]:
-                    if isinstance(slot.type, Pulse):
-                        for qubit in slot.targets:
-                            if qubit not in samples_dict:
-                                samples_dict[qubit] = prepare_dict()
-                            # We don't write samples for badly prep qubits
-                            if not self._bad_atoms[qubit]:
-                                write_samples(
-                                    slot, samples_dict[qubit], is_global, qubit
-                                )
-                self.samples["Local"][basis] = samples_dict
-
-            # Apply SLM mask if it was defined
-            if self._seq._slm_mask_targets and self._seq._slm_mask_time:
-                tf = self._seq._slm_mask_time[1]
-                for qubit in self._seq._slm_mask_targets:
-                    if qubit not in self.samples["Local"][basis]:
-                        continue
-                    for x in ("amp", "det", "phase"):
-                        self.samples["Local"][basis][qubit][x][0:tf] = 0
+            for qid in slot.targets:
+                if "doppler" in self.config.noise:
+                    noise_det = self._doppler_detune[qid]
+                    samples_dict[qid]["det"][slot.ti : slot.tf] += noise_det
+                # Gaussian beam loss in amplitude for global pulses only
+                # Noise is drawn at random for each pulse
+                if "amplitude" in self.config.noise and is_global_pulse:
+                    position = self._qdict[qid]
+                    r = np.linalg.norm(position)
+                    w0 = self.config.laser_waist
+                    noise_amp = noise_amp_base * np.exp(-((r / w0) ** 2))
+                    samples_dict[qid]["amp"][slot.ti : slot.tf] *= noise_amp
+
+        if local_noises:
+            for ch, ch_samples in self.samples_obj.channel_samples.items():
+                addr = self._seq.declared_channels[ch].addressing
+                basis = self._seq.declared_channels[ch].basis
+                samples_dict = samples["Local"][basis]
+                for slot in ch_samples.slots:
+                    add_noise(slot, samples_dict, addr == "Global")
+            # Delete samples for badly prepared atoms
+            for basis in samples["Local"]:
+                for qid in samples["Local"][basis]:
+                    if self._bad_atoms[qid]:
+                        for qty in ("amp", "det", "phase"):
+                            samples["Local"][basis][qid][qty] = 0.0
+        self.samples = samples
 
     def build_operator(self, operations: Union[list, tuple]) -> qutip.Qobj:
         """Creates an operator with non-trivial actions on some qubits.
@@ -613,19 +578,13 @@ def _build_basis_and_op_matrices(self) -> None:
             basis = ["u", "d"]
             projectors = ["uu", "du", "ud", "dd"]
         else:
-            # No samples => Empty dict entry => False
-            if (
-                not self.samples["Global"]["digital"]
-                and not self.samples["Local"]["digital"]
-            ):
+            used_bases = self.samples_obj.used_bases()
+            if "digital" not in used_bases:
                 self.basis_name = "ground-rydberg"
                 self.dim = 2
                 basis = ["r", "g"]
                 projectors = ["gr", "rr", "gg"]
-            elif (
-                not self.samples["Global"]["ground-rydberg"]
-                and not self.samples["Local"]["ground-rydberg"]
-            ):
+            elif "ground-rydberg" not in used_bases:
                 self.basis_name = "digital"
                 self.dim = 2
                 basis = ["g", "h"]
diff --git a/tutorials/advanced_features/Simulating Sequences with Errors and Noise.ipynb b/tutorials/advanced_features/Simulating Sequences with Errors and Noise.ipynb
index 982c0c174..69cac5eb6 100644
--- a/tutorials/advanced_features/Simulating Sequences with Errors and Noise.ipynb
+++ b/tutorials/advanced_features/Simulating Sequences with Errors and Noise.ipynb
@@ -2,7 +2,6 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "91a245c9",
    "metadata": {},
    "source": [
     "# Simulation with Noise and Errors"
@@ -10,7 +9,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67e0251f",
    "metadata": {},
    "source": [
     "## Introduction\n",
@@ -25,13 +23,14 @@
     "\n",
     "- Waist of the laser : For global pulses, the laser amplitude has a Gaussian profile and atoms at the border of the waist feel a slightly lower amplitude than those at the focus.\n",
     "\n",
+    "- Amplitude fluctuations: The `amp_sigma` parameter dictates fluctuations in the laser amplitude from pulse to pulse. \n",
+    "\n",
     "- Dephasing / phase-damping: Each qubit interacts with its environment, and we can model this interaction with random $Z$-rotations on each qubit. Given a dephasing probability $p$, this noise model adds two collapse operators $M_0 = \\sqrt{1-\\frac{p}{2}} \\times \\mathbb{1}$, $M_1 = \\sqrt{\\frac{p}{2}} \\sigma_z = \\sqrt{\\frac{p}{2}} (\\Ket{r}\\Bra{r} - \\Ket{g}\\Bra{g})$ and forces the solver to adopt a density matrix formalism. See [here](https://ocw.mit.edu/courses/nuclear-engineering/22-51-quantum-theory-of-radiation-interactions-fall-2012/lecture-notes/MIT22_51F12_Ch8.pdf) for a more thorough explanation.\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "aee2644a",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -47,7 +46,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "0e7fff3e",
    "metadata": {},
    "source": [
     "## Single atom noisy simulations"
@@ -55,7 +53,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "bafc3de4",
    "metadata": {},
    "source": [
     "### Sequence preparation"
@@ -63,7 +60,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "556360fc",
    "metadata": {},
    "source": [
     "Prepare a single atom:"
@@ -72,7 +68,6 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "46b32aac",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -81,7 +76,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "613dcffc",
    "metadata": {},
    "source": [
     "Act on this atom with a Constant Pulse, such that it oscillates towards the excited Rydberg state and back to the original state (Rabi oscillations):"
@@ -90,14 +84,13 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "id": "e3b15936",
    "metadata": {
     "scrolled": true
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1440x216 with 2 Axes>"
       ]
@@ -117,7 +110,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "8bad66f1",
    "metadata": {},
    "source": [
     "We now run the noiseless simulation, to obtain a `CoherentResults` object in `clean_res`."
@@ -126,7 +118,6 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "id": "a68d7f41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -136,7 +127,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "758ce4c0",
    "metadata": {},
    "source": [
     "Here we obtain the excited population using the projector onto the Rydberg state."
@@ -145,7 +135,6 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "455644d3",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -155,7 +144,6 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "59febbd8",
    "metadata": {},
    "outputs": [
     {
@@ -178,7 +166,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "71a84fc8",
    "metadata": {},
    "source": [
     "### The SimConfig object"
@@ -186,7 +173,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "124ead51",
    "metadata": {},
    "source": [
     "Each simulation has an associated `SimConfig` object, which encapsulates parameters such as noise types, the temperature of the register... You may view it at any time using the following command."
@@ -195,7 +181,6 @@
   {
    "cell_type": "code",
    "execution_count": 7,
-   "id": "1503db35",
    "metadata": {},
    "outputs": [
     {
@@ -215,7 +200,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "cc20da6e",
    "metadata": {},
    "source": [
     "When creating a new `SimConfig`, you may choose several parameters. `'runs'` indicates the number of times a noisy simulation is run to obtain the average result of several simulations, `'samples_per_run'` is the number of delivered samples per run - this has no physical interpretation, this is used simply to cut down on calculation time."
@@ -223,7 +207,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "b4d1a00e",
    "metadata": {},
    "source": [
     "We will also add `SPAM` noise to the simulation by creating a new `SimConfig` object, and assigning it to the `config` field of `sim` via the `Simulation.set_config` setter. We pass noise types as a tuple of strings to a SimConfig object. Possible strings are : `'SPAM', 'dephasing', 'doppler', 'amplitude'`."
@@ -232,7 +215,6 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "id": "73bf2544",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -242,7 +224,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "3bee68fc",
    "metadata": {},
    "source": [
     "We now show the new configuration to have an overview of the changes we made."
@@ -251,7 +232,6 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "id": "19022bb2",
    "metadata": {},
    "outputs": [
     {
@@ -273,7 +253,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "87cf1ac2",
    "metadata": {},
    "source": [
     "Note that `SimConfig.spam_dict` is the spam parameters dictionary. `eta` is the probability of a badly prepared state, `epsilon` the false positive probability, `epsilon_prime` the false negative one."
@@ -281,7 +260,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "8de7b636",
    "metadata": {},
    "source": [
     "When dealing with a `SimConfig` object with different noise parameters from the config in `Simulation.config`, you may \"add\" both configurations together, obtaining a single `SimConfig` with all noises from both configurations - on the other hand, the `runs` and `samples_per_run` will always be updated. This adds simulation parameters to noises that weren't available in the former `Simulation.config`. Noises specified in both `SimConfigs` will keep the noise parameters in `Simulation.config`. Try it out with `Simulation.add_config`:"
@@ -290,7 +268,6 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "id": "2601acb1",
    "metadata": {},
    "outputs": [
     {
@@ -301,9 +278,10 @@
       "----------\n",
       "Number of runs:        50\n",
       "Samples per run:       5\n",
-      "Noise types:           SPAM, dephasing, doppler\n",
+      "Noise types:           SPAM, doppler, dephasing\n",
       "SPAM dictionary:       {'eta': 0.005, 'epsilon': 0.01, 'epsilon_prime': 0.05}\n",
       "Temperature:           1000.0µK\n",
+      "Amplitude standard dev.:  0.05\n",
       "Dephasing probability: 0.05\n"
      ]
     }
@@ -321,7 +299,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "c291268a",
    "metadata": {},
    "source": [
     "Note that we set the temperature in $\\mu K$. We also observe that the `eta` parameter wasn't changed, since both `SimConfig` objects had `'SPAM'` as a noise model already. This feature might be useful when running several simulations with distinct noise parameters to observe the influence of each noise independtly, then wanting to combine noises together without losing your tailored noise parameters."
@@ -329,7 +306,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "9e13d45a",
    "metadata": {},
    "source": [
     "### Setting evaluation times"
@@ -337,7 +313,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "f8d69070",
    "metadata": {},
    "source": [
     "As a `Simulation` field, `eval_times` refers to the times at which the result have to be returned. Choose `'Full'` for all the times the Hamiltonian has been sampled in the sequence, a list of times of your choice (has to be a subset of all times in the simulation), or a real number between $0$ and $1$ to sample the full return times array. Here, we choose to keep $\\frac{8}{10}$ of the Hamiltonian sample times for our evaluation times."
@@ -346,7 +321,6 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "id": "449e2cc1",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -355,7 +329,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "5d0bad77",
    "metadata": {},
    "source": [
     "We now obtain a `NoisyResults` object from our noisy simulation. This object represents the final result as a probability distribution over the sampled bitstrings, rather than a quantum state `QObj` in the `CleanResults` case."
@@ -364,7 +337,6 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "id": "a7d7df94",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -373,7 +345,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "4bdd9d97",
    "metadata": {},
    "source": [
     "### Plotting noisy and clean results"
@@ -381,7 +352,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "d526f555",
    "metadata": {},
    "source": [
     "The new `res` instance has similar methods to the usual `SimResults` object. For example, we can calculate expectation values. Observe how different the Rydberg population in the clean case and noisy case are : we clearly see a damping due to all the noises we added."
@@ -390,12 +360,11 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "id": "3f6c3c74",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -414,7 +383,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "7abb4133",
    "metadata": {},
    "source": [
     "You can also use the `SimResults.plot(obs)` method to plot expectation values of a given observable. Here we compute the `sigma_z` local operator expectation values. You may choose to add error bars using the argument `error_bars = True` (`True` by default for `NoisyResults`.) Be wary that computing the expectation value of non-diagonal operators will raise an error, as `NoisyResults` bitstrings are already projected on the $Z$ basis."
@@ -423,14 +391,13 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "id": "47452cfb",
    "metadata": {
     "scrolled": true
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqCklEQVR4nO3df5RddXnv8fczk8S0Si0LYquEJKAJLajckuFn16JSjMZiybVJIYCt9KrBQCpCFSLtijTtbRGv5saaRlKkl1YhUBA7hWDgRjRt+dFMkBADNz+aJiRoFxEQtQjJZJ77x9572LPnnDN7Zs4++9fntdasnB97zvnu2Tn7Ofv7fb7P19wdERGpr668GyAiIvlSIBARqTkFAhGRmlMgEBGpOQUCEZGam5B3A0br6KOP9hkzZuTdDBGRUtm8efMP3X1Ko+dKFwhmzJhBX19f3s0QESkVM9vb7Dl1DYmI1JwCgYhIzSkQiIjUnAKBiEjNKRCIiNScAoGISM0pEIiI1JwCgYhIzZVuQpkMt+LBHazcsHPY41eeO5Or5szKoUUiUiaW5cI0ZjYXWAl0Aze7+w2J56cBtwK/GG6z1N3XtXrNnp4e18zi5mYsvY89N5yn4CAiQ5jZZnfvafRcZlcEZtYNrALmAPuBTWbW6+5PxTb7E+BOd19tZicC64AZWbWpTq6aM2vwhB8FBxGRRrIcIzgN2OXuu939ILAWmJfYxoFfCG+/Efh+hu0REZEGshwjOAbYF7u/Hzg9sc31wANm9ofA64F3Z9ie0krbzbN574uD/86efmTH2ici5ZZ31tBFwP9x96nAbwF/b2bD2mRmi8ysz8z6Dhw40PFG5u2qObPYc8N5w7p3Vm7YyYyl9zFj6X1cc9cWLrn5UQAuufnRIUEh/q+ISFKWgeBZ4NjY/anhY3EfBu4EcPdHgMnA0ckXcvc17t7j7j1TpjQsp10r8aAQ3Z5+1Os52D8AwKH+AR7d/Tyb977YMDiIiMRlGQg2ATPN7DgzmwQsBHoT2zwDnAtgZr9KEAjq95W/Dc44/igmTQgO58QJXZxx/FE8uvv5YcFBRCQpszECd+83syXAeoLU0FvcfZuZLQf63L0X+CPgb8zsKoKB40s9y3zWkms1BjB7+pF87SNnMH/1w3ztI2cMPj9pQhevHBoYDA5SbEr7lTxkOo8gC3WdRxB187xyaIDJE7s4661H8a3/1/jiKT6WsHnvi8xf/TB3Lz5LA8glo7RfaadW8wjyHiyWlOLdPAcPDbBxxw8BmDwxOISNBpOBwZO/goCINKNAUBLxMYCuLmMgvJI7FAYHEZGxUq2hkoiPASyf93aW37ttsO//8KF0wUD9z+URHw/auOOAjptkSmMEBTPSyTrqN476/v/iA+/gunu2Nnyt5O/Eqf+5uJLjQfHBfx03Gatcag3J2KStERSdGJbfuw1g2AkjCihRUJmx9D5A3yLLoFHar8Z4JEsKBCXX7IQRDyhSLtF4kNJ+pVM0WFxyyUlkUn7ReBAw5CpPJCu6IiiB5LhB1M0DNJxENpJr7toy7HVA3UZF0ijtV0UFJSsKBAUV/9DHu3mSQWH+6ocB2LjjQMOTQ7PBZwjGFV45NKDBxw5odRwirQJxsm5UFPiVCSbtoKyhAmqVNdJI2kySGUvv41PvPYHPP7CdAYdug8OOAkGHxY9Xq2MXf27VQ7uGHLer33MCV5zztqbbiyRpZnHJZFksLlmcTsqhUVFBkXbRmaCAsvzQJwcipVhWPLhjcI0JYPD2xh0HNIAsmdEYQQE1qyQa12wAOU3fcPL1NPhYHGnSfnWspN0UCApqpGJxo50n0CjjpNHgo2Sr0Ypx7QjEyiiS8VAgqIFGGSfQfDKaZCN+HC5a8wiHwxJRUeZXpNlV3YoHdwDD034v6JlK75bvAwrqMjYKBDXQbPBZs1c7a8hxOPxatl6z7K1WqaErN+wcklGkoC7jkelgsZnNNbPtZrbLzJY2eH6FmT0R/uwwsx9l2Z66ig8+H3b43PrtALwSVi09/+S36MTRAUOSALptMGurWfbWVXNmseeG87jy3JlDHo+CQ3SFoIwiGTd3z+SHYHnKfweOByYBW4ATW2z/hwTLWbZ83dmzZ3uVfeGB7T792nuH/Xzhge3jet2+PS/49Gvv9b49Lwx5fPq1947rdWV04schfnuk45B8Pnm/2fEViRAsEdzwvJpl19BpwC533w1gZmuBecBTTba/CPhMhu0ptKxniGqlsmJodBzacUx0fMunSLPCswwExwD7Yvf3A6c32tDMpgPHAd9q8vwiYBHAtGnT2tvKgkhbflqqZ7QZP8oQqoYifeaLMqFsIXCXux9u9KS7r3H3HnfvmTJlSoebJpKteEZXPK20kWQG2Ejbi6SR5RXBs8CxsftTw8caWQhckWFbJGY8k9Gk/UbK+IlfAWjRGslCloFgEzDTzI4jCAALgYuTG5nZrwBHAo9k2JZCSlORst3voZN+PlqVEh8IM0nNbFjGT/IKYNn7TxqS9rv3+f8a8lo6vjIWmQUCd+83syXAeoIMolvcfZuZLScYve4NN10IrA1HtWulUR9htBZxu/p/tVJZvtIMCEbH/I7Lzhx2zJNXAC++fHBY+ZEbF5yc/Y5IZoow5pPphDJ3XwesSzy2LHH/+izbUCbNas5LeaUZEGyV8dNo2UplCBXPWDOAivKZ18ziAlH/rySlKUAo+RtrBlBRPvMKBAWiRculEV0BlFOaq4SifOaLkj5aa/EUQNWcF6mGqERIdHUQ3Y53FSXXB6nkGIGMrFll0E7/hyjSLMcqajQgONqMLmWAVVMRrvgUCHKW5bKUo1GkWY5V02xAcLQZXcoAy1eadO8LeqYCw0uFR79f1OOnrqGcqXJk9Y012DdbtjKqOiqd1ayrJ7p99+KzBteFmDyxi7sXnzX4XPT7RaUrgpwVLSuk2eIn6n4Yu7EOCOoKoFyaBfwizBMYia4ICqAIfYSR6MTTaoBLRqcoA4KSrWZX9yPVhop/+Yr/dPLKT1cEBVKEUgGN1tSV8StSsJdsNLu6bzZPoEgJGgoEBZL3AG1yUFPKpUgnlipp9ne95q4tXHhqUBY/6vaJB/zoy9SE7i4O9g/vFmzU9Tdj6X25HCsFAhmU7OOU5op40lXmVzaSf9fJE4Pxnm9891m+8UQwOJwsDxH/UkVYRq3I3YIKBDIoPqjZ3WUcPuyFHuDKk0669TX4ZemwA8FJPtntE/9SdTgsL1vkz5ECQY6KNkEo3seJGeAqfieSMJgB1m1g1rDbJ5kpdvjQQMO5BckqtNG/nf68KRDkqIjpgdF/wP7D+RfCqoKiBXsZv+jL0u2LzgRomPqdHDiev/rhwavGRleQeVchVSCQhopQCKsK8gj2mguSrUYZYBt3HAiupEPxv32aE3reVUgzDQRmNhdYSbAwzc3ufkODbS4ArifobNvi7sNWMZPOK9IkNxmds2dNYeWGndy9+Kwh30RlfFqlVjcL+I26gxrJuwppZhPKzKwbWAW8DzgRuMjMTkxsMxP4NPDr7n4S8Ims2iOjo7z3dIo270IpwNkYy981eWUWLxeSlPekwyyvCE4Ddrn7bgAzWwvMA56KbfNRYJW7vwjg7s9l2B4Zg5EGuOos737dRpQCnI2x/F2vmjOLlRt2DrsiaxUM4v9GOpGqnGUgOAbYF7u/Hzg9sc0sADP7V4Luo+vd/ZvJFzKzRcAigGnTpmXS2LobaVBTKZLDPbr7eV49FJwUXjk0MKSPOK9g2ShbRcbvjOOPosuMAXcOh6urN6sEADT9LJ09awowusygTqQq5z1YPAGYCbwLmApsNLN3uPuP4hu5+xpgDUBPT0/tFrnvhCLNciyLM44/iteFk4uiSUZ5B8tG2SoyfrOnH8kdl53J/NUPc/fis0Y8iTf63BTxCjKSZdG5Z4FjY/enho/F7Qd63f2Qu/8HsIMgMEhOmpU+luGS/bpFkTy5FGX8ouzGO25WlLVHGkl9RWBmP+/uL4/itTcBM83sOIIAsBBIZgR9A7gI+FszO5qgq2j3KN5D2my82Q91U+RB9aJ++6yrZplBRZhrMmIgMLOzgJuBNwDTzOxk4DJ3v7zV77l7v5ktAdYT9P/f4u7bzGw50OfuveFz7zGzp4DDwKfcvThhMiNFrFMj7VGkwfU889JluGbVSYswsTTNFcEK4L1AL4C7bzGzs9O8uLuvA9YlHlsWu+3A1eFPbZStTk0ZFtYoilazRztNkwKLZzxXkFl+DlN1Dbn7PjOLP3S4ra2QwiryAFeRFCFYJq80Xwkzhs4/+S06ZqPUan3iLLtumr3vBT1TB5fBzOJzmCYQ7Au7h9zMJgJXAk+3rQVSaHlPfS+q5Ac2ys658KZHuOOyM3NpU7PMrzv79nNn3/4hj6sbsrW8rtqbve+qh3Zl+jlMEwg+RlAm4hiCQd8HgCva1gIptLynvhdV/AO76qFdfP6B7Qw4uHuhskGgWN1VMjZZfw5HTB919x+6+yXu/kvu/iZ3/2AdBnQ7oWjlCRrJe+p7GSTXqj3y5ycBxT6u0lnN0rLTrkuc9ecwTdbQ3xKtvhDj7v+jrS2pmTL1vRc5RbII4tkgy95/Esvv3QYU/7hK57QjMyjLz2GarqF7Y7cnAx8Avt/2ltSM+t6rJTp2L758MPfj2iwvXUYvrySATr/viIHA3e+O3zez24F/yaxFNaG+92oqwnFt9O1z894Xmb/6YaUAj0JeV+15vO9YSkzMBN7U7obUjfreq6mIxzV5YtHYRTp5lYTI433TjBH8hGCMwMJ//xO4NuN21ULR+96LMPW9jIp2XNUNOTZ5Xd0l33fv8//VtNJpx8pQu/sRbXknKZ0iTH0vujL0xxehu6qMmpWEyON9b1xwcqbv2TQQmNkprX7R3R9vf3OkiFQbqbkyFOnL64RWBXld3XX6fVtdEXy+xXMO/Gab2yIFVbbaSDJc0bqrpFiaBgJ3P6eTDRERkXykKjpnZm8nWIB+cvSYu/9dVo2qOg3CVpOOq5RVmqyhzxAsJXkiQUnp9xHMI1AgGCMNwlaTjms5aQws3RXBAuBk4Lvu/gdm9kvAV9O8uJnNJShY1w3c7O43JJ6/FPgcry1h+SV3vzll20VERmWkk340BhZtF23bqau7vK4qLVgbpsUGZv/m7qeZ2WbgHOAnwNPu/isj/F43wRrEcwjWJt4EXOTuT8W2uRTocfclaRvc09PjfX19aTeXNopmp6ZZvFuKodWJD6j1N+FGiQ9VToYws83u3tPouTRXBH1m9ovA3wCbgZ8Cj6T4vdOAXe6+O2zEWmAe8FTL35JCKlORPHnNSN1VygYTSFeG+nJ3/5G7f5ng2/2H3P0PUrz2McC+2P394WNJ883sSTO7y8yObfRCZrbIzPrMrO/AgQMp3lraLa/p9iKSvTSDxb3AWuAf3X1Pm9//n4Db3f1VM7sMuJUG8xPcfQ2wBoKuoTa3IROtlrqD8l1+a3aqBhWrqNHEvxUP7qjf8XT3lj/AbwB/DewF7iIYPJ6c4vfOBNbH7n8a+HSL7buBl0Z63dmzZ3vZTL/23iH/llXfnhd8+rX3et+eF/JuSu7KfiyTqrY/acT3Ofp/XeX/30CfNzmvpuka+o67Xw4cD9wEXAA8lyLGbAJmmtlxZjYJWAj0xjcwszfH7p6P1kIuNM1OlapotDpgnSu0pipDbWY/B8wnWL/4VIIunJbcvR9YAqwnOMHf6e7bzGy5mZ0fbvZxM9tmZluAjwOXjn4XRGQ8yrBkajs1K8td5zGwNGMEdxJkAH0T+BLwHXcfSPPi7r6OYBJa/LFlsdufJugyEpEc1DEbrFniQ53HwNJcEXwFeKu7f8zdH0obBESk+OqYDRYlPgBDTvpFW1Cok9KMEax398OdaEwVRZedtz32zJD7Ul5V6kppdlKssuQqco2er5tURedkbOKX3dfdsxUo5+W3iqm9pgpdKc3SYM8/+S2l25exiu9n/HjWlQJBhuKX3ZEyLhWoYmqvqcKyj43Wl5ix9L7MV8EqouTxrKu0ZaiPAabHt3f3jVk1qirik7Aidbn8roJm35wndBkD7jqWFZCcKHn4UD2DQZqsoc8CFxLUCIrGChxQIBhBfInAv/jAO7junq2l7Eqoq2Yrs0XF96p2LBvNsq16919yGc/5qx/Ou0m5SHNF8N+BE9z91YzbUknRieLi06dx3T1bK3XiqKuqTqyLAl3dCtBt3BHUL4uCQB3HwNIEgt3ARECBQKRCVjy4A3jtxNfoiqBqmiU+ALUKfklpAsHLwBNmtoFYMHD3j2fWKhHJ3NmzprByw85h60tUOSA0S3yo8j6nkWZCWS/wZ8DDBOsRRD8itVCleQORZmUWpJ5GvCJw91vDonFRGN3u7oeybVb5NbsErWP/Y5nFT5gX3vQI/QOvVUEv87FslgYbD3pVGgMZqSw8lPt4jleapSrfRVBkbg9gwLEEi9PkkjWkpSqLoS61+Vc9tIvPP7CdAYdug6vfcwJXnPO2vJs1blGAe+XQAJMndg3OsE0+VqVgEKnbYHhkvEtVfh54j7tvD19sFnA7MLt9TZSyaZZaWTVVXZAnmTY5e/qRrHpoV+kny8nYpBkjmBgFAQB330GQRSRSecm6NFU6MSbTYOtYd0gCaRevvxn4anj/EkB9Mw3Upbukbqo6byCp0VWC1EOaQLAYuIJg4RiAfyZYunJEZjYXWEmwDOXN7n5Dk+3mEyyDeaq7lzbI1KW7RKqr6kGvqoPh45WmDPWr7v4Fd/+d8GdFmlnGZtYNrALeB5wIXGRmJzbY7gjgSuCx0Tdf8lbF1EqpJqXMNtc0EIQrk2FmW83syeRPitc+Ddjl7rvd/SCwFpjXYLs/Az4LvDKG9kuO9MEqpxUP7mDG0vuGpDTPWHrf4EzjqqrjIjxpteoaujL89/1jfO1jgH2x+/uB0+MbmNkpwLHufp+ZfarZC5nZImARwLRp08bYHGm3KpRkrqO6lhWvagZYOzS9InD3H4Q3L3f3vfEf4PLxvrGZdQFfAP5opG3dfY2797h7z5QpU8b71pmrS3dJ1bNM6vrNuaqqnAE2XmkmlD3u7qckHnvS3d85wu+dCVzv7u8N738awN3/Mrz/RuDfgZ+Gv/LLwAvA+a0GjIs+oazRRJ0q/4eLSjIn69VIudQp462uiRxjmlBmZosJvvkfnxgTOAL41xTvuwmYaWbHAc8CC4GLoyfd/SXg6Nj7fRv4ZJmzhqB+3SXRvjWq417Fk0hV1bW7SAKtxghuA+4H/hJYGnv8J+7+wkgv7O79ZrYEWE+QPnqLu28zs+VAn7v3jqPdhVXXfsiq1LKv0zfjqtIxHL2mgSD8xv4ScBGAmb0JmAy8wcze4O7PjPTi7r4OWJd4bFmTbd+VvtnFpUk55aa5IOWnYzh6I84jMLPfNrOdwH8A3yEoPnd/xu0qtapPyhGRakkzs/jPgTOA/+vuv2Zm5wAfzLZZIiLt06wsvLqLAmkCwSF3f97Musysy90fMrP/nXXDpNhaLfmn6ftSNBoMby1NIPiRmb0B2Ah8zcyeA/4r22ZJ0SU/WPG02UtufrT04yN1rUlTpYHWuh7DsUgzj+D1wM8IxhMuAd4IfDVN5lAWijiPoEofnrGq0gIudZsL0kyZB1p1DIdrNY8gzXoEy9x9wN373f1Wd/8icG17m1huV82ZxZ4bzuPKc2cOeXzlhp21mYlapVnGqklTfjqGo5Oma2gOw0/872vwWO1dNWcWKzfsLO23qPGoUtpsXeeCVImO4ei0qj662My2Ar+SqDz6H8DWzjVRyqIqabOqSVN+Ooajk9nMYpEyq0pQqzMdw/RaVR99yd33EKww9kKs8mi/mZ3e7PdEpPzqUkFXAmkGi1fzWoVQwturs2lOuenDI1WgBYfqJ00gMI/lmLr7AOkGmWulzh8e1e2vFmXc1E+aE/puM/s4r10FXA7szq5J5VS38tNxVZq1qVIE5cq4aTaHJ66Ox3C00kwoexPwReA3AQc2AJ9w9+eyb95wRZxQBprAItVSxgWH4hPgyjwZLivjmlDm7s+5+0J3f5O7/5K7X5xXECgypatJlSjjpl7SlKGeZWYbzOx74f13mtmfpHlxM5trZtvNbJeZLW3w/MfMbKuZPWFm/2JmJ45+F4pDHx4RKaM0YwR/A3wKuAnA3Z80s9sIylM3ZWbdwCqCmcn7gU1m1uvuT8U2u83dvxxufz7BYvZzR70XIuOkelFSZ2kCwc+7+7+ZWfyx/hS/dxqwy913A5jZWmAeMBgI3P3Hse1fTzAGIdJxWtWq3BqlbqvqaHppAsEPzeythCdpM1sA/CDF7x0D7Ivd3w8Mm4hmZlcAVwOTCAakhzGzRcAigGnTpqV4a8lD2b5Vp8k4qZsyZk3FU7cvWvMIhF9aq1AOvVPSZA0dD6wBzgJeJFiy8pJwlnGr31sAzHX3j4T3fw843d2XNNn+YuC97v6hVq9bxKyhsp0AO6Fs36qVcVJe8RLoUb+FU/5y6O3WKmtoxCuCsGvn3eG6BF3u/pOU7/sscGzs/tTwsWbWUtIZy1XKoxcpmyHzHroNzDjYX/w5EEWSJmvoKDP7IvDPwLfNbKWZpfnrbgJmmtlxZjYJWAj0Jl47XsD/PEDX6ZIrlQkpn3jq9u2LzuT2jyqNe7TSlJhYCxwA5gMLwtt3jPRL7t4PLAHWA08Dd7r7NjNbHmYIASwxs21m9gTBOEHLbiGRLNW5TEjZxVO3lcY9emkGi9/s7n8Wu//nZnZhmhd393XAusRjy2K3r0zVSimVsq0VG7X364/vr22ZkLJpNi634sEd6qYdgzSB4AEzWwjcGd5fQPAtX2SY5Lfqol+ex9v7D337mNDdpf7lhCImQzRK952x9D4FgTFK0zX0UYJFal4Nf9YCl5nZT8zsxy1/U2qnbJUr4+09POAsmD0VUP9ynNbkrr40tYaOcPcud58Y/nSFjx3h7r/QiUZKeZRtEftke+efEgQCBYHhom/bydTaKCDkERSi90uWQI/fVqAa2YhdQ2b2YXf/Sux+N/An7v6nmbZMSim+iP0rhwaYv/rhIc8XbW5FvL26ChidIsy7uGrOLFZu2Kl5H+OUZozgXDObD3wYOAr4W+A7mbZKSi06mRbhRJGGskzKq2yJCUWVpmvoYuBWYCtwH8FaBJ/MumEiUixFm2OhdN/2SdM1NBO4Ergb+FXg98zsu+7+ctaNK6IiZlBIe0R9y/HbOq6BYfV8yP9beJ1XBWy3NF1D/wRc4e4bLChBejXBrOGTMm1ZQalK5diUIYDqWDYXP+kePBzUJ7vk5kdZ9v7gNJBHUCjTkppFl6bo3C8kykVjZrPcPZeh+CIVnVMgGKpVNc/4kodF+buVITgVRXwp1kgX0NVl9A94bsuzlnFJzbyMqeicmV3j7je6+4/N7Hfd/R9iT18KXNfmdkrJJYvvxU8eRZxcpmKB6cWzqyZNCCbddXUZA+EXySy7ZtIE7CL9vyqjVoPFC2O3P514TquIyYjKNrlMWotOtlFRt+Xz3t6ROSPRhLboKjK6rSDePq0CgTW53eh+7RQtg6KIyja5TNKJAsLFp08brPpZtKs9GZ1Wg8Xe5Haj+7VStno6eWk0WSuvvG+NB2RDczCqoVUgODmsJWTAz8XqChkwOfOWFZjS1tKLnyjyDKDK9qqWMi6pWWRNA4G7d3eyIWWitLWxUQAtp2Yn3fi8i06IX01qoL+90lQfHTMzm2tm281sl5ktbfD81Wb2lJk9aWYbzGx6lu1pl/iKSOoWSk9jBuUUH6yNfpKVSLMu8KZZxNlKM6FsTMLidKuAOcB+YJOZ9br7U7HNvgv0uPvLZrYYuBFItehN3tQ32lqzb5EX9Ezlzr79CqAl1+lv5LqazFZmgQA4Ddjl7rsBzGwtMA8YDATu/lBs+0eBD2bYHumgVieKO/v25/YhVpGyclJ3bLayDATHAPti9/cDp7fY/sPA/Rm2R2qoWbbQhTc9wh2XnalgME7tzsZq9XoqF56dLANBamb2QaAH+I0mzy8CFgFMmzatgy0LtCqdoGyFYktmC3UZDDi4u7oX2qDd2VhpXk/HrP2yDATPAsfG7k8NHxvCzN4N/DHwG+7+aqMXcvc1wBoIag21v6mtKfVw/IqS7qfuBZHhsgwEm4CZZnYcQQBYCFwc38DMfg24CZjr7s9l2BbJWd7pftHYwLL3n8R192xV90KbtXvs5Zq7tgCdT1Gtq8zSR929H1gCrAeeBu50921mttzMzg83+xzwBuAfzOwJM+vNqj3toLIS5RRPPVx+7zZA3Qvt1O7Uzs17X6R3y/cBmDxx+ClKaxG3X6ZjBO6+DliXeGxZ7Pa7s3z/dlJZifJKph5Ke403tbPVGFx0vNQdm61MJ5RViSpplldyIpu013gnCiari969+KzBK4HurqC+pa7Cs1WIrKEyUB5zec2efiTnn/wW7uzbP7iwirK92qdRccFIq2/70PjvH389zADXVXjGFAhSavWfXYrvxgUnc2fffnUxZKTZTPtGGXfNMu8aDTj3H9Zs4k7QdfIoqKyESDaaDTirNlVnKBCISOaiE/ttjz0z5H6k2Ricijt2xoiL1xdN3ovXa0JZuWhBmmyl+fs2Wvg+udh9o22avZ6MTavF6xUIUtDJRGTsVj20i88/sJ2BEU41UWXauxefNeTbv758tUerQKDB4hTynhUrUmbxjLtIdEUwf/XDQ07yeVamrTMFAqkMXbkVUzzj7i8+8I5UJT6KUpuqLhQIpDKiK7fkSWTlhp2s3LBTJ5EcRSf9i0+fxnX3bB1cwxoa1yfSVXhnKRC0oG+Y2cj673rVnFms3LCzZc66ZGekSWQwNF30wpseoT82gKBv/52nQNCCyk9nI+u/q4oD5qvZ8Y1XEo2ni7o7n3rvCVxxzts631gBFAikYuLfNC9a88jgYxqAzE88AES3P7d+++BjmiyWPwWCFLTObTay+LvGv2kePBx0N6hOTT6i45tMB40/r5ItxaBAkNCqf1MnlPbJqqx3o1RF1anpvDTHVyVbikMlJhKSJXE/9d4TCCvhqvx0G2VV1jtKVQTVqcmTyraXS6aBwMzmmtl2M9tlZksbPH+2mT1uZv1mtiDLtozVeGutS2NZ/l2jb5i3f1R1avLS6viueHDH4CpjoBXHiiCzriEz6wZWAXOA/cAmM+t196dimz0DXAp8Mqt2jFU840Tlp9svuUbA/NUPDz7XrrRBdT3kp1XZds0RKJ4sxwhOA3a5+24AM1sLzAMGA4G77wmfK9T6gY36N0EnlHaLrxEw2jTSNLnq0TfOFQ/u0IknBwrE5ZFl19AxwL7Y/f3hY6NmZovMrM/M+g4cONCWxrWi/s3iS47lRLf33HAeV547c8i2KzfsVNeDSAulyBpy9zXAGgiqj2b9fvHMk8P+Ws6zZjy2R7M6MtfctYUbF5w87tdX10O+VCeofLIMBM8Cx8buTw0fK7x4/2azHGgZu/iJOl6HvnfL97nw1Gmj+ntrjkfxKBCXT5aBYBMw08yOIwgAC4GLM3y/tlL/ZmfEu+GSg8bQ+ltkVnMRROoms0Dg7v1mtgRYD3QDt7j7NjNbDvS5e6+ZnQrcAxwJ/LaZ/am7n5RVm9LQZW1nxbvhmtWob6bRWI4CgcjoZTpG4O7rgHWJx5bFbm8i6DIqDF3WdlYyzTCSpqsnHkQ0x0Nk7DSzWHIXP+HHu3pGqh4an0WsbiGRsStF1pBUU7IbLj4+kLarR2M5IuOnxeulMOIZRNF4wezpR6aaPBbRWI5IY1q8vgWtQlYcyfGCjTsODMsiArigZyoXnjpN6b0ibaIrglBUG10nlny0Cshnz5rC/NUPM2lCFwf7B5jUbWDGwf6hVw4i0lyrKwIFApp3SUj+4scmElYFx4Fug6vfo2UORUbSKhAoawjVFiqy+LGJTOw2Jqo0uEjbKBCgNQeKLH5sJnUH1wK3LzpTaw2ItJECAcpHL7L4sbl90ZmDjyltVKR9ap81FNGJpbg27ghKj0cZRFHZj/htZXmJjF3tA4FqCxWXUntFOkNZQyIiNaAJZQn6piki8prKB4JmJ/0LeqbSu+X7mjsgIrVX+ayhq+bM4u7FZzF5YrCrkyd2cffis5h+1Os1d0BEhIwDgZnNNbPtZrbLzJY2eP51ZnZH+PxjZjYji3YkJ4zd/fh+nv3Rz5jQrbkDIiKZBQIz6wZWAe8DTgQuMrMTE5t9GHjR3d8GrAA+m0Vb4pOSDjvc9tgz3PbYM8OWSFzx4I4s3l5EpNCyHCM4Ddjl7rsBzGwtMA94KrbNPOD68PZdwJfMzLyNqUytShirTo2ISLZdQ8cA+2L394ePNdzG3fuBl4BhfTRmtsjM+sys78CBA6NqxFVzZrHnhvPYc8N5XHnuzCHPHXb43PrtuhIQkVorRdaQu68B1kAwj2CsrxOtR7x574s8uvt5zjj+KGUKiUjtZRkIngWOjd2fGj7WaJv9ZjYBeCOQefpOvFaNiEjdZdk1tAmYaWbHmdkkYCHQm9imF/hQeHsB8K12jg+IiMjIMrsicPd+M1sCrAe6gVvcfZuZLQf63L0X+Arw92a2C3iBIFiIiEgHZTpG4O7rgHWJx5bFbr8C/G6WbRARkdYqP7NYRERaUyAQEak5BQIRkZpTIBARqbnSLUxjZgeAvWP89aOBH7axOWWgfa4H7XM9jGefp7v7lEZPlC4QjIeZ9TVboaeqtM/1oH2uh6z2WV1DIiI1p0AgIlJzdQsEa/JuQA60z/Wgfa6HTPa5VmMEIiIyXN2uCEREJEGBQESk5ioZCMxsrpltN7NdZra0wfOvM7M7wucfM7MZOTSzrVLs86VmdsDMngh/PpJHO9vFzG4xs+fM7HtNnjcz+2L493jSzE7pdBvbLcU+v8vMXood42WNtisTMzvWzB4ys6fMbJuZXdlgm8oc65T72/7j7O6V+iEoef3vwPHAJGALcGJim8uBL4e3FwJ35N3uDuzzpcCX8m5rG/f5bOAU4HtNnv8t4H7AgDOAx/Jucwf2+V3AvXm3s837/GbglPD2EcCOBv+3K3OsU+5v249zFa8ITgN2uftudz8IrAXmJbaZB9wa3r4LONfMrINtbLc0+1wp7r6RYA2LZuYBf+eBR4FfNLM3d6Z12Uixz5Xj7j9w98fD2z8Bnmb42ueVOdYp97ftqhgIjgH2xe7vZ/gfcnAbd+8HXgKO6kjrspFmnwHmh5fOd5nZsQ2er5K0f5OqOdPMtpjZ/WZ2Ut6NaaewC/fXgMcST1XyWLfYX2jzca5iIJDG/gmY4e7vBB7ktSsiqY7HCerJnAz8FfCNfJvTPmb2BuBu4BPu/uO825O1Efa37ce5ioHgWSD+bXdq+FjDbcxsAvBG4PmOtC4bI+6zuz/v7q+Gd28GZneobXlJ8/+gUtz9x+7+0/D2OmCimR2dc7PGzcwmEpwUv+buX2+wSaWO9Uj7m8VxrmIg2ATMNLPjzGwSwWBwb2KbXuBD4e0FwLc8HIUpqRH3OdFnej5B32OV9QK/H2aUnAG85O4/yLtRWTKzX47GuszsNILPd5m/4BDuz1eAp939C002q8yxTrO/WRznTNcszoO795vZEmA9QTbNLe6+zcyWA33u3kvwh/57M9tFMPi2ML8Wj1/Kff64mZ0P9BPs86W5NbgNzOx2guyJo81sP/AZYCKAu3+ZYK3s3wJ2AS8Df5BPS9snxT4vABabWT/wM2Bhyb/gAPw68HvAVjN7InzsOmAaVPJYp9nfth9nlZgQEam5KnYNiYjIKCgQiIjUnAKBiEjNKRCIiNScAoGISM0pEEitmNlRsaqN/2lmz4a3f2pmf53Re37CzH5/DL83ycw2hpMeRTKj9FGpLTO7Hvipu/+vDN9jAkFJgFPCulaj/f3PEBQU/FrbGycS0hWBCIM13u8Nb19vZrea2T+b2V4z+x0zu9HMtprZN8MSAJjZbDP7jpltNrP1TSpe/ibweBQEzOzbZtYT3j7azPaEt08ys38Lr06eNLOZ4e9/A7gk272XulMgEGnsrQQn8fOBrwIPufs7CGZynhcGg78CFrj7bOAW4H82eJ1fBzaneL+PASvd/b8BPQQVNAG+B5w6jv0QGZH6HkUau9/dD5nZVoKyHd8MH98KzABOAN4OPBiWfekGGtW3eTPp6jo9AvyxmU0Fvu7uOwHc/bCZHTSzI8L69CJtp0Ag0tirAO4+YGaHYrVcBgg+NwZsc/czR3idnwGTE49FiyBNjB5w99vM7DHgPGCdmV3m7t8Kn34d8MrYd0WkNXUNiYzNdmCKmZ0JQengJguEPA28LfFY1NXzLoIrCczseGC3u38R+EfgneHjRwE/dPdDbd8DkZACgcgYhEuCLgA+a2ZbgCeAsxpsej/BWsNx7zazTcC7gRfM7OPABcD3woqTbwf+Ltz2HOC+tu+ASIzSR0UyZmb3ANe4+04z+zbwSXfvS/m7XweWuvuOLNso9aYrApHsLSUYNB6VcJGhbygISNZ0RSAiUnO6IhARqTkFAhGRmlMgEBGpOQUCEZGaUyAQEam5/w8RvEYE9VdOtgAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -449,12 +416,11 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "id": "2e2eb154",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -471,7 +437,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "422ec4e9",
    "metadata": {},
    "source": [
     "## SPAM effects"
@@ -479,7 +444,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "20987d71",
    "metadata": {},
    "source": [
     "Compare both clean and noisy simulations for the default SPAM parameters (taken from [De Léséleuc, et al., 2018](https://arxiv.org/abs/1802.10424))"
@@ -488,14 +452,13 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "id": "226b6667",
    "metadata": {
     "scrolled": true
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -520,7 +483,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "2e18bd3d",
    "metadata": {},
    "source": [
     "We will now modify the *SPAM* dictionary, as below, allowing for more ($40$%) badly prepared atoms."
@@ -529,12 +491,11 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "id": "b4c33a09",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -555,7 +516,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "ed80950b",
    "metadata": {},
    "source": [
     "We can see here that the population doesn't go well above $0.6 = 1 - \\eta$, which is to be expected : badly prepared atoms don't reach state $\\Ket{r}$. We can expect this limit of $0.6$ in the Rydberg population to be more and more respected as the number of runs grows."
@@ -563,7 +523,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "5f9e70bf",
    "metadata": {},
    "source": [
     "### Changing $\\eta$"
@@ -571,7 +530,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "f856f2f6",
    "metadata": {},
    "source": [
     "Let us first initialize all spam error values to $0$. Then, we do a sweep over the parameter $\\eta$, probability of badly prepared states, to notice its effects."
@@ -580,12 +538,11 @@
   {
    "cell_type": "code",
    "execution_count": 18,
-   "id": "f0a44162",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 720x360 with 1 Axes>"
       ]
@@ -611,7 +568,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "fa88078c",
    "metadata": {},
    "source": [
     "As $\\eta$ grows, more qubits are not well-prepared (i.e, pumped into a state different from $\\Ket{g}$) and we stop seeing occupations at all. You may increase the number of runs to smooth the curves."
@@ -619,7 +575,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "46ef2d98",
    "metadata": {},
    "source": [
     "### Changing $\\epsilon$"
@@ -627,7 +582,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "c1579e00",
    "metadata": {},
    "source": [
     "Let's now run a sweep over $\\epsilon$."
@@ -636,7 +590,6 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "id": "2202e805",
    "metadata": {},
    "outputs": [
     {
@@ -667,7 +620,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "04570d01",
    "metadata": {},
    "source": [
     "As more false positives appear, it looks like the system is never captured, so always in a Rydberg state. Note that when $\\eta=0$, the object we obtain is a `CoherentResults` rather than a `NoisyResults`, since in this case, the randomness comes from measurements and the simulation is entirely deterministic. This results in smooth curves rather than scattered dots."
@@ -675,7 +627,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "e2d78da0",
    "metadata": {},
    "source": [
     "### Changing $\\epsilon'$"
@@ -683,7 +634,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "a9b8ef1f",
    "metadata": {},
    "source": [
     "Finally, we run a sweep over $\\epsilon'$."
@@ -692,7 +642,6 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "id": "ceacfe1b",
    "metadata": {},
    "outputs": [
     {
@@ -723,7 +672,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "045815da",
    "metadata": {},
    "source": [
     "As there are more false negatives, all atoms seem to be recaptured, until no Rydberg occupation is detected."
@@ -731,7 +679,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "c2260bb5",
    "metadata": {},
    "source": [
     "## Doppler Noise"
@@ -739,7 +686,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "f22a5e46",
    "metadata": {},
    "source": [
     "As for any noise, Doppler noise is set via a `SimConfig` object. When averaging over several runs, it has the effect of damping the oscillations. Let's increase the number of runs in order to see this and get smoother curves."
@@ -747,7 +693,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "9e3d4834",
    "metadata": {},
    "source": [
     "Note that you may change the standard deviation of the doppler noise, which is $k \\times \\sqrt{k_B T / m}$, where $k$ is the norm of the effective wavevector of the lasers, by changing the temperature field, setting it in $\\mu K$. We'll exaggerate the temperature field here to emphasize the effects of Doppler damping; the default value for temperature is 50$\\mu K$."
@@ -756,7 +701,6 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "id": "fd4baccc",
    "metadata": {},
    "outputs": [
     {
@@ -768,7 +712,8 @@
       "Number of runs:        100\n",
       "Samples per run:       1\n",
       "Noise types:           doppler\n",
-      "Temperature:           5000.0µK\n"
+      "Temperature:           5000.0µK\n",
+      "Amplitude standard dev.:  0.05\n"
      ]
     }
    ],
@@ -782,7 +727,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "962335eb",
    "metadata": {},
    "source": [
     "Let us now simulate the entire sequence with Doppler noise, much like what we did in the SPAM case. We should see damped oscillations if the standard deviation is high enough. This is the case here, as we exaggerated the temperature field."
@@ -791,12 +735,11 @@
   {
    "cell_type": "code",
    "execution_count": 22,
-   "id": "fcf16353",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -816,7 +759,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "78e4c8dc",
    "metadata": {},
    "source": [
     "## Multiple Atoms"
@@ -824,7 +766,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "9885e2bc",
    "metadata": {},
    "source": [
     "We will now run the AFM preparation sequence from the Pulser tutorial with our noise models, and compare the results to the clean case. \n",
@@ -835,7 +776,6 @@
   {
    "cell_type": "code",
    "execution_count": 23,
-   "id": "4f6541ac",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -873,7 +813,6 @@
   {
    "cell_type": "code",
    "execution_count": 24,
-   "id": "cb510f6c",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -890,7 +829,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "32e3a9f5",
    "metadata": {},
    "source": [
     "We now plot the simulation results by sampling the final states."
@@ -899,12 +837,11 @@
   {
    "cell_type": "code",
    "execution_count": 25,
-   "id": "fdc590ac",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1440x360 with 1 Axes>"
       ]
@@ -934,7 +871,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "0510aaad",
    "metadata": {},
    "source": [
     "The bars represent the simulation results as populations of bitstrings. They're colored blue for the noiseless simulation, and orange for the noisy one. We clearly identify the antiferromagnetic state as the most populated one in both cases, but it is slightly less populated in the noisy case, while some other bitstrings, not present in the noiseless case, appear."


Test patch:
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 000000000..adaf1cc2c
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,70 @@
+# Copyright 2022 Pulser Development Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pytest
+
+from pulser.channels import Raman, Rydberg
+from pulser.devices import Device
+
+
+@pytest.fixture
+def mod_device() -> Device:
+    return Device(
+        name="ModDevice",
+        dimensions=3,
+        rydberg_level=70,
+        max_atom_num=2000,
+        max_radial_distance=1000,
+        min_atom_distance=1,
+        _channels=(
+            (
+                "rydberg_global",
+                Rydberg(
+                    "Global",
+                    1000,
+                    200,
+                    clock_period=1,
+                    min_duration=1,
+                    mod_bandwidth=4.0,  # MHz
+                ),
+            ),
+            (
+                "rydberg_local",
+                Rydberg(
+                    "Local",
+                    2 * np.pi * 20,
+                    2 * np.pi * 10,
+                    max_targets=2,
+                    phase_jump_time=0,
+                    fixed_retarget_t=0,
+                    min_retarget_interval=220,
+                    mod_bandwidth=4.0,
+                ),
+            ),
+            (
+                "raman_local",
+                Raman(
+                    "Local",
+                    2 * np.pi * 20,
+                    2 * np.pi * 10,
+                    max_targets=2,
+                    phase_jump_time=0,
+                    fixed_retarget_t=0,
+                    min_retarget_interval=220,
+                    mod_bandwidth=4.0,
+                ),
+            ),
+        ),
+    )
diff --git a/tests/test_sequence_sampler.py b/tests/test_sequence_sampler.py
index 575c39848..4ff9c36d9 100644
--- a/tests/test_sequence_sampler.py
+++ b/tests/test_sequence_sampler.py
@@ -13,7 +13,6 @@
 # limitations under the License.
 from __future__ import annotations
 
-import textwrap
 from copy import deepcopy
 
 import numpy as np
@@ -21,7 +20,6 @@
 
 import pulser
 import pulser_simulation
-from pulser.channels import Rydberg
 from pulser.devices import Device, MockDevice
 from pulser.pulse import Pulse
 from pulser.sampler import sample
@@ -137,7 +135,48 @@ def test_modulation(mod_seq: pulser.Sequence) -> None:
             getattr(input_ch_samples.modulate(chan), qty),
             getattr(output_ch_samples, qty),
         )
-    assert input_ch_samples.modulate(chan).slots == output_ch_samples.slots
+
+
+def test_modulation_local(mod_device):
+    seq = pulser.Sequence(pulser.Register.square(2), mod_device)
+    seq.declare_channel("ch0", "rydberg_local", initial_target=0)
+    ch_obj = seq.declared_channels["ch0"]
+    pulse1 = Pulse.ConstantPulse(500, 1, -1, 0)
+    pulse2 = Pulse.ConstantPulse(200, 2.5, 0, 0)
+    partial_fall = pulse1.fall_time(ch_obj) // 3
+    seq.add(pulse1, "ch0")
+    seq.delay(partial_fall, "ch0")
+    seq.add(pulse2, "ch0")
+    seq.target(1, "ch0")
+    seq.add(pulse1, "ch0")
+
+    input_samples = sample(seq)
+    output_samples = sample(seq, modulation=True)
+    assert input_samples.max_duration == seq.get_duration()
+    assert output_samples.max_duration == seq.get_duration(
+        include_fall_time=True
+    )
+
+    # Check that the target slots account for fall time
+    in_ch_samples = input_samples.channel_samples["ch0"]
+    out_ch_samples = output_samples.channel_samples["ch0"]
+    expected_slots = deepcopy(in_ch_samples.slots)
+    # The first slot should extend to the second
+    expected_slots[0].tf += partial_fall
+    assert expected_slots[0].tf == expected_slots[1].ti
+    # The next slots should fully account for fall time
+    expected_slots[1].tf += pulse2.fall_time(ch_obj)
+    expected_slots[2].tf += pulse1.fall_time(ch_obj)
+
+    assert out_ch_samples.slots == expected_slots
+
+    # Check that the samples are fully extracted to the nested dict
+    samples_dict = output_samples.to_nested_dict()
+    for qty in ("amp", "det", "phase"):
+        combined = sum(
+            samples_dict["Local"]["ground-rydberg"][t][qty] for t in range(2)
+        )
+        np.testing.assert_array_equal(getattr(out_ch_samples, qty), combined)
 
 
 @pytest.fixture
@@ -165,7 +204,6 @@ def seq_with_SLM() -> pulser.Sequence:
     return seq
 
 
-@pytest.mark.xfail(reason="SLM not handled by `sample()` for now")
 def test_SLM_samples(seq_with_SLM):
     pulse = Pulse.ConstantDetuning(BlackmanWaveform(200, np.pi / 2), 0.0, 0.0)
     a_samples = pulse.amplitude.samples
@@ -174,34 +212,20 @@ def z() -> np.ndarray:
         return np.zeros(seq_with_SLM.get_duration())
 
     want: dict = {
-        "Global": {},
+        "Global": {"ground-rydberg": {"amp": z(), "det": z(), "phase": z()}},
         "Local": {
             "ground-rydberg": {
-                "batman": {"amp": z(), "det": z(), "phase": z()},
                 "superman": {"amp": z(), "det": z(), "phase": z()},
             }
         },
     }
-    want["Local"]["ground-rydberg"]["batman"]["amp"][200:400] = a_samples
+    want["Global"]["ground-rydberg"]["amp"][200:400] = a_samples
     want["Local"]["ground-rydberg"]["superman"]["amp"][0:200] = a_samples
-    want["Local"]["ground-rydberg"]["superman"]["amp"][200:400] = a_samples
 
     got = sample(seq_with_SLM).to_nested_dict()
     assert_nested_dict_equality(got, want)
 
 
-slm_reason = textwrap.dedent(
-    """
-If the SLM is on, Global channels decay to local ones in the
-sampler, such that the Global key in the output dict is empty and
-all the samples are written in the Local dict. On the contrary, the
-simulation module use the Local dict only for the first pulse, and
-then write the remaining in the Global dict.
-"""
-)
-
-
-@pytest.mark.xfail(reason=slm_reason)
 def test_SLM_against_simulation(seq_with_SLM):
     assert_same_samples_as_sim(seq_with_SLM)
 
@@ -312,41 +336,3 @@ def mod_seq(mod_device: Device) -> pulser.Sequence:
     )
     seq.measure()
     return seq
-
-
-@pytest.fixture
-def mod_device() -> Device:
-    return Device(
-        name="ModDevice",
-        dimensions=3,
-        rydberg_level=70,
-        max_atom_num=2000,
-        max_radial_distance=1000,
-        min_atom_distance=1,
-        _channels=(
-            (
-                "rydberg_global",
-                Rydberg(
-                    "Global",
-                    1000,
-                    200,
-                    clock_period=1,
-                    min_duration=1,
-                    mod_bandwidth=4.0,  # MHz
-                ),
-            ),
-            (
-                "rydberg_local",
-                Rydberg(
-                    "Local",
-                    2 * np.pi * 20,
-                    2 * np.pi * 10,
-                    max_targets=2,
-                    phase_jump_time=0,
-                    fixed_retarget_t=0,
-                    min_retarget_interval=220,
-                    mod_bandwidth=4.0,
-                ),
-            ),
-        ),
-    )
diff --git a/tests/test_simconfig.py b/tests/test_simconfig.py
index ac64f59f2..9a09325c0 100644
--- a/tests/test_simconfig.py
+++ b/tests/test_simconfig.py
@@ -36,3 +36,7 @@ def test_init():
         SimConfig(temperature=-1.0)
     with pytest.raises(ValueError, match="SPAM parameter"):
         SimConfig(eta=-1.0)
+    with pytest.raises(
+        ValueError, match="The standard deviation in amplitude"
+    ):
+        SimConfig(amp_sigma=-0.001)
diff --git a/tests/test_simresults.py b/tests/test_simresults.py
index c95cf7084..6f83fa9ca 100644
--- a/tests/test_simresults.py
+++ b/tests/test_simresults.py
@@ -45,7 +45,7 @@
 seq.measure("ground-rydberg")
 
 sim = Simulation(seq)
-cfg_noisy = SimConfig(noise=("SPAM", "doppler", "amplitude"))
+cfg_noisy = SimConfig(noise=("SPAM", "doppler", "amplitude"), amp_sigma=1e-3)
 sim_noisy = Simulation(seq, config=cfg_noisy)
 results = sim.run()
 results_noisy = sim_noisy.run()
@@ -152,12 +152,12 @@ def test_get_final_state_noisy():
     assert isdiagonal(final_state)
     res3._meas_basis = "ground-rydberg"
     assert (
-        final_state[0, 0] == 0.06666666666666667 + 0j
-        and final_state[2, 2] == 0.92 + 0j
+        final_state[0, 0] == 0.12 + 0j
+        and final_state[2, 2] == 0.8666666666666667 + 0j
     )
     assert res3.states[-1] == final_state
     assert res3.results[-1] == Counter(
-        {"10": 0.92, "00": 0.06666666666666667, "11": 0.013333333333333334}
+        {"10": 0.8666666666666667, "00": 0.12, "11": 0.013333333333333334}
     )
 
 
@@ -242,7 +242,7 @@ def test_expect_noisy():
     with pytest.raises(ValueError, match="non-diagonal"):
         results_noisy.expect([bad_op])
     op = qutip.tensor([qutip.qeye(2), qutip.basis(2, 0).proj()])
-    assert np.isclose(results_noisy.expect([op])[0][-1], 0.6933333333333334)
+    assert np.isclose(results_noisy.expect([op])[0][-1], 0.7333333333333334)
 
 
 def test_plot():
@@ -285,7 +285,7 @@ def test_sample_final_state():
 def test_sample_final_state_noisy():
     np.random.seed(123)
     assert results_noisy.sample_final_state(N_samples=1234) == Counter(
-        {"00": 140, "01": 227, "10": 221, "11": 646}
+        {"11": 725, "10": 265, "01": 192, "00": 52}
     )
     res_3level = Simulation(
         seq_no_meas_noisy, config=SimConfig(noise=("SPAM", "doppler"), runs=10)
@@ -295,10 +295,10 @@ def test_sample_final_state_noisy():
         final_state.full(),
         np.array(
             [
-                [0.64 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-                [0.0 + 0.0j, 0.14 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-                [0.0 + 0.0j, 0.0 + 0.0j, 0.1 + 0.0j, 0.0 + 0.0j],
-                [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.12 + 0.0j],
+                [0.54 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+                [0.0 + 0.0j, 0.18 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+                [0.0 + 0.0j, 0.0 + 0.0j, 0.18 + 0.0j, 0.0 + 0.0j],
+                [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.1 + 0.0j],
             ]
         ),
     ).all()
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 56493d894..2d950dd90 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -25,53 +25,53 @@
 from pulser.waveforms import BlackmanWaveform, ConstantWaveform, RampWaveform
 from pulser_simulation import SimConfig, Simulation
 
-q_dict = {
-    "control1": np.array([-4.0, 0.0]),
-    "target": np.array([0.0, 4.0]),
-    "control2": np.array([4.0, 0.0]),
-}
-reg = Register(q_dict)
-
-duration = 1000
-pi = Pulse.ConstantDetuning(BlackmanWaveform(duration, np.pi), 0.0, 0)
-twopi = Pulse.ConstantDetuning(BlackmanWaveform(duration, 2 * np.pi), 0.0, 0)
-pi_Y = Pulse.ConstantDetuning(
-    BlackmanWaveform(duration, np.pi), 0.0, -np.pi / 2
-)
-
-seq = Sequence(reg, Chadoq2)
-
-# Declare Channels
-seq.declare_channel("ryd", "rydberg_local", "control1")
-seq.declare_channel("raman", "raman_local", "control1")
-
-d = 0  # Pulse Duration
-
-# Prepare state 'hhh':
-seq.add(pi_Y, "raman")
-seq.target("target", "raman")
-seq.add(pi_Y, "raman")
-seq.target("control2", "raman")
-seq.add(pi_Y, "raman")
-d += 3
-
-prep_state = qutip.tensor([qutip.basis(3, 2) for _ in range(3)])
-
-# Write CCZ sequence:
-seq.add(pi, "ryd", protocol="wait-for-all")
-seq.target("control2", "ryd")
-seq.add(pi, "ryd")
-seq.target("target", "ryd")
-seq.add(twopi, "ryd")
-seq.target("control2", "ryd")
-seq.add(pi, "ryd")
-seq.target("control1", "ryd")
-seq.add(pi, "ryd")
-d += 5
-
-# Add a ConstantWaveform part to testout the drawing procedure
-seq.add(Pulse.ConstantPulse(duration, 1, 0, 0), "ryd")
-d += 1
+
+@pytest.fixture
+def reg():
+    q_dict = {
+        "control1": np.array([-4.0, 0.0]),
+        "target": np.array([0.0, 4.0]),
+        "control2": np.array([4.0, 0.0]),
+    }
+    return Register(q_dict)
+
+
+@pytest.fixture
+def seq(reg):
+    duration = 1000
+    pi = Pulse.ConstantDetuning(BlackmanWaveform(duration, np.pi), 0.0, 0)
+    twopi = Pulse.ConstantDetuning(
+        BlackmanWaveform(duration, 2 * np.pi), 0.0, 0
+    )
+    pi_Y = Pulse.ConstantDetuning(
+        BlackmanWaveform(duration, np.pi), 0.0, -np.pi / 2
+    )
+    seq = Sequence(reg, Chadoq2)
+    # Declare Channels
+    seq.declare_channel("ryd", "rydberg_local", "control1")
+    seq.declare_channel("raman", "raman_local", "control1")
+
+    # Prepare state 'hhh':
+    seq.add(pi_Y, "raman")
+    seq.target("target", "raman")
+    seq.add(pi_Y, "raman")
+    seq.target("control2", "raman")
+    seq.add(pi_Y, "raman")
+
+    # Write CCZ sequence:
+    seq.add(pi, "ryd", protocol="wait-for-all")
+    seq.target("control2", "ryd")
+    seq.add(pi, "ryd")
+    seq.target("target", "ryd")
+    seq.add(twopi, "ryd")
+    seq.target("control2", "ryd")
+    seq.add(pi, "ryd")
+    seq.target("control1", "ryd")
+    seq.add(pi, "ryd")
+
+    # Add a ConstantWaveform part to testout the drawing procedure
+    seq.add(Pulse.ConstantPulse(duration, 1, 0, 0), "ryd")
+    return seq
 
 
 def test_bad_import():
@@ -85,7 +85,7 @@ def test_bad_import():
     assert pulser.simulation.SimConfig is SimConfig
 
 
-def test_initialization_and_construction_of_hamiltonian():
+def test_initialization_and_construction_of_hamiltonian(seq):
     fake_sequence = {"pulse1": "fake", "pulse2": "fake"}
     with pytest.raises(TypeError, match="sequence has to be a valid"):
         Simulation(fake_sequence)
@@ -93,7 +93,7 @@ def test_initialization_and_construction_of_hamiltonian():
     assert sim._seq == seq
     assert sim._qdict == seq.qubit_info
     assert sim._size == len(seq.qubit_info)
-    assert sim._tot_duration == duration * d
+    assert sim._tot_duration == 9000  # seq has 9 pulses of 1µs
     assert sim._qid_index == {"control1": 0, "target": 1, "control2": 2}
 
     with pytest.raises(ValueError, match="too small, less than"):
@@ -131,7 +131,7 @@ def test_initialization_and_construction_of_hamiltonian():
         Simulation(seq_)
 
 
-def test_extraction_of_sequences():
+def test_extraction_of_sequences(seq):
     sim = Simulation(seq)
     for channel in seq.declared_channels:
         addr = seq.declared_channels[channel].addressing
@@ -172,7 +172,7 @@ def test_extraction_of_sequences():
                         ).all()
 
 
-def test_building_basis_and_projection_operators():
+def test_building_basis_and_projection_operators(seq, reg):
     # All three levels:
     sim = Simulation(seq, sampling_rate=0.01)
     assert sim.basis_name == "all"
@@ -211,7 +211,8 @@ def test_building_basis_and_projection_operators():
     # Global ground-rydberg
     seq2 = Sequence(reg, Chadoq2)
     seq2.declare_channel("global", "rydberg_global")
-    seq2.add(pi, "global")
+    pi_pls = Pulse.ConstantDetuning(BlackmanWaveform(1000, np.pi), 0.0, 0)
+    seq2.add(pi_pls, "global")
     sim2 = Simulation(seq2, sampling_rate=0.01)
     assert sim2.basis_name == "ground-rydberg"
     assert sim2.dim == 2
@@ -228,7 +229,7 @@ def test_building_basis_and_projection_operators():
     # Digital
     seq2b = Sequence(reg, Chadoq2)
     seq2b.declare_channel("local", "raman_local", "target")
-    seq2b.add(pi, "local")
+    seq2b.add(pi_pls, "local")
     sim2b = Simulation(seq2b, sampling_rate=0.01)
     assert sim2b.basis_name == "digital"
     assert sim2b.dim == 2
@@ -245,7 +246,7 @@ def test_building_basis_and_projection_operators():
     # Local ground-rydberg
     seq2c = Sequence(reg, Chadoq2)
     seq2c.declare_channel("local_ryd", "rydberg_local", "target")
-    seq2c.add(pi, "local_ryd")
+    seq2c.add(pi_pls, "local_ryd")
     sim2c = Simulation(seq2c, sampling_rate=0.01)
     assert sim2c.basis_name == "ground-rydberg"
     assert sim2c.dim == 2
@@ -262,7 +263,7 @@ def test_building_basis_and_projection_operators():
     # Global XY
     seq2 = Sequence(reg, MockDevice)
     seq2.declare_channel("global", "mw_global")
-    seq2.add(pi, "global")
+    seq2.add(pi_pls, "global")
     sim2 = Simulation(seq2, sampling_rate=0.01)
     assert sim2.basis_name == "XY"
     assert sim2.dim == 2
@@ -281,7 +282,7 @@ def test_building_basis_and_projection_operators():
     )
 
 
-def test_empty_sequences():
+def test_empty_sequences(reg):
     seq = Sequence(reg, MockDevice)
     with pytest.raises(ValueError, match="no declared channels"):
         Simulation(seq)
@@ -383,7 +384,7 @@ def test_add_max_step_and_delays():
     assert np.isclose(occ_auto[-1], 0.5, 1e-4)
 
 
-def test_run():
+def test_run(seq):
     sim = Simulation(seq, sampling_rate=0.01)
     sim.set_config(SimConfig("SPAM", eta=0.0))
     with patch("matplotlib.pyplot.show"):
@@ -434,7 +435,7 @@ def test_run():
         sim.run()
 
 
-def test_eval_times():
+def test_eval_times(seq):
     with pytest.raises(
         ValueError, match="evaluation_times float must be between 0 " "and 1."
     ):
@@ -561,18 +562,26 @@ def test_config():
     )
 
 
-def test_noise():
+def test_noise(seq):
     sim2 = Simulation(
-        seq, sampling_rate=0.01, config=SimConfig(noise=("SPAM"), eta=0.4)
+        seq, sampling_rate=0.01, config=SimConfig(noise=("SPAM"), eta=0.9)
     )
     sim2.run()
     with pytest.raises(NotImplementedError, match="Cannot include"):
         sim2.set_config(SimConfig(noise="dephasing"))
     assert sim2.config.spam_dict == {
-        "eta": 0.4,
+        "eta": 0.9,
         "epsilon": 0.01,
         "epsilon_prime": 0.05,
     }
+    assert sim2.samples["Global"] == {}
+    assert any(sim2._bad_atoms.values())
+    for basis in ("ground-rydberg", "digital"):
+        for t in sim2._bad_atoms:
+            if not sim2._bad_atoms[t]:
+                continue
+            for qty in ("amp", "det", "phase"):
+                assert np.all(sim2.samples["Local"][basis][t][qty] == 0.0)
 
 
 def test_dephasing():
@@ -626,7 +635,7 @@ def test_add_config():
     assert sim.config.laser_waist == 172.0
 
 
-def test_cuncurrent_pulses():
+def test_concurrent_pulses():
     reg = Register({"q0": (0, 0)})
     seq = Sequence(reg, Chadoq2)
 
@@ -920,3 +929,84 @@ def test_effective_size_disjoint():
         assert sim.get_hamiltonian(0) == 0 * sim.build_operator(
             [("I", "global")]
         )
+
+
+def test_simulation_with_modulation(mod_device, reg):
+    seq = Sequence(reg, mod_device)
+    seq.declare_channel("ch0", "rydberg_global")
+    seq.config_slm_mask({"control1"})
+    pulse1 = Pulse.ConstantPulse(120, 1, 0, 2.0)
+    seq.add(pulse1, "ch0")
+
+    with pytest.raises(
+        NotImplementedError,
+        match="Simulation of sequences combining an SLM mask and output "
+        "modulation is not supported.",
+    ):
+        Simulation(seq, with_modulation=True)
+
+    seq = Sequence(reg, mod_device)
+    seq.declare_channel("ch0", "rydberg_global")
+    seq.declare_channel("ch1", "raman_local", initial_target="target")
+    seq.add(pulse1, "ch1")
+    seq.target("control1", "ch1")
+    seq.add(pulse1, "ch1")
+    seq.add(pulse1, "ch0")
+    ch1_obj = seq.declared_channels["ch1"]
+    pulse1_mod_samples = ch1_obj.modulate(pulse1.amplitude.samples)
+    mod_dt = pulse1.duration + pulse1.fall_time(ch1_obj)
+    assert pulse1_mod_samples.size == mod_dt
+
+    sim_config = SimConfig(("amplitude", "doppler"))
+    sim = Simulation(seq, with_modulation=True, config=sim_config)
+
+    assert sim.samples["Global"] == {}  # All samples stored in local
+    raman_samples = sim.samples["Local"]["digital"]
+    # Local pulses
+    for qid, time_slice in [
+        ("target", slice(0, mod_dt)),
+        ("control1", slice(mod_dt, 2 * mod_dt)),
+    ]:
+        np.testing.assert_allclose(
+            raman_samples[qid]["amp"][time_slice], pulse1_mod_samples
+        )
+        np.testing.assert_equal(
+            raman_samples[qid]["det"][time_slice], sim._doppler_detune[qid]
+        )
+        np.testing.assert_equal(
+            raman_samples[qid]["phase"][time_slice], pulse1.phase
+        )
+
+    def pos_factor(qid):
+        r = np.linalg.norm(reg.qubits[qid])
+        w0 = sim_config.laser_waist
+        return np.exp(-((r / w0) ** 2))
+
+    # Global pulse
+    time_slice = slice(2 * mod_dt, 3 * mod_dt)
+    rydberg_samples = sim.samples["Local"]["ground-rydberg"]
+    noise_amp_base = rydberg_samples["target"]["amp"][time_slice] / (
+        pulse1_mod_samples * pos_factor("target")
+    )
+    for qid in reg.qubit_ids:
+        np.testing.assert_allclose(
+            rydberg_samples[qid]["amp"][time_slice],
+            pulse1_mod_samples * noise_amp_base * pos_factor(qid),
+        )
+        np.testing.assert_equal(
+            rydberg_samples[qid]["det"][time_slice], sim._doppler_detune[qid]
+        )
+        np.testing.assert_equal(
+            rydberg_samples[qid]["phase"][time_slice], pulse1.phase
+        )
+
+    with pytest.raises(
+        ValueError,
+        match="Can't draw the interpolation points when the sequence "
+        "is modulated",
+    ):
+        sim.draw(draw_interp_pts=True)
+
+    # Drawing with modulation
+    with patch("matplotlib.pyplot.show"):
+        sim.draw()