paraqeet.model package

Submodules

paraqeet.model.closed_system module

Class definition of a closed model.

class paraqeet.model.closed_system.ClosedSystem

Bases: EquationOfMotion

Model of a closed physical system, defined by a Hamiltonian.

Its dynamics is given by the Schrödinger equation.

Parameters:

hamiltonian (Hamiltonian) – Matrix representation of a Hamiltonian.

__init__(hamiltonian, ode_propagation=False)
Parameters:
get_matrix(time)

Get the matrix equations of motion.

Computes the right hand side of the Schrödinger equation without multiplying the state. Used for unitary solvers.

Parameters:

time (Array) – Vector of time samples.

Returns:

RHS with dimension [t, n, n] with ‘t’ as time and ‘n’ as Hilbert space dimension.

Return type:

Array

get_parameters()

Get a list of optimisable parameters.

Returns:

List of optimisable parameters of the system.

Return type:

List[Quantity]

gradient(t)

Compute the gradient of getMatrix.

Parameters:

t (Array) – Vector of time samples.

Returns:

Returns the gradient of getMatrix.

Return type:

Array

property ode_propagation: bool

Flag to set method of propagation to ODE.

Returns:

Flag to use ODE propagation.

Return type:

bool

paraqeet.model.composite_hamiltonian module

Class definition of the composite Hamiltonian model.

class paraqeet.model.composite_hamiltonian.CompositeHamiltonian

Bases: Hamiltonian

A hamiltonian that consists of subsystems and couplings.

This class takes care of the tensor products. The list of parameters will contain the parameters of all subsystems and couplings in the order they were added.

Parameters:

  • subsystems (list[Hamiltonian]) – List of Hamiltonains forming the subsystems of a composite system.

  • couplings (list[Coupling], optional) – List of couplings between the various subsystems

__init__(subsystems, couplings=None)
Parameters:
dimension()

Return the dimension of the system.

Returns:

Dimension of the system.

Return type:

int

get_collapseops()

Gather collapse operators from the subsystems and then tensor product them with identity to create the collapse operators of the right dimension.

Return type:

list[tuple[Array, Array]]

get_matrix_one_time(t)

Get matrix representation of the Hamiltonian for a single time point.

Parameters:

t (float) – One time step.

Returns:

Hamiltonian of shape [n, n] with ‘n’ as the Hilbert space dimension.

Return type:

Array

get_parameters()

Collect parameters from all subsystems and couplings.

Parameters:

list[Quantity] – Returns the list of parameters of the system.

Return type:

list[Quantity]

get_subsystem_dimensions()

Return a list of dimensions of each subsystem in the composite Hamiltonian.

Returns:

list of dimension of each subsystem.

Return type:

list[int]

gradient(t)

Return the gradient of each parameter.

Returns as an array for an array of input times. Uses vmap to iterate over time array to generate the gradients.

Parameters:

t (Array) – Array of time samples.

Returns:

Gradient for each time point in the input array of times.

Return type:

Array

set_optimisable_parameters(params)

Set optimisable parameters for the system.

Forward parameters to the subsystems and couplings. All of them should find their own parameters in the list.

Parameters:

params (list[Quantity]) – Input list of parameters to be set.

Return type:

None

paraqeet.model.coupling module

Class definition of a coupling optimisable model.

class paraqeet.model.coupling.Coupling

Bases: Optimisable

Create a coupling optimisable model.

Represents the coupling of two or more subsystems in a composite Hamiltonian. This class implements longitudinal and transversal coupling with a constant scalar coefficient. The coefficient is the only optimisable parameter. Subclasses can alter the behavior by overriding the getMatrix function.

Parameters:

  • subsystems (list[Hamiltonian]) – The coupled subsystems.

  • coefficient (Quantity) – Either a constant coefficient as float or a callable that returns the coefficient for a given time.

  • is_longitudinal (bool) – Whether the coupling is longitudinal or transversal.

  • use_rwa (bool, optional) – If the transversal coupling should use the rotating-wave approximation or should include double excitation terms.

__init__(subsystems, coefficient, is_longitudinal, use_rwa=False)
Parameters:
get_matrices(t)

Return the matrices for an array of time.

vmaps over the method for one time step.

Parameters:

t (Array) – Array of times

Returns:

The outer list are the coupling terms. The inner list represents the subsystems. The matrices (Array) have the same shape as the subsystem’s Hamiltonian.get_matrix: (t,n,n) with t the time and n the subsystem dimension.

