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.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)
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 setUp(self):
self.test_dir = os.path.join(os.path.dirname(__file__), "..", "..",
"..", "..", 'test_files')
self.drone = SimpleVaspToComputedEntryDrone()
self.structure_drone = SimpleVaspToComputedEntryDrone(True)
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")
