def eggbox(self):
atom = Atoms(self.symbol, pbc=True, cell=(self.a, self.a, self.a))
negg = 25
self.Eegg = np.zeros((self.ng, negg))
self.Fegg = np.zeros((self.ng, negg))
eigensolver = 'rmm-diis'
if self.symbol in ['Ti', 'Sn', 'Te', 'Ba']: eigensolver = 'cg'
for i in range(self.ng):
h = self.gridspacings[i]
calc = GPAW(h=h,
txt='%s-eggbox-%.3f.txt' % (self.symbol, h),
mixer=Mixer(beta=0.1, nmaxold=5, weight=50),
eigensolver=eigensolver,
maxiter=300,
nbands=-10,
**self.parameters)
atom.set_calculator(calc)
for j in range(negg):
x = h * j / (2 * negg - 2)
atom[0].x = x
try:
e = calc.get_potential_energy(atom, force_consistent=True)
self.Eegg[i, j] = e
except ConvergenceError:
raise
self.Fegg[i, j] = atom.get_forces()[0, 0]
def calculate_isolate_molecular_levels(self, tp):
atoms = self.isolate_atoms
atoms.pbc = True
p = tp.gpw_kwargs.copy()
p['nbands'] = None
if 'mixer' in p:
if not tp.spinpol:
p['mixer'] = Mixer(0.1, 5, weight=100.0)
else:
p['mixer'] = MixerDif(0.1, 5, weight=100.0)
p['poissonsolver'] = PoissonSolver(nn=2)
if type(p['basis']) is dict and len(p['basis']) == len(tp.atoms):
p['basis'] = 'dzp'
raise Warning('the dict basis is not surpported in isolate atoms')
if 'txt' in p and p['txt'] != '-':
p['txt'] = 'isolate_' + p['txt']
atoms.set_calculator(GPAW(**p))
atoms.get_potential_energy()
setups = atoms.calc.wfs.setups
self.project_basis_in_molecule = get_atom_indices(
self.project_atoms_in_molecule, setups)
kpt = atoms.calc.wfs.kpt_u[0]
s_mm = atoms.calc.wfs.S_qMM[0]
c_nm = eig_states_norm(kpt.C_nM, s_mm)
self.isolate_eigen_values = kpt.eps_n
self.isolate_eigen_vectors = c_nm
self.isolate_s_mm = s_mm
def makeGPAWcalc():
from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac, setup_paths
if p['psp'] == 'oldpaw':
setup_paths.insert(
0, '/scratch/users/ksb/gpaw/oldpaw/gpaw-setups-0.6.6300/')
psp = 'paw'
else:
psp = p['psp']
return GPAW(
mode=PW(p['pw']),
xc=p['xc'],
kpts=json.loads(p['kpts']),
spinpol=p['spinpol'],
convergence={'energy': p['econv']} #eV/electron
,
mixer=((MixerSum(beta=p['mixing'], nmaxold=p['nmix'], weight=100))
if p['spinpol'] else
(Mixer(beta=p['mixing'], nmaxold=p['nmix'], weight=100))),
maxiter=p['maxstep'],
nbands=p['nbands'],
occupations=FermiDirac(p['sigma']),
setups=psp,
eigensolver=Davidson(5),
poissonsolver=None,
txt='log',
symmetry={'do_not_symmetrize_the_density': True})
def gpawRestart(calc):
from gpaw import restart, PW, Davidson, Mixer, MixerSum, FermiDirac
return restart(
'preCalc_inp.gpw',
mode=PW(calc.pw),
xc=calc.xc,
kpts={
'density': calc.kpt,
'gamma': True
} if isinstance(calc.kpt, int) else calc.kpt,
spinpol=calc.magmom > 0,
convergence={'energy': calc.eConv} #eV/electron
,
mixer=((MixerSum(beta=calc.mixing, nmaxold=calc.nmix, weight=100))
if calc.magmom > 0 else
(Mixer(beta=calc.mixing, nmaxold=calc.nmix, weight=100))),
maxiter=calc.maxsteps,
nbands=-1 * calc.nbands,
occupations=FermiDirac(calc.sigma),
setups='sg15' #(pspDict[calc.psp]).pthFunc[cluster]
,
eigensolver=Davidson(5),
poissonsolver=
None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None
,
txt=str(calc) + '.txt',
symmetry={'do_not_symmetrize_the_density':
True} #ERROR IN LI bcc 111 surface
)
def gpawRestart(self):
from gpaw import restart, PW, Davidson, Mixer, MixerSum, FermiDirac
spinpol = any([x > 0 for x in self.magmomsinit()])
return restart(
'preCalc_inp.gpw',
mode=PW(self.pw),
xc=self.xc,
kpts=self.kpt(),
spinpol=spinpol,
convergence={'energy': self.econv()} #eV/electron
,
mixer=(
(MixerSum(beta=self.mixing(), nmaxold=self.nmix(), weight=100))
if spinpol else
(Mixer(beta=self.mixing(), nmaxold=self.nmix(), weight=100))),
maxiter=self.maxstep(),
nbands=self.nbands(),
occupations=FermiDirac(self.sigma()),
setups=self.psp #(pspDict[calc.psp]).pthFunc[cluster]
,
eigensolver=Davidson(5),
poissonsolver=
None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None
,
txt='%d_%s.txt' % (self.pw, self.xc),
symmetry={'do_not_symmetrize_the_density':
True}) #ERROR IN LI bcc 111 surface
def gpawCalc(calc, restart=False, surf=False):
"""
Accepts a job (either Surface or Bulk) and returns a Calculator
"""
from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac
return GPAW(
mode=PW(calc.pw) #eV
,
xc=calc.xc,
kpts={
'density': calc.kpt,
'gamma': True
} if isinstance(calc.kpt, int) else calc.kpt,
spinpol=calc.magmom > 0,
convergence={'energy': calc.eConv} #eV/electron
,
mixer=((MixerSum(beta=calc.mixing, nmaxold=calc.nmix, weight=100))
if calc.magmom > 0 else
(Mixer(beta=calc.mixing, nmaxold=calc.nmix, weight=100))),
maxiter=calc.maxsteps,
nbands=-1 * calc.nbands,
occupations=FermiDirac(calc.sigma),
setups='sg15',
eigensolver=Davidson(5),
poissonsolver=
None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None
,
txt=str(calc) + '.txt',
symmetry={'do_not_symmetrize_the_density':
True} #ERROR IN LI bcc 111 surface
)
def PBEcalc(self):
from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac
return GPAW(
mode=PW(self.pw()) #eV
,
xc='PBE',
kpts=self.kpt(),
spinpol=self.spinpol(),
convergence={'energy': self.econv()} #eV/electron
,
mixer=(
(MixerSum(beta=self.mixing(), nmaxold=self.nmix(), weight=100))
if self.spinpol() else
(Mixer(beta=self.mixing(), nmaxold=self.nmix(), weight=100))),
maxiter=self.maxstep(),
nbands=self.nbands(),
occupations=FermiDirac(self.sigma()),
setups=self.psp(),
eigensolver=Davidson(5),
poissonsolver=
None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None
,
txt='%d_%s.txt' % (self.pw(), self.xc()),
symmetry={'do_not_symmetrize_the_density':
True}) #ERROR IN LI bcc 111 surface
def eggbox(self, fd, setup='de'):
energies = []
for h in [0.16, 0.18, 0.2]:
a0 = 16 * h
atoms = Atoms(self.symbol, cell=(a0, a0, 2 * a0), pbc=True)
if 58 <= self.Z <= 70 or 90 <= self.Z <= 102:
M = 999
mixer = {'mixer': Mixer(0.01, 5)}
else:
M = 333
mixer = {}
atoms.calc = GPAW(h=h,
xc='PBE',
symmetry='off',
setups=self.setup,
maxiter=M,
txt=fd,
**mixer)
atoms.positions += h / 2 # start with broken symmetry
e0 = atoms.get_potential_energy()
atoms.positions -= h / 6
e1 = atoms.get_potential_energy()
atoms.positions -= h / 6
e2 = atoms.get_potential_energy()
atoms.positions -= h / 6
e3 = atoms.get_potential_energy()
energies.append(np.ptp([e0, e1, e2, e3]))
# print(energies)
return energies
def convergence(self, n, fd):
a = 3.0
atoms = Atoms(self.symbol, cell=(a, a, a), pbc=True)
M = 333
if 58 <= self.Z <= 70 or 90 <= self.Z <= 102:
M = 999
mixer = {'mixer': Mixer(0.01, 5)}
else:
mixer = {}
atoms.calc = GPAW(mode=PW(1500),
xc='PBE',
setups='ga' + str(n),
symmetry='off',
maxiter=M,
txt=fd,
**mixer)
e0 = atoms.get_potential_energy()
de0 = 0.0
for ec in range(800, 200, -100):
atoms.calc.set(mode=PW(ec))
atoms.calc.set(eigensolver='rmm-diis')
de = abs(atoms.get_potential_energy() - e0)
if de > 0.1:
ec0 = ec + (de - 0.1) / (de - de0) * 100
return ec0
de0 = de
return 250
def eggbox(self, n, fd):
h = 0.18
a0 = 16 * h
atoms = Atoms(self.symbol, cell=(a0, a0, 2 * a0), pbc=True)
M = 333
if 58 <= self.Z <= 70 or 90 <= self.Z <= 102:
M = 999
mixer = {'mixer': Mixer(0.01, 5)}
else:
mixer = {}
atoms.calc = GPAW(h=h,
xc='PBE',
symmetry='off',
setups='ga' + str(n),
maxiter=M,
txt=fd,
**mixer)
atoms.positions += h / 2 # start with broken symmetry
e0 = atoms.get_potential_energy()
atoms.positions -= h / 6
e1 = atoms.get_potential_energy()
atoms.positions -= h / 6
e2 = atoms.get_potential_energy()
atoms.positions -= h / 6
e3 = atoms.get_potential_energy()
return np.ptp([e0, e1, e2, e3])
def test():
vdw = VDWFunctional('vdW-DF', verbose=1)
d = 3.9
x = d / sqrt(3)
L = 3.0 + 2 * 4.0
dimer = Atoms('Ar2', [(0, 0, 0), (x, x, x)], cell=(L, L, L))
dimer.center()
calc = GPAW(h=0.2,
xc=dict(name='revPBE', stencil=1),
mixer=Mixer(0.8, 7, 50.0),
eigensolver=Davidson(5))
dimer.set_calculator(calc)
e2 = dimer.get_potential_energy()
calc.write('Ar2.gpw')
e2vdw = calc.get_xc_difference(vdw)
e2vdwb = GPAW('Ar2.gpw').get_xc_difference(vdw)
print(e2vdwb - e2vdw)
assert abs(e2vdwb - e2vdw) < 1e-9
del dimer[1]
e = dimer.get_potential_energy()
evdw = calc.get_xc_difference(vdw)
E = 2 * e - e2
Evdw = E + 2 * evdw - e2vdw
print(E, Evdw)
assert abs(E - -0.0048) < 6e-3, abs(E)
assert abs(Evdw - +0.0223) < 3e-2, abs(Evdw)
print(e2, e)
equal(e2, -0.001581923, energy_tolerance)
equal(e, -0.003224226, energy_tolerance)
def dimer(self):
dimer = Atoms([self.symbol, self.symbol],
pbc=True,
cell=(self.a, self.a, self.a))
self.Edimer = np.zeros((self.ng, 7))
self.Fdimer = np.zeros((self.ng, 7, 2))
q0 = self.d0 / np.sqrt(3)
eigensolver = 'rmm-diis'
if self.symbol in ['Ti', 'Sn', 'Te', 'Ba']: eigensolver = 'cg'
for i in range(self.ng):
h = self.gridspacings[i]
calc = GPAW(
h=h,
txt='%s-dimer-%.3f.txt' % (self.symbol, h),
mixer=Mixer(beta=0.1, nmaxold=5, weight=50),
#mixer=Mixer(beta=0.05, nmaxold=7, weight=100),
eigensolver=eigensolver,
maxiter=300,
nbands=-10,
**self.parameters)
dimer.set_calculator(calc)
y = []
for j in range(-3, 4):
q = q0 * (1 + j * 0.02)
dimer.positions[1] = (q, q, q)
try:
e = calc.get_potential_energy(dimer, force_consistent=True)
self.Edimer[i, j + 3] = e
except ConvergenceError:
raise
self.Fdimer[i, j + 3] = dimer.get_forces()[:, 0]
def get_calculator():
calc = GPAW(h=0.2,
mode = 'lcao',
basis = 'szp(dzp)',
mixer=Mixer(beta=0.1, nmaxold=5, weight=50.0),
poissonsolver=PoissonSolver(nn='M', relax='GS'),
txt='C5H12.txt')
return calc
def create_gpaw(comm):
from gpaw import GPAW, FermiDirac, PoissonSolver, setup_paths
from gpaw import Mixer
setup_paths.insert(0, '.')
calc = GPAW(xc='PBE',
occupations=FermiDirac(width=0.02),
mixer=Mixer(beta=0.10, nmaxold=5, weight=100.0),
communicator=comm)
return calc
def GLLBSC_work():
calc = GPAW(xc='GLLBSC',
mixer=Mixer(0.5, 5, 50.0),
eigensolver='cg',
kpts=(4, 1, 1),
convergence={'density': 1e-8})
atoms.set_calculator(calc)
return atoms.get_potential_energy()
def MGGA_fail():
calc = GPAW(xc='TPSS',
mixer=Mixer(0.5, 5, 50.0),
eigensolver='cg',
kpts=(1, 2, 1),
convergence={'density': 1e-8})
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.set(kpts=(4, 1, 1))
return atoms.get_potential_energy()
def relaxGPAW(structure, label, forcemax=0.1, niter_max=1, steps=10):
'''
Relax a structure and saves the trajectory based in the index i
Parameters
----------
structure : ase Atoms object to be relaxed
i : index which the trajectory is saved under
ranks: ranks of the processors to relax the structure
Returns
-------
structure : relaxed Atoms object
'''
# Create calculator
calc=GPAW(#poissonsolver = PoissonSolver(relax = 'GS',eps = 1.0e-7), # C
mode = 'lcao',
basis = 'dzp',
xc='PBE',
#gpts = h2gpts(0.2, structure.get_cell(), idiv = 8), # C
occupations=FermiDirac(0.1),
#maxiter=99, # C
maxiter=49, # Sn3O3
mixer=Mixer(nmaxold=5, beta=0.05, weight=75),
nbands=-50,
#kpts=(1,1,1), # C
kpts=(2,2,1), # Sn3O3
txt = label+ '_lcao.txt')
# Set calculator
structure.set_calculator(calc)
# loop a number of times to capture if minimization stops with high force
# due to the VariansBreak calls
niter = 0
# If the structure is already fully relaxed just return it
if (structure.get_forces()**2).sum(axis = 1).max()**0.5 < forcemax:
return structure
traj = Trajectory(label+'_lcao.traj','w', structure)
while (structure.get_forces()**2).sum(axis = 1).max()**0.5 > forcemax and niter < niter_max:
dyn = BFGS(structure,
logfile=label+'.log')
vb = VariansBreak(structure, dyn, min_stdev = 0.01, N = 15)
dyn.attach(traj)
dyn.attach(vb)
dyn.run(fmax = forcemax, steps = steps)
niter += 1
return structure
def getcalc(**kwargs):
kwargs1 = dict(
xc='oldLDA',
gpts=(32, 24, 32),
setups={'Ag': '11'},
#h=0.24,
poissonsolver=PoissonSolver(relax='GS'),
mixer=Mixer(0.5, 5, 50.0),
mode='lcao',
basis='sz(dzp)')
kwargs1.update(kwargs)
return GPAW(**kwargs1)
def calculate(**kwargs1):
kwargs = dict(mode=mode,
basis='sz(dzp)',
eigensolver=Davidson(4) if mode != 'lcao' else None,
xc=vdw_df(),
h=0.25,
convergence=dict(energy=1e-6),
mixer=Mixer(0.5, 5, 10.))
kwargs.update(kwargs1)
calc = GPAW(**kwargs)
system.set_calculator(calc)
system.get_potential_energy()
return calc
def get_calculator():
calc = GPAW(gpts=(64, 64, 64), #h=0.18, gives 64x60x60
mode='lcao',
basis='szp(dzp)',
nbands=-5,
xc='LDA',
width=0.1,
mixer=Mixer(beta=0.1, nmaxold=5, weight=50.0),
poissonsolver=PoissonSolver(nn='M', relax='GS'),
convergence={'energy': 1e-4, 'bands': -3},
stencils=(3, 3),
txt='nanoparticle.txt')
return calc
def relaxGPAW(structure,
label,
calc=None,
forcemax=0.1,
niter_max=1,
steps=10):
# Create calculator
if calc is None:
calc = GPAW(
poissonsolver=PoissonSolver(relax='GS', eps=1.0e-7), # C
mode='lcao',
basis='dzp',
xc='PBE',
gpts=h2gpts(0.2, structure.get_cell(), idiv=8), # C
occupations=FermiDirac(0.1),
maxiter=99, # C
#maxiter=49, # Sn3O3
mixer=Mixer(nmaxold=5, beta=0.05, weight=75),
nbands=-50,
#kpts=(1,1,1), # C
kpts=(2, 2, 1), # Sn3O3
txt=label + '_lcao.txt')
else:
calc.set(txt=label + '_true.txt')
# Set calculator
structure.set_calculator(calc)
# loop a number of times to capture if minimization stops with high force
# due to the VariansBreak calls
niter = 0
# If the structure is already fully relaxed just return it
if (structure.get_forces()**2).sum(axis=1).max()**0.5 < forcemax:
return structure
traj = Trajectory(label + '_lcao.traj', 'w', structure)
while (structure.get_forces()**
2).sum(axis=1).max()**0.5 > forcemax and niter < niter_max:
dyn = BFGS(structure, logfile=label + '.log')
vb = VariansBreak(structure, dyn, min_stdev=0.01, N=15)
dyn.attach(traj)
dyn.attach(vb)
dyn.run(fmax=forcemax, steps=steps)
niter += 1
E = structure.get_potential_energy()
F = structure.get_forces()
return structure, E, F
def get_calculator():
basis = 'szp(dzp)'
calc = GPAW(
gpts=(64, 64, 128), # ca h=0.25
width=0.1,
nbands=-5,
xc='LDA',
mode='lcao',
txt='C2_Cu100.txt',
mixer=Mixer(beta=0.1, nmaxold=5, weight=50.0),
poissonsolver=PoissonSolver(nn='M', relax='GS'),
stencils=(3, 3),
maxiter=400,
basis=basis)
return calc
def simulate_CO(self, energy_cutoff, n_k_points):
# # # Create Al bulk and initialize calculator parameters # # #
mixer = Mixer(beta=0.1, nmaxold=5, weight=50.0) # Recommended values for small systems
calc = GPAW(mode=PW(energy_cutoff), # use the LCAO basis mode
h=0.18, # grid spacing, recommended value in this course
xc='PBE', # Exchange-correlation functional
mixer=mixer,
# k-point grid - LOOP OVER LATER TO CHECK "CONVERGENCE"
kpts=(n_k_points, n_k_points, n_k_points),
txt='simulate_CO_GPAW.txt') # name of GPAW output text file
self.adsorbate.set_calculator(calc)
return self.adsorbate.get_potential_energy()
def efield(efield=0.05, n=30):
printit('running GS calculation for {}'.format(efield))
fname = "sb_relaxed.cif"
a = read(fname)
atom = read(fname)
wire = make_supercell(atom, [[n, 0, 0], [0, 1, 0], [
0, 0, 1]], wrap=True, tol=1e-05)
wire.center(vacuum=15, axis=0)
a = wire.copy()
if not os.path.isfile('gs_{}.gpw'.format(efield)):
calc = GPAW( # mode='lcao',
mode='fd',
basis='szp(dzp)',
# eigensolver='cg',
#mixer=Mixer(beta=0.2, nmaxold=3, weight=70.0),
xc='PBE',
# poissonsolver=DipoleCorrection(PoissonSolver(relax='GS'), 2),
mixer=Mixer(beta=0.06, nmaxold=5, weight=100.0),
occupations=FermiDirac(width=0.1),
kpts={'density': 4.5},
txt='gs_output_{}.txt'.format(efield),
h=0.20,
external=ConstantElectricField(efield, [0, 0, 1]))
a.set_calculator(calc)
a.get_potential_energy()
calc.write('gs_{}.gpw'.format(efield))
calc = GPAW('gs_{}.gpw'.format(efield),
nbands=-100,
fixdensity=True,
symmetry='off',
kpts={'path': 'XGX', 'npoints': 100},
convergence={'bands': 'CBM+1'},
txt='gs_output_{}.txt'.format(efield))
calc.get_potential_energy()
bs = calc.band_structure()
bs.plot(filename='bandstructure_{}.png'.format(
efield), show=False, emax=calc.get_fermi_level()+1, emin=calc.get_fermi_level()-1)
bs.write('bs_{}.json'.format(
efield))
try:
gap, p1, p2 = get_gap(calc)
printit("{} {} {} {}".format(efield, gap, p1, p2), fname="gaps.dat")
except:
None
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
def simulate_surface_Al(self, miller_index, energy_cutoff, n_k_points):
''' Function that adds surfaces to the aluminum nano particle '''
mixer = Mixer(beta=0.1, nmaxold=5, weight=50.0) # Recommended values for small systems
# Initialize new calculator that only considers k-space in xy-plane,
# since we're only looking at the surface
calc = GPAW(mode=PW(energy_cutoff), # use the LCAO basis mode
h=0.18, # grid spacing
xc='PBE', # XC-functional
mixer=mixer,
kpts=(n_k_points, n_k_points, 1), # k-point grid
txt='simulate_surface_Al_' + miller_index + 'GPAW.txt') # name of GPAW output text file
self.get_surface_object(miller_index).set_calculator(calc)
# Calc pot. energy of FCC
surface_energy = self.surfaces[miller_index].get_potential_energy()
self.surfaces[miller_index]['energy'] = surface_energy
return surface_energy
def singleGPAW(structure, label):
# Create calculator
calc = GPAW(poissonsolver=PoissonSolver(relax='GS', eps=1.0e-7),
mode='lcao',
basis='dzp',
xc='PBE',
gpts=h2gpts(0.2, structure.get_cell(), idiv=8),
occupations=FermiDirac(0.1),
maxiter=99,
mixer=Mixer(nmaxold=5, beta=0.05, weight=75),
nbands=-50,
kpts=(1, 1, 1),
txt=label + '_single_lcao.txt')
# Set calculator
structure.set_calculator(calc)
return structure.get_potential_energy(), structure.get_forces()
def convergence(self, fd, setup='de'):
a = 3.0
atoms = Atoms(self.symbol, cell=(a, a, a), pbc=True)
if 58 <= self.Z <= 70 or 90 <= self.Z <= 102:
M = 999
mixer = {'mixer': Mixer(0.01, 5)}
else:
M = 333
mixer = {}
atoms.calc = GPAW(mode=PW(1500),
xc='PBE',
setups=self.setup,
symmetry='off',
maxiter=M,
txt=fd,
**mixer)
e0 = atoms.get_potential_energy()
energies = [e0]
iters = atoms.calc.get_number_of_iterations()
oldfde = None
area = 0.0
def f(x):
return x**0.25
for ec in range(800, 200, -100):
atoms.calc.set(mode=PW(ec))
atoms.calc.set(eigensolver='rmm-diis')
de = atoms.get_potential_energy() - e0
energies.append(de)
# print(ec, de)
fde = f(abs(de))
if fde > f(0.1):
if oldfde is None:
return np.inf, iters, energies
ec0 = ec + (fde - f(0.1)) / (fde - oldfde) * 100
area += ((ec + 100) - ec0) * (f(0.1) + oldfde) / 2
break
if oldfde is not None:
area += 100 * (fde + oldfde) / 2
oldfde = fde
return area, iters, energies
def simulate_bulk_Al(self, energy_cutoff, n_k_points):
''' Function that calculates volume and energy for bulk
aluminium. The function uses GPAW with a plane wave basis set
and the PBE exchange correlation. '''
# # # Create Al bulk and initialize calculator parameters # # #
mixer = Mixer(beta=0.1, nmaxold=5, weight=50.0) # Recommended values for small systems
calc = GPAW(mode=PW(energy_cutoff), # use the LCAO basis mode
h=0.18, # grid spacing, recommended value in this course
xc='PBE', # Exchange-correlation functional
mixer=mixer,
# k-point grid - LOOP OVER LATER TO CHECK "CONVERGENCE"
kpts=(n_k_points, n_k_points, n_k_points),
txt='simulate_bulk_Al_GPAW.txt') # name of GPAW output text file
self.bulk_Al['object'].set_calculator(calc)
self.bulk_Al['volume'] = self.bulk_Al['object'].get_volume()
self.bulk_Al['energy'] = self.bulk_Al['object'].get_potential_energy()
return self.bulk_Al['energy']
def makeGPAWcalc(p):
from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac
return GPAW(
mode=PW(p['pw']),
xc=p['xc'],
kpts=kpt,
spinpol=spinpol,
convergence={'energy': p['econv']} #eV/electron
,
mixer=((MixerSum(beta=p['mixing'], nmaxold=p['nmix'], weight=100))
if spinpol else
(Mixer(beta=p['mixing'], nmaxold=p['nmix'], weight=100))),
maxiter=p['maxstep'],
nbands=p['nbands'],
occupations=FermiDirac(p['sigma']),
setups=p['psp'],
eigensolver=Davidson(5),
poissonsolver=None,
txt='log',
symmetry={'do_not_symmetrize_the_density': True})