Return type:

list[list[Array]]

get_matrices_one_time(t)

Return the matrix representation of the coupling for all subsystems.

A list of terms in the coupling is returned, where each of the term contains operators for each subsystem. A composite Hamiltonian puts these operators in the correct position in the tensor space to create the operators and then sum over the terms.

Parameters:

t (float) – One time step.

Returns:

The outer list are the coupling terms. The inner list contains matrices for each subsystem. The matrices (Array) have the same shape as the subsystem’s Hamiltonian.get_matrix_one_time: (n,n) with n the subsystem dimension.

Return type:

list[List[Array]]

get_parameters()

Collect parameters from all subsystems and couplings.

Parameters:

list[Quantity] – Returns the list of parameters of the system.

Return type:

list[Quantity]

gradient(t)

Return the gradients for an array of times.

Parameters:

t (Array) – One-dimensional vector of timestamps.

Returns:

The outer list represents the gradients with respect to all optimised parameters. The rest is in the same shape as the result of get_matrices.

Return type:

list[list[Array]]

gradient_one_time(t)

Get the one-time gradient of the matrix.

Returns the gradient of the matrix representation of the coupling for all subsystems. Each entry in the list is the gradient with respect to one parameter, factorised into subsystems (representing a list of term in the coupling).

Parameters:

t (float) – One time point.

Returns:

The outer list represents the gradients with respect to all optimised parameters. The rest is in the same shape as the result of getMatricesOneTime.

Return type:

list[list[list[Array]]]

property subsystems: list[Hamiltonian]

Return all subsystems that are coupled by this term.

Returns:

List of subystems.

Return type:

list[Hamiltonian]

paraqeet.model.custom_hamiltonian module

Custom Hamiltonian wrapper for H(t).

class paraqeet.model.custom_hamiltonian.CustomHamiltonian

Bases: Hamiltonian

Custom Hamiltonian class to simulate systems using a user defined Hamitonian function..

Here we expect a Hamiltonian function of the form H(t, *params). Here params is a list of scalars (NOT `Quantity`).

But, parameters is a list of Quantity that would be optimised.

It is advised to make the Hamiltonian function vmap and jit compatible. Furthermore, it is advised to write the Hamiltonian function in a way such that it takes a single time point (scalar) as input and returns a jax array of dimensions [n, n].

Additionally, to optimise the parameters, one needs to pass a list of gradient functions correspoding to each parameter, in the same order as the parameter list.

To use open system simulation, provide a list of tuples of decay rates and corresponding collapse opearators.

__init__(hamiltonian_function, parameters, gradient_functions=None, collapse_operators=None)
Parameters:

  • hamiltonian_function (Callable[[Array, Any], Array])

  • parameters (list[Quantity])

  • gradient_functions (list[Callable] | None)

  • collapse_operators (list[tuple[Array, Array]] | None)

property collapse_operators: list[tuple[Array, Array]] | None

Return collapse operators.

dimension()

Return dimension of the Hilbert space.

get_collapseops()

Return collapse operators.

Return type:

list[tuple[Array, Array]]

get_matrix(t)

Return Hamiltonian as a function of time for an array of time.

Parameters:

t (Array)

Return type:

Array

get_matrix_one_time(t)

Return Hamiltonian as a function of time for a single time point.

Parameters:

t (Array)

get_parameters()

Return a list of optimisable parameters.

Return type:

list[Quantity]

gradient(t)

Return Hamiltonian as a function of time for a single time point.

Parameters:

t (Array)

Return type:

Array

property gradient_functions: list[Callable] | None

Return gradient functions.

gradient_one_time(t)

Return the gradient as a function of time for a single time point.

paraqeet.model.drive module

Class definition of a Drive optimisable model.

class paraqeet.model.drive.Drive

Bases: Optimisable, ABC

Represents a time-dependent drive on a subsystem.

This can for example be a microwave or flux drive.

get_matrix(annihilation_operator, t)

Return the matrix representation of the drive.

The dimension is given by the Hamiltonian to which this drive is attached. The default implementation calls getMatrixOneTime for each time step. Subclasses can override this function for a more efficient implementation.

Parameters:

  • annihilation_operator (Array) – Operator of the subsystem to which this drive is attached

  • t (Array) – Vector of time samples.

Returns:

Matrix of shape [t, n, n] with ‘t’ as time and ‘n’ as the Hilbert space dimension.

Return type:

Array

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

get_matrix_one_time(annihilation_operator, t)

