class Output(object):
"""
Output manager.
"""
def __init__(self):
self.drone = SimpleVaspToComputedEntryDrone(inc_structure=True)
self.queen = BorgQueen(self.drone)
def get_results(self, workdir):
"""
Get energy and structure obtained by the solver program.
Parameters
----------
workdir : str
Path to the working directory.
Returns
-------
phys : named_tuple("energy", "structure")
Total energy and atomic structure.
The energy is measured in the units of eV
and coodinates is measured in the units of Angstrom.
"""
# Read results from files in output_dir and calculate values
Phys = namedtuple("PhysVaules", ("energy", "structure"))
self.queen.serial_assimilate(workdir)
results = self.queen.get_data()[-1]
return Phys(np.float64(results.energy), results.structure)
def get_energies(rootdir, reanalyze, verbose, detailed, sort):
"""
Doc string.
"""
if verbose:
FORMAT = "%(relativeCreated)d msecs : %(message)s"
logging.basicConfig(level=logging.INFO, format=FORMAT)
if not detailed:
drone = SimpleVaspToComputedEntryDrone(inc_structure=True)
else:
drone = VaspToComputedEntryDrone(inc_structure=True,
data=["filename",
"initial_structure"])
ncpus = multiprocessing.cpu_count()
logging.info("Detected {} cpus".format(ncpus))
queen = BorgQueen(drone, number_of_drones=ncpus)
if os.path.exists(SAVE_FILE) and not reanalyze:
msg = "Using previously assimilated data from {}.".format(SAVE_FILE) \
+ " Use -f to force re-analysis."
queen.load_data(SAVE_FILE)
else:
if ncpus > 1:
queen.parallel_assimilate(rootdir)
else:
queen.serial_assimilate(rootdir)
msg = "Analysis results saved to {} for faster ".format(SAVE_FILE) + \
"subsequent loading."
queen.save_data(SAVE_FILE)
entries = queen.get_data()
if sort == "energy_per_atom":
entries = sorted(entries, key=lambda x: x.energy_per_atom)
elif sort == "filename":
entries = sorted(entries, key=lambda x: x.data["filename"])
all_data = []
for e in entries:
if not detailed:
delta_vol = "{:.2f}".format(e.data["delta_volume"] * 100)
else:
delta_vol = e.structure.volume / \
e.data["initial_structure"].volume - 1
delta_vol = "{:.2f}".format(delta_vol * 100)
all_data.append((e.data["filename"].replace("./", ""),
re.sub("\s+", "", e.composition.formula),
"{:.5f}".format(e.energy),
"{:.5f}".format(e.energy_per_atom),
delta_vol))
if len(all_data) > 0:
headers = ("Directory", "Formula", "Energy", "E/Atom", "% vol chg")
t = PrettyTable(headers)
t.align["Directory"] = "l"
for d in all_data:
t.add_row(d)
print(t)
print(msg)
else:
print("No valid vasp run found.")
def get_energies(rootdir, reanalyze, verbose, pretty, detailed, sort):
if verbose:
FORMAT = "%(relativeCreated)d msecs : %(message)s"
logging.basicConfig(level=logging.INFO, format=FORMAT)
if not detailed:
drone = SimpleVaspToComputedEntryDrone(inc_structure=True)
else:
drone = VaspToComputedEntryDrone(
inc_structure=True, data=["filename", "initial_structure"])
ncpus = multiprocessing.cpu_count()
logging.info("Detected {} cpus".format(ncpus))
queen = BorgQueen(drone, number_of_drones=ncpus)
if os.path.exists(save_file) and not reanalyze:
msg = "Using previously assimilated data from {}.".format(save_file) \
+ " Use -f to force re-analysis."
queen.load_data(save_file)
else:
if ncpus > 1:
queen.parallel_assimilate(rootdir)
else:
queen.serial_assimilate(rootdir)
msg = "Analysis results saved to {} for faster ".format(save_file) + \
"subsequent loading."
queen.save_data(save_file)
entries = queen.get_data()
if sort == "energy_per_atom":
entries = sorted(entries, key=lambda x: x.energy_per_atom)
elif sort == "filename":
entries = sorted(entries, key=lambda x: x.data["filename"])
all_data = []
for e in entries:
if not detailed:
delta_vol = "{:.2f}".format(e.data["delta_volume"] * 100)
else:
delta_vol = e.structure.volume / \
e.data["initial_structure"].volume - 1
delta_vol = "{:.2f}".format(delta_vol * 100)
all_data.append(
(e.data["filename"].replace("./", ""),
re.sub("\s+", "",
e.composition.formula), "{:.5f}".format(e.energy),
"{:.5f}".format(e.energy_per_atom), delta_vol))
if len(all_data) > 0:
headers = ("Directory", "Formula", "Energy", "E/Atom", "% vol chg")
if pretty:
from prettytable import PrettyTable
t = PrettyTable(headers)
t.set_field_align("Directory", "l")
map(t.add_row, all_data)
print t
else:
print str_aligned(all_data, headers)
print msg
else:
print "No valid vasp run found."
def run_task(self, fw_spec):
"""
go through the measurement job dirs and
put the measurement jobs in the database
"""
drone = MPINTVaspToDbTaskDrone(**self.get("dbase_params", {}))
queen = BorgQueen(drone) # , number_of_drones=ncpus)
queen.serial_assimilate(self["measure_dir"])
return FWAction()
def get_energies(rootdir, reanalyze, verbose, detailed, sort, fmt):
"""
Doc string.
"""
if verbose:
logformat = "%(relativeCreated)d msecs : %(message)s"
logging.basicConfig(level=logging.INFO, format=logformat)
if not detailed:
drone = SimpleVaspToComputedEntryDrone(inc_structure=True)
else:
drone = VaspToComputedEntryDrone(
inc_structure=True, data=["filename", "initial_structure"])
ncpus = multiprocessing.cpu_count()
logging.info("Detected {} cpus".format(ncpus))
queen = BorgQueen(drone, number_of_drones=ncpus)
if os.path.exists(SAVE_FILE) and not reanalyze:
msg = "Using previously assimilated data from {}.".format(SAVE_FILE) \
+ " Use -r to force re-analysis."
queen.load_data(SAVE_FILE)
else:
if ncpus > 1:
queen.parallel_assimilate(rootdir)
else:
queen.serial_assimilate(rootdir)
msg = "Analysis results saved to {} for faster ".format(SAVE_FILE) + \
"subsequent loading."
queen.save_data(SAVE_FILE)
entries = queen.get_data()
if sort == "energy_per_atom":
entries = sorted(entries, key=lambda x: x.energy_per_atom)
elif sort == "filename":
entries = sorted(entries, key=lambda x: x.data["filename"])
all_data = []
for e in entries:
if not detailed:
delta_vol = "{:.2f}".format(e.data["delta_volume"] * 100)
else:
delta_vol = e.structure.volume / \
e.data["initial_structure"].volume - 1
delta_vol = "{:.2f}".format(delta_vol * 100)
all_data.append(
(e.data["filename"].replace("./", ""),
re.sub(r"\s+", "",
e.composition.formula), "{:.5f}".format(e.energy),
"{:.5f}".format(e.energy_per_atom), delta_vol))
if len(all_data) > 0:
headers = ("Directory", "Formula", "Energy", "E/Atom", "% vol chg")
print(tabulate(all_data, headers=headers, tablefmt=fmt))
print("")
print(msg)
else:
print("No valid vasp run found.")
os.unlink(SAVE_FILE)
def run_task(self, fw_spec):
"""
go through the measurement job dirs and
put the measurement jobs in the database
"""
drone = MPINTVaspToDbTaskDrone(**self.get("dbase_params", {}))
queen = BorgQueen(drone) # , number_of_drones=ncpus)
queen.serial_assimilate(self["measure_dir"])
return FWAction()
def setUpClass(cls):
try:
drone = VaspToDbTaskDrone(database="creator_unittest")
queen = BorgQueen(drone)
queen.serial_assimilate(os.path.join(test_dir, "db_test", "success_mp_aflow"))
cls.conn = MongoClient()
cls.qe = QueryEngine(database="creator_unittest")
except ConnectionFailure:
cls.qe = None
cls.conn = None
class Output(object):
def __init__(self):
self.drone = SimpleVaspToComputedEntryDrone(inc_structure=True)
self.queen = BorgQueen(self.drone)
def get_results(self, output_dir):
# Read results from files in output_dir and calculate values
Phys = namedtuple("PhysVaules", ("energy", "structure"))
self.queen.serial_assimilate(output_dir)
results = self.queen.get_data()[-1]
return Phys(np.float64(results.energy), results.structure)
def setUpClass(cls):
try:
drone = VaspToDbTaskDrone(database="qetransmuter_unittest")
queen = BorgQueen(drone)
queen.serial_assimilate(
os.path.join(test_dir, 'db_test', 'success_mp_aflow'))
cls.conn = MongoClient()
cls.qe = QueryEngine(database="qetransmuter_unittest")
except ConnectionFailure:
cls.qe = None
cls.conn = None
def energy(self, spch_config):
""" Calculate total energy of the space charge model"""
structure = spch_config.structure.get_sorted_structure()
# if len(spinel_config.calc_history) >= 20:
# print("truncate calc_history")
# del spinel_config.calc_history[0:10]
# calc_history = spinel_config.calc_history
# if calc_history:
# # Try to avoid doing dft calculation for the same structure.
# # Assuming that calc_history is a list of ComputedStructureEntries
# for i in range(len(calc_history)):
# if self.matcher.fit(structure, calc_history[i].structure):
# print("match found in history")
# return calc_history[i].energy
# print("before poscar")
if self.selective_dynamics:
seldyn_arr = [[True, True, True] for i in range(len(structure))]
for specie in self.selective_dynamics:
indices = structure.indices_from_symbol(specie)
for i in indices:
seldyn_arr[i] = [False, False, False]
else:
seldyn_arr = None
poscar = Poscar(structure=structure, selective_dynamics=seldyn_arr)
# print("before vaspinput")
vaspinput = self.base_vaspinput
vaspinput.update({"POSCAR": poscar})
exitcode = self.vasp_run.submit(vaspinput, os.getcwd() + "/output")
# print("vasp exited with exit code", exitcode)
if exitcode != 0:
print("something went wrong")
sys.exit(1)
queen = BorgQueen(self.drone)
# print(os.getcwd())
queen.serial_assimilate("./output")
# print(queen.get_data())
# results = self.queen.get_data()[-1]
results = queen.get_data()[-1]
# calc_history.append(results)
spch_config.structure = results.structure
# print(results.energy)
# sys.stdout.flush()
return np.float64(results.energy)
def get_e_v(path):
"""
uses pymatgen drone and borgqueen classes to get energy and
volume data from the given directory path.
"""
volumes = []
energies = []
drone = MPINTVaspDrone(inc_structure=True)
bg = BorgQueen(drone)
# bg.parallel_assimilate(path)
bg.serial_assimilate(path)
allentries = bg.get_data()
for e in allentries:
if e:
energies.append(e.energy)
volumes.append(e.structure.lattice.volume)
return (volumes, energies)
def get_e_v(path):
"""
uses pymatgen drone and borgqueen classes to get energy and
volume data from the given directory path.
"""
volumes = []
energies = []
drone = MPINTVaspDrone(inc_structure=True)
bg = BorgQueen(drone)
# bg.parallel_assimilate(path)
bg.serial_assimilate(path)
allentries = bg.get_data()
for e in allentries:
if e:
energies.append(e.energy)
volumes.append(e.structure.lattice.volume)
return (volumes, energies)
def energy(self, HAp_config, save_history=False):
""" Calculate total energy of the space charge model"""
structure = HAp_config.structure.get_sorted_structure()
if save_history and self.matcher != None:
calc_history = HAp_config.calc_history
# Try to avoid doing dft calculation for the same structure.
# Assuming that calc_history is a list of ComputedStructureEntries
for i in range(len(calc_history)):
if self.matcher.fit(structure, calc_history[i].structure0):
print("match found in history")
return calc_history[i].energy
if self.selective_dynamics:
seldyn_arr = [[True, True, True] for i in range(len(structure))]
for specie in self.selective_dynamics:
indices = structure.indices_from_symbol(specie)
for i in indices:
seldyn_arr[i] = [False, False, False]
else:
seldyn_arr = None
poscar = Poscar(structure=structure, selective_dynamics=seldyn_arr)
vaspinput = self.base_vaspinput
vaspinput.update({"POSCAR": poscar})
exitcode = self.vasp_run.submit(vaspinput, os.getcwd() + "/output")
if exitcode != 0:
print("something went wrong")
sys.exit(1)
queen = BorgQueen(self.drone)
queen.serial_assimilate("./output")
results = queen.get_data()[-1]
if save_history:
results.structure0 = HAp_config.structure
HAp_config.calc_history.append(results)
HAp_config.structure = results.structure
return np.float64(results.energy)
def get_energies(rootdir, reanalyze, verbose, detailed,
sort, formulaunit, debug, hull, threshold, args, templatestructure):
ion_list = 'Novalue'
ave_key_list = 'Novalue'
threscount = 0
"""
Doc string.
"""
if (verbose and not debug):
FORMAT = "%(relativeCreated)d msecs : %(message)s"
logging.basicConfig(level=logging.INFO, format=FORMAT)
elif debug:
logging.basicConfig(level=logging.DEBUG)
if not detailed:
drone = SimpleVaspToComputedEntryDrone(inc_structure=True)
else:
drone = VaspToComputedEntryDrone(inc_structure=True,
data=["filename",
"initial_structure"])
ncpus = multiprocessing.cpu_count()
logging.info("Detected {} cpus".format(ncpus))
queen = BorgQueen(drone, number_of_drones=ncpus)
if os.path.exists(SAVE_FILE) and not reanalyze:
msg = "Using previously assimilated data from {}.".format(SAVE_FILE) \
+ " Use -f to force re-analysis."
queen.load_data(SAVE_FILE)
else:
if ncpus > 1:
queen.parallel_assimilate(rootdir)
else:
queen.serial_assimilate(rootdir)
msg = "Analysis results saved to {} for faster ".format(SAVE_FILE) + \
"subsequent loading."
queen.save_data(SAVE_FILE)
entries = queen.get_data()
if sort == "energy_per_atom":
entries = sorted(entries, key=lambda x: x.energy_per_atom)
elif sort == "filename":
entries = sorted(entries, key=lambda x: x.data["filename"])
# logging.debug('First Energy entry is {}'.format(entries[0]))
base_energy = entries[0].energy
logging.debug('Type of entries is: {}'.format(type(entries)))
logging.debug('First Element of Entries is:{}'.format(entries[0]))
# logging.debug('First Energy entry structure is {}'.format(entries[0].structure))
xy_direction = int(args.XYdirection)
tolerance = float(args.tolerance)
if args.template:
logging.debug('Temp Structure site info is: {}'.format(Na12(['Co','Mn'],['Na'],templatestructure,templatestructure,XY_Direction=xy_direction,tol=tolerance)))
template_site_info = Na12(['Co','Mn'],['Na'],templatestructure,templatestructure,XY_Direction=xy_direction,tol=tolerance)
all_data = []
energy_diff = []
threshold=float(threshold)
Structure_info_dict = {}
check_ion_seq = [args.dupion]
for e in entries:
if not detailed:
delta_vol = "{:.2f}".format(e.data["delta_volume"] * 100)
else:
delta_vol = e.structure.volume / \
e.data["initial_structure"].volume - 1
delta_vol = "{:.2f}".format(delta_vol * 100)
entry_path = e.data['filename'].rsplit('/',1)[0]
entry_site_info = Na12(['Co','Mn'],['Na'],e.structure,e.structure,XY_Direction=xy_direction,tol=tolerance)
logging.debug('Total Na site: {}'.format(entry_site_info['Total_Na_Site']))
#Coordination extraction part
# na_layer_site_fcoords = [site._fcoords for site in s if site.specie.symbol == "Na"]
# if 'Cif_Structure' in e.data.keys():
# na_sites_fcoords = [site._fcoords for site in e.data['Cif_Structure'] if site.specie.symbol == 'Na']
# na_sites_fcoords_list_tuple = [tuple(coord) for coord in na_sites_fcoords]
na_sites_fcoords = [site._fcoords for site in e.data['CONTCAR_Structure'] if site.specie.symbol == 'Na']
na_sites_fcoords_list_tuple = [tuple(coord) for coord in na_sites_fcoords]
if args.nupdown:
entry_data= [rootdir,e.data["filename"].replace("./", ""),
re.sub("\s+", "", e.composition.formula),
"{:.5f}".format(e.energy),
"{:.5f}".format(1000*(e.energy-base_energy)/int(formulaunit)),
"{:.5f}".format(e.energy_per_atom),
delta_vol,e.parameters['run_type'],
e.data['NUPDOWN'],e.data['ISMEAR'],na_sites_fcoords_list_tuple]
else:
entry_data= [rootdir,e.data["filename"].replace("./", ""),
re.sub("\s+", "", e.composition.formula),
"{:.5f}".format(e.energy),
"{:.5f}".format(1000*(e.energy-base_energy)/int(formulaunit)),
"{:.5f}".format(e.energy_per_atom),
delta_vol,e.parameters['run_type'],na_sites_fcoords_list_tuple]
if args.structure:
entry_data.extend([entry_site_info['Total_Na_Site'],entry_site_info['Na2_Site'],entry_site_info['Na1_Mn_Site'],
entry_site_info['Na1_Co_Site'],entry_site_info['Na1_Mn_Co_Site']])
if args.template:
entry_data.extend([template_site_info['Total_Na_Site'],template_site_info['Na2_Site'],template_site_info['Na1_Mn_Site'],
template_site_info['Na1_Co_Site'],template_site_info['Na1_Mn_Co_Site']])
# sitelist = ['Existed','Duplicate_Entry']
logging.debug(e.data)
if args.duplicate:
# filename.rsplit('/',2)[-2]
Duplicate, Duplicat_Entry, Structure_info_dict = check_ex(check_ion_seq,Structure_info_dict,
e,args.tolerance)
entry_data.extend([Duplicate,Duplicat_Entry])
if args.ion_list:
if args.ion_list[0] == "All":
ion_list = None
else:
(start, end) = [int(i) for i in re.split("-", args.ion_list[0])]
ion_list = list(range(start, end + 1))
for d in entry_path:
magdata = get_magnetization(d, ion_list)
entry_data.extend(magdata)
if args.ion_avg_list:
ave_mag_data, ave_key_list = get_ave_magnetization(entry_path,args.ion_avg_list)
entry_data.extend(ave_mag_data)
if threshold != 0:
all_data.append(entry_data)
if float(entry_data[4])<threshold:
threscount +=1
elif threshold == 0:
all_data.append(entry_data)
energy_diff.append("{:.5f}".format(1000*(e.energy-base_energy)/int(formulaunit)))
# if len(all_data) > 0:
# headers = ("Directory", "Formula", "Energy", "Energy Diff (meV)/F.U.","E/Atom", "% vol chg")
# t = PrettyTable(headers)
# t.align["Directory"] = "l"
# for d in all_data:
# logging.debug('data row in all data is: \n {}'.format(d))
# t.add_row(d)
# print(t)
# print(msg)
# else:
# print("No valid vasp run found.")
if hull:
print 'Analyzing group: {}\n'.format(rootdir)
print 'Energy above hull is: \n'
print map(lambda x: x.encode('ascii'), energy_diff)
logging.info('In group: {}, number of entries fall in threshold is {}'.format(rootdir,threscount))
all_data.append([])
return all_data
def test_assimilate(self):
"""Borg assimilation code.
This takes too long for a unit test!
"""
simulate = True if VaspToDbTaskDroneTest.conn is None else False
drone = VaspToDbTaskDrone(database="creator_unittest",
simulate_mode=simulate,
parse_dos=True,
compress_dos=1)
queen = BorgQueen(drone)
queen.serial_assimilate(os.path.join(test_dir, 'db_test'))
data = queen.get_data()
self.assertEqual(len(data), 6)
if VaspToDbTaskDroneTest.conn:
db = VaspToDbTaskDroneTest.conn["creator_unittest"]
data = db.tasks.find()
self.assertEqual(data.count(), 6)
warnings.warn("Actual db insertion mode.")
for d in data:
dir_name = d['dir_name']
if dir_name.endswith("killed_mp_aflow"):
self.assertEqual(d['state'], "killed")
self.assertFalse(d['is_hubbard'])
self.assertEqual(d['pretty_formula'], "SiO2")
elif dir_name.endswith("stopped_mp_aflow"):
self.assertEqual(d['state'], "stopped")
self.assertEqual(d['pretty_formula'], "ThFe5P3")
elif dir_name.endswith("success_mp_aflow"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "TbZn(BO2)5")
self.assertAlmostEqual(d['output']['final_energy'],
-526.66747274, 4)
elif dir_name.endswith("Li2O_aflow"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'],
-14.31446494, 6)
self.assertEqual(len(d["calculations"]), 2)
self.assertEqual(d['input']['is_lasph'], False)
self.assertEqual(d['input']['xc_override'], None)
elif dir_name.endswith("Li2O"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'],
-14.31337758, 6)
self.assertEqual(len(d["calculations"]), 1)
self.assertEqual(len(d["custodian"]), 1)
self.assertEqual(len(d["custodian"][0]["corrections"]), 1)
elif dir_name.endswith("Li2O_aflow_lasph"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'], -13.998171,
6)
self.assertEqual(len(d["calculations"]), 2)
self.assertEqual(d['input']['is_lasph'], True)
self.assertEqual(d['input']['xc_override'], "PS")
if VaspToDbTaskDroneTest.conn:
warnings.warn("Testing query engine mode.")
qe = QueryEngine(database="creator_unittest")
self.assertEqual(qe.query().count(), 6)
#Test mappings by query engine.
for r in qe.query(
criteria={"pretty_formula": "Li2O"},
properties=["dir_name", "energy", "calculations",
"input"]):
if r["dir_name"].endswith("Li2O_aflow"):
self.assertAlmostEqual(r['energy'], -14.31446494, 4)
self.assertEqual(len(r["calculations"]), 2)
self.assertEqual(r["input"]["is_lasph"], False)
self.assertEqual(r['input']['xc_override'], None)
elif r["dir_name"].endswith("Li2O"):
self.assertAlmostEqual(r['energy'], -14.31337758, 4)
self.assertEqual(len(r["calculations"]), 1)
self.assertEqual(r["input"]["is_lasph"], False)
self.assertEqual(r['input']['xc_override'], None)
#Test lasph
e = qe.get_entries({"dir_name": {"$regex": "lasph"}})
self.assertEqual(len(e), 1)
self.assertEqual(e[0].parameters["is_lasph"], True)
self.assertEqual(e[0].parameters["xc_override"], "PS")
# Test query one.
d = qe.query_one(criteria={"pretty_formula": "TbZn(BO2)5"},
properties=["energy"])
self.assertAlmostEqual(d['energy'], -526.66747274, 4)
d = qe.get_entries_in_system(["Li", "O"])
self.assertEqual(len(d), 3)
self.assertIsInstance(d[0], ComputedEntry)
s = qe.get_structure_from_id(d[0].entry_id)
self.assertIsInstance(s, Structure)
self.assertEqual(s.formula, "Li2 O1")
self.assertIsInstance(qe.get_dos_from_id(d[0].entry_id),
CompleteDos)
def test_assimilate(self):
simulate = True if VaspToDbTaskDroneTest.conn is None else False
drone = VaspToDbTaskDrone(database="creator_unittest",
simulate_mode=simulate)
queen = BorgQueen(drone)
queen.serial_assimilate(os.path.join(test_dir, 'db_test'))
data = queen.get_data()
self.assertEqual(len(data), 5)
if VaspToDbTaskDroneTest.conn:
db = VaspToDbTaskDroneTest.conn["creator_unittest"]
data = db.tasks.find()
self.assertEqual(data.count(), 5)
warnings.warn("Actual db insertion mode.")
for d in data:
dir_name = d['dir_name']
if dir_name.endswith("killed_mp_aflow"):
self.assertEqual(d['state'], "killed")
self.assertFalse(d['is_hubbard'])
self.assertEqual(d['pretty_formula'], "SiO2")
elif dir_name.endswith("stopped_mp_aflow"):
self.assertEqual(d['state'], "stopped")
self.assertEqual(d['pretty_formula'], "ThFe5P3")
elif dir_name.endswith("success_mp_aflow"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "TbZn(BO2)5")
self.assertAlmostEqual(d['output']['final_energy'],
-526.66747274, 4)
elif dir_name.endswith("Li2O_aflow"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'],
-14.31446494, 6)
self.assertEqual(len(d["calculations"]), 2)
elif dir_name.endswith("Li2O"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'],
-14.31337758, 6)
self.assertEqual(len(d["calculations"]), 1)
self.assertEqual(len(d["custodian"]), 1)
self.assertEqual(len(d["custodian"][0]["corrections"]), 1)
if VaspToDbTaskDroneTest.conn:
warnings.warn("Testing query engine mode.")
qe = QueryEngine(database="creator_unittest")
self.assertEqual(qe.query().count(), 5)
#Test mappings by query engine.
for r in qe.query(criteria={"pretty_formula": "Li2O"},
properties=["dir_name", "energy",
"calculations"]):
if r["dir_name"].endswith("Li2O_aflow"):
self.assertAlmostEqual(r['energy'], -14.31446494, 4)
self.assertEqual(len(r["calculations"]), 2)
elif r["dir_name"].endswith("Li2O"):
self.assertAlmostEqual(r['energy'],
-14.31337758, 4)
self.assertEqual(len(r["calculations"]), 1)
# Test query one.
d = qe.query_one(criteria={"pretty_formula": "TbZn(BO2)5"},
properties=["energy"])
self.assertAlmostEqual(d['energy'], -526.66747274, 4)
d = qe.get_entries_in_system(["Li", "O"])
self.assertEqual(len(d), 2)
self.assertIsInstance(d[0], ComputedEntry)
s = qe.get_structure_from_id(d[0].entry_id)
self.assertIsInstance(s, Structure)
self.assertEqual(s.formula, "Li2 O1")
def test_assimilate(self):
"""Borg assimilation code.
This takes too long for a unit test!
"""
simulate = True if VaspToDbTaskDroneTest.conn is None else False
drone = VaspToDbTaskDrone(database="creator_unittest",
simulate_mode=simulate,
parse_dos=True, compress_dos=1)
queen = BorgQueen(drone)
queen.serial_assimilate(os.path.join(test_dir, 'db_test'))
data = queen.get_data()
self.assertEqual(len(data), 6)
if VaspToDbTaskDroneTest.conn:
db = VaspToDbTaskDroneTest.conn["creator_unittest"]
data = db.tasks.find()
self.assertEqual(data.count(), 6)
warnings.warn("Actual db insertion mode.")
for d in data:
dir_name = d['dir_name']
if dir_name.endswith("killed_mp_aflow"):
self.assertEqual(d['state'], "killed")
self.assertFalse(d['is_hubbard'])
self.assertEqual(d['pretty_formula'], "SiO2")
elif dir_name.endswith("stopped_mp_aflow"):
self.assertEqual(d['state'], "stopped")
self.assertEqual(d['pretty_formula'], "ThFe5P3")
elif dir_name.endswith("success_mp_aflow"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "TbZn(BO2)5")
self.assertAlmostEqual(d['output']['final_energy'],
-526.66747274, 4)
elif dir_name.endswith("Li2O_aflow"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'],
-14.31446494, 6)
self.assertEqual(len(d["calculations"]), 2)
self.assertEqual(d['input']['is_lasph'], False)
self.assertEqual(d['input']['xc_override'], None)
self.assertEqual(d["oxide_type"], "oxide")
elif dir_name.endswith("Li2O"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'],
-14.31337758, 6)
self.assertEqual(len(d["calculations"]), 1)
self.assertEqual(len(d["custodian"]), 1)
self.assertEqual(len(d["custodian"][0]["corrections"]), 1)
elif dir_name.endswith("Li2O_aflow_lasph"):
self.assertEqual(d['state'], "successful")
self.assertEqual(d['pretty_formula'], "Li2O")
self.assertAlmostEqual(d['output']['final_energy'],
-13.998171, 6)
self.assertEqual(len(d["calculations"]), 2)
self.assertEqual(d['input']['is_lasph'], True)
self.assertEqual(d['input']['xc_override'], "PS")
if VaspToDbTaskDroneTest.conn:
warnings.warn("Testing query engine mode.")
qe = QueryEngine(database="creator_unittest")
self.assertEqual(qe.query().count(), 6)
#Test mappings by query engine.
for r in qe.query(criteria={"pretty_formula": "Li2O"},
properties=["dir_name", "energy",
"calculations", "input"]):
if r["dir_name"].endswith("Li2O_aflow"):
self.assertAlmostEqual(r['energy'], -14.31446494, 4)
self.assertEqual(len(r["calculations"]), 2)
self.assertEqual(r["input"]["is_lasph"], False)
self.assertEqual(r['input']['xc_override'], None)
self.assertEqual(d["oxide_type"], "oxide")
elif r["dir_name"].endswith("Li2O"):
self.assertAlmostEqual(r['energy'],
-14.31337758, 4)
self.assertEqual(len(r["calculations"]), 1)
self.assertEqual(r["input"]["is_lasph"], False)
self.assertEqual(r['input']['xc_override'], None)
# Test lasph
e = qe.get_entries({"dir_name":{"$regex":"lasph"}})
self.assertEqual(len(e), 1)
self.assertEqual(e[0].parameters["is_lasph"], True)
self.assertEqual(e[0].parameters["xc_override"], "PS")
# Test query one.
d = qe.query_one(criteria={"pretty_formula": "TbZn(BO2)5"},
properties=["energy"])
self.assertAlmostEqual(d['energy'], -526.66747274, 4)
d = qe.get_entries_in_system(["Li", "O"])
self.assertEqual(len(d), 3)
self.assertIsInstance(d[0], ComputedEntry)
self.assertEqual(d[0].data["oxide_type"], "oxide")
s = qe.get_structure_from_id(d[0].entry_id)
self.assertIsInstance(s, Structure)
self.assertEqual(s.formula, "Li2 O1")
self.assertIsInstance(qe.get_dos_from_id(d[0].entry_id), CompleteDos)
def get_energies(rootdir, reanalyze, verbose, quick, sort, fmt):
"""
Get energies of all vaspruns in directory (nested).
Args:
rootdir (str): Root directory.
reanalyze (bool): Whether to ignore saved results and reanalyze
verbose (bool): Verbose mode or not.
quick (bool): Whether to perform a quick analysis (using OSZICAR instead
of vasprun.xml
sort (bool): Whether to sort the results in ascending order.
fmt (str): tablefmt passed to tabulate.
"""
if verbose:
logformat = "%(relativeCreated)d msecs : %(message)s"
logging.basicConfig(level=logging.INFO, format=logformat)
if quick:
drone = SimpleVaspToComputedEntryDrone(inc_structure=True)
else:
drone = VaspToComputedEntryDrone(
inc_structure=True, data=["filename", "initial_structure"])
ncpus = multiprocessing.cpu_count()
logging.info("Detected {} cpus".format(ncpus))
queen = BorgQueen(drone, number_of_drones=ncpus)
if os.path.exists(SAVE_FILE) and not reanalyze:
msg = ("Using previously assimilated data from {}.".format(SAVE_FILE) +
" Use -r to force re-analysis.")
queen.load_data(SAVE_FILE)
else:
if ncpus > 1:
queen.parallel_assimilate(rootdir)
else:
queen.serial_assimilate(rootdir)
msg = ("Analysis results saved to {} for faster ".format(SAVE_FILE) +
"subsequent loading.")
queen.save_data(SAVE_FILE)
entries = queen.get_data()
if sort == "energy_per_atom":
entries = sorted(entries, key=lambda x: x.energy_per_atom)
elif sort == "filename":
entries = sorted(entries, key=lambda x: x.data["filename"])
all_data = []
for e in entries:
if quick:
delta_vol = "NA"
else:
delta_vol = e.structure.volume / e.data[
"initial_structure"].volume - 1
delta_vol = "{:.2f}".format(delta_vol * 100)
all_data.append((
e.data["filename"].replace("./", ""),
re.sub(r"\s+", "", e.composition.formula),
"{:.5f}".format(e.energy),
"{:.5f}".format(e.energy_per_atom),
delta_vol,
))
if len(all_data) > 0:
headers = ("Directory", "Formula", "Energy", "E/Atom", "% vol chg")
print(tabulate(all_data, headers=headers, tablefmt=fmt))
print("")
print(msg)
else:
print("No valid vasp run found.")
os.unlink(SAVE_FILE)
return 0