Source code for semi_cr.core.lab.utils.quam

from __future__ import annotations

from qm import qua
from qualang_tools.units import unit

from semi_cr.core.quam_components.helpers import get_mux_components

from numbers import Real
from typing import Any

u = unit(coerce_to_integer=True)




def serialize_quam(obj):
    if obj is None or isinstance(obj, (str, int, float, bool)):
        return obj

    if isinstance(obj, dict):
        data = {k: serialize_quam(v) for k, v in obj.items()}

    elif isinstance(obj, (list, tuple)):
        return [serialize_quam(v) for v in obj]

    elif hasattr(obj, "to_dict"):
        data = obj.to_dict()

    elif hasattr(obj, "__dict__"):
        data = {
            k: serialize_quam(v)
            for k, v in obj.__dict__.items()
            if not k.startswith("_")
        }

    else:
        return obj

    # Recurse after to_dict(), because to_dict() may return nested QUAM objects
    data = {k: serialize_quam(v) for k, v in data.items()}

    # Put __class__ first, then id, then the rest
    cls = data.pop("__class__", f"{obj.__class__.__module__}.{obj.__class__.__name__}")
    id_value = data.pop("id", None)

    ordered = {"__class__": cls}

    if "id" in data or id_value is not None:
        ordered["id"] = id_value

    ordered.update(data)

    return ordered




def update_rf_device_frequency(freq, rf_in):

    from semi_cr.core.lab.devices.tankinductor import TankInductor
    from semi_cr.core.lab.devices.multiplexer import Multiplexer

    device = rf_in.parent

    if isinstance(device, TankInductor):

        rf_in.update_frequency(freq)
        qua.wait(
            1000 * u.ns,
            rf_in.quam.id,
        )
    elif isinstance(device, Multiplexer):

        mux_components = get_mux_components(device)
        if not mux_components:
            raise ValueError("Expected at least one mux component.")

        # rf_in.update_frequency(freq)
        for mux_component in mux_components:
            mux_component.update_frequency(freq)
    
        qua.wait(
            1000 * u.ns,
            *(mux_component.id for mux_component in mux_components),
        )




def update_rf_device_amplitude(
    amplitude: Any,
    rf_in,
) -> None:
    """
    Set the dimensionless amplitude scale used by the next RF play/measure operation.

    `amplitude` may be:
    - a Python float, or
    - a QUA fixed variable/expression.

    The value is a multiplier of the amplitude configured in the
    readout pulse.
    """
    if isinstance(amplitude, Real):
        amplitude = float(amplitude)

        if not 0.0 <= amplitude <= 1.0:
            raise ValueError(
                "The QUA amplitude scale must satisfy "
                "0.0 <= amplitude <= 1.0."
            )

    rf_in._amplitude_scale = amplitude