def setUp(self):
UTGroundStateSetup.setUp(self)
for virtvar in ['timesteps', 'propagator']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
self.tdname = 'ut_tddft_td_' + self.propagator.lower()
self.tdcalc = TDDFT(self.gsname + '.gpw', propagator=self.propagator,
txt=self.tdname + '.txt')
def time_propagation(self,
filename,
kick_strength,
time_step,
iterations,
dipole_moment_file=None,
restart_file=None,
dump_interval=100,
**kwargs):
self.td_calc = TDDFT(filename, **kwargs)
if kick_strength is not None:
self.td_calc.absorption_kick(kick_strength)
self.td_calc.hamiltonian.poisson.set_kick(kick_strength)
self.td_calc.propagate(time_step, iterations, dipole_moment_file,
restart_file, dump_interval)
Ekin = 40e3 # kinetic energy of the ion (in eV)
# Adapted to the ion energy; here 4 as (probably too large!)
timestep = 16.0 * np.sqrt(10e3 / Ekin)
ekin_str = '_ek' + str(int(Ekin / 1000)) + 'k'
strbody = name + ekin_str
traj_file = strbody + '.traj'
# The parallelization options should match the number of cores, here 8.
p_bands = 2 # number of bands to parallelise over
dom_dc = (2, 2, 4) # domain decomposition for parallelization
parallel = {'band': p_bands, 'domain': dom_dc}
tdcalc = TDDFT(name + '.gpw',
propagator='EFSICN',
solver='BiCGStab',
txt=strbody + '_td.txt',
parallel=parallel)
proj_idx = 50 # atomic index of the projectile
delta_stop = 5.0 / Bohr # stop condition when ion is within 5 A of boundary.
# Setting the initial velocity according to the kinetic energy.
amu_to_aumass = _amu / _me
Mproj = tdcalc.atoms.get_masses()[proj_idx] * amu_to_aumass
Ekin *= 1 / Hartree
v = np.zeros((proj_idx + 1, 3))
v[proj_idx, 2] = -np.sqrt((2 * Ekin) / Mproj) * Bohr / AUT
tdcalc.atoms.set_velocities(v)
evv = EhrenfestVelocityVerlet(tdcalc)
# Test floating point arithmetic errors
equal(gs_calc.hamiltonian.poisson.shift_indices_1, [4, 4, 10], 0)
equal(gs_calc.hamiltonian.poisson.shift_indices_2, [8, 8, 16], 0)
# Save state
gs_calc.write('gs.gpw', 'all')
classical_material = None
gs_calc = None
# Initialize TDDFT and FDTD
kick = [0.0, 0.0, 1.0e-3]
time_step = 10.0
max_time = 100 # 0.1 fs
td_calc = TDDFT('gs.gpw')
td_calc.absorption_kick(kick_strength=kick)
td_calc.hamiltonian.poisson.set_kick(kick)
# Propagate TDDFT and FDTD
td_calc.propagate(time_step, max_time / time_step / 2, 'dm.dat', 'td.gpw')
td_calc2 = TDDFT('td.gpw')
td_calc2.propagate(time_step, max_time / time_step / 2, 'dm.dat', 'td.gpw')
# Test
ref_cl_dipole_moment = [5.25374117e-14, 5.75811267e-14, 3.08349334e-02]
ref_qm_dipole_moment = [1.78620337e-11, -1.57782578e-11, 5.21368300e-01]
#print("ref_cl_dipole_moment = %s" % td_calc2.hamiltonian.poisson.get_classical_dipole_moment())
#print("ref_qm_dipole_moment = %s" % td_calc2.hamiltonian.poisson.get_quantum_dipole_moment())
calc = GPAW(name + '_es.gpw',
txt=name + '_esx.txt',
parallel={'band': 1})
calc.set_positions()
dscf_collapse_orbitals(calc)
calc.write(name + '_esx.gpw', mode='all')
del calc
time.sleep(10)
while not os.path.isfile(name + '_esx.gpw'):
print('Node %d waiting for %s...' % (world.rank, name + '_esx.gpw'))
time.sleep(10)
world.barrier()
tdcalc = TDDFT(name + '_esx.gpw',
txt=name + '_td.txt',
propagator='EFSICN')
ehrenfest = EhrenfestVelocityVerlet(tdcalc)
traj = PickleTrajectory(name + '_td.traj', 'w', tdcalc.get_atoms())
t0 = time.time()
f = paropen(name + '_td.log', 'w')
for i in range(1, niter + 1):
ehrenfest.propagate(timestep)
if i % ndiv == 0:
rate = 60 * ndiv / (time.time() - t0)
ekin = tdcalc.atoms.get_kinetic_energy()
epot = tdcalc.get_td_energy() * Hartree
F_av = ehrenfest.F * Hartree / Bohr
print(
from gpaw.tddft import TDDFT
from gpaw.inducedfield.inducedfield_fdtd import (FDTDInducedField,
calculate_hybrid_induced_field
)
from gpaw.inducedfield.inducedfield_tddft import TDDFTInducedField
td_calc = TDDFT('td.gpw')
# Classical subsystem
cl_ind = FDTDInducedField(filename='cl.ind', paw=td_calc)
cl_ind.calculate_induced_field(gridrefinement=2)
cl_ind.write('cl_field.ind', mode='all')
# Quantum subsystem
qm_ind = TDDFTInducedField(filename='qm.ind', paw=td_calc)
qm_ind.calculate_induced_field(gridrefinement=2)
qm_ind.write('qm_field.ind', mode='all')
# Total system, interpolate/extrapolate to a grid with spacing h
tot_ind = calculate_hybrid_induced_field(cl_ind, qm_ind, h=1.0)
tot_ind.write('tot_field.ind', mode='all')
sigma = tar['Width']
except KeyError:
timestep = 1
sigma = None
omega_w = tar.get('Frequency')
gamma_w = tar.get('PhaseFactor')
Fnt_wsG = tar.get('FourierTransform')
Ant_sG = tar.get('Average')
atoms = None
del tar
gpw_filename = sys.argv[2]
assert gpw_filename.endswith('.gpw'), 'Invalid GPW tarfile.'
assert os.path.isfile(gpw_filename), 'GPW tarfile not found.'
calc = TDDFT(gpw_filename, txt=None)
obs = DensityFourierTransform(timestep * autime_to_attosec,
omega_w * aufrequency_to_eV,
(sigma is not None and sigma \
* aufrequency_to_eV or None))
obs.initialize(calc)
atoms = calc.get_atoms()
del calc
obs.read(ftd_filename, idiotproof=False)
try:
sys.stdout.write('Select grid refinement [1*/2]: ')
gdref = int(sys.stdin.readline().strip())
except:
gdref = 1
getall = slice(None) #hack to obtain all frequencies/spins
Fnt_wsG = obs.get_fourier_transform(getall, getall, gdref)
from gpaw.tddft import TDDFT
from gpaw.tddft.ehrenfest import EhrenfestVelocityVerlet
import sys
d = 4.5
atoms = Atoms('NaCl', [(0,0,0),(0,0,d)])
atoms.center(vacuum=4.5)
d = 4.0
atoms.set_positions([(0,0,0),(0,0,d)])
atoms.center()
gs_calc = GPAW(nbands=4, gpts=(64,64,96), xc='LDA', setups='hgh')
atoms.set_calculator(gs_calc)
atoms.get_potential_energy()
gs_calc.write('nacl_hgh_gs.gpw', 'all')
td_calc = TDDFT('nacl_hgh_gs.gpw', propagator='ETRSCN')
evv = EhrenfestVelocityVerlet(td_calc, 0.001)
i=0
evv.get_energy()
r = evv.x[1][2] - evv.x[0][2]
print 'E = ', [i, r, evv.Etot, evv.Ekin, evv.Epot]
for i in range(10000):
evv.propagate(1.0)
evv.get_energy()
r = evv.x[1][2] - evv.x[0][2]
print 'E = ', [i+1, r, evv.Etot, evv.Ekin, evv.Epot]
d = 4.0
atoms = Atoms('NaCl', [(0, 0, 0), (0, 0, d)])
atoms.center(vacuum=4.5)
gs_calc = GPAW(nbands=4,
eigensolver='cg',
gpts=(32, 32, 44),
xc='LDA',
setups={'Na': '1'})
atoms.set_calculator(gs_calc)
atoms.get_potential_energy()
gs_calc.write('nacl_gs.gpw', 'all')
td_calc = TDDFT('nacl_gs.gpw', propagator='EFSICN')
evv = EhrenfestVelocityVerlet(td_calc, 0.001)
i = 0
evv.get_energy()
r = evv.x[1][2] - evv.x[0][2]
# print 'E = ', [i, r, evv.Etot, evv.Ekin, evv.e_coulomb]
for i in range(5):
evv.propagate(1.0)
evv.get_energy()
r = evv.x[1][2] - evv.x[0][2]
print('E = ', [i + 1, r, evv.Etot, evv.Ekin, evv.e_coulomb])
equal(r, 7.558883144, 1e-6)
equal(evv.Etot, -0.1036763317, 1e-7)
atoms = molecule('SiH4')
atoms.center(vacuum=4.0)
# Ground-state calculation
calc = GPAW(nbands=7,
h=0.4,
poissonsolver=PoissonSolver(eps=1e-16),
convergence={'density': 1e-8},
xc='GLLBSC',
txt='gs.out')
atoms.set_calculator(calc)
energy = atoms.get_potential_energy()
calc.write('gs.gpw', mode='all')
# Time-propagation calculation
td_calc = TDDFT('gs.gpw', txt='td.out')
td_calc.absorption_kick(np.ones(3) * 1e-5)
td_calc.propagate(20, 3, 'dm.dat')
# Write a restart point
td_calc.write('td.gpw', mode='all')
# Keep propagating
td_calc.propagate(20, 3, 'dm.dat')
# Restart from the restart point
td_calc = TDDFT('td.gpw', txt='td2.out')
td_calc.propagate(20, 3, 'dm.dat')
world.barrier()
# Check dipole moment file
from ase.io import Trajectory
from ase.parallel import parprint
name = 'h2_diss'
# Ehrenfest simulation parameters
timestep = 10.0 # timestep given in attoseconds
ndiv = 10 # write trajectory every 10 timesteps
niter = 500 # run for 500 timesteps
# TDDFT calculator with an external potential emulating an intense
# harmonic laser field aligned (CWField uses by default the z axis)
# along the H2 molecular axis.
tdcalc = TDDFT(name + '_gs.gpw',
txt=name + '_td.txt',
propagator='EFSICN',
solver='BiCGStab',
td_potential=CWField(1000 * Hartree, 1 * AUT, 10))
# For Ehrenfest dynamics, we use this object for the Velocity Verlet dynamics.
ehrenfest = EhrenfestVelocityVerlet(tdcalc)
# Trajectory to save the dynamics.
traj = Trajectory(name + '_td.traj', 'w', tdcalc.get_atoms())
# Propagates the dynamics for niter timesteps.
for i in range(1, niter + 1):
ehrenfest.propagate(timestep)
if tdcalc.atoms.get_distance(0, 1) > 2.0:
# Stop simulation if H-H distance is greater than 2 A
# Initialize GPAW
gs_calc = GPAW(gpts=gpts,
eigensolver='cg',
nbands=-2,
poissonsolver=poissonsolver)
atoms.set_calculator(gs_calc)
# Ground state
energy = atoms.get_potential_energy()
# Save state
gs_calc.write('gs.%s.gpw' % tag, 'all')
# Initialize TDDFT and FDTD
td_calc = TDDFT('gs.%s.gpw' % tag)
td_calc.absorption_kick(kick_strength=kick)
td_calc.hamiltonian.poisson.set_kick(kick)
# Propagate TDDFT and FDTD
td_calc.propagate(time_step, 50, 'dm.%s.dat' % tag, 'td.%s.gpw' % tag)
# Test
ref_cl_dipole_moment = [2.72623607e-02, 1.98393701e-09, -1.98271199e-09]
ref_qm_dipole_moment = [1.44266213e-02, 1.04985435e-09, -1.04920610e-09]
tol = 0.0001
equal(td_calc.get_dipole_moment(), ref_qm_dipole_moment, tol)
equal(td_calc.hamiltonian.poisson.get_dipole_moment(), ref_cl_dipole_moment,
tol)
import numpy as np
from ase import Atoms
from gpaw import GPAW
from gpaw.tddft import TDDFT
from gpaw.tddft.abc import LinearAbsorbingBoundary
from gpaw.tddft.laser import CWField
atoms = Atoms('Be', [(0, 0, 0)], pbc=False)
atoms.center(vacuum=6)
calc = GPAW(h=0.35)
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write('be_gs.gpw', 'all')
td_calc = TDDFT('be_gs.gpw',
td_potential=CWField(1e-3, 2.0 * np.pi / 50.0, 150.0))
td_calc.set_absorbing_boundary(
LinearAbsorbingBoundary(5.0, 0.01, atoms.positions.copy()))
td_calc.propagate(8.0, 5, 'be_nl_dmz_ipabs_1e-3.dat', 'be_nl_td.gpw')
td_rest = TDDFT('be_nl_td.gpw',
td_potential=CWField(1e-3, 2.0 * np.pi / 50.0, 150.0))
td_rest.set_absorbing_boundary(
LinearAbsorbingBoundary(5.0, 0.01, atoms.positions.copy()))
td_rest.propagate(8.0, 5, 'be_nl_dmz_ipabs_1e-3.dat', 'be_nl_td.gpw')
# Initialize GPAW
gs_calc = GPAW(gpts=gpts, nbands=-1, poissonsolver=poissonsolver)
atoms.set_calculator(gs_calc)
# Ground state
energy = atoms.get_potential_energy()
# Save state
gs_calc.write('gs.gpw', 'all')
# Initialize TDDFT and FDTD
kick = [0.001, 0.000, 0.000]
time_step = 10
iterations = 1000
td_calc = TDDFT('gs.gpw')
td_calc.absorption_kick(kick_strength=kick)
td_calc.hamiltonian.poisson.set_kick(kick)
# Attach InducedField to the calculation
frequencies = [2.45]
width = 0.0
ind = FDTDInducedField(paw=td_calc, frequencies=frequencies, width=width)
# Propagate TDDFT and FDTD
td_calc.propagate(time_step, iterations, 'dm0.dat', 'td.gpw')
# Save results
td_calc.write('td.gpw', 'all')
ind.write('td.ind')
positions=[(0, 0, 0), (3.0, 0, 0)],
pbc=False)
atoms.center(vacuum=3.0)
# Standard ground state calculation
calc = GPAW(nbands=2, h=0.6, setups={'Na': '1'}, poissonsolver=poissonsolver,
convergence={'density': density_eps})
atoms.set_calculator(calc)
energy = atoms.get_potential_energy()
calc.write('na2_gs.gpw', mode='all')
# Standard time-propagation initialization
time_step = 10.0
iterations = 20
kick_strength = [1.0e-3, 1.0e-3, 0.0]
td_calc = TDDFT('na2_gs.gpw')
td_calc.absorption_kick(kick_strength=kick_strength)
# Create and attach InducedField object
frequencies = [1.0, 2.08] # Frequencies of interest in eV
folding = 'Gauss' # Folding function
width = 0.1 # Line width for folding in eV
ind = TDDFTInducedField(paw=td_calc,
frequencies=frequencies,
folding=folding,
width=width,
restart_file='na2_td.ind')
# Propagate as usual
td_calc.propagate(time_step, iterations // 2, 'na2_td_dm.dat', 'na2_td.gpw')
basis='dzp',
txt=name + '_gs.txt',
eigensolver='rmm-diis')
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write(name + '_gs.gpw', mode='all')
del atoms, calc
time.sleep(10)
while not os.path.isfile(name + '_gs.gpw'):
print('Node %d waiting for file...' % world.rank)
time.sleep(10)
world.barrier()
tdcalc = TDDFT(name + '_gs.gpw',
txt=name + '_td.txt',
parallel={'band': 5},
propagator='EFSICN')
ehrenfest = EhrenfestVelocityVerlet(tdcalc)
traj = Trajectory(name + '_td.traj', 'w', tdcalc.get_atoms())
t0 = time.time()
f = paropen(name + '_td.log', 'w')
for i in range(1, niter + 1):
ehrenfest.propagate(timestep)
if i % ndiv == 0:
rate = 60 * ndiv / (time.time() - t0)
ekin = tdcalc.atoms.get_kinetic_energy()
epot = tdcalc.get_td_energy() * Hartree
F_av = ehrenfest.F * Hartree / Bohr
s = 'i=%06d (%6.2f min^-1), ekin=%13.9f, epot=%13.9f, etot=%13.9f'
atoms.center(vacuum=6.0)
# Larger grid spacing, LDA is ok
gs_calc = GPAW(nbands=1, h=0.35, xc='LDA', setups={'Na': '1'})
atoms.set_calculator(gs_calc)
e = atoms.get_potential_energy()
niter = gs_calc.get_number_of_iterations()
gs_calc.write('na2_gs.gpw', 'all')
# 16 fs run with 8.0 attosec time step
time_step = 8.0 # 8.0 as (1 as = 0.041341 autime)5D
iters = 10 # 2000 x 8 as => 16 fs
# Weak delta kick to z-direction
kick = [0, 0, 1e-3]
# TDDFT calculator
td_calc = TDDFT('na2_gs.gpw')
# Kick
td_calc.absorption_kick(kick)
# Propagate
td_calc.propagate(time_step, iters, 'na2_dmz.dat', 'na2_td.gpw')
# Linear absorption spectrum
photoabsorption_spectrum('na2_dmz.dat', 'na2_spectrum_z.dat', width=0.3)
iters = 3
# test restart
td_rest = TDDFT('na2_td.gpw')
td_rest.propagate(time_step, iters, 'na2_dmz2.dat', 'na2_td2.gpw')
# test restart
td_rest = TDDFT('na2_td.gpw', solver='BiCGStab')
input_file = name + '_run' + str(run) + '.gpw'
traj_file = strbody + '.traj'
filename = strbody + '.txt'
f = open(filename, "w")
Natoms = 106
Nkord = 3
p_bands = 2
print(en, run)
#number of iterations and integer divisor to update states every 0.02 fs
#ndiv = int(np.ceil(0.01e3 / timestep))
niter = ndiv * int(np.ceil(duration / (ndiv * timestep)))
#parallel = { 'band' : p_bands, 'domain' : None, 'sl_auto' : True}
#parallel = { 'band' : p_bands, 'domain' : None, 'sl_default' : (4, 4, 64)}
parallel = {'band': p_bands, 'domain': None}
tdcalc = TDDFT(input_file,
solver='CSCG',
propagator='EFSICN',
parallel=parallel)
##Projectile part
proj_idx = Natoms - 1
v = np.zeros((Natoms, 3)) #set all velocity to zero
Mproj = tdcalc.atoms.get_masses()[proj_idx]
#Mat = []
#vat = np.zeros([12, 3])
#for i in range(0,12):
# Mat.append(tdcalc.atoms.get_masses()[i]*amu_to_aumass)
#ekin projectile
Ekin *= Mproj
Ekin = Ekin / Hartree
