def mesolve(H, rho0, tlist, c_ops, e_ops, args={}, options=None, progress_bar=BaseProgressBar()):
"""
Master equation evolution of a density matrix for a given Hamiltonian.
Evolve the state vector or density matrix (`rho0`) using a given
Hamiltonian (`H`) and an [optional] set of collapse operators
(`c_op_list`), by integrating the set of ordinary differential equations
that define the system. In the absence of collapse operators the system is
evolved according to the unitary evolution of the Hamiltonian.
The output is either the state vector at arbitrary points in time
(`tlist`), or the expectation values of the supplied operators
(`e_ops`). If e_ops is a callback function, it is invoked for each
time in `tlist` with time and the state as arguments, and the function
does not use any return values.
**Time-dependent operators**
For problems with time-dependent problems `H` and `c_ops` can be callback
functions that takes two arguments, time and `args`, and returns the
Hamiltonian or Liouvillian for the system at that point in time
(*callback format*).
Alternatively, `H` and `c_ops` can be a specified in a nested-list format
where each element in the list is a list of length 2, containing an
operator (:class:`qutip.qobj`) at the first element and where the
second element is either a string (*list string format*), a callback
function (*list callback format*) that evaluates to the time-dependent
coefficient for the corresponding operator, or a numpy array (*list
array format*) which specifies the value of the coefficient to the
corresponding operator for each value of t in tlist.
*Examples*
H = [[H0, 'sin(w*t)'], [H1, 'sin(2*w*t)']]
H = [[H0, sin(w*tlist)], [H1, sin(2*w*tlist)]]
H = [[H0, f0_t], [H1, f1_t]]
where f0_t and f1_t are python functions with signature f_t(t, args).
In the *list string format* and *list callback format*, the string
expression and the callback function must evaluate to a real or complex
number (coefficient for the corresponding operator).
In all cases of time-dependent operators, `args` is a dictionary of
parameters that is used when evaluating operators. It is passed to the
callback functions as second argument
.. note::
If an element in the list-specification of the Hamiltonian or
the list of collapse operators are in super-operator for it will be
added to the total Liouvillian of the problem with out further
transformation. This allows for using mesolve for solving master
equations that are not on standard Lindblad form.
.. note::
On using callback function: mesolve transforms all :class:`qutip.qobj`
objects to sparse matrices before handing the problem to the integrator
function. In order for your callback function to work correctly, pass
all :class:`qutip.qobj` objects that are used in constructing the
Hamiltonian via args. mesolve will check for :class:`qutip.qobj` in
`args` and handle the conversion to sparse matrices. All other
:class:`qutip.qobj` objects that are not passed via `args` will be
passed on to the integrator in scipy which will raise an NotImplemented
exception.
Parameters
----------
H : :class:`qutip.Qobj`
system Hamiltonian, or a callback function for time-dependent
Hamiltonians.
rho0 : :class:`qutip.Qobj`
initial density matrix or state vector (ket).
tlist : *list* / *array*
list of times for :math:`t`.
c_ops : list of :class:`qutip.Qobj`
single collapse operator, or list of collapse operators.
e_ops : list of :class:`qutip.Qobj` / callback function single
single operator or list of operators for which to evaluate
expectation values.
args : *dictionary*
dictionary of parameters for time-dependent Hamiltonians and
collapse operators.
options : :class:`qutip.Options`
with options for the ODE solver.
progress_bar: TextProgressBar
Optional instance of BaseProgressBar, or a subclass thereof, for
showing the progress of the simulation.
Returns
-------
output: :class:`qutip.solver`
An instance of the class :class:`qutip.solver`, which contains either
an *array* of expectation values for the times specified by `tlist`, or
an *array* or state vectors or density matrices corresponding to the
times in `tlist` [if `e_ops` is an empty list], or
nothing if a callback function was given in place of operators for
which to calculate the expectation values.
"""
# check whether c_ops or e_ops is is a single operator
# if so convert it to a list containing only that operator
if isinstance(c_ops, Qobj):
c_ops = [c_ops]
if isinstance(e_ops, Qobj):
e_ops = [e_ops]
if isinstance(e_ops, dict):
e_ops_dict = e_ops
e_ops = [e for e in e_ops.values()]
else:
e_ops_dict = None
# convert array based time-dependence to string format
H, c_ops, args = _td_wrap_array_str(H, c_ops, args, tlist)
# check for type (if any) of time-dependent inputs
_, n_func, n_str = _td_format_check(H, c_ops)
if options is None:
options = Options()
if (not options.rhs_reuse) or (not config.tdfunc):
# reset config collapse and time-dependence flags to default values
config.reset()
res = None
#
# dispatch the appropriate solver
#
if (
(c_ops and len(c_ops) > 0)
or (not isket(rho0))
or (isinstance(H, Qobj) and issuper(H))
or (isinstance(H, list) and isinstance(H[0], Qobj) and issuper(H[0]))
):
#
# we have collapse operators
#
#
# find out if we are dealing with all-constant hamiltonian and
# collapse operators or if we have at least one time-dependent
# operator. Then delegate to appropriate solver...
#
if isinstance(H, Qobj):
# constant hamiltonian
if n_func == 0 and n_str == 0:
# constant collapse operators
res = _mesolve_const(H, rho0, tlist, c_ops, e_ops, args, options, progress_bar)
elif n_str > 0:
# constant hamiltonian but time-dependent collapse
# operators in list string format
res = _mesolve_list_str_td([H], rho0, tlist, c_ops, e_ops, args, options, progress_bar)
elif n_func > 0:
# constant hamiltonian but time-dependent collapse
# operators in list function format
res = _mesolve_list_func_td([H], rho0, tlist, c_ops, e_ops, args, options, progress_bar)
elif isinstance(H, (types.FunctionType, types.BuiltinFunctionType, partial)):
# function-callback style time-dependence: must have constant
# collapse operators
if n_str > 0: # or n_func > 0:
raise TypeError(
"Incorrect format: function-format "
+ "Hamiltonian cannot be mixed with "
+ "time-dependent collapse operators."
)
else:
res = _mesolve_func_td(H, rho0, tlist, c_ops, e_ops, args, options, progress_bar)
elif isinstance(H, list):
# determine if we are dealing with list of [Qobj, string] or
# [Qobj, function] style time-dependencies (for pure python and
# cython, respectively)
if n_func > 0:
res = _mesolve_list_func_td(H, rho0, tlist, c_ops, e_ops, args, options, progress_bar)
else:
res = _mesolve_list_str_td(H, rho0, tlist, c_ops, e_ops, args, options, progress_bar)
else:
raise TypeError("Incorrect specification of Hamiltonian " + "or collapse operators.")
else:
#
# no collapse operators: unitary dynamics
#
if n_func > 0:
res = _sesolve_list_func_td(H, rho0, tlist, e_ops, args, options, progress_bar)
elif n_str > 0:
res = _sesolve_list_str_td(H, rho0, tlist, e_ops, args, options, progress_bar)
elif isinstance(H, (types.FunctionType, types.BuiltinFunctionType, partial)):
res = _sesolve_func_td(H, rho0, tlist, e_ops, args, options, progress_bar)
else:
res = _sesolve_const(H, rho0, tlist, e_ops, args, options, progress_bar)
if e_ops_dict:
res.expect = {e: res.expect[n] for n, e in enumerate(e_ops_dict.keys())}
return res
def odesolve(H, rho0, tlist, c_op_list, e_ops, args=None, options=None):
"""
Master equation evolution of a density matrix for a given Hamiltonian.
Evolution of a state vector or density matrix (`rho0`) for a given
Hamiltonian (`H`) and set of collapse operators (`c_op_list`), by
integrating the set of ordinary differential equations that define the
system. The output is either the state vector at arbitrary points in time
(`tlist`), or the expectation values of the supplied operators
(`e_ops`).
For problems with time-dependent Hamiltonians, `H` can be a callback
function that takes two arguments, time and `args`, and returns the
Hamiltonian at that point in time. `args` is a list of parameters that is
passed to the callback function `H` (only used for time-dependent
Hamiltonians).
Parameters
----------
H : :class:`qutip.qobj`
system Hamiltonian, or a callback function for time-dependent
Hamiltonians.
rho0 : :class:`qutip.qobj`
initial density matrix or state vector (ket).
tlist : *list* / *array*
list of times for :math:`t`.
c_op_list : list of :class:`qutip.qobj`
list of collapse operators.
e_ops : list of :class:`qutip.qobj` / callback function
list of operators for which to evaluate expectation values.
args : *dictionary*
dictionary of parameters for time-dependent Hamiltonians and
collapse operators.
options : :class:`qutip.Options`
with options for the ODE solver.
Returns
-------
output :array
Expectation values of wavefunctions/density matrices
for the times specified by `tlist`.
Notes
-----
On using callback function: odesolve transforms all :class:`qutip.qobj`
objects to sparse matrices before handing the problem to the integrator
function. In order for your callback function to work correctly, pass
all :class:`qutip.qobj` objects that are used in constructing the
Hamiltonian via args. odesolve will check for :class:`qutip.qobj` in
`args` and handle the conversion to sparse matrices. All other
:class:`qutip.qobj` objects that are not passed via `args` will be
passed on to the integrator to scipy who will raise an NotImplemented
exception.
Deprecated in QuTiP 2.0.0. Use :func:`mesolve` instead.
"""
warnings.warn("odesolve is deprecated since 2.0.0. Use mesolve instead.", DeprecationWarning)
if debug:
print(inspect.stack()[0][3])
if options is None:
options = Options()
if (c_op_list and len(c_op_list) > 0) or not isket(rho0):
if isinstance(H, list):
output = _mesolve_list_td(H, rho0, tlist, c_op_list, e_ops, args, options, BaseProgressBar())
if isinstance(H, (types.FunctionType, types.BuiltinFunctionType, partial)):
output = _mesolve_func_td(H, rho0, tlist, c_op_list, e_ops, args, options, BaseProgressBar())
else:
output = _mesolve_const(H, rho0, tlist, c_op_list, e_ops, args, options, BaseProgressBar())
else:
if isinstance(H, list):
output = _sesolve_list_td(H, rho0, tlist, e_ops, args, options, BaseProgressBar())
if isinstance(H, (types.FunctionType, types.BuiltinFunctionType, partial)):
output = _sesolve_func_td(H, rho0, tlist, e_ops, args, options, BaseProgressBar())
else:
output = _sesolve_const(H, rho0, tlist, e_ops, args, options, BaseProgressBar())
if len(e_ops) > 0:
return output.expect
else:
return output.states
def mesolve(H,
rho0,
tlist,
c_ops,
e_ops,
args={},
options=None,
progress_bar=BaseProgressBar()):
"""
Master equation evolution of a density matrix for a given Hamiltonian.
Evolve the state vector or density matrix (`rho0`) using a given
Hamiltonian (`H`) and an [optional] set of collapse operators
(`c_op_list`), by integrating the set of ordinary differential equations
that define the system. In the absense of collase operators the system is
evolved according to the unitary evolution of the Hamiltonian.
The output is either the state vector at arbitrary points in time
(`tlist`), or the expectation values of the supplied operators
(`e_ops`). If e_ops is a callback function, it is invoked for each
time in `tlist` with time and the state as arguments, and the function
does not use any return values.
**Time-dependent operators**
For problems with time-dependent problems `H` and `c_ops` can be callback
functions that takes two arguments, time and `args`, and returns the
Hamiltonian or Liuovillian for the system at that point in time
(*callback format*).
Alternatively, `H` and `c_ops` can be a specified in a nested-list format
where each element in the list is a list of length 2, containing an
operator (:class:`qutip.qobj`) at the first element and where the
second element is either a string (*list string format*) or a callback
function (*list callback format*) that evaluates to the time-dependent
coefficient for the corresponding operator.
*Examples*
H = [[H0, 'sin(w*t)'], [H1, 'sin(2*w*t)']]
H = [[H0, f0_t], [H1, f1_t]]
where f0_t and f1_t are python functions with signature f_t(t, args).
In the *list string format* and *list callback format*, the string
expression and the callback function must evaluate to a real or complex
number (coefficient for the corresponding operator).
In all cases of time-dependent operators, `args` is a dictionary of
parameters that is used when evaluating operators. It is passed to the
callback functions as second argument
.. note::
If an element in the list-specification of the Hamiltonian or
the list of collapse operators are in super-operator for it will be
added to the total Liouvillian of the problem with out further
transformation. This allows for using mesolve for solving master
equations that are not on standard Lindblad form.
.. note::
On using callback function: mesolve transforms all :class:`qutip.qobj`
objects to sparse matrices before handing the problem to the integrator
function. In order for your callback function to work correctly, pass
all :class:`qutip.qobj` objects that are used in constructing the
Hamiltonian via args. odesolve will check for :class:`qutip.qobj` in
`args` and handle the conversion to sparse matrices. All other
:class:`qutip.qobj` objects that are not passed via `args` will be
passed on to the integrator to scipy who will raise an NotImplemented
exception.
Parameters
----------
H : :class:`qutip.qobj`
system Hamiltonian, or a callback function for time-dependent
Hamiltonians.
rho0 : :class:`qutip.qobj`
initial density matrix or state vector (ket).
tlist : *list* / *array*
list of times for :math:`t`.
c_ops : list of :class:`qutip.qobj`
single collapse operator, or list of collapse operators.
e_ops : list of :class:`qutip.qobj` / callback function single
single operator or list of operators for which to evaluate
expectation values.
args : *dictionary*
dictionary of parameters for time-dependent Hamiltonians and
collapse operators.
options : :class:`qutip.Odeoptions`
with options for the ODE solver.
Returns
-------
output: :class:`qutip.odedata`
An instance of the class :class:`qutip.odedata`, which contains either
an *array* of expectation values for the times specified by `tlist`, or
an *array* or state vectors or density matrices corresponding to the
times in `tlist` [if `e_ops` is an empty list], or
nothing if a callback function was given inplace of operators for
which to calculate the expectation values.
"""
# check whether c_ops or e_ops is is a single operator
# if so convert it to a list containing only that operator
if isinstance(c_ops, Qobj):
c_ops = [c_ops]
if isinstance(e_ops, Qobj):
e_ops = [e_ops]
if isinstance(e_ops, dict):
e_ops_dict = e_ops
e_ops = [e for e in e_ops.values()]
else:
e_ops_dict = None
# check for type (if any) of time-dependent inputs
n_const, n_func, n_str = _ode_checks(H, c_ops)
if options is None:
options = Odeoptions()
if (not options.rhs_reuse) or (not odeconfig.tdfunc):
# reset odeconfig collapse and time-dependence flags to default values
odeconfig.reset()
res = None
#
# dispatch the appropriate solver
#
if ((c_ops and len(c_ops) > 0) or (not isket(rho0))
or (isinstance(H, Qobj) and issuper(H)) or
(isinstance(H, list) and isinstance(H[0], Qobj) and issuper(H[0]))):
#
# we have collapse operators
#
#
# find out if we are dealing with all-constant hamiltonian and
# collapse operators or if we have at least one time-dependent
# operator. Then delegate to appropriate solver...
#
if isinstance(H, Qobj):
# constant hamiltonian
if n_func == 0 and n_str == 0:
# constant collapse operators
res = _mesolve_const(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
elif n_str > 0:
# constant hamiltonian but time-dependent collapse
# operators in list string format
res = _mesolve_list_str_td([H], rho0, tlist, c_ops, e_ops,
args, options, progress_bar)
elif n_func > 0:
# constant hamiltonian but time-dependent collapse
# operators in list function format
res = _mesolve_list_func_td([H], rho0, tlist, c_ops, e_ops,
args, options, progress_bar)
elif isinstance(
H, (types.FunctionType, types.BuiltinFunctionType, partial)):
# old style time-dependence: must have constant collapse operators
if n_str > 0: # or n_func > 0:
raise TypeError("Incorrect format: function-format " +
"Hamiltonian cannot be mixed with " +
"time-dependent collapse operators.")
else:
res = _mesolve_func_td(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
elif isinstance(H, list):
# determine if we are dealing with list of [Qobj, string] or
# [Qobj, function] style time-dependencies (for pure python and
# cython, respectively)
if n_func > 0:
res = _mesolve_list_func_td(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
else:
res = _mesolve_list_str_td(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
else:
raise TypeError("Incorrect specification of Hamiltonian " +
"or collapse operators.")
else:
#
# no collapse operators: unitary dynamics
#
if n_func > 0:
res = _sesolve_list_func_td(H, rho0, tlist, e_ops, args, options,
progress_bar)
elif n_str > 0:
res = _sesolve_list_str_td(H, rho0, tlist, e_ops, args, options,
progress_bar)
elif isinstance(
H, (types.FunctionType, types.BuiltinFunctionType, partial)):
res = _sesolve_func_td(H, rho0, tlist, e_ops, args, options,
progress_bar)
else:
res = _sesolve_const(H, rho0, tlist, e_ops, args, options,
progress_bar)
if e_ops_dict:
res.expect = {
e: res.expect[n]
for n, e in enumerate(e_ops_dict.keys())
}
return res
def odesolve(H, rho0, tlist, c_op_list, e_ops, args=None, options=None):
"""
Master equation evolution of a density matrix for a given Hamiltonian.
Evolution of a state vector or density matrix (`rho0`) for a given
Hamiltonian (`H`) and set of collapse operators (`c_op_list`), by
integrating the set of ordinary differential equations that define the
system. The output is either the state vector at arbitrary points in time
(`tlist`), or the expectation values of the supplied operators
(`e_ops`).
For problems with time-dependent Hamiltonians, `H` can be a callback
function that takes two arguments, time and `args`, and returns the
Hamiltonian at that point in time. `args` is a list of parameters that is
passed to the callback function `H` (only used for time-dependent
Hamiltonians).
Parameters
----------
H : :class:`qutip.qobj`
system Hamiltonian, or a callback function for time-dependent
Hamiltonians.
rho0 : :class:`qutip.qobj`
initial density matrix or state vector (ket).
tlist : *list* / *array*
list of times for :math:`t`.
c_op_list : list of :class:`qutip.qobj`
list of collapse operators.
e_ops : list of :class:`qutip.qobj` / callback function
list of operators for which to evaluate expectation values.
args : *dictionary*
dictionary of parameters for time-dependent Hamiltonians and
collapse operators.
options : :class:`qutip.Odeoptions`
with options for the ODE solver.
Returns
-------
output :array
Expectation values of wavefunctions/density matrices
for the times specified by `tlist`.
Notes
-----
On using callback function: odesolve transforms all :class:`qutip.qobj`
objects to sparse matrices before handing the problem to the integrator
function. In order for your callback function to work correctly, pass
all :class:`qutip.qobj` objects that are used in constructing the
Hamiltonian via args. odesolve will check for :class:`qutip.qobj` in
`args` and handle the conversion to sparse matrices. All other
:class:`qutip.qobj` objects that are not passed via `args` will be
passed on to the integrator to scipy who will raise an NotImplemented
exception.
Deprecated in QuTiP 2.0.0. Use :func:`mesolve` instead.
"""
warnings.warn("odesolve is deprecated since 2.0.0. Use mesolve instead.",
DeprecationWarning)
if debug:
print(inspect.stack()[0][3])
if options is None:
options = Odeoptions()
if (c_op_list and len(c_op_list) > 0) or not isket(rho0):
if isinstance(H, list):
output = _mesolve_list_td(H, rho0, tlist, c_op_list, e_ops, args,
options, BaseProgressBar())
if isinstance(
H, (types.FunctionType, types.BuiltinFunctionType, partial)):
output = _mesolve_func_td(H, rho0, tlist, c_op_list, e_ops, args,
options, BaseProgressBar())
else:
output = _mesolve_const(H, rho0, tlist, c_op_list, e_ops, args,
options, BaseProgressBar())
else:
if isinstance(H, list):
output = _sesolve_list_td(H, rho0, tlist, e_ops, args, options,
BaseProgressBar())
if isinstance(
H, (types.FunctionType, types.BuiltinFunctionType, partial)):
output = _sesolve_func_td(H, rho0, tlist, e_ops, args, options,
BaseProgressBar())
else:
output = _sesolve_const(H, rho0, tlist, e_ops, args, options,
BaseProgressBar())
if len(e_ops) > 0:
return output.expect
else:
return output.states
def mesolve(H,
rho0,
tlist,
c_ops=[],
e_ops=[],
args={},
options=None,
progress_bar=None,
_safe_mode=True):
"""
Master equation evolution of a density matrix for a given Hamiltonian and
set of collapse operators, or a Liouvillian.
Evolve the state vector or density matrix (`rho0`) using a given
Hamiltonian (`H`) and an [optional] set of collapse operators
(`c_ops`), by integrating the set of ordinary differential equations
that define the system. In the absence of collapse operators the system is
evolved according to the unitary evolution of the Hamiltonian.
The output is either the state vector at arbitrary points in time
(`tlist`), or the expectation values of the supplied operators
(`e_ops`). If e_ops is a callback function, it is invoked for each
time in `tlist` with time and the state as arguments, and the function
does not use any return values.
If either `H` or the Qobj elements in `c_ops` are superoperators, they
will be treated as direct contributions to the total system Liouvillian.
This allows to solve master equations that are not on standard Lindblad
form by passing a custom Liouvillian in place of either the `H` or `c_ops`
elements.
**Time-dependent operators**
For time-dependent problems, `H` and `c_ops` can be callback
functions that takes two arguments, time and `args`, and returns the
Hamiltonian or Liouvillian for the system at that point in time
(*callback format*).
Alternatively, `H` and `c_ops` can be a specified in a nested-list format
where each element in the list is a list of length 2, containing an
operator (:class:`qutip.qobj`) at the first element and where the
second element is either a string (*list string format*), a callback
function (*list callback format*) that evaluates to the time-dependent
coefficient for the corresponding operator, or a NumPy array (*list
array format*) which specifies the value of the coefficient to the
corresponding operator for each value of t in tlist.
*Examples*
H = [[H0, 'sin(w*t)'], [H1, 'sin(2*w*t)']]
H = [[H0, f0_t], [H1, f1_t]]
where f0_t and f1_t are python functions with signature f_t(t, args).
H = [[H0, np.sin(w*tlist)], [H1, np.sin(2*w*tlist)]]
In the *list string format* and *list callback format*, the string
expression and the callback function must evaluate to a real or complex
number (coefficient for the corresponding operator).
In all cases of time-dependent operators, `args` is a dictionary of
parameters that is used when evaluating operators. It is passed to the
callback functions as second argument.
**Additional options**
Additional options to mesolve can be set via the `options` argument, which
should be an instance of :class:`qutip.solver.Options`. Many ODE
integration options can be set this way, and the `store_states` and
`store_final_state` options can be used to store states even though
expectation values are requested via the `e_ops` argument.
.. note::
If an element in the list-specification of the Hamiltonian or
the list of collapse operators are in superoperator form it will be
added to the total Liouvillian of the problem with out further
transformation. This allows for using mesolve for solving master
equations that are not on standard Lindblad form.
.. note::
On using callback function: mesolve transforms all :class:`qutip.qobj`
objects to sparse matrices before handing the problem to the integrator
function. In order for your callback function to work correctly, pass
all :class:`qutip.qobj` objects that are used in constructing the
Hamiltonian via args. mesolve will check for :class:`qutip.qobj` in
`args` and handle the conversion to sparse matrices. All other
:class:`qutip.qobj` objects that are not passed via `args` will be
passed on to the integrator in scipy which will raise an NotImplemented
exception.
Parameters
----------
H : :class:`qutip.Qobj`
System Hamiltonian, or a callback function for time-dependent
Hamiltonians, or alternatively a system Liouvillian.
rho0 : :class:`qutip.Qobj`
initial density matrix or state vector (ket).
tlist : *list* / *array*
list of times for :math:`t`.
c_ops : list of :class:`qutip.Qobj`
single collapse operator, or list of collapse operators, or a list
of Liouvillian superoperators.
e_ops : list of :class:`qutip.Qobj` / callback function single
single operator or list of operators for which to evaluate
expectation values.
args : *dictionary*
dictionary of parameters for time-dependent Hamiltonians and
collapse operators.
options : :class:`qutip.Options`
with options for the solver.
progress_bar : BaseProgressBar
Optional instance of BaseProgressBar, or a subclass thereof, for
showing the progress of the simulation.
Returns
-------
result: :class:`qutip.Result`
An instance of the class :class:`qutip.Result`, which contains
either an *array* `result.expect` of expectation values for the times
specified by `tlist`, or an *array* `result.states` of state vectors or
density matrices corresponding to the times in `tlist` [if `e_ops` is
an empty list], or nothing if a callback function was given in place of
operators for which to calculate the expectation values.
"""
# check whether c_ops or e_ops is is a single operator
# if so convert it to a list containing only that operator
if isinstance(c_ops, Qobj):
c_ops = [c_ops]
if isinstance(e_ops, Qobj):
e_ops = [e_ops]
if isinstance(e_ops, dict):
e_ops_dict = e_ops
e_ops = [e for e in e_ops.values()]
else:
e_ops_dict = None
if _safe_mode:
_solver_safety_check(H, rho0, c_ops, e_ops, args)
if progress_bar is None:
progress_bar = BaseProgressBar()
elif progress_bar is True:
progress_bar = TextProgressBar()
# check if rho0 is a superoperator, in which case e_ops argument should
# be empty, i.e., e_ops = []
if issuper(rho0) and not e_ops == []:
raise TypeError("Must have e_ops = [] when initial condition rho0 is" +
" a superoperator.")
# convert array based time-dependence to string format
H, c_ops, args = _td_wrap_array_str(H, c_ops, args, tlist)
# check for type (if any) of time-dependent inputs
_, n_func, n_str = _td_format_check(H, c_ops)
if options is None:
options = Options()
if (not options.rhs_reuse) or (not config.tdfunc):
# reset config collapse and time-dependence flags to default values
config.reset()
#check if should use OPENMP
check_use_openmp(options)
res = None
#
# dispatch the appropriate solver
#
if ((c_ops and len(c_ops) > 0) or (not isket(rho0))
or (isinstance(H, Qobj) and issuper(H)) or
(isinstance(H, list) and isinstance(H[0], Qobj) and issuper(H[0]))):
#
# we have collapse operators, or rho0 is not a ket,
# or H is a Liouvillian
#
#
# find out if we are dealing with all-constant hamiltonian and
# collapse operators or if we have at least one time-dependent
# operator. Then delegate to appropriate solver...
#
if isinstance(H, Qobj):
# constant hamiltonian
if n_func == 0 and n_str == 0:
# constant collapse operators
res = _mesolve_const(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
elif n_str > 0:
# constant hamiltonian but time-dependent collapse
# operators in list string format
res = _mesolve_list_str_td([H], rho0, tlist, c_ops, e_ops,
args, options, progress_bar)
elif n_func > 0:
# constant hamiltonian but time-dependent collapse
# operators in list function format
res = _mesolve_list_func_td([H], rho0, tlist, c_ops, e_ops,
args, options, progress_bar)
elif isinstance(
H, (types.FunctionType, types.BuiltinFunctionType, partial)):
# function-callback style time-dependence: must have constant
# collapse operators
if n_str > 0: # or n_func > 0:
raise TypeError("Incorrect format: function-format " +
"Hamiltonian cannot be mixed with " +
"time-dependent collapse operators.")
else:
res = _mesolve_func_td(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
elif isinstance(H, list):
# determine if we are dealing with list of [Qobj, string] or
# [Qobj, function] style time-dependencies (for pure python and
# cython, respectively)
if n_func > 0:
res = _mesolve_list_func_td(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
else:
res = _mesolve_list_str_td(H, rho0, tlist, c_ops, e_ops, args,
options, progress_bar)
else:
raise TypeError("Incorrect specification of Hamiltonian " +
"or collapse operators.")
else:
#
# no collapse operators: unitary dynamics
#
if n_func > 0:
res = _sesolve_list_func_td(H, rho0, tlist, e_ops, args, options,
progress_bar)
elif n_str > 0:
res = _sesolve_list_str_td(H, rho0, tlist, e_ops, args, options,
progress_bar)
elif isinstance(
H, (types.FunctionType, types.BuiltinFunctionType, partial)):
res = _sesolve_func_td(H, rho0, tlist, e_ops, args, options,
progress_bar)
else:
res = _sesolve_const(H, rho0, tlist, e_ops, args, options,
progress_bar)
if e_ops_dict:
res.expect = {
e: res.expect[n]
for n, e in enumerate(e_ops_dict.keys())
}
return res
