instrument_compilers
====================

.. py:module:: quantify_scheduler.backends.qblox.instrument_compilers 

.. autoapi-nested-parse::

   Compiler classes for Qblox backend.



Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   quantify_scheduler.backends.qblox.instrument_compilers.LocalOscillatorCompiler
   quantify_scheduler.backends.qblox.instrument_compilers.QCMCompiler
   quantify_scheduler.backends.qblox.instrument_compilers.QRMCompiler
   quantify_scheduler.backends.qblox.instrument_compilers.QCMRFCompiler
   quantify_scheduler.backends.qblox.instrument_compilers.QRMRFCompiler
   quantify_scheduler.backends.qblox.instrument_compilers.TimetagModuleCompiler
   quantify_scheduler.backends.qblox.instrument_compilers.ClusterCompiler




.. py:class:: LocalOscillatorCompiler(parent: quantify_scheduler.backends.qblox.compiler_container.CompilerContainer, name: str, total_play_time: float, instrument_cfg: dict[str, Any])


   Bases: :py:obj:`quantify_scheduler.backends.qblox.compiler_abc.InstrumentCompiler`

   Implementation of an :class:`~quantify_scheduler.backends.qblox.compiler_abc.InstrumentCompiler` that compiles for a generic LO. The main
   difference between this class and the other compiler classes is that it doesn't take
   pulses and acquisitions.


   :param parent: Reference to the parent container object.
   :param name: QCoDeS name of the device it compiles for.
   :param total_play_time: Total time execution of the schedule should go on for. This parameter is
                           used to ensure that the different devices, potentially with different clock
                           rates, can work in a synchronized way when performing multiple executions of
                           the schedule.
   :param instrument_cfg: The part of the hardware mapping dict referring to this instrument.

   .. py:property:: frequency
      :type: float | None

      Getter for the frequency.

      :returns: The current frequency.

   .. py:method:: compile(debug_mode, repetitions: int = 1) -> dict[str, Any] | None

      Compiles the program for the LO InstrumentCoordinator component.

      :param debug_mode: Debug mode can modify the compilation process,
                         so that debugging of the compilation process is easier.
      :param repetitions: Number of times execution the schedule is repeated.

      :returns: Dictionary containing all the information the InstrumentCoordinator
                component needs to set the parameters appropriately.



.. py:class:: QCMCompiler(parent: quantify_scheduler.backends.qblox.instrument_compilers.ClusterCompiler, name: str, total_play_time: float, instrument_cfg: dict[str, Any], latency_corrections: dict[str, float] | None = None, distortion_corrections: dict[int, Any] | None = None)


   Bases: :py:obj:`quantify_scheduler.backends.qblox.analog.BasebandModuleCompiler`

   QCM specific implementation of the qblox compiler.

   .. py:attribute:: supports_acquisition
      :value: False

      

   .. py:attribute:: max_number_of_instructions

      

   .. py:attribute:: static_hw_properties

      

   .. py:method:: _configure_hardware_distortion_corrections()

      Assign distortion corrections to settings of instrument compiler.


   .. py:method:: _configure_filter(filt, coefficient, marker_debug_mode_enable)



.. py:class:: QRMCompiler(parent: quantify_scheduler.backends.qblox.instrument_compilers.ClusterCompiler, name: str, total_play_time: float, instrument_cfg: dict[str, Any], latency_corrections: dict[str, float] | None = None, distortion_corrections: dict[int, Any] | None = None)


   Bases: :py:obj:`quantify_scheduler.backends.qblox.analog.BasebandModuleCompiler`

   QRM specific implementation of the qblox compiler.

   .. py:attribute:: supports_acquisition
      :value: True

      

   .. py:attribute:: max_number_of_instructions

      

   .. py:attribute:: static_hw_properties

      


.. py:class:: QCMRFCompiler(parent: quantify_scheduler.backends.qblox.instrument_compilers.ClusterCompiler, name: str, total_play_time: float, instrument_cfg: dict[str, Any], latency_corrections: dict[str, float] | None = None, distortion_corrections: dict[int, Any] | None = None)


   Bases: :py:obj:`quantify_scheduler.backends.qblox.analog.RFModuleCompiler`

   QCM-RF specific implementation of the qblox compiler.

   .. py:attribute:: supports_acquisition
      :value: False

      

   .. py:attribute:: max_number_of_instructions

      

   .. py:attribute:: static_hw_properties

      


.. py:class:: QRMRFCompiler(parent: quantify_scheduler.backends.qblox.instrument_compilers.ClusterCompiler, name: str, total_play_time: float, instrument_cfg: dict[str, Any], latency_corrections: dict[str, float] | None = None, distortion_corrections: dict[int, Any] | None = None)


   Bases: :py:obj:`quantify_scheduler.backends.qblox.analog.RFModuleCompiler`

   QRM-RF specific implementation of the qblox compiler.

   .. py:attribute:: supports_acquisition
      :value: True

      

   .. py:attribute:: max_number_of_instructions

      

   .. py:attribute:: static_hw_properties

      