Return the matrix representation of the drive.

The dimension is given by the Hamiltonian to which this drive is attached.

Parameters:

  • annihilation_operator (Array) – Operator of the subsystem to which this drive is attached.

  • t (float) – One time point.

Returns:

Matrix of shape [n, n] with n as the Hilbert space dimension.

Return type:

Array

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

gradient(annihilation_operator, t)

Return the gradient of the system.

Returns the gradient of the matrix representation of the Hamiltonian with respect to each parameter as a list.

Parameters:

  • annihilation_operator (Array) – Operator of the subsystem to which this drive is attached.

  • t (Array) – Vector of time samples.

Returns:

Array of shape [t, p, n, n] with ‘t’ as time, ‘p’ as number of parameters and ‘n’ as the Hilbert space dimension.

Return type:

Array

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

gradient_one_time(annihilation_operator, t)

Get the one-time gradient of the system.

Returns the gradient of the matrix representation of the Hamiltonian with respect to each parameter as a list.

Parameters:

  • annihilation_operator (Array) – Operator of the subsystem to which this drive is attached.

  • t (float) – One time step.

Returns:

Array of shape [p, n, n] with ‘p’ as the number of parameters and ‘n’ as the Hilbert space dimension.

Return type:

Array

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

paraqeet.model.drive_operator module

Class definition of the Generator Drive model.

class paraqeet.model.drive_operator.DriveOperator

Bases: Drive

Create a generator drive model.

Transversal (a^\dagger + a or \sigma_x type) or longitudinal (a^\dagger a or \sigma_z type) drive with a time-dependent scalar coefficient that is generated by a Generator object.

Parameters:

  • generator (Generator) – Signal generator stack.

  • is_longitudinal (bool) – Generator is longitudinal or transversal depending on this boolean.

__init__(generator, is_longitudinal)
Parameters:

  • generator (Generator)

  • is_longitudinal (bool)

property generator: Generator

Get the signal generator from the system.

Returns:

Returns the signal generator object from the system.

Return type:

paraqeet.signal.generator.Generator

get_matrix_one_time(a, t)

Get the one-time matrix of the system.

Fetches the coefficient from the drive and transforms it into the correct shape for the Hamiltonian.

Parameters:

  • a (Array) – Operator for longitudinal or transverse drive.

  • t (Array) – One-dimensional vector of timestamps.

Returns:

Returns the shape-shifted coefficient from the drive.

Return type:

Array

get_parameters()

Get a list of parameters of the system.

Returns:

List of optimizable parameters of the system.

Return type:

list[Quantity]

gradient_one_time(a, t)

Get the one-time gradient of the system.

Fetches the gradient from the drive and transforms it into the correct shape for the Hamiltonian.

Parameters:

  • a (Array) – Operator for longitudinal or transverse drive.

  • t (Array) – One-dimensional vector of timestamps.

Returns:

Returns the shape-shifted gradient from the drive.

Return type:

Array

paraqeet.model.equation_of_motion module

Class definition of the optimisable model.

class paraqeet.model.equation_of_motion.EquationOfMotion

Bases: Optimisable

Represents the equation of motion for a given Hamiltonian.

Implementations can for example be the Schrödinger equation for a closed system, Lindbladian for an open system, or Hamilton’s equations for a classical system.

Parameters:

hamiltonian (Hamiltonian) – Matrix representation of a Hamiltonian.

__init__(hamiltonian)
Parameters:

hamiltonian (Hamiltonian)

abstract get_matrix(time)

Abstract method to get the prefactor matrix.

Parameters:

time (Array) – Any one-dimensional vector of timestamps.

Returns:

Returns matrix equations of motion.

Return type:

Array

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

abstract get_parameters()

Abstract method to get parameters of the model.

Returns:

Returns the list of parameters as Quantities.

Return type:

list[Quantity]

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

get_right_hand_side(time, state)

Return the right-hand side of the equations of motion.

The format depends on the implementation and could for example be a state vector or a matrix. Default implementation assumes a homogeneous ODE with matrix operator given by self.getMatrix().

Parameters:

  • time (Array) – Any one-dimensional vector of timestamps.

  • state (Array)

Returns:

The right-hand side of the equation of motion at each time stamp.

Return type:

Array

abstract gradient(t)

Implement the gradient of either getEquationOfMotion or getMatrixEOM.

Parameters:

t (Array) – Any one-dimensional vector of timestamps.

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

Return type:

Array

