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 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 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