iqm-pulse 9.5__py3-none-any.whl → 9.6__py3-none-any.whl

iqm/pulse/gates/measure.py

@@ -573,3 +573,215 @@ class ProbePulse_CustomWaveforms(CustomIQWaveforms):
     @classmethod
     def get_locus_mapping_name(cls, operation_name: str, implementation_name: str) -> str:
         return PROBE_LINES_LOCUS_MAPPING
+
+
+class ProbePulse_CustomWaveforms_noIntegration(CustomIQWaveforms):
+    """Base class for implementing a probe line probe pulse with custom waveforms in the I and Q channels without
+    any integration.
+
+    Similar to the :class:`ProbePulse_CustomWaveforms` except that signal integration is removed.
+    """
+
+    root_parameters = {
+        "frequency": Parameter("", "Readout pulse frequency", "Hz"),
+        "duration": Parameter("", "Readout pulse duration", "s"),
+        "phase": Parameter("", "Readout pulse phase", "rad"),
+        "amplitude_i": Parameter("", "Readout channel I amplitude", ""),
+        "amplitude_q": Parameter("", "Readout channel Q amplitude", ""),
+    }
+
+    def __init__(
+        self, parent: QuantumOp, name: str, locus: Locus, calibration_data: OILCalibrationData, builder: ScheduleBuilder
+    ):
+        super().__init__(parent, name, locus, calibration_data, builder)
+
+        self._multiplexed_timeboxes: dict[tuple[str, str, bool], MultiplexedProbeTimeBox] = {}
+        """Cache for :meth:`probe_timebox`."""
+
+        if len(locus) == 1:  # factorizable gates only need calibration on 1-loci
+            self._probe_line: ProbeChannelProperties = self.builder.channels[
+                self.builder.get_probe_channel(self.locus[0])
+            ]
+            c_freq = self._probe_line.center_frequency
+            if_freq = (calibration_data["frequency"] - c_freq) / self._probe_line.sample_rate
+            self._duration = (
+                self._probe_line.duration_to_int_samples(
+                    self._probe_line.round_duration_to_granularity(calibration_data["duration"])
+                )
+                + self._probe_line.instruction_duration_granularity
+            )
+
+            waveform_params = self.convert_calibration_data(
+                calibration_data,
+                {k: v for k, v in self.parameters.items() if k not in self.root_parameters or k == "duration"},
+                self._probe_line,
+            )
+            root_params = {k: v for k, v in calibration_data.items() if k in self.root_parameters and k != "duration"}
+
+            probe_instruction = self._build_instructions(waveform_params, root_params, if_freq)
+            self._probe_instruction = probe_instruction
+            self._prio_calibration: OILCalibrationData | None = None
+        else:
+            # we need to store the possible cal_data == priority calibration in order to propagate it to the factored
+            # single-component measure calls in :meth:`probe_timebox`
+            self._prio_calibration = calibration_data or None
+
+    def _build_instructions(
+        self, waveform_params: OILCalibrationData, root_params: OILCalibrationData, if_freq: float
+    ) -> IQPulse:
+        """Builds a probe pulse and an acquisition method using the calibration data.
+
+        Subclasses may override this method if needed.
+        """
+        if self.dependent_waves:
+            wave_i = self.wave_i(**waveform_params)
+            wave_q = self.wave_q(**waveform_params)
+        else:
+            wave_i = self.wave_i(**waveform_params["i"])
+            wave_q = self.wave_q(**waveform_params["q"])
+
+        probe_pulse = IQPulse(
+            duration=waveform_params["n_samples"],
+            wave_i=wave_i,
+            wave_q=wave_q,
+            scale_i=root_params["amplitude_i"],
+            scale_q=root_params["amplitude_q"],
+            phase=root_params["phase"],
+            modulation_frequency=if_freq,
+        )
+
+        return probe_pulse
+
+    def probe_timebox(
+        self, key: str = "", feedback_key: str = "", do_acquisition: bool = False
+    ) -> MultiplexedProbeTimeBox:
+        """Returns a "naked" probe timebox that supports convenient multiplexing through
+        ``MultiplexedProbeTimeBox.__add__``.
+
+        This method can be used if the user wants to control the multiplexing explicitly. With two
+        ``MultiplexedProbeTimeBox``es ``A`` and ``B`` the result ``A + B`` has all the ``ReadoutTrigger`` instructions
+        on each probe channel of ``A`` and ``B`` multiplexed together and played simultaneously.
+
+        Args:
+            key: The readout results generated on this trigger will be assigned to
+                ``f"{qubit}__{key}"``, where ``qubit`` goes over the component names in ``self.locus``. If empty,
+                the key `"readout.result"` will be used to maintain backwards compatibility.
+            feedback_key: The signals generated by this measure operation are routed using this key for
+                fast feedback purposes. See :meth:`__call__`.
+            do_acquisition: if False, no acquisitions are added.
+
+        Returns:
+            MultiplexedProbeTimeBox containing the ReadoutTrigger instruction.
+
+        """
+        args = (key, feedback_key, do_acquisition)
+        # additional caching for probe timeboxes due to the fact that both ._call and .time_trace use this
+        if args not in self._multiplexed_timeboxes:
+            if len(self.locus) == 1:
+                multiplexed_iq = MultiplexedIQPulse(
+                    duration=self._probe_instruction.duration,
+                    entries=((self._probe_instruction, 0),),
+                )
+                readout_trigger = ReadoutTrigger(
+                    probe_pulse=multiplexed_iq,
+                    acquisitions=(),
+                    duration=self._duration,
+                )
+                probe_channel = self.builder.get_probe_channel(self.locus[0])
+                try:
+                    drive_channel = self.builder.get_drive_channel(self.locus[0])
+                except KeyError:
+                    drive_channel = ""
+
+                if drive_channel:
+                    # drive channel must be blocked, to prevent DD insertion while measurement is taking place
+                    # unfortunately we must allow for different channel sample rates because of UHFQA
+                    channels = self.builder.channels
+                    drive_channel_props = channels[drive_channel]
+                    rt_duration_in_seconds = channels[probe_channel].duration_to_seconds(readout_trigger.duration)
+                    block_duration = drive_channel_props.duration_to_int_samples(
+                        drive_channel_props.round_duration_to_granularity(
+                            rt_duration_in_seconds, round_up=True, force_min_duration=True
+                        )
+                    )
+                    probe_timebox = MultiplexedProbeTimeBox.from_readout_trigger(
+                        readout_trigger=readout_trigger,
+                        probe_channel=probe_channel,
+                        locus_components=self.locus,
+                        label=f"{self.__class__.__name__} on {self.locus}",
+                        block_channels=[drive_channel],
+                        block_duration=block_duration,
+                    )
+                else:
+                    probe_timebox = MultiplexedProbeTimeBox.from_readout_trigger(
+                        readout_trigger=readout_trigger,
+                        probe_channel=probe_channel,
+                        locus_components=self.locus,
+                        label=f"{self.__class__.__name__} on {self.locus}",
+                    )
+            else:
+                probe_timeboxes = [
+                    self.builder.get_implementation(
+                        self.parent.name, (c,), impl_name=self.name, priority_calibration=self._prio_calibration
+                    ).probe_timebox(key, feedback_key, do_acquisition)
+                    for c in self.locus
+                ]
+                probe_timebox = functools.reduce(lambda x, y: x + y, probe_timeboxes)
+            probe_timebox.neighborhood_components[0] = set(
+                self.locus + (self.builder.chip_topology.component_to_probe_line[self.locus[0]],)
+            )
+
+            self._multiplexed_timeboxes[args] = probe_timebox
+        return self._multiplexed_timeboxes[args]
+
+    def _call(self, key: str = "", feedback_key: str = "") -> TimeBox:
+        """Returns a TimeBox containing the multiplexed simultaneous measurement.
+
+        If ``len(self.locus) == 1``, the TimeBox contains the measurement for just that component, otherwise
+        the measurements of components that belong to the same probeline are multiplexed together.
+
+        The returned :class:`.TimeBox` instances behave like any other TimeBox in scheduling and circuit
+        generation. With measurement TimeBoxes ``A`` and ``B`` the result ``A + B`` first plays the ``ReadoutTrigger``
+        instructions of ``A`` and only then those of ``B`` in each probe channel. If the multiplexing features of
+        :class:`.MultiplexedProbeTimeBox` are needed, the method :meth:`probe_timebox` can be used.
+
+        In scheduling, the returned TimeBox blocks the locus components and the probe
+        lines they are associated with.
+
+        Args:
+            key: Readout results generated on this trigger will be assigned to the acquisition labels
+                ``f"{qubit}__{key}"``, where ``qubit`` goes over the component names in ``self.locus``.
+                If empty, the key ``"readout.result"`` will be used to maintain backwards compatibility.
+            feedback_key: If the readout mode is "threshold", the results generated by this ``measure`` operation
+                are routed using the label ``f"{qubit}__{feedback_key}"`` for fast feedback purposes.
+                The signals are picked up by :class:`.ConditionalInstruction`s that have the same label.
+                The default value ``""`` means the signal is not routed anywhere. TODO: currently the HW does not
+                support multiple feedback keys per drive channel, so the actual key used will be ``FEEDBACK_KEY``
+                whenever any non-empty key is inputted. When the HW is improved, the actual key the user inputs
+                should be passed.
+
+        Returns:
+            TimeBox containing the :class:`.ReadoutTrigger` instruction.
+
+        """
+        final_box = TimeBox.composite(
+            [self.probe_timebox(key=key, feedback_key=feedback_key)], label=f"Readout on {self.locus}"
+        )
+        final_box.neighborhood_components[0] = final_box.children[0].neighborhood_components[0]
+        return final_box
+
+    def duration_in_seconds(self) -> float:
+        probe_timebox = self.probe_timebox()
+        readout_schedule = probe_timebox.atom
+        return readout_schedule.duration_in_seconds(self.builder.channels)
+
+    @classmethod
+    def get_locus_mapping_name(cls, operation_name: str, implementation_name: str) -> str:
+        return SINGLE_COMPONENTS_WITH_READOUT_LOCUS_MAPPING
+
+
+class Probe_Constant(ProbePulse_CustomWaveforms_noIntegration, wave_i=Constant, wave_q=Constant):  # type: ignore[call-arg]
+    """Implementation of a single-qubit projective, dispersive measurement in the Z basis.
+
+    Uses a constant probe pulse.
+    """

