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, firsttime = initialize_text_stream(txt, mpi.rank)
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, firsttime = initialize_text_stream(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, firsttime = initialize_text_stream(
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, firsttime = initialize_text_stream(txt, mpi.rank)
if eh_comm == 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)
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()
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, firsttime = initialize_text_stream(txt, mpi.rank)
if eh_comm == 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)
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[0]).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()