paraqeet.model.hamiltonian module

Class definition for a matrix representation of a Hamiltonian.

class paraqeet.model.hamiltonian.Hamiltonian

Bases: Optimisable, ABC

Class definition for a matrix representation of a Hamiltonian.

Implementations can contain subsystems, couplings, and drive lines and have to take care of frame transformations. Derived classes need to implement the functions getMatrix, gradient, and dimension.

Parameters:

drives (list[Drive]) – List of time-dependent drives.

__init__(drives=None)
Parameters:

drives (list[Drive] | None)

dimension()

Return the dimension of the Hilbert space of this Hamiltonian.

Returns:

Returns the dimension of the Hilbert space of this Hamiltonian.

Return type:

int

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

property drives: list[Drive]

Return the list of Drives of the system.

Returns:

Returns a list of time-dependent drives of the system.

Return type:

list[Drive]

get_collapseops()

Return a list tuples of decay rates and collapse operators for each subsystem.

Returns:

List of collapse operators

Return type:

list[Tuple[Array, Array]]

get_matrix(t)

Return the matrix representation of the Hamiltonian.

The default implementation calls getMatrixOneTime for each time step. Subclasses can override this function for a more efficient implementation.

Parameters:

t (Array) – Vector of time samples.

Returns:

Hamiltonian of shape [t, n, n] with ‘t’ as time and ‘n’ as the Hilbert space dimension.

Return type:

Array

get_matrix_one_time(t)

Return the matrix representation of the Hamiltonian.

Parameters:

t (Array) – One time point.

Returns:

Hamiltonian of shape [n, n] with n as the Hilbert space dimension.

Return type:

Array

Raises:

NotImplementedError – Subclasses derived from this class must implement this method.

gradient(t)

Return the gradient of the system.

Returns the gradient of the matrix representation of the Hamiltonian with respect to each parameter for each time step in t. Implementations must make sure that only derivatives with respect to those parameters are included in the gradient that were registered in the Optimisable parent class. The order of the gradients should match the order of the parameters returned by getParameters. The default implementation calls gradient_one_time for each time step. Subclasses can override this function for a more efficient implementation.

Parameters:

t (Array) – Vector of time samples.

Returns:

Hamiltonian of shape [t, p, n, n] with ‘t’ as time, ‘p’ as number of parameters and ‘n’ as Hilbert space dimension.

Return type:

Array

gradient_one_time(t)

Return the one-time gradient of the system.

Return the gradient of the matrix representation of the Hamiltonian with respect to each parameter for one time step t. Implementations must make sure that only derivatives with respect to those parameters are included in the gradient that were registered in the Optimisable parent class. The order of the gradients should match the order of the parameters returned by getParameters.

Parameters:

t (Array) – One time step.

Returns:

Hamiltonian of shape [p, n, n] with ‘p’ as the number of parameters and ‘n’ as the Hilbert space dimension.

Return type:

list[Array]

paraqeet.model.open_system module

Class definition of an open system.

class paraqeet.model.open_system.OpenSystem

Bases: EquationOfMotion

Model of an open quantum system, defined by the Hamiltonian and collapse operators. Its dynamics given by the Lindblad master equation.

Currently the gradients for ODE propagation methods is not supported.

Parameters:

  • hamiltonian (Hamiltonian) – Matrix representation of a Hamiltonian.

  • sparse_superop (bool) – Flag to save superoperator as sparse matrices.

  • ode_propagation (bool) – Flag to use ODE methods for propgation. If true then get_matrix method returns list of Hamiltonian (with time) and collapse operator. Else returns Lindblad superoperator.

__init__(hamiltonian, sparse_superop=False, ode_propagation=False)
Parameters:

  • hamiltonian (Hamiltonian)

  • sparse_superop (bool)

  • ode_propagation (bool)

get_collapseops()

Get a list of tuples of decay rates and collapse operators for each subsystem.

Returns:

list of collapse operators

Return type:

list[tuple[float, Array]]

get_matrix(time)

Computes the right hand side of the Schrödinger equation without multiplying the state. Used for unitary solvers.

Parameters:

time (Array) – Vector of time samples

Returns:

RHS with dimension [t, n, n] with t: time, n: hilbert space

Return type:

Array

get_parameters()

Get a list of optimisable parameters.

Returns:

list of optimizable parameters of the system.

Return type:

list[Quantity]

gradient(t)

Compute the gradient of get_matrix.

Return type:

Array

property ode_propagation: bool

