def spectral_dens_from_corrfce(self):
#params = world.params
params = {"ftype": world.ctype,
"reorg": world.reorg,
"cortime": world.ctime,
"T": world.temp,
"matsubara":world.mats}
ta = world.ta
with energy_units(world.e_units):
cf = CorrelationFunction(ta,params)
world.sd = cf.get_SpectralDensity()
# time interval om which functions will be defined
ta = TimeAxis(0.0,1000,1.0)
temperature = 300.0
# parameters of the correlation function
params = {"ftype": "OverdampedBrownian",
"reorg": 20.0,
"cortime": 100.0,
"T": temperature,
"matsubara":20}
# here we create the correlation function assuming that the energy parameters
# are given in 1/cm
with energy_units("1/cm"):
cf = CorrelationFunction(ta,params)
#cf.save_data("ob_20cm_100fs_300K_m20",ext="dat")
sd = SpectralDensity(ta,params)
#sd.save_data("ob_sd_20cm_100fs_300K_m20", ext="dat")
if _show_plots_:
# plotting the correlation function
cf.plot(ylabel=r'$C(t)$ [rad$^2\cdot$fs$^{-2}$]',real_only=False)
# Fourier transform of the correlation function
cF = cf.get_Fourier_transform()
# This is the same thing, just has the units management
cF1 = cf.get_FTCorrelationFunction()
def test_of_correlation_function_addition(self):
"""Testing addition of CorrelationFunction objects """
t = TimeAxis(0.0, 1000, 1.0)
params1 = dict(ftype="OverdampedBrownian",
reorg=30.0,
cortime=100.0,
T=300.0)
params2 = dict(ftype="OverdampedBrownian",
reorg=40.0,
cortime=100.0,
T=300.0)
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params2)
#
# normal addition
#
f = f1 + f2
sum_data = f1.data + f2.data
sum_lamb = f1.lamb + f2.lamb
sum_cutoff = max(f1.cutoff_time, f2.cutoff_time)
sum_temp = f1.temperature
self.assertEqual(f.lamb, sum_lamb)
numpy.testing.assert_allclose(f.data, sum_data)
self.assertEqual(f.cutoff_time, sum_cutoff)
self.assertEqual(f.temperature, sum_temp)
#self.assertFalse(f.is_analytical())
self.assertTrue(f._is_composed)
self.assertFalse(f._is_empty)
#
# inplace addition by function
#
f1.add_to_data(f2)
self.assertEqual(f1.lamb, sum_lamb)
numpy.testing.assert_allclose(f1.data, sum_data)
self.assertEqual(f1.cutoff_time, sum_cutoff)
self.assertEqual(f1.temperature, sum_temp)
#self.assertFalse(f1.is_analytical())
self.assertTrue(f1._is_composed)
self.assertFalse(f1._is_empty)
#
# inplace addition by += operator
#
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1) # new object
fs = f1
f1 += f2
self.assertEqual(f1.lamb, sum_lamb)
numpy.testing.assert_allclose(f1.data, sum_data)
self.assertEqual(f1.cutoff_time, sum_cutoff)
self.assertEqual(f1.temperature, sum_temp)
#self.assertFalse(f1.is_analytical())
self.assertTrue(f1._is_composed)
self.assertFalse(f1._is_empty)
# test if inplace addition really happend
self.assertEqual(fs, f1)
def test_reorganization_energy_consistence(self):
"""Checking that reorganization energy is represented consistently
"""
t = TimeAxis(0.0, 2000, 1.0)
params1 = dict(ftype="OverdampedBrownian",
reorg=30.0,
cortime=100.0,
T=300.0)
params2 = dict(ftype="OverdampedBrownian",
reorg=40.0,
cortime=100.0,
T=300.0)
params3 = dict(ftype="OverdampedBrownian",
reorg=15.0,
cortime=200.0,
T=300.0)
params4 = dict(ftype="OverdampedBrownian",
reorg=10.0,
cortime=50.0,
T=300.0)
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params2)
f3 = CorrelationFunction(t, params3)
f4 = CorrelationFunction(t, params4)
l1 = f1.measure_reorganization_energy()
l2 = f1.lamb
#print(l1, l2, abs(l1-l2)/(l1+l2))
l1 = f3.measure_reorganization_energy()
l2 = f3.lamb
#print(l1, l2, abs(l1-l2)/(l1+l2))
self.assertTrue(f1.reorganization_energy_consistent())
self.assertTrue(f2.reorganization_energy_consistent())
self.assertTrue(f3.reorganization_energy_consistent())
self.assertTrue(f4.reorganization_energy_consistent())
for i in range(5):
f1 += f1
self.assertTrue(f1.reorganization_energy_consistent())
for i in range(5):
f3 += f2
self.assertTrue(f3.reorganization_energy_consistent())
def test_of_multiple_addition(self):
"""Testing multiple addition of CorrelationFunction objects """
t = TimeAxis(0.0, 1000, 1.0)
params1 = dict(ftype="OverdampedBrownian",
reorg=30.0,
cortime=100.0,
T=300.0)
params2 = dict(ftype="OverdampedBrownian",
reorg=40.0,
cortime=100.0,
T=300.0)
params3 = dict(ftype="OverdampedBrownian",
reorg=15.0,
cortime=200.0,
T=300.0)
params4 = dict(ftype="OverdampedBrownian",
reorg=10.0,
cortime=50.0,
T=300.0)
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params2)
f3 = CorrelationFunction(t, params3)
f4 = CorrelationFunction(t, params4)
f = f1 + f2 + f3 + f4
sum_data = f1.data + f2.data + f3.data + f4.data
sum_lamb = f1.lamb + f2.lamb + f3.lamb + f4.lamb
sum_cutoff = max(f1.cutoff_time, f2.cutoff_time, f3.cutoff_time,
f4.cutoff_time)
sum_temp = f1.temperature
self.assertEqual(f.lamb, sum_lamb)
numpy.testing.assert_allclose(f.data, sum_data)
self.assertEqual(f.cutoff_time, sum_cutoff)
self.assertEqual(f.temperature, sum_temp)
#self.assertFalse(f.is_analytical())
self.assertTrue(f._is_composed)
self.assertFalse(f._is_empty)
#
# Inplace
#
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params2)
f3 = CorrelationFunction(t, params3)
f4 = CorrelationFunction(t, params4)
fs = f1
sum_data = f1.data + f2.data + f3.data + f4.data
sum_lamb = f1.lamb + f2.lamb + f3.lamb + f4.lamb
sum_cutoff = max(f1.cutoff_time, f2.cutoff_time, f3.cutoff_time,
f4.cutoff_time)
sum_temp = f3.temperature
f1 += f2 + f3
f1 += f4
f = f1
self.assertEqual(f.lamb, sum_lamb)
numpy.testing.assert_allclose(f.data, sum_data)
#print(f.cutoff_time, sum_cutoff)
self.assertEqual(f.cutoff_time, sum_cutoff)
self.assertEqual(f.temperature, sum_temp)
#self.assertFalse(f.is_analytical())
self.assertTrue(f._is_composed)
self.assertFalse(f._is_empty)
# test if inplace addition really happend
self.assertEqual(fs, f1)
#
# Loops
#
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params1)
f1_data = f1.data.copy()
for i in range(5):
f1 += f1
with energy_units("1/cm"):
self.assertEqual(
f1.lamb,
32.0 * Manager().convert_energy_2_internal_u(params1["reorg"]))
numpy.testing.assert_allclose(f1.data, 32.0 * f1_data)
self.assertEqual(f1.temperature, params1["T"])
#self.assertFalse(f1.is_analytical())
self.assertTrue(f1._is_composed)
self.assertFalse(f1._is_empty)
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
for i in range(5):
f1 += f2
self.assertEqual(
f1.lamb,
6.0 * Manager().convert_energy_2_internal_u(params1["reorg"]))
numpy.testing.assert_allclose(f1.data, 6.0 * f1_data)
self.assertEqual(f1.temperature, params1["T"])
#self.assertFalse(f1.is_analytical())
self.assertTrue(f1._is_composed)
self.assertFalse(f1._is_empty)
def test_of_correlation_function_as_Saveable(self):
"""(CorrelationFunction) Testing of saving """
t = TimeAxis(0.0, 1000, 1.0)
params1 = dict(ftype="OverdampedBrownian",
reorg = 30.0,
cortime = 100.0,
T = 300.0)
params2 = dict(ftype="OverdampedBrownian",
reorg = 40.0,
cortime = 100.0,
T = 300.0)
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params2)
with h5py.File("test_file_1",driver="core",
backing_store=False) as f:
f1.save(f, test=True)
f1_loaded = CorrelationFunction()
f1_loaded.load(f, test=True)
with h5py.File("test_file_2",driver="core",
backing_store=False) as f:
f2.save(f, test=True)
f2_loaded = CorrelationFunction()
f2_loaded.load(f, test=True)
numpy.testing.assert_array_equal(f1.data, f1_loaded.data)
numpy.testing.assert_array_equal(f1.axis.data, f1_loaded.axis.data)
numpy.testing.assert_array_equal(f2.data, f2_loaded.data)
numpy.testing.assert_array_equal(f2.axis.data, f2_loaded.axis.data)
temperature = 300.0 # in Kelvins
# Time axis on which everything is calculated
time = TimeAxis(0.0, 2000, 1.0) # in fs
cfce_params1 = dict(ftype="OverdampedBrownian",
reorg=30.0,
cortime=60.0,
T=temperature)
cfce_params2 = dict(ftype="OverdampedBrownian",
reorg=30.0,
cortime=60.0,
T=temperature)
with energy_units("1/cm"):
cfce1 = CorrelationFunction(time,cfce_params1)
cfce2 = CorrelationFunction(time,cfce_params2)
explicit_mapping = False
if explicit_mapping:
cm = CorrelationFunctionMatrix(time,12)
i = cm.set_correlation_function(cfce1, [(1,1),(2,2)]) #,
#iof=1)
cm.set_correlation_function(cfce1, [(4,4),(6,6),(7,7),(11,11)])
cm.set_correlation_function(cfce2, [(0,0),(3,3),(5,5),(8,8),(9,9),(10,10)]) #,
#iof=2)
# Mapping of the correlation functions on the transitions in monomers
m1.set_egcf_mapping((0,1),cm,0)
m2.set_egcf_mapping((0,1),cm,1)
from quantarhei import TimeAxis
from quantarhei import energy_units, eigenbasis_of
#
# Define and build the system
#
en = [0.0, 1.0]
m1 = Molecule("Mol1", en)
m2 = Molecule("Mol2", en)
m3 = Molecule("Mol3", en)
m1.set_dipole(0, 1, [1.0, 0.0, 0.0])
time = TimeAxis(0.0, 1000, 1.0)
bath_params = dict(ftype="OverdampedBrownian", T=300, cortime=100, reorg=30.0)
with energy_units("1/cm"):
cf = CorrelationFunction(time, bath_params)
m1.set_transition_environment((0, 1), cf)
m2.set_transition_environment((0, 1), cf)
m3.set_transition_environment((0, 1), cf)
ag = Aggregate("Homodimer")
ag.add_Molecule(m1)
ag.add_Molecule(m2)
ag.add_Molecule(m3)
ag.set_resonance_coupling(0, 1, 0.1)
mult = 2
ag.build(mult=mult, sbi_for_higher_ex=False)
def redfield_relaxation(self):
print("Redfield rate calculation")
#
# Correlation function
#
params = {
"ftype": world.ctype,
"reorg": world.reorg,
"cortime": world.ctime,
"T": world.temp,
"matsubara": world.mats
}
# FIXME: also time_units, temperature_units
with energy_units(world.e_units):
cf = CorrelationFunction(world.ta, params)
#
# Homodimer
#
with energy_units(world.h_units):
en = world.senergy
m1 = Molecule("mol1", [0.0, en])
m2 = Molecule("mol2", [0.0, en])
# m3 = Molecule("mol2", [0.0, en])
m1.set_egcf((0, 1), cf)
m2.set_egcf((0, 1), cf)
# m3.set_egcf((0,1), cf)
agg = Aggregate("Homodimer")
agg.add_Molecule(m1)
agg.add_Molecule(m2)
# agg.add_Molecule(m3)
# with energy_units("1/cm"):
# Hm = m1.get_Hamiltonian()
# print(Hm)
# print(m.convert_energy_2_current_u(Hm._data))
with energy_units(world.r_units):
agg.set_resonance_coupling(0, 1, world.r_coupl)
# agg.set_resonance_coupling(1,2,world.r_coupl)
agg.build()
H = agg.get_Hamiltonian()
# with energy_units("1/cm"):
# print(H)
# print(m.convert_energy_2_current_u(H._data))
sbi = agg.get_SystemBathInteraction()
RRM = RedfieldRateMatrix(H, sbi)
world.K12 = numpy.real(RRM.data[1, 2])
dim = H.dim
rates_M = numpy.zeros(dim * dim)
k = 0
for i in range(dim):
for j in range(dim):
rates_M[k] = RRM.data[i, j]
k += 1
world.rates_M = rates_M
mol2.set_dipole(0,1,[1.0, 2.0, 0.0])
#
# Setting up laboratory
#
lab = lab_settings(lab_settings.FOUR_WAVE_MIXING)
a_0 = numpy.array([1.0, 0.0, 0.0], dtype=numpy.float64)
lab.set_laser_polarizations(a_0,a_0,a_0,a_0)
#
# System-bath interaction
#
tsbi = TimeAxis(0.0, 3*Nr, 2.0)
params = dict(ftype="OverdampedBrownian", T=300, reorg=70.0, cortime=100.0)
with energy_units('1/cm'):
cf = CorrelationFunction(tsbi, params)
params2 = dict(ftype="UnderdampedBrownian", T=300, reorg=10.0, freq=150.0,
gamma=1.0/10000.0)
with energy_units('1/cm'):
cf2 = CorrelationFunction(tsbi, params2)
cf.add_to_data(cf2)
#
# Set system-bath interaction
#
mol1.set_transition_environment((0,1),cf)
mol2.set_transition_environment((0,1),cf)
#
def redfield_tensor(self):
print("Redfield tensor calculation")
#
# Correlation function
#
params = {"ftype": world.ctype,
"reorg": world.reorg,
"cortime": world.ctime,
"T": world.temp,
"matsubara":world.mats}
# FIXME: also time_units, temperature_units
with energy_units(world.e_units):
cf = CorrelationFunction(world.ta,params)
#
# Homodimer
#
with energy_units(world.h_units):
en = world.senergy
m1 = Molecule([0.0, en], "mol1")
m2 = Molecule([0.0, en], "mol2")
m1.set_egcf((0,1), cf)
m2.set_egcf((0,1), cf)
agg = Aggregate(name="Homodimer")
agg.add_Molecule(m1)
agg.add_Molecule(m2)
# m = Manager()
##
# with energy_units("1/cm"):
# Hm = m1.get_Hamiltonian()
# print(Hm)
# print(m.convert_energy_2_current_u(Hm._data))
with energy_units(world.r_units):
agg.set_resonance_coupling(0,1,world.r_coupl)
agg.build()
H = agg.get_Hamiltonian()
world.HH = H
##
# with energy_units("1/cm"):
# print(H)
# print(m.convert_energy_2_current_u(H._data))
sbi = agg.get_SystemBathInteraction()
H.protect_basis()
with eigenbasis_of(H):
RRT = RedfieldRelaxationTensor(H, sbi)
dim = H.dim
rates_T = numpy.zeros(dim*dim)
k = 0
world.K12 = numpy.real(RRT.data[1,1,2,2])
for i in range(dim):
for j in range(dim):
rates_T[k] = numpy.real(RRT.data[i,i,j,j])
k += 1
world.rates_T = rates_T