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)