def set_calculator(self):
kpoints = self.input["kpoints"]
if isinstance(kpoints, str):
kpoints = (self.input["kpoints"].replace("[",
"").replace("]",
"").split())
self._create_working_directory()
calc = GPAWcode(
mode=PW(float(self.input["encut"])),
xc=self.input["potential"],
occupations=MethfesselPaxton(width=float(self.input["sigma"])),
kpts=kpoints,
txt=self.working_directory + "/" + self.job_name + ".txt",
)
self.structure.set_calculator(calc)
def run_if_interactive(self):
if self.structure.calc is None:
kpoints = self.input['kpoints']
if isinstance(kpoints, str):
kpoints = self.input['kpoints'].replace('[', '').replace(
']', '').split()
self._create_working_directory()
calc = GPAW(
mode=PW(float(self.input['encut'])),
xc=self.input['potential'],
occupations=MethfesselPaxton(width=float(self.input['sigma'])),
kpts=kpoints,
txt=self.working_directory + '/' + self.job_name + '.txt')
self.structure.set_calculator(calc)
self.status.running = True
self.structure.calc.calculate(self.structure)
self.interactive_collect()
def run_if_interactive(self):
if self.structure.calc is None:
kpoints = self.input["kpoints"]
if isinstance(kpoints, str):
kpoints = (self.input["kpoints"].replace("[", "").replace(
"]", "").split())
self._create_working_directory()
calc = GPAW(
mode=PW(float(self.input["encut"])),
xc=self.input["potential"],
occupations=MethfesselPaxton(width=float(self.input["sigma"])),
kpts=kpoints,
txt=self.working_directory + "/" + self.job_name + ".txt",
)
self.structure.set_calculator(calc)
self.status.running = True
self.structure.calc.calculate(self.structure)
self.interactive_collect()
import numpy as np
from ase.structure import bulk
from gpaw import FermiDirac, MethfesselPaxton, MixerSum
from gpaw.utilities.bulk2 import GPAWRunner
strains = np.linspace(0.98, 1.02, 9)
a0 = 2.84
atoms = bulk('Fe', 'bcc', a0)
atoms.set_initial_magnetic_moments([2.3])
def f(name, dist, k, g):
tag = '%s-%02d-%2d' % (name, k, g)
r = GPAWRunner('Fe', atoms, strains, tag=tag)
r.set_parameters(xc='PBE',
occupations=dist,
basis='dzp',
nbands=9,
kpts=(k, k, k),
gpts=(g, g, g))
r.run()
for width in [0.05, 0.1, 0.15, 0.2]:
for k in [2, 4, 6, 8, 10, 12]:
f('FD-%.2f' % width, FermiDirac(width), k, 12)
f('MP-%.2f' % width, MethfesselPaxton(width), k, 12)
for g in range(8, 32, 4):
f('FD-%.2f' % 0.1, FermiDirac(0.1), 8, g)
from gpaw import GPAW, PW, MethfesselPaxton
from ase.spacegroup import crystal
from ase.io import write
a = 4.55643
mnsi = crystal(['Mn', 'Si'], [(0.1380, 0.1380, 0.1380),
(0.84620, 0.84620, 0.84620)],
spacegroup=198,
cellpar=[a, a, a, 90, 90, 90])
for atom in mnsi:
if atom.symbol == 'Mn':
atom.magmom = 0.5
mnsi.calc = GPAW(xc='PBE',
kpts=(2, 2, 2),
mode=PW(800),
occupations=MethfesselPaxton(width=0.005),
txt='mnsi.txt')
mnsi.get_potential_energy()
mnsi.calc.write('mnsi.gpw')
v = mnsi.calc.get_electrostatic_potential()
write('mnsi.cube', mnsi, data=v)
assert abs(v.max() - 13.43) < 0.01
def _main():
parser = argparse.ArgumentParser("Build and run Heusler slab",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("atoms", type=str,
help="Comma-separated list of XYZ/X2YZ atoms (ex: 'Ni,Mn,Sb' or 'Co,Co,Mn,Si')")
parser.add_argument("latconst", type=float,
help="Lattice constant in Ang (conventional cell cubic edge)")
parser.add_argument("layers", type=int,
help="Number of layers in the slab")
parser.add_argument("--prefix", type=str, default=None,
help="System name (obtained from atoms if not specified)")
parser.add_argument("--soc", action="store_true",
help="Use spin-orbit coupling")
args = parser.parse_args()
atoms = args.atoms.split(',')
prefix = make_prefix(atoms, args.layers, args.soc)
filenames = standard_filenames(prefix)
vacuum = 20 # Angstrom
surface_normal_cubic = (1, 1, 1)
slab = make_surface_system(atoms, args.latconst, args.layers, surface_normal_cubic, vacuum)
slab.set_pbc((True, True, False))
parallel_scf = make_parallel_scf()
ase.io.write(filenames['structure_xsf'], slab, format='xsf')
# Perform self-consistent calculation.
h = 0.2 # FD grid spacing (Angstrom). Complains about Poisson grid if too small (h = 0.1).
smearing_width = 0.1 # eV
Nk_scf = 12
# LCAO documentation strongly encorages ensuring grid points are divisible by 8
# to improve performance.
gpts = h2gpts(h, slab.get_cell(), idiv=8)
calc = GPAW(mode='lcao',
basis='dzp',
gpts=gpts,
xc='PBE',
kpts=(Nk_scf, Nk_scf, 1),
occupations=MethfesselPaxton(smearing_width),
random=True,
parallel=parallel_scf,
txt=filenames['scf_calc_out'])
slab.set_calculator(calc)
E_gs = slab.get_potential_energy()
calc.write(filenames['scf_restart'])
E_F = calc.get_fermi_level()
parprint("E_gs = {}".format(E_gs))
parprint("E_F = {}".format(E_F))
# Perform bands calculation.
band_path, band_path_labels = get_band_path(surface_normal_cubic)
ks_per_panel = 60
band_ks, band_xs, band_special_xs = bandpath(band_path, slab.get_cell(), len(path)*ks_per_panel + 1)
run_bands(prefix, E_F, band_ks, band_xs, band_special_xs, band_path_labels)