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