def _correlation_me_4op_2t(H, rho0, tlist, taulist, c_ops,
a_op, b_op, c_op, d_op, reverse=False,
args=None, options=Odeoptions()):
"""
Calculate the four-operator two-time correlation function on the form
<A(t)B(t+tau)C(t+tau)D(t)>.
See, Gardiner, Quantum Noise, Section 5.2.1
"""
if debug:
print(inspect.stack()[0][3])
if rho0 is None:
rho0 = steadystate(H, c_ops)
elif rho0 and isket(rho0):
rho0 = ket2dm(rho0)
C_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
rho_t = mesolve(H, rho0, tlist, c_ops, [], args=args, options=options).states
for t_idx, rho in enumerate(rho_t):
C_mat[t_idx, :] = mesolve(H, d_op * rho * a_op, taulist,
c_ops, [b_op * c_op],
args=args, options=options).expect[0]
return C_mat
def _correlation_me_2op_2t(H, rho0, tlist, taulist, c_ops, a_op, b_op,
reverse=False, args=None, options=Odeoptions()):
"""
Internal function for calculating correlation functions using the master
equation solver. See :func:`correlation` for usage.
"""
if debug:
print(inspect.stack()[0][3])
if rho0 is None:
rho0 = steadystate(H, c_ops)
elif rho0 and isket(rho0):
rho0 = ket2dm(rho0)
C_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
rho_t_list = mesolve(H, rho0, tlist, c_ops, [], args=args, options=options).states
if reverse:
# <A(t+tau)B(t)>
for t_idx, rho_t in enumerate(rho_t_list):
C_mat[t_idx, :] = mesolve(H, b_op * rho_t, taulist,
c_ops, [a_op], args=args, options=options).expect[0]
else:
# <A(t)B(t+tau)>
for t_idx, rho_t in enumerate(rho_t_list):
C_mat[t_idx, :] = mesolve(H, rho_t * a_op, taulist,
c_ops, [b_op], args=args, options=options).expect[0]
return C_mat
def floquet_master_equation_steadystate(H, A):
"""
Returns the steadystate density matrix (in the floquet basis!) for the
Floquet-Markov master equation.
"""
c_ops = floquet_collapse_operators(A)
rho_ss = steadystate(H, c_ops)
return rho_ss
def floquet_master_equation_steadystate(H, A):
"""
Returns the steadystate density matrix (in the floquet basis!) for the
Floquet-Markov master equation.
"""
c_ops = floquet_collapse_operators(A)
rho_ss = steadystate(H, c_ops)
return rho_ss
def coherence_function_g2(H, rho0, taulist, c_ops, a_op, solver="me",
args=None, options=Odeoptions()):
"""
Calculate the second-order quantum coherence function:
.. math::
g^{(2)}(\\tau) =
\\frac{\\langle a^\\dagger(0)a^\\dagger(\\tau)a(\\tau)a(0)\\rangle}
{\\langle a^\\dagger(\\tau)a(\\tau)\\rangle
\\langle a^\\dagger(0)a(0)\\rangle}
Parameters
----------
H : :class:`qutip.qobj.Qobj`
system Hamiltonian.
rho0 : :class:`qutip.qobj.Qobj`
Initial state density matrix (or state vector). If 'rho0' is
'None', then the steady state will be used as initial state.
taulist : *list* / *array*
list of times for :math:`\\tau`.
c_ops : list of :class:`qutip.qobj.Qobj`
list of collapse operators.
a_op : :class:`qutip.qobj.Qobj`
The annihilation operator of the mode.
solver : str
choice of solver (currently only 'me')
Returns
-------
g2, G2: tuble of *array*
The normalized and unnormalized second-order coherence function.
"""
# first calculate the photon number
if rho0 is None:
rho0 = steadystate(H, c_ops)
n = np.array([expect(rho0, a_op.dag() * a_op)])
else:
n = mesolve(H, rho0, taulist, c_ops, [a_op.dag() * a_op], args=args).expect[0]
# calculate the correlation function G2 and normalize with n to obtain g2
G2 = correlation_4op_1t(H, rho0, taulist, c_ops,
a_op.dag(), a_op.dag(), a_op, a_op,
solver=solver, args=args, options=options)
g2 = G2 / (n[0] * n)
return g2, G2
def correlation_ss_mc(H, tlist, c_op_list, a_op, b_op, rho0=None):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation_ss` usage.
"""
if rho0 is None:
rho0 = steadystate(H, co_op_list)
return mcsolve(H, b_op * rho0, tlist, c_op_list, [a_op]).expect[0]
def correlation_ss_mc(H, tlist, c_op_list, a_op, b_op, rho0=None):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation_ss` usage.
"""
if rho0 == None:
rho0 = steadystate(H, co_op_list)
return mcsolve(H, b_op * rho0, tlist, c_op_list, [a_op]).expect[0]
def _correlation_me_ss_gtt(H, tlist, c_ops, a_op, b_op, c_op, d_op, rho0=None):
"""
Calculate the correlation function <A(0)B(tau)C(tau)D(0)>
(ss_gtt = steadystate general two-time)
See, Gardiner, Quantum Noise, Section 5.2.1
.. note::
Experimental.
"""
if rho0 is None:
rho0 = steadystate(H, c_ops)
return mesolve(H, d_op * rho0 * a_op, tlist,
c_ops, [b_op * c_op]).expect[0]
def correlation_ode(H, rho0, tlist, taulist, c_op_list, a_op, b_op):
"""
Internal function for calculating correlation functions using the master
equation solver. See :func:`correlation` usage.
"""
if rho0 == None:
rho0 = steadystate(H, co_op_list)
C_mat = np.zeros([np.size(tlist),np.size(taulist)],dtype=complex)
rho_t = mesolve(H, rho0, tlist, c_op_list, []).states
for t_idx in range(len(tlist)):
C_mat[t_idx,:] = mesolve(H, b_op * rho_t[t_idx], taulist, c_op_list, [a_op]).expect[0]
return C_mat
def correlation_ode(H, rho0, tlist, taulist, c_op_list, a_op, b_op):
"""
Internal function for calculating correlation functions using the master
equation solver. See :func:`correlation` usage.
"""
if rho0 == None:
rho0 = steadystate(H, co_op_list)
C_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
rho_t = mesolve(H, rho0, tlist, c_op_list, []).states
for t_idx in range(len(tlist)):
C_mat[t_idx, :] = mesolve(H, b_op * rho_t[t_idx], taulist, c_op_list,
[a_op]).expect[0]
return C_mat
def _correlation_me_4op_1t(H, rho0, tlist, c_ops, a_op, b_op, c_op, d_op,
args=None, options=Odeoptions()):
"""
Calculate the four-operator two-time correlation function on the form
<A(0)B(tau)C(tau)D(0)>.
See, Gardiner, Quantum Noise, Section 5.2.1
"""
if debug:
print(inspect.stack()[0][3])
if rho0 is None:
rho0 = steadystate(H, c_ops)
elif rho0 and isket(rho0):
rho0 = ket2dm(rho0)
return mesolve(H, d_op * rho0 * a_op, tlist,
c_ops, [b_op * c_op], args=args, options=options).expect[0]
def _correlation_me_2op_1t(H, rho0, tlist, c_ops, a_op, b_op, reverse=False,
args=None, options=Odeoptions()):
"""
Internal function for calculating correlation functions using the master
equation solver. See :func:`correlation_ss` for usage.
"""
if debug:
print(inspect.stack()[0][3])
if rho0 is None:
rho0 = steadystate(H, c_ops)
elif rho0 and isket(rho0):
rho0 = ket2dm(rho0)
if reverse:
# <A(t)B(t+tau)>
return mesolve(H, rho0 * a_op, tlist, c_ops, [b_op],
args=args, options=options).expect[0]
else:
# <A(t+tau)B(t)>
return mesolve(H, b_op * rho0, tlist, c_ops, [a_op],
args=args, options=options).expect[0]
def _correlation_me_gtt(H, rho0, tlist, taulist, c_ops, a_op, b_op,
c_op, d_op):
"""
Calculate the correlation function <A(t)B(t+tau)C(t+tau)D(t)>
(gtt = general two-time)
See, Gardiner, Quantum Noise, Section 5.2.1
.. note::
Experimental.
"""
if rho0 is None:
rho0 = steadystate(H, c_ops)
C_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
rho_t = mesolve(H, rho0, tlist, c_op_list, []).states
for t_idx, rho in enumerate(rho_t):
C_mat[t_idx, :] = mesolve(H, d_op * rho * a_op, taulist,
c_ops, [b_op * c_op]).expect[0]
return C_mat
