def get_xc_difference(self, xc):
if isinstance(xc, str):
xc = XC(xc)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
xc.set_positions(self.atoms.get_scaled_positions() % 1.0)
if xc.orbital_dependent:
self.converge_wave_functions()
return self.hamiltonian.get_xc_difference(xc, self.density) * Hartree
def get_xc_difference(self, xc):
if isinstance(xc, str):
xc = XC(xc)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
xc.set_positions(self.atoms.get_scaled_positions() % 1.0)
if xc.orbital_dependent:
self.converge_wave_functions()
return self.hamiltonian.get_xc_difference(xc, self.density) * Hartree
def get_xc_difference(self, xc):
if isinstance(xc, (str, dict)):
xc = XC(xc)
xc.set_grid_descriptor(self.density.finegd)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
xc.set_positions(self.spos_ac)
if xc.orbital_dependent:
self.converge_wave_functions()
return self.hamiltonian.get_xc_difference(xc, self.density) * Ha
def linearize_to_xc(self, newxc):
"""Linearize Hamiltonian to difference XC functional.
Used in real time TDDFT to perform calculations with various kernels.
"""
if isinstance(newxc, str):
newxc = XC(newxc)
self.log('Linearizing xc-hamiltonian to ' + str(newxc))
newxc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
self.hamiltonian.linearize_to_xc(newxc, self.density)
def linearize_to_xc(self, newxc):
"""Linearize Hamiltonian to difference XC functional.
Used in real time TDDFT to perform calculations with various kernels.
"""
if isinstance(newxc, str):
newxc = XC(newxc)
self.txt.write('Linearizing xc-hamiltonian to ' + str(newxc))
newxc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
self.hamiltonian.linearize_to_xc(newxc, self.density)
def initialize_fxc(self, niter):
self.has_fxc = self.fxc_name is not None
if not self.has_fxc:
return
self.timer.start('Initialize fxc')
# XXX: Similar functionality is available in
# paw.py: PAW.linearize_to_xc(self, newxc)
# See test/lcaotddft/fxc_vs_linearize.py
get_H_MM = self.get_hamiltonian_matrix
# Calculate deltaXC: 1. take current H_MM
if niter == 0:
self.deltaXC_H_uMM = [None] * len(self.wfs.kpt_u)
for u, kpt in enumerate(self.wfs.kpt_u):
self.deltaXC_H_uMM[u] = get_H_MM(kpt, addfxc=False)
# Update hamiltonian.xc
if self.fxc_name == 'RPA':
xc_name = 'null'
else:
xc_name = self.fxc_name
# XXX: xc is not written to the gpw file
# XXX: so we need to set it always
xc = XC(xc_name)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
xc.set_positions(self.hamiltonian.spos_ac)
self.hamiltonian.xc = xc
self.update()
# Calculate deltaXC: 2. update with new H_MM
if niter == 0:
for u, kpt in enumerate(self.wfs.kpt_u):
self.deltaXC_H_uMM[u] -= get_H_MM(kpt, addfxc=False)
self.timer.stop('Initialize fxc')
def initialize(self, atoms=None):
"""Inexpensive initialization."""
if atoms is None:
atoms = self.atoms
else:
# Save the state of the atoms:
self.atoms = atoms.copy()
par = self.input_parameters
world = par.communicator
if world is None:
world = mpi.world
elif hasattr(world, 'new_communicator'):
# Check for whether object has correct type already
#
# Using isinstance() is complicated because of all the
# combinations, serial/parallel/debug...
pass
else:
# world should be a list of ranks:
world = mpi.world.new_communicator(np.asarray(world))
self.wfs.world = world
self.set_text(par.txt, par.verbose)
natoms = len(atoms)
cell_cv = atoms.get_cell() / Bohr
pbc_c = atoms.get_pbc()
Z_a = atoms.get_atomic_numbers()
magmom_av = atoms.get_initial_magnetic_moments()
# Generate new xc functional only when it is reset by set
if self.hamiltonian is None or self.hamiltonian.xc is None:
if isinstance(par.xc, str):
xc = XC(par.xc)
else:
xc = par.xc
else:
xc = self.hamiltonian.xc
mode = par.mode
if xc.orbital_dependent and mode == 'lcao':
raise NotImplementedError('LCAO mode does not support '
'orbital-dependent XC functionals.')
if mode == 'pw':
mode = PW()
if mode == 'fd' and par.usefractrans:
raise NotImplementedError('FD mode does not support '
'fractional translations.')
if mode == 'lcao' and par.usefractrans:
raise Warning('Fractional translations have not been tested '
'with LCAO mode. Use with care!')
if par.realspace is None:
realspace = not isinstance(mode, PW)
else:
realspace = par.realspace
if isinstance(mode, PW):
assert not realspace
if par.gpts is not None:
N_c = np.array(par.gpts)
else:
h = par.h
if h is not None:
h /= Bohr
N_c = get_number_of_grid_points(cell_cv, h, mode, realspace)
if par.filter is None and not isinstance(mode, PW):
gamma = 1.6
hmax = ((np.linalg.inv(cell_cv)**2).sum(0)**-0.5 / N_c).max()
def filter(rgd, rcut, f_r, l=0):
gcut = np.pi / hmax - 2 / rcut / gamma
f_r[:] = rgd.filter(f_r, rcut * gamma, gcut, l)
else:
filter = par.filter
setups = Setups(Z_a, par.setups, par.basis, par.lmax, xc,
filter, world)
if magmom_av.ndim == 1:
collinear = True
magmom_av, magmom_a = np.zeros((natoms, 3)), magmom_av
magmom_av[:, 2] = magmom_a
else:
collinear = False
magnetic = magmom_av.any()
spinpol = par.spinpol
if par.hund:
if natoms != 1:
raise ValueError('hund=True arg only valid for single atoms!')
spinpol = True
magmom_av[0] = (0, 0, setups[0].get_hunds_rule_moment(par.charge))
if spinpol is None:
spinpol = magnetic
elif magnetic and not spinpol:
raise ValueError('Non-zero initial magnetic moment for a ' +
'spin-paired calculation!')
if collinear:
nspins = 1 + int(spinpol)
ncomp = 1
else:
nspins = 1
ncomp = 2
# K-point descriptor
bzkpts_kc = kpts2ndarray(par.kpts, self.atoms)
kd = KPointDescriptor(bzkpts_kc, nspins, collinear, par.usefractrans)
width = par.width
if width is None:
if pbc_c.any():
width = 0.1 # eV
else:
width = 0.0
else:
assert par.occupations is None
if hasattr(self, 'time') or par.dtype == complex:
dtype = complex
else:
if kd.gamma:
dtype = float
else:
dtype = complex
## rbw: If usefractrans=True, kd.set_symmetry might overwrite N_c.
## This is necessary, because N_c must be dividable by 1/(fractional translation),
## f.e. fractional translations of a grid point must land on a grid point.
N_c = kd.set_symmetry(atoms, setups, magmom_av, par.usesymm, N_c, world)
nao = setups.nao
nvalence = setups.nvalence - par.charge
M_v = magmom_av.sum(0)
M = np.dot(M_v, M_v)**0.5
nbands = par.nbands
if nbands is None:
nbands = 0
for setup in setups:
nbands_from_atom = setup.get_default_nbands()
# Any obscure setup errors?
if nbands_from_atom < -(-setup.Nv // 2):
raise ValueError('Bad setup: This setup requests %d'
' bands but has %d electrons.'
% (nbands_from_atom, setup.Nv))
nbands += nbands_from_atom
nbands = min(nao, nbands)
elif nbands > nao and mode == 'lcao':
raise ValueError('Too many bands for LCAO calculation: '
'%d bands and only %d atomic orbitals!' %
(nbands, nao))
if nvalence < 0:
raise ValueError(
'Charge %f is not possible - not enough valence electrons' %
par.charge)
if nbands <= 0:
nbands = int(nvalence + M + 0.5) // 2 + (-nbands)
if nvalence > 2 * nbands:
raise ValueError('Too few bands! Electrons: %f, bands: %d'
% (nvalence, nbands))
nbands *= ncomp
if par.width is not None:
self.text('**NOTE**: please start using '
'occupations=FermiDirac(width).')
if par.fixmom:
self.text('**NOTE**: please start using '
'occupations=FermiDirac(width, fixmagmom=True).')
if self.occupations is None:
if par.occupations is None:
# Create object for occupation numbers:
self.occupations = occupations.FermiDirac(width, par.fixmom)
else:
self.occupations = par.occupations
self.occupations.magmom = M_v[2]
cc = par.convergence
if mode == 'lcao':
niter_fixdensity = 0
else:
niter_fixdensity = None
if self.scf is None:
self.scf = SCFLoop(
cc['eigenstates'] / Hartree**2 * nvalence,
cc['energy'] / Hartree * max(nvalence, 1),
cc['density'] * nvalence,
par.maxiter, par.fixdensity,
niter_fixdensity)
parsize_kpt = par.parallel['kpt']
parsize_domain = par.parallel['domain']
parsize_bands = par.parallel['band']
if not realspace:
pbc_c = np.ones(3, bool)
if not self.wfs:
if parsize_domain == 'domain only': # XXX this was silly!
parsize_domain = world.size
parallelization = mpi.Parallelization(world,
nspins * kd.nibzkpts)
ndomains = None
if parsize_domain is not None:
ndomains = np.prod(parsize_domain)
if isinstance(mode, PW):
if ndomains > 1:
raise ValueError('Planewave mode does not support '
'domain decomposition.')
ndomains = 1
parallelization.set(kpt=parsize_kpt,
domain=ndomains,
band=parsize_bands)
domain_comm, kpt_comm, band_comm = \
parallelization.build_communicators()
#domain_comm, kpt_comm, band_comm = mpi.distribute_cpus(
# parsize_domain, parsize_bands,
# nspins, kd.nibzkpts, world, par.idiotproof, mode)
kd.set_communicator(kpt_comm)
parstride_bands = par.parallel['stridebands']
# Unfortunately we need to remember that we adjusted the
# number of bands so we can print a warning if it differs
# from the number specified by the user. (The number can
# be inferred from the input parameters, but it's tricky
# because we allow negative numbers)
self.nbands_parallelization_adjustment = -nbands % band_comm.size
nbands += self.nbands_parallelization_adjustment
# I would like to give the following error message, but apparently
# there are cases, e.g. gpaw/test/gw_ppa.py, which involve
# nbands > nao and are supposed to work that way.
#if nbands > nao:
# raise ValueError('Number of bands %d adjusted for band '
# 'parallelization %d exceeds number of atomic '
# 'orbitals %d. This problem can be fixed '
# 'by reducing the number of bands a bit.'
# % (nbands, band_comm.size, nao))
bd = BandDescriptor(nbands, band_comm, parstride_bands)
if (self.density is not None and
self.density.gd.comm.size != domain_comm.size):
# Domain decomposition has changed, so we need to
# reinitialize density and hamiltonian:
if par.fixdensity:
raise RuntimeError('Density reinitialization conflict ' +
'with "fixdensity" - specify domain decomposition.')
self.density = None
self.hamiltonian = None
# Construct grid descriptor for coarse grids for wave functions:
gd = self.grid_descriptor_class(N_c, cell_cv, pbc_c,
domain_comm, parsize_domain)
# do k-point analysis here? XXX
args = (gd, nvalence, setups, bd, dtype, world, kd, self.timer)
if par.parallel['sl_auto']:
# Choose scalapack parallelization automatically
for key, val in par.parallel.items():
if (key.startswith('sl_') and key != 'sl_auto'
and val is not None):
raise ValueError("Cannot use 'sl_auto' together "
"with '%s'" % key)
max_scalapack_cpus = bd.comm.size * gd.comm.size
nprow = max_scalapack_cpus
npcol = 1
# Get a sort of reasonable number of columns/rows
while npcol < nprow and nprow % 2 == 0:
npcol *= 2
nprow //= 2
assert npcol * nprow == max_scalapack_cpus
# ScaLAPACK creates trouble if there aren't at least a few
# whole blocks; choose block size so there will always be
# several blocks. This will crash for small test systems,
# but so will ScaLAPACK in any case
blocksize = min(-(-nbands // 4), 64)
sl_default = (nprow, npcol, blocksize)
else:
sl_default = par.parallel['sl_default']
if mode == 'lcao':
# Layouts used for general diagonalizer
sl_lcao = par.parallel['sl_lcao']
if sl_lcao is None:
sl_lcao = sl_default
lcaoksl = get_KohnSham_layouts(sl_lcao, 'lcao',
gd, bd, dtype,
nao=nao, timer=self.timer)
if collinear:
self.wfs = LCAOWaveFunctions(lcaoksl, *args)
else:
from gpaw.xc.noncollinear import \
NonCollinearLCAOWaveFunctions
self.wfs = NonCollinearLCAOWaveFunctions(lcaoksl, *args)
elif mode == 'fd' or isinstance(mode, PW):
# buffer_size keyword only relevant for fdpw
buffer_size = par.parallel['buffer_size']
# Layouts used for diagonalizer
sl_diagonalize = par.parallel['sl_diagonalize']
if sl_diagonalize is None:
sl_diagonalize = sl_default
diagksl = get_KohnSham_layouts(sl_diagonalize, 'fd',
gd, bd, dtype,
buffer_size=buffer_size,
timer=self.timer)
# Layouts used for orthonormalizer
sl_inverse_cholesky = par.parallel['sl_inverse_cholesky']
if sl_inverse_cholesky is None:
sl_inverse_cholesky = sl_default
if sl_inverse_cholesky != sl_diagonalize:
message = 'sl_inverse_cholesky != sl_diagonalize ' \
'is not implemented.'
raise NotImplementedError(message)
orthoksl = get_KohnSham_layouts(sl_inverse_cholesky, 'fd',
gd, bd, dtype,
buffer_size=buffer_size,
timer=self.timer)
# Use (at most) all available LCAO for initialization
lcaonbands = min(nbands, nao)
try:
lcaobd = BandDescriptor(lcaonbands, band_comm,
parstride_bands)
except RuntimeError:
initksl = None
else:
# Layouts used for general diagonalizer
# (LCAO initialization)
sl_lcao = par.parallel['sl_lcao']
if sl_lcao is None:
sl_lcao = sl_default
initksl = get_KohnSham_layouts(sl_lcao, 'lcao',
gd, lcaobd, dtype,
nao=nao,
timer=self.timer)
if hasattr(self, 'time'):
assert mode == 'fd'
from gpaw.tddft import TimeDependentWaveFunctions
self.wfs = TimeDependentWaveFunctions(par.stencils[0],
diagksl, orthoksl, initksl, gd, nvalence, setups,
bd, world, kd, self.timer)
elif mode == 'fd':
self.wfs = FDWaveFunctions(par.stencils[0], diagksl,
orthoksl, initksl, *args)
else:
# Planewave basis:
self.wfs = mode(diagksl, orthoksl, initksl, *args)
else:
self.wfs = mode(self, *args)
else:
self.wfs.set_setups(setups)
if not self.wfs.eigensolver:
# Number of bands to converge:
nbands_converge = cc['bands']
if nbands_converge == 'all':
nbands_converge = nbands
elif nbands_converge != 'occupied':
assert isinstance(nbands_converge, int)
if nbands_converge < 0:
nbands_converge += nbands
eigensolver = get_eigensolver(par.eigensolver, mode,
par.convergence)
eigensolver.nbands_converge = nbands_converge
# XXX Eigensolver class doesn't define an nbands_converge property
if isinstance(xc, SIC):
eigensolver.blocksize = 1
self.wfs.set_eigensolver(eigensolver)
if self.density is None:
gd = self.wfs.gd
if par.stencils[1] != 9:
# Construct grid descriptor for fine grids for densities
# and potentials:
finegd = gd.refine()
else:
# Special case (use only coarse grid):
finegd = gd
if realspace:
self.density = RealSpaceDensity(
gd, finegd, nspins, par.charge + setups.core_charge,
collinear, par.stencils[1])
else:
self.density = ReciprocalSpaceDensity(
gd, finegd, nspins, par.charge + setups.core_charge,
collinear)
self.density.initialize(setups, self.timer, magmom_av, par.hund)
self.density.set_mixer(par.mixer)
if self.hamiltonian is None:
gd, finegd = self.density.gd, self.density.finegd
if realspace:
self.hamiltonian = RealSpaceHamiltonian(
gd, finegd, nspins, setups, self.timer, xc, par.external,
collinear, par.poissonsolver, par.stencils[1], world)
else:
self.hamiltonian = ReciprocalSpaceHamiltonian(
gd, finegd,
self.density.pd2, self.density.pd3,
nspins, setups, self.timer, xc, par.external,
collinear, world)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
self.text()
self.print_memory_estimate(self.txt, maxdepth=memory_estimate_depth)
self.txt.flush()
self.timer.print_info(self)
if dry_run:
self.dry_run()
self.initialized = True
def initialize(self, atoms=None, reading=False):
"""Inexpensive initialization."""
self.log('Initialize ...\n')
if atoms is None:
atoms = self.atoms
else:
# Save the state of the atoms:
self.atoms = atoms.copy()
par = self.parameters
natoms = len(atoms)
cell_cv = atoms.get_cell() / Bohr
number_of_lattice_vectors = cell_cv.any(axis=1).sum()
if number_of_lattice_vectors < 3:
raise ValueError(
'GPAW requires 3 lattice vectors. Your system has {0}.'.
format(number_of_lattice_vectors))
pbc_c = atoms.get_pbc()
assert len(pbc_c) == 3
magmom_a = atoms.get_initial_magnetic_moments()
mpi.synchronize_atoms(atoms, self.world)
# Generate new xc functional only when it is reset by set
# XXX sounds like this should use the _changed_keywords dictionary.
if self.hamiltonian is None or self.hamiltonian.xc is None:
if isinstance(par.xc, basestring):
xc = XC(par.xc)
else:
xc = par.xc
else:
xc = self.hamiltonian.xc
mode = par.mode
if isinstance(mode, basestring):
mode = {'name': mode}
if isinstance(mode, dict):
mode = create_wave_function_mode(**mode)
if par.dtype == complex:
warnings.warn('Use mode={0}(..., force_complex_dtype=True) '
'instead of dtype=complex'.format(mode.name.upper()))
mode.force_complex_dtype = True
del par['dtype']
par.mode = mode
if xc.orbital_dependent and mode.name == 'lcao':
raise ValueError('LCAO mode does not support '
'orbital-dependent XC functionals.')
realspace = (mode.name != 'pw' and mode.interpolation != 'fft')
if not realspace:
pbc_c = np.ones(3, bool)
self.create_setups(mode, xc)
magnetic = magmom_a.any()
spinpol = par.spinpol
if par.hund:
if natoms != 1:
raise ValueError('hund=True arg only valid for single atoms!')
spinpol = True
magmom_a[0] = self.setups[0].get_hunds_rule_moment(par.charge)
if spinpol is None:
spinpol = magnetic
elif magnetic and not spinpol:
raise ValueError('Non-zero initial magnetic moment for a ' +
'spin-paired calculation!')
nspins = 1 + int(spinpol)
if spinpol:
self.log('Spin-polarized calculation.')
self.log('Magnetic moment: {0:.6f}\n'.format(magmom_a.sum()))
else:
self.log('Spin-paired calculation\n')
if isinstance(par.background_charge, dict):
background = create_background_charge(**par.background_charge)
else:
background = par.background_charge
nao = self.setups.nao
nvalence = self.setups.nvalence - par.charge
if par.background_charge is not None:
nvalence += background.charge
M = abs(magmom_a.sum())
nbands = par.nbands
orbital_free = any(setup.orbital_free for setup in self.setups)
if orbital_free:
nbands = 1
if isinstance(nbands, basestring):
if nbands[-1] == '%':
basebands = int(nvalence + M + 0.5) // 2
nbands = int((float(nbands[:-1]) / 100) * basebands)
else:
raise ValueError('Integer expected: Only use a string '
'if giving a percentage of occupied bands')
if nbands is None:
nbands = 0
for setup in self.setups:
nbands_from_atom = setup.get_default_nbands()
# Any obscure setup errors?
if nbands_from_atom < -(-setup.Nv // 2):
raise ValueError('Bad setup: This setup requests %d'
' bands but has %d electrons.' %
(nbands_from_atom, setup.Nv))
nbands += nbands_from_atom
nbands = min(nao, nbands)
elif nbands > nao and mode.name == 'lcao':
raise ValueError('Too many bands for LCAO calculation: '
'%d bands and only %d atomic orbitals!' %
(nbands, nao))
if nvalence < 0:
raise ValueError(
'Charge %f is not possible - not enough valence electrons' %
par.charge)
if nbands <= 0:
nbands = int(nvalence + M + 0.5) // 2 + (-nbands)
if nvalence > 2 * nbands and not orbital_free:
raise ValueError('Too few bands! Electrons: %f, bands: %d' %
(nvalence, nbands))
self.create_occupations(magmom_a.sum(), orbital_free)
if self.scf is None:
self.create_scf(nvalence, mode)
self.create_symmetry(magmom_a, cell_cv)
if not self.wfs:
self.create_wave_functions(mode, realspace, nspins, nbands, nao,
nvalence, self.setups, magmom_a,
cell_cv, pbc_c)
else:
self.wfs.set_setups(self.setups)
if not self.wfs.eigensolver:
self.create_eigensolver(xc, nbands, mode)
if self.density is None and not reading:
assert not par.fixdensity, 'No density to fix!'
olddens = None
if (self.density is not None and
(self.density.gd.parsize_c != self.wfs.gd.parsize_c).any()):
# Domain decomposition has changed, so we need to
# reinitialize density and hamiltonian:
if par.fixdensity:
olddens = self.density
self.density = None
self.hamiltonian = None
if self.density is None:
self.create_density(realspace, mode, background)
# XXXXXXXXXX if setups change, then setups.core_charge may change.
# But that parameter was supplied in Density constructor!
# This surely is a bug!
self.density.initialize(self.setups, self.timer, magmom_a, par.hund)
self.density.set_mixer(par.mixer)
if self.density.mixer.driver.name == 'dummy' or par.fixdensity:
self.log('No density mixing\n')
else:
self.log(self.density.mixer, '\n')
self.density.fixed = par.fixdensity
self.density.log = self.log
if olddens is not None:
self.density.initialize_from_other_density(olddens,
self.wfs.kptband_comm)
if self.hamiltonian is None:
self.create_hamiltonian(realspace, mode, xc)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
if xc.name == 'GLLBSC' and olddens is not None:
xc.heeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeelp(olddens)
self.print_memory_estimate(maxdepth=memory_estimate_depth + 1)
print_parallelization_details(self.wfs, self.density, self.log)
self.log('Number of atoms:', natoms)
self.log('Number of atomic orbitals:', self.wfs.setups.nao)
if self.nbands_parallelization_adjustment != 0:
self.log(
'Adjusting number of bands by %+d to match parallelization' %
self.nbands_parallelization_adjustment)
self.log('Number of bands in calculation:', self.wfs.bd.nbands)
self.log('Bands to converge: ', end='')
n = par.convergence.get('bands', 'occupied')
if n == 'occupied':
self.log('occupied states only')
elif n == 'all':
self.log('all')
else:
self.log('%d lowest bands' % n)
self.log('Number of valence electrons:', self.wfs.nvalence)
self.log(flush=True)
self.timer.print_info(self)
if dry_run:
self.dry_run()
if (realspace and self.hamiltonian.poisson.get_description()
== 'FDTD+TDDFT'):
self.hamiltonian.poisson.set_density(self.density)
self.hamiltonian.poisson.print_messages(self.log)
self.log.fd.flush()
self.initialized = True
self.log('... initialized\n')
class OmegaMatrix:
"""
Omega matrix in Casidas linear response formalism
Parameters
- calculator: the calculator object the ground state calculation
- kss: the Kohn-Sham singles object
- xc: the exchange correlation approx. to use
- derivativeLevel: which level i of d^i Exc/dn^i to use
- numscale: numeric epsilon for derivativeLevel=0,1
- filehandle: the oject can be read from a filehandle
- txt: output stream or file name
- finegrid: level of fine grid to use. 0: nothing, 1 for poisson only,
2 everything on the fine grid
"""
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()
def get_full(self):
self.paw.timer.start('Omega RPA')
self.get_rpa()
self.paw.timer.stop()
if self.xc is not None:
self.paw.timer.start('Omega XC')
self.get_xc()
self.paw.timer.stop()
self.eh_comm.sum(self.Om)
self.full = self.Om
def get_xc(self):
"""Add xc part of the coupling matrix"""
# shorthands
paw = self.paw
wfs = paw.wfs
gd = paw.density.finegd
comm = gd.comm
eh_comm = self.eh_comm
fg = self.finegrid is 2
kss = self.fullkss
nij = len(kss)
Om_xc = self.Om
# initialize densities
# nt_sg is the smooth density on the fine grid with spin index
if kss.nvspins == 2:
# spin polarised ground state calc.
nt_sg = paw.density.nt_sg
else:
# spin unpolarised ground state calc.
if kss.npspins == 2:
# construct spin polarised densities
nt_sg = np.array([.5 * paw.density.nt_sg[0],
.5 * paw.density.nt_sg[0]])
else:
nt_sg = paw.density.nt_sg
# check if D_sp have been changed before
D_asp = self.paw.density.D_asp
for a, D_sp in D_asp.items():
if len(D_sp) != kss.npspins:
if len(D_sp) == 1:
D_asp[a] = np.array([0.5 * D_sp[0], 0.5 * D_sp[0]])
else:
D_asp[a] = np.array([D_sp[0] + D_sp[1]])
# restrict the density if needed
if fg:
nt_s = nt_sg
else:
nt_s = self.gd.zeros(nt_sg.shape[0])
for s in range(nt_sg.shape[0]):
self.restrict(nt_sg[s], nt_s[s])
gd = paw.density.gd
# initialize vxc or fxc
if self.derivativeLevel == 0:
raise NotImplementedError
if kss.npspins == 2:
v_g = nt_sg[0].copy()
else:
v_g = nt_sg.copy()
elif self.derivativeLevel == 1:
pass
elif self.derivativeLevel == 2:
fxc_sg = np.zeros(nt_sg.shape)
self.xc.calculate_fxc(gd, nt_sg, fxc_sg)
else:
raise ValueError('derivativeLevel can only be 0,1,2')
# self.paw.my_nuclei = []
ns = self.numscale
xc = self.xc
print('XC', nij, 'transitions', file=self.txt)
for ij in range(eh_comm.rank, nij, eh_comm.size):
print('XC kss[' + '%d' % ij + ']', file=self.txt)
timer = Timer()
timer.start('init')
timer2 = Timer()
if self.derivativeLevel >= 1:
# vxc is available
# We use the numerical two point formula for calculating
# the integral over fxc*n_ij. The results are
# vvt_s smooth integral
# nucleus.I_sp atom based correction matrices (pack2)
# stored on each nucleus
timer2.start('init v grids')
vp_s = np.zeros(nt_s.shape, nt_s.dtype.char)
vm_s = np.zeros(nt_s.shape, nt_s.dtype.char)
if kss.npspins == 2: # spin polarised
nv_s = nt_s.copy()
nv_s[kss[ij].pspin] += ns * kss[ij].get(fg)
xc.calculate(gd, nv_s, vp_s)
nv_s = nt_s.copy()
nv_s[kss[ij].pspin] -= ns * kss[ij].get(fg)
xc.calculate(gd, nv_s, vm_s)
else: # spin unpolarised
nv = nt_s + ns * kss[ij].get(fg)
xc.calculate(gd, nv, vp_s)
nv = nt_s - ns * kss[ij].get(fg)
xc.calculate(gd, nv, vm_s)
vvt_s = (0.5 / ns) * (vp_s - vm_s)
timer2.stop()
# initialize the correction matrices
timer2.start('init v corrections')
I_asp = {}
for a, P_ni in wfs.kpt_u[kss[ij].spin].P_ani.items():
# create the modified density matrix
Pi_i = P_ni[kss[ij].i]
Pj_i = P_ni[kss[ij].j]
P_ii = np.outer(Pi_i, Pj_i)
# we need the symmetric form, hence we can pack
P_p = pack(P_ii)
D_sp = self.paw.density.D_asp[a].copy()
D_sp[kss[ij].pspin] -= ns * P_p
setup = wfs.setups[a]
I_sp = np.zeros_like(D_sp)
self.xc.calculate_paw_correction(setup, D_sp, I_sp)
I_sp *= -1.0
D_sp = self.paw.density.D_asp[a].copy()
D_sp[kss[ij].pspin] += ns * P_p
self.xc.calculate_paw_correction(setup, D_sp, I_sp)
I_sp /= 2.0 * ns
I_asp[a] = I_sp
timer2.stop()
timer.stop()
t0 = timer.get_time('init')
timer.start(ij)
for kq in range(ij, nij):
weight = self.weight_Kijkq(ij, kq)
if self.derivativeLevel == 0:
# only Exc is available
if kss.npspins == 2: # spin polarised
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] += kss[ij].get(fg)
nv_g[kss[kq].pspin] += kss[kq].get(fg)
Excpp = xc.get_energy_and_potential(
nv_g[0], v_g, nv_g[1], v_g)
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] += kss[ij].get(fg)
nv_g[kss[kq].pspin] -= kss[kq].get(fg)
Excpm = xc.get_energy_and_potential(
nv_g[0], v_g, nv_g[1], v_g)
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] -=\
kss[ij].get(fg)
nv_g[kss[kq].pspin] +=\
kss[kq].get(fg)
Excmp = xc.get_energy_and_potential(
nv_g[0], v_g, nv_g[1], v_g)
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] -= \
kss[ij].get(fg)
nv_g[kss[kq].pspin] -=\
kss[kq].get(fg)
Excpp = xc.get_energy_and_potential(
nv_g[0], v_g, nv_g[1], v_g)
else: # spin unpolarised
nv_g = nt_sg + ns * kss[ij].get(fg)\
+ ns * kss[kq].get(fg)
Excpp = xc.get_energy_and_potential(nv_g, v_g)
nv_g = nt_sg + ns * kss[ij].get(fg)\
- ns * kss[kq].get(fg)
Excpm = xc.get_energy_and_potential(nv_g, v_g)
nv_g = nt_sg - ns * kss[ij].get(fg)\
+ ns * kss[kq].get(fg)
Excmp = xc.get_energy_and_potential(nv_g, v_g)
nv_g = nt_sg - ns * kss[ij].get(fg)\
- ns * kss[kq].get(fg)
Excmm = xc.get_energy_and_potential(nv_g, v_g)
Om_xc[ij, kq] += weight *\
0.25 * \
(Excpp - Excmp - Excpm + Excmm) / (ns * ns)
elif self.derivativeLevel == 1:
# vxc is available
timer2.start('integrate')
Om_xc[ij, kq] += weight *\
self.gd.integrate(kss[kq].get(fg) *
vvt_s[kss[kq].pspin])
timer2.stop()
timer2.start('integrate corrections')
Exc = 0.
for a, P_ni in wfs.kpt_u[kss[kq].spin].P_ani.items():
# create the modified density matrix
Pk_i = P_ni[kss[kq].i]
Pq_i = P_ni[kss[kq].j]
P_ii = np.outer(Pk_i, Pq_i)
# we need the symmetric form, hence we can pack
# use pack as I_sp used pack2
P_p = pack(P_ii)
Exc += np.dot(I_asp[a][kss[kq].pspin], P_p)
Om_xc[ij, kq] += weight * self.gd.comm.sum(Exc)
timer2.stop()
elif self.derivativeLevel == 2:
# fxc is available
if kss.npspins == 2: # spin polarised
Om_xc[ij, kq] += weight *\
gd.integrate(kss[ij].get(fg) *
kss[kq].get(fg) *
fxc_sg[kss[ij].pspin, kss[kq].pspin])
else: # spin unpolarised
Om_xc[ij, kq] += weight *\
gd.integrate(kss[ij].get(fg) *
kss[kq].get(fg) *
fxc_sg)
# XXX still numeric derivatives for local terms
timer2.start('integrate corrections')
Exc = 0.
for a, P_ni in wfs.kpt_u[kss[kq].spin].P_ani.items():
# create the modified density matrix
Pk_i = P_ni[kss[kq].i]
Pq_i = P_ni[kss[kq].j]
P_ii = np.outer(Pk_i, Pq_i)
# we need the symmetric form, hence we can pack
# use pack as I_sp used pack2
P_p = pack(P_ii)
Exc += np.dot(I_asp[a][kss[kq].pspin], P_p)
Om_xc[ij, kq] += weight * self.gd.comm.sum(Exc)
timer2.stop()
if ij != kq:
Om_xc[kq, ij] = Om_xc[ij, kq]
timer.stop()
# timer2.write()
if ij < (nij - 1):
print('XC estimated time left',
self.time_left(timer, t0, ij, nij), file=self.txt)
def Coulomb_integral_kss(self, kss_ij, kss_kq, phit, rhot,
timer=None):
# smooth part
if timer:
timer.start('integrate')
I = self.gd.integrate(rhot * phit)
if timer:
timer.stop()
timer.start('integrate corrections 2')
wfs = self.paw.wfs
Pij_ani = wfs.kpt_u[kss_ij.spin].P_ani
Pkq_ani = wfs.kpt_u[kss_kq.spin].P_ani
# Add atomic corrections
Ia = 0.0
for a, Pij_ni in Pij_ani.items():
Pi_i = Pij_ni[kss_ij.i]
Pj_i = Pij_ni[kss_ij.j]
Dij_ii = np.outer(Pi_i, Pj_i)
Dij_p = pack(Dij_ii)
Pk_i = Pkq_ani[a][kss_kq.i]
Pq_i = Pkq_ani[a][kss_kq.j]
Dkq_ii = np.outer(Pk_i, Pq_i)
Dkq_p = pack(Dkq_ii)
C_pp = wfs.setups[a].M_pp
# ----
# 2 > P P C P P
# ---- ip jr prst ks qt
# prst
Ia += 2.0 * np.dot(Dkq_p, np.dot(C_pp, Dij_p))
I += self.gd.comm.sum(Ia)
if timer:
timer.stop()
return I
def get_rpa(self):
"""calculate RPA part of the omega matrix"""
# shorthands
kss = self.fullkss
finegrid = self.finegrid
wfs = self.paw.wfs
eh_comm = self.eh_comm
# calculate omega matrix
nij = len(kss)
print('RPA', nij, 'transitions', file=self.txt)
Om = self.Om
for ij in range(eh_comm.rank, nij, eh_comm.size):
print('RPA kss[' + '%d' % ij + ']=', kss[ij], file=self.txt)
timer = Timer()
timer.start('init')
timer2 = Timer()
# smooth density including compensation charges
timer2.start('with_compensation_charges 0')
rhot_p = kss[ij].with_compensation_charges(
finegrid is not 0)
timer2.stop()
# integrate with 1/|r_1-r_2|
timer2.start('poisson')
phit_p = np.zeros(rhot_p.shape, rhot_p.dtype.char)
self.poisson.solve(phit_p, rhot_p, charge=None)
timer2.stop()
timer.stop()
t0 = timer.get_time('init')
timer.start(ij)
if finegrid == 1:
rhot = kss[ij].with_compensation_charges()
phit = self.gd.zeros()
# print "shapes 0=",phit.shape,rhot.shape
self.restrict(phit_p, phit)
else:
phit = phit_p
rhot = rhot_p
for kq in range(ij, nij):
if kq != ij:
# smooth density including compensation charges
timer2.start('kq with_compensation_charges')
rhot = kss[kq].with_compensation_charges(
finegrid is 2)
timer2.stop()
pre = 2 * sqrt(kss[ij].get_energy() * kss[kq].get_energy() *
kss[ij].get_weight() * kss[kq].get_weight())
I = self.Coulomb_integral_kss(kss[ij], kss[kq],
rhot, phit, timer2)
Om[ij, kq] = pre * I
if ij == kq:
Om[ij, kq] += kss[ij].get_energy() ** 2
else:
Om[kq, ij] = Om[ij, kq]
timer.stop()
# timer2.write()
if ij < (nij - 1):
t = timer.get_time(ij) # time for nij-ij calculations
t = .5 * t * \
(nij - ij) # estimated time for n*(n+1)/2, n=nij-(ij+1)
print('RPA estimated time left',
self.timestring(t0 * (nij - ij - 1) + t), file=self.txt)
def singlets_triplets(self):
"""Split yourself into singlet and triplet transitions"""
assert(self.fullkss.npspins == 2)
assert(self.fullkss.nvspins == 1)
# strip kss from down spins
skss = KSSingles()
tkss = KSSingles()
map = []
for ij, ks in enumerate(self.fullkss):
if ks.pspin == ks.spin:
skss.append((ks + ks) / sqrt(2))
tkss.append((ks - ks) / sqrt(2))
map.append(ij)
nkss = len(skss)
# define the singlet and the triplet omega-matrixes
sOm = OmegaMatrix(kss=skss)
sOm.full = np.empty((nkss, nkss))
tOm = OmegaMatrix(kss=tkss)
tOm.full = np.empty((nkss, nkss))
for ij in range(nkss):
for kl in range(nkss):
sOm.full[ij, kl] = (self.full[map[ij], map[kl]] +
self.full[map[ij], nkss + map[kl]])
tOm.full[ij, kl] = (self.full[map[ij], map[kl]] -
self.full[map[ij], nkss + map[kl]])
return sOm, tOm
def timestring(self, t):
ti = int(t + 0.5)
td = ti // 86400
st = ''
if td > 0:
st += '%d' % td + 'd'
ti -= td * 86400
th = ti // 3600
if th > 0:
st += '%d' % th + 'h'
ti -= th * 3600
tm = ti // 60
if tm > 0:
st += '%d' % tm + 'm'
ti -= tm * 60
st += '%d' % ti + 's'
return st
def time_left(self, timer, t0, ij, nij):
t = timer.get_time(ij) # time for nij-ij calculations
t = .5 * t * (nij - ij) # estimated time for n*(n+1)/2, n=nij-(ij+1)
return self.timestring(t0 * (nij - ij - 1) + t)
def get_map(self, istart=None, jend=None, energy_range=None):
"""Return the reduction map for the given requirements"""
self.istart = istart
self.jend = jend
if istart is None and jend is None and energy_range is None:
return None, self.fullkss
# reduce the matrix
print('# diagonalize: %d transitions original'
% len(self.fullkss), file=self.txt)
if energy_range is None:
if istart is None:
istart = self.kss.istart
if self.fullkss.istart > istart:
raise RuntimeError('istart=%d has to be >= %d' %
(istart, self.kss.istart))
if jend is None:
jend = self.kss.jend
if self.fullkss.jend < jend:
raise RuntimeError('jend=%d has to be <= %d' %
(jend, self.kss.jend))
else:
try:
emin, emax = energy_range
except:
emax = energy_range
emin = 0.
emin /= Hartree
emax /= Hartree
map = []
kss = KSSingles()
for ij, k in zip(range(len(self.fullkss)), self.fullkss):
if energy_range is None:
if k.i >= istart and k.j <= jend:
kss.append(k)
map.append(ij)
else:
if k.energy >= emin and k.energy < emax:
kss.append(k)
map.append(ij)
kss.update()
print('# diagonalize: %d transitions now' % len(kss), file=self.txt)
return map, kss
def diagonalize(self, istart=None, jend=None, energy_range=None,
TDA=False):
"""Evaluate Eigenvectors and Eigenvalues:"""
if TDA:
raise NotImplementedError
map, kss = self.get_map(istart, jend, energy_range)
nij = len(kss)
if map is None:
evec = self.full.copy()
else:
evec = np.zeros((nij, nij))
for ij in range(nij):
for kq in range(nij):
evec[ij, kq] = self.full[map[ij], map[kq]]
assert(len(evec) > 0)
self.eigenvectors = evec
self.eigenvalues = np.zeros((len(kss)))
self.kss = kss
diagonalize(self.eigenvectors, self.eigenvalues)
def Kss(self, kss=None):
"""Set and get own Kohn-Sham singles"""
if kss is not None:
self.fullkss = kss
if(hasattr(self, 'fullkss')):
return self.fullkss
else:
return None
def read(self, filename=None, fh=None):
"""Read myself from a file"""
if fh is None:
f = open(filename, 'r')
else:
f = fh
f.readline()
nij = int(f.readline())
full = np.zeros((nij, nij))
for ij in range(nij):
l = f.readline().split()
for kq in range(ij, nij):
full[ij, kq] = float(l[kq - ij])
full[kq, ij] = full[ij, kq]
self.full = full
if fh is None:
f.close()
def write(self, filename=None, fh=None):
"""Write current state to a file."""
if mpi.rank == mpi.MASTER:
if fh is None:
f = open(filename, 'w')
else:
f = fh
f.write('# OmegaMatrix\n')
nij = len(self.fullkss)
f.write('%d\n' % nij)
for ij in range(nij):
for kq in range(ij, nij):
f.write(' %g' % self.full[ij, kq])
f.write('\n')
if fh is None:
f.close()
def weight_Kijkq(self, ij, kq):
"""weight for the coupling matrix terms"""
kss = self.fullkss
return 2. * sqrt(kss[ij].get_energy() * kss[kq].get_energy() *
kss[ij].get_weight() * kss[kq].get_weight())
def __str__(self):
str = '<OmegaMatrix> '
if hasattr(self, 'eigenvalues'):
str += 'dimension ' + ('%d' % len(self.eigenvalues))
str += '\neigenvalues: '
for ev in self.eigenvalues:
str += ' ' + ('%f' % (sqrt(ev) * Hartree))
return str
class OmegaMatrix:
"""
Omega matrix in Casidas linear response formalism
Parameters
- calculator: the calculator object the ground state calculation
- kss: the Kohn-Sham singles object
- xc: the exchange correlation approx. to use
- derivativeLevel: which level i of d^i Exc/dn^i to use
- numscale: numeric epsilon for derivativeLevel=0,1
- filehandle: the oject can be read from a filehandle
- txt: output stream or file name
- finegrid: level of fine grid to use. 0: nothing, 1 for poisson only,
2 everything on the fine grid
"""
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 get_full(self):
self.paw.timer.start('Omega RPA')
self.get_rpa()
self.paw.timer.stop()
if self.xc is not None:
self.paw.timer.start('Omega XC')
self.get_xc()
self.paw.timer.stop()
self.eh_comm.sum(self.Om)
self.full = self.Om
def get_xc(self):
"""Add xc part of the coupling matrix"""
# shorthands
paw = self.paw
wfs = paw.wfs
gd = paw.density.finegd
comm = gd.comm
eh_comm = self.eh_comm
fg = self.finegrid is 2
kss = self.fullkss
nij = len(kss)
Om_xc = self.Om
# initialize densities
# nt_sg is the smooth density on the fine grid with spin index
if kss.nvspins==2:
# spin polarised ground state calc.
nt_sg = paw.density.nt_sg
else:
# spin unpolarised ground state calc.
if kss.npspins==2:
# construct spin polarised densities
nt_sg = np.array([.5*paw.density.nt_sg[0],
.5*paw.density.nt_sg[0]])
else:
nt_sg = paw.density.nt_sg
# check if D_sp have been changed before
D_asp = self.paw.density.D_asp
for a, D_sp in D_asp.items():
if len(D_sp) != kss.npspins:
if len(D_sp) == 1:
D_asp[a] = np.array([0.5 * D_sp[0], 0.5 * D_sp[0]])
else:
D_asp[a] = np.array([D_sp[0] + D_sp[1]])
# restrict the density if needed
if fg:
nt_s = nt_sg
else:
nt_s = self.gd.zeros(nt_sg.shape[0])
for s in range(nt_sg.shape[0]):
self.restrict(nt_sg[s], nt_s[s])
gd = paw.density.gd
# initialize vxc or fxc
if self.derivativeLevel==0:
raise NotImplementedError
if kss.npspins==2:
v_g=nt_sg[0].copy()
else:
v_g=nt_sg.copy()
elif self.derivativeLevel==1:
pass
elif self.derivativeLevel==2:
fxc_sg = np.zeros(nt_sg.shape)
self.xc.calculate_fxc(gd, nt_sg, fxc_sg)
else:
raise ValueError('derivativeLevel can only be 0,1,2')
## self.paw.my_nuclei = []
ns=self.numscale
xc=self.xc
print >> self.txt, 'XC',nij,'transitions'
for ij in range(eh_comm.rank, nij, eh_comm.size):
print >> self.txt,'XC kss['+'%d'%ij+']'
timer = Timer()
timer.start('init')
timer2 = Timer()
if self.derivativeLevel >= 1:
# vxc is available
# We use the numerical two point formula for calculating
# the integral over fxc*n_ij. The results are
# vvt_s smooth integral
# nucleus.I_sp atom based correction matrices (pack2)
# stored on each nucleus
timer2.start('init v grids')
vp_s=np.zeros(nt_s.shape,nt_s.dtype.char)
vm_s=np.zeros(nt_s.shape,nt_s.dtype.char)
if kss.npspins == 2: # spin polarised
nv_s = nt_s.copy()
nv_s[kss[ij].pspin] += ns * kss[ij].get(fg)
xc.calculate(gd, nv_s, vp_s)
nv_s = nt_s.copy()
nv_s[kss[ij].pspin] -= ns * kss[ij].get(fg)
xc.calculate(gd, nv_s, vm_s)
else: # spin unpolarised
nv = nt_s + ns * kss[ij].get(fg)
xc.calculate(gd, nv, vp_s)
nv = nt_s - ns * kss[ij].get(fg)
xc.calculate(gd, nv, vm_s)
vvt_s = (0.5 / ns) * (vp_s - vm_s)
timer2.stop()
# initialize the correction matrices
timer2.start('init v corrections')
I_asp = {}
for a, P_ni in wfs.kpt_u[kss[ij].spin].P_ani.items():
# create the modified density matrix
Pi_i = P_ni[kss[ij].i]
Pj_i = P_ni[kss[ij].j]
P_ii = np.outer(Pi_i, Pj_i)
# we need the symmetric form, hence we can pack
P_p = pack(P_ii)
D_sp = self.paw.density.D_asp[a].copy()
D_sp[kss[ij].pspin] -= ns * P_p
setup = wfs.setups[a]
I_sp = np.zeros_like(D_sp)
self.xc.calculate_paw_correction(setup, D_sp, I_sp)
I_sp *= -1.0
D_sp = self.paw.density.D_asp[a].copy()
D_sp[kss[ij].pspin] += ns * P_p
self.xc.calculate_paw_correction(setup, D_sp, I_sp)
I_sp /= 2.0 * ns
I_asp[a] = I_sp
timer2.stop()
timer.stop()
t0 = timer.get_time('init')
timer.start(ij)
for kq in range(ij,nij):
weight = self.weight_Kijkq(ij, kq)
if self.derivativeLevel == 0:
# only Exc is available
if kss.npspins==2: # spin polarised
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] += kss[ij].get(fg)
nv_g[kss[kq].pspin] += kss[kq].get(fg)
Excpp = xc.get_energy_and_potential(
nv_g[0], v_g, nv_g[1], v_g)
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] += kss[ij].get(fg)
nv_g[kss[kq].pspin] -= kss[kq].get(fg)
Excpm = xc.get_energy_and_potential(\
nv_g[0],v_g,nv_g[1],v_g)
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] -=\
kss[ij].get(fg)
nv_g[kss[kq].pspin] +=\
kss[kq].get(fg)
Excmp = xc.get_energy_and_potential(\
nv_g[0],v_g,nv_g[1],v_g)
nv_g = nt_sg.copy()
nv_g[kss[ij].pspin] -= \
kss[ij].get(fg)
nv_g[kss[kq].pspin] -=\
kss[kq].get(fg)
Excpp = xc.get_energy_and_potential(\
nv_g[0],v_g,nv_g[1],v_g)
else: # spin unpolarised
nv_g=nt_sg + ns*kss[ij].get(fg)\
+ ns*kss[kq].get(fg)
Excpp = xc.get_energy_and_potential(nv_g,v_g)
nv_g=nt_sg + ns*kss[ij].get(fg)\
- ns*kss[kq].get(fg)
Excpm = xc.get_energy_and_potential(nv_g,v_g)
nv_g=nt_sg - ns*kss[ij].get(fg)\
+ ns*kss[kq].get(fg)
Excmp = xc.get_energy_and_potential(nv_g,v_g)
nv_g=nt_sg - ns*kss[ij].get(fg)\
- ns*kss[kq].get(fg)
Excmm = xc.get_energy_and_potential(nv_g,v_g)
Om_xc[ij,kq] += weight *\
0.25*(Excpp-Excmp-Excpm+Excmm)/(ns*ns)
elif self.derivativeLevel == 1:
# vxc is available
timer2.start('integrate')
Om_xc[ij,kq] += weight*\
self.gd.integrate(kss[kq].get(fg)*
vvt_s[kss[kq].pspin])
timer2.stop()
timer2.start('integrate corrections')
Exc = 0.
for a, P_ni in wfs.kpt_u[kss[kq].spin].P_ani.items():
# create the modified density matrix
Pk_i = P_ni[kss[kq].i]
Pq_i = P_ni[kss[kq].j]
P_ii = np.outer(Pk_i, Pq_i)
# we need the symmetric form, hence we can pack
# use pack as I_sp used pack2
P_p = pack(P_ii)
Exc += np.dot(I_asp[a][kss[kq].pspin], P_p)
Om_xc[ij, kq] += weight * self.gd.comm.sum(Exc)
timer2.stop()
elif self.derivativeLevel == 2:
# fxc is available
if kss.npspins==2: # spin polarised
Om_xc[ij,kq] += weight *\
gd.integrate(kss[ij].get(fg) *
kss[kq].get(fg) *
fxc_sg[kss[ij].pspin, kss[kq].pspin])
else: # spin unpolarised
Om_xc[ij,kq] += weight *\
gd.integrate(kss[ij].get(fg) *
kss[kq].get(fg) *
fxc_sg)
# XXX still numeric derivatives for local terms
timer2.start('integrate corrections')
Exc = 0.
for a, P_ni in wfs.kpt_u[kss[kq].spin].P_ani.items():
# create the modified density matrix
Pk_i = P_ni[kss[kq].i]
Pq_i = P_ni[kss[kq].j]
P_ii = np.outer(Pk_i, Pq_i)
# we need the symmetric form, hence we can pack
# use pack as I_sp used pack2
P_p = pack(P_ii)
Exc += np.dot(I_asp[a][kss[kq].pspin], P_p)
Om_xc[ij, kq] += weight * self.gd.comm.sum(Exc)
timer2.stop()
if ij != kq:
Om_xc[kq,ij] = Om_xc[ij,kq]
timer.stop()
## timer2.write()
if ij < (nij-1):
print >> self.txt,'XC estimated time left',\
self.time_left(timer, t0, ij, nij)
def Coulomb_integral_kss(self, kss_ij, kss_kq, phit, rhot,
timer=None):
# smooth part
if timer:
timer.start('integrate')
I = self.gd.integrate(rhot * phit)
if timer:
timer.stop()
timer.start('integrate corrections 2')
wfs = self.paw.wfs
Pij_ani = wfs.kpt_u[kss_ij.spin].P_ani
Pkq_ani = wfs.kpt_u[kss_kq.spin].P_ani
# Add atomic corrections
Ia = 0.0
for a, Pij_ni in Pij_ani.items():
Pi_i = Pij_ni[kss_ij.i]
Pj_i = Pij_ni[kss_ij.j]
Dij_ii = np.outer(Pi_i, Pj_i)
Dij_p = pack(Dij_ii)
Pk_i = Pkq_ani[a][kss_kq.i]
Pq_i = Pkq_ani[a][kss_kq.j]
Dkq_ii = np.outer(Pk_i, Pq_i)
Dkq_p = pack(Dkq_ii)
C_pp = wfs.setups[a].M_pp
# ----
# 2 > P P C P P
# ---- ip jr prst ks qt
# prst
Ia += 2.0*np.dot(Dkq_p, np.dot(C_pp, Dij_p))
I += self.gd.comm.sum(Ia)
if timer:
timer.stop()
return I
def get_rpa(self):
"""calculate RPA part of the omega matrix"""
# shorthands
kss=self.fullkss
finegrid=self.finegrid
wfs = self.paw.wfs
eh_comm = self.eh_comm
# calculate omega matrix
nij = len(kss)
print >> self.txt,'RPA',nij,'transitions'
Om = self.Om
for ij in range(eh_comm.rank, nij, eh_comm.size):
print >> self.txt,'RPA kss['+'%d'%ij+']=', kss[ij]
timer = Timer()
timer.start('init')
timer2 = Timer()
# smooth density including compensation charges
timer2.start('with_compensation_charges 0')
rhot_p = kss[ij].with_compensation_charges(
finegrid is not 0)
timer2.stop()
# integrate with 1/|r_1-r_2|
timer2.start('poisson')
phit_p = np.zeros(rhot_p.shape, rhot_p.dtype.char)
self.poisson.solve(phit_p, rhot_p, charge=None)
timer2.stop()
timer.stop()
t0 = timer.get_time('init')
timer.start(ij)
if finegrid == 1:
rhot = kss[ij].with_compensation_charges()
phit = self.gd.zeros()
## print "shapes 0=",phit.shape,rhot.shape
self.restrict(phit_p,phit)
else:
phit = phit_p
rhot = rhot_p
for kq in range(ij,nij):
if kq != ij:
# smooth density including compensation charges
timer2.start('kq with_compensation_charges')
rhot = kss[kq].with_compensation_charges(
finegrid is 2)
timer2.stop()
pre = 2 * sqrt(kss[ij].get_energy() * kss[kq].get_energy() *
kss[ij].get_weight() * kss[kq].get_weight() )
I = self.Coulomb_integral_kss(kss[ij], kss[kq],
rhot, phit, timer2)
Om[ij,kq] = pre * I
if ij == kq:
Om[ij,kq] += kss[ij].get_energy()**2
else:
Om[kq,ij]=Om[ij,kq]
timer.stop()
## timer2.write()
if ij < (nij-1):
t = timer.get_time(ij) # time for nij-ij calculations
t = .5*t*(nij-ij) # estimated time for n*(n+1)/2, n=nij-(ij+1)
print >> self.txt,'RPA estimated time left',\
self.timestring(t0*(nij-ij-1)+t)
def singlets_triplets(self):
"""Split yourself into singlet and triplet transitions"""
assert(self.fullkss.npspins == 2)
assert(self.fullkss.nvspins == 1)
# strip kss from down spins
skss = KSSingles()
tkss = KSSingles()
map = []
for ij, ks in enumerate(self.fullkss):
if ks.pspin == ks.spin:
skss.append((ks + ks) / sqrt(2))
tkss.append((ks - ks) / sqrt(2))
map.append(ij)
nkss = len(skss)
# define the singlet and the triplet omega-matrixes
sOm = OmegaMatrix(kss=skss)
sOm.full = np.empty((nkss, nkss))
tOm = OmegaMatrix(kss=tkss)
tOm.full = np.empty((nkss, nkss))
for ij in range(nkss):
for kl in range(nkss):
sOm.full[ij, kl] = (self.full[map[ij], map[kl]] +
self.full[map[ij], nkss + map[kl]])
tOm.full[ij, kl] = (self.full[map[ij], map[kl]] -
self.full[map[ij], nkss + map[kl]])
return sOm, tOm
def timestring(self, t):
ti = int(t + 0.5)
td = ti // 86400
st = ''
if td > 0:
st += '%d' % td + 'd'
ti -= td * 86400
th = ti // 3600
if th > 0:
st += '%d' % th + 'h'
ti -= th * 3600
tm = ti // 60
if tm > 0:
st += '%d' % tm + 'm'
ti -= tm * 60
st += '%d' % ti + 's'
return st
def time_left(self, timer, t0, ij, nij):
t = timer.get_time(ij) # time for nij-ij calculations
t = .5 * t * (nij - ij) # estimated time for n*(n+1)/2, n=nij-(ij+1)
return self.timestring(t0 * (nij - ij - 1) + t)
def get_map(self, istart=None, jend=None, energy_range=None):
"""Return the reduction map for the given requirements"""
self.istart = istart
self.jend = jend
if istart is None and jend is None and energy_range is None:
return None, self.fullkss
# reduce the matrix
print >> self.txt,'# diagonalize: %d transitions original'\
% len(self.fullkss)
if energy_range is None:
if istart is None: istart = self.kss.istart
if self.fullkss.istart > istart:
raise RuntimeError('istart=%d has to be >= %d' %
(istart, self.kss.istart))
if jend is None: jend = self.kss.jend
if self.fullkss.jend < jend:
raise RuntimeError('jend=%d has to be <= %d' %
(jend, self.kss.jend))
else:
try:
emin, emax = energy_range
except:
emax = energy_range
emin = 0.
emin /= Hartree
emax /= Hartree
map= []
kss = KSSingles()
for ij, k in zip(range(len(self.fullkss)), self.fullkss):
if energy_range is None:
if k.i >= istart and k.j <= jend:
kss.append(k)
map.append(ij)
else:
if k.energy >= emin and k.energy < emax:
kss.append(k)
map.append(ij)
kss.update()
print >> self.txt, '# diagonalize: %d transitions now' % len(kss)
return map, kss
def diagonalize(self, istart=None, jend=None, energy_range=None,
TDA=False):
"""Evaluate Eigenvectors and Eigenvalues:"""
if TDA:
raise NotImplementedError
map, kss = self.get_map(istart, jend, energy_range)
nij = len(kss)
if map is None:
evec = self.full.copy()
else:
evec = np.zeros((nij,nij))
for ij in range(nij):
for kq in range(nij):
evec[ij,kq] = self.full[map[ij],map[kq]]
assert(len(evec) > 0)
self.eigenvectors = evec
self.eigenvalues = np.zeros((len(kss)))
self.kss = kss
diagonalize(self.eigenvectors, self.eigenvalues)
def Kss(self, kss=None):
"""Set and get own Kohn-Sham singles"""
if kss is not None:
self.fullkss = kss
if(hasattr(self,'fullkss')):
return self.fullkss
else:
return None
def read(self, filename=None, fh=None):
"""Read myself from a file"""
if fh is None:
f = open(filename, 'r')
else:
f = fh
f.readline()
nij = int(f.readline())
full = np.zeros((nij,nij))
for ij in range(nij):
l = f.readline().split()
for kq in range(ij,nij):
full[ij,kq] = float(l[kq-ij])
full[kq,ij] = full[ij,kq]
self.full = full
if fh is None:
f.close()
def write(self, filename=None, fh=None):
"""Write current state to a file."""
if mpi.rank == mpi.MASTER:
if fh is None:
f = open(filename, 'w')
else:
f = fh
f.write('# OmegaMatrix\n')
nij = len(self.fullkss)
f.write('%d\n' % nij)
for ij in range(nij):
for kq in range(ij,nij):
f.write(' %g' % self.full[ij,kq])
f.write('\n')
if fh is None:
f.close()
def weight_Kijkq(self, ij, kq):
"""weight for the coupling matrix terms"""
kss = self.fullkss
return 2.*sqrt( kss[ij].get_energy() * kss[kq].get_energy() *
kss[ij].get_weight() * kss[kq].get_weight() )
def __str__(self):
str='<OmegaMatrix> '
if hasattr(self,'eigenvalues'):
str += 'dimension '+ ('%d'%len(self.eigenvalues))
str += "\neigenvalues: "
for ev in self.eigenvalues:
str += ' ' + ('%f'%(sqrt(ev) * Hartree))
return str
class LrTDDFT2:
"""Linear response TDDFT (Casida) class with indexed K-matrix storage."""
def __init__(self,
basefilename,
gs_calc,
fxc=None,
min_occ=None,
max_occ=None,
min_unocc=None,
max_unocc=None,
max_energy_diff=1e9,
recalculate=None,
lr_communicators=None,
txt='-'):
"""Initialize linear response TDDFT without calculating anything.
Note: Does NOT support spin polarized calculations yet.
Protip: If K_matrix file is too large and you keep running out of memory when trying to calculate spectrum or response wavefunction,
you can try
"split -l 100000 xxx.K_matrix.ddddddofDDDDDD xxx.K_matrix.ddddddofDDDDDD."
Input parameters:
basefilename
All files associated with this calculation are stored as
*<basefilename>.<extension>*
gs_calc
Ground state calculator (if you are using eh_communicator,
you need to take care that calc has suitable dd_communicator.)
fxc
Name of the exchange-correlation kernel (fxc) used in calculation.
(optional)
min_occ
Index of the first occupied state to be included in the calculation.
(optional)
max_occ
Index of the last occupied state (inclusive) to be included in the
calculation. (optional)
min_unocc
Index of the first unoccupied state to be included in the
calculation. (optional)
max_unocc
Index of the last unoccupied state (inclusive) to be included in the
calculation. (optional)
max_energy_diff
Noninteracting Kohn-Sham excitations above this value are not
included in the calculation. Units: eV (optional)
recalculate
| Force recalculation.
| 'eigen' : recalculate only eigensystem (useful for on-the-fly
| spectrum calculations and convergence checking)
| 'matrix' : recalculate matrix without solving the eigensystem
| 'all' : recalculate everything
| None : do not recalculate anything if not needed (default)
lr_communicators
Communicators for parallelizing over electron-hole pairs (i.e.,
rows of K-matrix) and domain. Note that ground state calculator
must have a matching (domain decomposition) communicator, which
can be assured by using lr_communicators
to create both communicators.
txt
Filename for text output
"""
# Save input params
self.basefilename = basefilename
self.fxc_name = fxc
self.xc = XC(self.fxc_name)
self.min_occ = min_occ
self.max_occ = max_occ
self.min_unocc = min_unocc
self.max_unocc = max_unocc
self.max_energy_diff = max_energy_diff / ase.units.Hartree
self.recalculate = recalculate
# Don't init calculator yet if it's not needed (to save memory)
self.calc = gs_calc
self.calc_ready = False
# FIXME: SUPPORT ALSO SPIN POLARIZED
self.kpt_ind = 0
# Input paramers?
self.deriv_scale = 1e-5 # fxc finite difference step
# ignore transition if population difference is below this value:
self.min_pop_diff = 1e-3
# set up communicators
self.lr_comms = lr_communicators
if self.lr_comms is None:
self.lr_comms = LrCommunicators()
self.lr_comms.initialize(gs_calc)
# Init text output
if self.lr_comms.parent_comm.rank == 0 and txt is not None:
if txt == '-':
self.txt = sys.stdout
elif isinstance(txt, str):
self.txt = open(txt, 'w')
else:
self.txt = txt
elif self.calc is not None:
self.txt = self.calc.log.fd
else:
self.txt = devnull
# Check and set unset params
# If min/max_occ/unocc were not given, initialized them to include
# everything: min_occ/unocc => 0, max_occ/unocc to nubmer of wfs,
# energy diff to numerical infinity
nbands = len(self.calc.wfs.kpt_u[self.kpt_ind].f_n)
if self.min_occ is None:
self.min_occ = 0
if self.min_unocc is None:
self.min_unocc = self.min_occ
if self.max_occ is None:
self.max_occ = nbands - 1
if self.max_unocc is None:
self.max_unocc = self.max_occ
if self.max_energy_diff is None:
self.max_energy_diff = 1e9
self.min_occ = max(self.min_occ, 0)
self.min_unocc = max(self.min_unocc, 0)
if self.max_occ >= nbands:
raise RuntimeError('Error in LrTDDFT2: max_occ >= nbands')
if self.max_unocc >= nbands:
raise RuntimeError('Error in LrTDDFT2: max_unocc >= nbands')
# Only spin unpolarized calculations are supported atm
# > FIXME
assert len(self.calc.wfs.kpt_u) == 1, \
'LrTDDFT2 does not support more than one k-point/spin.'
self.kpt_ind = 0
# <
# Internal classes
# list of singly excited Kohn-Sham Slater determinants
# (ascending KS energy difference)
self.ks_singles = KohnShamSingles(self.basefilename,
self.calc,
self.kpt_ind,
self.min_occ, self.max_occ,
self.min_unocc, self.max_unocc,
self.max_energy_diff,
self.min_pop_diff,
self.lr_comms,
self.txt)
# Response kernel matrix K = <ip|f_Hxc|jq>
# Note: this is not the Casida matrix
self.K_matrix = Kmatrix(self.ks_singles, self.xc, self.deriv_scale)
self.sl_lrtddft = self.calc.parallel['sl_lrtddft']
# LR-TDDFT transitions
self.lr_transitions = LrtddftTransitions(self.ks_singles,
self.K_matrix,
self.sl_lrtddft)
# Response wavefunction
self.lr_response_wf = None
# Pair density
self.pair_density = None # pair density class
# Timer
self.timer = self.calc.timer
self.timer.start('LrTDDFT')
# If a previous calculation exist, read info file
# self.read(self.basefilename)
# Write info file
# self.parent_comm.barrier()
# if self.parent_comm.rank == 0:
# self.write_info(self.basefilename)
# self.custom_axes = None
# self.K_matrix_scaling_factor = 1.0
self.K_matrix_values_ready = False
def get_transitions(self, filename=None, min_energy=0.0, max_energy=30.0, units='eVcgs'):
"""Get transitions: energy, dipole strength and rotatory strength.
Returns transitions as (w,S,R, Sx,Sy,Sz) where
w is an array of frequencies,
S is an array of corresponding dipole strengths,
and R is an array of corresponding rotatory strengths.
Input parameters:
min_energy
Minimum energy
min_energy
Maximum energy
units
Units for spectrum: 'au' or 'eVcgs'
"""
self.calculate()
self.txt.write('Calculating transitions (%s).\n' % str(datetime.datetime.now()))
trans = self.lr_transitions.get_transitions(filename, min_energy, max_energy, units)
self.txt.write('Transitions calculated (%s).\n' % str(datetime.datetime.now()))
return trans
#################################################################
def get_spectrum(self, filename=None, min_energy=0.0, max_energy=30.0,
energy_step=0.01, width=0.1, units='eVcgs'):
"""Get spectrum for dipole and rotatory strength.
Returns folded spectrum as (w,S,R) where w is an array of frequencies,
S is an array of corresponding dipole strengths, and R is an array of
corresponding rotatory strengths.
Input parameters:
min_energy
Minimum energy
min_energy
Maximum energy
energy_step
Spacing between calculated energies
width
Width of the Gaussian
units
Units for spectrum: 'au' or 'eVcgs'
"""
self.calculate()
self.txt.write('Calculating spectrum (%s).\n' % str(datetime.datetime.now()))
spec = self.lr_transitions.get_spectrum(filename, min_energy, max_energy, energy_step, width, units)
self.txt.write('Spectrum calculated (%s).\n' % str(datetime.datetime.now()))
return spec
#################################################################
def get_transition_contributions(self, index_of_transition):
"""Get contributions of Kohn-Sham singles to a given transition
as number of electrons contributing.
Includes population difference.
This method is meant to be used for small number of transitions.
It is not suitable for analysing densely packed transitions of
large systems. Use transition contribution map (TCM) or similar
approach for this.
Input parameters:
index_of_transition:
index of transition starting from zero
"""
self.calculate()
return self.lr_transitions.get_transition_contributions(index_of_transition)
def calculate_response(self, excitation_energy, excitation_direction, lorentzian_width, units='eVang'):
"""Calculates and returns response using TD-DFPT.
Input parameters:
excitation_energy
Energy of the laser in given units
excitation_direction
Vector for direction (will be normalized)
lorentzian_width
Life time or width parameter. Larger width results in wider
energy envelope around excitation energy.
"""
# S_z(omega) = 2 * omega sum_ip n_ip C^(im)_ip(omega) * mu^(z)_ip
self.calculate()
omega_au = excitation_energy
width_au = lorentzian_width
# always unit field in au !!!
direction_au = np.array(excitation_direction)
direction_au = direction_au / np.sqrt(np.vdot(direction_au,direction_au))
if units == 'au':
pass
elif units == 'eVang':
omega_au /= ase.units.Hartree
width_au /= ase.units.Hartree
else:
raise RuntimeError('Error in calculate_response_wavefunction: Invalid units.')
lr_response = LrResponse(self, omega_au, direction_au, width_au, self.sl_lrtddft)
lr_response.solve()
return lr_response
def calculate(self):
"""Calculates linear response matrix and properties of KS
electron-hole pairs.
This is called implicitly by get_spectrum, get_transitions, etc.
but there is no harm for calling this explicitly.
"""
if not self.calc_ready:
# Initialize wfs, paw corrections and xc, if not done yet
# FIXME: CHECK THIS STUFF, DOES GLLB WORK???
if not self.calc_ready:
mode = self.calc.wfs.mode
C_nM = self.calc.wfs.kpt_u[self.kpt_ind].C_nM
psit_nG = self.calc.wfs.kpt_u[self.kpt_ind].psit_nG
if ((mode == 'lcao' and C_nM is None) or
(mode == 'fd' and psit_nG is None)):
raise RuntimeError('Use ground state calculator ' +
'containing the wave functions.')
if not self.calc.scf.converged:
# Do not allow new scf cycles, it could change
# the wave function signs after every restart.
raise RuntimeError('Converge wave functions first.')
spos_ac = self.calc.initialize_positions()
self.calc.occupations.calculate(self.calc.wfs)
self.calc.wfs.initialize(self.calc.density,
self.calc.hamiltonian, spos_ac)
self.xc.initialize(self.calc.density, self.calc.hamiltonian,
self.calc.wfs, self.calc.occupations)
if mode == 'lcao':
self.calc.wfs.initialize_wave_functions_from_lcao()
self.calc_ready = True
# Singles logic
if self.recalculate == 'all' or self.recalculate == 'matrix':
self.ks_singles.update_list()
self.ks_singles.calculate()
elif self.recalculate == 'eigen':
self.ks_singles.read()
self.ks_singles.kss_list_ready = True
self.ks_singles.kss_prop_ready = True
elif ( ( not self.ks_singles.kss_list_ready ) or
( not self.ks_singles.kss_prop_ready ) ):
self.ks_singles.read()
self.ks_singles.update_list()
self.ks_singles.calculate()
else:
pass
# K-matrix logic
if self.recalculate == 'all' or self.recalculate == 'matrix':
# delete files
if self.lr_comms.parent_comm.rank == 0:
for ready_file in glob.glob(self.basefilename +
'.ready_rows.*'):
os.remove(ready_file)
for K_file in glob.glob(self.basefilename + '.K_matrix.*'):
os.remove(K_file)
self.K_matrix.calculate()
elif self.recalculate == 'eigen':
self.K_matrix.read_indices()
self.K_matrix.K_matrix_ready = True
elif not self.K_matrix.K_matrix_ready:
self.K_matrix.read_indices()
self.K_matrix.calculate()
else:
pass
# Wait... we don't want to read incomplete files
self.lr_comms.parent_comm.barrier()
if not self.K_matrix_values_ready:
self.K_matrix.read_values()
# lr_transitions logic
if not self.lr_transitions.trans_prop_ready:
trans_file = self.basefilename + '.transitions'
if os.path.exists(trans_file) and os.path.isfile(trans_file):
os.remove(trans_file)
self.lr_transitions.calculate()
# recalculate only once
self.recalculate = None
def read(self, basename):
"""Does not do much at the moment."""
info_file = open(basename + '.lr_info', 'r')
for line in info_file:
if line[0] == '#':
continue
if len(line.split()) <= 2:
continue
# key = line.split('=')[0]
# value = line.split('=')[1]
# .....
# FIXME: do something, like warn if changed
# ...
info_file.close()
def write_info(self, basename):
"""Writes used parameters to a file."""
f = open(basename + '.lr_info', 'a+')
f.write('# LrTDDFTindexed\n')
f.write('%20s = %s\n' % ('xc_name', self.xc_name))
f.write('%20s = %d\n' % ('min_occ', self.min_occ))
f.write('%20s = %d\n' % ('min_unocc', self.min_unocc))
f.write('%20s = %d\n' % ('max_occ', self.max_occ))
f.write('%20s = %d\n' % ('max_unocc', self.max_unocc))
f.write('%20s = %18.12lf\n' % ('max_energy_diff',self.max_energy_diff))
f.write('%20s = %18.12lf\n' % ('deriv_scale', self.deriv_scale))
f.write('%20s = %18.12lf\n' % ('min_pop_diff', self.min_pop_diff))
f.close()
def __del__(self):
self.timer.stop('LrTDDFT')
def initialize(self, atoms=None):
"""Inexpensive initialization."""
if atoms is None:
atoms = self.atoms
else:
# Save the state of the atoms:
self.atoms = atoms.copy()
par = self.input_parameters
world = par.communicator
if world is None:
world = mpi.world
elif hasattr(world, 'new_communicator'):
# Check for whether object has correct type already
#
# Using isinstance() is complicated because of all the
# combinations, serial/parallel/debug...
pass
else:
# world should be a list of ranks:
world = mpi.world.new_communicator(np.asarray(world))
self.wfs.world = world
if 'txt' in self._changed_keywords:
self.set_txt(par.txt)
self.verbose = par.verbose
natoms = len(atoms)
cell_cv = atoms.get_cell() / Bohr
pbc_c = atoms.get_pbc()
Z_a = atoms.get_atomic_numbers()
magmom_av = atoms.get_initial_magnetic_moments()
self.check_atoms()
# Generate new xc functional only when it is reset by set
# XXX sounds like this should use the _changed_keywords dictionary.
if self.hamiltonian is None or self.hamiltonian.xc is None:
if isinstance(par.xc, str):
xc = XC(par.xc)
else:
xc = par.xc
else:
xc = self.hamiltonian.xc
mode = par.mode
if mode == 'fd':
mode = FD()
elif mode == 'pw':
mode = pw.PW()
elif mode == 'lcao':
mode = LCAO()
else:
assert hasattr(mode, 'name'), str(mode)
if xc.orbital_dependent and mode.name == 'lcao':
raise NotImplementedError('LCAO mode does not support '
'orbital-dependent XC functionals.')
if par.realspace is None:
realspace = (mode.name != 'pw')
else:
realspace = par.realspace
if mode.name == 'pw':
assert not realspace
if par.filter is None and mode.name != 'pw':
gamma = 1.6
if par.gpts is not None:
h = ((np.linalg.inv(cell_cv)**2).sum(0)**-0.5 / par.gpts).max()
else:
h = (par.h or 0.2) / Bohr
def filter(rgd, rcut, f_r, l=0):
gcut = np.pi / h - 2 / rcut / gamma
f_r[:] = rgd.filter(f_r, rcut * gamma, gcut, l)
else:
filter = par.filter
setups = Setups(Z_a, par.setups, par.basis, par.lmax, xc, filter,
world)
if magmom_av.ndim == 1:
collinear = True
magmom_av, magmom_a = np.zeros((natoms, 3)), magmom_av
magmom_av[:, 2] = magmom_a
else:
collinear = False
magnetic = magmom_av.any()
spinpol = par.spinpol
if par.hund:
if natoms != 1:
raise ValueError('hund=True arg only valid for single atoms!')
spinpol = True
magmom_av[0] = (0, 0, setups[0].get_hunds_rule_moment(par.charge))
if spinpol is None:
spinpol = magnetic
elif magnetic and not spinpol:
raise ValueError('Non-zero initial magnetic moment for a ' +
'spin-paired calculation!')
if collinear:
nspins = 1 + int(spinpol)
ncomp = 1
else:
nspins = 1
ncomp = 2
if par.usesymm != 'default':
warnings.warn('Use "symmetry" keyword instead of ' +
'"usesymm" keyword')
par.symmetry = usesymm2symmetry(par.usesymm)
symm = par.symmetry
if symm == 'off':
symm = {'point_group': False, 'time_reversal': False}
bzkpts_kc = kpts2ndarray(par.kpts, self.atoms)
kd = KPointDescriptor(bzkpts_kc, nspins, collinear)
m_av = magmom_av.round(decimals=3) # round off
id_a = zip(setups.id_a, *m_av.T)
symmetry = Symmetry(id_a, cell_cv, atoms.pbc, **symm)
kd.set_symmetry(atoms, symmetry, comm=world)
setups.set_symmetry(symmetry)
if par.gpts is not None:
N_c = np.array(par.gpts)
else:
h = par.h
if h is not None:
h /= Bohr
N_c = get_number_of_grid_points(cell_cv, h, mode, realspace,
kd.symmetry)
symmetry.check_grid(N_c)
width = par.width
if width is None:
if pbc_c.any():
width = 0.1 # eV
else:
width = 0.0
else:
assert par.occupations is None
if hasattr(self, 'time') or par.dtype == complex:
dtype = complex
else:
if kd.gamma:
dtype = float
else:
dtype = complex
nao = setups.nao
nvalence = setups.nvalence - par.charge
M_v = magmom_av.sum(0)
M = np.dot(M_v, M_v)**0.5
nbands = par.nbands
orbital_free = any(setup.orbital_free for setup in setups)
if orbital_free:
nbands = 1
if isinstance(nbands, basestring):
if nbands[-1] == '%':
basebands = int(nvalence + M + 0.5) // 2
nbands = int((float(nbands[:-1]) / 100) * basebands)
else:
raise ValueError('Integer Expected: Only use a string '
'if giving a percentage of occupied bands')
if nbands is None:
nbands = 0
for setup in setups:
nbands_from_atom = setup.get_default_nbands()
# Any obscure setup errors?
if nbands_from_atom < -(-setup.Nv // 2):
raise ValueError('Bad setup: This setup requests %d'
' bands but has %d electrons.' %
(nbands_from_atom, setup.Nv))
nbands += nbands_from_atom
nbands = min(nao, nbands)
elif nbands > nao and mode.name == 'lcao':
raise ValueError('Too many bands for LCAO calculation: '
'%d bands and only %d atomic orbitals!' %
(nbands, nao))
if nvalence < 0:
raise ValueError(
'Charge %f is not possible - not enough valence electrons' %
par.charge)
if nbands <= 0:
nbands = int(nvalence + M + 0.5) // 2 + (-nbands)
if nvalence > 2 * nbands and not orbital_free:
raise ValueError('Too few bands! Electrons: %f, bands: %d' %
(nvalence, nbands))
nbands *= ncomp
if par.width is not None:
self.text('**NOTE**: please start using '
'occupations=FermiDirac(width).')
if par.fixmom:
self.text('**NOTE**: please start using '
'occupations=FermiDirac(width, fixmagmom=True).')
if self.occupations is None:
if par.occupations is None:
# Create object for occupation numbers:
if orbital_free:
width = 0.0 # even for PBC
self.occupations = occupations.TFOccupations(
width, par.fixmom)
else:
self.occupations = occupations.FermiDirac(
width, par.fixmom)
else:
self.occupations = par.occupations
# If occupation numbers are changed, and we have wave functions,
# recalculate the occupation numbers
if self.wfs is not None and not isinstance(self.wfs,
EmptyWaveFunctions):
self.occupations.calculate(self.wfs)
self.occupations.magmom = M_v[2]
cc = par.convergence
if mode.name == 'lcao':
niter_fixdensity = 0
else:
niter_fixdensity = None
if self.scf is None:
force_crit = cc['forces']
if force_crit is not None:
force_crit /= Hartree / Bohr
self.scf = SCFLoop(cc['eigenstates'] / Hartree**2 * nvalence,
cc['energy'] / Hartree * max(nvalence, 1),
cc['density'] * nvalence, par.maxiter,
par.fixdensity, niter_fixdensity, force_crit)
parsize_kpt = par.parallel['kpt']
parsize_domain = par.parallel['domain']
parsize_bands = par.parallel['band']
if not realspace:
pbc_c = np.ones(3, bool)
if not self.wfs:
if parsize_domain == 'domain only': # XXX this was silly!
parsize_domain = world.size
parallelization = mpi.Parallelization(world, nspins * kd.nibzkpts)
ndomains = None
if parsize_domain is not None:
ndomains = np.prod(parsize_domain)
if mode.name == 'pw':
if ndomains > 1:
raise ValueError('Planewave mode does not support '
'domain decomposition.')
ndomains = 1
parallelization.set(kpt=parsize_kpt,
domain=ndomains,
band=parsize_bands)
comms = parallelization.build_communicators()
domain_comm = comms['d']
kpt_comm = comms['k']
band_comm = comms['b']
kptband_comm = comms['D']
domainband_comm = comms['K']
self.comms = comms
kd.set_communicator(kpt_comm)
parstride_bands = par.parallel['stridebands']
# Unfortunately we need to remember that we adjusted the
# number of bands so we can print a warning if it differs
# from the number specified by the user. (The number can
# be inferred from the input parameters, but it's tricky
# because we allow negative numbers)
self.nbands_parallelization_adjustment = -nbands % band_comm.size
nbands += self.nbands_parallelization_adjustment
# I would like to give the following error message, but apparently
# there are cases, e.g. gpaw/test/gw_ppa.py, which involve
# nbands > nao and are supposed to work that way.
#if nbands > nao:
# raise ValueError('Number of bands %d adjusted for band '
# 'parallelization %d exceeds number of atomic '
# 'orbitals %d. This problem can be fixed '
# 'by reducing the number of bands a bit.'
# % (nbands, band_comm.size, nao))
bd = BandDescriptor(nbands, band_comm, parstride_bands)
if (self.density is not None
and self.density.gd.comm.size != domain_comm.size):
# Domain decomposition has changed, so we need to
# reinitialize density and hamiltonian:
if par.fixdensity:
raise RuntimeError(
'Density reinitialization conflict ' +
'with "fixdensity" - specify domain decomposition.')
self.density = None
self.hamiltonian = None
# Construct grid descriptor for coarse grids for wave functions:
gd = self.grid_descriptor_class(N_c, cell_cv, pbc_c, domain_comm,
parsize_domain)
# do k-point analysis here? XXX
args = (gd, nvalence, setups, bd, dtype, world, kd, kptband_comm,
self.timer)
if par.parallel['sl_auto']:
# Choose scalapack parallelization automatically
for key, val in par.parallel.items():
if (key.startswith('sl_') and key != 'sl_auto'
and val is not None):
raise ValueError("Cannot use 'sl_auto' together "
"with '%s'" % key)
max_scalapack_cpus = bd.comm.size * gd.comm.size
nprow = max_scalapack_cpus
npcol = 1
# Get a sort of reasonable number of columns/rows
while npcol < nprow and nprow % 2 == 0:
npcol *= 2
nprow //= 2
assert npcol * nprow == max_scalapack_cpus
# ScaLAPACK creates trouble if there aren't at least a few
# whole blocks; choose block size so there will always be
# several blocks. This will crash for small test systems,
# but so will ScaLAPACK in any case
blocksize = min(-(-nbands // 4), 64)
sl_default = (nprow, npcol, blocksize)
else:
sl_default = par.parallel['sl_default']
if mode.name == 'lcao':
# Layouts used for general diagonalizer
sl_lcao = par.parallel['sl_lcao']
if sl_lcao is None:
sl_lcao = sl_default
lcaoksl = get_KohnSham_layouts(sl_lcao,
'lcao',
gd,
bd,
domainband_comm,
dtype,
nao=nao,
timer=self.timer)
self.wfs = mode(collinear, lcaoksl, *args)
elif mode.name == 'fd' or mode.name == 'pw':
# buffer_size keyword only relevant for fdpw
buffer_size = par.parallel['buffer_size']
# Layouts used for diagonalizer
sl_diagonalize = par.parallel['sl_diagonalize']
if sl_diagonalize is None:
sl_diagonalize = sl_default
diagksl = get_KohnSham_layouts(
sl_diagonalize,
'fd', # XXX
# choice of key 'fd' not so nice
gd,
bd,
domainband_comm,
dtype,
buffer_size=buffer_size,
timer=self.timer)
# Layouts used for orthonormalizer
sl_inverse_cholesky = par.parallel['sl_inverse_cholesky']
if sl_inverse_cholesky is None:
sl_inverse_cholesky = sl_default
if sl_inverse_cholesky != sl_diagonalize:
message = 'sl_inverse_cholesky != sl_diagonalize ' \
'is not implemented.'
raise NotImplementedError(message)
orthoksl = get_KohnSham_layouts(sl_inverse_cholesky,
'fd',
gd,
bd,
domainband_comm,
dtype,
buffer_size=buffer_size,
timer=self.timer)
# Use (at most) all available LCAO for initialization
lcaonbands = min(nbands, nao)
try:
lcaobd = BandDescriptor(lcaonbands, band_comm,
parstride_bands)
except RuntimeError:
initksl = None
else:
# Layouts used for general diagonalizer
# (LCAO initialization)
sl_lcao = par.parallel['sl_lcao']
if sl_lcao is None:
sl_lcao = sl_default
initksl = get_KohnSham_layouts(sl_lcao,
'lcao',
gd,
lcaobd,
domainband_comm,
dtype,
nao=nao,
timer=self.timer)
if hasattr(self, 'time'):
assert mode.name == 'fd'
from gpaw.tddft import TimeDependentWaveFunctions
self.wfs = TimeDependentWaveFunctions(
par.stencils[0], diagksl, orthoksl, initksl, gd,
nvalence, setups, bd, world, kd, kptband_comm,
self.timer)
elif mode.name == 'fd':
self.wfs = mode(par.stencils[0], diagksl, orthoksl,
initksl, *args)
else:
assert mode.name == 'pw'
self.wfs = mode(diagksl, orthoksl, initksl, *args)
else:
self.wfs = mode(self, *args)
else:
self.wfs.set_setups(setups)
if not self.wfs.eigensolver:
# Number of bands to converge:
nbands_converge = cc['bands']
if nbands_converge == 'all':
nbands_converge = nbands
elif nbands_converge != 'occupied':
assert isinstance(nbands_converge, int)
if nbands_converge < 0:
nbands_converge += nbands
eigensolver = get_eigensolver(par.eigensolver, mode,
par.convergence)
eigensolver.nbands_converge = nbands_converge
# XXX Eigensolver class doesn't define an nbands_converge property
if isinstance(xc, SIC):
eigensolver.blocksize = 1
self.wfs.set_eigensolver(eigensolver)
if self.density is None:
gd = self.wfs.gd
if par.stencils[1] != 9:
# Construct grid descriptor for fine grids for densities
# and potentials:
finegd = gd.refine()
else:
# Special case (use only coarse grid):
finegd = gd
if realspace:
self.density = RealSpaceDensity(
gd, finegd, nspins, par.charge + setups.core_charge,
collinear, par.stencils[1])
else:
self.density = pw.ReciprocalSpaceDensity(
gd, finegd, nspins, par.charge + setups.core_charge,
collinear)
self.density.initialize(setups, self.timer, magmom_av, par.hund)
self.density.set_mixer(par.mixer)
if self.hamiltonian is None:
gd, finegd = self.density.gd, self.density.finegd
if realspace:
self.hamiltonian = RealSpaceHamiltonian(
gd, finegd, nspins, setups, self.timer, xc, world,
self.wfs.kptband_comm, par.external, collinear,
par.poissonsolver, par.stencils[1])
else:
self.hamiltonian = pw.ReciprocalSpaceHamiltonian(
gd, finegd, self.density.pd2, self.density.pd3, nspins,
setups, self.timer, xc, world, self.wfs.kptband_comm,
par.external, collinear)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
self.text()
self.print_memory_estimate(self.txt, maxdepth=memory_estimate_depth)
self.txt.flush()
self.timer.print_info(self)
if dry_run:
self.dry_run()
if realspace and \
self.hamiltonian.poisson.get_description() == 'FDTD+TDDFT':
self.hamiltonian.poisson.set_density(self.density)
self.hamiltonian.poisson.print_messages(self.text)
self.txt.flush()
self.initialized = True
self._changed_keywords.clear()
def initialize(self, atoms=None):
"""Inexpensive initialization."""
if atoms is None:
atoms = self.atoms
else:
# Save the state of the atoms:
self.atoms = atoms.copy()
par = self.input_parameters
world = par.communicator
if world is None:
world = mpi.world
elif hasattr(world, 'new_communicator'):
# Check for whether object has correct type already
#
# Using isinstance() is complicated because of all the
# combinations, serial/parallel/debug...
pass
else:
# world should be a list of ranks:
world = mpi.world.new_communicator(np.asarray(world))
self.wfs.world = world
self.set_text(par.txt, par.verbose)
natoms = len(atoms)
pos_av = atoms.get_positions() / Bohr
cell_cv = atoms.get_cell()
pbc_c = atoms.get_pbc()
Z_a = atoms.get_atomic_numbers()
magmom_a = atoms.get_initial_magnetic_moments()
magnetic = magmom_a.any()
spinpol = par.spinpol
if par.hund:
if natoms != 1:
raise ValueError('hund=True arg only valid for single atoms!')
spinpol = True
if spinpol is None:
spinpol = magnetic
elif magnetic and not spinpol:
raise ValueError('Non-zero initial magnetic moment for a '
'spin-paired calculation!')
nspins = 1 + int(spinpol)
if isinstance(par.xc, str):
xc = XC(par.xc)
else:
xc = par.xc
setups = Setups(Z_a, par.setups, par.basis, par.lmax, xc, world)
# K-point descriptor
kd = KPointDescriptor(par.kpts, nspins)
width = par.width
if width is None:
if kd.gamma:
width = 0.0
else:
width = 0.1 # eV
else:
assert par.occupations is None
if par.gpts is not None and par.h is None:
N_c = np.array(par.gpts)
else:
if par.h is None:
self.text('Using default value for grid spacing.')
h = 0.2
else:
h = par.h
N_c = h2gpts(h, cell_cv)
cell_cv /= Bohr
if hasattr(self, 'time') or par.dtype==complex:
dtype = complex
else:
if kd.gamma:
dtype = float
else:
dtype = complex
kd.set_symmetry(atoms, setups, par.usesymm, N_c)
nao = setups.nao
nvalence = setups.nvalence - par.charge
nbands = par.nbands
if nbands is None:
nbands = nao
elif nbands > nao and par.mode == 'lcao':
raise ValueError('Too many bands for LCAO calculation: ' +
'%d bands and only %d atomic orbitals!' %
(nbands, nao))
if nvalence < 0:
raise ValueError(
'Charge %f is not possible - not enough valence electrons' %
par.charge)
M = magmom_a.sum()
if par.hund:
f_si = setups[0].calculate_initial_occupation_numbers(
magmom=0, hund=True, charge=par.charge, nspins=nspins)
Mh = f_si[0].sum() - f_si[1].sum()
if magnetic and M != Mh:
raise RuntimeError('You specified a magmom that does not'
'agree with hunds rule!')
else:
M = Mh
if nbands <= 0:
nbands = int(nvalence + M + 0.5) // 2 + (-nbands)
if nvalence > 2 * nbands:
raise ValueError('Too few bands! Electrons: %d, bands: %d'
% (nvalence, nbands))
if par.width is not None:
self.text('**NOTE**: please start using '
'occupations=FermiDirac(width).')
if par.fixmom:
self.text('**NOTE**: please start using '
'occupations=FermiDirac(width, fixmagmom=True).')
if self.occupations is None:
if par.occupations is None:
# Create object for occupation numbers:
self.occupations = occupations.FermiDirac(width, par.fixmom)
else:
self.occupations = par.occupations
self.occupations.magmom = M
cc = par.convergence
if par.mode == 'lcao':
niter_fixdensity = 0
else:
niter_fixdensity = None
if self.scf is None:
self.scf = SCFLoop(
cc['eigenstates'] * nvalence,
cc['energy'] / Hartree * max(nvalence, 1),
cc['density'] * nvalence,
par.maxiter, par.fixdensity,
niter_fixdensity)
parsize, parsize_bands = par.parallel['domain'], par.parallel['band']
if parsize_bands is None:
parsize_bands = 1
# TODO delete/restructure so all checks are in BandDescriptor
if nbands % parsize_bands != 0:
raise RuntimeError('Cannot distribute %d bands to %d processors' %
(nbands, parsize_bands))
if not self.wfs:
if parsize == 'domain only': #XXX this was silly!
parsize = world.size
domain_comm, kpt_comm, band_comm = mpi.distribute_cpus(parsize,
parsize_bands, nspins, kd.nibzkpts, world, par.idiotproof)
kd.set_communicator(kpt_comm)
parstride_bands = par.parallel['stridebands']
bd = BandDescriptor(nbands, band_comm, parstride_bands)
if (self.density is not None and
self.density.gd.comm.size != domain_comm.size):
# Domain decomposition has changed, so we need to
# reinitialize density and hamiltonian:
if par.fixdensity:
raise RuntimeError("I'm confused - please specify parsize."
)
self.density = None
self.hamiltonian = None
# Construct grid descriptor for coarse grids for wave functions:
gd = self.grid_descriptor_class(N_c, cell_cv, pbc_c,
domain_comm, parsize)
# do k-point analysis here? XXX
args = (gd, nvalence, setups, bd, dtype, world, kd, self.timer)
if par.mode == 'lcao':
# Layouts used for general diagonalizer
sl_lcao = par.parallel['sl_lcao']
if sl_lcao is None:
sl_lcao = par.parallel['sl_default']
lcaoksl = get_KohnSham_layouts(sl_lcao, 'lcao',
gd, bd, dtype,
nao=nao, timer=self.timer)
self.wfs = LCAOWaveFunctions(lcaoksl, *args)
elif par.mode == 'fd' or isinstance(par.mode, PW):
# buffer_size keyword only relevant for fdpw
buffer_size = par.parallel['buffer_size']
# Layouts used for diagonalizer
sl_diagonalize = par.parallel['sl_diagonalize']
if sl_diagonalize is None:
sl_diagonalize = par.parallel['sl_default']
diagksl = get_KohnSham_layouts(sl_diagonalize, 'fd',
gd, bd, dtype,
buffer_size=buffer_size,
timer=self.timer)
# Layouts used for orthonormalizer
sl_inverse_cholesky = par.parallel['sl_inverse_cholesky']
if sl_inverse_cholesky is None:
sl_inverse_cholesky = par.parallel['sl_default']
if sl_inverse_cholesky != sl_diagonalize:
message = 'sl_inverse_cholesky != sl_diagonalize ' \
'is not implemented.'
raise NotImplementedError(message)
orthoksl = get_KohnSham_layouts(sl_inverse_cholesky, 'fd',
gd, bd, dtype,
buffer_size=buffer_size,
timer=self.timer)
# Use (at most) all available LCAO for initialization
lcaonbands = min(nbands, nao)
lcaobd = BandDescriptor(lcaonbands, band_comm, parstride_bands)
assert nbands <= nao or bd.comm.size == 1
assert lcaobd.mynbands == min(bd.mynbands, nao) #XXX
# Layouts used for general diagonalizer (LCAO initialization)
sl_lcao = par.parallel['sl_lcao']
if sl_lcao is None:
sl_lcao = par.parallel['sl_default']
initksl = get_KohnSham_layouts(sl_lcao, 'lcao',
gd, lcaobd, dtype,
nao=nao,
timer=self.timer)
if par.mode == 'fd':
self.wfs = FDWaveFunctions(par.stencils[0], diagksl,
orthoksl, initksl, *args)
else:
# Planewave basis:
self.wfs = par.mode(diagksl, orthoksl, initksl,
gd, nvalence, setups, bd,
world, kd, self.timer)
else:
self.wfs = par.mode(self, *args)
else:
self.wfs.set_setups(setups)
if not self.wfs.eigensolver:
# Number of bands to converge:
nbands_converge = cc['bands']
if nbands_converge == 'all':
nbands_converge = nbands
elif nbands_converge != 'occupied':
assert isinstance(nbands_converge, int)
if nbands_converge < 0:
nbands_converge += nbands
eigensolver = get_eigensolver(par.eigensolver, par.mode,
par.convergence)
eigensolver.nbands_converge = nbands_converge
# XXX Eigensolver class doesn't define an nbands_converge property
self.wfs.set_eigensolver(eigensolver)
if self.density is None:
gd = self.wfs.gd
if par.stencils[1] != 9:
# Construct grid descriptor for fine grids for densities
# and potentials:
finegd = gd.refine()
else:
# Special case (use only coarse grid):
finegd = gd
self.density = Density(gd, finegd, nspins,
par.charge + setups.core_charge)
self.density.initialize(setups, par.stencils[1], self.timer,
magmom_a, par.hund)
self.density.set_mixer(par.mixer)
if self.hamiltonian is None:
gd, finegd = self.density.gd, self.density.finegd
self.hamiltonian = Hamiltonian(gd, finegd, nspins,
setups, par.stencils[1], self.timer,
xc, par.poissonsolver,
par.external)
xc.initialize(self.density, self.hamiltonian, self.wfs,
self.occupations)
self.text()
self.print_memory_estimate(self.txt, maxdepth=memory_estimate_depth)
self.txt.flush()
if dry_run:
self.dry_run()
self.initialized = True
