def __init__(self, gd, finegd, nspins, charge, collinear=True):
"""Create the Density object."""
self.gd = gd
self.finegd = finegd
self.nspins = nspins
self.charge = float(charge)
self.collinear = collinear
self.ncomp = 1 if collinear else 2
self.ns = self.nspins * self.ncomp**2
self.charge_eps = 1e-7
self.D_asp = None
self.Q_aL = None
self.nct_G = None
self.nt_sG = None
self.rhot_g = None
self.nt_sg = None
self.nt_g = None
self.rank_a = None
self.atom_partition = None
self.mixer = BaseMixer()
self.timer = nulltimer
def __init__(self, gd, finegd, nspins, charge, collinear=True):
"""Create the Density object."""
self.gd = gd
self.finegd = finegd
self.nspins = nspins
self.charge = float(charge)
self.collinear = collinear
self.ncomp = 2 - int(collinear)
self.charge_eps = 1e-7
self.D_asp = None
self.Q_aL = None
self.nct_G = None
self.nt_sG = None
self.rhot_g = None
self.nt_sg = None
self.nt_g = None
self.rank_a = None
self.mixer = BaseMixer()
self.timer = nulltimer
def set_mixer(self, mixer):
if mixer is not None:
if self.nspins == 1 and isinstance(mixer, MixerSum):
raise RuntimeError('Cannot use MixerSum with nspins==1')
self.mixer = mixer
else:
if self.gd.pbc_c.any():
beta = 0.1
weight = 50.0
else:
beta = 0.25
weight = 1.0
if self.nspins == 2:
self.mixer = MixerSum(beta=beta, weight=weight)
else:
self.mixer = Mixer(beta=beta, weight=weight)
self.mixer.initialize(self)
def create_calc(name, spinpol, pbc):
# Bond lengths between H-C and C-C for ethyne (acetylene) cf.
# CRC Handbook of Chemistry and Physics, 87th ed., p. 9-28
dhc = 1.060
dcc = 1.203
atoms = Atoms([
Atom('H', (0, 0, 0)),
Atom('C', (dhc, 0, 0)),
Atom('C', (dhc + dcc, 0, 0)),
Atom('H', (2 * dhc + dcc, 0, 0))
],
pbc=pbc)
atoms.center(vacuum=2.0)
# Number of occupied and unoccupied bands to converge
nbands = int(10 / 2.0)
nextra = 3
#TODO use pbc and cell to calculate nkpts
kwargs = {}
if spinpol:
kwargs['mixer'] = MixerSum(nmaxold=5, beta=0.1, weight=100)
else:
kwargs['mixer'] = Mixer(nmaxold=5, beta=0.1, weight=100)
calc = GPAW(h=0.3,
nbands=nbands+nextra,
xc='PBE',
spinpol=spinpol,
eigensolver='cg',
convergence={'energy':1e-4/len(atoms), 'density':1e-5, \
'eigenstates': 1e-9, 'bands':-1},
txt=name+'.txt', **kwargs)
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write(name + '.gpw', mode='all')
def __init__(self, gd, finegd, nspins, charge):
"""Create the Density object."""
self.gd = gd
self.finegd = finegd
self.nspins = nspins
self.charge = float(charge)
self.charge_eps = 1e-7
self.D_asp = None
self.Q_aL = None
self.nct_G = None
self.nt_sG = None
self.rhot_g = None
self.nt_sg = None
self.nt_g = None
self.rank_a = None
self.mixer = BaseMixer()
self.timer = nulltimer
self.allocated = False
L = 7.00
basis = BasisMaker('Na').generate(1, 1, energysplit=0.3)
atoms = Atoms('Na9', pbc=(0, 0, 1), cell=[L, L, 9 * a])
atoms.positions[:9, 2] = [i * a for i in range(9)]
atoms.positions[:, :2] = L / 2.
atoms.center()
pl_atoms1 = range(4)
pl_atoms2 = range(5, 9)
pl_cell1 = (L, L, 4 * a)
pl_cell2 = pl_cell1
t = Transport(h=0.3,
xc='LDA',
basis={'Na': basis},
kpts=(1, 1, 1),
occupations=FermiDirac(0.1),
mode='lcao',
poissonsolver=PoissonSolver(nn=2, relax='GS'),
txt='Na_lcao.txt',
mixer=Mixer(0.1, 5, weight=100.0),
pl_atoms=[pl_atoms1, pl_atoms2],
pl_cells=[pl_cell1, pl_cell2],
pl_kpts=(1, 1, 5),
edge_atoms=[[0, 3], [0, 8]],
mol_atoms=[4],
guess_steps=1,
fixed_boundary=False)
atoms.set_calculator(t)
t.calculate_iv(0.5, 2)
cell = (12.01, 12.02, 12.03)
tag = 'g2_dzp'
if optimizer is not None:
tag += '_%s' % optimizer
calcopts_default = {
'mode': 'lcao',
'basis': 'dzp',
'xc': 'PBE',
'width': 0.0,
'fixmom': True,
'nbands': -2,
# make systems converge
'mixer': Mixer(0.05, 2),
'maxiter': 300,
}
calcfactory_default = GPAWFactory(**calcopts_default)
calcopts_d16 = calcopts_default.copy()
calcopts_d16.update({'convergence': {'density': 1.e-6}})
calcfactory_d16 = GPAWFactory(**calcopts_d16)
calcfactory = calcfactory_default
collection = Collection(data, names, cell)
taskopts = {'fmax': 0.05, 'steps': 100}
if optimizer is not None:
if 'D16' not in optimizer:
from gpaw.mixer import Mixer
from gpaw.response.df0 import DF
from gpaw.response.bse import BSE
GS = 1
df = 1
bse = 1
check_spectrum = 1
if GS:
a = 4.043
atoms = bulk('Al', 'fcc', a=a)
atoms.center()
calc = GPAW(h=0.2,
eigensolver=RMM_DIIS(),
mixer=Mixer(0.1,3),
kpts=(4,2,2),
xc='LDA',
nbands=4,
convergence={'bands':'all'})
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write('Al.gpw','all')
if bse:
bse = BSE('Al.gpw',
w=np.linspace(0,24,241),
nv=[0,4],
nc=[0,4],
coupling=True,
if len(sys.argv) == 1:
optimizer = None
else:
optimizer = sys.argv[1]
tag = 'htb_pw'
if optimizer is not None:
tag += '_%s' % optimizer
calcfactory = GPAWFactory(
mode=PW(),
xc='PBE',
width=0.1,
maxiter=400,
mixer=Mixer(0.10, 2),
eigensolver='cg',
# avoid problems with band parallelization
communicator=serial_comm,
)
taskopts = {'sfmax': 0.01, 'ssteps': 50}
if optimizer is not None:
taskopts.update({'soptimizer': optimizer})
task = Task(xc='LDA',
calcfactory=calcfactory,
tag=tag,
use_lock_files=True,
**taskopts)
def calculate(element, h, vacuum, xc, magmom):
atom = Atoms([Atom(element, (0, 0, 0))])
if magmom > 0.0:
mms = [magmom for i in range(len(atom))]
atom.set_initial_magnetic_moments(mms)
atom.center(vacuum=vacuum)
mixer = MixerSum(beta=0.4)
if element == 'O':
mixer = MixerSum(0.4, nmaxold=1, weight=100)
atom.set_positions(atom.get_positions() + [0.0, 0.0, 0.0001])
calc_atom = GPAW(h=h,
xc=_xc(data[element][xc][2]),
experimental={'niter_fixdensity': 2},
eigensolver='rmm-diis',
occupations=FermiDirac(0.0, fixmagmom=True),
mixer=mixer,
parallel=dict(augment_grids=True),
nbands=-2,
txt='%s.%s.txt' % (element, xc))
atom.set_calculator(calc_atom)
mixer = Mixer(beta=0.4, weight=100)
compound = molecule(element + '2')
if compound == 'O2':
mixer = MixerSum(beta=0.4)
mms = [1.0 for i in range(len(compound))]
compound.set_initial_magnetic_moments(mms)
calc = GPAW(h=h,
xc=_xc(data[element][xc][2]),
experimental={'niter_fixdensity': 2},
eigensolver='rmm-diis',
mixer=mixer,
parallel=dict(augment_grids=True),
txt='%s2.%s.txt' % (element, xc))
compound.set_distance(0, 1, data[element]['R_AA_B3LYP'])
compound.center(vacuum=vacuum)
compound.set_calculator(calc)
if data[element][xc][3] == 'hyb_gga': # only for hybrids
e_atom = atom.get_potential_energy()
e_compound = compound.get_potential_energy()
calc_atom.set(xc=_xc(xc))
calc.set(xc=_xc(xc))
e_atom = atom.get_potential_energy()
e_compound = compound.get_potential_energy()
dHf_0 = (e_compound - 2 * e_atom + data[element]['ZPE_AA_B3LYP'] +
2 * data[element]['dHf_0_A'])
dHf_298 = (dHf_0 + data[element]['H_298_H_0_AA_B3LYP'] -
2 * data[element]['H_298_H_0_A']) * (mol / kcal)
de = dHf_298 - data[element][xc][1]
E[element][xc] = de
if rank == 0:
print((xc, h, vacuum, dHf_298, data[element][xc][1], de,
de / data[element][xc][1]))
if element == 'H':
equal(dHf_298, data[element][xc][1], 0.25,
msg=xc + ': ') # kcal/mol
elif element == 'O':
equal(dHf_298, data[element][xc][1], 7.5,
msg=xc + ': ') # kcal/mol
else:
equal(dHf_298, data[element][xc][1], 2.15,
msg=xc + ': ') # kcal/mol
equal(de, E_ref[element][xc], 0.06, msg=xc + ': ') # kcal/mol
def run_slab(adsorbate, geometry, xc, code):
parameters = initialize_parameters(code, 0.1, h)
parameters['xc'] = xc
tag = 'Ru001'
if adsorbate != 'None':
name = adsorbate + tag
else:
name = tag
if geometry == 'fix':
slab = read_trajectory(code + '_' + name + '.traj')
else:
adsorbate_heights = {'N': 1.108, 'O': 1.257}
slab = hcp0001('Ru',
size=(2, 2, 4),
a=2.72,
c=1.58 * 2.72,
vacuum=5.0 + add_vacuum,
orthogonal=True)
slab.center(axis=2)
if adsorbate != 'None':
add_adsorbate(slab, adsorbate, adsorbate_heights[adsorbate], 'hcp')
slab.set_constraint(FixAtoms(mask=slab.get_tags() >= 3))
if code != 'elk':
parameters['nbands'] = 80
parameters['kpts'] = [4, 4, 1]
#
if code == 'gpaw':
from gpaw import GPAW as Calculator
from gpaw.mpi import rank
parameters['txt'] = code + '_' + name + '.txt'
from gpaw.mixer import Mixer, MixerSum
parameters['mixer'] = Mixer(beta=0.2, nmaxold=5, weight=100.0)
if code == 'dacapo':
from ase.calculators.dacapo import Dacapo as Calculator
rank = 0
parameters['txtout'] = code + '_' + name + '.txt'
if code == 'abinit':
from ase.calculators.abinit import Abinit as Calculator
rank = 0
parameters['label'] = code + '_' + name
if code == 'elk':
from ase.calculators.elk import ELK as Calculator
rank = 0
parameters['autokpt'] = True
elk_dir = 'elk_' + str(parameters['rgkmax'])
conv_param = 1.0
parameters['dir'] = elk_dir + '_' + name
#
calc = Calculator(**parameters)
#
slab.set_calculator(calc)
try:
if geometry == 'fix':
slab.get_potential_energy()
traj = PickleTrajectory(code + '_' + name + '.traj', mode='w')
traj.write(slab)
else:
opt = QuasiNewton(slab,
logfile=code + '_' + name + '.qn',
trajectory=code + '_' + name + '.traj')
opt.run(fmax=fmax)
except:
raise
def calculate(element, h, vacuum, xc, magmom):
atom = Atoms([Atom(element, (0, 0, 0))])
if magmom > 0.0:
mms = [magmom for i in range(len(atom))]
atom.set_initial_magnetic_moments(mms)
atom.center(vacuum=vacuum)
mixer = MixerSum(beta=0.2)
if element == 'O':
mixer = MixerSum(nmaxold=1, weight=100)
atom.set_positions(atom.get_positions() + [0.0, 0.0, 0.0001])
calc_atom = GPAW(h=h,
xc=data[element][xc][2],
occupations=FermiDirac(0.0, fixmagmom=True),
mixer=mixer,
nbands=-2,
txt='%s.%s.txt' % (element, xc))
atom.set_calculator(calc_atom)
mixer = Mixer(beta=0.2, weight=100)
compound = molecule(element + '2')
if compound == 'O2':
mixer = MixerSum(beta=0.2)
mms = [1.0 for i in range(len(compound))]
compound.set_initial_magnetic_moments(mms)
calc = GPAW(h=h,
xc=data[element][xc][2],
mixer=mixer,
txt='%s2.%s.txt' % (element, xc))
compound.set_distance(0, 1, data[element]['R_AA_B3LYP'])
compound.center(vacuum=vacuum)
compound.set_calculator(calc)
if data[element][xc][3] == 'hyb_gga': # only for hybrids
e_atom = atom.get_potential_energy()
e_compound = compound.get_potential_energy()
calc_atom.set(xc=xc)
calc.set(xc=xc)
if 0:
qn = QuasiNewton(compound)
qn.attach(
PickleTrajectory(element + '2' + '_' + xc + '.traj', 'w',
compound).write)
qn.run(fmax=0.02)
e_atom = atom.get_potential_energy()
e_compound = compound.get_potential_energy()
dHf_0 = (e_compound - 2 * e_atom + data[element]['ZPE_AA_B3LYP'] +
2 * data[element]['dHf_0_A'])
dHf_298 = (dHf_0 + data[element]['H_298_H_0_AA_B3LYP'] -
2 * data[element]['H_298_H_0_A']) * (mol / kcal)
dist_compound = compound.get_distance(0, 1)
de = dHf_298 - data[element][xc][1]
E[element][xc] = de
if rank == 0:
print(xc, h, vacuum, dHf_298, data[element][xc][1], de,
de / data[element][xc][1])
if element == 'H':
equal(dHf_298, data[element][xc][1], 0.25,
msg=xc + ': ') # kcal/mol
elif element == 'O':
equal(dHf_298, data[element][xc][1], 7.5,
msg=xc + ': ') # kcal/mol
else:
equal(dHf_298, data[element][xc][1], 2.15,
msg=xc + ': ') # kcal/mol
equal(de, E_ref[element][xc], 0.06, msg=xc + ': ') # kcal/mol
def read(self, reader):
"""Read state from file."""
if isinstance(reader, str):
reader = gpaw.io.open(reader, 'r')
r = reader
version = r['version']
assert version >= 0.3
self.xc = r['XCFunctional']
self.nbands = r.dimension('nbands')
self.spinpol = (r.dimension('nspins') == 2)
if r.has_array('NBZKPoints'):
self.kpts = r.get('NBZKPoints')
else:
self.kpts = r.get('BZKPoints')
self.usesymm = r['UseSymmetry']
try:
self.basis = r['BasisSet']
except KeyError:
pass
self.gpts = ((r.dimension('ngptsx') + 1) // 2 * 2,
(r.dimension('ngptsy') + 1) // 2 * 2,
(r.dimension('ngptsz') + 1) // 2 * 2)
self.lmax = r['MaximumAngularMomentum']
self.setups = r['SetupTypes']
self.fixdensity = r['FixDensity']
if version <= 0.4:
# Old version: XXX
print('# Warning: Reading old version 0.3/0.4 restart files ' +
'will be disabled some day in the future!')
self.convergence['eigenstates'] = r['Tolerance']
else:
self.convergence = {
'density': r['DensityConvergenceCriterion'],
'energy': r['EnergyConvergenceCriterion'] * Hartree,
'eigenstates': r['EigenstatesConvergenceCriterion'],
'bands': r['NumberOfBandsToConverge']
}
if version <= 0.6:
mixer = 'Mixer'
weight = r['MixMetric']
elif version <= 0.7:
mixer = r['MixClass']
weight = r['MixWeight']
metric = r['MixMetric']
if metric is None:
weight = 1.0
else:
mixer = r['MixClass']
weight = r['MixWeight']
if mixer == 'Mixer':
from gpaw.mixer import Mixer
elif mixer == 'MixerSum':
from gpaw.mixer import MixerSum as Mixer
elif mixer == 'MixerSum2':
from gpaw.mixer import MixerSum2 as Mixer
elif mixer == 'MixerDif':
from gpaw.mixer import MixerDif as Mixer
elif mixer == 'DummyMixer':
from gpaw.mixer import DummyMixer as Mixer
else:
Mixer = None
if Mixer is None:
self.mixer = None
else:
self.mixer = Mixer(r['MixBeta'], r['MixOld'], weight)
if version == 0.3:
# Old version: XXX
print('# Warning: Reading old version 0.3 restart files is ' +
'dangerous and will be disabled some day in the future!')
self.stencils = (2, 3)
self.charge = 0.0
fixmom = False
else:
self.stencils = (r['KohnShamStencil'], r['InterpolationStencil'])
if r['PoissonStencil'] == 999:
self.poissonsolver = FFTPoissonSolver()
else:
self.poissonsolver = PoissonSolver(nn=r['PoissonStencil'])
self.charge = r['Charge']
fixmom = r['FixMagneticMoment']
self.occupations = FermiDirac(r['FermiWidth'] * Hartree,
fixmagmom=fixmom)
try:
self.mode = r['Mode']
except KeyError:
self.mode = 'fd'
try:
dtype = r['DataType']
if dtype == 'Float':
self.dtype = float
else:
self.dtype = complex
except KeyError:
self.dtype = float
def wrap_old_gpw_reader(filename):
warnings.warn('You are reading an old-style gpw-file. Please check '
'the results carefully!')
r = Reader(filename)
data = {
'version': -1,
'gpaw_version': '1.0',
'ha': Ha,
'bohr': Bohr,
'scf.': {
'converged': True
},
'atoms.': {},
'wave_functions.': {}
}
class DictBackend:
def write(self, **kwargs):
data['atoms.'].update(kwargs)
write_atoms(DictBackend(), read_atoms(r))
e_total_extrapolated = r.get('PotentialEnergy').item() * Ha
magmom_a = r.get('MagneticMoments')
data['results.'] = {
'energy': e_total_extrapolated,
'magmoms': magmom_a,
'magmom': magmom_a.sum()
}
if r.has_array('CartesianForces'):
data['results.']['forces'] = r.get('CartesianForces') * Ha / Bohr
p = data['parameters.'] = {}
p['xc'] = r['XCFunctional']
p['nbands'] = r.dimension('nbands')
p['spinpol'] = (r.dimension('nspins') == 2)
bzk_kc = r.get('BZKPoints', broadcast=True)
if r.has_array('NBZKPoints'):
p['kpts'] = r.get('NBZKPoints', broadcast=True)
if r.has_array('MonkhorstPackOffset'):
offset_c = r.get('MonkhorstPackOffset', broadcast=True)
if offset_c.any():
p['kpts'] = monkhorst_pack(p['kpts']) + offset_c
else:
p['kpts'] = bzk_kc
if r['version'] < 4:
usesymm = r['UseSymmetry']
if usesymm is None:
p['symmetry'] = {'time_reversal': False, 'point_group': False}
elif usesymm:
p['symmetry'] = {'time_reversal': True, 'point_group': True}
else:
p['symmetry'] = {'time_reversal': True, 'point_group': False}
else:
p['symmetry'] = {
'point_group': r['SymmetryOnSwitch'],
'symmorphic': r['SymmetrySymmorphicSwitch'],
'time_reversal': r['SymmetryTimeReversalSwitch'],
'tolerance': r['SymmetryToleranceCriterion']
}
p['basis'] = r['BasisSet']
try:
h = r['GridSpacing']
except KeyError: # CMR can't handle None!
h = None
if h is not None:
p['h'] = Bohr * h
if r.has_array('GridPoints'):
p['gpts'] = r.get('GridPoints')
p['lmax'] = r['MaximumAngularMomentum']
p['setups'] = r['SetupTypes']
p['fixdensity'] = r['FixDensity']
nbtc = r['NumberOfBandsToConverge']
if not isinstance(nbtc, (int, str)):
# The string 'all' was eval'ed to the all() function!
nbtc = 'all'
p['convergence'] = {
'density': r['DensityConvergenceCriterion'],
'energy': r['EnergyConvergenceCriterion'] * Ha,
'eigenstates': r['EigenstatesConvergenceCriterion'],
'bands': nbtc
}
mixer = r['MixClass']
weight = r['MixWeight']
for key in ['basis', 'setups']:
dct = p[key]
if isinstance(dct, dict) and None in dct:
dct['default'] = dct.pop(None)
if mixer == 'Mixer':
from gpaw.mixer import Mixer
elif mixer == 'MixerSum':
from gpaw.mixer import MixerSum as Mixer
elif mixer == 'MixerSum2':
from gpaw.mixer import MixerSum2 as Mixer
elif mixer == 'MixerDif':
from gpaw.mixer import MixerDif as Mixer
elif mixer == 'DummyMixer':
from gpaw.mixer import DummyMixer as Mixer
else:
Mixer = None
if Mixer is None:
p['mixer'] = None
else:
p['mixer'] = Mixer(r['MixBeta'], r['MixOld'], weight)
p['stencils'] = (r['KohnShamStencil'], r['InterpolationStencil'])
vt_sG = r.get('PseudoPotential') * Ha
ps = r['PoissonStencil']
if isinstance(ps, int) or ps == 'M':
poisson = {'name': 'fd'}
poisson['nn'] = ps
if data['atoms.']['pbc'] == [1, 1, 0]:
v1, v2 = vt_sG[0, :, :, [0, -1]].mean(axis=(1, 2))
if abs(v1 - v2) > 0.01:
warnings.warn('I am guessing that this calculation was done '
'with a dipole-layer correction?')
poisson['dipolelayer'] = 'xy'
p['poissonsolver'] = poisson
p['charge'] = r['Charge']
fixmom = r['FixMagneticMoment']
p['occupations'] = FermiDirac(r['FermiWidth'] * Ha, fixmagmom=fixmom)
p['mode'] = r['Mode']
if p['mode'] == 'pw':
p['mode'] = PW(ecut=r['PlaneWaveCutoff'] * Ha)
if len(bzk_kc) == 1 and not bzk_kc[0].any():
# Gamma point only:
if r['DataType'] == 'Complex':
p['dtype'] = complex
data['occupations.'] = {
'fermilevel': r['FermiLevel'] * Ha,
'split': r.parameters.get('FermiSplit', 0) * Ha,
'h**o': np.nan,
'lumo': np.nan
}
data['density.'] = {
'density': r.get('PseudoElectronDensity') * Bohr**-3,
'atomic_density_matrices': r.get('AtomicDensityMatrices')
}
data['hamiltonian.'] = {
'e_coulomb': r['Epot'] * Ha,
'e_entropy': -r['S'] * Ha,
'e_external': r['Eext'] * Ha,
'e_kinetic': r['Ekin'] * Ha,
'e_total_extrapolated': e_total_extrapolated,
'e_xc': r['Exc'] * Ha,
'e_zero': r['Ebar'] * Ha,
'potential': vt_sG,
'atomic_hamiltonian_matrices': r.get('NonLocalPartOfHamiltonian') * Ha
}
data['hamiltonian.']['e_total_free'] = (sum(
data['hamiltonian.'][e] for e in [
'e_coulomb', 'e_entropy', 'e_external', 'e_kinetic', 'e_xc',
'e_zero'
]))
if r.has_array('GLLBPseudoResponsePotential'):
data['hamiltonian.']['xc.'] = {
'gllb_pseudo_response_potential':
r.get('GLLBPseudoResponsePotential') * Ha,
'gllb_dxc_pseudo_response_potential':
r.get('GLLBDxcPseudoResponsePotential') * Ha / Bohr,
'gllb_atomic_density_matrices':
r.get('GLLBAtomicDensityMatrices'),
'gllb_atomic_response_matrices':
r.get('GLLBAtomicResponseMatrices'),
'gllb_dxc_atomic_density_matrices':
r.get('GLLBDxcAtomicDensityMatrices'),
'gllb_dxc_atomic_response_matrices':
r.get('GLLBDxcAtomicResponseMatrices')
}
special = [('eigenvalues', 'Eigenvalues'),
('occupations', 'OccupationNumbers'),
('projections', 'Projections')]
if r['Mode'] == 'pw':
special.append(('coefficients', 'PseudoWaveFunctions'))
try:
data['wave_functions.']['indices'] = r.get('PlaneWaveIndices')
except KeyError:
pass
elif r['Mode'] == 'fd':
special.append(('values', 'PseudoWaveFunctions'))
else:
special.append(('coefficients', 'WaveFunctionCoefficients'))
for name, old in special:
try:
fd, shape, size, dtype = r.get_file_object(old, ())
except KeyError:
continue
offset = fd
data['wave_functions.'][name + '.'] = {
'ndarray': (shape, dtype.name, offset)
}
new = ulm.Reader(devnull,
data=data,
little_endian=r.byteswap ^ np.little_endian)
for ref in new._data['wave_functions']._data.values():
try:
ref.fd = ref.offset
except AttributeError:
continue
ref.offset = 0
return new
class Density:
"""Density object.
Attributes:
=============== =====================================================
``gd`` Grid descriptor for coarse grids.
``finegd`` Grid descriptor for fine grids.
``interpolate`` Function for interpolating the electron density.
``mixer`` ``DensityMixer`` object.
=============== =====================================================
Soft and smooth pseudo functions on uniform 3D grids:
========== =========================================
``nt_sG`` Electron density on the coarse grid.
``nt_sg`` Electron density on the fine grid.
``nt_g`` Electron density on the fine grid.
``rhot_g`` Charge density on the fine grid.
``nct_G`` Core electron-density on the coarse grid.
========== =========================================
"""
def __init__(self, gd, finegd, nspins, charge, collinear=True):
"""Create the Density object."""
self.gd = gd
self.finegd = finegd
self.nspins = nspins
self.charge = float(charge)
self.collinear = collinear
self.ncomp = 2 - int(collinear)
self.charge_eps = 1e-7
self.D_asp = None
self.Q_aL = None
self.nct_G = None
self.nt_sG = None
self.rhot_g = None
self.nt_sg = None
self.nt_g = None
self.rank_a = None
self.mixer = BaseMixer()
self.timer = nulltimer
def initialize(self, setups, timer, magmom_av, hund):
self.timer = timer
self.setups = setups
self.hund = hund
self.magmom_av = magmom_av
def reset(self):
# TODO: reset other parameters?
self.nt_sG = None
def set_positions(self, spos_ac, rank_a=None):
self.nct.set_positions(spos_ac)
self.ghat.set_positions(spos_ac)
self.mixer.reset()
#self.nt_sG = None
self.nt_sg = None
self.nt_g = None
self.rhot_g = None
self.Q_aL = None
# If both old and new atomic ranks are present, start a blank dict if
# it previously didn't exist but it will needed for the new atoms.
if (self.rank_a is not None and rank_a is not None and
self.D_asp is None and (rank_a == self.gd.comm.rank).any()):
self.D_asp = {}
if (self.rank_a is not None and self.D_asp is not None and
rank_a is not None and not isinstance(self.gd.comm, SerialCommunicator)):
self.timer.start('Redistribute')
requests = []
flags = (self.rank_a != rank_a)
my_incoming_atom_indices = np.argwhere(np.bitwise_and(flags, \
rank_a == self.gd.comm.rank)).ravel()
my_outgoing_atom_indices = np.argwhere(np.bitwise_and(flags, \
self.rank_a == self.gd.comm.rank)).ravel()
for a in my_incoming_atom_indices:
# Get matrix from old domain:
ni = self.setups[a].ni
D_sp = np.empty((self.nspins * self.ncomp**2,
ni * (ni + 1) // 2))
requests.append(self.gd.comm.receive(D_sp, self.rank_a[a],
tag=a, block=False))
assert a not in self.D_asp
self.D_asp[a] = D_sp
for a in my_outgoing_atom_indices:
# Send matrix to new domain:
D_sp = self.D_asp.pop(a)
requests.append(self.gd.comm.send(D_sp, rank_a[a],
tag=a, block=False))
self.gd.comm.waitall(requests)
self.timer.stop('Redistribute')
self.rank_a = rank_a
def calculate_pseudo_density(self, wfs):
"""Calculate nt_sG from scratch.
nt_sG will be equal to nct_G plus the contribution from
wfs.add_to_density().
"""
wfs.calculate_density_contribution(self.nt_sG)
self.nt_sG[:self.nspins] += self.nct_G
def update(self, wfs):
self.timer.start('Density')
self.timer.start('Pseudo density')
self.calculate_pseudo_density(wfs)
self.timer.stop('Pseudo density')
self.timer.start('Atomic density matrices')
wfs.calculate_atomic_density_matrices(self.D_asp)
self.timer.stop('Atomic density matrices')
self.timer.start('Multipole moments')
comp_charge = self.calculate_multipole_moments()
self.timer.stop('Multipole moments')
if isinstance(wfs, LCAOWaveFunctions):
self.timer.start('Normalize')
self.normalize(comp_charge)
self.timer.stop('Normalize')
self.timer.start('Mix')
self.mix(comp_charge)
self.timer.stop('Mix')
self.timer.stop('Density')
def normalize(self, comp_charge=None):
"""Normalize pseudo density."""
if comp_charge is None:
comp_charge = self.calculate_multipole_moments()
pseudo_charge = self.gd.integrate(self.nt_sG[:self.nspins]).sum()
if pseudo_charge + self.charge + comp_charge != 0:
if pseudo_charge != 0:
x = -(self.charge + comp_charge) / pseudo_charge
self.nt_sG *= x
else:
# Use homogeneous background:
volume = self.gd.get_size_of_global_array().prod() * self.gd.dv
self.nt_sG[:self.nspins] = -(self.charge +
comp_charge) / volume
def mix(self, comp_charge):
if not self.mixer.mix_rho:
self.mixer.mix(self)
comp_charge = None
self.interpolate_pseudo_density(comp_charge)
self.calculate_pseudo_charge()
if self.mixer.mix_rho:
self.mixer.mix(self)
def calculate_multipole_moments(self):
"""Calculate multipole moments of compensation charges.
Returns the total compensation charge in units of electron
charge, so the number will be negative because of the
dominating contribution from the nuclear charge."""
comp_charge = 0.0
self.Q_aL = {}
for a, D_sp in self.D_asp.items():
Q_L = self.Q_aL[a] = np.dot(D_sp[:self.nspins].sum(0),
self.setups[a].Delta_pL)
Q_L[0] += self.setups[a].Delta0
comp_charge += Q_L[0]
return self.gd.comm.sum(comp_charge) * sqrt(4 * pi)
def initialize_from_atomic_densities(self, basis_functions):
"""Initialize D_asp, nt_sG and Q_aL from atomic densities.
nt_sG is initialized from atomic orbitals, and will
be constructed with the specified magnetic moments and
obeying Hund's rules if ``hund`` is true."""
# XXX does this work with blacs? What should be distributed?
# Apparently this doesn't use blacs at all, so it's serial
# with respect to the blacs distribution. That means it works
# but is not particularly efficient (not that this is a time
# consuming step)
self.D_asp = {}
f_asi = {}
for a in basis_functions.atom_indices:
c = self.charge / len(self.setups) # distribute on all atoms
M_v = self.magmom_av[a]
M = (M_v**2).sum()**0.5
f_si = self.setups[a].calculate_initial_occupation_numbers(
M, self.hund, charge=c,
nspins=self.nspins * self.ncomp)
if self.collinear:
if M_v[2] < 0:
f_si = f_si[::-1].copy()
else:
f_i = f_si.sum(axis=0)
fm_i = f_si[0] - f_si[1]
f_si = np.zeros((4, len(f_i)))
f_si[0] = f_i
if M > 0:
f_si[1:4] = np.outer(M_v / M, fm_i)
if a in basis_functions.my_atom_indices:
self.D_asp[a] = self.setups[a].initialize_density_matrix(f_si)
f_asi[a] = f_si
self.nt_sG = self.gd.zeros(self.nspins * self.ncomp**2)
basis_functions.add_to_density(self.nt_sG, f_asi)
self.nt_sG[:self.nspins] += self.nct_G
self.calculate_normalized_charges_and_mix()
def initialize_from_wavefunctions(self, wfs):
"""Initialize D_asp, nt_sG and Q_aL from wave functions."""
self.nt_sG = self.gd.empty(self.nspins * self.ncomp**2)
self.calculate_pseudo_density(wfs)
self.D_asp = {}
my_atom_indices = np.argwhere(wfs.rank_a == self.gd.comm.rank).ravel()
for a in my_atom_indices:
ni = self.setups[a].ni
self.D_asp[a] = np.empty((self.nspins, ni * (ni + 1) // 2))
wfs.calculate_atomic_density_matrices(self.D_asp)
self.calculate_normalized_charges_and_mix()
def initialize_directly_from_arrays(self, nt_sG, D_asp):
"""Set D_asp and nt_sG directly."""
self.nt_sG = nt_sG
self.D_asp = D_asp
#self.calculate_normalized_charges_and_mix()
# No calculate multipole moments? Tests will fail because of
# improperly initialized mixer
def calculate_normalized_charges_and_mix(self):
comp_charge = self.calculate_multipole_moments()
self.normalize(comp_charge)
self.mix(comp_charge)
def set_mixer(self, mixer):
if mixer is not None:
if self.nspins == 1 and isinstance(mixer, MixerSum):
raise RuntimeError('Cannot use MixerSum with nspins==1')
self.mixer = mixer
else:
if self.gd.pbc_c.any():
beta = 0.05
history = 5
weight = 50.0
else:
beta = 0.25
history = 3
weight = 1.0
if self.nspins == 2:
self.mixer = MixerSum(beta, history, weight)
else:
self.mixer = Mixer(beta, history, weight)
self.mixer.initialize(self)
def estimate_magnetic_moments(self):
magmom_av = np.zeros_like(self.magmom_av)
if self.nspins == 2 or not self.collinear:
for a, D_sp in self.D_asp.items():
if self.collinear:
magmom_av[a, 2] = np.dot(D_sp[0] - D_sp[1],
self.setups[a].N0_p)
else:
magmom_av[a] = np.dot(D_sp[1:4], self.setups[a].N0_p)
self.gd.comm.sum(magmom_av)
return magmom_av
def get_correction(self, a, spin):
"""Integrated atomic density correction.
Get the integrated correction to the pseuso density relative to
the all-electron density.
"""
setup = self.setups[a]
return sqrt(4 * pi) * (
np.dot(self.D_asp[a][spin], setup.Delta_pL[:, 0])
+ setup.Delta0 / self.nspins)
def get_all_electron_density(self, atoms, gridrefinement=2):
"""Return real all-electron density array."""
# Refinement of coarse grid, for representation of the AE-density
if gridrefinement == 1:
gd = self.gd
n_sg = self.nt_sG.copy()
elif gridrefinement == 2:
gd = self.finegd
if self.nt_sg is None:
self.interpolate_pseudo_density()
n_sg = self.nt_sg.copy()
elif gridrefinement == 4:
# Extra fine grid
gd = self.finegd.refine()
# Interpolation function for the density:
interpolator = Transformer(self.finegd, gd, 3)
# Transfer the pseudo-density to the fine grid:
n_sg = gd.empty(self.nspins)
if self.nt_sg is None:
self.interpolate_pseudo_density()
for s in range(self.nspins):
interpolator.apply(self.nt_sg[s], n_sg[s])
else:
raise NotImplementedError
# Add corrections to pseudo-density to get the AE-density
splines = {}
phi_aj = []
phit_aj = []
nc_a = []
nct_a = []
for a, id in enumerate(self.setups.id_a):
if id in splines:
phi_j, phit_j, nc, nct = splines[id]
else:
# Load splines:
phi_j, phit_j, nc, nct = self.setups[a].get_partial_waves()[:4]
splines[id] = (phi_j, phit_j, nc, nct)
phi_aj.append(phi_j)
phit_aj.append(phit_j)
nc_a.append([nc])
nct_a.append([nct])
# Create localized functions from splines
phi = BasisFunctions(gd, phi_aj)
phit = BasisFunctions(gd, phit_aj)
nc = LFC(gd, nc_a)
nct = LFC(gd, nct_a)
spos_ac = atoms.get_scaled_positions() % 1.0
phi.set_positions(spos_ac)
phit.set_positions(spos_ac)
nc.set_positions(spos_ac)
nct.set_positions(spos_ac)
I_sa = np.zeros((self.nspins, len(atoms)))
a_W = np.empty(len(phi.M_W), np.intc)
W = 0
for a in phi.atom_indices:
nw = len(phi.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
x_W = phi.create_displacement_arrays()[0]
rho_MM = np.zeros((phi.Mmax, phi.Mmax))
for s, I_a in enumerate(I_sa):
M1 = 0
for a, setup in enumerate(self.setups):
ni = setup.ni
D_sp = self.D_asp.get(a)
if D_sp is None:
D_sp = np.empty((self.nspins, ni * (ni + 1) // 2))
else:
I_a[a] = ((setup.Nct - setup.Nc) / self.nspins -
sqrt(4 * pi) *
np.dot(D_sp[s], setup.Delta_pL[:, 0]))
if gd.comm.size > 1:
gd.comm.broadcast(D_sp, self.rank_a[a])
M2 = M1 + ni
rho_MM[M1:M2, M1:M2] = unpack2(D_sp[s])
M1 = M2
phi.lfc.ae_valence_density_correction(rho_MM, n_sg[s], a_W, I_a,
x_W)
phit.lfc.ae_valence_density_correction(-rho_MM, n_sg[s], a_W, I_a,
x_W)
a_W = np.empty(len(nc.M_W), np.intc)
W = 0
for a in nc.atom_indices:
nw = len(nc.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
scale = 1.0 / self.nspins
for s, I_a in enumerate(I_sa):
nc.lfc.ae_core_density_correction(scale, n_sg[s], a_W, I_a)
nct.lfc.ae_core_density_correction(-scale, n_sg[s], a_W, I_a)
gd.comm.sum(I_a)
N_c = gd.N_c
g_ac = np.around(N_c * spos_ac).astype(int) % N_c - gd.beg_c
for I, g_c in zip(I_a, g_ac):
if (g_c >= 0).all() and (g_c < gd.n_c).all():
n_sg[s][tuple(g_c)] -= I / gd.dv
return n_sg, gd
def estimate_memory(self, mem):
nspins = self.nspins
nbytes = self.gd.bytecount()
nfinebytes = self.finegd.bytecount()
arrays = mem.subnode('Arrays')
for name, size in [('nt_sG', nbytes * nspins),
('nt_sg', nfinebytes * nspins),
('nt_g', nfinebytes),
('rhot_g', nfinebytes),
('nct_G', nbytes)]:
arrays.subnode(name, size)
lfs = mem.subnode('Localized functions')
for name, obj in [('nct', self.nct),
('ghat', self.ghat)]:
obj.estimate_memory(lfs.subnode(name))
self.mixer.estimate_memory(mem.subnode('Mixer'), self.gd)
# TODO
# The implementation of interpolator memory use is not very
# accurate; 20 MiB vs 13 MiB estimated in one example, probably
# worse for parallel calculations.
def get_spin_contamination(self, atoms, majority_spin=0):
"""Calculate the spin contamination.
Spin contamination is defined as the integral over the
spin density difference, where it is negative (i.e. the
minority spin density is larger than the majority spin density.
"""
if majority_spin == 0:
smaj = 0
smin = 1
else:
smaj = 1
smin = 0
nt_sg, gd = self.get_all_electron_density(atoms)
dt_sg = nt_sg[smin] - nt_sg[smaj]
dt_sg = np.where(dt_sg > 0, dt_sg, 0.0)
return gd.integrate(dt_sg)
def read(self, reader, parallel, kd, bd):
if reader['version'] > 0.3:
density_error = reader['DensityError']
if density_error is not None:
self.mixer.set_charge_sloshing(density_error)
if not reader.has_array('PseudoElectronDensity'):
return
hdf5 = hasattr(reader, 'hdf5')
nt_sG = self.gd.empty(self.nspins)
if hdf5:
# Read pseudoelectron density on the coarse grid
# and broadcast on kpt_comm and band_comm:
indices = [slice(0, self.nspins)] + self.gd.get_slice()
do_read = (kd.comm.rank == 0) and (bd.comm.rank == 0)
reader.get('PseudoElectronDensity', out=nt_sG, parallel=parallel,
read=do_read, *indices) # XXX read=?
kd.comm.broadcast(nt_sG, 0)
bd.comm.broadcast(nt_sG, 0)
else:
for s in range(self.nspins):
self.gd.distribute(reader.get('PseudoElectronDensity', s),
nt_sG[s])
# Read atomic density matrices
D_asp = {}
natoms = len(self.setups)
self.rank_a = np.zeros(natoms, int)
all_D_sp = reader.get('AtomicDensityMatrices', broadcast=True)
if self.gd.comm.rank == 0:
D_asp = read_atomic_matrices(all_D_sp, self.setups)
self.initialize_directly_from_arrays(nt_sG, D_asp)
# XC functional + kinetic functional (minus the Tw contribution) to be used
xcname = '1.0_LDA_K_TF+1.0_LDA_X+1.0_LDA_C_PW'
# Fraction of Tw
lambda_coeff = 1.0
name = 'lambda_{0}'.format(lambda_coeff)
filename = 'atoms_' + name + '.dat'
f = paropen(filename, 'w')
elements = ['N']
for symbol in elements:
mixer = Mixer()
eigensolver = CG(tw_coeff=lambda_coeff)
poissonsolver = PoissonSolver()
molecule = Atoms(symbol, positions=[(c, c, c)], cell=(a, a, a))
calc = GPAW(h=h,
xc=xcname,
maxiter=240,
eigensolver=eigensolver,
mixer=mixer,
setups=name,
poissonsolver=poissonsolver)
molecule.set_calculator(calc)
setup_paths.insert(0, '../')
atoms = read_xyz('../Au102_revised.xyz')
prefix = 'Au_cluster'
L = 32.0
atoms.set_cell((L,L,L),scale_atoms=False)
atoms.center()
atoms.set_pbc(1)
r = [1, 1, 1]
atoms = atoms.repeat(r)
n = [240 * ri for ri in r]
# nbands (>=1683) is the number of bands per cluster
nbands = 3*6*6*16 # 1728
for ri in r: nbands = nbands*ri
mixer = Mixer(beta=0.1, nmaxold=5, weight=100.0)
# the next three lines decrease memory usage
es = RMM_DIIS(keep_htpsit=False)
from gpaw.hs_operators import MatrixOperator
MatrixOperator.nblocks = 16
calc = GPAW(nbands=nbands,
# uncomment next two lines to use lcao/sz
#mode='lcao',
#basis='sz',
gpts=tuple(n),
maxiter=5,
width = 0.1,
xc='LDA',
mixer=mixer,
eigensolver = es,
txt=prefix + '.txt',
results = [0.245393619863, 9.98114719239]
electrons = [6, 3]
charges = [0,1]
for symbol in elements:
xcname = '1.0_LDA_K_TF+1.0_LDA_X'
g = gen(symbol, xcname=xcname, scalarrel=False, orbital_free=True,
gpernode=75)
for element, result, e, charge in zip(elements, results, electrons, charges):
atom = Atoms(element,
positions=[(c, c, c)],
cell=(a, a, a))
mixer = Mixer(0.3, 5, 1)
calc = GPAW(gpts=(32, 32, 32),
txt='-', xc=xcname,
poissonsolver=PoissonSolver(eps=1e-6),
eigensolver='cg', mixer=mixer, charge=charge)
atom.set_calculator(calc)
E = atom.get_total_energy()
n = calc.get_all_electron_density()
dv = atom.get_volume() / calc.get_number_of_grid_points().prod()
I = n.sum() * dv / 2**3
equal(I, e, 1.0e-6)
equal(result, E, 1.0e-3)
class Density:
"""Density object.
Attributes:
=============== =====================================================
``gd`` Grid descriptor for coarse grids.
``finegd`` Grid descriptor for fine grids.
``interpolate`` Function for interpolating the electron density.
``mixer`` ``DensityMixer`` object.
=============== =====================================================
Soft and smooth pseudo functions on uniform 3D grids:
========== =========================================
``nt_sG`` Electron density on the coarse grid.
``nt_sg`` Electron density on the fine grid.
``nt_g`` Electron density on the fine grid.
``rhot_g`` Charge density on the fine grid.
``nct_G`` Core electron-density on the coarse grid.
========== =========================================
"""
def __init__(self, gd, finegd, nspins, charge, collinear=True):
"""Create the Density object."""
self.gd = gd
self.finegd = finegd
self.nspins = nspins
self.charge = float(charge)
self.collinear = collinear
self.ncomp = 1 if collinear else 2
self.ns = self.nspins * self.ncomp**2
self.charge_eps = 1e-7
self.D_asp = None
self.Q_aL = None
self.nct_G = None
self.nt_sG = None
self.rhot_g = None
self.nt_sg = None
self.nt_g = None
self.rank_a = None
self.atom_partition = None
self.mixer = BaseMixer()
self.timer = nulltimer
def initialize(self, setups, timer, magmom_av, hund):
self.timer = timer
self.setups = setups
self.hund = hund
self.magmom_av = magmom_av
def reset(self):
# TODO: reset other parameters?
self.nt_sG = None
def set_positions(self, spos_ac, rank_a):
atom_partition = AtomPartition(self.gd.comm, rank_a)
self.nct.set_positions(spos_ac)
self.ghat.set_positions(spos_ac)
self.mixer.reset()
#self.nt_sG = None
self.nt_sg = None
self.nt_g = None
self.rhot_g = None
self.Q_aL = None
# If both old and new atomic ranks are present, start a blank dict if
# it previously didn't exist but it will needed for the new atoms.
assert rank_a is not None
if (self.rank_a is not None and
self.D_asp is None and (rank_a == self.gd.comm.rank).any()):
self.D_asp = {}
if (self.rank_a is not None and self.D_asp is not None
and not isinstance(self.gd.comm, SerialCommunicator)):
self.timer.start('Redistribute')
def get_empty(a):
ni = self.setups[a].ni
return np.empty((self.ns, ni * (ni + 1) // 2))
self.atom_partition.redistribute(atom_partition, self.D_asp,
get_empty)
self.timer.stop('Redistribute')
self.rank_a = rank_a
self.atom_partition = atom_partition
def calculate_pseudo_density(self, wfs):
"""Calculate nt_sG from scratch.
nt_sG will be equal to nct_G plus the contribution from
wfs.add_to_density().
"""
wfs.calculate_density_contribution(self.nt_sG)
self.nt_sG[:self.nspins] += self.nct_G
def update(self, wfs):
self.timer.start('Density')
self.timer.start('Pseudo density')
self.calculate_pseudo_density(wfs)
self.timer.stop('Pseudo density')
self.timer.start('Atomic density matrices')
wfs.calculate_atomic_density_matrices(self.D_asp)
self.timer.stop('Atomic density matrices')
self.timer.start('Multipole moments')
comp_charge = self.calculate_multipole_moments()
self.timer.stop('Multipole moments')
if isinstance(wfs, LCAOWaveFunctions):
self.timer.start('Normalize')
self.normalize(comp_charge)
self.timer.stop('Normalize')
self.timer.start('Mix')
self.mix(comp_charge)
self.timer.stop('Mix')
self.timer.stop('Density')
def normalize(self, comp_charge=None):
"""Normalize pseudo density."""
if comp_charge is None:
comp_charge = self.calculate_multipole_moments()
pseudo_charge = self.gd.integrate(self.nt_sG[:self.nspins]).sum()
if pseudo_charge + self.charge + comp_charge != 0:
if pseudo_charge != 0:
x = -(self.charge + comp_charge) / pseudo_charge
self.nt_sG *= x
else:
# Use homogeneous background:
volume = self.gd.get_size_of_global_array().prod() * self.gd.dv
self.nt_sG[:self.nspins] = -(self.charge +
comp_charge) / volume
def mix(self, comp_charge):
if not self.mixer.mix_rho:
self.mixer.mix(self)
comp_charge = None
self.interpolate_pseudo_density(comp_charge)
self.calculate_pseudo_charge()
if self.mixer.mix_rho:
self.mixer.mix(self)
def calculate_multipole_moments(self):
"""Calculate multipole moments of compensation charges.
Returns the total compensation charge in units of electron
charge, so the number will be negative because of the
dominating contribution from the nuclear charge."""
comp_charge = 0.0
self.Q_aL = {}
for a, D_sp in self.D_asp.items():
Q_L = self.Q_aL[a] = np.dot(D_sp[:self.nspins].sum(0),
self.setups[a].Delta_pL)
Q_L[0] += self.setups[a].Delta0
comp_charge += Q_L[0]
return self.gd.comm.sum(comp_charge) * sqrt(4 * pi)
def initialize_from_atomic_densities(self, basis_functions):
"""Initialize D_asp, nt_sG and Q_aL from atomic densities.
nt_sG is initialized from atomic orbitals, and will
be constructed with the specified magnetic moments and
obeying Hund's rules if ``hund`` is true."""
# XXX does this work with blacs? What should be distributed?
# Apparently this doesn't use blacs at all, so it's serial
# with respect to the blacs distribution. That means it works
# but is not particularly efficient (not that this is a time
# consuming step)
self.D_asp = {}
f_asi = {}
for a in basis_functions.atom_indices:
c = self.charge / len(self.setups) # distribute on all atoms
M_v = self.magmom_av[a]
M = (M_v**2).sum()**0.5
f_si = self.setups[a].calculate_initial_occupation_numbers(
M, self.hund, charge=c, nspins=self.nspins * self.ncomp)
if self.collinear:
if M_v[2] < 0:
f_si = f_si[::-1].copy()
else:
f_i = f_si.sum(axis=0)
fm_i = f_si[0] - f_si[1]
f_si = np.zeros((4, len(f_i)))
f_si[0] = f_i
if M > 0:
f_si[1:4] = np.outer(M_v / M, fm_i)
if a in basis_functions.my_atom_indices:
self.D_asp[a] = self.setups[a].initialize_density_matrix(f_si)
f_asi[a] = f_si
self.nt_sG = self.gd.zeros(self.ns)
basis_functions.add_to_density(self.nt_sG, f_asi)
self.nt_sG[:self.nspins] += self.nct_G
self.calculate_normalized_charges_and_mix()
def initialize_from_wavefunctions(self, wfs):
"""Initialize D_asp, nt_sG and Q_aL from wave functions."""
self.timer.start("Density initialize from wavefunctions")
self.nt_sG = self.gd.empty(self.ns)
self.calculate_pseudo_density(wfs)
self.D_asp = {}
my_atom_indices = np.argwhere(wfs.rank_a == self.gd.comm.rank).ravel()
for a in my_atom_indices:
ni = self.setups[a].ni
self.D_asp[a] = np.empty((self.nspins, ni * (ni + 1) // 2))
wfs.calculate_atomic_density_matrices(self.D_asp)
self.calculate_normalized_charges_and_mix()
self.timer.stop("Density initialize from wavefunctions")
def initialize_directly_from_arrays(self, nt_sG, D_asp):
"""Set D_asp and nt_sG directly."""
self.nt_sG = nt_sG
self.D_asp = D_asp
#self.calculate_normalized_charges_and_mix()
# No calculate multipole moments? Tests will fail because of
# improperly initialized mixer
def calculate_normalized_charges_and_mix(self):
comp_charge = self.calculate_multipole_moments()
self.normalize(comp_charge)
self.mix(comp_charge)
def set_mixer(self, mixer):
if mixer is not None:
if self.nspins == 1 and isinstance(mixer, MixerSum):
raise RuntimeError('Cannot use MixerSum with nspins==1')
self.mixer = mixer
else:
if self.gd.pbc_c.any():
beta = 0.05
history = 5
weight = 50.0
else:
beta = 0.25
history = 3
weight = 1.0
if self.nspins == 2:
self.mixer = MixerSum(beta, history, weight)
else:
self.mixer = Mixer(beta, history, weight)
self.mixer.initialize(self)
def estimate_magnetic_moments(self):
magmom_av = np.zeros_like(self.magmom_av)
if self.nspins == 2 or not self.collinear:
for a, D_sp in self.D_asp.items():
if self.collinear:
magmom_av[a, 2] = np.dot(D_sp[0] - D_sp[1],
self.setups[a].N0_p)
else:
magmom_av[a] = np.dot(D_sp[1:4], self.setups[a].N0_p)
self.gd.comm.sum(magmom_av)
return magmom_av
def get_correction(self, a, spin):
"""Integrated atomic density correction.
Get the integrated correction to the pseuso density relative to
the all-electron density.
"""
setup = self.setups[a]
return sqrt(4 * pi) * (
np.dot(self.D_asp[a][spin], setup.Delta_pL[:, 0])
+ setup.Delta0 / self.nspins)
def get_all_electron_density(self, atoms=None, gridrefinement=2, spos_ac=None):
"""Return real all-electron density array.
Usage: Either get_all_electron_density(atoms) or
get_all_electron_density(spos_ac=spos_ac) """
if spos_ac is None:
spos_ac = atoms.get_scaled_positions() % 1.0
# Refinement of coarse grid, for representation of the AE-density
if gridrefinement == 1:
gd = self.gd
n_sg = self.nt_sG.copy()
elif gridrefinement == 2:
gd = self.finegd
if self.nt_sg is None:
self.interpolate_pseudo_density()
n_sg = self.nt_sg.copy()
elif gridrefinement == 4:
# Extra fine grid
gd = self.finegd.refine()
# Interpolation function for the density:
interpolator = Transformer(self.finegd, gd, 3)
# Transfer the pseudo-density to the fine grid:
n_sg = gd.empty(self.nspins)
if self.nt_sg is None:
self.interpolate_pseudo_density()
for s in range(self.nspins):
interpolator.apply(self.nt_sg[s], n_sg[s])
else:
raise NotImplementedError
# Add corrections to pseudo-density to get the AE-density
splines = {}
phi_aj = []
phit_aj = []
nc_a = []
nct_a = []
for a, id in enumerate(self.setups.id_a):
if id in splines:
phi_j, phit_j, nc, nct = splines[id]
else:
# Load splines:
phi_j, phit_j, nc, nct = self.setups[a].get_partial_waves()[:4]
splines[id] = (phi_j, phit_j, nc, nct)
phi_aj.append(phi_j)
phit_aj.append(phit_j)
nc_a.append([nc])
nct_a.append([nct])
# Create localized functions from splines
phi = BasisFunctions(gd, phi_aj)
phit = BasisFunctions(gd, phit_aj)
nc = LFC(gd, nc_a)
nct = LFC(gd, nct_a)
phi.set_positions(spos_ac)
phit.set_positions(spos_ac)
nc.set_positions(spos_ac)
nct.set_positions(spos_ac)
I_sa = np.zeros((self.nspins, len(spos_ac)))
a_W = np.empty(len(phi.M_W), np.intc)
W = 0
for a in phi.atom_indices:
nw = len(phi.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
x_W = phi.create_displacement_arrays()[0]
rho_MM = np.zeros((phi.Mmax, phi.Mmax))
for s, I_a in enumerate(I_sa):
M1 = 0
for a, setup in enumerate(self.setups):
ni = setup.ni
D_sp = self.D_asp.get(a)
if D_sp is None:
D_sp = np.empty((self.nspins, ni * (ni + 1) // 2))
else:
I_a[a] = ((setup.Nct - setup.Nc) / self.nspins -
sqrt(4 * pi) *
np.dot(D_sp[s], setup.Delta_pL[:, 0]))
if gd.comm.size > 1:
gd.comm.broadcast(D_sp, self.rank_a[a])
M2 = M1 + ni
rho_MM[M1:M2, M1:M2] = unpack2(D_sp[s])
M1 = M2
phi.lfc.ae_valence_density_correction(rho_MM, n_sg[s], a_W, I_a,
x_W)
phit.lfc.ae_valence_density_correction(-rho_MM, n_sg[s], a_W, I_a,
x_W)
a_W = np.empty(len(nc.M_W), np.intc)
W = 0
for a in nc.atom_indices:
nw = len(nc.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
scale = 1.0 / self.nspins
for s, I_a in enumerate(I_sa):
nc.lfc.ae_core_density_correction(scale, n_sg[s], a_W, I_a)
nct.lfc.ae_core_density_correction(-scale, n_sg[s], a_W, I_a)
gd.comm.sum(I_a)
N_c = gd.N_c
g_ac = np.around(N_c * spos_ac).astype(int) % N_c - gd.beg_c
for I, g_c in zip(I_a, g_ac):
if (g_c >= 0).all() and (g_c < gd.n_c).all():
n_sg[s][tuple(g_c)] -= I / gd.dv
return n_sg, gd
def estimate_memory(self, mem):
nspins = self.nspins
nbytes = self.gd.bytecount()
nfinebytes = self.finegd.bytecount()
arrays = mem.subnode('Arrays')
for name, size in [('nt_sG', nbytes * nspins),
('nt_sg', nfinebytes * nspins),
('nt_g', nfinebytes),
('rhot_g', nfinebytes),
('nct_G', nbytes)]:
arrays.subnode(name, size)
lfs = mem.subnode('Localized functions')
for name, obj in [('nct', self.nct),
('ghat', self.ghat)]:
obj.estimate_memory(lfs.subnode(name))
self.mixer.estimate_memory(mem.subnode('Mixer'), self.gd)
# TODO
# The implementation of interpolator memory use is not very
# accurate; 20 MiB vs 13 MiB estimated in one example, probably
# worse for parallel calculations.
def get_spin_contamination(self, atoms, majority_spin=0):
"""Calculate the spin contamination.
Spin contamination is defined as the integral over the
spin density difference, where it is negative (i.e. the
minority spin density is larger than the majority spin density.
"""
if majority_spin == 0:
smaj = 0
smin = 1
else:
smaj = 1
smin = 0
nt_sg, gd = self.get_all_electron_density(atoms)
dt_sg = nt_sg[smin] - nt_sg[smaj]
dt_sg = np.where(dt_sg > 0, dt_sg, 0.0)
return gd.integrate(dt_sg)
def read(self, reader, parallel, kptband_comm):
if reader['version'] > 0.3:
density_error = reader['DensityError']
if density_error is not None:
self.mixer.set_charge_sloshing(density_error)
if not reader.has_array('PseudoElectronDensity'):
return
hdf5 = hasattr(reader, 'hdf5')
nt_sG = self.gd.empty(self.nspins)
if hdf5:
# Read pseudoelectron density on the coarse grid
# and broadcast on kpt_comm and band_comm:
indices = [slice(0, self.nspins)] + self.gd.get_slice()
do_read = (kptband_comm.rank == 0)
reader.get('PseudoElectronDensity', out=nt_sG, parallel=parallel,
read=do_read, *indices) # XXX read=?
kptband_comm.broadcast(nt_sG, 0)
else:
for s in range(self.nspins):
self.gd.distribute(reader.get('PseudoElectronDensity', s),
nt_sG[s])
# Read atomic density matrices
D_asp = {}
natoms = len(self.setups)
self.rank_a = np.zeros(natoms, int)
all_D_sp = reader.get('AtomicDensityMatrices', broadcast=True)
if self.gd.comm.rank == 0:
D_asp = read_atomic_matrices(all_D_sp, self.setups)
self.initialize_directly_from_arrays(nt_sG, D_asp)
class Density:
"""Density object.
Attributes:
=============== =====================================================
``gd`` Grid descriptor for coarse grids.
``finegd`` Grid descriptor for fine grids.
``interpolate`` Function for interpolating the electron density.
``mixer`` ``DensityMixer`` object.
=============== =====================================================
Soft and smooth pseudo functions on uniform 3D grids:
========== =========================================
``nt_sG`` Electron density on the coarse grid.
``nt_sg`` Electron density on the fine grid.
``nt_g`` Electron density on the fine grid.
``rhot_g`` Charge density on the fine grid.
``nct_G`` Core electron-density on the coarse grid.
========== =========================================
"""
def __init__(self, gd, finegd, nspins, charge):
"""Create the Density object."""
self.gd = gd
self.finegd = finegd
self.nspins = nspins
self.charge = float(charge)
self.charge_eps = 1e-7
self.D_asp = None
self.Q_aL = None
self.nct_G = None
self.nt_sG = None
self.rhot_g = None
self.nt_sg = None
self.nt_g = None
self.rank_a = None
self.mixer = BaseMixer()
self.timer = nulltimer
self.allocated = False
def initialize(self, setups, stencil, timer, magmom_a, hund):
self.timer = timer
self.setups = setups
self.hund = hund
self.magmom_a = magmom_a
# Interpolation function for the density:
self.interpolator = Transformer(self.gd, self.finegd, stencil,
allocate=False)
spline_aj = []
for setup in setups:
if setup.nct is None:
spline_aj.append([])
else:
spline_aj.append([setup.nct])
self.nct = LFC(self.gd, spline_aj,
integral=[setup.Nct for setup in setups],
forces=True, cut=True)
self.ghat = LFC(self.finegd, [setup.ghat_l for setup in setups],
integral=sqrt(4 * pi), forces=True)
if self.allocated:
self.allocated = False
self.allocate()
def allocate(self):
assert not self.allocated
self.interpolator.allocate()
self.allocated = True
def reset(self):
# TODO: reset other parameters?
self.nt_sG = None
def set_positions(self, spos_ac, rank_a=None):
if not self.allocated:
self.allocate()
self.nct.set_positions(spos_ac)
self.ghat.set_positions(spos_ac)
self.mixer.reset()
self.nct_G = self.gd.zeros()
self.nct.add(self.nct_G, 1.0 / self.nspins)
#self.nt_sG = None
self.nt_sg = None
self.nt_g = None
self.rhot_g = None
self.Q_aL = None
# If both old and new atomic ranks are present, start a blank dict if
# it previously didn't exist but it will needed for the new atoms.
if (self.rank_a is not None and rank_a is not None and
self.D_asp is None and (rank_a == self.gd.comm.rank).any()):
self.D_asp = {}
if self.rank_a is not None and self.D_asp is not None:
self.timer.start('Redistribute')
requests = []
flags = (self.rank_a != rank_a)
my_incoming_atom_indices = np.argwhere(np.bitwise_and(flags, \
rank_a == self.gd.comm.rank)).ravel()
my_outgoing_atom_indices = np.argwhere(np.bitwise_and(flags, \
self.rank_a == self.gd.comm.rank)).ravel()
for a in my_incoming_atom_indices:
# Get matrix from old domain:
ni = self.setups[a].ni
D_sp = np.empty((self.nspins, ni * (ni + 1) // 2))
requests.append(self.gd.comm.receive(D_sp, self.rank_a[a],
tag=a, block=False))
assert a not in self.D_asp
self.D_asp[a] = D_sp
for a in my_outgoing_atom_indices:
# Send matrix to new domain:
D_sp = self.D_asp.pop(a)
requests.append(self.gd.comm.send(D_sp, rank_a[a],
tag=a, block=False))
self.gd.comm.waitall(requests)
self.timer.stop('Redistribute')
self.rank_a = rank_a
def calculate_pseudo_density(self, wfs):
"""Calculate nt_sG from scratch.
nt_sG will be equal to nct_G plus the contribution from
wfs.add_to_density().
"""
wfs.calculate_density_contribution(self.nt_sG)
self.nt_sG += self.nct_G
def update(self, wfs):
self.timer.start('Density')
self.timer.start('Pseudo density')
self.calculate_pseudo_density(wfs)
self.timer.stop('Pseudo density')
self.timer.start('Atomic density matrices')
wfs.calculate_atomic_density_matrices(self.D_asp)
self.timer.stop('Atomic density matrices')
self.timer.start('Multipole moments')
comp_charge = self.calculate_multipole_moments()
self.timer.stop('Multipole moments')
if isinstance(wfs, LCAOWaveFunctions):
self.timer.start('Normalize')
self.normalize(comp_charge)
self.timer.stop('Normalize')
self.timer.start('Mix')
self.mix(comp_charge)
self.timer.stop('Mix')
self.timer.stop('Density')
def normalize(self, comp_charge=None):
"""Normalize pseudo density."""
if comp_charge is None:
comp_charge = self.calculate_multipole_moments()
pseudo_charge = self.gd.integrate(self.nt_sG).sum()
if pseudo_charge + self.charge + comp_charge != 0:
if pseudo_charge != 0:
x = -(self.charge + comp_charge) / pseudo_charge
self.nt_sG *= x
else:
# Use homogeneous background:
self.nt_sG[:] = (self.charge + comp_charge) * self.gd.dv
def calculate_pseudo_charge(self, comp_charge):
self.nt_g = self.nt_sg.sum(axis=0)
self.rhot_g = self.nt_g.copy()
self.ghat.add(self.rhot_g, self.Q_aL)
if debug:
charge = self.finegd.integrate(self.rhot_g) + self.charge
if abs(charge) > self.charge_eps:
raise RuntimeError('Charge not conserved: excess=%.9f' %
charge)
def mix(self, comp_charge):
if not self.mixer.mix_rho:
self.mixer.mix(self)
comp_charge = None
self.interpolate(comp_charge)
self.calculate_pseudo_charge(comp_charge)
if self.mixer.mix_rho:
self.mixer.mix(self)
def interpolate(self, comp_charge=None):
"""Interpolate pseudo density to fine grid."""
if comp_charge is None:
comp_charge = self.calculate_multipole_moments()
if self.nt_sg is None:
self.nt_sg = self.finegd.empty(self.nspins)
for s in range(self.nspins):
self.interpolator.apply(self.nt_sG[s], self.nt_sg[s])
# With periodic boundary conditions, the interpolation will
# conserve the number of electrons.
if not self.gd.pbc_c.all():
# With zero-boundary conditions in one or more directions,
# this is not the case.
pseudo_charge = -(self.charge + comp_charge)
if abs(pseudo_charge) > 1.0e-14:
x = pseudo_charge / self.finegd.integrate(self.nt_sg).sum()
self.nt_sg *= x
def calculate_multipole_moments(self):
"""Calculate multipole moments of compensation charges.
Returns the total compensation charge in units of electron
charge, so the number will be negative because of the
dominating contribution from the nuclear charge."""
comp_charge = 0.0
self.Q_aL = {}
for a, D_sp in self.D_asp.items():
Q_L = self.Q_aL[a] = np.dot(D_sp.sum(0), self.setups[a].Delta_pL)
Q_L[0] += self.setups[a].Delta0
comp_charge += Q_L[0]
return self.gd.comm.sum(comp_charge) * sqrt(4 * pi)
def initialize_from_atomic_densities(self, basis_functions):
"""Initialize D_asp, nt_sG and Q_aL from atomic densities.
nt_sG is initialized from atomic orbitals, and will
be constructed with the specified magnetic moments and
obeying Hund's rules if ``hund`` is true."""
# XXX does this work with blacs? What should be distributed?
# Apparently this doesn't use blacs at all, so it's serial
# with respect to the blacs distribution. That means it works
# but is not particularly efficient (not that this is a time
# consuming step)
f_sM = np.empty((self.nspins, basis_functions.Mmax))
self.D_asp = {}
f_asi = {}
for a in basis_functions.atom_indices:
c = self.charge / len(self.setups) # distribute on all atoms
f_si = self.setups[a].calculate_initial_occupation_numbers(
self.magmom_a[a], self.hund, charge=c, nspins=self.nspins)
if a in basis_functions.my_atom_indices:
self.D_asp[a] = self.setups[a].initialize_density_matrix(f_si)
f_asi[a] = f_si
self.nt_sG = self.gd.zeros(self.nspins)
basis_functions.add_to_density(self.nt_sG, f_asi)
self.nt_sG += self.nct_G
self.calculate_normalized_charges_and_mix()
def initialize_from_wavefunctions(self, wfs):
"""Initialize D_asp, nt_sG and Q_aL from wave functions."""
self.nt_sG = self.gd.empty(self.nspins)
self.calculate_pseudo_density(wfs)
self.D_asp = {}
my_atom_indices = np.argwhere(wfs.rank_a == self.gd.comm.rank).ravel()
for a in my_atom_indices:
ni = self.setups[a].ni
self.D_asp[a] = np.empty((self.nspins, ni * (ni + 1) // 2))
wfs.calculate_atomic_density_matrices(self.D_asp)
self.calculate_normalized_charges_and_mix()
def initialize_directly_from_arrays(self, nt_sG, D_asp):
"""Set D_asp and nt_sG directly."""
self.nt_sG = nt_sG
self.D_asp = D_asp
#self.calculate_normalized_charges_and_mix()
# No calculate multipole moments? Tests will fail because of
# improperly initialized mixer
def calculate_normalized_charges_and_mix(self):
comp_charge = self.calculate_multipole_moments()
self.normalize(comp_charge)
self.mix(comp_charge)
def set_mixer(self, mixer):
if mixer is not None:
if self.nspins == 1 and isinstance(mixer, MixerSum):
raise RuntimeError('Cannot use MixerSum with nspins==1')
self.mixer = mixer
else:
if self.gd.pbc_c.any():
beta = 0.1
weight = 50.0
else:
beta = 0.25
weight = 1.0
if self.nspins == 2:
self.mixer = MixerSum(beta=beta, weight=weight)
else:
self.mixer = Mixer(beta=beta, weight=weight)
self.mixer.initialize(self)
def estimate_magnetic_moments(self):
magmom_a = np.zeros_like(self.magmom_a)
if self.nspins == 2:
for a, D_sp in self.D_asp.items():
magmom_a[a] = np.dot(D_sp[0] - D_sp[1], self.setups[a].N0_p)
self.gd.comm.sum(magmom_a)
return magmom_a
def get_correction(self, a, spin):
"""Integrated atomic density correction.
Get the integrated correction to the pseuso density relative to
the all-electron density.
"""
setup = self.setups[a]
return sqrt(4 * pi) * (
np.dot(self.D_asp[a][spin], setup.Delta_pL[:, 0])
+ setup.Delta0 / self.nspins)
def get_density_array(self):
XXX
# XXX why not replace with get_spin_density and get_total_density?
"""Return pseudo-density array."""
if self.nspins == 2:
return self.nt_sG
else:
return self.nt_sG[0]
def get_all_electron_density(self, atoms, gridrefinement=2):
"""Return real all-electron density array."""
# Refinement of coarse grid, for representation of the AE-density
if gridrefinement == 1:
gd = self.gd
n_sg = self.nt_sG.copy()
elif gridrefinement == 2:
gd = self.finegd
if self.nt_sg is None:
self.interpolate()
n_sg = self.nt_sg.copy()
elif gridrefinement == 4:
# Extra fine grid
gd = self.finegd.refine()
# Interpolation function for the density:
interpolator = Transformer(self.finegd, gd, 3)
# Transfer the pseudo-density to the fine grid:
n_sg = gd.empty(self.nspins)
if self.nt_sg is None:
self.interpolate()
for s in range(self.nspins):
interpolator.apply(self.nt_sg[s], n_sg[s])
else:
raise NotImplementedError
# Add corrections to pseudo-density to get the AE-density
splines = {}
phi_aj = []
phit_aj = []
nc_a = []
nct_a = []
for a, id in enumerate(self.setups.id_a):
if id in splines:
phi_j, phit_j, nc, nct = splines[id]
else:
# Load splines:
phi_j, phit_j, nc, nct = self.setups[a].get_partial_waves()[:4]
splines[id] = (phi_j, phit_j, nc, nct)
phi_aj.append(phi_j)
phit_aj.append(phit_j)
nc_a.append([nc])
nct_a.append([nct])
# Create localized functions from splines
phi = LFC(gd, phi_aj)
phit = LFC(gd, phit_aj)
nc = LFC(gd, nc_a)
nct = LFC(gd, nct_a)
spos_ac = atoms.get_scaled_positions() % 1.0
phi.set_positions(spos_ac)
phit.set_positions(spos_ac)
nc.set_positions(spos_ac)
nct.set_positions(spos_ac)
all_D_asp = []
for a, setup in enumerate(self.setups):
D_sp = self.D_asp.get(a)
if D_sp is None:
ni = setup.ni
D_sp = np.empty((self.nspins, ni * (ni + 1) // 2))
if gd.comm.size > 1:
gd.comm.broadcast(D_sp, self.rank_a[a])
all_D_asp.append(D_sp)
for s in range(self.nspins):
I_a = np.zeros(len(atoms))
nc.add1(n_sg[s], 1.0 / self.nspins, I_a)
nct.add1(n_sg[s], -1.0 / self.nspins, I_a)
phi.add2(n_sg[s], all_D_asp, s, 1.0, I_a)
phit.add2(n_sg[s], all_D_asp, s, -1.0, I_a)
for a, D_sp in self.D_asp.items():
setup = self.setups[a]
I_a[a] -= ((setup.Nc - setup.Nct) / self.nspins +
sqrt(4 * pi) *
np.dot(D_sp[s], setup.Delta_pL[:, 0]))
gd.comm.sum(I_a)
N_c = gd.N_c
g_ac = np.around(N_c * spos_ac).astype(int) % N_c - gd.beg_c
for I, g_c in zip(I_a, g_ac):
if (g_c >= 0).all() and (g_c < gd.n_c).all():
n_sg[s][tuple(g_c)] -= I / gd.dv
return n_sg, gd
def new_get_all_electron_density(self, atoms, gridrefinement=2):
"""Return real all-electron density array."""
# Refinement of coarse grid, for representation of the AE-density
if gridrefinement == 1:
gd = self.gd
n_sg = self.nt_sG.copy()
elif gridrefinement == 2:
gd = self.finegd
if self.nt_sg is None:
self.interpolate()
n_sg = self.nt_sg.copy()
elif gridrefinement == 4:
# Extra fine grid
gd = self.finegd.refine()
# Interpolation function for the density:
interpolator = Transformer(self.finegd, gd, 3)
# Transfer the pseudo-density to the fine grid:
n_sg = gd.empty(self.nspins)
if self.nt_sg is None:
self.interpolate()
for s in range(self.nspins):
interpolator.apply(self.nt_sg[s], n_sg[s])
else:
raise NotImplementedError
# Add corrections to pseudo-density to get the AE-density
splines = {}
phi_aj = []
phit_aj = []
nc_a = []
nct_a = []
for a, id in enumerate(self.setups.id_a):
if id in splines:
phi_j, phit_j, nc, nct = splines[id]
else:
# Load splines:
phi_j, phit_j, nc, nct = self.setups[a].get_partial_waves()[:4]
splines[id] = (phi_j, phit_j, nc, nct)
phi_aj.append(phi_j)
phit_aj.append(phit_j)
nc_a.append([nc])
nct_a.append([nct])
# Create localized functions from splines
phi = BasisFunctions(gd, phi_aj)
phit = BasisFunctions(gd, phit_aj)
nc = LFC(gd, nc_a)
nct = LFC(gd, nct_a)
spos_ac = atoms.get_scaled_positions() % 1.0
phi.set_positions(spos_ac)
phit.set_positions(spos_ac)
nc.set_positions(spos_ac)
nct.set_positions(spos_ac)
I_sa = np.zeros((self.nspins, len(atoms)))
a_W = np.empty(len(phi.M_W), np.int32)
W = 0
for a in phi.atom_indices:
nw = len(phi.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
rho_MM = np.zeros((phi.Mmax, phi.Mmax))
for s, I_a in enumerate(I_sa):
M1 = 0
for a, setup in enumerate(self.setups):
ni = setup.ni
D_sp = self.D_asp.get(a)
if D_sp is None:
D_sp = np.empty((self.nspins, ni * (ni + 1) // 2))
else:
I_a[a] = ((setup.Nct - setup.Nc) / self.nspins -
sqrt(4 * pi) *
np.dot(D_sp[s], setup.Delta_pL[:, 0]))
if gd.comm.size > 1:
gd.comm.broadcast(D_sp, self.rank_a[a])
M2 = M1 + ni
rho_MM[M1:M2, M1:M2] = unpack2(D_sp[s])
M1 = M2
phi.lfc.ae_valence_density_correction(rho_MM, n_sg[s], a_W, I_a)
phit.lfc.ae_valence_density_correction(-rho_MM, n_sg[s], a_W, I_a)
a_W = np.empty(len(nc.M_W), np.int32)
W = 0
for a in nc.atom_indices:
nw = len(nc.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
scale = 1.0 / self.nspins
for s, I_a in enumerate(I_sa):
nc.lfc.ae_core_density_correction(scale, n_sg[s], a_W, I_a)
nct.lfc.ae_core_density_correction(-scale, n_sg[s], a_W, I_a)
gd.comm.sum(I_a)
N_c = gd.N_c
g_ac = np.around(N_c * spos_ac).astype(int) % N_c - gd.beg_c
for I, g_c in zip(I_a, g_ac):
if (g_c >= 0).all() and (g_c < gd.n_c).all():
n_sg[s][tuple(g_c)] -= I / gd.dv
return n_sg, gd
if extra_parameters.get('usenewlfc', True):
get_all_electron_density = new_get_all_electron_density
def estimate_memory(self, mem):
nspins = self.nspins
nbytes = self.gd.bytecount()
nfinebytes = self.finegd.bytecount()
arrays = mem.subnode('Arrays')
for name, size in [('nt_sG', nbytes * nspins),
('nt_sg', nfinebytes * nspins),
('nt_g', nfinebytes),
('rhot_g', nfinebytes),
('nct_G', nbytes)]:
arrays.subnode(name, size)
lfs = mem.subnode('Localized functions')
for name, obj in [('nct', self.nct),
('ghat', self.ghat)]:
obj.estimate_memory(lfs.subnode(name))
self.mixer.estimate_memory(mem.subnode('Mixer'), self.gd)
# TODO
# The implementation of interpolator memory use is not very
# accurate; 20 MiB vs 13 MiB estimated in one example, probably
# worse for parallel calculations.
self.interpolator.estimate_memory(mem.subnode('Interpolator'))
def get_spin_contamination(self, atoms, majority_spin=0):
"""Calculate the spin contamination.
Spin contamination is defined as the integral over the
spin density difference, where it is negative (i.e. the
minority spin density is larger than the majority spin density.
"""
if majority_spin == 0:
smaj = 0
smin = 1
else:
smaj = 1
smin = 0
nt_sg, gd = self.get_all_electron_density(atoms)
dt_sg = nt_sg[smin] - nt_sg[smaj]
dt_sg = np.where(dt_sg > 0, dt_sg, 0.0)
return gd.integrate(dt_sg)
calc = GPAW(mode=PW(),
xc='PBE',
kpts=kpts,
parallel={'band': 1},
eigensolver='cg',
txt='na2o4.txt')
bulk.set_calculator(calc)
try:
bulk.get_potential_energy()
except ConvergenceError:
pass
assert not calc.scf.converged
del bulk.calc
calc1 = GPAW(mode=PW(),
xc='PBE',
kpts=kpts,
parallel={'band': 1},
eigensolver='cg',
txt='na2o4.txt')
calc1.set(mixer=Mixer(0.10, 2))
calc1.set(txt='na2o4_m1.txt')
bulk.set_calculator(calc1)
bulk.get_potential_energy()
from gpaw import GPAW
from gpaw.mixer import Mixer
from gpaw.test import equal
from gpaw.test import gen
symbol = 'C'
result = -224.200276535
electrons = 48
xcname = 'LDA_K_TF+LDA_X'
g = gen(symbol, xcname=xcname, scalarrel=False, orbital_free=True)
h = 0.14
a = 2.8
atoms = bulk(symbol, 'diamond', a=a, cubic=True) # Generate diamond
mixer = Mixer(0.1, 5)
calc = GPAW(h=h,
xc=xcname,
maxiter=120,
eigensolver = 'cg',
mixer=mixer)
atoms.set_calculator(calc)
e = atoms.get_potential_energy()
n = calc.get_all_electron_density()
dv = atoms.get_volume() / calc.get_number_of_grid_points().prod()
def read(self, reader):
"""Read state from file."""
r = reader
version = r['version']
assert version >= 0.3
self.xc = r['XCFunctional']
self.nbands = r.dimension('nbands')
self.spinpol = (r.dimension('nspins') == 2)
bzk_kc = r.get('BZKPoints', broadcast=True)
if r.has_array('NBZKPoints'):
self.kpts = r.get('NBZKPoints', broadcast=True)
if r.has_array('MonkhorstPackOffset'):
offset_c = r.get('MonkhorstPackOffset', broadcast=True)
if offset_c.any():
self.kpts = monkhorst_pack(self.kpts) + offset_c
else:
self.kpts = bzk_kc
if version < 4:
self.symmetry = usesymm2symmetry(r['UseSymmetry'])
else:
self.symmetry = {'point_group': r['SymmetryOnSwitch'],
'symmorphic': r['SymmetrySymmorphicSwitch'],
'time_reversal': r['SymmetryTimeReversalSwitch'],
'tolerance': r['SymmetryToleranceCriterion']}
try:
self.basis = r['BasisSet']
except KeyError:
pass
if version >= 2:
try:
h = r['GridSpacing']
except KeyError: # CMR can't handle None!
h = None
if h is not None:
self.h = Bohr * h
if r.has_array('GridPoints'):
self.gpts = r.get('GridPoints')
else:
if version >= 0.9:
h = r['GridSpacing']
else:
h = None
gpts = ((r.dimension('ngptsx') + 1) // 2 * 2,
(r.dimension('ngptsy') + 1) // 2 * 2,
(r.dimension('ngptsz') + 1) // 2 * 2)
if h is None:
self.gpts = gpts
else:
self.h = Bohr * h
self.lmax = r['MaximumAngularMomentum']
self.setups = r['SetupTypes']
self.fixdensity = r['FixDensity']
if version <= 0.4:
# Old version: XXX
print(('# Warning: Reading old version 0.3/0.4 restart files ' +
'will be disabled some day in the future!'))
self.convergence['eigenstates'] = r['Tolerance']
else:
nbtc = r['NumberOfBandsToConverge']
if not isinstance(nbtc, (int, str)):
# The string 'all' was eval'ed to the all() function!
nbtc = 'all'
if version < 5:
force_crit = None
else:
force_crit = r['ForcesConvergenceCriterion']
if force_crit is not None:
force_crit *= (Hartree / Bohr)
self.convergence = {'density': r['DensityConvergenceCriterion'],
'energy':
r['EnergyConvergenceCriterion'] * Hartree,
'eigenstates':
r['EigenstatesConvergenceCriterion'],
'bands': nbtc,
'forces': force_crit}
if version < 1:
# Volume per grid-point:
dv = (abs(np.linalg.det(r.get('UnitCell'))) /
(gpts[0] * gpts[1] * gpts[2]))
self.convergence['eigenstates'] *= Hartree**2 * dv
if version <= 0.6:
mixer = 'Mixer'
weight = r['MixMetric']
elif version <= 0.7:
mixer = r['MixClass']
weight = r['MixWeight']
metric = r['MixMetric']
if metric is None:
weight = 1.0
else:
mixer = r['MixClass']
weight = r['MixWeight']
if mixer == 'Mixer':
from gpaw.mixer import Mixer
elif mixer == 'MixerSum':
from gpaw.mixer import MixerSum as Mixer
elif mixer == 'MixerSum2':
from gpaw.mixer import MixerSum2 as Mixer
elif mixer == 'MixerDif':
from gpaw.mixer import MixerDif as Mixer
elif mixer == 'DummyMixer':
from gpaw.mixer import DummyMixer as Mixer
else:
Mixer = None
if Mixer is None:
self.mixer = None
else:
self.mixer = Mixer(r['MixBeta'], r['MixOld'], weight)
if version == 0.3:
# Old version: XXX
print(('# Warning: Reading old version 0.3 restart files is ' +
'dangerous and will be disabled some day in the future!'))
self.stencils = (2, 3)
self.charge = 0.0
fixmom = False
else:
self.stencils = (r['KohnShamStencil'],
r['InterpolationStencil'])
if r['PoissonStencil'] == 999:
self.poissonsolver = FFTPoissonSolver()
else:
self.poissonsolver = PoissonSolver(nn=r['PoissonStencil'])
self.charge = r['Charge']
fixmom = r['FixMagneticMoment']
self.occupations = FermiDirac(r['FermiWidth'] * Hartree,
fixmagmom=fixmom)
try:
self.mode = r['Mode']
except KeyError:
self.mode = 'fd'
if self.mode == 'pw':
self.mode = PW(ecut=r['PlaneWaveCutoff'] * Hartree)
if len(bzk_kc) == 1 and not bzk_kc[0].any():
# Gamma point only:
if r['DataType'] == 'Complex':
self.dtype = complex