def floquet_collapse_operators(A):
"""
Construct collapse operators corresponding to the Floquet-Markov
master-equation rate matrix `A`.
.. note::
Experimental.
"""
c_ops = []
N, M = np.shape(A)
#
# Here we really need a master equation on Bloch-Redfield form, or perhaps
# we can use the Lindblad form master equation with some rotating frame
# approximations? ...
#
for a in range(N):
for b in range(N):
if a != b and abs(A[a, b]) > 0.0:
# only relaxation terms included...
c_ops.append(sqrt(A[a, b]) * projection(N, a, b))
return c_ops
def floquet_collapse_operators(A):
"""
Construct collapse operators corresponding to the Floquet-Markov
master-equation rate matrix `A`.
.. note::
Experimental.
"""
c_ops = []
N, M = np.shape(A)
#
# Here we really need a master equation on Bloch-Redfield form, or perhaps
# we can use the Lindblad form master equation with some rotating frame
# approximations? ...
#
for a in range(N):
for b in range(N):
if a != b and abs(A[a, b]) > 0.0:
# only relaxation terms included...
c_ops.append(sqrt(A[a, b]) * projection(N, a, b))
return c_ops
def _parallel_mesolve(n, N, H, tlist, c_op_list, args, options, dims=None):
col_idx, row_idx = np.unravel_index(n, (N, N))
rho0 = projection(N, row_idx, col_idx)
rho0.dims = dims
output = mesolve(H,
rho0,
tlist,
c_ops=c_op_list,
args=args,
options=options,
_safe_mode=False)
return output
def floquet_collapse_operators(A):
"""
Construct
"""
c_ops = []
N, M = shape(A)
#
# Here we really need a master equation on Bloch-Redfield form, or perhaps
# we can use the Lindblad form master equation with some rotating frame
# approximations? ...
#
for a in range(N):
for b in range(N):
if a != b and abs(A[a,b]) > 0.0:
# only relaxation terms included...
c_ops.append(sqrt(A[a,b]) * projection(N, a, b))
return c_ops
def floquet_collapse_operators(A):
"""
Construct
"""
c_ops = []
N, M = shape(A)
#
# Here we really need a master equation on Bloch-Redfield form, or perhaps
# we can use the Lindblad form master equation with some rotating frame
# approximations? ...
#
for a in range(N):
for b in range(N):
if a != b and abs(A[a, b]) > 0.0:
# only relaxation terms included...
c_ops.append(sqrt(A[a, b]) * projection(N, a, b))
return c_ops
def propagator(H,
t,
c_op_list=[],
args={},
options=None,
unitary_mode='batch',
parallel=False,
progress_bar=None,
_safe_mode=True,
**kwargs):
r"""
Calculate the propagator U(t) for the density matrix or wave function such
that :math:`\psi(t) = U(t)\psi(0)` or
:math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
where :math:`\rho_{\mathrm vec}` is the vector representation of the
density matrix.
Parameters
----------
H : qobj or list
Hamiltonian as a Qobj instance of a nested list of Qobjs and
coefficients in the list-string or list-function format for
time-dependent Hamiltonians (see description in :func:`qutip.mesolve`).
t : float or array-like
Time or list of times for which to evaluate the propagator.
c_op_list : list
List of qobj collapse operators.
args : list/array/dictionary
Parameters to callback functions for time-dependent Hamiltonians and
collapse operators.
options : :class:`qutip.Options`
with options for the ODE solver.
unitary_mode = str ('batch', 'single')
Solve all basis vectors simulaneously ('batch') or individually
('single').
parallel : bool {False, True}
Run the propagator in parallel mode. This will override the
unitary_mode settings if set to True.
progress_bar: BaseProgressBar
Optional instance of BaseProgressBar, or a subclass thereof, for
showing the progress of the simulation. By default no progress bar
is used, and if set to True a TextProgressBar will be used.
Returns
-------
a : qobj
Instance representing the propagator :math:`U(t)`.
"""
kw = _default_kwargs()
if 'num_cpus' in kwargs:
num_cpus = kwargs['num_cpus']
else:
num_cpus = kw['num_cpus']
if progress_bar is None:
progress_bar = BaseProgressBar()
elif progress_bar is True:
progress_bar = TextProgressBar()
if options is None:
options = Options()
options.rhs_reuse = True
rhs_clear()
if isinstance(t, (int, float, np.integer, np.floating)):
tlist = [0, t]
else:
tlist = t
if _safe_mode:
_solver_safety_check(H, None, c_ops=c_op_list, e_ops=[], args=args)
td_type = _td_format_check(H, c_op_list, solver='me')
if isinstance(
H,
(types.FunctionType, types.BuiltinFunctionType, functools.partial)):
H0 = H(0.0, args)
if unitary_mode == 'batch':
# batch don't work with function Hamiltonian
unitary_mode = 'single'
elif isinstance(H, list):
H0 = H[0][0] if isinstance(H[0], list) else H[0]
else:
H0 = H
if len(c_op_list) == 0 and H0.isoper:
# calculate propagator for the wave function
N = H0.shape[0]
dims = H0.dims
if parallel:
unitary_mode = 'single'
u = np.zeros([N, N, len(tlist)], dtype=complex)
output = parallel_map(_parallel_sesolve,
range(N),
task_args=(N, H, tlist, args, options),
progress_bar=progress_bar,
num_cpus=num_cpus)
for n in range(N):
for k, t in enumerate(tlist):
u[:, n, k] = output[n].states[k].full().T
else:
if unitary_mode == 'single':
output = sesolve(H,
qeye(dims[0]),
tlist, [],
args,
options,
_safe_mode=False)
return output.states[-1] if len(tlist) == 2 else output.states
elif unitary_mode == 'batch':
u = np.zeros(len(tlist), dtype=object)
_rows = np.array([(N + 1) * m for m in range(N)])
_cols = np.zeros_like(_rows)
_data = np.ones_like(_rows, dtype=complex)
psi0 = Qobj(sp.coo_matrix((_data, (_rows, _cols))).tocsr())
if td_type[1] > 0 or td_type[2] > 0:
H2 = []
for k in range(len(H)):
if isinstance(H[k], list):
H2.append([tensor(qeye(N), H[k][0]), H[k][1]])
else:
H2.append(tensor(qeye(N), H[k]))
else:
H2 = tensor(qeye(N), H)
options.normalize_output = False
output = sesolve(H2,
psi0,
tlist, [],
args=args,
options=options,
_safe_mode=False)
for k, t in enumerate(tlist):
u[k] = sp_reshape(output.states[k].data, (N, N))
unit_row_norm(u[k].data, u[k].indptr, u[k].shape[0])
u[k] = u[k].T.tocsr()
else:
raise ValueError('Invalid unitary mode.')
elif len(c_op_list) == 0 and H0.issuper:
# calculate the propagator for the vector representation of the
# density matrix (a superoperator propagator)
unitary_mode = 'single'
N = H0.shape[0]
sqrt_N = int(np.sqrt(N))
dims = H0.dims
if parallel:
output = parallel_map(_parallel_mesolve,
range(N),
task_args=(sqrt_N, H, tlist, c_op_list, args,
options),
task_kwargs={"dims": H0.dims[0]},
progress_bar=progress_bar,
num_cpus=num_cpus)
u = np.zeros([N, N, len(tlist)], dtype=complex)
for n in range(N):
for k, t in enumerate(tlist):
u[:, n, k] = mat2vec(output[n].states[k].full()).T
else:
rho0 = qeye(H0.dims[0])
output = mesolve(H,
rho0,
tlist,
args=args,
options=options,
_safe_mode=False)
return output.states[-1] if len(tlist) == 2 else output.states
else:
# calculate the propagator for the vector representation of the
# density matrix (a superoperator propagator)
unitary_mode = 'single'
N = H0.shape[0]
dims = [H0.dims, H0.dims]
u = np.zeros([N * N, N * N, len(tlist)], dtype=complex)
if parallel:
output = parallel_map(_parallel_mesolve,
range(N * N),
task_args=(N, H, tlist, c_op_list, args,
options),
task_kwargs={"dims": H0.dims},
progress_bar=progress_bar,
num_cpus=num_cpus)
for n in range(N * N):
for k, t in enumerate(tlist):
u[:, n, k] = mat2vec(output[n].states[k].full()).T
else:
progress_bar.start(N * N)
for n in range(N * N):
progress_bar.update(n)
col_idx, row_idx = np.unravel_index(n, (N, N))
rho0 = projection(N, row_idx, col_idx)
rho0.dims = H0.dims
output = mesolve(H,
rho0,
tlist,
c_ops=c_op_list,
args=args,
options=options,
_safe_mode=False)
for k, t in enumerate(tlist):
u[:, n, k] = mat2vec(output.states[k].full()).T
progress_bar.finished()
if len(tlist) == 2:
data = u[-1] if unitary_mode == 'batch' else u[:, :, 1]
return Qobj(data, dims=dims)
out = np.empty((len(tlist), ), dtype=object)
if unitary_mode == 'batch':
out[:] = [Qobj(u[k], dims=dims) for k in range(len(tlist))]
else:
out[:] = [Qobj(u[:, :, k], dims=dims) for k in range(len(tlist))]
return out
