def __init__(self, atoms, Excitations,
indices=None,
gsname='rraman', # name for ground state calculations
exname=None, # name for excited state calculations
delta=0.01,
nfree=2,
directions=None,
exkwargs={}, # kwargs to be passed to Excitations
txt='-'):
assert(nfree == 2)
Vibrations.__init__(self, atoms, indices, gsname, delta, nfree)
self.name = gsname + '-d%.3f' % delta
if exname is None:
exname = gsname
self.exname = exname + '-d%.3f' % delta
if directions is None:
self.directions = np.array([0, 1, 2])
else:
self.directions = np.array(directions)
self.exobj = Excitations
self.exkwargs = exkwargs
self.timer = Timer()
self.txt = get_txt(txt, rank)
def __init__(
self,
atoms,
Excitations,
indices=None,
gsname='rraman', # name for ground state calculations
exname=None, # name for excited state calculations
delta=0.01,
nfree=2,
directions=None,
exkwargs={}, # kwargs to be passed to Excitations
exext='.ex.gz', # extension for Excitation names
txt='-',
verbose=False):
assert (nfree == 2)
Vibrations.__init__(self, atoms, indices, gsname, delta, nfree)
self.name = gsname + '-d%.3f' % delta
if exname is None:
exname = gsname
self.exname = exname + '-d%.3f' % delta
self.exext = exext
if directions is None:
self.directions = np.array([0, 1, 2])
else:
self.directions = np.array(directions)
self.exobj = Excitations
self.exkwargs = exkwargs
self.timer = Timer()
self.txt = get_txt(txt, rank)
self.verbose = verbose
def __init__(self, calculator=None, txt=None):
# initialise empty list
list.__init__(self)
self.calculator = calculator
if not txt and calculator:
txt = calculator.txt
self.txt = get_txt(txt, mpi.rank)
def __init__(self, lrtddft, d=0.001, txt=None, parallel=None):
"""Finite difference calculator for LrTDDFT.
parallel: Can be used to parallelize the numerical force
calculation over images
"""
self.timer = Timer()
self.atoms = None
world = mpi.world
if lrtddft is not None:
self.lrtddft = lrtddft
self.calculator = self.lrtddft.calculator
self.atoms = self.calculator.atoms
if self.calculator.initialized:
world = self.calculator.wfs.world
if txt is None:
self.txt = self.lrtddft.txt
else:
self.txt = get_txt(txt, world.rank)
prnt('#', self.__class__.__name__, version, file=self.txt)
self.d = d
self.parallel = {
'world': world, 'mycomm': world, 'ncalcs': 1, 'icalc': 0}
if world.size < 2:
if parallel > 0:
prnt('#', (self.__class__.__name__ + ':'),
'Serial calculation, keyword parallel ignored.',
file=self.txt)
elif parallel > 0:
mycomm, ncalcs, icalc = distribute_cpus(parallel, world)
if type(ncalcs) != type(1):
# this is ase < r3431
ncalcs = world.size / parallel
self.parallel = {'world': world, 'mycomm': mycomm,
'ncalcs': ncalcs, 'icalc': icalc}
self.calculator.set(communicator=mycomm)
def __init__(self,
calculator=None,
kss=None,
xc=None,
derivativeLevel=None,
numscale=0.001,
filehandle=None,
txt=None,
finegrid=2,
eh_comm=None,
):
if not txt and calculator:
txt = calculator.txt
self.txt = get_txt(txt, mpi.rank)
if eh_comm is None:
eh_comm = mpi.serial_comm
self.eh_comm = eh_comm
if filehandle is not None:
self.kss = kss
self.read(fh=filehandle)
return None
self.fullkss = kss
self.finegrid = finegrid
if calculator is None:
return
self.paw = calculator
wfs = self.paw.wfs
# handle different grid possibilities
self.restrict = None
# self.poisson = PoissonSolver(nn=self.paw.hamiltonian.poisson.nn)
self.poisson = calculator.hamiltonian.poisson
if finegrid:
self.poisson.set_grid_descriptor(self.paw.density.finegd)
self.poisson.initialize()
self.gd = self.paw.density.finegd
if finegrid == 1:
self.gd = wfs.gd
else:
self.poisson.set_grid_descriptor(wfs.gd)
self.poisson.initialize()
self.gd = wfs.gd
self.restrict = Transformer(self.paw.density.finegd, wfs.gd,
self.paw.input_parameters.stencils[1]
).apply
if xc == 'RPA':
xc = None # enable RPA as keyword
if xc is not None:
self.xc = XC(xc)
self.xc.initialize(self.paw.density, self.paw.hamiltonian,
wfs, self.paw.occupations)
# check derivativeLevel
if derivativeLevel is None:
derivativeLevel = \
self.xc.get_functional().get_max_derivative_level()
self.derivativeLevel = derivativeLevel
# change the setup xc functional if needed
# the ground state calculation may have used another xc
if kss.npspins > kss.nvspins:
spin_increased = True
else:
spin_increased = False
else:
self.xc = None
self.numscale = numscale
self.singletsinglet = False
if kss.nvspins < 2 and kss.npspins < 2:
# this will be a singlet to singlet calculation only
self.singletsinglet = True
nij = len(kss)
self.Om = np.zeros((nij, nij))
self.get_full()