def test_optimizer(systems, optimizer, calculator, prefix='', db=None,
eggbox=0.0):
"""Test optimizer on systems."""
for name, atoms in systems:
if db is not None:
optname = optimizer.__name__
id = db.reserve(optimizer=optname, name=name)
if id is None:
continue
atoms = atoms.copy()
tag = '{}{}-{}'.format(prefix, optname, name)
atoms.calc = calculator(txt=tag + '.txt')
error, nsteps, texcl, tincl = run_test(atoms, optimizer, tag,
eggbox=eggbox)
if db is not None:
db.write(atoms,
id=id,
optimizer=optname,
name=name,
error=error,
n=nsteps,
t=texcl,
T=tincl,
eggbox=eggbox)
def write(self, outfile: Union[str, BinaryIO, TextIO]):
"""
Writes structure container to a file.
Parameters
----------
outfile
output file name or file object
"""
# Write cluster space to tempfile
temp_cs_file = tempfile.NamedTemporaryFile()
self.cluster_space.write(temp_cs_file.name)
# Write fit structures as an ASE db in tempfile
temp_db_file = tempfile.NamedTemporaryFile()
if self._structure_list:
db = ase.db.connect(temp_db_file.name, type='db', append=False)
for fit_structure in self._structure_list:
data_dict = {
'user_tag': fit_structure.user_tag,
'properties': fit_structure.properties,
'cluster_vector': fit_structure.cluster_vector
}
db.write(fit_structure.structure, data=data_dict)
with tarfile.open(outfile, mode='w') as handle:
handle.add(temp_db_file.name, arcname='database')
handle.add(temp_cs_file.name, arcname='cluster_space')
def prepare_db():
atoms = bulk("Al", a=4.15)
atoms = atoms * (4, 4, 4)
for i in range(0, 42):
if (i < 21):
atoms[i].symbol = "Si"
else:
atoms[i].symbol = "Mg"
symbols = [atom.symbol for atom in atoms]
random.shuffle(symbols)
for symb, atom in zip(symbols, atoms):
atom.symbol = symb
db = ase.db.connect(db_name())
for i in range(8):
db.write(atoms)
def store_node(args, dirname, names):
db_filenaem, pub_data = args
db = ase.db.connect(db_filename)
for name in names:
if name.endswith('.traj'):
sys.stdout.write('.')
dsplit = dirname.split('/')
if len(dsplit) == 6: #adsorbed structure
#print(len(dsplit))
publication, dft_code, dft_functional, reaction, substrate, facet = dsplit
elif len(dsplit) == 4: # gas phase molecule
publication, dft_code, dft_functional, reaction = dsplit
substrate, facet = '', ''
# have to use string because ase.db does not accept None
else:
continue
if not facet == 'None':
facet = '({facet})'.format(**locals())
username = publication.split('_')[0]
atoms = ase.io.read(os.path.join(dirname, name))
adsorbate = os.path.splitext(name)[0]
db.write(
atoms,
publication=publication,
dft_code=dft_code,
dft_functional=dft_functional,
reaction=reaction,
substrate=substrate,
facet=facet,
username=username,
adsorbate=adsorbate,
publication_volume=pub_data.get('volume', ''),
publication_publisher=pub_data.get('publisher', ''),
publication_doi=pub_data.get('doi', ''),
publication_title=pub_data.get('title', ''),
publication_url=pub_data.get('url', ''),
publication_journal=pub_data.get('journal', ''),
publication_authors=pub_data.get('authors', ''),
publication_year=pub_data.get('year', ''),
publication_number=pub_data.get('number', ''),
publication_pages=pub_data.get('pages', ''),
)
def main():
all_atoms, is_common_arr = get_all_atoms()
common_atoms = [a for a, c in zip(all_atoms, is_common_arr) if c]
uncommon_atoms = [a for a, c in zip(all_atoms, is_common_arr) if not c]
fold_id = generate_folds(len(common_atoms), 5)
print("Writing to DB")
with ase.db.connect(os.path.join(msgnet.defaults.datadir, "matproj.db"),
append=False) as db:
for atom_keyval, fold in zip(common_atoms, fold_id):
atom = atom_keyval[0]
keyval = atom_keyval[1]
keyval["fold"] = int(fold)
db.write(atom, key_value_pairs=keyval)
for atom, keyval in uncommon_atoms:
keyval["fold"] = "None"
db.write(atom, key_value_pairs=keyval)
def dump_bulks(output_file_name='bulks.db'):
with get_mongo_collection('atoms') as collection:
docs = list(tqdm(collection.find({'fwname.calculation_type': 'unit cell optimization'}),
desc='pulling from FireWorks'))
db = ase.db.connect(output_file_name)
for doc in tqdm(docs, desc='writing to database'):
atoms = make_atoms_from_doc(doc)
_ = db.write(atoms, mpid=doc['fwname']['mpid'])
def main():
atoms = bulk("Al", crystalstructure="fcc", a=4.6, cubic=False)
atoms = atoms * (2, 2, 2)
print(len(atoms))
db = ase.db.connect("test_db.db")
tid = db.write(atoms,
name="testCase%d" % (np.random.randint(0, 1000000000)),
started=False,
queued=False)
print("Test ID: %d" % (tid))
def write(self, skip=[], goto_reaction=None):
for key_values in self.read(skip=skip, goto_reaction=goto_reaction):
with CathubSQLite(self.cathub_db) as db:
id = db.check(key_values['chemical_composition'], key_values['reaction_energy'])
#print('Allready in reaction db with row id = {}'.format(id))
if id is None:
id = db.write(key_values)
print('Written to reaction db row id = {}'.format(id))
elif self.update:
db.update(id, key_values)
print('Updated reaction db row id = {}'.format(id))
else:
print('Allready in reaction db with row id = {}'.format(id))
def save_structures(entries, ids, cif=False, conv=False, ref=False, db=None):
"""
Args:
ids (list): indexes of the entries to save
"""
fmt = 'cif' if cif else 'poscar'
if db:
db = ase.db.connect(db)
for i in ids:
e = entries[i - 1]
sym = SpacegroupAnalyzer(e.structure)
if conv:
struct = sym.get_conventional_standard_structure()
else:
struct = sym.get_primitive_standard_structure()
if db is not None:
db.write(AseAtomsAdaptor.get_atoms(struct))
else:
formula = e.data['pretty_formula']
filename = 'POSCAR_{}_{}'.format(formula, i)
struct.to(filename=filename, fmt=fmt)
def test_optimizer(systems, optimizer, calculator, prefix='', db=None):
for atoms in systems:
formula = atoms.get_chemical_formula()
if db is not None:
optname = optimizer.__name__
id = db.reserve(optimizer=optname, name=formula)
if id is None:
continue
atoms = atoms.copy()
tag = '{}{}-{}'.format(prefix, optname, formula)
atoms.calc = calculator(txt=tag + '.txt')
error, nsteps, texcl, tincl = run_test(atoms, optimizer, tag)
if db is not None:
db.write(atoms,
id=id,
optimizer=optname,
name=formula,
error=error,
n=nsteps,
t=texcl,
T=tincl)
def main(argv):
relax_atoms = (argv[1] == "atoms")
runID = int(argv[0])
print("Running job: %d" % (runID))
db_name = db_name_atoms
#db_name = "/home/ntnu/davidkl/Documents/GPAWTutorials/ceTest.db"
db = ase.db.connect(db_name)
new_run = not db.get(id=runID).key_value_pairs["started"]
# Update the databse
db.update(runID, started=True, converged=False)
atoms = db.get_atoms(id=runID)
calc = EAM(potential="/home/davidkl/Documents/EAM/mg-al-set.eam.alloy")
atoms.set_calculator(calc)
init_energy = atoms.get_potential_energy()
logfile = "CE_eam/ceEAM%d.log" % (runID)
traj = "CE_eam/ceEAM%d.traj" % (runID)
trajObj = Trajectory(traj, 'w', atoms)
if (relax_atoms):
relaxer = BFGS(atoms, logfile=logfile)
relaxer.attach(trajObj)
relaxer.run(fmax=0.025)
energy = atoms.get_potential_energy()
else:
res = minimize(target_function, x0=4.05, args=(atoms, ))
a = res["x"]
atoms = set_cell_parameter(atoms, a)
energy = atoms.get_potential_energy()
print("Final energy: {}, final a_la: {}".format(energy, a))
row = db.get(id=runID)
del db[runID]
kvp = row.key_value_pairs
kvp["init_energy"] = init_energy
runID = db.write(atoms, key_value_pairs=kvp)
db.update(runID, converged=True)
print("Energy: %.2E eV/atom" % (energy / len(atoms)))
print("Initial energy: %.2E eV/atom" % (init_energy / len(atoms)))
def add_vasp_structure(dbname, folder, system_id=''):
"""Add a VASP structure into a database.
Keyword arguments:
dbname -- database filename
folder -- path with VASP outputs
system_id -- type of calculation you performed
"""
import sys
import os
import re
import ase.db
from ase.io import read
from ase.io.vasp import read_vasp_out
start_dir = os.path.realpath(".")
db = ase.db.connect(dbname)
os.chdir(folder)
structure = read_vasp_out("OUTCAR")
fin = open("INCAR"); INCAR = fin.readlines(); fin.close()
fin = open("KPOINTS"); KPOINTS = fin.readlines(); fin.close()
fin = open("POTCAR"); POTCARf = fin.read(); fin.close();
POTCAR = re.findall('TITEL = (.*)',POTCARf)
fin = open("CONTCAR"); CONTCAR= fin.readlines(); fin.close()
datain = {"INCAR" : INCAR,
"KPOINTS" : KPOINTS,
"POTCAR_TITEL" : POTCAR,
"CONTCAR" : CONTCAR}
str_path = os.path.realpath(".")
#str_system = str(type_system)
os.chdir(start_dir)
row_id = db.write(structure,data=datain, structure_path=str_path,system_id=system_id)
print ("Structure added with id:", row_id)
return row_id
def add_VASP_structure(dbname, folder):
#-#
from ase.io import read
from ase.io.vasp import read_vasp_out
import ase.db
import sys, os, re
start_dir = os.path.realpath(".")
db = ase.db.connect(dbname)
os.chdir(folder)
structure = read_vasp_out("OUTCAR")
fin = open("INCAR")
INCAR = fin.readlines()
fin.close()
fin = open("KPOINTS")
KPOINTS = fin.readlines()
fin.close()
fin = open("POTCAR")
POTCARf = fin.read()
fin.close()
POTCAR = re.findall('TITEL = (.*)', POTCARf)
fin = open("CONTCAR")
CONTCAR = fin.readlines()
fin.close()
datain = {
"INCAR": INCAR,
"KPOINTS": KPOINTS,
"POTCAR_TITEL": POTCAR,
"CONTCAR": CONTCAR
}
str_path = os.path.realpath(".")
os.chdir(start_dir)
row_id = db.write(structure, data=datain, structure_path=str_path)
print("Structure added with id:", row_id)
return row_id
def test_db(name):
print(name)
db = ase.db.connect(name, append=False)
db.write(Atoms(), x=1, data={'a': 1})
db.update(1, y=2, data={'b': 2})
db.update(1, delete_keys=['x'])
row = db.get(1)
print(row.y, row.data)
assert 'x' not in row
db.update(1, atoms=Atoms('H'))
row = db.get(1)
print(row.y, row.data, row.numbers)
assert (row.numbers == [1]).all()
assert sorted(row.data) == ['a', 'b']
db.write(Atoms(), id=1)
row = db.get(1)
assert len(row.data) == 0
assert len(row.key_value_pairs) == 0
assert len(row.numbers) == 0
# N = 100
N = 5
for i in range(N):
db.write(Atoms('H10'), i=i, data={'c': 3})
t0 = time()
for id in range(2, 2 + N):
db.update(id, z=3)
print(time() - t0)
# This should be faster for large N:
t0 = time()
with db:
for id in range(2, 2 + N):
db.update(id, z=3)
print(time() - t0)
from time import time
import ase.db
from ase import Atoms
for name in ['x.json', 'x.db']:
print(name)
db = ase.db.connect(name, append=False)
db.write(Atoms(), x=1, data={'a': 1})
db.update(1, y=2, data={'b': 2})
db.update(1, delete_keys=['x'])
row = db.get(1)
print(row.y, row.data)
assert 'x' not in row
db.update(1, atoms=Atoms('H'))
row = db.get(1)
print(row.y, row.data, row.numbers)
assert (row.numbers == [1]).all()
assert sorted(row.data) == ['a', 'b']
db.write(Atoms(), id=1)
row = db.get(1)
assert len(row.data) == 0
assert len(row.key_value_pairs) == 0
assert len(row.numbers) == 0
# N = 100
N = 5
for i in range(N):
db.write(Atoms('H10'), i=i, data={'c': 3})
t0 = time()
def main(argv):
print("Dry-run", gp.dry_run)
if (len(argv) > 2):
print("Usage: python almg.py paramID")
return
possible_dbs = {
"vilje": "/home/ntnu/davidkl/GPAWTutorial/Exercises/AlMg/AlMg.db",
"laptop": "AlMg.db"
}
# Find which database to use
db_name = None
for key in possible_dbs:
if (os.path.isfile(possible_dbs[key])):
db_name = possible_dbs[key]
break
if (db_name is None):
raise RuntimeError("Could not find database")
#db_name = "/home/ntnu/davidkl/GPAWTutorial/Exercises/AlMg/AlMg.db"
db = ase.db.connect(db_name)
runID = int(argv[0])
# Read parameters from the database
con = sq.connect(db_name)
cur = con.cursor()
cur.execute(
"SELECT hspacing,relax,atomID,kpts,nbands,latticeConst,cutoff,traj,fmax,tags FROM runs WHERE ID=?",
(runID, ))
params = cur.fetchall()[0]
con.close()
save_pov = False
run_sim = True
swap_atoms = False
useOnlyUnitCellFilter = True
repeatFCCStructure = True # If False, ASE find_optimal_cell_shape will be used to create the unit cell
h_spacing = params[0]
relax = params[1]
atom_row_id = params[2]
Nkpts = params[3]
nbands = params[4]
cutoff = params[6]
old_traj = params[7]
fmax = params[8]
tags = params[9]
# Lattice parameter
a = float(params[5])
if (old_traj != "none"):
# Read the atoms from the trajectory file
print("Reading atoms from trajectory file")
traj = Trajectory(old_traj)
atoms = traj[-1]
elif (atom_row_id < 0):
print(
"Building supercell using find_optimal_cell_shape_pure_python from ASE"
)
# Target primitive cell
atoms = build.bulk("Al", crystalstructure="fcc", a=a)
# Create a supercell consisting of 32 atoms
if (not "test" in tags):
# Skip this if the run is a test run. For some reason the target_shape="fcc" does not work
# using sc instead
if (repeatFCCStructure):
atoms = atoms * (4, 4, 2)
else:
P = build.find_optimal_cell_shape_pure_python(
atoms.cell, 32, "sc")
atoms = build.make_supercell(atoms, P)
# Replace some atoms with Mg atoms
n_mg_atoms = int(0.2 * len(atoms))
for i in range(n_mg_atoms):
atoms[i].set("symbol", "Mg")
else:
print("Reading atoms object from the database")
# Read atoms from database
atoms = db.get_atoms(selection=atom_row_id)
if (swap_atoms):
from ase.io import write
for i in range(0, 2 * len(atoms)):
first = np.random.randint(0, len(atoms))
second = np.random.randint(0, len(atoms))
firstSymbol = atoms[first].symbol
atoms[first].symbol = atoms[second].symbol
atoms[second].symbol = firstSymbol
atoms.write("almg_swap.xyz")
if (save_pov):
from ase.io import write
write("Al.pov", atoms * (3, 3, 1), rotation="-10z,-70x")
return
if (run_sim):
kpts = {"size": (Nkpts, Nkpts, Nkpts), "gamma": True} # Monkhorst pack
kpts = (Nkpts, Nkpts, Nkpts)
if (cutoff > 0):
mode = PW(cutoff)
else:
mode = "fd"
#calc = GPAW( mode="fd", h=h_spacing, xc="PBE", nbands=nbands, kpts=kpts, basis="dzp", poissonsolver=PoissonSolver(relax="GS", eps=1E-7) )
densityConv = 1E-2 # Default 1E-4
wfsConv = 5E-3
cnvg = {"density": 1E-2, "eigenstates": 5E-3}
calc = GPAW(mode=mode, xc="PBE", nbands=nbands, kpts=kpts)
calc.set(convergence=cnvg)
atoms.set_calculator(calc)
logfile = "none"
trajfile = "none"
if (relax):
from ase.optimize import QuasiNewton, BFGS
#from ase.optimize.precon import PreconLBFGS
uid = rnd.randint(0, 10000000)
# First relax only the unit cell
logfile = "relaxation_%d.log" % (uid)
trajfile = "trajectory_%d.traj" % (uid)
print("Logfile: %s, Trajectory file: %s" % (logfile, trajfile))
traj = Trajectory(trajfile, 'w', atoms)
if (not useOnlyUnitCellFilter):
for num_kpts in [Nkpts]:
kpts = (num_kpts, num_kpts, num_kpts)
calc.set(kpts=kpts)
energy = atoms.get_potential_energy()
# Relax unit cell
strfilter = StrainFilter(atoms)
relaxer = BFGS(strfilter, logfile=logfile)
relaxer.attach(traj)
convergence = np.abs(0.01 * energy)
relaxer.run(
fmax=convergence
) # NOTE: Uses generalized forces = volume*stress
# Relax atoms within the unit cell
relaxer = BFGS(atoms, logfile=logfile)
relaxer.attach(traj)
relaxer.run(fmax=fmax)
else:
# Optimize both simultaneously
uf = UnitCellFilter(atoms)
relaxer = PreconLBFGS(uf, logfile=logfile)
relaxer.attach(traj)
relaxer.run(fmax=fmax)
energy = atoms.get_potential_energy()
print("Energy %.2f eV/atom" % (energy))
lastID = db.write(atoms, relaxed=True)
# Update the database
con = sq.connect(db_name)
cur = con.cursor()
cur.execute(
"UPDATE runs SET status='finished',resultID=?,logfile=?,traj=? WHERE ID=?",
(lastID, logfile, trajfile, runID))
con.commit()
con.close()
def main(argv):
relax_mode = "both" # both, cell, positions
system = "AlMg"
runID = int(argv[0])
nkpt = int(argv[1])
single_point = False
if (len(argv) >= 3):
single_point = (int(argv[2]) == 1)
print("Running job: %d" % (runID))
db_paths = [
"/home/ntnu/davidkl/GPAWTutorial/CE/almg_fcc_vac.db",
"almg_fcc_vac.db", "/home/davidkl/GPAWTutorial/CE/almg_fcc_vac.db"
]
for path in db_paths:
if (os.path.isfile(path)):
db_name = path
break
#db_name = "almgsi_test_db.db"
db = ase.db.connect(db_name)
name = db.get(id=runID).key_value_pairs["name"]
new_run = not db.get(id=runID).key_value_pairs["started"]
# Update the databse
db.update(runID, started=True, converged=False)
db.update(runID, nkpt=nkpt)
atoms = db.get_atoms(id=runID)
atoms = delete_vacancies(atoms)
if (len(atoms) == 1):
nbands = -10
else:
nbands = "120%"
kpts = (nkpt, nkpt, nkpt)
try:
restart_name = SaveRestartFiles.restart_name(name)
atoms, calc = gp.restart(restart_name)
except:
calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=kpts, nbands=nbands)
atoms.set_calculator(calc)
if (single_point):
calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=kpts, nbands=nbands)
atoms.set_calculator(calc)
logfile = "almg_fcc_vac{}.log".format(name)
traj = "almg_bcc{}.traj".format(name)
db.update(runID, trajfile=traj)
trajObj = Trajectory(traj, 'w', atoms)
#storeBest = SaveToDB(db_name,runID,name,mode=relax_mode)
save_calc = SaveRestartFiles(calc, name)
update_db_info = UpdateDBInfo(db_name, runID, atoms)
volume = atoms.get_volume()
try:
precon = Exp(mu=1.0, mu_c=1.0)
fmax = 0.025
smax = 0.003
if (relax_mode == "both"):
relaxer = PreconLBFGS(atoms,
logfile=logfile,
use_armijo=True,
variable_cell=True)
elif (relax_mode == "positions"):
#relaxer = SciPyFminCG( atoms, logfile=logfile )
relaxer = BFGS(atoms, logfile=logfile)
elif (relax_mode == "cell"):
str_f = StrainFilter(atoms, mask=[1, 1, 1, 0, 0, 0])
relaxer = BFGS(str_f, logfile=logfile)
fmax = smax * volume
relaxer.attach(trajObj)
#relaxer.attach( storeBest, interval=1, atoms=atoms )
relaxer.attach(save_calc, interval=1)
relaxer.attach(update_db_info, interval=1)
if (not single_point):
if (relax_mode == "both"):
relaxer.run(fmax=fmax, smax=smax)
else:
relaxer.run(fmax=fmax)
energy = atoms.get_potential_energy()
orig_atoms = db.get_atoms(runID)
single_p_calc = SinglePointCalculator(orig_atoms, energy=energy)
orig_atoms.set_calculator(single_p_calc)
kvp = db.get(name=name).key_value_pairs
del db[runID]
newID = db.write(orig_atoms, key_value_pairs=kvp)
if (relax_mode == "positions"):
db.update(newID, converged_force=True)
elif (relax_mode == "cell"):
db.update(newID, converged_stress=True)
else:
db.update(newID, converged_stress=True, converged_force=True)
db.update(newID, single_point=single_point)
db.update(newID, restart_file=SaveRestartFiles.restart_name(name))
row = db.get(id=newID)
conv_force = row.get("converged_force", default=0)
conv_stress = row.get("converged_stress", default=0)
if ((conv_force == 1) and (conv_stress == 1) and (nkpt == 4)):
db.update(newID, converged=True)
except Exception as exc:
print(exc)
def get_reactions(columns='all', n_results=20, write_db=False, **kwargs):
"""
Get reactions from server
Give key value strings as arguments
"""
if write_db or columns == 'all':
columns = all_columns['reactions']
queries = {}
for key, value in kwargs.items():
key = map_column_names(key)
if key == 'distinct':
if value in [True, 'True', 'true']:
queries.update({key: True})
continue
if isinstance(value, int) or isinstance(value, float):
queries.update({key: value})
else:
queries.update({key: '{0}'.format(value)})
subtables = []
if write_db:
subtables = ['reactionSystems', 'publication']
else:
subtables = []
data = query(table='reactions',
subtables=subtables,
columns=columns,
n_results=n_results,
queries=queries)
if not write_db:
return data
print('Writing result to Reactions.db')
unique_ids = []
for row in data['reactions']['edges']:
with CathubSQLite('Reactions.db') as db:
row = row['node']
key_values = {}
for key in all_columns['reactions']:
v = row[key]
# if isinstance(v, unicode):
# v = v.encode('utf-8')
try:
v = json.loads(v)
except BaseException:
pass
key_values[convert(key)] = v
ase_ids = {}
energy_corrections = {}
for row_rs in row['reactionSystems']:
if row_rs['name'] == 'N/A':
continue
ase_ids[row_rs['name']] = row_rs['aseId']
energy_corrections[row_rs['name']] = row_rs['energyCorrection']
if not ase_ids:
ase_ids = None
energy_corrections = None
else:
unique_ids += ase_ids.values()
key_values['ase_ids'] = ase_ids
key_values['energy_corrections'] = ase_ids
# publications
pub_key_values = {}
row_p = row['publication']
for key in all_columns['publications']:
pub_key_values[convert(key)] = row_p[key]
db.write_publication(pub_key_values)
# reactions and reaction_systems
id = db.check(key_values['chemical_composition'],
key_values['reaction_energy'])
if id is None:
id = db.write(key_values)
else:
db.update(id, key_values)
if ase_ids is not None:
# Ase structures
with ase.db.connect('Reactions.db') as ase_db:
con = ase_db.connection
cur = con.cursor()
cur.execute('SELECT unique_id from systems;')
unique_ids0 = cur.fetchall()
unique_ids0 = [un[0] for un in unique_ids0]
unique_ids = [un for un in unique_ids if un not in unique_ids0]
for unique_id in list(set(unique_ids)):
# if ase_db.count('unique_id={}'.format(unique_id)) == 0:
atomsrow = get_atomsrow_by_id(unique_id)
ase_db.write(atomsrow)
print('Writing complete!')
return data
def get_reactions(n_results=20, write_db=False, **kwargs):
queries = {}
for key, value in kwargs.items():
key = map_column_names(key)
if key == 'distinct':
if value in ['True', 'true']:
# WARNING: undefined variable name 'query_dict'
query_dict.update({key: True})
continue
try:
value = int(value)
queries.update({key: value})
except BaseException:
queries.update({key: '{0}'.format(value)})
subtables = []
# if write_local:
subtables = ['reactionSystems', 'publication']
data = query(table='reactions',
subtables=subtables,
columns=all_columns['reactions'],
n_results=n_results,
queries=queries)
if not write_db:
return data
for row in data['data']['reactions']['edges']:
with CathubSQLite('Reactions.db') as db:
row = row['node']
key_values = {}
for key in all_columns['reactions']:
v = row[key]
# if isinstance(v, unicode):
# v = v.encode('utf-8')
try:
v = json.loads(v)
except BaseException:
pass
key_values[convert(key)] = v
ase_ids = {}
energy_corrections = {}
for row_rs in row['reactionSystems']:
if row_rs['name'] == 'N/A':
continue
ase_ids[row_rs['name']] = row_rs['aseId']
energy_corrections[row_rs['name']] = row_rs['energyCorrection']
if not ase_ids:
ase_ids = None
energy_corrections = None
key_values['ase_ids'] = ase_ids
key_values['energy_corrections'] = ase_ids
# publications
pub_key_values = {}
row_p = row['publication']
for key in all_columns['publications']:
pub_key_values[convert(key)] = row_p[key]
db.write_publication(pub_key_values)
# reactions and reaction_systems
id = db.check(key_values['chemical_composition'],
key_values['reaction_energy'])
if id is None:
id = db.write(key_values)
else:
db.update(id, key_values)
if ase_ids is not None:
# Ase structures
with ase.db.connect('Reactions.db') as ase_db:
for unique_id in ase_ids.values():
if ase_db.count('unique_id={}'.format(unique_id)) == 0:
atomsrow = get_atomsrow_by_id(unique_id)
ase_db.write(atomsrow)
return data
'fwname.calculation_type': 'unit cell optimization',
'fwname.vasp_settings.gga': 'RP',
'fwname.vasp_settings.pp': 'PBE',
'fwname.vasp_settings.xc': {
'$exists': False
},
'fwname.vasp_settings.pp_version': '5.4',
'fwname.vasp_settings.encut': 500,
'fwname.vasp_settings.isym': 0
}),
desc='pulling from FireWorks'))
mpids = set()
db = ase.db.connect('bulks.db')
for doc in tqdm(docs, desc='writing to database'):
atoms = make_atoms_from_doc(doc)
n_elements = len(set(atoms.symbols))
if n_elements <= 3:
mpid = doc['fwname']['mpid']
if mpid not in mpids:
mpids.add(mpid)
_ = db.write(atoms,
mpid=doc['fwname']['mpid'],
n_elements=n_elements)
else:
warnings.warn(
'Found a duplicate MPID: %s; adding the first one' % mpid,
RuntimeWarning)
total=n_sites))
docs_by_id = {doc['_id']: doc for doc in all_docs}
# Make up an energy
for mpid, _samples in tqdm(samples.items(), desc='bulks'):
sampled_bulk_mean = norm.rvs(loc=bulk_mean, scale=bulk_std)
for surface, sites in tqdm(_samples.items(), desc='surfaces'):
sampled_surface_mean = norm.rvs(loc=sampled_bulk_mean,
scale=surface_std)
for site in tqdm(sites, desc='sites'):
sampled_energy = norm.rvs(loc=sampled_surface_mean, scale=site_std)
# Make the atoms object
doc = docs_by_id[site['mongo_id']]
atoms = make_atoms_from_doc(doc)
# Grab meta info
miller = tuple(site['miller'])
shift = round(site['shift'], 2)
top = site['top']
data = {
'adsorption_energy': sampled_energy,
'mpid': mpid,
'miller': miller,
'shift': shift,
'top': top
}
# Write to the DB
db.write(atoms, data=data)
