def make_system(self, H, c_ops, tlist=None, args={}, options=None):
if options is None:
options = self.options
else:
self.options = options
var = _collapse_args(args)
ss = SolverSystem()
ss.td_c_ops = []
ss.td_n_ops = []
ss.args = args
ss.col_args = var
if type(c_ops) is list:
for c in c_ops: # Accounts for nested list format of c_ops
cevo = QobjEvo(c, args, tlist=tlist)
cdc = cevo._cdc()
cevo.compile()
cdc.compile()
ss.td_c_ops.append(cevo)
ss.td_n_ops.append(cdc)
if isinstance(H, (list, Qobj, QobjEvo)):
H_td = QobjEvo(H, args, tlist=tlist)
H_td *= -1j
for c in ss.td_n_ops:
H_td += -0.5 * c
if options.rhs_with_state:
H_td._check_old_with_state()
H_td.compile()
ss.H_td = H_td
ss.makefunc = _qobjevo_set
ss.set_args = _qobjevo_args # <- redundant
ss.type = "QobjEvo"
elif callable(H):
ss.h_func = H
ss.Hc_td = -0.5 * sum(ss.td_n_ops)
ss.Hc_td.compile()
ss.with_state = options.rhs_with_state
ss.makefunc = _func_set
ss.set_args = _func_args # <- redundant
ss.type = "callback"
else:
raise Exception("Format of c_ops not supported.")
solver_safe["mcsolve"] = ss
self.ss = ss
self.reset()
def make_system(self, H, c_ops, tlist=None, args={}, options=None):
if options is None:
options = self.options
else:
self.options = options
var = _collapse_args(args)
ss = SolverSystem()
ss.td_c_ops = []
ss.td_n_ops = []
ss.args = args
ss.col_args = var
for c in c_ops:
cevo = QobjEvo(c, args, tlist=tlist)
cdc = cevo._cdc()
cevo.compile()
cdc.compile()
ss.td_c_ops.append(cevo)
ss.td_n_ops.append(cdc)
try:
H_td = QobjEvo(H, args, tlist=tlist)
H_td *= -1j
for c in ss.td_n_ops:
H_td += -0.5 * c
if options.rhs_with_state:
H_td._check_old_with_state()
H_td.compile()
ss.H_td = H_td
ss.makefunc = _qobjevo_set
ss.set_args = _qobjevo_args
ss.type = "QobjEvo"
except:
ss.h_func = H
ss.Hc_td = -0.5 * sum(ss.td_n_ops)
ss.Hc_td.compile()
ss.with_state = options.rhs_with_state
ss.makefunc = _func_set
ss.set_args = _func_args
ss.type = "callback"
solver_safe["mcsolve"] = ss
self.ss = ss
self.reset()
def __init__(self, e_ops=[], super_=False):
# take care of expectation values, if any
self.isfunc = False
self.e_ops_dict = False
self.raw_e_ops = e_ops
self.e_ops_qoevo = []
self.e_num = 0
self.e_ops_isherm = []
if isinstance(e_ops, (Qobj, QobjEvo)):
e_ops = [e_ops]
elif isinstance(e_ops, dict):
self.e_ops_dict = e_ops
e_ops = [e for e in e_ops.values()]
self.e_ops = e_ops
if isinstance(e_ops, list):
self.e_num = len(e_ops)
e_ops_qoevo = []
e_ops_isherm = []
for e in e_ops:
if isinstance(e, (Qobj, QobjEvo)):
e_ops_isherm.append(e.isherm)
e_ops_qoevo_entry = None
if not super_:
e_ops_qoevo_entry = QobjEvo(e)
else:
e_ops_qoevo_entry = QobjEvo(spre(e))
e_ops_qoevo_entry.compile()
e_ops_qoevo.append(e_ops_qoevo_entry)
elif callable(e):
e_ops_isherm.append(None)
e_ops_qoevo.append(e)
else:
raise TypeError("Expectation value list entry needs to be "
"either a function either an operator")
self.e_ops_isherm = e_ops_isherm
self.e_ops_qoevo = np.array(e_ops_qoevo, dtype=object)
elif callable(e_ops):
self.isfunc = True
self.e_num = 1
def make_diag_system(self, H, c_ops):
ss = SolverSystem()
ss.td_c_ops = []
ss.td_n_ops = []
H_ = H.copy()
H_ *= -1j
for c in c_ops:
H_ += -0.5 * c.dag() * c
w, v = np.linalg.eig(H_.full())
arg = np.argsort(np.abs(w))
eig = w[arg]
U = v.T[arg].T
Ud = U.T.conj()
for c in c_ops:
c_diag = Qobj(Ud @ c.full() @ U, dims=c.dims)
cevo = QobjEvo(c_diag)
cdc = cevo._cdc()
cevo.compile()
cdc.compile()
ss.td_c_ops.append(cevo)
ss.td_n_ops.append(cdc)
ss.H_diag = eig
ss.Ud = Ud
ss.U = U
ss.args = {}
ss.type = "Diagonal"
solver_safe["mcsolve"] = ss
if self.e_ops and not self.e_ops.isfunc:
e_ops = [
Qobj(Ud @ e.full() @ U, dims=e.dims) for e in self.e_ops.e_ops
]
self.e_ops = ExpectOps(e_ops)
self.ss = ss
self.reset()
