Merge branch 'fix-test_acquisitions' into 'main'

- Updated pulse_diagram_matplotlib to be compatible with future quantify-core release (!517)

- Instrument Coordinator - Check if a parameter cache is valid before lazy setting (!505, #351)

- Qblox backend - Explicit error message when trying to do acquisitions on a QCM (!519)

- Acquisitions - Refactor tests: Move to `mock_setup_basic_transmon_with_standard_params` and replace `qcompile` by `SerialCompiler` (!516)

## 0.9.0 (2022-10-06)

    close_instruments(mock_instruments)

@pytest.fixture(scope="function", autouse=False)

def mock_setup_basic_transmon_with_standard_params(mock_setup_basic_transmon):

    set_standard_params_transmon(mock_setup_basic_transmon)

    yield mock_setup_basic_transmon

@pytest.fixture(scope="function", autouse=False)

def mock_setup_basic_nv(tmp_test_data_dir):

    """

# pylint: disable=missing-function-docstring

# pylint: disable=missing-module-docstring

# pylint: disable=no-name-in-module

# pylint: disable=no-self-use

# pylint: disable=redefined-outer-name

# pylint: disable=unused-argument

# Licensed according to the LICENCE file on the main branch

"""Tests for acquisitions module."""

import math

import pprint

from typing import Dict, Any

import pytest

from qblox_instruments import ClusterType, PulsarType

from quantify_scheduler import waveforms, Schedule

from quantify_scheduler.backends.qblox.instrument_compilers import QrmModule

from quantify_scheduler.enums import BinMode

from quantify_scheduler.backends import SerialCompiler

from quantify_scheduler.backends.qblox import constants

from quantify_scheduler.backends.qblox.instrument_compilers import QrmModule

from quantify_scheduler.backends.qblox.operation_handling import acquisitions

from quantify_scheduler.backends.qblox.qasm_program import QASMProgram

from quantify_scheduler.backends.qblox.register_manager import RegisterManager

from quantify_scheduler.backends.types import qblox as types

from quantify_scheduler.compilation import qcompile

from quantify_scheduler.gettables import ScheduleGettable

from quantify_scheduler.operations.gate_library import Measure

from quantify_scheduler.instrument_coordinator.components.qblox import (

def test_trace_acquisition_measurement_control(

    mock_setup_basic_transmon, mocker, make_cluster_component

    mock_setup_basic_transmon_with_standard_params, mocker, make_cluster_component

):

    hardware_cfg = {

        "backend": "quantify_scheduler.backends.qblox_backend.hardware_compile",

        },

    }

    mock_setup = mock_setup_basic_transmon_with_standard_params

    ic_cluster0 = make_cluster_component("cluster0")

    instr_coordinator = mock_setup_basic_transmon["instrument_coordinator"]

    instr_coordinator = mock_setup["instrument_coordinator"]

    instr_coordinator.add_component(ic_cluster0)

    quantum_device = mock_setup_basic_transmon["quantum_device"]

    quantum_device = mock_setup["quantum_device"]

    quantum_device.hardware_config(hardware_cfg)

    acq_duration = 5e-6  # retrieve 5000 samples

    q2 = mock_setup_basic_transmon["q2"]

    q2 = mock_setup["q2"]

    q2.measure.acq_delay(600e-9)

    q2.clock_freqs.readout(7404000000.0)

    q2.measure.integration_time(acq_duration)

    instr_coordinator.remove_component(ic_cluster0.name)

def test_multiple_measurements(mock_setup_basic_transmon, make_cluster_component):

def test_multiple_measurements(

    mock_setup_basic_transmon_with_standard_params, make_cluster_component

):  # pylint: disable=too-many-locals

    hardware_cfg = {

        "backend": "quantify_scheduler.backends.qblox_backend.hardware_compile",

        "cluster0": {

            },

        },

    }

    # Setup objects needed for experiment

    mock_setup = mock_setup_basic_transmon_with_standard_params

    ic_cluster0 = make_cluster_component("cluster0")

    instr_coordinator = mock_setup_basic_transmon["instrument_coordinator"]

    instr_coordinator = mock_setup["instrument_coordinator"]

    instr_coordinator.add_component(ic_cluster0)

    quantum_device = mock_setup_basic_transmon["quantum_device"]

    quantum_device = mock_setup["quantum_device"]

    quantum_device.hardware_config(hardware_cfg)

    q0 = mock_setup_basic_transmon["q0"]

    q1 = mock_setup_basic_transmon["q1"]

    q0 = mock_setup["q0"]

    q1 = mock_setup["q1"]

    # Define experiment schedule

    schedule = Schedule("test multiple measurements")

    q1.measure.integration_time(3e-6)

    # Generate compiled schedule

    compiled_sched = qcompile(

        schedule=schedule,

        device_cfg=quantum_device.generate_device_config(),

        hardware_cfg=hardware_cfg,

    compiler = SerialCompiler(name="compiler")

    compiled_sched = compiler.compile(

        schedule=schedule, config=quantum_device.generate_compilation_config()

    )

    # Upload schedule and run experiment

    instr_coordinator.prepare(compiled_sched)

    instr_coordinator.start()

    "module_under_test",

    [ClusterType.CLUSTER_QRM_RF, ClusterType.CLUSTER_QRM, PulsarType.PULSAR_QRM],

)

def test_trace_acquisition_instrument_coordinator(  # pylint: disable=too-many-locals

def test_trace_acquisition_instrument_coordinator(  # pylint: disable=too-many-locals, too-many-statements

    mocker,

    mock_setup_basic_transmon,

    mock_setup_basic_transmon_with_standard_params,

    make_cluster_component,

    make_qrm_component,

    module_under_test,

    }

    hardware_cfg = hardware_cfgs[module_under_test]

    instr_coordinator = mock_setup_basic_transmon["instrument_coordinator"]

    mock_setup = mock_setup_basic_transmon_with_standard_params

    instr_coordinator = mock_setup["instrument_coordinator"]

    if isinstance(module_under_test, ClusterType):

        name = "cluster0"

    except ValueError:

        ic_component.instrument.reset()

    quantum_device = mock_setup_basic_transmon["quantum_device"]

    quantum_device = mock_setup["quantum_device"]

    quantum_device.hardware_config(hardware_cfg)

    q2 = mock_setup_basic_transmon["q2"]

    q2 = mock_setup["q2"]

    q2.measure.acq_delay(600e-9)

    q2.clock_freqs.readout(

        7.404e9 if module_under_test is ClusterType.CLUSTER_QRM_RF else 3e8

    schedule = trace_schedule_circuit_layer(qubit_name="q2")

    compiled_sched = qcompile(

        schedule=schedule,

        device_cfg=quantum_device.generate_device_config(),

        hardware_cfg=hardware_cfg,

    compiler = SerialCompiler(name="compiler")

    compiled_sched = compiler.compile(

        schedule=schedule, config=quantum_device.generate_compilation_config()

    )

    wrappee = (

    instr_coordinator.remove_component(ic_component.name)

def test_mix_lo_flag(mock_setup_basic_transmon, make_cluster_component):

def test_mix_lo_flag(

    mock_setup_basic_transmon_with_standard_params, make_cluster_component

):

    hardware_cfg = {

        "backend": "quantify_scheduler.backends.qblox_backend.hardware_compile",

        "cluster0": {

    }

    # Setup objects needed for experiment

    mock_setup = mock_setup_basic_transmon_with_standard_params

    ic_cluster0 = make_cluster_component("cluster0")

    instr_coordinator = mock_setup_basic_transmon["instrument_coordinator"]

    instr_coordinator = mock_setup["instrument_coordinator"]

    instr_coordinator.add_component(ic_cluster0)

    quantum_device = mock_setup_basic_transmon["quantum_device"]

    quantum_device = mock_setup["quantum_device"]

    quantum_device.hardware_config(hardware_cfg)

    # Define experiment schedule

    schedule.add_resource(ClockResource(name="q0.ro", freq=70e6))

    # Generate compiled schedule where mix_lo is true

    compiled_sched_mix_lo_true = qcompile(

        schedule=schedule,

        device_cfg=quantum_device.generate_device_config(),

        hardware_cfg=hardware_cfg,

    compiler = SerialCompiler(name="compiler")

    compiled_sched_mix_lo_true = compiler.compile(

        schedule=schedule, config=quantum_device.generate_compilation_config()

    )

    # Change mix_lo to false, set new LO freq and generate new compiled schedule

    hardware_cfg["cluster0"]["cluster0_module1"]["complex_output_0"]["mix_lo"] = False

    compiled_sched_mix_lo_false = qcompile(

        schedule=schedule,

        device_cfg=quantum_device.generate_device_config(),

        hardware_cfg=hardware_cfg,

    compiled_sched_mix_lo_false = compiler.compile(

        schedule=schedule, config=quantum_device.generate_compilation_config()

    )

    # Assert LO freq got set to 20e6 if mix_lo is true.