Flag to set method of propagation to ODE.

Returns:

Flag to use ODE propagation.

Return type:

bool

property sparse_superop: bool

Flag to store superoperators as sparse matrices.

Returns:

Flag to store sparse matrices.

Return type:

bool

paraqeet.model.qubit module

Class definition of a qubit model.

class paraqeet.model.qubit.Qubit

Bases: Hamiltonian

Hamiltonian of a single qubit frequency/2 * sigma_z.

The implementation uses the convention of having the excited state of the qubit as the first entry in the state. If you need a two-level system that is compatible with the projection of a higher-dimensional system (ground state as first entry), use a resonator and restrict its dimension to 2.

Parameters:

  • frequency (Quantity) – Frequency for characterizing the qubit.

  • drives (list[Drive] | None) – List of time-dependent drives.

__init__(frequency, drives=None, t1=None, temp=None, t2star=None)
Parameters:
dimension()

Dimension of the qubit.

Returns:

Returns 2 as the dimension.

Return type:

int

property frequency: Quantity

Get the frequency of the qubit.

get_collapseops()

Return a list tuples of decay rates and collapse operators for each subsystem.

Return type:

list[tuple[Array, Array]]

get_decay_rates()

Return decay rate for T1, T2star and Temp respectively.

Return type:

list[Array]

get_matrix_one_time(t)

Get the drive matrix.

Parameters:

t (Array) – One time stamp.

Returns:

The repeated drive matrix.

Return type:

Array

get_parameters()

Get parameters of the model.

Returns:

Returns the list of parameters of the system.

Return type:

list[Quantity]

gradient_one_time(t)

Get the gradient of the drive.

Parameters:

t (Array) – One time stamp.

Returns:

Returns the gradients of the drive.

Return type:

Array

property t1: Quantity | None

Get the t1 of the resonator.

property t2star: Quantity | None

Get the t2star of the resonator.

property temp: Quantity | None

Get the temp of the resonator.

paraqeet.model.resonator module

Class definition of the Resonator Hamiltonian model.

class paraqeet.model.resonator.Resonator

Bases: Hamiltonian

Hamiltonian of a harmonic oscillator.

The only optimisable parameter is the frequency.

Parameters:

  • dimension (int) – Dimension of the harmonic oscillator.

  • frequency (Quantity) – Frequency of the harmonic oscillator.

  • drives (list[Drive], optional) – List of time-dependent drives of the subsystem.

__init__(dimension, frequency, drives=None, t1=None, temp=None, t2star=None)
Parameters:
dimension()

Get the dimension of the resonator.

property frequency: Quantity

Get the frequency of the resonator.

get_collapseops()

Return a list tuples of decay rates and collapse operators for each subsystem.

Returns:

List of collapse operators

Return type:

list[tuple[Array, Array]]

get_decay_rates()

Return decay rate for T1, T2star and Temp respectively.

Return type:

list[Array]

get_matrix_one_time(t)

Get the drive matrix.

Parameters:

t (float) – One time stamp.

Returns:

The drive matrix at a single timestamp.

Return type:

Array

get_parameters()

Get parameters of the model.

Returns:

Returns the list of parameters of the system.

Return type:

List[Quantity]

gradient_one_time(t)

Get the gradient of the drive.

Parameters:

t (float) – One time stamp.

Returns:

Returns the gradients of the drive.

Return type:

Array

property t1: Quantity | None

Get the t1 of the resonator.

property t2star: Quantity | None

Get the t2star of the resonator.

property temp: Quantity | None

Get the temp of the resonator.

paraqeet.model.rotating_frame_coupling module

Coupling Hamiltonian in the rotating frame of drive.

class paraqeet.model.rotating_frame_coupling.RotatingFrameCoupling

Bases: Coupling

Implements the coupling in the rotating frame of the drive.

If multiple subsystems are coupled specify the difference frequency of the individual drive frames.

NOTE - Right now this only works for TWO SUBSYSTEMS. TODO - Generalize this for multiple subsystems

Parameters:

  • subsystems (list[Hamiltonian]) – A set of Hamiltonians which represent the coupling

  • coefficient (Quantity) – Constant drive coefficient.

  • diffFreq (Quantity) – Diffrence of drive frequencies for multiple subsystems.

__init__(subsystems, coefficient, diffFreq)
Parameters:
get_matrices_one_time(t)

Return the matrix representation of the coupling for all subsystems.

