operations
==========

.. py:module:: quantify_scheduler.qblox.operations 

.. autoapi-nested-parse::

   Module containing qblox specific operations.



Package Contents
----------------

Classes
~~~~~~~

.. autoapisummary::

   quantify_scheduler.qblox.operations.ConditionalReset
   quantify_scheduler.qblox.operations.LatchReset
   quantify_scheduler.qblox.operations.SimpleNumericalPulse




.. py:class:: ConditionalReset(qubit_name: str, name: str = 'conditional_reset', **kwargs)

   Bases: :py:obj:`quantify_scheduler.schedules.schedule.Schedule`


   Reset a qubit to the :math:`|0\rangle` state.

   The
   :class:`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`
   gate is a conditional gate that first measures the state of the qubit using
   an
   :class:`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`
   operation and then performs a :math:`\pi` rotation on the condition that the
   measured state is :math:`|1\rangle`. If the measured state is in
   :math:`|0\rangle`, the hardware will wait the same amount of time the
   :math:`\pi` rotation would've taken to ensure that total execution time of
   :class:`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`
   is the same regardless of the measured state.

   .. note::

       The total time of the the ConditionalReset is the sum of

        1) integration time (<qubit>.measure.integration_time)
        2) acquisition delay (<qubit>.measure.acq_delay)
        3) trigger delay (364ns)
        4) pi-pulse duration (<qubit>.rxy.duration)
        5) idle time (4ns)

   .. note::

       Due to current hardware limitations, overlapping conditional resets
       might not work correctly if multiple triggers are sent within a 364ns
       window. See :ref:`sec-qblox-conditional-playback` for more information.

   .. note::

       :class:`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`
       is currently implemented as a subschedule, but can be added to an
       existing schedule as if it were a gate. See examples below.

   :param name: The name of the conditional subschedule, by default "conditional_reset".
   :type name: str
   :param qubit_name: The name of the qubit to reset to the :math:`|0\rangle` state.
   :type qubit_name: str
   :param \*\*kwargs: Additional keyword arguments are passed to
                      :class:`~quantify_scheduler.operations.gate_library.Measure`. e.g.
                      ``acq_channel``, ``acq_index``, and ``bin_mode``.

   .. rubric:: Examples

   .. admonition:: Examples

       .. jupyter-execute::
           :hide-output:

           from quantify_scheduler.backends.qblox.operations.gate_library import ConditionalReset
           from quantify_scheduler.schedules.schedule import Schedule

           schedule = Schedule("example schedule")
           schedule.add(ConditionalReset("q0"))


.. py:class:: LatchReset(portclock: tuple[str, str], t0: float = 0, duration: float = 4e-09)

   Bases: :py:obj:`quantify_scheduler.operations.operation.Operation`


   Operation that resets the feedback trigger addresses from the hardware.

   Currently only implemented for Qblox backend, refer to
   :class:`~quantify_scheduler.backends.qblox.operation_handling.virtual.ResetFeedbackTriggersStrategy`
   for more details.


.. py:class:: SimpleNumericalPulse(samples: numpy.ndarray | list, port: str, clock: str = BasebandClockResource.IDENTITY, reference_magnitude: quantify_scheduler.operations.pulse_library.ReferenceMagnitude | None = None, t0: float = 0)

   Bases: :py:obj:`quantify_scheduler.operations.pulse_library.NumericalPulse`


   Wrapper on top of NumericalPulse to provide a simple interface for creating a pulse
   where the samples correspond 1:1 to the produced waveform, without needing to specify
   the time samples.


   :param samples: An array of (possibly complex) values specifying the shape of the pulse.
   :param port: The port that the pulse should be played on.
   :param clock: Clock used to (de)modulate the pulse.
                 By default the baseband clock.
   :param reference_magnitude: Scaling value and unit for the unitless samples. Uses settings in
                               hardware config if not provided.
   :param t0: Time in seconds when to start the pulses relative to the start time
              of the Operation in the Schedule.

   .. rubric:: Example

   .. jupyter-execute::

       from quantify_scheduler.backends.qblox.operations.pulse_library import SimpleNumericalPulse
       from quantify_scheduler import Schedule

       waveform = [0.1,0.2,0.2,0.3,0.5,0.4]

       schedule = Schedule("")
       schedule.add(SimpleNumericalPulse(waveform, port="q0:out"))


   .. py:attribute:: samples


   .. py:attribute:: t_samples