.. py:class:: TimetagModuleCompiler(parent: ClusterCompiler, name: str, total_play_time: float, instrument_cfg: dict[str, Any], latency_corrections: dict[str, float] | None = None, distortion_corrections: dict[str, Any] | None = None)


   Bases: :py:obj:`quantify_scheduler.backends.qblox.compiler_abc.ClusterModuleCompiler`

   QTM specific implementation of the qblox compiler.

   :param parent: Reference to the parent object.
   :type parent: :class:`quantify_scheduler.backends.qblox.instrument_compilers.ClusterCompiler`
   :param name: Name of the `QCoDeS` instrument this compiler object corresponds to.
   :param total_play_time: Total time execution of the schedule should go on for. This parameter is
                           used to ensure that the different devices, potentially with different clock
                           rates, can work in a synchronized way when performing multiple executions of
                           the schedule.
   :param instrument_cfg: The part of the hardware configuration dictionary referring to this device. This is one
                          of the inner dictionaries of the overall hardware config.
   :param latency_corrections: Dict containing the delays for each port-clock combination. This is specified in
                               the top layer of hardware config.

   .. py:property:: max_number_of_instructions
      :type: int

      The maximum number of Q1ASM instructions supported by this module type.

   .. py:property:: supports_acquisition
      :type: bool

      Specifies whether the device can perform acquisitions.

   .. py:property:: static_hw_properties
      :type: quantify_scheduler.backends.types.qblox.StaticTimetagModuleProperties

      The static properties of the hardware. This effectively gathers all the
      differences between the different modules.

   .. py:method:: _construct_sequencer_compiler(index: int, portclock: tuple[str, str], channel_name: str, sequencer_cfg: dict[str, Any], channel_cfg: dict[str, Any]) -> quantify_scheduler.backends.qblox.timetag.TimetagSequencerCompiler

      Create the sequencer object of the correct sequencer type belonging to the module.


   .. py:method:: prepare() -> None

      Performs the logic needed before being able to start the compilation. In effect,
      this means assigning the pulses and acquisitions to the sequencers and
      calculating the relevant frequencies in case an external local oscillator is
      used.



.. py:class:: ClusterCompiler(parent: quantify_scheduler.backends.qblox.compiler_container.CompilerContainer, name: str, total_play_time: float, instrument_cfg: dict[str, Any], latency_corrections: dict[str, float] | None = None, distortion_corrections: dict[int, Any] | None = None)


   Bases: :py:obj:`quantify_scheduler.backends.qblox.compiler_abc.InstrumentCompiler`

   Compiler class for a Qblox cluster.

   :param parent: Reference to the parent object.
   :param name: Name of the `QCoDeS` instrument this compiler object corresponds to.
   :param total_play_time: Total time execution of the schedule should go on for.
   :param instrument_cfg: The part of the hardware configuration dictionary referring to this device. This is one
                          of the inner dictionaries of the overall hardware config.
   :param latency_corrections: Dict containing the delays for each port-clock combination. This is
                               specified in the top layer of hardware config.

   .. py:attribute:: compiler_classes
      :type: dict[str, type]

      References to the individual module compiler classes that can be used by the
      cluster.

   .. py:method:: add_op_info(port: str, clock: str, op_info: quantify_scheduler.backends.types.qblox.OpInfo) -> None

      Assigns a certain pulse or acquisition to this device.

      :param port: The port this waveform is sent to (or acquired from).
      :param clock: The clock for modulation of the pulse or acquisition. Can be a BasebandClock.
      :param op_info: Data structure containing all the information regarding this specific
                      pulse or acquisition operation.


   .. py:method:: construct_module_compilers() -> dict[str, quantify_scheduler.backends.qblox.analog.AnalogModuleCompiler]

      Constructs the compilers for the modules inside the cluster.

      :returns: A dictionary with the name of the instrument as key and the value its
                compiler.


   .. py:method:: _get_module_distortion_corrections(cfg)


   .. py:method:: prepare() -> None

      Prepares the instrument compiler for compilation by assigning the data.


   .. py:method:: distribute_data() -> None

      Distributes the pulses and acquisitions assigned to the cluster over the
      individual module compilers.


   .. py:method:: compile(debug_mode: bool, repetitions: int = 1) -> dict[str, Any]

      Performs the compilation.

      :param debug_mode: Debug mode can modify the compilation process,
                         so that debugging of the compilation process is easier.
      :param repetitions: Amount of times to repeat execution of the schedule.

      :returns: The part of the compiled instructions relevant for this instrument.