def propagator(self, t, tau, notrace=False):
"""
Compute propagator for time t and time-delay tau
Parameters
----------
t : *float*
current time
tau : *float*
time-delay
notrace : *bool* {False}
If this optional is set to True, a propagator is returned for a
cascade of k systems, where :math:`(k-1) tau < t < k tau`.
If set to False (default), a generalized partial trace is performed
and a propagator for a single system is returned.
Returns
-------
: :class:`qutip.Qobj`
time-propagator for reduced system dynamics
"""
k = int(t / tau) + 1
s = t - (k - 1) * tau
G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
self.c_ops_markov)
E = _integrate(G1,
E0,
0.,
s,
integrator=self.integrator,
parallel=self.parallel,
opt=self.options)
if k > 1:
G2, null = _generator(k - 1, self.H_S, self.L1, self.L2,
self.S_matrix, self.c_ops_markov)
G2 = qt.composite(G2, self.Id)
E = _integrate(G2,
E,
s,
tau,
integrator=self.integrator,
parallel=self.parallel,
opt=self.options)
E.dims = E0.dims
if not notrace:
E = _genptrace(E, k)
return E
def generator(k,H,L1,L2):
"""
Create the generator for the cascaded chain of k system copies
"""
# create bare operators
id = qt.qeye(H.dims[0][0])
Id = qt.spre(id)*qt.spost(id)
Hlist = []
L1list = []
L2list = []
for l in range(1,k+1):
h = H
l1 = L1
l2 = L2
for i in range(1,l):
h = qt.tensor(h,id)
l1 = qt.tensor(l1,id)
l2 = qt.tensor(l2,id)
for i in range(l+1,k+1):
h = qt.tensor(id,h)
l1 = qt.tensor(id,l1)
l2 = qt.tensor(id,l2)
Hlist.append(h)
L1list.append(l1)
L2list.append(l2)
# create Lindbladian
L = qt.Qobj()
H0 = 0.5*Hlist[0]
L0 = L2list[0]
#L0 = 0.*L2list[0]
L += qt.liouvillian(H0,[L0])
E0 = Id
for l in range(k-1):
E0 = qt.composite(Id,E0)
Hl = 0.5*(Hlist[l]+Hlist[l+1]+1j*(L1list[l].dag()*L2list[l+1]
-L2list[l+1].dag()*L1list[l]))
Ll = L1list[l] + L2list[l+1]
L += qt.liouvillian(Hl,[Ll])
Hk = 0.5*Hlist[k-1]
Hk = 0.5*Hlist[k-1]
Lk = L1list[k-1]
L += qt.liouvillian(Hk,[Lk])
E0.dims = L.dims
return L,E0
def rhot(rho0,t,tau,H_S,L1,L2,Id,options=qt.Options()):
"""
Compute rho(t)
"""
k= int(t/tau)+1
s = t-(k-1)*tau
rhovec = qt.operator_to_vector(rho0)
G1,E0 = generator(k,H_S,L1,L2)
E = integrate(G1,E0,0.,s,opt=options)
if k>1:
G2,null = generator(k-1,H_S,L1,L2)
G2 = qt.composite(Id,G2)
E = integrate(G2,E,s,tau,opt=options)
E.dims = E0.dims
E = TensorQobj(E)
for l in range(k-1):
E = E.loop()
sol = qt.vector_to_operator(E*rhovec)
return sol
def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
"""
Create a Liouvillian for a cascaded chain of k system copies
"""
id = qt.qeye(H.dims[0][0])
Id = qt.sprepost(id, id)
if S is None:
S = np.identity(len(L1))
# create Lindbladian
L = qt.Qobj()
E0 = Id
# first system
L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
for l in range(1, k):
# Identiy superoperator
E0 = qt.composite(E0, Id)
# Bare Hamiltonian
Hl = _localop(H, l, k)
L += qt.liouvillian(Hl, [])
# Markovian Decay channels
if c_ops_markov is not None:
for c in c_ops_markov:
cl = _localop(c, l, k)
L += qt.liouvillian(None, [cl])
# Cascade coupling
c1 = np.array([_localop(c, l, k) for c in L1])
c2 = np.array([_localop(c, l+1, k) for c in L2])
c2dag = np.array([c.dag() for c in c2])
Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
Hcasc += Hcasc.dag()
Lvec = c2 + np.dot(S, c1)
L += qt.liouvillian(Hcasc, [c for c in Lvec])
# last system
L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
if c_ops_markov is not None:
for c in c_ops_markov:
cl = _localop(c, k, k)
L += qt.liouvillian(None, [cl])
E0.dims = L.dims
# return generator and identity superop E0
return L, E0
def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
"""
Create a Liouvillian for a cascaded chain of k system copies
"""
id = qt.qeye(H.dims[0][0])
Id = qt.sprepost(id, id)
if S is None:
S = np.identity(len(L1))
# create Lindbladian
L = qt.Qobj()
E0 = Id
# first system
L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
for l in range(1, k):
# Identiy superoperator
E0 = qt.composite(E0, Id)
# Bare Hamiltonian
Hl = _localop(H, l, k)
L += qt.liouvillian(Hl, [])
# Markovian Decay channels
if c_ops_markov is not None:
for c in c_ops_markov:
cl = _localop(c, l, k)
L += qt.liouvillian(None, [cl])
# Cascade coupling
c1 = np.array([_localop(c, l, k) for c in L1])
c2 = np.array([_localop(c, l+1, k) for c in L2])
c2dag = np.array([c.dag() for c in c2])
Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
Hcasc += Hcasc.dag()
Lvec = c2 + np.dot(S, c1)
L += qt.liouvillian(Hcasc, [c for c in Lvec])
# last system
L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
if c_ops_markov is not None:
for c in c_ops_markov:
cl = _localop(c, k, k)
L += qt.liouvillian(None, [cl])
E0.dims = L.dims
# return generator and identity superop E0
return L, E0
def propagator(self, t, tau, notrace=False):
"""
Compute propagator for time t and time-delay tau
Parameters
----------
t : *float*
current time
tau : *float*
time-delay
notrace : *bool* {False}
If this optional is set to True, a propagator is returned for a
cascade of k systems, where :math:`(k-1) tau < t < k tau`.
If set to False (default), a generalized partial trace is performed
and a propagator for a single system is returned.
Returns
-------
: :class:`qutip.Qobj`
time-propagator for reduced system dynamics
"""
k = int(t/tau)+1
s = t-(k-1)*tau
G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
self.c_ops_markov)
E = _integrate(G1, E0, 0., s, integrator=self.integrator,
parallel=self.parallel, opt=self.options)
if k > 1:
G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
self.S_matrix, self.c_ops_markov)
G2 = qt.composite(G2, self.Id)
E = _integrate(G2, E, s, tau, integrator=self.integrator,
parallel=self.parallel, opt=self.options)
E.dims = E0.dims
if not notrace:
E = _genptrace(E, k)
return E
def initialize(state):
return qt.composite(state, qt.bell_state(state='11'))
