def __init__(self,
generator,
name=None,
run=True,
gtxt='-',
non_relativistic_guess=False,
xc='PBE'):
if isinstance(generator, str): # treat 'generator' as symbol
generator = Generator(generator,
scalarrel=True,
xcname=xc,
txt=gtxt,
nofiles=True)
generator.N *= 4
self.generator = generator
self.rgd = AERadialGridDescriptor(generator.beta,
generator.N,
default_spline_points=100)
self.name = name
if run:
if non_relativistic_guess:
ae0 = AllElectron(generator.symbol,
scalarrel=False,
nofiles=False,
txt=gtxt,
xcname=xc)
ae0.N = generator.N
ae0.beta = generator.beta
ae0.run()
# Now files will be stored such that they can
# automagically be used by the next run()
generator.run(write_xml=False,
use_restart_file=False,
**parameters[generator.symbol])
def gen(symbol, exx=False, name=None, **kwargs):
if mpi.rank == 0:
if 'scalarrel' not in kwargs:
kwargs['scalarrel'] = True
g = Generator(symbol, **kwargs)
g.run(exx=exx, name=name, use_restart_file=False, **parameters[symbol])
mpi.world.barrier()
if setup_paths[0] != '.':
setup_paths.insert(0, '.')
def generate_old(self, fd, xc, scalar_relativistic, tag):
from gpaw.atom.configurations import parameters
from gpaw.atom.generator import Generator
par = parameters[self.symbol]
g = Generator(self.symbol,
xc,
scalarrel=scalar_relativistic,
nofiles=True,
txt=fd)
g.run(exx=True,
logderiv=False,
use_restart_file=False,
name=tag,
**par)
def __init__(self,
generator,
name=None,
run=True,
gtxt='-',
non_relativistic_guess=False,
xc='PBE',
save_setup=False):
if isinstance(generator, str): # treat 'generator' as symbol
generator = Generator(generator,
scalarrel=True,
xcname=xc,
txt=gtxt,
nofiles=True)
generator.N *= 4
self.generator = generator
self.rgd = AERadialGridDescriptor(generator.beta / generator.N,
1.0 / generator.N,
generator.N,
default_spline_points=100)
self.name = name
if run:
if non_relativistic_guess:
ae0 = AllElectron(generator.symbol,
scalarrel=False,
nofiles=False,
txt=gtxt,
xcname=xc)
ae0.N = generator.N
ae0.beta = generator.beta
ae0.run()
# Now files will be stored such that they can
# automagically be used by the next run()
setup = generator.run(write_xml=False,
use_restart_file=False,
name=name,
**parameters[generator.symbol])
if save_setup:
setup.write_xml()
else:
if save_setup:
raise ValueError('cannot save setup here because setup '
'was already generated before basis '
'generation.')
def test():
# Generate setup
symbol = 'He'
if rank == 0:
g = Generator(symbol, 'revPBE', scalarrel=True, nofiles=True)
g.run(exx=True, **parameters[symbol])
barrier()
setup_paths.insert(0, '.')
a = 7.5 * Bohr
n = 16
atoms = Atoms([Atom('He', (0.0, 0.0, 0.0))], cell=(a, a, a), pbc=True)
calc = Calculator(gpts=(n, n, n), nbands=1, xc='revPBE')
atoms.set_calculator(calc)
e1 = atoms.get_potential_energy()
calc.write('He')
e2 = e1 + calc.get_xc_difference('vdWDF')
print e1, e2
def gen(symbol, exx=False, name=None, **kwargs):
setup = None
if mpi.rank == 0:
if 'scalarrel' not in kwargs:
kwargs['scalarrel'] = True
g = Generator(symbol, **kwargs)
if 'orbital_free' in kwargs:
setup = g.run(exx=exx,
name=name,
use_restart_file=False,
**tf_parameters.get(symbol, {'rcut': 0.9}))
else:
setup = g.run(exx=exx,
name=name,
use_restart_file=False,
**parameters[symbol])
setup = mpi.broadcast(setup, 0)
if setup_paths[0] != '.':
setup_paths.insert(0, '.')
return setup
def generate_setup(self):
if mpi.rank == 0:
gen = Generator(self.symbol, 'PBE', scalarrel=True)
gen.run(logderiv=True, **parameters[self.symbol])
data = analyse(gen, show=False)
g = np.arange(gen.N)
r_g = gen.r
dr_g = gen.beta * gen.N / (gen.N - g)**2
rcutcomp = gen.rcutcomp
rcutfilter = gen.rcutfilter
# Find cutoff for core density:
if gen.Nc == 0:
rcore = 0.5
else:
N = 0.0
g = gen.N - 1
while N < 1e-7:
N += np.sqrt(4 * np.pi) * gen.nc[g] * r_g[g]**2 * dr_g[g]
g -= 1
rcore = r_g[g]
nlfer = []
for j in range(gen.njcore):
nlfer.append(
(gen.n_j[j], gen.l_j[j], gen.f_j[j], gen.e_j[j], 0.0))
for n, l, f, eps in zip(gen.vn_j, gen.vl_j, gen.vf_j, gen.ve_j):
nlfer.append((n, l, f, eps, gen.rcut_l[l]))
self.data = dict(Z=gen.Z,
Nv=gen.Nv,
Nc=gen.Nc,
rcutcomp=rcutcomp,
rcutfilter=rcutfilter,
rcore=rcore,
Ekin=gen.Ekin,
Epot=gen.Epot,
Exc=gen.Exc,
nlfer=nlfer)
def gen(symbol, xcname):
g = Generator(symbol, xcname, scalarrel=True, nofiles=True)
g.run(exx=True, **parameters[symbol])
files.append('%s.%s' % (symbol, XCFunctional(xcname).get_name()))
def calculate(self):
ESIC = 0
xc = self.paw.hamiltonian.xc
assert xc.type == 'LDA'
# Calculate the contribution from the core orbitals
for a in self.paw.density.D_asp:
setup = self.paw.density.setups[a]
# TODO: Use XC which has been used to calculate the actual
# calculation.
# TODO: Loop over setups, not atoms.
print('Atom core SIC for ', setup.symbol)
print('%10s%10s%10s' % ('E_xc[n_i]', 'E_Ha[n_i]', 'E_SIC'))
g = Generator(setup.symbol, xcname='LDA', nofiles=True, txt=None)
g.run(**parameters[setup.symbol])
njcore = g.njcore
for f, l, e, u in zip(g.f_j[:njcore], g.l_j[:njcore],
g.e_j[:njcore], g.u_j[:njcore]):
# Calculate orbital density
# NOTE: It's spherically symmetrized!
#n = np.dot(self.f_j,
assert l == 0, ('Not tested for l>0 core states')
na = np.where(abs(u) < 1e-160, 0, u)**2 / (4 * pi)
na[1:] /= g.r[1:]**2
na[0] = na[1]
nb = np.zeros(g.N)
v_sg = np.zeros((2, g.N))
e_g = np.zeros(g.N)
vHr = np.zeros(g.N)
Exc = xc.calculate_spherical(g.rgd, np.array([na, nb]), v_sg)
hartree(0, na * g.r * g.dr, g.r, vHr)
EHa = 2 * pi * np.dot(vHr * na * g.r, g.dr)
print(
('%10.2f%10.2f%10.2f' % (Exc * Hartree, EHa * Hartree, -f *
(EHa + Exc) * Hartree)))
ESIC += -f * (EHa + Exc)
sic = SIC(finegrid=True, coulomb_factor=1, xc_factor=1)
sic.initialize(self.paw.density, self.paw.hamiltonian, self.paw.wfs)
sic.set_positions(self.paw.atoms.get_scaled_positions())
print('Valence electron sic ')
print('%10s%10s%10s%10s%10s%10s' %
('spin', 'k-point', 'band', 'E_xc[n_i]', 'E_Ha[n_i]', 'E_SIC'))
assert len(
self.paw.wfs.kpt_u) == 1, ('Not tested for bulk calculations')
for s, spin in sic.spin_s.items():
spin.initialize_orbitals()
spin.update_optimal_states()
spin.update_potentials()
n = 0
for xc, c in zip(spin.exc_m, spin.ecoulomb_m):
print(('%10i%10i%10i%10.2f%10.2f%10.2f' %
(s, 0, n, -xc * Hartree, -c * Hartree, 2 *
(xc + c) * Hartree)))
n += 1
ESIC += spin.esic
print('Total correction for self-interaction energy:')
print('%10.2f eV' % (ESIC * Hartree))
print('New total energy:')
total = (ESIC * Hartree + self.paw.get_potential_energy() +
self.paw.get_reference_energy())
print('%10.2f eV' % total)
return total
for name in all_names:
check(con, name)
data = {}
for name in all_names:
if '.' in name:
symbol, e = name.split('.')
params = parameters_extra[symbol]
assert params['name'] == e
else:
symbol = name
e = 'default'
params = parameters[symbol]
data[symbol] = []
gen = Generator(symbol, 'PBE', scalarrel=True, txt=None)
gen.run(write_xml=False, **params)
nlfer = []
for j in range(gen.njcore):
nlfer.append((gen.n_j[j], gen.l_j[j], gen.f_j[j], gen.e_j[j], 0.0))
for n, l, f, eps in zip(gen.vn_j, gen.vl_j, gen.vf_j, gen.ve_j):
nlfer.append((n, l, f, eps, gen.rcut_l[l]))
energies = summary(con, name)
data[symbol].append((e, nlfer, energies))
with open('datasets.json', 'w') as fd:
fd.write(encode(data))
#!/usr/bin/env python
from ase import *
from gpaw import GPAW
from gpaw.mpi import run, world
from gpaw.atom.generator import Generator
from gpaw.atom.configurations import parameters
from gpaw import setup_paths
# Generate setups for oxygen and hydrogen:
if world.rank == 0:
g = Generator('O', xcname='GLLBLDARCR', scalarrel=True, nofiles=True)
g.run(**parameters['O'])
g = Generator('H', xcname='GLLBLDARCR', scalarrel=True, nofiles=True)
g.run(**parameters['H'])
world.barrier()
setup_paths.insert(0, '.')
# Then, calculate the core-eigenvalue of H2O molecule
a = 5.0
d = 0.9575
t = pi / 180 * 104.51
H2O = Atoms([
Atom('O', (0, 0, 0)),
Atom('H', (d, 0, 0)),
Atom('H', (d * cos(t), d * sin(t), 0))
],
cell=(a, a, a),
pbc=False)
H2O.center()
calc = GPAW(nbands=10, h=0.2, xc='GLLBLDARCR')
def main():
parser = build_parser()
opt, args = parser.parse_args()
import sys
from gpaw.atom.generator import Generator
from gpaw.atom.configurations import parameters, tf_parameters
from gpaw.atom.all_electron import AllElectron
from gpaw import ConvergenceError
if args:
atoms = args
else:
atoms = parameters.keys()
bad_density_warning = """\
Problem with initial electron density guess! Try to run the program
with the '-nw' option (non-scalar-relativistic calculation + write
density) and then try again without the '-n' option (this will
generate a good initial guess for the density)."""
for symbol in atoms:
scalarrel = not opt.non_scalar_relativistic
corehole = None
if opt.core_hole is not None:
state, occ = opt.core_hole.split(',')
# Translate corestate string ('1s') to n and l:
ncorehole = int(state[0])
lcorehole = 'spdf'.find(state[1])
fcorehole = float(occ)
corehole = (ncorehole, lcorehole, fcorehole)
if opt.all_electron_only:
a = AllElectron(symbol, opt.xcfunctional, scalarrel, corehole,
opt.configuration, not opt.write_files, '-',
opt.points_per_node,
opt.orbital_free, opt.tw_coefficient)
try:
a.run()
except ConvergenceError:
print(bad_density_warning, file=sys.stderr)
continue
g = Generator(symbol, opt.xcfunctional, scalarrel, corehole,
opt.configuration, not opt.write_files, '-',
opt.points_per_node, orbital_free=opt.orbital_free,
tw_coeff=opt.tw_coefficient)
if opt.orbital_free:
p = tf_parameters.get(symbol, {'rcut': 0.9})
else:
p = parameters.get(symbol, {})
if opt.core is not None:
p['core'] = opt.core
if opt.radius is not None:
p['rcut'] = [float(x) for x in opt.radius.split(',')]
if opt.extra_projectors is not None:
extra = {}
if opt.extra_projectors != '':
for l, x in enumerate(opt.extra_projectors.split(';')):
if x != '':
extra[l] = [float(y) for y in x.split(',')]
p['extra'] = extra
if opt.normconserving is not None:
p['normconserving'] = opt.normconserving
if opt.filter is not None:
p['filter'] = [float(x) for x in opt.filter.split(',')]
if opt.compensation_charge_radius is not None:
p['rcutcomp'] = opt.compensation_charge_radius
if opt.zero_potential is not None:
vbar = opt.zero_potential.split(',')
p['vbar'] = (vbar[0], float(vbar[1]))
if opt.empty_states is not None:
p['empty_states'] = opt.empty_states
try:
g.run(logderiv=opt.logarithmic_derivatives,
exx=opt.exact_exchange, name=opt.name,
use_restart_file=opt.use_restart_file,
**p)
except ConvergenceError:
print(bad_density_warning, file=sys.stderr)
except RuntimeError as m:
if len(m.__str__()) == 0:
raise
print(m)
if opt.plot:
from gpaw.atom.analyse_setup import analyse
analyse(g, show=True)
import os
from gpaw import Calculator
from gpaw.atom.generator import Generator
from gpaw.atom.configurations import parameters
# Generate setups with 0.5, 1.0, 0.0 core holes in 1s
elements = ['O', 'C', 'N']
coreholes = [0.5, 1.0, 0.0]
names = ['hch1s', 'fch1s', 'xes1s']
functionals = ['LDA', 'PBE']
for el in elements:
for name, ch in zip(names, coreholes):
for funct in functionals:
g = Generator(el,
scalarrel=True,
xcname=funct,
corehole=(1, 0, ch),
nofiles=True)
g.run(name=name, **parameters[el])
from gpaw.atom.generator import Generator
from gpaw.atom.basis import BasisMaker
args = {'core': '[Kr]', 'rcut': 2.45}
generator = Generator('Ag', 'GLLBSC', scalarrel=True)
generator.N *= 2 # Increase grid resolution
generator.run(**args)
bm = BasisMaker(generator, name='GLLBSC', run=False)
basis = bm.generate(
zetacount=2,
polarizationcount=0,
energysplit=0.07,
jvalues=[0, 1, 2], # include d, s and p
rcutmax=12.0)
basis.write_xml()
from gpaw.atom.generator import Generator
from gpaw.atom.configurations import parameters
from gpaw.atom.basis import BasisMaker
symbol = 'Au'
args = parameters[symbol] # Dictionary of default setup parameters
args['rcut'] = 2.6 # Set cutoff of augmentation sphere
generator = Generator(symbol, 'RPBE')
generator.N *= 2 # Increase grid resolution
generator.run(write_xml=False, **args)
bm = BasisMaker(generator, name='special', run=False)
# Create double-zeta RPBE basis where p orbital is considered a valence state
# (ordinary dzp basis would use a smaller p-type Gaussian for polarization)
# The list jvalues indicates which states should be included, and the
# ordering corresponds to the valence states in the setup.
basis = bm.generate(zetacount=2,
polarizationcount=0,
energysplit=0.1,
jvalues=[0, 1, 2],
rcutmax=12.0)
basis.write_xml() # Dump to file 'Au.special.basis'
diff = e_HOMO_cs[atom] + e_homo
print('%2s %8g %6.1f %4.1g' % (atom, e_HOMO_cs[atom], -e_homo, diff))
assert abs(diff) < 6
barrier()
setup_paths.insert(0, '.')
setups = {}
print('**** 3D calculations')
print('atom [refs] -e_homo diff all in mHa')
for atom in e_HOMO_cs.keys():
e_ref = e_HOMO_cs[atom]
# generate setup for the atom
if rank == 0 and not setups.has_key(atom):
g = Generator(atom, 'LB94', nofiles=True, txt=txt)
g.run(**parameters[atom])
setups[atom] = 1
barrier()
SS = Atoms([Atom(atom)], cell=(7, 7, 7), pbc=False)
SS.center()
c = GPAW(h=.3, xc='LB94', nbands=-2, txt=txt)
if atom in ['Mg']:
c.set(eigensolver='cg')
c.calculate(SS)
# find H**O energy
eps_n = c.get_eigenvalues(kpt=0, spin=0) / 27.211
f_n = c.get_occupation_numbers(kpt=0, spin=0)
for e, f in zip(eps_n, f_n):
if f < 0.99:
import os
from math import pi, cos, sin
from ase import *
from gpaw import GPAW
from gpaw.atom.generator import Generator
from gpaw.atom.configurations import parameters
from gpaw import setup_paths
from gpaw.mpi import world
# Generate the setups
if world.rank == 0:
Generator('O', nofiles=True, xcname='LDA').run(**parameters['O'])
Generator('O', nofiles=True, xcname='GLLBLDA').run(**parameters['O'])
Generator('H', nofiles=True, xcname='LDA').run(**parameters['H'])
Generator('H', nofiles=True, xcname='GLLBLDA').run(**parameters['H'])
setup_paths.insert(0, '.')
a = 4.0
d = 0.9575
t = pi / 180 * 104.51
system = [
Atom('O', (0, 0, 0)),
Atom('H', (d, 0, 0)),
Atom('H', (d * cos(t), d * sin(t), 0))
]
c = {
'energy': 1e-6, # eV / atom
'density': 1.0e-7,
elif symbol in ['Be', 'B', 'C', 'N', 'O', 'F', 'Ne']:
rcut = 1.2
elif symbol in ['Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'Ar']:
rcut = 1.4
else:
rcut = 1.0
# If the lambda scaling is used change name to differentiate the setup
name = 'lambda_{0}'.format(lambda_coeff)
# Use of Kinetic functional (minus the Tw contribution) inside the
# xc definition
#pauliname = '{0}_LDA_K_TF+1.0_LDA_X+1.0_LDA_C_PW'.format(gamma_coeff)
#pauliname = '{0}_LDA_K_TF+1.0_LDA_K_LP+-1.0_LDA_K_LP+1.0_LDA_X+1.0_LDA_C_PW'.format(gamma_coeff)
pauliname = '1.0_GGA_K_TFVW+-1.0_GGA_K_VW+1.0_GGA_X_PBE+1.0_GGA_C_PBE'
print('Pauliname: ' + pauliname)
# Calculate OFDFT density
g = Generator(symbol,
xcname=pauliname,
scalarrel=False,
orbital_free=True,
tw_coeff=lambda_coeff,
gpernode=gpernode)
g.run(exx=False,
name=name,
use_restart_file=False,
rcut=rcut,
write_xml=True)
from gpaw import GPAW, restart, Davidson, Mixer
from gpaw.atom.generator import Generator
from gpaw.atom.configurations import parameters
from gpaw import setup_paths
from gpaw.mpi import world
from gpaw.test import equal
# This test calculates the derivative discontinuity of Ne-atom
# first on 3D without restart. Then does restart and recalculates.
atom = 'Ne'
setup_paths.insert(0, '.')
for xcname in ['GLLB', 'GLLBSC']:
if world.rank == 0:
g = Generator(atom, xcname=xcname, scalarrel=False, nofiles=True)
g.run(**parameters[atom])
eps = g.e_j[-1]
world.barrier()
a = 10
Ne = Atoms([Atom(atom, (0, 0, 0))], cell=(a, a, a), pbc=False)
Ne.center()
calc = GPAW(eigensolver=Davidson(4),
nbands=10,
h=0.18,
xc=xcname,
basis='dzp',
mixer=Mixer(0.6))
Ne.set_calculator(calc)
e = Ne.get_potential_energy()
from ase import *
from gpaw import GPAW
from gpaw.utilities import equal
from gpaw.atom.generator import Generator
from gpaw.atom.configurations import parameters
from gpaw import setup_paths
Generator('Ne', nofiles=True, scalarrel=False,
xcname='GLLBNORESP').run(**parameters['Ne'])
setup_paths.insert(0, '.')
a = 8
hydrogen = Atoms([Atom('Ne')], cell=(a, a, a), pbc=False)
hydrogen.center()
calc = GPAW(xc='GLLBNORESP')
hydrogen.set_calculator(calc)
e1 = hydrogen.get_potential_energy()
