qblox ===== .. py:module:: quantify_scheduler.instrument_coordinator.components.qblox .. autoapi-nested-parse:: Module containing Qblox InstrumentCoordinator Components. Module Contents --------------- Classes ~~~~~~~ .. autoapisummary:: quantify_scheduler.instrument_coordinator.components.qblox._StaticHardwareProperties quantify_scheduler.instrument_coordinator.components.qblox._StaticAnalogModuleProperties quantify_scheduler.instrument_coordinator.components.qblox._StaticTimetagModuleProperties quantify_scheduler.instrument_coordinator.components.qblox._ModuleComponentBase quantify_scheduler.instrument_coordinator.components.qblox._AnalogModuleComponent quantify_scheduler.instrument_coordinator.components.qblox._QCMComponent quantify_scheduler.instrument_coordinator.components.qblox._QRMComponent quantify_scheduler.instrument_coordinator.components.qblox._RFComponent quantify_scheduler.instrument_coordinator.components.qblox._QCMRFComponent quantify_scheduler.instrument_coordinator.components.qblox._QRMRFComponent quantify_scheduler.instrument_coordinator.components.qblox._QTMComponent quantify_scheduler.instrument_coordinator.components.qblox._AcquisitionManagerBase quantify_scheduler.instrument_coordinator.components.qblox._QRMAcquisitionManager quantify_scheduler.instrument_coordinator.components.qblox._QTMAcquisitionManager quantify_scheduler.instrument_coordinator.components.qblox.ClusterComponent Functions ~~~~~~~~~ .. autoapisummary:: quantify_scheduler.instrument_coordinator.components.qblox._supported_bin_modes quantify_scheduler.instrument_coordinator.components.qblox._get_instrument_ip quantify_scheduler.instrument_coordinator.components.qblox._get_configuration_manager quantify_scheduler.instrument_coordinator.components.qblox._download_log Attributes ~~~~~~~~~~ .. autoapisummary:: quantify_scheduler.instrument_coordinator.components.qblox.logger quantify_scheduler.instrument_coordinator.components.qblox._QCM_BASEBAND_PROPERTIES quantify_scheduler.instrument_coordinator.components.qblox._QRM_BASEBAND_PROPERTIES quantify_scheduler.instrument_coordinator.components.qblox._QCM_RF_PROPERTIES quantify_scheduler.instrument_coordinator.components.qblox._QRM_RF_PROPERTIES quantify_scheduler.instrument_coordinator.components.qblox._QTM_PROPERTIES quantify_scheduler.instrument_coordinator.components.qblox._ReadoutModuleComponentT quantify_scheduler.instrument_coordinator.components.qblox.F quantify_scheduler.instrument_coordinator.components.qblox._ClusterModule .. py:data:: logger .. py:class:: _StaticHardwareProperties Dataclass for storing configuration differences across Qblox devices. .. py:attribute:: settings_type :type: Type[quantify_scheduler.backends.types.qblox.BaseModuleSettings] The settings dataclass to use that the hardware needs to configure to. .. py:attribute:: number_of_sequencers :type: int The number of sequencers the hardware has available. .. py:attribute:: number_of_output_channels :type: int The number of physical output channels that can be used. .. py:attribute:: number_of_input_channels :type: int The number of physical input channels that can be used. .. py:class:: _StaticAnalogModuleProperties Bases: :py:obj:`_StaticHardwareProperties` Dataclass for storing configuration differences across Qblox devices. .. py:attribute:: settings_type :type: Type[quantify_scheduler.backends.types.qblox.AnalogModuleSettings] The settings dataclass to use that the hardware needs to configure to. .. py:attribute:: has_internal_lo :type: bool Specifies if an internal lo source is available. .. py:class:: _StaticTimetagModuleProperties Bases: :py:obj:`_StaticHardwareProperties` Dataclass for storing configuration differences across Qblox devices. .. py:attribute:: settings_type :type: Type[quantify_scheduler.backends.types.qblox.TimetagModuleSettings] The settings dataclass to use that the hardware needs to configure to. .. py:data:: _QCM_BASEBAND_PROPERTIES .. py:data:: _QRM_BASEBAND_PROPERTIES .. py:data:: _QCM_RF_PROPERTIES .. py:data:: _QRM_RF_PROPERTIES .. py:data:: _QTM_PROPERTIES .. py:class:: _ModuleComponentBase(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase` Qblox InstrumentCoordinator component base class. .. py:attribute:: _instrument_module .. py:attribute:: _seq_name_to_idx_map .. py:attribute:: _program .. py:attribute:: _nco_frequency_changed :type: dict[int, bool] Private attribute for automatic mixer calibration. The keys are sequencer indices. The `prepare` method resets this to an empty dictionary. .. py:property:: instrument :type: qblox_instruments.qcodes_drivers.module.Module Returns a reference to the module instrument. .. py:method:: _set_parameter(instrument: Union[qblox_instruments.qcodes_drivers.module.Module, qblox_instruments.qcodes_drivers.sequencer.Sequencer], parameter_name: str, val: Any) -> None Set the parameter directly or using the lazy set. :param instrument: The instrument or instrument channel that holds the parameter to set, e.g. `self.instrument` or `self.instrument[f"sequencer{idx}"]`. :param parameter_name: The name of the parameter to set. :param val: The new value of the parameter. .. py:property:: is_running :type: bool Finds if any of the sequencers is currently running. :returns: True if any of the sequencers reports the `SequencerStates.RUNNING` status. .. py:method:: wait_done(timeout_sec: int = 10) -> None Blocks the instrument until all the sequencers are done running. :param timeout_sec: The timeout in seconds. N.B. the instrument takes the timeout in minutes (int), therefore it is rounded down to whole minutes with a minimum of 1. .. py:method:: get_hardware_log(compiled_schedule: quantify_scheduler.schedules.schedule.CompiledSchedule) -> dict | None Retrieve the hardware log of the Qblox instrument associated to this component. This log does not include the instrument serial number and firmware version. :param compiled_schedule: Compiled schedule to check if this component is referenced in. :returns: A dict containing the hardware log of the Qblox instrument, in case the component was referenced; else None. .. py:method:: prepare(program: Dict[str, dict]) -> None Store program containing sequencer settings. .. py:method:: disable_sync() -> None Disable sync for all sequencers. .. py:method:: stop() -> None Stops all execution. .. py:method:: _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.BaseModuleSettings) -> None :abstractmethod: Configures all settings that are set globally for the whole instrument. :param settings: The settings to configure it to. .. py:method:: _configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.SequencerSettings) -> None Configures all sequencer-specific settings. :param seq_idx: Index of the sequencer to configure. :param settings: The settings to configure it to. .. py:method:: arm_all_sequencers_in_program() -> None Arm all the sequencers that are part of the program. .. py:method:: start() -> None Clear data, arm sequencers and start sequencers. .. py:method:: _start_armed_sequencers() Start execution of the schedule: start armed sequencers. .. py:method:: clear_data() -> None Clears remaining data on the module. Module type specific function. .. py:property:: _hardware_properties :type: _StaticHardwareProperties :abstractmethod: Holds all the differences between the different modules. :returns: A dataclass with all the hardware properties for this specific module. .. py:class:: _AnalogModuleComponent(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`_ModuleComponentBase` Qblox InstrumentCoordinator component base class. .. py:method:: _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.AnalogModuleSettings) -> None :abstractmethod: Configures all settings that are set globally for the whole instrument. :param settings: The settings to configure it to. .. py:method:: _configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) -> None Configures all sequencer-specific settings. :param seq_idx: Index of the sequencer to configure. :param settings: The settings to configure it to. .. py:method:: _determine_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) -> Dict[str, str] Returns a dictionary with the channel map parameters for this module. .. py:method:: _determine_output_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings, channel_map_parameters: Dict[str, str]) -> Dict[str, str] Adds the outputs to the channel map parameters dict. .. py:method:: _configure_nco_mixer_calibration(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) -> None .. py:property:: _hardware_properties :type: _StaticAnalogModuleProperties :abstractmethod: Holds all the differences between the different modules. :returns: A dataclass with all the hardware properties for this specific module. .. py:class:: _QCMComponent(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`_AnalogModuleComponent` QCM specific InstrumentCoordinator component. .. py:attribute:: _hardware_properties Holds all the differences between the different modules. :returns: A dataclass with all the hardware properties for this specific module. .. py:method:: retrieve_acquisition() -> None Retrieves the previous acquisition. :returns: QCM returns None since the QCM has no acquisition. .. py:method:: prepare(program: Dict[str, dict]) -> None Uploads the waveforms and programs to the sequencers. All the settings that are required are configured. Keep in mind that values set directly through the driver may be overridden (e.g. the offsets will be set according to the specified mixer calibration parameters). :param program: Program to upload to the sequencers. Under the key :code:`"sequencer"` you specify the sequencer specific options for each sequencer, e.g. :code:`"seq0"`. For global settings, the options are under different keys, e.g. :code:`"settings"`. .. py:method:: _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.AnalogModuleSettings) Configures all settings that are set globally for the whole instrument. :param settings: The settings to configure it to. .. py:class:: _QRMComponent(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`_AnalogModuleComponent` QRM specific InstrumentCoordinator component. .. py:attribute:: _hardware_properties Holds all the differences between the different modules. :returns: A dataclass with all the hardware properties for this specific module. .. py:attribute:: _acquisition_manager :type: Optional[_QRMAcquisitionManager] :value: None Holds all the acquisition related logic. .. py:method:: retrieve_acquisition() -> Optional[xarray.Dataset] Retrieves the latest acquisition results. :returns: The acquired data. .. py:method:: prepare(program: Dict[str, dict]) -> None Uploads the waveforms and programs to the sequencers. All the settings that are required are configured. Keep in mind that values set directly through the driver may be overridden (e.g. the offsets will be set according to the specified mixer calibration parameters). :param program: Program to upload to the sequencers. Under the key :code:`"sequencer"` you specify the sequencer specific options for each sequencer, e.g. :code:`"seq0"`. For global settings, the options are under different keys, e.g. :code:`"settings"`. .. py:method:: _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.AnalogModuleSettings) Configures all settings that are set globally for the whole instrument. :param settings: The settings to configure it to. .. py:method:: _configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) -> None Configures all sequencer-specific settings. :param seq_idx: Index of the sequencer to configure. :param settings: The settings to configure it to. .. py:method:: _determine_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) -> Dict[str, str] Returns a dictionary with the channel map parameters for this module. .. py:method:: _determine_input_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings, channel_map_parameters: Dict[str, str]) -> Dict[str, str] Adds the inputs to the channel map parameters dict. .. py:method:: _determine_scope_mode_acquisition_sequencer_and_qblox_acq_index(acquisition_metadata: Dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata]) -> Optional[Tuple[int, int]] Finds the sequencer and qblox_acq_index that performs the raw trace acquisition. Raises an error if multiple scope mode acquisitions are present per sequencer. Note, that compiler ensures there is at most one scope mode acquisition, however the user is able to freely modify the compiler program, so we make sure this requirement is still satisfied. See :func:`~quantify_scheduler.backends.qblox.analog.AnalogModuleCompiler._ensure_single_scope_mode_acquisition_sequencer`. :param acquisition_metadata: The acquisition metadata for each sequencer. :returns: The sequencer and qblox_acq_channel for the trace acquisition, if there is any, otherwise None, None. .. py:method:: clear_data() -> None Clears remaining data on the module. Module type specific function. .. py:class:: _RFComponent(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`_AnalogModuleComponent` Mix-in for RF-module-specific InstrumentCoordinatorComponent behaviour. .. py:method:: prepare(program: Dict[str, dict]) -> None Uploads the waveforms and programs to the sequencers. Overrides the parent method to additionally set LO settings for automatic mixer calibration. This must be done _after_ all NCO frequencies have been set. :param program: Program to upload to the sequencers. Under the key :code:`"sequencer"` you specify the sequencer specific options for each sequencer, e.g. :code:`"seq0"`. For global settings, the options are under different keys, e.g. :code:`"settings"`. .. py:method:: _configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) -> None Configures all sequencer-specific settings. :param seq_idx: Index of the sequencer to configure. :param settings: The settings to configure it to. .. py:method:: _determine_output_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings, channel_map_parameters: Dict[str, str]) -> Dict[str, str] Adds the outputs to the channel map parameters dict. .. py:method:: _get_connected_lo_idx_for_sequencer(sequencer_settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) -> list[int] Looks at the connected _output_ ports of the sequencer (if any) to determine which LO this sequencer's output is coupled to. .. py:method:: _configure_lo_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings, lo_idx_to_connected_seq_idx: dict[int, list[int]]) -> None :abstractmethod: Configure the settings for LO frequency and automatic mixer calibration. .. py:class:: _QCMRFComponent(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`_RFComponent`, :py:obj:`_QCMComponent` QCM-RF specific InstrumentCoordinator component. .. py:attribute:: _hardware_properties Holds all the differences between the different modules. :returns: A dataclass with all the hardware properties for this specific module. .. py:method:: _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings) Configures all settings that are set globally for the whole instrument. :param settings: The settings to configure it to. .. py:method:: _configure_lo_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings, lo_idx_to_connected_seq_idx: dict[int, list[int]]) -> None Configure the settings for LO frequency and automatic mixer calibration. .. py:class:: _QRMRFComponent(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`_RFComponent`, :py:obj:`_QRMComponent` QRM-RF specific InstrumentCoordinator component. .. py:attribute:: _hardware_properties Holds all the differences between the different modules. :returns: A dataclass with all the hardware properties for this specific module. .. py:method:: _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings) Configures all settings that are set globally for the whole instrument. :param settings: The settings to configure it to. .. py:method:: _configure_lo_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings, lo_idx_to_connected_seq_idx: dict[int, list[int]]) -> None Configure the settings for LO frequency and automatic mixer calibration. .. py:method:: _determine_input_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings, channel_map_parameters: Dict[str, str]) -> Dict[str, str] Adds the inputs to the channel map parameters dict. .. py:class:: _QTMComponent(instrument: qblox_instruments.qcodes_drivers.module.Module) Bases: :py:obj:`_ModuleComponentBase` QTM specific InstrumentCoordinator component. .. py:attribute:: _hardware_properties Holds all the differences between the different modules. :returns: A dataclass with all the hardware properties for this specific module. .. py:attribute:: _acquisition_manager :type: _QTMAcquisitionManager | None :value: None Holds all the acquisition related logic. .. py:method:: retrieve_acquisition() -> Optional[xarray.Dataset] Retrieves the latest acquisition results. :returns: The acquired data. .. py:method:: prepare(program: Dict[str, dict]) -> None Uploads the waveforms and programs to the sequencers. All the settings that are required are configured. Keep in mind that values set directly through the driver may be overridden (e.g. the offsets will be set according to the specified mixer calibration parameters). :param program: Program to upload to the sequencers. Under the key :code:`"sequencer"` you specify the sequencer specific options for each sequencer, e.g. :code:`"seq0"`. For global settings, the options are under different keys, e.g. :code:`"settings"`. .. py:method:: _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.TimetagModuleSettings) Configures all settings that are set globally for the whole instrument. :param settings: The settings to configure it to. .. py:method:: _configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.TimetagSequencerSettings) -> None Configures all sequencer-specific settings. :param seq_idx: Index of the sequencer to configure. :param settings: The settings to configure it to. .. py:method:: _configure_io_channel_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.TimetagSequencerSettings) -> None Configures all io_channel-specific settings. :param seq_idx: Index of the sequencer to configure. :param settings: The settings to configure it to. .. py:method:: clear_data() -> None Clears remaining data on the module. Module type specific function. .. py:data:: _ReadoutModuleComponentT .. py:class:: _AcquisitionManagerBase(parent: _ReadoutModuleComponentT, acquisition_metadata: Dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata], acquisition_duration: Dict[str, int], seq_name_to_idx_map: Dict[str, int]) Bases: :py:obj:`abc.ABC` Utility class that handles the acquisitions performed with a module. An instance of this class is meant to exist only for a single prepare-start- retrieve_acquisition cycle to prevent stateful behavior. :param parent: Reference to the parent QRM IC component. :param acquisition_metadata: Provides a summary of the used acquisition protocol, bin mode, acquisition channels, acquisition indices per channel, and repetitions, for each sequencer. :param acquisition_duration: The duration of each acquisition for each sequencer. :param seq_name_to_idx_map: All available sequencer names to their ids in a dict. .. py:attribute:: parent .. py:attribute:: _acquisition_metadata .. py:attribute:: _acq_duration .. py:attribute:: _seq_name_to_idx_map .. py:property:: instrument Returns the QRM driver from the parent IC component. .. py:property:: _protocol_to_acq_function_map :type: dict[str, Callable] :abstractmethod: Mapping from acquisition protocol name to the function that processes the raw acquisition data. The acquisition processing function signature should be the following (for brevity, it's not listed in the typehint): .. code-block:: python def acq_processing_function( self, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable, ) -> DataArray: .. py:method:: retrieve_acquisition() -> xarray.Dataset Retrieves all the acquisition data in the correct format. :returns: The acquisitions with the protocols specified in the `acquisition_metadata`. Each `xarray.DataArray` in the `xarray.Dataset` corresponds to one `acq_channel`. The ``acq_channel`` is the name of each `xarray.DataArray` in the `xarray.Dataset`. Each `xarray.DataArray` is a two-dimensional array, with ``acq_index`` and ``repetition`` as dimensions. .. py:method:: _assert_acquisition_data_exists(hardware_retrieved_acquisitions: dict, qblox_acq_index: int, acq_channel: Hashable) -> None Assert that the qblox_acq_index is in the acquisition data. .. py:method:: _get_acquisitions_from_instrument(seq_idx: int, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata) -> dict .. py:method:: _acq_channel_attrs(protocol: str) -> dict :staticmethod: .. py:method:: _get_bin_data(hardware_retrieved_acquisitions: dict, qblox_acq_index: int = 0) -> dict :classmethod: Returns the bin entry of the acquisition data dict. .. py:method:: _qblox_acq_index_to_qblox_acq_name(qblox_acq_index: int) -> str :staticmethod: Returns the name of the acquisition from the qblox_acq_index. .. py:data:: F .. py:function:: _supported_bin_modes(bin_modes: Sequence[quantify_scheduler.enums.BinMode | str]) -> Callable[[F], F] .. py:class:: _QRMAcquisitionManager(parent: _QRMComponent, acquisition_metadata: Dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata], acquisition_duration: Dict[str, int], seq_name_to_idx_map: Dict[str, int], scope_mode_sequencer_and_qblox_acq_index: Optional[Tuple[int, int]] = None) Bases: :py:obj:`_AcquisitionManagerBase` Utility class that handles the acquisitions performed with the QRM. An instance of this class is meant to exist only for a single prepare-start- retrieve_acquisition cycle to prevent stateful behavior. :param parent: Reference to the parent QRM IC component. :param acquisition_metadata: Provides a summary of the used acquisition protocol, bin mode, acquisition channels, acquisition indices per channel, and repetitions, for each sequencer. :param acquisition_duration: The duration of each acquisition for each sequencer. :param seq_name_to_idx_map: All available sequencer names to their ids in a dict. :param scope_mode_sequencer_and_qblox_acq_index: The sequencer and qblox acq_index of the scope mode acquisition if there's any. .. py:attribute:: _scope_mode_sequencer_and_qblox_acq_index .. py:property:: _protocol_to_acq_function_map :type: dict[str, Callable] Mapping from acquisition protocol name to the function that processes the raw acquisition data. The acquisition processing function signature should be the following (for brevity, it's not listed in the typehint): .. code-block:: python def acq_processing_function( self, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable, ) -> DataArray: .. py:method:: retrieve_acquisition() -> xarray.Dataset Retrieves all the acquisition data in the correct format. :returns: The acquisitions with the protocols specified in the `acquisition_metadata`. Each `xarray.DataArray` in the `xarray.Dataset` corresponds to one `acq_channel`. The ``acq_channel`` is the name of each `xarray.DataArray` in the `xarray.Dataset`. Each `xarray.DataArray` is a two-dimensional array, with ``acq_index`` and ``repetition`` as dimensions. .. py:method:: _store_scope_acquisition() Calls :code:`store_scope_acquisition` function on the Qblox instrument. This will ensure that the correct sequencer will store the scope acquisition data on the hardware, so it will be filled out when we call :code:`get_acquisitions` on the Qblox instrument's sequencer corresponding to the scope acquisition. .. py:method:: _get_scope_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray Retrieves the scope mode acquisition associated with an `acq_channel`. :param acq_indices: Acquisition indices. :param hardware_retrieved_acquisitions: The acquisitions dict as returned by the sequencer. :param acquisition_metadata: Acquisition metadata. :param acq_duration: Desired maximum number of samples for the scope acquisition. :param qblox_acq_index: The Qblox acquisition index from which to get the data. :param acq_channel: The acquisition channel. :returns: The scope mode data. .. py:method:: _get_integration_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable, multiplier: float = 1, separated: bool = True) -> xarray.DataArray Retrieves the integrated acquisition data associated with an `acq_channel`. :param acq_indices: Acquisition indices. :param hardware_retrieved_acquisitions: The acquisitions dict as returned by the sequencer. :param acquisition_metadata: Acquisition metadata. :param acq_duration: Desired maximum number of samples for the scope acquisition. :param qblox_acq_index: The Qblox acquisition index from which to get the data. :param acq_channel: The acquisition channel. :param multiplier: Multiplies the data with this number. :param separated: True: return I and Q data separately False: return I+Q in the real part and 0 in the imaginary part :returns: The integrated data. .. py:method:: _get_integration_amplitude_data(acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray Gets the integration data but normalized to the integration time. The return value is thus the amplitude of the demodulated signal directly and has volt units (i.e. same units as a single sample of the integrated signal). :param acq_indices: Acquisition indices. :param hardware_retrieved_acquisitions: The acquisitions dict as returned by the sequencer. :param acquisition_metadata: Acquisition metadata. :param acq_duration: Desired maximum number of samples for the scope acquisition. :param qblox_acq_index: The Qblox acquisition index from which to get the data. :param acq_channel: The acquisition channel. :returns: Array containing binned, normalized acquisition data. .. py:method:: _get_threshold_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray Retrieve the thresholded acquisition data associated with ``acq_channel`` and ``acq_index``. :param acq_indices: Acquisition indices. :param hardware_retrieved_acquisitions: The acquisitions dict as returned by the sequencer. :param acquisition_metadata: Acquisition metadata. :param acq_duration: Desired maximum number of samples for the scope acquisition. :param qblox_acq_index: The Qblox acquisition index from which to get the data. :param acq_channel: The acquisition channel. :returns: DataArray containing thresholded acquisition data. .. py:method:: _get_trigger_count_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray Retrieves the trigger count acquisition data associated with `acq_channel`. :param acq_indices: Acquisition indices. :param hardware_retrieved_acquisitions: The acquisitions dict as returned by the sequencer. :param acquisition_metadata: Acquisition metadata. :param acq_duration: Desired maximum number of samples for the scope acquisition. :param qblox_acq_index: The Qblox acquisition index from which to get the data. :param acq_channel: The acquisition channel. :returns: **data** -- The acquired trigger count data. :rtype: xarray.DataArray .. rubric:: Notes - For BinMode.AVERAGE, `data` contains the distribution of counts. - For BinMode.APPEND, `data` contains the raw trigger counts. .. py:class:: _QTMAcquisitionManager(parent: _ReadoutModuleComponentT, acquisition_metadata: Dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata], acquisition_duration: Dict[str, int], seq_name_to_idx_map: Dict[str, int]) Bases: :py:obj:`_AcquisitionManagerBase` Utility class that handles the acquisitions performed with the QTM. An instance of this class is meant to exist only for a single prepare-start- retrieve_acquisition cycle to prevent stateful behavior. :param parent: Reference to the parent QRM IC component. :param acquisition_metadata: Provides a summary of the used acquisition protocol, bin mode, acquisition channels, acquisition indices per channel, and repetitions, for each sequencer. :param acquisition_duration: The duration of each acquisition for each sequencer. :param seq_name_to_idx_map: All available sequencer names to their ids in a dict. .. py:property:: _protocol_to_acq_function_map :type: dict[str, Callable] Mapping from acquisition protocol name to the function that processes the raw acquisition data. The acquisition processing function signature should be the following (for brevity, it's not listed in the typehint): .. code-block:: python def acq_processing_function( self, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable, ) -> DataArray: .. py:method:: _get_acquisitions_from_instrument(seq_idx: int, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata) -> dict .. py:method:: _get_trigger_count_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray Retrieves the trigger count acquisition data associated with `acq_channel`. :param acq_indices: Acquisition indices. :param hardware_retrieved_acquisitions: The acquisitions dict as returned by the sequencer. :param acquisition_metadata: Acquisition metadata. :param acq_duration: Desired maximum number of samples for the scope acquisition. :param qblox_acq_index: The Qblox acquisition index from which to get the data. :param acq_channel: The acquisition channel. :returns: **data** -- The acquired trigger count data. :rtype: xarray.DataArray .. rubric:: Notes - BinMode.AVERAGE is not implemented for the QTM. - For BinMode.APPEND, `data` contains the raw trigger counts. .. py:method:: _get_digital_trace_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray .. py:method:: _get_timetag_trace_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray .. py:method:: _split_timetag_trace_data_per_window(timetags: list[int], scope_data: list[tuple[str, int]]) -> list[list[float]] Split the long array of ``scope_data`` on acquisition windows. The scope_data is formatted like [[TYPE, TIME],[TYPE,TIME],...], where TYPE is one of "OPEN", "RISE", "CLOSE". The TIME is absolute (cluster system time). Each acquisition window starts with "OPEN" and ends with "CLOSE". This method uses that information to divide the long ``scope_data`` array up into smaller arrays for each acquisition window. Furthermore, the ``timetags`` list contains the *relative* timetags of the *first* pulse recorded in each window. This data is used to calculate the relative timetags for all timetags in the trace. .. py:method:: _get_timetag_data(*, acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) -> xarray.DataArray .. py:data:: _ClusterModule Type that combines all the possible modules for a cluster. .. py:class:: ClusterComponent(instrument: qblox_instruments.Cluster) Bases: :py:obj:`quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase` Class that represents an instrument coordinator component for a Qblox cluster. New instances of the ClusterComponent will automatically add installed modules using name `"_module"`. :param instrument: Reference to the cluster driver object. .. py:attribute:: _cluster_modules :type: Dict[str, _ClusterModule] .. py:attribute:: _program .. py:attribute:: module_type_map .. py:property:: is_running :type: bool Returns true if any of the modules are currently running. .. py:method:: start() -> None Starts all the modules in the cluster. .. py:method:: stop() -> None Stops all the modules in the cluster. .. py:method:: _configure_cmm_settings(settings: Dict[str, Any]) Set all the settings of the Cluster Management Module. These setting have been provided by the backend. :param settings: A dictionary containing all the settings to set. .. py:method:: prepare(options: Dict[str, dict]) -> None Prepares the cluster component for execution of a schedule. :param options: The compiled instructions to configure the cluster to. .. py:method:: retrieve_acquisition() -> Optional[xarray.Dataset] Retrieves all the data from the instruments. :returns: The acquired data or ``None`` if no acquisitions have been performed. .. py:method:: wait_done(timeout_sec: int = 10) -> None Blocks until all the components are done executing their programs. :param timeout_sec: The time in seconds until the instrument is considered to have timed out. .. py:method:: get_hardware_log(compiled_schedule: quantify_scheduler.schedules.schedule.CompiledSchedule) -> dict | None Retrieve the hardware log of the Cluster Management Module and associated modules. This log includes the module serial numbers and firmware version. :param compiled_schedule: Compiled schedule to check if this cluster is referenced in (and if so, which specific modules are referenced in). :returns: A dict containing the hardware log of the cluster, in case the component was referenced; else None. .. py:function:: _get_instrument_ip(component: quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase) -> str .. py:function:: _get_configuration_manager(instrument_ip: str) -> qblox_instruments.ConfigurationManager .. py:function:: _download_log(config_manager: qblox_instruments.ConfigurationManager, is_cluster: Optional[bool] = False) -> dict