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')
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)
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,
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:
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
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 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
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()
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()
# 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)
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
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 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."""
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