A list of terms in the coupling is returned, where each of the term contains operators for each subsystem. A composite Hamiltonian puts these operators in the correct position in the tensor space to create the operators and then sum over the terms.

Parameters:

t (Array) – One time step.

Returns:

The outer list are the coupling terms. The inner list contains matrices for each subsystem. The matrices (Array) have the same shape as the subsystem’s Hamiltonian.get_matrix_one_time: (n,n) with n the subsystem dimension.

Return type:

list[list[Array]]

get_parameters()

Return the coupling coeffecient and the difference frequency.

NOTE - Optimisation using relational quantities can be optimise the drive frequencies for the two subsystems.

Parameters:

list[Quantity] – Returns the list of parameters of the system.

Return type:

list[Quantity]

gradient_one_time(t)

Get the one-time gradient of the matrix.

Returns the gradient of the matrix representation of the coupling for all subsystems. Each entry in the list is the gradient with respect to one parameter, factorised into subsystems (representing a list of term in the coupling).

Parameters:

t (Array) – One time point.

Returns:

The outer list represents the gradients with respect to all optimised parameters. The rest is in the same shape as the result of get_matrices_one_time.

Return type:

list[list[list[Array]]]

paraqeet.model.rotating_frame_drive module

Class definition of the Drive Hamiltonian in the rotating frame of drive.

class paraqeet.model.rotating_frame_drive.RotatingFrameDrive

Bases: Drive

Drive Hamiltonian in the Frame rotating at the frequency of the drive.

__signal_generator: Generator

Signal Generator without a LO, like the PWCGenerator

__init__(signal_generator)
Parameters:

signal_generator (Generator)

property generator: Generator

Get the signal generator from the system.

Returns:

Returns the signal generator object from the system.

Return type:

Generator

get_matrix_one_time(annihilation_operator, t)

Implement drive in the rotating frame of drive.

Drive Hamiltonian is implemented as \big\{ \Omega a + \Omega^* a^\dagger \big\} Where \Omega is the envelope (without the LO).

Parameters:

  • annihilation_operator (Array) – Annihilation operator of the subsystem

  • t (Array) – One time step

Return type:

Array

get_parameters()

Get a list of parameters of the system.

Returns:

List of optimizable parameters of the system.

Return type:

list[Quantity]

gradient_one_time(annihilation_operator, t)

Get the one-time gradient of the system.

Fetches the gradient from the drive and transforms it into the correct shape for the Hamiltonian.

Parameters:

  • annihilation_operator (Array) – Operator for longitudinal or transverse drive.

  • t (Array) – One-dimensional vector of timestamps.

Returns:

Returns the shape-shifted gradient from the drive.

Return type:

Array

paraqeet.model.transmon module

Class definition of the Transmon Hamiltonian model.

class paraqeet.model.transmon.Transmon

Bases: Hamiltonian

Hamiltonian of an anharmonic oscillator.

Optimisable parameters are the ground frequency and the anharmonicity.

Parameters:

  • dimension (int) – Dimension of the anharmonic oscillator.

  • frequency (Quantity) – Frequency of the anharmonic oscillator.

  • anharmonicity (Quantity) – Anharmonicity of the oscillator.

  • drives (list[Drive]) – List of time-dependent drives of the subsystem.

__init__(dimension, frequency, anharmonicity, drives=None, t1=None, temp=None, t2star=None)
Parameters:
property anharmonicity: Quantity

Get the anharmonicity of the Transmon system.

dimension()

Get the dimension of the Transmon system.

Return type:

int

property frequency: Quantity

Get the frequency of the Transmon system.

get_collapseops()

Return a list tuples of decay rates and collapse operators for each subsystem.

Returns:

List of collapse operators

Return type:

list[tuple[Array, Array]]

get_decay_rates()

Return decay rate for T1, T2star and Temp respectively.

Return type:

list[Array]

get_matrix_one_time(t)

Get the drive matrix.

Parameters:

t (Array) – Vector of time samples.

Returns:

The repeated drive matrix.

Return type:

Array

get_parameters()

Get parameters of the model.

Returns:

Returns the list of parameters of the system.

Return type:

List[Quantity]

gradient_one_time(t)

Get the gradient of the drive.

Parameters:

t (Array) – Single time stamp.

Returns:

Returns the gradients of the drive.

Return type:

Array

property t1: Quantity | None

Get the t1 of the resonator.

property t2star: Quantity | None

Get the t2star of the resonator.

property temp: Quantity | None

Get the temp of the resonator.

Module contents

Base model module.