def build_aggregate_2(settings): """Example function for building aggregate no. 2""" mol_l = [] mod_l = [] with qr.energy_units("1/cm"): for ind in range(settings["Nmol"]): mol = Molecule([0.0, settings["E1"]]) # mol1.set_dipole(0,1,[1.0, 0.0, 0.0]) # mol1.set_transition_width((0,1), width) mod = Mode(settings["omega"]) mol.add_Mode(mod) mod.set_nmax(0, settings["Nvib_0"]) mod.set_nmax(1, settings["Nvib_1"]) mod.set_HR(1, settings["HR"]) mol_l.append(mol) mod_l.append(mod) agg = Aggregate(molecules=mol_l) for ind in range(settings["Nmol"] - 1): agg.set_resonance_coupling(ind, ind + 1, settings["JJ"]) # agg.set_resonance_coupling(settings["Nmol"]-1, 0, settings["JJ"]) agg.build(mult=1) return agg
def test_abs_calculator(self): """Testing some basic methods of the AbsSpectrumCalculator class """ #Calculations for monomer are already performed. Now testing that #absorption spectrum can be calculated for an aggregate. try: mol1 = Molecule(elenergies=[0.0, 12000.0]) mol2 = Molecule(elenergies=[0.0, 12000.0]) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) mol1.set_dipole(0,1,[0.0, 1.0, 0.0]) mol2.set_dipole(0,1,[0.0, 1.0, 0.0]) cf = CorrelationFunction(self.ta, params) mol1.set_transition_environment((0,1),cf) mol2.set_transition_environment((0,1),cf) agg = Aggregate(name="tester_dim", molecules=[mol1, mol2]) agg.build() HH = agg.get_Hamiltonian() abs_calc = AbsSpectrumCalculator(self.ta, system=agg, dynamics="secular", relaxation_tensor=None, rate_matrix=None) abs_calc.bootstrap(rwa=12000) abs_calc = abs_calc.calculate() except: raise Exception('Absorption not calculatable for aggregate')
def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule",elenergies=self.en) self.m.set_dipole(0,1,[1.0,0.0,0.0]) self.m.set_dipole(0,2,[0.5,0.0,0.0]) self.rho_eq = self.m.get_thermal_ReducedDensityMatrix()
def setUp(self,verbose=False): fluors = FluorSpectrumBase() with energy_units("1/cm"): f = FrequencyAxis(10000.0,2000, 1.0) a = self._spectral_shape(f, [1.0, 11000.0, 100.0]) fluors.axis = f fluors.data = a self.fluors = fluors self.axis = fluors.axis #make a single-molecule system time = TimeAxis(0.0,1000,1.0) self.ta = time with energy_units("1/cm"): mol1 = Molecule(elenergies=[0.0, 12000.0]) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) mol1.set_dipole(0,1,[0.0, 1.0, 0.0]) cf = CorrelationFunction(time, params) mol1.set_transition_environment((0,1),cf) fluor_calc = FluorSpectrumCalculator(time, system=mol1) fluor_calc.bootstrap(rwa=12000) fluor1 = fluor_calc.calculate() self.fluor1 = fluor1
class TestReducedDensityMatrix(unittest.TestCase): """Tests for the Manager class """ def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule", elenergies=self.en) self.m.set_dipole(0, 1, [1.0, 0.0, 0.0]) self.m.set_dipole(0, 2, [0.5, 0.0, 0.0]) self.rho_eq = self.m.get_thermal_ReducedDensityMatrix() def test_excitation_by_delta(self): """Testing reduced density matrix excitation by delta-pulse """ rho_exp = numpy.zeros((3, 3), dtype=numpy.float) rho_exp[0, 0] = 1.0 self.assertTrue(numpy.allclose(self.rho_eq._data, rho_exp)) dd = self.m.get_TransitionDipoleMoment() epol = [1.0, 0.0, 0.0] rho_ex = self.rho_eq.excite_delta(dmoment=dd, epolarization=epol) rho_exp = numpy.array([[0.00 + 0.j, 0.00 + 0.j, 0.00 + 0.j], [0.00 + 0.j, 1.00 + 0.j, 0.50 + 0.j], [0.00 + 0.j, 0.50 + 0.j, 0.25 + 0.j]]) self.assertTrue(numpy.allclose(rho_exp, rho_ex._data)) rho_ex2 = self.rho_eq.excite_delta( dmoment=dd, epolarization=[1.0 / numpy.sqrt(2.0), 1.0 / numpy.sqrt(2.0), 0.0]) rho_exp2 = numpy.array([[0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j], [0.000 + 0.j, 0.500 + 0.j, 0.250 + 0.j], [0.000 + 0.j, 0.250 + 0.j, 0.125 + 0.j]]) self.assertTrue(numpy.allclose(rho_ex2._data, rho_exp2)) def test_conversion_2_populations(self): """Testing conversion of reduced density matrix to population vector """ rdm = ReducedDensityMatrix( data=[[0.5, 0.0, 0.1], [0.0, 0.3, 0.0], [0.1, 0.0, 0.2]]) pop = rdm.get_populations() self.assertTrue(numpy.allclose(pop, [0.5, 0.3, 0.2]))
def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule", elenergies=self.en) time = TimeAxis(0, 1000, 1.0) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) with energy_units("1/cm"): fc = CorrelationFunction(time, params) self.m.set_transition_environment((0, 1), fc) self.fc = fc
def homochain_aggregate(self): molecules = [] time = world.time #TimeAxis(0.0, 10000, 1.0) k = 0 couplings = [] temp = 0.0 for row in self.hashes: tenergy = float(row['tr_energy']) coupling = float(row['neighbor_coupling']) ftype_abbv = row['corfce'] if ftype_abbv == "OB": ftype = "OverdampedBrownian" reorg = float(row['reorg']) e_units = row['e_units'] ctime = float(row['ctime']) tempp = float(row['temperature']) matsu = int(row['matsubara']) if temp == 0.0: temp = tempp else: if temp != tempp: raise Exception( "Temperatures must be the same for all molecules") params = dict(ftype=ftype, cortime=ctime, reorg=reorg, T=temp, matsubara=matsu) with energy_units(e_units): m = Molecule(name="", elenergies=[0.0, tenergy]) cf = CorrelationFunction(time, params) m.set_transition_environment((0, 1), cf) molecules.append(m) couplings.append(coupling) k += 1 agg = Aggregate(name="", molecules=molecules) with energy_units("1/cm"): for i in range(k): if i + 1 < k: agg.set_resonance_coupling(i, i + 1, couplings[i]) else: agg.set_resonance_coupling(i, 0, couplings[i]) agg.build() world.temperature = temp world.aggregate = agg world.time = time world.N = k + 1
def setUp(self, verbose=False): self.verbose = verbose # # PURE ELECTRONIC AGGREGATE # m1 = Molecule([0.0, 1.0]) m2 = Molecule([0.0, 1.0]) agg = Aggregate(molecules=[m1, m2]) agg.set_resonance_coupling(0, 1, 0.1) agg.build() self.ham = agg.get_Hamiltonian() KK12 = ProjectionOperator(1, 2, dim=self.ham.dim) KK21 = ProjectionOperator(2, 1, dim=self.ham.dim) self.rates = (1.0 / 100.0, 1.0 / 200.0) self.sbi = SystemBathInteraction([KK12, KK21], rates=self.rates) self.sbi.set_system(agg) # # VIBRONIC AGGREGATE # vm1 = Molecule([0.0, 1.0]) vm2 = Molecule([0.0, 1.0]) mod1 = Mode(0.01) mod2 = Mode(0.01) vm1.add_Mode(mod1) vm2.add_Mode(mod2) mod1.set_nmax(0, 3) mod1.set_nmax(1, 3) mod2.set_nmax(0, 3) mod2.set_nmax(1, 3) vagg = Aggregate(molecules=[vm1, vm2]) vagg.set_resonance_coupling(0, 1, 0.1) vagg.build() self.vham = vagg.get_Hamiltonian() self.vsbi = SystemBathInteraction([KK12, KK21], rates=self.rates) self.vsbi.set_system(vagg)
def homochain_aggregate(self): molecules = [] time = world.time #TimeAxis(0.0, 10000, 1.0) k = 0 couplings = [] temp = 0.0 for row in self.hashes: tenergy = float(row['tr_energy']) coupling = float(row['neighbor_coupling']) ftype_abbv = row['corfce'] if ftype_abbv == "OB": ftype = "OverdampedBrownian" reorg = float(row['reorg']) e_units = row['e_units'] ctime = float(row['ctime']) tempp = float(row['temperature']) matsu = int(row['matsubara']) if temp == 0.0: temp = tempp else: if temp != tempp: raise Exception("Temperatures must be the same for all molecules") params = dict(ftype=ftype, cortime=ctime, reorg=reorg, T=temp, matsubara=matsu) with energy_units(e_units): m = Molecule([0.0, tenergy]) cf = CorrelationFunction(time, params) m.set_transition_environment((0,1), cf) molecules.append(m) couplings.append(coupling) k += 1 agg = Aggregate(molecules=molecules) with energy_units("1/cm"): for i in range(k): if i+1 < k: agg.set_resonance_coupling(i,i+1,couplings[i]) else: agg.set_resonance_coupling(i,0,couplings[i]) agg.build() world.temperature = temp world.aggregate = agg world.time = time world.N = k+1
class TestMolecule(unittest.TestCase): """Tests for the Manager class """ def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule", elenergies=self.en) def test_Molecule_instantiation(self): """Testing Molecule instantiation """ self.assertEqual(self.m.name, "Molecule") for i in range(2): self.assertEqual(self.m.elenergies[i], self.en[i]) def test_get_Hamiltonian(self): """Testing that Molecule returns correct Hamiltonian """ H = self.m.get_Hamiltonian() h = numpy.zeros((3, 3), dtype=numpy.float) h[1, 1] = 1.0 h[2, 2] = 2.0 self.assertTrue(numpy.allclose(H.data, h))
def setUp(self): en = [0.0, 1.0] self.m = Molecule(name="Molecule",elenergies=en) mod1 = Mode(frequency=0.1) self.m.add_Mode(mod1) mod1.set_nmax(0,3) mod1.set_nmax(1,3) en2 = [0.0,0.1,0.1] self.m2 = Molecule(name="AdMolecule",elenergies=en2) self.m2.set_adiabatic_coupling(1,2,0.02) mod2 = Mode(frequency=0.01) self.m2.add_Mode(mod2) mod2.set_nmax(0,3) mod2.set_nmax(1,3) mod2.set_nmax(2,3)
def setUp(self): en = [0.0, 1.0] self.m = Molecule(name="Molecule", elenergies=en) mod1 = Mode(frequency=0.1) self.m.add_Mode(mod1) mod1.set_nmax(0, 3) mod1.set_nmax(1, 3) en2 = [0.0, 0.1, 0.1] self.m2 = Molecule(name="AdMolecule", elenergies=en2) self.m2.set_adiabatic_coupling(1, 2, 0.02) mod2 = Mode(frequency=0.01) self.m2.add_Mode(mod2) mod2.set_nmax(0, 3) mod2.set_nmax(1, 3) mod2.set_nmax(2, 3)
def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule",elenergies=self.en) time = TimeAxis(0,1000,1.0) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) with energy_units("1/cm"): fc = CorrelationFunction(time,params) self.m.set_transition_environment((0,1),fc) self.fc = fc
def absorption_spectrum_molecule(self): dd = [0.0,1.0,0.0] cf = world.cf with energy_units("1/cm"): m = Molecule([0.0, 12000]) m.set_dipole(0,1,dd) m.set_egcf([0,1],cf) ac = AbsSpectrumCalculator(world.ta,m) ac.bootstrap(rwa=m.elenergies[1]) a1 = ac.calculate(raw=True) with energy_units("1/cm"): world.abs = numpy.zeros((len(a1.data),2)) for kk in range(len(a1.data)): world.abs[kk,0] = a1.axis.data[kk] #frequency[kk] world.abs[kk,1] = a1.data[kk]
def when_molecules_are_created(self): N = len(world.e0) molecules = [] for i in range(N): e0 = world.e0[i] e1 = world.e1[i] units = world.units[i] m1 = Molecule("Mol",[e0,e1]) molecules.append(m1) world.molecules = molecules
def hamiltonian_is_created(self): # # Homodimer # with energy_units(world.h_units): en = world.senergy m1 = Molecule([0.0, en], "mol1") m2 = Molecule([0.0, en], "mol2") agg = Aggregate(name="Homodimer") agg.add_Molecule(m1) agg.add_Molecule(m2) with energy_units(world.r_units): agg.set_resonance_coupling(0, 1, world.r_coupl) agg.build() world.HH = agg.get_Hamiltonian()
def setUp(self, verbose=False): abss = AbsSpectrumBase() with energy_units("1/cm"): f = FrequencyAxis(10000.0, 2000, 1.0) a = self._spectral_shape(f, [1.0, 11000.0, 100.0]) abss.axis = f abss.data = a self.abss = abss self.axis = abss.axis time = TimeAxis(0.0, 1000, 1.0) with energy_units("1/cm"): mol1 = Molecule(elenergies=[0.0, 12000.0]) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) mol1.set_dipole(0, 1, [0.0, 1.0, 0.0]) cf = CorrelationFunction(time, params) mol1.set_transition_environment((0, 1), cf) abs_calc = AbsSpectrumCalculator(time, system=mol1) abs_calc.bootstrap(rwa=12000) abs1 = abs_calc.calculate() self.abs1 = abs1
def build_testing_aggregate(): """Testing aggregate for unit tests.""" # Number of molecules Nmol = 2 # energy of molecule one E1 = 12500.0 # energy gap to molecule two Edelta = 100.0 # coupling between the two molecules JJ = 30.0 # frequency of the vibrational mode omega = 110.0 # Huan-Rhys factor HR = 0.01 # transition width width = 80 # max nvib states Nvib_0 = 3 Nvib_1 = 3 mol_l = [] mod_l = [] with qr.energy_units("1/cm"): for ind in range(Nmol): mol = Molecule([0.0, E1]) mol.set_dipole(0, 1, [1.0, 0.0, 0.0]) mol.set_transition_width((0, 1), width) mod = Mode(omega) mol.add_Mode(mod) mod.set_nmax(0, Nvib_0) mod.set_nmax(1, Nvib_1) mod.set_HR(1, HR) mol_l.append(mol) mod_l.append(mod) agg = Aggregate(molecules=mol_l) for ind in range(Nmol - 1): agg.set_resonance_coupling(ind, ind + 1, JJ) agg.set_resonance_coupling(Nmol - 1, 0, JJ) agg.build(mult=1) return agg
def setUp(self,verbose=False): self.verbose = verbose # # PURE ELECTRONIC AGGREGATE # m1 = Molecule([0.0, 1.0]) m2 = Molecule([0.0, 1.0]) agg = Aggregate(molecules=[m1, m2]) agg.set_resonance_coupling(0,1, 0.1) agg.build() self.ham = agg.get_Hamiltonian() KK12 = ProjectionOperator(1, 2, dim=self.ham.dim) KK21 = ProjectionOperator(2, 1, dim=self.ham.dim) self.rates = (1.0/100.0, 1.0/200.0) self.sbi = SystemBathInteraction([KK12,KK21], rates=self.rates) self.sbi.set_system(agg) # # VIBRONIC AGGREGATE # vm1 = Molecule([0.0, 1.0]) vm2 = Molecule([0.0, 1.0]) mod1 = Mode(0.01) mod2 = Mode(0.01) vm1.add_Mode(mod1) vm2.add_Mode(mod2) mod1.set_nmax(0, 3) mod1.set_nmax(1, 3) mod2.set_nmax(0, 3) mod2.set_nmax(1, 3) vagg = Aggregate(molecules=[vm1, vm2]) vagg.set_resonance_coupling(0, 1, 0.1) vagg.build() self.vham = vagg.get_Hamiltonian() self.vsbi = SystemBathInteraction([KK12, KK21], rates=self.rates) self.vsbi.set_system(vagg)
def absorption_spectrum_molecule(self): dd = [0.0, 1.0, 0.0] cf = world.cf with energy_units("1/cm"): m = Molecule("Mol", [0.0, 12000]) m.set_dipole(0, 1, dd) m.set_egcf([0, 1], cf) a1 = AbsSpect(world.ta, m) a1.calculate(rwa=m.elenergies[1]) with energy_units("1/cm"): world.abs = numpy.zeros((len(a1.data), 2)) for kk in range(len(a1.data)): world.abs[kk, 0] = a1.axis.data[kk] #frequency[kk] world.abs[kk, 1] = a1.data[kk]
# -*- coding: utf-8 -*- from quantarhei import Molecule, Aggregate, CorrelationFunction 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
class TestMolecule(unittest.TestCase): """Tests for the Manager class """ def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule",elenergies=self.en) time = TimeAxis(0,1000,1.0) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) with energy_units("1/cm"): fc = CorrelationFunction(time,params) self.m.set_transition_environment((0,1),fc) self.fc = fc def test_Molecule_instantiation(self): """Testing Molecule instantiation """ self.assertEqual(self.m.name,"Molecule") for i in range(2): self.assertEqual(self.m.elenergies[i],self.en[i]) def test_get_Hamiltonian(self): """Testing that Molecule returns correct Hamiltonian """ H = self.m.get_Hamiltonian() h = numpy.zeros((3,3),dtype=numpy.float) h[1,1] = 1.0 h[2,2] = 2.0 self.assertTrue(numpy.allclose(H.data,h)) def test_saving_of_molecule(self): """Testing the saving capability of the Molecule class """ use_temporary_file = True with energy_units("1/cm"): mod = Mode(frequency=150) mod1 = Mode(frequency=100) m2 = Molecule(elenergies=[0.0, 2.0]) m2.add_Mode(mod) m2.add_Mode(mod1) if use_temporary_file: #drv = "core" #bcs = False #with h5py.File('tempfile.hdf5', # driver=drv, # backing_store=bcs) as f: with tempfile.TemporaryFile() as f: #self.m.save_as(f,"Molecule") self.m.save(f, test=True) # reread it m = Molecule() #m.load_as(f,"Molecule") m = m.load(f, test=True) else: #with h5py.File('tempfile.hdf5') as f: with open('tempfile.qrp', 'wb') as f: #self.m.save_as(f,"Molecules") self.m.save(f) #with h5py.File('tempfile.hdf5') as f: with open('tempfile.qrp', 'rb') as f: m = Molecule() #m.load_as(f,"Molecules") m = m.load(f) self.assertEqual(self.m.name, m.name) self.assertEqual(self.m.nel, m.nel) numpy.testing.assert_array_equal(self.m.elenergies, m.elenergies) numpy.testing.assert_array_equal( self.m.get_transition_environment((0,1)).data, self.fc.data) #with h5py.File('tempfile.hdf5', # driver=drv, # backing_store=bcs) as f: with tempfile.TemporaryFile() as f: #self.m.save_as(f,"Molecule") m2.save(f, test=True) # reread it m3 = Molecule() #m.load_as(f,"Molecule") m3 = m3.load(f, test=True) self.assertEqual(m2.name, m3.name) self.assertEqual(m2.nel, m3.nel) numpy.testing.assert_array_equal(m2.elenergies, m3.elenergies) self.assertEqual(m2.get_Mode(0).get_energy(0), mod.get_energy(0)) self.assertEqual(m2.get_Mode(1).get_energy(0), mod1.get_energy(0))
def test_saving_of_molecule(self): """Testing the saving capability of the Molecule class """ use_temporary_file = True with energy_units("1/cm"): mod = Mode(frequency=150) mod1 = Mode(frequency=100) m2 = Molecule(elenergies=[0.0, 2.0]) m2.add_Mode(mod) m2.add_Mode(mod1) if use_temporary_file: #drv = "core" #bcs = False #with h5py.File('tempfile.hdf5', # driver=drv, # backing_store=bcs) as f: with tempfile.TemporaryFile() as f: #self.m.save_as(f,"Molecule") self.m.save(f, test=True) # reread it m = Molecule() #m.load_as(f,"Molecule") m = m.load(f, test=True) else: #with h5py.File('tempfile.hdf5') as f: with open('tempfile.qrp', 'wb') as f: #self.m.save_as(f,"Molecules") self.m.save(f) #with h5py.File('tempfile.hdf5') as f: with open('tempfile.qrp', 'rb') as f: m = Molecule() #m.load_as(f,"Molecules") m = m.load(f) self.assertEqual(self.m.name, m.name) self.assertEqual(self.m.nel, m.nel) numpy.testing.assert_array_equal(self.m.elenergies, m.elenergies) numpy.testing.assert_array_equal( self.m.get_transition_environment((0,1)).data, self.fc.data) #with h5py.File('tempfile.hdf5', # driver=drv, # backing_store=bcs) as f: with tempfile.TemporaryFile() as f: #self.m.save_as(f,"Molecule") m2.save(f, test=True) # reread it m3 = Molecule() #m.load_as(f,"Molecule") m3 = m3.load(f, test=True) self.assertEqual(m2.name, m3.name) self.assertEqual(m2.nel, m3.nel) numpy.testing.assert_array_equal(m2.elenergies, m3.elenergies) self.assertEqual(m2.get_Mode(0).get_energy(0), mod.get_energy(0)) self.assertEqual(m2.get_Mode(1).get_energy(0), mod1.get_energy(0))
def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule", elenergies=self.en)
pause("\nLet us add some vibrational states to the studied system ...") print(""" ############################################################################### # # # EXAMPLE 2.2 # # # ############################################################################### """) # # The same Hamiltonian using the Molecule class # from quantarhei import Molecule m = Molecule(name="Mol 1", elenergies=[0.0, 1.0]) m.set_adiabatic_coupling(0,1,0.4) from quantarhei import Mode vib1 = Mode(frequency=0.01) m.add_Mode(vib1) vib1.set_shift(1, 0.5) vib1.set_nmax(0, 5) vib1.set_nmax(1, 5) Hm = m.get_Hamiltonian() print(Hm) print(m)
if verbose: print("\nSingle photosynthetic reaction center fluorescence simulation") print( "-------------------------------------------------------------\n") # # All definitions below are done with energy units of inverse # centimeters (1/cm). We use Python's context manager concept for this. # # Here we switch to the 1/cm units with energy_units("1/cm"): # Molecule named "RC-P" with three states (ground, CT and exciton state) # is created en = [0.0, 14500, 15500] m = Molecule("RC-P",en) # Transition dipole moment from 0 -> 2 (exciton state) is set to # a unit vector in the direction of x-axis (this choice is arbitrary) di = numpy.sqrt(23.0)*0.20819434 m.set_dipole(0,2,[di,0.0,0.0]) # # To represent CT coordinate, we add an explicite harmonic mode # to the molecule. # # First the mode with frequency 10 1/cm is created qct = Mode(frequency=10.0) # and registered with the molecule m.add_Mode(qct)
def setup(self): """Simulation definition In this method we define the simulation. We have to define molecular system, type of system-bath interaction and the theory to handel it, and the data to be calculated. Below, the definition sections are described in detail together with the definition options and required Quantarhei imports. """ ############################################################### # # General section # ############################################################### from quantarhei import TimeAxis # time interval of propagation self.timeaxis = TimeAxis(0.0, 1000, 1.0) ############################################################### # # Molecular system definition section # ############################################################### from quantarhei import Molecule from quantarhei import energy_units # define as many molecules as you want # use energy units of your choice with energy_units("1/cm"): m1 = Molecule([0.0, 12000.0]) m2 = Molecule([0.0, 12200.0]) m3 = Molecule([0.0, 12000.0]) # optionally you can specify positions (default units are Angstroms) m1.position = [0.0, 0.0, 0.0] m2.position = [10.0, 0.0, 0.0] m3.position = [0.0, 10.0, 0.0] # transition dipole moments for selected transitions m1.set_dipole(0, 1, [12.0, 0.0, 0.0]) m2.set_dipole(0, 1, [8.0, 8.0, 0.0]) m3.set_dipole(0, 1, [0.0, 8.0, 8.0]) # couplings between molecules # #self.coupling_matrix = [[0.0, 100.0], # [100.0, 0.0]] #self.energy_units = "1/cm" # # or # self.coupling_matrix = "by_dipole_dipole" # # setting molecules is compulsory self.molecules = [m1, m2, m3] ############################################################## # # Type of excitonic problem section # ############################################################## # here we define what kind of problem we calculate self.exciton_type = "electronic" #self.exciton_type = "vibronic" # exciton multiplicity specifies if we handle only single # exciton band (value 1) or also include two-exciton band (value 2) self.exciton_multiplicity = 2 ############################################################# # # Relaxation theory # ############################################################# # # Relaxation using Lindblad form # from quantarhei.qm import Operator o1 = Operator(dim=7, real=True) o1.data[1,2] = 1.0 o1.data[2,3] = 1.0 self.sys_operators = [o1] self.rates = (1.0/300,) self.relaxation_theory = "Lindblad_form" # Use it in site or excitonic basis self.use_sitebasis = True # # Redfield theory # #self.relaxation_theory = "Standard_Redfield" # # Nothings else needs to be specified; it was defined on molecules # # Redfield is calculated strictly in excitonic basis # The ``use_sitebasis`` attribute does not affect anything # ############################################################# # # Initial condition # ############################################################# from quantarhei import ReducedDensityMatrix rho0 = ReducedDensityMatrix(dim=7) rho0.data[3,3] = 1.0 self.rho0 = rho0 ############################################################# # # Simulation tasks # ############################################################# #task_1 = dict(task="density_matrix_dynamics", # object_file="rdm"+self._get_timestamp(filename=True) # +".hdf5") task_1 = dict(task="density_matrix_dynamics") self.tasks = [task_1]
# -*- coding: utf-8 -*- from quantarhei import Molecule from quantarhei import energy_units en = [0.0, 12500] # 12500 1/cm corresponds to an absorption # at the wavelength of 800 nm (near infra red light) with energy_units("1/cm"): m = Molecule("Molecule with units", en) H = m.get_Hamiltonian() print(H) with energy_units("1/cm"): print(H) with energy_units("eV"): print("Managed data: \n", H.data) print("\nRaw data:\n", H._data)
time = TimeAxis() # time is not used here at all LFa, ham = agg.get_RelaxationTensor(time, relaxation_theory="electronic_Lindblad") LFa.convert_2_tensor() print(LFa.data[1,1,2,2]) print(LFa.data[1,2,1,2]) # # VIBRONIC Aggregate of two molecules # m1v = Molecule([0.0, 1.0]) m2v = Molecule([0.0, 1.1]) m3v = Molecule([0.0, 1.2]) from quantarhei import Mode mod1 = Mode(0.01) mod2 = Mode(0.01) mod3 = Mode(0.01) Nvib = 2 m1v.add_Mode(mod1) mod1.set_nmax(0, Nvib) mod1.set_nmax(1, Nvib) mod1.set_HR(1, 0.3)
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([0.0, en],"mol1") m2 = Molecule([0.0, en], "mol2") # 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(name="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
def when_Molecule_is_created(self): with energy_units(world.units): world.m1 = Molecule("Mol1",[world.e0,world.e1])
# -*- coding: utf-8 -*- from quantarhei import Molecule from quantarhei import energy_units en = [0.0, 12500] # 12500 1/cm corresponds to an absorption # at the wavelength of 800 nm (near infra red light) with energy_units("1/cm"): m = Molecule(en, name="Molecule with units") H = m.get_Hamiltonian() print("\nInternal units:") print("---------------") print(H) with energy_units("1/cm"): print("\nInverse centimeters:") print("--------------------") print(H) with energy_units("eV"): print("\nElectronvolts:") print("--------------") print("\nManaged data: \n", H.data) print("\nRaw data:\n", H._data)
def setup(self): """Simulation definition In this method we define the simulation. We have to define molecular system, type of system-bath interaction and the theory to handel it, and the data to be calculated. Below, the definition sections are described in detail together with the definition options and required Quantarhei imports. """ ############################################################### # # General section # ############################################################### from quantarhei import TimeAxis # time interval of propagation self.timeaxis = TimeAxis(0.0, 1000, 1.0) ############################################################### # # Molecular system definition section # ############################################################### from quantarhei import Molecule from quantarhei import energy_units # define as many molecules as you want # use energy units of your choice with energy_units("1/cm"): m1 = Molecule([0.0, 12000.0]) m2 = Molecule([0.0, 12200.0]) m3 = Molecule([0.0, 12000.0]) # optionally you can specify positions (default units are Angstroms) m1.position = [0.0, 0.0, 0.0] m2.position = [10.0, 0.0, 0.0] m3.position = [0.0, 10.0, 0.0] # transition dipole moments for selected transitions m1.set_dipole(0, 1, [12.0, 0.0, 0.0]) m2.set_dipole(0, 1, [8.0, 8.0, 0.0]) m3.set_dipole(0, 1, [0.0, 8.0, 8.0]) # couplings between molecules # #self.coupling_matrix = [[0.0, 100.0], # [100.0, 0.0]] #self.energy_units = "1/cm" # # or # self.coupling_matrix = "by_dipole_dipole" # # setting molecules is compulsory self.molecules = [m1, m2, m3] ############################################################## # # Type of excitonic problem section # ############################################################## # here we define what kind of problem we calculate self.exciton_type = "electronic" #self.exciton_type = "vibronic" # exciton multiplicity specifies if we handle only single # exciton band (value 1) or also include two-exciton band (value 2) self.exciton_multiplicity = 2 ############################################################# # # Relaxation theory # ############################################################# # # Relaxation using Lindblad form # from quantarhei.qm import Operator o1 = Operator(dim=7, real=True) o1.data[1, 2] = 1.0 o1.data[2, 3] = 1.0 self.sys_operators = [o1] self.rates = (1.0 / 300, ) self.relaxation_theory = "Lindblad_form" # Use it in site or excitonic basis self.use_sitebasis = True # # Redfield theory # #self.relaxation_theory = "Standard_Redfield" # # Nothings else needs to be specified; it was defined on molecules # # Redfield is calculated strictly in excitonic basis # The ``use_sitebasis`` attribute does not affect anything # ############################################################# # # Initial condition # ############################################################# from quantarhei import ReducedDensityMatrix rho0 = ReducedDensityMatrix(dim=7) rho0.data[3, 3] = 1.0 self.rho0 = rho0 ############################################################# # # Simulation tasks # ############################################################# #task_1 = dict(task="density_matrix_dynamics", # object_file="rdm"+self._get_timestamp(filename=True) # +".hdf5") task_1 = dict(task="density_matrix_dynamics") self.tasks = [task_1]
# Time axis for t1 and t3 times Nr = 1000 ta = TimeAxis(0.0, Nr, 2.0) ############################################################################### # # Define problem # ############################################################################### # # define molecules # with energy_units("1/cm"): mol1 = Molecule(elenergies=[0.0, 12300.0]) mol2 = Molecule(elenergies=[0.0, 12000.0]) mol1.position = [0.0, 0.0, 0.0] # dimer 1 mol2.position = [0.0, 6.0, 0.0] ## dimer 2 #mol2.position = [0.0, 0.0, 6.0] mol1.set_dipole(0, 1, [4.0, 2.0, 0.0]) 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)
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
# Time axis for t1 and t3 times Nr = 1000 ta = TimeAxis(0.0, Nr, 2.0) ############################################################################### # # Define problem # ############################################################################### # # define molecules # with energy_units("1/cm"): mol1 = Molecule(elenergies=[0.0, 12300.0]) mol2 = Molecule(elenergies=[0.0, 12000.0]) mol1.position = [0.0, 0.0, 0.0] # dimer 1 mol2.position = [0.0, 6.0, 0.0] ## dimer 2 #mol2.position = [0.0, 0.0, 6.0] mol1.set_dipole(0,1,[4.0, 2.0, 0.0]) 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)
class TestMoleculeVibrations(unittest.TestCase): def setUp(self): en = [0.0, 1.0] self.m = Molecule(name="Molecule", elenergies=en) mod1 = Mode(frequency=0.1) self.m.add_Mode(mod1) mod1.set_nmax(0, 3) mod1.set_nmax(1, 3) en2 = [0.0, 0.1, 0.1] self.m2 = Molecule(name="AdMolecule", elenergies=en2) self.m2.set_adiabatic_coupling(1, 2, 0.02) mod2 = Mode(frequency=0.01) self.m2.add_Mode(mod2) mod2.set_nmax(0, 3) mod2.set_nmax(1, 3) mod2.set_nmax(2, 3) def test_molecule_with_vibrations_1(self): """Testing hamiltonian of a two-level molecule with one mode """ H1 = self.m.get_Hamiltonian() H1expected = numpy.diag([0.0, 0.1, 0.2, 1.0, 1.1, 1.2]) self.assertTrue(numpy.allclose(H1expected, H1.data)) mod1 = self.m.get_Mode(0) mod1.set_nmax(1, 2) H2 = self.m.get_Hamiltonian() H2expected = numpy.diag([0.0, 0.1, 0.2, 1.0, 1.1]) self.assertTrue(numpy.allclose(H2expected, H2.data)) def test_thermal_density_matrix_0_temp(self): """Thermal density matrix: molecule with one mode, zero temperature """ rho_eq = self.m.get_thermal_ReducedDensityMatrix() # Check if the matrix is diagonal dat = rho_eq.data.copy() for i in range(dat.shape[0]): dat[i, i] = 0.0 zer = numpy.zeros(dat.shape, dtype=numpy.float) self.assertTrue(numpy.allclose(dat, zer)) # Check if diagonal is a thermal population pop = numpy.zeros(dat.shape[0]) # get temperature from the molecule T = self.m.get_temperature() self.assertEquals(T, 0.0) # get density matrix rho = self.m.get_thermal_ReducedDensityMatrix() rpop = rho.get_populations() if numpy.abs(T) < 1.0e-10: pop[0] = 1.0 else: # thermal populations pass self.assertTrue(numpy.allclose(pop, rpop)) def test_thermal_density_matrix_finite_temp(self): """Thermal density matrix: molecule with one mode, finite temperature """ timeAxis = TimeAxis(0.0, 1000, 1.0) params = { "ftype": "OverdampedBrownian", "T": 300, "reorg": 30, "cortime": 100 } cfcion = CorrelationFunction(timeAxis, params) self.m.set_egcf((0, 1), cfcion) rho_eq = self.m.get_thermal_ReducedDensityMatrix() # Check if the matrix is diagonal dat = rho_eq.data.copy() for i in range(dat.shape[0]): dat[i, i] = 0.0 zer = numpy.zeros(dat.shape, dtype=numpy.float) self.assertTrue(numpy.allclose(dat, zer)) # Check if diagonal is a thermal population pop = numpy.zeros(dat.shape[0]) # get temperature from the molecule T = self.m.get_temperature() self.assertTrue(T == 300.0) # get density matrix rpop = rho_eq.get_populations() # get Hamiltonian H = self.m.get_Hamiltonian() if numpy.abs(T) < 1.0e-10: pop[0] = 1.0 else: # thermal populations psum = 0.0 for n in range(pop.shape[0]): pop[n] = numpy.exp(-H.data[n, n] / (kB_intK * T)) psum += pop[n] pop *= 1.0 / psum self.assertTrue(numpy.allclose(pop, rpop)) def test_thermal_density_matrix_finite_temp_nondiag(self): """Thermal density matrix: finite temperature, non-diagonal Hamiltonian """ timeAxis = TimeAxis(0.0, 1000, 1.0) params = { "ftype": "OverdampedBrownian", "T": 300.0, "reorg": 30, "cortime": 100 } cfcion = CorrelationFunction(timeAxis, params) self.m2.set_egcf((0, 1), cfcion) self.m2.set_egcf((0, 2), cfcion) rho_eq = self.m2.get_thermal_ReducedDensityMatrix() pop = numpy.zeros(rho_eq._data.shape[0]) # get temperature from the molecule T = self.m2.get_temperature() self.assertTrue(numpy.abs(T - 300.0) < 1.0e-10) # get Hamiltonian H = self.m2.get_Hamiltonian() with eigenbasis_of(H): # get density matrix rpop = rho_eq.get_populations() if numpy.abs(T) < 1.0e-10: pop[0] = 1.0 else: # thermal populations psum = 0.0 for n in range(pop.shape[0]): pop[n] = numpy.exp(-H.data[n, n] / (kB_intK * T)) psum += pop[n] pop *= 1.0 / psum self.assertTrue(numpy.allclose(pop, rpop))
_show_plots_ = False """ Demo of the Lindblad form First we create a Lindblad form for a purely electronic system, the we create electronic Lindblad form for a system with vibrational levels """ # # PURELY ELECTRONIC Aggregate of two molecules # from quantarhei import Molecule m1 = Molecule([0.0, 1.0]) m2 = Molecule([0.0, 1.1]) m3 = Molecule([0.0, 1.2]) from quantarhei import Aggregate agg = Aggregate([m1, m2, m3]) agg.build() # # Operator describing relaxation # from quantarhei.qm import Operator HH = agg.get_Hamiltonian() K = Operator(dim=HH.dim,real=True)
def setUp(self): m1 = Molecule(name="Molecule 1", elenergies=[0.0, 1.0]) m2 = Molecule(name="Molecule 2", elenergies=[0.0, 1.0]) time = TimeAxis(0.0, 1000, 1.0) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) with energy_units("1/cm"): fc = CorrelationFunction(time, params) m1.set_transition_environment((0, 1), fc) m1.position = [0.0, 0.0, 0.0] m1.set_dipole(0, 1, [10.0, 0.0, 0.0]) m2.set_transition_environment((0, 1), fc) m2.position = [10.0, 0.0, 0.0] m2.set_dipole(0, 1, [10.0, 0.0, 0.0]) self.agg = Aggregate(name="TestAgg", molecules=[m1, m2]) self.agg.set_coupling_by_dipole_dipole() self.agg.build() m3 = Molecule(name="Molecule 1", elenergies=[0.0, 1.0]) m4 = Molecule(name="Molecule 2", elenergies=[0.0, 1.0]) m3.add_Mode(Mode(0.01)) m4.add_Mode(Mode(0.01)) mod3 = m3.get_Mode(0) mod4 = m4.get_Mode(0) mod3.set_nmax(0, 4) mod3.set_nmax(1, 4) mod3.set_HR(1, 0.1) mod4.set_nmax(0, 4) mod4.set_nmax(1, 4) mod4.set_HR(1, 0.3) self.vagg = Aggregate(molecules=[m3, m4]) self.vagg.build()
# -*- coding: utf-8 -*- _show_plots_ = False from quantarhei import Molecule, Aggregate #from quantarhei import energy_units en = [0.0, 1.0] m1 = Molecule(name="Mol1", elenergies=en) m2 = Molecule(name="Mol2", elenergies=en) ag = Aggregate(name="Homodimer") ag.add_Molecule(m1) ag.add_Molecule(m2) ag.set_resonance_coupling(0, 1, 0.1) ag.build(mult=1) H = ag.get_Hamiltonian() #with energy_units("1/cm"): # print(H)
def absorption_spectrum_trimer(self): dd1 = [0.0,3.0,0.0] dd2 = [0.0,1.0,2.0] dd3 = [0.0,1.0,1.0] cf = world.cf with energy_units("1/cm"): m1 = Molecule([0.0, 12100]) m1.set_dipole(0,1,dd1) m1.set_transition_environment((0,1), cf) m2 = Molecule([0.0, 11800]) m2.set_dipole(0,1,dd2) m2.set_transition_environment((0,1), cf) m3 = Molecule([0.0, 12500]) m3.set_dipole(0,1,dd3) m3.set_transition_environment((0,1), cf) m1.position = [0.0,0.0,0.0] m2.position = [5.0,0.0,0.0] m3.position = [0.0,5.0,0.0] AG = Aggregate(name="TestAggregate") AG.add_Molecule(m1) AG.add_Molecule(m2) AG.add_Molecule(m3) AG.set_coupling_by_dipole_dipole(epsr=3.0) AG.build() (RRr,hamr) = AG.get_RelaxationTensor(world.ta, relaxation_theory="standard_Redfield", time_dependent=True) ac = AbsSpectrumCalculator(world.ta,AG, relaxation_tensor=RRr, effective_hamiltonian=hamr) with energy_units("1/cm"): ac.bootstrap(rwa=12000) a1 = ac.calculate(raw=True) with energy_units("1/cm"): world.abs = numpy.zeros((len(a1.data),2)) for kk in range(len(a1.data)): world.abs[kk,0] = a1.axis.data[kk] #frequency[kk] world.abs[kk,1] = a1.data[kk]
from quantarhei import energy_units from quantarhei.utils import normalize2 from quantarhei.core.units import cm2int, kB_intK """ Create monomers """ # state energies en1 = [0.0,12100] #*cm2int] en2 = [0.0,12000] #*cm2int] # transition dipole moment """ d0 = [0.0,0.0,0.0] """ d1 = normalize2([0.0,1.0,0.0],1.0) with energy_units("1/cm"): m1 = Molecule("M1",en1) #,[d0,d1]) m1.set_dipole(0,1,d1) m2 = Molecule("M2",en1) #,[d0,d1]) m2.set_dipole(0,1,d1) m3 = Molecule("M3",en2) #,[d0,d1]) m3.set_dipole(0,1,d1) m4 = Molecule("M4",en1) #,[d0,d1]) m4.set_dipole(0,1,d1) m5 = Molecule("M5",en1) #,[d0,d1]) m5.set_dipole(0,1,d1) m6 = Molecule("M6",en1) #,[d0,d1]) m6.set_dipole(0,1,d1) m7 = Molecule("M7",en1) #,[d0,d1]) m7.set_dipole(0,1,d1) m8 = Molecule("M8",en1) #,[d0,d1]) m8.set_dipole(0,1,d1)
# Time axis for t1 and t3 times Nr = 100 ta = TimeAxis(0.0, Nr, 10.0) ############################################################################### # # Define problem # ############################################################################### # # define molecules # with energy_units("1/cm"): mol1 = Molecule(elenergies=[0.0, 12000.0]) mol2 = Molecule(elenergies=[0.0, 12200.0]) mol3 = Molecule(elenergies=[0.0, 12400.0]) mol4 = Molecule(elenergies=[0.0, 12500.0]) mol1.position = [0.0, 0.0, 0.0] mol2.position = [0.0, 10.0, 0.0] mol3.position = [10.0, 0.0, 0.0] mol4.position = [0.0, 0.0, 10.0] mol1.set_dipole(0, 1, [10.0, 0.0, 0.0]) mol2.set_dipole(0, 1, [-10.0, 0.0, 0.0]) mol3.set_dipole(0, 1, [0.0, 0.0, 10.0]) v1 = numpy.array([0.3, 0.3, 0.3]) v1 = 10.0 * v1 / numpy.sqrt(numpy.dot(v1, v1)) mol4.set_dipole(0, 1, v1) molecules = [mol1, mol2, mol3, mol4]
def absorption_spectrum_dimer(self): dd1 = [0.0,3.0,0.0] dd2 = [0.0,1.0,1.0] cf = world.cf #cm = CorrelationFunctionMatrix(world.ta,2,1) #cm.set_correlation_function(cf,[(1,1),(0,0)]) with energy_units("1/cm"): m1 = Molecule([0.0, 12100]) m1.set_dipole(0,1,dd1) m1.set_transition_environment((0,1), cf) m2 = Molecule([0.0, 12000]) m2.set_dipole(0,1,dd2) m2.set_transition_environment((0,1), cf) #m1.set_egcf([0,1],cf) #m2.set_egcf([0,1],cf) #m1.set_egcf_mapping((0,1),cm,0) #m2.set_egcf_mapping((0,1),cm,1) m1.position = [0.0,0.0,0.0] m2.position = [5.0,0.0,0.0] AG = Aggregate(name="TestAggregate") #AG.set_egcf_matrix(cm) AG.add_Molecule(m1) AG.add_Molecule(m2) AG.set_coupling_by_dipole_dipole() AG.build() ac = AbsSpectrumCalculator(world.ta,AG) with energy_units("1/cm"): ac.bootstrap(rwa=12000) a1 = ac.calculate(raw=True) with energy_units("1/cm"): world.abs = numpy.zeros((len(a1.data),2)) for kk in range(len(a1.data)): world.abs[kk,0] = a1.axis.data[kk] #frequency[kk] world.abs[kk,1] = a1.data[kk]
class TestReducedDensityMatrix(unittest.TestCase): """Tests for the Manager class """ def setUp(self): self.en = [0.0, 1.0, 2.0] self.m = Molecule(name="Molecule",elenergies=self.en) self.m.set_dipole(0,1,[1.0,0.0,0.0]) self.m.set_dipole(0,2,[0.5,0.0,0.0]) self.rho_eq = self.m.get_thermal_ReducedDensityMatrix() def test_excitation_by_delta(self): """Testing reduced density matrix excitation by delta-pulse """ rho_exp = numpy.zeros((3,3),dtype=numpy.float) rho_exp[0,0] = 1.0 self.assertTrue(numpy.allclose(self.rho_eq._data,rho_exp)) dd = self.m.get_TransitionDipoleMoment() epol = [1.0, 0.0, 0.0] rho_ex = self.rho_eq.excite_delta(dmoment=dd,epolarization=epol) rho_exp = numpy.array([[ 0.00+0.j, 0.00+0.j, 0.00+0.j], [ 0.00+0.j, 1.00+0.j, 0.50+0.j], [ 0.00+0.j, 0.50+0.j, 0.25+0.j]]) self.assertTrue(numpy.allclose(rho_exp,rho_ex._data)) rho_ex2 = self.rho_eq.excite_delta(dmoment=dd, epolarization=[1.0/numpy.sqrt(2.0), 1.0/numpy.sqrt(2.0),0.0]) rho_exp2 = numpy.array([[ 0.000+0.j, 0.000+0.j, 0.000+0.j], [ 0.000+0.j, 0.500+0.j, 0.250+0.j], [ 0.000+0.j, 0.250+0.j, 0.125+0.j]]) self.assertTrue(numpy.allclose(rho_ex2._data,rho_exp2)) def test_conversion_2_populations(self): """Testing conversion of reduced density matrix to population vector """ rdm = ReducedDensityMatrix(data=[[0.5, 0.0, 0.1], [0.0, 0.3, 0.0], [0.1, 0.0, 0.2]]) pop = rdm.get_populations() self.assertTrue(numpy.allclose(pop,[0.5,0.3,0.2])) def test_saveable(self): """Testing reduced density matrix as Saveable """ rdm = ReducedDensityMatrix(data=[[0.5, 0.0, 0.1], [0.0, 0.3, 0.0], [0.1, 0.0, 0.2]]) #import h5py #with h5py.File("test_file_operators",driver="core", # backing_store=False) as fid: import tempfile with tempfile.TemporaryFile() as fid: rdm.save(fid) #, test=True) fid.seek(0) rdm2 = ReducedDensityMatrix() rdm2 = rdm2.load(fid) #, test=True) self.assertTrue(numpy.allclose(rdm2.data,rdm.data))
def setUp(self): m1 = Molecule(name="Molecule 1", elenergies=[0.0, 1.0]) m2 = Molecule(name="Molecule 2", elenergies=[0.0, 1.0]) time = TimeAxis(0.0, 1000, 1.0) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) with energy_units("1/cm"): fc = CorrelationFunction(time, params) m1.set_transition_environment((0,1), fc) m1.position = [0.0, 0.0, 0.0] m1.set_dipole(0,1,[10.0, 0.0, 0.0]) m2.set_transition_environment((0,1), fc) m2.position = [10.0, 0.0, 0.0] m2.set_dipole(0,1,[10.0, 0.0, 0.0]) self.agg = Aggregate(name="TestAgg", molecules=[m1,m2]) self.agg.set_coupling_by_dipole_dipole() self.agg.build() m3 = Molecule(name="Molecule 1", elenergies=[0.0, 1.0]) m4 = Molecule(name="Molecule 2", elenergies=[0.0, 1.0]) m3.add_Mode(Mode(0.01)) m4.add_Mode(Mode(0.01)) mod3 = m3.get_Mode(0) mod4 = m4.get_Mode(0) mod3.set_nmax(0, 4) mod3.set_nmax(1, 4) mod3.set_HR(1, 0.1) mod4.set_nmax(0, 4) mod4.set_nmax(1, 4) mod4.set_HR(1, 0.3) self.vagg = Aggregate(molecules=[m3, m4]) self.vagg.build()
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("mol1", [0.0, en]) m2 = Molecule("mol2", [0.0, en]) m1.set_egcf((0, 1), cf) m2.set_egcf((0, 1), cf) agg = Aggregate("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
# -*- coding: utf-8 -*- from quantarhei import Molecule from quantarhei import energy_units en = [0.0, 12500] # 12500 1/cm corresponds to an absorption # at the wavelength of 800 nm (near infra red light) with energy_units("1/cm"): m = Molecule(en, name="Molecule with units") H = m.get_Hamiltonian() print("\nInternal units:") print("---------------") print(H) with energy_units("1/cm"): print("\nInverse centimeters:") print("--------------------") print(H) with energy_units("eV"): print("\nElectronvolts:") print("--------------") print("\nManaged data: \n", H.data) print("\nRaw data:\n",H._data)
def setUp(self,verbose=False): circdichs = CircDichSpectrumBase() with energy_units("1/cm"): f = FrequencyAxis(10000.0,2000, 1.0) a = self._spectral_shape(f, [1.0, 11000.0, 100.0]) circdichs.axis = f circdichs.data = a self.circdichs = circdichs self.axis = circdichs.axis #make a single-molecule system time = TimeAxis(0.0,1000,1.0) self.ta = time with energy_units("1/cm"): mol1 = Molecule(elenergies=[0.0, 12000.0]) mol2 = Molecule(elenergies=[0.0, 12000.0]) params = dict(ftype="OverdampedBrownian", reorg=20, cortime=100, T=300) mol1.set_dipole(0,1,[0.0, 1.0, 0.0]) mol2.set_dipole(0,1,[0.0, 1.0, 0.0]) cf = CorrelationFunction(time, params) mol1.set_transition_environment((0,1),cf) mol2.set_transition_environment((0,1),cf) mol1.position = [0, 0, 0] mol2.position = [10, 10, 10] agg = Aggregate(name="tester_dim", molecules=[mol1, mol2]) agg.build() circdich_calc = CircDichSpectrumCalculator(time, system=agg) circdich_calc.bootstrap(rwa=12000) circdich1 = circdich_calc.calculate() self.circdich1 = circdich1
# -*- coding: utf-8 -*- from quantarhei import Molecule, Aggregate from quantarhei import energy_units en = [0.0, 1.0] m1 = Molecule("Mol1", en) m2 = Molecule("Mol2", en) ag = Aggregate("Homodimer", maxband=1) ag.add_Molecule(m1) ag.add_Molecule(m2) ag.set_resonance_coupling(0, 1, 0.1) ag.build() H = ag.get_Hamiltonian() with energy_units("1/cm"): print(H)
* *********************************************************** """) from quantarhei import Manager # # FIXME: temporary fix for version 0.0.34 # Manager().gen_conf.legacy_relaxation = True # # PURELY ELECTRONIC Aggregate of two molecules # from quantarhei import Molecule m1 = Molecule([0.0, 1.0]) m2 = Molecule([0.0, 1.1]) m3 = Molecule([0.0, 1.2]) from quantarhei import Aggregate agg = Aggregate([m1, m2, m3]) agg.build() # # Operator describing relaxation # from quantarhei.qm import Operator HH = agg.get_Hamiltonian() K = Operator(dim=HH.dim, real=True)
class TestMoleculeVibrations(unittest.TestCase): def setUp(self): en = [0.0, 1.0] self.m = Molecule(name="Molecule",elenergies=en) mod1 = Mode(frequency=0.1) self.m.add_Mode(mod1) mod1.set_nmax(0,3) mod1.set_nmax(1,3) en2 = [0.0,0.1,0.1] self.m2 = Molecule(name="AdMolecule",elenergies=en2) self.m2.set_adiabatic_coupling(1,2,0.02) mod2 = Mode(frequency=0.01) self.m2.add_Mode(mod2) mod2.set_nmax(0,3) mod2.set_nmax(1,3) mod2.set_nmax(2,3) def test_molecule_with_vibrations_1(self): """Testing hamiltonian of a two-level molecule with one mode """ H1 = self.m.get_Hamiltonian() H1expected = numpy.diag([0.0, 0.1, 0.2, 1.0, 1.1, 1.2]) self.assertTrue(numpy.allclose(H1expected,H1.data)) mod1 = self.m.get_Mode(0) mod1.set_nmax(1,2) H2 = self.m.get_Hamiltonian() H2expected = numpy.diag([0.0, 0.1, 0.2, 1.0, 1.1]) self.assertTrue(numpy.allclose(H2expected,H2.data)) def test_thermal_density_matrix_0_temp(self): """Thermal density matrix: molecule with one mode, zero temperature """ rho_eq = self.m.get_thermal_ReducedDensityMatrix() # Check if the matrix is diagonal dat = rho_eq.data.copy() for i in range(dat.shape[0]): dat[i,i] = 0.0 zer = numpy.zeros(dat.shape,dtype=numpy.float) self.assertTrue(numpy.allclose(dat,zer)) # Check if diagonal is a thermal population pop = numpy.zeros(dat.shape[0]) # get temperature from the molecule T = self.m.get_temperature() self.assertEquals(T,0.0) # get density matrix rho = self.m.get_thermal_ReducedDensityMatrix() rpop = rho.get_populations() if numpy.abs(T) < 1.0e-10: pop[0] = 1.0 else: # thermal populations pass self.assertTrue(numpy.allclose(pop,rpop)) def test_thermal_density_matrix_finite_temp(self): """Thermal density matrix: molecule with one mode, finite temperature """ timeAxis = TimeAxis(0.0,1000,1.0) params = {"ftype":"OverdampedBrownian", "T":300, "reorg":30, "cortime":100} with energy_units("1/cm"): cfcion = CorrelationFunction(timeAxis,params) self.m.set_egcf((0,1),cfcion) rho_eq = self.m.get_thermal_ReducedDensityMatrix() # Check if the matrix is diagonal dat = rho_eq.data.copy() for i in range(dat.shape[0]): dat[i,i] = 0.0 zer = numpy.zeros(dat.shape,dtype=numpy.float) self.assertTrue(numpy.allclose(dat,zer)) # Check if diagonal is a thermal population pop = numpy.zeros(dat.shape[0]) # get temperature from the molecule T = self.m.get_temperature() self.assertTrue(T==300.0) # get density matrix rpop = rho_eq.get_populations() # get Hamiltonian H = self.m.get_Hamiltonian() if numpy.abs(T) < 1.0e-10: pop[0] = 1.0 else: # thermal populations psum = 0.0 for n in range(pop.shape[0]): pop[n] = numpy.exp(-H.data[n,n]/(kB_intK*T)) psum += pop[n] pop *= 1.0/psum self.assertTrue(numpy.allclose(pop,rpop)) def test_thermal_density_matrix_finite_temp_nondiag(self): """Thermal density matrix: finite temperature, non-diagonal Hamiltonian """ timeAxis = TimeAxis(0.0,1000,1.0) params = {"ftype":"OverdampedBrownian", "T":300.0, "reorg":30, "cortime":100} cfcion = CorrelationFunction(timeAxis,params) self.m2.set_egcf((0,1),cfcion) self.m2.set_egcf((0,2),cfcion) rho_eq = self.m2.get_thermal_ReducedDensityMatrix() pop = numpy.zeros(rho_eq._data.shape[0]) # get temperature from the molecule T = self.m2.get_temperature() self.assertTrue(numpy.abs(T-300.0)<1.0e-10) # get Hamiltonian H = self.m2.get_Hamiltonian() with eigenbasis_of(H): # get density matrix rpop = rho_eq.get_populations() if numpy.abs(T) < 1.0e-10: pop[0] = 1.0 else: # thermal populations psum = 0.0 for n in range(pop.shape[0]): pop[n] = numpy.exp(-H.data[n,n]/(kB_intK*T)) psum += pop[n] pop *= 1.0/psum self.assertTrue(numpy.allclose(pop,rpop))