def __init__(self, symbol, f_sln, h=0.05, rcut=10.0, **kwargs):
assert len(f_sln) in [1, 2]
self.symbol = symbol
gd = AtomGridDescriptor(h, rcut)
GPAW.__init__(self,
mode=MakeWaveFunctions(gd),
eigensolver=AtomEigensolver(gd, f_sln),
poissonsolver=AtomPoissonSolver(),
nbands=sum([(2 * l + 1) * len(f_n)
for l, f_n in enumerate(f_sln[0])]),
communicator=mpi.serial_comm,
parallel=dict(augment_grids=False),
occupations=AtomOccupations(f_sln),
**kwargs)
# Initialize function will raise an error unless we set a (bogus) cell
self.initialize(Atoms(symbol, calculator=self, cell=np.eye(3)))
self.density.charge_eps = 1e-3
self.calculate(system_changes=['positions'])
def __init__(self,
filename,
td_potential=None,
propagator='SICN',
calculate_energy=True,
propagator_kwargs=None,
solver='CSCG',
tolerance=1e-8,
**kwargs):
"""Create TDDFT-object.
Parameters:
filename: string
File containing ground state or time-dependent state to propagate
td_potential: class, optional
Function class for the time-dependent potential. Must have a method
'strength(time)' which returns the strength of the linear potential
to each direction as a vector of three floats.
propagator: {'SICN','ETRSCN','ECN','SITE','SIKE4','SIKE5','SIKE6'}
Name of the time propagator for the Kohn-Sham wavefunctions
solver: {'CSCG','BiCGStab'}
Name of the iterative linear equations solver for time propagation
tolerance: float
Tolerance for the linear solver
The following parameters can be used: `txt`, `parallel`, `communicator`
`mixer` and `dtype`. The internal parameters `mixer` and `dtype` are
strictly used to specify a dummy mixer and complex type respectively.
"""
# Set initial time
self.time = 0.0
# Set initial kick strength
self.kick_strength = np.array([0.0, 0.0, 0.0], dtype=float)
# Set initial value of iteration counter
self.niter = 0
# Parallelization dictionary should default to strided bands
self.default_parallel = GPAW.default_parallel.copy()
self.default_parallel['stridebands'] = True
self.default_parameters = GPAW.default_parameters.copy()
self.default_parameters['mixer'] = DummyMixer()
# NB: TDDFT restart files contain additional information which
# will override the initial settings for time/kick/niter.
GPAW.__init__(self, filename, **kwargs)
assert isinstance(self.wfs, TimeDependentWaveFunctions)
assert isinstance(self.wfs.overlap, TimeDependentOverlap)
# Prepare for dipole moment file handle
self.dm_file = None
# Initialize wavefunctions and density
# (necessary after restarting from file)
if not self.initialized:
self.initialize()
self.set_positions()
# Don't be too strict
self.density.charge_eps = 1e-5
wfs = self.wfs
self.rank = wfs.world.rank
self.text = self.log
self.text('')
self.text('')
self.text('------------------------------------------')
self.text(' Time-propagation TDDFT ')
self.text('------------------------------------------')
self.text('')
self.text('Charge epsilon: ', self.density.charge_eps)
# Time-dependent variables and operators
self.td_potential = td_potential
self.td_hamiltonian = TimeDependentHamiltonian(self.wfs, self.spos_ac,
self.hamiltonian,
td_potential)
self.td_overlap = self.wfs.overlap # TODO remove this property
self.td_density = TimeDependentDensity(self)
# Solver for linear equations
self.text('Solver: ', solver)
if solver == 'BiCGStab':
self.solver = BiCGStab(gd=wfs.gd,
timer=self.timer,
tolerance=tolerance)
elif solver == 'CSCG':
self.solver = CSCG(gd=wfs.gd,
timer=self.timer,
tolerance=tolerance)
else:
raise RuntimeError('Solver %s not supported.' % solver)
# Preconditioner
# No preconditioner as none good found
self.text('Preconditioner: ', 'None')
self.preconditioner = None # TODO! check out SSOR preconditioning
# self.preconditioner = InverseOverlapPreconditioner(self.overlap)
# self.preconditioner = KineticEnergyPreconditioner(
# wfs.gd, self.td_hamiltonian.hamiltonian.kin, np.complex)
# Time propagator
self.text('Propagator: ', propagator)
if propagator_kwargs is None:
propagator_kwargs = {}
if propagator == 'ECN':
self.propagator = ExplicitCrankNicolson(
self.td_density, self.td_hamiltonian, self.td_overlap,
self.solver, self.preconditioner, wfs.gd, self.timer,
**propagator_kwargs)
elif propagator == 'SICN':
self.propagator = SemiImplicitCrankNicolson(
self.td_density, self.td_hamiltonian, self.td_overlap,
self.solver, self.preconditioner, wfs.gd, self.timer,
**propagator_kwargs)
elif propagator == 'EFSICN':
self.propagator = EhrenfestPAWSICN(self.td_density,
self.td_hamiltonian,
self.td_overlap, self.solver,
self.preconditioner, wfs.gd,
self.timer, **propagator_kwargs)
elif propagator == 'EFSICN_HGH':
self.propagator = EhrenfestHGHSICN(self.td_density,
self.td_hamiltonian,
self.td_overlap, self.solver,
self.preconditioner, wfs.gd,
self.timer, **propagator_kwargs)
elif propagator == 'ETRSCN':
self.propagator = EnforcedTimeReversalSymmetryCrankNicolson(
self.td_density, self.td_hamiltonian, self.td_overlap,
self.solver, self.preconditioner, wfs.gd, self.timer,
**propagator_kwargs)
elif propagator == 'SITE':
self.propagator = SemiImplicitTaylorExponential(
self.td_density, self.td_hamiltonian, self.td_overlap,
self.solver, self.preconditioner, wfs.gd, self.timer,
**propagator_kwargs)
elif propagator == 'SIKE':
self.propagator = SemiImplicitKrylovExponential(
self.td_density, self.td_hamiltonian, self.td_overlap,
self.solver, self.preconditioner, wfs.gd, self.timer,
**propagator_kwargs)
elif propagator.startswith('SITE') or propagator.startswith('SIKE'):
raise DeprecationWarning(
'Use propagator_kwargs to specify degree.')
else:
raise RuntimeError('Time propagator %s not supported.' %
propagator)
if self.rank == 0:
if wfs.kd.comm.size > 1:
if wfs.nspins == 2:
self.text('Parallelization Over Spin')
if wfs.gd.comm.size > 1:
self.text('Using Domain Decomposition: %d x %d x %d' %
tuple(wfs.gd.parsize_c))
if wfs.bd.comm.size > 1:
self.text('Parallelization Over bands on %d Processors' %
wfs.bd.comm.size)
self.text('States per processor = ', wfs.bd.mynbands)
self.hpsit = None
self.eps_tmp = None
self.mblas = MultiBlas(wfs.gd)
# Restarting an FDTD run generates hamiltonian.fdtd_poisson, which
# now overwrites hamiltonian.poisson
if hasattr(self.hamiltonian, 'fdtd_poisson'):
self.hamiltonian.poisson = self.hamiltonian.fdtd_poisson
self.hamiltonian.poisson.set_grid_descriptor(self.density.finegd)
# For electrodynamics mode
if self.hamiltonian.poisson.get_description() == 'FDTD+TDDFT':
self.initialize_FDTD()
self.hamiltonian.poisson.print_messages(self.text)
self.log.flush()
self.calculate_energy = calculate_energy
if self.hamiltonian.xc.name.startswith('GLLB'):
self.text('GLLB model potential. Not updating energy.')
self.calculate_energy = False
def _write(self, writer, mode):
GPAW._write(self, writer, mode)
writer.child('tddft').write(time=self.time,
niter=self.niter,
kick_strength=self.kick_strength)
def initialize(self, reading=False):
self.parameters.mixer = DummyMixer()
self.parameters.experimental['reuse_wfs_method'] = None
GPAW.initialize(self, reading=reading)
def read(self, filename):
reader = GPAW.read(self, filename)
if 'tddft' in reader:
self.time = reader.tddft.time
self.niter = reader.tddft.niter
self.kick_strength = reader.tddft.kick_strength
def create_wave_functions(self, mode, *args, **kwargs):
mode = FDTDDFTMode(mode.nn, mode.interpolation, True)
GPAW.create_wave_functions(self, mode, *args, **kwargs)
def initialize(self, reading=False):
self.parameters.mixer = DummyMixer()
GPAW.initialize(self, reading=reading)