def __init__(self, symbol, filename=None, index=None, txt=None):
if filename is None or filename == '-':
formula, index = get_system(symbol)
filename = restart_filename % formula
calc = Calculator(filename, txt=txt)
atoms = calc.get_atoms()
symbols = atoms.get_chemical_symbols()
if index is None:
index = symbols.index(symbol)
else:
if not symbols[index] == symbol:
raise ValueError(
('Atom (%s) at specified index (%d) not of ' +
'requested type (%s)') % (symbols[index], index, symbol))
self.calc = calc
self.filename = filename
self.atoms = atoms
self.symbol = symbol
self.symbols = symbols
self.index = index
self.cell = atoms.get_cell().diagonal() # cubic cell
#self.center = atoms.positions[index]
self.spos_ac = atoms.positions / self.cell
self.gpts = calc.wfs.gd.N_c
if calc.kpt_u[0].psit_nG is None:
raise RuntimeError('No wave functions found in .gpw file')
def __init__(self, symbol, filename=None, index=None, txt=None):
if filename is None or filename == '-':
formula, index = get_system(symbol)
filename = restart_filename % formula
calc = Calculator(filename, txt=txt)
atoms = calc.get_atoms()
symbols = atoms.get_chemical_symbols()
if index is None:
index = symbols.index(symbol)
else:
if not symbols[index] == symbol:
raise ValueError(('Atom (%s) at specified index (%d) not of '+
'requested type (%s)') % (symbols[index],
index, symbol))
self.calc = calc
self.filename = filename
self.atoms = atoms
self.symbol = symbol
self.symbols = symbols
self.index = index
self.cell = atoms.get_cell().diagonal() # cubic cell
#self.center = atoms.positions[index]
self.spos_ac = atoms.positions / self.cell
self.gpts = calc.wfs.gd.N_c
if calc.kpt_u[0].psit_nG is None:
raise RuntimeError('No wave functions found in .gpw file')
class STM:
def __init__(self, surfacecalc, tipcalc):
self.scalc = surfacecalc
self.tcalc = tipcalc
self.surface = surfacecalc.get_atoms()
self.tip = tipcalc.get_atoms()
def initialize(self):
tip = self.tip.copy()
htip = tip.get_cell()[2, 2]
#tip.translate((0, 0, htip))
self.combined = self.surface + tip
self.combined.cell[2, 2] += htip
self.calc = Calculator(h=0.2, eigensolver='lcao', basis='sz',
txt=None)
#self.combined.set_calculator(self.calc)
self.calc.initialize(self.combined)
self.calc.hamiltonian.initialize(self.calc)
self.calc.density.initialize()
self.vtip_G = self.tcalc.hamiltonian.vt_sG[0]
self.vsurface_G = self.scalc.hamiltonian.vt_sG[0]
self.get_basis_functions()
self.tgd = self.tcalc.wfs.gd
self.sgd = self.scalc.wfs.gd
def get_basis_functions(self):
gd = self.calc.wfs.gd
self.functions = []
for nucleus in self.calc.nuclei:
spos0_c = np.round(nucleus.spos_c * gd.N_c) / gd.N_c
f_iG = clf(nucleus.setup.phit_j, gd,
nucleus.spos_c + 0.5 - spos0_c,
dtype=float, cut=False,
forces=False, lfbc=None).box_b[0].get_functions()
self.functions.append((spos0_c, f_iG))
def set_position(self, dG):
positions = self.combined.get_positions()
tippositions = self.tip.get_positions()
tippositions += dG * self.calc.wfs.gd.h_c / Bohr
positions[-len(self.tip):] = tippositions
self.combined.set_positions(positions)
self.calc.set_positions(self.combined)
self.calc.hamiltonian.initialize_lcao()
def memory_bandwidth(code='gpaw', runs=7):
slab = Atoms([
Atom('Al', (0, 0, 0)),
Atom('Al', (a, 0, 0)),
Atom('Al', (a / 2, d / 2, -d / 2)),
Atom('Al', (3 * a / 2, d / 2, -d / 2)),
Atom('Al', (0, 0, -d)),
Atom('Al', (a, 0, -d)),
Atom('Al', (a / 2, d / 2, -3 * d / 2)),
Atom('Al', (3 * a / 2, d / 2, -3 * d / 2)),
Atom('Al', (0, 0, -2 * d)),
Atom('Al', (a, 0, -2 * d)),
Atom('H', (a / 2 - b / 2, 0, z)),
Atom('H', (a / 2 + b / 2, 0, z))
],
cell=(2 * a, d, 5 * d),
pbc=(1, 1, 1))
h = 0.15
nbands = 28
kpts = (2, 6, 1)
parameters = {}
if code == 'gpaw':
from gpaw import Calculator
from gpaw.mpi import rank
parameters['convergence'] = {'eigenstates': 1e-5}
parameters['h'] = h
elif code == 'dacapo':
from ase.calculators.dacapo import Dacapo as Calculator
parameters['planewavecutoff'] = gridspacing2cutoff(h)
parameters['densitycutoff'] = parameters['planewavecutoff'] * 1.5
rank = 0
t = 0.0
t_runs = []
for n in range(runs):
t0 = time.time()
for i in range(1):
calc = Calculator(nbands=nbands, kpts=kpts, **parameters)
slab.set_calculator(calc)
e = slab.get_potential_energy()
del calc
if exists('out.nc'): remove('out.nc')
t1 = time.time()
t = t + t1 - t0
t_runs.append(t1 - t0)
print 'Run: ', n, ' energy ', e, ' rank: ', str(
rank), ' time: ', time.time() - t0
if rank == 0:
print 'Rank ' + str(rank) + ': time [sec]: avg ' + str(
round(np.average(t_runs), 1)) + ', stddev ' + str(
round(np.std(t_runs), 1)) + ', min ' + str(
round(min(t_runs), 1)) + ', max ' + str(
round(max(t_runs), 1))
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 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 initialize(self):
tip = self.tip.copy()
htip = tip.get_cell()[2, 2]
#tip.translate((0, 0, htip))
self.combined = self.surface + tip
self.combined.cell[2, 2] += htip
self.calc = Calculator(h=0.2, eigensolver='lcao', basis='sz',
txt=None)
#self.combined.set_calculator(self.calc)
self.calc.initialize(self.combined)
self.calc.hamiltonian.initialize(self.calc)
self.calc.density.initialize()
self.vtip_G = self.tcalc.hamiltonian.vt_sG[0]
self.vsurface_G = self.scalc.hamiltonian.vt_sG[0]
self.get_basis_functions()
self.tgd = self.tcalc.wfs.gd
self.sgd = self.scalc.wfs.gd
def rotation_test():
molecule = 'NH3'
a = 7.
rcut = 5.
l = 1
from gpaw.output import plot
rotationvector = np.array([1.0, 1.0, 1.0])
angle_increment = 0.3
system = g2.molecule(molecule)
system.set_cell([a, a, a])
system.center()
calc = Calculator(h=0.27, txt=None)
system.set_calculator(calc)
pog = PolarizationOrbitalGenerator(rcut)
r = np.linspace(0., rcut, 300)
maxvalues = []
import pylab
for i in range(0, int(6.28 / angle_increment)):
ascii = plot(system.positions, system.get_atomic_numbers(),
system.get_cell().diagonal())
print ascii
print 'angle=%.03f' % (angle_increment * i)
energy = system.get_potential_energy()
center = (system.positions / system.get_cell().diagonal())[0]
orbital = pog.generate(l, calc.wfs.gd, calc.kpt_u[0].psit_nG, center)
y = orbital(r)
pylab.plot(r, y, label='%.02f' % (i * angle_increment))
maxvalues.append(max(y))
print 'Quality by orbital', #pretty(pog.optimizer.lastterms)
system.rotate(rotationvector, angle_increment)
system.center()
print max(maxvalues) - min(maxvalues)
pylab.legend()
pylab.show()
tests = []
for nkpt in [4]:
for magmom in [3.0]:
test = 'test: nkpt = %d magmom = %1.1f' % (nkpt, magmom)
for nhosts in nhostswrite:
print test
file_prefix = 'Fe_%d_%1.1f_par%d' % (nkpt, magmom, nhosts)
fcc = Atoms([Atom('Fe', (0, 0, 0.0001), magmom=magmom)],
pbc=True,
cell=(2.55, 2.55, 2.55))
calc = Calculator(nbands=6,
gpts=(ng, ng, ng),
kpts=(4, 2, 2),
txt=file_prefix + '.txt',
tolerance=1e-10)
fcc.set_calculator(calc)
#fcc[0].set_magnetic_moment(magmom)
e = fcc.get_potential_energy()
calc.write(file_prefix + '.gpw')
del calc, fcc
for nhosts in nhostsread:
file_prefix = 'Fe_%d_%1.1f_par%d' % (nkpt, magmom, nhosts)
print '------ restart calculation ', file_prefix, rank * 111111111
calc = Calculator(file_prefix + '.gpw',
txt=file_prefix + '_restart.txt',
tolerance=1e-10)
from ase import *
from gpaw import Calculator
h = 0.2
n = 24
a = n * h
H2 = Atoms('He2',
positions=[(0.123, 0.234, 0.345), (2.523, 2.634, 0.345)],
pbc=True,
cell=(a, a, a))
calc = Calculator(
nbands=2,
gpts=(n, n, n), #hosts=8,
txt='tmp')
H2.set_calculator(calc)
e0 = H2.get_potential_energy()
for i in range(51):
e = H2.get_potential_energy()
print i * a / 25, e - e0
calc.txt.flush()
H2.positions[0] += (a / 25, 0, 0)
H2.positions[1] += (0, 0, a / 25)
assert abs(e - e0) < 1e-4
from ase import *
from gpaw import Calculator
from gpaw.utilities import equal
a = 4.8 # => N = 4.8 / 0.2 = 24
loa = Atoms([Atom('C', [a / 2 + .3, a / 2 -.1, a / 2], magmom=2)],
pbc=False,
cell=(a, a, a))
p = []
exx = []
i = 0
calc = Calculator(convergence={'eigenstates': 1e-6}, hund=1,
txt='exx_parallel.txt')
loa.set_calculator(calc)
p.append(loa.get_potential_energy())
exx.append(calc.get_exact_exchange())
print 'Potential energy :', p[i]
print 'Exchange energy :', exx[i]
print ''
## number of CPUs : 1
## Potential energy : -1.04946572514
## Exchange energy : -5.05252232093
## number of CPUs : 2
## Potential energy : -1.04946572514
## Exchange energy : -5.05252232093
from ase import *
from gpaw import Calculator
from gpaw.utilities import equal
a = 4.8 # => N = 4.8 / 0.2 = 24
loa = Atoms([Atom('C', [a / 2 + .3, a / 2 - .1, a / 2], magmom=2)],
pbc=False,
cell=(a, a, a))
p = []
exx = []
i = 0
calc = Calculator(convergence={'eigenstates': 1e-6},
hund=1,
txt='exx_parallel.txt')
loa.set_calculator(calc)
p.append(loa.get_potential_energy())
exx.append(calc.get_exact_exchange())
print 'Potential energy :', p[i]
print 'Exchange energy :', exx[i]
print ''
## number of CPUs : 1
## Potential energy : -1.04946572514
## Exchange energy : -5.05252232093
## number of CPUs : 2
## Potential energy : -1.04946572514
## Exchange energy : -5.05252232093
import numpy as np
from ASE import Atom
from gpaw.utilities import equal
from gpaw.cluster import Cluster
from gpaw import Calculator
from gpaw.analyse.expandyl import ExpandYl
R = 1.
H2 = Cluster([Atom('H',(0,0,0)), Atom('H',(0,0,R))])
H2.minimal_box(3.)
calc = Calculator(h=0.2, width=0.01, nbands=2)
H2.SetCalculator(calc)
H2.GetPotentialEnergy()
yl = ExpandYl(H2.center_of_mass(), calc.wfs.gd, Rmax=2.5)
gl = []
for n in range(calc.nbands):
psit_G = calc.kpt_u[0].psit_nG[n]
norm = calc.wfs.gd.integrate(psit_G**2)
g = yl.expand(psit_G)
gsum = np.sum(g)
# allow for 10 % inaccuracy in the norm
print "norm, sum=", norm, gsum
equal(norm, gsum, 0.1)
gl.append(g/gsum*100)
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 run_molecule(adsorbate, geometry, xc, code):
parameters = initialize_parameters(code, 0.01, h)
parameters['xc'] = xc
molecules = {
'None': ('NO', 8),
'N': ('N2', 8),
'O': ('O2', 8),
}
for name, nbands in [molecules[adsorbate]]:
if code != 'elk':
parameters['nbands'] = nbands
if geometry == 'fix':
mol = read_trajectory(code + '_' + name + '.traj')
else:
mol = molecule(name)
mol.center(vacuum=3.0 + add_vacuum)
if name == 'NO':
mol.translate((0, 0.1, 0))
#
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
#if name == 'N2':
# parameters['mixer'] = Mixer(beta=0.1, nmaxold=5, metric='new', weight=100.0)
#else:
# #parameters['eigensolver'] = 'cg'
# parameters['mixer'] = MixerSum(beta=0.2, nmaxold=5, metric='new', 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
elk_dir = 'elk_' + str(parameters['rgkmax'])
conv_param = 1.0
parameters['dir'] = elk_dir + '_' + name
#
calc = Calculator(**parameters)
#
mol.set_calculator(calc)
try:
if geometry == 'fix':
mol.get_potential_energy()
traj = PickleTrajectory(code + '_' + name + '.traj', mode='w')
traj.write(mol)
else:
opt = QuasiNewton(mol,
logfile=code + '_' + name + '.qn',
trajectory=code + '_' + name + '.traj')
opt.run(fmax=fmax)
except:
raise
tests = []
for nkpt in [4]:
for magmom in [3.0]:
test = 'test: nkpt = %d magmom = %1.1f' % (nkpt, magmom)
for nhosts in nhostswrite:
print test
file_prefix = 'Fe_%d_%1.1f_par%d'%(nkpt,magmom,nhosts)
fcc = Atoms([Atom('Fe', (0, 0, 0.0001) ,magmom=magmom)],
pbc=True,
cell = (2.55,2.55,2.55))
calc = Calculator(nbands=6,
gpts=(ng,ng,ng),
kpts=(4, 2, 2),
txt=file_prefix+'.txt',
tolerance = 1e-10)
fcc.set_calculator(calc)
#fcc[0].set_magnetic_moment(magmom)
e = fcc.get_potential_energy()
calc.write(file_prefix+'.gpw')
del calc,fcc
for nhosts in nhostsread:
file_prefix = 'Fe_%d_%1.1f_par%d'%(nkpt,magmom,nhosts)
print '------ restart calculation ',file_prefix, rank*111111111
calc = Calculator(file_prefix+'.gpw',
txt=file_prefix+'_restart.txt',
tolerance = 1e-10)
