def __init__(self, atoms, kpts=(1,1,1), use_spline=False,
maximum_angular_momenta={}, **kwargs):
if type(kpts) == float or type(kpts) == int:
mp = kptdensity2monkhorstpack(atoms, kptdensity=kpts, even=False)
kpts = tuple(mp)
if use_spline:
kwargs['Hamiltonian_PolynomialRepulsive'] = 'SetForAll { No }'
else:
kwargs['Hamiltonian_PolynomialRepulsive'] = 'SetForAll { Yes }'
if type(kpts) == float or type(kpts) == int:
mp = kptdensity2monkhorstpack(atoms, kptdensity=kpts, even=False)
kpts = tuple(mp)
kwargs['Hamiltonian_MaxAngularMomentum_'] = ''
symbols = atoms.get_chemical_symbols()
unique_symbols = list(set(symbols))
for s in unique_symbols:
key = 'Hamiltonian_MaxAngularMomentum_%s' % s
maxmom = maximum_angular_momenta[s]
kwargs[key] = 'spd'[maxmom].__repr__()
kwargs['Hamiltonian_SCC'] = 'Yes'
kwargs['Hamiltonian_ShellResolvedSCC'] = 'No'
Dftb.__init__(self, atoms=atoms, kpts=kpts, **kwargs)
def row(project, uid):
db = databases[project]
if not hasattr(db, 'meta'):
db.meta = ase.db.web.process_metadata(db)
prefix = '{}/{}-{}-'.format(tmpdir, project, uid)
key = db.meta.get('unique_key', 'id')
try:
uid = int(uid)
except ValueError:
pass
row = db.get(**{key: uid})
s = Summary(row, db.meta, SUBSCRIPT, prefix)
atoms = Atoms(cell=row.cell, pbc=row.pbc)
n1, n2, n3 = kptdensity2monkhorstpack(atoms, kptdensity=1.8, even=False)
return render_template('summary.html',
project=project,
s=s,
uid=uid,
n1=n1,
n2=n2,
n3=n3,
home=home,
back=True,
ase_db_footer=ase_db_footer,
md=db.meta,
open_ase_gui=open_ase_gui)
def kpts2sizeandoffsets(size=None, density=None, gamma=None, even=None,
atoms=None):
"""Helper function for selecting k-points.
Use either size or density.
size: 3 ints
Number of k-points.
density: float
K-point density in units of k-points per Ang^-1.
gamma: None or bool
Should the Gamma-point be included? Yes / no / don't care:
True / False / None.
even: None or bool
Should the number of k-points be even? Yes / no / don't care:
True / False / None.
atoms: Atoms object
Needed for calculating k-point density.
"""
if size is None:
if density is None:
size = [1, 1, 1]
else:
size = kptdensity2monkhorstpack(atoms, density, even)
offsets = [0, 0, 0]
if gamma is not None:
for i, s in enumerate(size):
if atoms.pbc[i] and s % 2 != bool(gamma):
offsets[i] = 0.5 / s
return size, offsets
def kpts2sizeandoffsets(size=None, density=None, gamma=None, even=None,
atoms=None):
"""Helper function for selecting k-points.
Use either size or density.
size: 3 ints
Number of k-points.
density: float
K-point density in units of k-points per Ang^-1.
gamma: None or bool
Should the Gamma-point be included? Yes / no / don't care:
True / False / None.
even: None or bool
Should the number of k-points be even? Yes / no / don't care:
True / False / None.
atoms: Atoms object
Needed for calculating k-point density.
"""
if size is None:
if density is None:
size = [1, 1, 1]
else:
size = kptdensity2monkhorstpack(atoms, density, even)
offsets = [0, 0, 0]
if gamma is not None:
for i, s in enumerate(size):
if atoms.pbc[i] and s % 2 != bool(gamma):
offsets[i] = 0.5 / s
return size, offsets
def __init__(self, geometryfile, **kwargs):
self.geometryfile = Path(geometryfile)
assert (self.geometryfile.exists()
and self.geometryfile.is_file()), "No structure input found."
self.dirpath = Path(self.geometryfile).parent
self.structure = Structure(self.geometryfile)
xc = kwargs.get("xc", "pbe")
spin = kwargs.get("spin", "none")
tier = kwargs.get("tier", 1)
basis = kwargs.get("basis", "tight")
k_grid = kwargs.get("k_grid", [])
k_density = kwargs.get("k_density", 5)
if k_grid == []:
k_grid = kptdensity2monkhorstpack(self.structure,
kptdensity=k_density,
even=False)
species_dir = Path(os.getenv("AIMS_SPECIES_DIR"))
species_dir = species_dir.joinpath(basis)
self.aseargs = {
"xc": xc,
"relativistic": ("atomic_zora", "scalar"),
"spin": spin,
"k_grid": list(k_grid),
"species_dir": species_dir,
"tier": tier,
}
self.tasks = set()
tasks = kwargs.get("tasks", set())
self.set_tasks(tasks)
if self.structure.is_2d():
logger.info("Structure is recognized as two-dimensional.")
def __init__(self,
atoms,
kpts=(1, 1, 1),
label='cp2k_run',
run_type=None,
**extra_cp2k_kwargs):
try:
niggli_reduce(atoms)
except RuntimeError:
pass
kwargs = {k: None for k in CP2K.default_parameters}
kwargs['debug'] = False
kwargs['potential_file'] = 'GTH_POTENTIALS'
kwargs['pseudo_potential'] = 'GTH-PBE'
kwargs['basis_set_file'] = 'BASIS_MOLOPT'
kwargs['basis_set'] = 'DZVP-MOLOPT-SR-GTH'
if type(kpts) == float or type(kpts) == int:
mp = kptdensity2monkhorstpack(atoms, kptdensity=kpts, even=False)
kpts = tuple(mp)
inp = template.replace('__MPMESH__', ' '.join(map(str, kpts)))
kwargs['inp'] = inp
kwargs.update(extra_cp2k_kwargs)
CP2K.__init__(self, atoms=atoms, label=label, **kwargs)
def row2dct(
row,
key_descriptions: Dict[str, Tuple[str, str,
str]] = {}) -> Dict[str, Any]:
"""Convert row to dict of things for printing or a web-page."""
from ase.db.core import float_to_time_string, now
dct = {}
atoms = Atoms(cell=row.cell, pbc=row.pbc)
dct['size'] = kptdensity2monkhorstpack(atoms, kptdensity=1.8, even=False)
dct['cell'] = [['{:.3f}'.format(a) for a in axis] for axis in row.cell]
par = ['{:.3f}'.format(x) for x in cell_to_cellpar(row.cell)]
dct['lengths'] = par[:3]
dct['angles'] = par[3:]
stress = row.get('stress')
if stress is not None:
dct['stress'] = ', '.join('{0:.3f}'.format(s) for s in stress)
dct['formula'] = Formula(row.formula).format('abc')
dipole = row.get('dipole')
if dipole is not None:
dct['dipole'] = ', '.join('{0:.3f}'.format(d) for d in dipole)
data = row.get('data')
if data:
dct['data'] = ', '.join(data.keys())
constraints = row.get('constraints')
if constraints:
dct['constraints'] = ', '.join(c.__class__.__name__
for c in constraints)
keys = ({'id', 'energy', 'fmax', 'smax', 'mass', 'age'}
| set(key_descriptions) | set(row.key_value_pairs))
dct['table'] = []
for key in keys:
if key == 'age':
age = float_to_time_string(now() - row.ctime, True)
dct['table'].append(('ctime', 'Age', age))
continue
value = row.get(key)
if value is not None:
if isinstance(value, float):
value = '{:.3f}'.format(value)
elif not isinstance(value, str):
value = str(value)
desc, unit = key_descriptions.get(key, ['', '', ''])[1:]
if unit:
value += ' ' + unit
dct['table'].append((key, desc, value))
return dct
def prepare_k_point_convergence(self, **preparation_kwargs):
""" Prepares files for calculations in directory `aimstools_kpoint_convergence/`. """
logger.info("Preparing files for calculation ...")
prep_kwargs = preparation_kwargs
_ = prep_kwargs.pop("k_density", 0)
_ = prep_kwargs.pop("k_grid", None)
setup = FHIAimsSetup(self.geometryfile, **prep_kwargs)
if setup.dirpath.joinpath("geometry.in").exists():
logger.info("Using geometry from {} .".format(
str(setup.dirpath.joinpath("geometry.in"))))
else:
setup.setup_geometry()
if setup.dirpath.joinpath("control.in").exists():
logger.info("Using calculation setup from {} .".format(
str(setup.dirpath.joinpath("control.in"))))
else:
setup.setup_control()
if setup.dirpath.joinpath("submit.sh").exists():
logger.info("Using submission script from {} .".format(
str(setup.dirpath.joinpath("submit.sh"))))
else:
setup.write_submission_file()
geometry = setup.dirpath.joinpath("geometry.in")
control = setup.dirpath.joinpath("control.in")
submit = setup.dirpath.joinpath("submit.sh")
files_to_copy = (geometry, control, submit)
k_grids = np.array(
[
kptdensity2monkhorstpack(
setup.structure, kptdensity=i, even=False)
for i in range(1, 12)
],
dtype=int,
)
k_grids = np.unique(k_grids, axis=0)
logger.info(
"Preparing {} calculations for k-point convergence.".format(
len(k_grids)))
for i, k in enumerate(k_grids):
kstring = "{}x{}x{}".format(*k)
targetdir = setup.dirpath.joinpath(self.dirname).joinpath(kstring)
targetdir.mkdir(parents=True, exist_ok=True)
for n in files_to_copy:
shutil.copy(str(n), str(targetdir.joinpath(n.parts[-1])))
for line in fileinput.input(str(targetdir.joinpath("control.in")),
inplace=True):
if "k_grid" in line:
print("k_grid \t \t {} {} {}\n".format(*k), end="")
else:
print(line, end="")
def get_kpts(atoms, kptdensity):
''' Returns a tuple corresponding to the appropriate
Monkhorst-Pack mesh for the requested k-point density
and Atoms object.
atoms: an Atoms object
kptdensity: the target k-point density in reciprocal
Angstrom. If None, the Gamma-point only
mesh is returned (i.e. (1 x 1 x 1)).
'''
if kptdensity is None:
kpts = (1, 1, 1)
else:
kpts = tuple(kptdensity2monkhorstpack(atoms, even=False,
kptdensity=kptdensity))
return kpts
def get_bz_k_points(self):
kgrid = self['kpts']
if type(kgrid) in [int, float]:
kgrid = kptdensity2monkhorstpack(self.atoms, kgrid, False)
bz_k_points = []
n1 = kgrid[0]
n2 = kgrid[1]
n3 = kgrid[2]
for i in range(n1):
for j in range(n2):
# Monkhorst Pack Grid [H.J. Monkhorst and J.D. Pack,
# Phys. Rev. B 13, 5188 (1976)]
for k in range(n3):
bz_k_points.append((0.5 * float(2 * i - n1 + 1) / n1,
0.5 * float(2 * j - n2 + 1) / n2,
0.5 * float(2 * k - n3 + 1) / n3))
return np.array(bz_k_points)
def __init__(self,
atoms,
kpts=(1, 1, 1),
use_spline=False,
maximum_angular_momenta={},
read_chg=False,
label='dftb_run',
**extra_dftbplus_kwargs):
if type(kpts) == float or type(kpts) == int:
mp = kptdensity2monkhorstpack(atoms, kptdensity=kpts, even=False)
kpts = tuple(mp)
s = 'No' if use_spline else 'Yes'
polyrep = 'SetForAll { %s }' % s
self.read_chg = read_chg
parameters = {
'Hamiltonian_SCC': 'Yes',
'Hamiltonian_OrbitalResolvedSCC': 'Yes',
'Hamiltonian_SCCTolerance': '1e-5',
'Hamiltonian_MaxSCCIterations': 250,
'Hamiltonian_MaxAngularMomentum_': '',
'Hamiltonian_Charge': '0.000000',
'Hamiltonian_ReadInitialCharges': 'No',
'Hamiltonian_Filling': 'Fermi {',
'Hamiltonian_Filling_empty': 'Temperature [Kelvin] = 500',
'Hamiltonian_PolynomialRepulsive': polyrep,
'Hamiltonian_Eigensolver': 'RelativelyRobust {}',
}
symbols = atoms.get_chemical_symbols()
unique_symbols = list(set(symbols))
for s in unique_symbols:
key = 'Hamiltonian_MaxAngularMomentum_%s' % s
maxmom = maximum_angular_momenta[s]
parameters[key] = 'spd'[maxmom].__repr__()
parameters.update(extra_dftbplus_kwargs)
Dftb.__init__(self, label=label, kpts=kpts, atoms=atoms, **parameters)
def summary(id):
db = database()
if not hasattr(db, 'meta'):
db.meta = ase.db.web.process_metadata(db)
prfx = prefix() + str(id) + '-'
row = db.get(id)
s = Summary(row, db.meta, SUBSCRIPT, prfx, tmpdir)
atoms = Atoms(cell=row.cell, pbc=row.pbc)
n1, n2, n3 = kptdensity2monkhorstpack(atoms,
kptdensity=1.8,
even=False)
return render_template('summary.html',
project=request.args.get('project', 'default'),
projects=projects,
s=s,
n1=n1,
n2=n2,
n3=n3,
home=home,
md=db.meta,
open_ase_gui=open_ase_gui)
def summary(id):
db = database()
if db is None:
return ''
if not hasattr(db, 'meta'):
db.meta = ase.db.web.process_metadata(db)
prfx = prefix() + str(id) + '-'
row = db.get(id)
s = Summary(row, db.meta, SUBSCRIPT, prfx, tmpdir)
atoms = Atoms(cell=row.cell, pbc=row.pbc)
n1, n2, n3 = kptdensity2monkhorstpack(atoms, kptdensity=1.8, even=False)
return render_template('summary.html',
project=request.args.get('project', 'default'),
projects=projects,
s=s,
n1=n1,
n2=n2,
n3=n3,
home=home,
md=db.meta,
open_ase_gui=open_ase_gui)
f.create_dataset('Y', (n_images, 1))
else:
print 'ERROR: You must supply the dimension.'
exit(-1)
return f
if __name__ == '__main__':
parser = parseArgs()
os.environ['DFTB_PREFIX'] = '/home/kryczko/dftbplus-17.1.x86_64-linux/matsci-0-3/'
os.environ['DFTB_COMMAND'] = '/home/kryczko/dftbplus-17.1.x86_64-linux/bin/dftb+'
atoms = aseio.read(parser.file, format='vasp')
dftb_options = {}
for elem in list(set(atoms.get_chemical_symbols())):
dftb_options['Hamiltonian_MaxAngularMomentum_' + elem] = '"p"'
dftb_options['kpts'] = kptdensity2monkhorstpack(atoms, kptdensity=1.0)
batch_size = multiprocessing.cpu_count()
pool = Pool(batch_size)
h5_file = createH5File(parser)
iters = parser.num / batch_size + 1
for i in range(iters):
start = i * batch_size
end = (i + 1) * batch_size
if end > parser.num:
end = parser.num
results = pool.map(getImageAndEnergy, zip(range(batch_size), [atoms] * (end - start), [dftb_options] * (end - start), [parser] * (end - start)))
images, energies = [], []
for im, e in results:
images.append(im)
from ase.db import connect
from ase.build import bulk
from ase.data import atomic_numbers, covalent_radii
from ase.calculators.calculator import kptdensity2monkhorstpack
from gpaw import GPAW, PW, Mixer, FermiDirac
calc = GPAW(
mode=PW(400),
xc='LDA',
txt='gpawout_diamond.txt',
occupations=FermiDirac(0.05),
mixer=Mixer(0.1, 5, 100.),
convergence={
'density': 1e-5,
'eigenstates': 1e-5
},
)
db = connect('training.db')
Z = atomic_numbers['Si']
d0 = 2 * covalent_radii[Z]
a0 = d0 * 4. / np.sqrt(3)
for x in np.arange(0.9, 1.31, 0.05):
atoms = bulk('Si', 'diamond', a=a0 * x)
kpts = kptdensity2monkhorstpack(atoms, 2.5, even=False)
calc.set(kpts=kpts)
atoms.set_calculator(calc)
atoms.get_potential_energy()
db.write(atoms, relaxed=1, gaid=0)
