def setUp(self): self.test_dir = os.path.join( os.path.dirname(__file__), "..", "..", "..", "..", "test_files" ) self.drone = SimpleVaspToComputedEntryDrone() self.structure_drone = SimpleVaspToComputedEntryDrone(True) warnings.simplefilter("ignore")
class SimpleVaspToComputedEntryDroneTest(unittest.TestCase): def setUp(self): self.test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", 'test_files') self.drone = SimpleVaspToComputedEntryDrone() self.structure_drone = SimpleVaspToComputedEntryDrone(True) def test_get_valid_paths(self): for path in os.walk(self.test_dir): if path[0] == self.test_dir: self.assertTrue(len(self.drone.get_valid_paths(path)) > 0) def test_to_from_dict(self): d = self.structure_drone.as_dict() drone = SimpleVaspToComputedEntryDrone.from_dict(d) self.assertEqual(type(drone), SimpleVaspToComputedEntryDrone)
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."
class SimpleVaspToComputedEntryDroneTest(unittest.TestCase): def setUp(self): self.drone = SimpleVaspToComputedEntryDrone() self.structure_drone = SimpleVaspToComputedEntryDrone(True) warnings.simplefilter("ignore") def tearDown(self): warnings.simplefilter("default") def test_get_valid_paths(self): for path in os.walk(PymatgenTest.TEST_FILES_DIR): if path[0] == PymatgenTest.TEST_FILES_DIR: self.assertTrue(len(self.drone.get_valid_paths(path)) > 0) def test_to_from_dict(self): d = self.structure_drone.as_dict() drone = SimpleVaspToComputedEntryDrone.from_dict(d) self.assertEqual(type(drone), SimpleVaspToComputedEntryDrone)
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)
class SimpleVaspToComputedEntryDroneTest(unittest.TestCase): def setUp(self): self.drone = SimpleVaspToComputedEntryDrone() self.structure_drone = SimpleVaspToComputedEntryDrone(True) def test_get_valid_paths(self): for path in os.walk(test_dir): if path[0] == test_dir: self.assertTrue(len(self.drone.get_valid_paths(path)) > 0) def test_to_from_dict(self): d = self.structure_drone.to_dict drone = SimpleVaspToComputedEntryDrone.from_dict(d) self.assertEqual(type(drone), SimpleVaspToComputedEntryDrone)
def __init__(self, rootdir): """read vasp output via drone and extract all data :param rootdir: root directory containing collection of VASP dirs :type rootdir: str """ from pymatgen.apps.borg.hive import SimpleVaspToComputedEntryDrone from pymatgen.apps.borg.queen import BorgQueen self.rootdir = rootdir self.drone = SimpleVaspToComputedEntryDrone(inc_structure=True) self.queen = BorgQueen( self.drone, rootdir, 1) # TODO: make sure uw2_si2 also works in parallel self.data = self.queen.get_data()
def __init__( self, calcode, vasp_run, base_vaspinput, matcher, matcher_site, queen, selective_dynamics=None, ): self.calcode = calcode self.matcher = matcher self.matcher_site = matcher_site self.drone = SimpleVaspToComputedEntryDrone(inc_structure=True) self.queen = queen self.base_vaspinput = base_vaspinput self.vasp_run = vasp_run self.selective_dynamics = selective_dynamics
solver = VASPSolver(path_to_vasp) vasprun = runner( Solver=solver, nprocs=nprocs_per_vasp, comm=MPI.COMM_SELF, ) baseinput = VaspInput.from_directory( "baseinput") # (os.path.join(os.path.dirname(__file__), "baseinput")) ltol = 0.1 matcher = StructureMatcher(ltol=ltol, primitive_cell=False) matcher_base = StructureMatcher(ltol=ltol, primitive_cell=False, stol=0.5, allow_subset=True) # , # comparator=FrameworkComparator(), ignored_species=["Pt","Zr"]) drone = SimpleVaspToComputedEntryDrone(inc_structure=True) queen = BorgQueen(drone) model = dft_HAp( calcode="VASP", vasp_run=vasprun, base_vaspinput=baseinput, matcher_base=matcher_base, queen=queen, matcher=matcher, ) # matcher=matcher, matcher_site=matcher_site, queen=queen, selective_dynamics=["Pt"]) myrank = comm.Get_rank() os.mkdir(str(myrank)) os.chdir(str(myrank)) for i in range(len(reps)):
def setUp(self): self.drone = SimpleVaspToComputedEntryDrone() self.structure_drone = SimpleVaspToComputedEntryDrone(True)
def test_to_from_dict(self): d = self.structure_drone.to_dict drone = SimpleVaspToComputedEntryDrone.from_dict(d) self.assertEqual(type(drone), SimpleVaspToComputedEntryDrone)
def setUp(self): self.test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", 'test_files') self.drone = SimpleVaspToComputedEntryDrone() self.structure_drone = SimpleVaspToComputedEntryDrone(True)
def test_to_from_dict(self): d = self.structure_drone.as_dict() drone = SimpleVaspToComputedEntryDrone.from_dict(d) self.assertEqual(type(drone), SimpleVaspToComputedEntryDrone)
def __init__(self): self.drone = SimpleVaspToComputedEntryDrone(inc_structure=True) self.queen = BorgQueen(self.drone)
def collect_single_folder(job_folder, drone=None, vasprun_parsing_lvl=1): """ Reading and parsing of VASP files in the job_folder folder vasprun_parsing_lvl > 0.5 : parse vasprun, else only parse vasp inputs returns a Rundict instance """ # status : # 0 : not a job folder # 1 : pre-run # 2 : failed run # 3 : converged run # if no drone give, minimal parsing if drone is None: drone = drone = VaspToComputedEntryDrone(inc_structure=True, parameters=["incar"], data=['efermi', "converged"]) status = 0 with warnings.catch_warnings(): # warnings.filterwarnings('once') if PARAM['verbose'] == 0: warnings.simplefilter("ignore") if vasprun_parsing_lvl > 0.5: if if_file_exist_gz(job_folder, "vasprun.xml"): # try unzip the vasprun c_e = drone.assimilate(job_folder) if c_e is not None: print(c_e.parameters['incar']) status = 3 if c_e.data['converged'] else 2 if status <= 0: # try unzip the whole dir c_e = SimpleVaspToComputedEntryDrone( inc_structure=True).assimilate(job_folder) if c_e is not None: incar = Incar.from_file( '{}/INCAR'.format(job_folder)).as_dict() c_e.parameters.update({"incar": incar}) try: status = 2 if c_e.energy < 10000000 else 1 except TypeError as ex: print("exception caught", ex) # c_e.energy = 10000000 status = 1 # if there is an error, the run didn't converge # default energy of parser when ozscicar not read # to distinguish "pre-runs" from corrupted / suppressed vasprun if status > 0: for k in ['LDAUU', 'LDAUJ', 'LDAUL', "@class", "@module"]: # "MAGMOM" c_e.parameters['incar'].pop(k, None) for file_name in ["param", "data"]: file_path = os.path.join(job_folder, '{}.json'.format(file_name)) try: with open(file_path) as file_object: # load file data into object param = json.load(file_object) print(file_name, param) c_e.parameters['custom'] = param except Exception: # print(ex) continue else: break # print("finished gathering c_e data") # if hasattr(c_e, "run_type"): # print(c_e.run_type) # print(c_e.parameters) # print(type(c_e.parameters["run_type"])) if not isinstance(c_e.parameters["run_type"], str): c_e.parameters["run_type"] = None # print("run type changed to None") # print(c_e) rundict = Rundict(c_e, status, job_folder) if PARAM["verbose"] > 0: print("sucessfully parsed : \n", rundict) return (rundict)
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
def setUp(self): self.drone = SimpleVaspToComputedEntryDrone() self.structure_drone = SimpleVaspToComputedEntryDrone(True) warnings.simplefilter("ignore")