Struct qoqo_aqt::BackendWrapper

pub struct BackendWrapper {
    pub internal: Backend,
}

AQT backend

provides functions to run circuits and measurements on AQT devices.

Fields

internal: Backend

Internal storage of roqoqo_aqt::Backend

Implementations

impl BackendWrapper

pub fn new(device: &PyAny, access_token: Option<String>) -> PyResult<Self>

Create a new AQT Backend.

Args: device (Device): AQT Device providing information about the endpoint running Circuits. access_token (Optionalstr): Optional access token to AQT endpoints. When None access token is read from $AQT_ACCESS_TOKEN environmental variable

Raises: TypeError: Device Parameter is not AqtDevice RuntimeError: No access token found

pub fn to_aqt_json(&self, circuit: &PyAny) -> PyResult<String>

Create an AQT json represenstaion of a Circuit.

Args: circuit (Circuit): The circuit that is translated to a AQT json.

Returns: str: The output registers written by the evaluated circuits.

Raises: TypeError: Circuit argument cannot be converted to qoqo Circuit RuntimeError: Translating Circuit failed

pub fn __copy__(&self) -> BackendWrapper

Return a copy of the Backend (copy here produces a deepcopy).

Returns: Backend: A deep copy of self.

pub fn __deepcopy__(&self, _memodict: Py<PyAny>) -> BackendWrapper

Return a deep copy of the Backend.

Returns: Backend: A deep copy of self.

pub fn to_bincode(&self) -> PyResult<Py<PyByteArray>>

Return the bincode representation of the Backend using the bincode crate.

Returns: ByteArray: The serialized Backend (in bincode form).

Raises: ValueError: Cannot serialize Backend to bytes.

pub fn from_bincode(input: &PyAny) -> PyResult<BackendWrapper>

Convert the bincode representation of the Backend to a Backend using the bincode crate.

Args: input (ByteArray): The serialized Backend (in bincode form).

Returns: Backend: The deserialized Backend.

Raises: TypeError: Input cannot be converted to byte array. ValueError: Input cannot be deserialized to Backend.

pub fn run_circuit( &self, circuit: &PyAny ) -> PyResult<(HashMap<String, BitOutputRegister>, HashMap<String, FloatOutputRegister>, HashMap<String, ComplexOutputRegister>)>

Run a circuit with the AQT backend.

A circuit is passed to the backend and executed. During execution values are written to and read from classical registers (Listbool, List[float], List[complex]). To produce sufficient statistics for evaluating expectation values, circuits have to be run multiple times. The results of each repetition are concatenated in OutputRegisters (List[Listbool], List[List[float]], List[List[complex]]).

Args: circuit (Circuit): The circuit that is run on the backend.

Returns: Tuple[Dict[str, List[Listbool]], Dict[str, List[List[float]]]], Dict[str, List[List[complex]]]]: The output registers written by the evaluated circuits.

Raises: TypeError: Circuit argument cannot be converted to qoqo Circuit RuntimeError: Running Circuit failed

pub fn run_measurement_registers( &self, measurement: &PyAny ) -> PyResult<(HashMap<String, BitOutputRegister>, HashMap<String, FloatOutputRegister>, HashMap<String, ComplexOutputRegister>)>

Run all circuits corresponding to one measurement with the AQT backend.

An expectation value measurement in general involves several circuits. Each circuit is passes to the backend and executed separately. A circuit is passed to the backend and executed. During execution values are written to and read from classical registers (Listbool, List[float], List[complex]). To produce sufficient statistics for evaluating expectation values, circuits have to be run multiple times. The results of each repetition are concatenated in OutputRegisters (List[Listbool], List[List[float]], List[List[complex]]).

Args: measurement (Measurement): The measurement that is run on the backend.

Returns: Tuple[Dict[str, List[Listbool]], Dict[str, List[List[float]]]], Dict[str, List[List[complex]]]]: The output registers written by the evaluated circuits.

Raises: TypeError: Circuit argument cannot be converted to qoqo Circuit RuntimeError: Running Circuit failed

pub fn run_measurement( &self, measurement: &PyAny ) -> PyResult<Option<HashMap<String, f64>>>

Evaluates expectation values of a measurement with the backend.

Args: measurement (Measurement): The measurement that is run on the backend.

Returns: Optional[Dict[str, float]]: The dictionary of expectation values.

Raises: TypeError: Measurement evaluate function could not be used RuntimeError: Internal error measurement.evaluation returned unknown type

Trait Implementations

impl Clone for BackendWrapper

fn clone(&self) -> BackendWrapper

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BackendWrapper

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl IntoPy<Py<PyAny>> for BackendWrapper

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PartialEq for BackendWrapper

fn eq(&self, other: &BackendWrapper) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for BackendWrapper

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for BackendWrapper

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<BackendWrapper>

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForBackendWrapper

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<BackendWrapper> for PyClassImplCollector<BackendWrapper>

fn new_text_signature(self) -> Option<&'static str>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a BackendWrapper

type Holder = Option<PyRef<'py, BackendWrapper>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut BackendWrapper

type Holder = Option<PyRefMut<'py, BackendWrapper>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl PyTypeInfo for BackendWrapper

type AsRefTarget = PyCell<BackendWrapper>

Utility type to make Py::as_ref work.

const NAME: &'static str = "Backend"

Class name.

const MODULE: Option<&'static str> = _

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl Eq for BackendWrapper

impl StructuralPartialEq for BackendWrapper