Circuit Class
Circuit
- class SQcircuit.Circuit(elements, flux_dist='junctions', random=False)[source]
Class that contains the circuit properties and uses the theory discussed in the original paper of the SQcircuit to calculate:
Eigenvalues and eigenvectors
Phase coordinate representation of eigenvectors
Coupling operators
Matrix elements
Decoherence rates
Robustness analysis
- Parameters
elements (
Dict
[Tuple
[int
,int
],List
[Union
[Capacitor
,Inductor
,Junction
]]]) – A dictionary that contains the circuit’s elements at each branch of the circuit.random (
bool
) – If True, each element of the circuit is a random number due to fabrication error. This is necessary for robustness analysis.flux_dist (
str
) – Provide the method of distributing the external fluxes. Ifflux_dist
is"all"
, SQcircuit assign the external fluxes based on the capacitor of each inductive element (This option is necessary for time-dependent external fluxes). Ifflux_dist
is"inductor"
SQcircuit finds the external flux distribution by assuming the capacitor of the inductors are much smaller than the junction capacitors, Ifflux_dist
is"junction"
it is the other way around.
- coord_transform(var_type)[source]
Return the transformation of the coordinates as ndarray for each type of variables, either charge or flux.
- Parameters
var_type (
str
) – The type of the variables that can be either"charge"
or"flux"
.- Return type
ndarray
- coupling_op(ctype, nodes)[source]
Return the capacitive or inductive coupling operator related to the specified nodes. The output has the qutip.Qobj format.
- Parameters
ctype (
str
) – Coupling type which is either"capacitive"
or"inductive"
.nodes (
Tuple
[int
,int
]) – A tuple of circuit nodes to which we want to couple.
- Return type
Qobj
- dec_rate(dec_type, states, total=True)[source]
Return the decoherence rate in [1/s] between each two eigenstates for different types of depolarization and dephasing.
- Parameters
dec_type (
str
) – decoherence type that can be:"capacitive"
for capacitive loss;"inductive"
for inductive loss; “quasiparticle” for quasiparticle loss;"charge"
for charge noise,"flux"
for flux noise; and"cc"
for critical current noise.states (
Tuple
[int
,int
]) – A tuple of eigenstate indices, for which we want to calculate the decoherence rate. For example, forstates=(0, 1)
, we calculate the decoherence rate between the ground state and the first excited state.total (
bool
) – if False return a decoherence rate associated with a transition from state m to state n forstates=(m, n)
. if True return a decoherence rate associated with both m to n and n to m transitions.
- Return type
float
- description(tp=None, _test=False)[source]
Print out Hamiltonian and a listing of the modes (whether they are harmonic or charge modes with the frequency for each harmonic mode), Hamiltonian parameters, and external flux values.
- Parameters
tp (
Optional
[str
]) – IfNone
prints out the output as Latex if SQcircuit is running in a Jupyter notebook and as text if SQcircuit is running in Python terminal. Iftp
is"ltx"
, the output is in Latex format iftp
is"txt"
the output is in text format._test (
bool
) – if True, return the entire description as string text. (use only for testing the function)
- Return type
Optional
[str
]
- diag(n_eig)[source]
Diagonalize the Hamiltonian of the circuit and return the eigenfrequencies and eigenvectors of the circuit up to specified number of eigenvalues.
- Parameters
n_eig (
int
) – Number of eigenvalues to output. The lowern_eig
, the fasterSQcircuit
finds the eigenvalues.- Return type
Tuple
[ndarray
,List
[Qobj
]]- Returns
efreq – ndarray of eigenfrequencies in frequency unit of SQcircuit ( gigahertz by default)
evecs – List of eigenvectors in qutip.Qobj format.
- eig_phase_coord(k, grid)[source]
Return the phase coordinate representations of the eigenvectors as ndarray.
- Parameters
k (
int
) – The eigenvector index. For example, we set it to 0 for the ground state and 1 for the first excited state.grid (
Sequence
[ndarray
]) – A list that contains the range of values of phase φ for which we want to evaluate the wavefunction.
- Return type
ndarray
- hamiltonian()[source]
Returns the transformed hamiltonian of the circuit as qutip.Qobj format.
- Return type
Qobj
- loop_description(_test=False)[source]
Print out the external flux distribution over inductive elements.
- Parameters
_test (
bool
) – if True, return the entire description as string text. (use only for testing the function)- Return type
Optional
[str
]
- matrix_elements(ctype, nodes, states)[source]
Return the matrix element of two eigenstates for either capacitive or inductive coupling.
- Parameters
ctype (
str
) – Coupling type which is either"capacitive"
or"inductive"
.nodes (
Tuple
[int
,int
]) – A tuple of circuit nodes to which we want to couple.states (
Tuple
[int
,int
]) – A tuple of indices of eigenstates for which we want to calculate the matrix element.
- Return type
float
- set_charge_noise(mode, A)[source]
set the charge noise for each charge mode.
- Parameters
mode (
int
) – An integer that specifies the charge mode. To see which mode is a charge mode, we can usedescription()
method.A (
float
) – The charge noise.
- Return type
None
- set_charge_offset(mode, ng)[source]
set the charge offset for each charge mode.
- Parameters
mode (
int
) – An integer that specifies the charge mode. To see, which mode is a charge mode, one can usedescription()
method.ng (
float
) – The charge offset.
- Return type
None
- set_trunc_nums(nums)[source]
Set the truncation numbers for each mode.
- Parameters
nums (
List
[int
]) – A list that contains the truncation numbers for each mode. Harmonic modes with truncation number N are 0, 1 , …, (N-1), and charge modes with truncation number N are -(N-1), …, 0, …, (N-1).- Return type
None