def propagate(self, rho_0, t_init, t_final, dt,
input_has_bath=False, output_has_bath=False,
is_verbose=True):
if is_verbose:
print "--- Propagating RDM ...",
times = np.arange(t_init, t_final, dt)
self.write_bath_corr_fn(times)
if input_has_bath:
rho_hierarchy = rho_0.copy()
else:
rho_hierarchy = self.initialize_rho_hierarchy(rho_0)
integrator = Integrator('ODE', dt, deriv_fn=self.heom_deriv)
integrator.set_initial_value(rho_hierarchy, t_init)
rhos_site = []
rhos_eig = []
while integrator.t < t_final+1e-8:
#print " - Propagating at time t =", integrator.t
# Retrieve data from integrator
if output_has_bath:
rho_site = integrator.y
rho_eig = []
for ado_site in rho_site:
rho_eig.append(self.ham.site2eig(ado_site))
rho_eig = np.array(rho_eig)
else:
rho_site = integrator.y[0]
rho_eig = self.ham.site2eig(rho_site)
# Collect results
rhos_site.append(rho_site.copy())
rhos_eig.append(rho_eig.copy())
# Propagate one timestep
integrator.integrate()
# TODO(TCB): If filtering, check if we can remove any ADMs
if is_verbose:
print "done."
return times, rhos_site, rhos_eig
def propagate_full(self, rho_hierarchy, t_init, t_final, dt):
integrator = Integrator('ODE', dt, deriv_fn=self.heom_deriv)
integrator.set_initial_value(rho_hierarchy, t_init)
rhos_site = list()
times = np.arange(t_init, t_final, dt)
for time in times:
rhos_site.append(integrator.y.copy())
integrator.integrate()
# TODO(TCB): If filtering, check if we can remove any ADMs
return times, np.array(rhos_site)
def propagate_full(self,
rho_0,
t_init,
t_final,
dt,
markov_tol=1e-3,
markov_time=np.inf,
is_verbose=False):
self.markov_tol = markov_tol
self.markov_time = markov_time
times = np.arange(t_init, t_final, dt)
rho_eig = self.ham.site2eig(rho_0)
integrator = Integrator(self.diffeq_type,
dt,
Omega=self.Omega,
R=self.R,
K=self.K)
if self.method == 'TCL2':
if not hasattr(self, 'redfield_tensor_n'):
self.precompute_redfield_tensor(t_init, t_final, dt)
elif len(self.redfield_tensor_n) < int((t_final - t_init) / dt):
self.precompute_redfield_tensor(t_init, t_final, dt)
if self.method == 'TC2':
self.precompute_redfield_tensor(t_init, t_final, dt)
#self.precompute_redfield_tensor_finegrid(t_init, t_final, dt,
# integrator)
integrator.set_initial_value(utils.to_liouville(rho_eig), t_init)
rhos_site = []
for time in times:
# Retrieve data from integrator
rho_eig = utils.from_liouville(integrator.y)
# Collect results
rho_site = self.ham.eig2site(rho_eig)
rhos_site.append(rho_site)
# Propagate one timestep
integrator.integrate()
if is_verbose:
print("\n--- Finished performing RDM dynamics")
return times, rhos_site
def propagate_full(self, rho_bath, t_init, t_final, dt):
times = np.arange(t_init, t_final, dt)
def deriv_fn(t, y):
return self.deriv(t, y)
rho_0, q, p = self.unpack(rho_bath)
rho_int_0 = self.ham.to_interaction(self.ham.site2eig(rho_0), t_init)
integrator = Integrator('ODE', dt, deriv_fn=deriv_fn)
integrator.set_initial_value(self.pack(rho_int_0, q, p), t_init)
rho_bath_traj = list()
for time in times:
rho_int_t, qt, pt = self.unpack(np.array(integrator.y))
rho_t = self.ham.eig2site(
self.ham.from_interaction(rho_int_t, time))
rho_bath_traj.append(self.pack(rho_t, qt, pt))
integrator.integrate()
return times, np.array(rho_bath_traj)
def propagate(self, rho_0, t_init, t_final, dt, is_verbose=True):
"""Propagate the RDM according to Ehrenfest dynamics.
Parameters
----------
rho_0 : np.array
The initial RDM.
t_init : float
The initial time.
t_final : float
The final time.
dt : float
The timestep.
is_verbose : bool
Flag to indicate verbose printing.
Returns
-------
times : list of floats
The times at which the RDM has been calculated.
rhos_site : list of np.arrays
The RDM at each time in the site basis.
rhos_eig : list of np.arrays
The RDM at each time in the system eigen-basis.
"""
times = np.arange(t_init, t_final, dt)
modes = self.modes = self.ham.init_classical_modes(self.nmode)
self._hamsb = np.array(self.ham.sysbath)
self._omegasq = np.zeros((self.ham.nbath,self.nmode))
self._c = np.zeros((self.ham.nbath,self.nmode))
for n,modes_n in enumerate(self.modes):
self._omegasq[n,:] = np.array([mode.omega**2 for mode in modes_n])
self._c[n:] = np.array([mode.c for mode in modes_n])
def deriv_fn(t,y):
return self.deriv(t,y)
rhos_site_avg = np.zeros((len(times),self.ham.nsite,self.ham.nsite), dtype=np.complex)
rhos_eig_avg = np.zeros((len(times),self.ham.nsite,self.ham.nsite), dtype=np.complex)
for trajectory in range(self.ntraj):
self.ham.sample_classical_modes(modes)
q = np.zeros((self.ham.nbath, self.nmode))
p = np.zeros((self.ham.nbath, self.nmode))
for n in range(self.ham.nbath):
for k in range(self.nmode):
q[n,k] = modes[n][k].Q
p[n,k] = modes[n][k].P
integrator = Integrator('ODE', dt, deriv_fn=deriv_fn)
integrator.set_initial_value(self.pack(rho_0,q,p), t_init)
rhos_site = []
rhos_eig = []
for time in times:
# Retrieve data from integrator
rho_site, q, p = self.unpack(integrator.y)
# Collect results
rhos_site.append(rho_site)
rhos_eig.append(self.ham.site2eig(rho_site))
# Propagate one timestep
integrator.integrate()
# Remember: rhos_site is a Python list, not a numpy array
rhos_site_avg += np.array(rhos_site)/self.ntraj
rhos_eig_avg += np.array(rhos_eig)/self.ntraj
if is_verbose:
print "\n--- Finished performing RDM dynamics"
# Return as a list of 2D ndarrays
return times, [x for x in rhos_site_avg], [x for x in rhos_eig_avg]
def propagate(self, rho_0, t_init, t_final, dt,
markov_tol = 1e-3, markov_time = np.inf,
is_verbose=True):
"""Propagate the RDM according to Redfield-like dynamics.
Parameters
----------
rho_0 : np.array
The initial RDM.
t_init : float
The initial time.
t_final : float
The final time.
dt : float
The timestep.
markov_tol : float
The relative tolerance at which to decide that the memory tensor
has stopped changing (and henceforth Markovian).
markov_time : float
The hard-coded time to stop re-calculating the memory tensor.
is_verbose : bool
Flag to indicate verbose printing.
Returns
-------
times : list of floats
The times at which the RDM has been calculated.
rhos_site : list of np.arrays
The RDM at each time in the site basis.
rhos_eig : list of np.arrays
The RDM at each time in the system eigen-basis.
"""
self.markov_tol = markov_tol
self.markov_time = markov_time
times = np.arange(t_init, t_final, dt)
rho_site = rho_0.copy()
rho_eig = self.ham.site2eig(rho_site)
integrator = Integrator(self.diffeq_type, dt,
Omega=self.Omega, R=self.R, K=self.K)
if self.method in ['TCL2', 'TC2']:
self.precompute_redfield_tensor(t_init, t_final, dt)
#self.precompute_redfield_tensor_finegrid(t_init, t_final, dt,
# integrator)
integrator.set_initial_value(utils.to_liouville(rho_eig), t_init)
rhos_site = []
rhos_eig = []
for time in times:
# Retrieve data from integrator
rho_eig = utils.from_liouville(integrator.y)
# Collect results
rho_site = self.ham.eig2site(rho_eig)
rhos_site.append(rho_site)
rhos_eig.append(rho_eig)
# Propagate one timestep
integrator.integrate()
if is_verbose:
print "\n--- Finished performing RDM dynamics"
return times, rhos_site, rhos_eig