def band_calc():
if world.rank == 0:
pathlib.Path('outputs').mkdir(parents=True, exist_ok=True)
calc = GPAW('licoo2_gs.gpw',
nbands=-90,
fixdensity=True,
symmetry='off',
kpts={
'path': licoo2.cell.bandpath().path,
'npoints': 60
},
convergence={'bands': -90},
txt='outputs/licoo2_bands.txt')
occasionally = 2
class OccasionalWriter:
def __init__(self):
self.iter = 0
def write(self):
calc.write('filename.%03d.gpw' % self.iter)
self.iter += occasionally
calc.attach(OccasionalWriter().write, occasionally)
calc.get_potential_energy()
calc.write('licoo2_bands.gpw', mode='all')
return calc
def check(reuse):
atoms = molecule('H2')
atoms.pbc = 1
atoms.center(vacuum=1.5)
atoms.positions -= atoms.positions[1]
dz = 1e-2
atoms.positions[:, 2] += dz
calc = GPAW(mode='pw',
txt='gpaw.txt',
nbands=1,
experimental=dict(reuse_wfs_method='paw' if reuse else None),
kpts=[[-0.3, 0.4, 0.2]],
symmetry='off',
mixer=Mixer(0.7, 5, 50.0))
atoms.calc = calc
first_iter_err = []
def monitor():
logerr = np.log10(calc.wfs.eigensolver.error)
n = calc.scf.niter
if n == 1:
first_iter_err.append(logerr)
if world.rank == 0:
print('iter', n, 'err', logerr)
calc.attach(monitor, 1)
atoms.get_potential_energy()
logerr1 = first_iter_err.pop()
atoms.positions[:, 2] -= 2 * dz
atoms.get_potential_energy()
logerr2 = first_iter_err.pop()
if world.rank == 0:
print('reuse={}'.format(bool(reuse)))
print('logerr1', logerr1)
print('logerr2', logerr2)
gain = logerr2 - logerr1
print('gain', gain)
return logerr2
from ase.build import molecule
from gpaw import GPAW, Mixer
from gpaw.atom.generator import Generator
from gpaw.xc.libvdwxc import vdw_df, vdw_mbeef
system = molecule('H2O')
system.center(vacuum=1.5)
system.pbc = 1
for mode in ['lcao', 'fd', 'pw']:
kwargs = dict(mode=mode,
basis='szp(dzp)',
xc=vdw_df(),
mixer=Mixer(0.3, 5, 10.))
calc = GPAW(**kwargs)
def stopcalc():
calc.scf.converged = True
calc.attach(stopcalc, 6)
system.set_calculator(calc)
system.get_potential_energy()
import os
import filecmp
from gpaw import GPAW
from ase import Atom, Atoms
from gpaw.test import equal
restart = 'gpaw-restart'
result = 'gpaw-result'
# H atom:
H = Atoms([Atom('H')])
H.center(vacuum=3.0)
calc = GPAW(gpts=(32, 32, 32), nbands=1)
calc.attach(calc.write, 4, restart)
H.set_calculator(calc)
e = H.get_potential_energy()
niter = calc.get_number_of_iterations()
calc.write(result)
# the two files should be equal
from gpaw.mpi import rank
if rank == 0:
for f in ['gpaw-restart', 'gpaw-result']:
os.system('rm -rf %s; mkdir %s; cd %s; tar xf ../%s.gpw' %
(f, f, f, f))
assert os.system('diff -r gpaw-restart gpaw-result > /dev/null') == 0
os.system('rm -rf gpaw-restart gpaw-result')
energy_tolerance = 0.00006
for augment_grids in 0, 1:
if world.rank == 0:
print(mode, augment_grids)
calc = GPAW(mode=mode,
gpts=(16, 16, 16),
txt='gpaw.%s.%d.txt' % (mode, int(augment_grids)),
eigensolver=eigensolver,
parallel=dict(augment_grids=augment_grids,
band=band, domain=domain),
basis='szp(dzp)',
kpts=[1, 1, 4],
nbands=8)
def stopcalc():
calc.scf.converged = True
# Iterate enough for density to update so it depends on potential
calc.attach(stopcalc, 3 if mode == 'lcao' else 5)
system.set_calculator(calc)
energy.append(system.get_potential_energy())
force.append(system.get_forces())
if mode == 'pw':
stress.append(system.get_stress())
ferr = np.abs(force[1] - force[0]).max()
eerr = abs(energy[1] - energy[0])
if mode == 'pw':
serr = np.abs(stress[1] - stress[0]).max()
assert eerr < 1e-10, eerr
assert ferr < 1e-10, ferr
from gpaw.xas import XAS, RecursionMethod
from gpaw.test import gen
# Generate setup for oxygen with half a core-hole:
gen('Si', name='hch1s', corehole=(1, 0, 0.5), gpernode=30)
a = 2.6
si = Atoms('Si', cell=(a, a, a), pbc=True)
import numpy as np
calc = GPAW(nbands=None,
h=0.25,
occupations=FermiDirac(width=0.05),
setups={0: 'hch1s'})
def stopcalc():
calc.scf.converged = 1
calc.attach(stopcalc, 1)
si.set_calculator(calc)
e = si.get_potential_energy()
niter = calc.get_number_of_iterations()
calc.write('si.gpw')
# restart from file
calc = GPAW('si.gpw')
import gpaw.mpi as mpi
if mpi.size == 1:
xas = XAS(calc)
x, y = xas.get_spectra()
else:
x = np.linspace(0, 10, 50)
# http://listserv.fysik.dtu.dk/pipermail/gpaw-developers/2014-February/004374.html
from __future__ import print_function
from ase import Atom, Atoms
from gpaw import GPAW
from gpaw.test import equal
for i in range(40):
a = 6.
b = a / 2
mol = Atoms([
Atom('O', (b, b, 0.1219 + b)),
Atom('H', (b, 0.7633 + b, -0.4876 + b)),
Atom('H', (b, -0.7633 + b, -0.4876 + b))
],
pbc=False,
cell=[a, a, a])
calc = GPAW(gpts=(24, 24, 24), nbands=4, mode='lcao', txt=None, xc='LDA')
def stop():
calc.scf.converged = True
calc.attach(stop, 1)
mol.set_calculator(calc)
e = mol.get_potential_energy()
if i == 0:
eref = e
if calc.wfs.world.rank == 0:
print(repr(e))
equal(e - eref, 0, 1.e-12)
# http://listserv.fysik.dtu.dk/pipermail/gpaw-developers/2014-February/004374.html
from ase import Atom, Atoms
from gpaw import GPAW
from gpaw.test import equal
for i in range(40):
a = 6.
b = a / 2
mol = Atoms([Atom('O',(b, b, 0.1219 + b)),
Atom('H',(b, 0.7633 + b, -0.4876 + b)),
Atom('H',(b, -0.7633 + b, -0.4876 + b))],
pbc=False, cell=[a, a, a])
calc = GPAW(gpts=(24, 24, 24), nbands=4, mode='lcao', txt=None,
xc='LDA')
def stop():
calc.scf.converged = True
calc.attach(stop, 1)
mol.set_calculator(calc)
e = mol.get_potential_energy()
if i == 0:
eref = e
if calc.wfs.world.rank == 0:
print repr(e)
equal(e - eref, 0, 1.e-12)
setups={'Co': ':d,5.0'}, # U=5 eV for Co d orbitals
txt='Coo.txt',
kpts=(k, k, k),
nbands='nao',
xc='PBE')
occasionally = 10
class OccasionalWriter:
def __init__(self):
self.iter = 0
def write(self):
calc.write('coo_gs.%03d.gpw' % self.iter)
self.iter += occasionally
calc.attach(OccasionalWriter().write, occasionally)
atom.set_calculator(calc)
e = atom.get_potential_energy()
calc.write('coo_gs.gpw')
parprint("total energy = {}".format(e))
calc.set(nbands='nao',
fixdensity=True,
symmetry='off',
kpts={
'path': atom.cell.bandpath().path,
'npoints': 200
},
convergence={'bands': 'all'})
calc.get_potential_energy()
if world.size >= 4:
parallel['band'] = 2
if correction.name != 'dense':
parallel['sl_auto'] = True
calc = GPAW(mode=LCAO(atomic_correction=correction),
basis='sz(dzp)',
#kpts=(1, 1, 4),
#spinpol=True,
poissonsolver=PoissonSolver('fd', relax='J', eps=1e100, nn=1),
parallel=parallel,
h=0.35)
def stopcalc():
calc.scf.converged = True
calc.attach(stopcalc, 2)
system.set_calculator(calc)
energy = system.get_potential_energy()
energies.append(energy)
master = calc.wfs.world.rank == 0
if master:
print('energies', energies)
eref = energies[0]
errs = []
for energy, c in zip(energies, corrections):
err = abs(energy - eref)
nops = calc.wfs.world.sum(c.nops)
errs.append(err)
if master:
import os
from glob import glob
from gpaw import GPAW
from ase import Atom, Atoms
from gpaw.test import equal
restart = 'gpaw-restart'
result = 'gpaw-result'
# H atom:
H = Atoms([Atom('H')])
H.center(vacuum=3.0)
calc = GPAW(gpts=(32, 32, 32), nbands=1)
calc.attach(calc.write, 4, restart)
H.set_calculator(calc)
e = H.get_potential_energy()
niter = calc.get_number_of_iterations()
calc.write(result)
# the two files should be equal
from gpaw.mpi import rank
if rank == 0:
for f in ['gpaw-restart', 'gpaw-result']:
os.system('rm -rf %s; mkdir %s; cd %s; tar xf ../%s.gpw' %
(f, f, f, f))
# make a list of the files to compare
files_restart = glob(restart + '/*')
files_result = glob(result + '/*')
def run(self):
self.steps.append(calc.iter)
def converge(self):
calc.scf.converged = True
H = Atoms('H', positions=[(1.5, 1.5, 1.5)])
H.set_cell((3, 3, 3))
calc = GPAW(convergence={'density': -1}, maxiter=11)
AllCall = ObsTest()
EvenCall = ObsTest()
OneCall = ObsTest()
FinalCall = ObsTest()
calc.attach(AllCall.run, 1)
calc.attach(EvenCall.run, 2)
calc.attach(OneCall.run, -7)
calc.attach(OneCall.converge, -7)
calc.attach(FinalCall.run, 0)
H.set_calculator(calc)
H.get_potential_energy()
assert AllCall.steps == [1, 2, 3, 4, 5, 6, 7]
assert EvenCall.steps == [2, 4, 6, 7]
assert OneCall.steps == [7]
assert FinalCall.steps == [7]
def run(self):
self.steps.append(calc.iter)
def converge(self):
calc.scf.converged = True
H = Atoms('H', positions=[(1.5, 1.5, 1.5)])
H.set_cell((3, 3, 3))
calc = GPAW(convergence={'density': -1}, maxiter=11)
AllCall = ObsTest()
EvenCall = ObsTest()
OneCall = ObsTest()
FinalCall = ObsTest()
calc.attach(AllCall.run, 1)
calc.attach(EvenCall.run, 2)
calc.attach(OneCall.run, -7)
calc.attach(OneCall.converge, -7)
calc.attach(FinalCall.run, 0)
H.set_calculator(calc)
H.get_potential_energy()
assert AllCall.steps == [1, 2, 3, 4, 5, 6, 7]
assert EvenCall.steps == [2, 4, 6, 7]
assert OneCall.steps == [7]
assert FinalCall.steps == [7]
