def __init__(self, ps_name):
"""
"""
self.param = {}
self.df_data = {}
self.results = {}
self.etotal_data = {}
self.df_extra = np.inf
self.ps_name = ps_name
self.pseudo = Pseudo.from_file(ps_name+'.psp8')
def set_pseudos_from_paths(self, pseudos_path):
# this should be compatible with both version prior and after 0.3 of the pseudo dojo
pseudos_name = []
pseudos_md5 = []
for path in pseudos_path:
pseudo = Pseudo.from_file(path)
pseudos_name.append(pseudo.basename)
pseudos_md5.append(pseudo.md5)
self.pseudos_name = pseudos_name
self.pseudos_md5 = pseudos_md5
self.pseudos_path = pseudos_path
def set_pseudos_from_paths(self, pseudos_path):
# this should be compatible with both version prior and after 0.3 of the pseudo dojo
pseudos_name = []
pseudos_md5 = []
for path in pseudos_path:
pseudo = Pseudo.from_file(path)
pseudos_name.append(pseudo.basename)
pseudos_md5.append(pseudo.md5)
self.pseudos_name = pseudos_name
self.pseudos_md5 = pseudos_md5
self.pseudos_path = pseudos_path
def dojopseudo_from_file(filepath):
"""
Factory function used to construct a :class:`Pseudo` object from file.
A DojoPseudo has a DojoReport section and this function adds the report
to the object.
Args:
filepath: Path of the pseudopotential file or djrepo file.
.. note::
We cannot subclass Pseudo because it's actually the abstract base class
and Pseudo.from_file is the factory function that returns the concreate subclass.
"""
filepath = os.path.abspath(filepath)
dojo_report = None
if filepath.endswith(".djrepo"):
dojo_report = DojoReport.from_file(filepath)
pp_basename = dojo_report["basename"]
filepath = os.path.join(os.path.dirname(filepath), pp_basename)
# Init pseudo from file. Return None if parser error.
pseudo = Pseudo.from_file(filepath)
if pseudo is None: return pseudo
#pseudo.__class__.dojo_report = property(lambda self: self.a + 1)
if dojo_report is not None:
# We've already read the report.
pseudo.dojo_report = dojo_report
return pseudo
# Read DojoReport and add it to pseudos
root, ext = os.path.splitext(filepath)
djrepo = root + ".djrepo"
if not os.path.exists(djrepo):
raise RuntimeError("Cannot find djrepo file at %s" % djrepo)
pseudo.dojo_report = DojoReport.from_file(djrepo)
return pseudo
def main():
try:
top = sys.argv[1]
except IndexError:
print("Usage: extract_djreport TOPDIR")
# Find all .psp8 files starting from top.
paths = find_exts(top, ["psp8"], exclude_dirs="_*")
#print(paths)
for path in paths:
try:
pseudo = Pseudo.from_file(path)
except Exception as exc:
print(path, exc)
raise
if pseudo is None:
print("Parser error in %s" % path)
continue
report_file = path.replace(".psp8", ".djrepo")
if os.path.exists(report_file):
#print("New DOJO file already exists. Ignoring", pseudo.filepath)
continue
print("Moving DOJOREPORT to", report_file)
report = remove_dojo_report(pseudo.filepath)
# Change md5 and pseudo_type
report["md5"] = pseudo.compute_md5()
if report["pseudo_type"] == "norm-conserving":
report["pseudo_type"] = "NC"
with open(report_file, "wt") as fh:
json.dump(report, fh, indent=-1, sort_keys=True)
def oncv_run(options):
"""
Run oncvpsp, generate djrepo file, plot results. Requires input file.
"""
# Select calc_type
calc_type = dict(nor="non-relativistic",
sr="scalar-relativistic",
fr="fully-relativistic")[options.rel]
# Build names of psp8 and djson files from input and relativistic mode.
in_path = options.filename
root, _ = os.path.splitext(in_path)
# Enforce convention on output files.
if options.rel == "nor":
if not root.endswith("_nor"): root += "_nor"
elif options.rel == "fr":
if not root.endswith("_r"):
root += "_r"
cprint("FR calculation with input file without `_r` suffix. Will add `_r` to output files", "yellow")
# Build names of output files.
psp8_path = root + ".psp8"
djrepo_path = root + ".djrepo"
out_path = root + ".out"
if os.path.exists(psp8_path):
cprint("%s already exists and will be overwritten" % os.path.relpath(psp8_path), "yellow")
if os.path.exists(djrepo_path):
cprint("%s already exists and will be overwritten" % os.path.relpath(djrepo_path), "yellow")
if os.path.exists(out_path):
cprint("%s already exists and will be overwritten" % os.path.relpath(out_path), "yellow")
# Build Generator and start generation.
oncv_ppgen = OncvGenerator.from_file(in_path, calc_type, workdir=None)
print(oncv_ppgen)
print(oncv_ppgen.input_str)
oncv_ppgen.start()
retcode = oncv_ppgen.wait()
if oncv_ppgen.status != oncv_ppgen.S_OK:
cprint("oncvpsp returned %s. Exiting" % retcode, "red")
return 1
# Tranfer final output file.
shutil.copy(oncv_ppgen.stdout_path, out_path)
# Parse the output file
onc_parser = OncvOutputParser(out_path)
onc_parser.scan()
if not onc_parser.run_completed:
cprint("oncvpsp output is not complete. Exiting", "red")
return 1
# Extract psp8 files from the oncvpsp output and write it to file.
s = onc_parser.get_psp8_str()
with open(psp8_path, "wt") as fh:
fh.write(s)
# Write upf if available.
upf_str = onc_parser.get_upf_str()
if upf_str is not None:
with open(psp8_path.replace(".psp8", ".upf"), "wt") as fh:
fh.write(upf_str)
pseudo = Pseudo.from_file(psp8_path)
if pseudo is None:
cprint("Cannot parse psp8 file: %s" % psp8_path, "red")
return 1
# Initialize and write djson file.
report = DojoReport.empty_from_pseudo(pseudo, onc_parser.hints, devel=False)
report.json_write()
return 0
def change_icmod3(self, fcfact_list=(3, 4, 5), rcfact_list=(1.3, 1.35, 1.4, 1.45, 1.5, 1.55)):
"""
Change the value of fcfact and rcfact in the template. Generate the new pseudos
and create new directories with the pseudopotentials in the current workding directory.
Return:
List of `Pseudo` objects
Old version with icmod == 1.
# icmod fcfact
1 0.085
New version with icmod == 3.
# icmod, fcfact (rcfact)
3 5.0 1.3
"""
magic = "# icmod fcfact"
for i, line in enumerate(self.template_lines):
if line.strip() == magic: break
else:
raise ValueError("Cannot find magic line `%s` in template:\n%s" % (magic, "\n".join(self.template_lines)))
# Extract the parameters from the line.
pos = i + 1
line = self.template_lines[pos]
tokens = line.split()
icmod = int(tokens[0])
#if len(tokens) != 3:
# raise ValueError("Expecting line with 3 numbers but got:\n%s" % line)
#icmod, old_fcfact, old_rcfact = int(tokens[0]), float(tokens[1]), float(tokens[2])
#if icmod != 3:
# raise ValueError("Expecting icmod == 3 but got %s" % icmod)
base_name = os.path.basename(self.filepath).replace(".in", "")
ppgens = []
for fcfact, rcfact in product(fcfact_list, rcfact_list):
new_input = self.template_lines[:]
new_input[pos] = "%i %s %s\n" % (3, fcfact, rcfact)
input_str = "".join(new_input)
#print(input_str)
ppgen = OncvGenerator(input_str, calc_type=self.calc_type)
name = base_name + "_fcfact%3.2f_rcfact%3.2f" % (fcfact, rcfact)
ppgen.name = name
ppgen.stdin_basename = name + ".in"
ppgen.stdout_basename = name + ".out"
# Attach fcfact and rcfact to ppgen
ppgen.fcfact, ppgen.rcfact = fcfact, rcfact
if not ppgen.start() == 1:
raise RuntimeError("ppgen.start() failed!")
ppgens.append(ppgen)
for ppgen in ppgens:
retcode = ppgen.wait()
ppgen.check_status()
# Ignore errored calculations.
ok_ppgens = [gen for gen in ppgens if gen.status == gen.S_OK]
print("%i/%i generations completed with S_OK" % (len(ok_ppgens), len(ppgens)))
ok_pseudos = []
for ppgen in ok_ppgens:
# Copy files to dest
pseudo = ppgen.pseudo
#dest = os.path.basename(self.filepath) + "_fcfact%3.2f_rcfact%3.2f" % (ppgen.fcfact, ppgen.rcfact)
dest = os.path.split(self.filepath)[0]
shutil.copy(os.path.join(ppgen.workdir,ppgen.stdin_basename), dest)
shutil.copy(os.path.join(ppgen.workdir,ppgen.stdout_basename), dest)
# Reduce the number of ecuts in the DOJO_REPORT
# Re-parse the output and use devel=True to overwrite initial psp8 file
psp8_path = os.path.join(dest, ppgen.name + ".psp8")
out_path = os.path.join(dest, ppgen.name + ".out")
parser = OncvOutputParser(out_path)
parser.scan()
# Rewrite pseudo file in devel mode.
with open(psp8_path, "w") as fh:
fh.write(parser.get_pseudo_str(devel=True))
# Build new pseudo.
p = Pseudo.from_file(psp8_path)
ok_pseudos.append(p)
return ok_pseudos
def check_status(self):
"""Check the status of the run, set and return self.status attribute."""
if self.status == self.S_OK:
return self._status
parser = self.OutputParser(self.stdout_path)
try:
parser.scan()
except parser.Error:
self._status = self.S_ERROR
return self._status
logger.info("run_completed:", parser.run_completed)
if self.status == self.S_DONE and not parser.run_completed:
logger.info("Run is not completed!")
self._status = self.S_ERROR
if parser.run_completed:
logger.info("setting status to S_OK")
self._status = self.S_OK
#########################################
# Here we initialize results and plotter.
#########################################
if parser.warnings:
self.errors.extend(parser.warnings)
try:
self._results = parser.get_results()
except parser.Error:
# File may not be completed.
time.sleep(2)
try:
self._results = parser.get_results()
except Exception:
raise
self._plotter = parser.make_plotter()
# Write Abinit pseudopotential.
filepath = os.path.join(self.workdir, parser.atsym + "." + self.format)
self.filepath = filepath
#if os.path.exists(filepath):
# raise RuntimeError("File %s already exists" % filepath)
if self.format == 'psp8':
# Write psp8 file.
psp8_str = parser.get_psp8_str()
if psp8_str is not None:
with open(filepath, "wt") as fh:
fh.write(psp8_str)
# Add upf string (if present).
upf_str = parser.get_upf_str()
if upf_str is not None:
with open(filepath.replace(".psp8", ".upf"), "wt") as fh:
fh.write(upf_str)
# Initialize self.pseudo from file.
self._pseudo = p = Pseudo.from_file(filepath)
# Add md5 checksum to dojo_report
if p.has_dojo_report:
p.dojo_report["md5"] = p.compute_md5()
p.write_dojo_report(report=p.dojo_report)
if parser.errors:
logger.warning("setting status to S_ERROR")
self._status = self.S_ERROR
self.errors.extend(parser.errors)
print(self.errors)
return self._status