FullZeroPi¶
- class scqubits.core.zeropi_full.FullZeroPi(EJ, EL, ECJ, EC, dEJ, dCJ, dC, dEL, flux, ng, zeropi_cutoff, zeta_cutoff, grid, ncut, ECS=None, truncated_dim=6, id_str=None, evals_method=None, evals_method_options=None, esys_method=None, esys_method_options=None)[source]¶
Zero-Pi qubit [Brooks2013] [Dempster2014] including coupling to the zeta mode. The circuit is described by the Hamiltonian \(H = H_{0-\pi} + H_\text{int} + H_\zeta\), where
\[\begin{split}&H_{0-\pi} = -2E_\text{CJ}\partial_\phi^2+2E_{\text{C}\Sigma}(i\partial_\theta-n_g)^2 +2E_{C\Sigma}dC_J\,\partial_\phi\partial_\theta\\ &\qquad\qquad\qquad+2E_{C\Sigma}(\delta C_J/C_J)\partial_\phi\partial_\theta +2\,\delta E_J \sin\theta\sin(\phi-\varphi_\text{ext}/2)\\ &H_\text{int} = 2E_{C\Sigma}dC\,\partial_\theta\partial_\zeta + E_L dE_L \phi\,\zeta\\ &H_\zeta = E_{\zeta} a^\dagger a\end{split}\]expressed in phase basis. The definition of the relevant charging energies \(E_\text{CJ}\), \(E_{\text{C}\Sigma}\), Josephson energies \(E_\text{J}\), inductive energies \(E_\text{L}\), and relative amounts of disorder \(dC_\text{J}\), \(dE_\text{J}\), \(dC\), \(dE_\text{L}\) follows [Groszkowski2018]. Internally, the
FullZeroPi
class formulates the Hamiltonian matrix via the product basis of the decoupled Zero-Pi qubit (seeZeroPi
) on one hand, and the zeta LC oscillator on the other hand.- Parameters:
EJ (
float
) – mean Josephson energy of the two junctionsEL (
float
) – inductive energy of the two (super-)inductorsECJ (
float
) – charging energy associated with the two junctionsEC (
float
) – charging energy of the large shunting capacitances; set to None if ECS is provided insteaddEJ (
float
) – relative disorder in EJ, i.e., (EJ1-EJ2)/EJavgdEL (
float
) – relative disorder in EL, i.e., (EL1-EL2)/ELavgdCJ (
float
) – relative disorder of the junction capacitances, i.e., (CJ1-CJ2)/CJavgdC (
float
) – relative disorder in large capacitances, i.e., (C1-C2)/Cavgng (
float
) – offset charge associated with thetazeropi_cutoff (
int
) – cutoff in the number of states of the disordered zero-pi qubitzeta_cutoff (
int
) – cutoff in the zeta oscillator basis (Fock state basis)flux (
float
) – magnetic flux through the circuit loop, measured in units of flux quanta (h/2e)grid (
Grid1d
) – specifies the range and spacing of the discretization latticencut (
int
) – charge number cutoff for n_theta, n_theta = -ncut, …, ncutECS (
float
) – total charging energy including large shunting capacitances and junction capacitances; may be provided instead of ECtruncated_dim (
int
) – desired dimension of the truncated quantum system; expected: truncated_dim > 1id_str (
Optional
[str
]) – optional string by which this instance can be referred to in HilbertSpace and ParameterSweep. If not provided, an id is auto-generated.esys_method (
Union
[Callable
,str
,None
]) – method for esys diagonalization, callable or string representationesys_method_options (
Optional
[dict
]) – dictionary with esys diagonalization optionsevals_method (
Union
[Callable
,str
,None
]) – method for evals diagonalization, callable or string representationevals_method_options (
Optional
[dict
]) – dictionary with evals diagonalization options
Methods
Returns the qubit's fundamental energy splitting, E_1 - E_0.
FullZeroPi.__init__
(EJ, EL, ECJ, EC, dEJ, ...)Returns the qubit's anharmonicity, (E_2 - E_1) - (E_1 - E_0).
FullZeroPi.broadcast
(event, **kwargs)Request a broadcast from CENTRAL_DISPATCH reporting event.
Use ipywidgets to create a new class instance
FullZeroPi.create_from_file
(filename)Read initdata and spectral data from file, and use those to create a new SpectrumData object.
Calculates a derivative of the Hamiltonian w.r.t EJ.
Calculates a derivative of the Hamiltonian w.r.t flux, at the current value of flux, as stored in the object.
FullZeroPi.d_hamiltonian_d_ng
([energy_esys])Calculates a derivative of the Hamiltonian w.r.t ng.
Return dictionary with default parameter values for initialization of class instance
FullZeroPi.deserialize
(io_data)Take the given IOData and return an instance of the described class, initialized with the data stored in io_data.
Return a list of noise channels that are used when calculating the effective noise (i.e. via t1_effective and t2_effective.
FullZeroPi.eigensys
([evals_count, filename, ...])Calculates eigenvalues and corresponding eigenvectors using scipy.linalg.eigh.
FullZeroPi.eigenvals
([evals_count, ...])Calculates eigenvalues using scipy.linalg.eigh, returns numpy array of eigenvalues.
FullZeroPi.filewrite
(filename)Convenience method bound to the class.
FullZeroPi.g_coupling_matrix
([...])Returns a matrix of coupling strengths g_{ll'} [cmp.
FullZeroPi.g_phi_coupling_matrix
(zeropi_states)Returns a matrix of coupling strengths g^phi_{ll'} [cmp.
FullZeroPi.g_theta_coupling_matrix
(zeropi_states)Returns a matrix of coupling strengths i*g^theta_{ll'} [cmp.
Calculates eigenvalues/eigenstates for a varying system parameter, given an array of parameter values.
Returns dict appropriate for creating/initializing a new Serializable object.
Calculates matrix elements for a varying system parameter, given an array of parameter values.
Returns a list of all operator names for the quantum system.
FullZeroPi.get_spectrum_vs_paramvals
(...[, ...])Calculates eigenvalues/eigenstates for a varying system parameter, given an array of parameter values.
FullZeroPi.hamiltonian
([return_parts, ...])Returns Hamiltonian in basis obtained by discretizing \(\phi\), employing charge basis for \(\theta\), and Fock basis for \(\zeta\), or in the eigenenergy basis.
Returns Hilbert space dimension
FullZeroPi.i_d_dphi_operator
([zeropi_evecs, ...])Returns \(i d/d\phi\) operator in the product or eigenenergy basis.
FullZeroPi.matrixelement_table
(operator[, ...])Returns table of matrix elements for operator with respect to the eigenstates of the qubit.
FullZeroPi.n_theta_operator
([zeropi_evecs, ...])Returns \(n_\theta\) operator in the product or eigenenergy basis.
FullZeroPi.phi_operator
([zeropi_evecs, ...])Returns \(\phi\) operator in the product or eigenenergy basis.
Show plots of coherence for various channels supported by the qubit as they vary as a function of a changing parameter.
Generates a simple plot of a set of curves representing the charge or flux dispersion of transition energies.
FullZeroPi.plot_evals_vs_paramvals
(...[, ...])Generates a simple plot of a set of eigenvalues as a function of one parameter.
FullZeroPi.plot_matelem_vs_paramvals
(...[, ...])Generates a simple plot of a set of eigenvalues as a function of one parameter.
FullZeroPi.plot_matrixelements
(operator[, ...])Plots matrix elements for operator, given as a string referring to a class method that returns an operator matrix.
Plot effective \(T_1\) coherence time (rate) as a function of changing parameter.
Plot effective \(T_2\) coherence time (rate) as a function of changing parameter.
FullZeroPi.process_hamiltonian
(...[, ...])Return qubit Hamiltonian in chosen basis: either return unchanged (i.e., in native basis) or transform into eigenenergy basis
FullZeroPi.process_op
(native_op[, energy_esys])Processes the operator native_op: either hand back native_op unchanged, or transform it into the energy eigenbasis.
FullZeroPi.receive
(event, sender, **kwargs)Receive a message from CENTRAL_DISPATCH and initiate action on it.
Convert the content of the current class instance into IOData format.
Helper function to set EC by providing ECS, keeping ECJ constant.
FullZeroPi.set_E_zeta
(value)- rtype:
None
FullZeroPi.set_and_return
(attr_name, value)Allows to set an attribute after which self is returned. This is useful for doing something like example::.
FullZeroPi.set_params
(**kwargs)Set new parameters through the provided dictionary.
FullZeroPi.set_params_from_gui
(**kwargs)Set new parameters through the provided dictionary.
Return a list of supported noise channels
FullZeroPi.t1
(i, j, noise_op, spectral_density)Calculate the transition time (or rate) using Fermi's Golden Rule due to a noise channel with a spectral density spectral_density and system noise operator noise_op.
FullZeroPi.t1_capacitive
([i, j, Q_cap, T, ...])\(T_1\) due to dielectric dissipation in the Josephson junction capacitances.
FullZeroPi.t1_charge_impedance
([i, j, Z, T, ...])Noise due to charge coupling to an impedance (such as a transmission line).
FullZeroPi.t1_effective
([noise_channels, ...])Calculate the effective \(T_1\) time (or rate).
FullZeroPi.t1_flux_bias_line
([i, j, M, Z, ...])Noise due to a bias flux line.
FullZeroPi.t1_inductive
([i, j, Q_ind, T, ...])\(T_1\) due to inductive dissipation in a superinductor.
FullZeroPi.t1_quasiparticle_tunneling
([i, ...])Noise due to quasiparticle tunneling across a Josephson junction.
FullZeroPi.t2_effective
([noise_channels, ...])Calculate the effective \(T_2\) time (or rate).
FullZeroPi.tphi_1_over_f
(A_noise, i, j, noise_op)Calculate the 1/f dephasing time (or rate) due to arbitrary noise source.
FullZeroPi.tphi_1_over_f_cc
([A_noise, i, j, ...])Calculate the 1/f dephasing time (or rate) due to critical current noise.
FullZeroPi.tphi_1_over_f_flux
([A_noise, i, ...])Calculate the 1/f dephasing time (or rate) due to flux noise.
FullZeroPi.tphi_1_over_f_ng
([A_noise, i, j, ...])Calculate the 1/f dephasing time (or rate) due to charge noise.
FullZeroPi.widget
([params])Use ipywidgets to modify parameters of class instance
Attributes
EC
Descriptor class for properties that are to be monitored for changes.
ECJ
Descriptor class for properties that are to be monitored for changes.
ECS
Descriptor class for properties that are to be monitored for changes.
EJ
Descriptor class for properties that are to be monitored for changes.
EL
Descriptor class for properties that are to be monitored for changes.
Returns energy quantum of the zeta mode
dC
Descriptor class for properties that are to be monitored for changes.
dCJ
Descriptor class for properties that are to be monitored for changes.
dEJ
Descriptor class for properties that are to be monitored for changes.
dEL
Descriptor class for properties that are to be monitored for changes.
esys_method
esys_method_options
evals_method
evals_method_options
flux
Descriptor class for properties that are to be monitored for changes.
grid
Descriptor class for properties that are to be monitored for changes.
id_str
ncut
Descriptor class for properties that are to be monitored for changes.
ng
Descriptor class for properties that are to be monitored for changes.
truncated_dim
Descriptor class for properties that are to be monitored for changes.
zeropi_cutoff
Descriptor class for properties that are to be monitored for changes.
- E01()¶
Returns the qubit’s fundamental energy splitting, E_1 - E_0.
- Return type:
float
- property E_zeta: float¶
Returns energy quantum of the zeta mode
- anharmonicity()¶
Returns the qubit’s anharmonicity, (E_2 - E_1) - (E_1 - E_0).
- Return type:
float
- broadcast(event, **kwargs)¶
Request a broadcast from CENTRAL_DISPATCH reporting event.
- Parameters:
event (
str
) – event name from EVENTS**kwargs
- Return type:
None
- classmethod create_from_file(filename)¶
Read initdata and spectral data from file, and use those to create a new SpectrumData object.
- Returns:
new SpectrumData object, initialized with data read from file
- Return type:
- Parameters:
filename (str)
- d_hamiltonian_d_EJ(zeropi_evecs=None, energy_esys=False)[source]¶
Calculates a derivative of the Hamiltonian w.r.t EJ. The returned operator is in the product basis or eigenenergy basis.
Helper method _zeropi_operator_in_product_basis is employed which converts a zeropi operator into one in the product basis. If user already has zeropi eigenvectors, user can input as zeropi_evecs=ndarray.
- Parameters:
zeropi_evecs (
ndarray
) – If None (default), helper method _zeropi_operator_in_product_basis calculates zeropi eigenvectors and uses them to convert operator to the product basis, if product basis is chosen. If zeropi_evecs = zeropievecs, where zeropievecs is an ndarray, and product basis is chosen, helper method _zeropi_operator_in_product_basis uses zeropievecs to convert the operator to the product basis.energy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns operator in the product basis. If True, the energy eigenspectrum is computed, returns operator in the energy eigenbasis. If energy_esys = esys, where esys is a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns operator in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
Operator in chosen basis. If product basis chosen, operator returned as a csc_matrix. If the eigenenergy basis is chosen, unless energy_esys is specified, operator has dimensions of truncated_dim x truncated_dim, and is returned as an ndarray. Otherwise, if eigenenergy basis is chosen, operator has dimensions of m x m, for m given eigenvectors, and is returned as an ndarray.
- d_hamiltonian_d_flux(zeropi_evecs=None, energy_esys=False)[source]¶
Calculates a derivative of the Hamiltonian w.r.t flux, at the current value of flux, as stored in the object. The returned operator is in the product basis or eigenenergy basis.
Helper method _zeropi_operator_in_product_basis is employed which converts a zeropi operator into one in the product basis. If user already has zeropi eigenvectors, user can input as zeropi_evecs=ndarray.
- Parameters:
zeropi_evecs (
ndarray
) – If None (default), helper method _zeropi_operator_in_product_basis calculates zeropi eigenvectors and uses them to convert operator to the product basis, if product basis is chosen. If zeropi_evecs = zeropievecs, where zeropievecs is an ndarray, and product basis is chosen, helper method _zeropi_operator_in_product_basis uses zeropievecs to convert the operator to the product basis.energy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns operator in the product basis. If True, the energy eigenspectrum is computed, returns operator in the energy eigenbasis. If energy_esys = esys, where esys is a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns operator in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
Operator in chosen basis. If product basis is chosen, operator returned as a csc_matrix. If the eigenenergy basis is chosen, unless energy_esys is specified, operator has dimensions of truncated_dim x truncated_dim, and is returned as an ndarray. Otherwise, if eigenenergy basis is chosen, operator has dimensions of m x m, for m given eigenvectors, and is returned as an ndarray.
- d_hamiltonian_d_ng(energy_esys=False)[source]¶
Calculates a derivative of the Hamiltonian w.r.t ng. Returns matrix representing a derivative of the Hamiltonian in the native Hamiltonian basis or eigenenergy basis.
- Parameters:
energy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns operator in the native basis. If True, the energy eigenspectrum is computed, returns operator in the energy eigenbasis. If energy_esys = esys, where esys is a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns operator in the energy eigenbasis, and does not have to recalculate eigenspectrum.- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
Operator in chosen basis. If native basis chosen, operator returned as a csc_matrix. If the eigenenergy basis is chosen, unless energy_esys is specified, operator has dimensions of truncated_dim x truncated_dim, and is returned as an ndarray. Otherwise, if eigenenergy basis is chosen, operator has dimensions of m x m, for m given eigenvectors, and is returned as an ndarray.
- static default_params()[source]¶
Return dictionary with default parameter values for initialization of class instance
- Return type:
Dict
[str
,Any
]
- classmethod deserialize(io_data)¶
Take the given IOData and return an instance of the described class, initialized with the data stored in io_data.
- Return type:
TypeVar
(SerializableType
, bound= Serializable)- Parameters:
io_data (IOData)
- classmethod effective_noise_channels()¶
Return a list of noise channels that are used when calculating the effective noise (i.e. via t1_effective and t2_effective.
- Return type:
List
[str
]
- eigensys(evals_count=6, filename=None, return_spectrumdata=False)¶
Calculates eigenvalues and corresponding eigenvectors using scipy.linalg.eigh. Returns two numpy arrays containing the eigenvalues and eigenvectors, respectively.
- Parameters:
evals_count (
int
) – number of desired eigenvalues/eigenstates (default value = 6)filename (
Optional
[str
]) – path and filename without suffix, if file output desired (default value = None)return_spectrumdata (if set to true, the returned data is provided as a SpectrumData object) – (default value = False)
- Return type:
Union
[Tuple
[ndarray
,ndarray
],SpectrumData
]- Returns:
eigenvalues, eigenvectors as numpy arrays or in form of a SpectrumData object
- eigenvals(evals_count=6, filename=None, return_spectrumdata=False)¶
Calculates eigenvalues using scipy.linalg.eigh, returns numpy array of eigenvalues.
- Parameters:
evals_count (
int
) – number of desired eigenvalues/eigenstates (default value = 6)filename (
Optional
[str
]) – path and filename without suffix, if file output desired (default value = None)return_spectrumdata (
bool
) – if set to true, the returned data is provided as a SpectrumData object (default value = False)
- Return type:
Union
[SpectrumData
,ndarray
]- Returns:
eigenvalues as ndarray or in form of a SpectrumData object
- filewrite(filename)¶
Convenience method bound to the class. Simply accesses the write function.
- Return type:
None
- Parameters:
filename (str)
- g_coupling_matrix(zeropi_states=None, evals_count=None)[source]¶
Returns a matrix of coupling strengths g_{ll’} [cmp. Dempster et al., text above Eq. (17)], using the states from ‘zeropi_states’. If zeropi_states==None, then a set of self.zeropi eigenstates is calculated. Only in that case is which used for the eigenstate number (and hence the coupling matrix size).
- Return type:
ndarray
- Parameters:
zeropi_states (ndarray)
evals_count (int)
- g_phi_coupling_matrix(zeropi_states)[source]¶
Returns a matrix of coupling strengths g^phi_{ll’} [cmp. Dempster et al., Eq. (18)], using the states from the list zeropi_states. Most commonly, zeropi_states will contain eigenvectors of the DisorderedZeroPi type.
- Return type:
ndarray
- Parameters:
zeropi_states (ndarray)
- g_theta_coupling_matrix(zeropi_states)[source]¶
Returns a matrix of coupling strengths i*g^theta_{ll’} [cmp. Dempster et al., Eq. (17)], using the states from the list ‘zeropi_states’.
- Return type:
ndarray
- Parameters:
zeropi_states (ndarray)
- get_dispersion_vs_paramvals(dispersion_name, param_name, param_vals, ref_param=None, transitions=(0, 1), levels=None, point_count=50, num_cpus=None)¶
Calculates eigenvalues/eigenstates for a varying system parameter, given an array of parameter values. Returns a SpectrumData object with energy_data[n] containing eigenvalues calculated for parameter value param_vals[n].
- Parameters:
dispersion_name (
str
) – parameter inducing the dispersion, typically ‘ng’ or ‘flux’ (will be scanned over range from 0 to 1)param_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged inref_param (
Optional
[str
]) – optional, name of parameter to use as reference for the parameter value; e.g., to compute charge dispersion vs. EJ/EC, use EJ as param_name and EC as ref_paramtransitions (
Union
[Tuple
[int
,int
],Tuple
[Tuple
[int
,int
],...
]]) – integer tuple or tuples specifying for which transitions dispersion is to be calculated (default: = (0,1))levels (
Union
[int
,Tuple
[int
,...
],None
]) – tuple specifying levels (rather than transitions) for which dispersion should be plotted; overrides transitions parameter when givenpoint_count (
int
) – number of points scanned for the dispersion parameter for determining min and max values of transition energies (default: 50)num_cpus (
Optional
[int
]) – number of cores to be used for computation (default value: settings.NUM_CPUS)
- Return type:
- get_initdata()¶
Returns dict appropriate for creating/initializing a new Serializable object.
- Return type:
Dict
[str
,Any
]
- get_matelements_vs_paramvals(operator, param_name, param_vals, evals_count=6, num_cpus=None)¶
Calculates matrix elements for a varying system parameter, given an array of parameter values. Returns a SpectrumData object containing matrix element data, eigenvalue data, and eigenstate data..
- Parameters:
operator (
str
) – name of class method in string form, returning operator matrixparam_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged inevals_count (
int
) – number of desired eigenvalues (sorted from smallest to largest) (default value = 6)num_cpus (
Optional
[int
]) – number of cores to be used for computation (default value: settings.NUM_CPUS)
- Return type:
- classmethod get_operator_names()¶
Returns a list of all operator names for the quantum system. Note that this list omits any operators that start with “_”.
- Parameters:
subsys – Class instance of quantum system
- Return type:
List
[str
]- Returns:
list of operator names
- get_spectrum_vs_paramvals(param_name, param_vals, evals_count=6, subtract_ground=False, get_eigenstates=False, filename=None, num_cpus=None)¶
Calculates eigenvalues/eigenstates for a varying system parameter, given an array of parameter values. Returns a SpectrumData object with energy_data[n] containing eigenvalues calculated for parameter value param_vals[n].
- Parameters:
param_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged inevals_count (
int
) – number of desired eigenvalues (sorted from smallest to largest) (default value = 6)subtract_ground (
bool
) – if True, eigenvalues are returned relative to the ground state eigenvalue (default value = False)get_eigenstates (
bool
) – return eigenstates along with eigenvalues (default value = False)filename (
str
) – file name if direct output to disk is wantednum_cpus (
Optional
[int
]) – number of cores to be used for computation (default value: settings.NUM_CPUS)
- Return type:
- hamiltonian(return_parts=False, energy_esys=False)[source]¶
Returns Hamiltonian in basis obtained by discretizing \(\phi\), employing charge basis for \(\theta\), and Fock basis for \(\zeta\), or in the eigenenergy basis.
- Parameters:
return_parts (
bool
) – If set to true, hamiltonian returns [hamiltonian, evals, evecs, g_coupling_matrix]energy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns Hamiltonian in native Hamiltonian basis If True, the energy eigenspectrum is computed, returns Hamiltonian in the energy eigenbasis. If energy_esys = esys, where esys is a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns Hamiltonian in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[csc_matrix
,Tuple
[csc_matrix
,ndarray
,ndarray
,ndarray
]]- Returns:
Hamiltonian in chosen basis as csc_matrix. If the eigenenergy basis is chosen, unless energy_esys is specified, the Hamiltonian has dimensions of truncated_dim x truncated_dim. Otherwise, if eigenenergy basis is chosen, Hamiltonian has dimensions of m x m, for m given eigenvectors.
- i_d_dphi_operator(zeropi_evecs=None, energy_esys=False)[source]¶
Returns \(i d/d\phi\) operator in the product or eigenenergy basis.
Helper method _zeropi_operator_in_product_basis is employed which converts a zeropi operator into one in the product basis. If user already has zeropi eigenvectors, user can input as zeropi_evecs=ndarray.
- Parameters:
zeropi_evecs (
ndarray
) – If None (default), helper method _zeropi_operator_in_product_basis calculates zeropi eigenvectors and uses them to convert operator to the product basis, if product basis is chosen. If zeropi_evecs = zeropievecs, where zeropievecs is an ndarray, and product basis is chosen, helper method _zeropi_operator_in_product_basis uses zeropievecs to convert the operator to the product basis.energy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns operator in the product basis. If True, the energy eigenspectrum is computed, returns operator in the energy eigenbasis. If energy_esys = esys, where esys is a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns operator in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
Operator in chosen basis. If product basis chosen, operator returned as a csc_matrix. If the eigenenergy basis is chosen, unless energy_esys is specified, operator has dimensions of truncated_dim x truncated_dim, and is returned as an ndarray. Otherwise, if eigenenergy basis is chosen, operator has dimensions of m x m, for m given eigenvectors, and is returned as an ndarray.
- matrixelement_table(operator, evecs=None, evals_count=6, filename=None, return_datastore=False)¶
Returns table of matrix elements for operator with respect to the eigenstates of the qubit. The operator is given as a string matching a class method returning an operator matrix. E.g., for an instance trm of Transmon, the matrix element table for the charge operator is given by trm.op_matrixelement_table(‘n_operator’). When esys is set to None, the eigensystem is calculated on-the-fly.
- Parameters:
operator (
str
) – name of class method in string form, returning operator matrix in qubit-internal basis.evecs (
ndarray
) – if not provided, then the necessary eigenstates are calculated on the flyevals_count (
int
) – number of desired matrix elements, starting with ground state (default value = 6)filename (
str
) – output file namereturn_datastore (
bool
) – if set to true, the returned data is provided as a DataStore object (default value = False)
- Return type:
Union
[DataStore
,ndarray
]
- n_theta_operator(zeropi_evecs=None, energy_esys=False)[source]¶
Returns \(n_\theta\) operator in the product or eigenenergy basis.
Helper method _zeropi_operator_in_product_basis is employed which converts a zeropi operator into one in the product basis. If user already has zeropi eigenvectors, user can input as zeropi_evecs=ndarray.
- Parameters:
zeropi_evecs (
ndarray
) – If None (default), helper method _zeropi_operator_in_product_basis calculates zeropi eigenvectors and uses them to convert operator to the product basis, if product basis is chosen. If zeropi_evecs = zeropievecs, where zeropievecs is an ndarray, and product basis is chosen, helper method _zeropi_operator_in_product_basis uses zeropievecs to convert the operator to the product basis.energy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns operator in the product basis. If True, the energy eigenspectrum is computed, returns operator in the energy eigenbasis. If energy_esys = esys, where esys is a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns operator in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
Operator in chosen basis. If product basis chosen, operator returned as a csc_matrix. If the eigenenergy basis is chosen, unless energy_esys is specified, operator has dimensions of truncated_dim x truncated_dim, and is returned as an ndarray. Otherwise, if eigenenergy basis is chosen, operator has dimensions of m x m, for m given eigenvectors, and is returned as an ndarray.
- phi_operator(zeropi_evecs=None, energy_esys=False)[source]¶
Returns \(\phi\) operator in the product or eigenenergy basis.
Helper method _zeropi_operator_in_product_basis is employed which converts a zeropi operator into one in the product basis. If user already has zeropi eigenvectors, user can input as zeropi_evecs=ndarray.
- Parameters:
zeropi_evecs (
ndarray
) – If None (default), helper method _zeropi_operator_in_product_basis calculates zeropi eigenvectors and uses them to convert operator to the product basis, if product basis is chosen. If zeropi_evecs = zeropievecs, where zeropievecs is an ndarray, and product basis is chosen, helper method _zeropi_operator_in_product_basis uses zeropievecs to convert the operator to the product basis.energy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns operator in the product basis. If True, the energy eigenspectrum is computed, returns operator in the energy eigenbasis. If energy_esys = esys, where esys is a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns operator in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
Operator in chosen basis. If product basis chosen, operator returned as a csc_matrix. If the eigenenergy basis is chosen, unless energy_esys is specified, operator has dimensions of truncated_dim x truncated_dim, and is returned as an ndarray. Otherwise, if eigenenergy basis is chosen, operator has dimensions of m x m, for m given eigenvectors, and is returned as an ndarray.
- plot_coherence_vs_paramvals(param_name, param_vals, noise_channels=None, common_noise_options=None, spectrum_data=None, scale=1, num_cpus=None, **kwargs)¶
Show plots of coherence for various channels supported by the qubit as they vary as a function of a changing parameter.
For example, assuming qubit is a qubit object with flux being one of its parameters, one can see how coherence due to various noise channels vary as the flux changes:
qubit.plot_coherence_vs_paramvals(param_name='flux', param_vals=np.linspace(-0.5, 0.5, 100), scale=1e-3, ylabel=r"$\mu s$");
- Parameters:
param_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged innoise_channels (
Union
[str
,List
[str
],List
[Tuple
[str
,Dict
]]]) – channels to be plotted, if None then noise channels given by supported_noise_channels are usedcommon_noise_options (
Dict
) – common options used when calculating coherence timesspectrum_data (
SpectrumData
) – spectral data used during noise calculationsscale (float) – a number that all data is multiplied by before being plotted
num_cpus (
Optional
[int
]) – number of cores to be used for computation
- Return type:
Figure, Axes
- plot_dispersion_vs_paramvals(dispersion_name, param_name, param_vals, ref_param=None, transitions=(0, 1), levels=None, point_count=50, num_cpus=None, **kwargs)¶
Generates a simple plot of a set of curves representing the charge or flux dispersion of transition energies.
- Parameters:
dispersion_name (
str
) – parameter inducing the dispersion, typically ‘ng’ or ‘flux’ (will be scanned over range from 0 to 1)param_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged inref_param (
Optional
[str
]) – optional, name of parameter to use as reference for the parameter value; e.g., to compute charge dispersion vs. EJ/EC, use EJ as param_name and EC as ref_paramtransitions (
Union
[Tuple
[int
,int
],Tuple
[Tuple
[int
,int
],...
]]) – integer tuple or tuples specifying for which transitions dispersion is to be calculated (default: = (0,1))levels (
Union
[int
,Tuple
[int
,...
],None
]) – int or tuple specifying level(s) (rather than transitions) for which dispersion should be plotted; overrides transitions parameter when givenpoint_count (
int
) – number of points scanned for the dispersion parameter for determining min and max values of transition energies (default: 50)num_cpus (
Optional
[int
]) – number of cores to be used for computation (default value: settings.NUM_CPUS)**kwargs – standard plotting option (see separate documentation)
- Return type:
Tuple
[Figure
,Axes
]
- plot_evals_vs_paramvals(param_name, param_vals, evals_count=6, subtract_ground=False, num_cpus=None, **kwargs)¶
Generates a simple plot of a set of eigenvalues as a function of one parameter. The individual points correspond to the a provided array of parameter values.
- Parameters:
param_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged inevals_count (
int
) – number of desired eigenvalues (sorted from smallest to largest) (default value = 6)subtract_ground (
bool
) – whether to subtract ground state energy from all eigenvalues (default value = False)num_cpus (
Optional
[int
]) – number of cores to be used for computation (default value: settings.NUM_CPUS)**kwargs – standard plotting option (see separate documentation)
- Return type:
Tuple
[Figure
,Axes
]
- plot_matelem_vs_paramvals(operator, param_name, param_vals, select_elems=4, mode='abs', num_cpus=None, **kwargs)¶
Generates a simple plot of a set of eigenvalues as a function of one parameter. The individual points correspond to the a provided array of parameter values.
- Parameters:
operator (
str
) – name of class method in string form, returning operator matrixparam_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged inselect_elems (
Union
[int
,List
[Tuple
[int
,int
]]]) – either maximum index of desired matrix elements, or list [(i1, i2), (i3, i4), …] of index tuples for specific desired matrix elements (default value = 4)mode (
str
) – idx_entry from MODE_FUNC_DICTIONARY, e.g., ‘abs’ for absolute value (default value = ‘abs’)num_cpus (
Optional
[int
]) – number of cores to be used for computation (default value: settings.NUM_CPUS)**kwargs – standard plotting option (see separate documentation)
- Return type:
Tuple
[Figure
,Axes
]
- plot_matrixelements(operator, evecs=None, evals_count=6, mode='abs', show_numbers=False, show3d=True, **kwargs)¶
Plots matrix elements for operator, given as a string referring to a class method that returns an operator matrix. E.g., for instance trm of Transmon, the matrix element plot for the charge operator n is obtained by trm.plot_matrixelements(‘n’). When esys is set to None, the eigensystem with which eigenvectors is calculated.
- Parameters:
operator (
str
) – name of class method in string form, returning operator matrixevecs (
ndarray
) – eigensystem data of evals, evecs; eigensystem will be calculated if set to None (default value = None)evals_count (
int
) – number of desired matrix elements, starting with ground state (default value = 6)mode (
str
) – idx_entry from MODE_FUNC_DICTIONARY, e.g., ‘abs’ for absolute value (default)show_numbers (
bool
) – determines whether matrix element values are printed on top of the plot (default: False)show3d (
bool
) – whether to show a 3d skyscraper plot of the matrix alongside the 2d plot (default: True)**kwargs – standard plotting option (see separate documentation)
- Return type:
Union
[Tuple
[Figure
,Tuple
[Axes
,Axes
]],Tuple
[Figure
,Axes
]]
- plot_t1_effective_vs_paramvals(param_name, param_vals, noise_channels=None, common_noise_options=None, spectrum_data=None, get_rate=False, scale=1, num_cpus=None, **kwargs)¶
Plot effective \(T_1\) coherence time (rate) as a function of changing parameter.
The effective \(T_1\) is calculated by considering a variety of depolarizing noise channels, according to the formula:
\[\frac{1}{T_{1}^{\rm eff}} = \frac{1}{2} \sum_k \frac{1}{T_{1}^{k}}\]where \(k\) runs over the channels that can contribute to the effective noise. By default all the depolarizing noise channels given by the method effective_noise_channels are included.
For example, assuming qubit is a qubit object with flux being one of its parameters, one can see how the effective \(T_1\) varies as the flux changes:
qubit.plot_t1_effective_vs_paramvals(param_name='flux', param_vals=np.linspace(-0.5, 0.5, 100), );
- Parameters:
param_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged innoise_channels (
Union
[str
,List
[str
],List
[Tuple
[str
,Dict
]]]) – channels to be plotted, if None then noise channels given by supported_noise_channels are usedcommon_noise_options (
Dict
) – common options used when calculating coherence timesspectrum_data (
SpectrumData
) – spectral data used during noise calculationsget_rate (
bool
) – determines if rate or time should be plottedscale (
float
) – a number that all data is multiplied by before being plottednum_cpus (
Optional
[int
]) – number of cores to be used for computation
- Return type:
Figure, Axes
- plot_t2_effective_vs_paramvals(param_name, param_vals, noise_channels=None, common_noise_options=None, spectrum_data=None, get_rate=False, scale=1, num_cpus=None, **kwargs)¶
Plot effective \(T_2\) coherence time (rate) as a function of changing parameter.
The effective \(T_2\) is calculated from both pure dephasing channels, as well as depolarization channels, according to the formula:
\[\frac{1}{T_{2}^{\rm eff}} = \sum_k \frac{1}{T_{\phi}^{k}} + \frac{1}{2} \sum_j \frac{1}{T_{1}^{j}}\]where \(k\) (\(j\)) run over the relevant pure dephasing ( depolarization) channels that can contribute to the effective noise. By default all noise channels given by the method effective_noise_channels are included.
For example, assuming qubit is a qubit object with flux being one of its parameters, one can see how the effective \(T_2\) varies as the flux changes:
qubit.plot_t2_effective_vs_paramvals(param_name='flux', param_vals=np.linspace(-0.5, 0.5, 100), );
- Parameters:
param_name (
str
) – name of parameter to be variedparam_vals (
ndarray
) – parameter values to be plugged innoise_channels (
Union
[str
,List
[str
],List
[Tuple
[str
,Dict
]]]) – channels to be plotted, if None then noise channels given by supported_noise_channels are usedcommon_noise_options (
Dict
) – common options used when calculating coherence timesspectrum_data (
SpectrumData
) – spectral data used during noise calculationsget_rate (
bool
) – determines if rate or time should be plottedscale (
float
) – a number that all data is multiplied by before being plottednum_cpus (
Optional
[int
]) – number of cores to be used for computation
- Return type:
Figure, Axes
- process_hamiltonian(native_hamiltonian, energy_esys=False)¶
Return qubit Hamiltonian in chosen basis: either return unchanged (i.e., in native basis) or transform into eigenenergy basis
- Parameters:
native_hamiltonian (
Union
[ndarray
,csc_matrix
]) – Hamiltonian in native basisenergy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns Hamiltonian in the native basis If True, the energy eigenspectrum is computed, returns Hamiltonian in the energy eigenbasis if energy_esys is the energy eigenspectrum, in the form of a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns Hamiltonian in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
Hamiltonian, either unchanged in native basis, or transformed into eigenenergy basis
- process_op(native_op, energy_esys=False)¶
Processes the operator native_op: either hand back native_op unchanged, or transform it into the energy eigenbasis. (Native basis refers to the basis used internally by each qubit, e.g., charge basis in the case of Transmon.
- Parameters:
native_op (
Union
[ndarray
,csc_matrix
]) – operator in native basisenergy_esys (
Union
[bool
,Tuple
[ndarray
,ndarray
]]) – If False (default), returns operator in the native basis If True, the energy eigenspectrum is computed, returns operator in the energy eigenbasis if energy_esys is the energy eigenspectrum, in the form of a tuple containing two ndarrays (eigenvalues and energy eigenvectors), returns operator in the energy eigenbasis, and does not have to recalculate eigenspectrum.
- Return type:
Union
[ndarray
,csc_matrix
]- Returns:
native_op either unchanged or transformed into eigenenergy basis
- receive(event, sender, **kwargs)[source]¶
Receive a message from CENTRAL_DISPATCH and initiate action on it.
- Parameters:
event (
str
) – event name from EVENTSsender (
object
) – original sender reporting the event**kwargs
- Return type:
None
- serialize()¶
Convert the content of the current class instance into IOData format.
- Return type:
- set_EC_via_ECS(ECS)[source]¶
Helper function to set EC by providing ECS, keeping ECJ constant.
- Return type:
None
- Parameters:
ECS (float)
- set_and_return(attr_name, value)¶
Allows to set an attribute after which self is returned. This is useful for doing something like example:
qubit.set_and_return('flux', 0.23).some_method()
instead of example:
qubit.flux=0.23 qubit.some_method()
- Parameters:
attr_name (
str
) – name of class attribute in string formvalue (
Any
) – value that the attribute is to be set to
- Return type:
- Returns:
self
- set_params(**kwargs)¶
Set new parameters through the provided dictionary.
- set_params_from_gui(**kwargs)[source]¶
Set new parameters through the provided dictionary.
- Return type:
None
- classmethod supported_noise_channels()[source]¶
Return a list of supported noise channels
- Return type:
List
[str
]
- t1(i, j, noise_op, spectral_density, T=0.015, total=True, esys=None, get_rate=False)¶
Calculate the transition time (or rate) using Fermi’s Golden Rule due to a noise channel with a spectral density spectral_density and system noise operator noise_op. Mathematically, it reads:
\[\frac{1}{T_1} = \frac{1}{\hbar^2} |\langle i| A_{\rm noise} | j \rangle|^2 S(\omega)\]We assume that the qubit energies (or the passed in eigenspectrum) has units of frequency (and not angular frequency).
The spectral_density argument should be a callable object (typically a function) of one argument, which is assumed to be an angular frequency (in the units currently set as system units.
- Parameters:
i (int >=0) – state index that along with j defines a transition (i->j)
j (int >=0) – state index that along with i defines a transition (i->j)
noise_op (
Union
[ndarray
,csc_matrix
]) – noise operatorT (
float
) – Temperature defined in Kelvinspectral_density (
Callable
) – defines a spectral density, must take two arguments: omega and T (assumed to be in units of 2 pi * <system units>)total (
bool
) – if False return a time/rate associated with a transition from state i to state j. if True return a time/rate associated with both i to j and j to i transitionsesys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or time
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- t1_capacitive(i=1, j=0, Q_cap=None, T=0.015, total=True, esys=None, get_rate=False, noise_op=None, branch_params=None)¶
\(T_1\) due to dielectric dissipation in the Josephson junction capacitances.
References: Smith et al (2020), see also Nguyen et al (2019).
- Parameters:
i (int >=0) – state index that along with j defines a transition (i->j)
j (int >=0) – state index that along with i defines a transition (i->j)
Q_cap (
Union
[float
,Callable
]) – capacitive quality factor; a fixed value or function of omegaT (
float
) – temperature in Kelvintotal (
bool
) – if False return a time/rate associated with a transition from state i to state j. if True return a time/rate associated with both i to j and j to i transitionsesys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or timenoise_op (ndarray | csc_matrix | Qobj | None)
branch_params (dict | None)
- Returns:
time or rate –
- decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate
in inverse units.
- Return type:
float
- t1_charge_impedance(i=1, j=0, Z=50, T=0.015, total=True, esys=None, get_rate=False, noise_op=None)¶
Noise due to charge coupling to an impedance (such as a transmission line).
References: Schoelkopf et al (2003), Ithier et al (2005)
- Parameters:
i (int >=0) – state index that along with j defines a transition (i->j)
j (int >=0) – state index that along with i defines a transition (i->j)
Z (
Union
[float
,Callable
]) – impedance; a fixed value or function of omegaT (
float
) – temperature in Kelvintotal (
bool
) – if False return a time/rate associated with a transition from state i to state j. if True return a time/rate associated with both i to j and j to i transitionsesys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or timenoise_op (ndarray | csc_matrix | Qobj | None)
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- t1_effective(noise_channels=None, common_noise_options=None, esys=None, get_rate=False, **kwargs)¶
Calculate the effective \(T_1\) time (or rate).
The effective \(T_1\) is calculated by considering a variety of depolarizing noise channels, according to the formula:
\[\frac{1}{T_{1}^{\rm eff}} = \frac{1}{2} \sum_k \frac{1}{T_{1}^{k}}\]where \(k\) runs over the channels that can contribute to the effective noise. By default all the depolarizing noise channels given by the method effective_noise_channels are included. Users can also provide specific noise channels, with selected options, to be included in the effective \(T_1\) calculation. For example, assuming qubit is a qubit object, can can execute:
tune_tmon.t1_effective(noise_channels=['t1_charge_impedance', 't1_flux_bias_line'], common_noise_options=dict(T=0.050))
- Parameters:
noise_channels (
Union
[str
,List
[str
],List
[Tuple
[str
,Dict
]]]) – channels to be plotted, if None then noise channels given by supported_noise_channels are usedcommon_noise_options (
Dict
) – common options used when calculating coherence timesesys (
Tuple
[ndarray
,ndarray
]) – spectral data used during noise calculationsget_rate (
bool
) – get rate or time
- Return type:
float
- Returns:
- decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate
in inverse units.
- t1_flux_bias_line(i=1, j=0, M=400, Z=50, T=0.015, total=True, esys=None, get_rate=False, noise_op_method=None)¶
Noise due to a bias flux line.
References: Koch et al (2007), Groszkowski et al (2018)
- Parameters:
i (int >=0) – state index that along with j defines a transition (i->j)
j (int >=0) – state index that along with i defines a transition (i->j)
M (
float
) – Inductance in units of Phi_0 / AmpereZ (
Union
[complex
,float
,Callable
]) – A complex impedance; a fixed value or function of omegaT (
float
) – temperature in Kelvintotal (
bool
) – if False return a time/rate associated with a transition from state i to state j. if True return a time/rate associated with both i to j and j to i transitionsesys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or timenoise_op_method (Callable | None)
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- t1_inductive(i=1, j=0, Q_ind=None, T=0.015, total=True, esys=None, get_rate=False, noise_op=None, branch_params=None)¶
\(T_1\) due to inductive dissipation in a superinductor.
References: Smith et al (2020), see also Nguyen et al (2019).
- Parameters:
i (int >=0) – state index that along with j defines a transition (i->j)
j (int >=0) – state index that along with i defines a transition (i->j)
Q_ind (
Union
[float
,Callable
]) – inductive quality factor; a fixed value or function of omegaT (
float
) – temperature in Kelvintotal (
bool
) – if False return a time/rate associated with a transition from state i to state j. if True return a time/rate associated with both i to j and j to i transitionsesys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or timenoise_op (ndarray | csc_matrix | Qobj | None)
branch_params (dict | None)
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- t1_quasiparticle_tunneling(i=1, j=0, Y_qp=None, x_qp=3e-06, T=0.015, Delta=0.00034, total=True, esys=None, get_rate=False, noise_op=None)¶
Noise due to quasiparticle tunneling across a Josephson junction.
References: Smith et al (2020), Catelani et al (2011), Pop et al (2014).
- Parameters:
i (int >=0) – state index that along with j defines a transition (i->j)
j (int >=0) – state index that along with i defines a transition (i->j)
Y_qp (
Union
[float
,Callable
]) – complex admittance; a fixed value or function of omegax_qp (
float
) – quasiparticle density (in units of eV)T (
float
) – temperature in KelvinDelta (
float
) – superconducting gap (in units of eV)total (
bool
) – if False return a time/rate associated with a transition from state i to state j. if True return a time/rate associated with both i to j and j to i transitionsesys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or timenoise_op (ndarray | csc_matrix | Qobj | None)
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- t2_effective(noise_channels=None, common_noise_options=None, esys=None, get_rate=False)¶
Calculate the effective \(T_2\) time (or rate).
The effective \(T_2\) is calculated by considering a variety of pure dephasing and depolarizing noise channels, according to the formula:
\[\frac{1}{T_{2}^{\rm eff}} = \sum_k \frac{1}{T_{\phi}^{k}} + \frac{1}{2} \sum_j \frac{1}{T_{1}^{j}},\]where \(k\) (\(j\)) run over the relevant pure dephasing ( depolarization) channels that can contribute to the effective noise. By default all the noise channels given by the method effective_noise_channels are included. Users can also provide specific noise channels, with selected options, to be included in the effective \(T_2\) calculation. For example, assuming qubit is a qubit object, can can execute:
qubit.t2_effective(noise_channels=['t1_flux_bias_line', 't1_capacitive', ('tphi_1_over_f_flux', dict(A_noise=3e-6))], common_noise_options=dict(T=0.050))
- Parameters:
noise_channels (None or str or list(str) or list(tuple(str, dict))) – channels to be plotted, if None then noise channels given by supported_noise_channels are used
common_noise_options (dict) – common options used when calculating coherence times
esys (tuple(evals, evecs)) – spectral data used during noise calculations
get_rate (bool) – get rate or time
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- tphi_1_over_f(A_noise, i, j, noise_op, esys=None, get_rate=False, **kwargs)¶
Calculate the 1/f dephasing time (or rate) due to arbitrary noise source.
We assume that the qubit energies (or the passed in eigenspectrum) has units of frequency (and not angular frequency).
- Parameters:
A_noise (
float
) – noise strengthi (int >=0) – state index that along with j defines a qubit
j (int >=0) – state index that along with i defines a qubit
noise_op (
Union
[ndarray
,csc_matrix
]) – noise operator, typically Hamiltonian derivative w.r.t. noisy parameteresys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or time
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- tphi_1_over_f_cc(A_noise=1e-07, i=0, j=1, esys=None, get_rate=False, **kwargs)¶
Calculate the 1/f dephasing time (or rate) due to critical current noise.
- Parameters:
A_noise (
float
) – noise strengthi (int >=0) – state index that along with j defines a qubit
j (int >=0) – state index that along with i defines a qubit
esys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or time
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- tphi_1_over_f_flux(A_noise=1e-06, i=0, j=1, esys=None, get_rate=False, **kwargs)¶
Calculate the 1/f dephasing time (or rate) due to flux noise.
- Parameters:
A_noise (
float
) – noise strengthi (int >=0) – state index that along with j defines a qubit
j (int >=0) – state index that along with i defines a qubit
esys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or time
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float
- tphi_1_over_f_ng(A_noise=0.0001, i=0, j=1, esys=None, get_rate=False, **kwargs)¶
Calculate the 1/f dephasing time (or rate) due to charge noise.
- Parameters:
A_noise (
float
) – noise strengthi (int >=0) – state index that along with j defines a qubit
j (int >=0) – state index that along with i defines a qubit
esys (
Tuple
[ndarray
,ndarray
]) – evals, evecs tupleget_rate (
bool
) – get rate or time
- Returns:
time or rate – decoherence time in units of \(2\pi ({\rm system\,\,units})\), or rate in inverse units.
- Return type:
float