{iqm_pulse-9.5.dist-info → iqm_pulse-9.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 9.5
+Version: 9.6
 Summary: A Python-based project for providing interface and implementations for control pulses.
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License

{iqm_pulse-9.5.dist-info → iqm_pulse-9.6.dist-info}/RECORD

@@ -16,7 +16,7 @@ iqm/pulse/gates/default_gates.py,sha256=kLNYjt-ZXYPvfBS1p8pi7e3gZz2UnMSWS4S2Xmj6
 iqm/pulse/gates/delay.py,sha256=nST9dY2JFp_mpKhiSfsYa5yL4hFKcNJSAyCzXjhauQg,3767
 iqm/pulse/gates/enums.py,sha256=ATwb6vZYpfgQ1gQyFPW53JyIKrdAP3FPHm6jV-t9OAk,2532
 iqm/pulse/gates/flux_multiplexer.py,sha256=lnlynR_SWM6Wp7RjVcyParCSNKacKargEC5lLF5jwKU,9692
-iqm/pulse/gates/measure.py,sha256=VlcPufdl3tG2MNcRkUzKjBz5BFqVVqBOCn6-mPTRhoc,29518
+iqm/pulse/gates/measure.py,sha256=izqaO4Pxxb7THJhs6tx3QT_YCFDpdt8Mi30E-gwvM7g,40429
 iqm/pulse/gates/move.py,sha256=yKY-Et4YJV0KmcDwN0yE3oHgDtLL-Xfgy1G_InsJN0U,17182
 iqm/pulse/gates/prx.py,sha256=SaJHcVu-NURUBTF5LtmTwwK1qcCtXA89NA5VwJXBM1o,24504
 iqm/pulse/gates/reset.py,sha256=ZgliZd2yVJZuVyeVt6qnnVTt3CGb-cLCIWmoq4nS4lk,7574
@@ -38,8 +38,8 @@ iqm/pulse/playlist/visualisation/templates/static/logo.png,sha256=rbfQZ6_UEaztpY
 iqm/pulse/playlist/visualisation/templates/static/moment.min.js,sha256=4iQZ6BVL4qNKlQ27TExEhBN1HFPvAvAMbFavKKosSWQ,53324
 iqm/pulse/playlist/visualisation/templates/static/vis-timeline-graph2d.min.css,sha256=svzNasPg1yR5gvEaRei2jg-n4Pc3sVyMUWeS6xRAh6U,19837
 iqm/pulse/playlist/visualisation/templates/static/vis-timeline-graph2d.min.js,sha256=OqCqCyA6JnxPz3PGXq_P_9VuSqWptgNt5Ev3T-xjefQ,570288
-iqm_pulse-9.5.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_pulse-9.5.dist-info/METADATA,sha256=NX869B0rRRNQsZlG_eF1nBj-GejOTkUSAXNdTclcj34,14520
-iqm_pulse-9.5.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_pulse-9.5.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_pulse-9.5.dist-info/RECORD,,
+iqm_pulse-9.6.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_pulse-9.6.dist-info/METADATA,sha256=PvoI-osxl1RWW5_IrkkNTiyl-1SEQYjCPFzWFHPNAaQ,14520
+iqm_pulse-9.6.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_pulse-9.6.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_pulse-9.6.dist-info/RECORD,,