def _correlation_mc_2op_2t(H, psi0, tlist, taulist, c_ops, a_op, b_op,
reverse=False, args=None, options=Odeoptions()):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation` usage.
"""
if debug:
print(inspect.stack()[0][3])
raise NotImplementedError("The Monte-Carlo solver currently cannot be " +
"used for correlation functions on the form " +
"<A(t)B(t+tau)>")
if psi0 is None or not isket(psi0):
raise Exception("_correlation_mc_2op_2t requires initial state as ket")
C_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
psi_t = mcsolve(
H, psi0, tlist, c_ops, [], args=args, options=options).states
for t_idx in range(len(tlist)):
psi0_t = psi_t[0][t_idx]
C_mat[t_idx, :] = mcsolve(H, b_op * psi0_t, tlist, c_ops, [a_op],
args=args, options=options).expect[0]
return C_mat
def _correlation_mc_2op_1t(H,
psi0,
taulist,
c_ops,
a_op,
b_op,
reverse=False,
args=None,
options=Odeoptions()):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation_ss` for usage.
"""
if debug:
print(inspect.stack()[0][3])
if psi0 is None or not isket(psi0):
raise Exception("_correlation_mc_2op_1t requires initial state as ket")
b_op_psi0 = b_op * psi0
norm = b_op_psi0.norm()
return norm * mcsolve(H,
b_op_psi0 / norm,
taulist,
c_ops, [a_op],
args=args,
options=options).expect[0]
def _correlation_mc_2op_2t(H,
psi0,
tlist,
taulist,
c_ops,
a_op,
b_op,
reverse=False,
args=None,
options=Odeoptions()):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation` usage.
"""
if debug:
print(inspect.stack()[0][3])
raise NotImplementedError("The Monte-Carlo solver currently cannot be " +
"used for correlation functions on the form " +
"<A(t)B(t+tau)>")
if psi0 is None or not isket(psi0):
raise Exception("_correlation_mc_2op_2t requires initial state as ket")
C_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
options.gui = False
psi_t = mcsolve(H, psi0, tlist, c_ops, [], args=args,
options=options).states
for t_idx in range(len(tlist)):
psi0_t = psi_t[0][t_idx]
C_mat[t_idx, :] = mcsolve(H,
b_op * psi0_t,
tlist,
c_ops, [a_op],
args=args,
options=options).expect[0]
return C_mat
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_mc(H, psi0, tlist, taulist, c_op_list, a_op, b_op):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation` usage.
"""
C_mat = np.zeros([np.size(tlist),np.size(taulist)],dtype=complex)
ntraj = 100
mc_opt = Mcoptions()
mc_opt.progressbar = False
psi_t = mcsolve(H, psi0, tlist, ntraj, c_op_list, [], mc_opt).states
for t_idx in range(len(tlist)):
psi0_t = psi_t[0][t_idx]
C_mat[t_idx, :] = mcsolve(H, b_op * psi0_t, tlist, ntraj, c_op_list, [a_op], mc_opt).expect[0]
return C_mat
def correlation_mc(H, psi0, tlist, taulist, c_op_list, a_op, b_op):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation` usage.
"""
C_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
ntraj = 100
mc_opt = Mcoptions()
mc_opt.progressbar = False
psi_t = mcsolve(H, psi0, tlist, ntraj, c_op_list, [], mc_opt).states
for t_idx in range(len(tlist)):
psi0_t = psi_t[0][t_idx]
C_mat[t_idx, :] = mcsolve(H, b_op * psi0_t, tlist, ntraj, c_op_list,
[a_op], mc_opt).expect[0]
return C_mat
def _correlation_mc_2op_1t(H, psi0, taulist, c_ops, a_op, b_op, reverse=False, args=None, options=Options()):
"""
Internal function for calculating correlation functions using the Monte
Carlo solver. See :func:`correlation_ss` for usage.
"""
if debug:
print(inspect.stack()[0][3])
if psi0 is None or not isket(psi0):
raise Exception("_correlation_mc_2op_1t requires initial state as ket")
b_op_psi0 = b_op * psi0
norm = b_op_psi0.norm()
return norm * mcsolve(H, b_op_psi0 / norm, taulist, c_ops, [a_op], args=args, options=options).expect[0]
def _correlation_mc_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
args=None, options=Options()):
"""
Internal function for calculating the three-operator two-time
correlation function:
<A(t)B(t+tau)C(t)>
using a Monte Carlo solver.
"""
# the solvers only work for positive time differences and the correlators
# require positive tau
if state0 is None:
raise NotImplementedError("steady state not implemented for " +
"mc solver, please use `es` or `me`")
elif not isket(state0):
raise TypeError("state0 must be a state vector.")
psi0 = state0
if debug:
print(inspect.stack()[0][3])
psi_t_mat = mcsolve(
H, psi0, tlist, c_ops, [],
args=args, ntraj=options.ntraj[0], options=options, progress_bar=None
).states
corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
H_shifted, _args = _transform_H_t_shift(H, args)
# calculation of <A(t)B(t+tau)C(t)> from only knowledge of psi0 requires
# averaging over both t and tau
for t_idx in range(np.size(tlist)):
if not isinstance(H, Qobj):
_args["_t0"] = tlist[t_idx]
for trial_idx in range(options.ntraj[0]):
if isinstance(a_op, Qobj) and isinstance(c_op, Qobj):
if a_op.dag() == c_op:
# A shortcut here, requires only 1/4 the trials
chi_0 = (options.mc_corr_eps + c_op) * \
psi_t_mat[trial_idx, t_idx]
# evolve these states and calculate expectation value of B
c_tau = chi_0.norm()**2 * mcsolve(
H_shifted, chi_0/chi_0.norm(), taulist, c_ops, [b_op],
args=_args, ntraj=options.ntraj[1], options=options,
progress_bar=None
).expect[0]
# final correlation vector computed by combining the
# averages
corr_mat[t_idx, :] += c_tau/options.ntraj[1]
else:
# otherwise, need four trial wavefunctions
# (Ad+C)*psi_t, (Ad+iC)*psi_t, (Ad-C)*psi_t, (Ad-iC)*psi_t
if isinstance(a_op, Qobj):
a_op_dag = a_op.dag()
else:
# assume this is a number, ex. i.e. a_op = 1
# if this is not correct, the over-loaded addition
# operation will raise errors
a_op_dag = a_op
chi_0 = [(options.mc_corr_eps + a_op_dag +
np.exp(1j*x*np.pi/2)*c_op) *
psi_t_mat[trial_idx, t_idx]
for x in range(4)]
# evolve these states and calculate expectation value of B
c_tau = [
chi.norm()**2 * mcsolve(
H_shifted, chi/chi.norm(), taulist, c_ops, [b_op],
args=_args, ntraj=options.ntraj[1], options=options,
progress_bar=None
).expect[0]
for chi in chi_0
]
# final correlation vector computed by combining the averages
corr_mat[t_idx, :] += \
1/(4*options.ntraj[0]) * (c_tau[0] - c_tau[2] -
1j*c_tau[1] + 1j*c_tau[3])
if t_idx == 1:
options.rhs_reuse = True
return corr_mat
def run_state(self, init_state=None, analytical=False, states=None,
noisy=True, solver="mesolve", **kwargs):
"""
If `analytical` is False, use :func:`qutip.mesolve` to
calculate the time of the state evolution
and return the result. Other arguments of mesolve can be
given as keyword arguments.
If `analytical` is True, calculate the propagator
with matrix exponentiation and return a list of matrices.
Noise will be neglected in this option.
Parameters
----------
init_state : :class:`qutip.Qobj`
Initial density matrix or state vector (ket).
analytical: bool
If True, calculate the evolution with matrices exponentiation.
states : :class:`qutip.Qobj`, optional
Old API, same as init_state.
solver: str
"mesolve" or "mcsolve",
for :func:`~qutip.mesolve` and :func:`~qutip.mcsolve`.
noisy: bool
Include noise or not.
**kwargs
Keyword arguments for the qutip solver.
E.g `tlist` for time points for recording
intermediate states and expectation values;
`args` for the solvers and `qutip.QobjEvo`.
Returns
-------
evo_result : :class:`qutip.Result`
If ``analytical`` is False, an instance of the class
:class:`qutip.Result` will be returned.
If ``analytical`` is True, a list of matrices representation
is returned.
"""
if states is not None:
warnings.warn(
"states will be deprecated and replaced by init_state",
DeprecationWarning)
if init_state is None and states is None:
raise ValueError("Qubit state not defined.")
elif init_state is None:
# just to keep the old parameters `states`,
# it is replaced by init_state
init_state = states
if analytical:
if kwargs or self.noise:
raise warnings.warn(
"Analytical matrices exponentiation"
"does not process noise or"
"any keyword arguments.")
return self.run_analytically(init_state=init_state)
# kwargs can not contain H
if "H" in kwargs:
raise ValueError(
"`H` is already specified by the processor "
"and can not be given as a keyword argument")
# construct qobjevo for unitary evolution
if "args" in kwargs:
noisy_qobjevo, sys_c_ops = self.get_qobjevo(
args=kwargs["args"], noisy=noisy)
else:
noisy_qobjevo, sys_c_ops = self.get_qobjevo(noisy=noisy)
# add collpase operators into kwargs
if "c_ops" in kwargs:
if isinstance(kwargs["c_ops"], (Qobj, QobjEvo)):
kwargs["c_ops"] += [kwargs["c_ops"]] + sys_c_ops
else:
kwargs["c_ops"] += sys_c_ops
else:
kwargs["c_ops"] = sys_c_ops
# choose solver:
if "tlist" in kwargs:
tlist = kwargs["tlist"]
del kwargs["tlist"]
else:
tlist=noisy_qobjevo.tlist
if solver == "mesolve":
evo_result = mesolve(
H=noisy_qobjevo, rho0=init_state,
tlist=tlist, **kwargs)
elif solver == "mcsolve":
evo_result = mcsolve(
H=noisy_qobjevo, psi0=init_state,
tlist=tlist, **kwargs)
return evo_result
